sitzung-04.md aktualisiert

sitzung-04.md

@@ -1,6 +1,6 @@
-### Sitzung 4: Didaktische Ansätze zum Programmierenlernen
+# Sitzung 4: Didaktische Ansätze zum Programmierenlernen
 
-** Aufgabe: Entwickeln Sie ein Spiel — didaktisch durchdacht (ca. 60 Min.)
+## 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
@@ -17,39 +17,46 @@ Welche Programmierelemente die Schüler*innen dabei lernen (z. B. Schleifen, B
 
 ## 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
+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
+- **Variablen**
 Für Positionen (x, y), Geschwindigkeit, Punktestand, Restzeit und Spielzustand (z. B. running = True).
-•	Schleifen
+- **Schleifen**
 Eine Hauptspielschleife, z. B.
+
 python
 running = True
 while running:
-    # Events, Logik, Zeichnen
+    #Events, Logik, Zeichnen
+
 In dieser Schleife laufen Event Verarbeitung, Spiellogik und Zeichnen ab.
-•	Bedingungen (if / elif / else)
+
-o	Auswertung der Tastatureingaben (Pfeiltasten, ESC).
+**Bedingungen (if / elif / else)**
-o	Randabfrage für Spielfigur/Ziel Objekte (nicht aus dem Fenster laufen).
+- Auswertung der Tastatureingaben (Pfeiltasten, ESC).
-o	Kollisionserkennung mit if player_rect.colliderect(target_rect):.
+- Randabfrage für Spielfigur/Ziel Objekte (nicht aus dem Fenster laufen).
-o	Überprüfung, ob die Spielzeit abgelaufen ist.
+- Kollisionserkennung mit if player_rect.colliderect(target_rect):.
-•	Events / Ereignisse
+- Ü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.
 
@@ -67,20 +74,24 @@ o	Ergänze Score Anzeige (z. B. mit pygame.font) und Zeitbegrenzung.
 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
+### Code zum Spiel
+
 import pygame
 import random
 import sys
 
-# Fenstergröße
+**Fenstergröße**
+
 WIDTH = 800
 HEIGHT = 600
 
-# Geschwindigkeiten
+**Geschwindigkeiten**
+
 PLAYER_SPEED = 5
 TARGET_SPEED = 4
 
-# Spielzeit in Sekunden
+**Spielzeit in Sekunden**
+
 GAME_DURATION = 30
 
 pygame.init()
@@ -89,11 +100,13 @@ pygame.display.set_caption("Catch the Target")
 clock = pygame.time.Clock()
 font = pygame.font.Font(None, 36)
 
-# Spielfigur
+**Spielfigur**
+
 player_rect = pygame.Rect(50, 50, 50, 50)
 player_color = (50, 150, 250)
 
-# Ziel-Objekt
+**Ziel-Objekt**
+
 target_rect = pygame.Rect(
     random.randint(100, WIDTH - 100),
     random.randint(100, HEIGHT - 100),
@@ -105,7 +118,7 @@ target_color = (250, 80, 80)
 target_speed_x = TARGET_SPEED
 target_speed_y = TARGET_SPEED
 
-# Spielzustand
+**Spielzustand**
 score = 0
 running = True
 start_ticks = pygame.time.get_ticks()
@@ -127,7 +140,8 @@ while running:
             if event.key == pygame.K_ESCAPE:
                 running = False
 
-    # Tastatureingaben für Bewegung
+    **Tastatureingaben für Bewegung**
+
     keys = pygame.key.get_pressed()
     if keys[pygame.K_LEFT]:
         player_rect.x -= PLAYER_SPEED
@@ -138,7 +152,8 @@ while running:
     if keys[pygame.K_DOWN]:
         player_rect.y += PLAYER_SPEED
 
-    # Randabfrage Spielfigur
+    **Randabfrage Spielfigur**
+
     if player_rect.left < 0:
         player_rect.left = 0
     if player_rect.right > WIDTH:
@@ -148,7 +163,8 @@ while running:
     if player_rect.bottom > HEIGHT:
         player_rect.bottom = HEIGHT
 
-    # Ziel bewegt sich und prallt am Rand ab
+    **Ziel bewegt sich und prallt am Rand ab**
+
     target_rect.x += target_speed_x
     target_rect.y += target_speed_y
 
@@ -157,17 +173,18 @@ while running:
     if target_rect.top < 0 or target_rect.bottom > HEIGHT:
         target_speed_y = -target_speed_y
 
-    # Kollisionserkennung
+    **Kollisionserkennung**
+
     if player_rect.colliderect(target_rect):
         score += 1
         reset_target()
 
-    # Zeitbegrenzung prüfen
+    **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
+    **Bildschirm zeichnen**
     screen.fill((30, 30, 40))
     pygame.draw.rect(screen, player_color, player_rect)
     pygame.draw.rect(screen, target_color, target_rect)
@@ -207,26 +224,26 @@ sys.exit()
 
 ## Code analysieren
 
-** Erkennbare Programmierkonzepte
+**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?
+**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?
+**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 
+### 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
+### 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