# Snake - Schlange wächst nicht



## Viktim (25. Nov 2015)

Hallo,
Ich hab das Problem, das ich es nicht hinkriege, die Schlange in meinem Snake Spiel wachsen zu lassen...
Ich hab mir überlegt, das ich die Koordinaten von meinem 2D Spielfeldarray in ein anderes Array schreibe, in dem ich die Koordinaten dann in jedem sieldurchlauf weiter nach hinten reiche, und die Koordinate der letzten Stelle lösche...
aber irgendwie funktioniert das nicht...

ich stell hier erstmal nur meine Klasse rein, in der ich das Array für das Spielfeld aufbaue, wenn ihr die Klassen für die GUI braucht, sagt bescheid...


```
package snake;

import javax.swing.JOptionPane;

public class SpielfeldAufbau {
  int x = 20;
  int y = 20;
  private boolean starterfolgt = false;
  private boolean punktGegessen = true;
  String[][] spielfeld;
  public int anzahlPunkte = 0;
  int yKoordinate = 10;
  int xKoordinate = 10;
  public static String richtung = "";
  int[][] schlange;
  int zuLöschendeXKoordinate = 0;
  int zuLöschendeYKoordinate = 0;

  public String[][] spielfeld() {
    if (!starterfolgt) {
      spielfeld = new String[x][y];
      for (int i = 0; i < x; i++) {
        for (int j = 0; j < y; j++) {
          spielfeld[i][j] = " ";
        }
      }
      spielfeld[xKoordinate][yKoordinate] = ">";
      starterfolgt = true;
    }
    // Wenn das Spielfeld verlassen wird, Spiel beenden
    if (xKoordinate >= x || xKoordinate < 0 || yKoordinate >= y || yKoordinate < 0) {
      JOptionPane.showMessageDialog(null, "GAME OVER");
      System.exit(0);
    }

    for (int i = 0; i < x; i++) {
      for (int j = 0; j < y; j++) {
        if (spielfeld[i][j].equals("x")) {
          spielfeld[i][j]=" ";
        }
      }
    }

    String[][] uebergangsspielfeld = new String[x][y];
    for (int i = 0; i < x; i++) {
      for (int j = 0; j < y; j++) {
        uebergangsspielfeld[i][j] = spielfeld[i][j];
      }
    }
    // Schlangen länge usw. festlegen
    schlange = new int[((anzahlPunkte + 2) / 2)][2];
    int[][] uebergangsSchlange = new int[schlange.length][2];

    for (int i = 0; i < schlange.length; i++) {
      uebergangsSchlange[i][0] = schlange[i][0];
      uebergangsSchlange[i][1] = schlange[i][1];
    }
    for (int k = 0; k < (schlange.length - 1); k++) {
      schlange[k + 1][0] = uebergangsSchlange[k][0];
      schlange[k + 1][1] = uebergangsSchlange[k][1];
    }
    for (int i = 0; i < x; i++) {
      for (int j = 0; j < y; j++) {
        if (spielfeld[i][j].equals(">")) {
          schlange[0][0] = i;
          schlange[0][1] = j;
        }
      }
    }
    for (int i = 0; i < schlange.length; i++) {
      uebergangsspielfeld[schlange[i][0]][schlange[i][1]] = "x";
    }
    if (schlange.length > 1) {
      uebergangsspielfeld[schlange[schlange.length - 1][0]][schlange[schlange.length - 1][1]] = " ";
    }
    // Schlange vorbei

    switch (richtung) {
      case "w":
        xKoordinate++;
        break;
      case "o":
        xKoordinate--;
        break;
      case "n":
        yKoordinate--;
        break;
      case "s":
        yKoordinate++;
        break;
    }

    spielfeld[xKoordinate][yKoordinate] = ">";
    // Punkt essen
    for (int i = 0; i < x; i++) {
      for (int j = 0; j < y; j++) {
        if (spielfeld[i][j].equals(">") && uebergangsspielfeld[i][j].equals("O")) {
          spielfeld[i][j] = ">";
          punktGegessen = true;
          anzahlPunkte++;
        }
        if (uebergangsspielfeld[i][j].equals(">")) {
          uebergangsspielfeld[i][j] = " ";
        }
      }
    }

    for (int i = 0; i < x; i++) {
      for (int j = 0; j < y; j++) {
        spielfeld[i][j] = uebergangsspielfeld[i][j];
      }
    }
    spielfeld[xKoordinate][yKoordinate] = ">";

    // Neuen Punkt spawnen

    if (punktGegessen) {
      boolean guterPunktGespawnt = false;
      while (!guterPunktGespawnt) {
        int xPunkt = (int) (Math.random() * x);
        int yPunkt = (int) (Math.random() * y);
        if (spielfeld[xPunkt][yPunkt].equals(" ")) {
          spielfeld[xPunkt][yPunkt] = "O";
          guterPunktGespawnt = true;
        }
      }
      punktGegessen = false;
    }
    return spielfeld;
  }
}
```


----------



## InfectedBytes (25. Nov 2015)

eine einfache möglichkeit ist es, die schlange als liste von punkten aufzufassen.
die bewegung kannst du dann erreichen, indem du einen neuen punkt (Kopf der schlange) an das eine Ende der liste hängst und das letzte teil (schwanzende) entfernst.


----------



## Viktim (26. Nov 2015)

mach ich ja eigentlich genau so, nur das ich halt ein Array statt einer Liste nehme und das Kopfende and die erste und nicht an die letzte Stelle des arrays setzte


----------



## Viktim (26. Nov 2015)

ich habs rausgefunden 
ich hab einfach nur nicht bemerkt, das ich mein array ja in jedem durchlauf neu setzte 

richtig sieht die stelle von der schlange jetzt so aus:

```
/ Schlangenlänge etc. festlegen
    if (schlangeSetzten) {
      uebergangsSchlange = new int[schlange.length][2];

      for (int i = 0; i < schlange.length; i++) {
        uebergangsSchlange[i][0] = schlange[i][0];
        uebergangsSchlange[i][1] = schlange[i][1];
      }
    }
    schlangeSetzten = true;
    schlange = new int[((anzahlPunkte + 2) / 2)][2];

    for (int k = 0; k < (schlange.length - 1); k++) {
      schlange[k + 1][0] = uebergangsSchlange[k][0];
      schlange[k + 1][1] = uebergangsSchlange[k][1];
    }

    for (int i = 0; i < x; i++) {
      for (int j = 0; j < y; j++) {
        if (spielfeld[i][j].equals(">")) {
          schlange[0][0] = i;
          schlange[0][1] = j;
        }
      }
    }

    for (int i = 0; i < schlange.length; i++) {
      uebergangsspielfeld[schlange[i][0]][schlange[i][1]] = "x";
    }
    if (schlange.length > 1) {
      uebergangsspielfeld[schlange[schlange.length - 1][0]][schlange[schlange.length - 1][1]] = " ";
    }

    // Schlange vorbei
```

die dümmsten Fehler sind mal wieder am schwersten zu finden


----------

