# Problem mit Animation bei Little Fighter



## Desilusionado (22. Mrz 2008)

Hi @all,

ich habe mir vorgenommen, ein kleines Prügelspiel im Stil von "Little Fighter 2" zu basteln. Da dies mein erstes Spiel in Java ist, wollt ich mch erstmal auf Grundfunktionen (Laufen, Schiessen, Kollisionsabfragen) beschränken.

Ich habe nach dem in diesem Forum verlinkten SPiele-Tut mit dem Helicopter gearbeitet und habe die dort verwendeten Klassen und Methoden soweit es ging, auf meinen kleinen Kämpfer abgewandelt.

Momentan verfügt der über ne Laufanimation, lässt sich steuern, und schiesst auf knopfdruck.

Woran ich scheiter ist folgendes:

Ich habe verschiedene Animationen für den Charakter (stehend - gucken nach links/rechts, und laufen nach rechts/links).

Ich erstelle am Anfang des Spiels die figur mit nem BufferedImage welches die animation für "stehen und gucken nach rechts" enthält. Nun hatte ich mir gedacht, dass ich mit ner simplen abfrage der horizontalen Geschwindigkeit nachprüfen kann, in welche Richtung der grade guckt. Nun scheiter ich aber daran, die figur dann wieder neu zu erstellen bzw die animation zu ändern.

so werden die animationen am anfang des programms erstellt

```
BufferedImage[] man_left = this.loadPics("images/figur_left.gif",1);
	BufferedImage[] man_right = this.loadPics("images/figur_right.gif",1);
	BufferedImage[] walk_left = this.loadPics("images/walk_left.gif",5);
	BufferedImage[] walk_right = this.loadPics("images/walk_right.gif",5);
```


und dann so auf die figur gelegt:


```
figur = new Figur(man_right,400,300,100,this);
```


und nun hab ich versucht, die einfach so zu ändern:


```
if(figur.getHorizontalSpeed()>0){

figur = new Figur(walk_right,figur.getX(),figur.getY(),100,this);
}
```

Wenn ich dann den Charakter nach rechts bewege, ändert sich keine animation und der Charakter lässt sich nicht mehr stoppen und rennt voll gegen die rechte Fenster-Kante.


Irgendjemand nen Vorschlag, wie ich das richtig realisiern kann?

Muss ich die alte figur erst löschen und dann ne neue erstellen?

mfg


----------



## Marco13 (22. Mrz 2008)

Man erkennt daran jetzt nicht die Klassenstruktur und die Abläufe (welche Threads es gibt, was die Threads machen etc...) aber es sieht IMHO erstmal SEHR seltsam aus, wenn bei einem Richtungswechsel eine neue Figur erstellt wird. Es wird ja nicht die _Figur_ geändert, sondern nur eine _Eigenschaft_ der Figur: Nämlich die Laufrichtung (und damit das Bild, das für sie angezeigt wird). 

Also, ich hätte mir da jetzt eher sowas vorgestellt 

```
class Figure
{
    private Image images[] = { Bilder für die ganzen Zustände }

    private Image currentImage = images[das Bild für Stillstehen];

    public void draw(Graphics g)
    {
        g.drawImage(currentImage, currentX, currentY, null);
    }

    public void laufeLos(int richtung)
    {
         currentImage = images[das Bild für laufen in die entsprechende Richtung];
    }

    public void bleibStehen(int richtung)
    {
         currentImage = images[das Bild für "gucken" in die letzte Laufrichtung];
    }
}
```
Und wenn dann in der Anwendung ... ja, eine Taste gedrückt wird oder so, wird eben einfach
figure.laufeLos(richtung);
aufgerufen, und der interne Zustand passend geändert.

Aber nochmal: Deine Idee und Klassenstruktur ist noch nicht klar! Ich weiß jetzt zum Beispiel nicht, WO genau die Abfrage "figur.getHorizontalSpeed()>0" gemacht werden soll, und (wichtig) wer die "HorizontalSpeed" auf irgendeinen bestimmten Wert setzt.... ???:L


----------



## Desilusionado (22. Mrz 2008)

Also die Hauptklasse sieht momentan so aus:

GamePanel.java:

