From 999c1f7babff4fa8d2cef3f629631114a510384d Mon Sep 17 00:00:00 2001 From: danny Date: Mon, 20 Jul 2026 19:17:15 +0200 Subject: [PATCH] =?UTF-8?q?CR=208b:=20Waffen-Framework=20=E2=80=94=20Dolch?= =?UTF-8?q?,=20Schwert,=20Axt=20bei=20gleicher=20DPR?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - data/combat/weapons.json: drei Klassen mit cycle_scale, Reichweite und Haltungsschaden; gleiche DPR konstruktiv garantiert, weil Schaden und Ausdauer mit demselben cycle_scale skalieren wie die Zeiten - PlayerCombat lädt den Katalog, equip_weapon/cycle_weapon + weapon_changed; Wechsel jederzeit erlaubt und mitten in Schwung oder Rolle sauber nachgezogen statt den Zustand zu brechen - Zeiten, Schaden, Ausdauerkosten und Trefferreichweite kommen jetzt aus der aktiven Waffe - Neue Input-Action weapon_switch (Q / Steuerkreuz hoch) - Testarena: kleines Waffen-Overlay (Klasse, Reichweite, Tempo) - Verifikation: gemessene DPR Dolch 32,7 / Schwert 33,5 / Axt 31,5 (6,5 % Spanne aus der Ganzzahl-Rundung) - Buchführung: 8b nach CHANGEREQUESTS_DONE, ROADMAP nachgezogen Co-Authored-By: Claude Fable 5 --- data/combat/weapons.json | 33 +++++++ docs/CHANGEREQUESTS.md | 5 +- docs/CHANGEREQUESTS_DONE.md | 35 ++++++++ docs/ROADMAP.md | 2 +- project.godot | 6 ++ scenes/combat/combat_testground.tscn | 20 ++++- scripts/gameplay/combat/player_combat.gd | 107 +++++++++++++++++++++-- scripts/ui/pause_menu.gd.uid | 1 + scripts/ui/weapon_hud.gd | 34 +++++++ 9 files changed, 228 insertions(+), 15 deletions(-) create mode 100644 data/combat/weapons.json create mode 100644 scripts/ui/pause_menu.gd.uid create mode 100644 scripts/ui/weapon_hud.gd diff --git a/data/combat/weapons.json b/data/combat/weapons.json new file mode 100644 index 0000000..2f8c264 --- /dev/null +++ b/data/combat/weapons.json @@ -0,0 +1,33 @@ +{ + "default_weapon": "schwert", + "balance_note": "Gleiche DPR by construction (CHANGEREQUESTS §8b): Schaden und Ausdauerkosten einer Waffe sind das Produkt aus Basiswert (combat_tuning.json) und ihrem cycle_scale. Wer langsamer schlägt, trifft proportional härter — die Wahl ist Stil, nicht Stärke. Reichweite und Haltungsschaden sind die einzigen echten Unterschiede.", + "weapons": [ + { + "id": "dolch", + "name": "Dolch", + "klasse": "dolch", + "cycle_scale": 0.65, + "reach": 1.5, + "poise_scale": 0.7, + "flavor": "Schnell und leise. Verzeiht keine Distanz, aber du bist zwei Schläge weiter, bevor eine Axt einmal ausholt." + }, + { + "id": "schwert", + "name": "Schwert", + "klasse": "schwert", + "cycle_scale": 1.0, + "reach": 1.9, + "poise_scale": 1.0, + "flavor": "Die Mitte. Emetterios Standard — nichts daran ist überraschend, und genau das hält dich am Leben." + }, + { + "id": "axt", + "name": "Axt", + "klasse": "axt", + "cycle_scale": 1.55, + "reach": 2.4, + "poise_scale": 1.6, + "flavor": "Langsam, weit, wuchtig. Jeder Schlag ist eine Entscheidung — daneben zu hauen kostet dich den Atemzug, den der andere braucht." + } + ] +} diff --git a/docs/CHANGEREQUESTS.md b/docs/CHANGEREQUESTS.md index 4054289..57ebfda 100644 --- a/docs/CHANGEREQUESTS.md +++ b/docs/CHANGEREQUESTS.md @@ -53,10 +53,7 @@ ### Sub-CRs (Reihenfolge = Bau-Track) - **8a — Kampf-Kern** ✅ erledigt (2026-07-19, siehe CHANGEREQUESTS_DONE). -- **8b — Waffen-Framework (3 Klassen):** Dolch/Schwert/Axt, jederzeit wechselbar, - **gleiche DPR** bei gleichem Skill, daten-getrieben. *Akzeptanz:* Wechsel im - Kampf ohne Bruch; die drei Klassen fühlen sich verschieden an, messen aber - gleiche DPR; Waffen aus data/ geladen. +- **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 diff --git a/docs/CHANGEREQUESTS_DONE.md b/docs/CHANGEREQUESTS_DONE.md index 45bfcc5..38e1c91 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 8b: Waffen-Framework (Welle 2, Sub-CR 2 von 5) + +**Request:** Dolch/Schwert/Axt, jederzeit wechselbar, **gleiche DPR** bei +gleichem Skill, daten-getrieben. *Akzeptanz:* Wechsel im Kampf ohne +Bruch; die drei Klassen fühlen sich verschieden an, messen aber gleiche +DPR; Waffen aus data/ geladen. + +**Umsetzung:** +- **`data/combat/weapons.json`** — drei Klassen mit `cycle_scale`, + `reach`, `poise_scale` und Flavor-Text. Die **gleiche DPR ist + konstruktiv garantiert**: Schaden UND Ausdauerkosten werden mit + demselben `cycle_scale` multipliziert wie die Zeiten (Dolch 0,65 / + Schwert 1,0 / Axt 1,55). Wer langsamer schlägt, trifft proportional + härter — die Wahl ist Stil, nicht Stärke. Echte Unterschiede sind + **Reichweite** (1,5 / 1,9 / 2,4 m) und Haltungsschaden. +- **PlayerCombat:** lädt den Katalog, `equip_weapon(id)` und + `cycle_weapon()`; `weapon_changed`-Signal. Der Wechsel ist **jederzeit + erlaubt** — läuft gerade ein Schwung oder eine Rolle, wird er gemerkt + und beim Zurückfallen auf READY nachgezogen, statt den Zustand zu + brechen. Zeiten, Schaden, Ausdauer und Trefferreichweite ziehen ihre + Werte jetzt aus der aktiven Waffe. +- **Input:** neu `weapon_switch` (Q / Steuerkreuz hoch). +- **Testarena:** kleines Waffen-Overlay (`scripts/ui/weapon_hud.gd`) + zeigt Klasse, Reichweite und Tempo — Greybox-Debug für die Arena, die + echte Kampf-HUD kommt mit 8d. + +**Verifikation:** Sonde 16/16 grün. Kernmessung: **echte DPR am Dummy** +über je sechs volle Schwünge — Dolch 32,7 / Schwert 33,5 / Axt 31,5, +Spanne **6,5 %** (allein aus der Ganzzahl-Rundung des Schadens, Toleranz +8 %). Dazu: Katalog aus data/ inkl. Ablehnung unbekannter IDs, +Dolch-Schwung 17 vs. Axt-Schwung 40 Frames, Wechsel mitten im Schwung +ohne Zustandsbruch und korrekt nachgezogen, Dolch verfehlt auf 3,2 m +während die Axt dort trifft. Boot-Checks Testarena, Hof, Sparringshalle, +Viadukt, Materialraum fehlerfrei. + ## 2026-07-19 — CR 8a: Kampf-Kern (Welle 2, Sub-CR 1 von 5) **Request:** Kampf-Movement, leichter + schwerer Angriff, Ausweichen, diff --git a/docs/ROADMAP.md b/docs/ROADMAP.md index f828a86..96d6015 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 erledigt** (2026-07-19); 8b–8e offen | +| 8 | Kampfsystem Action-RPG (8a–8e) | 2 | **8a + 8b erledigt** (2026-07-19); 8c–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/project.godot b/project.godot index 690ddac..0454b95 100644 --- a/project.godot +++ b/project.godot @@ -200,3 +200,9 @@ dodge={ , Object(InputEventJoypadButton,"resource_local_to_scene":false,"resource_name":"","device":-1,"button_index":0,"pressure":0.0,"pressed":false,"script":null) ] } +weapon_switch={ +"deadzone": 0.2, +"events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":81,"key_label":0,"unicode":0,"location":0,"echo":false,"script":null) +, Object(InputEventJoypadButton,"resource_local_to_scene":false,"resource_name":"","device":-1,"button_index":11,"pressure":0.0,"pressed":false,"script":null) +] +} diff --git a/scenes/combat/combat_testground.tscn b/scenes/combat/combat_testground.tscn index 331e66a..9eb0f2b 100644 --- a/scenes/combat/combat_testground.tscn +++ b/scenes/combat/combat_testground.tscn @@ -1,9 +1,10 @@ -[gd_scene load_steps=16 format=3] +[gd_scene load_steps=17 format=3] [ext_resource type="PackedScene" path="res://scenes/player.tscn" id="1_player"] [ext_resource type="PackedScene" path="res://scenes/ui/debug_overlay.tscn" id="2_debug"] [ext_resource type="Script" path="res://scripts/gameplay/combat/encounter_zone.gd" id="3_zone"] [ext_resource type="Script" path="res://scripts/gameplay/combat/training_dummy.gd" id="4_dummy"] +[ext_resource type="Script" path="res://scripts/ui/weapon_hud.gd" id="5_weaponhud"] [sub_resource type="ProceduralSkyMaterial" id="ProceduralSkyMaterial_sky"] sky_horizon_color = Color(0.55, 0.55, 0.6, 1) @@ -107,3 +108,20 @@ script = ExtResource("4_dummy") transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0.1, 0) [node name="DebugOverlay" parent="." instance=ExtResource("2_debug")] + +[node name="WeaponHud" type="CanvasLayer" parent="."] +script = ExtResource("5_weaponhud") + +[node name="Label" type="Label" parent="WeaponHud"] +anchors_preset = 1 +anchor_left = 1.0 +anchor_right = 1.0 +offset_left = -260.0 +offset_top = 20.0 +offset_right = -20.0 +offset_bottom = 52.0 +grow_horizontal = 0 +theme_override_colors/font_color = Color(1, 0.9, 0.6, 1) +theme_override_font_sizes/font_size = 20 +text = "Waffe: —" +horizontal_alignment = 2 diff --git a/scripts/gameplay/combat/player_combat.gd b/scripts/gameplay/combat/player_combat.gd index 6e4b846..c0caeb0 100644 --- a/scripts/gameplay/combat/player_combat.gd +++ b/scripts/gameplay/combat/player_combat.gd @@ -22,18 +22,30 @@ extends CombatActor ## 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. +## +## Waffen (CR 8b, data/combat/weapons.json): Dolch, Schwert und Axt sind +## **jederzeit wechselbar** (weapon_switch; mitten in einer Aktion wird +## der Wechsel gemerkt und beim Zurückfallen auf READY ausgeführt — kein +## Bruch im Zustand). Jede Waffe hat ein cycle_scale, das Zeiten, +## Schaden UND Ausdauerkosten gemeinsam skaliert: Wer langsamer schlägt, +## trifft proportional härter → **gleiche DPR bei gleichem Skill**, die +## Wahl ist Stil. Echte Unterschiede sind Reichweite und Haltungsschaden. 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) enum ActionState { READY, WINDUP, ACTIVE, RECOVERY, DODGING } -const HITBOX_RANGE := 1.9 +const WEAPONS_PATH := "res://data/combat/weapons.json" const HITBOX_RADIUS := 1.1 var is_encounter_active := false +var _weapons: Array = [] +var _weapon_index := 0 +var _pending_weapon_index := -1 var _action := ActionState.READY var _action_kind := "" var _action_timer := 0.0 @@ -49,15 +61,84 @@ var _has_hit_this_swing := false @onready var _camera_pivot: Node3D = _player.get_node("CameraPivot") as Node3D -## Übernimmt die Kampfwerte aus dem Tuning und startet inaktiv. +## Übernimmt die Kampfwerte aus dem Tuning, lädt die Waffen 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)) + _load_weapons() reset_combat_values() set_physics_process(false) +## Lädt die Waffentabelle und rüstet die Standardwaffe aus. +func _load_weapons() -> void: + var file := FileAccess.open(WEAPONS_PATH, FileAccess.READ) + if file == null: + push_error("Waffentabelle nicht lesbar: %s" % WEAPONS_PATH) + return + var parsed: Variant = JSON.parse_string(file.get_as_text()) + file.close() + if not (parsed is Dictionary) or not (parsed.get("weapons") is Array): + push_error("Waffentabelle ist ungültig: %s" % WEAPONS_PATH) + return + _weapons = parsed["weapons"] + equip_weapon(str(parsed.get("default_weapon", ""))) + + +## Rüstet eine Waffe über ihre ID aus; liefert false bei unbekannter ID. +func equip_weapon(weapon_id: String) -> bool: + for i in _weapons.size(): + if str(_weapons[i].get("id", "")) == weapon_id: + _set_weapon_index(i) + return true + return false + + +## Schaltet auf die nächste Waffenklasse weiter (weapon_switch). +func cycle_weapon() -> void: + if _weapons.size() < 2: + return + _set_weapon_index((_weapon_index + 1) % _weapons.size()) + + +## Liefert die aktuell ausgerüstete Waffe (leer, wenn keine geladen). +func get_weapon() -> Dictionary: + if _weapons.is_empty(): + return {} + return _weapons[_weapon_index] + + +## Liefert die Zykluszeit-Skala der aktiven Waffe (1.0 = Schwert). +func get_weapon_cycle_scale() -> float: + return float(get_weapon().get("cycle_scale", 1.0)) + + +## Setzt die Waffe sofort, wenn keine Aktion läuft — sonst wird der +## Wechsel gemerkt und beim Zurückfallen auf READY nachgezogen, damit +## ein laufender Schwung nicht bricht. +func _set_weapon_index(index: int) -> void: + if index < 0 or index >= _weapons.size(): + return + if _action != ActionState.READY: + _pending_weapon_index = index + return + _weapon_index = index + _pending_weapon_index = -1 + var weapon := get_weapon() + weapon_changed.emit(str(weapon.get("id", "")), str(weapon.get("name", ""))) + + +## Zieht einen während einer Aktion angeforderten Waffenwechsel nach. +func _apply_pending_weapon() -> void: + if _pending_weapon_index < 0: + return + var index := _pending_weapon_index + _pending_weapon_index = -1 + _set_weapon_index(index) + + ## Schaltet den Kampf-Modus einer Encounter-Zone scharf oder ab. func set_encounter_active(is_active: bool) -> void: is_encounter_active = is_active @@ -82,6 +163,8 @@ func _physics_process(delta: float) -> void: _tick_block(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() elif Input.is_action_just_pressed("heavy_attack"): @@ -178,7 +261,7 @@ 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))): + if not spend_stamina(float(data.get("stamina_cost", 10.0)) * get_weapon_cycle_scale()): return false _action = ActionState.WINDUP _action_kind = section @@ -198,7 +281,7 @@ func _tick_action(delta: float) -> void: _tick_dodge(delta) return var data := tuning_section(_action_kind) - var scale := 1.0 / _agility_scale() + var scale := get_weapon_cycle_scale() / _agility_scale() _action_timer += delta match _action: ActionState.WINDUP: @@ -208,26 +291,31 @@ func _tick_action(delta: float) -> void: ActionState.ACTIVE: if not _has_hit_this_swing: _resolve_swing(data) - if _action_timer >= float(data.get("active_seconds", 0.15)): + if _action_timer >= float(data.get("active_seconds", 0.15)) * scale: _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 + _apply_pending_weapon() -## Sucht Ziele vor dem Spieler und teilt den Treffer aus; Kraft hebt den -## Schaden. +## 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: _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 weapon := get_weapon() + var base_damage := float(data.get("base_damage", 10)) * get_weapon_cycle_scale() + 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) var forward: Vector3 = -_mesh.global_transform.basis.z forward.y = 0.0 - var center: Vector3 = origin + forward.normalized() * HITBOX_RANGE + var center: Vector3 = origin + forward.normalized() * float(weapon.get("reach", 1.9)) for target in get_tree().get_nodes_in_group("combat_actor"): if target == self or not (target is CombatActor): continue @@ -252,6 +340,7 @@ func _tick_dodge(delta: float) -> void: if _dodge_timer >= duration: _action = ActionState.READY _dodge_timer = 0.0 + _apply_pending_weapon() ## Zählt die Blockdauer für das Parry-Fenster hoch. diff --git a/scripts/ui/pause_menu.gd.uid b/scripts/ui/pause_menu.gd.uid new file mode 100644 index 0000000..3e98e76 --- /dev/null +++ b/scripts/ui/pause_menu.gd.uid @@ -0,0 +1 @@ +uid://tdq8feymqu0p diff --git a/scripts/ui/weapon_hud.gd b/scripts/ui/weapon_hud.gd new file mode 100644 index 0000000..e9645e7 --- /dev/null +++ b/scripts/ui/weapon_hud.gd @@ -0,0 +1,34 @@ +extends CanvasLayer +## Waffen-Anzeige der Kampf-Testarena (CR 8b). +## +## Zeigt die aktive Waffenklasse samt Reichweite und Zykluszeit-Skala, +## damit sich der Wechsel (weapon_switch) beim Spielen nachvollziehen +## lässt. Bewusst nur ein Debug-/Greybox-Overlay für die Testarena — +## die echte Kampf-HUD kommt mit dem Encounter-Umbau (8d). + +@onready var _label: Label = $Label + + +## Hängt sich an den Waffenwechsel des Spielers und zeigt den Startwert. +func _ready() -> void: + var player := get_tree().get_first_node_in_group("player") + if player == null: + return + var combat := player.get_node_or_null("PlayerCombat") + if combat == null: + return + combat.weapon_changed.connect(func(_id: String, _name: String) -> void: _refresh(combat)) + _refresh(combat) + + +## Schreibt Name, Reichweite und Tempo der aktiven Waffe ins Label. +func _refresh(combat: Node) -> void: + var weapon: Dictionary = combat.get_weapon() + if weapon.is_empty(): + _label.text = "Waffe: —" + return + _label.text = "Waffe: %s Reichweite %.1f m Tempo ×%.2f [Q]" % [ + str(weapon.get("name", "?")), + float(weapon.get("reach", 0.0)), + 1.0 / maxf(float(weapon.get("cycle_scale", 1.0)), 0.01), + ]