# Action-Spiel in Java?



## Javaner 0815 (14. Sep 2009)

Hi,
---(genaues Problem unten, hier nur Einleitung)---
ich wollte mal ein einfaches Spiel in Java machen. Und wollt euch fragen, ob ich da grundlegend was falsch mache oder ob das nicht geht.

Und zwar wollte ich das erst in einem Frame (extends Frame) machen. Da trat aber ein Problem auf (gleiche wie unten), also suchte ich mal nach nem Tut und bin in dem Forum hier auf Quaxli's ausführliches 2D-Spieleprogrammierung-Tut gestoßen hier. Habe also JPannel und JFrame statt Frame genommen und die Bewegung anhand der vergangenen Zeit statt mit Einheiten je Zeit gemacht. Habe nicht das ganze Tut-Programm gemacht sondern nur in etwa die beschriebene Bewegung. Hatte da gleich die Dateien von meinem Frame-Spiel-Versuch genommen und abgeändert.

Problem: Bewegungen von Bild nicht flüssig.

Obwohl ich paintComponent vom JPanel aller 10ms (100fps) aufrufe ruckelt das bildvor sich hin. Auch 100ns bringen nix. Das Bild hat eine Geschwindigkeit von ca. 200px/sec. 

hier relevanter code: (steuerung mit  wasd)

```
@Override
    public void paintComponent(Graphics g) {
        super.paintComponent(g);
        setMovement();   
        time = System.nanoTime();
        g.drawImage(thePlayer, (int) player.x_pos, (int) player.y_pos, this);
    }

    public void run() {
        while (running) {
            paintComponent(data.getGraphics());
            try {
                Thread.sleep(10);
            } catch (InterruptedException ex) {
            }
        }
    }


//------------------
  public void setMovement() {
        if (data.getKeyboard().d_isD) {
            player.x_pos += 400*((double) (System.nanoTime() - time)) / div;
        }
        if (data.getKeyboard().a_isD) {
            player.x_pos -= 400*((double) (System.nanoTime() - time)) / div;
        }
        if (data.getKeyboard().s_isD) {
            player.y_pos += 400*((double) (System.nanoTime() - time)) / div;
        }
        if (data.getKeyboard().w_isD) {
            player.y_pos -= 400*((double) (System.nanoTime() - time)) / div;
        }
    }
```

oder ist das bild noch nicht geladen und muss immer wieder neu geladen werden?

```
Image thePlayer = Toolkit.getDefaultToolkit().getImage("data\\player.jpg");
```

Dies ist zwar nicht 100% wie im Tut aber müsste doch auch klappen, oder?

Oder liegts daran, dass erst das alte bild gelöscht wird und dann das neue hinzu kommt und das so lange dauert, dass man denk es ist nich flüssig? Da Lieber noch ein 2. Bild reinmachen, dass dem ersten in der Bewegung folgt?


----------



## Quaxli (14. Sep 2009)

Poste doch mal die Klasse von thePlayer oder gleich das ganze Game als ZIP


----------



## dayaftereh (14. Sep 2009)

Hey, ich glaube das problem liegt daran das du die paintComponent Methode direckt aus der Schleife aufruft, normaler weiß ruf man die [java=11] public void repaint()  [/code] auf, ich habe ein kleines Code beispiel am mit gepostet, ich hoffe das es dir Hilft, Also Ich erzuge eine JFame und füghe da ein JPanel hinzu, und überschiebe dan die [java=109] protected void paintComponent(Graphics g)  [/code]. Auserdem füghe ich dan ein KeyListener auf das JPanel hinzu. um das Viereck auf dem jpanel zu bewegen, schau dir einfach mal den code an, bei fragen Scheib mir ne PN:

GameLoop.java

