Thread reagiert nicht sofort auf Tastendruck

[Unknown_User]

Hallo,

ich habe ein JPanel auf dem ein Ball von oben nach unten "herabfällt".
Dazu habe ich einen Thread laufen der diese Animation steuert. So fällt der Ball also jede Sekunde um eine bestimmte Pixelanzahl herunter.

Wenn jetzt die Leertaste gedrückt wird, dann soll der Ball schneller herunterwandern.
Wenn die Taste gedrückt wird, dann ist es jetzt leider so, dass diese Änderung der Geschwindigkeit nicht direkt eintritt, sondern verzögert.
Das hat ja damit zu tun, dass der Thread die neu gesetzte Geschwindigkeit erst umsetzt wenn die ursprüngliche Sekunde rum ist bevor es wieder weiter geht in der while Schleife des Threads.

Wie kann ich also eine Synchronisation zwischen dem Thread und der Oberfläche mit dem Keylistener herstellen, so dass nach Leertastendruck die Geschwindigkeit geändert wird und die Animation direkt schneller wird.

Danke schon mal für eure Tipps.

 

[maki]

Code?

 

[ikam]

Du kannst auf den Thread interrupt() aufrufen, dann wird dein sleep() abgebrochen.

Code?

?????

 

[Unknown_User]

Hallo,

@Maki
also hier ist mal der komplette Code:

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

import javax.swing.JComponent;
import javax.swing.JFrame;


public class Test extends JFrame implements KeyListener{
		
	public Test(){
		setSize(new Dimension(500,500));
		addKeyListener(this);
		setVisible(true);
		add(new MyBall(this));
		setDefaultCloseOperation(EXIT_ON_CLOSE);
	}
	
	public static void main(String[] args) {
		new Test();
	}

	@Override
	public void keyPressed(KeyEvent arg0) {
		// TODO Auto-generated method stub
		if(arg0.getKeyCode() == KeyEvent.VK_SPACE);
		MyThread.speed = 50;
	}

	@Override
	public void keyReleased(KeyEvent arg0) {
		// TODO Auto-generated method stub
		MyThread.speed = 1000;
	}

	@Override
	public void keyTyped(KeyEvent arg0) {
		// TODO Auto-generated method stub
	}
	
}

class MyBall extends JComponent{
	
	int yValue = 0;
	public MyBall(JFrame main){
		new MyThread(this, main, yValue);
	}
	
	public void paintComponent(Graphics g){
		super.paintComponents(g);
		
		g.drawOval(50, yValue, 20, 20);
	}
	
}

class MyThread extends Thread {
	
	static int speed = 1000;
	int yCoord;
	JFrame f;
	MyBall mb;
	
	public MyThread(MyBall mb, JFrame mainFrame, int yCoord){
		this.f = mainFrame;
		this.mb = mb;
		this.yCoord = yCoord;
		start();
	}
	
	public void run(){
		while(true){
			try{
				sleep(speed);
				mb.yValue += 5;
				f.repaint();
			}catch(Exception e){
				e.printStackTrace();
			}
		}
	}
}

Wenn ihr es startet und unmittelbar nach dem der "Ball" einen schritt runter gegangen ist die Leertaste drückt reagiert der ball aufs schneller werden erst, wenn er den nächsten schritt nach unten abgearbeitet hat.

@ikam
Ein interrupt stoppt doch meinen Thread und gestoppte Threads kann man ja nicht wieder weitermachen lassen.

Müsste ich also meinen Thread stoppen und der übergibt an einen neuen Thread die neue Geschwindigkeit (also so lange der user die leertaste drückt) und beendet den auch wenn die leertaste wieder losgelassen wird?

Danke

 

[njans]

Maki möchte gerne etwas code sehen, denn damit wird auch klarer, wo genau das Problem liegt

 

[njans]

Hmm du könntest doch erstmal die Zeit pro neuzeichnung verringern:
Setze mal mb.yValue += 1;
Und dann wartest du standart gemäß nicht 1000, sondern 200. Damit hast du schon mal ein deutlich kleinere Delay
Ist das nicht schon ausreichend?

 

[Kevin94]

Nein ein interrupt() beendet nicht den Thread. Es "weckt" einen schlafenden Thread auf. Konkret versetzt es einen Thread der sich selber in den "blocked" Zustand begeben hat (z.B. durch sleep()) in den Zustand "ready-to-run" dabei wird in der entsprechenden Methode eine InterrupedException geworfen.

 

[Unknown_User]

@Kevin94
Bedeutet das, dass mein Thread nach dem interrupt() seine Arbeit also wieder aufnimmt? Und das mit dem dann neu gesetzten Sleep-Wert?

@njans
Ok das würde zwar gehen, aber nicht sinn der sache sein. Es soll schon möglich sein, dass auch mit einem Sleep-wert von einer Sekunde immernoch ein direktes beschleunigen des Threads möglich ist.

 

[Kevin94]

Bei deinem Geposten code würde folgendes passiern:
sleep wirft eine InterruptedException -> catch Block -> ausgabe
neuer Durchlauf der while Schleife-> noch mal sleep -> verschieben.

Ein interrupt würde also erst mal zu einer Velängerung der Verzögerung führen. Wenn du aber das try-catch nur um den sleep()-Aufruf machst oder ihn ans Ende setzt würde es zum Ziel führen.

 

[Unknown_User]

@Kevin94
Hey Danke schon mal an dich.
Also mit dem hier geposteten Code macht er es jetzt schon mal so wie ich es gerne haben möchte, nur es wird immer die InterruptedException geschmissen...
Kannst du mir das nochmal ein wenig mehr erklären, warum er das tut?

Ich habe deinen Rat befolgt und nur noch den sleep()-Befehl in der Try and Catch drin, aber es wird trotzdem ein Printstacktrace geworfen..

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

import javax.swing.JComponent;
import javax.swing.JFrame;


public class Test extends JFrame implements KeyListener{
		
	MyBall myB;
	public Test(){
		setSize(new Dimension(500,500));
		addKeyListener(this);
		setVisible(true);
		myB = new MyBall(this);
		add(myB);
		setDefaultCloseOperation(EXIT_ON_CLOSE);
	}
	
	public static void main(String[] args) {
		new Test();
	}

	@Override
	public void keyPressed(KeyEvent arg0) {
		// TODO Auto-generated method stub
		if(arg0.getKeyCode() == KeyEvent.VK_SPACE);
		MyThread.speed = 50;
		myB.mainThread.interrupt();	
	}

	@Override
	public void keyReleased(KeyEvent arg0) {
		// TODO Auto-generated method stub
		MyThread.speed = 1000;
	}

	@Override
	public void keyTyped(KeyEvent arg0) {
		// TODO Auto-generated method stub
	}
}

class MyBall extends JComponent{
	
	int yValue = 0;
	Thread mainThread;
	public MyBall(JFrame main){
		mainThread = new MyThread(this, main, yValue);
	}
	
	public void paintComponent(Graphics g){
		super.paintComponents(g);
		
		g.drawOval(50, yValue, 20, 20);
	}
}

class MyThread extends Thread {
	
	static int speed = 1000;
	int yCoord;
	JFrame f;
	MyBall mb;
	
	public MyThread(MyBall mb, JFrame mainFrame, int yCoord){
		this.f = mainFrame;
		this.mb = mb;
		this.yCoord = yCoord;
		start();
	}
	
	public void run(){
		while(true){
			mb.yValue += 5;
			f.repaint();
			try{
				sleep(speed);
			}catch(InterruptedException e){
				e.printStackTrace();
			}
		}
	}
}

 

[Kevin94]

Ist auch richtig so. Eine InterruptedException wird immer geworfen wenn die sleep Methode mittels interrupt() abgebrochen wird. Es teilt dem Programmierer sozusagen mit: "Du hast was gemacht, was du nicht erwartet hast, also reagier gefälligst anders drauf". Mann kann die Exception eigentlich als Überflüssig ansehen. Einfach try-catch und ignorieren.

 

[Unknown_User]

@Kevin94
Ah ok, vielen dank.
Du hast mir wirklich weiter geholfen.

 

[tagedieb]

Schöner wär's allerdings die Fallgeschwindigkeit und nicht die Frames Per Second (FPS) zu verändern

 

[hdi]

Schöner wär's allerdings die Fallgeschwindigkeit und nicht die Frames Per Second (FPS) zu verändern

Absolut richtig. @TO zur Erklärung: Die Anzeige bleibt konstant. Maximal 100fps, i.d.R. reicht 60 (Die meisten Bildschirme haben immernoch max. 60 Hz). Also 60 mal repaint() pro Sekunde. Unabhängig davon ist die Geschwindigkeit der Logik ("Ticks"). Du kannst den Thread ruhig 100 mal pro Sekunde durch seine Schleife schicken. Er berechnet bei jedem Durchlauf die Zeit, die seit dem letzten Durchlauf vergangen ist (Timestamp bei jedem Durchlauf) und addiert diese auf, solange bis ein Wert erreicht ist, der für ihn bedeutet: Es wird Zeit, die Logik voranzutreiben. D.h. er ändert die Position des Balls. Das passiert bei dir zB alle 1000ms und bei jedem Drücken der Leertaste.

