8. Game

Einführung in Pygame

In diesem Kapitel entwickeln wir Schritt für Schritt ein eigenes 2D-Game mit pygame-ce. pygame-ce ist eine moderne, Community-gepflegte Variante von Pygame und wird genau gleich importiert mit import pygame as pg. Sie eignet sich hervorragend, um in Python Grafiken, Animationen, Sound und Interaktionen umzusetzen.

Essentielle Bausteine eines Games sind:

Fenster (Auflösung, Titel) und Zeichenfläche (“screen”)
Game-Schleife mit Ereignissen (Tastatur, Maus) und Zeitsteuerung ( / “refresh rate”)
Zeichnen: Hintergrund, Farben, geometrische Figuren, Bilder (“Sprites”)
Zustände und Objekte (z.B. Spieler als Rect), Bewegungen und Kollisionen
Medien: Bilder, Icon, Schrift, Sound / Musik

Game-Schleife

Ein Game läuft in einer Endlosschleife, bis das Programm beendet wird. In jeder Runde werden der Eingabestatus gelesen (“Events”), der interne Zustand aktualisiert (“Update”) und die Szene gezeichnet (“Render”). Eine Clock (\(=\) Uhr) begrenzt die Bildwiederholrate (), sodass das Game stabil und gleichmässig läuft.

Um in VS Code zu installieren, gehen Sie wie folgt vor:

Öffnen Sie ein Terminal-Fenster in VS Code (“Terminal” \(\rightarrow\) “New Terminal”).
Installieren Sie pygame-ce mit pip:\ pip install pygame-ce
Überprüfen Sie die Installation, indem Sie eine neue Python-Datei game_test.py mit folgendem Code ausführen:

import pygame as pg
        print(pg.ver)

Note

💡 Hinweis: Dieses Skript verwendet grafische Desktop-Bibliotheken (turtle / pygame). Führen Sie diesen Code in Ihrer lokalen Entwicklungsumgebung (z.B. VS Code) aus.

Dieser Code sollte, sofern pygame-ce korrekt installiert ist, die Versionsnummer von pygame-ce ausgeben. Damit ist pygame-ce einsatzbereit und Sie können mit den unten stehenden Übungen starten.

Wichtiger Hinweis

Falls die Installation nicht funktioniert, erstellen Sie zuerst ein virtuelles Umfeld (venv) in VS Code und installieren Sie pygame-ce darin:

Öffnen Sie ein Terminal-Fenster in VS Code (“Terminal” \(\rightarrow\) “New Terminal”).
Erstellen Sie ein virtuelles Environment:\ python3 -m venv venv\ Aktivieren Sie das venv:\ Windows: venv\Scripts\activate\ macOS: source venv/bin/activate
Führen Sie nun nochmals die obigen Schritte zur Installation von pygame-ce durch.

Minimale Game-Schleife

Folgender Code zeigt den minimalen Aufbau eines Pygame-Programms mit Fenster, Game-Schleife und Ereignisverarbeitung. Kopieren Sie den Code in eine Datei game_intro.py und führen Sie ihn in VS Code aus.

import pygame as pg

pg.init()  # Pygame initialisieren (starten)
HEIGHT = 600  # Höhe des Fensters
WIDTH = 800  # Breite des Fensters
WINDOW = (WIDTH, HEIGHT)  # Fenstergrösse (als Tuple gespeichert)
screen = pg.display.set_mode(WINDOW)  # Fenster erstellen
pg.display.set_caption("Mein erstes Game")  # Fenstertitel setzen
clock = pg.time.Clock()  # Clock für Zeitsteuerung erstellen

running = True  # Hauptschleife
while running:
    # --- Events ---
    for event in pg.event.get():
        if event.type == pg.QUIT:
            running = False

    # --- Update --- (Spielzustand aktualisieren)

    # --- render (zeichnen) ---
    screen.fill((30, 30, 40))
    pg.display.flip()

    # --- Zeitsteuerung ---
    clock.tick(60)  # 60 FPS

pg.quit()

Note

💡 Hinweis: Dieses Skript verwendet grafische Desktop-Bibliotheken (turtle / pygame). Führen Sie diesen Code in Ihrer lokalen Entwicklungsumgebung (z.B. VS Code) aus.

