# In 4 Richtungen schießen



## Krypthor (3. Dez 2011)

Hi,
ich möchte das mein charakter nach oben, unten, links und rechts schießt, dass hat auch funktioniert,
dass Problem ist das wenn man sich danach bewegt, die Kugeln mitbewegt werden.

Ich habe für die 4 Richtungen des Spielers 4 int festgelegt (1-4) und dann bei der Kugelbewegung 
abgefragt, je nach dem in welche Richtung der Spieler blickt :

```
if(Player.richtung == 3){
	y = y + 2;
}
if(Player.richtung == 4){
	x = x - 2;
}
if(Player.richtung == 1){
	y = y - 2;
}
if(Player.richtung == 2){
	x = x + 2;
}
```
Daher ist es auch logisch das die Kugeln sich mitbewegen.
Wie kann man festlegen, dass die Kugeln in die beliebigen Richtungen fliegen ohne
ihre Richtung zu ändern?

Mfg,
Krypthor


----------



## Beni (3. Dez 2011)

Die Klasse "Kugel" (die du sicherlich hast), muss auch ein Feld "richtung" besitzen. Dieses Feld muss in dem Augenblick gesetzt werden, wenn die Kugel erstellt/abgeschossen wird.


----------



## Krypthor (3. Dez 2011)

Das Problem ist das es sich immer die neuen Koordinaten nimmt, hier mal  teile des Codes:

Player :

```
....

	public static int Richtung(){
		return richtung;
	}

....
	public static ArrayList getKugeln(){
		return kugeln;
	}
....
	public void fire(){
		Kugel z = new Kugel(x, y);
		kugeln.add(z);
	}
....  


//Taste zum schießen   
                  if (key == KeyEvent.VK_P){
			richtung = richtungs + 0;
			fire();
		}
	}

	public void keyReleased(KeyEvent e){
		int key = e.getKeyCode(); 
	
		if (key == KeyEvent.VK_LEFT){
			dx = 0;
			still = ls.getImage();
			richtungs = 4;
		}
		if (key == KeyEvent.VK_RIGHT){
			dx = 0;
			still = rs.getImage();
			richtungs = 2;
		}
		if (key == KeyEvent.VK_UP){
			dy = 0;
			still = i.getImage();
			richtungs = 1;
		}
		if (key == KeyEvent.VK_DOWN){
			dy = 0;
			still = i.getImage();
			richtungs = 3;
		}
		if (key == KeyEvent.VK_P){
			hit = false;
		}
```

In dem Board wo alles zusammen gesetzt wird:

```
.....
public void actionPerformed(ActionEvent e) {
...
		ArrayList kugeln = Player.getKugeln();
		for (int w = 0; w < kugeln.size(); w++){
			Kugel k = (Kugel) kugeln.get(w);
			if(k.getVisible() == true){
				k.move();
			}
			else{
				kugeln.remove(w);
			}
.....
	public void paint(Graphics g) {
		
		super.paint(g);
			Graphics2D g2d = (Graphics2D) g;
			ArrayList kugeln = Player.getKugeln();
			for (int w = 0; w < kugeln.size(); w++){
				Kugel k = (Kugel) kugeln.get(w);
				g2d.drawImage(k.getImage(), k.getX(), k.getY(), null);
			}
....
```

Und in der Kugel Klasse:

```
public class Kugel {
int y, x;
Image imgk;
boolean visible;

	public Kugel(int startX, int startY){
		x = startX;
		y = startY;
		ImageIcon neueKugel = new ImageIcon("Bilder/Kugel.png");
		imgk = neueKugel.getImage();
		visible = true;
		
	}
	
	public Rectangle getBounds(){
		return new Rectangle(x, y, 10, 10);
    }
	public int getX(){
		return x;
	}
	public int getY(){
		return y;
	}
	public boolean getVisible(){
		return visible;
	}
	public Image getImage(){
		return imgk;
	}
	
	public void move(){	
		if(Player.richtung == 3){
			y = y + 2;
		}
		if(Player.richtung == 4){
			x = x - 2;
		}
		if(Player.richtung == 1){
			y = y - 2;
		}
		if(Player.richtung == 2){
			x = x + 2;
		}
		if(x > 600){
			visible = false;
		}
		if(y > 400){
			visible = false;
		}
		if(x < 2){
			visible = false;
		}
		if(y < 2){
			visible = false;
		}
	}
	
    public void setVisible(boolean isVisible)
    {
            visible = isVisible;
    }
}
```


----------



## Marco13 (4. Dez 2011)

In der Kugel greifst du offenbar auf die Player.richtung zu (die anscheinend static ist, was sie NICHT sein sollte!). Stattdessen könntest du dir auch eine 'richtung' in der Kugel speichern, die NUR im Konstruktor gesetzt und dann verwendet wird.


----------



## Krypthor (4. Dez 2011)

