one.empty3.apps.opad.PositionUpdateImpl Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of empty3-library-3d Show documentation
Show all versions of empty3-library-3d Show documentation
3D rendering engine. Plus modeling. Expected glsl textures 3d and 2d rendering
/*
* Copyright (c) 2023. Manuel Daniel Dahmen
*
*
* Copyright 2012-2023 Manuel Daniel Dahmen
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package one.empty3.apps.opad;
import one.empty3.apps.opad.help.BonusClass;
import one.empty3.library.*;
import one.empty3.library.core.nurbs.ParametricLine;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ConcurrentModificationException;
import java.util.ResourceBundle;
import java.util.logging.Level;
import java.util.logging.Logger;
public class PositionUpdateImpl implements PositionUpdate, Runnable, ActionListener {
protected Path path;
protected static int STATE_GAME_IN_PROGRESS = 1;
private final ResourceBundle bundle;
private final Ciel bleu;
protected Point3D positionOrigine;
protected Point3D position = positionOrigine;
protected double positionIncrement;
protected double positionIncrement2;
protected double directionNorme;
protected Point3D directionOrigine;
protected Point3D direction = directionOrigine;
protected double angle;
protected double angleY;
protected CompletePositionMobile positionMobile;
private double unitPerSec;
private double rotationPerNano;
private Point2D position2D;
private Point2D direction2D;
private double hauteur;
private int score = 1000;
private boolean gagne = false;
private double collision_distance;
private Circuit circuit;
private Terrain terrain;
private Bonus bonus;
private double energy;
private Point2D direction2DY = new Point2D(1, 0);
private Plotter3D plotter3D;
private double positionEpsilon = 0.000001;
private Player player;
private double calibrage = 1;
private double accera = 0;
private double tourSec;
private DarkFortressGUI main;
public PositionUpdateImpl(Terrain t, Player player) {
bundle = ResourceBundle.getBundle("one.empty3.apps.opad.Bundle"); // NOI18N
unitPerSec = Double.parseDouble(bundle.getString("unitPerSec"));
tourSec = Double.parseDouble(bundle.getString("tourSec"));
rotationPerNano = Double.parseDouble(bundle.getString("rotationPerNanos"));
hauteur = Double.parseDouble(bundle.getString("hauteur"));
positionOrigine = new Point3D(0.5, 0.5, 0.0);
position = positionOrigine;
positionIncrement = Double.parseDouble(bundle.getString("positionIncrement"));
positionIncrement2 = Double.parseDouble(bundle.getString("positionIncrement2"));
directionNorme = Double.parseDouble(bundle.getString("directionNorme"));
directionOrigine = new Point3D(Double.parseDouble(bundle.getString("directionOrigine.x")),
Double.parseDouble(bundle.getString("directionOrigine.y")),
Double.parseDouble(bundle.getString("directionOrigine.z")));
direction = new Point3D(directionOrigine);
angle = Double.parseDouble(bundle.getString("angle"));
if (player == null) {
player = new Player("Manu", Color.GRAY, 0);
score = (int) player.score();
}
STATE_GAME_IN_PROGRESS = Integer.parseInt(bundle.getString("STATE_GAME_IN_PROGRESS"));
gagne = Boolean.parseBoolean(bundle.getString("gagne"));
energy = Double.parseDouble(bundle.getString("energy"));
this.terrain = t;
bonus = new Bonus();
collision_distance = Double.parseDouble(bundle.getString("collision_distance"));
bleu = new Ciel();
circuit = new Circuit(bonus);
path = new Path();
positionMobile = new CompletePositionMobile(this);
positionMobile.getPositionSol().setX(Double.parseDouble(bundle.getString("position2d.x")));
positionMobile.getPositionSol().setY(Double.parseDouble(bundle.getString("position2d.y")));
}
@Override
public double getAngle() {
return angle;
}
@Override
public Point2D directionY() {
return direction2DY;
}
public Circuit getCircuit() {
return circuit;
}
@Override
public double energy() {
return energy;
}
@Override
public void update() {
//if (main.drawer instanceof JoglDrawer) {
//JoglDrawer drawer = (JoglDrawer) main.drawer;
//drawer.getGlcanvas().display();
//drawer.getGlcanvas().requestFocusInWindow();
//}
}
protected boolean isPositionOk(Point3D p, boolean repositionne) {
Logger.getAnonymousLogger().log(Level.INFO, "candidate new position : " + p + "\n" + getPositionMobile().getAngleVisee());
if (p.getX() >= -positionEpsilon && p.getX() <= 1 + positionEpsilon
&& p.getY() >= -positionEpsilon && p.getY() <= 1 + positionEpsilon) {
update();
return true;
} else {
if (repositionne) {
p.setX(0.5);
p.setY(0.5);
p.setZ(hauteur);
//Logger.getAnonymousLogger().log(Level.INFO, "CORRECT position : " + p);
}
return false;
}
}
public Point3D getVecDir2D() {
return new Point3D(Math.cos(positionMobile.getAngleVisee().getZ() * Math.PI * 2),
Math.sin(positionMobile.getAngleVisee().getZ() * Math.PI * 2),
0.0).mult(directionNorme * 1).norme1();
}
@Override
public void actionPerformed(ActionEvent e) {
}
@Override
public void acc(long timeNano) {
Logger.getAnonymousLogger().log(Level.INFO, "ACC" + timeNano);
Point3D direction2D = getVecDir2D().norme1().mult(1.0 * timeNano * 1E-9 * unitPerSec);
accera += timeNano;
Point3D p2 = positionMobile.getPositionSol().plus(direction2D);
Logger.getAnonymousLogger().log(Level.INFO, "acc:" + p2.toString());
if (isPositionOk(p2, false)) {
positionMobile.setPositionSol(p2);
} else;
Logger.getAnonymousLogger().log(Level.INFO, "OUT acc:" + p2.toString());
}
@Override
public void dec(long timeNano) {
Logger.getAnonymousLogger().log(Level.INFO, "DEC" + timeNano);
Point3D direction2D = getVecDir2D().norme1().mult(timeNano * 1E-9 * unitPerSec);
accera -= timeNano;
Point3D p2 = positionMobile.getPositionSol().plus(direction2D);
if (isPositionOk(p2, false)) {
positionMobile.setPositionSol(p2);
} else;
Logger.getAnonymousLogger().log(Level.INFO, "OUT acc:" + p2.toString());
}
@Override
public boolean plot(Point3D position, Point3D deplacement, Cube plottee) {
return getPlotter3D().plot(position, deplacement, plottee);
}
@Override
public void moveUp(long timeKeyPress) {
double z = positionMobile.getPositionSol().getZ() + timeKeyPress * unitPerSec;
if (isPositionOk(new Point3D(positionMobile.getPositionSol().getX(), positionMobile.getPositionSol().getY(), z), false)) {
positionMobile.getPositionSol().setZ(z);
}
}
@Override
public void moveDown(long timeKeyPress) {
double z = positionMobile.getPositionSol().getZ() - timeKeyPress * unitPerSec;
if (isPositionOk(new Point3D(positionMobile.getPositionSol().getX(), positionMobile.getPositionSol().getY(), z), false)) {
positionMobile.getPositionSol().setZ(z);
}
}
public int state() {
return STATE_GAME_IN_PROGRESS();
}
int numAxe = 2;
@Override
public void rotationGauche(long timeNano) {
angle = positionMobile.getAngleVisee().get(numAxe) - tourSec * rotationPerNano * 1E-9;
positionMobile.getAngleVisee().set(numAxe, angle);
if (isPositionOk(getPositionMobile().getPositionSol(), false)) {
;
}
}
@Override
public void rotationDroite(long timeNano) {
angle = positionMobile.getAngleVisee().get(numAxe) + tourSec * rotationPerNano * 1E-9;
positionMobile.getAngleVisee().set(numAxe, angle);
if (isPositionOk(getPositionMobile().getPositionSol(), false)) {
;
}
}
public synchronized void testCollision(PositionMobile positionMobile) {
if (bonus == null) {
return;
}
Point3D pos = terrain.p3(positionMobile.getPositionSol());
boolean catched = true;
while (catched)
try {
for (Representable representable : bonus.getListRepresentable()) {
Representable bon = representable;
if (bon != null && bon instanceof TRISphere2
&& Point3D.distance(((Sphere) bon).getCircle().getCenter(), pos)
< ((Sphere) bon).getCircle().getRadius()) {
bonus.remove(bon);
double points = 0.0;
points = ((TRISphere2) bon).getGameObject().getValue();
score += points;
Sounds.playSoundBonusHit();
Mouvement mouvement = new Mouvement(bon, 10000,
new ParametricLine(new LineSegment(((Sphere) bon).getCircle().getCenter(),
((Sphere) bon).getCircle().getCenter().plus(P.n(0, 0, 10))))) {
@Override
protected synchronized void action(Representable representable, double moveTimeRatio) {
}
@Override
protected synchronized void setPosition(Point3D position) {
/*
if (representable instanceof TRISphere2) {
((TRISphere2) representable).setCentre(position);
}
*/
}
@Override
protected synchronized void startMoveAction() {
/*
path.add(((TRISphere2) bon).getCoords());
*/
}
@Override
protected synchronized void endMoveAction() {
bonus.removeBonus(bon);
}
};
mouvement.start();
Logger.getAnonymousLogger().log(Level.INFO,""+ score);
//circuit = new Circuit(bonus);
}
}
catched = false;
} catch (ConcurrentModificationException | java.util.NoSuchElementException ex) {
catched = true;
}
}
@Override
public void ennemi(Bonus e) {
this.bonus = e;
}
@Override
public int score() {
return score;
}
private void win() {
gagne = true;
}
@Override
public boolean estGagnant() {
return bonus.getListRepresentable().isEmpty();
}
@Override
public Point3D calcCposition() {
return positionMobile.calcPosition();
}
@Override
public Point3D calcDirection() {
return positionMobile.calcDirection();
}
public double getHauteur() {
if (getPlotter3D().isActive()) {
return positionMobile.getPositionMobile().getZ();
} else {
return positionMobile.getPositionSol().getZ();
}
}
@Override
public int STATE_GAME_IN_PROGRESS() {
return STATE_GAME_IN_PROGRESS;
}
@Override
public Point3D calculerPositionAuSol(Point2D position2D) {
return getTerrain().calcCposition(position2D.getX(), position2D.getY());
}
@Override
public Point3D calculerPositionModule(Point2D position2D) {
return getTerrain().p3(position);
}
public Terrain getTerrain() {
return terrain;
}
@Override
public void setTerrain(Terrain t) {
this.terrain = t;
}
@Override
public void run() {
while (true) {
testCollision(positionMobile);
try {
Thread.sleep(20);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public Plotter3D getPlotter3D() {
return plotter3D;
}
public void setPlotter3D(Plotter3D plotter3D) {
this.plotter3D = plotter3D;
}
@Override
public PositionMobile getPositionMobile() {
return positionMobile;
}
public synchronized Path getPath() {
return path;
}
public synchronized void setPath(Path path) {
this.path = path;
}
@Override
public void setMain(DarkFortressGUI darkFortressGUI) {
this.main = darkFortressGUI;
}
@Override
public DarkFortressGUI getMain() {
return main;
}
public Player getPlayer() {
return player;
}
}