Breakout programmieren

Vom sichtbaren Spielobjekt zur strukturierten Programmlogik

Das Breakout-Projekt eignet sich besonders gut, um Schülerinnen und Schüler vom einfachen Verändern sichtbarer Objekte schrittweise zu strukturierter Programmlogik zu führen. frameCraft übernimmt dabei die technische Infrastruktur für Fenster, Darstellung und Kollisionssystem, ohne die für den Informatikunterricht relevanten Entscheidungen zu verstecken. Schläger, Ball und Blöcke werden als klar benannte Objekte modelliert, während ihre Bewegung und ihr Verhalten weiterhin durch normalen Python-Code bestimmt werden. Lernende erkennen dadurch unmittelbar, welche Variablen und Algorithmen hinter einem scheinbar einfachen Arcade-Spiel stehen – und können einzelne Mechanismen gezielt verändern, testen und erklären.

for row in range(BLOCK_ROWS):
    for col in range(BLOCK_COLS):
        block_name = "block_" + str(row) + "_" + str(col)

        block_x = BLOCK_START_X + col * BLOCK_ABSTAND_X
        block_y = BLOCK_START_Y + row * BLOCK_ABSTAND_Y

        OBJEKT(block_name, pos=(block_x, block_y), tag="block")

Die Erzeugung des Blockfeldes bietet einen besonders anschaulichen Zugang zu verschachtelten Schleifen und zweidimensionalen Strukturen. Statt 35 Blöcke einzeln anzulegen, beschreiben wenige Zeilen eine allgemeine Regel für Zeilen, Spalten, Namen und Positionen. Damit wird unmittelbar sichtbar, weshalb Schleifen in der Programmierung benötigt werden: Sie reduzieren nicht nur Schreibarbeit, sondern formulieren wiederkehrende Strukturen als Algorithmus. Aus den Indizes row und col entstehen gleichzeitig eindeutige Namen und Koordinaten. Lehrkräfte können daran sehr gut weitere Aufgaben anschließen – beispielsweise andere Rastergrößen, Abstände, Muster, fehlende Blöcke oder unterschiedliche Eigenschaften einzelner Reihen.

farbe = REIHEN_FARBEN[row % len(REIHEN_FARBEN)]

gfx_rechteck(
    ctx.E(block_name),
    BLOCK_B,
    BLOCK_H,
    fuell=farbe,
    rand=(0, 0, 0)
)

Schon die Farbzuweisung enthält ein weiteres gut vermittelbares Informatikprinzip. Mit dem Modulo-Operator wird der aktuelle Zeilenindex auf die vorhandene Farbliste abgebildet. Damit verbinden sich Listen, Indizes und arithmetische Operationen mit einem sofort sichtbaren Ergebnis. Lernende können anschließend eigene Muster entwickeln oder untersuchen, wie sich die Darstellung verändert, wenn weniger Farben als Reihen vorhanden sind. Solche kleinen, visuell überprüfbaren Experimente helfen besonders dabei, abstrakte Operatoren nicht isoliert, sondern innerhalb eines verständlichen Problems zu behandeln.

if ball_entity.x - ball_entity.w / 2.0 <= RAND:
    ball_entity.x = RAND + ball_entity.w / 2.0
    ball_entity.vx = abs(ball_entity.vx)

if ball_entity.x + ball_entity.w / 2.0 >= window_width - RAND:
    ball_entity.x = (window_width - RAND) - ball_entity.w / 2.0
    ball_entity.vx = -abs(ball_entity.vx)

Die Reflexion des Balls an den Spielfeldrändern ist ein gutes Beispiel dafür, wie sich Bedingungen, Koordinaten und Vorzeichen zu einer funktionierenden Spielregel verbinden. Lernende müssen nicht nur erkennen, ob der Ball eine Grenze erreicht hat, sondern auch entscheiden, in welche Richtung seine Geschwindigkeit anschließend zeigen soll. Die Funktionen abs() und -abs() erhalten dabei einen konkreten Zweck: Sie garantieren die gewünschte Bewegungsrichtung. Gleichzeitig wird die Position korrigiert, damit der Ball nicht außerhalb des Spielfelds verbleibt. Aus einer einfachen if-Bedingung entsteht so ein nachvollziehbares Beispiel für robustes Programmverhalten.

versatz = (ball_entity.x - paddle_entity.x) / denom

if versatz < -1:
    versatz = -1
if versatz > 1:
    versatz = 1

ball_entity.vx = BALL_SPEED * versatz

Noch interessanter wird die Kollisionslogik am Schläger: Der Ball prallt nicht immer im gleichen Winkel zurück. Stattdessen wird berechnet, wo der Ball den Schläger getroffen hat. Ein Treffer links vom Mittelpunkt erzeugt eine andere horizontale Geschwindigkeit als ein Treffer rechts. Hier lassen sich Koordinatensystem, Differenzen, Normierung und Wertebereiche direkt mit einem sichtbaren Verhalten verknüpfen. Der berechnete versatz wird auf den Bereich von −1 bis 1 begrenzt und anschließend mit der Ballgeschwindigkeit multipliziert. Damit enthält eine bekannte Spielmechanik bereits ein kleines mathematisches Modell, das sich hervorragend untersuchen und verändern lässt.