```
import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;

import javax.swing.JFrame;
import javax.swing.JPanel;

public class GameLoop extends JPanel implements Runnable {
	
	private static final long serialVersionUID = -5173186462217554467L;
	
	/** Ob der Loop gestarted ist */
	private boolean started = true;
	/** Welche Pfeil taste gedrückt ist */
	private boolean up, down, left, right = false;

	/** Die Fps als int */
	private int fps = 0;
	/** der bewegungs speed ist 100px pro Sekunde */
	private int speed = 100;

	/** Letzte berechnugn von den fps */
	private long last = 0;
	/** das Delay */
	private long delay = 0;

	/** Der JFrame */
	private JFrame f = null;

	/** Die X und Y position vom Rechteck */
	private double x, y = 0;

	public GameLoop() {
		initComponents();
	}

	/**
	 * Erzeugt den {@link JFrame} und füght das {@link JPanel} hinzu
	 */
	private void initComponents() {
		f = new JFrame();
		f.setTitle("Game");
		f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

		f.setLayout(new BorderLayout());

		this.setPreferredSize(new Dimension(800, 600));
		// Der KeyListener
		this.addKeyListener(new MoveAdapter());
		f.add(this, BorderLayout.CENTER);

		f.pack();
		f.setLocationRelativeTo(null);
		f.setVisible(true);

		this.requestFocus();
	}

	public void run() {
		last = System.nanoTime();

		// Setzt Start Position
		x = this.getWidth() / 2;
		y = this.getHeight() / 2;

		// Die render Schleife
		while (started) {

			// Berechnet das Delay und FPS
			culFPS();

			// Prüft die Tasten
			isKey();

			// Zeichnet neu
			this.repaint();

			// Schläft
			try {
				Thread.sleep(20);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

	/**
	 * Prüft welche Taste gedrück worden ist und berechnet den Speed und addiert
	 * ihn zu der Position.
	 */
	private void isKey() {
		if (down) {
			y += (delay / 1e9) * speed;
		}
		if (up) {
			y -= (delay / 1e9) * speed;
		}
		if (right) {
			x += (delay / 1e9) * speed;
		}
		if (left) {
			x -= (delay / 1e9) * speed;
		}
	}

	@Override
	protected void paintComponent(Graphics g) {
		super.paintComponent(g);
		g.drawString("Fps:" + fps, 10, 20);
		g.drawRect((int) x, (int) y, 50, 50);
	}

	/**
	 * Berechnung der FPS
	 */
	private void culFPS() {
		delay = System.nanoTime() - last;
		fps = (int) (1e9 / delay);
		last = System.nanoTime();
	}

	public static void main(String[] args) {
		GameLoop gameLoop = new GameLoop();
		Thread t = new Thread(gameLoop);
		t.start();
	}

	/**
	 * Der Key Listener
	 * 
	 * @author LoefflerL
	 * 
	 */
	private class MoveAdapter implements KeyListener {

		public void keyPressed(KeyEvent e) {
			if (e.getKeyCode() == KeyEvent.VK_UP) {
				up = true;
			} else if (e.getKeyCode() == KeyEvent.VK_DOWN) {
				down = true;
			} else if (e.getKeyCode() == KeyEvent.VK_LEFT) {
				left = true;
			} else if (e.getKeyCode() == KeyEvent.VK_RIGHT) {
				right = true;
			}
		}

		public void keyReleased(KeyEvent e) {
			if (e.getKeyCode() == KeyEvent.VK_UP) {
				up = false;
			} else if (e.getKeyCode() == KeyEvent.VK_DOWN) {
				down = false;
			} else if (e.getKeyCode() == KeyEvent.VK_LEFT) {
				left = false;
			} else if (e.getKeyCode() == KeyEvent.VK_RIGHT) {
				right = false;
			}
		}

		public void keyTyped(KeyEvent e) {

		}

	}

}
```


----------



## Javaner 0815 (14. Sep 2009)

Quaxli hat gesagt.:


> Poste doch mal die Klasse von thePlayer oder gleich das ganze Game als ZIP


thePlayer ist nur das Bild (erster Post ganz unten)

aber ich denke du meintest player (hab nicht so tolle namen gemacht^^)


```
public class player {
double x_pos=100;
double y_pos=100;
}
```
sollte man nicht so machen! (Für die die das lesen, lieber get/set).
und btw thx für das schöne tut.




dayaftereh hat gesagt.:


> Hey, ich glaube das problem liegt daran das du die paintComponent Methode direckt aus der Schleife aufruft, normaler weiß ruf man die [java=11] public void repaint()  [/code] auf


ja thx so klappts.
Ich weiß zwar nich warum aber es geht 
Ist Java so schlau, dass es sich alles Componenten merkt und diese dann aktualisiert?


----------



## dayaftereh (15. Sep 2009)

Hey

Also, die repaint methode kommt aus der Klasse Component, wie du weißt hat jedes Swing Componete die Klasse Component als Vater. So wenn du jetzt auf eine JFrame ein JPanel addes wird das JFrame zu dem obenliegendem Container, wird das JFrame neu gezeichentet (z.B. wenn es den Focus verliert und wieder bekommt) dan wird bei alle Component die auf dem JFrame liegt die paintComponent methode aufgerufen. dieses neu zeichnen geschiet duch die Methode repaint, also wenn der JFrame sein Focus wieder bekommt wird die Method repaint() aufgerufen und ruft bei allen Component die auf dem JFrame liegen die paintComponent methode auf. Vieleicht liesst du dir das noch mal nach und denke dran das du mit 2 Threads abeites, die paintComponent wird vom EventDispatcher-Thread aufgerufen, also muss du synchronize nutzen, wenn du objekte veränderst.

Ich weiß nur nich ob man in der paintComponent Methode auch die super.paintComponent  aufrufen soll?

Wenn ich was falsch erklärt habe? pls Posten!


----------



## andre111 (15. Sep 2009)

Auch wenn in paintComponent() kein super.paintComponent()-Aufruf drin ist, wird mit repaint() trotzdem neu gezeichnet.


----------



## dayaftereh (15. Sep 2009)

Ja, das ist mir klar, nur als ich das mal ausprobiert habe , war das panel weiß als ich die super.paintComponent weg gelassen habe. und als ich sie wieder genutzt habe war das JPanel wieder Grau!


----------



## andre111 (15. Sep 2009)

Der Aufruf von super.paintComponent() sorgt dafür, dass die Hintergrundfarbe gezeichnet wird --> grauer Hintergrund, ansonsten weiß. Sonst macht er bei einem JPanel nichts weiter (denke ich, bin mir aber nicht genau sicher).


----------

