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. ## ## 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. 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) enum ActionState { READY, WINDUP, ACTIVE, RECOVERY, DODGING } const WEAPONS_PATH := "res://data/combat/weapons.json" const HITBOX_RADIUS := 1.1 var is_encounter_active := false var _weapons: 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 @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. 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() reset_combat_values() set_physics_process(false) ## 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", ""))) ## 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) if is_staggered(): return if Input.is_action_just_pressed("weapon_switch"): cycle_weapon() 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)) * get_weapon_cycle_scale()): 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 := get_weapon_cycle_scale() / _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)) * 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 _apply_pending_weapon() ## 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) -> 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() 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) 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 _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 ## 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)))