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

[Edlmann]

Zum Einen: Erst Blockaussehen definieren, dann benutzen.
Zum Zweiten: Warum px[0..3] und py[0..3]? Damit gehst du ja nur eine Zeile und eine Spalte durch. Ich würde die Blöcke als

Delphi-Quellcode:

  ObjType: Array[1..7] of Record
    VMatrix: Array[0..3, 0..3] of Boolean;
    cRGB: TcRGB;
  end;

Definieren. Also Eine Matrix von 4x4, die das Aussehen der Blöcke definiert. Auch reichen hier Variablen vom Typ Boolean, da man ja nur 1 und 0 hat (1=> An dieser Stelle der Matrix ist ein Stein, 0 => Kein Stein)

Zum Zweiten: Du gehst im Moment nur jeden Wert durch und setzt ihn auf 1, korrekt wäre:

Delphi-Quellcode:

 // Block-Daten einstellen
 // -- Type 1 -- //
 ObjType[1].cRGB := GetRGB(0, 1, 0); // Farbe
 ObjType[1].VMAtrix[0,0] := 1; // Aussehen
 ObjType[1].VMAtrix[0,1] := 1;
 ObjType[1].VMAtrix[0,2] := 1;
 ObjType[1].VMAtrix[0,3] := 1; // Einfach ein Balken der Länge 4
 // -- Type 2 -- //
 ObjType[2].cRGB := GetRGB(1, 1, 0);
 ObjType[1].VMAtrix[0,0] := 1; // Aussehen
 ObjType[1].VMAtrix[0,1] := 1;
 ObjType[1].VMAtrix[0,2] := 1;
 ObjType[1].VMAtrix[1,2] := 1; // Das typische Tetris L

 For i := 1 to 4 do // Block aussehen angeben
  FormBlocks
  [Round(FallingObject.pX/BlockSizeX)]
  [Round(FallingObject.pY/BlockSizeY)]
  := ObjType[FallingObject.aType].;

Auch könntest du in FallingObject die Koordinaten direkt als Blockanzahl abspeichern, so dass du bei deinen Berechnungen nicht immer

Delphi-Quellcode:

Round(FallingObject.pX/BlockSizeX)

sondern nur noch

Delphi-Quellcode:

[FallingObject.px]

hast.

Mfg

[Destroxi]

Danke aber wie übergebe ich die VMatrix an OpenGL?
Voher habe ich die X/Y-Positionen ja plus gerechnet muss ich hier überall "If" Abfragen machen?
Also wo und wie gebe ich an wie er das Teil zeichnen soll?
Und muss ich nicht

Delphi-Quellcode:

ObjType[1].VMAtrix[0,0] := Bool(1);

machen?
PS: Bin für ne Stunde weg, gucke danach wd hier rein [13:20]

Mfg, Destroxi

[Edlmann]

Du musst VMatrix gar nicht an OpenGL Übergeben ;) VMatrix dient lediglich der Spiellogik, um Festzustellen wie er welchen Typ von Stein zu interpetieren hat. OpenGL muss ja nur dein Spielfeld

Delphi-Quellcode:

FormBlocks: Array[0..Round(SizeX/BlockSizeX)] of Array [0..Round(SizeY/BlockSizeY)] of Integer;

Rendern - sonst macht OpenGL nichts. Der Rest ist wirklich nur durch Standard-Delphi zu implementieren. VMatrix dient wirklich nur, um zu wissen wenn du einen Stein in dein array übeträgst, wie dieser Stein aussehen soll. Die Komplette Spiellogik hat nichts mit OpenGL zu tun und sollte auf jeden Fall davon abgekapselt bleiben!

[DeddyH]

Wie ich schon sagte: erst die Logik, dann erst die Darstellung.

[Destroxi]

Sollen die For-Schleifen dann etwa so aussehen (um das Aussehen direkt zu übergeben):

Delphi-Quellcode:

For i1 := 0 to 3 do                                                       // Block aussehen angeben
  For i2 := 0 to 3 do
   If ObjType[FallingObject.aType].VMatrix[i1][i2] then
    FormBlocks
    [Round(FallingObject.pX+i1)]
    [Round(FallingObject.pY+i2)]
    := 1;

€dit: Ich habs jeze so aber es klappt nur bei der Linie:

Delphi-Quellcode:

