Differences

This shows you the differences between two versions of the page.

--- lehrkraefte:snr:informatik:glf22:python:snake [2023/01/27 06:04] – [Aufgabe: Ein Snake-Programm in Grundzügen verstehen] Olaf Schnürer
+++ lehrkraefte:snr:informatik:glf22:python:snake [2023/02/14 19:01] (current) – [Richtung Snake: Listen in Python] Olaf Schnürer
@@ Line 1: / Line 1: @@
+~~NOTOC~~
+Online programmieren über dieses trinket... funktioniert nicht sinnvoll: Tastendrücke werden nicht (oder sehr spät) erkannt, f-strings klappen nicht (was nicht so schlimm wäre), Grösse des Spielfeldes muss man anpassen, damit alles angezeigt wird. Letzteres Problem auch bei manch kleinem Laptop-Bildschirm.
+==== Eventuelle Nachträge ====
+  * (2aLIM): [[lehrkraefte:snr:informatik:glf22:python:simulationen:ziegenproblem|Simulation des Ziegenproblems]]
+  * [[lehrkraefte:snr:informatik:glf22:python:simulationen:erwartungswerte-mathematisch|Mathematische Begrüdung für die durchschnittliche Wurfanzahl, bis zwei Sechser direkt hintereinander kommen]]
+====== Pygame: a ball game and snake ======
+Pygame ist eine Python-Library zur Spiele-Programmierung.
+Ziele dieses Abschnitts:
+  * einen groben Eindruck bekommen, wie ein Snake-Programm in Python funktioniert.
+Selbst solch ein Programm zu schreiben ist deutlich schwieriger und braucht vor allem viel Übung im Programmieren.
+===== Aufgabe: A ball game - grobes Verstehen (und Korrigieren) eines Python-Programms =====
+<WRAP center round todo>
+Hist ist ein Link zu einem in ''pygame'' programmierten Spiel (bitte nur kurz ausprobieren).
+  * [[lehrkraefte:snr:informatik:glf22:python:snake:ballgame-fehlerhaftes-programm|Link zum Programm ''ball-game-zu-verbessern.py'']]
+<hidden Falls das Programm bei dir nicht läuft:>
+<WRAP center round info box>
+Es könnte sein, dass pygame nicht installiert ist: Installation mit ''pip install pygame'' in der "command line"/"cmd"/Eingabeaufforderung/Befehlszeile.
+Alternativ kannst du online programmieren:
+    * Programmiere online: https://trinket.io/features/pygame
+Lösche das Programm dort und ersetze es durch das Programm "ball-game.py".
+Die Tastatursteuerung ist online wohl etwas langsam.
+</WRAP>
+</hidden>
+----
+<WRAP center round box>
+Der Spieler (grünes Quadrat) gewinnt ein Leben, wenn er den purpurfarbenen Ball fängt, und verliert zwei Leben, wenn der Ball an der rechten Seite des Spielfeldrandes reflektiert wird. Man startet am Anfang mit 10 Leben, gewinnt bei 20 Leben und verliert bei 0 Leben.
+</WRAP>
+Das grüne Quadrat wird mit den Pfeiltasten gesteuert, jedoch hat der Programmierer dies nicht wie erwünscht hinbekommen.
+Auch bewegt sich der Ball nicht wie beabsichtigt.
+<WRAP center round box>
+Die gewünschte Steuerung mit den Pfeiltasten ist wie folgt.
+  * Jedes Drücken einer Pfeiltaste bewegt das Quadrat um ein Feld in die entsprechende Richtung, mit folgenden Ausnahmen:
+  * Das Quadrat kann das Spielfeld rechts und links nicht verlassen und stösst dort an die Ränder an.
+  * Wenn es das Spielfeld oben verlässt, kommt es sofort an derselben x-Koordinate unten in das Spielfeld und umgekehrt.
+</WRAP>
+<WRAP center round box>
+Erwünschte Bewegung des Balls:
+  * An allen Seiten des Spielfelds ausser der linken soll der Ball normal reflektiert werden.
+  * An der linken Seite soll das bereits programmierte zufällige Verhalten bestehen bleiben.
+</WRAP>
+Beachte: Für die folgenden Aufgaben musst du nur einen geringen Teil des Programms verstehen! Was du wissen musst, ist jeweils in den Hinweisen erläutert.
+<WRAP center round box>
+=== Teilaufgabe 1 ===
+Hilf dem Programmierer, die gewünschte Steuerung mit den Pfeiltasten zu erreichen (dabei sollst du den Ball vollständig ignorieren, es geht nur um das grüne Quadrat).
+  * (1) Kümmere dich darum, dass jede der vier Pfeiltasten das Quadrat um genau ein Feld in die gewünschte Richtung bewegt.
+  * (2) Kümmere dich darum, dass das Quadrat nicht aus dem Spielfeld verschwindet, sondern das oben beschriebene Verhalten zeigt.
+Dafür musst du nur etwa 20 Zeilen ab Zeile 176 ändern, das gesamte restliche Programm bleibt unverändert (vgl. Kommentar in Zeile 173).
+<hidden Hinweise>
+<WRAP center round box>
+Die gesamte ''if-elif-...''-Struktur kann unverändert bleiben.
+Die y-Achse des "Spielfeld-Koordinatensystems" zeigt nach **unten**! Der Ursprung des Koordinatensystems ist in der linken oberen Ecke des Spielfeldes.
+Die aktuelle Position des grünen Quadrats ist in der Variablen ''spieler'' gespeichert:
+  * ''spieler.x'' ist seine $x$-Koordinate,
+  * ''spieler.y'' ist seine $y$-Koordinate.
+Überlege zuerst, wie du diese Koordinaten bei den jeweiligen Pfeiltasten verändern musst.
+Für das gewünschte Verhalten an den Rändern des Spielfelds:
+Die Koordinaten des Spielfelds gehen in
+  * $x$-Richtung von ''0'' bis ''MAXX'' und in
+  * $y$-Richtung von ''0'' bis ''MAXY''.
+</WRAP>
+</hidden>
+</WRAP>
+<WRAP center round box>
+=== Teilaufgabe 2 ===
+Hilf dem Programmierer, das gewünschte Reflexionsverhalten des Balles zu erreichen.
+Dafür musst du nur etwa 10 Zeilen ab Zeile 220 anpassen, das gesamte restliche Programm bleibt unverändert (vgl. Kommentar in Zeile 217 - Zeilenangaben beziehen sich auf das "Originalprogramm").
+<hidden Hinweis>
+<WRAP center round box>
+Beobachte zuerst genau, an welchen der drei Spielfeldränder (oben, rechts, unten) das Reflexionsverhalten falsch ist.
+Die ''if''-Bedingungen können und sollen so stehen bleiben.
+Die aktuelle Position des Balls ist in der Variablen ''ball'' gespeichert:
+  * ''ball.x'' ist seine $x$-Koordinate,
+  * ''ball.y'' ist seine $y$-Koordinate.
+Während des Spielablaufs wird die sogenannte "game loop" (beginnend in Zeile 140 und endend in Zeile 236) immer wieder durchlaufen (ca. 40 Mal pro Sekunde).
+Die Variable ''bewegungsrichtung_ball'' hat ebenfalls zwei Komponenten:
+  * ''bewegungsrichtung_ball.x'' ist seine x-Koordinate,
+  * ''bewegungsrichtung_ball.y'' ist seine y-Koordinate.
+In jedem Durchlauf der "game loop" wird (in Zeile 215) dieser Vektor zur Position ''ball'' des Balls hinzuaddiert ($x$-Koordinate zu $x$-Koordinate, $y$-Koordinate zu $y$-Koordinate, wie bei der Addition von Kräften in der Physik bzw. der Vektoraddition in der Mathematik). Deswegen wirkt die Bewegung des Balls kontinuierlich.
+Passe nun jeweils die Zeilen nach den drei ''if''-Zeilen an; zwei Programm-Zeilen können eingespart werden.
+</WRAP>
+</hidden>
+</WRAP>
+<WRAP center round box>
+=== Teilaufgabe 3 ===
+Schau dir zuerst die "game loop" (Zeilen 140 bis 236) und dann das Hauptprogamm (beginnend in Zeile 120) an und versuche, möglichst viel zu verstehen. Wer will, kann sich natürlich auch den Rest des Programms anschauen.
+</WRAP>
+<WRAP center round box>
+=== Teilaufgabe 4 ===
+Viel Spass beim Spielen! Mit der nun einfacheren Bedienung hat man bessere Gewinnchancen! - Aber bitte nicht zu lange spielen.
+</WRAP>
+=== Bonusaufgaben ===
+(teilweise vielleicht auch eine gute Idee, diese in Zukunft einzubauen)
+  * Steuere eine zweite farbige Box mit den Tasten ''a'', ''s'', ''d'', ''w''. Was passiert bei einer Kollision der beiden Spieler?
+  * Ändere die Steuerung (vermutlich nicht so leicht; braucht u.a. ''KEYUP'' als mögliches key event):
+    * Wenn man auf einer Pfeiltaste bleibt, bewegt sich das grüne Quadrat immer weiter in die entsprechende Richtung.
+    * Das Quadrat bewegt sich kontinuierlich (ähnlich wie der Ball). Das Drücken einer Pfeiltaste ändert die Richtung. (Diese Art der Steuerung werden wir bei Snake verwenden.)
+</WRAP>
+===== Richtung Snake: Listen in Python =====
+<WRAP center round info box>
+Um Snake zu programmieren, kommt man kaum um Listen herum, denn die Positionen, an denen sich die "Körperglieder" der Schlange befinden, speichert man sinnvollerweise in einer solchen Liste.
+In gewisser Weise kommen wir hier an's Ende des Programmierkurses: Neben den Kontrollstrukturen (if-statements für Bedingungen, for- und while-Schleifen für Wiederholungen, Funktionen) sind beim Programmieren Datentypen und Datenstrukturen (wie Listen) essentiell. Wer das bisher erklärte kennt, kann mit etwas Übung eigentlich alles programmieren.
+</WRAP>
+Statt auf den Abschnitt [[lehrkraefte:snr:informatik:glf22:python:listen|Listen]] des Programmierkurses über Listen zu verweisen, erkläre ich hier direkt, was für Snake nötig ist.
+<hidden Das hier verborgene Programm enthält alles über Listen, was in Snake benötigt wird>
+Per Python-Shell erklären oder direkt das Programm laufen lassen, am besten mit Breakpoint ganz am Anfang.
+<code python listen-demo.py>
+# Beispiel 1:
+# Top 5 der Vornamen in der italienischen Schweiz 2021 laut BFS, https://babynames-stat.ch/de/index.html
+namensliste = ['Leonardo', 'Alessandro', 'Liam', 'Noah', 'Tommaso']
+print(namensliste)
+print(namensliste[3])
+print(namensliste[0])
+namensliste[3] = 'Urs'
+print(namensliste)
+print("Liam" in namensliste)
+print("Luca" in namensliste)
+print(len(namensliste))
+for name in namensliste:
+    print('Mi chiamo ' + name + '.')
+namensliste.insert(0, 'Nathan')
+print(namensliste)
+namensliste.insert(3, 'Ephraim')
+print(namensliste)
+namensliste.pop()
+print(namensliste)
+namensliste.pop(2)
+print(namensliste)
+print(namensliste[1:3])
+# Beispiel 2:
+notenliste=[1, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1]
+summe = 0
+for note in notenliste:
+    summe = summe + note
+print(summe / len(notenliste))
+# Beispiel 3:
+from random import *
+liste_der_wuerfe = []
+while liste_der_wuerfe[0:2] != [0, 0]:
+    liste_der_wuerfe.insert(0, randrange(2))
+    print(liste_der_wuerfe)
+</code>
+</hidden>
+----
+Ausserdem sollte man verstehen, warum eine Liste die naheliegende Datenstruktur für Snake ist (verbale Erklärung mit Snake-Beispielprogramm, anhalten mit Leertaste, Liste wird unten angezeigt).
+<hidden Tafelfoto dazu>
+{{lehrkraefte:snr:informatik:glf22:python:snake-mit-listen.jpg}}
+</hidden>
+===== Aufgabe: Ein Snake-Programm in Grundzügen verstehen =====
+<WRAP center round todo>
+Hist ist ein Link zu einem in ''pygame'' programmierten snake-ähnlichen Spiel.
+(Zusammen die per ''## GEMEINSAM ANSCHAUEN:'' markierten Stellen anschauen: An diesen Stellen wird eine Liste namens ''schlange'' verwendet, um die aktuellen Positionen der Schlangenquadrate zu speichern.)
+  * [[lehrkraefte:snr:informatik:glf22:python:snake:snake-zu-verbessern|Link zum Programm ''snake-zu-verbessern.py'']]
+Korrigiere dieses Programm, so dass es dem üblichen Snake ähnelt:
+  * Statt mit den Tasten ''r'', ''t'', ''f'', ''g'' soll die Steuerung wie gewohnt mit den Pfeiltasten funktionieren.
+  * Wenn die Schlange einen Apfel frisst, soll die unter dem Spielfeld angezeigte Variable ''gefressene_aepfel'' um eins erhöht werden.
+  * Pro gefressenem Apfel soll die Länge der Schlange um eins wachsen.
+  * Wenn die Schlange gegen eine der vier Wände des Spielfelds läuft, endet das Spiel.
+  * Färbe den Kopf der Schlange in einer anderen Farbe, damit man weiss, wo er ist.
+Hinweis: Es sind nur wenige Änderungen innnerhalb der "game loop" (ab Zeile 171) nötig.
+<hidden Für diejenigen, die Online programmieren (da dort f-strings wohl nicht funktionieren; hier sind noch diverse auskommentierte Sachen einzukommentieren - bitte mich fragen; erfahrungsgemäss ist die Tastatureingabe online so langsam, dass es keinen Spass macht.):>
+<code python snake-zu-verbessern-fuer-online>
+import pygame
+from pygame.locals import *
+from random import *
+# Geschwindigkeit des Spiels bzw. genauer
+# Frequenz, mit der das Spielfeld neu gezeichnet wird.
+FRAMES_PER_SECOND_AM_ANFANG = 7
+VERGROESSERUNG_PRO_APFEL = 0.5
+# Das Spielfeld besteht aus kleinen rechteckigen Boxen mit Koordinaten
+# 0 bis MAXX (jeweils einschliesslich) in x-Richtung und
+# 0 bis MAXY (jeweils einschliesslich) in y-Richtung.
+# Achtung: y-Achse zeigt nach unten (wie Zeilennummern)
+MAXX = 24
+MAXY = 15
+# Festlegung von Breite und Höhe einer Box in Pixel.
+# Meist sind Breite und Höhe gleich, was quadratische Boxen liefert.
+SEITENLAENGE_BOX = 40
+# Es geht auch mit Bildern (Hintergrund, Apfel, Schlangenkopf)
+# und Sound (Crash bzw. Game over).
+# Suche dafür geeignete Dateien und speichere diese am besten
+# in demselben Verzeichnis wie dieses Programm.
+# In der Funktion ''lade_bilder_und_sound'' musst du
+# dann die Namen deiner Dateien (evtl. inklusive Pfad) angeben.
+BOXEN_STATT_BILDER = True
+EINFARBIGER_HINTERGRUND = True
+MIT_SOUND = False
+# Ab hier Konstanten, die von den obigen abhängen.
+ANZAHL_BOXEN_X = MAXX + 1
+ANZAHL_BOXEN_Y = MAXY + 1
+FENSTER_BREITE = ANZAHL_BOXEN_X * SEITENLAENGE_BOX
+FENSTER_HOEHE = ANZAHL_BOXEN_Y * SEITENLAENGE_BOX
+PLATZ_FUER_TEXT = 5 * SEITENLAENGE_BOX
+# Farben per Rot-, Grün- und Blauwert
+# (jeweils auf Skala von 0 bis 255).
+# Wer will, kann hier zusätzliche eigene Farben festlegen.
+#             rot  grün  blau
+ROT     =    (255,    0,    0)
+GRUEN   =    (  0,  255,    0)
+BLAU    =    (  0,    0,  255)
+GELB    =    (255,  255,    0)
+MAGENTA =    (255,    0,  255)
+CYAN    =    (  0,  255,  255)
+WEISS   =    (255,  255,  255)
+SCHWARZ =    (  0,    0,    0)
+HELLGRAU =   (80,  80,  80)
+DUNKELGRAU = (160,  160,  160)
+HINTERGRUND_FARBE = SCHWARZ
+# HINTERGRUND_FARBE = HELLGRAU
+#
+# Definition der Klasse Punkt. Bitte einfach akzeptieren.
+#
+class Punkt:
+    def __init__(self, x, y):
+        self.x = x
+        self.y = y
+    def __str__(self):
+        return '(' + str(self.x) + ',' + str(self.y) + ')'
+    def __repr__(self):
+        return '(' + str(self.x) + ',' + str(self.y) + ')'
+    def __eq__(self, other):
+        return self.x == other.x and self.y == other.y
+    def __add__(self, other):
+        return Punkt(self.x + other.x, self.y + other.y)
+    def __hash__(self):
+        return hash(str(self))
+#
+# Ende der Definition der Klasse Punkt.
+#
+def zeichne_box(p, farbe):
+    rechteck = pygame.Rect(p.x * SEITENLAENGE_BOX + 1, p.y * SEITENLAENGE_BOX + 1, SEITENLAENGE_BOX - 1, SEITENLAENGE_BOX - 1)
+    pygame.draw.rect(leinwand, farbe, rechteck)
+def zeichne_gitter():
+    for x in range(ANZAHL_BOXEN_X + 1):
+        pygame.draw.line(leinwand, HELLGRAU, (x * SEITENLAENGE_BOX, 0), (x * SEITENLAENGE_BOX, FENSTER_HOEHE))
+    for y in range(ANZAHL_BOXEN_Y + 1):
+        pygame.draw.line(leinwand, HELLGRAU, (0, y * SEITENLAENGE_BOX), (FENSTER_BREITE, y * SEITENLAENGE_BOX))
+def schreibe(x, y, text, groesse):
+    schrift = pygame.font.SysFont('freemono', round(groesse * SEITENLAENGE_BOX))
+    formatierter_text = schrift.render(text, True, WEISS, SCHWARZ)
+    rechteck = formatierter_text.get_rect()
+    rechteck.center = (round((x + 0.5) * SEITENLAENGE_BOX), round((y + 0.5) * SEITENLAENGE_BOX))
+    leinwand.blit(formatierter_text, rechteck)
+def schreibe_transparent(x, y, text, groesse):
+    schrift = pygame.font.SysFont('freemono', round(groesse * SEITENLAENGE_BOX))
+    formatierter_text = schrift.render(text, True, SCHWARZ)
+    rechteck = formatierter_text.get_rect()
+    rechteck.center = (round((x + 0.5) * SEITENLAENGE_BOX), round((y + 0.5) * SEITENLAENGE_BOX))
+    if rechteck.x >= 0 and rechteck.y >= 0:
+        text_flaeche = pygame.Surface((rechteck.x, rechteck.y))
+        text_flaeche.fill(WEISS)
+        text_flaeche.blit(formatierter_text, rechteck)
+        text_flaeche.set_alpha(50)
+        leinwand.blit(formatierter_text, rechteck)
+def neue_apfelposition():
+    a = Punkt(randrange(0, MAXX + 1), randrange(0, MAXY + 1))
+    while a in schlange:
+        a = Punkt(randrange(0, MAXX + 1), randrange(0, MAXY + 1))
+    return a
+def lade_bilder_und_sound():
+    global hintergrundbild, bild_kopf_der_schlange, bild_apfel, apfel_ess_sound, crash_sound
+    if not EINFARBIGER_HINTERGRUND:
+        hintergrundbild = pygame.image.load('landschaft.jpg')
+        hintergrundbild = pygame.transform.scale(hintergrundbild, (FENSTER_BREITE, FENSTER_HOEHE))
+    if not BOXEN_STATT_BILDER:
+        bild_apfel = pygame.image.load('apple.svg')
+        bild_apfel = pygame.transform.scale(bild_apfel, (SEITENLAENGE_BOX, SEITENLAENGE_BOX))
+        bild_kopf_der_schlange = pygame.image.load('Excited-Smiley-Face.svg')
+        bild_kopf_der_schlange = pygame.transform.scale(bild_kopf_der_schlange, (SEITENLAENGE_BOX, SEITENLAENGE_BOX))
+    if MIT_SOUND:
+        crash_sound = pygame.mixer.Sound('mixkit-funny-game-lose-tone-2877.wav')
+        apfel_ess_sound = pygame.mixer.Sound('mixkit-video-game-retro-click-237.wav')
+def zeige_bild(bild, p):
+    rechteck = pygame.Rect(p.x * SEITENLAENGE_BOX + 1, p.y * SEITENLAENGE_BOX + 1, SEITENLAENGE_BOX - 1, SEITENLAENGE_BOX - 1)
+    leinwand.blit(bild, rechteck)
+pygame.init()
+uhr = pygame.time.Clock()
+leinwand = pygame.display.set_mode((FENSTER_BREITE + 1, FENSTER_HOEHE + 1 + PLATZ_FUER_TEXT))
+pygame.display.set_caption('Snake game')
+lade_bilder_und_sound()
+# Initialisiere die Liste, deren Einträge die Koordinaten der Quadrate der Schlange sind.
+# Der 0-te Eintrag enhält die Position des Kopfes der Schlange.
+laenge = 4
+#I schlange = [Punkt(4, 7), Punkt(3, 7), Punkt(2, 7), Punkt(1, 7)]
+# Oder besser, da abhängig von der Variablen "länge"
+schlange = []
+for i in range(laenge):
+    schlange.insert(0, Punkt(1 + i, MAXY // 2))
+# Und noch besser bzw. kürzer geht das so:
+# schlange = [Punkt(laenge - i, MAXY // 2) for i in range(laenge)]
+farbe_schlange = GRUEN
+# Änderung der Spielerposition pro Spielzyklus:
+bewegungsrichtung = Punkt(0, 0)
+# Hilfsvariablen, anfangs am besten ignorieren.
+neue_richtung = bewegungsrichtung
+richtung_vor_stopp = Punkt(0, 0)
+# Initialisiere Apfelposition (nicht auf Schlange!) und Farbe.
+apfel = neue_apfelposition()
+farbe_apfel = ROT
+# Initialisierung der "Spielvariablen"
+frames_per_second = FRAMES_PER_SECOND_AM_ANFANG
+spiel_aktiv = True
+crash = False
+gefressene_aepfel = 0
+# Hier startet die "game loop".
+while spiel_aktiv:
+    # Graphische Darstellung des Spielgeschehens:
+    # Hintergrund
+    if EINFARBIGER_HINTERGRUND:
+        leinwand.fill(HINTERGRUND_FARBE)
+    else:
+        leinwand.fill(HINTERGRUND_FARBE)
+        leinwand.blit(hintergrundbild, (0, 0))
+    # Ausgabe diverser Zahlen unter dem Spielfeld
+    schreibe(MAXX // 4, MAXY + 1, 'apple count: ' + str(gefressene_aepfel), 0.8)
+    schreibe(3 * MAXX // 4, MAXY + 1, 'length: ' + str(laenge), 0.8)
+    schreibe(MAXX // 4, MAXY + 2, 'apple: ' + str(apfel), 0.8)
+    schreibe(3 * MAXX // 4, MAXY + 2, 'current length: ' + str(len(set(schlange))), 0.8)
+    schreibe(MAXX // 4, MAXY + 3, 'head of snake: ' + str(schlange[0]), 0.8)
+    schreibe(3 * MAXX // 4, MAXY + 3, 'frames per second: ' + str(frames_per_second), 0.8)
+    text = str(schlange)
+    schreibe(MAXX // 2, MAXY + 4, text, 0.6)
+    schreibe(MAXX // 2, MAXY + 5, 'Space key: pause game', 0.8)
+    # Raster zeichnen
+    zeichne_gitter()
+    # Apfel zeichnen
+    if BOXEN_STATT_BILDER:
+        zeichne_box(apfel, farbe_apfel)
+        schreibe_transparent(apfel.x, apfel.y , str(apfel), 0.25)
+    else:
+        zeige_bild(bild_apfel, apfel)
+        schreibe_transparent(apfel.x, apfel.y , str(apfel), 0.25)
+    # Schlange zeichnen
+    for element in schlange:
+        zeichne_box(element, farbe_schlange)
+        schreibe_transparent(element.x, element.y , str(element), 0.25)
+    if not BOXEN_STATT_BILDER:
+        zeige_bild(bild_kopf_der_schlange, schlange[0])
+        schreibe_transparent(schlange[0].x, schlange[0].y , str(schlange[0]), 0.25)
+    # Alles bis jetzt "versteckt" Gezeichnete sichtbar machen.
+    pygame.display.update()
+    uhr.tick(frames_per_second)
+    # Verarbeitung von Tastatureingaben:
+    for ereignis in pygame.event.get():
+        if ereignis.type == QUIT:
+            print("Button zum Schliessen des Pygame-Fensters angeklickt.")
+            spiel_aktiv = False
+        elif ereignis.type == KEYDOWN:
+            if ereignis.key == K_ESCAPE:
+                print("Escape-Taste gedrückt.")
+                spiel_aktiv = False
+            elif ereignis.key == K_q:
+                print("Taste 'q' gedrückt.")
+                spiel_aktiv = False
+            elif ereignis.key == K_SPACE:
+                print("Leer-Taste gedrückt.")
+                if bewegungsrichtung != Punkt(0, 0):
+                    richtung_vor_stopp = bewegungsrichtung
+                    bewegungsrichtung = Punkt(0, 0)
+                else:
+                    bewegungsrichtung =richtung_vor_stopp
+            else:
+                if ereignis.key == K_r:
+                    print("Pfeiltaste links gedrückt.")
+                    neue_richtung = Punkt(-1, -1)
+                elif ereignis.key == K_f:
+                    print("Pfeiltaste rechts gedrückt.")
+                    neue_richtung = Punkt(-1, 1)
+                elif ereignis.key == K_t:
+                    print("Pfeiltaste hoch gedrückt.")
+                    neue_richtung = Punkt(1, -1)
+                elif ereignis.key == K_g:
+                    print("Pfeiltaste runter gedrückt.")
+                    neue_richtung = Punkt(1, 1)
+                # Die folgende if-Bedingung verhindert, dass die
+                # Snake die Richtung umkehren kann (und mit sich selbst kollidiert).
+                if schlange[1] != schlange[0] + neue_richtung:
+                    bewegungsrichtung = neue_richtung
+    # Bewegen der Schlange:
+    if bewegungsrichtung != Punkt(0, 0):
+        # Falls die Schlange die gewünschte Länge hat:
+        # Beseitige das letzte Element aus der Liste "schlange".
+        if len(schlange) == laenge:
+            schlange.pop()
+        # Neues Feld, auf das sich die Schlange bewegt:
+        neue_position = schlange[0] + bewegungsrichtung
+        # Verhalten am Spielfeldrand:
+        if neue_position.x < 0:
+            neue_position.x = MAXX
+        if neue_position.x > MAXX:
+            neue_position.x = 0
+        if neue_position.y < 0:
+            neue_position.y = MAXY
+        if neue_position.y > MAXY:
+            neue_position.y = 0
+        # Selbstkollision:
+        if neue_position in schlange:
+            crash = True
+            spiel_aktiv = False
+            if MIT_SOUND:
+                pygame.mixer.Sound.play(crash_sound)
+        else:
+            # Hänge die neue Position vorne an die Liste "schlange".
+            schlange.insert(0, neue_position)
+            # Apfel erreicht?
+            if neue_position == apfel:
+                gefressene_aepfel = 1
+                if MIT_SOUND:
+                    pygame.mixer.Sound.play(apfel_ess_sound)
+                laenge = laenge * 2
+                frames_per_second = frames_per_second + VERGROESSERUNG_PRO_APFEL
+                apfel = neue_apfelposition()
+# Ende der game loop.
+# Nach Abbruch oder Crash:
+if crash:
+    schreibe(MAXX // 2, MAXY // 2, 'GAME OVER', 2)
+    schreibe(MAXX // 2, MAXY // 2 + 3, 'press any key', 1)
+    pygame.display.update()
+    pygame.time.delay(500)
+    for ereignis in pygame.event.get():
+        pygame.time.delay(100)
+    while pygame.event.get() == []:
+        pygame.time.delay(100)
+pygame.quit()
+exit()
+</code>
+</hidden>
+</WRAP>
+<WRAP center round todo>
+Überlege dir, wie man das Spiel weiterentwickeln könnte. Verstehe das Programm dazu möglichst gut bzw. wenigstens so weit wie nötig.
+<hidden einige Ideen>
+  * Füge ein Hindernis ein: Die Schlange stirbt, wenn sie dagegen fährt. Das Hindernis könnte sich auch bewegen (hin und her oder gar Richtung Schlange).
+  * Programmiere eine zweite Schlange, die sich etwa mit den Tasten ''a'', ''s'', ''d'', ''w'' steuern lässt, so dass ihr gegeneinander spielen könnt (Achtung, das ''q'' für den Abbruch ist gefährlich nah an diesen Tasten.) Wer verschlingt mehr Äpfel? Zeige den jeweiligen Punktestand an. Was passiert und wer ist schuld, wenn es eine Kollision gibt? Endet das Spiel oder muss man einen Apfel abgeben oder wird man länger/kürzer? Vielleicht gibt es auch gar keine Äpfel mehr und es geht nur darum, den Gegner zu einer Kollision zu zwingen. Eventuell mehrere Runden hintereinander spielen.
+  * Die Schlange benötigt Energie für's Herumschleichen; zum Beispiel könnte sie alle 100 Schritte einen Apfel verlieren.
+  * Statt einem Apfel könnte es mehrere Äpfel geben (die nur eine begrenzte Zeit lang existieren). Hier wäre es vermutlich sinnvoll, eine Liste mit den aktuellen Apfelpositionen zu verwenden.
+  * Es könnte auch mehrere Hindernisse geben oder mehrere Schlangen.
+  * Verschiedene Level einführen.
+Schwieriger:
+  * Sprites
+  * gleichmässige Bewegung
+  * Kopf der Schlange (also geeignetes Bild) zeigt in Laufrichtung
+  * Schlange schlanker (also Rechtecke statt Quadrate mit richtig gekrümmten Abbiegefeldern)
+  * Spielen übers Netzwerk?
+</hidden>
+</WRAP>
+=== ... wenn du eigene Bilder oder Sounds integrieren willst ===
+<WRAP center round todo>
+Vorbereitet ist das Programm so, dass du
+  * Bilder für den Hintergrund oder
+  * Bilder für den Apfel und den Schlangenkopf oder
+  * Sounds für Spielende und Apfelfressen
+leicht einbinden kannst (du kannst beispielsweise nur ein Hintergrundbild einbinden).
+Dazu musst du geeignete Dateien bereitstellen (am besten in demselben Verzeichnis wie das Programm) und
+  * in der Funktion ''lade_bilder_und_sound'' die entsprechenden Dateinamen (eventuell inklusive Pfad) angeben und
+  * die booleschen Konstanten ''EINFARBIGER_HINTERGRUND'' (Hintergrund), ''BOXEN_STATT_BILDER'' (Apfel und Schlangenkopf) und ''MIT_SOUND'' (Spielende und Apfelfressen) entsprechend anpassen, d.h. auf ''False'' bzw. ''False'' bzw.''True'' setzen.
+</WRAP>
+===== Link zur Kursseite =====
+[[lehrkraefte:snr:informatik:glf22|Zur Kursseite]]