"Verrutschen" von Komponenten bei repaint()

[Frost_]

Hallöchen,

ich habe mal ein kleines Snake Spiel geschrieben und wollte nun noch einen Punktezähler einbauen.
Dazu will ich mein JFrame so aufteilen, dass oben die Punkte in einem JLabel angezeigt werden und darunter in einem JPanel das Spiel abläuft.
Problem:
Kurz nach Programmstart verrutscht alles etwas nach unten und ist doppelt da. Dazu auch zwei Bilder:

So sieht es einen kurzen Moment nach Programmstart aus ( so sollte es auch sein )


So sieht es danach aus ( ist ein neues Spiel mit anderen Koordinaten für den grünen Punkt, daher ist der so weit unten )


Und zwar passiert das im zweiten Durchlauf der while Schleife in 48 - 59.
Das erste repaint() in 50 funktioniert also noch. ( habe das mit einer längeren Sleep Zeit getestet )
Sobald man die Schlange über die verrutschten Sachen bewegt verschwinden diese.

Auch tritt das Problem nicht mehr auf, nachdem man einmal vor die Wand gefahren und die Zeichenfläche mit meiner clear() Methode geleert wird.

Erläuterungen zum Quellcode:
drawSnake ist die Zeichenfläche auf der das Spiel ablaufen soll. Sie erbt von JPanel
In der paint Methode davon zeichne ich jeweils nur das Futter (grün), das erste Segement der Schlange (schwarz) und übermale das letzte Segement mit der Hintergrundfarbe.
Rufe ich clear() auf, so übermalt er mir vorher alles mit der Hintergrundfarbe.

Wäre schön wenn mir da jemand helfen könnte.

public class SnakeGame extends Thread {

	SnakeField field;
	Snakelist snake;
	int foodX;
	int foodY;
	JFrame snakeFrame;
	Zeichenflaeche drawSnake;
	final int dimX = 24;
	final int dimY = 19;
	MyKeyListener steuerung;
	
	public static void main(String[]args) {
		
		SnakeGame game = new SnakeGame();
		game.start();
		
	}
	
	SnakeGame() {
		field = new SnakeField (dimX, dimY);
		foodX = field.foodX;
		foodY = field.foodY;
		JPanel top = new JPanel();
		
		drawSnake = new Zeichenflaeche(dimX,dimY,field);
		snakeFrame = new JFrame();
		snakeFrame.setLayout(new BorderLayout());
		
		top.add(new JLabel("Punkte: "+0));
		
		snakeFrame.setSize(800, 600);
		snakeFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		steuerung = new MyKeyListener();
		snakeFrame.addKeyListener(steuerung);
		snakeFrame.getContentPane().add(top,BorderLayout.NORTH);
		snakeFrame.getContentPane().add(drawSnake,BorderLayout.CENTER);
		
		snakeFrame.setResizable(false);
		
		snakeFrame.setVisible(true);
	}
	