Ein schwarzes Fenster sollte erscheinen, das Sie mit dem Schliessen-Knopf beenden können.

Fenster-Titel setzen

Setzen Sie einen passenden Fenstertitel, indem Sie folgende Zeile abändern:

Challenge

Laden Sie ein Fenster-Icon (.png oder .jpg): Laden Sie ein beliebiges Bild aus dem Internet herunter, speichern Sie es unter den Downloads und ziehen Sie es in Ihren Projektordner in VS Code (dort wo auch Ihre Python-Datei ist). Fügen Sie nun diese beiden Zeilen nach pg.display.set_mode(...) ein:

Wenn Ihr Ordner beispielsweise Informatik/ heisst und das Bild unter

Informatik/Game/icon.png

gespeichert ist, dann verwenden Sie

pg.image.load("Game/icon.png").

Bei Windows ändert sich nur das Fenster-Icon, bei macOS wird das Icon nur im Dock angezeigt.

💡 Musterlösung anzeigen

import pygame as pg

pg.init()  # Pygame initialisieren (starten)
WINDOW = (800, 600)  # Fenstergrösse (als Tuple gespeichert)
screen = pg.display.set_mode(WINDOW)  # Fenster erstellen
icon = pg.image.load("Grundlagen_Info/00_Programmieren/Skript/Code/K09_Game/icon.png")
pg.display.set_caption("Mein erstes Game")  # Fenstertitel setzen
pg.display.set_icon(icon)
clock = pg.time.Clock()  # Clock für Zeitsteuerung erstellen

running = True  # Hauptschleife
while running:
    # --- Events ---
    for event in pg.event.get():
        if event.type == pg.QUIT:
            running = False

    # --- Update --- (Spielzustand aktualisieren)

    # --- render (zeichnen) ---
    screen.fill((30, 30, 40))
    pg.display.flip()

    # --- Zeitsteuerung ---
    clock.tick(60)  # 60 FPS

pg.quit()

Note

💡 Hinweis: Dieses Skript verwendet grafische Desktop-Bibliotheken (turtle / pygame). Führen Sie diesen Code in Ihrer lokalen Entwicklungsumgebung (z.B. VS Code) aus.

Hintergrund zeichnen

Füllen Sie den Hintergrund pro Frame mit einer Farbe mittels screen.fill((R,G,B)). Experimentieren Sie mit zufällig generierten Farbtönen:

Die Farbe muss in der Hauptschleife, aber noch vor pg.display.flip(), gesetzt werden.

Was ändert sich, wenn Sie die drei Zeilen für die Farbwerte r, g, b vor die Hauptschleife setzen?
Schreiben Sie den Code so um, dass die Farbe nur alle 10 Frames geändert wird.

💡 Musterlösung anzeigen

import pygame as pg
import random

pg.init()  # Pygame initialisieren (starten)
WINDOW = (800, 600)  # Fenstergrösse (als Tuple gespeichert)
screen = pg.display.set_mode(WINDOW)  # Fenster erstellen
pg.display.set_caption("Mein erstes Game")  # Fenstertitel setzen
icon = pg.image.load("Grundlagen_Info/00_Programmieren/Skript/Code/K09_Game/icon.png")
pg.display.set_icon(icon)
clock = pg.time.Clock()  # Clock für Zeitsteuerung erstellen

running = True  # Hauptschleife
while running:
    # --- Events ---
    for event in pg.event.get():
        if event.type == pg.QUIT:
            running = False

    # --- render (zeichnen) ---
    r = random.randint(0, 255)
    g = random.randint(0, 255)
    b = random.randint(0, 255)
    background_color = (r, g, b)
    screen.fill(background_color)  # Hintergrundfarbe setzen

    pg.display.flip()

    # --- Zeitsteuerung ---
    clock.tick(10)  # 10 FPS

pg.quit()

Note

💡 Hinweis: Dieses Skript verwendet grafische Desktop-Bibliotheken (turtle / pygame). Führen Sie diesen Code in Ihrer lokalen Entwicklungsumgebung (z.B. VS Code) aus.

Geometrische Figuren

