Kursvorlage
Flappy Farbenflug
Die Lernenden entwickeln in 12 aufeinander aufbauenden Schritten ein einfaches Flappy-Bird-artiges Spiel mit frameCraft. Dabei entstehen Spielfenster, Vogel, Eingabe, Schwerkraft, Hindernisse, Kollisionen, Punkte, steigende Schwierigkeit, Game Over und Neustart.
Didaktische Zielsetzung
Diese Vorlage führt schrittweise in die Entwicklung eines einfachen Flappy-Bird-artigen Spiels mit frameCraft ein und verbindet dabei sichtbare Spielobjekte mit Eingabe, Bewegung und Spielzuständen. Im Mittelpunkt stehen der Aufbau eines Spielfensters, die Modellierung von Entities mit Collidern und GFX-Formen sowie die strukturierte Umsetzung von Regeln für Steuerung, Schwerkraft, Hindernisse und Kollisionen. Der Kompetenzaufbau verläuft vom **Szenenaufbau** über **zeitbasierte Bewegung** bis zur **Spielmechanik** mit Punkten, steigender Schwierigkeit, Game Over und Neustart. Fachlich ist die Vorlage der Spielentwicklung mit frameCraft zuzuordnen und unterstützt insbesondere das Verständnis für Modellierung, Zustandsverwaltung und schrittweise Implementierung.
Kompetenzschwerpunkte
Die Vorlage bündelt fachliche und methodische Schwerpunkte der frameCraft-basierten Spielentwicklung in einer klaren Progression.
- Spielstruktur modellieren: Spielfenster, Szene, Szenenaufbau, Himmel, Boden und Dekoration werden als grundlegende frameCraft-Struktur angelegt.
- Entities fachlich einordnen: Vogel, Boden, Decke und Hindernisse werden über Entity, Collider, Tags und GFX-Formen als Spielobjekte umgesetzt.
- Eingaben abstrahieren: Tastatur- und Touch-Eingaben werden über Aktionen gebündelt und mit einer Sperre gegen Dauerimpulse abgesichert.
- Bewegung zeitbasiert implementieren: Vogelphysik und Hindernisbewegung nutzen Geschwindigkeit, Schwerkraft und ctx.dt für frameunabhängige Aktualisierung.
- Kollisionen und Zustände steuern: Trigger-Collider, Tags und Kollisionshandler führen zu Game Over und stoppen die Spiellogik über einen gespeicherten Spielzustand.
- Objekte wiederverwenden: Hindernisse werden als nummerierte Entity-Pools verwaltet, synchron bewegt und nach dem Verlassen des Bildschirms neu positioniert.
- Spielmechanik ausbauen: Punkte, einmalige Zählung pro Hindernis, steigende Schwierigkeit, sichtbare Rückmeldung und Neustart schließen den Spielablauf ab.
Informatik sichtbar machen: Bewegung, Zustände und Algorithmen im Spiel
Mit Flappy Farbenflug zeigt frameCraft besonders anschaulich, wie sich klassische Informatikinhalte mit einem unmittelbar verständlichen und motivierenden Anwendungsszenario verbinden lassen. Die Lernenden arbeiten von Beginn an mit einem sichtbaren, lauffähigen Spiel und erweitern dieses schrittweise um neue Regeln. Dabei bleibt der eigentliche Python-Code überschaubar: Technische Details wie Fensterverwaltung oder Rendering stehen nicht im Vordergrund, während Variablen, Funktionen, Bedingungen, Schleifen und Zustände direkt das sichtbare Verhalten des Spiels bestimmen. Für den Unterricht entsteht dadurch ein enger Zusammenhang zwischen Code und Wirkung – Änderungen können sofort ausprobiert, beobachtet und begründet werden.
def vogel_bewegen(ctx):
vogel = hole_entity(ctx, 'vogel')
vy = hole_wert(ctx, 'vogel_vy', 0)
vy = vy + SCHWERKRAFT * ctx.dt
ctx.vars['vogel_vy'] = vy
vogel.y = vogel.y + vy * ctx.dtDie Bewegung des Vogels bietet beispielsweise einen sehr zugänglichen Einstieg in zeitabhängige Simulationen. Geschwindigkeit und Position werden nicht einfach um feste Pixelwerte verändert, sondern mithilfe von ctx.dt auf die tatsächlich vergangene Zeit bezogen. Damit lässt sich im Informatikunterricht nachvollziehbar erklären, warum Animationen und Simulationen unabhängig von der Bildwiederholrate berechnet werden sollten. Gleichzeitig entsteht eine natürliche Verbindung zu mathematischen und physikalischen Modellen: Die Geschwindigkeit verändert sich durch die Schwerkraft, die Geschwindigkeit wiederum verändert die Position. Schon mit wenigen Zeilen Code können Lernende untersuchen, wie unterschiedliche Werte für SCHWERKRAFT oder SPRUNG_KRAFT das System beeinflussen.
def vogel_steuern(ctx):
if not aktion_aktiv(ctx, 'flap'):
ctx.vars['flap_sperre'] = False
if aktion_aktiv(ctx, 'flap') and not hole_wert(ctx, 'flap_sperre', False):
ctx.vars['flap_sperre'] = True
ctx.vars['vogel_vy'] = SPRUNG_KRAFTAuch die Eingabesteuerung enthält mehr Informatik, als zunächst sichtbar ist. Mit der Variablen flap_sperre wird verhindert, dass eine gehaltene Taste in jedem Frame erneut einen Sprung auslöst. Lernende begegnen damit einem typischen Problem ereignisorientierter Systeme: Sie müssen zwischen einem Zustand – „Taste ist gedrückt“ – und einem Ereignis – „Taste wurde neu gedrückt“ – unterscheiden. Diese kleine Spielmechanik bietet einen sehr konkreten Anlass, Boolesche Variablen, Zustandswechsel und Kontrollfluss zu behandeln, ohne sie zunächst über abstrakte Beispiele einführen zu müssen.
if oben.x < -PIPE_B:
neues_x = weiteste_pipe_x(ctx) + PIPE_ABSTAND
neues_hindernis(ctx, i, neues_x)Besonders ergiebig ist die Hindernisverwaltung. Die Pipes werden nicht fortlaufend neu erzeugt, sondern nach dem Verlassen des sichtbaren Bereichs wiederverwendet und an einer neuen Position eingesetzt. Dadurch lernen Schülerinnen und Schüler ein wichtiges Prinzip moderner Softwareentwicklung kennen: bestehende Objekte können ihren Zustand verändern und erneut verwendet werden. Gleichzeitig wird der Umgang mit Objektgruppen und Schleifen eingeübt. Die Funktion weiteste_pipe_x durchsucht beispielsweise alle Hindernisse nach der größten x-Position und liefert damit die Grundlage dafür, das nächste Hindernis korrekt hinter der bestehenden Sequenz einzuordnen.
def weiteste_pipe_x(ctx):
groesstes_x = 0
for i in range(PIPE_ANZAHL):
oben = hole_entity(ctx, 'pipe_oben_%d' % i)
if oben is not None and oben.x > groesstes_x:
groesstes_x = oben.x
return groesstes_xAn diesem kleinen Algorithmus lassen sich grundlegende Muster der Informatik besonders gut herausarbeiten: Eine Menge von Elementen wird durchlaufen, ein Vergleich durchgeführt und dabei schrittweise ein Ergebnis aufgebaut. Das Prinzip entspricht dem klassischen Bestimmen eines Maximums und wird hier unmittelbar für eine reale Funktion des Spiels benötigt. Solche Stellen eignen sich im Unterricht sehr gut, um bekannten Algorithmik-Inhalten einen sichtbaren Zweck zu geben und anschließend Varianten entwickeln zu lassen – etwa die linkeste Pipe zu bestimmen, Abstände auszuwerten oder Hindernisse nach bestimmten Kriterien auszuwählen.
punkte = hole_wert(ctx, 'punkte', 0)
gap = PIPE_GAP_START - punkte * 2
gap = clamp(gap, PIPE_GAP_MIN, PIPE_GAP_START)
neues_tempo = START_SPEED + punkte * SPEED_PLUS_PRO_PUNKT
ctx.vars['tempo'] = clamp(
neues_tempo,
START_SPEED,
MAX_SPEED
)Ein weiterer didaktisch interessanter Bereich ist das algorithmische Balancing. Der Schwierigkeitsgrad entsteht nicht durch fest vorgegebene Level, sondern wird aus dem aktuellen Punktestand berechnet: Mit zunehmender Punktzahl steigt das Tempo, während die Durchfluglücke kleiner wird. Gleichzeitig begrenzt clamp beide Entwicklungen auf sinnvolle Wertebereiche. Lernende können hier unmittelbar erkennen, wie mathematische Beziehungen und Randbedingungen das Verhalten eines Programms bestimmen. Besonders geeignet sind experimentelle Aufgaben: Wie schnell darf das Tempo steigen? Welche minimale Lücke bleibt spielbar? Soll die Schwierigkeit linear wachsen oder beispielsweise nur alle fünf Punkte verändert werden? Aus einfachen Parameteränderungen entstehen so Hypothesen, Tests und begründete Entscheidungen.
if hole_wert(ctx, 'spiel_zustand', 'laeuft') != 'laeuft':
return
# ...
ctx.vars['spiel_zustand'] = 'gameover'Der zentrale spiel_zustand führt schließlich verschiedene Teile des Programms zu einem gemeinsamen Modell zusammen. Solange der Zustand laeuft gilt, werden Steuerung, Bewegung, Hindernisse und Punktezählung aktualisiert. Nach einer Kollision wechselt das Programm in gameover, die eigentliche Spiellogik stoppt und andere Funktionen – etwa die Neustartlogik – werden relevant. Damit lernen Schülerinnen und Schüler, ein Programm nicht nur als Folge einzelner Anweisungen zu betrachten, sondern als System mit definierten Zuständen und Zustandsübergängen.
Für Informatiklehrkräfte bietet die Vorlage damit deutlich mehr als den Nachbau eines bekannten Spielprinzips. In einem einzigen, für Lernende leicht verständlichen Projekt lassen sich Variablen, Bedingungen, Funktionen, Schleifen, Zeitberechnung, Ereignisse, Objektgruppen, Suchalgorithmen, Zustandsmodelle und mathematisch gesteuerte Parameter miteinander verbinden. frameCraft sorgt dafür, dass diese Konzepte schnell sichtbar und experimentell erfahrbar werden, während der Programmcode übersichtlich genug bleibt, um einzelne Mechanismen gezielt zu untersuchen, zu verändern und im Unterricht gemeinsam zu diskutieren.
Struktur der Bausteine
Die Bausteine entwickeln den Prototypen von der statischen Szene über die Spielfigur und ihre Physik bis zu Hindernislogik, Punktezählung, Balancing und abschließendem Neustart.
Grundstruktur mit Himmel und Boden
Der Baustein legt mit SPIEL, SZENE, Konstanten, Himmel, Boden, Rechteck-GFX und leerer Regel das strukturelle Fundament der späteren Spielwelt.
Der Vogel erscheint
Der Baustein führt den Vogel als zentrale Spielfigur ein und verbindet Entity, Collider, Mittelpunktlogik, Konstanten und vorbereitete Grafikfunktion.
Flattern mit Aktionen
Der Baustein abstrahiert Tastatur- und Touch-Eingaben zu einer flap-Aktion und führt eine Sperre für einzelne Sprungimpulse ein.
Vogelphysik mit Schwerkraft
Der Baustein ergänzt zeitbasierte Physik, indem vogel_vy über ctx.vars gespeichert, mit Schwerkraft verändert und die y-Position mit ctx.dt aktualisiert wird.
Kollision und Game Over
Der Baustein verknüpft Tags, Trigger-Collider, Kollisionshandler und spiel_zustand, sodass Berührungen mit Gefahr-Objekten den Game-Over-Zustand auslösen.
Erstes Hindernispaar
Der Baustein erweitert die Spielwelt um ein statisches Rohrpaar und macht die Berechnung von oberem Rohr, unterem Rohr und gemeinsamer Lücke nachvollziehbar.
Hindernisse bewegen
Der Baustein überführt das Hindernispaar in eine synchrone Linksbewegung und nutzt tempo sowie ctx.dt für eine zeitbasierte Bewegung nur im Zustand laeuft.
Hindernis wiederverwenden
Der Baustein führt Wiederverwendung ein, indem das bestehende Rohrpaar nach Verlassen des Bildschirms rechts neu eingesetzt und mit neuer Lücke aktualisiert wird.
Mehrere Pipe-Paare
Der Baustein skaliert die Hindernislogik zu einem Entity-Pool mit nummerierten Pipe-Paaren, Schleifen, stabilen Abständen und Recycling hinter der weitesten Pipe.
Punkte einmal zählen
Der Baustein ergänzt eine robuste Punktezählung, bei der jedes Hindernispaar über pipe_gezaehlt nur einmal nach vollständigem Passieren des Vogels zählt.
Schwierigkeit steigern
Der Baustein verknüpft Punkte mit Spielbalance, indem Tempo und Lückengröße über Konstanten, clamp und HUD-Anzeige kontrolliert angepasst werden.
Flappy Farbenflug fertigstellen
Der Baustein führt Farb- und Lückenmuster, Hindernis-Kollisionen, Game-Over-UI und Neustart mit Sperre zu einem vollständigen Spielablauf zusammen.
Die klar aufeinander bezogenen Bausteine machen Lernziele, technische Konzepte und Spielmechaniken transparent. Dadurch lässt sich die Vorlage gut in Unterrichtsreihen zur Spielentwicklung mit frameCraft einordnen.
Über einen Demo-Zugang können Sie die Vorlage erproben und die Bausteine an Ihre Lerngruppe anpassen. So bleibt die didaktische Struktur erhalten, während Schwerpunktsetzung und Umfang flexibel bleiben.