Ein Spiel bauen 🐍

Bis hierher hast du Programme geschrieben, die etwas ausrechnen und dann fertig sind. Ein Spiel ist anders: Es hört nicht auf. Es zeichnet ein Bild, wartet einen Sechzigstel einer Sekunde, rechnet weiter, zeichnet das nächste Bild — sechzigmal pro Sekunde, bis jemand das Fenster schließt.

Genau diese Schleife nimmt dir Pygame Zero ab. Du schreibst nur noch, was in jedem Bild passieren soll.

Eine Ente bringt ihre fünf Küken über den Teich. Auf dem Wasser fahren Boote. Wer erwischt wird, muss zurück und noch einmal los.

Das bauen wir in neun Stufen. Nach jeder Stufe läuft dein Spiel — du kannst also jederzeit aufhören, weiterspielen oder etwas anderes daraus machen. Der vollständige Quelltext steht auf dieser Seite, du musst nichts herunterladen, um mitzulesen.

Was du brauchst

Du brauchst einen Editor auf deinem Rechner — Thonny ist dafür gemacht — und ein zusätzliches Modul. Module sind fertige Lösungen von anderen Leuten, und man installiert sie einmal:

pip install pgzero

In Thonny geht das auch ohne Konsole: Werkzeuge → Verwalte Pakete, dort pgzero suchen und installieren.

Modul

Ein Modul ist eine Sammlung fertiger Funktionen, die jemand anderes geschrieben hat. import holt sie in dein Programm. Fast alles, was Python kann, kommt aus Modulen — und die allermeisten davon musst du erst installieren.

Die drei Bilder

Ab Stufe 4 brauchst du diese drei Bilder. Rechtsklick auf ein Bild → „Bild speichern unter", und zwar in einen Ordner namens images direkt neben deinem Programm. Der Ordner muss genau so heißen, sonst findet Pygame Zero die Bilder nicht.

Bild	Dateiname
	ente.png
	kueken.png
	boot.png

Die drei Bilder sind für dieses Buch gezeichnet worden. Du darfst sie behalten, verändern und in deinen eigenen Spielen benutzen.

Am Ende sieht dein Ordner so aus:

mein-spiel/
├── spiel.py
└── images/
    ├── ente.png
    ├── kueken.png
    └── boot.png

Alles auf einmal herunterladen

Wer die drei Bilder nicht einzeln speichern mag, bekommt hier den fertigen Ordner: das Spiel im Stand von Stufe 9, mit allen Bildern und einer Kurzanleitung.

ente-am-teich.zip

Zum Mitbauen ist das nicht gedacht — darin ist ja schon alles fertig. Praktisch ist es, wenn du sehen willst, wie es laufen soll, oder wenn bei dir etwas klemmt und du vergleichen möchtest.

Stufe 1: Ein Fenster

import pgzrun

WIDTH = 800
HEIGHT = 600

def draw():
    screen.fill((74, 144, 180))

pgzrun.go()

Sechs Zeilen, und schon läuft ein Spiel — es passiert nur noch nichts darin.

WIDTH und HEIGHT schreibt man groß, weil sie sich nie ändern. Pygame Zero liest sie aus und baut danach das Fenster.

Die Funktion draw() rufst du nirgends auf. Das macht Pygame Zero, sechzigmal pro Sekunde. Du legst nur fest, was drinsteht. Die drei Zahlen sind eine Farbe: Rot, Grün, Blau, jeweils von 0 bis 255. (74, 144, 180) ist ein tiefes Teichblau.

Test

Führe das Programm aus. Es muss sich ein blaues Fenster öffnen. Schließe es wieder — Programme mit pgzrun.go() laufen sonst weiter.

Eine andere Farbe?

Probier (20, 40, 90) für einen nächtlichen Teich oder (120, 190, 200) für ein Schwimmbad. Farben zum Aussuchen findest du mit jedem Farbwähler im Netz, zum Beispiel bei w3schools.

Stufe 2: Ufer und Ente

Noch ohne Bilder — Pygame Zero kann selbst zeichnen.

