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()