Tetris

Hallo,

Ich bin gerade dabei ein Tetris zu programmieren.
Habe bis jetzt das Feld und ein Stein der runterfällt den ich auch bewegen kann.
Nun weiß ich aber nicht wie ich weitermachen soll.

Habt ihr vielleicht ein paar Tipps für mich?

Grüß Markus

[niemand]

Naja, wenn der Stein unten ist, kommt halt der nächste Stein

cu

ja klar, aber ich hab erst einen einzelnen, ich brauch ja verschiedene Figuren und weiß nicht so genau wie ich das machen soll.

Mfg

[SlaterB]

wenn das hier einer ist

--------------
|           |
|           |
|           |
|           |
-------------

dann sind zwei davon nebeneinander ein Zweier

---------------------------
|           |           |
|           |           |
|           |           |
|           |           |
--------------------------

[LoN_Nemesis]

Hm ich weiss auch nicht wie man die Formen der Steine am besten repräsentiert. Eventuell durch ein boolean Array?

1000
1000
1000
1000

0000
1000
1000
1100

0000
0000
1100
1100

0000
0000
0100
1110

Das wären dann zum Beispiel einige typische Tetrissteine. Ist bestimmt ziemlich schnell und einfach.

Erstmal Danke für die Antworten!

Kann mir einer diesen Codeausschnitt erklären:
Darin wird ein "L" gespeichert:

       //L Rechts
        koordX[0][0] = 0; koordY[0][0] = 0;
        koordX[1][0] = 0; koordY[1][0] = 1;
        koordX[2][0] = 0; koordY[2][0] = 2;
        koordX[3][0] = 1; koordY[3][0] = 2;
        breite[0] = 2;
        hoehe[0] = 3;
        
        koordX[0][1] = 0; koordY[0][1] = 0;
        koordX[1][1] = 1; koordY[1][1] = 0;
        koordX[2][1] = 2; koordY[2][1] = 0;
        koordX[3][1] = 0; koordY[3][1] = 1;
        breite[1] = 3;
        hoehe[1] = 2;
        
        koordX[0][2] = 0; koordY[0][2] = 0;
        koordX[1][2] = 1; koordY[1][2] = 0;
        koordX[2][2] = 1; koordY[2][2] = 1;
        koordX[3][2] = 1; koordY[3][2] = 2;
        breite[2] = 2;
        hoehe[2] = 3;
        
        koordX[0][3] = 0; koordY[0][3] = 1;
        koordX[1][3] = 1; koordY[1][3] = 1;
        koordX[2][3] = 2; koordY[2][3] = 1;
        koordX[3][3] = 2; koordY[3][3] = 0;
        breite[3] = 3;
        hoehe[3] = 2;

Danke!

[LoN_Nemesis]

Das kann mit Sicherheit keiner, denn das einzige was man sieht ist ein 2-dimensionales Array, in das irgendwelche int Werte eingetragen werden. Was 0, 1, 2 oder 3 jeweils bedeutet, kann man ohne den Rest vom Code nicht sagen.

[Zunera]

Hallo,

und ein "Klar kann man den Code verstehen!". Wer schonmal selbst Tetris programmiert hat, der weiß, was es für Schwierigkeiten gibt und wie man sie versucht zu überwinden.
Der Programmcode definiert dir in einem "breite x hoehe" Feld einen Stein - und zwar in allen vier Varianten, die durch Drehung des Steines entstehen können.
Stell dir einfach ein Koordinatensystem vor (wobei ich jetzt den Ursprung links oben gewählt habe - ist beliebig) und trage dort einfach mal an koordX und koordY ein X ein und du erkennst das "L". Hier mal die ersten beiden Beispiele:

- 0 1 2 3 - x
0 X
1 X
2 X X
3
|
y

- 0 1 2 3 - x
0 X X X
1 X
2
3
|
y


