Animentor

Heyho, aufstrebender Pythonista! Du hast jetzt genug Einkaufslisten erstellt, dutzendmal den ollen Zinseszins berechnet und bringst dich beim nächsten “Hello world”-Programm um? Du willst endlich deinem Traum näher kommen und ein eigenes Spiel in Python schreiben? Perfekt! Lassen wir also diesen Unsinn und legen wir los.

Wir beginnen mit einem simplen, RPG-ähnlichen Kampfsystem, das wir in den folgenden Artikeln ausbauen werden. Natürlich kannst du den kompletten Code einfach kopieren und damit anstellen, was du willst, aber es wäre vielleicht cool, wenn du wüsstet, was du da kopierst.

Kein Kampf ohne Kämpfer, hier ist der Bauplan:

Wir können mithilfe des Konstruktors bestimmen, wie der Kämpfer heißt, auf welchem Level er sich befindet und ob entweder der Spieler oder der Computer ihn steuert. Dann setzen wir nicht nicht einfach feste Werte für Hitpoints, Angriffsstärke, Verteidigung und Flinkheit, sondern lassen sie von einer globalen attribute()-Funktion in Abhängigkeit vom Level und des Zufalls bestimmen. Die Funktion sieht so aus:

Um zu verstehen, was diese Funktion macht, stell dir eine exponentiell steigende Kurve in einem Koordinatensystem wie in der Schule vor und greif dir einen beliebigen Punkt aus der Kurve heraus. Je weiter rechts der Punkt liegt, desto höher ist der Level, und weil die Kurve steigt, spuckt die Funktion auch einen höheren Attributwert aus als bei den weiter links liegenden Punkten. Die Formel für die Kurve ist ziemlich simpel: Der Level dient als Basis, und der Exponent von 1 wird um einen zufälligen Wert zwischen mindestens 0 und höchstens 0.1 erhöht, je nach dem, ob eine Abweichung in beide Richtungen(deviation) angegeben ist. Das Zufallselement ist wichtig, damit die Kämpfer selbst bei gleichem Level noch individuelle Stärken und Schwächen haben. Das Ergebnis wird dann noch mit einem beliebigen Faktor multipliziert.

Ein Kämpfer muss ordentlich zuschlagen können, darum fügen wir der Fighter()-Klasse eine hit()-Methode zu:

Die kriegt den Gegner als Argument mitgeteilt und berechnet nach einer einfachen Formel den Schaden, den sein Schlag verursachen würde. Genau wie in richtigen Fights fällt nicht jeder Schlag immer genau gleich aus, darum schwankt hier der tatsächliche Angriff zwischen 30% und 170% des eigenen Angriffswertes. Davon ziehen wir zwischen 0% und 50% des aktuellen gegnerischen Verteidigungswertes ab. Dann prüfen wir mit der beats()-Methode, ob der Angreifer in diesem Moment flinker als sein Gegner reagiert, und falls ja, berührt der Schlag den Gegner – falls nicht, konnte der Gegner ausweichen. Die beats()-Methode ist ziemlich clever, weil sie Zufall simuliert und darum auch bei gleichen Attributen verschiedene Ergebnisse liefern kann:

Mithilfe der globalen compare()-Funktion berechnet sie das Verhältnis des eigenen und gegnerischen Attributes in Prozent und dann die Differenz von gegnerischem und eigenem Prozentsatz – das Ergebnis ist entweder negativ oder positiv, aber nie weniger als -100 und nie mehr als 100. Eine Formel, die im Grunde genauso funktioniert wie in attribute(), berechnet schließlich die Chance des Gegners, den Kämpfer in einem Attributvergleich zu schlagen. Je größer eine positive Differenz ist, desto höher ist die Potenz und desto kleiner ist der Teiler, und desto größer ist im Ergebnis die Chance für Kämpfer 2, Kämpfer 1 im Vergleich zu schlagen. Für eine negative Differenz gilt jeweils das Gegenteil.

Die compare()-Funktion ist dagegen extrem simpel:

Sie gibt einfach nur die Prozentsätze der beiden Kämpfer für ein Attribut zurück, wobei der stärkere mit 100% den Orientierungswert bietet. Diese Funktion wird auch später von der “AI” benutzt, um Entscheidungen zu treffen.

Gut, Kämpfer können nun Schläge austeilen. Aber was passiert, wenn jemand getroffen wird? Das erledigt die get_hit()-Methode der Fighter()-Klasse:

Die hit()-Methode des Angreifers teilt dem Verteidiger den berechneten Schaden mit. Wenn der kleiner oder gleich Null ist, kann der Verteidiger diesen Schlag abwehren, ansonsten wird ihm der Schaden von den Hitpoints abgezogen. Wenn ihm dadurch die Hitpoints ausgehen, markieren wir den Kämpfer als besiegt. Das Spiel reagiert später darauf. Die get_defeated()-Methode ist ausgelagert, weil sie in Zukunft noch mehr erledigen könnte. Im Moment ist sie ganz spartanisch:

Unter Umständen zieht es ein Kämpfer vor, in einer Runde auf einen Angriff zu verzichten und stattdessen seine Chancen zu verbessern, den nächsten Schlag des Gegners abzuwehren. Dafür beherrscht er die defend()-Methode, die einen zufälligen Faktor zwischen 1.1 und 1.3 bestimmt, mit dem sein Verteidigungswert beim nächsten gegnerischen Angriff multipliziert wird.

