Swing JPanel in JLayeredPane animieren

[evindar]

Hallo,

bin neu hier im Forum und brauche bitte Hilfe bei meinem Spiel:

und zwar möchte ich in einem JLayeredPane einige JPanels animieren. Dabei will ich, dass wenn ein Jpanel geklickt und auf einen anderen Stein bewegt wird, sich dieser Stein nach rechts rückt und mein bewegter Jpanel seinen Platz einnimt. Die Positionen der Jpanels sind fest, d.h dass man die Steine nur auf bestimmte Positionen bewegen und verschieben kann.
Wie kann ich jetzt eine Animation jedem Jpanel so einbauen, dass mein Programm nicht geblockt wird, d.h. also nicht extra gestoppt wird um diese Animation noch zu zeigen (also vielleicht mit einem anderen neuen Thread, nur weiß ich nicht wie man das machen kann).
Die Jpanels sind die Klasse Stein und das JLayeredPane die Klasse Tisch.
Ich habe mal die source-Bilder hochgeladen, damit das ganze auch anschaulich wird.

Vielen Dank

Gruß

Klasse Stein:

package Hilfe;

import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.RenderingHints;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.awt.image.BufferedImage;

import javax.swing.JLayeredPane;
import javax.swing.JPanel;

public class Stein extends JPanel implements MouseMotionListener, MouseListener, Runnable{
	private int zahl;
	private BufferedImage bild;
	private boolean dragged = false;
	private Point offset;
	private Point lastPoint;
	private int lastPointPosition;
	private boolean[] points = new boolean[24];
	private JLayeredPane layers;
	Thread thread;
	
	public Point[] position(){
		Point[] points = new Point[28];
		for(int i =0; i<24; i++){
			if (i < 12){
				points[i] = new Point(110+i*45, 406);
			} else{
				points[i] = new Point(110+(i-12)*45, 483);
			}
		}
		points[24] = new Point(391, 195);
		points[25] = new Point(499, 299);
		points[26] = new Point(216, 299);
		points[27] = new Point(325, 195);
		return points;
	}

	public Stein(){
	}
	public Stein(BufferedImage[][] image, int zahl, int farbe, boolean[] points, JLayeredPane layers){
		setLayout(null);
		this.points = points;
		this.layers = layers;
		setBild(image[zahl][farbe]);
		this.zahl = zahl + 1;
		this.setFocusable(true);
		setSize(bild.getWidth(), bild.getHeight());
		setVisible(true);
		setOpaque(false);
	}

	protected void paintComponent(Graphics g) {
		super.paintComponent(g);
		Graphics2D g2 = (Graphics2D) g;
		g2.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
				RenderingHints.VALUE_TEXT_ANTIALIAS_ON);

		
		g2.drawImage(bild, 0, 0, bild.getWidth(), bild.getHeight(), this);

	}
	@Override
	public void mouseDragged(MouseEvent e) {
		if (dragged)
		{
			setLocation(e.getPoint().x - offset.x, e.getPoint().y - offset.y);		
			repaint();
		}
	}
	
	@Override
	public void mouseMoved(MouseEvent e) {

		
	}
	
	public void mouseClicked(MouseEvent e) {
	}
	public void mouseEntered(MouseEvent e) {
		
	}
	public void mouseExited(MouseEvent e) {		
	}
	public void mousePressed(MouseEvent e) {
		offset = new Point(e.getPoint().x-getLocation().x, e.getPoint().y-getLocation().y);
		if (contains(offset))
		{		
			for(int i=0; i<28; i++){
				if(e.getX() > position()[i].x && e.getX() < position()[i].x+45 && e.getY() > position()[i].y && e.getY() < position()[i].y+63){
					lastPoint = position()[i];
					lastPointPosition = i;
				}
			}
			layers.moveToFront(this);
			dragged = true;
			repaint();
		}
	}
	@Override
	public void mouseReleased(MouseEvent e) {
		System.out.println("Dragged? " + dragged);
		if(dragged){
			for(int i=0; i<28; i++){
				if(e.getX() > position()[i].x && e.getX() < position()[i].x+45 && e.getY() > position()[i].y && e.getY() < position()[i].y+63){
					if(points[i] == false){
						setLocation(position()[i]);
						points[i] = true;
						points[lastPointPosition] = false;
						break;
					}	
				} else {
					setLocation(lastPoint);
				}
			}
		}
		dragged = false;
		repaint();
	}
	
	public int getZahl() {
		return zahl;
	}
	
	public void setZahl(int zahl) {
		this.zahl = zahl;
	}

	public BufferedImage getBild() {
		return bild;
	}
	public void setBild(BufferedImage bild) {
		this.bild = bild;
		
	}

	@Override
	public void run() {
		Thread me = Thread.currentThread();
	    while (thread == me) {
	      repaint();
	    }
	    thread = null;
		
	}
}

