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. signal attack_landed(result: String, damage: int) signal attack_started(kind: String) signal dodge_started(has_iframes: bool) enum ActionState { READY, WINDUP, ACTIVE, RECOVERY, DODGING } const HITBOX_RANGE := 1.9 const HITBOX_RADIUS := 1.1 var is_encounter_active := false 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 @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 und startet inaktiv. 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)) reset_combat_values() set_physics_process(false) ## 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) if is_staggered(): return if Input.is_action_just_pressed("attack"): 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() ## 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). 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() 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(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 attack_started.emit(section) 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 := 1.0 / _agility_scale() _action_timer += delta match _action: ActionState.WINDUP: if _action_timer >= float(data.get("windup_seconds", 0.15)) * scale: _action = ActionState.ACTIVE _action_timer = 0.0 ActionState.ACTIVE: if not _has_hit_this_swing: _resolve_swing(data) if _action_timer >= float(data.get("active_seconds", 0.15)): _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 ## Sucht Ziele vor dem Spieler und teilt den Treffer aus; Kraft hebt den ## Schaden. func _resolve_swing(data: Dictionary) -> void: _has_hit_this_swing = true var stats := tuning_section("stats") var damage := int(round(float(data.get("base_damage", 10)) * (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() * HITBOX_RANGE 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) attack_landed.emit(result, damage) return attack_landed.emit("miss", damage) ## 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 ## Zählt die Blockdauer für das Parry-Fenster hoch. func _tick_block(delta: float) -> void: if _is_block_held: _block_timer += delta ## 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). func _agility_scale() -> float: var stats := tuning_section("stats") return 1.0 + minf(GameState.agility * float(stats.get("agility_speed_per_point", 0.006)), float(stats.get("agility_speed_max_bonus", 0.4)))