Tetris - Spielstein wird nicht dauerhaft angezeigt

Hallo,
ich wollte eine Tetris App machen.
In einem Timer werden zufällige Steine nach unten bewegt und sie können mit den Tasten gesteuert werden. Aber immer wenn ein Stein unten ankommt und ich einen neuen Stein erstelle, verschwindet der alte Stein. Wie kann ich den alten Spielstein fest an seine Position setzen?
Schonmal Danke im vorraus.

  class  GameLoop extends TimerTask {
    Random random = new Random();

     @Override
    public void run() {

         mainactivity.runOnUiThread(new TimerTask() {

             @Override
             public void run() {
                 spielFeld.nachUnten(SpielStein); // Stein nach unten bewegne
                 if (spielFeld.nachUntenverschiebar(SpielStein) == false) {
                     SpielStein = neuerStein(); // neuen SpielStein erzeugen
                 }
                 invalidate();
             }
         });
     }

public Stein neuerStein() {
    Stein s = new Stein(random.nextInt(7) + 1);
    return s;
 }
}

— geändert am 01.05.2018, 10:48:27 durch Moderator

Hallo,
ich habe jetzt folgendes versucht, jetzt bewegt sich der Stein aber nicht mehr nach unten:

     @Override
             public void run() {

                if(SteinListe.isEmpty()) {
                    SteinListe.add(neuerStein());
                }

                 spielFeld.nachUnten(aktuellerStein());

                if (spielFeld.nachUntenverschiebar(aktuellerStein()) == false) {
                    SteinListe.add(neuerStein());
                 }
           invalidate();
              }
         });
     }

public Stein aktuellerStein() {
    return SteinListe.get(0);
}

public Stein neuerStein() {
    Stein s = new Stein(random.nextInt(7) + 1);
    return s;
 }

Die Steine zeichne ich auf ein Canvas, in der onDraw() Methode. Wie kann ich den alle Steine von Liste neuzeichnen?

Ok, danke. Jetzt sehe ich unten in der Konsole immer die Koordinaten von den runterfallenden Steinen, aber auf dem Canvas werden sie nicht neugezeichnet

Eine Schleife die überalle Steine läuft hatte ich eben schon wenn du so etwas meinst:

 for(Stein s: SteinListe)  {
                    invalidate();
                }

Aber ich durchlaufe in meiner onDraw() Methode immer das gesamte SpielFeld und wenn der Wert im Array ungleich 0 ist wird an der entsprechenden Stelle ein Rechteck gefüllt. (in der Steinfarbe)

Jeder Stein bekommt ja beim erstellen ein zufälligen Farbcode als Integer und jenachdem wie dieser Wert ist wird dann die Farbe gesetzt.

@Override
protected void onDraw(Canvas canvas) {
    int spielfeld[][] = spielFeld.getSpielFeld();

    super.onDraw(canvas);
    Paint p = new Paint();
    p.setColor(Color.BLUE);

    for (int a = 0; a < höhe; a++) {  // canvas(SpielFeld) durchlaufen
        for (int b = 0; b < breite; b++) {

            if (spielfeld[a][b] == 1) {
                p.setColor(Color.RED);
                canvas.drawRect(b*30, a*30, b*30+30, a*30+30,p);
            }
        if(spielfeld[a][b]==2) {
            p.setColor(Color.GREEN);
            canvas.drawRect(b*30, a*30, b*30+30, a*30+30,p); 
        }
      ... alle 7 Farbcodes

         }
      }
   }

— geändert am 01.05.2018, 22:05:25

Das Array aus meiner SpielFeld Klasse, wo die Steine verschoben und gedreht werden

Naja der Stein bleibt oben am Rand hängen und fällt nicht runter.
So wie es am Anfang hatte, wo die Steine nur immer überschrieben wurden hat es ja auch geklappt mit dem runterfallen der Steine.

Hallo,
In der Steinklasse werden die Koordinaten gespeichert, Abhängig vom Farbcode:

public Stein(int f) {

    switch(f) { // Quadrat Rot
        case 1:
            x1=0; y1=7; x2=0; y2=8;
            x3=1; y3=7; x4=1; y4=8;
            farbcode=1;
            break;

        case 2:    // Z Teil    Blau
            x1=0; y1=7; x2=0; y2=8;
            x3=1; y3=8; x4=1; y4=9;
            farbcode=2;
            break;

....

In der SpielFeld Klasse sind Methoden um den SpielStein zudrehen und zu verschieben, mit dem aktuellen Stein als Parameter. Mit der getSpielFeld() Methode wird das SpielFeld Array zurückgegeben.

 public void löscheStein(Stein SpielStein) {
    SpielFeld[SpielStein.x1][SpielStein.y1] = 0;
    SpielFeld[SpielStein.x2][SpielStein.y2] = 0;
    SpielFeld[SpielStein.x3][SpielStein.y3] = 0;
    SpielFeld[SpielStein.x4][SpielStein.y4] = 0;
 }

— geändert am 02.05.2018, 16:15:36

SpielFeld Aray: int SpielFeld[][]=new int[30][30];
Achso, das löschen der Steine ist nur dafür da um sie dann zuverschieben.

Hi,
So mache ich es auch: alte Steinposition löschen und neu setzen ( alles in der SpielFeld Klasse) Keine Ahnung was du mit Drawables meinst, aber so wie ich es mache kann ich alle Steine zeichen.
Ich verstehe nur immer noch nicht warum sich die Steine nicht bewegen.

So wie in Post 4

Achso, das mache ich mit timer.schedule() im Konstruktor.

1. Ja
2. Habe ich jetzt verbessert, einen Log in die If Bedingung eingebaut: Log.v("NeuerStein", ""+ SteinListe.size())
   Die If Bedingung wird immer erreicht wenn die Stein Koordinate 28 ist( die Steinkoordinaten lasse ich mir immer ausgeben), der Stein also am Boden ist. Das funktioniert also soweit. Nur die Steine bewegen sich immer noch nicht.

Muss ich die SpielFeld Klasse nochmal ändern, damit dort mehrere Steine verarbeitet werden können?

— geändert am 02.05.2018, 22:45:30

Die Steine bewegen sich nicht.

Die Erstellung der Liste und den ersten Stein füge ich im Konstruktor von Tetris hinzu.

Ich poste jetzt mal den Code von der SpielFeld klasse, weil ich nicht mehr weiterkomme, die Drehung von dem Stein habe ich rausgenommen:

public class SpielFeld  {

  final int höhe=30;
     final int breite=30;

int SpielFeld[][]=new int[höhe+2][breite+2]; // +2 für die Drehbarkeit

public void setzeStein(Stein SpielStein) {
    SpielFeld[SpielStein.x1][SpielStein.y1] = SpielStein.farbcode;
    SpielFeld[SpielStein.x2][SpielStein.y2] = SpielStein.farbcode;
    SpielFeld[SpielStein.x3][SpielStein.y3] = SpielStein.farbcode;
    SpielFeld[SpielStein.x4][SpielStein.y4] = SpielStein.farbcode;
}

public void löscheStein(Stein SpielStein) {
    SpielFeld[SpielStein.x1][SpielStein.y1] = 0;
    SpielFeld[SpielStein.x2][SpielStein.y2] = 0;
    SpielFeld[SpielStein.x3][SpielStein.y3] = 0;
    SpielFeld[SpielStein.x4][SpielStein.y4] = 0;
}

public  void verschieben(Stein SpielStein,int x, int y)  {
    löscheStein(SpielStein);
    SpielStein.verschieben(x, y);
    setzeStein(SpielStein);
    Log.v("SpielStein",""+SpielStein.x1+" "+SpielStein.y1);
}

public void nachRechtsverschieben(Stein SpielStein) {
    if(nachRechtsverschiebar(SpielStein)==true) {
        verschieben(SpielStein,0,1);
    }
}

public  void nachLinksverschieben(Stein SpielStein) {
    if(nachLinksverschiebar(SpielStein)==true) {
        verschieben(SpielStein,0,-1);
    }
}

public  void nachUnten(Stein SpielStein) {
    if(nachUntenverschiebar(SpielStein)==true) {
        verschieben(SpielStein, 1, 0);
    }
}

public  boolean nachLinksverschiebar(Stein SpielStein) {
    if(SpielStein.y1>=1 && SpielStein.x4<=höhe-2) { // Stein noch nach links und  nach unten verschiebar ist
        return true; // Stein beweglich
    }
    return false; // Stein wird am Boden festgesetzt
}

public  boolean nachRechtsverschiebar(Stein SpielStein) {
    if(SpielStein.y4<=breite-2 && SpielStein.x4<=höhe-2) {
        return true;
    }
    return false;
}

public   boolean nachUntenverschiebar(Stein SpielStein) {
    if(SpielStein.x4<=höhe-2 ) {
        return true;
    }
    return false;
}

public  int[][] getSpielFeld() {
    return SpielFeld;
}

public int getHöhe() {
    return höhe;
}

public int getBreite() {
    return breite;
}

}

Hi,
Einen etwas "peinlichen" Fehler habe ich jetzt noch gefunden, die Steine fallen jedenfalls richtig runter und bleiben auch liegen nur, bei der Steuerung gibt es noch Probleme. Ich melde mich später nochmal.

So jetzt funktioniert es
Danke euch beiden.

Naja nachdem ich die Verbesserungen umgesetzt hatte, fielen sehr unregelmäßig Steine runter. In der onDraw() Methode hatte ich aber nur zwischen 2 Farbcodes unterschieden (es gibt 7 Steine also 7 Farbcodes) , es wurden also immer nur 2 Steine sehr unregelmäßig gezeichnet.