def kollision_ball_block(ctx, ball_entity, block_entity):
    if not block_entity.alive:
        return

    block_entity.alive = False
    ctx.vars["punkte"] += 10
    ctx.vars["bloecke"] -= 1
    ball_entity.vy = -ball_entity.vy

Die Blockkollision verdeutlicht wiederum das Zusammenspiel mehrerer Programmzustände. Ein Block besitzt mit alive einen eigenen Zustand, während punkte und bloecke Informationen über den Gesamtzustand des Spiels speichern. Ein einzelnes Ereignis verändert damit mehrere Teile des Systems: Der Block verschwindet, der Punktestand steigt, die Anzahl verbleibender Blöcke sinkt und der Ball ändert seine Bewegungsrichtung. Gerade diese Stelle eignet sich gut, um mit Lernenden darüber zu sprechen, dass komplexere Programme aus vielen miteinander verbundenen Zustandsänderungen bestehen.

if ctx.vars["bloecke"] <= 0:
    ctx.vars["gewonnen"] = True
    ctx.vars["aktiv"] = False
    ctx.vars["meldung_text"] = (
        "GEWONNEN! " + str(ctx.vars["punkte"]) + " Punkte!"
    )

Aus dem Blockzähler ergibt sich gleichzeitig eine verständliche Siegbedingung. Statt jedes Objekt erneut prüfen zu müssen, führt das Programm einen passenden Zustandswert mit. Sobald dieser den Wert null erreicht, wechselt das Spiel in einen neuen Zustand. Damit lässt sich sehr anschaulich zeigen, warum Programme Informationen über ihren aktuellen Zustand speichern und wie daraus unterschiedliche Abläufe entstehen können. Die Variablen aktiv, gewonnen, game_over und meldung_text bilden zusammen bereits ein kleines Zustandsmodell.

# Todeszone unterhalb des Spielfelds
ZONE("tod", (0, window_height + 2, window_width, 14), tag="tod")

# Beispiel für die zugehörige Schutzlogik
if not Zugriff.wert(ctx, "tod_sperre", False):
    ctx.vars["tod_sperre"] = True
    ctx.vars["leben"] -= 1

Ein besonders wertvoller Lernanlass entsteht schließlich durch die Todeszone und das tod_sperre-Flag. Ohne eine solche Sperre könnte dieselbe Situation während mehrerer aufeinanderfolgender Frames mehrfach ausgewertet werden und unbeabsichtigt mehrere Leben abziehen. Damit begegnen Schülerinnen und Schüler einem Problem, das auch außerhalb der Spieleprogrammierung häufig vorkommt: Ein Zustand bleibt eine gewisse Zeit bestehen, ein daraus resultierendes Ereignis darf aber nur einmal verarbeitet werden. Das Sperr-Flag macht diese Unterscheidung unmittelbar verständlich. Beim Zurücksetzen des Balls wird die Sperre wieder aufgehoben, sodass der nächste Ballverlust erneut genau einmal gezählt werden kann.

Für den Informatikunterricht verbindet das Breakout-Projekt damit klassische Grundlagen wie Variablen, Listen, Schleifen, Bedingungen, Funktionen und Berechnungen mit weiterführenden Konzepten wie Objektzuständen, Ereignisverarbeitung, Kollisionshandlern und Zustandsautomaten. frameCraft sorgt dafür, dass die Ergebnisse jeder Änderung sofort sichtbar werden, während die entscheidenden Algorithmen im Python-Code offen und nachvollziehbar bleiben. Dadurch kann eine Lerngruppe zunächst mit kleinen Veränderungen experimentieren und später zunehmend selbstständig Regeln modellieren, Fehler analysieren und vorhandene Mechanismen erweitern – vom veränderten Blockraster bis hin zu eigenen Kollisions- und Spielregeln.

• Szenenstruktur: Aufbau einer Hauptszene mit Startwerten, Eingaben, Objekten und registrierten Regeln.
• Eingabemodell: Abbildung von Tastatur- und Touch-Steuerung auf abstrakte Aktionen wie links, rechts, start und stop.
• Objektmodellierung: Anlage von Schläger, Ball und Blöcken als Spielobjekte mit Collider-Strukturen und optionaler grafischer Darstellung.
• Bewegungslogik: Umsetzung zeitbasierter Bewegung mit Geschwindigkeiten, Begrenzungen und Reflexionen an Spielfeldrändern.
• Rasterbildung: Automatische Erzeugung eines Block-Gitters über Doppelschleifen, Positionsberechnung, Farblogik und Zählvariablen.
• Kollisionsverarbeitung: Reaktion auf Ball-Schläger- und Ball-Block-Kollisionen mit Abprallwinkel, Punktevergabe und Siegbedingung.
• Zustandsverwaltung: Steuerung von HUD, Leben, Meldungen, Game Over, Sieg, Neustart und Sperr-Flags.