	public void run() {
		
		while ( true ) {
			boolean collision = false;
			while ( !collision ) {
				collision = field.simulateOneStep(steuerung.getAlignment());
				drawSnake.repaint();
				foodX = field.foodX;
				foodY = field.foodY;
				try {
					sleep(100);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			try {
				sleep(300);
			} catch (InterruptedException e1) {
				// TODO Auto-generated catch block
				e1.printStackTrace();
			}
			field.reset(dimX, dimY);
			drawSnake.clear();
			steuerung.reset();
		}
	}
}

class Zeichenflaeche extends JPanel {
	
	SnakeField field;
	int dimX;
	int dimY;
	int width;
	int height;
	boolean clear;
	
	Zeichenflaeche(int dX, int dY, SnakeField f) {
		super();
		clear = false;
		dimX = dX;
		dimY = dY;
		field = f;
	}
	
	public void clear() {
		clear = true;
		repaint();
	}
	
	public void paint(Graphics g) {
		Color bg = this.getBackground();
		width = getWidth() / dimX;
		height = getHeight() / dimY;
		if ( clear ) {
			g.setColor(bg);
			g.fillRect(0, 0, getWidth(), getHeight());
			clear = false;
		}
		g.setColor(Color.green);
		g.fillRect(field.foodX*width, field.foodY*height, width, height);
		g.setColor(bg);
		g.fillRect(field.getSnake().getTail().getX()*width, field.getSnake().getTail().getY()*height, width, height);
		g.setColor(Color.black);
		g.fillRect(field.getSnake().getHead().getX()*width, field.getSnake().getHead().getY()*height, width, height);
	}
	
}

 

[Schandro]

überschreib "paintComponent" statt "paint" und ruf innerhalb von "paintComponent" als erstes "super.paintComponent(g);" auf

Sollte man grundsätzlich immer machen vllt. liegt dein Grafikbug auch dadran.

 

[Frost_]

Erstmal danke für die schnelle Antwort.

Funktioniert mit der Änderung aber leider noch genauso wenig.

/edit sagt:

Ups, hab super.paintComponents gehabt statt super.paintComponent.

Jetzt hab ich das Problem mit dem verrutschen nicht mehr, dafür wird die Schlange in jedem Schritt komplett übermalt, sodass nur noch das erste Segement da ist

 

[Schandro]

Jep, beim neuzeichnen wird das Fenster jedesmal komplett geleert. (Falls du das nicht willst, kannst du der Methode repaint Parameter mitgeben (siehe API), dann wird nur der gegeben Abschnitt neugemalt. Sowas sollte aber nur für Performancezwecke genutzt werden!)

        g.fillRect(field.getSnake().getTail().getX()*width, field.getSnake().getTail().getY()*height, width, height);
        g.setColor(Color.black);
        g.fillRect(field.getSnake().getHead().getX()*width, field.getSnake().getHead().getY()*height, width, height);

Du malst nur 2 Rechtecke, deswegen kann es eh nie eine richtige Schlange ergeben. Ansonsten: Poste den restlichen Code.

 

[Frost_]

Ja, die beiden Rechtecke die ich da male sind einmal der neue Schlangenkopf und das Ende der Schlange, dass ich mit der Hintergrundfarbe wieder übermalen möchte.

Eben aus "Performancegründen" ( auch wenn man es nicht wirklich merken dürfte ) will ich nicht die ganze Schlange neu zeichnen. Die Schlange realisiere ich intern mit einer ConcurrentLinkedQueue. Wenn ich sie komplett neuzeichnen will müsste ich die Queue auf ein Array abbilden und das Array elementweise durchgehen. Dann bestünde das Problem auch nicht.
Das repaint mit Parameter dürfte hier wohl auch nicht dazu führen dass es so funktioniert wie ich es gern hätte. Müsste ja trotzdem jedes Mal den Hintergrund löschen, was auch wieder den Rest meiner Schlange killen würde.

Oder ist es einfach so, dass man alles neu zeichnen muss ( sprich, erst Hintergrund und dann was man davor haben will ), wenn man keine Fehler haben möchte?

Wie auch immer, hier der komplette Quelltext:

import java.util.concurrent.ConcurrentLinkedQueue;


public class Snakelist {
	
	private ConcurrentLinkedQueue<Snakenode> snake;
	private Snakenode head;
	/**
	 * Creates a new Snake Object. 
	 * @param initX
	 * @param initY
	 * @param initLenght
	 * @param alignment -- 0 = North, 1 = East, 2 = South, 3 = West, 4 = None
	 */
	public Snakelist(int initX, int initY, int initLenght, int alignment) {
		snake = new ConcurrentLinkedQueue<Snakenode>();
		snake.offer(new Snakenode ( initX, initY, 4 ));
		initLenght--;
		while ( initLenght > 0 ) {
			switch ( alignment ) {
			case 3 : 
				initX--;
				break;
			case 1 :
				initX++;
				break;
			case 2 :
				initY--;
				break;
			case 0:
				initY++;
				break;
			}
			initLenght--;
			head = new Snakenode ( initX, initY, 4 );
			snake.offer(head);
		}
	}
	
	public Snakenode getHead() {
		return head;
	}
	public Snakenode getTail() {
		return snake.peek();
	}
	public ConcurrentLinkedQueue<Snakenode> getSnake() {
		return snake;
	}
	
	
	public void move(int newAlignment, boolean eaten) {
		
		if ( !eaten ) {
			snake.poll();
		}
		
		int newX = head.getX();
		int newY = head.getY();
		int chosenAlignment = 0;
		if ( newAlignment != (head.getAlignment()+2)%4 ) {	
			chosenAlignment = newAlignment;
		} else {
			chosenAlignment = head.getAlignment();
		}
		switch(chosenAlignment) {
		case 1:
			newX++;
			break;
		case 2:
			newY++;
			break;
		case 3:
			newX--;
			break;
		case 0:
			newY--;
			break;
		}
		head = new Snakenode(newX,newY,chosenAlignment);
		snake.offer(head);
	}
	
}


	
	/**
	 * Represents the single segements of the snake
	 * @author gwue
	 *
	 */
class Snakenode {
	
	private int alignment;
	private int coordX;
	private int coordY;
	
	/**
	 * Creates a new body segement
	 * @param initX
	 * @param initY
	 * @param alignment -- 0 = North, 1 = East, 2 = South, 3 = West
	 */
	Snakenode (int initX, int initY, int alignment ) {
		coordX = initX;
		coordY = initY;
		this.alignment = alignment;
	}

	int getX() {
		return coordX;
	}
	int getY() {
		return coordY;
	}
	int getAlignment() {
		return alignment;
	}
}

public class SnakeField {

	private Snakelist snake;
	boolean [][]area;
	boolean eaten;
	int foodX;
	int foodY;
	
	SnakeField(int dimX, int dimY ) {
		reset(dimX, dimY);
	}
	
	private void newFood() {
		boolean valid = false;
		int newX=0;
		int newY=0;
		while ( !valid ) {
			newX = (int)(Math.random()*area.length);
			newY = (int)(Math.random()*area[0].length);
			if ( !area[newX][newY])
				valid = true;
		}
		foodX = newX;
		foodY = newY;
	}
	public void reset(int dimX, int dimY) {
		area = new boolean[dimX][dimY];
		for ( int i = 0; i < area.length; i++ ) {
			for ( int j = 0; j < area[0].length; j++ ) {
				area[i][j] = false;
			}
		}
		snake = new Snakelist ( dimX/2, dimY/2, 2, 4);
		newFood();
	}
	
	public Snakelist getSnake() {
		return snake;
	}
	
	/**
	 * Moves the snake 1 field
	 * @param alignment where the snake shall go
	 * @return true if collided into tail or wall, false if not
	 */
	public boolean simulateOneStep(int alignment) {
		//if (alignment != 4 ) {
			eaten = false;
			if ( snake.getHead().getX() == foodX && snake.getHead().getY() == foodY ) {
				eaten = true;
				newFood();
			}
			snake.move(alignment, eaten);
			if ( !eaten ) {
				area[snake.getTail().getX()][snake.getTail().getY()] = false;
			}
			if ( snake.getHead().getX() < 0 || snake.getHead().getX() >= area.length
					|| snake.getHead().getY() < 0 || snake.getHead().getY() >= area[0].length 
				|| area[snake.getHead().getX()][snake.getHead().getY()] ) {	
				return true;
			}
			else {
				area[snake.getHead().getX()][snake.getHead().getY()] = true;
			}
		//}
		return false;
	}	
}

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.FlowLayout;
import java.awt.Graphics;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.util.concurrent.ConcurrentLinkedQueue;

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

public class SnakeGame extends Thread {

	SnakeField field;
	Snakelist snake;
	int foodX;
	int foodY;
	JFrame snakeFrame;
	int snakepoints;
	Zeichenflaeche drawSnake;
	final int dimX = 24;
	final int dimY = 19;
	JLabel punkteLabel;
	MyKeyListener steuerung;
	
	public static void main(String[]args) {
		
		SnakeGame game = new SnakeGame();
		game.start();
		
	}
	
	SnakeGame() {
		snakepoints = 0;
		field = new SnakeField (dimX, dimY);
		foodX = field.foodX;
		foodY = field.foodY;
		JPanel top = new JPanel();
		
		drawSnake = new Zeichenflaeche(dimX,dimY,field);
		snakeFrame = new JFrame();
		snakeFrame.setLayout(new BorderLayout());
		punkteLabel = new JLabel("Punkte: "+snakepoints);
		top.setLayout(new FlowLayout());
		top.add(punkteLabel);
		
		snakeFrame.setSize(800, 600);
		snakeFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		steuerung = new MyKeyListener();
		snakeFrame.addKeyListener(steuerung);
		snakeFrame.getContentPane().add(top,BorderLayout.NORTH);
		snakeFrame.getContentPane().add(drawSnake,BorderLayout.CENTER);
		
		snakeFrame.setResizable(false);
		snakeFrame.setVisible(true);
	}
	
	public void run() {
		
		while ( true ) {
			boolean collision = false;
			while ( !collision ) {
				collision = field.simulateOneStep(steuerung.getAlignment());
				if ( field.eaten ) {
					snakepoints++;
					punkteLabel.setText("Punkte: "+snakepoints);
				}
				drawSnake.repaint();
				foodX = field.foodX;
				foodY = field.foodY;
				try {
					sleep(100);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			try {
				sleep(300);
			} catch (InterruptedException e1) {
				// TODO Auto-generated catch block
				e1.printStackTrace();
			}
			snakepoints = 0;
			punkteLabel.setText("Punkte: "+snakepoints);
			field.reset(dimX, dimY);
			drawSnake.clear();
			steuerung.reset();
		}
	}
}

class Zeichenflaeche extends JPanel {
	
	SnakeField field;
	int dimX;
	int dimY;
	int width;
	int height;
	boolean clear;
	
	Zeichenflaeche(int dX, int dY, SnakeField f) {
		super();
		clear = false;
		dimX = dX;
		dimY = dY;
		field = f;
	}
	
	public void clear() {
		clear = true;
		repaint();
	}
	
	public void paintComponent(Graphics g) {
		//super.paintComponent(g);
		Color bg = this.getBackground();
		width = getWidth() / dimX;
		height = getHeight() / dimY;
		if ( clear ) {
			g.setColor(bg);
			g.fillRect(0, 0, getWidth(), getHeight());
			clear = false;
		}
		g.setColor(Color.green);
		g.fillRect(field.foodX*width, field.foodY*height, width, height);
		g.setColor(bg);
		g.fillRect(field.getSnake().getTail().getX()*width, field.getSnake().getTail().getY()*height, width, height);
		g.setColor(Color.black);
		g.fillRect(field.getSnake().getHead().getX()*width, field.getSnake().getHead().getY()*height, width, height);
	}
	
}

class MyKeyListener implements KeyListener {

	private int alignment;
	
	MyKeyListener() {
		alignment = 4;
	}
	
	public void reset() {
		alignment = 4;
	}
	
	public int getAlignment() {
		return alignment;
	}
	
	public void keyPressed(KeyEvent e) {
		
		switch ( e.getKeyCode() ) {
		case KeyEvent.VK_UP :
			alignment = 0;
			break;
		case KeyEvent.VK_RIGHT :
			alignment = 1;
			break;
		case KeyEvent.VK_DOWN :
			alignment = 2;
			break;
		case KeyEvent.VK_LEFT :
			alignment = 3;
			break;
		}
	}
	public void keyReleased(KeyEvent e) {
	}
	public void keyTyped(KeyEvent e) {
	}
	
	
}

 

[André Uhres]

Oder ist es einfach so, dass man alles neu zeichnen muss ( sprich, erst Hintergrund und dann was man davor haben will ), wenn man keine Fehler haben möchte?

Die paintComponent Methode sollte in der Lage sein, notfalls die ganze Komponente neuzuzeichnen. Komponenten, die komplizierte Darstellungen ausgeben, sollten repaint() mit den Argumenten aufrufen, welche nur den Bereich definieren, der eine Aktualisierung erfordert:

    public void repaint(int x, int y, int width, int height)

Diese Argumente dienen dazu, das "clip"-Rechteck zu definieren, das im Graphics Objekt der paintComponent Methode den Bereich darstellt, der aktualisieren muss (Graphics#getClipBounds). Die paintComponent Methode muss nur das neuzeichnen, was sich mit dem "clip"-Rechteck überschneidet. Siehe auch: Malen in Swing Teil 1: der grundlegende Mechanismus - Byte-Welt Wiki

 

[Valkyrion]

Das Thema ist zwar schon etwas älter, aber vielleicht interressiert es ja noch Jemanden...
Wenn du verhindern willst, dass der Fensterinhalt komplett gelöscht wird, kannst du einfach die update-Methode in der Klasse Zeichenflaeche überschreiben, sollte bei Snake keine Probleme geben, hats zumindest bei mir nicht.
[Java]//die Methode beinhaltet sonst sowas wie:

//g.setColor(this.getBackground());
//g.fillRect(0, 0, this.getWidth(), this.getHeight());
//this.paint(g);

//das löscht dann den gesamten Bereich
public void update (Graphics g) {

}[/Java]
update ist die Methode, die beim Aufruf von repaint() eigentlich aufgerufen wird, darum kann man so das Löschen der Animation auch leicht verhindern.
Aber Vorsicht: Mindestens bei Win-XP (und vielleicht auch bei anderen Betriebssystemen) führt das dazu, dass das Fenster komplett leer ist und als Hintergrund das hat, was vorher da war!! Also muss der Frame zumindest beim Programmstart bei paint mal ausgemalt werden!

 

[Schandro]

solche Spielerein mit dem Swing-paint-Mechanismus sind gefährlich und grundsätzlich nicht empfehlenswert...

 

[André Uhres]

Wenn du verhindern willst, dass der Fensterinhalt komplett gelöscht wird, kannst du einfach die update-Methode in der Klasse Zeichenflaeche überschreiben [...] update ist die Methode, die beim Aufruf von repaint() eigentlich aufgerufen wird

Bei AWT ergibt ein Aufruf von repaint() in der Tat zuerst einen Aufruf von update(), der in der Default-Implementierung an paint() weitergeleitet wird. Heavyweight Komponenten können update() überschreiben, um zusätzliches Zeichnen (incremental painting) zu tun, wenn es gewünscht wird (lightweight Komponenten unterstützen nicht das zusätzliche Zeichnen). Für Swing Komponenten wird update() nie aufgerufen. Daher ist es zwecklos, die update-Methode in der Klasse Zeichenflaeche zu überschreiben. Siehe auch Malen in AWT und Swing - Byte-Welt Wiki

 

[Valkyrion]

Ja du hast recht, ich hab net daran gedacht, dass er Frost ein JPanel benutzt hat ich hab da noch einen Frame benutzt...
Und zu dem gefährlich: hast recht, aber "Et het noch ever jot jejange!"