import pgzrun

WIDTH = 800
HEIGHT = 600

# Farben bekommen Namen, damit man den Teich an einer Stelle umfärben kann.
WATER = (74, 144, 180)
SHORE = (110, 170, 90)

# Solange die Ente ein Punkt ist, ist sie nichts weiter als zwei Zahlen.
duck_x = 400
duck_y = 565

def draw():
    screen.fill(WATER)
    screen.draw.filled_rect(Rect(0, 0, 800, 70), SHORE)
    screen.draw.filled_rect(Rect(0, 530, 800, 70), SHORE)
    screen.draw.filled_circle((duck_x, duck_y), 22, (255, 255, 255))

pgzrun.go()

Schau dir den Aufruf genau an, der das obere Ufer zeichnet:

screen.draw.filled_rect(Rect(0, 0, 800, 70), SHORE)

Er bekommt zwei Dinge: ein Rechteck und eine Farbe. Und das Rechteck selbst besteht wieder aus vier Zahlen:

• 0 — wie weit rechts die linke Kante liegt
• 0 — wie weit unten die obere Kante liegt
• 800 — wie breit
• 70 — wie hoch

Englische Namen, deutsche Kommentare

Die Namen im Programm sind englisch — duck, boat, WATER. Fast aller Code, den du je lesen wirst, ist so benannt, und du gewöhnst dich am besten sofort daran. Die Kommentare dagegen schreibst du auf Deutsch: Sie sollen erklären, warum etwas so gebaut ist, und das denkst du nun einmal auf Deutsch.

Nur die Bilddateien behalten ihre deutschen Namen — sie heißen eben so, wie sie heißen.

Wichtig ist die zweite Zahl: y wächst nach unten. Der Punkt (0, 0) ist die obere linke Ecke, nicht die untere. Das ist bei fast allen Bildschirmen so und der Grund, warum das untere Ufer bei y = 530 anfängt und nicht bei 0.

Test

Du solltest zwei grüne Ufer sehen und einen weißen Punkt unten in der Mitte. Der Punkt ist vorerst die Ente.

Verschiebe sie: Ändere duck_x auf 100 und führe das Programm noch einmal aus.

Stufe 3: Die Ente bewegt sich

Bisher gab es nur draw(). Jetzt kommt die zweite Funktion dazu, und der Unterschied zwischen beiden ist das Wichtigste an diesem ganzen Kapitel.

import pgzrun

WIDTH = 800
HEIGHT = 600

# Farben bekommen Namen, damit man den Teich an einer Stelle umfärben kann.
WATER = (74, 144, 180)
SHORE = (110, 170, 90)

# Solange die Ente ein Punkt ist, ist sie nichts weiter als zwei Zahlen.
duck_x = 400
duck_y = 565

def update():
    global duck_x, duck_y

    if keyboard.left:
        duck_x = duck_x - 4
    if keyboard.right:
        duck_x = duck_x + 4
    if keyboard.up:
        duck_y = duck_y - 4
    if keyboard.down:
        duck_y = duck_y + 4

def draw():
    screen.fill(WATER)
    screen.draw.filled_rect(Rect(0, 0, 800, 70), SHORE)
    screen.draw.filled_rect(Rect(0, 530, 800, 70), SHORE)
    screen.draw.filled_circle((duck_x, duck_y), 22, (255, 255, 255))

pgzrun.go()

draw und update

update() rechnet, draw() zeichnet. Beide werden sechzigmal pro Sekunde aufgerufen, erst update, dann draw.

In update() gehört alles hin, was sich verändert: Bewegungen, Tastendrücke, Zusammenstöße, Punkte. In draw() gehört nur hin, wie der aktuelle Zustand aussieht — dort wird nichts verändert.

Wer beides vermischt, bekommt Spiele, die auf schnellen Rechnern schneller laufen als auf langsamen. Halte die zwei sauber getrennt.

keyboard.left ist wahr, solange die linke Pfeiltaste gedrückt ist — also in jedem Bild neu. Deshalb schleicht die Ente gleichmäßig und hüpft nicht.

Das global brauchst du, weil duck_x außerhalb der Funktion angelegt wurde. Ohne diese Zeile würde Python beim ersten duck_x = ... eine neue, eigene Variable in der Funktion anlegen, und draußen bliebe alles beim Alten. In der nächsten Stufe wirst du es wieder los.

Test

Führe das Programm aus und steuere die Ente mit den Pfeiltasten über den Teich. Sie darf dabei ruhig aus dem Bild laufen — das reparieren wir später.

Stufe 4: Aus Formen werden Bilder

Jetzt brauchst du den images-Ordner von oben.

import pgzrun

WIDTH = 800
HEIGHT = 600

# Farben bekommen Namen, damit man den Teich an einer Stelle umfärben kann.
WATER = (74, 144, 180)
SHORE = (110, 170, 90)

# Der Name in Actor(...) ist der Dateiname: Die Bilder heißen deutsch, der Code englisch.
duck = Actor("ente")
duck.pos = (400, 565)

def update():
    if keyboard.left:
        duck.x = duck.x - 4
    if keyboard.right:
        duck.x = duck.x + 4
    if keyboard.up:
        duck.y = duck.y - 4
    if keyboard.down:
        duck.y = duck.y + 4

def draw():
    screen.fill(WATER)
    screen.draw.filled_rect(Rect(0, 0, 800, 70), SHORE)
    screen.draw.filled_rect(Rect(0, 530, 800, 70), SHORE)
    duck.draw()

pgzrun.go()

Actor("ente") sucht die Datei images/ente.png — ohne Ordner, ohne Endung, nur der Name.

Actor

Ein Actor ist ein Objekt mit einem Bild. Er hat Attribute wie x, y, pos und angle, und er kann sich mit draw() selbst zeichnen. Ändere x, und beim nächsten Bild steht er woanders.

Das ist genau die Klasse aus dem Objekte-Kapitel — nur hat sie diesmal jemand anderes geschrieben.

Zwei Zeilen sind verschwunden, und das ist kein Zufall: global ist weg. Vorher hast du der Variablen duck_x einen neuen Wert zugewiesen — dafür braucht Python die Erlaubnis. Jetzt änderst du nur ein Attribut innerhalb des Objekts. Die Variable duck zeigt weiterhin auf dieselbe Ente, also gibt es nichts zu erlauben.

Test

Die weiße Ente muss jetzt als Bild über den Teich schwimmen. Wenn stattdessen eine Fehlermeldung mit images/ente.png kommt, heißt der Ordner falsch oder liegt an der falschen Stelle.

Eine eigene Ente?

Nimm ein beliebiges PNG mit durchsichtigem Hintergrund, leg es in den images-Ordner und schreib seinen Namen in Actor(...). Ein Frosch tut es auch.

Stufe 5: Ein Boot fährt

Das Boot bewegt sich, ohne dass jemand eine Taste drückt. Der Trick ist derselbe wie bei der Spirale im Variablen-Kapitel: In jedem Bild wird eine Zahl ein Stück größer.

Neu sind nur diese Zeilen:

boat = Actor("boot")
boat.pos = (0, 280)

    boat.x = boat.x + 3
    if boat.x > 880:
        boat.x = -80

Und in draw(), vor der Ente, damit sie im Vordergrund bleibt:

    boat.draw()

Das Ganze zusammen:

import pgzrun

WIDTH = 800
HEIGHT = 600

# Farben bekommen Namen, damit man den Teich an einer Stelle umfärben kann.
WATER = (74, 144, 180)
SHORE = (110, 170, 90)

# Der Name in Actor(...) ist der Dateiname: Die Bilder heißen deutsch, der Code englisch.
duck = Actor("ente")
duck.pos = (400, 565)

boat = Actor("boot")
boat.pos = (0, 280)

def update():
    if keyboard.left:
        duck.x = duck.x - 4
    if keyboard.right:
        duck.x = duck.x + 4
    if keyboard.up:
        duck.y = duck.y - 4
    if keyboard.down:
        duck.y = duck.y + 4

    boat.x = boat.x + 3
    if boat.x > 880:
        boat.x = -80

