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>
596 lines
23 KiB
GDScript
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 {}
|