# 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(...)). 
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)**
- Auswertung der Tastatureingaben (Pfeiltasten, ESC).
- Randabfrage für Spielfigur/Ziel Objekte (nicht aus dem Fenster laufen).
- Kollisionserkennung mit if player_rect.colliderect(target_rect):.
- Ü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.


