Snakespiel - Programmieren eines Klassikers mit Python
Abschnittsübersicht
-
In diesem Kurs lernst du die Programmiersprache Python kennen. Falls du schon ein wenig Erfahrung mit Python aus vorherigen Kursen hast, kannst du in diesem Kurs das bisher Gelernte anwenden.
Unser Ziel wird es sein den Spiele-Klassiker Snake zu programmieren. Dabei werden wir die verschiedenen Entwicklungsphasen in der Programmierung kennenlernen und anhand des Snake-Spiels vom Entwurf bis zum fertigen Spiel selbst durchlaufen.
Als Programmiersprache lernen wir Python kennen. Python gilt als eine leicht zu erlernende Programmiersprache, die für Anfänger gut geeignet ist. Der wesentliche Grund dafür liegt in der einfachen Syntax. Mit Python lassen sich aber auch komplexe Programme programmieren. -
-
Installation
Falls du Python bereits installiert hast, kannst du diesen Abschnitt überspringen.
Um Python programmieren zu können, wird ein geeigneter Texteditor zum Schreiben des Codes benötigt. Damit der Code ausgeführt werden kann, brauchen wir einen Python Interpreter. Ich gehe im Folgenden auf die nötigen Schritte für Windows-Anwender ein.
(Andere Betriebssysteme wie Linux oder Ubutu verfügen in der Regel bereits über ein passendes Programm.)
Die Entwicklergemeinschaft von Python stellt den notwendigen Interpreter unter folgendem Link zum Download bereit:
https://www.python.org/downloads/
Ein Klick auf die gelbe Schaltfläche und der Download wird gestartet. Wenn du die heruntergeladen exe-Datei startest, bekommst du folgendes Fenster.
In diesem Fenster ist es wichtig, dass du die Checkbox Add Python 3.10 to PATH anklickst. Das bewirkt, dass der Installations-Assistent automatisch den Pfad des Python-Interpreters zu den Umgebungsvariablen hinzufügt. Sonst lässt sich der Python-Interpreter nur öffnen, wenn man sich in dem Verzeichnis befindet, in dem er installiert wurde. Da es aber nicht sinnvoll ist die eigenen Programme im Installationsverzeichnis des Python-Interpreters abzulegen, würde das eine große Einschränkung bedeuten.
Nach der Auswahl der Checkbox klickst du auf Install Now.
War die Installation erfolgreich, schließt du das Fenster mit der Schaltfläche Close.
Da es sehr viele verschiedene Texteditoren gibt, werde ich zur Einfachheit die von Python mitgelieferte IDLE Umgebung verwenden. Du solltest sie nach der Installation in deinem Startmenü unter IDLE finden. Einfach starten und los geht's.
-
Das erste Programm
Wenn du die IDLE-Umgebung startest, sollte das geöffnete Fenster, wie folgt aussehen.
Das ist das Shell-Fenster. In diesem Fenster erfolgen die Ausgaben deines Codes. Du könntest in der Shell programmieren, aber dann kannst du deinen Code nicht sauber abspeichern. Darum gehst du zunächst auf File->New File. Es öffnet sich ein neues Fenster, dies ist das Editor-Fenster bzw. Code-Fenster, indem du programmierst.
Zum Testen, ob alles funktioniert, wirst du deinen ersten Befehl schreiben.
Die Shell soll Hallo Welt! ausgeben. Im Code-Fenster schreibst du dafür:
print("Hallo Welt!")
Zur Erklärung: Der Befehl lautet print() und Hallo Welt! ist vom Datentyp ein String, also eine Zeichenkette. Strings müssen immer in Anführungsstriche gesetzt werden. Würdest du 1234 schreiben, also vom Datentyp Integer bzw. Zahlen, brauchst du keine Anführungsstriche.
Jetzt musst du deinen Programmcode speichern. Gehe dafür im Code-Fenster auf File->Save As wähle einen Ordner, in dem du dein Programm speichern möchtest, oder lege einen neuen Ordner in einem von dir gewählten Pfad an. Gib deiner Datei einen Namen und füge den Dateityp .py an, zum Beispiel Test.py.Nun kannst du deinen Code über das Code-Fenster ausführen. Im Menü auf Run->Run-Module klicken.
Daraufhin sollte die Shell in den Vordergrund treten und du siehst deine erste Ausgabe.
Merke dir: Programm Schreiben -> Speichern -> AusführenDas Programm soll nun erweitert werden.
1. Der Nutzer soll mit Hallo Welt! begrüßt werden. (Das hast du bereits programmiert.)
2. Anschließend nach seinem Namen gefragt werden.
3. Mit seinem Namen begrüßt werden.
Ich zeige dir, wie das Programm aussehen soll.
Wir erweitern nun dein Programm. Python soll mit der Funktion len() die Länge des eingegebenen Namens ermitteln und anschließend ausgeben.
Leg eine neue Variable an und weise ihr die Funktion len() zu. Übergib der Funktion die Variable person. Anschließend soll die Ausgabe des Wertes erfolgen. Damit man weiß, wofür die Zahl steht, die angezeigt wird, soll ein Satz die Ausgabe umschließen.
Im Bild seht ihr, wie der Code aussehen könnte.
Zur Erklärung:
person ist eine Variable, mit dem = erfolgt die Zuweisung, was in die Variable geschrieben wird. Die Variablen sollten möglichst so bezeichnet werden, dass sie angeben, was in ihnen gespeichert wird.
Variablennamen sollten mit einem Buchstaben beginnen. Du kannst Buchstaben und Zahlen verwenden. Symbole wie -, /, # oder @ sind nicht erlaubt. Leerzeichen dürfen nicht verwendet werden, stattdessen kannst du Unterstriche verwenden. Groß- und Kleinschreibung werden unterschieden. Python behandelt person und Person als zwei verschiedene Variablen. Verwende keine Wörter wie print, die bereits Befehle in Python sind.
input("optional") liest Eingaben aus, optional kann ein String angegeben werden, der vor der Eingabeaufforderung ausgegeben werden soll. Eingabeaufforderungen werden mit Enter bestätigt.
print() dient der Ausgabe von Werten, z.B. Strings, die in Hochkommas oder Anführungsstrichen geschrieben werden oder auch zum Auslesen von Variablen verwendet wird. Die Ausgabe von mehreren Werten wird mit Komma getrennt.
len() steht für das englische Wort length zu Deutsch Länge und gibt die Länge eines Strings inklusive Leerzeichen wieder.
Speichere dein Programm und führe dein Programm aus.
Tipp zum schnelleren Ausführen:
Strg+s speichert dein Programm
F5 führt dein Programm aus
-
Du kennst vielleicht das Spiel Snake. Es zählt zu den Klassikern bei Spielen und ist relativ einfach gehalten. Du wirst in diesem Abschnitt erfahren, wie du das Spielfenster einrichtest, die Schlange oder Raupe und das Futter erstellst.
-
Grundlagen des Snake-Spiels
Erstellen einer neuen Datei
Um eine Python-Datei anzulegen, öffne IDLE (die installierte Entwicklungsumgebung für Python). Klicke auf File und anschließend auf New File. Speichere diese Datei als raupe.py (oder snake.py, den Namen kannst du frei wählen) indem du auf File und dann auf Save As gehst. Wähle dir einen geeigneten Speicherort für deine Python-Projekte, gib den Dateinamen ein und speichere die Datei ab.
turtle-Modul importieren
Für die Programmierung des Spiels werden Befehle bzw. Funktionen verwendet, die aus Modulen bzw. Bibliotheken zuvor importiert werden müssen. Wir verwenden die Turtle-Grafik und das Modul wird wie folgt importiert.
Spielfeld erstellen
Zunächst wollen wir das Spielfeld erstellen, auf dem die Spielfigur angezeigt werden soll.
Vor Beginn des Spiels sollen für das Spielfeld Anfangseigenschaften festgelegt werden. Für die Initialisierung des Spielfelds und dessen Eigenschaften legen wir eine eigene Funktion an:
Mit def definieren wir eine eigene Funktion. Die Funktion erhält in diesem Fall den Namen initSpielfeld(). Weiterhin übergeben wir der Funktion 2 Parameter (die Breite und die Höhe des Spielfeldes), die wir innerhalb der Funktion verwenden. Alles was zu der Funktion gehört folgt hinter dem Doppelpunkt eingerückt darunter.
Innerhalb der Funktion legen wir dann den Titel title(), die Hintergrundfarbe bgcolor() und die Größe setup() des Spielfeldes fest.
Zur Auswahl der Farbe kannst du dir auf folgender Seite die Namen der Farben raussuchen.
https://cs111.wellesley.edu/labs/lab01/colors
Unter der folgenden Webseite findest du im Absatz Colour Map ebenfalls die Namen der Farben, sowie deren Hexadezimalcode und RGB-Farbcode:
http://appjar.info/pythonBasics/
Oder du trägst die Farbe im Hexadezimalcode eintragen, den kannst du auch in einem Bildbearbeitungsprogramm ermitteln. (z.B. black -> #000000)
Der hier roteingefärbte Text beginnend mit # ist ein Kommentar. Kommentare helfen Programmierern ihren Code zu dokumentieren, um ihn zu strukturieren bzw. lesbar zu gestalten. Gerade bei größeren Programmen ist das Kommentieren sehr hilfreich.
Aufrufen der Funktion
Damit unsere Funktion auch ausgeführt wird müssen wir sie auch aufrufen und die Werte für die Parameter mitgeben.
aktuelles Programm
Unser Programm hat einen ersten Zwischenstand erreicht und sieht nun wie folgt aus.
Wenn wir unser Programm speichern und ausführen, sehen wir das Spielfeld.
-
-
-
Schlange erstellen
Die Schlange wird mit dem Turtle-Module erzeugt. Wenn du dir den folgenden Code ansiehst, wird aus der Variablen Snake ein Turtle-Objekt Snake = t.Turtle(), so dass die Funktionen des Turtle-Moduls vom Objekt raupe verwendet werden können.
Das Initialisieren der Schlange erfolgt wieder über eine eigene Funktion, die wir schreiben.
Die Geschwindigkeit der Schlange wird zu beginn auf 1 gesetzt speed(1).
Die Form der Schlange wird zu einem Kreis mit shape('circle').
Als Farbe habe ich eine schwarze Schlange gewählt color('black'), du kannst dir wieder eine Farbe frei wählen.
Zu Beginn soll die Schlange keine Richtung zugewiesen bekommen richtung = "keine".
Damit keine Linien gezeichnet werden muss der Stift angehoben werden penup(), da mit dem Turtle-Module sonst gezeichnet wird.
Und zum Schluss soll noch eine Startposition festgelegt werden mit goto(x-Wert, y-Wert). Mit dem Befehl goto(wertX, werty) kannst du die Turtle entlang der Koordinaten der Oberfläche bewegen. Das ist einfacher, da man genau bestimmen kann, wo die Turtle sich befinden soll.
Damit die Eigenschaften für die Schlange auch gesetzt werden, muss die Funktion noch aufgerufen werden.
Der Zwischenstand des Programms sieht wie folgt aus:
Wenn wir unser Programm speichern und ausführen, sieht es wie folgt aus:
-
Es kommt Bewegung in die Schlange
Als nächste soll sich die Schlange bewegen, und zwar immer in die Richtung, die der gerade gedrückten Pfeiltaste entspricht.
Dabei kannst du ausnutzen, dass jeder Tastendruck ein Event auslöst: ein Ereignis, das das Spielfeld zur Kenntnis nimmt, wenn wir es dazu auffordern, auf diese Ereignisse zu achten (zu lauschen, auf Englisch to listen).
Mit der Anweisung Spielfeld.listen() sagst du dem Spielfeld, dass es auf Tastendruck-Events lauschen soll.
Die vier Pfeiltasten der Tastatur lösen die vier folgenden Events aus: Up, Down, Right, Left (hoch, runter, rechts und links).
Für jedes dieser Evens denken wir uns nun einen Funktionsnamen aus. Die Funktion wird beim Eintreten des Events ausgeführt. Die Verbindung zwischen dem Funktionsnamen und dem Event stellt man durch den Befehl onkey her.Für die Pfeiltasten erstellen wir uns nun eine Initialisierungsfunktion mit der wir den Events die entsprechende Funktion zuweisen und außerdem dem Spielfeld die Anweisung geben auf diese Events zu "lauschen".
Nun fehlen aber noch die Funktionen selbst.
-
Damit sich die Schlange in die Richtung bewegt, die gedrückt wurde, muss sie nun noch ihre Position verändern. Eine Position wird durch zwei Zahlen angegeben, die x-Koordinate (die sich ändert bei der Bewegung von links nach rechts) und die y-Koordinate (die sich ändert bei der Bewegung von oben nach unten).
Wir müssen uns also zunächst die aktuelle x- und y-Koordinate merken, damit wir sie dann mit der Schrittlänge hoch oder runterzählen können.
x=Snake.xcor() und y=Snake.ycor()
Auch die Änderung der Position werden wir wieder in einer eigenen Funktion schreiben.
Da man bei diesem Spiel natürlich nicht nur einmal eine Pfeiltaste drückt, sondern immer wieder, wirst du eine Schleife verwenden, die das Spielfeld mit der Position der Schlange immer wieder neu zeichnet. Das Zeichnen des Spielfeldes haben wir bereits Spielfeld.update(). Diese Anweisung muss nun in eine Schleife und unsere Funktion zur Bewegung der Schlange kommt dazu:
Das Programm sieht somit wie folgt aus:
-
-
Die Schlange kann nun über das Spielfeld bewegt werden (sogar über die Spielfeldränder hinaus, aber darum kümmern wir uns später). Bei so viel Bewegung wird die Schlange irgendwann hungrig und braucht Futter. Unter "Futter" verstehen wir Objekte, die auf dem Spielfeld erscheinen. Die Schlange soll dann das Futter "fressen", indem sie auf die Futterposition gesteuert wird.
-
Auch Futter ist ein Turtle()-Objekt im Spiel, so wie der Schlangenkopf.
Zu Beginn des Programms wird es mit Futter = t.Turtle() erstellt. Wie bei der Schlange auch gibt es eine Funktion initFutter(), mit der die Eigenschaften vom Futter (Farbe, Aussehen, Position) festgelegt wird.
Statt eines Quadrates als Futter kannst du auch eine Schildkröte anzeigen lassen mit der Futter.shape("turtle"). Es ist aber auch möglich die Schlange Blätter fressen zu lassen. Die Form dafür muss man sich jedoch selbst erzeugen.
Die Form des Blattes wird mittels Koordinaten (x, y) erzeugt, dafür wird ein Tuple mit Koordinatenpunkten genutzt. In meinem Codebeispiel werden diese Koordinaten in die Variable blatt_koerper geschrieben.
Anschließend wird die Form anhand der Koordinaten erzeugt mit t.register_shape('Bezeichnung', Liste mit Koordinaten), damit die Form aufgerufen werden kann, benötigt sie eine Bezeichnung. Ich habe sie in meinem Beispiel blatt genannt. Nun folgt der Aufruf der Form mit shape('blatt').Hier ein Beispiel dafür:
Folgend das Anlegen des Futter-Objektes und dessen erster Aufruf.
Wenn wir unsere Programm nun ausprobieren. Lässt sich die Schlange bewegen und das Futter ist sichtbar, aber das Futter verschwindet noch nicht, wenn die Schlange das Futter erreicht.
-
Wir müssen in unserer while-Schleife noch eine Prüfung bzw. Bedingung einfügen. Wenn die Schlange und das Futter die gleiche Position haben, soll das Futter mit hideturtle() versteckt werden bzw. verschwinden .
-
Das Futter soll ja eigentlich nicht wirklich verschwinden, sondern irgendwo anders auf dem Spielfeld neu erscheinen. Dafür brauchst du Zufallszahlen.
Für Zufallszahlen musst du ganz oben im Programmcode ein zweites Modul importieren, das random-Modul. Ergänze deinen Import in deinem Programm mit der Zeile:
Angenommen, die neue Futterposition hat die Koordinaten fx und fy. Dann kannst du mit Futter.setposition(fx, fy) die Futterkoordinaten neu setzen. Um nun eine passende zufällige Zahl für fx und fy zu erhalten, hilft uns die Funktion randrange(unterGrenze, oberGrenze, Schrittweite). Sie gibt die eine Zufallszahl zwischen den beiden Werten, die du für die unterGrenze und die oberGrenze einsetzt. Die Schrittweite ist ausgehend von der unterGrenze und kann die Zahlen eingrenzen.
Beispiel: randrange(-4, 8, 2) Es sind Zahlen zwischen -4 und 8, bei 2er-Schritten bleiben nur noch die Zahlen -2, 0, 2, 4, 6 und 8 übrig.
Die Schrittweite ist wichtig, da unsere Schlange sich in 20er-Schritten bewegt. Würde das Futter dazwischen auftauchen, würde die Schlange es niemals erreichen. Wir brauchen für die Futterposition also ebenfalls eine Schrittweite von 20 Pixeln.
Wenn wir die Zufallsposition in unsere Programm integrieren, brauchen wir das Futter nicht mehr verstecken. Der Programmabschnitt sieht dann wie folgt aus:
-
-
Zum Abschluss erstellst du nun noch die Texte.
-
Auch die Punkteausgabe ist ein Turtle()-Objekt im Spiel, so wie der Schlangenkopf oder das Futter.
Zu Beginn des Programms wird es mit Anzeige = t.Turtle() erstellt. Wie bei der Schlange oder dem Futter gibt es eine Funktion initAnzeige(), mit der die Eigenschaften der Punkteausgabe (Farbe, Schriftart, Schriftgröße, Position) festgelegt wird.
In der Funktion initAnzeige() geben wir die Textfarbe an, verstecken das Turtlesymbol und heben den "Stift" an, damit nicht ungewollte Linien entstehen.
Die beiden Befehle Anzeige.setposition(-Breite/2+40, Hoehe/2-40) und Anzeige.write("Punkte: "+str(Punkte), font=("Courier", 14, "bold")) hatten wir bislang noch nicht verwenden, lassen sich von ihrem Wortlaut her jedoch leicht ableiten.
setposition(x, y) ist für die Position der Punkteausgabe auf dem Spielfeld.Um nun unseren Wert an die Höhe und Breite unseres Spielfeldes auszurichten übergeben wir der Funktion initAnzeige() die Parameter Breite und Höhe -> initAnzeige(Breite, Hoehe)
Mit write("Ausgabetext", font=("Schriftart", Schriftgröße, "Schrifttyp")) schreiben wir den Text. Dabei gibt man als erstes den eigentlichen Text in Anführungsstrichen an. Im Spiel setzt sich dieser aus dem Wort Punkte: und der Punktzahl zusammen.
"Punkte: "+str(Punkte)
Mit einem Komma getrennt folgt danach die Einstellung der Schrift.
font=("Courier", 14, "bold")
Dabei gibt man in Anführungsstrichen eine Schriftart an, gefolgt von der Zahl für die Schriftgröße, sowie die Schrifttyp
normal = "normal"
fett = "bold"
kursiv = "italic"Für write() gibt es auch noch die Eigenschaften move und align. Da diese in dem Spiel nicht verwendet werden verzichte ich an dieser Stelle auf nähere Erklärungen.
Da sich die Punktzahl im Laufe des Spiels ändert, muss sie auch aktualisiert werden. Dafür legen wir eine neue Funktion an updateAnzeige().
In dieser Funktion leeren wir die bisherige Anzeige mit dem Befehl clear() und anschließend schreiben wir den neuen Punktestand auf mit dem Befehl write("Punkte: "+str(Punkte), font=("Courier", 14, "bold")), so wie wir den Befehl auch schon bei der Initalisierung verwendet haben.Zum Schluss muss die Funktion updateAnzeige() in die Schleife integriert werden, damit auf während des Spiels der Punktestand aktualisiert wird.
-
