"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>
196 lines
6.2 KiB
GDScript
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()
|