Tetris erstellen - wie ?

[Destroxi]

Hi,
ich will ein Spiel erstellen - zuerst einmal Tetris.
Ich habe mich in letzter Zeit viel mit OpenGL 2D beschäftigt, und glaube, dass ich es theoretisch auch erstellen könnte.
Nur habe ich wenig Ahnung wo ich Anfange - wie ich z.B. die Objekte die nicht Quadratisch / einfache Linien sind also die "Abzweigungen" haben, darstelle,
also allgemein der Aufbau eines solchen Projektes.

Ich will also keinerlei Code sondern nur Tipps ;)

Freue mich über nützliche Tipps :)

[Edlmann]

Tetris war auch eines der ersten Spiele die ich auf die Beine gestellt habe - allerdings in Java :P

Ich würd das Spielfeld als 2 dimensionales Integerarray aufbauen, und jenachdem ob dort ein Stein ist oder nicht halt dementsprechend den Wert 0 oder 1 reinschreiben (dafür würdes auch ein array of boolean tun, aber man kann nachher dann ja noch so schnickschnack wie verschiedene Farben der Steine etc einbauen).
Dann brauchst du noch einen Variablentyp, der den aktuellen Stein enthält (denn beim Tetris bewegt sich ja immer nur ein Stein). Dieser Muss den aktuellen Mittelpunkt, den Typ und eine Funktion die den nächsten Schritt berechnet enthalten. Hierbei muss einfach je nach Typ geschaut werden ob der Stein denn Platz hat oder nicht ;)
Dann brauchst du natürlich noch eine Prozedur, die bei jedem Durchlauf der Spiellogik nach fertigen Reihen sucht - diese sollte als allerletztes in der Spiellogik aufgerufen werden. Ist eine Reihe voll, muss diese entfernt werden, der Rest rückt nach (=> Array oberhalb durchgehen und eine Zeile nach unten kopieren). An dieser Stelle kannst du einen Score erhöhen.

Ich hoffe dass dir das schonmal etwas weiterhilft, viel Erfolg dabei, kannst das fertige Projekt ja auch mal hochladen ;)
Lg, Edlmann

[Destroxi]

Erstmal danke für die schnelle Antwort :)

Dann werde ich erstmal also ein Array machen das jede Position (der größe nach pro Block) bestimmt.
Wegen dem aktuellen Stein - da mache ich ein Record.
Das Problem liegt eher woanders: bei den stehenden Steinen.
Wie lasse ich sie stehen, ohne dass ich sie immer neu zeichnen muss?
Muss ich alle Steine speichern?

€dit: Soll ich für die Steine texturen benutzen oder erstmal nur in einer Farbe?

Mfg

[DeddyH]

Vielleicht kannst Du Dir hier die eine oder andere Anregung holen: http://delphi.about.com/od/gameprogr.../ss/tetris.htm

[Destroxi]

Eher weniger, da dort mit ImageList, Timern usw. gearbeitet wird, außerdem die Sprache was weiß ich was ist^^ und ich mit OpenGL arbeiten will,
da es sehr viel schneller ist. Außerdem ist das Spiel buggy ^.^
Wenn Pause ist kann man immernoch drehen und mit "Pfeiltaste unten" den Block nach unten verschieben xD

Trotzdem Danke vielleicht kann ich mir ja paar Funktionsweisen abgucken oda so...

[DeddyH]

Es ging ja nicht um OpenGL oder TImageList, sondern darum, wie man die benötigten Teile (Spielfeld, Steine etc.) deklarieren und verwalten kann. Es hat ja keinen Sinn, sich über die Oberfläche Gedanken zu machen, wenn man die Daten darunter noch nicht im Griff hat.

[Destroxi]

Also, ich habe mal kurz, nach deinen Ratschlägen, Edlmann, ein kleinen Code zusammen geschrieben, und würde gerne wissen, ob das ein "Anfang" ist.

Zitat:

wie man die benötigten Teile (Spielfeld, Steine etc.) deklarieren und verwalten kann.

Darum gings mir auch nur versteh ich da nicht sooviel da die Variablen namen sehr "unbedeutend" sind und man da erst mal suchen muss für was sie verwendet werden.