```
import java.io.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;
import java.util.*;
import java.awt.image.*;
import java.net.*;
import javax.imageio.*;

public class GamePanel extends JPanel implements KeyListener, Runnable
{


	boolean game_running = true;  	//	Game-Schleife
	boolean started = false;
	boolean once = false;


	long delta = 0;					//	==
	long last = 0;					//	Zeitmessung
	long fps = 0;					//  ==

	Figur figur;
	Vector<Sprite> actors;

	BufferedImage background;

	boolean up = false;
	boolean down = false;
	boolean left = false;
	boolean right = false;
	boolean shoot1_active = false;

	boolean view_left = false;
	boolean view_right =false;

	int speed = 150;
	BufferedImage [] shoot1;

	BufferedImage[] man_left = this.loadPics("images/figur_left.gif",1);
	BufferedImage[] man_right = this.loadPics("images/figur_right.gif",1);
	BufferedImage[] walk_left = this.loadPics("images/walk_left.gif",5);
	BufferedImage[] walk_right = this.loadPics("images/walk_right.gif",5);



	public static void main(String args[])
	{
		new GamePanel(800,600);
	}



	public GamePanel(int w, int h)
	{
		this.setPreferredSize(new Dimension(w,h));
		this.setBackground(Color.cyan);
		JFrame frame = new JFrame("Imba Fighter");
		frame.setLocation(100,100);
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		frame.add(this);
		frame.pack();
		frame.setVisible(true);
		frame.addKeyListener(this);

		doInitialization();

		//Methode zum Schließen des Fensters

		setLayout(null);
		addKeyListener(this);
		setFocusable(true);

	}



	public void doInitialization()

	{

	background = loadPics("images/background.gif",1)[0];

	last = System.nanoTime();


	actors = new Vector<Sprite>();



	shoot1 = this.loadPics("images/shoot_right.gif",6);



	figur = new Figur(man_right,400,300,100,this);


	actors.add(figur);

	if(!once)
	{
		once = true;
		Thread t = new Thread (this);
		t.start();
	}

	}


	public void run ()
	{
		// Erniedrigen der ThreadPriority um zeichnen zu erleichtern
		Thread.currentThread().setPriority(Thread.MIN_PRIORITY);

		// Solange true ist läuft der Thread weiter
		while (game_running)
		{

			computeDelta();

			if(isStarted())
			{
			checkKeys();
			doLogic();
			moveObjects();
			}


			repaint();



			try
			{
				// Stoppen des Threads für in Klammern angegebene Millisekunden
				Thread.sleep (10);
			}

			catch (InterruptedException ex)	{}

			// Zurücksetzen der ThreadPriority auf Maximalwert
			Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
		}
	}


	private BufferedImage[] loadPics(String path, int pics)
	{


		BufferedImage[] anim = new BufferedImage[pics];
		BufferedImage source = null;

		URL pic_url = getClass().getClassLoader().getResource(path);

		try
		{
			source = ImageIO.read(pic_url);
		}catch (IOException e) {}

		for (int x=0;x<pics;x++)
		{

			anim[x] = source.getSubimage(x*source.getWidth()/pics,0,source.getWidth()/pics, source.getHeight() );
		}

		return anim;

	}



	public void computeDelta()
	{

	delta = System.nanoTime() - last;
	last= System.nanoTime();

	fps = ((long) 1e9)/delta;

	}


	@Override
	public void paintComponent(Graphics g)
	{

		super.paintComponent(g);

		g.drawImage(background,0,0,this);

		g.setColor(Color.red);
		g.drawString("FPS: " + Long.toString(fps), 200, 10);

		if(!isStarted())
		{
			return;
		}


		if(actors != null)
		{
			for(Drawable draw:actors)
			{
				draw.drawObjects(g);
			}
		}

	}


	private void checkKeys()
	{

		if(up) figur.setVerticalSpeed(-speed);
		if(down) figur.setVerticalSpeed(speed);
		if(left) {figur.setHorizontalSpeed(-speed); view_left=true; view_right=false;}
		if(right) {figur.setHorizontalSpeed(speed); view_left=false; view_right=true;}
		if(!up&&!down) figur.setVerticalSpeed(0);
		if(!left&&!right) figur.setHorizontalSpeed(0);
		if(shoot1_active) fireShoot1();

	}

	private void doLogic()
	{
		for(Movable mov:actors)
		{
			mov.doLogic(delta);
		}


	}

	private void moveObjects()
	{
			for(Movable mov:actors)
			{
				mov.move(delta);
			}
	}

public boolean isStarted()
{
	return started;
}

public void setStarted(boolean started)
{
	this.started = started;
}


public void fireShoot1()
{

	double x = figur.getX();
	double y = figur.getY();


	Shoot1 sh1 = new Shoot1(shoot1,x,y,100,this);

	sh1.setHorizontalSpeed(400);

	actors.add(sh1);

	shoot1_active = false;


}






//Events:

	public void keyPressed(KeyEvent e)

	{

		switch(e.getKeyCode())
       {
           case KeyEvent.VK_LEFT : left = true; break;
           case KeyEvent.VK_RIGHT: right = true; break;
           case KeyEvent.VK_UP   : up = true; break;
           case KeyEvent.VK_DOWN : down = true;
       	}

	}


    public void keyReleased(KeyEvent e)

	{
		switch(e.getKeyCode())
       {
           case KeyEvent.VK_LEFT : left = false; break;
           case KeyEvent.VK_RIGHT: right = false; break;
           case KeyEvent.VK_UP   : up = false; break;
           case KeyEvent.VK_DOWN : down = false; break;
           case KeyEvent.VK_A: shoot1_active = true;
       	}


	if(e.getKeyCode()==KeyEvent.VK_ENTER)
	{
		if(!isStarted())
		{
			doInitialization();
			setStarted(true);
		}
	}

	if(e.getKeyCode()==KeyEvent.VK_ESCAPE)
	{
		if(isStarted())
		{
			setStarted(false);
		}else{
			setStarted(false);
			System.exit(0);
		}
	}




	}


    public void keyTyped(KeyEvent e)

	{

	}

}
```



