diff --git a/data/story/schauplaetze.json b/data/story/schauplaetze.json new file mode 100644 index 0000000..8b2e205 --- /dev/null +++ b/data/story/schauplaetze.json @@ -0,0 +1,15 @@ +{ + "_entwurf": "CR 51 — welche Dialogszene an welchem echten Ort spielt, statt auf der Greybox-Plattform des Kapitel-Runners. Liegt hier statt in den Dialogdateien, damit die Autorentexte unangetastet bleiben. Szenen OHNE Eintrag laufen weiter auf der Plattform — das ist Absicht, nicht Rueckstand: Ein Ort wird erst eingetragen, wenn seine Ablauf-Logik steht. — ort: die Szene, die geladen wird. anreise: Flugstrecke aus flugstrecken.json, die VOR dem Dialog geflogen wird. landepunkt: der Akteur, an dem gelandet wird (Tyrveil steigt daneben ab). zeigen/verbergen: Knoten, deren Sichtbarkeit (und Physik) fuer diesen Zustand geschaltet wird — so wird aus EINER Karte der K2- oder der K3-Zustand. zur_gruppe: Akteure des Orts, die sich fuer diese Szene zu Tyrveil stellen, statt an ihrem Szenenplatz zu bleiben. Sprecher, die der Ort gar nicht hat, bekommen eine Greybox-Figur in der Gruppe.", + "szenen": { + "akt2_k2_lieferung_erste": { + "_hinweis": "Die friedliche Lieferung, K2-Zustand des Dorfs. Imogen fliegt mit und spricht, obwohl die Szene sie standardmaessig verbirgt (dort ist der K3-Zustand vorgesehen, in dem sie erst am Ende kommt). DeadRing bleibt unsichtbar — der graue Ring gehoert zu K3.", + "ort": "res://scenes/village/dorf.tscn", + "anreise": "akt2_lieferung", + "landepunkt": "Smaladh", + "zeigen": ["Imogen"], + "zur_gruppe": ["Imogen"], + "verbergen": ["DeadRing"] + } + }, + "_offen": "akt3_k3_dorf, akt3_k3_smaladh und akt3_k3_kinder spielen am selben Ort, sind hier aber bewusst NOCH NICHT eingetragen: Ohne ihre Ablauf-Logik (DeadRing sichtbar, Such-Loop ueber die SearchPoints, Encounter aus den VeneniSpawns, FallAtmosphaere) waeren sie am echten Ort schlechter als auf der Plattform." +} diff --git a/scripts/gameplay/chapter_runner.gd b/scripts/gameplay/chapter_runner.gd index b2a6644..818e5d9 100644 --- a/scripts/gameplay/chapter_runner.gd +++ b/scripts/gameplay/chapter_runner.gd @@ -16,6 +16,18 @@ extends Node3D ## 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 @@ -51,6 +63,14 @@ 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") @@ -72,6 +92,11 @@ const FIGURE_COLORS := { "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 @@ -83,6 +108,11 @@ 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. @@ -91,6 +121,7 @@ func _ready() -> void: _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) @@ -103,6 +134,7 @@ func _ready() -> void: _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() @@ -120,6 +152,7 @@ func run_all() -> void: chapter_skipped.emit(skipped_id) continue await run_chapter(chapter) + _verlasse_ort() is_running = false SaveSystem.save_game() run_finished.emit() @@ -156,7 +189,13 @@ func run_scene(scene_id: String) -> void: push_error("Szene nicht spielbar (Dialogdatei fehlt oder ungültig): %s" % path) return scene_started.emit(scene_id) - var speakers := _ensure_figures(data.get("speakers", {})) + 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 @@ -164,6 +203,212 @@ func run_scene(scene_id: String) -> void: 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