fadiinf-sose26/sitzung-04.md

Sitzung 4: Didaktische Ansätze zum Programmierenlernen

** Aufgabe: Entwickeln Sie ein Spiel — didaktisch durchdacht (ca. 60 Min.) Zielgruppe: Klassenstufe 11 (Gymnasium, Wahlfach Informatik) Lernumgebung: Computerraum mit Einzelarbeitsplätzen (1 Gerät pro Schüler*in) Lernvoraussetzungen: Heterogene Gruppe mit unterschiedlicher Programmiererfahrung

Sie haben verschiedene didaktische Ansätze zum Programmierenlernen kennengelernt. Jetzt wenden Sie diese praktisch an: Sie erstellen mit KI-Unterstützung ein konkretes Spiel, das als Grundlage für Ihren Unterrichtsentwurf dient.

Bearbeitungsschritte:

Anforderungen definieren (10 Min.): Versetzen Sie sich in die Rolle der Lehrkraft. Formulieren Sie eine Aufgabenstellung, die Sie Ihren Schülerinnen und Schülern geben würden: Spieltitel und Ziel des Spiels (z. B. Labyrinth, Klickspiel, 2D-Reaktionsspiel) Welche Spielmechanik oder Steuerung enthalten sein soll Welche Programmierelemente die Schüler*innen dabei lernen (z. B. Schleifen, Bedingungen, Events, Kollisionen)

Anforderungen an Spiel

Aufgabenstellung (für Schüler - Pygame): Du programmierst mit Python und der der Bibliothek pygame ein kleines 2D Reaktionsspiel namens „Catch the Target“. • Auf dem Spielfeld bewegt sich ein Ziel Objekt (z. B. ein farbiger Block oder Kreis). • Deine Spielfigur wird mit den Pfeiltasten gesteuert. • Ziel ist es, innerhalb einer vorgegebenen Zeit möglichst viele Ziele zu fangen und Punkte zu sammeln. Dein Programm soll mindestens: • Ein Pygame Fenster öffnen (z. B. 800×600 Pixel, Hintergrundfarbe deiner Wahl). • Eine Spielfigur anzeigen (z. B. farbiges Rechteck mit pygame.Rect), deren Position sich mit den Pfeiltasten verändert. • Ein Ziel Objekt anzeigen (ebenfalls z. B. pygame.Rect), das sich automatisch bewegt (waagrecht, senkrecht oder zufällig) und beim Rand abprallt oder die Richtung ändert. • Eine Kollision zwischen Spielfigur und Ziel Objekt erkennen (z. B. mit rect.colliderect(...)). o Bei Kollision: Punktestand erhöhen und Ziel Objekt an eine neue zufällige Position setzen. • Eine Zeitbegrenzung (z. B. 30 Sekunden) umsetzen: Nach Ablauf der Zeit endet das Spiel und der erreichte Score wird angezeigt. Optionale Erweiterungen für Schnellere: • Mehrere Ziel Objekte mit unterschiedlicher Geschwindigkeit. • „Gefährliche“ Objekte, die Punkte abziehen oder das Spiel vorzeitig beenden. • Anzeige eines Highscores (z. B. in einer Datei speichern und beim Start laden).

Programmierelemente, die du verwenden sollst In deinem Pygame Programm sollen folgende Elemente klar erkennbar sein: • Variablen Für Positionen (x, y), Geschwindigkeit, Punktestand, Restzeit und Spielzustand (z. B. running = True). • Schleifen Eine Hauptspielschleife, z. B. python running = True while running: # Events, Logik, Zeichnen In dieser Schleife laufen Event Verarbeitung, Spiellogik und Zeichnen ab. • Bedingungen (if / elif / else) o Auswertung der Tastatureingaben (Pfeiltasten, ESC). o Randabfrage für Spielfigur/Ziel Objekte (nicht aus dem Fenster laufen). o Kollisionserkennung mit if player_rect.colliderect(target_rect):. o Überprüfung, ob die Spielzeit abgelaufen ist. • Events / Ereignisse Event Schleife mit for event in pygame.event.get():, Reaktion auf QUIT (Fenster schließen) und KEYDOWN für die Steuerung.

Arbeitsauftrag in drei Phasen

