Snake Movement

[julian.veh]

Hi
Ich habe mal eine kleines Snakespiel programmiert um einen Einstieg in die Spieleprogrammierung zu haben. Meine Frage passt denke ich aber hier besser rein. Habe erstmal das Movement der Schlange so geregelt:

public void drawSnake(Graphics g) {
        g.setColor(Color.blue);
        int x = xPos - radius;
        int y = yPos - radius;

        int alpha = length;
        int betta = 0;
        int gamma = 1;
        while (alpha > 0) {
            if (directionLeft) {
                g.fillOval(x + betta * radius, y, 2 * radius, 2 * radius);
                betta++;
                alpha--;
            }
            if (directionRight) {
                g.fillOval(x - betta * radius, y, 2 * radius, 2 * radius);
                betta++;
                alpha--;
            }
            if (directionUp) {
                g.fillOval(x, y + betta * radius, 2 * radius, 2 * radius);
                betta++;
                alpha--;
            }
            if (directionDown) {
                g.fillOval(x, y - betta * radius, 2 * radius, 2 * radius);
                betta++;
                alpha--;
            }
            if (!directionLeft && !directionRight && !directionUp && !directionDown) {
                g.fillOval(x, y, 2 * radius, 2 * radius);
                alpha = 0;
            }
        }
    }

Jetzt habe ich mich aber dafür entschieden, das Spiel doch noch weiter zu machen und so kann man ja gar nicht verlieren, weil die schnecke sich immer komplett dreht.
Meine Idee ist jetzt eine Klasse Punkt zu schreiben und immer wenn die Schlange ein Korn frisst einene neuen Punkt der Schlange zu erzeugen. Und dann soll sich nur der vorderste Punkt bewegen und der dahinter immer die Koordinaten die alten Koordinaten des Punktes davor hat.
1) Hat jemand vielleicht eine einfachere Idee
und falls nicht 2) Wie kann ich denn ein zufälliges Objekt der Klasse Punkt dann erzeugen, so dass ich darauf zugreifen kann. Brauche ja immer einen Bezeichner. Oder sollte ich das mit einer ArrayList machen?

Will das nicht irgendwie machen, sondern soll schon schön sein und wenn es einfacher ginge, ist es finde ich schöner auch einen einfachen Weg zu wählen .

Habe mir auch noch überlegt immer den letzten Punkt der Schlange zu löschen und dafür vorne einen hinzuzufügen?

Grüße

 

[Fant]

Habe mir auch noch überlegt immer den letzten Punkt der Schlange zu löschen und dafür vorne einen hinzuzufügen?

Das wär auch meine erste Idee gewesen. Dafür eignet sich doch ein Queue wunderbar.

Gruß Fant

 

[julian.veh]

Lese ich mir mal bei der insel durch danke

 

[Marco13]

Ja, man kann dafür eine LinkedList verwenden (implementiert Queue). Aber... der gepostete Code sieht auf den ersten Blick etwas suspekt aus ... wo werden directionUp usw. gesetzt? (Sieht aus als wären da das Zeichnen und die Spiellogik vermischt bzw. dasselbe...)

 

[julian.veh]

nene vermischt wird das denke ich nicht. Hier mal die ganze Klasse

import java.awt.Color;
import java.awt.Graphics;
import java.util.ArrayList;

public class Snake {

    public int xPos, yPos, length, radius, panelx, panely;
    private boolean directionRight, directionLeft, directionUp, directionDown;
    ArrayList arrl;

    public Snake(int myXPos, int myYPos, int myLength, int myRadius, int myPanelx, int myPanely) {
        this.xPos = myXPos;
        this.yPos = myYPos;
        this.length = myLength;
        this.radius = myRadius;
        this.panelx = myPanelx;
        this.panely = myPanely;
    }
    
    
    public void drawSnake(Graphics g) {
        g.setColor(Color.blue);
        int x = xPos - radius;
        int y = yPos - radius;

        int alpha = length;
        int betta = 0;
        int gamma = 1;
        while (alpha > 0) {
            if (directionLeft) {
                g.fillOval(x + betta * radius, y, 2 * radius, 2 * radius);
                betta++;
                alpha--;
            }
            if (directionRight) {
                g.fillOval(x - betta * radius, y, 2 * radius, 2 * radius);
                betta++;
                alpha--;
            }
            if (directionUp) {
                g.fillOval(x, y + betta * radius, 2 * radius, 2 * radius);
                betta++;
                alpha--;
            }
            if (directionDown) {
                g.fillOval(x, y - betta * radius, 2 * radius, 2 * radius);
                betta++;
                alpha--;
            }
            if (!directionLeft && !directionRight && !directionUp && !directionDown) {
                g.fillOval(x, y, 2 * radius, 2 * radius);
                alpha = 0;
            }
        }
    }