Zeichnen Sie geometrische Formen: Rechteck, Kreis, Linie. Nutzen Sie dafür pg.draw.rect, pg.draw.circle und pg.draw.line. Achten Sie darauf, nach dem Zeichnen pg.display.flip() aufzurufen. Versuchen Sie, mittels folgender Befehle einen Apfel zu zeichnen: Verwenden Sie folgende Befehle:

Dabei bezeichnen die Parameter Folgendes:

screen: die Zeichenfläche
rect_color, circle_color, line_color: Farbe als RGB-tuple, z.,B. (255, 0, 0) für Rot
pg.Rect(...): Rechteck-Objekt mit Position (x,y) und Grösse (width,height)
(circle_x, circle_y): Mittelpunkt des Kreises
circle_radius: Radius des Kreises
(start_x, start_y), (end_x, end_y): Start- und Endpunkt der Linie
line_width: Dicke der Linie in Pixeln (optional)

Sonnenuntergang erstellen

Erzeugen Sie eine einfache Szene mit Himmel, Sonne und Meer. Tipp: Zeichnen Sie einen Farbverlauf am Himmel, indem Sie in einer Schleife schmale horizontale Rechtecke in leicht unterschiedlichen Farbtönen zeichnen. Die Sonne ist ein Kreis; das Meer ein Rechteck in der unteren Hälfte. Das Meer sollte ebenfalls einen Farbverlauf haben (von hellblau zu dunkelblau). Verwenden Sie folgenden Code als Vorlage:

Optional: Lassen Sie die Sonne langsam sinken (Animation über mehrere Frames).

💡 Musterlösung anzeigen

Diese Musterlösung finden Sie in Abschnitt.

Bewegungen (Tastatur)

Erstellen Sie ein Spieler-Rect (z.,B. 50 x 50) und bewegen Sie es mit den Pfeiltasten. Nutzen Sie pg.key.get_pressed() und begrenzen Sie die Bewegung auf das Fenster (“Screen Bounds”). Verwenden Sie folgende Code-Vorlage:

💡 Musterlösung anzeigen

Diese Musterlösung finden Sie in Abschnitt.

Kollisionen

Legen Sie ein Rect als “Ziel/Item” an (z.,B. kleiner Kreis oder Block). Prüfen Sie eine Kollision mit player.colliderect(item). Bei Kollision: Position des Items neu zufällig setzen und optional Punkte zählen.

Highscore anzeigen

Erstellen Sie eine Variable score, die bei jeder Kollision um 1 erhöht wird. Zeichnen Sie den aktuellen Punktestand mit font.render(...) oben links im Fenster. Verwenden Sie folgenden Code, um Text zu zeichnen:

💡 Musterlösung anzeigen

Diese Musterlösung finden Sie in Abschnitt.

Ereignisse (Keyboard / Maus)

Reagieren Sie auf KEYDOWN- und MOUSEBUTTONDOWN-Events. Beispiel: Bei Mausklick wird an der Klickposition ein kleiner Kreis gezeichnet (oder eine Partikelspur gestartet). Bei ESC beendet sich das Game. Da die Kreise jedes Frame neu gezeichnet werden müssen, speichern Sie die Positionen in einer Liste.

Um Ereignisse wie etwa einen Maus-Klick zu verarbeiten, verwenden Sie folgenden Code:

💡 Musterlösung anzeigen

Diese Musterlösung finden Sie in Abschnitt.

Medien: Bild und Sound

Laden Sie ein Bild (.png /.jpg) und zeichnen Sie es mit screen.blit(...). Skalieren/rotieren Sie es optional. Laden Sie einen Sound (.wav/ .ogg / .mp3) mit pg.mixer.Sound und spielen Sie ihn bei einer Kollision ab.

Für Bilder:

Für Sounds:

Hinweis: Legen Sie die Medien in einem Ordner (z.,B. assets/) ab und achten Sie auf relative Pfade. Die Dateien player.jpeg und motor.wav finden Sie auf Moodle.

Optional: Skalieren Sie das Bild auf eine bestimmte Höhe, wobei das Seitenverhältnis beibehalten wird, indem Sie das Seitenverhältnis mit den Befehlen img.get_width() und img.get_height() berechnen.

Tipp: Viele kostenlose Soundeffekte finden Sie unter https://pixabay.com/sound-effects.