Klasse Steine:

package Hilfe;

import java.awt.image.BufferedImage;
import java.io.IOException;

import javax.swing.JLayeredPane;

public class Steine {
	private Stein[][] steine;
	BufferedImage[][] bilder;
	
	public Steine(boolean[] points, JLayeredPane layers) throws IOException, IllegalArgumentException{
		
		Bilder okeyBilder = new Bilder();
		bilder = okeyBilder.getAlleSteinBilder();
		
		setSteine(new Stein[15][4]);
		
		for(int i=0; i<15; i++){
			for (int j = 0; j < 4; j++) {
				steine[i][j] = new Stein(bilder, i, j, points, layers);
			}
		}
	}
	
	public Stein getStein(int zahl, int farbe){
		return getSteine()[zahl][farbe];
	}
	public Stein[][] getSteine() {
		return steine;
	}
	public void setSteine(Stein[][] steine) {
		this.steine = steine;
	}
}

Klasse Tisch:

package Hilfe;

import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.event.MouseEvent;
import java.awt.event.MouseMotionListener;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import javax.swing.JFrame;
import javax.swing.JLayeredPane;


public class Tisch extends JLayeredPane implements MouseMotionListener {
	List<Stein> meineSteine = new ArrayList<Stein>();

	BufferedImage background;
	private int mouseX;
	private int mouseY;
	private boolean naechste;
	private List<Stein> spieler1;
	private List<Stein> spieler2;
	private List<Stein> spieler3;
	private List<Stein> spieler4;
	private List<Stein> steineMitte;
	private Stein mitteLeer;
	protected boolean[] points = new boolean[28];
	private Stein draggedStein;

	
	public void aufteilungSteine() throws IllegalArgumentException, IOException{		
		spieler1 = new ArrayList<Stein>();
		spieler2 = new ArrayList<Stein>();
		spieler3 = new ArrayList<Stein>();
		spieler4 = new ArrayList<Stein>();
		steineMitte = new ArrayList<Stein>();

		Steine alleSteine1 = new Steine(points, this);
		Steine alleSteine2 = new Steine(points, this);
		List<Stein> temp = new ArrayList<Stein>();
		
		mitteLeer = alleSteine1.getSteine()[14][0];
		
		// zwei	dimensionales Array in ein eindimensionales Array überführen (zweimal), sahte ebenfalls zweimal hinzufügen
		for (int k = 0; k < 2; k++) {
			if (k == 0) {
				temp.add(alleSteine1.getSteine()[13][0]);
				for (int i = 0; i < 13; i++) {
					for (int j = 0; j < 4; j++) {
						temp.add(alleSteine1.getSteine()[i][j]);
					}
				}
			} else{
				temp.add(alleSteine1.getSteine()[13][0]);
				for (int i = 0; i < 13; i++) {
					for (int j = 0; j < 4; j++) {
						temp.add(alleSteine2.getSteine()[i][j]);
					}
				}
			}
		}
		// Steine mischen
		Collections.shuffle(temp);
		Collections.shuffle(temp);
		Collections.shuffle(temp);
		Collections.shuffle(temp);
		Collections.shuffle(temp);
		
		// Steine aufteilen
		for(int i=0; i<temp.size(); i++){
			if (i<14){
				spieler1.add(temp.get(i));
			} else if (i>=14 && i <28){
				spieler2.add(temp.get(i));
			} else if (i>28 && i <42){
				spieler3.add(temp.get(i));
			} else if (i>=42 && i <56){
				spieler4.add(temp.get(i));
			} else {
				steineMitte.add(temp.get(i));
			}
		}
		
		// ein zufälliger Spieler bekommt jedesmal ein Stein mehr
		int zufallSpieler = (int) (Math.random()*4);
		if (zufallSpieler == 0){
			spieler1.add(steineMitte.get(0));
			steineMitte.remove(0);
		} else if (zufallSpieler == 1){
			spieler2.add(steineMitte.get(0));
			steineMitte.remove(0);
		} else if (zufallSpieler == 2){
			spieler3.add(steineMitte.get(0));
			steineMitte.remove(0);
		} else{
			spieler4.add(steineMitte.get(0));
			steineMitte.remove(0);
		}
	}

