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
|
|
@ -41,11 +41,28 @@
|
|||
"parry_window_seconds": 0.22,
|
||||
"parry_stagger_seconds": 1.1
|
||||
},
|
||||
"combo": {
|
||||
"window_seconds": 0.45,
|
||||
"links": [
|
||||
{ "id": "eroeffnung", "min_skill": 0, "damage_scale": 1.0, "windup_scale": 1.0 },
|
||||
{ "id": "folge", "min_skill": 20, "damage_scale": 1.0, "windup_scale": 0.5 },
|
||||
{ "id": "abschluss", "min_skill": 50, "damage_scale": 1.6, "windup_scale": 0.7 }
|
||||
]
|
||||
},
|
||||
"skill": {
|
||||
"gain_per_hit": 1,
|
||||
"max": 100,
|
||||
"stamina_discount_max": 0.3,
|
||||
"counter_window_seconds": 0.6,
|
||||
"counter_damage_scale": 1.8
|
||||
},
|
||||
"stats": {
|
||||
"strength_damage_per_point": 0.02,
|
||||
"agility_speed_per_point": 0.006,
|
||||
"agility_speed_max_bonus": 0.4,
|
||||
"intellect_parry_per_point": 0.004,
|
||||
"intellect_parry_max_bonus": 0.12
|
||||
"intellect_parry_max_bonus": 0.12,
|
||||
"intellect_counter_per_point": 0.006,
|
||||
"intellect_counter_max_bonus": 0.4
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -54,11 +54,7 @@
|
|||
### Sub-CRs (Reihenfolge = Bau-Track)
|
||||
- **8a — Kampf-Kern** ✅ erledigt (2026-07-19, siehe CHANGEREQUESTS_DONE).
|
||||
- **8b — Waffen-Framework** ✅ erledigt (2026-07-19, siehe CHANGEREQUESTS_DONE).
|
||||
- **8c — Kombo- & Waffenskill-System:** Angriffsketten je Klasse; **getrennter
|
||||
Skill pro Waffenart**, der Kombos/Optionen freischaltet und Ausdauerkosten senkt
|
||||
(**NICHT** den Rohschaden). *Akzeptanz:* min. eine Kombo pro Klasse; Skill einer
|
||||
Waffe wächst unabhängig von den anderen und ändert Kosten/Optionen, nicht die
|
||||
DPR; Verstand hilft beim Konter.
|
||||
- **8c — Kombo- & Waffenskill-System** ✅ erledigt (2026-07-19, siehe CHANGEREQUESTS_DONE).
|
||||
- **8d — Encounter-Umbau:** Sparring und Tag-9-Hinterhalt auf 8a–8c umstellen,
|
||||
ein bis zwei gesetzte Encounter-Zonen. *Akzeptanz:* Sparring nutzt das echte
|
||||
System statt des Timing-Duells; der Hinterhalt ist echter Kampf statt QTE;
|
||||
|
|
|
|||
|
|
@ -85,6 +85,41 @@ Gewichts-Summe + `randi_range`), damit das Feld tatsächlich wirkt statt nur
|
|||
dekorativ zu sein. Die zehn ursprünglichen erfundenen Siegelkräfte bleiben als
|
||||
Baseline (weight 10) erhalten.
|
||||
|
||||
## 2026-07-19 — CR 8c: Kombo- & Waffenskill-System (Welle 2, Sub-CR 3 von 5)
|
||||
|
||||
**Request:** Angriffsketten je Klasse; **getrennter Skill pro Waffenart**,
|
||||
der Kombos/Optionen freischaltet und Ausdauerkosten senkt (**NICHT** den
|
||||
Rohschaden). *Akzeptanz:* min. eine Kombo pro Klasse; Skill einer Waffe
|
||||
wächst unabhängig von den anderen und ändert Kosten/Optionen, nicht die
|
||||
DPR; Verstand hilft beim Konter.
|
||||
|
||||
**Umsetzung:**
|
||||
- **Kombo-Kette** (`combat_tuning.json` → `combo`): Eröffnung → Folge →
|
||||
Abschluss. Ein gelandeter Treffer öffnet ein 0,45-s-Eingabefenster;
|
||||
wer darin nachschlägt, hängt das nächste Glied an (Folge mit halbem
|
||||
Windup, Abschluss mit ×1,6 Schaden). Ein **Fehlschlag bricht die
|
||||
Kette** — Kombos sind kein Freifahrtschein. Die Kette ist für alle
|
||||
drei Klassen gleich aufgebaut und skaliert mit `cycle_scale`, damit
|
||||
die **DPR-Parität aus 8b unangetastet bleibt**.
|
||||
- **Waffenskill pro Klasse** (`GameState.weapon_skills`, save-persistent
|
||||
mit eigenem Signal): wächst +1 je gelandetem Treffer der geführten
|
||||
Waffe, gedeckelt bei 100. Er **schaltet Kettenglieder frei** (Folge ab
|
||||
20, Abschluss ab 50) und **senkt die Ausdauerkosten** (bis −30 %) —
|
||||
den Rohschaden rührt er nicht an.
|
||||
- **Konter (Verstand):** Ein gelungener Parry öffnet ein Konter-Fenster
|
||||
(0,6 s Basis, durch Verstand bis +0,4 s); ein Schlag darin trifft mit
|
||||
×1,8. Ergänzt die bereits in 8a bestehende Verstand-Kopplung aufs
|
||||
Parry-Fenster.
|
||||
|
||||
**Verifikation:** Sonde 18/18 grün — Skill startet bei 0, wächst pro
|
||||
Treffer, **Dolch- und Axt-Skill wachsen nachweislich unabhängig**,
|
||||
landet im Spielstand; bei Skill 0 nur die Eröffnung, bei Skill 100 die
|
||||
volle Kette; Ausdauerkosten 12,0 → 8,4 bei identischem Rohschaden
|
||||
(14 = 14); alle drei Klassen spielen die Kette „folge → abschluss";
|
||||
ohne Skill kein Folgeglied; Konter-Fenster 0,60 → 0,96 s durch Verstand
|
||||
und der Konter trifft 14 → 24. Boot-Checks Testarena, Hof,
|
||||
Sparringshalle, Hauptmenü, Dreschen fehlerfrei.
|
||||
|
||||
## 2026-07-19 — CR 8b: Waffen-Framework (Welle 2, Sub-CR 2 von 5)
|
||||
|
||||
**Request:** Dolch/Schwert/Axt, jederzeit wechselbar, **gleiche DPR** bei
|
||||
|
|
|
|||
|
|
@ -87,7 +87,7 @@ Greifen erst nach Dreschen + erstem Flug; brauchen die CR-6-Basis.
|
|||
| 5 | Staffel/Geschwader-Setup | 1 | erledigt (2026-07-19) |
|
||||
| 6 | Zweite Siegelkraft | 1 | erledigt (2026-07-19, latent; Ausspielung: Akt 3) |
|
||||
| 7 | Stehendes Gauntlet-Rad | — | erledigt (2026-07-16) |
|
||||
| 8 | Kampfsystem Action-RPG (8a–8e) | 2 | **8a + 8b erledigt** (2026-07-19); 8c–8e offen |
|
||||
| 8 | Kampfsystem Action-RPG (8a–8e) | 2 | **8a–8c erledigt** (2026-07-19); 8d + 8e offen |
|
||||
| 8-magie | Magie-Kampf | 4 (Akt 2) | offen |
|
||||
| 9 | Bindungs-Achse (Akt 2) | 4 | offen |
|
||||
| 10 | Drachenpflege (Akt 2) | 4 | offen |
|
||||
|
|
|
|||
|
|
@ -12,6 +12,7 @@ extends Node
|
|||
signal blade_heart_tone_changed(new_tone: int)
|
||||
signal relationship_changed(npc_id: String, new_value: int)
|
||||
signal faction_standing_changed(faction_id: String, new_value: int)
|
||||
signal weapon_skill_changed(weapon_id: String, new_value: int)
|
||||
|
||||
const STAT_MIN := 0
|
||||
const STAT_MAX := 100
|
||||
|
|
@ -41,6 +42,7 @@ var completed_dialogues: Dictionary = {}
|
|||
var story_flags: Dictionary = {}
|
||||
var faction_standings: Dictionary = {}
|
||||
var bound_dragon: Dictionary = {}
|
||||
var weapon_skills: Dictionary = {}
|
||||
var saved_scene_path := ""
|
||||
var lexicon_notes := ""
|
||||
|
||||
|
|
@ -57,6 +59,7 @@ func reset() -> void:
|
|||
story_flags.clear()
|
||||
faction_standings.clear()
|
||||
bound_dragon.clear()
|
||||
weapon_skills.clear()
|
||||
saved_scene_path = ""
|
||||
lexicon_notes = ""
|
||||
blade_heart_tone_changed.emit(blade_heart_tone)
|
||||
|
|
@ -167,6 +170,22 @@ func has_bound_dragon() -> bool:
|
|||
return not bound_dragon.is_empty()
|
||||
|
||||
|
||||
## Liefert den Waffenskill einer Waffenklasse (0, wenn nie geführt).
|
||||
## Jede Klasse wächst getrennt (CR 8c).
|
||||
func get_weapon_skill(weapon_id: String) -> int:
|
||||
return int(weapon_skills.get(weapon_id, 0))
|
||||
|
||||
|
||||
## Hebt den Waffenskill einer Klasse (geklemmt auf 0..maximum) und
|
||||
## meldet die Änderung.
|
||||
func add_weapon_skill(weapon_id: String, amount: int, maximum := 100) -> void:
|
||||
var new_value := clampi(get_weapon_skill(weapon_id) + amount, 0, maximum)
|
||||
if new_value == get_weapon_skill(weapon_id):
|
||||
return
|
||||
weapon_skills[weapon_id] = new_value
|
||||
weapon_skill_changed.emit(weapon_id, new_value)
|
||||
|
||||
|
||||
## Serialisiert den kompletten Zustand als Dictionary für das SaveSystem.
|
||||
## current_scene hält die Szene des Speicherzeitpunkts fest, damit
|
||||
## Fortsetzen dort weitermacht (z. B. bei den Drachen nach dem
|
||||
|
|
@ -187,6 +206,7 @@ func to_save_dict() -> Dictionary:
|
|||
"story_flags": story_flags.duplicate(),
|
||||
"faction_standings": faction_standings.duplicate(),
|
||||
"bound_dragon": bound_dragon.duplicate(),
|
||||
"weapon_skills": weapon_skills.duplicate(),
|
||||
"time_day": TimeSystem.day_count,
|
||||
"time_slot": TimeSystem.current_slot,
|
||||
"time_slot_used": TimeSystem.is_current_slot_used,
|
||||
|
|
@ -223,6 +243,10 @@ func apply_save_dict(data: Dictionary) -> void:
|
|||
var saved_dragon: Variant = data.get("bound_dragon", {})
|
||||
if saved_dragon is Dictionary:
|
||||
bound_dragon = saved_dragon.duplicate()
|
||||
weapon_skills.clear()
|
||||
var saved_skills: Dictionary = data.get("weapon_skills", {})
|
||||
for weapon_id in saved_skills:
|
||||
weapon_skills[String(weapon_id)] = int(saved_skills[weapon_id])
|
||||
saved_scene_path = str(data.get("current_scene", ""))
|
||||
lexicon_notes = str(data.get("lexicon_notes", ""))
|
||||
TimeSystem.apply_save_state(int(data.get("time_day", 1)), int(data.get("time_slot", 0)), bool(data.get("time_slot_used", false)))
|
||||
|
|
|
|||
|
|
@ -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