def draw():
    screen.fill(WATER)
    screen.draw.filled_rect(Rect(0, 0, 800, 70), SHORE)
    screen.draw.filled_rect(Rect(0, 530, 800, 70), SHORE)
    boat.draw()
    duck.draw()

pgzrun.go()

Warum 880 und −80? Das Boot ist 120 Pixel breit, boat.x ist seine Mitte. Bei 880 ist es also gerade vollständig rechts hinausgefahren, bei −80 steht es vollständig links außerhalb. Setzte man es schon bei 800 zurück, würde es sichtbar verschwinden.

Test

Ein Boot muss von links nach rechts fahren und danach wieder von vorn anfangen. Ändere die 3 in eine 8 und schau, was passiert. Ändere sie in eine 0,5 — geht das?

Stufe 6: Zusammenstoß

# Zurück an den Start — das wird gleich an mehreren Stellen gebraucht.
def back_to_start():
    duck.pos = (400, 565)

und in update(), hinter der Bootsbewegung:

    if duck.colliderect(boat):
        back_to_start()

colliderect prüft, ob sich die beiden Bilder überlappen. Genauer: ob sich ihre Rechtecke überlappen — auch die durchsichtigen Ecken zählen mit. Deshalb wirkt die Ente manchmal etwas empfindlich. Fast alle Spiele rechnen so, weil es viel schneller geht als eine genaue Prüfung.

Dass das Zurücksetzen in einer eigenen Funktion steht, ist kein Zufall: Ab Stufe 8 brauchst du es an zwei Stellen, und dann willst du es nur einmal geschrieben haben.

Das ganze Programm bis hierher

import pgzrun

WIDTH = 800
HEIGHT = 600

# Farben bekommen Namen, damit man den Teich an einer Stelle umfärben kann.
WATER = (74, 144, 180)
SHORE = (110, 170, 90)

# Der Name in Actor(...) ist der Dateiname: Die Bilder heißen deutsch, der Code englisch.
duck = Actor("ente")
duck.pos = (400, 565)

boat = Actor("boot")
boat.pos = (0, 280)

# Zurück an den Start — das wird gleich an mehreren Stellen gebraucht.
def back_to_start():
    duck.pos = (400, 565)

def update():
    if keyboard.left:
        duck.x = duck.x - 4
    if keyboard.right:
        duck.x = duck.x + 4
    if keyboard.up:
        duck.y = duck.y - 4
    if keyboard.down:
        duck.y = duck.y + 4

    boat.x = boat.x + 3
    if boat.x > 880:
        boat.x = -80

    if duck.colliderect(boat):
        back_to_start()

def draw():
    screen.fill(WATER)
    screen.draw.filled_rect(Rect(0, 0, 800, 70), SHORE)
    screen.draw.filled_rect(Rect(0, 530, 800, 70), SHORE)
    boat.draw()
    duck.draw()

pgzrun.go()

Test

Fahr absichtlich in das Boot. Die Ente muss unten wieder auftauchen.

Stufe 7: Viele Boote

Ein Boot ist noch kein Hindernis. Drei sind eins — und drei Boote schreibt man nicht dreimal hin.

def new_boat(x, y, speed):
    boat = Actor("boot")
    boat.pos = (x, y)
    boat.speed = speed  # jedes Boot bekommt sein eigenes Tempo
    return boat

boats = [
    new_boat(100, 140, 2),
    new_boat(500, 280, 4),
    new_boat(300, 420, 3)
]

boat.speed = speed ist der interessante Teil: Ein Actor darf zusätzliche Attribute bekommen, die es vorher nicht gab. Jedes Boot merkt sich damit sein eigenes Tempo — genau wie jedes Pferd im Objekte-Kapitel seine eigene Farbe hatte.

In update() und in draw() läufst du jetzt über die Liste:

    for boat in boats:
        boat.x = boat.x + boat.speed
        if boat.x > 880:
            boat.x = -80
        if duck.colliderect(boat):
            back_to_start()

    for boat in boats:
        boat.draw()

