Feinde überlappen sich in Java Spiel

[xFearofdarkness]

Hey, ich arbeite gerade an meinem ersten Spiel in Java. Ich benutze dafür zu großen Teilen swing und awt. Mein Spiel besteht daraus, dass mehrere Gegner erstellt werden, die man besiegen muss. Diese Feinde kommen auf den Spieler zu, abhängig von seiner Position. Ich habe dann Kollision eingebaut, die über Rechtecke um den Spieler und den Feind funktioniert. Überschneiden sich diese Rechtecke, wird die Kollision erkannt (intersect Methode). Meine Gegner speichere ich in einer ArrayList, über die der Gegner entfernt werden kann, sollte er besiegt werden. Nun überschneiden sich die Gegner jedoch auch selbst, wenn sie auf den Spieler zukommen. Wie kann ich die Kollision zwischen Objekten in einer Liste implementieren? Mein Ansatz war erst über die Liste zu iterieren und mit jeder Iteration die Rechtecke zu vergleichen. Ich bin jetzt seit mehreren Stunden dabei, aber die Feinde überlappen sich trotzdem. Hat jemand eine Idee? Hier mal ein Beispiel Code, wie sich meine Gegner (Flammen) bewegen(sie überlappen sich trotzdem). Der Spieler ist hier ein Schneemann. Die Methode getBounds ist in meiner Flame Klasse als Rechteck definiert. Wichtig wäre noch, dass sowohl das überprüfen der Kollisionen und das erstellen von Gegnern teil des Game loops sind (update Methode).
Falls noch Fragen zu bestimmten Methoden bestehen dann lasst es mich wissen, danke im Voraus

private void moveFlames(int snowmanX, int snowmanY) {
    for (Flame flame : flames) {
        flame.move(snowmanX, snowmanY);

        // Kollision mit anderen Flammen überprüfen
        for (Flame otherFlame : flames) {
            if (flame != otherFlame && flame.getBounds().intersects(otherFlame.getBounds())) {
                 flame.setSpeedX(-flame.getSpeedX());
                 flame.setSpeedY(-flame.getSpeedY());
                
            }
        }
    }
}

private void update() {
        int panelWidth = panel.getWidth();
        int panelHeight = panel.getHeight();
    
         if (upPressed && posY > 0) {
             posY -= speed;
             snowman.setDirection(1);
         }
          if (downPressed && posY < panelHeight - 135) {
               posY += speed;
               snowman.setDirection(0);
          }
          if (leftPressed && posX > 30) {
              posX -= speed;
               snowman.setDirection(2);
          }
          if (rightPressed && posX < panelWidth - 60) {
              posX += speed;
               snowman.setDirection(3);
          }
            
         if(!gameOver){
            snowman.setPosition(posX, posY);
            snowman.animate();
            if (flames.size() < MAX_FLAMES) { //In der Liste gespeicherte Objekte werden abgeglichen
                createFlame(); // Erzeugt neue Flammen, wenn die maximale Anzahl nicht erreicht ist
            }
            if(tokens.size() < MAX_TOKENS){
                createToken();
            }
            moveSnowballs();
            moveFlames(snowman.getX(), snowman.getY()); //Hier bewegen sich die Flammen 
            checkCollisionWithSnowman(snowman);
            checkCollisionWithSnowballs();
            checkCollisionWithToken();
            
            }
            else{
            JFrame frame = new JFrame("Game Over"); //Neuer Game-Over Bildschirm
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            frame.setResizable(false);
            
            GameOverScreen gameOverScreen = new GameOverScreen(score); // Übergebe den Highscore oder die Punktzahl
            frame.add(gameOverScreen);
            frame.pack();
            frame.setLocationRelativeTo(null);
            frame.setVisible(true);
    
            // Stoppe das Spiel
            timer.stop();
            this.dispose();
            }
    }

 

[KonradN]

Ich bin mir jetzt nicht ganz sicher, aber meine Vermutung wäre, dass es schlicht daran liegt, dass Du auch eine Bewegung hast ohne check auf Kollisionen.

Du hast ja:

            if (flame != otherFlame && flame.getBounds().intersects(otherFlame.getBounds())) {
                 flame.setSpeedX(-flame.getSpeedX());
                 flame.setSpeedY(-flame.getSpeedY());
                
            }

Und das wird bei jedem Flame gemacht, das sich überschneiden sollte.

Ich würde da also raten, das in mehr Methoden zu unterteilen und eine Methode zu machen, die nur prüft, ob es eine Überschneidung gibt.

Dann kannst Du folgenden Algorithmus umsetzen:

• Position merken
• In die gewünschte Richtung bewegen
• Gibt es eine Kollision? Dann bewege Dich in die andere Richtung
• Gibt es eine Kollision? Dann setze die gemerkte Position (die hatte ja noch keine Kollision)

