windgeschworen/scripts/gameplay/combat/combat_actor.gd
danny a5fec979a5 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) laesst
sich nicht behaupten, nur bauen. Neuer Autoload FallState mit vier Phasen,
jede an einen Dialogknoten gebunden:

- GEFECHT (akt3_k3_dorf/gefecht): kein Fail-State — Tyrveil kann nicht
  sterben, und das Spiel sagt es ihm nicht. Kosten und Gefahr gelten weiter,
  damit die erste Phase ein echtes Gefecht bleibt.
- KOSTENLOS (akt3_k3_smaladh/es_kostet_nichts): Ausdauer, Rueckstoss und
  Erschoepfung kosten nichts mehr, nichts blinkt rot. Ab hier erodiert die
  Oberflaeche gestaffelt.
- EROSION (akt3_k3_smaladh/die_erosion): die Eingabe wird weniger,
  input_share() faellt von 1 auf 0, der Schlag kommt von allein.
- AUS (akt3_k3_kinder/sie_kommt): Imogens Ankunft beendet den Fall — sonst
  liefe K4 mit abgeschaltetem Fail-State und leerer Oberflaeche weiter.

Kein Autorentext geaendert: Die Zuordnung Knoten -> Phase liegt in
data/story/akt3_k3_fall.json, nicht in den Dialogdateien. Moeglich durch ein
neues allgemeines Signal DialogueSystem.node_started.

CombatActor bekam die ueberschreibbaren is_death_blocked() und
is_cost_free() (Basis beides nein), player_combat beantwortet sie aus
FallState. combat_hud blendet auf phase_changed nacheinander aus: Ausdauer,
Waffe, Gegner, zuletzt Leben. Der Uebergang Phase 1 -> 2 hat keine Ansage —
es_ist_entschieden schaltet selbst nichts, und FallState baut nie UI.

Verifikation: Sonde 22/22 mit Kontrollen — im Fall ueberleben 30 volle
Treffer, OHNE den Fall toetet derselbe Treffer sofort; im Fall gelingt eine
Aktion bei 0 Ausdauer, ohne ihn scheitert sie. Anzeigen verschwinden
nachweislich gestaffelt, am Ende ist die Oberflaeche leer. End-to-End durch
den Kapitel-Runner: genau vier Phasenwechsel in den richtigen Szenen, K1/K2
und K4/K5 unberuehrt. Regression CR 44 und Boot-Check 7 Szenen: 0 Fehler.

Offen: K3 laeuft derzeit als reine Dialogszene durch den Runner — eine
Kampf-Arena fuers Dorf gibt es noch nicht. Das System steht und ist geprueft,
sichtbar werden die vier Punkte erst mit dem Szenenbau.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-08 06:28:57 +02:00

196 lines
6.2 KiB
GDScript

