windgeschworen/scripts/gameplay/chapter_runner.gd
danny c285a6806d CR 48: Der Fall im Dorf spielbar (akt3_k3_dorf/_smaladh/_kinder)
DorfFall spielt die drei K3-Dateien in Segmenten mit dem Spiel dazwischen,
Werte und Schnittknoten in data/story/dorf_fall.json:
- Anflug ueber die Lieferstrecke, "Es steht noch" und der graue Ring noch
  in der Luft (DeadRing sichtbar), Landung bei "landung".
- Gefecht ueber das bestehende Encounter-System, je ein Gegner an den drei
  VeneniSpawn-Markern, Smaladh in der Luft; sein "Ich weiss, was das ist"
  nach dem ersten Toten.
- Nach der Entscheidung ein durchgehender Encounter samt Frau vom Brunnen,
  damit die Anzeigen nacheinander wegbrechen. Smaladh landet, wenn er
  aufhoert; waehrend der Erosion rueckt nach, bis sie durch ist, der Kopf
  dreht sich ohne Dialogbox nach Nordosten; bei die_pfuetze schwarze Augen.
- Suche ueber die vier SearchPoints in beliebiger Reihenfolge, Stehenbleiben
  fuehrt ins naechste Haus; danach zweiter Durchgang oder Rueckfuehrung,
  Imogen steht hinter ihm in der Tuer, dann sie_kommt.
Phasen weiter nur aus akt3_k3_fall.json.

Runner: im_flug_bis (Dialog waehrend der Anreise), ablauf (Komponente je
Ort), Folgeszenen am selben Ort setzen Tyrveil nicht an den Landepunkt
zurueck, im Flug ruht nur seine Physik (vorher hing seine erste Antwort im
Flugdialog, weil seine Sprechblase mit angehalten war).

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-14 18:32:17 +02:00

596 lines
23 KiB
GDScript

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 — und Tyrveil mit ihm —; eine Szene ohne Eintrag stellt die
## Plattform wieder her. `im_flug_bis` laesst den Dialog schon im Anflug
## laufen; `ablauf` nennt eine Komponente, die die Szene statt eines
## einzelnen Dialogs spielt (Akt 3 K3: `DorfFall`, CR 48).
##
## **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 _ort_neu := false
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 weiter_ab := ""
var ablauf: Node = null
var schauplatz: Dictionary = _schauplaetze.get(scene_id, {})
if not schauplatz.is_empty() and _lade_ort(schauplatz):
if not _manifest_string(schauplatz, "im_flug_bis").is_empty():
speakers = _figuren_am_ort(data.get("speakers", {}), schauplatz)
weiter_ab = await _reise_an(path, speakers, schauplatz)
speakers = _figuren_am_ort(data.get("speakers", {}), schauplatz)
ablauf = _ablauf(schauplatz)
else:
_verlasse_ort()
speakers = _ensure_figures(data.get("speakers", {}))
if ablauf != null:
await ablauf.spiele(scene_id, path, speakers, weiter_ab)
else:
DialogueSystem.start_dialogue(path, speakers, weiter_ab)
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 (dann
## ist `_ort_neu` false). `false`, wenn der Ort nicht ladbar ist; dann
## spielt die Szene auf der Plattform statt gar nicht.
func _lade_ort(schauplatz: Dictionary) -> bool:
var pfad := _manifest_string(schauplatz, "ort")
_ort_neu = false
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_neu = true
ort_betreten.emit(pfad)
return true
## Schaltet den Zustand des Orts und bringt Tyrveil hin: per Anreise-Flug,
## wenn der Eintrag einen nennt, sonst nur beim frisch geladenen Ort an den
## Landepunkt. Folgeszenen am selben Ort lassen ihn stehen, wo er ist (K3:
## vom Gefecht in die Suche). Liefert den Knoten, ab dem der Dialog nach
## einem Dialog im Flug weiterlaeuft, sonst "".
func _reise_an(pfad: String, speakers: Dictionary, schauplatz: Dictionary) -> String:
_schalte_zustand(schauplatz)
var anreise := _manifest_string(schauplatz, "anreise")
if not anreise.is_empty():
return await _fliege_an(anreise, schauplatz, pfad, speakers)
if _ort_neu:
_uebergib_an_spieler(schauplatz)
return ""
## Die Ablauf-Komponente eines Orts (`ablauf`: Skriptpfad), einmal pro Ort
## unter ihm angelegt und ueber dessen Szenen hinweg behalten. Sie spielt
## die Szene statt eines einzelnen Dialogs (`spiele`), z. B. den Fall im
## Dorf mit Gefecht und Suche zwischen den Segmenten. Ohne Eintrag `null`.
func _ablauf(schauplatz: Dictionary) -> Node:
var skript_pfad := _manifest_string(schauplatz, "ablauf")
if skript_pfad.is_empty() or _ort == null:
return null
var knoten_name := skript_pfad.get_file().get_basename().to_pascal_case()
var vorhanden := _ort.get_node_or_null(NodePath(knoten_name))
if vorhanden != null:
return vorhanden
var skript: GDScript = load(skript_pfad) as GDScript if ResourceLoader.exists(skript_pfad) else null
if skript == null:
push_error("Ablauf nicht ladbar, Szene laeuft als reiner Dialog: %s" % skript_pfad)
return null
var ablauf: Node = skript.new()
if not ablauf.has_method("spiele"):
push_error("Ablauf ohne spiele(): %s" % skript_pfad)
ablauf.free()
return null
ablauf.name = knoten_name
_ort.add_child(ablauf)
return ablauf
## 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.
## Angehalten wird nur Tyrveils Physik, nicht der ganze Knoten — seine
## Sprechblase muss weiterlaufen, sonst haengt eine Antwort im Flugdialog.
##
## Nennt der Eintrag `im_flug_bis`, laeuft der Dialog schon waehrend des
## Flugs bis vor diesen Knoten (K3: „Es steht noch", der Ring aus der Luft).
## Gelandet wird erst, wenn Strecke UND Segment durch sind — die Flugkamera
## haelt so lange ueber dem Landepunkt. Rueckgabe: der Knoten, ab dem der
## Dialog am Boden weiterlaeuft.
func _fliege_an(strecken_id: String, schauplatz: Dictionary, pfad := "", speakers: Dictionary = {}) -> String:
var im_flug := _manifest_string(schauplatz, "im_flug_bis")
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.set_physics_process(false)
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)
if not im_flug.is_empty() and not pfad.is_empty():
DialogueSystem.start_dialogue(pfad, speakers, "", im_flug)
await strecke.strecke_beendet
if not im_flug.is_empty() and DialogueSystem.is_dialogue_active:
await DialogueSystem.dialogue_finished
strecke.rig().visible = false
_uebergib_an_spieler(schauplatz)
angekommen.emit(strecken_id)
return im_flug
## 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.set_physics_process(true)
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 "<null>" 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 {}