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>
533 lines
20 KiB
GDScript
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 {}
|