From 6ccc94cfda15316836ac3b530bc77aef6159205c Mon Sep 17 00:00:00 2001 From: danny Date: Mon, 20 Jul 2026 20:07:27 +0200 Subject: [PATCH] =?UTF-8?q?CR=2012:=20Blaetter=20jagen=20=E2=80=94=20verlo?= =?UTF-8?q?rene=20Seiten=20einfangen?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Lose Heftblaetter treiben im Wind ueber den Hof: gewuerfelte Driftrichtung, Wippen, Trudeln, und am Rand des Treibkreises setzen sie sich auf der Gegenseite neu an. Die Flughoehe wird zwischen 0,5 und 2,3 Metern gewuerfelt — tiefe Blaetter erwischt man im Slide, hohe im Sprung. Gefangen wird ohne Interaktionstaste, allein durch Beruehrung. Der Spawner streut pro Tag drei Blaetter aus: erst die festen Schluessel-Seiten ab ihrem min_day, dann gewichtet gezogener Rest. Gefangene Seiten kommen nie wieder (GameState.caught_pages, im Spielstand). Vier Fund-Typen: wahrheit legt ein Fragment aufs Muster-Board, notiz hebt einen Lexicon-Fachzaehler und gibt Verstand, vater ist der seltene Fund, flavor traegt nur die Zeile. Kanon-Entscheidung (STORY vor CR): Wahrheit 2 ist anvertraute Wahrheit und kommt von Mira, nicht vom Wind. Die Vater-Seiten enthuellen deshalb nichts — sie sind seine Handschrift und liegen unter vater_seite_* auf einer eigenen Lexicon-Seite statt auf dem Muster-Board; sie ziehen Richtung Herz. Verifiziert mit dev_cr12_probe (25/25) und einem Boot-Check ueber acht Szenen; Sonde vor dem Commit geloescht. Co-Authored-By: Claude Opus 4.8 --- data/pages/loose_pages.json | 104 ++++++++++++++++++++++ docs/CHANGEREQUESTS.md | 15 ---- docs/CHANGEREQUESTS_DONE.md | 45 ++++++++++ docs/ROADMAP.md | 6 +- scenes/hub/rider_quadrant.tscn | 9 +- scenes/props/loose_page.tscn | 29 ++++++ scripts/autoloads/game_state.gd | 20 +++++ scripts/gameplay/loose_page.gd | 98 +++++++++++++++++++++ scripts/gameplay/loose_page.gd.uid | 1 + scripts/gameplay/page_spawner.gd | 126 +++++++++++++++++++++++++++ scripts/gameplay/page_spawner.gd.uid | 1 + scripts/ui/lexicon.gd | 30 +++++++ 12 files changed, 466 insertions(+), 18 deletions(-) create mode 100644 data/pages/loose_pages.json create mode 100644 scenes/props/loose_page.tscn create mode 100644 scripts/gameplay/loose_page.gd create mode 100644 scripts/gameplay/loose_page.gd.uid create mode 100644 scripts/gameplay/page_spawner.gd create mode 100644 scripts/gameplay/page_spawner.gd.uid diff --git a/data/pages/loose_pages.json b/data/pages/loose_pages.json new file mode 100644 index 0000000..a384fdb --- /dev/null +++ b/data/pages/loose_pages.json @@ -0,0 +1,104 @@ +{ + "design_note": "CR 12 („Blätter jagen“). Vier Fund-Typen: 'wahrheit' legt ein Fragment aufs Muster-Board (Story-Flag mit Präfix w1_fragment_, CR 2), 'notiz' füllt eine Fach-Seite des Lexicons (counter_flag aus data/lexicon/subjects.json) und gibt Verstand, 'vater' ist ein seltener, emotionaler Fund (Story-Flag mit Präfix vater_seite_, eigene Lexicon-Seite) und 'flavor' trägt nur Atmosphäre. Seiten mit is_fixed erscheinen ab ihrem min_day garantiert, bis sie gefangen sind — das sind die Schlüssel-Funde. Alle anderen werden nach weight gezogen; die Vater-Seiten tragen bewusst das kleinste Gewicht.", + "canon_note": "Wahrheit 2 (wer Robert Rowyth wirklich war) wird NICHT über Blätter enthüllt — sie ist anvertraute Wahrheit und kommt von Mira (STORY.md). Die Vater-Seiten rühren nur daran: seine Handschrift, seine Randnotizen, seine Art zu denken. Sie geben Tyrveil den Menschen zurück, nicht die Auflösung.", + "pages": [ + { + "id": "aushang_fetzen", + "type": "wahrheit", + "is_fixed": true, + "min_day": 2, + "catch_line": "Ein halber Aushang, am Rand abgerissen. Namen, Jahrgänge, Alter. Eine Zeile ist mit dem Daumen verschmiert — als hätte jemand sie wegwischen wollen.", + "fragment_flag": "w1_fragment_seiten_aushang", + "fragment_text": "Ein zerrissener Aushang vom Hof: Jahrgangslisten mit Altersangaben. Eine Zeile ist absichtlich verschmiert. Wer wischt ein Alter weg?" + }, + { + "id": "einberufungsliste", + "type": "wahrheit", + "is_fixed": true, + "min_day": 5, + "catch_line": "Eine Durchschlagseite. Einberufungen, nach Jahrgang sortiert — und ganz unten drei Namen ohne Jahrgang, mit einem Vermerk in anderer Tinte.", + "fragment_flag": "w1_fragment_seiten_liste", + "fragment_text": "Durchschlag einer Einberufungsliste: drei Namen stehen ohne Jahrgang darunter, nachgetragen in anderer Tinte. Nachgetragen heißt: nicht vorgesehen." + }, + { + "id": "wachplan_rand", + "type": "wahrheit", + "weight": 3, + "min_day": 3, + "catch_line": "Ein Wachplan-Fetzen. Am Rand hat jemand mitgezählt, wie oft dieselben Namen auf denselben Posten stehen. Die Striche hören mitten im Zählen auf.", + "fragment_flag": "w1_fragment_seiten_wachplan", + "fragment_text": "Ein Wachplan mit Strichliste am Rand: jemand hat gezählt, wie oft dieselben Namen dieselben Posten ziehen. Das Zählen bricht ab. Freiwillig hört man anders auf." + }, + { + "id": "notiz_drachenkunde", + "type": "notiz", + "weight": 8, + "catch_line": "Vorlesungsnotizen, fremde Handschrift, Jahrgang vor deinem. Schwanztypen, sauber skizziert — und in der Ecke: „der Skorpion war der, der Belen geholt hat“.", + "subject_flag": "drachenkunde_wissen" + }, + { + "id": "notiz_gefechtskunde", + "type": "notiz", + "weight": 8, + "catch_line": "Mitschrift aus der Gefechtskunde. Frontverläufe, Nachschubwege, alles ordentlich. Über den letzten Absatz hat jemand später mit Kohle geschrieben: „stimmt nicht“.", + "subject_flag": "battle_brief_wissen" + }, + { + "id": "notiz_geschichte", + "type": "notiz", + "weight": 8, + "catch_line": "Markhams Chronik, abgeschrieben Wort für Wort. Am unteren Rand, ganz klein: „Er sagt diesen Satz jedes Jahr gleich. Wortgleich.“", + "subject_flag": "geschichte_wissen" + }, + { + "id": "vater_randnotiz", + "type": "vater", + "is_fixed": true, + "min_day": 7, + "catch_line": "Du hast die Seite gefangen, bevor du sie gelesen hast. Die Handschrift kennst du, seit du Buchstaben kennst. Deine Hand hält still. Der Rest von dir nicht.", + "keepsake_flag": "vater_seite_randnotiz", + "keepsake_text": "Randnotiz in seiner Handschrift, an den Rand eines Dienstplans gekritzelt: „Wer die Liste schreibt, entscheidet, wer alt wird.“ Kein Datum. Keine Unterschrift. Er hat nie unterschrieben, wenn es ihm ernst war." + }, + { + "id": "vater_marschbefehl", + "type": "vater", + "weight": 1, + "min_day": 4, + "catch_line": "Ein Blatt, weicher als die anderen — oft gefaltet, oft aufgemacht. Und dann seine Schrift, mitten im Hof, im Wind. Du stehst länger still, als du wolltest.", + "keepsake_flag": "vater_seite_marschbefehl", + "keepsake_text": "Die Rückseite eines alten Marschbefehls, vollgeschrieben in seiner Handschrift — Namen, durchgestrichen, wieder danebengeschrieben, wieder durchgestrichen. Er hat jemanden von einer Liste geholt. Immer wieder denselben Namen." + }, + { + "id": "flavor_essensplan", + "type": "flavor", + "weight": 10, + "catch_line": "Der Essensplan der Woche. Dienstag steht zweimal drauf. Küchendienst hat aufgegeben." + }, + { + "id": "flavor_liebesbrief", + "type": "flavor", + "weight": 10, + "catch_line": "Ein angefangener Brief. Drei Anläufe für denselben ersten Satz, jeder durchgestrichen. Der vierte fehlt. Manche Dinge schafft man nicht bis zum Wind." + }, + { + "id": "flavor_schuldschein", + "type": "flavor", + "weight": 10, + "catch_line": "Ein Schuldschein über vier Marken, unterschrieben mit einem Kringel. Auf der Rückseite: „ich zahl das NICHT, du hast beschissen“." + }, + { + "id": "flavor_geruecht", + "type": "flavor", + "weight": 10, + "min_day": 4, + "catch_line": "Eine Zeile, aus einem Heft gerissen: „Zwei Namen fehlen im Appell und keiner fragt nach.“ Keine Handschrift, die du kennst. Aber jemand hat es aufgeschrieben." + }, + { + "id": "flavor_gauntlet_wette", + "type": "flavor", + "weight": 10, + "min_day": 2, + "catch_line": "Ein Wettzettel auf die Gauntlet-Zeiten. Dein Name steht drauf. Die Quote daneben ist nicht schmeichelhaft." + } + ] +} diff --git a/docs/CHANGEREQUESTS.md b/docs/CHANGEREQUESTS.md index 6b6a920..d061a71 100644 --- a/docs/CHANGEREQUESTS.md +++ b/docs/CHANGEREQUESTS.md @@ -84,21 +84,6 @@ schätzt er sie; das erste zugelassene Streicheln ist ein echter Meilenstein. - Default: kleine Interaktion (leichtes QTE/Rhythmus), einmal pro Tag (Anti-Farming). -## 12. „Blätter jagen" — verlorene Seiten einfangen -> Kaddis-Runde 2. -- Lose **Heftblätter** treiben im Wind über Hof/Zonen; man fängt sie mit dem - bestehenden Movement (Laufen/Sprint/Slide/Jump). Thematisch: In - **Windgeschworen** trägt der Wind die Wahrheiten. -- Fund-Typen: - 1. **Wahrheits-Fragmente** → Muster-Tafel / Zirkel (CR 2). - 2. **Verlorene Fach-Notizen** eines Vorjahres-Schülers → füllen das Lexicon - (CR 4), kleiner Verstand-/Drachenkunde-Bonus. - 3. **Notizen von Tyrveils Vater (Robert)** → seltene, kostbare Fragmente, die - direkt an Wahrheit 2 rühren (emotionaler Fund). - 4. **Flavor-Fetzen** (Gerüchte, Basgiath-Atmosphäre). -- Default: echte Geheimnis-/Vater-Seiten **selten** (wertvoll); Mischung aus festen - Story-Plätzen (garantierte Schlüssel-Fragmente) und zufälligem Flavor. - ## 13. Minispiele mit Einsatz > Kaddis-Runde 2. - Diegetische Minispiele in Schlafsaal/Commons (locations/citadel/COMMONS.md, diff --git a/docs/CHANGEREQUESTS_DONE.md b/docs/CHANGEREQUESTS_DONE.md index e50905b..25fc8af 100644 --- a/docs/CHANGEREQUESTS_DONE.md +++ b/docs/CHANGEREQUESTS_DONE.md @@ -3,6 +3,51 @@ > Abgearbeitete Change Requests aus CHANGEREQUESTS.md, mit Datum und > Anmerkung, was geändert wurde. +## 2026-07-20 — CR 12: „Blätter jagen" — verlorene Seiten einfangen + +**Request:** CHANGEREQUESTS §12 (Welle 3) — lose Heftblätter treiben im +Wind über den Hof und werden mit dem bestehenden Movement gefangen; vier +Fund-Typen; Vater-/Geheimnis-Seiten selten; Mischung aus festen +Story-Plätzen und zufälligem Flavor. + +**Umsetzung:** `data/pages/loose_pages.json` hält dreizehn Seiten mit +Typ, Fundzeile, `min_day` und Gewicht. `scenes/props/loose_page.tscn` + +`scripts/gameplay/loose_page.gd` sind das treibende Blatt: es driftet in +gewürfelter Windrichtung, wippt, trudelt und setzt sich am +gegenüberliegenden Rand des Treibkreises neu an, wenn es hinausläuft. +Die Flughöhe wird zwischen 0,5 und 2,3 Metern gewürfelt — tiefe Blätter +erwischt man im Slide, hohe im Sprung; gefangen wird ohne +Interaktions-Taste, allein durch Berührung. +`scripts/gameplay/page_spawner.gd` streut pro Tag drei Blätter aus: erst +die festen Schlüssel-Seiten (ab ihrem `min_day`, solange ungefangen), +dann gewichtet gezogener Rest. Gefangene Seiten kommen nie wieder +(`GameState.caught_pages`, im Spielstand). + +**Fund-Typen:** `wahrheit` legt ein Fragment aufs Muster-Board +(`w1_fragment_*`, CR 2). `notiz` hebt den Fach-Zähler einer +Lexicon-Seite und gibt +1 Verstand (CR 4). `vater` ist der seltene +Fund. `flavor` trägt nur die Zeile. + +**Kanon-Entscheidung (STORY > CR):** Der CR-Text wollte die Vater-Seiten +„direkt an Wahrheit 2 rühren". Wahrheit 2 ist laut STORY.md aber +**anvertraute** Wahrheit — Mira erzählt sie, sie ist nicht sammelbar +(KADDIS_RESPONSE_DONE.md: Wahrheit 1 = Fragmente, Wahrheit 2 = +anvertraut). Die Vater-Seiten enthüllen deshalb nichts: sie sind seine +Handschrift, seine Randnotizen, seine Art zu denken. Sie landen NICHT +auf dem Muster-Board, sondern unter `vater_seite_*` auf einer neuen +Lexicon-Seite „Seiten seines Vaters", und ziehen den Klinge/Herz-Wert +Richtung Herz (+1 Menschlichkeit). Die Seite schließt selbst mit „Kein +Beweis. Nur er." + +**Verifikation:** Sonde `dev_cr12_probe` 25/25 — Datenschema und +Flag-Präfixe, alle vier Typen, keine doppelten IDs, Vater-Seiten nicht +auf dem Muster-Board, zufällige Vater-Seiten seltener als Flavor, +`min_day` respektiert, feste Schlüssel-Seiten an Tag 7 garantiert, +Fragment/Fach-Zähler/Verstand/Herz-Wirkung, kein Doppelzählen, +Persistenz über Speichern und Laden, Flughöhe im Fangbereich, Drift, +Treibkreis-Grenze und Fang durch Spielerberührung. Boot-Check über acht +Szenen fehlerfrei. Sonde vor dem Commit gelöscht. + ## 2026-07-20 — CR 11: Gefechtskunde (Devera) als interaktive Kontinent-Karte **Request:** CHANGEREQUESTS §11 (Welle 3) — Karte des Kontinents mit diff --git a/docs/ROADMAP.md b/docs/ROADMAP.md index 9211855..92c0a46 100644 --- a/docs/ROADMAP.md +++ b/docs/ROADMAP.md @@ -65,8 +65,10 @@ Setzen auf bereits erledigte Systeme auf (CR 8 nicht nötig). Klick-Karte mit animierten Truppenbewegungen als `map_question`-Beat im Unterricht; Buch-1-Zeitfilter eingehalten (Poromiel/Greife offen, Veneni nur als Anomalien, die mit Wahrheit 1 verzahnen). -- **CR 12 — „Blätter jagen".** Zulieferer für Zirkel (CR 2) + Lexicon (CR 4); - nutzt das bestehende Movement. Vater-/Geheimnis-Seiten selten halten. +- ~~**CR 12 — „Blätter jagen".**~~ **ERLEDIGT (2026-07-20).** Treibende Blätter + im Hof, gefangen mit dem bestehenden Movement; speist Muster-Board und + Lexicon. Vater-Seiten selten und bewusst ohne Wahrheit-2-Enthüllung (eigene + Lexicon-Seite statt Muster-Board). - **CR 13 — Minispiele mit Einsatz** (Poker/Messerspiel zuerst) in der Minispiel-Ecke der Aula → **braucht CR 14**. diff --git a/scenes/hub/rider_quadrant.tscn b/scenes/hub/rider_quadrant.tscn index aabf172..99e9a57 100644 --- a/scenes/hub/rider_quadrant.tscn +++ b/scenes/hub/rider_quadrant.tscn @@ -1,4 +1,4 @@ -[gd_scene load_steps=60 format=3] +[gd_scene load_steps=61 format=3] [ext_resource type="Script" path="res://scripts/gameplay/hub_room.gd" id="1_room"] [ext_resource type="PackedScene" path="res://scenes/player.tscn" id="2_player"] @@ -16,6 +16,7 @@ [ext_resource type="Script" path="res://scripts/gameplay/grief_state.gd" id="16_grief"] [ext_resource type="Script" path="res://scripts/gameplay/evidence_prop.gd" id="17_evidence"] [ext_resource type="Script" path="res://scripts/gameplay/xaden_zirkel.gd" id="18_xaden"] +[ext_resource type="Script" path="res://scripts/gameplay/page_spawner.gd" id="19_pages"] [ext_resource type="PackedScene" path="res://scenes/npcs/googly_eyes.tscn" id="90_eyes"] [sub_resource type="ProceduralSkyMaterial" id="ProceduralSkyMaterial_sky"] @@ -834,6 +835,12 @@ script = ExtResource("11_grey") spawn_extents = Vector3(14, 0, 14) wren_path = NodePath("../Wren") +[node name="PageSpawner" type="Node3D" parent="."] +transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0) +script = ExtResource("19_pages") +pages_per_day = 3 +drift_radius = 16.0 + [node name="WrenEscort" type="Node" parent="."] script = ExtResource("14_escort") wren_path = NodePath("../Wren") diff --git a/scenes/props/loose_page.tscn b/scenes/props/loose_page.tscn new file mode 100644 index 0000000..b46949d --- /dev/null +++ b/scenes/props/loose_page.tscn @@ -0,0 +1,29 @@ +[gd_scene load_steps=6 format=3] + +[ext_resource type="Script" path="res://scripts/gameplay/loose_page.gd" id="1_page"] +[ext_resource type="PackedScene" path="res://scenes/ui/speech_bubble.tscn" id="2_bubble"] + +[sub_resource type="StandardMaterial3D" id="StandardMaterial3D_paper"] +albedo_color = Color(0.93, 0.9, 0.78, 1) +cull_mode = 2 +roughness = 0.9 + +[sub_resource type="BoxMesh" id="BoxMesh_paper"] +material = SubResource("StandardMaterial3D_paper") +size = Vector3(0.3, 0.42, 0.01) + +[sub_resource type="BoxShape3D" id="BoxShape3D_catch"] +size = Vector3(0.7, 0.8, 0.7) + +[node name="LoosePage" type="Area3D" groups=["loose_page"]] +collision_layer = 0 +collision_mask = 2 +script = ExtResource("1_page") + +[node name="MeshInstance3D" type="MeshInstance3D" parent="."] +mesh = SubResource("BoxMesh_paper") + +[node name="CollisionShape3D" type="CollisionShape3D" parent="."] +shape = SubResource("BoxShape3D_catch") + +[node name="SpeechBubble" parent="." instance=ExtResource("2_bubble")] diff --git a/scripts/autoloads/game_state.gd b/scripts/autoloads/game_state.gd index b44ba2d..ad52bba 100644 --- a/scripts/autoloads/game_state.gd +++ b/scripts/autoloads/game_state.gd @@ -43,6 +43,7 @@ var story_flags: Dictionary = {} var faction_standings: Dictionary = {} var bound_dragon: Dictionary = {} var weapon_skills: Dictionary = {} +var caught_pages: Dictionary = {} var equipped_armor := "" var saved_scene_path := "" var lexicon_notes := "" @@ -61,6 +62,7 @@ func reset() -> void: faction_standings.clear() bound_dragon.clear() weapon_skills.clear() + caught_pages.clear() equipped_armor = "" saved_scene_path = "" lexicon_notes = "" @@ -188,6 +190,19 @@ func add_weapon_skill(weapon_id: String, amount: int, maximum := 100) -> void: weapon_skill_changed.emit(weapon_id, new_value) +## Gibt zurück, ob ein loses Blatt schon gefangen wurde (CR 12) — +## gefangene Seiten treiben nie wieder über den Hof. +func has_caught_page(page_id: String) -> bool: + return bool(caught_pages.get(page_id, false)) + + +## Merkt ein gefangenes Blatt. +func mark_page_caught(page_id: String) -> void: + if page_id.is_empty(): + return + caught_pages[page_id] = true + + ## Serialisiert den kompletten Zustand als Dictionary für das SaveSystem. ## current_scene hält die Szene des Speicherzeitpunkts fest, damit ## Fortsetzen dort weitermacht (z. B. bei den Drachen nach dem @@ -209,6 +224,7 @@ func to_save_dict() -> Dictionary: "faction_standings": faction_standings.duplicate(), "bound_dragon": bound_dragon.duplicate(), "weapon_skills": weapon_skills.duplicate(), + "caught_pages": caught_pages.duplicate(), "equipped_armor": equipped_armor, "time_day": TimeSystem.day_count, "time_slot": TimeSystem.current_slot, @@ -250,6 +266,10 @@ func apply_save_dict(data: Dictionary) -> void: var saved_skills: Dictionary = data.get("weapon_skills", {}) for weapon_id in saved_skills: weapon_skills[String(weapon_id)] = int(saved_skills[weapon_id]) + caught_pages.clear() + var saved_pages: Dictionary = data.get("caught_pages", {}) + for page_id in saved_pages: + caught_pages[String(page_id)] = bool(saved_pages[page_id]) equipped_armor = str(data.get("equipped_armor", "")) saved_scene_path = str(data.get("current_scene", "")) lexicon_notes = str(data.get("lexicon_notes", "")) diff --git a/scripts/gameplay/loose_page.gd b/scripts/gameplay/loose_page.gd new file mode 100644 index 0000000..c7e35a9 --- /dev/null +++ b/scripts/gameplay/loose_page.gd @@ -0,0 +1,98 @@ +extends Area3D +## Ein loses Heftblatt, das im Wind über den Hof treibt (CR 12). +## +## Das Blatt driftet in Windrichtung, wippt dabei auf und ab und +## trudelt um die eigene Achse — gefangen wird es allein mit dem +## bestehenden Movement (Laufen, Sprint, Slide, Sprung), ohne +## Interaktions-Taste. Die Flughöhe wird beim Spawn gewürfelt: tiefe +## Blätter erwischt man im Slide, hohe im Sprung. +## +## Verlässt es den Wirkungsradius, setzt es sich auf der Gegenseite neu +## an, damit man es weiter jagen kann. Beim Fangen meldet es sich per +## caught mit seinen Daten und zeigt die Fundzeile über der Sprechblase; +## die Auswertung macht der PageSpawner. + +signal caught(page: Dictionary) + +const DRIFT_SPEED_MIN := 2.2 +const DRIFT_SPEED_MAX := 3.6 +const BOB_AMPLITUDE := 0.35 +const BOB_SPEED_MIN := 1.4 +const BOB_SPEED_MAX := 2.6 +const TUMBLE_SPEED := 2.0 +const HEIGHT_MIN := 0.5 +const HEIGHT_MAX := 2.3 + +var _page: Dictionary = {} +var _drift := Vector3.FORWARD +var _drift_speed := DRIFT_SPEED_MIN +var _bob_speed := BOB_SPEED_MIN +var _bob_phase := 0.0 +var _base_height := 1.2 +var _center := Vector3.ZERO +var _radius := 20.0 +var _is_caught := false + +@onready var _mesh: Node3D = $MeshInstance3D +@onready var _bubble: SpeechBubble = $SpeechBubble + + +## Verbindet den Fang-Trigger. +func _ready() -> void: + body_entered.connect(_on_body_entered) + + +## Richtet das Blatt ein: Daten, Treibkreis und gewürfelte Flugbahn. +func setup(page: Dictionary, center: Vector3, radius: float) -> void: + _page = page + _center = center + _radius = radius + _drift = Vector3(randf_range(-1.0, 1.0), 0.0, randf_range(-1.0, 1.0)).normalized() + _drift_speed = randf_range(DRIFT_SPEED_MIN, DRIFT_SPEED_MAX) + _bob_speed = randf_range(BOB_SPEED_MIN, BOB_SPEED_MAX) + _bob_phase = randf_range(0.0, TAU) + _base_height = randf_range(HEIGHT_MIN, HEIGHT_MAX) + global_position = _center + Vector3( + randf_range(-_radius, _radius), + _base_height, + randf_range(-_radius, _radius) + ) + + +## Die Daten des Blattes (für Spawner und Tests). +func get_page() -> Dictionary: + return _page + + +## Treibt das Blatt, lässt es wippen und trudeln und setzt es am +## gegenüberliegenden Rand neu an, wenn es den Kreis verlässt. +func _process(delta: float) -> void: + if _is_caught: + return + global_position += _drift * _drift_speed * delta + _bob_phase += _bob_speed * delta + global_position.y = _base_height + sin(_bob_phase) * BOB_AMPLITUDE + _mesh.rotate_y(TUMBLE_SPEED * delta) + _mesh.rotation.x = sin(_bob_phase * 0.7) * 0.6 + var offset := global_position - _center + offset.y = 0.0 + if offset.length() > _radius: + var wrapped := _center - offset.normalized() * _radius + global_position = Vector3(wrapped.x, global_position.y, wrapped.z) + + +## Fängt das Blatt, sobald der Spieler es berührt: Mesh weg, Fundzeile +## einblenden, melden und nach der Zeile verschwinden. +func _on_body_entered(body: Node3D) -> void: + if _is_caught or not body.is_in_group("player"): + return + _is_caught = true + _mesh.visible = false + monitoring = false + caught.emit(_page) + var line := str(_page.get("catch_line", "")) + if line.is_empty(): + queue_free() + return + _bubble.line_finished.connect(queue_free) + _bubble.show_line(line) diff --git a/scripts/gameplay/loose_page.gd.uid b/scripts/gameplay/loose_page.gd.uid new file mode 100644 index 0000000..ee58c9f --- /dev/null +++ b/scripts/gameplay/loose_page.gd.uid @@ -0,0 +1 @@ +uid://xwqdwxqbqe73 diff --git a/scripts/gameplay/page_spawner.gd b/scripts/gameplay/page_spawner.gd new file mode 100644 index 0000000..a97ae64 --- /dev/null +++ b/scripts/gameplay/page_spawner.gd @@ -0,0 +1,126 @@ +extends Node3D +## Spawner für „Blätter jagen" (CR 12). +## +## Verteilt beim Szenen-Start lose Heftblätter aus +## data/pages/loose_pages.json im Umkreis um sich. Zuerst kommen die +## festen Schlüssel-Seiten dran (is_fixed, ab ihrem min_day, solange +## ungefangen) — so sind die Story-tragenden Fragmente garantiert +## erreichbar; die restlichen Plätze zieht der Spawner gewichtet aus dem +## übrigen Pool. Schon gefangene Seiten kommen nie wieder. +## +## Die Auswertung beim Fangen richtet sich nach dem Fund-Typ: +## - wahrheit: Fragment aufs Muster-Board (Story-Flag w1_fragment_*, CR 2) +## - notiz: Fach-Zähler des Lexicons +1 und Verstand +1 (CR 4) +## - vater: seltener Erinnerungsfund (Story-Flag vater_seite_*) und +## ein Schritt Richtung Herz — Wahrheit 2 selbst bleibt +## anvertraute Wahrheit und kommt von Mira, nicht vom Wind +## - flavor: nur die Fundzeile + +const PAGE_SCENE := preload("res://scenes/props/loose_page.tscn") +const PAGES_PATH := "res://data/pages/loose_pages.json" + +@export var pages_per_day := 3 +@export var drift_radius := 18.0 + +var _pages: Array = [] +var _spawned: Array[Node3D] = [] + + +## Lädt den Seiten-Pool und streut die Blätter des heutigen Tages aus. +func _ready() -> void: + var file := FileAccess.open(PAGES_PATH, FileAccess.READ) + if file == null: + push_error("Seiten-Daten nicht lesbar: %s" % PAGES_PATH) + return + var parsed: Variant = JSON.parse_string(file.get_as_text()) + file.close() + if not (parsed is Dictionary) or not (parsed.get("pages") is Array): + push_error("Seiten-Daten sind ungültig: %s" % PAGES_PATH) + return + _pages = parsed["pages"] + for page in pick_pages_for_today(): + _spawn_page(page) + + +## Wählt die Seiten des heutigen Tages: feste Schlüssel-Seiten zuerst, +## der Rest gewichtet gezogen. Ohne Seiteneffekte, damit Tests die +## Auswahl prüfen können. +func pick_pages_for_today() -> Array: + var chosen: Array = [] + var pool: Array = [] + for page in _pages: + if not _is_available(page): + continue + if bool(page.get("is_fixed", false)): + chosen.append(page) + else: + pool.append(page) + chosen = chosen.slice(0, pages_per_day) + while chosen.size() < pages_per_day and not pool.is_empty(): + var drawn := _draw_weighted(pool) + if drawn.is_empty(): + break + chosen.append(drawn) + pool.erase(drawn) + return chosen + + +## Anzahl gerade treibender Blätter (für Tests/Overlay). +func floating_page_count() -> int: + var count := 0 + for page in _spawned: + if is_instance_valid(page): + count += 1 + return count + + +## Wertet einen Fund nach seinem Typ aus und merkt die Seite als +## gefangen, damit sie nicht wiederkehrt. +func resolve_catch(page: Dictionary) -> void: + var page_id := str(page.get("id", "")) + if page_id.is_empty() or GameState.has_caught_page(page_id): + return + GameState.mark_page_caught(page_id) + match str(page.get("type", "flavor")): + "wahrheit": + GameState.set_story_flag(str(page.get("fragment_flag", "")), str(page.get("fragment_text", ""))) + "notiz": + var counter := str(page.get("subject_flag", "")) + if not counter.is_empty(): + GameState.set_story_flag(counter, int(GameState.get_story_flag(counter, 0)) + 1) + GameState.increase_stat("intellect", 1) + "vater": + GameState.set_story_flag(str(page.get("keepsake_flag", "")), str(page.get("keepsake_text", ""))) + GameState.shift_blade_heart_tone(-1) + GameState.shift_humanity(1) + + +## Prüft, ob eine Seite heute überhaupt auftauchen darf. +func _is_available(page: Dictionary) -> bool: + if GameState.has_caught_page(str(page.get("id", ""))): + return false + return TimeSystem.day_count >= int(page.get("min_day", 1)) + + +## Zieht eine Seite gewichtet aus dem Pool (weight, Standard 1). +func _draw_weighted(pool: Array) -> Dictionary: + var total := 0 + for page in pool: + total += maxi(int(page.get("weight", 1)), 1) + if total <= 0: + return {} + var roll := randi_range(1, total) + for page in pool: + roll -= maxi(int(page.get("weight", 1)), 1) + if roll <= 0: + return page + return pool[pool.size() - 1] + + +## Setzt ein Blatt in den Wind und hängt die Auswertung an. +func _spawn_page(page: Dictionary) -> void: + var leaf: Node3D = PAGE_SCENE.instantiate() + add_child(leaf) + leaf.setup(page, global_position, drift_radius) + leaf.caught.connect(resolve_catch) + _spawned.append(leaf) diff --git a/scripts/gameplay/page_spawner.gd.uid b/scripts/gameplay/page_spawner.gd.uid new file mode 100644 index 0000000..5369af6 --- /dev/null +++ b/scripts/gameplay/page_spawner.gd.uid @@ -0,0 +1 @@ +uid://c0sigservym80 diff --git a/scripts/ui/lexicon.gd b/scripts/ui/lexicon.gd index 5bb4002..4000f00 100644 --- a/scripts/ui/lexicon.gd +++ b/scripts/ui/lexicon.gd @@ -20,6 +20,7 @@ extends CanvasLayer const SUBJECTS_PATH := "res://data/lexicon/subjects.json" const CODEX_PATH := "res://data/story/codex.json" const FRAGMENT_PREFIX := "w1_fragment_" +const FATHER_PAGE_PREFIX := "vater_seite_" const NOTES_PAGE_ID := "notizen" var _is_open := false @@ -97,6 +98,7 @@ func _build_pages() -> void: _pages.append({ "id": "fach:%s" % str(subject.get("id", "")), "title": str(subject.get("title", "?")) }) _pages.append({ "id": "personen", "title": "Personen & Gerüchte" }) _pages.append({ "id": "muster", "title": "Muster-Board" }) + _pages.append({ "id": "vater", "title": "Seiten seines Vaters" }) _pages.append({ "id": NOTES_PAGE_ID, "title": "Eigene Notizen" }) @@ -167,6 +169,8 @@ func _page_content(page_id: String) -> String: return _persons_text() if page_id == "muster": return _pattern_board_text() + if page_id == "vater": + return _father_pages_text() return "" @@ -276,6 +280,32 @@ func _pattern_board_text() -> String: return "\n".join(lines) +## Seiten seines Vaters: die seltenen Blätter aus „Blätter jagen" +## (CR 12, Story-Flags mit Präfix vater_seite_). Kein Beweis-Register — +## eine Sammlung seiner Handschrift. Was er wirklich getan hat, steht +## hier bewusst nicht; das erfährt Tyrveil von Mira. +func _father_pages_text() -> String: + var lines := PackedStringArray() + var found := PackedStringArray() + for flag_name in GameState.story_flags: + if not str(flag_name).begins_with(FATHER_PAGE_PREFIX): + continue + var value: Variant = GameState.story_flags[flag_name] + if value is String and not str(value).is_empty(): + found.append("• %s" % str(value)) + if found.is_empty(): + lines.append("Noch nichts von ihm.") + lines.append("") + lines.append("Sie haben seinen Namen aus den Chroniken gestrichen und seine Papiere verbrannt. Aber Basgiath ist alt und der Wind ist gründlich. Irgendwo liegt noch etwas von seiner Hand.") + return "\n".join(lines) + lines.append("SEINE HANDSCHRIFT") + lines.append("") + lines.append_array(found) + lines.append("") + lines.append("Kein Beweis. Nur er.") + return "\n".join(lines) + + ## Liefert den Flag-abhängigen Zusatztext eines Codex-Eintrags ## (leer, wenn der Eintrag keine Varianten hat oder keine passt). func _entry_variant(entry: Dictionary) -> String: