Beginnen wir damit, eine geeignete Repräsentation des Spiels und seiner Regeln als Programm zu finden. Da ich dieses Tutorial schreibe, ohne das ganze bis zum Ende durchgeplant zu haben, finde ich jetzt vielleicht nicht die optimale Repräsentation, aber irgendwie müssen wir ja anfangen.
Vielleicht hat sich der eine oder die andere bereits auf die Suche nach den Regeln begeben. Man findet sie mit Google. Es sind etwa 20 Seiten, die ich hier nicht alle wiedergeben will (oder kann, denn auch nach 40 Jahren unterliegen sie natürlich noch einem Copyright).
Hier ist eine Kurzfassung:
Gespielt wird auf einer Karte mit 15 x 22 durchnummerierten Hex-Feldern. 28 Hex-Felder enthalten Sternsysteme, sechs davon sind Heimatwelten. Zwischen einigen Sternen gibt es Warp-Linien.
Es spielen zwei Spieler gegeneinander. Jeder Spieler besitzt Raumschiffe. Er verfügt über Baupunkte, mit denen er neue Schiffe erschaffen oder vorhandene repariert kann. Wer zuerst drei Siegpunkte gesammelt hat, gewinnt. Einen Siegpunkt bekommt, wer eine gegnerische Heimatwelt kontrolliert.
Raumschiffe sind entweder Warp-Schiffe oder Systemschiffe. Sie befinden sich immer auf einem Hex-Feld, welches beliebig viele Schiffe (beliebig vieler Spieler) enthalten kann. Ein Warp-Schiff kann sich über die Karte bewegen und dabei Systemschiffe transportieren. Systemschiffe können sich ohne transportierendes Warp-Schiff nur auf einem Feld mit einem Sternsystem aufhalten.
Raumschiffe haben diverse Eigenschaften: Power/Drive (PD), Warp Generator (WG), Beams (B), Screens (S), Tubes (T), Missiles (M), Systemship Racks (SR) und Level.
Im Kampf bekommt jedes Raumschiff eine Taktik zugewiesen und kann beschädigt (oder zerstört) werden. Details betrachte ich erst, wenn es um den Kampf geht.
Das Spiel findet in Runden und Phasen statt. Jeder Spieler gibt pro Phase Befehle ab. Dazu liegt ihm eine Beschreibung des Spielstands vor. Er erhält einen Report mit der aktualisierten Beschreibung des Spielstands.
Mein Datenmodell soll aus Exemplaren der folgenden Klassen bestehen.
Ich werde im folgenden Python 3.2 benutzen. Python bietet leider keine gute Möglichkeit, ein Datenmodell zu beschreiben, daher gebe ich jeweils eine `__init__`-Methode an, die alle Eigenschaften eines Objekts initialisiert.
Code: Alles auswählen
class Game:
def __init__(self):
self.players = [] # Liste beide Spieler
self.stars = [] # Liste der 27 Sternsysteme
self.eships = [] # Liste alle Raumschiffe aller Spieler
self.turn = 0 # Rundenzähler
self.phase = 0 # Phasenzähler
Ein Objekt der Klasse `Game` soll den Ist-Zustand des Spiels beschreiben. Es kennt Spieler (`Player`), Sternsysteme (`Star`) und Raumschiffe (`Ship`). Ich denke, ich komme ohne eine explizite Karte aus. Stattdessen haben `Star`s und `Ship`s eine Position. Über das `Game`-Objekt kann ich dann alle Raumschiffe an einer bestimmten Position finden.
Code: Alles auswählen
class Player:
def __init__(self):
self.name = "" # Wie nennt sich der Spieler
self.password = "" # Kennwort, damit nicht jeder Befehle einreichen kann
self.bp = 20 # Baupunkte
self.vp = 0 # Siegpunkte
self.orders = [] # Liste aller Befehle für die aktuelle Phase
class Order:
def execute(self, game, player):
pass
Ein `Player` hat eine Liste von Befehlen (`Order`) und später noch einen Report (`Report`), den ich mir noch nicht weiter überlegt habe. Befehle haben Parameter wie z.B. das Raumschiff, das bewegt werden soll und das Zielfeld, wohin es bewegt werden soll, aber ich denke, `Game` und `Player`, die jeder Befehl kennen muss, damit er ausgeführt werden kann, übergebe ich und speichere ich nicht als Teil eines jeden Befehls.
Code: Alles auswählen
class Star:
def __init__(self):
self.name = "" # Name des Sternsystems
self.position = Coord() # X/Y-Koordinate
self.owner = None # Ist es eine Heimatwelt? Dann hier Spieler
self.warp_lines = [] # Liste der durch Warp-Linien verbundenen Systeme
Ein `Star` hat einen `Player` als Besitzer, wenn er eine Heimatwelt ist. Er hat eine Reihe von Warp-Linien-Verbindungen zu anderen Sternsystemen. Die Position repräsentiere ich als Objekt, das weiß, welche Koordinaten die sechs Nachbarfelder haben.
Code: Alles auswählen
class Ship:
def __init__(self):
self.no = 0 # Identifikator
self.position = Coord() # X/Y-Koordinate
self.owner = None # Besitzer (ein Spieler)
self.level = 0 # Tech-Level
self.pd = 0 # Power/Drive
self.wg = 0 # Warp Generator (0=Systemship, 1=Warp-Ship)
self.b = 0 # Beams
self.s = 0 # Screens
self.t = 0 # Tubes
self.m = 0 # Missiles
self.sr = 0 # Systemship Racks
self.ships = []
Ein `Ship` hat ebenfalls eine Position und immer einen `Player` als Besitzer und wenn es ein Warp-Schiff ist, kann es Systemschiffe transportieren. Die Liste der Attribute ist in sofern noch nicht vollständig, als das es jedes Attribut einmal für den maximalen Wert und für den aktuellen Wert geben muss und ich wohl auch noch für einen Kampf mir merken muss, welche Taktik benutzt werden soll und welchen Schaden ein Schiff genommen hat. Um es aber einfach zu bauen, reicht das so erst einmal.
Nach dieser Vorplanung kann ich das nächste Mal mit der Implementierung beginnen.