CR 8c: Kombo-Ketten + getrennter Waffenskill je Klasse
- Kombo-Kette Eröffnung → Folge → Abschluss mit 0,45-s-Eingabefenster; Folge hat halben Windup, Abschluss ×1,6 Schaden, ein Fehlschlag bricht die Kette; für alle Klassen gleich aufgebaut und mit cycle_scale skaliert, damit die DPR-Parität aus 8b erhalten bleibt - Waffenskill pro Klasse in GameState (save-persistent, eigenes Signal): +1 je Treffer, schaltet Folge ab 20 und Abschluss ab 50 frei und senkt die Ausdauerkosten um bis zu 30 % — der Rohschaden bleibt unberührt - Konter: gelungener Parry öffnet ein Fenster (0,6 s + bis 0,4 s durch Verstand), ein Schlag darin trifft mit ×1,8 - Verifikation: Skill 12,0 → 8,4 Ausdauer bei identischem Schaden 14=14; Dolch- und Axt-Skill wachsen unabhängig; Konter 14 → 24 - Buchführung: 8c nach CHANGEREQUESTS_DONE, ROADMAP nachgezogen Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
This commit is contained in:
parent
999c1f7bab
commit
e662648522
6 changed files with 226 additions and 13 deletions
|
|
@ -31,10 +31,24 @@ extends CombatActor
|
|||
## 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 }
|
||||
|
||||
|
|
@ -55,6 +69,10 @@ 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
|
||||
|
|
@ -69,9 +87,51 @@ func _ready() -> void:
|
|||
max_stamina = float(player_data.get("max_stamina", 100.0))
|
||||
_load_weapons()
|
||||
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)
|
||||
|
|
@ -161,12 +221,16 @@ func _physics_process(delta: float) -> void:
|
|||
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"):
|
||||
try_light_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"):
|
||||
|
|
@ -261,17 +325,46 @@ 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()):
|
||||
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)
|
||||
|
||||
|
||||
## 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:
|
||||
|
|
@ -282,15 +375,16 @@ func _tick_action(delta: float) -> void:
|
|||
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:
|
||||
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)
|
||||
_resolve_swing(data, link)
|
||||
if _action_timer >= float(data.get("active_seconds", 0.15)) * scale:
|
||||
_action = ActionState.RECOVERY
|
||||
_action_timer = 0.0
|
||||
|
|
@ -298,18 +392,35 @@ func _tick_action(delta: float) -> void:
|
|||
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) -> void:
|
||||
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()
|
||||
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)
|
||||
|
|
@ -325,11 +436,28 @@ func _resolve_swing(data: Dictionary) -> void:
|
|||
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)
|
||||
|
|
@ -349,6 +477,19 @@ func _tick_block(delta: float) -> void:
|
|||
_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:
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue