Mehrere Bilder bewegen

[skizZ]

Hallo, ich möchte, dass sich 2 Bilder parallel bewegen.
Es wird allerdings immer nur das von Thread 2 aufgegeben :-(

Hier mal mein Code

import javax.swing.*; 
import java.awt.*; 
import java.awt.event.*; 
import java.util.GregorianCalendar;
import java.awt.*;

import javax.swing.*;
import java.awt.BorderLayout;

public class Animation extends JApplet {  
	String s;  //  @jve:decl-index=0:
	private JPanel jContentPane = null;
	
public void init() {  
	s = getParameter("Farbe");
	this.setSize(new Dimension(361, 400));
	Container c = getContentPane(); 	
	Pictures p1= new Pictures("Thread 1",50, 100, 100, "new-1.gif");
	Pictures p2= new Pictures("Thread 2",50, 0, 0, "new-2.gif");
	c.add(p1);
	c.add(p2);
} 

public class Pictures extends JComponent implements Runnable { 
	String str;  
	int i; 
	Image pic;
	int x;
	int y;
	public Pictures(String str,int i, int x, int y, String pic) { 
		this.str=str; //Wird auf den übergebenen Wert gesetzt 
		this.i=i; //Wird auf den übergebenen Wert gesetzt 
		this.pic = getImage(getDocumentBase(),pic);
		this.x = x;
		this.y = y;
		new Thread(this).start(); 
	}
 
	public void paintComponent(Graphics g)
	   {
		x++;
		y++;
	      g.drawImage(pic,x,y,null);
	   }


	public void run() { 
		while(true) {
			try { 
				Thread.sleep(i);
				repaint();
			}  
			catch (InterruptedException e){}
		}
	}
}}

Ich schätze es hat etwas mit meiner paint()-Methode zu tun, oder?

MfG
skizZ

 

[Marco13]

Oder damit, dass das zwei Components sind... Mit einem
getContentPane().setLayout(new GridLayout(1,2));
werden die zumindest nebeneinander angezeigt. Übereinander ist... auch möglich, aber nicht schön.

 

[skizZ]

Hallo,

ja, das habe ich auch schon herausbekommen.
Es soll aber am Ende folgende Situation realisieren:

Bild 1: Von oben links, nach unten rechts.
Bild 2: von Oben rechts, nach unten links.
Bild 3: Von links nach rechts
Bild 4: Von oben nach unten.

Und dann funktioniert das mit dem Layout nicht mehr :-(

Wie bekomme ich hin, dass es "übereinander" angezeigt wird?

 

[Marco13]

Theoretisch geht das mit sowas wie

    c.setLayout(null);
    p1.setBounds(0,0,300,300);
    p2.setBounds(0,0,300,300);

Aber es empfiehlt sich i.a. für solche Sachen keine Components zu verwenden - und für jedes Bild ein eigener Thread ist vermutlich auch nicht nötig. Man müßte jetzt genauer wissen, wie sich das ganze verhalten soll...

 

[skizZ]

Hallo,

wie sollte ich deiner Meinung nach vorgehen?

Also es sollen 4 Bilder geladen werden.
Das erste Bild soll von oben links, nach unten rechts wandern.
Das zweite Bild von oben rechts, nach unten links.
Das dritte von links nach rechts (vertikal zentriert)
und das vierte von oben nach unten(horizontal zentriert)

Wenn das Bild aus dem fenster verschwindet, soll es wieder an der Startposition erscheinen.

alles soll auf manuelle änderung der fenstergröße angepasst sein.

Das alles natürlich gleichzeitig.

Es muss doch dann für jedes einzeln Bild ein eigener Thread erstellt werden, oder?

 

[Marco13]

Es muss nicht unbedingt für jedes Bild einen eigenen Thread geben. Partikelsysteme mit Millionen von Partikeln werden auch mit einem Thread animiert

Meine Frage in nach dem Verhalten zielte eher auf solche Dinge ab wie z.B. wer die Bewegung der Bilder festlegt. Wenn ich das richtig verstehe, haben die eine Startposition und eine Bewegungsrichtung (und Geschwindigkeit), und nicht eine Start- und Endposition. Soll sich die Bewegung der Bilder irgendwie verändern können, während die Animation läuft? Soll sich die Anzahl der Bilder ändern können? ...

Wie auch immer... Mal schnell hingeschrieben...

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.util.*;
import java.util.List;
import java.awt.*;

import javax.swing.*;
import java.awt.BorderLayout;

public class Animation extends JApplet
{
    String s;
    PictureComponent pc;

    public void init()
    {
        s = getParameter("Farbe");
        this.setSize(new Dimension(361, 400));
        Container c = getContentPane();

        pc = new PictureComponent();
        c.add(pc);

    }

    public void start()
    {
        PictureAnimator pa = new PictureAnimator(pc);

        Picture p0 = new Picture(getImage(getDocumentBase(),"bild1_02.jpg"), 10, 10, 10,8);
        Picture p1 = new Picture(getImage(getDocumentBase(),"bild1_03.jpg"), 100, 100, 6, -12);

        pa.addPicture(p0);
        pa.addPicture(p1);
    }


}


class Picture
{
    private Image image;
    private int x;
    private int y;
    private int dx;
    private int dy;

    public Picture(Image image, int x, int y, int dx, int dy)
    {
        this.image = image;
        this.x = x;
        this.y = y;
        this.dx = dx;
        this.dy = dy;
    }
    public Image getImage()
    {
        return image;
    }
    public int getX()
    {
        return x;
    }
    public int getY()
    {
        return y;
    }
    public void setX(int x)
    {
        this.x = x;
    }
    public void setY(int y)
    {
        this.y = y;
    }
    public int getDX()
    {
        return dx;
    }
    public int getDY()
    {
        return dy;
    }
}


class PictureComponent extends JComponent
{
    private List<Picture> pictures =
        Collections.synchronizedList(new ArrayList<Picture>());

    public void paintComponent(Graphics g)
    {
        super.paintComponent(g);
        synchronized (pictures)
        {
            for (Picture picture : pictures)
            {
                g.drawImage(picture.getImage(), picture.getX(), picture.getY(), this);
            }
        }
    }

    public void addPicture(Picture picture)
    {
        pictures.add(picture);
    }
}


class PictureAnimator implements Runnable
{
    private PictureComponent pictureComponent;

    private List<Picture> pictures =
        Collections.synchronizedList(new ArrayList<Picture>());


    public PictureAnimator(PictureComponent pictureComponent)
    {
        this.pictureComponent = pictureComponent;

        new Thread(this).start();
    }

    public void addPicture(Picture picture)
    {
        pictures.add(picture);
        pictureComponent.addPicture(picture);
    }

    public void run()
    {
        while (true)
        {
            synchronized (pictures)
            {
                for (Picture picture : pictures)
                {
                    int x = picture.getX();
                    int y = picture.getY();
                    x += picture.getDX();
                    y += picture.getDY();

                    // Should be done on EDT...
                    int w = pictureComponent.getWidth();
                    int h = pictureComponent.getHeight();

                    x %= w;
                    if (x < 0)
                    {
                        x += w;
                    }

                    y %= h;
                    if (y < 0)
                    {
                        y += h;
                    }


                    picture.setX(x);
                    picture.setY(y);
                }
                pictureComponent.repaint();
            }
            try
            {
                Thread.sleep(40);
            }
            catch (InterruptedException e)
            {
                Thread.currentThread().interrupt();
            }

        }
    }


}