Anno dazumal hab ich auch ein Tetris programmiert, und ich habe die Steine ähnlich kodiert, wobei man sich bei mir ein 4x4 Feld vorstellen muss, das durchlaufend nummeriert ist:

1 5 9 13
2 6 10 14
3 7 11 15
4 8 12 16

Und dann hab ich einfach ein 3-dimensionales Array, wobei kurz ausgedrückt

BLOCK[steinart][drehung][bausteinnr]

den Zugriff steuert. Also über die erte Dimension bekommt man die verschiedenen Steine, über die zweite die verschiedenen Drehungen und über die dritte den Wert, an welcher Stelle "baustein"-Nr 1 bis 4 liegt (jeder Tetrisstein besteht ja aus 4-"Einzelbausteinen"). So sind dann alle Steine kodiert:

    public final static int[][][] BLOCK = {{   { 5, 6, 9,10},  //Quadrat
                                        { 5, 6, 9,10},
                                        { 5, 6, 9,10},
                                        { 5, 6, 9,10}},
                                    {   { 1, 5, 9,13},  //Stab
                                        { 8, 9,10,11},
                                        { 1, 5, 9,13},
                                        { 8, 9,10,11}},
                                    {   { 2, 6, 9,10}, //L
                                        { 5, 9,10,11},
                                        { 2, 3, 6,10},
                                        { 5, 6, 7,11}},
                                    {   { 1, 5, 9,10}, //umgekehrtes L
                                        { 5, 6, 7, 9},
                                        { 1, 2, 6,10},
                                        { 6, 8, 9,10}},
                                    {   { 1, 5, 6,10}, //umgekehrtes S
                                        { 5, 6, 8, 9},
                                        { 1, 5, 6,10},
                                        { 5, 6, 8, 9}},
                                    {   { 2, 5, 6, 9},//S
                                        { 4, 5, 9,10},
                                        { 2, 5, 6, 9},
                                        { 4, 5, 9,10}},
                                    {   { 1, 5, 9, 6},//...
                                        { 4, 5, 6, 9},
                                        { 1, 5, 9, 4},
                                        { 4, 5, 6, 1}}};

Vielleicht als Anregung, wie du selbst deine Steine kodieren kannst...

Viele Grüße

Danke, das hat mir sehr weitergeholfen!
Hab jetzt alle Steine implementiert.

Wie mach ich das jetzt am besten mit den Kolisionen? z.b. das er nicht an der Seite raus kann.

Gruß Markus

[Zunera]

Die Frage ist nicht leicht zu beantworten - ich weiß ja nicht, wie dein Tetrisprogramm aufgebaut ist. Bei mir stammten wie gesagt alle Steine-Objekte aus der Klasse "Block", dazu hatte ich eine Klasse "Player" (ich habe ein MultiplayerTetris programmiert, so dass es viele "Player" Objekte geben konnte). Jedes "Player"Objekt beinhaltete das Spielfeld des Spielers (ein einfaches int[][] (Array)), dessen Punkte, ... und unter anderem den aktuellen Stein. Jeder Stein kannte seine eigene Position. Nun habe ich nach jedem Zug mit folgender Funktion geprüft, ob der "aktuelle Stein" noch im Spielfeld ist und sich auch nicht auf einen anderen Stein drauf bewegt hat:

public boolean movePossible() {
        if(!mbLooser) {
            Point[] pt = getActBlockPos();
            for(int i = 0;i<4;i++) {
                if( pt[i].x>=TetrisGame.COLUMNS || pt[i].x<0 ||
                    pt[i].y>=TetrisGame.ROWS|| pt[i].y<0 ||
                    maaiField[pt[i].x][pt[i].y]!=EMPTY)
                        return false;
            }
        } else return false;
        return true;
    }

Also ich hab zuerst den Zug ausgeführt, dann geprüft ob er zulässig ist - wenn ja, fein; wenn nein, Zug zurück nehmen.

Grüße