// Block-Daten einstellen
 // -- Type 1 -- //
 ObjType[1].cRGB := GetRGB(0, 1, 0); // Farbe
 ObjType[1].ALengthX := 4;
 ObjType[1].VMAtrix[0,0] := Bool(1); // Aussehen
 ObjType[1].VMAtrix[1,0] := Bool(1);
 ObjType[1].VMAtrix[2,0] := Bool(1);
 ObjType[1].VMAtrix[3,0] := Bool(1); // Einfach ein Balken der Länge 4
 // -- Type 2 -- //
 ObjType[2].cRGB := GetRGB(1, 1, 0); // Farbe
 ObjType[2].ALengthX := 3;
 ObjType[2].VMAtrix[0,0] := Bool(1); // Aussehen
 ObjType[2].VMAtrix[1,0] := Bool(1);
 ObjType[2].VMAtrix[2,0] := Bool(1);
 ObjType[2].VMAtrix[2,1] := Bool(1); // Das typische Tetris L

 // Block erstellen
 FallingObject.aType := 2;
 FallingObject.pX := (SizeX/2-BlockSizeX*ObjType[FallingObject.aType].ALengthX/2)/BlockSizeX;
 FallingObject.pY := (SizeY-50)/BlockSizeY;
 For i1 := 0 to 3 do                                                       // Block aussehen angeben
  For i2 := 0 to 3 do
   If ObjType[FallingObject.aType].VMatrix[i1][i2] then
    FormBlocks
    [Round(FallingObject.pX+i1)]
    [Round(FallingObject.pY+i2)]
    := 1;
end;

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

end.

Mfg, Destroxi

[Edlmann]

Warum das nicht funktioniert kann ich dir auf Anhieb auch nicht sagen. Aber wofür benutzt du ALengthX noch? Ist doch jetzt (da die Matrix fest ist) überflüssig.

[Sir Rufo]

Auch wenn DeddyH das schon mehrfach hier erwähnt hat (und es anscheinend völlig unbeachtet im Hintergrundrauschen untergeht):

Mach dir zunächst keine Gedanken darüber wie du das zeichnest, sondern darüber was wann wo gezeichnet werden müsste!

Da eine Visualisierung bei der Entwicklung des Codes allerdings hilfreich ist solltest du dir ein ganz einfaches Ausgabe-Modul bauen.
Und da reicht eine Ausgabe als Text vollkommen aus.

Code:

: : : : : : : : : : :
: : : :X:X: : : : : :
: : : :X:X: : : : : :
: : : : : : : : : : :
: : : : : : : : : : :
: : : : : : : : : : :
: : : : : : : : : : :
:X: : : : : : : : : :
:X: : : : : : : : : :
:X:X: : : : : : : : :
:X:X:X:X: : : : : : :

Du solltest dir dabei eine entsprechende Funktion überlegen, der du quasi die Spielfelddaten übergibst und die Funktion daraus das Spielfeld zeichnet.
Nachher kannst du diese Funktion dann mit der OpenGL-Version ersetzen (oder auch immer nach Belieben austauschen)

[Destroxi]

Zitat:

Aber wofür benutzt du ALengthX noch?

Damit ich ohne viele Abfragen die Mitte der X-Achse bestimmen kann.

Zitat:

... sondern darüber was wann wo gezeichnet werden müsste!
... solltest du dir ein ganz einfaches Ausgabe-Modul bauen.

Werd ich machen ;)
:: Hab ich gemacht, rausgekommen sind 2 Fehler:
- FormBlocks Y-Wert muss "BlockY-i2" gerechnet werden
- Fehler im FormBlocks format, da im Textdokument steht

Code:

x
x
xx

aber auf der Form ein Platz zuviel zischen dem untersten Block und dem abzweigendem Block (1 weiter rechts); habe aber noch keine Lösung

Jetziger Code:

Delphi-Quellcode:

For i1 := 0 to 3 do s[i1] := '';
 For i1 := 0 to 3 do                                                       // Block aussehen angeben
  For i2 := 0 to 3 do
   If ObjType[FallingObject.aType].VMatrix[i1][i2] then
   begin
    s[i2] := s[i2] + 'x';
    FormBlocks
    [Round(FallingObject.pX+i1)]
    [Round(FallingObject.pY-i2)]
    := 1;
   end;
 For i1 := 0 to 3 do sl.Add(s[i1]);
 sl.SaveToFile('C:\VMatrix2.txt');
 sl.Free;

:: Fehler liegt in der Größer der Blöcke; bei Größer 30x30 passt alles; Ich gucke mal was da falsch ist...
:: Fehler gefunden: Es muss einzeln gerundet werden, also:

Delphi-Quellcode:

FormBlocks
    [Round(FallingObject.pX)+Round(i1)]
    [Round(FallingObject.pY)-Round(i2)]
    := 1;

Vielen Dank, an alle die mir bis jetzt mit der Vorgehensweise geholfen haben :)
Werde jetzt mich ans bewegen der Objekte machen...
:: So... Jez hab ich kleines bisschen gemacht, funzt auch, nur dass der Block anhält wenn da schon einer is funzt net...
:: Der 1. Code war mist xD ^^ hier ist mein neuer Code (Timer):

Delphi-Quellcode:

// Bewegung
procedure TForm1.tiBewegungTimer(Sender: TObject);
procedure NewBlock;
var
 i1, i2: Integer;
begin
 FallingObject.aType := 2;
 FallingObject.pX := (SizeX/2-BlockSizeX*ObjType[FallingObject.aType].ALengthX/2)/BlockSizeX;
 FallingObject.pY := (SizeY-50)/BlockSizeY;
 For i1 := 0 to 3 do // Block aussehen angeben
  For i2 := 0 to 3 do
   If ObjType[FallingObject.aType].VMatrix[i1][i2] then
    FormBlocks
    [Round(FallingObject.pX)+i1]
    [Round(FallingObject.pY)-i2]
    := 1;
end;
const
 Verkleinerung = 1;
begin
 If FallingObject.pY <= ObjType[FallingObject.aType].ALengthY then
 begin
  FallingObject.pY := ObjType[FallingObject.aType].ALengthY;
  SetFormBlockColors;
  NewBlock;
 end
 {else if FormBlocks[Round(FallingObject.pX)]
                    [Round(FallingObject.pY -Verkleinerung)]
                    <> 0 then
       begin
        SetFormBlockColors;
        NewBlock;
       end} // FUNZT NIT!!!
 else
 begin
  FallingObject.pY := FallingObject.pY - Verkleinerung;
  SetFormBlockColors;
 end;
end;

Bloß wie kriege ich's hin, dass das funzt, wo steht "FUNZT NIT!!!"?
Also, mit welchem "Gedanken"? ^^

Mfg, Destroxi

[Destroxi]

Hat nirgendwer nen Tipp oder guckt keiner rein? :|

[Sir Rufo]

Zitat:

Zitat von Destroxi (Beitrag 1134539)

Hat nirgendwer nen Tipp oder guckt keiner rein? :|

Wir schlagen gerade im Duden deine Wörter nach ("funzt") um zu verstehen was du meinst :stupid:

BTW Wieso bist du die ganze Zeit am Runden? Das ist IMHO völliger Unsinn

[Destroxi]

Funzt = Funktioniert ;D
und... ich bin am Runden da pX und pY Singels sind^^

[Sir Rufo]

Zitat:

Zitat von Destroxi (Beitrag 1134568)

Funzt = Funktioniert ;D
und... ich bin am Runden da pX und pY Singels sind^^

Das das irgendwas Floatiges war mir schon klar, aber den Sinn der Übung verstehe ich nicht:
Wenn das hier das Tetris-Feld ist:

Code:

X 0123456789
9
8   X
7   X
6   XX
5
4
3
2
1
0

Da sehe ich nicht die Notwendigkeit für Float, Double oder Extended.
Mit schnöden Integres kann man genau beschreiben, wo sich der Klotz befindet.

Du vermischt gerade schon wieder Anzeige und Code ;)

[Destroxi]

Ja...
Das mit dem unterscheiden der Anzeige und des Codes (OpenGL und Delphi) fällt mir nicht ganz so leicht^^

Aber hast du eine Ahnung wie ich das hinkriege, abzufragen ob der nächste Block "nichts" ist oder ein Block?

Mfg, Destroxi

[Sir Rufo]

Das wichtigste ist sich eben erst mal Gedanken um die Logik insgesamt zu machen.

Also wir haben ein Spielfeld von der Größe 10x18

Code:

++ 000000000011
++ 012345678901
18 X..........X
17 X..........X
16 X..........X
15 X..........X
14 X..........X
13 X..........X
12 X..........X
11 X..........X
10 X..........X
09 X..........X
08 X..........X
07 X..........X
06 X..........X
05 X..........X
04 X..........X
03 X..........X
02 X..........X
01 X..........X
00 XXXXXXXXXXXX

Das könnten wir ja in einem Array darstellen.

Dann wären da noch die fallenden Blöcke:
1. Jeder Block besteht aus 4 Feldern (unterschiedlich angeordnet)
2. Die Blöcke müssen sich drehen lassen
3. Die Blöcke bewegen sich nach einer Zeit x eine Reihe weiter nach unten
4. Die Blöcke dürfen nicht in die Wände laufen
5. Die Blöcke dürfen nicht in schon belegte Stellen laufen (ja, ist ja wie bei den Wänden)
6. Ist der Block an einer Stelle angekommen, wo es keine Zeile tiefer geht, dann bleibt er an dieser Stelle liegen
7. Ist der Block zur Ruhe gekommen, dann zerlegt sich dieser "Fallende Block" in seine Felder, die Bestandteil des Spielfeldes werden und der Block damit aufhört ein Block zu sein.

Wenn Punkt 7 ausgeführt wird dann wird das Spielfeld auf komplette Reihen durchsucht und diese Reihen werden entfernt.

Nur dieses solltest du zunächst umsetzen und nicht mehr!

[Destroxi]

ok...