- JAVA - Tetris - volle Reihen entfernen...

[flomei]

Hallo!
Freitag is Abgabe meiner Facharbeit und momentan hänge ich an einem wichtigen Punkt fest.
Und zwar hapert es Entfernen komplett gefüllter Reihen.
Ich weiss nicht wie ich das klären soll...
Habe in einer Liste alle gelegten Blöcke und kann diese nach ihrer X und Y Position fragen. In eine Reihe passen 10 Blöcke nebeneinander.
Wie kann ich nun am Besten überprüfen ob 10 Blöcke direkt nebeneinander in meiner Liste rumgammeln.
Habe mal mit Paint ne Skizze gemacht um das anschaulich zu machen... ;)

Der Rest ist eigentlich kaum nen Problem.
Ich würde die Reihe entfernen und würde dann alle Blöcke die noch da sind versuchen "einen tiefer" rutschen zu lassen...

Also wie mach ich das jetzt am Besten?

MFG Florian :hi:

P.S.: Bitte ne Lösung mit Schleifen und meiner Liste. Hab genug Streß weil ich 1,5mal neu anfangen durfte... :roll:

[sniper_w]

Jedes mal wenn ein Block runterfählt, merkst du das in einem Feld (10*Hoche) (2d array). Danach überprüfst du ob eine ganze Reie voll "besetz" ist.
z.B. so ungefähr

Delphi-Quellcode:

const Hoche : integer = 20; // das kannst du ändern

var Field:array[0..9] of array[0..Hoche] of Boolean;

// ANNAHME -> Wenn Field[x,y]=TRUE dann ist das besetzt, sonst frei

function ReieVoll(reie:integer):Boolean;
 var i:integer;
begin
 result := True;
 for i:=0 to 9 do
   if Field[i,reie] then
    begin
     Result := False;
     Exit;
    end;
end;
....
 for a:=0 to Hoche-1 do
  if ReieVoll(a) then
   begin
      // heir machst du was du schon willst
   end;

[flomei]

Einfachere Lösungsmöglichkeiten?
Würde gerne heute Abend bzw. Nacht die Arbeit vollenden, bzw. so gut wie vollenden...
Notfalls lass ich das Entfernen der Reihen halt raus. Ist zwar nicht toll aber ich schreib dann schon was Nettes in die Bewertung der Arbeit...

MFG Florian :hi:

[Pr0g]

Ich würde es auch so machen, wie sniper_w vorgeschlagen hat.

Oder du nimmst ein weiteres Arrays, in welchem du für jede Reihe die Anzahl der besetzen Blöcke speicherst. Nach jedem Stein musst du halt ausrechnen wie viele Blöcke welcher Reihe hinzugefügt werden, danach kannst du das Array durchgehen und prüfen ob eine Reihe voll ist. Wenn ja, die Reihe löschen und alle Werte (in dem Array und in deinem Array mit den Blöcken) eins nach unten schieben, bzw. nach oben je nach dem, wie du es aufgebaut hast.

MfG Pr0g

[sniper_w]

Zitat:

Einfachere Lösungsmöglichkeiten?

:roll: :gruebel: :shock: :?
Und das war nicht einfach ? :dp:

[flomei]

Das war schon einfach aber ob es für den Lehrer einfach genug ist... :roll:

MfG Florian :hi:

[atreju2oo0]

Ich denke mal Du willst das Array umgehen, da Du ja ne Liste hast, richtig?

Dann würde ich einfach ne Funktion schreiben die das so macht:

Delphi-Quellcode:

procedure getReihe
var reihe:array[1..Hoehe]of integer;
begin
   while Blockliste.next <> nil do   // Wie das mit JAva geht weiß ich nciht... gemeint ist halt die Liste mit deinen Blöcken
    begin
      Blockliste:=Blockliste.next;
      inc(reihe[Blockliste.y]);
    end;
    // Diese while Schleife durchläuft deine ganzen Blöcke und erhöht jeweils den Eintrag der Liste in dem der Stein ist.
       Wenn jetzt am Ende ein Feld der reihe=10 ist so muss zwangsläufig die Reihe voll sein!
       Wie Du das prüfst und so schaffste schon alleine!

end;

[GuenterS]

Statt dem Array könntest Du auch die ersten 10 Bit eines Integers verwenden. Damit würdest Dir das "Array" sparen und würdest noch Kenntnisse mit BitOperatoren nachweisen.

[atreju2oo0]

Nen Array braucht man aber trotzdem, da ja pro Zeile Werte von 0 bis 10 gespeichert werden müssen.
Da denk ich ist meine Version besser geeignet oder hab ich Dich falsch verstanden?

[GuenterS]

Nun du brauchst pro Zeile eine Zahl, die aber sicher größer als 10 wird.

Wenn Du jede Reihe durchgehst und das entsprechende Bit setzt oder löscht, je nachdem ob da ein Stein ist oder nicht, kommst Du auf eine bestimmten Wert der Reihe. Wenn die Reihe voll ist, brauchst Du die Wertigkeit der Reihe nur mit 1023 vergleichen. Ist sie gleich, ist die Reihe voll, wenn nicht fehlt mindestens 1 Stein.