Ansonsten sah der Code prinzipiell ok aus, wobei da natürlich noch Fragen offen sind. So bewegst Du Dich in die entgegengesetzte Richtung, aber du änderst nicht die Richtung? Wäre da nicht eine Veränderung der Richtung notwendig? Aber wenn Du mit dem Ziel die Richtung vorgibst (beim move Aufruf), dann ist das evtl. auch so nicht ok. Dann ist die Logik evtl. einfach nur:

• Position merken
• In die gewünschte Richtung bewegen
• Gibt es eine Kollision? Dann setze gemerkte Position.

Sprich: Wenn die neue Position nicht frei ist, dann bewegt sich die Flamme nicht.

 

[xFearofdarkness]

Ansonsten sah der Code prinzipiell ok aus, wobei da natürlich noch Fragen offen sind. So bewegst Du Dich in die entgegengesetzte Richtung, aber du änderst nicht die Richtung? Wäre da nicht eine Veränderung der Richtung notwendig? Aber wenn Du mit dem Ziel die Richtung vorgibst (beim move Aufruf), dann ist das evtl. auch so nicht ok. Dann ist die Logik evtl. einfach nur:

• Position merken
• In die gewünschte Richtung bewegen
• Gibt es eine Kollision? Dann setze gemerkte Position.

Sprich: Wenn die neue Position nicht frei ist, dann bewegt sich die Flamme nicht.

Ja, ich hatte die move Methode in der falschen for Schleife im Beispiel, das konnte natürlich nicht gehen. Meine Idee war ursprünglich bei einer Kollision, dass die Flammen sich nur in die Richtung des Schneemanns bewegen können, wenn sie nicht kollidieren. Wenn sie kollidieren, dürfen sie jedoch nicht stehenbleiben. Meine derzeitige Logik war eigentlich:

• Abfrage, ob Kollision erkannt wurde
• Wenn Nein, dann bewege die Flamme normal weiter
• Wenn Ja, dann bewege Flamme in gewünschte Position

Mein Problem ist nur, dass ich keinen wirklichen Ansatz habe, in welche Richtung die Flamme gehen soll. Sonst stimmt jetzt alles. Die move Methode funktioniert so:

public void move(int snowmanX, int snowmanY) {
        double angle = Math.atan2(snowmanY - y, snowmanX - x); //Berechnet Winkel abhängig von der X und Y Koordinate relativ zum Ursprung
        x += (int) (speed * Math.cos(angle)); //Richtung für die Flamme;  cos bzw. sin wird mit speed multipliziert
        y += (int) (speed * Math.sin(angle));
       
}

Die Flamme bewegt sich immer zum Schneemann hin, wenn diese Methode aufgerufen wird. Mir ist nur keine andere eingefallen, da mir noch ziemlich die Erfahrung fehlt. Hier mal ein unvollständiger Ansatz:

    private void moveFlames(int snowmanX, int snowmanY) {
        for (Flame flame : flames) {
            boolean collided = false; // Hilfsvariable, um festzuhalten, ob eine Kollision aufgetreten ist
            for (Flame otherFlame : flames) {
                if (flame != otherFlame && flame.getBounds().intersects(otherFlame.getBounds())) {
                    // Kollision erkannt, markiere die Kollision
                    collided = true;
                   
                    //To-Do; neue Richtung
                    break; // Beende die Schleife, da eine Kollision erkannt wurde
                }
            }
           
            if (!collided) {
                flame.move(snowmanX, snowmanY); // Bewege die Flamme, wenn keine Kollision auftritt
               
            }
        }
    }

Vielleicht überdenke ich die Flammen grundsätzlich und platziere sie auf einem Gitter. Das würde Kollisionsüberprüfung einfacher machen, falls das hier zu kompliziert wird.

 

[xFearofdarkness]

Ich habe gerade einen Weg gefunden, mit dem ich ganz zufrieden bin. Danke für die Hilfe

    public void moveFlames(int snowmanX, int snowmanY) {
        for (int i = 0; i < flames.size(); i++) {
            Flame flame = flames.get(i);
            int oldX = flame.getX();
            int oldY = flame.getY();
   
            flame.move(snowmanX, snowmanY); // Bewege die Flamme entsprechend der Schneemann-Bewegung
   
            for (int j = i + 1; j < flames.size(); j++) {
                Flame otherFlame = flames.get(j);
                if (flame.getBounds().intersects(otherFlame.getBounds())) {
                    // Berechne die Differenz der Positionen
                    int diffX = flame.getX() - otherFlame.getX();
                    int diffY = flame.getY() - otherFlame.getY();
   
                    // Skaliere die Differenz, um die Bewegung zu vergrößern
                    int scale = 2;
                    diffX *= scale;
                    diffY *= scale;
                   
   
                    // Verschiebe die Flammen voneinander weg
                    flame.setX(oldX - diffX);
                    flame.setY(oldY - diffY);
                    otherFlame.setX(otherFlame.getX() + diffX);
                    otherFlame.setY(otherFlame.getY()+ diffY);
                }
            }
        }
    }