windgeschworen/scripts/gameplay/combat/combat_actor.gd
danny 32f75a732b CR 8a: Kampf-Kern — leicht/schwer, Ausweichen, Dodge, Block/Parry
- CombatActor als gemeinsame Basis (HP, Ausdauer mit Regeneration,
  Haltung, Stagger); take_hit wertet i-Frames → Parry → Block → Treffer,
  schwere Angriffe umgehen Block und Parry
- PlayerCombat am Spieler: Grammatik über der unveränderten Bewegung —
  leichter Angriff, schwerer Angriff (langer Windup, bricht Blocks),
  Seitenschritt ohne i-Frames, Dodge-Rolle mit i-Fenster, Block mit
  Parry-Fenster; Windup → Active → Recovery, ein Treffer pro Schwung
- Stats: Kraft → Schaden, Schnelligkeit → Tempo und i-Frames,
  Verstand → Parry-Fenster (alle gedeckelt, Feinbalancing bleibt 8e)
- EncounterZone schaltet den Kampf nur in definierten Zonen scharf
  (Option B, keine roamenden Gegner); außerhalb bleibt Movement frei
- Trainings-Dummy mit telegrafiertem Schlag + Greybox-Testarena
  (scenes/combat/combat_testground.tscn)
- Neue Input-Actions heavy_attack (F / L2) und dodge (Leertaste / A✕);
  Tuning daten-getrieben in data/combat/combat_tuning.json
- Buchführung: 8a nach CHANGEREQUESTS_DONE, ROADMAP nachgezogen

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-20 19:07:40 +02:00

174 lines
5.4 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
## 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 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 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 _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
health = maxi(health - damage, 0)
health_changed.emit(health, max_health)
if health == 0:
died.emit()