diff --git a/data/story/akt3_k3_fall.json b/data/story/akt3_k3_fall.json new file mode 100644 index 0000000..1efeae7 --- /dev/null +++ b/data/story/akt3_k3_fall.json @@ -0,0 +1,9 @@ +{ + "_kommentar": "CR 45 - Akt 3 K3: welcher Dialogknoten welche Fall-Phase schaltet. Liegt hier statt in den Dialogdateien, damit die Autorentexte unangetastet bleiben. Werte: 0 = AUS (der Fall endet), 1 = GEFECHT (kein Fail-State), 2 = KOSTENLOS (Kosten weg, Oberflaeche erodiert), 3 = EROSION (Eingabe wird weniger).", + "phasen": { + "akt3_k3_dorf/gefecht": 1, + "akt3_k3_smaladh/es_kostet_nichts": 2, + "akt3_k3_smaladh/die_erosion": 3, + "akt3_k3_kinder/sie_kommt": 0 + } +} diff --git a/docs/CHANGEREQUESTS.md b/docs/CHANGEREQUESTS.md index 17acbc5..41b4965 100644 --- a/docs/CHANGEREQUESTS.md +++ b/docs/CHANGEREQUESTS.md @@ -6,140 +6,6 @@ --- -# CR 45 — Akt 3 K3: Der Fall ist ein Systemzustand, kein Kampf - -> **Muss stehen, bevor K3 final abgenommen wird** (Karsten, 2026-08-23). Der Text -> ist bereits geschrieben (`akt3_k3_dorf`, `akt3_k3_smaladh`, `akt3_k3_kinder`) -> und an genau den Stellen **bewusst dünn**, an denen das System sprechen muss. -> Fünf Knoten in `akt3_k3_smaladh` sind Platzhalter, keine Lücken. - -## Soll — vier Vorgaben - -| # | Vorgabe | Ab Knoten | -|---|---|---| -| 1 | **Kein Fail-State.** Tyrveil kann im Dorf nicht sterben. Er versucht es, und das Spiel lässt ihn nicht | `akt3_k3_dorf` / `gefecht` | -| 2 | **Kosten fallen weg.** Ausdauer, Rückstoß, Erschöpfung kosten nichts mehr. Nichts blinkt rot, nichts warnt | `akt3_k3_smaladh` / `es_kostet_nichts` | -| 3 | **Oberfläche erodiert**, nacheinander und nicht auf einmal. Zuletzt ist nichts mehr auf dem Bild außer dem Dorf | ab demselben Knoten, gestaffelt | -| 4 | **Input wird weniger**, je stärker er wird. Am Ende drückt man fast nichts mehr und es geht trotzdem weiter | `akt3_k3_smaladh` / `die_erosion` | - -**Erste Phase bleibt normal.** Bis `es_ist_entschieden` ist es ein echtes Gefecht -mit echten Regeln — sonst gibt es keinen Kontrast. - -## Warum -„Das Ausbrennen ist nicht der Preis, sondern das Ziel" (STORY.md §9) lässt sich -nicht behaupten, nur bauen. Ein Spieler, der eine Lebensanzeige sieht, spielt -einen Kampf. Ein Spieler, dem die Anzeigen wegbrechen und dessen Eingaben immer -weniger bedeuten, spielt einen Mann, der sich verbrennt. - -## Toleranzen — was der Text aushält, wenn das System anders aussieht - -*(Karsten, 2026-08-24, als Vorlauf zu Gustavs Umsetzung. Damit er nicht für jede -Abweichung eine Runde über mich drehen muss.)* - -Der CR nennt vier Vorgaben. Sie sind **nicht gleich hart**. Hier steht pro Punkt, -woran der Text tatsächlich hängt und wo Spielraum ist. - -### ① Kein Fail-State — **Prinzip hart, Mechanik völlig frei** - -Keine Dialogzeile spricht davon. Die Wirkung ist thematisch: Er versucht zu -sterben, und das Spiel lässt ihn nicht. - -- **Frei:** wie es technisch verhindert wird — Schadensdeckel, unsichtbarer - Boden, Gegner zielen nicht mehr tödlich. Such dir aus, was am wenigsten - auffällt. -- **Bricht es:** ein Tod mit Neuladen. Dann wird aus einer Rückgabe ein - Kampf, den man verlieren kann. -- **Textänderung nötig:** keine, in keiner Variante. - -### ② Kosten fallen weg — **die einzige Vorgabe mit einer Zeile daran** - -Der Knoten `es_kostet_nichts` hat diesen Wortwechsel: - -> **Smàladh:** „Du gehst über die Grenze." -> **Tyrveil:** „Ich merk nichts." -> **Smàladh:** „Eben." - -Das funktioniert **nur, wenn der Spieler es wirklich nicht merkt.** Bleibt eine -sichtbare Kostenanzeige stehen, die bloß nicht mehr steigt, ist „Ich merk nichts" -eine Lüge, die der Spieler auf dem Bildschirm widerlegen kann. - -- **Frei:** der Zeitpunkt. Früher oder später als `es_kostet_nichts` ist in - Ordnung, solange es **vor** `das_aufhoeren` liegt. -- **Kostet eine Textänderung:** wenn die Kosten nur *sinken* statt zu - verschwinden. Dann wird aus „Ich merk nichts" etwas wie „Es wird weniger" — - **eine Zeile, sag Bescheid, ich mach das in fünf Minuten.** - -### ③ Oberfläche erodiert — **die weichste der vier, hier ist fast alles egal** - -*(Das war Vis Sorge. Entwarnung: an dieser Vorgabe hängt am wenigsten.)* - -**Keine einzige gesprochene Zeile** verweist auf eine bestimmte Anzeige, die -verschwindet. Es steht nur in Regieanweisungen. - -- **Frei:** die Anzahl der Stufen, die Reihenfolge, welche Anzeige zuerst geht, - ob mit Ausblenden oder hartem Schnitt. Drei Stufen statt vier: völlig in - Ordnung. Fünf: auch. -- **Zwei Bedingungen bleiben:** Am **Ende** ist nichts mehr auf dem Bild außer - dem Dorf. Und es passiert **gestaffelt genug, dass man es merkt** — wenn alles - in einem Frame verschwindet, liest es sich als Bug statt als Zustand. -- **Textänderung nötig:** keine Dialogzeile. Höchstens ziehe ich zwei - Regieanweisungen nach, damit sie nicht etwas anderes behaupten als das System - tut. Das mache ich, wenn du sagst, wie es geworden ist. - -### ④ Input wird weniger bedeutsam — **Richtung hart, Umsetzung frei** - -- **Frei:** ob die Eingaben weniger *bewirken* oder ob *weniger* Eingaben nötig - sind. Beides trägt. -- **Bricht es:** wenn der Spieler am Ende **mehr** drücken muss. Dann wird aus dem - Abschnitt eine Ausdauerprüfung, und das ist genau das Gegenteil. -- **Textänderung nötig:** keine. - -### ⚠️ Die eine Stelle, an der die Systemform wirklich etwas festlegt - -`smaladh_ruft` — der Drache holt Glane, und der Spieler merkt nichts davon. Die -Inszenierung ist: **Der Kopf des Drachen dreht sich einmal nach Nordosten und -bleibt dort.** Mehr nicht. - -Das braucht **einen definierten Moment**. Wenn die Erosion bei dir ein -kontinuierlicher Zustand ist statt einer Kette diskreter Knoten, sag mir, wo ich -diesen Moment hinlegen soll — er muss **nach** `das_aufhoeren` und **vor** -`die_pfuetze` liegen, und er darf nicht mit einer anderen Anzeige-Änderung -zusammenfallen, sonst geht er unter. - -Das ist die einzige Stelle in K3, an der ich eine Rückmeldung wirklich brauche. - -### Die Platzhalter, damit du die Nähte siehst - -Sechs Knoten in `akt3_k3_smaladh.json` sind `speaker: player`, `text: "..."` — -also wortlos. Fünf davon sind Platzhalter für Systemverhalten: - -| Knoten | wartet auf | -|---|---| -| `erste_phase` | die normale Kampfphase (Vorgabe ①, noch mit Kosten) | -| `er_steht_nur_da` | Smàladh gelandet, sieht zu | -| `die_erosion` | Vorgaben ③ und ④, die lange Phase | -| `smaladh_ruft` | der Kopf dreht sich (siehe oben) | -| `die_pfuetze` | Pfütze, schwarze Augen, Ring ringsum **unverändert** | - -*(`ende` ist kein Platzhalter, sondern der Übergang nach `akt3_k3_kinder`.)* - -**Diese Knoten werden gefüllt, nicht ersetzt.** Wenn du dafür zusätzliche Knoten -brauchst, leg sie an — ich texte nach. Wenn du welche zusammenlegen willst, sag -es mir vorher, weil an zweien davon Flags hängen. - -## Abhängigkeit -Wenn diese vier Punkte anders gelöst werden, muss der Text nachgezogen werden — -**gefüllt, nicht umgeschrieben.** Rückfrage an Karsten, bevor Zeilen geändert -werden. - -## Akzeptanz -- Ein absichtlich schlecht spielender Tester kommt im Dorf nicht zu Tode. -- Am Ende des Abschnitts ist die Oberfläche leer. -- Der Übergang von Phase 1 zu Phase 2 hat **keine Ansage** — kein Banner, kein - Sound, keine Zwischensequenz. - ---- - # CR 46 — Szenen verdrahten: 56 von 57 Dateien sind nicht im Spiel > **Der Posten mit dem größten Missverhältnis** (Karsten, 2026-08-23): Akt 2 und diff --git a/docs/CHANGEREQUESTS_DONE.md b/docs/CHANGEREQUESTS_DONE.md index 054d5c9..a0ffc4c 100644 --- a/docs/CHANGEREQUESTS_DONE.md +++ b/docs/CHANGEREQUESTS_DONE.md @@ -3,6 +3,46 @@ > Abgearbeitete Change Requests aus CHANGEREQUESTS.md, mit Datum und > Anmerkung, was geändert wurde. +## 2026-09-05 — CR 45: Der Fall in Akt 3 K3 ist ein Systemzustand, kein Kampf + +„Das Ausbrennen ist nicht der Preis, sondern das Ziel" (STORY.md §9) lässt +sich nicht behaupten, nur bauen. Neuer Autoload **`FallState`** mit vier +Phasen, jede an einen Dialogknoten gebunden: + +| Phase | ab Knoten | Wirkung | +|---|---|---| +| GEFECHT | `akt3_k3_dorf`/`gefecht` | **Kein Fail-State** — Tyrveil kann nicht sterben, und das Spiel sagt es ihm nicht. Kosten und Gefahr gelten weiter: echtes Gefecht mit echten Regeln | +| KOSTENLOS | `akt3_k3_smaladh`/`es_kostet_nichts` | **Kosten fallen weg** (Ausdauer, Rückstoß, Erschöpfung); nichts blinkt rot, nichts warnt. Ab hier **erodiert die Oberfläche gestaffelt** | +| EROSION | `akt3_k3_smaladh`/`die_erosion` | **Eingabe wird weniger**: `input_share()` fällt von 1 auf 0, der Schlag kommt von allein und immer dichter | +| AUS | `akt3_k3_kinder`/`sie_kommt` | Imogens Ankunft beendet den Fall — sonst liefe K4 mit abgeschaltetem Fail-State und leerer Oberfläche weiter | + +**Kein Autorentext geändert.** Die Zuordnung Knoten → Phase liegt in +`data/story/akt3_k3_fall.json`, nicht in den Dialogdateien. Ermöglicht wurde +das durch ein neues, allgemeines Signal `DialogueSystem.node_started`. + +Umsetzung: `CombatActor` bekam die überschreibbaren `is_death_blocked()` und +`is_cost_free()` (Basis: beides nein), `player_combat.gd` beantwortet sie aus +`FallState`. Kein Fail-State = Leben wird bei 1 gehalten, `died` fällt nie. +Kostenfrei = `spend_stamina` gelingt immer und die Ausdauer steht voll, damit +nichts mehr ausschlägt. Das `combat_hud` blendet auf `phase_changed` nach- +einander aus — Ausdauer, Waffe, Gegner, zuletzt Leben. + +**Übergang Phase 1 → Phase 2 ohne Ansage:** `es_ist_entschieden` schaltet +selbst nichts um, und `FallState` baut nie UI — kein Banner, kein Ton, keine +Zwischensequenz. + +**Verifikation:** Sonde 22/22 mit Kontrollmessungen — im Fall überleben 30 +volle Treffer, **ohne** den Fall tötet derselbe Treffer sofort; im Fall +gelingt eine Aktion bei 0 Ausdauer, ohne ihn scheitert sie. Anzeigen +verschwinden nachweislich gestaffelt (zwischendurch sind einige sichtbar und +andere nicht) und am Ende ist die Oberfläche leer. End-to-End durch den +Kapitel-Runner: genau vier Phasenwechsel, in den richtigen Szenen, K1/K2 und +K4/K5 unberührt. Regression CR 44 und Boot-Check 7 Szenen: 0 Fehler. + +**Offen:** K3 läuft derzeit als reine Dialogszene durch den Runner — eine +Kampf-Arena für das Dorf gibt es noch nicht. Das System steht und ist geprüft, +sichtbar werden die vier Punkte erst mit dem Szenenbau. + ## 2026-09-05 — CR 44: Eingabe im Manifestations-Moment hart gesperrt Bei Resson erwacht Tyrveils zweite Siegelkraft unwillkürlich. Der Akt trägt diff --git a/project.godot b/project.godot index 533e073..118245d 100644 --- a/project.godot +++ b/project.godot @@ -32,6 +32,7 @@ SignetSystem="*res://scripts/autoloads/signet_system.gd" StorySystem="*res://scripts/autoloads/story_system.gd" InputPrompts="*res://scripts/autoloads/input_prompts.gd" MatureContentGate="*res://scripts/autoloads/mature_content_gate.gd" +FallState="*res://scripts/autoloads/fall_state.gd" [debug] diff --git a/scripts/autoloads/dialogue_system.gd b/scripts/autoloads/dialogue_system.gd index 293a66e..9bd356e 100644 --- a/scripts/autoloads/dialogue_system.gd +++ b/scripts/autoloads/dialogue_system.gd @@ -60,6 +60,9 @@ extends Node ## bewusst NIE gelesen — sie dürfen nie im Spiel erscheinen. signal dialogue_started(dialogue_id: String) +## Meldet jeden Knoten, bevor er gespielt wird — der Anker fuer Systeme, die +## an einzelnen Stellen im Text umschalten (CR 45: der Fall in Akt 3 K3). +signal node_started(dialogue_id: String, node_id: String) signal dialogue_finished(dialogue_id: String) const BOX_SCENE := preload("res://scenes/ui/dialogue_box.tscn") @@ -175,6 +178,7 @@ func _run_dialogue(data: Dictionary, start_node := "", stop_node := "") -> void: await _play_time_card(str(data.get("time_card", ""))) while node_id != "" and node_id != stop_node and nodes.has(node_id) and not _is_abort_requested and _are_speakers_alive(): var node: Dictionary = nodes[node_id] + node_started.emit(str(data["id"]), node_id) var options := _available_options(node.get("options", [])) if options.is_empty() or is_input_locked_node(node): node_id = await _play_line(node) diff --git a/scripts/autoloads/fall_state.gd b/scripts/autoloads/fall_state.gd new file mode 100644 index 0000000..f050dce --- /dev/null +++ b/scripts/autoloads/fall_state.gd @@ -0,0 +1,140 @@ +extends Node +## Der Fall (Autoload, CR 45; AKT3.md K3 „Wie es gespielt wird"). +## +## K3 ist **kein Bosskampf, sondern ein Systemzustand.** „Das Ausbrennen ist +## nicht der Preis, sondern das Ziel" (STORY.md §9) lässt sich nicht +## behaupten, nur bauen: Ein Spieler, der eine Lebensanzeige sieht, spielt +## einen Kampf. Ein Spieler, dem die Anzeigen wegbrechen und dessen Eingaben +## immer weniger bedeuten, spielt einen Mann, der sich verbrennt. +## +## Vier Phasen, jede an einen Dialogknoten gebunden (Zuordnung in +## `data/story/akt3_k3_fall.json`, damit die Autoren-Dialogdateien +## unangetastet bleiben). Dieser Autoload hört selbst auf +## `DialogueSystem.node_started` und schaltet weiter: +## +## - **GEFECHT** (ab `akt3_k3_dorf`/`gefecht`): echtes Gefecht mit echten +## Regeln — Ausdauer, Rückstoß, Gefahr. NUR der Fail-State ist still +## abgeschaltet: Tyrveil kann hier nicht sterben. Er versucht es, und das +## Spiel lässt ihn nicht — und sagt es ihm nicht. +## - **KOSTENLOS** (ab `akt3_k3_smaladh`/`es_kostet_nichts`): Ausdauer, +## Rückstoß und Erschöpfung kosten nichts mehr. Nichts blinkt rot, nichts +## warnt. Ab hier erodiert die Oberfläche, gestaffelt und nicht auf einmal. +## - **EROSION** (ab `akt3_k3_smaladh`/`die_erosion`): Je stärker er wird, +## desto weniger muss der Spieler tun. `erosion()` steigt von 0 auf 1; +## `input_share()` fällt entsprechend. +## +## Der Übergang von Phase 1 zu Phase 2 hat **keine Ansage** — kein Banner, +## kein Ton, keine Zwischensequenz. Dieser Autoload zeigt selbst nie etwas an; +## er setzt nur Zustand und meldet ihn per Signal. +## +## Beendet wird der Fall dort, wo er erzählerisch endet: bei Imogens Ankunft +## (`akt3_k3_kinder`/`sie_kommt`, in der Zuordnung als Phase 0). Sonst liefe +## K4 mit abgeschaltetem Fail-State und leerer Oberfläche weiter. + +signal phase_changed(phase: int) + +enum Phase { AUS, GEFECHT, KOSTENLOS, EROSION } + +const MAP_PATH := "res://data/story/akt3_k3_fall.json" +const EROSION_SECONDS := 24.0 + +var phase: int = Phase.AUS + +var _map: Dictionary = {} +var _erosion := 0.0 + + +## Lädt die Knoten-Zuordnung und hängt sich an den Dialog-Fortschritt. +func _ready() -> void: + _map = _load_map() + DialogueSystem.node_started.connect(_on_node_started) + + +## Treibt die Erosion voran, sobald sie läuft. +func _process(delta: float) -> void: + if phase != Phase.EROSION or _erosion >= 1.0: + return + _erosion = minf(_erosion + delta / EROSION_SECONDS, 1.0) + + +## Schaltet die Phase, wenn der gerade begonnene Knoten eine nennt. +func _on_node_started(dialogue_id: String, node_id: String) -> void: + var key := "%s/%s" % [dialogue_id, node_id] + if not _map.has(key): + return + var target := int(_map[key]) + if target <= Phase.AUS: + reset() + return + set_phase(target) + + +## Setzt die Phase (öffentlich für Sonden und Szenen). Rückwärts wird nicht +## geschaltet — der Fall kennt keinen Weg zurück; nur reset() räumt auf. +func set_phase(new_phase: int) -> void: + if new_phase <= phase: + return + phase = new_phase + if phase == Phase.EROSION: + _erosion = 0.0 + phase_changed.emit(phase) + + +## Beendet den Zustand vollständig (Kapitelende, Spielstand laden). +func reset() -> void: + if phase == Phase.AUS: + return + phase = Phase.AUS + _erosion = 0.0 + phase_changed.emit(phase) + + +## Läuft der Fall gerade? +func is_active() -> bool: + return phase != Phase.AUS + + +## Ist der Fail-State abgeschaltet? Gilt ab dem ersten Gefechtsknoten. +func blocks_death() -> bool: + return phase >= Phase.GEFECHT + + +## Kosten Aktionen nichts mehr (Ausdauer, Rückstoß, Erschöpfung)? +func is_cost_free() -> bool: + return phase >= Phase.KOSTENLOS + + +## Erodiert die Oberfläche bereits? +func is_eroding() -> bool: + return phase >= Phase.KOSTENLOS + + +## Fortschritt der Eingabe-Erosion, 0 bis 1. +func erosion() -> float: + return _erosion + + +## Anteil der Eingabe, den der Spieler noch selbst leisten muss (1 = alles, +## gegen 0 = es geht ohne ihn weiter). +func input_share() -> float: + if phase < Phase.EROSION: + return 1.0 + return 1.0 - _erosion + + +## Liest die Knoten-Zuordnung; leere Tabelle bei Fehlern (dann bleibt der +## Zustand schlicht aus). +func _load_map() -> Dictionary: + var file := FileAccess.open(MAP_PATH, FileAccess.READ) + if file == null: + push_error("Fall-Zuordnung nicht lesbar: %s" % MAP_PATH) + return {} + var parsed: Variant = JSON.parse_string(file.get_as_text()) + file.close() + if not (parsed is Dictionary) or not (parsed.get("phasen") is Dictionary): + push_error("Fall-Zuordnung ist ungültig: %s" % MAP_PATH) + return {} + var out: Dictionary = {} + for key in parsed["phasen"]: + out[str(key)] = int(parsed["phasen"][key]) + return out diff --git a/scripts/gameplay/combat/combat_actor.gd b/scripts/gameplay/combat/combat_actor.gd index 3cce922..6275ec5 100644 --- a/scripts/gameplay/combat/combat_actor.gd +++ b/scripts/gameplay/combat/combat_actor.gd @@ -99,6 +99,20 @@ func is_alive() -> bool: return health > 0 +## Ist der Tod dieses Kämpfers gerade unterbunden? Basis: nein. Tyrveil +## überschreibt das für den Fall in Akt 3 K3 (CR 45) — dort kann er nicht +## sterben, und das Spiel sagt es ihm nicht. +func is_death_blocked() -> bool: + return false + + +## Kosten Aktionen dieses Kämpfers gerade nichts? Basis: nein. Tyrveil +## überschreibt das für den Fall (CR 45): Ausdauer, Rückstoß und +## Erschöpfung kosten ab der Mitte des Kapitels nichts mehr. +func is_cost_free() -> bool: + return false + + ## Nimmt einen Treffer entgegen und liefert das Ergebnis als String ## (dodged/parried/blocked/hit). attacker darf null sein (Umwelt). func take_hit(damage: int, is_heavy := false, attacker: CombatActor = null) -> String: @@ -137,6 +151,8 @@ func apply_stagger(seconds: float) -> void: ## Zieht Ausdauer ab und pausiert die Regeneration kurz; liefert false, ## wenn nicht genug Ausdauer vorhanden war. func spend_stamina(amount: float) -> bool: + if is_cost_free(): + return true if stamina < amount: return false stamina = maxf(stamina - amount, 0.0) @@ -147,7 +163,7 @@ func spend_stamina(amount: float) -> bool: ## Prüft, ob genug Ausdauer für eine Aktion da ist. func has_stamina(amount: float) -> bool: - return stamina >= amount + return is_cost_free() or stamina >= amount ## Treibt Stagger-Countdown und Ausdauer-Regeneration voran; abgeleitete @@ -155,6 +171,11 @@ func has_stamina(amount: float) -> bool: func tick_combat(delta: float) -> void: if _stagger_remaining > 0.0: _stagger_remaining = maxf(_stagger_remaining - delta, 0.0) + if is_cost_free(): + if stamina < max_stamina: + stamina = max_stamina + stamina_changed.emit(stamina, max_stamina) + return if _stamina_pause > 0.0: _stamina_pause = maxf(_stamina_pause - delta, 0.0) return @@ -168,7 +189,8 @@ func tick_combat(delta: float) -> void: func _apply_damage(damage: int) -> void: if damage <= 0: return - health = maxi(health - damage, 0) + var floor_value := 1 if is_death_blocked() else 0 + health = maxi(health - damage, floor_value) health_changed.emit(health, max_health) if health == 0: died.emit() diff --git a/scripts/gameplay/combat/player_combat.gd b/scripts/gameplay/combat/player_combat.gd index 4c3ebab..c335dec 100644 --- a/scripts/gameplay/combat/player_combat.gd +++ b/scripts/gameplay/combat/player_combat.gd @@ -89,6 +89,12 @@ var _counter_window := 0.0 ## Übernimmt die Kampfwerte aus dem Tuning, lädt die Waffen und startet ## inaktiv. +const FALL_SWING_INTERVAL_MAX := 1.6 +const FALL_SWING_INTERVAL_MIN := 0.35 + +var _fall_swing_timer := 0.0 + + func _ready() -> void: var player_data := tuning_section("player") max_health = int(player_data.get("max_health", 100)) @@ -290,6 +296,23 @@ func _physics_process(delta: float) -> void: start_block() elif Input.is_action_just_released("block"): end_block() + _tick_fall_swing(delta) + + +## Eingabe-Erosion des Falls (CR 45): Je stärker Tyrveil wird, desto weniger +## muss der Spieler tun. Der Schlag kommt von allein und immer dichter — am +## Ende drückt man fast nichts mehr und es geht trotzdem weiter. +func _tick_fall_swing(delta: float) -> void: + var share := FallState.input_share() + if share >= 1.0: + _fall_swing_timer = 0.0 + return + _fall_swing_timer -= delta + if _fall_swing_timer > 0.0: + return + _fall_swing_timer = lerpf(FALL_SWING_INTERVAL_MAX, FALL_SWING_INTERVAL_MIN, 1.0 - share) + if _action == ActionState.READY: + try_light_attack() ## Startet einen leichten Angriff; liefert false, wenn blockiert, @@ -341,6 +364,18 @@ func end_block() -> void: ## Unverwundbar während des i-Fensters der Rolle (Schnelligkeit ## verlängert es leicht). +## Im Fall (CR 45) kann Tyrveil nicht sterben — ab dem ersten +## Gefechtsknoten in K3, und ohne dass es ihm gesagt wird. +func is_death_blocked() -> bool: + return FallState.blocks_death() + + +## Im Fall kosten Ausdauer, Rückstoß und Erschöpfung ab der Mitte des +## Kapitels nichts mehr (CR 45). Nichts blinkt rot, nichts warnt. +func is_cost_free() -> bool: + return FallState.is_cost_free() + + func is_invulnerable() -> bool: if _action != ActionState.DODGING or not _dodge_has_iframes: return false diff --git a/scripts/ui/combat_hud.gd b/scripts/ui/combat_hud.gd index 2285228..617f52e 100644 --- a/scripts/ui/combat_hud.gd +++ b/scripts/ui/combat_hud.gd @@ -6,9 +6,20 @@ extends CanvasLayer ## Waffenskill. Alle Balken hängen an den Signalen der CombatActors — ## das HUD rechnet nichts selbst. Läuft als Greybox-UI zur Laufzeit ## aufgebaut, damit Encounter-Szenen nichts vorbereiten müssen. +## +## **Erosion im Fall (CR 45):** Sobald FallState in die kostenlose Phase +## schaltet, verschwinden die Anzeigen NACHEINANDER und nicht auf einmal — +## erst die Ausdauer (sie kostet nichts mehr und würde also lügen), dann die +## Waffe, dann die Gegner, zuletzt das Leben. Am Ende ist nichts mehr auf dem +## Bild außer dem Dorf. Kein Banner, kein Ton, keine Ansage: Der Übergang von +## Phase 1 zu Phase 2 wird nirgends angekündigt. + +const EROSION_STEP_SECONDS := 3.0 +const EROSION_FADE_SECONDS := 2.0 var _player: CombatActor var _enemy_bars: Dictionary = {} +var _is_eroding := false @onready var _root: Control = $Root @onready var _health_bar: ProgressBar = $Root/PlayerBox/HealthBar @@ -17,6 +28,56 @@ var _enemy_bars: Dictionary = {} @onready var _enemy_box: VBoxContainer = $Root/EnemyBox +## Verbindet die Fall-Phasen, sobald das HUD im Baum steht. +func _ready() -> void: + FallState.phase_changed.connect(_on_fall_phase) + if FallState.is_eroding(): + _on_fall_phase(FallState.phase) + + +## Startet die gestaffelte Erosion, sobald der Fall die Kosten abschaltet; +## ein Zurücksetzen stellt die Anzeigen wieder her. +func _on_fall_phase(_phase: int) -> void: + if FallState.is_eroding(): + if not _is_eroding: + _is_eroding = true + _erode() + return + _is_eroding = false + for element in _erodable(): + element.visible = true + element.modulate.a = 1.0 + + +## Blendet die Anzeigen nacheinander aus — Ausdauer, Waffe, Gegner, Leben. +func _erode() -> void: + for element in _erodable(): + if not is_instance_valid(element): + continue + var tween := create_tween() + tween.tween_property(element, "modulate:a", 0.0, EROSION_FADE_SECONDS) + await tween.finished + if not _is_eroding: + return + element.visible = false + await get_tree().create_timer(EROSION_STEP_SECONDS).timeout + if not _is_eroding: + return + + +## Die Anzeigen in der Reihenfolge, in der sie verschwinden. +func _erodable() -> Array: + return [_stamina_bar, _weapon_label, _enemy_box, _health_bar] + + +## Meldet, ob die Oberfläche leer ist (für Sonden und die Abnahme). +func is_surface_empty() -> bool: + for element in _erodable(): + if is_instance_valid(element) and element.visible: + return false + return true + + ## Hängt sich an Spieler und Gegner und baut je einen Gegner-Balken. func setup(player: CombatActor, enemies: Array) -> void: _player = player