Hallo DGL,

ich bin's mal wieder. Naja ich muss wirklich sagen, ich hab noch nie richtig ein Spiel programmiert und da ich gerade voll aufm Tetristrip bin, dachte ich, ich programmier mein eigenes Tetris. Soll ganz viel später (wenn's überhaupt funktioniert) auch sowas gemeines bekommen, wie Geschwindigkeitssteuerung nach dem Puls des Spielers.

Naja, aber ehrlich gesagt, scheitere ich schon am Konzept. Ich weiß nicht, wie ich das am effizientesten programmieren kann. Was mir natürlich klar ist, dass ich das Spielfeld und die Darstellung auf dem Bildschirm trennen sollte. An die Darstellung habe ich eventuell an OpenGL gedacht, damit ich damit auch mal etwas mehr arbeite.

Nur weiß ich nicht, wie ich das am besten intern mache. Spielfeld als Array? Wie Steine definieren?

Naja, ich hoffe, ihr lacht mich deswegen jetzt nicht aus und könnt mir ein wenig helfen.


mfg
Müllermilchtrinker

Ich hab da selbst noch nicht reingeguckt, aber bei den Tutorials gibt es doch das Bomberman-Spiel.

Ehrlichgesagt ich habe mich an Tetris nie rangewagt . Aber ok. Anfangen kann man, indem man das aktuelle (feste) Spielfeld als Array definiert. Mit fest meine ich den Teil, der bereits liegt. Das was fällt, wird separat behandelt. Das kann man einfach (Booleans) oder komplexer (Integer) machen, um auch unterschiedliche Steinfarben in dem Spielfeldarray abzubilden. Oder Objekte/Records wenn man noch coole sondersteine bauen möchte oder sonstwas. Was einem so einfällt. Ich würde vielleicht mit nem Integer, der auf farben abbildet anfangen und dann bunte steine fallen lassen.

Die fallenden Steine lässt man dann alle x Sekunden (wobei x auch gerne < 1 sein kann) ein Feld nach unten rutschen. Dabei prüft man, ob die Form des fallenden Steins (die man am besten mit einem n×m Array aus Booleans/Integers abbildet: 0 == da ist kein Stein, sonst ist da ein Stein. Die größe des arrays kann man entweder statisch (sodass jede beliebige Steinform in das gleiche Array passt) oder dynamisch (je nach Bounding Box des steins) wählen) mit einem bereits liegenden Stein kollidiert. Ist das der Fall, wird der stein nicht nach unten verschoben, sondern an ort und stelle in das Spielfeldarray „eingepflanzt“. Dann den nächsten Stein spawnen.

So würde das Datenmodell und die Logik grob aufbauen.

Visualisierung: Durch das Modell gehen und Quads entsprechend rendern. Kann man auch gut zu Quadern ausweiten und das ganze dann in 3D machen.

Boßhaftigkeit: Schau dir mal bastet an. Das Tetris, das dich wirklich hasst

Noch fragen?

greetings

_________________
If you find any deadlinks, please send me a notification – Wenn du tote Links findest, sende mir eine Benachrichtigung.
current projects: ManiacLab; aioxmpp
zombofant network • my photostream
„Writing code is like writing poetry“ - source unknown

„Give a man a fish, and you feed him for a day. Teach a man to fish and you feed him for a lifetime. “ ~ A Chinese Proverb

Stimmt, ich glaube, da komme ich aufjedenfall weiter, wenn ich die festen Steine mit dem fallenden Stein trenne. Werde mich dann mal wieder melden, wenn ich Zeit habe, werde ich mal anfangen.


Da gibt's auch noch ein anderes: Not Tetris

so ich hoffe mal ich hab die hauptschleife noch drauf *hust*

-spielfeld erstellen (wie schon gesagt als array)
-->solange(wahr) {
----->sonderformen vom userinput abarbeiten (z.b. esc)
----->wenn kein stein{
------->erstelle stein (form,farbe und startpos)
------->wenn spielfeld[stein.pos + stein.form] != 0{
--------->break und verloren
------->}
----->}
----->zeichne spielfeld
----->wenn spielfeld[stein.pos + stein.form + vec[0,1] + user.lastinput] == 0 {
------->stein.pos = stein.pos + vec[0,1] + user.lastinput
------->zeichne stein
----->} sonst {
-------->spielfeld[stein.pos + stein.form] = stein.farbe
-------->linecount = 0
-------->wenn spielfeld(stein.pos[y] + stein.form[y])(x) != 0 {
---------->spielfeld(stein.pos[y]+stein.form[y])(x) = spielfeld(stein.pos[y-1]+stein.form[y])(x)
---------->linecount += 1
-------->}
-------->punkte = punkteproline * linecount
-------->wenn punkte >= level*win_punkte {
---------->level += 1
---------->gamespeed(level)
---------->spielfeld erstellen
-------->}
-------->lösche stein
----->}
----->sleep(gamespeed)
-->}

_________________
Meine Homepage

Das Spielfeld würde ich nicht als Array aus Integern machen, sondern als Array aus Enumerationen. Dann ist das ganze auch typsicher. Geht in Delphi IIRC so:



Btw: In Scala (Blick-über-den-Tellerrand™):

_________________
"Für kein Tier wird so viel gearbeitet wie für die Katz'."