In 4 Richtungen schießen

K

Krypthor

Aktives Mitglied
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 :
Java: 
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
 
B

Beni

Gast
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.
 
K

Krypthor

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

Player :
Java: 
....

	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:
Java: 
.....
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:
Java: 
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;
    }
}
 
M

Marco13

Top Contributor
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.
 
K

Krypthor

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

Marco13

Top Contributor
Java: 
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
Java: 
// 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:
Java: 
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
Java: 
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 :)
 
K

Krypthor

Aktives Mitglied
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:
Java: 
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
Java: 
	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;
		}
	}
 
M

Marco13

Top Contributor
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...
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
E Dartpfeile schießen Spiele- und Multimedia-Programmierung 3
M Beim schießen richtet sich die Kugel nach der Maus aus (Quaternion) Spiele- und Multimedia-Programmierung 5
G Kugeln schießen Spiele- und Multimedia-Programmierung 3

Ähnliche Java Themen

Aktuelle Jobs

Neue Themen


Oben