Das Problem bei deinem Ansatz mit konstanten Werten ist, dass die Spiellogik von der Geschwindigkeit der CPU abhängig ist:

Rechner A (alter Schrott-PC):
24ms Berechnung (Ball um 5 px verschieben)
100ms sleep
24ms Berechung (Ball um 5 px verschieben)
100ms sleep
= Ball um 10px gefallen nach 248ms = Ball um 100px gefallen nach 2,48 Sekunden

Rechner B (High-End PC):
2ms Berechnung (Ball um 5 px verschieben)
100ms sleep
2ms Berechung (Ball um 5 px verschieben)
100ms sleep
= Ball um 10px gefallen nach 204ms = Ball um 100px gefallen nach 2,04 Sekunden

Das ist natürlich nicht, was du beabsichtigst. Wenn du dein Spiel machst denkst du dir ja "der Ball sollte so und so schnell fallen", und nicht "der Loop sollte so und so oft ausgeführt werden". Aber genau auf letzterem basiert deine Spiellogik. Wenn es jetzt ein Reaktionsspiel wäre dann würd ich meine CPU mit im Hintergrund laufenden Programmen so stark belasten, dass er mit der Berechnung deines Spiels kaum mitkommt. Ich spiele dann dein Spiel in Slow-Motion und knacke jeden Highscore.. Mit obigem Ansatz ist das nicht so - dort fällt der Ball auf jedem PC in 1 Sekunde um x Pixel, völlig unabhängig davon wie oft die Schleife durchlaufen wurde oder wie oft er ein Repaint geschafft hat.

Andersrum gilt das selbe: Man kennt es von einigen sehr alten Spielen, die teils noch für DOS gecodet wurden, dass sie auf neuen Rechnern unspielbar sind weil alles viel zu schnell abläuft. Das ist der gleiche Fehler, die Programmierer sind davon ausgegangen dass der Loop x mal pro Sekunde durchlaufen wird. Aber das ist halt abhängig vom PC, und vom Scheduling d.h. was noch so für Programme grad laufen usw.

 

[hdi]

Hier mal noch ein Beispiel was ich meine:

import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Point;

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

public class GameLoopDemo {

	public static void main(String[] args) {

		SwingUtilities.invokeLater(new Runnable() {
			public void run() {

				final Point ballPos = new Point(0, 0);

				@SuppressWarnings("serial")
				final JPanel p = new JPanel() {
					protected void paintComponent(Graphics g) {
						super.paintComponent(g);
						g.fillOval(ballPos.x, ballPos.y, 50, 50);
					};
				};
				p.setPreferredSize(new Dimension(100, 500));

				JFrame f = new JFrame();
				f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
				f.add(p);
				f.pack();
				f.setVisible(true);

				new Thread() {
					public void run() {

						long ticks = 0;
						long timePrevious = System.nanoTime();

						while (true) {
							p.repaint();

							long timeNow = System.nanoTime();
							long delta = timeNow - timePrevious;
							timePrevious = timeNow;

							ticks += delta;
							long ballSpeed = 1000000000L / 100; // 1 Milliarde
																// Nanosekunden
																// / 100
							while (ticks >= ballSpeed) {
								ballPos.y++;
								ticks -= ballSpeed;
							}

							/*
							 * 100 FPS
							 */
							try {
								Thread.sleep(10);
							} catch (InterruptedException e) {
								e.printStackTrace();
							}

							// /*
							// * 5 FPS - Das Spiel ruckelt, läuft aber genauso
							// * schnell ab. (Ballbewegung)
							// */
							// try {
							// Thread.sleep(200);
							// } catch (InterruptedException e) {
							// e.printStackTrace();
							// }

						}

					};
				}.start();
			};
		});
	}
}

Ein schneller PC schafft 100 fps, ein langsamer evtl. weniger. Aber egal wie oft der Loop durchlaufen wird, das Endergebnis (Position des Balls) ist immer das selbe.

Die ganze Sache mit dem Gameloop wird übrigens auch sehr schön in Quaxli's Spieletutorial erklärt.