Das Bemerkenswerte: Ob drei Boote in der Liste stehen oder dreißig, ändert am Programm keine einzige Zeile. Das ist die Liste aus dem Listen-Kapitel — diesmal mit Objekten darin statt mit Zahlen.

Das ganze Programm bis hierher

import pgzrun

WIDTH = 800
HEIGHT = 600

# Farben bekommen Namen, damit man den Teich an einer Stelle umfärben kann.
WATER = (74, 144, 180)
SHORE = (110, 170, 90)

# Der Name in Actor(...) ist der Dateiname: Die Bilder heißen deutsch, der Code englisch.
duck = Actor("ente")
duck.pos = (400, 565)

def new_boat(x, y, speed):
    boat = Actor("boot")
    boat.pos = (x, y)
    boat.speed = speed  # jedes Boot bekommt sein eigenes Tempo
    return boat

boats = [
    new_boat(100, 140, 2),
    new_boat(500, 280, 4),
    new_boat(300, 420, 3)
]

# Zurück an den Start — das wird gleich an mehreren Stellen gebraucht.
def back_to_start():
    duck.pos = (400, 565)

def update():
    if keyboard.left:
        duck.x = duck.x - 4
    if keyboard.right:
        duck.x = duck.x + 4
    if keyboard.up:
        duck.y = duck.y - 4
    if keyboard.down:
        duck.y = duck.y + 4

    for boat in boats:
        boat.x = boat.x + boat.speed
        if boat.x > 880:
            boat.x = -80
        if duck.colliderect(boat):
            back_to_start()

def draw():
    screen.fill(WATER)
    screen.draw.filled_rect(Rect(0, 0, 800, 70), SHORE)
    screen.draw.filled_rect(Rect(0, 530, 800, 70), SHORE)
    for boat in boats:
        boat.draw()
    duck.draw()

pgzrun.go()

Test

Drei Boote in drei Bahnen, jedes in seinem Tempo. Füge ein viertes hinzu und finde ein Tempo, bei dem das Spiel gerade noch schaffbar ist.

Stufe 8: Küken zählen und gewinnen

Bisher kann man nicht verlieren, aber auch nicht gewinnen. Das ändert sich jetzt — hier ist das vollständige Spiel:

import pgzrun

WIDTH = 800
HEIGHT = 600

# Farben bekommen Namen, damit man den Teich an einer Stelle umfärben kann.
WATER = (74, 144, 180)
SHORE = (110, 170, 90)

# Der Name in Actor(...) ist der Dateiname: Die Bilder heißen deutsch, der Code englisch.
duck = Actor("ente")
duck.pos = (400, 565)

chick = Actor("kueken")

saved = 0

def new_boat(x, y, speed):
    boat = Actor("boot")
    boat.pos = (x, y)
    boat.speed = speed  # jedes Boot bekommt sein eigenes Tempo
    return boat

boats = [
    new_boat(100, 140, 2),
    new_boat(500, 280, 4),
    new_boat(300, 420, 3)
]

# Zurück an den Start — das wird gleich an mehreren Stellen gebraucht.
def back_to_start():
    duck.pos = (400, 565)

def update():
    global saved

    if saved == 5:
        return  # Spielende: ab hier wird nicht mehr gerechnet, nur noch gezeichnet.

    if keyboard.left:
        duck.x = duck.x - 4
    if keyboard.right:
        duck.x = duck.x + 4
    if keyboard.up:
        duck.y = duck.y - 4
    if keyboard.down:
        duck.y = duck.y + 4

    for boat in boats:
        boat.x = boat.x + boat.speed
        if boat.x > 880:
            boat.x = -80
        if duck.colliderect(boat):
            back_to_start()

    if duck.y < 70:
        saved = saved + 1
        back_to_start()

