diff --git a/docs/CHANGEREQUESTS.md b/docs/CHANGEREQUESTS.md index b17a3af..bb1ad8c 100644 --- a/docs/CHANGEREQUESTS.md +++ b/docs/CHANGEREQUESTS.md @@ -125,11 +125,17 @@ damit der billigste Weg, den Runner überhaupt zu bauen. Hängt an **CR 43** (`requires_flag`, `time_card`) und **CR 45**. Ohne CR 43 laufen sechs Verzweigungen falsch (Liste dort). -## Akzeptanz +## Akzeptanz — ✅ ERFÜLLT für Akt 3 (2026-09-05, Commit s. DONE) - Akt 3 ist von `akt3_k1_anflug` bis `akt3_k5_aretia` durchspielbar. - Alle in AKT3.md §9 ① gelisteten Flags werden gesetzt. - Die Bark-Pools laufen in ihren Kapiteln — und **K3 bekommt keine**. +> **Stand:** Der Runner (`scripts/gameplay/chapter_runner.gd`) steht und spielt +> Akt 3 komplett (13 Szenen, Sonde 16/16). **Offen bleibt Akt 2** — dieselbe +> Mechanik plus offene Welt, Unterricht und Tageszyklus (eigenes Programm, +> AKT2 §7 ⑩). `neue_wirbelsaeule` ist zweigabhängig (Option 2 in +> `keine_busse`), nicht in jedem Durchlauf gesetzt — laut §9 ① eine „Auswahl". + --- # CR 47 — Der Geschichts-Unterricht ist absichtlich falsch. Nicht korrigieren. diff --git a/scenes/akt3/akt3_runner.tscn b/scenes/akt3/akt3_runner.tscn new file mode 100644 index 0000000..fca003f --- /dev/null +++ b/scenes/akt3/akt3_runner.tscn @@ -0,0 +1,49 @@ +[gd_scene load_steps=8 format=3] + +[ext_resource type="Script" path="res://scripts/gameplay/chapter_runner.gd" id="1_runner"] + +[sub_resource type="ProceduralSkyMaterial" id="ProceduralSkyMaterial_sky"] +sky_horizon_color = Color(0.55, 0.54, 0.56, 1) +ground_horizon_color = Color(0.55, 0.54, 0.56, 1) + +[sub_resource type="Sky" id="Sky_sky"] +sky_material = SubResource("ProceduralSkyMaterial_sky") + +[sub_resource type="Environment" id="Environment_env"] +background_mode = 2 +sky = SubResource("Sky_sky") +tonemap_mode = 2 + +[sub_resource type="StandardMaterial3D" id="StandardMaterial3D_ground"] +albedo_color = Color(0.29, 0.28, 0.28, 1) + +[sub_resource type="BoxShape3D" id="BoxShape3D_ground"] +size = Vector3(40, 1, 40) + +[sub_resource type="BoxMesh" id="BoxMesh_ground"] +material = SubResource("StandardMaterial3D_ground") +size = Vector3(40, 1, 40) + +[node name="Akt3Runner" type="Node3D"] +script = ExtResource("1_runner") +manifest_path = "res://data/story/akt3_kapitel.json" + +[node name="WorldEnvironment" type="WorldEnvironment" parent="."] +environment = SubResource("Environment_env") + +[node name="Sun" type="DirectionalLight3D" parent="."] +transform = Transform3D(0.866025, 0.383022, -0.321394, 0, 0.642788, 0.766044, 0.5, -0.663414, 0.55667, 0, 12, 0) +shadow_enabled = true + +[node name="Camera3D" type="Camera3D" parent="."] +transform = Transform3D(1, 0, 0, 0, 0.965926, 0.258819, 0, -0.258819, 0.965926, 0, 5, 11) +current = true + +[node name="Ground" type="StaticBody3D" parent="."] +transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, -0.5, 0) + +[node name="CollisionShape3D" type="CollisionShape3D" parent="Ground"] +shape = SubResource("BoxShape3D_ground") + +[node name="MeshInstance3D" type="MeshInstance3D" parent="Ground"] +mesh = SubResource("BoxMesh_ground") diff --git a/scripts/gameplay/bark_player.gd b/scripts/gameplay/bark_player.gd new file mode 100644 index 0000000..2a575d9 --- /dev/null +++ b/scripts/gameplay/bark_player.gd @@ -0,0 +1,122 @@ +extends Node +## Bark-Pool eines Kapitels (CR 46). +## +## Spielt gewichtete Einzeiler aus `data/barks/.json` als +## Welt-Ambiente über eine Sprechblase — nie während eines laufenden +## Dialogs, damit die Barks der Dialog-Box nicht ins Wort fallen. Der +## Kapitel-Runner lädt zu jedem Kapitel den zugehörigen Pool und schaltet +## ihn am Kapitelende wieder ab; Kapitel ohne Pool (Akt 3 K3 — bewusst +## keine Barks) bleiben still. +## +## Gewichtung wie bei den Siegelkräften: `weight` spiegelt, wie oft eine +## Zeile fallen darf. Gespielte Zeilen werden bis zum Pool-Ende nicht +## wiederholt, damit ein Kapitel sich nicht sofort wiederholt. + +const BARKS_DIR := "res://data/barks/" +const DEFAULT_WEIGHT := 1 + +@export var interval_min := 11.0 +@export var interval_max := 19.0 + +var _pool: Array = [] +var _unused: Array = [] +var _remaining := 0.0 +var _bubble: Node3D +var _pool_id := "" + + +## Setzt die Sprechblase, über die die Barks laufen. +func setup(bubble: Node3D) -> void: + _bubble = bubble + + +## Lädt den Pool eines Kapitels und schaltet ihn scharf. Leere pool_id +## (Kapitel ohne Barks) schaltet still ab. Liefert true, wenn ein Pool +## läuft. +func start_pool(pool_id: String) -> bool: + stop() + if pool_id.is_empty(): + return false + var path := "%s%s.json" % [BARKS_DIR, pool_id] + var file := FileAccess.open(path, FileAccess.READ) + if file == null: + push_error("Bark-Pool nicht lesbar: %s" % path) + return false + var parsed: Variant = JSON.parse_string(file.get_as_text()) + file.close() + if not (parsed is Dictionary) or not (parsed.get("barks") is Array): + push_error("Bark-Pool ist ungültig: %s" % path) + return false + _pool = parsed["barks"] + _unused = _pool.duplicate() + _pool_id = pool_id + _reset_timer() + return not _pool.is_empty() + + +## Schaltet den laufenden Pool ab (Kapitelende, oder Kapitel ohne Barks). +func stop() -> void: + _pool.clear() + _unused.clear() + _pool_id = "" + + +## Die ID des laufenden Pools; leer, wenn gerade keiner läuft. +func get_pool_id() -> String: + return _pool_id + + +## Zählt das Intervall herunter und spielt die nächste Zeile — pausiert, +## solange ein Dialog läuft. +func _process(delta: float) -> void: + if _pool.is_empty() or _bubble == null or not is_instance_valid(_bubble): + return + if DialogueSystem.is_dialogue_active: + return + _remaining -= delta + if _remaining > 0.0: + return + _reset_timer() + play_bark() + + +## Spielt sofort eine gewichtet gezogene Zeile (öffentlich für Tests). +func play_bark() -> String: + var bark := _draw() + if bark.is_empty(): + return "" + var text := str(bark.get("text", "")) + if _bubble != null and is_instance_valid(_bubble): + _bubble.show_line(text) + return text + + +## Zieht eine gewichtete Zeile aus den noch ungespielten; ist der Pool +## durch, füllt er sich wieder auf. +func _draw() -> Dictionary: + if _pool.is_empty(): + return {} + if _unused.is_empty(): + _unused = _pool.duplicate() + var total := 0 + for bark in _unused: + total += maxi(int(bark.get("weight", DEFAULT_WEIGHT)), 0) + if total <= 0: + var fallback: Dictionary = _unused.pick_random() + _unused.erase(fallback) + return fallback + var roll := randi_range(1, total) + var cumulative := 0 + for bark in _unused: + cumulative += maxi(int(bark.get("weight", DEFAULT_WEIGHT)), 0) + if roll <= cumulative: + _unused.erase(bark) + return bark + var last: Dictionary = _unused.back() + _unused.erase(last) + return last + + +## Würfelt die Pause bis zur nächsten Zeile. +func _reset_timer() -> void: + _remaining = randf_range(interval_min, interval_max) diff --git a/scripts/gameplay/bark_player.gd.uid b/scripts/gameplay/bark_player.gd.uid new file mode 100644 index 0000000..2d4ebfd --- /dev/null +++ b/scripts/gameplay/bark_player.gd.uid @@ -0,0 +1 @@ +uid://btuucxv8uar4f diff --git a/scripts/gameplay/chapter_runner.gd b/scripts/gameplay/chapter_runner.gd new file mode 100644 index 0000000..0b52827 --- /dev/null +++ b/scripts/gameplay/chapter_runner.gd @@ -0,0 +1,222 @@ +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, solange sie wieder vorkommen. 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. +## +## **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. +## +## **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) +signal chapter_finished(chapter_id: String) +signal scene_started(scene_id: String) +signal scene_finished(scene_id: String) +signal run_finished + +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 FIGURE_COLORS := { + "player": 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) + +@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 _ambience: Node3D + + +## 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) + 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) + _chapters = _load_manifest() + 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: + await run_chapter(chapter) + 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) + _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", []): + 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 := _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 + + +## 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. +func _ensure_figures(speakers: Dictionary) -> Dictionary: + var map: Dictionary = {} + var ids: Array = speakers.keys() + for i in ids.size(): + var speaker_id := str(ids[i]) + if not _figures.has(speaker_id): + var figure := _make_figure(str(speakers[speaker_id]), speaker_id) + figure.position = _figure_position(speaker_id, i, ids.size()) + add_child(figure) + _figures[speaker_id] = figure + map[speaker_id] = _figures[speaker_id] + return map + + +## 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 "" 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 {} diff --git a/scripts/gameplay/chapter_runner.gd.uid b/scripts/gameplay/chapter_runner.gd.uid new file mode 100644 index 0000000..3e0d878 --- /dev/null +++ b/scripts/gameplay/chapter_runner.gd.uid @@ -0,0 +1 @@ +uid://cfr3vylmm4rfm