class_name CombatActor
extends Node
## Gemeinsame Kampf-Basis für Spieler und Gegner (CR 8a).
##
## Hält Trefferpunkte, Ausdauer und Haltung (Poise) eines Kämpfers und
## nimmt Treffer entgegen. Ein Treffer prüft in dieser Reihenfolge:
## Unverwundbarkeit (i-Frames der Dodge-Rolle) → Parry-Fenster (der
## Angreifer wird gestaggert, kein Schaden) → Block (stark reduzierter
## Schaden, kostet Ausdauer; schwere Angriffe brechen den Block) →
## voller Schaden. Ausdauer regeneriert nach einer kurzen Pause. Die
## Zahlen kommen aus data/combat/combat_tuning.json; abgeleitete
## Klassen (player_combat, training_dummy) füllen Verhalten und
## Eingaben. Der Tod meldet nur das Signal — die Konsequenz (Respawn,
## Szenenende) gehört der jeweiligen Encounter-Szene.
signal health_changed(current: int, maximum: int)
signal stamina_changed(current: float, maximum: float)
signal hit_taken(damage: int, result: String)
signal parried(attacker: CombatActor)
signal staggered(seconds: float)
signal died
const TUNING_PATH := "res://data/combat/combat_tuning.json"
const RESULT_DODGED := "dodged"
const RESULT_PARRIED := "parried"
const RESULT_BLOCKED := "blocked"
const RESULT_HIT := "hit"
static var _tuning: Dictionary = {}
var max_health := 100
var max_stamina := 100.0
var health := 100
var stamina := 100.0
var poise := 30
var _stagger_remaining := 0.0
var _stamina_pause := 0.0
## Lädt die Tuning-Tabelle einmalig in den statischen Cache.
static func load_tuning() -> Dictionary:
if not _tuning.is_empty():
return _tuning
var file := FileAccess.open(TUNING_PATH, FileAccess.READ)
if file == null:
push_error("Kampf-Tuning nicht lesbar: %s" % TUNING_PATH)
return {}
var parsed: Variant = JSON.parse_string(file.get_as_text())
file.close()
if parsed is Dictionary:
_tuning = parsed
else:
push_error("Kampf-Tuning ist ungültig: %s" % TUNING_PATH)
return _tuning
## Liefert einen Tuning-Abschnitt (leer, wenn unbekannt).
static func tuning_section(section: String) -> Dictionary:
var data := load_tuning()
return data.get(section, {})
## Setzt Werte auf Maximum zurück (Encounter-Start).
func reset_combat_values() -> void:
health = max_health
stamina = max_stamina
_stagger_remaining = 0.0
_stamina_pause = 0.0
health_changed.emit(health, max_health)
stamina_changed.emit(stamina, max_stamina)
## Gibt zurück, ob der Kämpfer gerade unverwundbar ist (i-Frames).
## Abgeleitete Klassen überschreiben das.
func is_invulnerable() -> bool:
return false
## Gibt zurück, ob gerade geblockt wird. Abgeleitete Klassen überschreiben.
func is_blocking() -> bool:
return false
## Gibt zurück, ob der Block noch im Parry-Fenster liegt. Abgeleitete
## Klassen überschreiben.
func is_parrying() -> bool:
return false
## Gibt zurück, ob der Kämpfer gerade gestaggert ist (keine Aktionen).
func is_staggered() -> bool:
return _stagger_remaining > 0.0
## Gibt zurück, ob der Kämpfer noch lebt.
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:
if not is_alive():
return RESULT_HIT
if is_invulnerable():
hit_taken.emit(0, RESULT_DODGED)
return RESULT_DODGED
if is_parrying() and not is_heavy:
var block_data := tuning_section("block")
var stagger := float(block_data.get("parry_stagger_seconds", 1.0))
if attacker != null:
attacker.apply_stagger(stagger)
parried.emit(attacker)
hit_taken.emit(0, RESULT_PARRIED)
return RESULT_PARRIED
if is_blocking() and not is_heavy:
var block_data := tuning_section("block")
var reduced := int(round(float(damage) * float(block_data.get("damage_multiplier", 0.25))))
spend_stamina(float(block_data.get("stamina_cost_per_hit", 12.0)))
_apply_damage(reduced)
hit_taken.emit(reduced, RESULT_BLOCKED)
return RESULT_BLOCKED
_apply_damage(damage)
hit_taken.emit(damage, RESULT_HIT)
return RESULT_HIT
## Legt den Kämpfer für seconds Sekunden lahm (Parry-Folge, schwerer
## Treffer gegen die Haltung).
func apply_stagger(seconds: float) -> void:
_stagger_remaining = maxf(_stagger_remaining, seconds)
staggered.emit(seconds)
## 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)
_stamina_pause = float(tuning_section("player").get("stamina_regen_delay", 0.6))
stamina_changed.emit(stamina, max_stamina)
return true
## Prüft, ob genug Ausdauer für eine Aktion da ist.
func has_stamina(amount: float) -> bool:
return is_cost_free() or stamina >= amount
## Treibt Stagger-Countdown und Ausdauer-Regeneration voran; abgeleitete
## Klassen rufen das in ihrem eigenen _physics_process auf.
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
if stamina < max_stamina:
var regen := float(tuning_section("player").get("stamina_regen_per_second", 15.0))
stamina = minf(stamina + regen * delta, max_stamina)
stamina_changed.emit(stamina, max_stamina)
## Zieht Schaden ab und meldet den Tod einmalig.
func _apply_damage(damage: int) -> void:
if damage <= 0:
return
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()