Spielidee: „Escape“ (Labyrinth-Spiel)
Ziel des Spiels
Du steuertst ein Ritter durch ein Labyrinth und musst den Ausgang finden, ohne dabei am Feuer zu „verbrennen“. Auf dem Weg müssen alle Schatztruhen eingesammelt werden, um den Eingang zur Burg freizuschalten. 
Spielmechanik und Steuerung
Die Figur wird mit den Pfeiltasten gesteuert.
•	Ein Feuer blockiert den Weg 
•	Schatztruhen müssen alle eingesammelt werden 
•	Der Ausgang öffnet sich erst, wenn alle Schatztruhen gesammelt wurden 
•	Das Spiel ist entweder vorbei, wenn der Ritter das Feuer berührt oder zur Burg gelangt
Programmierelemente, die gelernt werden
•	Events: Tastatureingaben steuern die Bewegung 
•	Schleifen: sorgen dafür, dass das Spiel dauerhaft läuft (Game Loop) 
•	IF-Bedingungen: prüfen z. B. „Wenn Schatztruhe gesammelt → öffne Ausgang“ 
•	Kollisionen: erkennen Berührungen mit Wänden, Schlüsseln oder Feuer 
•	Variablen: speichern Punktestand oder Anzahl gesammelter Schlüssel
•	Einbetten von Bildern: Grafikausgaben
•	Datenstruktur: Das Labyrinth ist eine 2D-Liste
•	Funktionen: Anwendung von Funktionen 
2.	Aufgabe
Erstelle ein 2D-Labyrinth-Spiel in Python, in dem die Spielerin oder der Spieler eine Figur mit den Pfeiltasten durch ein Labyrinth steuert, um den Ausgang zu erreichen, ohne Hindernisse zu berühren. Wände blockieren den Weg, Hindernisse wie flammen müssen vermieden werden. Im Labyrinth müssen Schatztruhen eingesammelt werden, die notwendig sind, um den Ausgang freizuschalten. Verwende dabei grundlegende Programmierelemente wie Events (für die Steuerung), eine Game Loop (Schleife), Bedingungen (z. B. zum Öffnen des Ausgangs nach dem Sammeln aller Schlüssel), Kollisionserkennung sowie Variablen zur Speicherung von Spielzuständen wie Punktestand oder gesammelten Schlüsseln.


import pygame
import sys

# Initialisierung
pygame.init()

# Fenster
WIDTH, HEIGHT = 640, 480
TILE = 32
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Labyrinth Spiel")

# Farben
WHITE = (255, 255, 255)

# 🔥 BILDER LADEN
wall_img = pygame.image.load("assets/mauer.png")
key_img = pygame.image.load("assets/key.png")
door_closed_img = pygame.image.load("assets/door_closed.png")
door_open_img = pygame.image.load("assets/door_open.png")
player_img = pygame.image.load("assets/player.png")
fire_img = pygame.image.load("assets/wall.png")

# skalieren
wall_img = pygame.transform.scale(wall_img, (TILE, TILE))
key_img = pygame.transform.scale(key_img, (TILE, TILE))
door_closed_img = pygame.transform.scale(door_closed_img, (TILE, TILE))
door_open_img = pygame.transform.scale(door_open_img, (TILE, TILE))
player_img = pygame.transform.scale(player_img, (TILE, TILE))
fire_img = pygame.transform.scale(fire_img, (TILE, TILE))

# Level
level = [
    [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],
    [1,0,0,0,2,0,0,0,0,0,0,0,4,0,0,0,2,0,3,1],
    [1,0,1,1,1,0,1,1,1,1,1,0,1,1,1,0,1,1,0,1],
    [1,0,0,0,1,0,0,0,0,2,1,0,0,0,1,0,0,0,0,1],
    [1,1,1,0,1,1,1,1,0,1,1,1,1,0,1,1,1,1,0,1],
    [1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,1],
    [1,0,1,1,1,1,0,1,1,1,1,0,1,1,1,1,0,1,0,1],
    [1,0,0,2,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1],
    [1,0,1,1,1,1,1,1,1,0,1,1,1,1,1,1,0,1,0,1],
    [1,0,0,0,0,0,0,0,1,0,0,0,0,0,2,0,0,0,0,1],
    [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],
]

# Spieler
player_x, player_y = 1, 1
keys_collected = 0
total_keys = sum(row.count(2) for row in level)

clock = pygame.time.Clock()

def draw():
    screen.fill(WHITE)
    
    for y, row in enumerate(level):
        for x, tile in enumerate(row):
            pos = (x*TILE, y*TILE)
            
            if tile == 1:
                 # pygame.draw.rect(screen, (0,0,0), (*pos, TILE, TILE))
               screen.blit(wall_img, pos)
            elif tile == 2:
                screen.blit(key_img, pos)
            elif tile == 3:
                # Tür je nach Zustand
                if keys_collected == total_keys:
                    screen.blit(door_open_img, pos)
                else:
                    screen.blit(door_closed_img, pos)
            elif tile == 4:
                screen.blit(fire_img, pos)
              #  pygame.draw.rect(screen, (255,0,0), (*pos, TILE, TILE))

    # Spieler
    screen.blit(player_img, (player_x*TILE, player_y*TILE))
    
    pygame.display.flip()

def move(dx, dy):
    global player_x, player_y, keys_collected
    
    new_x = player_x + dx
    new_y = player_y + dy
    
    tile = level[new_y][new_x]
    
    if tile == 1:
        return
    
    if tile == 4:
        print("Game Over!")
        pygame.quit()
        sys.exit()
    
    if tile == 2:
        keys_collected += 1
        level[new_y][new_x] = 0
        print("Schlüssel gesammelt:", keys_collected)
    
    if tile == 3:
        if keys_collected == total_keys:
            print("Gewonnen!")
            pygame.quit()
            sys.exit()
        else:
            print("Du brauchst noch Schlüssel!")
            return
    
    player_x, player_y = new_x, new_y

# Game Loop
while True:
    clock.tick(10)
    
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
            sys.exit()
        
        if event.type == pygame.KEYDOWN:
            if event.key == pygame.K_LEFT:
                move(-1, 0)
            elif event.key == pygame.K_RIGHT:
                move(1, 0)
            elif event.key == pygame.K_UP:
                move(0, -1)
            elif event.key == pygame.K_DOWN:
                move(0, 1)

    draw()


3.	Aufgabe




Erkannte Programmierkonzepte:
•	Variablen: z. B. player_x, keys_collected, enemy_dir 
•	Schleifen: die while running-Schleife als Game Loop 
•	Funktionen: z. B. move_player(), move_enemy(), draw_level() 
•	Bedingungen: if-Abfragen für Kollisionen, Wände, Spielende 
•	Events: Reaktion auf Tastatureingaben
Verständlichkeit für Schüler*innen:
•	Gut nachvollziehbar: Spielfigur bewegen, einfache if-Abfragen 
•	Schwieriger: 
o	2D-Listen für das Level (abstrakt) 
o	Kollisionserkennung über Koordinaten 
o	„Game Loop“-Konzept (dauerhafte Schleife)
•	Was könnte überfordern?
o	Zusammenspiel vieler Konzepte auf einmal 
o	 kognitive Überlastung möglich
o	Verständnis von Raster/Koordinatensystem 
o	Game Loop
	insgesamt eher anspruchsvoll für Anfänger*innen

Vereinfachung / Zerlegung:
Der Code sollte in Teilschritte zerlegt werden:
1.	Grundgerüst von Spielfeld gegeben und nur mit der Bewegung der Spieler starten
2.	Nur Wände (keine Schatztruhen/Feuer) – if Bedingungen verstehen 
3.	Sammelobjekte hinzufügen  Zustand speichern 

4.	Didaktischer Ansatz
Kombination aus Leseansatz + Spiralansatz 
Warum ist dieser Ansatz für Ihr Spiel und diese Lerngruppe geeignet?:
Leseansatz: Verständnis aufbauen durch Beobachtung (Warum komme ich nicht durch die Wand, warum komme ich nicht durch die Tür,..)   hohe Motivation durch Spielcharakter 
Spiralansatz: Schrittweise Erweiterung von Einfacher zu Komplexer, da Spiel viele Konzepte verwendet, die bei zu Beginn überfordern können (Abhängig von Vorwissen) 

Wie genau würden Sie vorgehen? (z. B. fertigen Code als Lösungsbeispiel geben, Teile weglassen als Vervollständigungsaufgabe, schrittweise live entwickeln)
1.	Einstieg mit Leseansatz
Beobachtungsaufgabe: Was passiert beim Feuer? Wann öffnet sich die Burg? Was passiert beim Einsammeln der Truhen? 
2.	Code verstehen und Analysieren 
Zusammenhang zwischen Code und Spiel erkennen
3.	Erweiterung bestehendes Programm
SuS sollen Schatztruhe und Feuerstelle hinzufügen 
4.	Spiralansatz  Vertiefungsaufgabe
a)	Bewerbung verstehen
b)	Kollision mit Wänden 
c)	Sammeln von Truhen 
d)	Feuerstellen erstellen
e)	Schloss öffnet sich 
f)	BONUS: Gegner der sich im Spiel auch bewegt
Welche Teile des Codes eignen sich als Einstieg, welche erst später?
Einstieg:
Spielbewegung/einfache if-Bedingungen/Truhe sammeln
Später: 
Kollision mit Euer/Tür-Logik/Arbeiten mit 2D-Liste