1. Konzeptskizze (ca. 10 Minuten) o Skizziere dein Spielfeld (Fenstergröße, Startposition der Figur, Bewegungsrichtung des Ziels). o Notiere: Wie wird gesteuert? Wann gibt es einen Punkt? Wann ist das Spiel zu Ende?
2. Implementierung in Pygame (ca. 60 Minuten) o Installiere pygame (z. B. mit pip install pygame) und binde es dann mit import pygame in das eigene Programm ein. o Starte mit einem minimalen Pygame Grundgerüst: Fenster, Hauptschleife, Event Handling. o Füge zuerst die Spielfigur und ihre Tastatursteuerung hinzu. o Implementiere dann das Ziel Objekt mit automatischer Bewegung und Kollisionserkennung. o Ergänze Score Anzeige (z. B. mit pygame.font) und Zeitbegrenzung.
3. Reflexion (Restzeit / Hausaufgabe) o Markiere in deinem Code mindestens eine Schleife und eine Bedingung und kommentiere kurz, warum sie für das Spiel nötig sind. o Schreibe 2–3 Sätze dazu, was dir beim Programmieren mit Pygame geholfen hat (z. B. Rechtecke, Events) und was du beim nächsten Mal anders machen würdest.

Code zum Spiel

import pygame import random import sys

Fenstergröße

WIDTH = 800 HEIGHT = 600

Geschwindigkeiten

PLAYER_SPEED = 5 TARGET_SPEED = 4

Spielzeit in Sekunden

GAME_DURATION = 30

pygame.init() screen = pygame.display.set_mode((WIDTH, HEIGHT)) pygame.display.set_caption("Catch the Target") clock = pygame.time.Clock() font = pygame.font.Font(None, 36)

Spielfigur

player_rect = pygame.Rect(50, 50, 50, 50) player_color = (50, 150, 250)

Ziel-Objekt

target_rect = pygame.Rect( random.randint(100, WIDTH - 100), random.randint(100, HEIGHT - 100), 40, 40, ) target_color = (250, 80, 80)

target_speed_x = TARGET_SPEED target_speed_y = TARGET_SPEED

Spielzustand

score = 0 running = True start_ticks = pygame.time.get_ticks()

def reset_target(): global target_rect, target_speed_x, target_speed_y target_rect.x = random.randint(50, WIDTH - target_rect.width - 50) target_rect.y = random.randint(50, HEIGHT - target_rect.height - 50) target_speed_x = random.choice([-TARGET_SPEED, TARGET_SPEED]) target_speed_y = random.choice([-TARGET_SPEED, TARGET_SPEED])

while running: # Events / Ereignisse for event in pygame.event.get(): if event.type == pygame.QUIT: running = False elif event.type == pygame.KEYDOWN: if event.key == pygame.K_ESCAPE: running = False

# Tastatureingaben für Bewegung
keys = pygame.key.get_pressed()
if keys[pygame.K_LEFT]:
    player_rect.x -= PLAYER_SPEED
if keys[pygame.K_RIGHT]:
    player_rect.x += PLAYER_SPEED
if keys[pygame.K_UP]:
    player_rect.y -= PLAYER_SPEED
if keys[pygame.K_DOWN]:
    player_rect.y += PLAYER_SPEED

# Randabfrage Spielfigur
if player_rect.left < 0:
    player_rect.left = 0
if player_rect.right > WIDTH:
    player_rect.right = WIDTH
if player_rect.top < 0:
    player_rect.top = 0
if player_rect.bottom > HEIGHT:
    player_rect.bottom = HEIGHT

# Ziel bewegt sich und prallt am Rand ab
target_rect.x += target_speed_x
target_rect.y += target_speed_y

if target_rect.left < 0 or target_rect.right > WIDTH:
    target_speed_x = -target_speed_x
if target_rect.top < 0 or target_rect.bottom > HEIGHT:
    target_speed_y = -target_speed_y

# Kollisionserkennung
if player_rect.colliderect(target_rect):
    score += 1
    reset_target()

# Zeitbegrenzung prüfen
seconds_passed = (pygame.time.get_ticks() - start_ticks) / 1000
time_left = max(0, GAME_DURATION - int(seconds_passed))
game_over = time_left <= 0

# Bildschirm zeichnen
screen.fill((30, 30, 40))
pygame.draw.rect(screen, player_color, player_rect)
pygame.draw.rect(screen, target_color, target_rect)

score_text = font.render(f"Punkte: {score}", True, (255, 255, 255))
time_text = font.render(f"Zeit: {time_left}s", True, (255, 255, 255))
screen.blit(score_text, (20, 20))
screen.blit(time_text, (20, 60))

if game_over:
    end_text = font.render("Zeit abgelaufen! Spielende.", True, (255, 255, 0))
    final_text = font.render(f"Gesamtpunkte: {score}", True, (255, 255, 255))
    restart_text = font.render("Drücke ESC oder schließe das Fenster.", True, (200, 200, 200))
    screen.blit(end_text, (180, 250))
    screen.blit(final_text, (260, 300))
    screen.blit(restart_text, (180, 350))

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

if game_over:
    # Warten, bis der Spieler das Fenster schließt oder ESC drückt
    while True:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False
                break
            elif event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
                running = False
                break
        if not running:
            break
        clock.tick(10)

pygame.quit() sys.exit()

Code analysieren

** Erkennbare Programmierkonzepte

• Im Code stecken viele grundlegende Programmierkonzepte: Variablen (z.B. WIDTH, score, target_speed_x), eine Schleife für den Spielablauf (while running:), eine Funktion (reset_target()), einfache Datenstrukturen/Objekte (pygame.Rect) sowie Ereignisbehandlung und Bedingungen.

** Ist der Code für Schüler*innen verständlich? Was würde überfordern?

• Für viele Schüler*innen (v.a. Sek I / frühe Sek II) ist der Code in dieser Form zu komplex: Es kommen auf einmal sehr viele neue Dinge zusammen (externes Modul pygame, Ereignisschleife, Koordinatensystem, Kollision, Zeitmessung, verschachtelte Bedingungen, global in der Funktion), und es ist schwer, die Spielidee vom technischen „Drumherum“ zu trennen.
• Aber Einzelne Teile des Codes mit z.B. If-Bedinungen kann man gut vorzeigen und den Schülern verständlich erklären, ohne das es zu Verwirrungen kommt

** Wie könnte man den Code vereinfachen oder in Teilschritte zerlegen?

• Schrittweiser Aufbau in Unterrichtsphasen
• Struktur klarer machen: Den Code in logisch benannte Funktionen aufteilen, z.B. handle_events(), update_game(), draw_screen(), check_collision().
• Komplexität reduzieren: Für eine erste Version auf Zeitmessung verzichten (kein GAME_DURATION, keine time_left‑Berechnung).

Didaktischen Ansatz wählen und begründen

• Ich würde eine Kombination aus Spiralansatz und Live‑Coding wählen
• Inhaltlich würde ich das Spiel schrittweise ausbauen: Version 1 nur bewegen, Version 2 mit Ziel, Version 3 mit Punkten, Version 4 mit Zeitlimit. Bei Bedarf Live Coding Sessions zu paar Bereichen machen. Dann SuS selber programmieren lassen oder Übungen dazu machen oder Teile weglassen als Vervollständigungsaufgabe.
• So werden sie Schrittweise mit Hilfestellung herangeführt und die Komplexität wird Schrittweise gesteigert.
• Als Einstieg eignen sich: Die IF-Bedinungen für key oder player

Reflexion

• Bei meinem Ansatz (Spiralansatz + Live‑Coding mit dem Catch‑Spiel) sehe ich vor allem Schwierigkeiten, wenn mehrere neue Ideen gleichzeitig zusammenkommen: Einige Schüler*innen werden zwar die einzelnen Versionen verstehen (z.B. nur Bewegung oder nur Kollision), aber Mühe haben, später das Gesamtprogramm geistig zu überblicken und die Verbindung zwischen den Teilen (Ereignisse, Spiellogik, Zeichnen) zu erkennen.
• Sinnvoll sind deshalb gut strukturierte Kommentierung und Hilfestellungen, etwa klar abgegrenzte Code‑Blöcke mit kurzen Überschriften („Eingaben“, „Bewegung“, „Punkte“, „Zeit“) sowie kleine Hinweis‑Karten oder Musterlösungen zu typischen Problemen, und außerdem Partnerarbeit
• Die KI‑Unterstützung hat meinen eigenen Arbeitsprozess deutlich erleichtert, weil sie mir schnell Formulierungen, Strukturvorschläge und didaktische Perspektiven geliefert hat; für den Unterricht heißt das aus meiner Sicht, dass KI ein hilfreiches Werkzeug für Planung, Materialerstellung und auch für Schüler*innen beim Erklären und Umformulieren von Code sein kann – aber ich muss bewusst Lernphasen einplanen, in denen die Klasse ohne KI‑„Abkürzungen“ lesen, verstehen und selbst denken muss, damit zentrale Programmierkompetenzen nicht an das Tool delegiert werden.