Differences

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

--- lehrkraefte:snr:informatik:glf22:python:snake [2023/01/27 00:41]
Olaf Schnürer [Aufgabe: Listen in Python]
+++ lehrkraefte:snr:informatik:glf22:python:snake [2023/02/14 20:01] (current)
Olaf Schnürer [Richtung Snake: Listen in Python]
@@ 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 ====
@@ Line 142: / Line 144: @@
 </WRAP>
-===== Aufgabe: Listen in Python =====
+===== Richtung Snake: Listen in Python =====
-<WRAP center round todo>
+<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.
-Aufgabe: Beginne, den Abschnitt [[lehrkraefte:snr:informatik:glf22:python:listen|Listen]] des Programmierkurses über Listen zu lesen. Wer bis zur Modifikation von Listen kommt, weiss mehr, als wir für Snake brauchen werden!
+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 italienschen Schweiz 2021 laut BFS, https://babynames-stat.ch/de/index.html
+# Top 5 der Vornamen in der italienischen Schweiz 2021 laut BFS, https://babynames-stat.ch/de/index.html
-namens_liste = ['Leonardo', 'Alessandro', 'Liam', 'Noah', 'Tommaso']
+namensliste = ['Leonardo', 'Alessandro', 'Liam', 'Noah', 'Tommaso']
-print(namens_liste)
+print(namensliste)
-print(namens_liste[3])
+print(namensliste[3])
-print(namens_liste[0])
+print(namensliste[0])
-print("Liam" in namens_liste)
+namensliste[3] = 'Urs'
-print("Luca" in namens_liste)
+print(namensliste)
-print(len(namens_liste))
+print("Liam" in namensliste)
-for name in namens_liste:
+print("Luca" in namensliste)
+print(len(namensliste))
+for name in namensliste:
     print('Mi chiamo ' + name + '.')
-print(len(namens_liste))
+namensliste.insert(0, 'Nathan')
-namens_liste.insert(0, 'Nathan')
+print(namensliste)
-namens_liste.pop()
+namensliste.insert(3, 'Ephraim')
-print(namens_liste)
+print(namensliste)
-print(namens_liste[2:6])
+namensliste.pop()
+print(namensliste)
+namensliste.pop(2)
+print(namensliste)
+print(namensliste[1:3])
 # Beispiel 2:
@@ Line 174: / Line 185: @@
 for note in notenliste:
     summe = summe + note
-print(f'Durchschnitt = {summe / len(notenliste)}')
+print(summe / len(notenliste))
 # Beispiel 3:
@@ Line 181: / Line 192: @@
 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.
+----
+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 (bitte nur kurz ausprobieren).
+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'']]
@@ Line 199: / Line 217: @@
   * 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>
-==== Bonusaufgaben ====
 <WRAP center round todo>
-Überlege dir, wie man das Spiel weiterentwickeln könnte.
+Ü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 Idee>
+<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.
@@ Line 214: / Line 545: @@
   * 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>