Wie oben bereits erwähnt verzichte auf die Klasse Timer. Sie ist threadsicher was zwar wichtig ist wenn mehrere Threads auf die Klasse zugreifen wollen, das kostet aber auch Performance. Mache lieber ein Runable und starte einen einfachen Thread so wie oben beschrieben.
,das ist nicht möglich.. du hast wahrscheinlich die aufrufe pro sekunde gezählt
das rufst du 2 mal zu unterschiedllichen zeitpunkten auf.. das ist abgesehen davon dass es nicht performant ist auch noch fehlerhaft
@Override
protected void paintComponent(Graphics g) {
last_time = System.nanoTime();
super.paintComponent(g);
paintLayer(g, mapLayer1); //Layer1 wird gezeichnet
paintLayer(g, mapLayer2); //Layer2 wird gezeichnet
paintHero(g, mario.getDirection(), mario.getFeetPosition(), mario.getPositionX(), mario.getPositionY()); //Mario wird gezeichnet, je nach Position, Blickrichtung, Fußposition (Lauf, Sprung, Fall)
if (counter > 10) {
delta_time = (System.nanoTime() - last_time) / 1000000;
counter = 0;
}
g.drawString("FrameTime: " + delta_time, 50, 50);
counter++;
}public class Canvas extends JPanel {
...
public Canvas() {
physics = new Physics(this);
physics.startAnimation();
}
}
...
public Physics(Canvas canvas) {
this.canvas = canvas;
animationRunnable = new Runnable() {
@Override
public void run() {
while (isRunning) {
if (mario.getSpeed() > 0) {
if (isJumping || isFalling) {
mario.setFeetPosition(2); //FeetPosition 2 beim Jump heißt, dass Mario rechts guckt
}
if (mario.getPositionX() >= mario.getFinalPositionX() && !isJumping && !isFalling) { //Wenn 16 Pixel/halber Block erreicht dann feetPosition changen
mario.changeFeetPosition();
mario.refreshFinalPositionX();
}
}
if (mario.getSpeed() < 0) {
if (isJumping || isFalling) {
mario.setFeetPosition(1); //Wenn Mario links guckt, muss das entsprechende Bild gezeichnet werden
}
if (mario.getPositionX() <= mario.getFinalPositionX() && !isJumping && !isFalling) { //Wenn 16 Pixel/halber Block erreicht dann feetPosition changen
mario.changeFeetPosition();
mario.refreshFinalPositionX();
}
}
mario.move(mario.getSpeed());
//////////////////////////////////// MOVETIMER VORBEI
if (isJumping) {
mario.setDirection(Direction.UP);
timerDrivenJumpMethod();
}
if (isFalling) {
mario.setDirection(Direction.DOWN); //Wenn Mario fällt, dann setze Direction auf "down"
timerDrivenFallMethod(jumpDownTimerSpeed);
}
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
animationThread = new Thread(animationRunnable);
}
public void startAnimation() {
animationThread.start();
}da ist dein performance fresser... du hast es falsch rum gemacht
somit skalierst du den vektor runter auf die frame rate... und nicht anders rum.. du hast es verkehrt herum gemacht
Es geht vermutlich darum, dass die Geschwindigkeit der Bewegungen von der Zeit abhängig sein sollen.
Du musst gar nichts explizit mit Vektoren machen, sie vereinfachen halt einiges.
11.500.000 FPS Du hast wohl den besten Computer aller Zeiten.
public void render( Graphics g ){
..
frames++;
}public void run(){
..
if (System.currentTimeMillis() - frameTime > 1000) {
frameCount = frames;
frames = 0;
frameTime = System.currentTimeMillis();
}
}Die Vektoren waren nur ein Beispiel für das unnötige erzeugen von Objekten innerhalb eines Gameloops. Ich verwende eine Klasse names Sprite, die x und y Position und die Richtungen mittels dx, dy vom primitiven Type float verwaltet.
Das stimmt.
public void run() {
..
int sleepTime = 12; // ca 80 fps
while (running) {
update(); // vebrauchte Zeit für Update
render(); // verbrauchte Zeit für Zeichnen
..
Thread.sleep(sleepTime ); // hier muss die update und render Zeit abgezogen werden
// falls seepTime < 0 gibt der Thread nicht ab
// --> periodisch ist dies mittels Thread.yield() anzustoßen
// außerdem müssen die verlorenen Frames gezählt werden, um update entsprechend oft
// nachzuholen. Dadurch bewegen sich die Objekte mit der gewünschten Zeit auch wenn
// beim Zeichnen nur 70 fps erreicht wurden. super.paintComponent(g);
paintLayer(g, mapLayer1); //Layer1 wird gezeichnet
paintLayer(g, mapLayer2); //Layer2 wird gezeichnet
paintHero(g, mario.getDirection(), mario.getFeetPosition(), mario.getPositionX(), mario.getPositionY()); //Mario wird gezeichnet, je nach Position, Blickrichtung, Fußposition (Lauf, Sprung, Fall) protected void paintComponent(Graphics g) {
...
if (graphics == null) {
System.out.println("Graphics Objekt wurde gesetzt");
graphics = g;
} public void move(int speed) { //Bewegt Charakter in angegebener Geschwindigkeit (- oder +)
positionX += speed;
if (speed != 0) {
canvas.doRepaint();
}
Die Fenster werden nur in den paint / paintComponent Methoden gemalt. Du kannst nicht mitten drin da etwas malen. Das Graphics Objekt ist nur während der Methode, der es als Parameter übergeben wurde, gültig.
private Thread physicsThread;
private Canvas canvas;
public Canvas() { //Konstruktor Start
canvas = this;
physicsThread = new Thread(new Runnable() {
@Override
public void run() {
physics = new Physics(canvas);
}
});
physicsThread.start();
physics.startAnimation(); //Läuft diese Anweisung im physicsThread?Er bezieht sich auf meinen Post #46.
@Override
protected void paintComponent(Graphics g) {
graphics = g;
super.paintComponent(g);
if (physics.getBuffImageB() != null) { //Liegt neues Bild in B vor?
if (!physics.isDoRepaintActive) {
System.out.println("Neues Bild liegt zum painten bereit!!!!!!!!!!!!!!");
physics.setBuffImageD(physics.getBuffImageA()); //Altes Bild wird zum Malen nach D geschoben
physics.setBuffImageA(physics.getBuffImageB()); //Da neues Bild in B, wird dies zu A
physics.setBuffImageB(null); //Bild B wurde zu A, also ist B wieder null
}
}
g.drawImage(physics.getBuffImageA(), 0, 0, null);
}Ich kann Dich wiederum nur auf meinen Post #46 verweisen.
Du speicherst hier das Graphics Objekt in eine (?) Klassenvariable. Das ist keine gute Idee. Der Aufruf von paintComponent() wird durch z.B. repaint() und anderen Ereignissen veranlasst. Damit das dort verwendete Graphics Objekt unbeschwert intern bearbeitet werden kann.
Bei meiner Idee finden die Verschiebevorgänge automatisch statt, wenn die Zugriffe darauf erfolgen. Damit mehrere Threads da parallel keinen Unsinn machen können, müssen diese Zugriffe teilweise in synchronisierten Blöcken stattfinden. Und Variablen, die von mehreren Threads verwendet werden, sollten volatile sein.
Daher wäre es interessant, wenn Du Details bringen würdest, was Du genau machst. Ohne Details kann man keine Fehler aufzeigen. Dabei ist es egal, welchen Weg du einschlägst.
Versionsverwaltung ist erst einmal unabhängig von der IDE. Die IDEs haben lediglich (meist per Plugins) eine Unterstützung für diverse Versionsverwaltungen.
Könntes Du die Bücher zu git nennen?
Die beiden Bücher, die ich im Kopf hatte, sind:
package Pokemon;
import PokemonEditor.*;
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.KeyEvent;
import java.awt.image.BufferedImage;
public class Canvas extends JPanel { //Klasse Start
private BlockArrayList mapLayer1;
private BlockArrayList mapLayer2;
private BufferedImage tilesetBufferedImage;
private final BufferedImage spritesBufferedImage;
private final int ZOOM = 4; //TODO muss noch eingebaut werden 4 ist Standard
private final int TILESIZE = 16;
private final int OFFSET = 11 * ZOOM; //umso höher umso höher zeichnet er
// private final Physics physics; //ohne thread
private Physics physics; //mit thread
private final Hero mario;
// private final MediaPlayer mediaPlayer;
private final LoadMap loadMap;
private boolean isPressingRightButton = false;
private boolean isPressingLeftButton = false;
private boolean isPressingSpaceButton = false;
private final Thread physicsThread;
private final Canvas canvas;
private long last_time;
private long delta_time;
private int counter;
private BufferedImage mapBufferedImage = new BufferedImage(1024, 860, BufferedImage.TYPE_INT_ARGB);
private Graphics mapGraphics = mapBufferedImage.createGraphics();
private boolean accessingBufferedImageHeroB = false;
BufferedImage bufferedImageHeroA;
BufferedImage bufferedImageHeroB;
BufferedImage bufferedImageHeroC;
BufferedImage bufferedImageHeroD;
Graphics graphicsHero;
Thread refreshBufferedImagesThread = new Thread(new Runnable() {
@Override
public void run() {
while (true) {
if (mario.heroDataChanged()) {
refreshHeroBufferedImage(mario.getDirection(), mario.getFeetPosition(), mario.getPositionX(), mario.getPositionY()); //Mario wird gezeichnet, je nach Position, Blickrichtung, Fußposition (Lauf, Sprung, Fall)
System.out.println("refreshed");
} else {
try {
Thread.sleep(0); //Workaround, sonst //TODO
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
});
public Canvas() { //Konstruktor Start
canvas = this;
physicsThread = new Thread(() -> physics = new Physics(canvas));
physicsThread.start();
// physics = new Physics(this); //Ohne Thread
keyBinding();
System.out.println(physics);
mario = new Hero(this, physics);
physics.startAnimation();
loadMap = new LoadMap();
if (loadMap.getMapString() != null) {
this.mapLayer1 = loadMap.getLoadedMap()[0];
this.mapLayer2 = loadMap.getLoadedMap()[1];
}
try {
tilesetBufferedImage = TilePanel.getExistingInstance().getBufferedImage();
} catch (Exception e) {
System.err.println("Konnte TilePanel-Image nicht holen");
e.printStackTrace();
}
spritesBufferedImage = loadMap.getBufferedImage(GuiData.filenameSpriteSet);
refreshBufferedImagesThread.start();
refreshMapBufferedImage();
setFocusable(true);
requestFocusInWindow();
}
public void keyBinding() {
InputMap im = getInputMap(WHEN_IN_FOCUSED_WINDOW);
ActionMap am = getActionMap();
im.put(KeyStroke.getKeyStroke(KeyEvent.VK_SPACE, 0, false), "pressedSpace");
im.put(KeyStroke.getKeyStroke(KeyEvent.VK_SPACE, 0, true), "releasedSpace");
im.put(KeyStroke.getKeyStroke(KeyEvent.VK_LEFT, 0, false), "pressedLeft");
im.put(KeyStroke.getKeyStroke(KeyEvent.VK_LEFT, 0, true), "releasedLeft");
im.put(KeyStroke.getKeyStroke(KeyEvent.VK_RIGHT, 0, false), "pressedRight");
im.put(KeyStroke.getKeyStroke(KeyEvent.VK_RIGHT, 0, true), "releasedRight");
im.put(KeyStroke.getKeyStroke(KeyEvent.VK_R, 0, true), "pressedR");
am.put("pressedSpace", new AbstractAction() {
@Override
public void actionPerformed(ActionEvent e) {
if (!isPressingSpaceButton && !physics.getJumping() && !physics.getFalling()) { //Doppelsprung wird vermieden durch diese If Bedingung
isPressingSpaceButton = true;
if (mario.getDirection() == Direction.LEFT) {
mario.setFeetPosition(1); //FeetPosition1 beim Jump heißt, er schaut links
}
if (mario.getDirection() == Direction.RIGHT) {
mario.setFeetPosition(2);
}
mario.setDirectionBackup(mario.getDirection()); //FeetPosition2 beim Jump heißt, er schaut rechts
mario.doJump();
}
}
});
am.put("releasedSpace", new AbstractAction() {
@Override
public void actionPerformed(ActionEvent e) {
isPressingSpaceButton = false; // boolean der speichert, ob die Leertaste gerade gedrückt wird
}
});
am.put("pressedLeft", new AbstractAction() {
@Override
public void actionPerformed(ActionEvent e) {
if (!isPressingLeftButton) {
isPressingLeftButton = true;
mario.setSpeed(-mario.getWalkSpeed()); //Geschwindigkeit auf negativen Wert setzen, bedeutet, dass Mario nach links läuft
mario.setDirection(Direction.LEFT); //Wichtig für paintComponent
mario.setDirectionBackup(Direction.LEFT);
mario.refreshFinalPositionX();
if (!physics.getJumping() && !physics.getFalling()) {
mario.setFeetPosition(1); //Er fängt immer mit einem Fuß vorne an zu laufen
}
}
}
});
am.put("releasedLeft", new AbstractAction() {
@Override
public void actionPerformed(ActionEvent e) {
isPressingLeftButton = false;
if (!physics.getJumping() && !physics.getFalling()) {
mario.setFeetPosition(2);
}
if (physics.getJumping() && physics.getFalling()) {
mario.setFeetPosition(1); //Feet Position 1 bei Jump heißt er guckt links
}
repaint();
if (!isPressingRightButton) { //Wenn kein anderer Button gedrückt wird, dann Mario anhalten durch Geschwindigkeit 0
mario.setSpeed(0);
}
}
});
am.put("pressedRight", new AbstractAction() {
@Override
public void actionPerformed(ActionEvent e) {
if (!isPressingRightButton) {
isPressingRightButton = true;
mario.setSpeed(mario.getWalkSpeed()); //Geschwindigkeit auf positiven Wert setzen, bedeutet, dass Mario nach rechts läuft
mario.setDirection(Direction.RIGHT); //Wichtig für paintComponent
mario.setDirectionBackup(Direction.RIGHT);
mario.refreshFinalPositionX();
if (!physics.getJumping() && !physics.getFalling()) {
mario.setFeetPosition(1); //Er fängt immer mit einem Fuß vorne an zu laufen
}
}
}
});
am.put("releasedRight", new AbstractAction() {
@Override
public void actionPerformed(ActionEvent e) {
isPressingRightButton = false;
if (!physics.getJumping() && !physics.getFalling()) {
mario.setFeetPosition(2);
}
if (physics.getJumping() && physics.getFalling()) {
mario.setFeetPosition(2); //Feet Position 1 bei Jump heißt er guckt links
}
// physics.doRepaint();
repaint();
if (!isPressingLeftButton) { //Wenn kein anderer Button gedrückt wird, dann Mario anhalten durch Geschwindigkeit 0
mario.setSpeed(0);
}
}
});
am.put("pressedR", new AbstractAction() {
@Override
public void actionPerformed(ActionEvent e) {
// mario.setDirection(mario.getDirectionBackup()); //Wenn während des Sprungs/Falls die Richtung durch Tastendruck gewechselt wird, wird das DirectionBackup damit überschrieben
// mario.setFeetPosition(2);
System.out.println("Pressed R!");
refreshHeroBufferedImage(mario.getDirection(), 2, mario.getPositionX(), mario.getPositionY());
canvas.repaint();
}
});
}
private void refreshMapBufferedImage() {
for (int i = 0; i < mapLayer1.size(); i++) {
mapGraphics.drawImage(canvas.getTilesetBufferedImage(), mapLayer1.get(i).getDestinationX() * TILESIZE * ZOOM, mapLayer1.get(i).getDestinationY() * TILESIZE * ZOOM, (mapLayer1.get(i).getDestinationX() + 1) * TILESIZE * ZOOM, (mapLayer1.get(i).getDestinationY() + 1) * TILESIZE * ZOOM, mapLayer1.get(i).getSourceX() * TILESIZE, mapLayer1.get(i).getSourceY() * TILESIZE, (mapLayer1.get(i).getSourceX() + 1) * TILESIZE, (mapLayer1.get(i).getSourceY() + 1) * TILESIZE, null);
}
for (int i = 0; i < mapLayer2.size(); i++) {
mapGraphics.drawImage(canvas.getTilesetBufferedImage(), mapLayer2.get(i).getDestinationX() * TILESIZE * ZOOM, mapLayer2.get(i).getDestinationY() * TILESIZE * ZOOM, (mapLayer2.get(i).getDestinationX() + 1) * TILESIZE * ZOOM, (mapLayer2.get(i).getDestinationY() + 1) * TILESIZE * ZOOM, mapLayer2.get(i).getSourceX() * TILESIZE, mapLayer2.get(i).getSourceY() * TILESIZE, (mapLayer2.get(i).getSourceX() + 1) * TILESIZE, (mapLayer2.get(i).getSourceY() + 1) * TILESIZE, null);
}
}
public void refreshHeroBufferedImage(Direction direction, int feetPosition, int positionX, int positionY) {
if (System.currentTimeMillis() - last_time > 15 || !isPressingRightButton && !isPressingLeftButton) { //Nur neu zeichnen wenn mehr als 15ms vergangen sind (66,66 FPS) oder er nicht bewegt wird (Workaround, da er nach dem Fallen nicht mehr die buffImages refresht hat
bufferedImageHeroC = new BufferedImage(1024, 860, BufferedImage.TYPE_INT_ARGB);
graphicsHero = bufferedImageHeroC.createGraphics();
if (mario.getDirection().equals(Direction.LEFT)) {
switch (mario.getFeetPosition()) { //+ZOOM=Korrektur
case 1 -> graphicsHero.drawImage(canvas.getSpritesBufferedImage(), positionX, positionY - OFFSET, positionX + TILESIZE * ZOOM, (positionY + TILESIZE * ZOOM) + ZOOM, 1, 91, 17, 118 + 1, null); //links Fuß vorn
case 2 -> graphicsHero.drawImage(canvas.getSpritesBufferedImage(), positionX, positionY - OFFSET, positionX + TILESIZE * ZOOM, (positionY + TILESIZE * ZOOM) + ZOOM, 19, 91, 35, 118 + 1, null); //links stehend
}
}
if (direction.equals(Direction.RIGHT)) {
switch (feetPosition) { // offset ist der Wert wieviel über 16 Pixel Block gezeichnet werden soll //+ZOOM=Korrektur
case 1 -> graphicsHero.drawImage(canvas.getSpritesBufferedImage(), positionX, positionY - OFFSET, positionX + TILESIZE * ZOOM, (positionY + TILESIZE * ZOOM) + ZOOM, 1, 31, 17, 58 + 1, null); //rechts Fuß vorn
case 2 -> graphicsHero.drawImage(canvas.getSpritesBufferedImage(), positionX, positionY - OFFSET, positionX + TILESIZE * ZOOM, (positionY + TILESIZE * ZOOM) + ZOOM, 19, 31, 35, 58 + 1, null); //rechts stehend
}
}
if (direction.equals(Direction.UP)) { //Springen
switch (feetPosition) {
case 1 -> graphicsHero.drawImage(canvas.getSpritesBufferedImage(), positionX, positionY - OFFSET - ZOOM, positionX + TILESIZE * ZOOM, (positionY + TILESIZE * ZOOM), 1, 1, 17, 28 + 1, null); //Springen links
case 2 -> graphicsHero.drawImage(canvas.getSpritesBufferedImage(), positionX, positionY - OFFSET - ZOOM, positionX + TILESIZE * ZOOM, (positionY + TILESIZE * ZOOM), 19, 1, 35, 28 + 1, null); //Springen rechts
}
}
if (direction.equals(Direction.DOWN)) { //Fallen
switch (feetPosition) {
case 1 -> graphicsHero.drawImage(canvas.getSpritesBufferedImage(), positionX, positionY - canvas.getOFFSET() - ZOOM, positionX + TILESIZE * ZOOM, positionY + TILESIZE * ZOOM, 1, 61, 17, 89, null); //Fallen links
case 2 -> graphicsHero.drawImage(canvas.getSpritesBufferedImage(), positionX, positionY - canvas.getOFFSET() - ZOOM, positionX + TILESIZE * ZOOM, positionY + TILESIZE * ZOOM, 19, 61, 35, 89, null); //Fallen rechts
}
}
mario.refreshHeroData();
if (!accessingBufferedImageHeroB) {
if (bufferedImageHeroB != null) {
accessingBufferedImageHeroB = true;
bufferedImageHeroD = bufferedImageHeroB;
}
accessingBufferedImageHeroB = true;
bufferedImageHeroB = bufferedImageHeroC;
accessingBufferedImageHeroB = false;
bufferedImageHeroC = null;
}
last_time = System.currentTimeMillis();
}
}
@Override
protected void paintComponent(Graphics g) {
super.paintComponent(g);
if (mapBufferedImage != null) {
g.drawImage(mapBufferedImage, 0, 0, this);
}
g.drawString("GameLoops " + physics.getGameLoops(), 50, 50);
if (bufferedImageHeroB != null) {
bufferedImageHeroD = bufferedImageHeroA;
if (!accessingBufferedImageHeroB) {
accessingBufferedImageHeroB = true;
bufferedImageHeroA = bufferedImageHeroB;
bufferedImageHeroB = null;
accessingBufferedImageHeroB = false;
}
}
g.drawImage(bufferedImageHeroA, 0, 0, this);
}
/*
Getter und Setter - Der spannendste Teil meines Codes
*/
public BlockArrayList getMapLayer1() {
return mapLayer1;
}
public BlockArrayList getMapLayer2() {
return mapLayer2;
}
public BufferedImage getTilesetBufferedImage() {
return tilesetBufferedImage;
}
public BufferedImage getSpritesBufferedImage() {
return spritesBufferedImage;
}
public boolean isPressingRightButton() {
return isPressingRightButton;
}
public boolean isPressingLeftButton() {
return isPressingLeftButton;
}
public boolean isPressingSpaceButton() {
return isPressingSpaceButton;
}
public int getOFFSET() {
return OFFSET;
}
public int getZOOM() {
return ZOOM;
}
public int getTILESIZE() {
return TILESIZE;
}
}package Pokemon;
import java.util.List;
public class Physics {
private final double gravitation = 9.81; // m/s //Veränderte Gravitation lässt Mario langsamer hoch gleiten
private int pixelPerTimerPass = 1; //muss verändert werden für Geschwindigkeit,
private final double timerPassInMs = 17; //so viele ms pro TimerDurchlauf
private long timeElapsedInMs; //TODO ersetzen durch gameLoopDurchgänge????
private int jumpedPixelCounter = 0;
private long fallStartTime;
private long fallDuration = 0;
private double startSpeedInMeterPerSecond = 11; // 11 braucht er für 300 hoch Dieser Wert bestimmt die zu erreichende Höhe
private final int minimumSpeed = 4; //3Mindestens 2 -> je höher dieser Wert, desto höher die Geschwindigkeit des Heros bei Kehrtwende von oben nach unten
private final int jumpDownTimerSpeed = 30;
private long start;
private List<Integer> pixelPerTimerPassList;
private Hero mario;
private Canvas canvas;
private long startTime = System.currentTimeMillis();
private long duration = 0;
private int counterFrames = 0;
private boolean isJumping = false;
private boolean isFalling = false;
private boolean isRunning = true; //Gameloop
Runnable animationRunnable;
private Thread animationThread;
private final int sleepDuration = 10;
private int gameLoopCounter = 0;
private int gameLoops = 0;
private long startTime2 = 0;
private long end;//nötig??
// in 1 s = 58 Durchgänge = 58 Pixel
// Mario 20 Pixel hoch = 2m?
//Sprung = 300 Pixel = 30m?
// Bei 58 Pixel = 5,8m pro Sekunde muss man für 20m/s oder 200 Pixel/s gleich 20m/s durch
public Physics(Canvas canvas) {
this.canvas = canvas;
animationRunnable = new Runnable() {
@Override
public void run() {
System.out.println("Aufruf GameLoop");
startTime2 = System.currentTimeMillis();
while (isRunning) {
if (canvas.isPressingLeftButton() && canvas.isPressingRightButton() && mario.getSpeed() == 0) {
mario.setFeetPosition(2);
}
if (mario.getSpeed() > 0) {
if (isJumping || isFalling) {
mario.setFeetPosition(2); //FeetPosition 2 beim Jump heißt, dass Mario rechts guckt
}
if (mario.getPositionX() >= mario.getFinalPositionX() && !isJumping && !isFalling) { //Wenn 16 Pixel/halber Block erreicht dann feetPosition changen
mario.changeFeetPosition();
mario.refreshFinalPositionX();
}
}
if (mario.getSpeed() < 0) {
if (isJumping || isFalling) {
mario.setFeetPosition(1); //Wenn Mario links guckt, muss das entsprechende Bild gezeichnet werden
}
if (mario.getPositionX() <= mario.getFinalPositionX() && !isJumping && !isFalling) { //Wenn 16 Pixel/halber Block erreicht dann feetPosition changen
mario.changeFeetPosition();
mario.refreshFinalPositionX();
}
}
mario.move(mario.getSpeed());
//////////////////////////////////// Ende des MoveEvents
if (isJumping) {
mario.setDirection(Direction.UP); //Wenn Mario springt, dann setze Direction auf "up" //TODO doppelt?
gameloopDrivenJumpMethod();
}
if (isFalling) { //TODO Dieser Code verhindert die Möglichkeit die Fußstellung noch vor dem Erreichen des Bodens zurückzustellen
mario.setDirection(Direction.DOWN); //Wenn Mario fällt, dann setze Direction auf "down"
gameloopDrivenFallMethod(jumpDownTimerSpeed);
}
try {
Thread.sleep(sleepDuration);
} catch (InterruptedException e) {
e.printStackTrace();
}
/*
Durchgänge pro Sekunde bei etwa 64
*/
gameLoopCounter++;
if (System.currentTimeMillis() - startTime2 >= 1000) {
gameLoops = gameLoopCounter;
canvas.repaint();
gameLoopCounter = 0;
startTime2 = System.currentTimeMillis();
}
}
}
};
animationThread = new Thread(animationRunnable);
}
public void startAnimation() {
animationThread.start();
}
private void gameloopDrivenFallMethod(int jumpDownTimerSpeed) {
setFallDuration(System.currentTimeMillis() - (getFallStartTime()));
jumpDownTimerSpeed = (int) (jumpDownTimerSpeed / getGravitation()) * (int) (getFallDuration() / mario.getFallDelay());
for (int i = 0; i < jumpDownTimerSpeed; i++) {
mario.moveDown(1); //1 Pixel nach unten
if (mario.getPositionY() == mario.getFinalPositionY()) {
isFalling = false;
setFallDuration(0);
mario.setDirection(mario.getDirectionBackup()); //Wenn während des Sprungs/Falls die Richtung durch Tastendruck gewechselt wird, wird das DirectionBackup damit überschrieben
mario.setFeetPosition(2); //FußPosition 2 -> Mario steht
canvas.refreshHeroBufferedImage(mario.getDirection(), 2, mario.getPositionX(), mario.getPositionY()); //
canvas.repaint();
break;
}
}
canvas.repaint();
}
private void gameloopDrivenJumpMethod() {
setTimeElapsedInMs(); //Aktuell vergangene Zeit setzen
for (int i = 0; i < getPixelPerTimerPass(); i++) {
setTimeElapsedInMs(); //Aktuell vergangene Zeit setzen //TODO kann vielleicht weg
refreshPixelPerTimerPass();
//So viel PixelSprung pro Schleifendurchgang
mario.moveUp(1); //eins nach oben pro Schleifendurchgang
increaseJumpedPixelCounter(1);
if (getPixelPerTimerPass() < getMinimumSpeed()) { //Methode 1: Wenn er weniger als 3 Pixel pro Durchlauf Geschwindigkeit hat, hört er auf -> unterschiedliche Sprunghöhen
// if (getJumpedPixelCounter() == 288) { //Methode 2: Wenn er 288 Pixel erreicht hat, stoppt er den JumpUpTimer -> wenn nie erreicht bleibt er stehen -> unterschiedliche Sprungzeiten
// if (getDurationJump() >= getJumpTimeInMs()) { //Methode 3: Wenn Zeit abgelaufen, dann stoppt er den JumpUpTimer -> unterschiedliche Sprunghöhen?
isJumping = false; //Jumping abgeschlossen
mario.setFinalPositionY(mario.getPositionY() + getJumpedPixelCounter()); //FinalPositionY berechnen durch aktuelle PositionY - Sprunghöhe
System.out.println("gesprungene Pixel:"); //debug
System.out.println(getJumpedPixelCounter()); //debug
System.out.println("Vergangene Zeit"); //debug
System.out.println(getTimeElapsedInMs()); //debug
System.out.println(); //debug
setJumpedPixelCounter(0); //Gesprungene Pixel wieder auf 0 setzen, da Sprung zurückgesetzt wird
setFallStartTime(System.currentTimeMillis());
isFalling = true; //Fallen eingeleitet
break; //Wenn If Bedingung eintritt, for Schleife abbrechen
}
}
}
/**
* Formel zum Berechnen der Sprungdauer bei gegebener Start-Geschwindigkeit
*
* @return
*/
public double getJumpTimeInMs() {
double time = (-this.startSpeedInMeterPerSecond / -this.gravitation);
return time * 1000;
}
public long getDurationJump() {
return System.currentTimeMillis() - start;
}
/**
* Formel zum Berechnen der Geschwindigkeit nach einer gewissen Zeit
*
* @param timeElapsedInMs
* @return
*/
public double getSpeedAfterTimeInMeterPerSecond(long timeElapsedInMs) {
// return startSpeedInMeterPerSecond - gravitation * (timeElapsedInMs / 1000.0);
return ((this.startSpeedInMeterPerSecond * 1000) - (this.gravitation * timeElapsedInMs)) / 1000;
}
// public void calculateJump() {
// pixelPerTimerPassList = new ArrayList<>();
// for (int i = 0; i < getJumpTimeInMs(); i++) { //JumpTime 500ms
// pixelPerTimerPassList.add(getNeededPixelPerTimerPassWithGivenSpeedInMeterPerSecond(getSpeedAfterTimeInMeterPerSecond(i)));
// }
// }
public int getNeededPixelPerTimerPassWithGivenSpeedInMeterPerSecond(double speedInMeterPerSecond) {
return (int) (speedInMeterPerSecond);
}
public Physics refreshPixelPerTimerPass() {
this.pixelPerTimerPass = getPixelPerTimerPass();
return this;
}
public int getPixelPerTimerPass() { //Pixel die er pro TimerDurchgang hoch springt
int speed = (int) (getSpeedAfterTimeInMeterPerSecond(timeElapsedInMs));
if (speed > 0) return (int) (getSpeedAfterTimeInMeterPerSecond(timeElapsedInMs));
else return 1;
}
public Physics setTimeElapsedInMs() {
long timeElapsedInMs = System.currentTimeMillis() - start;
this.timeElapsedInMs = timeElapsedInMs;
return this;
}
public double getStartSpeedInMeterPerSecond() {
return startSpeedInMeterPerSecond;
}
public void setStartSpeedInMeterPerSecond(double startSpeedInMeterPerSecond) {
this.startSpeedInMeterPerSecond = startSpeedInMeterPerSecond;
}
public double getGravitation() {
return gravitation;
}
public long getTimeElapsedInMs() {
return timeElapsedInMs;
}
public int getJumpedPixelCounter() {
return jumpedPixelCounter;
}
public Physics setJumpedPixelCounter(int jumpedPixelCounter) {
this.jumpedPixelCounter = jumpedPixelCounter;
return this;
}
public Physics increaseJumpedPixelCounter(int pixel) {
jumpedPixelCounter = jumpedPixelCounter + pixel;
return this;
}
public long getFallStartTime() {
return fallStartTime;
}
public Physics setFallStartTime(long fallStartTime) {
this.fallStartTime = fallStartTime;
return this;
}
public long getFallDuration() {
return fallDuration;
}
public Physics setFallDuration(long fallDuration) {
this.fallDuration = fallDuration;
return this;
}
public int getMinimumSpeed() {
return minimumSpeed;
}
public long getStart() {
return start;
}
public Physics setStart(long start) {
this.start = start;
return this;
}
public List<Integer> getPixelPerTimerPassList() {
return pixelPerTimerPassList;
}
public Physics setHeroObject(Hero mario) {
this.mario = mario;
return this;
}
public boolean getJumping() {
return isJumping;
}
public Physics setJumping(boolean jumping) {
this.isJumping = jumping;
return this;
}
public boolean getFalling() {
return isFalling;
}
public Physics setFalling(boolean falling) {
this.isFalling = falling;
return this;
}
public int getGameLoops() {
return gameLoops;
}
}package Pokemon;
public class Hero {
private final Physics physics;
private Canvas canvas;
private final int TILESIZE;
private final int ZOOM;
private int speed = 0;
private int feetPosition = 2; //1,2,3 (1 = rechter Fuß, 2 = normal, 3 = linker Fuß) Veraltetes Kommentar, da Wiederverwendung aus anderem Projekt
private Direction direction = Direction.RIGHT;
private int positionX = 0; //Position des Charakters beim Start
private int positionY; //Position des Charakters beim Start
private int finalPositionX; //Temporäre Final-Position für den Fußwechsel
private int finalPositionY;
private int walkSpeed = 4;
private int fallDelay = 41; //Umso höher umso langsamer fällt Mario
private int feetPositionBackup;
private Direction directionBackup;
Direction directionOld = getDirection();
int feetPositionOld = getFeetPosition();
int positionXOld = positionX;
int positionYOld = positionY;
private boolean promptRepaintHero = false;
public Hero(Canvas canvas, Physics physics) {
this.physics = physics;
this.canvas = canvas;
ZOOM = canvas.getZOOM();
TILESIZE = canvas.getTILESIZE();
positionX = 2 * TILESIZE * ZOOM;
positionY = 10 * TILESIZE * ZOOM;
physics.setHeroObject(this);
}
public boolean heroDataChanged() {
if (promptRepaintHero) {
promptRepaintHero = false;
return true;
}
if (directionOld != getDirection() || feetPositionOld != getFeetPosition() || positionXOld != positionX || positionYOld != positionY) {
refreshHeroData();
return true;
}
return false;
}
public void refreshHeroData() {
directionOld = getDirection();
feetPositionOld = getFeetPosition();
positionXOld = positionX;
positionYOld = positionY;
}
public void doJump() {
if (!physics.getJumping() && !physics.getFalling()) {
finalPositionY = getPositionY() - physics.getJumpedPixelCounter();
physics.setStart(System.currentTimeMillis());
physics.setJumping(true);
}
}
public void move(int speed) { //Bewegt Charakter in angegebener Geschwindigkeit (- oder +)
if (speed != 0) { //Bei Geschwindigkeit 0 muss nicht repainted werden
positionX += speed;
promptRepaintHero = true;
canvas.repaint();
}
}
public void moveUp(int pixel) {
for (int i = 0; i < pixel; i++) {
positionY--;
promptRepaintHero = true;
canvas.repaint();
}
}
public void moveDown(int pixel) {
for (int i = 0; i < pixel; i++) {
positionY++;
promptRepaintHero = true;
canvas.repaint();
}
}
public void refreshFinalPositionX() {
if (speed > 0) {
finalPositionX = positionX + (canvas.getTILESIZE() / 2) * canvas.getZOOM(); //Wert muss das X fache sein
}
if (speed < 0) {
finalPositionX = positionX - (canvas.getTILESIZE() / 2) * canvas.getZOOM();
}
}
public void changeFeetPosition() {
if (feetPosition == 1) { //rechts1, normal2, links3 //im Mario Projekt kein rechter Fuß
feetPosition = 2;
} else if (feetPosition == 2) {
feetPosition = 1;
} else {
feetPosition = 2;
}
promptRepaintHero = true;
canvas.repaint();
}
/*
Getter und Setter
*/
public int getFeetPosition() {
return feetPosition;
}
public Hero setFeetPosition(int feetPosition) {
this.feetPosition = feetPosition;
promptRepaintHero = true;
canvas.repaint();
return this;
}
public Direction getDirection() {
return direction;
}
public Hero setDirection(Direction direction) {
this.direction = direction;
promptRepaintHero = true;
canvas.repaint();
return this;
}
public int getPositionX() {
return positionX;
}
public Hero setPositionX(int positionX) {
this.positionX = positionX;
promptRepaintHero = true;
canvas.repaint();
return this;
}
public int getFinalPositionX() {
return finalPositionX;
}
public Hero setFinalPositionX(int finalPositionX) {
this.finalPositionX = finalPositionX;
return this;
}
public int getWalkSpeed() {
return walkSpeed;
}
public Hero setWalkSpeed(int walkSpeed) {
this.walkSpeed = walkSpeed;
return this;
}
public int getFeetPositionBackup() {
return feetPositionBackup;
}
public Hero setFeetPositionBackup(int feetPositionBackup) {
this.feetPositionBackup = feetPositionBackup;
return this;
}
public Direction getDirectionBackup() {
return directionBackup;
}
public Hero setDirectionBackup(Direction directionBackup) {
this.directionBackup = directionBackup;
return this;
}
public int getSpeed() {
return speed;
}
public Hero setSpeed(int speed) {
this.speed = speed;
return this;
}
public int getFallDelay() {
return fallDelay;
}
public Hero setFallDelay(int fallDelay) {
this.fallDelay = fallDelay;
return this;
}
public int getPositionY() {
return positionY;
}
public int getFinalPositionY() {
return finalPositionY;
}
public Hero setFinalPositionY(int finalPositionY) {
this.finalPositionY = finalPositionY;
return this;
}
public Hero setPromptRepaintHero(boolean promptRepaintHero) {
this.promptRepaintHero = promptRepaintHero;
return this;
}
}package Pokemon;
import java.awt.image.BufferedImage;
/**
* Management of Images for
*/
public class ImageManagement {
private Object viewingImageLock = new Object();
/**
* Width of window / images.
*/
private volatile int width;
/**
* Height of window / images.
*/
private volatile int height;
private volatile BufferedImage currentDrawingImage;
private volatile BufferedImage nextDrawingImage1;
private volatile BufferedImage nextDrawingImage2;
private volatile BufferedImage currentViewingImage;
private volatile BufferedImage nextViewingImage;
/**
* Creates a new instance of ImageManagement;
* @param width width of images.
* @param height height of images.
*/
public ImageManagement(int width, int height) {
this.width = width;
this.height = height;
currentDrawingImage = createImage();
nextDrawingImage1 = createImage();
nextDrawingImage2 = createImage();
}
/**
* Creates a new BufferedImage in the correct size.
* @return BufferedImage to use.
*/
private BufferedImage createImage() {
return new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
}
/**
* Sets the new size of the images.
* @param width Width of images.
* @param height Height of images.
*/
public void setSize(int width, int height) {
this.width = width;
this.height = height;
}
/**
* Gets the current image to view. Takes care of a new image and moves old image back to queue.
* @return The BufferedImage that should be displayed.
*/
public BufferedImage getCurrentViewingImage() {
if (nextViewingImage != null) {
synchronized (viewingImageLock) {
if (nextDrawingImage1 == null) {
nextDrawingImage1 = currentViewingImage;
} else {
nextDrawingImage2 = currentViewingImage;
}
currentViewingImage = nextViewingImage;
nextViewingImage = null;
}
}
return currentViewingImage;
}
/**
* Gets the next BufferedImage to draw.
* <li>
* <ul>The last drawn image is moved to be shown next.</ul>
* <ul>Gets the next image in the queue</ul>
* <ul>Checks the size of the image and creates a new one if required.</ul>
* </li>
* @return
*/
public BufferedImage getNextDrawingImage() {
synchronized (viewingImageLock) {
if (nextViewingImage != null) {
nextDrawingImage2 = nextViewingImage;
}
nextViewingImage = currentDrawingImage;
currentDrawingImage = nextDrawingImage1;
nextDrawingImage1 = nextDrawingImage2;
nextDrawingImage2 = null;
}
// Check if resize happened
if (currentDrawingImage.getWidth() != width || currentDrawingImage.getHeight() != height)
currentDrawingImage = createImage();
return currentDrawingImage;
}
}drawingImage = imageManagement.getNextDrawingImage();
canvas.repaint();case 1 -> graphicsHero.drawImage(canvas.getSpritesBufferedImage(), positionX, positionY, positionX + TILESIZE, positionY + TILESIZE, 0, 32, 0, 32, null); if (mario.getDirection().equals(Direction.LEFT)) {
switch (mario.getFeetPosition()) { //+ZOOM=Korrektur
case 1 -> graphicsHero.drawImage(canvas.getSpritesBufferedImage(), positionX, positionY - OFFSET, positionX + TILESIZE * ZOOM, (positionY + TILESIZE * ZOOM) + ZOOM, 1, 91, 17, 118 + 1, null); //links Fuß vorn
case 2 -> graphicsHero.drawImage(canvas.getSpritesBufferedImage(), positionX, positionY - OFFSET, positionX + TILESIZE * ZOOM, (positionY + TILESIZE * ZOOM) + ZOOM, 19, 91, 35, 118 + 1, null); //links stehend
}
}
if (direction.equals(Direction.RIGHT)) {
switch (feetPosition) { // offset ist der Wert wieviel über 16 Pixel Block gezeichnet werden soll //+ZOOM=Korrektur
case 1 -> graphicsHero.drawImage(canvas.getSpritesBufferedImage(), positionX, positionY - OFFSET, positionX + TILESIZE * ZOOM, (positionY + TILESIZE * ZOOM) + ZOOM, 1, 31, 17, 58 + 1, null); //rechts Fuß vorn
case 2 -> graphicsHero.drawImage(canvas.getSpritesBufferedImage(), positionX, positionY - OFFSET, positionX + TILESIZE * ZOOM, (positionY + TILESIZE * ZOOM) + ZOOM, 19, 31, 35, 58 + 1, null); //rechts stehend
}
... uswDas liegt einfach vermutlich einfach daran, dass ich derzeit nur sehr wenig Zeit in andere Hobbies stecke / stecken kann. Die laufen hetzt zwar auch alle nach und nach wieder an (nach Corona) aber ich bin da halt doch etwas vorsichtig.
)