und die Klasse(n) für figur/Animation:

Sprite.java:

```
import java.awt.Graphics;
import java.awt.geom.*;
import java.awt.image.*;

public abstract class Sprite extends Rectangle2D.Double implements Drawable, Movable
{

	long delay;
	long animation = 0;
	GamePanel parent;
	BufferedImage[] pics;
	int currentpic;


	protected double dx;
	protected double dy;

	int loop_from;
	int loop_to;


	public Sprite (BufferedImage[] i, double x, double y, long delay, GamePanel p)
	{


		pics = i;
		this.x = x;
		this.y = y;
		this.delay = delay;
		this.width = pics[0].getWidth();
		this.height = pics[0].getHeight();
		parent = p;
		loop_from =0;
		loop_to = pics.length -1;


	}


	public void drawObjects(Graphics g)
	{
		g.drawImage(pics[currentpic], (int) x, (int) y, null);
	}


	public void doLogic(long delta)
	{

		animation += (delta/1000000);

		if(animation > delay)
		{
			animation = 0;
			computeAnimation();
		}

	}

	public void move (long delta)
	{

		if(dx != 0)
		{
			x += dx*(delta/1e9);
		}

		if(dy != 0)
		{
			y += dy*(delta/1e9);
		}

	}


	private void computeAnimation()
	{

		currentpic++;

		if(currentpic > loop_to)
		{
			currentpic = loop_from;
		}
	}


	public void setLoop(int from, int to)
	{
		loop_from = from;
		loop_to = to;
		currentpic = from;
	}



	public void setVerticalSpeed (double d)
	{
		dy = d;
	}

	public void setHorizontalSpeed (double d)
	{
		dx = d;
	}

	public double getVerticalSpeed ()
	{
		return dy;
	}

	public double getHorizontalSpeed ()
	{
		return dx;
	}


	public void setX(double i)
	{
		x = i;
	}

	public void setY(double i)
	{
		y = i;
	}



}
```

Figur.java:

```
import java.awt.image.*;


public class Figur extends Sprite
{

	public Figur (BufferedImage[] i, double x, double y, long delay, GamePanel p)
	{
		super(i,x,y,delay,p);
	}


	@Override
	public void doLogic(long delta)
	{

		super.doLogic(delta);

		if(getX()<0)
		{
			setHorizontalSpeed(0);
			setX(0);
		}

		if(getX()+getWidth()>parent.getWidth())
		{
			setX(parent.getWidth()-getWidth());
			setHorizontalSpeed(0);
		}

		if(getY()<350-getHeight())
		{
			setVerticalSpeed(0);
			setY(350-getHeight());
		}

		if(getY()+getHeight()>parent.getHeight())
		{
			setY(parent.getHeight()-getHeight());
			setVerticalSpeed(0);
		}

	}



}
```

Wie gesagt, hab das nach dem Heli-Tutorial gemacht. Das doofe is halt, dass der Heli im Tut nur eine Animation hatte und keine unterschiedlichen für Richtungsänderungen. Geht das dann überhaupt mit diesem BufferedImage ?

mfg


----------



## Marco13 (23. Mrz 2008)

Habs jetzt nicht getestet, nur überflogen, aber ... der Sprite-Klasse wird ein Array von Images übergeben, die (durch den Aufruf von doAnimation) nacheinander angezeigt werden. Du willst nun sozusagen(!) mehrere Animationen in eine Klasse bringen. Die Figur bräuchte wohl "alle" pics (nicht nur die für eine Blick- oder Laufrichtung). Aus welchen Bildern die animation Besteht, könnte dann mit "setLoop" ausgewählt werden... Ganz groß und sinngemäß (!!! es ist DEIN Job, das "schöner" zu machen !!!)

```
BufferedImage allPics[] = Array mit ALLEN Bildern zum Beispiel:
allPics[0] = Geradeaus gucken
allPics[1] = Nach rechts gucken
allPics[2] = Nach links gucken
allPics[3] = Nach rechts gehen 0
allPics[4] = Nach rechts gehen 1
allPics[5] = Nach rechts gehen 2
allPics[6] = Nach links gehen 0
allPics[7] = Nach links gehen 1
allPics[8] = Nach links gehen 2

Sprite figur = new Figur(allPics, ....);

public Figur(BufferedImage allPics, ....)
{
    setHorizontalSpeed(0);
}

setHorizontalSpeed(int speed)
{
     if (speed > 0) setLoop(3,5); // Animation aus Bildern 3-5: Nach rechts gehen
     if (speed < 0) setLoop(6,8); // Animation aus Bildern 6-8: Nach links gehen
     if (speed == 0) setLoop(0,0); // Geradeaus gucken
}
```
Da muss dann evtl. auch jeweils das 'currentPic' angepasst werden.... Falls es nicht klappt, sag' nochmal bescheid...


----------



## Desilusionado (23. Mrz 2008)

danke erstmal soweit... ich probier das nachher mal aus

mfg


----------



## Desilusionado (24. Mrz 2008)

jo thx nochmal... mitm bissl feintuning hat das so mit den loops geklappt...


mfg


----------