    public void goRight() {
        if (xPos < panelx - radius) {
            xPos += 2;
            directionRight = true;
            directionLeft = false;
            directionUp = false;
            directionDown = false;
        }
    }

    public void goLeft() {
        if (xPos > radius) {
            xPos -= 2;
            directionLeft = true;
            directionRight = false;
            directionUp = false;
            directionDown = false;
        }
    }

    public void goUp() {
        if (yPos > radius) {
            yPos -= 2;
            directionUp = true;
            directionLeft = false;
            directionRight = false;
            directionDown = false;
        }
    }

    public void goDown() {
        if (yPos < panely - radius) {
            yPos += 2;
            directionDown = true;
            directionUp = false;
            directionRight = false;
            directionLeft = false;
        }
    }

    public int getX() {
        return xPos;
    }

    public int getY() {
        return yPos;
    }
}

 

[Marco13]

OK, dann kapier' ich nicht, was da gemacht wird... Bzw. wie da eine normale Snake-Schlange rauskommt... aber vielleicht ist das gerade nicht so wichtig. Beim Umstellen auf Queue dürfte sich da ohnehin eniiges ändern.

 

[vanny]

Man könnte auch einfach eine Klasse für ein Glied der Snake schreiben, die mit Index 0 initialisiert wird und mit jedem move der Snake per Methode (nextStep(); zBsp.) um eins erhöht wird. Dann prüft das SnakeGlied, ob sein index = Size der Collection ist, in der alle Glieder liegen und schmeisst sich dann selbst raus.
So hast du dann die variable Länge der Snake automatisch drinn.

Nur so als Alternative, ich hoffe es kam rüber, was ich meinte.

Gruß Vanny

 

[AquaBall]

Empfehlung von mir: Als Programmierer solltest du dir angewöhnen Strukturen zu erkennen, und möglichst keine Zeile 2x tippen (schon gar nicht 4 mal).

Auch ist dein häufiges '2' auffällig. Ob das nicht anders gestaltet sein sollte? (oder wenigstens als zentrale Konstante)

import java.awt.Color;
import java.awt.Graphics;
import java.util.ArrayList;

public class Snake {

    public int xPos, yPos, length, radius, panelx, panely;
    private boolean directionRight, directionLeft, directionUp, directionDown;
    ArrayList arrl;

    public Snake(int myXPos, int myYPos, int myLength, int myRadius, int myPanelx, int myPanely) {
        this.xPos = myXPos;
        this.yPos = myYPos;
        this.length = myLength;
        this.radius = myRadius;
        this.panelx = myPanelx;
        this.panely = myPanely;
    }
    
    
    public void drawSnake(Graphics g) {
        g.setColor(Color.blue);
        int x = xPos - radius;
        int y = yPos - radius;

        int alpha = length;
        int betta = 0;
        int gamma = 1;
        while (alpha > 0) {
            if (directionLeft)  myFill( + betta, 0);
            if (directionRight) myFill( - betta, 0);
            if (directionUp)    myFill( 0, + betta);
            if (directionDown)  myFill( 0, - betta);
            if (!directionLeft && !directionRight && !directionUp && !directionDown) {
                myFill( 0, 0);
                alpha = 0;
            }
        }
    }
    private myFill(int myXbetta, int myYbetta) {
       g.fillOval(x + myXbetta * radius, y + myYbetta* radius, 2 * radius, 2 * radius);
       betta++;
       alpha--;
    }

    public void goRight(){ goMove(+2, 0, false, false, true, false); }
    public void goLeft() { goMove(-2, 0, false, false, true, false); }
    public void goUp()   { goMove( 0,-2, true, false, false, false); }
    public void goDown() { goMove( 0,+2, false, true, false, false); }

   private void goMove(int myXstep, int myYstep, boolean myUp, boolean myDown, boolean myLeft, boolean myRight;) {
        if (    (radius < xPos) && (yPos < panely - radius) 
          &&  (radius < yPos) && (yPos < panely - radius) ) {
            xPos += myXstep;
            xPos += myYstep;
            directionDown = myDown;
            directionUp = myUp;
            directionRight = myRight;
            directionLeft = myLeft;
        }
   }
    public int getX() { return xPos; }
    public int getY() { return yPos; }
}