def draw():
    screen.fill(WATER)
    screen.draw.filled_rect(Rect(0, 0, 800, 70), SHORE)
    screen.draw.filled_rect(Rect(0, 530, 800, 70), SHORE)

    # Ein einziges Küken-Objekt wird mehrfach hingesetzt und gezeichnet.
    for i in range(saved):
        chick.pos = (60 + i * 70, 35)
        chick.draw()

    for boat in boats:
        boat.draw()

    duck.draw()

    screen.draw.text("Gerettet: " + str(saved) + " von 5",
                     (20, 550), fontsize=36, color=(255, 255, 255))

    if saved == 5:
        screen.draw.text("Alle Küken sind drüben!", center=(400, 300),
                         fontsize=64, color=(255, 255, 255))

pgzrun.go()

Drei Stellen lohnen einen zweiten Blick.

Das return ganz oben in update(). Sind alle fünf Küken drüben, bricht die Funktion sofort ab: keine Bewegung, keine Boote, kein Zählen. Gezeichnet wird trotzdem weiter — das Bild bleibt einfach stehen. Ein Spielende, in drei Zeilen.

Die Schleife über range(saved). Sie zeichnet ein einziges Küken-Objekt an mehreren Stellen hintereinander: hinsetzen, zeichnen, weitersetzen, zeichnen. Für ein Bild, das sich nicht bewegt, braucht man keine fünf Objekte.

saved braucht wieder global. Anders als duck.x ist es eine gewöhnliche Zahl, und die wird beim Zählen neu zugewiesen. Genau der Unterschied aus Stufe 4.

Test

Spiel eine Runde durch. Fünf Küken müssen oben ankommen, dann steht die Meldung im Bild.

Stufe 9: Leben im Teich

Das Spiel ist fertig. Diese Stufe verändert nichts daran — sie lässt es nur besser aussehen.

Ein echtes Wellenmodell wäre viel Arbeit. Fünfzig helle Punkte, die langsam nach rechts wandern, sehen aus dieser Entfernung aber genauso gut aus. Effekte sind fast nie Physik.

import random

# Fünfzig helle Punkte reichen als bewegtes Wasser.
waves = []
for i in range(50):
    waves.append([random.randint(0, 800), random.randint(80, 520)])

In update():

    for wave in waves:
        wave[0] = wave[0] + 1
        if wave[0] > 800:
            wave[0] = 0

Und in draw() direkt nach screen.fill(WATER), damit die Punkte auf dem Wasser liegen und nicht auf den Booten:

    for wave in waves:
        screen.draw.filled_circle((wave[0], wave[1]), 2, (108, 168, 202))

Jede Welle ist eine Liste aus zwei Zahlen: wave[0] ist x, wave[1] ist y. Eine Liste von Listen — mehr braucht es nicht.

Das ganze Programm bis hierher

import pgzrun
import random

WIDTH = 800
HEIGHT = 600

# Farben bekommen Namen, damit man den Teich an einer Stelle umfärben kann.
WATER = (74, 144, 180)
SHORE = (110, 170, 90)

# Der Name in Actor(...) ist der Dateiname: Die Bilder heißen deutsch, der Code englisch.
duck = Actor("ente")
duck.pos = (400, 565)

chick = Actor("kueken")

saved = 0

# Fünfzig helle Punkte reichen als bewegtes Wasser.
waves = []
for i in range(50):
    waves.append([random.randint(0, 800), random.randint(80, 520)])

def new_boat(x, y, speed):
    boat = Actor("boot")
    boat.pos = (x, y)
    boat.speed = speed  # jedes Boot bekommt sein eigenes Tempo
    return boat

boats = [
    new_boat(100, 140, 2),
    new_boat(500, 280, 4),
    new_boat(300, 420, 3)
]

# Zurück an den Start — das wird gleich an mehreren Stellen gebraucht.
def back_to_start():
    duck.pos = (400, 565)

def update():
    global saved

    if saved == 5:
        return  # Spielende: ab hier wird nicht mehr gerechnet, nur noch gezeichnet.

    if keyboard.left:
        duck.x = duck.x - 4
    if keyboard.right:
        duck.x = duck.x + 4
    if keyboard.up:
        duck.y = duck.y - 4
    if keyboard.down:
        duck.y = duck.y + 4

    for boat in boats:
        boat.x = boat.x + boat.speed
        if boat.x > 880:
            boat.x = -80
        if duck.colliderect(boat):
            back_to_start()

    for wave in waves:
        wave[0] = wave[0] + 1
        if wave[0] > 800:
            wave[0] = 0

    if duck.y < 70:
        saved = saved + 1
        back_to_start()