Oder er könnte versuchen, dem Kampf zu entfliehen, hier die escape()-Methode:

Hier benutzen wir wieder die beats()-Methode, diesmal um den Fluchtversuch zu simulieren, und wieder ist die Flinkheit das entscheidende Attribut. Der Rückgabewert steht für den Erfolg oder Misserfolg der Flucht und wird in der Spielschleife aufgegriffen, die darauf angemessen reagiert.

Wo wir von der Spielschleife sprechen …! Jetzt haben wir unsere Kämpfer, doch wie lassen wir sie gegeneinander antreten? Weil das Programm noch nicht besonders komplex ist, können wir die Logik komfortabel in der main()-Funktion des Programms ausbreiten:

Erst einmal erstellen wir natürlich zwei Kämpfer, und blue_fighter soll vom Spieler gesteuert werden. Dann bedienen wir uns wieder einmal der beats()-Methode, um zu erfahren, wer das Flinkheits-Duell gewinnt und als Erster angreifen darf. Die while-Schleife ruft nun so lange die globale fight()-Funktion auf, bis der Kampf auf irgendeine Art beendet wird (Sieg bzw. Niederlage, Flucht, Spielende). Die turn_update()-Methode ist dafür gedacht, etwaige temporäre Zustände wieder zu entfernen und Standardwerte wiederherzustellen, aber bisher setzt sie nur den temporären Verteidigungsbonus von defend() wieder zurück:

Die globale print_stats()-Funktion zeigt dem Spieler vor jedem Zug eines Kämpfers die Hitpoints der Kämpfer an, damit er eine begründete Entscheidung treffen kann:

Kommen wir nun zur fight()-Funktion, in der die wesentlichen Entscheidungen der Kämpfer getroffen und bearbeitet werden:

Hier teilt sich der Weg: in einen für vom Spieler kontrollierte und einen für vom Computer gesteuerte Kämpfer. Erstere erhalten mit der fight_options()-Funktion ein Menü angeboten, in dem sie ihren Zug bestimmen, und je nach Auswahl wird die entsprechende Fighter()-Methode ausgeführt. Wenn daraufhin der Kampf weiterläuft, gibt die Funktion True zurück, doch falls der Kampf durch irgendeine Auswahl oder einen besiegten Kämpfer beendet wird, gibt sie False zurück, worauf main() mit dem Abbruch der Spielschleife, break, reagiert (siehe oben).

Sehen wir uns kurz die Kampfoptionen von fight_options() an:

Der Spieler trifft seine Entscheidung also über ein Eingabefeld in der Konsole, und der entsprechende String wird fight() mitgeteilt.

Wesentlich interessanter ist die decide()-Methode der Fighter()-Klasse, die von fight() aufgerufen wird (siehe oben). Sie ist unsere “AI”, unsere künstliche Intelligenz für die vom Computer gesteuerten Kämpfer, obwohl sie in diesem Fall sehr einfach gestrickt ist:

Zunächst holt sich die “AI” die Prozentsätze seines eigenen Kämpfers für Angriffsstärke, Verteidigung und verbliebene Hitpoints im Vergleich zu denen seines Gegners. Wenn der computergesteuerte Kämpfer schwächer abschneidet, wird ein Prozentsatz kleiner als 100 sein. Das ist noch kein Grund für Gefahr. Aber falls sowohl seine eigene Angriffsstärke als auch seine Verteidigung weniger als 20% der gegnerischen Werte ausmachen oder falls sie weniger als 50% ausmachen und dafür die Hitpoints weniger als 20% der gegnerischen Hitpoints entsprechen, sieht der Computer einen gewichtigen Grund, die Flucht anzutreten, statt sich auf einen aussichtslosen Kampf einzulassen. Wenn lediglich die Angriffsstärke nur 20% des gegnerischen Wertes ausmacht, probiert er es mit Verteidigung, um einen Schlag abzuwehren. In allen anderen Fällen greift der Computer seinen Gegner an. Die decide()-Methode gibt außerdem den Wert True zurück, falls der Kampf weitergeht, und False, falls der Kampf durch Sieg bzw. Niederlage oder eine erfolgreiche Flucht beendet wird.

Weil wir ein paar Mal die in der Python-Standardbibliothek enthaltene round()-Methode benutzen, um Dezimalzahlen zu runden, diese Methode aber seit Python 3 nicht mehr dem Verfahren entspricht, wie man es aus der Schule kennt und erwartet (“Runde immer ab .5 auf!”), sondern bei geraden Vorkommastellen vor .5 ab- und bei geraden aufrundet, stellen wir das alte und erwartete Verhalten wieder her, indem wir in unserem Programm round() mit einer globalen Funktion überschreiben:

Damit ist die Konsolen-Version unserer RPG-artigen, rundenbasierten Kampfengine so gut wie fertig. Fehlen nur noch die Importe und ein paar Konventionen:

Die komplette Fassung als Python-Skript: simpleFight

Nachdem wir jetzt verstanden haben, wie die Kämpfer interagieren und die Züge sich abwechseln, reisen wir in der nächsten Ausgabe in die 90er Jahre und spielen mit grafischer Oberfläche, Maus und diesen ganzen neumodischen Interfaces, die sich niemals durchsetzen werden! Und weil ich keine sadomasochistische Ader habe, setze ich auf Qt und PyQt.