Vor einigen Jahren war das Spiel 2048 recht populär. Gabriele Cirulli hat Ideen aus einem anderen Spiel übernommen und daraus das 2048 Spiel entwickelt und als Open Source Software veröffentlicht. Es gibt auch eine Implementierung für die PDP-8.

Mich reizt es, das Spielprinzip selbst zu implementieren. Die PDP-8 als 12-Bit Maschine scheint geradezu prädestiniert dafür, ist doch die Zahl 2048 die 2 in der elften Potenz (2^11) und die grösste Zahl, die sich in einem 12 bit signed int darstellen lässt. 😉

Für die Implementierung benötigen wir zum einen ein gutes Veständnis über die Spielmechanik und einige grundlegende I/O Routinen.

Spielprinzip

2048 wird auf einem 4×4 Felder grossen Spielbrett gespielt.

Spielzüge sind rundenbasiert:

1. Der Computer platziert eine zufällig gewählte Zahl auf einem freien Feld.
2. Der Spieler “verdichtet” das Spielfeld in eine bestimmte Richtung. Dabei werden zwei benachbarte gleichwertige Felder addiert; ein vorher besetztes Feld wird dabei frei.

Bei beiden Zügen gibt es folgendes zu berücksichtigen:

Computerzug

• Der Computer platziert entweder eine 2 (sehr häufig) oder eine 4 (rar) auf einem freien Feld.
  • Das Verhältnis der Wahl von der 2 zur 4 beträgt etwa 1 zu 5.
• Das Spiel endet, wenn es kein freies Feld mehr gibt.

Spielerzug

• Der Spieler wählt mit Tastendruck, auf welche Seite des Spielfelds “verdichtet” wird.
• Zuerst fallen die Steine auf die gewählte Seite, sodass keine Lücken mehr zwischen den Steinen sind.
• Verdichtet wird von unten nach oben.
• Einmal verdichtete Steine werden in diesem Spielzug nicht weiter verdichtet.

Spielfeld

Das Spielfeld liegt als einfaches Array im Speicher. Die Zelle 0 liegt oben links:

            Nord
     +---+---+---+---+
     | 0 | 4 | 8 | 12|
     +---+---+---+---+
     | 1 | 5 | 9 | 13| 
West +---+---+---+---+ Ost
     | 2 | 6 | 10| 14| 
     +---+---+---+---+
     | 3 | 7 | 11| 15| 
     +---+---+---+---+
            Süd

Da der Spieler in alle “Himmelsrichtungen” verdichten kann schwebt mir vor eine Routine zum Rechtsdrehen des Spielfelds zu implementieren. So muss ich die “Steine fallen” bzw. “Steine verdichten” nur einmal implementieren.

Grundlegende Routinen

Das Spiel soll auf einer PDP-8 mit TTY (Teletype, ASR-33 Terminal) laufen. Später soll dann eine Terminal-Version (VT100) folgen. Auf der VT100 kann ich dann Dinge wie Fettschrift oder Farben nutzen.

Um das Spiel zu implementieren benötigen wir:

• Eingabe (Tastaturabfrage)
  • Abfrage einer einzelnen Taste
• Ausgabe (TTY)
  • Spielfeld
  • Zahlen
• Zufallszahlengenerator
  • keine hohe Qualität gefordert (PRNG)

Ein- und Ausgabe

Das klassische E/A Gerät ist die Teletype, also eine elektrische Schreibmaschine. Das Ansprechen der Teletype ist einfach und in Dokument commonly used utility routines beschrieben. Nachfolgend einige Notizen dazu.

Initialisierung

CLA     / clear acc
TLS     / initialize teletype

Tastatur abfragen

KRB     / read keyboard buffer, clear kbd flag
KSF     / check keyboard flag
JMP *-1 / wait until ready

Zeichen ausgeben

TLS     / terminal output, clear terminal flag
TSF     / check terminal flag
JMP *-1 / wait until ready

Zufallszahlengenerator

Für das Spiel benötigen wir Zufallszahlen im Zahlenbereich von 0..15. Wir benötigen keine “starken” Zufallszahlen, da wir keine Kryptographie implementieren.

Beim Stöbern im Netz habe ich eine Implementierung von Steve Gibson gefunden, an der ich mich orientieren werde.

Zusammenfassung

Grundlegendes ist geklärt und ich arbeite an der Implementierung der Hilfsroutinen. Das reduziert Komplexität und ich kann Code für andere Projekte wieder verwenden. Auch eine nachträgliche Umstellung auf ein VT100 Terminal wird dadurch einfacher.

Routinen

• initty – TTY initialisiseren
• putc – einzelnes Zeichen ausgeben
  • put6s – 6 bit packed string ausgeben, \0 terminiert. Basiert auf putc
• getc – Tastatur abfragen
• srand – PRNG initialisieren
• rand – Zufallszahl holen