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>
This commit is contained in:
parent
942672c4ad
commit
32f75a732b
15 changed files with 828 additions and 7 deletions
174
scripts/gameplay/combat/combat_actor.gd
Normal file
174
scripts/gameplay/combat/combat_actor.gd
Normal file
|
|
@ -0,0 +1,174 @@
|
|||
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()
|
||||
1
scripts/gameplay/combat/combat_actor.gd.uid
Normal file
1
scripts/gameplay/combat/combat_actor.gd.uid
Normal file
|
|
@ -0,0 +1 @@
|
|||
uid://vi0gkiwoijnr
|
||||
44
scripts/gameplay/combat/encounter_zone.gd
Normal file
44
scripts/gameplay/combat/encounter_zone.gd
Normal file
|
|
@ -0,0 +1,44 @@
|
|||
extends Area3D
|
||||
## Encounter-Zone (CR 8a, Reichweiten-Entscheidung Option B).
|
||||
##
|
||||
## Kampf gibt es nur in definierten Zonen — kein Welt-Sandbox, keine
|
||||
## roamenden Gegner auf dem Hof. Betritt der Spieler die Zone, schaltet
|
||||
## sie seinen PlayerCombat-Knoten scharf (Angriffe, Dodge, Block); beim
|
||||
## Verlassen wieder ab, damit Sprung, Slide und Klettern außerhalb
|
||||
## unberührt bleiben. Die Zone kennt ihre Gegner über die Gruppe
|
||||
## combat_actor in ihrer Szene — Sieg/Niederlage werten die
|
||||
## Encounter-Skripte darüber aus (8d).
|
||||
|
||||
signal encounter_started
|
||||
signal encounter_ended
|
||||
|
||||
|
||||
## Verbindet die Reichweiten-Signale.
|
||||
func _ready() -> void:
|
||||
body_entered.connect(_on_body_entered)
|
||||
body_exited.connect(_on_body_exited)
|
||||
|
||||
|
||||
## Schaltet den Kampf-Modus des Spielers scharf.
|
||||
func _on_body_entered(body: Node3D) -> void:
|
||||
var combat := _combat_of(body)
|
||||
if combat == null:
|
||||
return
|
||||
combat.set_encounter_active(true)
|
||||
encounter_started.emit()
|
||||
|
||||
|
||||
## Schaltet den Kampf-Modus wieder ab.
|
||||
func _on_body_exited(body: Node3D) -> void:
|
||||
var combat := _combat_of(body)
|
||||
if combat == null:
|
||||
return
|
||||
combat.set_encounter_active(false)
|
||||
encounter_ended.emit()
|
||||
|
||||
|
||||
## Liefert den PlayerCombat-Knoten eines Körpers (null, wenn keiner).
|
||||
func _combat_of(body: Node3D) -> Node:
|
||||
if not body.is_in_group("player"):
|
||||
return null
|
||||
return body.get_node_or_null("PlayerCombat")
|
||||
1
scripts/gameplay/combat/encounter_zone.gd.uid
Normal file
1
scripts/gameplay/combat/encounter_zone.gd.uid
Normal file
|
|
@ -0,0 +1 @@
|
|||
uid://br3djfvsdsjs8
|
||||
278
scripts/gameplay/combat/player_combat.gd
Normal file
278
scripts/gameplay/combat/player_combat.gd
Normal file
|
|
@ -0,0 +1,278 @@
|
|||
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)))
|
||||
1
scripts/gameplay/combat/player_combat.gd.uid
Normal file
1
scripts/gameplay/combat/player_combat.gd.uid
Normal file
|
|
@ -0,0 +1 @@
|
|||
uid://deioua7q7grsk
|
||||
102
scripts/gameplay/combat/training_dummy.gd
Normal file
102
scripts/gameplay/combat/training_dummy.gd
Normal file
|
|
@ -0,0 +1,102 @@
|
|||
extends CombatActor
|
||||
## Trainings-Gegner des Kampf-Kerns (CR 8a) — Node an einem Körper.
|
||||
##
|
||||
## Greybox-Sparringspartner zum Verifizieren der Grammatik: Er steht,
|
||||
## nimmt Treffer entgegen (Trefferpunkte über der Kapsel als Label) und
|
||||
## fährt in festem Rhythmus telegrafierte Angriffe, an denen sich
|
||||
## Ausweichen, Rollen, Blocken und Parieren üben lassen. Das Telegraph-
|
||||
## Fenster ist bewusst lang und sichtbar (Farbwechsel des Meshes) —
|
||||
## Lesbarkeit vor Härte. Reagiert auf Stagger (nach einem Parry steht er
|
||||
## offen) und meldet seinen Tod über das Basis-Signal.
|
||||
|
||||
const TELEGRAPH_SECONDS := 1.0
|
||||
const STRIKE_RANGE := 2.6
|
||||
const STRIKE_DAMAGE := 12
|
||||
const STRIKE_COOLDOWN := 2.2
|
||||
|
||||
var is_auto_attacking := true
|
||||
|
||||
var _cooldown := STRIKE_COOLDOWN
|
||||
var _telegraph_remaining := 0.0
|
||||
|
||||
@onready var _body: Node3D = get_parent() as Node3D
|
||||
@onready var _mesh: MeshInstance3D = _body.get_node_or_null("MeshInstance3D")
|
||||
@onready var _label: Label3D = _body.get_node_or_null("HealthLabel")
|
||||
|
||||
|
||||
## Setzt die Kampfwerte und meldet den Dummy als Ziel an.
|
||||
func _ready() -> void:
|
||||
add_to_group("combat_actor")
|
||||
max_health = 120
|
||||
max_stamina = 100.0
|
||||
poise = 40
|
||||
reset_combat_values()
|
||||
health_changed.connect(_on_health_changed)
|
||||
_update_label()
|
||||
|
||||
|
||||
## Treibt Telegraph und Schlagrhythmus voran.
|
||||
func _physics_process(delta: float) -> void:
|
||||
tick_combat(delta)
|
||||
if not is_alive() or not is_auto_attacking or is_staggered():
|
||||
_set_telegraph(false)
|
||||
return
|
||||
if _telegraph_remaining > 0.0:
|
||||
_telegraph_remaining -= delta
|
||||
if _telegraph_remaining <= 0.0:
|
||||
_resolve_strike()
|
||||
return
|
||||
_cooldown -= delta
|
||||
if _cooldown <= 0.0:
|
||||
_begin_telegraph()
|
||||
|
||||
|
||||
## Startet einen sichtbar angekündigten Schlag.
|
||||
func _begin_telegraph() -> void:
|
||||
_telegraph_remaining = TELEGRAPH_SECONDS
|
||||
_set_telegraph(true)
|
||||
|
||||
|
||||
## Führt den Schlag aus, wenn der Spieler in Reichweite steht.
|
||||
func _resolve_strike() -> void:
|
||||
_set_telegraph(false)
|
||||
_cooldown = STRIKE_COOLDOWN
|
||||
var player := get_tree().get_first_node_in_group("player") as Node3D
|
||||
if player == null or _body == null:
|
||||
return
|
||||
if player.global_position.distance_to(_body.global_position) > STRIKE_RANGE:
|
||||
return
|
||||
var combat := player.get_node_or_null("PlayerCombat") as CombatActor
|
||||
if combat != null:
|
||||
combat.take_hit(STRIKE_DAMAGE, false, self)
|
||||
|
||||
|
||||
## Erzwingt einen sofortigen Schlag (für Sonden und gescriptete Beats).
|
||||
func force_strike() -> void:
|
||||
_telegraph_remaining = 0.0
|
||||
_resolve_strike()
|
||||
|
||||
|
||||
## Meldet, ob der Dummy gerade einen Schlag ankündigt.
|
||||
func is_telegraphing() -> bool:
|
||||
return _telegraph_remaining > 0.0
|
||||
|
||||
|
||||
## Färbt das Mesh während des Telegraphs auffällig ein.
|
||||
func _set_telegraph(is_active: bool) -> void:
|
||||
if _mesh == null:
|
||||
return
|
||||
var material := StandardMaterial3D.new()
|
||||
material.albedo_color = Color(0.85, 0.35, 0.3) if is_active else Color(0.45, 0.45, 0.5)
|
||||
_mesh.material_override = material
|
||||
|
||||
|
||||
## Hält das Trefferpunkte-Label aktuell.
|
||||
func _on_health_changed(_current: int, _maximum: int) -> void:
|
||||
_update_label()
|
||||
|
||||
|
||||
## Schreibt die Trefferpunkte über die Kapsel.
|
||||
func _update_label() -> void:
|
||||
if _label != null:
|
||||
_label.text = "Dummy %d/%d" % [health, max_health]
|
||||
1
scripts/gameplay/combat/training_dummy.gd.uid
Normal file
1
scripts/gameplay/combat/training_dummy.gd.uid
Normal file
|
|
@ -0,0 +1 @@
|
|||
uid://c5thw4lpgdghd
|
||||
Loading…
Add table
Add a link
Reference in a new issue