	public Tisch() throws IllegalArgumentException, IOException {
		aufteilungSteine();
		setLayout(null);
		
		addMouseMotionListener(this);
		
		// Steine anzeigen
		for(int i=0; i<spieler1.size(); i++){
			addMouseListener(spieler1.get(i));
			addMouseMotionListener(spieler1.get(i));
			add(spieler1.get(i));
		}
		
		// Steine mitte
		addMouseListener(mitteLeer);
		addMouseMotionListener(mitteLeer);
		add(mitteLeer);
		mitteLeer.setLocation(mitteLeer.position()[27]);
		
		// Steine nebeneinander aufstellen
		for(int i=0; i<spieler1.size(); i++){
			spieler1.get(i).setLocation(spieler1.get(i).position()[i]);
			getPoints()[i] = true; // Platz ist besetzt
		}
		
		Bilder bilder = new Bilder();
		background = bilder.getTisch();
		
	}
	protected void paintComponent(Graphics g) {
		super.paintComponent(g);
		Graphics2D g2 = (Graphics2D) g;
		g2.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
				RenderingHints.VALUE_TEXT_ANTIALIAS_ON);

		g2.drawImage(background, 0, 0, this);
	}

	public static void main(String[] args) throws IOException {

		Tisch okey = new Tisch();
		JFrame f = new JFrame();
		f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		f.getContentPane().add(okey);
		f.setResizable(true);
		f.setSize(766, 588);
		f.setResizable(false);
		f.setLocationRelativeTo(null);
		f.setVisible(true);
		f.setTitle("Okey");
	}

	public int getMouseX() {
		return mouseX;
	}

	public void setMouseX(int mouseX) {
		this.mouseX = mouseX;
	}

	public int getMouseY() {
		return mouseY;
	}

	public void setMouseY(int mouseY) {
		this.mouseY = mouseY;
	}


	public void mouseDragged(MouseEvent e) {		
	}


	public void mouseMoved(MouseEvent e) {		
	}

	public boolean[] getPoints() {
		return points;
	}

	public void setPoints(boolean[] points) {
		this.points = points;
	}
}

Klasse Bilder ( nur ein Bild zur Veranschaulichung mit hochgeladen)

package Hilfe;

import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

import javax.imageio.ImageIO;

public class Bilder {
	
	private BufferedImage tisch;
	private BufferedImage[][] alleSteinBilder;
	
	public Bilder() throws IOException, IllegalArgumentException {
		setAlleSteinBilder(new BufferedImage[15][4]);

		for (int i = 0; i < 15; i++) {
			for (int j = 0; j <= 3; j++) {
				alleSteinBilder[i][j] = ImageIO.read(new File(
						"1.png"));
			}
		}
		tisch = ImageIO.read(new File("tisch.jpg"));

	}

	public BufferedImage getTisch() {
		return tisch;
	}

	public BufferedImage[][] getAlleSteinBilder() {
		return alleSteinBilder;
	}