💡 Musterlösung anzeigen

Diese Musterlösung finden Sie in Abschnitt.

Bonus: Kleines Sammelspiel

Verbinden Sie die vorherigen Bausteine: Bewegen Sie den Spieler, sammeln Sie Items (Punkte zählen), spielen Sie dabei einen Sound ab und zeichnen Sie im Hintergrund Ihren Sonnenuntergang. Begrenzen Sie die Spielzeit auf 60 Sekunden und zeigen Sie die verbleibende Zeit im Fenstertitel an.

Pong-Spiel

Erstellen Sie das klassische Pong-Spiel mit zwei Paddles und einem Ball.

Das folgende Video zeigt das fertige Pong-Spiel: https://youtu.be/vCoBgJlUg_c

Die Paddles werden mit den Tasten W/S (links) und UP/DOWN (rechts) gesteuert. Der Ball bewegt sich automatisch und prallt von den Paddles und den oberen/unteren Bildschirmrändern ab. Zählen Sie die Punkte, wenn ein Spieler den Ball am Gegner vorbei spielt. Gehen Sie Schritt für Schritt vor, indem Sie folgende Elemente umsetzen:

Rechtecke für Paddles und Ball zeichnen
Mittellinie zeichnen
Tastatur-Eingaben für Paddle-Bewegung (W/S und UP/DOWN)
Ball von der Mitte aus in eine zufällige Richtung starten lassen
Kollisionserkennung für Ball und Paddles, Richtung von Ball umkehren bei Kollision oder sofern der Ball die oberen/unteren Ränder berührt
Punkte zählen und anzeigen
Soundeffekte bei Kollisionen und Punkten

💡 Musterlösung anzeigen

Eine mögliche Lösung zum Pong-Spiel finden Sie auf Moodle.

Hinweise zu Pong

Die folgende Sammlung von Hinweisen zeigt kleine Bausteine, die im Pong-Beispiel verwendet werden und Ihnen beim Verständnis oder bei eigenen Varianten helfen.

Zufällige Start-Richtung für den Ball:

**Rect-Ränder nutzen und Kollisionen “sauber** auflösen:”

Abprall oben/unten (Wände):

Trefferwinkel variieren: Je weiter oben/unten am Paddle getroffen wird, desto mehr vertikale Geschwindigkeit.

Ball nach Punkt neu zentrieren (als Funktion):

Nützliche Rect-Eigenschaften: left, right, top, bottom, center, centery helfen bei Ausrichtung und Kollisionen.

Pong-Bonus

Fügen Sie dem Pong-Spiel folgende Features hinzu:

Soundeffekte bei Paddle-Kollision und Punktgewinn
Startbildschirm mit Anweisungen
Game-Over-Bildschirm nach einer bestimmten Punktzahl (z.,B. 10 Punkte)
Paddle-Geschwindigkeit erhöhen, wenn der Ball getroffen wird
Hintergrundmusik während des Spiels

Videoaufnahme des Spiels

Nehmen Sie ein kurzes Video (ca. 1-2 Minuten) auf, das das Gameplay Ihres Spiels zeigt. Laden Sie das Video auf eine Plattform (z.,B. YouTube, Vimeo) hoch und fügen Sie den Link auf Moodle ein. Für die Bildschirmaufnahme können Sie folgende Tools verwenden:

Windows: Verwenden Sie die Bildschirmaufnahme-Funktion von PowerPoint (unter “Einfügen” \(\rightarrow\) “Bildschirmaufnahme”) oder die Xbox Game Bar (), beenden Sie die Aufnahme mit
macOS: Verwenden Sie die integrierte Bildschirmaufnahme (), beenden Sie die Aufnahme mit

Dateiverarbeitung: Speicher- & Highscore-Systeme (File I/O)

Damit ein Game Spielstände, Einstellungen oder Highscores auch nach dem Beenden des Programms behält, müssen Daten dauerhaft auf dem Datenträger gespeichert werden. In Python erfolgt der Dateizugriff am sichersten mit dem with open(...)-Konstrukt, welches sicherstellt, dass die Datei nach dem Bearbeiten automatisch geschlossen wird.

Einfache Textdateien (.txt)

