windgeschworen/scripts/gameplay/combat/player_combat.gd
danny 9352ec277b Encounter: Nachschub, Neustart und zielender Fall-Schlag
- CombatEncounter.add_enemy: weiterer Gegner in einen laufenden Encounter,
  der erst endet, wenn auch der Nachschub am Boden ist (HUD bekommt den
  Balken mit, auch wenn die Anzeige schon wegerodiert ist).
- stop() loest die Verbindung zu Tyrveils Tod; bei gesperrtem Tod wurde sie
  nie verbraucht und derselbe Rahmen liess sich nicht erneut starten.
- Der automatische Fall-Schlag (CR 45) dreht Tyrveil zum naechsten Gegner
  in Reichweite. Ohne Eingabe dreht sich der Koerper nicht; gemessen gingen
  21 von 21 Schlaegen daneben, mit Ausrichtung treffen 16 von 19.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-14 18:32:17 +02:00

637 lines
23 KiB
GDScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

extends CombatActor
## Tyrveils Kampf-Kern (CR 8a) — Node am Spieler, ersetzt kein Movement.
##
## Die Bewegung bleibt frei: player.gd läuft weiter, dieses Skript legt
## nur die Kampf-Grammatik darüber (SPEC §1, CHANGEREQUESTS §8). Aktiv
## ist es ausschließlich in Encounter-Zonen (set_encounter_active) —
## außerhalb schluckt es keine Eingaben, damit Sprung, Slide und
## Klettern unberührt bleiben (Option B: kein Welt-Sandbox).
##
## Grammatik:
## - **Leichter Angriff** (attack): schnell, günstig.
## - **Schwerer Angriff** (heavy_attack): langer Windup, hoher Schaden,
## **bricht Blocks** und kann nicht pariert werden.
## - **Seitenschritt** (dodge + Bewegungsrichtung quer): kurzer Schritt
## OHNE Unverwundbarkeit — reine Positionierung, billig.
## - **Dodge-Rolle** (dodge ohne Richtung bzw. vorwärts): Rolle MIT
## Unverwundbarkeits-Fenster, teurer.
## - **Block/Parry** (block halten): stark reduzierter Schaden; in den
## ersten Sekundenbruchteilen ein **Parry**, das den Angreifer
## staggert.
##
## Stats-Kopplung (SPEC §6): Kraft hebt den Schaden, Schnelligkeit
## verkürzt Windup/Recovery und verlängert die i-Frames, Verstand weitet
## das Parry-Fenster. Alle Zahlen aus data/combat/combat_tuning.json.
##
## Rüstungen (CR 8e, data/combat/armor.json): Leder, Gehärtetes Leder
## und Schuppenpanzer bilden einen echten **Trade-off Schutz ↔ Tempo** —
## mehr Schadensreduktion bedeutet langsamere Aktionen, kürzere i-Frames
## und höhere Ausdauerkosten. Es gibt kein „mehr ist besser". Die
## getragene Rüstung liegt im GameState und reist im Spielstand mit.
##
## Waffen (CR 8b, data/combat/weapons.json): Dolch, Schwert und Axt sind
## **jederzeit wechselbar** (weapon_switch; mitten in einer Aktion wird
## der Wechsel gemerkt und beim Zurückfallen auf READY ausgeführt — kein
## Bruch im Zustand). Jede Waffe hat ein cycle_scale, das Zeiten,
## Schaden UND Ausdauerkosten gemeinsam skaliert: Wer langsamer schlägt,
## trifft proportional härter → **gleiche DPR bei gleichem Skill**, die
## Wahl ist Stil. Echte Unterschiede sind Reichweite und Haltungsschaden.
## Kombos & Waffenskill (CR 8c): Ein Treffer öffnet ein kurzes
## Eingabefenster — wer rechtzeitig nachschlägt, hängt das nächste
## Kettenglied an (Eröffnung → Folge → Abschluss). Die Kette ist für
## alle drei Klassen gleich aufgebaut und skaliert wie alles andere mit
## cycle_scale, damit die **DPR-Parität aus 8b erhalten bleibt**. Der
## **Waffenskill wächst pro Waffenklasse getrennt** (GameState,
## save-persistent): Er schaltet die späteren Kettenglieder frei und
## senkt die Ausdauerkosten — er hebt **NICHT** den Rohschaden. Nach
## einem Parry öffnet sich ein **Konter-Fenster**, das Verstand weitet;
## ein Schlag darin trifft deutlich härter.
signal attack_landed(result: String, damage: int)
signal attack_started(kind: String)
signal dodge_started(has_iframes: bool)
signal weapon_changed(weapon_id: String, weapon_name: String)
signal combo_advanced(link_id: String, link_index: int)
signal counter_window_opened
signal counter_landed(damage: int)
enum ActionState { READY, WINDUP, ACTIVE, RECOVERY, DODGING }
const WEAPONS_PATH := "res://data/combat/weapons.json"
const ARMOR_PATH := "res://data/combat/armor.json"
const HITBOX_RADIUS := 1.1
var is_encounter_active := false
var _weapons: Array = []
var _armor_sets: Array = []
var _weapon_index := 0
var _pending_weapon_index := -1
var _action := ActionState.READY
var _action_kind := ""
var _action_timer := 0.0
var _dodge_timer := 0.0
var _dodge_has_iframes := false
var _dodge_direction := Vector3.ZERO
var _block_timer := 0.0
var _is_block_held := false
var _has_hit_this_swing := false
var _combo_index := 0
var _combo_window := 0.0
var _is_combo_queued := false
var _counter_window := 0.0
@onready var _player: CharacterBody3D = get_parent() as CharacterBody3D
@onready var _mesh: Node3D = _player.get_node("MeshInstance3D") as Node3D
@onready var _camera_pivot: Node3D = _player.get_node("CameraPivot") as Node3D
## Ü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
const FALL_AIM_RANGE := 4.0
var _fall_swing_timer := 0.0
func _ready() -> void:
var player_data := tuning_section("player")
max_health = int(player_data.get("max_health", 100))
max_stamina = float(player_data.get("max_stamina", 100.0))
_load_weapons()
_load_armor()
reset_combat_values()
parried.connect(_on_parried)
set_physics_process(false)
## Ein gelungener Parry öffnet das Konter-Fenster (Verstand weitet es).
func _on_parried(_attacker: CombatActor) -> void:
var skill_data := tuning_section("skill")
var stats := tuning_section("stats")
var window := float(skill_data.get("counter_window_seconds", 0.6))
window += minf(GameState.intellect * float(stats.get("intellect_counter_per_point", 0.006)), float(stats.get("intellect_counter_max_bonus", 0.4)))
_counter_window = window
counter_window_opened.emit()
## Liefert die verbleibende Zeit des Konter-Fensters in Sekunden.
func get_counter_window() -> float:
return _counter_window
## Liefert den Skill der aktiven Waffenklasse (0–100).
func get_weapon_skill() -> int:
return GameState.get_weapon_skill(str(get_weapon().get("id", "")))
## Liefert den Index des nächsten Kettenglieds (0 = frischer Angriff).
func get_combo_index() -> int:
return _combo_index
## Liefert die Kettenglieder aus dem Tuning.
func get_combo_links() -> Array:
return tuning_section("combo").get("links", [])
## Gibt zurück, wie viele Kettenglieder der aktuelle Waffenskill
## freigeschaltet hat (mindestens eines).
func get_unlocked_combo_links() -> int:
var skill := get_weapon_skill()
var unlocked := 0
for link in get_combo_links():
if skill >= int(link.get("min_skill", 0)):
unlocked += 1
return maxi(unlocked, 1)
## Lädt die Waffentabelle und rüstet die Standardwaffe aus.
func _load_weapons() -> void:
var file := FileAccess.open(WEAPONS_PATH, FileAccess.READ)
if file == null:
push_error("Waffentabelle nicht lesbar: %s" % WEAPONS_PATH)
return
var parsed: Variant = JSON.parse_string(file.get_as_text())
file.close()
if not (parsed is Dictionary) or not (parsed.get("weapons") is Array):
push_error("Waffentabelle ist ungültig: %s" % WEAPONS_PATH)
return
_weapons = parsed["weapons"]
equip_weapon(str(parsed.get("default_weapon", "")))
## Lädt die Rüstungstabelle und rüstet die gespeicherte bzw. die
## Standard-Rüstung aus (CR 8e).
func _load_armor() -> void:
var file := FileAccess.open(ARMOR_PATH, FileAccess.READ)
if file == null:
push_error("Rüstungstabelle nicht lesbar: %s" % ARMOR_PATH)
return
var parsed: Variant = JSON.parse_string(file.get_as_text())
file.close()
if not (parsed is Dictionary) or not (parsed.get("sets") is Array):
push_error("Rüstungstabelle ist ungültig: %s" % ARMOR_PATH)
return
_armor_sets = parsed["sets"]
if GameState.equipped_armor.is_empty():
GameState.equipped_armor = str(parsed.get("default_armor", ""))
## Rüstet eine Rüstung über ihre ID aus; liefert false bei unbekannter ID.
func equip_armor(armor_id: String) -> bool:
for armor_set in _armor_sets:
if str(armor_set.get("id", "")) == armor_id:
GameState.equipped_armor = armor_id
return true
return false
## Liefert die aktuell getragene Rüstung (leer, wenn keine geladen).
func get_armor() -> Dictionary:
for armor_set in _armor_sets:
if str(armor_set.get("id", "")) == GameState.equipped_armor:
return armor_set
return {}
## Liefert alle Rüstungs-IDs (für UI und Tests).
func get_armor_ids() -> Array:
var ids: Array = []
for armor_set in _armor_sets:
ids.append(str(armor_set.get("id", "")))
return ids
## Rüstet eine Waffe über ihre ID aus; liefert false bei unbekannter ID.
func equip_weapon(weapon_id: String) -> bool:
for i in _weapons.size():
if str(_weapons[i].get("id", "")) == weapon_id:
_set_weapon_index(i)
return true
return false
## Schaltet auf die nächste Waffenklasse weiter (weapon_switch).
func cycle_weapon() -> void:
if _weapons.size() < 2:
return
_set_weapon_index((_weapon_index + 1) % _weapons.size())
## Liefert die aktuell ausgerüstete Waffe (leer, wenn keine geladen).
func get_weapon() -> Dictionary:
if _weapons.is_empty():
return {}
return _weapons[_weapon_index]
## Liefert die Zykluszeit-Skala der aktiven Waffe (1.0 = Schwert).
func get_weapon_cycle_scale() -> float:
return float(get_weapon().get("cycle_scale", 1.0))
## Setzt die Waffe sofort, wenn keine Aktion läuft — sonst wird der
## Wechsel gemerkt und beim Zurückfallen auf READY nachgezogen, damit
## ein laufender Schwung nicht bricht.
func _set_weapon_index(index: int) -> void:
if index < 0 or index >= _weapons.size():
return
if _action != ActionState.READY:
_pending_weapon_index = index
return
_weapon_index = index
_pending_weapon_index = -1
var weapon := get_weapon()
weapon_changed.emit(str(weapon.get("id", "")), str(weapon.get("name", "")))
## Zieht einen während einer Aktion angeforderten Waffenwechsel nach.
func _apply_pending_weapon() -> void:
if _pending_weapon_index < 0:
return
var index := _pending_weapon_index
_pending_weapon_index = -1
_set_weapon_index(index)
## Schaltet den Kampf-Modus einer Encounter-Zone scharf oder ab.
func set_encounter_active(is_active: bool) -> void:
is_encounter_active = is_active
set_physics_process(is_active)
if is_active:
reset_combat_values()
return
_action = ActionState.READY
_is_block_held = false
_block_timer = 0.0
## Liest im Encounter die Kampf-Eingaben und treibt Aktions- und
## Dodge-Timer voran; ohne Encounter passiert nichts.
func _physics_process(delta: float) -> void:
tick_combat(delta)
if not is_alive() or _player == null:
return
if _player.is_control_locked() or DialogueSystem.is_dialogue_active:
return
_tick_action(delta)
_tick_block(delta)
_tick_windows(delta)
if is_staggered():
return
if Input.is_action_just_pressed("weapon_switch"):
cycle_weapon()
if Input.is_action_just_pressed("attack"):
if _action != ActionState.READY and _combo_window > 0.0:
_is_combo_queued = true
else:
try_light_attack()
elif Input.is_action_just_pressed("heavy_attack"):
try_heavy_attack()
elif Input.is_action_just_pressed("dodge"):
try_dodge(Input.get_vector("move_left", "move_right", "move_forward", "move_back"))
if Input.is_action_just_pressed("block"):
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.
##
## Der Schlag geht dorthin, wo jemand steht (CR 48): Ohne Eingabe dreht sich
## der Körper nicht, und ein Schlag in die Richtung, in die er zuletzt gelaufen
## ist, geht im Dorf fast immer daneben — gemessen 21 von 21 Schlägen bei einem
## Gegner 1,8 m seitlich. Dann ginge es eben nicht 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:
_face_nearest_enemy()
try_light_attack()
## Dreht Tyrveils Körper zum nächsten lebenden Gegner in Reichweite des
## Fall-Schlags; ist keiner nah genug, bleibt die Richtung.
func _face_nearest_enemy() -> void:
var nearest: Node3D = null
var nearest_distance := FALL_AIM_RANGE
for target in get_tree().get_nodes_in_group("combat_actor"):
if target == self or not (target is CombatActor) or not target.is_alive():
continue
var body := target.get_parent() as Node3D
if body == null or body == _player:
continue
var distance := body.global_position.distance_to(_player.global_position)
if distance < nearest_distance:
nearest_distance = distance
nearest = body
if nearest == null:
return
var direction := nearest.global_position - _player.global_position
direction.y = 0.0
if direction.length_squared() < 0.0001:
return
_mesh.rotation.y = atan2(-direction.x, -direction.z) - _player.global_rotation.y
## Startet einen leichten Angriff; liefert false, wenn blockiert,
## gestaggert, in einer anderen Aktion oder ohne Ausdauer.
func try_light_attack() -> bool:
return _start_attack("light_attack")
## Startet einen schweren Angriff (langer Windup, bricht Blocks).
func try_heavy_attack() -> bool:
return _start_attack("heavy_attack")
## Startet Seitenschritt oder Rolle: Eine überwiegend seitliche
## Eingaberichtung ergibt den billigen Seitenschritt OHNE i-Frames,
## alles andere die teurere Rolle MIT Unverwundbarkeits-Fenster.
func try_dodge(input_dir := Vector2.ZERO) -> bool:
if _action == ActionState.DODGING or is_staggered():
return false
var is_sidestep: bool = input_dir.length() > 0.4 and absf(input_dir.x) > absf(input_dir.y)
var section := "sidestep" if is_sidestep else "dodge_roll"
var data := tuning_section(section)
if not spend_stamina(float(data.get("stamina_cost", 15.0))):
return false
_action = ActionState.DODGING
_action_kind = section
_dodge_timer = 0.0
_dodge_has_iframes = not is_sidestep
_dodge_direction = _direction_from_input(input_dir)
_is_block_held = false
_block_timer = 0.0
dodge_started.emit(_dodge_has_iframes)
return true
## Beginnt zu blocken und öffnet das Parry-Fenster.
func start_block() -> void:
if _action != ActionState.READY or is_staggered():
return
_is_block_held = true
_block_timer = 0.0
## Beendet den Block.
func end_block() -> void:
_is_block_held = false
_block_timer = 0.0
## 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
var data := tuning_section("dodge_roll")
var scale := _agility_scale() * float(get_armor().get("iframe_scale", 1.0))
return _dodge_timer >= float(data.get("iframe_start", 0.05)) and _dodge_timer <= float(data.get("iframe_end", 0.3)) * scale
## Block zählt, solange die Taste gehalten wird und keine Aktion läuft.
func is_blocking() -> bool:
return _is_block_held and _action == ActionState.READY
## Parry-Fenster: die ersten Augenblicke des Blocks (Verstand weitet es).
func is_parrying() -> bool:
if not is_blocking():
return false
var data := tuning_section("block")
var stats := tuning_section("stats")
var window := float(data.get("parry_window_seconds", 0.2))
window += minf(GameState.intellect * float(stats.get("intellect_parry_per_point", 0.004)), float(stats.get("intellect_parry_max_bonus", 0.12)))
return _block_timer <= window
## Liefert den Namen der laufenden Aktion (für Tests und Debug).
func get_action_name() -> String:
return ActionState.keys()[_action]
## Startet einen Angriff aus dem Tuning-Abschnitt; Schnelligkeit
## verkürzt Windup und Recovery.
func _start_attack(section: String) -> bool:
if _action != ActionState.READY or is_staggered():
return false
var data := tuning_section(section)
if not spend_stamina(_stamina_cost(float(data.get("stamina_cost", 10.0)))):
return false
_action = ActionState.WINDUP
_action_kind = section
_action_timer = 0.0
_has_hit_this_swing = false
_is_block_held = false
_combo_index = 0
attack_started.emit(section)
return true
## Ausdauerkosten einer Aktion: Waffen-Zykluszeit mal Skill-Rabatt
## (Skill senkt die Kosten, NICHT den Rohschaden — CR 8c).
func _stamina_cost(base_cost: float) -> float:
var skill_data := tuning_section("skill")
var maximum := maxf(float(skill_data.get("max", 100)), 1.0)
var discount := float(skill_data.get("stamina_discount_max", 0.3)) * (float(get_weapon_skill()) / maximum)
return base_cost * get_weapon_cycle_scale() * (1.0 - discount) * float(get_armor().get("stamina_scale", 1.0))
## Nimmt einen Treffer entgegen und zieht vorher die Schutzwirkung der
## Rüstung ab (CR 8e — Schutz ist die eine Hälfte des Trade-offs).
func take_hit(damage: int, is_heavy := false, attacker: CombatActor = null) -> String:
var reduction := float(get_armor().get("damage_reduction", 0.0))
var reduced := maxi(int(round(float(damage) * (1.0 - reduction))), 1 if damage > 0 else 0)
return super(reduced, is_heavy, attacker)
## Hängt das nächste Kettenglied an, wenn der Skill es freigeschaltet
## hat und noch eines übrig ist; sonst endet die Kette.
func _try_advance_combo() -> bool:
var links := get_combo_links()
if _combo_index >= links.size() or _combo_index >= get_unlocked_combo_links():
return false
var data := tuning_section("light_attack")
if not spend_stamina(_stamina_cost(float(data.get("stamina_cost", 10.0)))):
return false
_action = ActionState.WINDUP
_action_kind = "light_attack"
_action_timer = 0.0
_has_hit_this_swing = false
_is_block_held = false
combo_advanced.emit(str(links[_combo_index].get("id", "")), _combo_index)
attack_started.emit("light_attack")
return true
## Treibt Windup → Active → Recovery voran und schlägt in der aktiven
## Phase genau einmal zu.
func _tick_action(delta: float) -> void:
if _action == ActionState.READY:
return
if _action == ActionState.DODGING:
_tick_dodge(delta)
return
var data := tuning_section(_action_kind)
var scale := get_weapon_cycle_scale() / _agility_scale()
var link := _current_combo_link()
_action_timer += delta
match _action:
ActionState.WINDUP:
if _action_timer >= float(data.get("windup_seconds", 0.15)) * scale * float(link.get("windup_scale", 1.0)):
_action = ActionState.ACTIVE
_action_timer = 0.0
ActionState.ACTIVE:
if not _has_hit_this_swing:
_resolve_swing(data, link)
if _action_timer >= float(data.get("active_seconds", 0.15)) * scale:
_action = ActionState.RECOVERY
_action_timer = 0.0
ActionState.RECOVERY:
if _action_timer >= float(data.get("recovery_seconds", 0.25)) * scale:
_action = ActionState.READY
_action_timer = 0.0
if _is_combo_queued:
_is_combo_queued = false
if _try_advance_combo():
return
_apply_pending_weapon()
## Liefert die Werte des gerade laufenden Kettenglieds (leer außerhalb
## einer Kombo — dann gelten die Basiswerte).
func _current_combo_link() -> Dictionary:
var links := get_combo_links()
if _action_kind != "light_attack" or _combo_index >= links.size():
return {}
return links[_combo_index]
## Sucht Ziele vor dem Spieler und teilt den Treffer aus. Der Schaden
## ist Basiswert × Waffen-cycle_scale × Kraft-Faktor — die Skalierung
## mit derselben Zahl wie die Zeiten hält die DPR über alle
## Waffenklassen gleich (CR 8b). Die Reichweite kommt aus der Waffe.
func _resolve_swing(data: Dictionary, link: Dictionary = {}) -> void:
_has_hit_this_swing = true
var stats := tuning_section("stats")
var weapon := get_weapon()
var base_damage := float(data.get("base_damage", 10)) * get_weapon_cycle_scale() * float(link.get("damage_scale", 1.0))
var is_counter := _counter_window > 0.0
if is_counter:
base_damage *= float(tuning_section("skill").get("counter_damage_scale", 1.8))
_counter_window = 0.0
var damage := int(round(base_damage * (1.0 + GameState.strength * float(stats.get("strength_damage_per_point", 0.1)))))
var is_heavy: bool = bool(data.get("breaks_block", false))
var origin: Vector3 = _player.global_position + Vector3(0, 1.0, 0)
var forward: Vector3 = -_mesh.global_transform.basis.z
forward.y = 0.0
var center: Vector3 = origin + forward.normalized() * float(weapon.get("reach", 1.9))
for target in get_tree().get_nodes_in_group("combat_actor"):
if target == self or not (target is CombatActor):
continue
var body := target.get_parent() as Node3D
if body == null or body == _player:
continue
if body.global_position.distance_to(center) > HITBOX_RADIUS + 0.6:
continue
var result: String = target.take_hit(damage, is_heavy, self)
_on_swing_connected(result, damage, is_counter)
attack_landed.emit(result, damage)
return
_combo_window = 0.0
_combo_index = 0
attack_landed.emit("miss", damage)
## Wertet einen verbundenen Schlag aus: Skill der geführten Waffe
## wächst, die Kombo-Kette rückt vor und ihr Eingabefenster öffnet sich.
## Ein Fehlschlag (miss) bricht die Kette — Kombos sind kein Freifahrtschein.
func _on_swing_connected(result: String, damage: int, is_counter: bool) -> void:
if is_counter:
counter_landed.emit(damage)
var skill_data := tuning_section("skill")
GameState.add_weapon_skill(str(get_weapon().get("id", "")), int(skill_data.get("gain_per_hit", 1)), int(skill_data.get("max", 100)))
if result == "parried" or _action_kind != "light_attack":
return
_combo_index += 1
_combo_window = float(tuning_section("combo").get("window_seconds", 0.45))
## Bewegt den Spieler während Seitenschritt/Rolle und beendet sie.
func _tick_dodge(delta: float) -> void:
var data := tuning_section(_action_kind)
_dodge_timer += delta
var duration := float(data.get("duration_seconds", 0.4)) / _agility_scale()
_player.velocity.x = _dodge_direction.x * float(data.get("speed", 8.0))
_player.velocity.z = _dodge_direction.z * float(data.get("speed", 8.0))
if _dodge_timer >= duration:
_action = ActionState.READY
_dodge_timer = 0.0
_apply_pending_weapon()
## Zählt die Blockdauer für das Parry-Fenster hoch.
func _tick_block(delta: float) -> void:
if _is_block_held:
_block_timer += delta
## Lässt Kombo- und Konter-Fenster ablaufen; ein verstrichenes
## Kombo-Fenster setzt die Kette zurück.
func _tick_windows(delta: float) -> void:
if _counter_window > 0.0:
_counter_window = maxf(_counter_window - delta, 0.0)
if _combo_window <= 0.0:
return
_combo_window = maxf(_combo_window - delta, 0.0)
if _combo_window == 0.0 and _action == ActionState.READY:
_combo_index = 0
_is_combo_queued = false
## Wandelt die Eingaberichtung in eine Weltrichtung; ohne Eingabe rollt
## Tyrveil nach vorn.
func _direction_from_input(input_dir: Vector2) -> Vector3:
if input_dir.length() < 0.2:
var forward: Vector3 = -_mesh.global_transform.basis.z
forward.y = 0.0
return forward.normalized()
var direction: Vector3 = _camera_pivot.global_transform.basis * Vector3(input_dir.x, 0.0, input_dir.y)
direction.y = 0.0
return direction.normalized()
## Tempo-Faktor aus Schnelligkeit (>1 = schneller, gedeckelt).
## Tempo-Faktor aus Schnelligkeit UND Rüstung (>1 = schneller): Die
## Rüstung ist die andere Hälfte des Trade-offs — Schutz kostet Tempo
## (CR 8e).
func _agility_scale() -> float:
var stats := tuning_section("stats")
var scale := 1.0 + minf(GameState.agility * float(stats.get("agility_speed_per_point", 0.006)), float(stats.get("agility_speed_max_bonus", 0.4)))
return scale * float(get_armor().get("speed_scale", 1.0))