From e66264852290a46900c870a6466788c5aa155910 Mon Sep 17 00:00:00 2001 From: danny Date: Mon, 20 Jul 2026 19:31:02 +0200 Subject: [PATCH] CR 8c: Kombo-Ketten + getrennter Waffenskill je Klasse MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 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 --- data/combat/combat_tuning.json | 19 ++- docs/CHANGEREQUESTS.md | 6 +- docs/CHANGEREQUESTS_DONE.md | 35 ++++++ docs/ROADMAP.md | 2 +- scripts/autoloads/game_state.gd | 24 ++++ scripts/gameplay/combat/player_combat.gd | 153 ++++++++++++++++++++++- 6 files changed, 226 insertions(+), 13 deletions(-) diff --git a/data/combat/combat_tuning.json b/data/combat/combat_tuning.json index 5a38e6b..49956bb 100644 --- a/data/combat/combat_tuning.json +++ b/data/combat/combat_tuning.json @@ -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 } } diff --git a/docs/CHANGEREQUESTS.md b/docs/CHANGEREQUESTS.md index 57ebfda..e1419c1 100644 --- a/docs/CHANGEREQUESTS.md +++ b/docs/CHANGEREQUESTS.md @@ -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; diff --git a/docs/CHANGEREQUESTS_DONE.md b/docs/CHANGEREQUESTS_DONE.md index 38e1c91..5497214 100644 --- a/docs/CHANGEREQUESTS_DONE.md +++ b/docs/CHANGEREQUESTS_DONE.md @@ -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 diff --git a/docs/ROADMAP.md b/docs/ROADMAP.md index 96d6015..9730f87 100644 --- a/docs/ROADMAP.md +++ b/docs/ROADMAP.md @@ -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 | diff --git a/scripts/autoloads/game_state.gd b/scripts/autoloads/game_state.gd index 448763c..4bc9ade 100644 --- a/scripts/autoloads/game_state.gd +++ b/scripts/autoloads/game_state.gd @@ -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))) diff --git a/scripts/gameplay/combat/player_combat.gd b/scripts/gameplay/combat/player_combat.gd index c0caeb0..e230af5 100644 --- a/scripts/gameplay/combat/player_combat.gd +++ b/scripts/gameplay/combat/player_combat.gd @@ -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: