Sitzung_08

sitzung-04.md

@@ -0,0 +1,211 @@
+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

sitzung-05.md

@@ -0,0 +1,56 @@
+Videoeinstieg (https://www.youtube.com/watch?v=pcjapsP3noM)
+•	Spiele = Gamification?
+    o Game-based: hier steht Lernen NICHT im Vordergrund
+    o Lernspiele: Für Lernen designe 
+    o Gamification: Aufgaben unabhängig von Inhalten mit Punkten belohnt 
+    o Simulationen 
+    o Modellieren 
+ 
+•	Argumente für spielerisches Lernen
+    o Entwicklung gesundes Selbstvertrauen durch freies Spielen
+    o Höhere Lernleistung dank gesteigertem Interesse und entsprechend stärkerer intrinsischer Motivation 
+    o Erhöhte Selbständigkeit der SuS durch Experimentieren und Problemlösen
+    o Förderung von Kompetenzen, die in der zunehmen digital geprägten Gesellschaft wichtig sind (4k-Modell – Kreativität, kritische Denken, kollaboration, kommunikation)
+    o Verankerung des Erlenten durch Emotionen 
+•	Fünf Säulen der Gamification im Informatikunterricht
+•	Elemente Gamification 
+    o Storytelling 
+    o Avataren  Spieler werden zu Helden
+    o Epic Meaning  werden Teil von einem Großen ganzen 
+    o Quest und Sidequests  Missionen im Team oder einzeln erfüllt
+    o Erfahrungspunkte
+    o Level
+    o Ranglisten  auch Problem für schwächer SuS wegen Demotivation 
+    o Badges 
+    o Fortschrittanzeige
+    o Skill-Tree
+•	Informatik Unterricht
+    o Spiel Programmieren
+    o Physical Computing mit Storytelling
+    o Kommerzielle Spiele
+    o Simulationen
+    o Strukturelle Gamification 
+    o Digitale Lernspiele 
+    o Escape-Games
+Abschlussdiskussion
+•	Welche Tools überzeugen am meisten und warum? 
+    o CheckiO überzeigt am meisten
+    o Fokus echtes Programmieren 
+    o Community-Lösung hilfreich 
+    o Gamification unterstützt Lernen statt abzulenken 
+    o Gute Mischung aus Motivation und Inhalt 
+•	Grenze zwischen Gamification und Ablenkung
+    o Sinnvoll für Motivation und Feedback 
+    o Problematisch Fokus nur auf Punkten/Belohnung
+    o Spiel darf Lernziele nicht überdecken
+    o Wettbewerb kann stressig werden 
+•	Extrinsisch vs. intrinsische Motivation 
+    o Punkte motivierend kurzfristig
+    o Echtes Interesse wichtig für langfristiges Lernen 
+    o Gamification gut als Einstieg
+•	Rolle von Gamification im Informatikunterricht
+    o Passt gut zu Programmieren und Problemlösen
+    o Direktes Feedback motiviert
+    o Spielerisches Lernen leichter umsetzbar
+    o Informatik ähnelt oft bereits Spielmechaniken 
+

sitzung-06

@@ -0,0 +1,57 @@
+Entwicklung einer Programmierprojekteinheit: 
+Übergeordnetes Ziel (Studienleistung bis Semesterende)
+Planen Sie eine interaktive Unterrichtseinheit für das Fach Informatik, in der die Schülerinnen und Schüler in Zweiergruppen ein Spiel in einer Programmiersprache bzw. Programmierumgebung ihrer Wahl entwickeln (z. B. Scratch, Python, JavaScript …). Die Aufgabe umfasst die Konzeption des Spiels, die technische Umsetzung, die detaillierte Dokumentation und die grafische Darstellung des Spielablaufs. Ein wesentlicher Teil Ihrer Planung beinhaltet die Erstellung eines Anforderungskatalogs und eines Bewertungsbogens, die als Grundlage für die Bewertung der Schülerarbeiten dienen.
+
+1.	Bildungsplan: 
+•	Bundesland: Baden-Württemberg
+•	Schulart: TG
+•	Klassenstufe: Eingangsklasse – 11
+o	Es kann nicht von Vorkenntnissen ausgegangen werden, da es eine Eingangsklasse ist und der Wissensstand damit sehr individuell 
+•	Kompetenzen: Die Schülerinnen und Schüler erstellen und implementieren einfache Spiele.
+o	Prozessbezogenen Kompetenzen
+	Strukturieren und Vernetzten 
+•	Spiel in Teilprobleme zerlegen 
+•	Planen Spiellogik
+•	Strukturieren Programmcode
+•	Vernetzen Spielobjekte, Eingaben & Ergebnisse
+	Modellieren und Implementieren  
+•	Entwicklung eines Spielmodells
+•	Umsetzung von Algorithmen 
+•	Programmierung von Figuren, Steuerung, Spielregeln 
+	Kommunizieren und Kooperieren 
+•	Zweiergruppen 
+	Analysieren und Bewerten 
+•	Fehlersuche - Debugging
+o	Fachkompetenz
+•	Stoffverteilungsplan: 2 HJ der Eingangsklasse
+•	Zielformulierung je Stunde:  SuS entwickeln und implementieren einfache 2D-Spiele anhand eigener Entwürfe und Vorgaben 
+2.	Anforderungskatalog
+•	Genutzt wird Scratch – geeignet für den Fokus Projektarbeit, Spielentwicklung und Problemlösung – Fokus nicht auf komplexer Syntax
+•	2D-Spiel mit dem Spielfigur Objekte sammeln und Hindernisse ausweichen – muss – dafür gibt es Punkte
+o	Optional: es läuft ein Counter mit, in dem so viel Punkte wie möglich erreicht werden sollen 
+•	Anforderungen
+o	Steuerung – Spielfigur muss per Tastatur steuerbar sein
+o	Variable – Mindestens 2 Variable müssen verwendet werden (z.B. Punkte, Leben, Zeit)  
+o	Schleifen - das Spiel muss 2 Schleifen beinhalten  
+o	Bedingungen – mind. 3 Bedingungen 
+o	Figuren - mindestens 3 unterschiedliche Figuren (Hindernisse, Sammelobjekte, …)
+o	Nachrichten – mindestens 2 Nachrichten müssen ausgegeben werden 
+o	Funktionalität – Spiel muss spielbar sein
+o	Benutzeroberfläche – Startbild und Endbildschirm einbauen
+o	Spielende – es gibt ein Szenario zum Gewinnen und Verlieren
+o	Benutzerfreundlich – verständliche Steuerung & klare Bedienung
+o	Gestaltung – Verwendung passender Grafik, Farben, Hintergründe
+o	Sinnvoller Spielablauf
+o	Erweiterungen möglich – zusätzliche Funktionen (z.B Timer, Sound, mehrere Level) 
+•	Dokumentation	
+o	Titel des Spiels
+o	Beschreibung Spielidee
+o	Erklärung Spielregeln
+o	Zustandsdiagramm
+	Startzustand
+	Spiel läuft
+	Pause
+	Gewinn
+	Verlust
+o	Aufgabenverteilung
+o	Reflexion 

sitzung-md07

@@ -0,0 +1,71 @@
+3.	Bewertungsbogen
+Anforderung	Punkte
+Technisch	50
+Spielfigur muss per Tastatur steuerbar	4
+2 Variable sinnvoll verwendet 	2
+2 Schleifen korrekt verwendet  	4
+3 Bedingungen korrekt verwendet	6
+3 verschiedene Figuren eingesetzt	3
+2 Nachrichten müssen ausgegeben werden – z.B. „Du hast verloren“	2
+Spiel ist spielbar und funktionsfähig	10
+Startbildschirm vorhanden	2
+Endbildschirm vorhanden 	2
+Szenario für Gewinner und Verlierer berücksichtigt	4
+Benutzerfreundliche Steuerung/Bedienung	2
+Sinnvoller & nachvollziehbarer Spielablauf	4
+Saubere Programmierstruktur – Übersichtlich, sinnvolle Aufteilung, kein überflüssiger Code, nachvollziehbar	3
+Verwendung von sinnvollen Kommentaren	2
+Kreativ	15
+Eigenständige und kreative Spielidee	5
+Passende Grafiken, Figuren, Hintergründe	4
+Farbgestaltung unterstützt Spielverständnis (Grün – Gewinn) 	2
+Zusätzliche Funktionen (z.B Timer, Sound, Level)
+•	Keine Erweiterung
+•	Erweiterung nur teilweise Umgesetzt
+•	Eine sinnvolle Erweiterung
+•	Mehrere sinnvolle Erweiterungen	
+0
+1
+2
+4
+
+Präsentatorisch	15
+Verständliche Vorstellung des Spiels (Aufbau der Präsentation)	3
+Spielidee und Regeln erläutert	2
+Technische Umsetzung erläutert	2
+Demo des Spiels	2
+Fragen beantworten 	1
+Auftreten (deutliche Sprache, Blickkontakt, angemessen Lautstärke)	5
+Dokumentation	20
+Titel des Spiels vorhanden	1
+Spielidee verständlich beschrieben	3
+Spielregeln erläutert	3
+Zustandsdiagramm vorhanden
+•	Startzustand
+•	Spiel läuft
+•	Pause
+•	Gewinn
+•	Verlust	5
+Aufgabenverteilung dokumentiert 	2
+Reflexion
+•	Gruppenarbeit 
+•	Technische Herausforderungen	5
+Übersichtlichkeit der Dokumentation 	2
+Gesamtpunktzahl	100
+
+4.	Differenzierung
+o	Diagnose: Wie erheben Sie zu Beginn den Lernstand Ihrer Klasse?
+	Kleine Scratch-Aufgabe, bei der Figur mithilfe von Pfeiltasten gesteuert werden sollen  Grundlegende Kenntnisse werden abgefragt
+	Ergänzend kleine Selbsteinschätzung um Vorkenntnisse abzufragen
+o	Pauschale Angebote: Welche Differenzierungsangebote stellen Sie für alle bereit? (z. B. gestufte Hilfekarten, Pflicht-/Küraufgaben, Lerntheke) 
+	Lerntheke – mit dem Aufbau/Anleitung von Variablen, Bedingungen, Schleifen – hier sind auch kleine Aufgaben vorhanden die explizit auf ein Komponente abzielt (Innere Differenzierung)
+	Pflichtlektüren 
+o	Qualitativ & quantitativ: Geben Sie je ein konkretes Beispiel für eine qualitative und eine quantitative Differenzierung in Ihrem Projekt. 
+	Qualitativ: 
+	Quantitativ:
+o	Bewertung & Fairness: Wie berücksichtigt Ihr Bewertungsbogen differenzierte Anforderungen? Wird für alle dasselbe verlangt, oder gibt es ein gemeinsames Grundniveau mit gestuften Zusatzkriterien? Begründen Sie, wie Sie trotz Differenzierung fair bewerten.
+	Haben ein Grundniveau das jede Gruppe erreichen sollte. Das stellt die technischen Mindestanforderungen voraus
+	Gewährleisten, dass auch mit der „Mindestanforderung“ eine gute Leistung erreicht werden kann 
+	Bewertungskritierien sind vorhanden, die nicht NUR auf die technische Umsetzung fokussiert (z.B. Kreativität, Präsentation, Dokumentation), sodass verschiedene Stärken in der Beurteilung miteinfließen
+	Leistungsstärkere Schüler haben trotzdem die Möglichkeit bessere Leistung zu erbringen, die in einem bestimmten Umfang auch bei der Benotung berücksichtigt wird
+	Transparenz bereits zu Beginn der Umsetzung bzgl. der Punktevergabe