Mit dem Modus "r" (Read) werden Daten gelesen, mit "w" (Write) überschrieben und mit "a" (Append) angefügt.

Dateien lesen und schreiben

Highscore-Speicher in Pygame

Schreiben Sie zwei Hilfsfunktionen load_highscore() und save_highscore(score) für Ihr Game:

load_highscore() prüft mit os.path.exists("highscore.txt"), ob die Datei existiert. Falls ja, liest sie die Zahl aus und gibt sie als int zurück. Falls nicht (oder bei einem Fehler), gibt sie 0 zurück.
save_highscore(score) schreibt den neuen Punktestand in die Datei highscore.txt.

Strukturierte Tabellen mit CSV (.csv)

Möchte man eine Rangliste (Leaderboard) mit mehreren Spielernamen und Punkteständen speichern, eignet sich das CSV-Format (Comma-Separated Values). Python bietet dafür das eingebaute Modul csv.

CSV-Dateien lesen und schreiben

Leaderboard-Tabelle mit CSV

Implementieren Sie eine Funktion load_leaderboard(), welche die CSV-Datei highscores.csv einliest, die Einträge nach Punktestand absteigend sortiert und die Top-3-Spieler auf der Konsole oder im Pygame-Fenster ausgibt.

Game-Auftrag

Thema

Im Folgenden wählen Sie in Zweier- bis Dreier-Gruppen ein Game-Thema aus und entwickeln ein kleines 2D-Game mit pygame-ce. Mögliche Themen sind:

Sammelspiel: Bewegen Sie eine Spielfigur (z.,B. Auto, Raumschiff) und sammeln Sie Items ein (z.,B. Treibstoff, Sterne). Jedes eingesammelte Item gibt Punkte.
Endlos-Runner: Steuern Sie eine Spielfigur (z.,B. Läufer, Auto) und weichen Sie Hindernissen aus (z.,B. Mauern, andere Autos). Jedes überstandene Hindernis gibt Punkte.
Fangspiel: Steuern Sie eine Spielfigur (z.,B. Katze, Netz) und fangen Sie herumspringende Objekte (z.,B. Mäuse, Schmetterlinge). Jedes gefangene Objekt gibt Punkte.
Shooter (z.B. Space Invaders): Steuern Sie ein Raumschiff und schiessen Sie auf herannahende Gegner. Jeder abgeschossene Gegner gibt Punkte.

Weitere Themen können in Absprache mit der Lehrperson gewählt werden. Wichtig ist, dass das Spiel die geforderten Python-Konzepte sinnvoll einsetzt (siehe Anforderungen) und die Komplexität angemessen ist (nicht zu einfach, aber auch nicht zu komplex).

Anforderungen

Ihr Projekt sollte folgende, essentielle Python-Konzepte sinnvoll einsetzen

