Tetris rotation

[pustekuchen]

Guten Tag,

ich bin derzeit in C# ein Tetris am Programmieren. Ich suche aber eine Allgemeine Lösung.
Mir stellt sich derzeit eine Frage und ich wollte mal wissen, wie Ihr es machen würdet.

Und zwar geht es um die Rotation der Spielsteine.
Es gibt mehrere Rotationssysteme. Ich habe mich für das SRS(Super Rotation System) entschieden, weil dies mir am vertrautesten vorkommt.
So wie setzte ich das ganze nun am besten um?
Bei meiner Recherche sind mir 2 Wege aufgefallen, entweder Mathematisch oder mit vorher festgelegten Werten z.B. in einem Array in dem alle Rotationsfälle stehen.

Dieses Bild habe ich zur Mathematischen lösung gefunden, doch ganz versteh ich das nicht.

Was sagt Ihr? Vielleicht könnt ihr mir einen kleinen Denkanstoß geben

[Jumpy]

Ich versteh das so, dass ja jede Figur in einen quadratischen Block eingeschlossen wird, der je nach Figur untersch. groß ist. Ein quadratischer Block entspricht einer quadr. Matrix.
Wo in der quadratischen Matrix eine 1 steht, ist im Bild ein Blöckchen der Tetris-Steins. Somit für den langen gereden 4er Tetris-Stein gibt es je eine 4x4 Matrix:

Code:

0010    0000    0100    0000
0010    0000    0100    1111
0010    1111    0100    0000
0010    0000    0100    0000

Wahrsch. ist es aber einfacher, jeweils 4 fertige Bilder in einer Liste zu haben...

[Aphton]

Du kannst dir ein Array of Array of Boolean mit einer Dimension von n*n definieren, wobei n = ungerade.

Beispiel: n = 5:
Array[0..4, 0..4] of Boolean;

Hier wäre die Mitte [2,2]. Dh. diese Stein wird nicht geändert.
Beim Rotieren kannst du einfach von diesem Punkt aus Vektoren zu den einzelnen Feldern aufstellen und dazu jeweils die passende Normale nehmen (kippen nach links [-y|x] oder rechts [y|-x]).
Dieser Vektor addiert auf [2,2] ergibt die Koordinaten des Zielfeldes.

Codemäßig dürfte das wie folgt aussehen:

Delphi-Quellcode:

const
  BrickDimension = 5;

type
  TTetrisBrick = Array[0..BrickDimension-1, 0..BrickDimension-1] of Boolean;

const
// die Waagrechte
  Brick1: TTetrisBrick= (
    (False, False, False, False, False),
    (False, False, False, False, False),
    (True,  True,  True,  True,  True),
    (False, False, False, False, False),
    (False, False, False, False, False)
  );
// weitere
{...}

procedure RotateBrick(var B: TTetrisBrick);
var
  i, j: Integer;
  M, AB: TPoint;
  R: TTetrisBrick;
begin
  M := Point( BrickDimension div 2, BrickDimension div 2 );
  for i := 0 to BrickDimension - 1 do
    for j := 0 to BrickDimension - 1 do
    begin
      AB := Point( i - M.X, j - M.Y );
      // normale(nach links kippen):
      AB := Point( -AB.Y, AB.X );
      R[M.X+AB.X,M.Y+AB.Y] := B[i,j];
    end;
  B := R;
end;

Ich habs sogar grad getestet (habs ja nur ausm Kopf hingeschrieben gehabt) und das funzt wie es soll...

[pustekuchen]

Danke erstmal.

Ihr würdet also auch ehr den Mathematischen weg nehmen?
Ich werde mich morgen damit weiter befassen und das ganze mal umsetzten, jetzt hab ich erstmal Feierabend

[Aphton]

Ja, ich würde den mathematischen Weg nehmen!
Have fun!

[pustekuchen]

Hallo,

hab das ganze jetzt mal für den ' ---- '-Stein angepasst.
Nur ein Problem besteht jetzt noch, wenn ich öfters hintereinander nach rechts drehe Bewegt der Spielstein sich nach rechts.
Bei der Linksdrehung bleibt alles okay.

Hier mal die jetzige Methode:

Code:

public override void rotate(RotateDirection rotDir) 
        { 
            Point AB;
            int Dimension = 5;

            Mittelpunkt = (Fields[2].X > Fields[1].X || Fields[2].Y > Fields[1].Y) ? Fields[2] : Fields[1];

            bool[] fieldIsRefreshed = {false,false,false,false};
            for (int i = Mittelpunkt.X - 2; i < Mittelpunkt.X - 2 + Dimension - 1; i++)
            {
                for (int j = Mittelpunkt.Y - 2; j < Mittelpunkt.Y - 2 + Dimension - 1; j++)
                {
                    for (int k = 0; k < Fields.Length ; k++)
                    {
                        if (!fieldIsRefreshed[k])
                        {
                            if (i == Fields[k].X && j == Fields[k].Y)
                            {
                                AB = new Point(i - Mittelpunkt.X, j - Mittelpunkt.Y);
                                AB = (rotDir == RotateDirection.Right) ? AB = new Point(-AB.Y, AB.X) : new Point(AB.Y, -AB.X);
                                Fields[k] = new Point(AB.X + Mittelpunkt.X, AB.Y + Mittelpunkt.Y);
                                fieldIsRefreshed[k] = true;
                            }
                        }
                    }
                }
            }
        }

Jetzt nur noch verallgemeinern für die anderen Spielsteine und dann sollte es klappen