extends Node3D ## Kapitel-Runner (CR 46) — spielt eine Szenenfolge aus einem Manifest ab. ## ## Ersetzt die Einzelverdrahtung pro Dialogdatei: Der Runner liest ein ## Kapitel-Manifest (`data/story/akt3_kapitel.json`, später auch ## `akt2_kapitel.json`) und arbeitet es ab — ## **Kapitel → Szenenliste → Dialog laden → Flags setzen → nächste Szene.** ## Die Reihenfolge im Manifest deckt sich mit den „ÜBERGANG nach …"-Notizen ## im letzten `_regie` jeder Datei; Quelle bleiben AKT2.md/AKT3.md. ## ## Für jede Szene baut der Runner die Sprecher-Figuren, die die Datei in ## ihrem `speakers`-Block nennt (Greybox: Kapsel, NameLabel, Sprechblase), ## und meldet sie dem DialogueSystem. Figuren bleiben über Szenen hinweg ## bestehen und sind nur in Szenen sichtbar, in denen sie vorkommen; sie ## gehören zur Person, nicht zur Sprecher-ID (siehe `_ensure_figures`, das ## Imogen-POV-Zwischenspiel). Akt 3 ist eine gerade Kette ## ohne offene Welt, ohne Unterricht und ohne Tageszyklus — der Runner ## braucht darum keine Spielersteuerung; Bewegung und Inszenierung kommen ## erst mit dem Szenen-Bau dazu. ## ## **Echte Orte:** Steht eine Szene in `data/story/schauplaetze.json`, spielt ## sie nicht auf der Plattform, sondern im gebauten Ort (erster Fall: Mikes ## Dorf fuer `akt2_k2_lieferung_erste`). Der Runner raeumt dafuer seine eigene ## Kulisse aus dem Baum — zwei WorldEnvironments vertragen sich nicht —, ## schaltet den Zustand des Orts (`zeigen`/`verbergen`), fliegt die `anreise` ## ueber den `Flugstrecke`-Knoten des Orts und uebergibt am `landepunkt` an ## Tyrveil: Flugkamera aus, Spielerkamera an, Tyrveil steigt neben dem Drachen ## ab. Sprecher werden zuerst unter den Akteuren des Orts gesucht (Knotenname ## wie die Sprecher-ID, gross geschrieben); wer dort fehlt, bekommt eine ## Greybox-Figur neben der Gruppe. Folgt eine Szene am selben Ort, bleibt er ## stehen; eine Szene ohne Eintrag stellt die Plattform wieder her. ## ## **Zurueckgestellte Kapitel:** Traegt ein Kapitel im Manifest ## `zurueckgestellt`, ueberspringt der Runner es und meldet es ueber ## `chapter_skipped` — samt Grund auf der Konsole. Gedacht fuer offene ## Autorenfragen, damit der Rest des Akts trotzdem laufen kann, ohne dass die ## Luecke still verschwindet. ## ## **Flags:** Die `setzt_flags` eines Kapitels werden gesetzt, wenn seine ## letzte Szene durch ist. Zusätzlich hält der Runner in ## `FLAG_CHAPTER` fest, welches Kapitel zuletzt lief, damit ein Spielstand ## mittendrin wieder einsteigen kann. ## ## **Inszenierung:** Die Figuren drehen sich zum Sprecher und tragen die ## Zeichen, die ein Beat braucht (CR 36/37) — was wann, steht in ## `data/story/inszenierung.json`. Ohne Eintrag passiert nichts. ## ## **Barks pro Szene:** Trägt ein Kapitel `barks_pro_szene`, gilt statt des ## Kapitel-Pools eine Zuordnung Szene -> Pool; Szenen ohne Eintrag bleiben ## still. Gebraucht fürs Akt-2-Zwischenspiel, das laut AKT2.md §7 ⑦ zwei ## Pools hat (`akt2_zw_basgiath` in Basgiath, `akt2_zw_hoehlen` in den Höhlen) ## und keinen gemeinsamen. ## ## **Barks:** Zu jedem Kapitel läuft sein Pool (`barks`), am Kapitelende ## wird er abgeschaltet. Kapitel ohne Pool bleiben still — Akt 3 K3 ## bekommt bewusst keine Barks (AKT3.md §3). Trägt ein Kapitel ## `barks_bis`, versiegt der Pool schon nach dieser Szene (K2: „Ab da ist ## es still, und das fällt auf."). signal chapter_started(chapter_id: String) ## Ein Kapitel wurde uebersprungen, weil es im Manifest als ## `zurueckgestellt` markiert ist (offene Autorenfrage). signal chapter_skipped(chapter_id: String) signal chapter_finished(chapter_id: String) signal scene_started(scene_id: String) signal scene_finished(scene_id: String) signal run_finished ## Ein echter Ort wurde geladen (Pfad der Ortsszene). signal ort_betreten(ort_pfad: String) ## Der Ort ist wieder abgebaut, die Plattform steht. signal ort_verlassen(ort_pfad: String) ## Die Anreise-Flugstrecke eines Orts laeuft los. signal anreise_gestartet(strecken_id: String) ## Gelandet und an Tyrveil uebergeben — ab hier laeuft der Dialog. signal angekommen(strecken_id: String) const DIALOGUE_DIR := "res://data/dialogue/" const BUBBLE_SCENE := preload("res://scenes/ui/speech_bubble.tscn") const FLAG_CHAPTER := "kapitel_aktuell" const SCENE_GAP := 0.8 const FIGURE_RADIUS := 4.2 const PLAYER_SPEAKER := "player" const PLAYER_FIGURE := "tyrveil" const FIGURE_COLORS := { "tyrveil": Color(0.30, 0.50, 0.85), "smaladh": Color(0.10, 0.09, 0.11), "xaden": Color(0.35, 0.33, 0.40), "imogen": Color(0.85, 0.35, 0.50), "garrick": Color(0.55, 0.45, 0.35), "bodhi": Color(0.45, 0.60, 0.70), "liam": Color(0.45, 0.72, 0.55), "rhiannon": Color(0.70, 0.60, 0.40), "ilva": Color(0.60, 0.55, 0.65), "buerger": Color(0.50, 0.48, 0.44), "frau": Color(0.62, 0.52, 0.52), } const DEFAULT_COLOR := Color(0.55, 0.55, 0.58) const SCHAUPLAETZE := "res://data/story/schauplaetze.json" const KULISSE := ["WorldEnvironment", "Sun", "Camera3D", "Ground"] const ABSTIEG := Vector3(3.0, 0.0, 0.0) const SPIELER_KAMERA := "CameraPivot/SpringArm3D/Camera3D" const AMBIENCE_HOEHE := 2.2 @export_file("*.json") var manifest_path := "res://data/story/akt3_kapitel.json" @export var autostart := true var is_running := false var _chapters: Array = [] var _figures: Dictionary = {} var _bark_player: Node var _inszenierung: Inszenierung var _ambience: Node3D var _schauplaetze: Dictionary = {} var _ort: Node3D var _ort_pfad := "" var _kulisse: Array[Node] = [] var _ambience_platz := Vector3.ZERO ## Baut Bark-Player und Ambiente-Träger, lädt das Manifest und startet. func _ready() -> void: Input.set_mouse_mode(Input.MOUSE_MODE_VISIBLE) _ambience = Node3D.new() _ambience.name = "Ambience" _ambience.position = Vector3(0, 2.2, 6.0) _ambience_platz = _ambience.position var bubble := BUBBLE_SCENE.instantiate() bubble.name = "SpeechBubble" _ambience.add_child(bubble) add_child(_ambience) _bark_player = preload("res://scripts/gameplay/bark_player.gd").new() _bark_player.name = "BarkPlayer" add_child(_bark_player) _bark_player.setup(bubble) _inszenierung = Inszenierung.new() _inszenierung.name = "Inszenierung" add_child(_inszenierung) _chapters = _load_manifest() _schauplaetze = _load_json(SCHAUPLAETZE).get("szenen", {}) if autostart and not _chapters.is_empty(): run_all.call_deferred() ## Spielt alle Kapitel des Manifests der Reihe nach ab. func run_all() -> void: if is_running: return is_running = true for chapter in _chapters: if bool(chapter.get("zurueckgestellt", false)): var skipped_id := _manifest_string(chapter, "id") print("[runner] Kapitel zurueckgestellt, uebersprungen: %s — %s" % [ skipped_id, _manifest_string(chapter, "zurueckgestellt_grund")]) chapter_skipped.emit(skipped_id) continue await run_chapter(chapter) _verlasse_ort() is_running = false SaveSystem.save_game() run_finished.emit() ## Spielt ein einzelnes Kapitel: Bark-Pool an, Szenen der Reihe nach, ## Flags setzen, Pool aus. func run_chapter(chapter: Dictionary) -> void: var chapter_id := _manifest_string(chapter, "id") GameState.set_story_flag(FLAG_CHAPTER, chapter_id) var scene_pools: Dictionary = chapter.get("barks_pro_szene", {}) if scene_pools.is_empty(): _bark_player.start_pool(_manifest_string(chapter, "barks")) chapter_started.emit(chapter_id) var barks_until := _manifest_string(chapter, "barks_bis") for scene_id in chapter.get("scenes", []): if not scene_pools.is_empty(): _bark_player.start_pool(_manifest_string(scene_pools, str(scene_id))) await run_scene(str(scene_id)) if barks_until == str(scene_id): _bark_player.stop() _bark_player.stop() for flag in chapter.get("setzt_flags", []): GameState.set_story_flag(str(flag), true) chapter_finished.emit(chapter_id) ## Spielt eine einzelne Szene: Dialogdatei laden, Sprecher-Figuren ## bereitstellen, Dialog abspielen und sein Ende abwarten. func run_scene(scene_id: String) -> void: var path := "%s%s.json" % [DIALOGUE_DIR, scene_id] var data := _load_json(path) if data.is_empty(): push_error("Szene nicht spielbar (Dialogdatei fehlt oder ungültig): %s" % path) return scene_started.emit(scene_id) var speakers: Dictionary = {} var schauplatz: Dictionary = _schauplaetze.get(scene_id, {}) if not schauplatz.is_empty() and await _betrete_ort(schauplatz): speakers = _figuren_am_ort(data.get("speakers", {}), schauplatz) else: _verlasse_ort() speakers = _ensure_figures(data.get("speakers", {})) DialogueSystem.start_dialogue(path, speakers) if DialogueSystem.is_dialogue_active: await DialogueSystem.dialogue_finished scene_finished.emit(scene_id) await get_tree().create_timer(SCENE_GAP).timeout ## Laedt den Ort einer Szene (oder behaelt ihn, wenn er schon steht), ## schaltet seinen Zustand und bringt Tyrveil hin — per Anreise-Flug, wenn ## der Eintrag einen nennt. `false`, wenn der Ort nicht ladbar ist; dann ## spielt die Szene auf der Plattform statt gar nicht. func _betrete_ort(schauplatz: Dictionary) -> bool: var pfad := _manifest_string(schauplatz, "ort") if _ort == null or _ort_pfad != pfad: _verlasse_ort() var paket: PackedScene = load(pfad) as PackedScene if ResourceLoader.exists(pfad) else null if paket == null: push_error("Schauplatz nicht ladbar, Szene laeuft auf der Plattform: %s" % pfad) return false _raeume_kulisse() _ort = paket.instantiate() as Node3D _ort_pfad = pfad add_child(_ort) ort_betreten.emit(pfad) _schalte_zustand(schauplatz) var anreise := _manifest_string(schauplatz, "anreise") if anreise.is_empty(): _uebergib_an_spieler(schauplatz) else: await _fliege_an(anreise, schauplatz) return true ## Baut den Ort ab und stellt die Plattform samt Greybox-Figuren wieder her. ## Ohne geladenen Ort passiert nichts. func _verlasse_ort() -> void: if _ort == null: return var pfad := _ort_pfad remove_child(_ort) _ort.queue_free() _ort = null _ort_pfad = "" for knoten in _kulisse: add_child(knoten) move_child(knoten, 0) if knoten is Camera3D: (knoten as Camera3D).make_current() _kulisse.clear() for figur in _figures.values(): figur.visible = true _ambience.position = _ambience_platz ort_verlassen.emit(pfad) ## Nimmt die eigene Kulisse (Umgebung, Licht, Kamera, Boden) aus dem Baum ## und blendet die Greybox-Figuren aus, solange ein Ort steht. func _raeume_kulisse() -> void: for knoten_name in KULISSE: var knoten := get_node_or_null(NodePath(knoten_name)) if knoten != null: remove_child(knoten) _kulisse.append(knoten) for figur in _figures.values(): figur.visible = false ## Schaltet Knoten des Orts fuer den Zustand dieser Szene. Verborgene Knoten ## werden auch aus der Physik genommen — ein unsichtbarer DeadRing darf ## keine Wand sein. func _schalte_zustand(schauplatz: Dictionary) -> void: for knoten_name in schauplatz.get("zeigen", []): _setze_aktiv(_ort.get_node_or_null(NodePath(str(knoten_name))), true) for knoten_name in schauplatz.get("verbergen", []): _setze_aktiv(_ort.get_node_or_null(NodePath(str(knoten_name))), false) ## Sichtbarkeit und Physik eines Ortsknotens gemeinsam schalten. func _setze_aktiv(knoten: Node, aktiv: bool) -> void: if knoten == null: return if knoten is Node3D: (knoten as Node3D).visible = aktiv knoten.process_mode = Node.PROCESS_MODE_INHERIT if aktiv else Node.PROCESS_MODE_DISABLED ## Fliegt die Anreise: Tyrveil und der gelandete Drache sind so lange aus ## dem Bild, die Flugkamera fuehrt, bis die Strecke am Landepunkt endet. func _fliege_an(strecken_id: String, schauplatz: Dictionary) -> void: var strecke := _ort.get_node_or_null("Flugstrecke") as Flugstrecke if strecke == null: push_error("Schauplatz %s hat keine Flugstrecke, Anreise entfaellt" % _ort_pfad) _uebergib_an_spieler(schauplatz) return var spieler := _ort.get_node_or_null("Player") as Node3D if spieler != null: spieler.visible = false spieler.process_mode = Node.PROCESS_MODE_DISABLED var landung := _landepunkt(schauplatz) if landung != null: landung.visible = false if not strecke.starte(strecken_id): _uebergib_an_spieler(schauplatz) return strecke.rig().visible = true var kamera := strecke.get_node_or_null("Kamera") as Camera3D if kamera != null: kamera.make_current() anreise_gestartet.emit(strecken_id) await strecke.strecke_beendet strecke.rig().visible = false _uebergib_an_spieler(schauplatz) angekommen.emit(strecken_id) ## Landung: Der Drache steht, Tyrveil steigt neben ihm ab (nicht in seine ## Kollision), und die Spielerkamera uebernimmt. func _uebergib_an_spieler(schauplatz: Dictionary) -> void: var landung := _landepunkt(schauplatz) if landung != null: landung.visible = true var spieler := _ort.get_node_or_null("Player") as Node3D if spieler == null: return if landung != null: var absetzen := landung.global_position + ABSTIEG absetzen.y = spieler.global_position.y spieler.global_position = absetzen spieler.visible = true spieler.process_mode = Node.PROCESS_MODE_INHERIT if spieler.has_method("reset_motion"): spieler.reset_motion() var kamera := spieler.get_node_or_null(SPIELER_KAMERA) as Camera3D if kamera != null: kamera.make_current() _ambience.position = spieler.global_position + Vector3.UP * AMBIENCE_HOEHE ## Der Akteur, an dem gelandet wird, oder `null`. func _landepunkt(schauplatz: Dictionary) -> Node3D: var knoten_name := _manifest_string(schauplatz, "landepunkt") if knoten_name.is_empty(): return null return _ort.get_node_or_null(NodePath(knoten_name)) as Node3D ## Sprecher-Map am echten Ort: Akteure des Orts zuerst, fehlende Sprecher als ## Greybox-Figur. Neue Figuren und die in `zur_gruppe` genannten stellen sich ## im Halbkreis neben Tyrveil auf — auf der dem Landepunkt abgewandten Seite. func _figuren_am_ort(speakers: Dictionary, schauplatz: Dictionary) -> Dictionary: var map: Dictionary = {} var gruppe: Array[Node3D] = [] var zur_gruppe: Array = schauplatz.get("zur_gruppe", []) for id in speakers: var speaker_id := str(id) var knoten := _ort.get_node_or_null(NodePath(speaker_id.capitalize())) as Node3D if knoten == null or knoten.get_node_or_null("SpeechBubble") == null: knoten = _make_figure(str(speakers[id]), speaker_id) _ort.add_child(knoten) gruppe.append(knoten) elif zur_gruppe.has(str(knoten.name)): gruppe.append(knoten) map[speaker_id] = knoten _stelle_gruppe_auf(gruppe, schauplatz) _inszenierung.setup(_blickfiguren(map)) return map ## Halbkreis um Tyrveil, vom Landepunkt weg. func _stelle_gruppe_auf(gruppe: Array[Node3D], schauplatz: Dictionary) -> void: var spieler := _ort.get_node_or_null("Player") as Node3D if spieler == null or gruppe.is_empty(): return var anker := spieler.global_position var weg := ABSTIEG var landung := _landepunkt(schauplatz) if landung != null: weg = anker - landung.global_position weg.y = 0.0 weg = weg.normalized() if weg.length() > 0.01 else Vector3.RIGHT var spanne := PI * 0.8 for i in gruppe.size(): var winkel := -spanne / 2.0 + spanne * (float(i) + 0.5) / float(gruppe.size()) var platz := anker + weg.rotated(Vector3.UP, winkel) * FIGURE_RADIUS platz.y = anker.y gruppe[i].global_position = platz ## Fuer die Blickregie zaehlt am echten Tyrveil nur der Koerper: Die Wurzel ## dreht die Kamera mit, die Mesh-Instanz traegt schon die Augen. func _blickfiguren(map: Dictionary) -> Dictionary: var figuren: Dictionary = {} for id in map: var knoten: Node3D = map[id] var koerper := knoten.get_node_or_null("MeshInstance3D") as Node3D figuren[id] = koerper if koerper != null and koerper.get_node_or_null("GooglyEyes") != null else knoten return figuren ## Die Kulisse liegt waehrend eines Orts ausserhalb des Baums und wuerde ## beim Abbau des Runners sonst verwaisen. func _notification(what: int) -> void: if what == NOTIFICATION_PREDELETE: for knoten in _kulisse: if is_instance_valid(knoten) and not knoten.is_inside_tree(): knoten.free() ## Der gerade geladene Ort (fuer Sonden), sonst `null`. func aktueller_ort() -> Node3D: return _ort ## Stellt für jede Sprecher-ID der Szene eine Figur bereit (vorhandene ## werden wiederverwendet) und liefert die Sprecher-Map fürs ## DialogueSystem. Sprecher ohne Anzeigenamen (der abgeschaffte ## `narrator`) bekommen trotzdem eine Figur, damit ihre Zeilen nicht ## sprecherlos ins Leere laufen. ## ## Figuren gehören zu Personen, nicht zu Sprecher-IDs: `player` ist in den ## Imogen-POV-Szenen des Zwischenspiels Imogen, und dort spricht Tyrveil als ## `tyrveil`. Wer hinter `player` steht, sagt der Anzeigename der Szene selbst ## — nicht das `pov` des Kapitels, denn `akt2_zw_abbruch` liegt im ## Imogen-Kapitel und ist trotzdem Tyrveils Sicht. Die Figur in der ## `player`-Rolle rückt nach vorn in die Mitte; wer in der Szene nicht ## vorkommt, ist ausgeblendet, damit sich die Kapseln dort nicht stapeln. func _ensure_figures(speakers: Dictionary) -> Dictionary: var map: Dictionary = {} var anwesend: Array = [] var ids: Array = speakers.keys() var vorn := _figure_position(PLAYER_SPEAKER, 0, 1) for i in ids.size(): var speaker_id := str(ids[i]) var figur_id := _figur_id(speaker_id, speakers) var platz := _figure_position(speaker_id, i, ids.size()) if not _figures.has(figur_id): var figure := _make_figure(str(speakers[speaker_id]), figur_id) figure.position = platz add_child(figure) _figures[figur_id] = figure else: var vorhanden: Node3D = _figures[figur_id] if speaker_id == PLAYER_SPEAKER or vorhanden.position.is_equal_approx(vorn): vorhanden.position = platz map[speaker_id] = _figures[figur_id] anwesend.append(_figures[figur_id]) for figur in _figures.values(): figur.visible = anwesend.has(figur) _inszenierung.setup(map) return map ## Die Person hinter einer Sprecher-ID. `player` ist, wen die Szene als ## Anzeigenamen nennt (Tyrveil oder im Zwischenspiel Imogen), ohne Namen ## Tyrveil; alle anderen IDs sind schon Personen. func _figur_id(speaker_id: String, speakers: Dictionary) -> String: if speaker_id != PLAYER_SPEAKER: return speaker_id var anzeigename := str(speakers.get(speaker_id, "")).strip_edges().to_lower() return anzeigename if not anzeigename.is_empty() else PLAYER_FIGURE ## Platziert Tyrveil vorn in der Mitte, alle anderen im Halbkreis davor. func _figure_position(speaker_id: String, index: int, count: int) -> Vector3: if speaker_id == PLAYER_SPEAKER: return Vector3(0, 0, 2.5) var span := PI * 0.8 var angle := -span / 2.0 + span * (float(index) + 0.5) / float(maxi(count, 1)) return Vector3(sin(angle) * FIGURE_RADIUS, 0, -cos(angle) * FIGURE_RADIUS) ## Baut eine Greybox-Figur: Kapsel, NameLabel und Sprechblase. func _make_figure(display_name: String, speaker_id: String) -> Node3D: var root := Node3D.new() root.name = speaker_id.capitalize() var mesh_instance := MeshInstance3D.new() var mesh := CapsuleMesh.new() mesh.radius = 0.4 mesh.height = 1.8 var material := StandardMaterial3D.new() material.albedo_color = FIGURE_COLORS.get(speaker_id, DEFAULT_COLOR) mesh.material = material mesh_instance.mesh = mesh mesh_instance.position = Vector3(0, 0.9, 0) root.add_child(mesh_instance) if not display_name.is_empty(): var label := Label3D.new() label.name = "NameLabel" label.text = display_name label.position = Vector3(0, 2.2, 0) label.billboard = BaseMaterial3D.BILLBOARD_ENABLED label.font_size = 48 label.outline_size = 12 root.add_child(label) var bubble := BUBBLE_SCENE.instantiate() bubble.name = "SpeechBubble" bubble.position = Vector3(0, 2.7, 0) root.add_child(bubble) return root ## Liest ein Textfeld aus einem Manifest-Eintrag. JSON-`null` (im Manifest ## fuer Kapitel ohne Bark-Pool) gilt als leerer String — `str(null)` waere ## sonst der Text "" und wuerde eine Datei dieses Namens suchen. func _manifest_string(entry: Dictionary, key: String) -> String: var value: Variant = entry.get(key) return str(value) if value is String else "" ## Liest die Kapitelliste aus dem Manifest. func _load_manifest() -> Array: var data := _load_json(manifest_path) if not (data.get("chapters") is Array): push_error("Kapitel-Manifest ist ungültig: %s" % manifest_path) return [] return data["chapters"] ## Liefert die Kapitel des geladenen Manifests (für Tests und Wiedereinstieg). func get_chapters() -> Array: return _chapters ## Lädt und parst eine JSON-Datei; leeres Dictionary bei Fehlern. func _load_json(path: String) -> Dictionary: var file := FileAccess.open(path, FileAccess.READ) if file == null: push_error("Datei nicht lesbar: %s" % path) return {} var parsed: Variant = JSON.parse_string(file.get_as_text()) file.close() return parsed if parsed is Dictionary else {}