Dazu fängt man unten an und geht mit einer schleife nach oben. Nicht vergessen darf man aber, nach jedem erfolgreichen durchgehen die Steine runterrutschen lassen.

[atreju2oo0]

Das Problem ist doch aber gerade, dass er nur eine Liste hat in der alle Blöcke noctiert sind.
Somit kann man nicht mit ner einfachen Schleife alles durchgehen, da nach nem Stein aus Reihe 2 wieder einer aus Reihe 1 kommen kann.
Somit ist meine Version wo einfach nur der Wert in der Zeile um eins erhöht wird doch besser...
Da braucht man sich um den Rest keinen Kopf zu machen.

Dass shl shr schon schöne Sachen sind will ich damit natürlich nicht aberkennen und sicherlich geht deine Version!
:)

[Pr0g]

Zitat:

Zitat von atreju2oo0

Da denk ich ist meine Version besser geeignet oder hab ich Dich falsch verstanden?

Zitat:

Zitat von atreju2oo0

Somit ist meine Version wo einfach nur der Wert in der Zeile um eins erhöht wird doch besser...

Deine Version? Vielleicht habe ich das schon drei Posts vor dir vorgeschlagen :zwinker:

[flomei]

Ich hab jetzt Folgendes hier:

Code:

   private void pruefeReihen()
   {
      int[] lReihen = { 225,245,265,285,305,325,345,365,385,405,425,445,465,485,505,525,545,565,585,605,625,645 };
      int    lCounter = 0 ,lIndex = 0;
      
      for(lIndex=0;lIndex==21;lIndex++)
      {
         hatBlockliste.zumAnfang();
         while(!hatBlockliste.istDahinter())
         {
            if(hatBlockliste.erbitteBlock().erbitteY() == lReihen[lIndex])
            {
               lCounter++;
            }
            hatBlockliste.vor();
         }
         if(lCounter == 9)
         {
            hatBlockliste.zumAnfang();
            while(!hatBlockliste.istDahinter())
            {
               if(hatBlockliste.erbitteBlock().erbitteY() == lReihen[lIndex])
               {
                  hatBlockliste.entferneAktuelles();
                  hatBlockliste.vor();
               }
            }
            hatBlockliste.zumAnfang();
            while(!hatBlockliste.istDahinter())
            {
               oBlock1 = hatBlockliste.erbitteBlock();
               oBlock2 = hatBlockliste.erbitteBlock();
               oBlock3 = hatBlockliste.erbitteBlock();
               
               if(this.kannAbwaerts())
               {
                  this.bewegeAbwaertsOhnePause();
               }
            }
         }
      }      
   }

Scheint aber irgendwie nicht ganz zu funktionieren. Sieht irgendwer von euch nen Fehler?

Werde das nachher auch nochmal meinem Lehrer zeigen, dann kann der sehen was er mir da aufgebrummt hat. Vielleicht kann ich dann später abgeben... *hoff*

MfG Florian :hi:

[sniper_w]

Zitat:

Statt dem Array könntest Du auch die ersten 10 Bit eines Integers verwenden. Damit würdest Dir das "Array" sparen und würdest noch Kenntnisse mit BitOperatoren nachweisen.

Ich wollte absichtlich diese Lösung nicht vorschlagen, da es IMHO zu Profesionell für eine Schularbeit ist. Bestimmt wäre dies die beste Lösung und schnellste auch.
Aber ARRAY könnte man trotzdem nicht sparen :wink: , denn für jede Reie braucht man ein Integer, d.h.

Delphi-Quellcode:

const Hoche = 20;
var Reien : array[0..Hoche]of Integer;

[GuenterS]

Zitat:

Zitat von sniper_w

Zitat:

Statt dem Array könntest Du auch die ersten 10 Bit eines Integers verwenden. Damit würdest Dir das "Array" sparen und würdest noch Kenntnisse mit BitOperatoren nachweisen.

Ich wollte absichtlich diese Lösung nicht vorschlagen, da es IMHO zu Profesionell für eine Schularbeit ist. Bestimmt wäre dies die beste Lösung und schnellste auch.
Aber ARRAY könnte man trotzdem nicht sparen :wink: , denn für jede Reie braucht man ein Integer, d.h.

Delphi-Quellcode:

const Hoche = 20;
var Reien : array[0..Hoche]of Integer;

Du brauchst eben kein array, Du hast ja eine Liste. Mag sein, dass es mit array performanter wäre, aber notwendig ist es nicht. Man muss ja auch beachten, dass manche Steine aufgrund von vorher entfernten nachrutschen, also müßtest dein Array auch immer wieder neu aufbauen.

[Pr0g]

Zitat:

Zitat von GuenterS

Man muss ja auch beachten, dass manche Steine aufgrund von vorher entfernten nachrutschen, also müßtest dein Array auch immer wieder neu aufbauen.

Aber viel ist da eigentlich nicht zu machen, da beim Entfernen einer Reihe einfach nur die Werte der anderen Reihen um eins nach unten verschoben werden und die oberste Reihe wieder zu 0 wird. Es ist ja nicht so, dass die Steine in irgendwelche Lücken nachrutschen, die durch das Entfernen weiter unten frei werden könnten. Erst dann müsste man alles berechnen.