def draw():
    screen.fill(WATER)

    for wave in waves:
        screen.draw.filled_circle((wave[0], wave[1]), 2, (108, 168, 202))

    screen.draw.filled_rect(Rect(0, 0, 800, 70), SHORE)
    screen.draw.filled_rect(Rect(0, 530, 800, 70), SHORE)

    # Ein einziges Küken-Objekt wird mehrfach hingesetzt und gezeichnet.
    for i in range(saved):
        chick.pos = (60 + i * 70, 35)
        chick.draw()

    for boat in boats:
        boat.draw()

    duck.draw()

    screen.draw.text("Gerettet: " + str(saved) + " von 5",
                     (20, 550), fontsize=36, color=(255, 255, 255))

    if saved == 5:
        screen.draw.text("Alle Küken sind drüben!", center=(400, 300),
                         fontsize=64, color=(255, 255, 255))

pgzrun.go()

Test

Der Teich muss jetzt leicht in Bewegung sein. Wenn es zu unruhig wirkt, nimm 20 Wellen statt 50 oder lass sie nur jedes zweite Bild wandern.

Kurzes Quiz

Beantworte aus dem Kopf, dann sieh nach.

Warum steht die Bewegung in update() und nicht in draw()?

Weil draw() nur den aktuellen Zustand zeichnen soll. Verändert man dort etwas, hängt das Spielgeschehen davon ab, wie oft gezeichnet wird — und das ist auf jedem Rechner anders.

Warum braucht saved ein global, duck.x aber nicht?

saved = saved + 1 weist der Variablen einen neuen Wert zu. duck.x = ... verändert ein Attribut im Objekt; die Variable duck selbst bleibt dieselbe.

Wo müssen Bilddateien liegen?

In einem Ordner images direkt neben dem Programm. Actor("boot") findet damit images/boot.png.

Warum wird das Boot vor der Ente gezeichnet?

Weil später Gezeichnetes oben liegt. Zeichnete man das Boot zuletzt, würde die Ente darunter verschwinden.

Challenge 🐍🐍

Kein Lösungsweg, nur Ziele. Such dir aus, was dich reizt.

1. Rand. Die Ente soll das Fenster nicht verlassen können.
2. Leben. Drei Zusammenstöße, dann ist das Spiel vorbei. Zeig die verbleibenden Leben an.
3. Schwerer werden. Nach jedem geretteten Küken werden alle Boote ein bisschen schneller.
4. Gegenverkehr. Ein Boot fährt von rechts nach links. Du brauchst dafür ein zweites Bild — oder einen Trick mit boat.angle.
5. Strömung. Im Wasser treibt die Ente langsam nach rechts ab, auf dem Ufer nicht.
6. Seerosen. Sichere Felder, auf denen kein Boot fahren kann.
7. Ton. sounds.platsch.play() spielt sounds/platsch.wav. Freie Geräusche findest du bei freesound.org.

Ein eigenes Spiel 🐍🐍🐍

Du hast jetzt alles beisammen, was die meisten 2D-Spiele ausmacht: ein Fenster, eine Spielfigur, Steuerung, bewegte Gegner, Zusammenstöße, Punkte und ein Spielende. Was fehlt, ist nur noch eine Idee.

Fang klein an. Ein Spiel, das in zwei Sätzen erklärt ist, wird meistens fertig; eines mit einer Weltkarte und drei Endgegnern nicht. Schreib zuerst auf, was man tun muss, um zu gewinnen — und dann, was einen daran hindert. Mehr braucht ein Spiel nicht.

Die vollständige Anleitung zu Pygame Zero, mit allem, was hier nicht vorkam — Töne, Musik, Zeitsteuerung, Animationen:

https://pygame-zero.readthedocs.io/de/latest/