Also dann verschiedene "move()" in der Kugel? Ich hab nicht genau verstanden wie ich jetzt dann die "richtung"
des Spielers anders abfragen soll?!


----------



## Marco13 (5. Dez 2011)

```
class Kugel
{
    ...
    private int richtung = 0;
 
    public Kugel(int startX, int startY, int richtungAmAnfang){
        x = startX;
        y = startY;
        richtung = richtungAmAnfang;
        ...


    public void move(){ 
        //if(Player.richtung == 3){ // WEG
        if(this.richtung == 3){  // HIN
            y = y + 2;
        ...

}
```

Und dort wo sie erstellt wird dann 

```
// Kugel z = new Kugel(x, y); // WEG
Kugel z = new Kugel(x, y, Player.richtung); // HIN
```

Dieses static ist häßlich. Für die Richtung könnte man sich ggf. auch was allgemeineres Überlegen, z.B. direkt die Bewegung speichern:

```
class Kugel
{
    private int x;
    private int y;
    private int stepX;
    private int stepY;

    public Kugel(int x, int y, int stepX, int stepY)
    {
        this.x = x;
        this.y = y;
        this.stepX= stepX;
        this.stepY= stepY;
    }

    public void move()
    {
        x+= stepX;
        y+= stepY;
    }
```

Und erstellen mit

```
Kugel kugel = new Kugel(x,y,1,-1); // In jedem Schritt 1 nach rechts und 1 nach unten
```

Aber wenn man DAS jetzt noch weiter verallgemeinern will, braucht man http://www.java-forum.org/spiele-mu...iniges-geometrie-punkte-vektoren-geraden.html


----------



## Krypthor (12. Dez 2011)

Ich danke dir, doch ein kleines Problem hätte ich noch und zwar wenn ich nach links gehe und dann nach rechts und die Taste loslasse und dann schieße fliegt die erste Kugel nach links. Also die erste abgeschossene Kugel fliegt dann immer in die Richtung welche Taste zuletzt gedrückt wurde.

Kugel Klasse:

```
public class Kugel {
int y, x, a;
Image imgk;
boolean visible;
private int richtung = 0;

	public Kugel(int startX, int startY, int richtungAmAnfang){
		x = startX;
		y = startY;
		richtung = richtungAmAnfang;
		ImageIcon neueKugel = new ImageIcon("Bilder/Kugel.png");
		imgk = neueKugel.getImage();
		visible = true;
	}
	
	public Rectangle getBounds(){
		return new Rectangle(x, y, 10, 10);
    }
	public int getX(){
		return x;
	}
	public int getY(){
		return y;
	}
	public boolean getVisible(){
		return visible;
	}
	public Image getImage(){
		return imgk;
	}
	
    public void setVisible(boolean isVisible)
    {
            visible = isVisible;
    }

 
    public void move(){
        if(this.richtung == 3){
			y = y + 3;
		}
		if(this.richtung == 4){
			x = x - 3;
		}
		if(this.richtung == 1){
			y = y - 3;
		}
		if(this.richtung == 2){
			x = x + 3;
		}
		if(x > 600){
			visible = false;
		}
		if(y > 400){
			visible = false;
		}
		if(x < 2){
			visible = false;
		}
		if(y < 2){
			visible = false;
		}
  }
}
```

Player 

```
public void fire(){
		Kugel z = new Kugel(x, y, richtung);
		kugeln.add(z);
	}
	public Player(){
		richtungs = 3;
		richtung = 3;
		kugeln = new ArrayList();
	}
	
	public int Richtung(){
		return richtung;
	}
	
	public static ArrayList getKugeln(){
		return kugeln;
	}
	
	public void keyPressed(KeyEvent e){
		int key = e.getKeyCode(); 
	
		if (key == KeyEvent.VK_LEFT){
			dx = -1;
			still = l.getImage();
			richtungs = 4;
		}
		if (key == KeyEvent.VK_RIGHT){
			dx = +1;
			still = r.getImage();
			richtungs = 2;
		}
		if (key == KeyEvent.VK_UP){
			dy = -1;
			still = ud.getImage();
			richtungs = 1;
		}
		if (key == KeyEvent.VK_DOWN){
			dy = +1;
			still = ud.getImage();
			richtungs = 3;
		}
		if (key == KeyEvent.VK_P){
		    long current = System.currentTimeMillis();
		    if (lastPressMS == -1  || current > lastPressMS + 500) {
		        lastPressMS = current;
		        fire();
		    }
		    richtung = richtungs + 0;
		}
	}
```


----------



## Marco13 (12. Dez 2011)

Anhand des Codes jetzt schwer zu erkennen ... wenn Debug-Ausgaben wie
System.out.println("Richtung nach Tastendruck "+richtung);
und
System.out.println("Schieße in Richtung "+richtung);
nichts helfen, wäre ein KSKB gut...


----------



## Krypthor (12. Dez 2011)

okay danke hat sich erledigt.


----------