	public void setAlleSteinBilder(BufferedImage[][] alleSteinBilder) {
		this.alleSteinBilder = alleSteinBilder;
	}

}

 

[Marco13]

Da der Stein ein JPanel ist :autsch: müßte man da mit einem eigenen THread noch mehr aufpassen als sowieso schon, schau vielleicht mal unter How to Use Swing Timers (The Java™ Tutorials > Creating a GUI With JFC/Swing > Using Other Swing Features)

 

[evindar]

Erstmal danke für deine Antwort

Ich habe aber nicht so ganz verstanden, wie ich das jetzt machen könnte.
Wie kann man denn also den Timer benutzen, um die Animation zu realisieren, ohne dass das Programm geblockt wird?
Also könntest du das bitte vielleicht an einem Code-Beispiel zeigen?

Danke

 

[Marco13]

Was genau sollte ich posten, was über http://docs.oracle.com/javase/tutor...bleItemProject/src/components/TumbleItem.java hinausgeht...?

 

[evindar]

Danke für dein Hilfe Marco,

ich bin ein neuling was java angeht und bräuchte etwas mehr Details darüber, was ich genau machen muss.
Ich will ja, dass wenn ich einen Stein sozusagen dragge und auf einem anderen Stein loslasse (release), dass dann der alte Stein sich nach rechts bewegt zur nächsten Position (animiert) und der andere Stein seinen Platz einnimmt.
Ich würde mich freuen, wenn du so etwas an einem Code-Beispiel oder vielleicht gleich an meinem Code zeigen würdest, wie man das machen könnte. Denn ehrlich gesagt habe ich nicht ganz verstanden und weiß auch nicht, wie man das mit dem Timer realisieren kann. Ich habe mir auch diesen TumbleItem angeschaut, aber das hat mir nicht weiterhelfen können.

Danke

 

[Michael...]

Ich selbst nutzte für sowas lieber Runnables und Threads.
Für den Swing Timer musst Du zunächst einen ActionListener definieren, der die Position des zu animierenden Steins schrittweise verändert und ein repaint() auf der den Stein enthaltenden Komponente aufruft.
Dem Timer übergibst du beim Erstellen ein Delaywert (z.B. 100 für 100ms) und den ActionListener, das heißt wenn der Timer läuft wird alle 100ms die actionPerformed des ActionListeners ausgeführt.

Beim Fallenlassen eines Steins startest Du den Timer und stoppst diesen wenn der zu verschiebende Stein sein Ziel erreicht hat.

Grundsätzlich halte ich aber Deine Vorgehensweise für die Steine JPanels zu verwenden eher ungünstig, so ein Spiel würde man eher komplett selbst zeichnen.

Ausserdem interessant für solche Anwendungen ist das MVC Pattern, o.ä.

 

[Marco13]

Ja, ich finde Runnables und Threads auch oft praktischer (vor allem sind es "Echte" Threads, und nicht eine weitere Aufgabe, die man auf den EDT legt), aber wenn der Stein ein JPanel ist, müßte man bei allen setBounds-Aufrufen usw. noch SwingUtilities drumwickeln...
(Ich bin ja ohnehin Verfechter des "Sprites-Sind-Keine-Components"-Ansatzes, aber ... wie auch immer).

Sobald die Animation losgehen soll, kann man (SCHNELL HINGEHACKT!) grob sowas wie

final Timer timer = new Timer(30);
final int startX = 0;
final int endX = 100;
timer.addActionListener(new ActionListener()
{
    int currentX = startX;

    @Override
    public void actionPerformed(ActionEvent e) 
    {
        stein.setBounds(currentX,0,100,100);
        currentX += 10;
        if (currentX > endX) timer.stop();
    }
});
timer.start();

machen, um den Stein zu bewegen. Ansonsten... ist die Grenze zwischen einem Tipp-Snippet und einem Refactoring fließend...

 

[evindar]

Vielen Dank!
Es hat mir sehr geholfen