windgeschworen/scripts/gameplay/chapter_runner.gd
danny 99d28d3675 Greybox-Figuren gehoeren zur Person, nicht zur Sprecher-ID player
Nach Karstens Sprecher-Fix ist player in den Imogen-POV-Szenen Imogen. Der
Runner hat Figuren aber nach Sprecher-ID wiederverwendet und gefaerbt: Imogen
stand als blaue Kapsel mit dem Schild "Tyrveil" vorn. Jetzt entscheidet der
Anzeigename der Szene, wer hinter player steht (nicht das pov des Kapitels:
akt2_zw_abbruch liegt im Imogen-Kapitel und ist Tyrveils Sicht). Die Figur
in der player-Rolle rueckt nach vorn; Figuren, die in einer Szene nicht
vorkommen, sind ausgeblendet, damit sich keine Kapseln stapeln.

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

533 lines
20 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; 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 "<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 {}