Jetzt zu meinem Quelltext:

Delphi-Quellcode:

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, dglOpenGL, Coding;

type
  TForm1 = class(TForm)
    procedure FormCreate(Sender: TObject);
    procedure FormResize(Sender: TObject);
  private
    { Private declarations }
    procedure SetSizeOptions; // Viewport und größen der map einstellen
    procedure Render(Sender: TObject; var Done: Boolean); // Rendern
  public
    { Public declarations }
    DC: HDC;
    RC: HGLRC;
  end;
  TcRGB = Record      // TcRGB Record um Farben zu speichern im RGB format
    cRed, cGreen, cBlue: Single;
  end;

const
  SizeX = 640; // Map größe X
  SizeY = 480; // Map größe Y
  Unusable_Margin_X = 50; // Linker Rand um später Punkte etc anzuzeigen
  Unusable_Margin_Y = 10; // Bisschen Platz unten muss sein ;)
  BlockSizeX = 20; // Block größe X
  BlockSizeY = 20; // Block größe Y

var
  Form1: TForm1;
  FormBlocks: Array[0..Round(SizeX/BlockSizeX)] of Array [0..Round(SizeY/BlockSizeY)] of Integer;  // Map Farben
  FormSettings: Record // Sonstige Optionen
    cRGB: TcRGB;
  end;
  FallingObject: Record  // Fallendes Objekt
    pX, pY: Single;
    pType: Integer;
  end;

implementation

{$R *.dfm}

// Rot, Grün, Blau in TcRGB umwandeln
function GetRGB(cRed, cGreen, cBlue: Single): TcRGB;
begin
 Result.cRed := cRed;
 Result.cGreen := cGreen;
 Result.cBlue := cBlue;
end;

// Block zeichnen
procedure DrawBlock(cRGB: TcRGB; pX, pY: Single);
begin
 glBegin(GL_QUADS);
  glColor3f(cRGB.cRed, cRGB.cGreen, cRGB.cBlue);
  glVertex3f(pX-BlockSizeX/2, pY-BlockSizeY/2, 0);
  glVertex3f(pX+BlockSizeX/2, pY-BlockSizeY/2, 0);
  glVertex3f(pX+BlockSizeX/2, pY+BlockSizeY/2, 0);
  glVertex3f(pX-BlockSizeX/2, pY+BlockSizeY/2, 0);
 glEnd;
end;

// Viewport und Größer der map einstellen
procedure TForm1.SetSizeOptions;
begin
 glMatrixMode(GL_PROJECTION);
 glLoadIdentity;
 glViewPort(Unusable_Margin_X, Unusable_Margin_Y, ClientWidth, ClientHeight);
 glOrtho(0, SizeX, 0, SizeY, -128, 128);
 glMatrixMode(GL_MODELVIEW);
 glLoadIdentity;
end;

// Rendern
procedure TForm1.Render(Sender: TObject; var Done: Boolean);
var
 i1, i2: Integer;
begin
 SetSizeOptions;

 For i1 := 0 to Round(SizeX/BlockSizeX) do                       // Hintergrund für Tetris Färben
  For i2 := 0 to Round(SizeY/BlockSizeY) do
   If FormBlocks[i1][i2] = 0 then
    DrawBlock(FormSettings.cRGB, i1*BlockSizeX, i2*BlockSizeY);

 SwapBuffers(DC);

 Done := False;
end;

procedure TForm1.FormCreate(Sender: TObject);
begin
 // OpenGL initialisieren
 InitOpenGL;
 DC := GetDC(Handle);
 RC := CreateRenderingContext(DC, [opDoubleBuffered], 32, 24, 0, 0, 0, 0);
 ActivateRenderingContext(DC, RC);

 // Alle Blöcke löschen
 FillChar(FormBlocks, SizeOf(FormBlocks), 0);

 // Hintergrundfarbe einstellen
 FormSettings.cRGB := GetRGB(0.3, 0.3, 1);

 // Viewport und Größe der map einstellen
 SetSizeOptions;

 // Dauerhaft Rendern
 Application.OnIdle := Render;
end;

procedure TForm1.FormResize(Sender: TObject);
begin
 // Viewport und Größer der map einstellen
 SetSizeOptions;