Ihr Game muss Kommentare enthalten, die den Code erklären und die Struktur des Programms verdeutlichen. Verwenden Sie sowohl einzeilige Kommentare (mit #) als auch mehrzeilige Kommentare (mit """...""") für Funktionen und Klassen. Schauen Sie sich die detaillierten Bewertungskriterien auf Moodle an, um sicherzustellen, dass Ihr Code den Anforderungen entspricht.

Bonus

Bewertung

Projektbewertung

Die Bewertung Ihres Projekts erfolgt anhand der auf Moodle aufgelisteten Kriterien. Die maximale Punktzahl beträgt 100 Punkte.

Gruppen-Besprechung des Spiels

Im Anschluss an Ihre Abgabe findet eine Besprechung Ihres Spiels in Gruppen mit der Lehrperson statt (ca. 5 Minuten pro Person). Dabei werden Ihnen Fragen zu Ihrem Spiel gestellt, um Ihr Verständnis und Ihre Reflexion zu überprüfen. Die Besprechung resultiert in einer individuellen Verständnis-Punktzahl von bis zu 16 Punkten, welche mit Ihrer Endnote multipliziert wird:

Ihre Endnote wird wie folgt berechnet: [ = + _{}]

Wobei:

Projekt-Note die Note ist, die Sie basierend auf der Bewertung Ihres Projekts erhalten (0–100 Punkte, umgerechnet in Notenstufen)
Verständnis-Delta ein Bonus oder Malus ist, abhängig von Ihrer Verständnis-Punktzahl (0–16 Punkte), wie folgt:
14 Punkte: \(\Delta = 0\) (keine Veränderung)
15 Punkte: \(\Delta = +0.1\)
16 Punkte: \(\Delta = +0.2\)
Unter 14 Punkte: lineare Verschlechterung, maximal \(\Delta = -1\) Note

KI-Tools

Es wird von Ihnen erwartet, dass Sie sich aktiv an der Entwicklung des Spiels beteiligen und die geforderten Python-Konzepte verstehen und anwenden können. ChatGPT oder andere KI-Tools dürfen Sie verwenden, solange Sie Ihren gesamten Code verstehen und erklären können. Wie Sie im obigen Benotungsschema erkennen können, kann Ihre Note durch mangelndes Verständnis stark beeinträchtigt werden. Falls Sie ChatGPT oder andere KI-Tools verwenden, müssen Sie dies im Code klar dokumentieren (z.B. mit Kommentaren oder in einer Begleit-Dokumentation). Jede Zeile Code muss durch Sie erklärbar sein!

Längere Lösungen

💡 Musterlösung anzeigen

[myexercise:Sonnenuntergang] %

# File: game_intro_sunset.py
import pygame as pg

pg.init()  # Pygame initialisieren (starten)
HEIGHT = 600  # Höhe des Fensters
WIDTH = 800  # Breite des Fensters
WINDOW = (WIDTH, HEIGHT)  # Fenstergrösse (als Tuple gespeichert)
screen = pg.display.set_mode(WINDOW)  # Fenster erstellen
pg.display.set_caption("Sonnenuntergang")  # Fenstertitel setzen
icon = pg.image.load("Grundlagen_Info/00_Programmieren/Skript/Code/K09_Game/icon.png")
pg.display.set_icon(icon)
clock = pg.time.Clock()  # Clock für Zeitsteuerung erstellen

sun_center_x = WIDTH // 2 # x-Koorinate Kreismittelpunkt Sonne
sun_center_y = HEIGHT // 3 # y-Koorinate Kreismittelpunkt Sonne
sun_radius = 60 # Radius der Sonne

running = True  # Hauptschleife
while running:
    # --- Events ---
    for event in pg.event.get():
        if event.type == pg.QUIT:
            running = False

    # --- Update & Render ---
    # Himmel (einfacher Gradient)
    for y in range(0, HEIGHT // 2):
        red = 100 + int(155 * (y / (HEIGHT // 2)))  # 100 ... 255
        pg.draw.rect(screen, (red, 120, 180), (0, y, WIDTH, 1))

    # Sonne sinkt langsam (maximal bis zum Meer)
    # nicht mehr sichtbare Sonne soll nicht mehr berechnet werden
    if sun_center_y < (HEIGHT // 2 + sun_radius):
        sun_center_y += 0.5  # y-Position der Sonne verändern
        # Sonne
        pg.draw.circle(screen, (255, 200, 0), (sun_center_x, sun_center_y), sun_radius)

    # Meer
    pg.draw.rect(screen, (20, 80, 160), (0, HEIGHT // 2, WIDTH, HEIGHT // 2))

    # Bildschirm aktualisieren
    pg.display.flip()

    # --- Zeitsteuerung ---
    clock.tick(60)  # 60 FPS

pg.quit()

Note

💡 Hinweis: Dieses Skript verwendet grafische Desktop-Bibliotheken (turtle / pygame). Führen Sie diesen Code in Ihrer lokalen Entwicklungsumgebung (z.B. VS Code) aus.

💡 Musterlösung anzeigen

[myexercise:Bewegungen] %

# File: game_intro_player_rect.py
import pygame as pg

pg.init()  # Pygame initialisieren (starten)
WINDOW = (800, 600)  # Fenstergrösse (als Tuple gespeichert)
screen = pg.display.set_mode(WINDOW)  # Fenster erstellen
icon = pg.image.load("Grundlagen_Info/00_Programmieren/Skript/Code/K09_Game/icon.png")
pg.display.set_caption("Mein erstes Game")  # Fenstertitel setzen
pg.display.set_icon(icon)
background_color = (50, 80, 120)
clock = pg.time.Clock()  # Clock für Zeitsteuerung erstellen

# Spieler-Rect und Geschwindigkeit
player = pg.Rect(100, 100, 50, 50)
speed = 5

running = True  # Hauptschleife
while running:
    # --- Events ---
    for event in pg.event.get():
        if event.type == pg.QUIT:
            running = False

    # --- Update (Input / Bewegung) ---
    keys = pg.key.get_pressed()
    if keys[pg.K_LEFT]:
        player.x -= speed
    if keys[pg.K_RIGHT]:
        player.x += speed
    if keys[pg.K_UP]:
        player.y -= speed
    if keys[pg.K_DOWN]:
        player.y += speed
    player.clamp_ip(screen.get_rect())  # im Fenster halten

    # --- render (zeichnen) ---
    screen.fill(background_color)  # Hintergrundfarbe setzen
    pg.draw.rect(screen, (255, 255, 255), player)  # Spieler zeichnen

    pg.display.flip()

    # --- Zeitsteuerung ---
    clock.tick(60)  # 60 FPS

pg.quit()

Note

💡 Hinweis: Dieses Skript verwendet grafische Desktop-Bibliotheken (turtle / pygame). Führen Sie diesen Code in Ihrer lokalen Entwicklungsumgebung (z.B. VS Code) aus.

💡 Musterlösung anzeigen

[myexercise:Kollisionen] %

# File: game_intro_collision.py
import pygame as pg
import random

pg.init()
WIDTH, HEIGHT = 800, 600
screen = pg.display.set_mode((WIDTH, HEIGHT))
pg.display.set_caption("Kollisions-Game")
icon = pg.image.load("Grundlagen_Info/00_Programmieren/Skript/Code/K09_Game/icon.png")
pg.display.set_icon(icon)

background_color = (50, 80, 120)

player = pg.Rect(WIDTH // 2 - 20, HEIGHT // 2 - 20, 40, 40)
item = pg.Rect(400, 300, 30, 30)
speed = 5
score = 0
font = pg.font.Font(None, 36)

clock = pg.time.Clock()

running = True
while running:
    for event in pg.event.get():
        if event.type == pg.QUIT:
            running = False

    keys = pg.key.get_pressed()
    if keys[pg.K_RIGHT]:
        player.x += speed
    if keys[pg.K_LEFT]:
        player.x -= speed
    if keys[pg.K_DOWN]:
        player.y += speed
    if keys[pg.K_UP]:
        player.y -= speed

    player.clamp_ip(screen.get_rect())

    if player.colliderect(item):
        score += 1
        item.topleft = (
            random.randint(0, WIDTH - item.width),
            random.randint(0, HEIGHT - item.height),
        )

    screen.fill(background_color)
    pg.draw.rect(screen, (240, 220, 90), player)
    pg.draw.ellipse(screen, (200, 60, 60), item)
    score_surf = font.render(f"Punkte: {score}", True, (255, 255, 255))
    screen.blit(score_surf, (10, 10))

    pg.display.flip()
    clock.tick(60)

pg.quit()

Note

💡 Hinweis: Dieses Skript verwendet grafische Desktop-Bibliotheken (turtle / pygame). Führen Sie diesen Code in Ihrer lokalen Entwicklungsumgebung (z.B. VS Code) aus.

💡 Musterlösung anzeigen

[myexercise:HighscoreTxt] %

💡 Musterlösung anzeigen

[myexercise:HighscoreCsv] %

💡 Musterlösung anzeigen

[myexercise:Ereignisse] %

# File: game_intro_events.py
import pygame as pg

pg.init()  # Pygame initialisieren (starten)
WINDOW = (800, 600)  # Fenstergrösse (als Tuple gespeichert)
screen = pg.display.set_mode(WINDOW)  # Fenster erstellen
pg.display.set_caption("Mein erstes Game")  # Fenstertitel setzen
icon = pg.image.load("Grundlagen_Info/00_Programmieren/Skript/Code/K09_Game/icon.png")
pg.display.set_icon(icon)

background_color = (50, 80, 120)

clock = pg.time.Clock()  # Clock für Zeitsteuerung erstellen

# Liste für Kreise
mouse_positions = []  # Liste für Maus-Klick-Positionen

running = True  # Hauptschleife
while running:
    # --- Events ---
    for event in pg.event.get():
        if event.type == pg.QUIT:
            running = False
        elif event.type == pg.KEYDOWN or event.type == pg.K_ESCAPE:
            running = False
        elif event.type == pg.MOUSEBUTTONDOWN:
            x, y = event.pos
            mouse_positions.append((x, y))

    # --- render (zeichnen) ---
    screen.fill(background_color)  # Hintergrundfarbe setzen

    # Kreise zeichnen
    # In der Game-Loop, im Render-Abschnitt:
    for pos in mouse_positions:
        pg.draw.circle(screen, (255, 100, 100), pos, 10)

    pg.display.flip()

    # --- Zeitsteuerung ---
    clock.tick(60)  # 60 FPS

pg.quit()

Note

💡 Hinweis: Dieses Skript verwendet grafische Desktop-Bibliotheken (turtle / pygame). Führen Sie diesen Code in Ihrer lokalen Entwicklungsumgebung (z.B. VS Code) aus.

💡 Musterlösung anzeigen

[myexercise:Medien] %

# File: game_intro_media.py
import pygame as pg
from pathlib import Path

pg.init()  # Pygame initialisieren (starten)
WIDTH = 800
HEIGHT = 600
WINDOW = (WIDTH, HEIGHT)  # Fenstergrösse (als Tuple gespeichert)
screen = pg.display.set_mode(WINDOW)  # Fenster erstellen

base_dir = Path(__file__).parent
icon = pg.image.load(base_dir / "icon.png")
pg.display.set_caption("Mein erstes Game")  # Fenstertitel setzen
pg.display.set_icon(icon)

# Medien laden (Bild und Sound)
assets = base_dir / "assets"
img = pg.image.load(assets / "player.jpeg")
# Skalieren auf bestimmte Höhe, Seitenverhältnis beibehalten
desired_height = 100
aspect_ratio = img.get_width() / img.get_height()
new_width = int(desired_height * aspect_ratio)
img = pg.transform.scale(img, (new_width, desired_height))

# Spieler-Rect für Position/Kollision
player = img.get_rect(center=(WIDTH // 2, HEIGHT // 2))

# Einfaches Item als farbiges Quadrat
item_surf = pg.Surface((40, 40), pg.SRCALPHA)
item_surf.fill((255, 200, 0))
item = item_surf.get_rect(center=(WIDTH // 3, HEIGHT // 2))

# Sound laden
try:
    pg.mixer.init()
    motor = pg.mixer.Sound(assets / "motor.mp3")
except Exception:
    motor = None  # falls kein Audio verfügbar ist

background_color = (50, 80, 120)
clock = pg.time.Clock()  # Clock für Zeitsteuerung erstellen

running = True  #  Hauptschleife
collided = False
speed = 5

while running:
    # --- Events ---
    for event in pg.event.get():
        if event.type == pg.QUIT:
            running = False

    # --- Update ---
    keys = pg.key.get_pressed()
    if keys[pg.K_LEFT]:
        player.x -= speed
    if keys[pg.K_RIGHT]:
        player.x += speed
    if keys[pg.K_UP]:
        player.y -= speed
    if keys[pg.K_DOWN]:
        player.y += speed

    # Im Fenster halten
    player.clamp_ip(screen.get_rect())

    # Kollision + Sound
    if player.colliderect(item):
        if not collided and motor:
            motor.play()
        collided = True
    else:
        collided = False

    # --- render (zeichnen) ---
    screen.fill(background_color)  # Hintergrundfarbe setzen

    # Item und Spieler zeichnen
    screen.blit(item_surf, item)
    # optional: Rotation -> pg.transform.rotate(img, angle)
    screen.blit(img, player)

    pg.display.flip()

    # --- Zeitsteuerung ---
    clock.tick(60)  # 60 FPS

pg.quit()

Note

💡 Hinweis: Dieses Skript verwendet grafische Desktop-Bibliotheken (turtle / pygame). Führen Sie diesen Code in Ihrer lokalen Entwicklungsumgebung (z.B. VS Code) aus.

}