diff --git a/data/pages/loose_pages.json b/data/pages/loose_pages.json index a384fdb..8545bca 100644 --- a/data/pages/loose_pages.json +++ b/data/pages/loose_pages.json @@ -1,6 +1,19 @@ { "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.", + "flight": { + "balance_note": "CR 21, harte Autoren-Regel: JEDE Jagd muss einholbar bleiben. Drei Sicherungen greifen ineinander. Erstens ist gust_speed kleiner als die Sprint-Geschwindigkeit des Spielers (player.gd SPRINT_SPEED = 7.5) — das Blatt kann rein rechnerisch nie davonlaufen. Zweitens ermuedet es: jede Boe ist um fatigue_per_gust schwaecher als die vorige, und nach max_gusts Boeen gibt das Blatt auf und treibt nur noch. Drittens folgt auf jede Boe ein Sackenfenster (settle_seconds bei settle_speed_scale), in dem Slide, Sprint und Sprung sicher zugreifen. Wer die Werte anfasst, muss die erste Regel erhalten.", + "flee_radius": 8.0, + "gust_speed": 6.8, + "gust_seconds": 1.5, + "gust_rise": 1.3, + "gust_cooldown": 0.15, + "settle_seconds": 0.55, + "settle_speed_scale": 0.35, + "settle_sink": 0.55, + "fatigue_per_gust": 0.15, + "max_gusts": 5 + }, "pages": [ { "id": "aushang_fetzen", diff --git a/docs/CHANGEREQUESTS.md b/docs/CHANGEREQUESTS.md index 60e11a5..07f3ee6 100644 --- a/docs/CHANGEREQUESTS.md +++ b/docs/CHANGEREQUESTS.md @@ -55,25 +55,6 @@ - **Wichtig:** Reiner Schreibpass — **keine** Story-Fakten, Flags, Effekte oder Verzweigungen ändern (Ton ≠ Ausgang, STORY §6). -## 21. „Blätter jagen": echte Hatz statt driftendes Pickup -> Delta gegen die CR-12-Umsetzung. Vorbild: die Sea-Shanty-Seiten aus AC4 -> Black Flag. -- **Befund:** `loose_page.gd` lässt jedes Blatt in *einer zufälligen, konstanten - Richtung* treiben und am Kreisrand umspringen — es **reagiert nicht auf den - Spieler**. Dadurch ist es ein bewegtes Pickup, keine Jagd. -- **Soll:** Das Blatt **reagiert auf die Annäherung** — kommt der Spieler nah, - reißt eine Böe es weg, es wirbelt hoch, wechselt die Richtung. Der Reiz ist die - Hatz mit Beinahe-Griffen. -- **Harte Balancing-Regel (Autor):** Es muss **trotzdem erreichbar bleiben**. Die - Flucht darf das Blatt nicht unfangbar machen — z. B. nachlassende Böen, - Abklingzeit zwischen Ausweichern, Sacken nach einer Flucht, oder ein Fenster, in - dem Slide/Sprint/Sprung sicher zugreifen. **Jede Jagd endet einholbar.** -- **Akzeptanz:** Ein Blatt weicht bei Annäherung spürbar aus (nicht nur konstantes - Driften); mehrere Beinahe-Griffe pro Jagd sind normal; **keine Jagd ist - unabschließbar** — mit dem bestehenden Movement ist jedes Blatt sicher fangbar; - Fund-Typen und Belohnungen aus CR 12 bleiben unverändert. -- **Betrifft:** `loose_page.gd` (Flugverhalten), ggf. `page_spawner.gd`. - ## 24. Primitiven-Austausch in den echten Szenen (Folge-Schritt aus CR 23) > Aufgemacht am 2026-07-21, nachdem CR 23 die Pipeline verifiziert hat. Die > Assets liegen sortiert und importiert unter `assets/models/`, die diff --git a/docs/CHANGEREQUESTS_DONE.md b/docs/CHANGEREQUESTS_DONE.md index 79d3397..77c5ae0 100644 --- a/docs/CHANGEREQUESTS_DONE.md +++ b/docs/CHANGEREQUESTS_DONE.md @@ -3,6 +3,55 @@ > Abgearbeitete Change Requests aus CHANGEREQUESTS.md, mit Datum und > Anmerkung, was geändert wurde. +## 2026-07-21 — CR 21: „Blätter jagen" als echte Hatz + +**Request:** CHANGEREQUESTS §21 — die CR-12-Blätter trieben in einer +zufälligen, konstanten Richtung und reagierten nicht auf den Spieler: +ein bewegtes Pickup, keine Jagd. Vorbild sind die Sea-Shanty-Seiten aus +AC4 Black Flag. Harte Autoren-Regel: **jede Jagd bleibt einholbar.** + +**Umsetzung:** `loose_page.gd` hat jetzt drei Flugzustände. Im **Treiben** +verhält es sich wie bisher. Kommt der Spieler in `flee_radius`, reißt +eine **Böe** das Blatt weg — fort vom Spieler, mit seitlichem Ausschlag, +schneller und höher, sichtbar heftiger trudelnd. Danach **sackt** es ab: +tiefer als vorher und deutlich langsamer als die Grunddrift. Das ist das +Fenster, in dem Slide, Sprint und Sprung zugreifen. Alle Werte stehen im +neuen `flight`-Block von `data/pages/loose_pages.json`, der Spawner +reicht sie durch. + +**Die Einholbarkeit ist konstruiert, nicht gehofft** — drei Sicherungen +greifen ineinander, alle in den Daten dokumentiert: +1. `gust_speed` (6,8) liegt **unter** der Sprint-Geschwindigkeit des + Spielers (`player.gd` SPRINT_SPEED = 7,5). Das Blatt kann rein + rechnerisch nie davonlaufen. +2. Es **ermüdet**: jede Böe ist um `fatigue_per_gust` schwächer als die + vorige, und nach `max_gusts` (5) gibt es auf und treibt nur noch. +3. Die Böen-Sperre deckt das Sackenfenster **vollständig** ab + (`gust_seconds + settle_seconds + gust_cooldown`), damit keine Böe + mitten ins Sacken hineinreißt. + +**Balance in zwei Schritten gefunden:** Die erste Fassung war zu zahm — +die simulierte Jagd endete nach 1,4 s mit einer einzigen Böe, also ohne +die geforderten Beinahe-Griffe. Beim Nachziehen fiel dann auf, dass die +Abklingzeit mitten im Sacken ablief und das sichere Fenster auf 0,45 s +zusammenschrumpfte; seitdem deckt die Sperre das ganze Fenster ab. Mit +`flee_radius` 8,0 (das Blatt spürt einen früher kommen) und kürzerem +Sacken dauert die Jagd jetzt **7,4 Sekunden über drei Böen** und endet +sicher. + +**Unverändert:** Fund-Typen, Gewichte, feste Schlüssel-Seiten und alle +Belohnungen aus CR 12. Gefangen wird weiter allein durch Berührung. + +**Verifikation:** Sonde `dev_cr21_probe` 24/24 — Flugwerte und +Balance-Regel in den Daten; Böengeschwindigkeit unter Sprint; +ruhiges Treiben fern vom Spieler; Annäherung löst eine Böe aus, die vom +Spieler wegträgt und hochwirbelt; danach Sacken, langsamer als das +Treiben; keine zweite Böe in der Abklingzeit; jede Böe schwächer als die +vorige; nach der letzten gibt das Blatt auf. Dazu eine **simulierte +Jagd**: ein sprintender Verfolger holt das Blatt nachweislich ein, mit +mindestens zwei Böen unterwegs. Boot-Check über acht Szenen fehlerfrei. +Sonde vor dem Commit gelöscht. + ## 2026-07-21 — CR 17: Poker mit echten Karten + Figuren am Tisch **Request:** CHANGEREQUESTS §17 — Poker lief rein über Menü-Optionen und diff --git a/docs/ROADMAP.md b/docs/ROADMAP.md index 68a0bde..70383a8 100644 --- a/docs/ROADMAP.md +++ b/docs/ROADMAP.md @@ -8,8 +8,8 @@ > Stand: **2026-07-21**. Erledigt: Phasen 0–11, CR 1–8 (8a–8e), CR 11–16, > CR 23 (Asset-Pipeline steht und ist verifiziert) — **Wellen 0–3 komplett**, > v1 steht inhaltlich. Offen: die **Politur-Welle -> CR 19, 21, 22** (Findings aus dem Akt-1-Testdurchlauf, Priorität; CR 17, CR 18 -> und CR 20 sind erledigt), der +> CR 19 + CR 22** (Schreibpass, Findings aus dem Akt-1-Testdurchlauf; CR 17, +> CR 18, CR 20 und CR 21 sind erledigt), der > Primitiven-Austausch **CR 24** (Folge-Schritt aus CR 23), danach Welle 4 > (Akt 2: CR 9/10/8-magie/CR-16-Camp) und das eigene Kartenspiel (Stretch). @@ -91,8 +91,6 @@ Setzen auf bereits erledigte Systeme auf (CR 8 nicht nötig). **Priorität vor Welle 4.** Findings des Autors am fertigen v1-Umfang. Gut parallelisierbar; zwei davon sind reine Schreibarbeit. -- **CR 21 — Blätter-Jagd auf Black-Flag-Gefühl.** Blatt reagiert auf Annäherung, - bleibt aber garantiert einholbar. - **CR 19 + CR 22 — Schreibpass** (Dialoge + Journal/Lexicon) gegen die sechs Anti-Muster. Können als **ein** Durchgang laufen; Xaden zuerst. @@ -126,7 +124,7 @@ Greifen erst nach Dreschen + erstem Flug; brauchen die CR-6-Basis. | 18 | Viertes Geschwader (Ridoc/Sawyer/Liam/Dain) | Politur | **erledigt (2026-07-21)** — vier Dialogbäume, vier Figuren im Hof, Staffel-Appell als Gruppenszene | | 19 | Stimmen-Schreibpass (Dialoge) | Politur | offen | | 20 | Viadukt-Respawn-Fix (Bug) | Politur | **erledigt (2026-07-21)** — Respawn am Checkpoint; dabei Wind-Beschleunigungs-Bug in `player.gd` mitbehoben | -| 21 | Blätter-Jagd (Black-Flag-Gefühl) | Politur | offen | +| 21 | Blätter-Jagd (Black-Flag-Gefühl) | Politur | **erledigt (2026-07-21)** — Böen bei Annäherung, Ermüdung und Sackenfenster; Einholbarkeit in der Sonde nachgewiesen | | 22 | Journal/Lexicon-Texte | Politur | offen | | 23 | Asset-Import-Grundausstattung (Quaternius) | Politur | **erledigt (2026-07-21)** — 296 Modelle sortiert unter `assets/models/`, Rig-Kompatibilität in `scenes/test/asset_pipeline_test.tscn` verifiziert | | 24 | Primitiven-Austausch in den echten Szenen | Politur | offen — Folge-Schritt aus CR 23, Pipeline steht | diff --git a/scripts/gameplay/loose_page.gd b/scripts/gameplay/loose_page.gd index c7e35a9..9f38e52 100644 --- a/scripts/gameplay/loose_page.gd +++ b/scripts/gameplay/loose_page.gd @@ -1,18 +1,33 @@ extends Area3D -## Ein loses Heftblatt, das im Wind über den Hof treibt (CR 12). +## Ein loses Heftblatt, das im Wind über den Hof treibt — und ausweicht, +## wenn man danach greift (CR 12, Flugverhalten überarbeitet in CR 21). ## -## 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. +## Das Blatt reagiert auf den Spieler. Kommt er in flee_radius, reißt es +## eine Böe weg: Es beschleunigt vom Spieler fort, wirbelt hoch und +## wechselt die Richtung. Danach sackt es ab und treibt für einen Moment +## kraftlos — das ist das Fenster, in dem Slide, Sprint und Sprung +## zugreifen. Gefangen wird weiter allein durch Berührung, ohne Taste. ## -## 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. +## **Jede Jagd bleibt einholbar** (harte Regel des Autors, CR 21). Drei +## Sicherungen greifen ineinander, alle in data/pages/loose_pages.json +## unter "flight" nachvollziehbar: +## 1. gust_speed liegt **unter** der Sprint-Geschwindigkeit des Spielers. +## Das Blatt kann rein rechnerisch nie davonlaufen. +## 2. Es ermüdet: Jede Böe ist um fatigue_per_gust schwächer als die +## vorige, und nach max_gusts gibt es auf und treibt nur noch. +## 3. Nach jeder Böe folgt das Sackenfenster — langsamer als die +## Grunddrift und tiefer, also sicher greifbar. Die Böen-Sperre deckt +## dieses Fenster **vollständig** ab (gust_seconds + settle_seconds + +## gust_cooldown), damit keine Böe mitten ins Sacken hineinreißt. +## +## Verlässt das Blatt den Wirkungsradius, setzt es sich auf der +## Gegenseite neu an. Beim Fangen meldet es sich per caught mit seinen +## Daten; die Auswertung macht der PageSpawner. signal caught(page: Dictionary) +signal gust_started(remaining_gusts: int) + +enum FlightState { DRIFT, GUST, SETTLE } const DRIFT_SPEED_MIN := 2.2 const DRIFT_SPEED_MAX := 3.6 @@ -20,38 +35,53 @@ const BOB_AMPLITUDE := 0.35 const BOB_SPEED_MIN := 1.4 const BOB_SPEED_MAX := 2.6 const TUMBLE_SPEED := 2.0 +const TUMBLE_GUST_SCALE := 3.5 const HEIGHT_MIN := 0.5 const HEIGHT_MAX := 2.3 +const HEIGHT_CEILING := 3.2 +const LATERAL_SPREAD := 0.7 +const HEIGHT_EASE := 3.0 var _page: Dictionary = {} +var _flight: 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 _rest_height := 1.2 var _center := Vector3.ZERO var _radius := 20.0 var _is_caught := false +var _state := FlightState.DRIFT +var _state_timer := 0.0 +var _cooldown := 0.0 +var _gust_count := 0 +var _player: Node3D + @onready var _mesh: Node3D = $MeshInstance3D @onready var _bubble: SpeechBubble = $SpeechBubble -## Verbindet den Fang-Trigger. +## Verbindet den Fang-Trigger und sucht den Spieler. func _ready() -> void: body_entered.connect(_on_body_entered) + _player = get_tree().get_first_node_in_group("player") -## Richtet das Blatt ein: Daten, Treibkreis und gewürfelte Flugbahn. -func setup(page: Dictionary, center: Vector3, radius: float) -> void: +## Richtet das Blatt ein: Daten, Flugwerte, Treibkreis und Flugbahn. +func setup(page: Dictionary, center: Vector3, radius: float, flight: Dictionary = {}) -> void: _page = page + _flight = flight _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) + _rest_height = randf_range(HEIGHT_MIN, HEIGHT_MAX) + _base_height = _rest_height global_position = _center + Vector3( randf_range(-_radius, _radius), _base_height, @@ -64,21 +94,113 @@ 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. +## Der aktuelle Flugzustand (für Sonden). +func get_flight_state() -> int: + return _state + + +## Wie viele Böen das Blatt noch hat, bevor es aufgibt (für Sonden). +func remaining_gusts() -> int: + return maxi(_tuning("max_gusts", 5) - _gust_count, 0) + + +## Die Geschwindigkeit, mit der das Blatt gerade treibt (für Sonden). +func current_speed() -> float: + match _state: + FlightState.GUST: + return _gust_speed() + FlightState.SETTLE: + return _drift_speed * float(_tuning("settle_speed_scale", 0.4)) + return _drift_speed + + +## Treibt das Blatt, lässt es wippen und trudeln, prüft die Annäherung +## des Spielers und setzt es am Kreisrand neu an. func _process(delta: float) -> void: if _is_caught: return - global_position += _drift * _drift_speed * delta + _cooldown = maxf(_cooldown - delta, 0.0) + _advance_state(delta) + _check_player() + global_position += _drift * current_speed() * delta _bob_phase += _bob_speed * delta - global_position.y = _base_height + sin(_bob_phase) * BOB_AMPLITUDE - _mesh.rotate_y(TUMBLE_SPEED * delta) + var target_height := _base_height + sin(_bob_phase) * BOB_AMPLITUDE + global_position.y = move_toward(global_position.y, target_height, HEIGHT_EASE * delta) + var tumble := TUMBLE_SPEED + if _state == FlightState.GUST: + tumble *= TUMBLE_GUST_SCALE + _mesh.rotate_y(tumble * delta) _mesh.rotation.x = sin(_bob_phase * 0.7) * 0.6 + _wrap_into_circle() + + +## Zählt den laufenden Zustand herunter und schaltet weiter: Die Böe geht +## ins Sacken über, das Sacken zurück in die Grunddrift. +func _advance_state(delta: float) -> void: + if _state == FlightState.DRIFT: + return + _state_timer -= delta + if _state_timer > 0.0: + return + if _state == FlightState.GUST: + _state = FlightState.SETTLE + _state_timer = float(_tuning("settle_seconds", 1.4)) + _base_height = maxf(_rest_height - float(_tuning("settle_sink", 0.55)), HEIGHT_MIN * 0.5) + return + _state = FlightState.DRIFT + _base_height = _rest_height + + +## Löst eine Böe aus, sobald der Spieler nah genug ist — sofern das Blatt +## nicht gerade flieht, in der Abklingzeit steckt oder schon aufgegeben hat. +func _check_player() -> void: + if _player == null or _state == FlightState.GUST: + return + if _cooldown > 0.0 or remaining_gusts() <= 0: + return + var away := global_position - _player.global_position + away.y = 0.0 + if away.length() > float(_tuning("flee_radius", 4.5)): + return + _start_gust(away) + + +## Startet die Böe: weg vom Spieler, mit seitlichem Ausschlag, hoch in +## die Luft — und schwächer als die Böe davor. +func _start_gust(away: Vector3) -> void: + if away.length_squared() < 0.01: + away = Vector3(randf_range(-1.0, 1.0), 0.0, randf_range(-1.0, 1.0)) + var lateral := Vector3(-away.z, 0.0, away.x).normalized() * randf_range(-LATERAL_SPREAD, LATERAL_SPREAD) + _drift = (away.normalized() + lateral).normalized() + _gust_count += 1 + _state = FlightState.GUST + _state_timer = float(_tuning("gust_seconds", 1.0)) + _cooldown = _state_timer + float(_tuning("settle_seconds", 1.4)) + float(_tuning("gust_cooldown", 1.6)) + _base_height = minf(_rest_height + float(_tuning("gust_rise", 1.3)), HEIGHT_CEILING) + gust_started.emit(remaining_gusts()) + + +## Die Geschwindigkeit der laufenden Böe — jede ist um fatigue_per_gust +## schwächer als die vorige und nie schneller als der Startwert. +func _gust_speed() -> float: + var fatigue := 1.0 - float(_tuning("fatigue_per_gust", 0.18)) * float(_gust_count - 1) + return maxf(float(_tuning("gust_speed", 6.0)) * maxf(fatigue, 0.25), _drift_speed) + + +## Setzt das Blatt am gegenüberliegenden Rand neu an, wenn es den +## Treibkreis verlässt. +func _wrap_into_circle() -> void: 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) + if offset.length() <= _radius: + return + var wrapped := _center - offset.normalized() * _radius + global_position = Vector3(wrapped.x, global_position.y, wrapped.z) + + +## Liest einen Flugwert aus den Daten, mit Rückfall auf den Standard. +func _tuning(key: String, fallback: Variant) -> Variant: + return _flight.get(key, fallback) ## Fängt das Blatt, sobald der Spieler es berührt: Mesh weg, Fundzeile diff --git a/scripts/gameplay/page_spawner.gd b/scripts/gameplay/page_spawner.gd index a97ae64..53f8b29 100644 --- a/scripts/gameplay/page_spawner.gd +++ b/scripts/gameplay/page_spawner.gd @@ -23,6 +23,7 @@ const PAGES_PATH := "res://data/pages/loose_pages.json" @export var drift_radius := 18.0 var _pages: Array = [] +var _flight: Dictionary = {} var _spawned: Array[Node3D] = [] @@ -38,6 +39,7 @@ func _ready() -> void: push_error("Seiten-Daten sind ungültig: %s" % PAGES_PATH) return _pages = parsed["pages"] + _flight = parsed.get("flight", {}) for page in pick_pages_for_today(): _spawn_page(page) @@ -121,6 +123,6 @@ func _draw_weighted(pool: Array) -> Dictionary: func _spawn_page(page: Dictionary) -> void: var leaf: Node3D = PAGE_SCENE.instantiate() add_child(leaf) - leaf.setup(page, global_position, drift_radius) + leaf.setup(page, global_position, drift_radius, _flight) leaf.caught.connect(resolve_catch) _spawned.append(leaf)