end;

end.

Kann ich so weitermachen?

Mfg, Destroxi

[blackfin]

Zitat:

...außerdem die Sprache was weiß ich was ist^^ und ich mit OpenGL arbeiten will...

Bis auf ein paar Math-Funktionen (die in aktuellen OpenGL-Releases auch entfernt wurden) bietet dir OpenGL rein gar nichts für die Spiellogik an sich, es ist nur für die reine grafische Darstellung da.
Die Spiellogik selbst wirst du auch bei Verwendung von OpenGL mit konventionellen Delphi-Konstrukten lösen müssen :-)

Was ich dir sehr empfehlen kann ist ein gutes Buch, die "GPU Gems" Reihe oder "Graphic programming - a top-down aproach using OpenGL" zum Beispiel.
In diesen Büchern wird Tetris auch oft abgehandelt, fernab von reinem Code wird die Herangehensweise bei der Spieleprogrammierung beschrieben.
OpenGL-spezifisch wird dir auch das Red Book zum Nachlesen sehr sehr helfen.

Oder du surfst einfach durchs GameDev :-)

[Edlmann]

Ein Anfang ist das auf jeden Fall schonmal ;) Auch wenn du im Moment nur die Steine Renderst, die den Wert 0 besitzen

Delphi-Quellcode:

If FormBlocks[i1][i2] = 0 then

Ist das so gewollt? Ich würde 0 jetzt als kein Stein interpretieren ;)
Und was dir halt jetzt noch fehlt ist die Hauptschleife, die das Spiel kontrolliert. Diese sollte folgende Schritte durchlaufen:

1.) Den aktuellen Stein zurücksetzen (Je nach Typ alle Werte, die dieser Stein belegt hat, auf 0 zurücksetzen)
2.) Den aktuellen Stein je nach Spielereingaben bewegen (Drehen, Rechts, Links, Einen Runter, Ganz Runter)
3.) Den aktuellen Stein wieder in dein Array übertragen, an seiner neuen Position
4.) Wenn der aktuelle Stein sich nicht weiter bewegen kann => Neuen Stein erzeugen (kannst du einfach überschreiben, da ja nur ein Stein der aktuelle sein kann)
5.) Auf fertige Reihen prüfen und Score anpassen
(BONUS) 6.) Schwierigkeit erhöhen, je nach Score

[Destroxi]

Danke für die vielen hilfreichen Antworten :)

Könntet ihr vielleicht nochmal hierzu Tipps geben?

Zitat:

Das Problem liegt eher woanders: bei den stehenden Steinen.
Wie lasse ich sie stehen, ohne dass ich sie immer neu zeichnen muss?
Muss ich alle Steine speichern?

€dit: Ich habe jez weiter gemacht und probiert das Aussehen eines Blockes durch ein Array anzugeben... Nur der Block ist immer gleich :|
Mein Quelltext:

Delphi-Quellcode:

var
  Form1: TForm1;
  FormBlocks: Array[0..Round(SizeX/BlockSizeX)] of Array [0..Round(SizeY/BlockSizeY)] of Integer;  // Map Farben
  FormSettings: Record // Sonstige Optionen
    cRGB: TcRGB;
  end;
  FallingObject: Record  // Fallendes Objekt
    pX, pY: Single;
    aType: Integer;
  end;
  ObjType: Array[1..7] of Record
    pX, pY: Array[1..4] of Single;
    ALengthX, ALengthY: Integer;
    cRGB: TcRGB;
  end;

implementation

{$R *.dfm}

// Rot, Grün, Blau in TcRGB umwandeln
function GetRGB(cRed, cGreen, cBlue: Single): TcRGB;
begin
 Result.cRed := cRed;
 Result.cGreen := cGreen;
 Result.cBlue := cBlue;
end;

// Block zeichnen
procedure DrawBlock(cRGB: TcRGB; pX, pY: Single);
begin
 glBegin(GL_QUADS);
  glColor3f(cRGB.cRed, cRGB.cGreen, cRGB.cBlue);
  glVertex3f(pX-BlockSizeX/2, pY-BlockSizeY/2, 0);
  glVertex3f(pX+BlockSizeX/2, pY-BlockSizeY/2, 0);
  glVertex3f(pX+BlockSizeX/2, pY+BlockSizeY/2, 0);
  glVertex3f(pX-BlockSizeX/2, pY+BlockSizeY/2, 0);
 glEnd;
end;

// Viewport und Größer der map einstellen
procedure TForm1.SetSizeOptions;
begin
 glMatrixMode(GL_PROJECTION);
 glLoadIdentity;
 glViewPort(Unusable_Margin_X, Unusable_Margin_Y, ClientWidth, ClientHeight);
 glOrtho(0, SizeX, 0, SizeY, -128, 128);
 glMatrixMode(GL_MODELVIEW);
 glLoadIdentity;
end;

// Rendern
procedure TForm1.Render(Sender: TObject; var Done: Boolean);
var
 i1, i2: Integer;
begin
 SetSizeOptions;

 For i1 := 0 to Round(SizeX/BlockSizeX) do                       // Hintergrund für Tetris Färben
  For i2 := 0 to Round(SizeY/BlockSizeY) do
   If FormBlocks[i1][i2] = 0 then
    DrawBlock(FormSettings.cRGB, i1*BlockSizeX, i2*BlockSizeY)
   else if FormBlocks[i1][i2] = 1 then
    DrawBlock(ObjType[FallingObject.aType].cRGB, i1*BlockSizeX, i2*BlockSizeY);

 SwapBuffers(DC);

 Done := False;
end;

procedure TForm1.FormCreate(Sender: TObject);
var
 i: Integer;
begin
 // OpenGL initialisieren
 InitOpenGL;
 DC := GetDC(Handle);
 RC := CreateRenderingContext(DC, [opDoubleBuffered], 32, 24, 0, 0, 0, 0);
 ActivateRenderingContext(DC, RC);

 // Alle Blöcke löschen
 FillChar(FormBlocks, SizeOf(FormBlocks), 0);

 // Hintergrundfarbe einstellen
 FormSettings.cRGB := GetRGB(0.3, 0.3, 1);

 // Viewport und Größe der map einstellen
 SetSizeOptions;

 // Dauerhaft Rendern
 Application.OnIdle := Render;

 // Block erstellen
 FallingObject.aType := 1;
 FallingObject.pX := SizeX/2-BlockSizeX*ObjType[FallingObject.aType].ALengthX/2;
 FallingObject.pY := SizeY-20;
 For i := 1 to 4 do                                                       // Block aussehen angeben
  FormBlocks
  [Round(FallingObject.pX/BlockSizeX+ObjType[FallingObject.aType].pX[i])]
  [Round(FallingObject.pY/BlockSizeY+ObjType[FallingObject.aType].pY[i])]
  := 1;

 // Block-Daten einstellen
 // -- Type 1 -- //
 ObjType[1].cRGB := GetRGB(0, 1, 0); // Farbe
 ObjType[1].ALengthX := 4;           // Länge
 ObjType[1].ALengthY := 1;           // Länge
 ObjType[1].pX[1] := 0;              // Aussehen
 ObjType[1].pX[2] := 1;
 ObjType[1].pX[3] := 2;
 ObjType[1].pX[4] := 3;
 ObjType[1].pY[1] := 0;
 ObjType[1].pY[2] := 0;
 ObjType[1].pY[3] := 0;
 ObjType[1].pY[4] := 0;
 // -- Type 2 -- //  
 ObjType[2].cRGB := GetRGB(1, 1, 0);
 ObjType[2].ALengthX := 3;           // Länge
 ObjType[2].ALengthY := 2;           // Länge
 ObjType[2].pX[1] := 0;
 ObjType[2].pX[2] := 1;
 ObjType[2].pX[3] := 1;
 ObjType[2].pX[4] := 2;
 ObjType[2].pY[1] := 0;
 ObjType[2].pY[2] := 0;
 ObjType[2].pY[3] := 1;
 ObjType[2].pY[4] := 0;
end;

procedure TForm1.FormResize(Sender: TObject);
begin
 // Viewport und Größer der map einstellen
 SetSizeOptions;
end;

end.

PS: Screen im Anhang (Block quadratisch obwohl er Längs eingestellt ist)

Mfg, Destroxi