<!-- Markdown-Fassung von https://www.allknivesnobagel.com/teaching/gec1/days/03/ · Stand 2026-10-05T13:39Z · 21cef83 -->

# Tag 3: Interaktion von Hand

13.11.2026 · Game Engines & Coding 1 · Macromedia Leipzig · Folien: https://www.allknivesnobagel.com/teaching/gec1/days/03/slides/

Ereignisse, Bedingungen und Aktionen als Graph, dazu Kräfte, die Dinge in Bewegung setzen.

Begriffe: [event](https://www.allknivesnobagel.com/teaching/gec1/concepts/event/), [state](https://www.allknivesnobagel.com/teaching/gec1/concepts/state/), [condition](https://www.allknivesnobagel.com/teaching/gec1/concepts/condition/), [reference](https://www.allknivesnobagel.com/teaching/gec1/concepts/reference/), [graph](https://www.allknivesnobagel.com/teaching/gec1/concepts/graph/), [collision](https://www.allknivesnobagel.com/teaching/gec1/concepts/collision/), [rigidbody](https://www.allknivesnobagel.com/teaching/gec1/concepts/rigidbody/), [torque](https://www.allknivesnobagel.com/teaching/gec1/concepts/torque/), [console](https://www.allknivesnobagel.com/teaching/gec1/concepts/console/), [revert](https://www.allknivesnobagel.com/teaching/gec1/concepts/revert/)

Bis zum nächsten Termin: Meilenstein Vertical Slice bis 27.11.: zwei Interaktionen laufen im Blockout, ein aktueller Windows-Build dieses Stands läuft auf einem fremden Rechner, das KI-Verzeichnis hat Einträge. Nach 48 Stunden: Schlüssel und Tür im eigenen Projekt nachgebaut und die Werkstatt aus Kurs-Paket 0.3.2 repariert. Eine Woche später im Blackboard-Thread: 30-Sekunden-Clip von Interaktion 1, ein Hindernis, der nächste Schritt. Dazu die Spec der zweiten Interaktion. Aufwand: etwa 10 bis 13 Stunden.

## Was läuft schon?

1. Ein grauer Raum, durch den die Spielfigur läuft
2. Der Build läuft auf einem fremden Windows-Rechner
3. Die Spec der ersten Interaktion steht
4. Das [Devlog](https://www.allknivesnobagel.com/teaching/gec1/concepts/devlog/) unten in `DOKUMENTATION.md` hat einen Eintrag

Noch nicht so weit? Nehmt das Blatt „Rettungsweg“.

Jetzt wird der Probe-Build getauscht: den Build-Ordner als ZIP per USB-Stick oder Cloud-Link an eine Person mit Windows-Rechner geben, dort entpacken und die `.exe` starten. Der Rettungsweg steht auch online: [Rettungsweg als Blatt](/teaching/gec1/druck/rettungsweg.html). Er zeigt, wie ihr heute im Kurs mitkommt und in der Woche danach aufholt.

## Kurs-Paket prüfen

1. Kurs › Setup prüfen: Steht beim Kurs-Paket 0.3.2 oder höher? Dann ist alles gut.
2. Älter? GitHub Desktop: erst committen
3. Window › Package Manager › + › Install package from git URL…, Adresse einfügen, Install
4. Commit: „Kurs-Paket auf 0.3.2“

```
https://
github.com/
BabyToad/
macromedia-
gec1-kit.git
#v0.3.2
```

Die Kursvorlage bringt 0.3.2 seit dem 09.10. mit; aktualisieren müssen nur Projekte, die älter sind oder ohne Vorlage entstanden. Die Adresse am Stück: `https://github.com/BabyToad/macromedia-gec1-kit.git#v0.3.2`. Version 0.3.2 bringt die kaputte Werkstatt für heute, das Menü **Tools › Kit › Eigener Knoten (C#)** und zwei Korrekturen im Kit: Warnungen „Vor Play“ bleiben in der Console stehen, und **Kraft › Dauerkraft** schiebt jetzt so lange, bis der Eingang **Stopp** kommt. Ausführlich steht das in der Anleitung „Kurs-Paket aktualisieren“. Kontrolle: **Kurs › Setup prüfen** zeigt beim Kurs-Paket 0.3.2.

## Heute reagiert die Welt

Bisher läuft man durch den Raum. Ab heute antwortet er.

Wenn ich die Türzone betrete und den Schlüssel habe, fährt die Tür hoch. Sonst steht auf dem Schild: Verschlossen.

## Event, Bedingung, Aktion

**Tafelbild:** Die Tür als Kette in drei Spalten. Event: Zone, Betreten. Bedingung: Wenn, Schlüssel da?, gespeist vom Merker „Schlüssel vorhanden“. Aktion: bei Ja Bewegen, die Tür fährt hoch; bei Nein Text setzen, „Verschlossen.“

[Event](https://www.allknivesnobagel.com/teaching/gec1/concepts/event/): ein Moment

[Zustand](https://www.allknivesnobagel.com/teaching/gec1/concepts/state/): was das Spiel sich merkt

[Bedingung](https://www.allknivesnobagel.com/teaching/gec1/concepts/condition/): ja oder nein

Ein [Event](https://www.allknivesnobagel.com/teaching/gec1/concepts/event/) ist ein Zeitpunkt, an dem etwas passiert: Betreten, Drücken, Aufprall. Ein [Zustand](https://www.allknivesnobagel.com/teaching/gec1/concepts/state/) bleibt von Frame zu Frame erhalten, etwa ob der Schlüssel schon aufgehoben ist. Eine [Bedingung](https://www.allknivesnobagel.com/teaching/gec1/concepts/condition/) fragt diesen Zustand in dem Moment ab, in dem das Event ankommt, und schickt es auf den einen oder den anderen Weg.

## Drei Arten von Drähten

**Tafelbild:** Drei Drahtarten. Event, gestrichelt: wann etwas passiert, etwa Betreten zu Prüfen. Daten, durchgezogen: ein Wert, der gelesen wird, etwa Wert zu Bedingung. Referenz, doppelt: welches Objekt gemeint ist, etwa Schlüssel zu An/Aus.

Der [Graph](https://www.allknivesnobagel.com/teaching/gec1/concepts/graph/) des Kits kennt drei Drahtarten. ▶ Events laufen von links nach rechts durch die Kette. ● Daten werden gelesen, wenn ein Knoten sie braucht. ◆ Referenzen sagen einem Knoten, mit welchem Objekt in der Szene er arbeitet. Hängen an einem Event-Ausgang mehrere Drähte, tragen sie Nummern: Nr. 1 läuft zuerst. Falsche Verbindungen lassen sich gar nicht ziehen: Ein Event-Ausgang passt nur auf einen Event-Eingang.

## Das Beispiel holen

Tools › Kit › Beispiel „Schlüssel und Tür“ bauen

**Screenshot:** Das Graph-Fenster mit dem Beispiel Schlüssel und Tür: neun Knoten auf dunkler Tafel, darunter Benutzen, Merker, An/Aus, Zone, Wenn, Bewegen, Text setzen und Ton abspielen, verbunden mit orangen, violetten und blaugrünen Drähten. (Unity 6.3 · Kurs-Paket 0.3.1).

Doppelklick auf die Datei „Schlüssel und Tür.kit“ öffnet den Graph.

Das Menü legt den Ordner `Assets/Kit Beispiel` an, mit dem Graph `Schlüssel und Tür.kit` und der Szene `Keller`. Gibt es das Beispiel schon, fragt Unity nach, bevor etwas überschrieben wird. Beispiele holt ihr immer über dieses Menü. Ist alles rosa, ist das Kurs-Paket zu alt: oben aktualisieren. Den Graph öffnet ein Doppelklick auf die `.kit`-Datei oder im Inspector der Interaktion der Knopf **Graph öffnen**.

## Ein Graph, viele Türen

**Tafelbild:** Ein Graph mit dem Knoten Bewegen und einem leeren Platz ◆ Objekt. Zwei Interaktionen in der Szene, Keller und Dachboden, füllen diesen Platz verschieden: die eine mit Tür A, die andere mit Tür B.

Der [Graph](https://www.allknivesnobagel.com/teaching/gec1/concepts/graph/) sagt, was passiert. Die Interaktion sagt, mit welchen Objekten: je Platz eine [Referenz](https://www.allknivesnobagel.com/teaching/gec1/concepts/reference/).

Der Graph ist eine Datei im Projekt. Er kennt keine Objekte der Szene, nur Plätze für sie (◆). Die Component **Interaktion** an einem GameObject verbindet beides: Sie zeigt auf einen Graph und hält eine Tabelle, welches Objekt welchen Platz füllt. Das ist eine [Referenz](https://www.allknivesnobagel.com/teaching/gec1/concepts/reference/). Umbenennen oder Verschieben bricht sie nicht. Ein leerer Platz ist ein Fehler, und das Kit meldet ihn schon vor Play. Jede Interaktion hat ihren eigenen Merker: Zwei kopierte Türen öffnen sich nicht gegenseitig.

## Die Plätze im Inspector

**Screenshot:** Die Liste Objekte (◆) im Inspector der Interaktion: Schlüssel = Schlüssel, Benutzen: Kamera = leer, Zone: Zone = Türzone, Bewegen: Objekt = Tür, Text setzen: Textfeld = Schild, Ton abspielen: Quelle = Tür-Klack. Neben jedem Platz eine Lupe. (Unity 6.3 · Kurs-Paket 0.3.1).

Objekte (◆): hineinziehen, was gemeint ist.

Die Lupe neben jedem Platz springt in den Graph zum passenden Knoten. **Benutzen: Kamera** darf leer bleiben: Dann nimmt der Knoten die Hauptkamera, also die der Spielfigur.

## Zuschauen, während es läuft

**Screenshot:** Der Graph im Play-Modus: Wenn trägt ein Häkchen mit „Ja, weil Schlüssel vorhanden: ja“, Bewegen ist gelb hinterlegt und meldet „läuft: 0,5 / 1,0 s“, Ton abspielen steht auf „noch nicht erreicht“. (Unity 6.3 · Kurs-Paket 0.3.1).

○ empfangen

▬ läuft

✓ fertig

⛔ blockiert

! Fehler

Zum Ausprobieren: Play, ohne Schlüssel zur Tür laufen. Wenn zeigt „Nein, weil Schlüssel vorhanden: nein“, das Schild sagt „Verschlossen.“. Dann den Schlüssel anschauen und E drücken, zurück zur Tür: Bewegen läuft. Graph-Fenster und Game-Fenster nebeneinander legen hilft. Jeder Knoten zeigt im Play-Modus, was er gerade tut, und warum. Ein Knoten mit Fehler feuert nie seinen Erfolgs-Ausgang; der Grund steht am Knoten und in der Console. Die Leiste unten im Graph-Fenster zählt zusammen, wie viele Knoten laufen, fertig sind oder noch nicht erreicht wurden.

## Vom Knoten zum Objekt

**Screenshot:** Links die Hierarchy: Schlüssel ist ausgewählt; er und die anderen Objekte der Interaktion tragen das Abzeichen ◆1. Rechts der Graph: Der Knoten „Objekt: Schlüssel“ ist hervorgehoben, seine blaugrünen Drähte führen zu Benutzen und An/Aus. (Unity 6.3 · Kurs-Paket 0.3.1).

Doppelklick auf einen Knoten: Das Objekt leuchtet in der Hierarchy.

Objekt auswählen: Seine Knoten leuchten im Graph.

Ein Klick auf einen Knoten zeigt unten im Graph-Fenster, was er tut, und die Knöpfe **In der Hierarchy zeigen**, **Komponente öffnen** und **Code ansehen**. Ein Doppelklick wählt das gebundene Objekt aus. Umgekehrt leuchten alle Knoten auf, die ein in der Hierarchy ausgewähltes Objekt benutzen. Das Abzeichen ◆1 in der Hierarchy zählt, wie viele Plätze ein Objekt füllt; mit der Maus darauf steht da, welche.

## Was steckt in einem Knoten?

**Screenshot:** Das Fenster Code ansehen für den Knoten Wenn, Branch.cs mit 32 Zeilen. Zeile 28, chosen.Fire(signal), ist orange markiert: Dort feuert der Knoten Ja oder Nein. (Unity 6.3 · Kurs-Paket 0.3.1).

&#x20;am Knoten

Orange: Hier feuert ein Ausgang.

Jeder Knoten ist eine kleine C#-Datei. **Code ansehen** zeigt sie schreibgeschützt und markiert die Stellen, die zählen: orange, wo ein Ausgang feuert; gelb, wo der Knoten „läuft“ meldet; rot, wo er einen Fehler meldet; blaugrün, wo ein ◆-Platz steht. **Im Code-Editor öffnen** zeigt dieselbe Datei in VS Code. Lesen genügt; niemand muss das schreiben können.

## Jetzt baut ihr sie nach

In eurem Blockout

1. Würfel „Schlüssel“ und Würfel „Tür“
2. Schild: 3D Object › Text - TextMeshPro
3. Türzone: leeres GameObject vor der Tür, Box Collider, Is Trigger
4. GameObject › Kit › Interaktion, dann Neuer Graph …

So entstehen die Objekte, alle als Kinder einer leeren „Tür-Gruppe“ oder lose in der Szene:

| Objekt | Anlegen | Maße und Lage |
|---|---|---|
| Schlüssel | 3D Object › Cube | Scale 0,2 × 0,2 × 0,6, auf den Boden, ein paar Meter von der Tür |
| Tür | 3D Object › Cube | Scale 3 × 3 × 0,2, steht im Türdurchgang auf dem Boden |
| Schild | 3D Object › Text - TextMeshPro | neben die Tür, auf Augenhöhe; beim ersten Mal fragt Unity nach **Import TMP Essentials**: bestätigen |
| Türzone | Create Empty, dann Add Component › Box Collider, **Is Trigger** an | **Size** 3 × 2 × 2, Mitte etwa 1,5 m vor der Tür und 1 m über dem Boden, so dass man auf dem Weg zur Tür hineinläuft |

Ein leeres GameObject entsteht dort, wo die Scene-Ansicht gerade hinschaut, und sein Box Collider ist 1 × 1 × 1 m. Darum die Türzone bewusst verschieben und vergrößern; der grüne Drahtrahmen zeigt, wo sie liegt. Dann **GameObject › Kit › Interaktion** und im Inspector **Neuer Graph …**: Unity fragt, wo die `.kit`-Datei liegen soll.

## Acht Knoten holen

1. „+ Knoten“: Benutzen, Merker, An/Aus, Zone, Wenn, Bewegen, Text setzen
2. Den Schlüssel aus der Hierarchy auf die Leinwand ziehen: Objekt „Schlüssel“
3. Unten links: Instanz wählen

Ohne Instanz bleiben die ◆-Felder grau.

„+ Knoten“ unten links im Graph-Fenster öffnet die deutsche Liste mit den Gruppen Auslöser, Ablauf, Zustand, Aktion, Spielsysteme und Erweiterung. Die Leertaste im Graph öffnet die Liste des Graph Toolkits mit englischen Klassennamen; beide legen dieselben Knoten an. Den Schlüssel brauchen zwei Knoten, Benutzen und An/Aus. Darum bekommt er einen eigenen Knoten **Objekt**: Zieht ihn aus der Hierarchy direkt auf die Leinwand. **Instanz** heißt: welche Interaktion in der Szene dieses Fenster gerade bearbeitet. Der Knopf unten links im Graph-Fenster wählt sie; erst dann lassen sich Objekte auf die ◆-Felder ziehen. Der Ton aus dem Beispiel ist für den Nachbau nicht nötig.

## Die Drähte

1. Objekt ◆ → Benutzen, An/Aus
2. Benutzt ▶ → 1. Ja setzen, 2. Ausschalten
3. Betreten ▶ → Prüfen
4. Wert ● → Bedingung
5. Ja ▶ → Hin. Nein ▶ → Setzen

Die vollständige Liste für den Nachbau. Links der Ausgang, rechts der Eingang:

| Von | Nach | Draht |
|---|---|---|
| Objekt „Schlüssel“ · ◆ Objekt | Benutzen · ◆ Objekt | ◆ |
| Objekt „Schlüssel“ · ◆ Objekt | An/Aus · ◆ Objekt | ◆ |
| Benutzen · Benutzt | Merker · Ja setzen (Nr. 1) | ▶ |
| Benutzen · Benutzt | An/Aus · Ausschalten (Nr. 2) | ▶ |
| Zone · Betreten | Wenn · Prüfen | ▶ |
| Merker · Wert | Wenn · Bedingung | ● |
| Wenn · Ja | Bewegen · Hin | ▶ |
| Wenn · Nein | Text setzen · Setzen | ▶ |

Einstellungen an den Knoten: Merker **Name** „Schlüssel vorhanden“, **Startwert** aus. Bewegen **Was** Position, **Weg** 0, 3, 0, **Dauer** 1. Text setzen **Text** „Verschlossen.“. Zone **Nur Tag** Player (so ist es voreingestellt).

Was auf die ◆-Felder der Knoten kommt, aus der Hierarchy hineingezogen:

| Knoten · Platz | Objekt |
|---|---|
| Objekt „Schlüssel“ | Schlüssel |
| Zone · ◆ Zone | Türzone |
| Bewegen · ◆ Objekt | Tür |
| Text setzen · ◆ Textfeld | Schild |
| Benutzen · ◆ Kamera | leer lassen (Hauptkamera) |

Dann Play. Gespeichert wird von selbst: Vor jedem Play speichert das Kit offene Graphen und prüft alle Interaktionen; was fehlt, steht als Warnung in der Console.

**Wenn es hängt:**

- Die ◆-Felder sind grau und nehmen nichts an: unten links im Graph-Fenster die Instanz wählen.
- Wenn sagt immer Nein: Der Draht von Merker · Wert zu Wenn · Bedingung fehlt.
- Zone zeigt nie ✓: Is Trigger fehlt, die Zone liegt nicht im Weg, oder sie ist zu klein (grüner Rahmen in der Scene-Ansicht).
- Der Schlüssel reagiert nicht auf E: näher als 3 m herangehen und ihn ansehen; er braucht seinen Box Collider.

## Die Interaktion als Satz

Sagt den Satz zu eurer Tür laut, bevor ihr Play drückt.

Wenn \[Event] und \[Bedingung], dann \[Aktion]. Sonst \[andere Aktion].

Wer den Satz nicht sagen kann, hat noch keine klare Interaktion. Das gilt auch für die eigene Spec.

## Läuft nicht? So sucht ihr

1. Steht ein ! an einem Knoten? Grund lesen.
2. ⛔ blockiert? Dort endet die Kette, mit Begründung.
3. Gar nichts passiert? Hat der Auslöser ✓? Sonst Zone oder Tag prüfen.

Der Graph sagt, wo es hängt. Gesucht wird von links nach rechts, vom Auslöser zur Aktion.

## Eure Variation

10 Minuten

- Drei Schlüssel: [Zähler](https://www.allknivesnobagel.com/teaching/gec1/concepts/state/) mit Ziel 3
- Die Tür fällt nach 5 s wieder zu: Warten, dann Bewegen › Zurück
- Das Schild spricht nur beim ersten Mal: Einmal

Erst den Satz sagen, dann bauen.

Eine Variante reicht; wer fertig ist, nimmt die nächste. Die Falle mit einer Kiste kommt nach der Pause, weil sie einen Rigidbody braucht.

## Pause

10 Minuten

## Collider oder Trigger?

**Tafelbild:** Links eine feste Wand: Die Kugel prallt ab, Unity meldet OnCollisionEnter. Rechts eine gestrichelte Zone: Die Kugel rollt hindurch, Unity meldet OnTriggerEnter.

[Kollision](https://www.allknivesnobagel.com/teaching/gec1/concepts/collision/): fest oder durchlässig.

Is Trigger ist ein Haken am Collider.

Ein Collider ist die unsichtbare Form, mit der ein Objekt an der [Kollision](https://www.allknivesnobagel.com/teaching/gec1/concepts/collision/) teilnimmt. Ein normaler Collider ist fest. Mit **Is Trigger** wird er durchlässig und meldet nur noch, dass etwas hinein- oder hinauskommt. Die beiden Meldungen haben verschiedene Voraussetzungen:

| Meldung | im Kit | wann sie kommt |
|---|---|---|
| Trigger: `OnTriggerEnter` | **Zone** | eines der beiden Objekte hat einen [Rigidbody](https://www.allknivesnobagel.com/teaching/gec1/concepts/rigidbody/) (auch kinematisch) oder einen CharacterController, wie die Spielfigur |
| Aufprall: `OnCollisionEnter` | **Zusammenstoß** | mindestens eines der beiden hat einen Rigidbody, bei dem Is Kinematic aus ist |

Darum meldet die Spielfigur Zonen zuverlässig, aber keinen Aufprall: Läuft sie gegen eine Wand, gibt es kein `OnCollisionEnter` und der Knoten Zusammenstoß bleibt still. Der CharacterController hat dafür eine eigene Meldung, `OnControllerColliderHit`, die das Kit nicht als Knoten anbietet. Zusammenstoß gehört an Dinge mit Rigidbody: eine Kiste, die auf den Boden fällt, ein Ball, der gegen eine Wand rollt.

## Ein Rigidbody übergibt an die Physik

Mit [Rigidbody](https://www.allknivesnobagel.com/teaching/gec1/concepts/rigidbody/) fällt der Würfel.

1. Kiste in die Luft, Add Component › Rigidbody, Play
2. Die Falle: Zone, dann Kraft auf die Kiste
3. Kraft: Richtung 0, 1, 0, Stärke 6, Stoß

Felder: Mass, Use Gravity, Is Kinematic

Mit Rigidbody bestimmt die Physik die Position. Wer die Transform trotzdem direkt verschiebt, arbeitet gegen sie; das Objekt ruckelt oder rutscht durch Wände. **Is Kinematic** heißt: Die Physik bewegt das Objekt nicht, ein Skript oder eine Animation tut es. Auf einen kinematischen Körper wirkt auch der Knoten Kraft nicht; er meldet das. **Constraints** sperren einzelne Achsen, etwa damit eine Figur nicht umkippt.

Ein Aufprall lässt sich jetzt auch hören: Eine neue Interaktion mit **Zusammenstoß** (◆ Körper: der Collider der Kiste) · Getroffen → **Notiz in Konsole**. Fällt die Kiste auf den Boden, steht die Notiz in der Console. Das geht, weil die Kiste einen Rigidbody hat; an der Spielfigur bliebe Zusammenstoß still.

Die Falle als Graph: eine neue Interaktion, **Zone** (◆ Zone: eine Türzone-artige Trigger-Box vor der Kiste) · Betreten → **Kraft** · Anstoßen, ◆ Körper = Kiste. **Stoß** wirkt einmal, wenn das Event ankommt. **Dauerkraft** schiebt ab Kurs-Paket 0.3.2 so lange, bis der Eingang **Stopp** kommt, etwa von Zone · Verlassen.

Wie so etwas in einem fertigen Spiel aussieht: In HIGH WATER (gebaut in Godot) ist jeder Gegner ein Rigidbody mit 3 kg. Im Stehen sind seine Drehachsen gesperrt, damit er aufrecht läuft; ein harter Treffer hebt die Sperre auf, und aus dem Läufer wird ein Geschoss, das beim Aufprall andere trifft. In Unity hieße das **Constraints › Freeze Rotation**, im Code wieder freigegeben mit `rb.constraints = RigidbodyConstraints.None`.

## Kraft und Drehmoment

**Tafelbild:** Links: Eine Kraft am Schwerpunkt schiebt eine Kiste in eine Richtung, AddForce. Rechts: Ein Drehmoment dreht einen Balken um seine Achse, von oben gesehen, AddTorque.

Kraft: Knoten im Kit

[Drehmoment](https://www.allknivesnobagel.com/teaching/gec1/concepts/torque/): fehlt im Kit

Eine Kraft ist ein [Vektor](https://www.allknivesnobagel.com/teaching/gec1/concepts/vector/): Richtung und Stärke. `AddForce` schiebt den ganzen Körper, `AddTorque` dreht ihn um eine Achse. Beide gibt es als Stoß (`ForceMode.Impulse`, ein einzelner Moment, etwa ein Tritt) oder als gleichmäßiges Schieben (`ForceMode.Force`, in jedem Physik-Schritt, also in `FixedUpdate()`). Masse zählt: Die gleiche Kraft bewegt eine schwere Kiste weniger.

## Die Console liest man von oben

1. Rot: Fehler. Gelb: Warnung. Weiß: Hinweis.
2. Den obersten Fehler zuerst: Die anderen folgen oft aus ihm.
3. Doppelklick führt zur Zeile im Code.
4. Collapse fasst gleiche Meldungen zusammen.

[Console](https://www.allknivesnobagel.com/teaching/gec1/concepts/console/): Window › General › Console

Strg + Umschalt + C

Die [Console](https://www.allknivesnobagel.com/teaching/gec1/concepts/console/) sammelt, was Unity und eure Skripte melden. Ein roter Kompilierfehler (`error CS…`) blockiert Play ganz, bis er behoben ist; Unity sagt dann „All compiler errors have to be fixed before you can enter playmode!“. Ein Laufzeitfehler (Exception) bricht nur das Skript an dieser Stelle ab, das Spiel läuft weiter. Steht dieselbe Meldung hundertmal da, kommt sie aus `Update()` oder `FixedUpdate()`: in jedem Frame einmal. **Clear** leert die Liste (Kompilierfehler bleiben stehen), **Error Pause** hält das Spiel an, sobald ein Skript einen Fehler meldet.

## Die kaputte Werkstatt

10 Minuten

Tools › Kit › Beispiel „Werkstatt (kaputt)“ bauen

Fünf Fehler. Play drücken, Console lesen, einen beheben, wieder Play.

**Bild:** Isometrische Kreidezeichnung einer kaputten Werkstatt: Eine Kiste schwebt, das Windrad sitzt nicht auf seiner Welle, eine Lampe ist nicht eingesteckt und eine Figur läuft gegen eine unsichtbare Wand. (KI-generiert).

Ab Kurs-Paket 0.3.2

Szene: Assets › Kit Beispiel › Werkstatt

Die Werkstatt ist eine Beispiel-Szene im Kurs-Paket ab Version 0.3.2, absichtlich kaputt. Bauen: **Tools › Kit › Beispiel „Werkstatt (kaputt)“ bauen**. Das legt `Assets/Kit Beispiel/Werkstatt/` an, darin die Szene `Werkstatt.unity`; per Doppelklick öffnen. Fehlt der Menüpunkt, ist das Kurs-Paket noch auf 0.3.1: oben unter „Kurs-Paket prüfen“ aktualisieren.

So sieht die Console nach dem ersten Play aus, mit Collapse:

```
[Kit] Lampe › An/Aus: ◆ Objekt fehlt (Slot „An/Aus: Objekt“ ist leer)            1
UnassignedReferenceException: The variable fluegel of Windrad has not been assigned.  356
```

Auflösung, erst nach dem eigenen Versuch

1. **Knopfzone**: Is Trigger fehlt. Die Spielfigur läuft gegen eine unsichtbare Wand. Das Kit warnt vor Play: „„Knopfzone“: Collider ist kein Trigger (Is Trigger anhaken)“, und der Graph „Knopf und Kiste“ markiert die Zone rot.
2. **Kiste**: Is Kinematic ist an. Erst wenn Fehler 1 behoben ist, meldet der Knoten Kraft: „„Kiste“ ist kinematisch: Kräfte wirken nicht“. Ein Fehler kann den nächsten verdecken.
3. **Lampe**: Der ◆-Platz von An/Aus ist leer. Lampenschirm hineinziehen, dann schaltet L das Licht.
4. **Kiste (soll fallen)**: Ihr fehlt ein Rigidbody. Keine Meldung, sie schwebt einfach.
5. **Windrad**: Im Skript ist das Feld Fluegel leer, in jedem Physik-Schritt kommt die Meldung neu. Doppelklick zeigt die Zeile mit `AddTorque`; die Lösung liegt im Inspector: Flügel hineinziehen.

**Screenshot:** Der Graph Knopf und Kiste: Der Knoten Zone ist rot hinterlegt und meldet: „Knopfzone“: Collider ist kein Trigger (Is Trigger anhaken). Daneben der Knoten Kraft mit Richtung 0, 1, 0, Stärke 6, Art Stoß, Körper = Kiste. (Unity 6.3 · Prototyp der Werkstatt).

## Eine Meldung ist ein Hinweis

Die Console sagt, wo es kracht. Warum, findet ihr in der Szene.

Fehler 5 der Werkstatt ist der Normalfall in Unity: Die Zeile im Code ist richtig, das Feld im Inspector ist leer. Fehler 4 zeigt, dass nicht jeder Fehler eine Meldung hat.

## Interaktion 1 in eurem Blockout

1. Den Satz aus eurer Spec sagen
2. Event, Bedingung und Aktion darin markieren
3. Bauen, Play, beobachten
4. Commit

Bis 17:00. Ich komme rum.

Wer noch keine Spec hat, schreibt sie jetzt in fünf Minuten: Verb, Regel, Rückmeldung, Scheitern. Vor dem ersten Knoten ein Commit.

## Ein Knoten, den es nicht gibt

Kein Drehmoment im Kit? Tools › Kit › Eigener Knoten (C#), dann füllt ein Agent die Dateien.

```
Knoten „Drehmoment“
füllen, wie Kraft
(Push.cs).
◆ Körper: Rigidbody.
Achse, Stärke.
Drehen → Angewendet.
Kopfkommentar.
Nur diese zwei
Dateien ändern.
```

Agenten-Übung Tag 3: Spec → Agent schreibt einen kleinen Knoten im Vertrag des Kits → Diff lesen → spielen → committen oder verwerfen. Im Kurs lesen wir einen vorbereiteten Diff. Zu Hause selbst ausprobieren ist freiwillig. Zuerst **Tools › Kit › Eigener Knoten (C#)** mit dem Namen „Drehmoment“ ausführen; das legt die beiden Dateien in `Assets/Eigene Knoten` an. Dann committen. Dann der Auftrag an den Agenten: „Fülle den Kit-Knoten in `Assets/Eigene Knoten/Drehmoment.cs` und `Assets/Eigene Knoten/Editor/DrehmomentNode.cs` nach dem Muster von Kraft (Push.cs im Kurs-Paket). ◆ Körper: Rigidbody. Einstellungen Achse und Stärke. Eingang Drehen, Ausgang Angewendet. Ist der Körper kinematisch, soll der Knoten mit Grund scheitern (Fail). Beide Dateien bekommen oben einen Kopfkommentar. Nur diese zwei Dateien ändern, nicht committen.“ Danach eine Zeile ins KI-Verzeichnis.

## Was ein Knoten braucht

**Tafelbild:** Links fünf Markierungen aus dem C#-Code, rechts der Knoten, der daraus entsteht. NodeInfo gibt Titel und Gruppe, Input den Eingang Drehen, Ref den Platz ◆ Körper, Setting die Einstellung Stärke, Output den Ausgang Angewendet.

Zwei Dateien in Assets › Eigene Knoten. Das Menü legt sie an.

Ein eigener Knoten besteht aus zwei Dateien, beide unter `Assets/Eigene Knoten`: `Drehmoment.cs` (der Knoten) und `Editor/DrehmomentNode.cs` (sein Gesicht im Graph-Editor). Das Menü **Tools › Kit › Eigener Knoten (C#)** legt beide an, dazu die Assembly-Dateien des Ordners; dasselbe gibt es unter **Assets › Create › Kit › Eigener Knoten (C#)**. Danach steht der Knoten unter „+ Knoten“ › Aktion › Drehmoment. Ohne `NodeInfo` landet er in der Gruppe „Eigene“ unter seinem Klassennamen.

So sollte der Diff aussehen

`Assets/Eigene Knoten/Drehmoment.cs`:

```csharp
// Drehmoment: ein eigener Kit-Knoten, der einen Rigidbody um eine Achse dreht.
// Herkunft: geschrieben von einem Agenten (Werkzeug und Modell siehe KI-Verzeichnis),
// geprüft und getestet von <Name>, 13.11.2026.
using System;
using UnityEngine;
using Kit;

[Serializable]
[NodeInfo("Drehmoment", "Aktion", "Rigidbody um eine Achse drehen")]
public class Drehmoment : KitNode
{
    [Ref("Körper")] public Rigidbody body;
    [Setting("Achse")] public Vector3 axis = Vector3.up;
    [Setting("Stärke")] public float strength = 5f;

    [Output("Angewendet")] [NonSerialized] public Output applied;

    [Input("Drehen")]
    public void Spin(Signal s)
    {
        if (body.isKinematic) { Fail($"„{body.name}“ ist kinematisch: Drehmoment wirkt nicht"); return; }
        body.AddTorque(axis.normalized * strength, ForceMode.Impulse);
        applied.Fire(s);
    }
}
```

`Assets/Eigene Knoten/Editor/DrehmomentNode.cs`:

```csharp
// DrehmomentNode: zeigt den Knoten Drehmoment im Graph-Editor des Kits.
// Herkunft: wie Drehmoment.cs.
using System;
using Kit.Editor;

[Serializable]
public class DrehmomentNode : KitEditorNode
{
    public override Type RuntimeType => typeof(Drehmoment);
}
```

## Diff lesen, spielen, entscheiden

1. Diff: Nur die zwei Dateien in Eigene Knoten?
2. Steht oben ein Kopfkommentar? Feuert `Angewendet`?
3. Drehkreuz bauen, Taste → Drehmoment, Play
4. Dreht es? Commit. Sonst verwerfen.

In GitHub Desktop zeigt der Reiter **Changes** den Diff. Hat der Agent andere Dateien als die zwei in `Assets/Eigene Knoten` angefasst, ist das ein Grund zum Verwerfen, auch wenn es läuft.

Das Drehkreuz zum Testen: ein Würfel „Arm“, Scale 2,4 × 0,12 × 0,25, auf etwa 1 m Höhe. Dazu Add Component › Rigidbody mit **Use Gravity** aus, **Angular Damping** 0,6 und unter **Constraints** Freeze Position X, Y und Z sowie Freeze Rotation X und Z. Ohne diese Sperren fällt der Arm herunter und rollt weg; das ist dann kein Fehler des Knotens. Graph: **Taste** (Taste R) · Gedrückt → **Drehmoment** · Drehen, Achse 0, 1, 0, Stärke 4, ◆ Körper = Arm.

## Jedes Skript sagt, was es ist

Ab heute beginnt jedes eigene Skript mit einem Kopfkommentar.

```csharp
// Drehmoment: dreht einen Rigidbody.
// Herkunft: Agent, geprüft von <Name>, 13.11.2026.
```

Der Agent darf ihn schreiben. Ihr prüft, ob er stimmt.

Der Kopfkommentar steht oben in jedem Skript, das ihr selbst oder mit einem Agenten schreibt: in einem Satz, was es tut, und woher es kommt (selbst geschrieben, oder von welchem Agenten, geprüft von wem). Stellen, an denen das Warum nicht offensichtlich ist, bekommen ebenfalls einen Kommentar. Der Abgabe-Check am Ende des Semesters fragt genau danach. Die Zeile im KI-Verzeichnis ersetzt er nicht.

## Der neue Knoten im Graph

**Screenshot:** Ein Graph mit zwei Knoten im Play-Modus: Taste R, Ausgang Gedrückt, führt zu Drehmoment, Eingang Drehen. Drehmoment hat Achse 0, 1, 0, Stärke 4 und den Platz ◆ Körper = Arm (Rigidbody); darunter ein Häkchen: Angewendet. (Unity 6.3 · Kurs-Paket 0.3.1, eigener Knoten).

Taste R, und der Arm des Drehkreuzes dreht sich.

Der eigene Knoten steht unter „+ Knoten“ › Aktion und hat **Code ansehen** wie die eingebauten.

## Kaputt? Zurück zum letzten guten Stand

**Tafelbild:** Eine Zeitleiste mit Commits: Blockout begehbar, Tür geht auf, Agent: Drehmoment. Der dritte ist kaputt. Ein neuer Commit Revert nimmt ihn zurück; der Fehler bleibt im Verlauf sichtbar.

Noch nicht committet: Discard changes

Committet: Revert Changes in Commit, ein [Revert](https://www.allknivesnobagel.com/teaching/gec1/concepts/revert/)

In GitHub Desktop: Reiter **History**, Rechtsklick auf den Commit, **Revert Changes in Commit**, dann **Push origin**. Ein [Revert](https://www.allknivesnobagel.com/teaching/gec1/concepts/revert/) löscht nichts. Git legt einen neuen Commit an, der die Änderungen eines alten zurücknimmt; beide bleiben im Verlauf. Das ist sicher, auch wenn der kaputte Stand schon gepusht ist. Noch nicht committete Änderungen verwirft in GitHub Desktop **Discard changes** (Rechtsklick auf die Datei). Vor dem Revert in Unity alles speichern; danach lädt Unity die geänderten Dateien neu. Im Terminal: `git revert <Kennung>`.

## Vor jedem Experiment ein Commit

Commit vor dem Agenten, Commit vor dem Experiment. Dann kostet ein Fehlschlag einen Klick.

## Erklärt eure Interaktion

Zu zweit: Satz sagen, dann im Graph auf jeden Knoten zeigen, der darin vorkommt.

Die andere Person fragt: „Und wenn nicht?“

Ab heute jeden Freitag: ein System des eigenen Spiels laut erklären. Das ist die Übung für das Kapitel „ein System in eigenen Worten“ in der Dokumentation.

## Checkpoint

1. Interaktion 1 läuft im Blockout
2. Committet und gepusht
3. Zwei Sätze im Devlog unten in `DOKUMENTATION.md`
4. Antwort eines Agenten übernommen? Zeile im KI-Verzeichnis

Was fehlt, ist eure Aufgabe für die nächsten 48 Stunden.

Ins KI-Verzeichnis kommt eine Zeile, sobald die Antwort eines Agenten in die Arbeit eingeht: Code, eine Diagnose, die ihr anwendet, ein Text. Werkzeug, Modell, Zweck, Datei oder System, eine Notiz.

## Die nächsten 14 Tage

1. Nach 48 Stunden: Schlüssel und Tür im eigenen Projekt, Werkstatt repariert
2. Eine Woche später: Clip, Hindernis, nächster Schritt in den Blackboard-Thread
3. Wer 30 Minuten feststeckt, fragt
4. Bis zum 27.11.: zwei Interaktionen und ein aktueller Build

Am 27.11. spielen andere euren Stand.

Meilenstein Vertical Slice am 27.11.: zwei Interaktionen aus der Liste der Aufgabenstellung laufen im Blockout, das KI-Verzeichnis hat Einträge, und ein aktueller Windows-Build dieses Stands läuft auf einem fremden Rechner. Reihenfolge für den Build: speichern, committen, aus genau diesem Stand bauen, die `.exe` auf einem anderen Windows-Rechner testen (ZIP per USB-Stick oder Cloud-Link). Ab Tag 5 bekommt der getestete Commit zusätzlich einen Tag.

Aufwand bis zum 27.11., ehrlich gerechnet: etwa 10 bis 13 Stunden.

| Was | Mindestens | Zeit |
|---|---|---|
| Schlüssel und Tür im eigenen Projekt | läuft, committet | 2–3 h |
| Werkstatt | alle fünf Fehler behoben | 1 h |
| Spec der zweiten Interaktion | vier Zeilen und der Satz | 0,5 h |
| Interaktion 2 | läuft im Blockout, mit Knoten, die ihr kennt | 4–6 h |
| Build und Test auf fremdem Rechner | `.exe` startet, beide Interaktionen gehen | 1 h |
| Clip, Post, Devlog | 30 s, ein Hindernis, zwei Sätze | 1 h |

Wird Interaktion 2 größer als sechs Stunden, wird sie kleiner: weniger Schritte, bekannte Knoten. Wer den Rettungsweg geht, rechnet etwa vier Stunden dazu. Wer feststeckt: 30 Minuten selbst suchen (Graph, Console, Konzeptseiten), dann im Blackboard-Thread fragen, mit Bild der Console und des Graphs.