diff --git a/data/combat/combat_tuning.json b/data/combat/combat_tuning.json new file mode 100644 index 0000000..5a38e6b --- /dev/null +++ b/data/combat/combat_tuning.json @@ -0,0 +1,51 @@ +{ + "player": { + "max_health": 100, + "max_stamina": 100, + "stamina_regen_per_second": 18.0, + "stamina_regen_delay": 0.6 + }, + "light_attack": { + "base_damage": 8, + "stamina_cost": 12.0, + "windup_seconds": 0.12, + "active_seconds": 0.14, + "recovery_seconds": 0.24, + "poise_damage": 8 + }, + "heavy_attack": { + "base_damage": 20, + "stamina_cost": 28.0, + "windup_seconds": 0.42, + "active_seconds": 0.18, + "recovery_seconds": 0.5, + "poise_damage": 30, + "breaks_block": true + }, + "sidestep": { + "stamina_cost": 10.0, + "duration_seconds": 0.22, + "speed": 9.0, + "has_iframes": false + }, + "dodge_roll": { + "stamina_cost": 22.0, + "duration_seconds": 0.5, + "speed": 8.0, + "iframe_start": 0.06, + "iframe_end": 0.34 + }, + "block": { + "damage_multiplier": 0.2, + "stamina_cost_per_hit": 14.0, + "parry_window_seconds": 0.22, + "parry_stagger_seconds": 1.1 + }, + "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 + } +} diff --git a/docs/CHANGEREQUESTS.md b/docs/CHANGEREQUESTS.md index 91bf7e6..4054289 100644 --- a/docs/CHANGEREQUESTS.md +++ b/docs/CHANGEREQUESTS.md @@ -52,11 +52,7 @@ cast). Greybox-First, daten-getrieben. ### Sub-CRs (Reihenfolge = Bau-Track) -- **8a — Kampf-Kern (frei, waffenlos/generisch):** Kampf-Movement, leichter + - schwerer Angriff, Ausweichen, Dodgen (i-Frames), Block/Parry; Stats-Kopplung. - *Akzeptanz:* freie Bewegung im Encounter; Dummy mit leicht/schwer treffen; per - Seitenschritt ausweichen UND per Rolle mit i-Fenster durch einen Angriff dodgen; - blocken/parieren; Kraft/Schnelligkeit wirken messbar. +- **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 diff --git a/docs/CHANGEREQUESTS_DONE.md b/docs/CHANGEREQUESTS_DONE.md index 0630c54..45bfcc5 100644 --- a/docs/CHANGEREQUESTS_DONE.md +++ b/docs/CHANGEREQUESTS_DONE.md @@ -85,6 +85,53 @@ 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 8a: Kampf-Kern (Welle 2, Sub-CR 1 von 5) + +**Request:** Kampf-Movement, leichter + schwerer Angriff, Ausweichen, +Dodgen (i-Frames), Block/Parry, Stats-Kopplung. *Akzeptanz:* freie +Bewegung im Encounter; Dummy mit leicht/schwer treffen; per Seitenschritt +ausweichen UND per Rolle mit i-Fenster durch einen Angriff dodgen; +blocken/parieren; Kraft/Schnelligkeit wirken messbar. + +**Umsetzung:** +- **`CombatActor`** (`scripts/gameplay/combat/combat_actor.gd`): gemeinsame + Basis mit Trefferpunkten, Ausdauer (Regeneration nach kurzer Pause), + Haltung und Stagger. `take_hit()` wertet in fester Reihenfolge: + i-Frames → Parry (Angreifer wird gestaggert) → Block (stark + reduzierter Schaden, kostet Ausdauer) → voller Schaden; schwere + Angriffe umgehen Block und Parry. +- **`PlayerCombat`** (Node in player.tscn): legt die Grammatik über die + **unveränderte** Bewegung von player.gd — leichter Angriff (schnell, + günstig), schwerer Angriff (langer Windup, bricht Blocks), + **Seitenschritt ohne i-Frames** (Positionierung, billig) vs. + **Dodge-Rolle mit i-Fenster** (teurer), Block mit **Parry-Fenster**. + Jede Aktion läuft Windup → Active → Recovery und trifft pro Schwung + genau einmal. +- **Stats-Kopplung:** Kraft hebt den Schaden (0,02/Punkt — bewusst + moderat, Feinbalancing bleibt 8e), Schnelligkeit verkürzt Windup und + Recovery und verlängert die i-Frames (gedeckelt bei +40 %), Verstand + weitet das Parry-Fenster (gedeckelt). +- **Encounter-Zonen (Option B):** `EncounterZone` schaltet den + Kampf-Modus beim Betreten scharf und beim Verlassen wieder ab — + außerhalb bleiben Sprung, Slide und Klettern unberührt, es gibt + **keine roamenden Gegner**. +- **Trainings-Dummy + Greybox-Testarena** (`scenes/combat/combat_testground.tscn`): + Gegner mit sichtbar telegrafiertem Schlag (Farbwechsel) und + Trefferpunkte-Label zum Üben von Ausweichen, Rollen, Blocken, Parieren. +- **Input (SPEC §9 erweitert):** neu `heavy_attack` (F / L2) und `dodge` + (Leertaste / Ⓐ✕) — kontextgebunden wie die bestehenden Mehrfach- + Belegungen des Projekts. `weapon_switch` folgt mit 8b. +- Alle Zahlen daten-getrieben in **`data/combat/combat_tuning.json`**. + +**Verifikation:** Sonde 22/22 grün (Zone schaltet scharf/ab; leichter +und schwerer Treffer inkl. Schadensunterschied; Ausdauer-Sperre; +Seitenschritt ohne und Rolle mit i-Frames inkl. durchgehendem Treffer; +Parry ohne Schaden + Angreifer-Stagger; Block reduziert, schwerer +Angriff bricht durch; Kraft 8→21 Schaden, Schnelligkeit 28→26 Frames). +Boot-Checks Testarena, Hof, Sparringshalle, Viadukt, Gauntlet, +Materialraum fehlerfrei. **Sparring und Tag-9 laufen noch auf dem alten +System — der Umbau ist 8d.** + ## 2026-07-19 — CR 14 + CR 15: Aula-Bau, Schlafsaal-Tür-Fix, Hub-Layout (Welle 1 abgeschlossen) **Request (CR 14):** Verwaiste Klassenraum-Tür im Erstjahr-Schlafsaal diff --git a/docs/ROADMAP.md b/docs/ROADMAP.md index 029faa6..f828a86 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 | Scope ✅; **Bau offen** | +| 8 | Kampfsystem Action-RPG (8a–8e) | 2 | **8a erledigt** (2026-07-19); 8b–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 8760468..690ddac 100644 --- a/project.godot +++ b/project.godot @@ -188,3 +188,15 @@ look_down={ "events": [Object(InputEventJoypadMotion,"resource_local_to_scene":false,"resource_name":"","device":-1,"axis":3,"axis_value":1.0,"script":null) ] } +heavy_attack={ +"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":70,"key_label":0,"unicode":0,"location":0,"echo":false,"script":null) +, Object(InputEventJoypadMotion,"resource_local_to_scene":false,"resource_name":"","device":-1,"axis":4,"axis_value":1.0,"script":null) +] +} +dodge={ +"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":32,"key_label":0,"unicode":0,"location":0,"echo":false,"script":null) +, Object(InputEventJoypadButton,"resource_local_to_scene":false,"resource_name":"","device":-1,"button_index":0,"pressure":0.0,"pressed":false,"script":null) +] +} diff --git a/scenes/combat/combat_testground.tscn b/scenes/combat/combat_testground.tscn new file mode 100644 index 0000000..331e66a --- /dev/null +++ b/scenes/combat/combat_testground.tscn @@ -0,0 +1,109 @@ +[gd_scene load_steps=16 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"] + +[sub_resource type="ProceduralSkyMaterial" id="ProceduralSkyMaterial_sky"] +sky_horizon_color = Color(0.55, 0.55, 0.6, 1) +ground_horizon_color = Color(0.55, 0.55, 0.6, 1) + +[sub_resource type="Sky" id="Sky_sky"] +sky_material = SubResource("ProceduralSkyMaterial_sky") + +[sub_resource type="Environment" id="Environment_env"] +background_mode = 2 +sky = SubResource("Sky_sky") +tonemap_mode = 2 + +[sub_resource type="StandardMaterial3D" id="StandardMaterial3D_floor"] +albedo_color = Color(0.4, 0.38, 0.36, 1) + +[sub_resource type="BoxShape3D" id="BoxShape3D_floor"] +size = Vector3(24, 1, 24) + +[sub_resource type="BoxMesh" id="BoxMesh_floor"] +material = SubResource("StandardMaterial3D_floor") +size = Vector3(24, 1, 24) + +[sub_resource type="StandardMaterial3D" id="StandardMaterial3D_mat"] +albedo_color = Color(0.55, 0.3, 0.25, 1) + +[sub_resource type="CylinderMesh" id="CylinderMesh_mat"] +material = SubResource("StandardMaterial3D_mat") +top_radius = 7.0 +bottom_radius = 7.0 +height = 0.08 + +[sub_resource type="CapsuleShape3D" id="CapsuleShape3D_dummy"] +radius = 0.45 +height = 1.9 + +[sub_resource type="StandardMaterial3D" id="StandardMaterial3D_dummy"] +albedo_color = Color(0.45, 0.45, 0.5, 1) + +[sub_resource type="CapsuleMesh" id="CapsuleMesh_dummy"] +material = SubResource("StandardMaterial3D_dummy") +radius = 0.45 +height = 1.9 + +[sub_resource type="CylinderShape3D" id="CylinderShape3D_zone"] +radius = 7.5 +height = 4.0 + +[node name="CombatTestground" type="Node3D"] + +[node name="WorldEnvironment" type="WorldEnvironment" parent="."] +environment = SubResource("Environment_env") + +[node name="Sun" type="DirectionalLight3D" parent="."] +transform = Transform3D(0.866025, 0.383022, -0.321394, 0, 0.642788, 0.766044, 0.5, -0.663414, 0.55667, 0, 10, 0) + +[node name="Floor" type="StaticBody3D" parent="."] +transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, -0.5, 0) + +[node name="CollisionShape3D" type="CollisionShape3D" parent="Floor"] +shape = SubResource("BoxShape3D_floor") + +[node name="MeshInstance3D" type="MeshInstance3D" parent="Floor"] +mesh = SubResource("BoxMesh_floor") + +[node name="RingMat" type="MeshInstance3D" parent="."] +transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0.04, 0) +mesh = SubResource("CylinderMesh_mat") + +[node name="EncounterZone" type="Area3D" parent="."] +transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 2, 0) +collision_layer = 0 +collision_mask = 2 +script = ExtResource("3_zone") + +[node name="CollisionShape3D" type="CollisionShape3D" parent="EncounterZone"] +shape = SubResource("CylinderShape3D_zone") + +[node name="Dummy" type="StaticBody3D" parent="."] +transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, -3.5) + +[node name="CollisionShape3D" type="CollisionShape3D" parent="Dummy"] +transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0.95, 0) +shape = SubResource("CapsuleShape3D_dummy") + +[node name="MeshInstance3D" type="MeshInstance3D" parent="Dummy"] +transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0.95, 0) +mesh = SubResource("CapsuleMesh_dummy") + +[node name="HealthLabel" type="Label3D" parent="Dummy"] +transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 2.3, 0) +billboard = 1 +text = "Dummy" +font_size = 48 +outline_size = 12 + +[node name="TrainingDummy" type="Node" parent="Dummy"] +script = ExtResource("4_dummy") + +[node name="Player" parent="." instance=ExtResource("1_player")] +transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0.1, 0) + +[node name="DebugOverlay" parent="." instance=ExtResource("2_debug")] diff --git a/scenes/player.tscn b/scenes/player.tscn index 06f12bc..83afec6 100644 --- a/scenes/player.tscn +++ b/scenes/player.tscn @@ -1,9 +1,10 @@ -[gd_scene load_steps=9 format=3] +[gd_scene load_steps=10 format=3] [ext_resource type="Script" path="res://scripts/gameplay/player.gd" id="1_player"] [ext_resource type="PackedScene" path="res://scenes/ui/speech_bubble.tscn" id="2_bubble"] [ext_resource type="PackedScene" path="res://scenes/ui/lexicon.tscn" id="3_journal"] [ext_resource type="PackedScene" path="res://scenes/ui/pause_menu.tscn" id="4_pause"] +[ext_resource type="Script" path="res://scripts/gameplay/combat/player_combat.gd" id="5_combat"] [ext_resource type="PackedScene" path="res://scenes/npcs/googly_eyes.tscn" id="90_eyes"] [sub_resource type="StandardMaterial3D" id="StandardMaterial3D_player"] @@ -49,5 +50,8 @@ transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 2.4, 0) [node name="PauseMenu" parent="." instance=ExtResource("4_pause")] +[node name="PlayerCombat" type="Node" parent="."] +script = ExtResource("5_combat") + [node name="GooglyEyes" parent="MeshInstance3D" instance=ExtResource("90_eyes")] transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0.55, -0.3) diff --git a/scripts/gameplay/combat/combat_actor.gd b/scripts/gameplay/combat/combat_actor.gd new file mode 100644 index 0000000..3cce922 --- /dev/null +++ b/scripts/gameplay/combat/combat_actor.gd @@ -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() diff --git a/scripts/gameplay/combat/combat_actor.gd.uid b/scripts/gameplay/combat/combat_actor.gd.uid new file mode 100644 index 0000000..f576480 --- /dev/null +++ b/scripts/gameplay/combat/combat_actor.gd.uid @@ -0,0 +1 @@ +uid://vi0gkiwoijnr diff --git a/scripts/gameplay/combat/encounter_zone.gd b/scripts/gameplay/combat/encounter_zone.gd new file mode 100644 index 0000000..6cc9539 --- /dev/null +++ b/scripts/gameplay/combat/encounter_zone.gd @@ -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") diff --git a/scripts/gameplay/combat/encounter_zone.gd.uid b/scripts/gameplay/combat/encounter_zone.gd.uid new file mode 100644 index 0000000..ce6692d --- /dev/null +++ b/scripts/gameplay/combat/encounter_zone.gd.uid @@ -0,0 +1 @@ +uid://br3djfvsdsjs8 diff --git a/scripts/gameplay/combat/player_combat.gd b/scripts/gameplay/combat/player_combat.gd new file mode 100644 index 0000000..6e4b846 --- /dev/null +++ b/scripts/gameplay/combat/player_combat.gd @@ -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))) diff --git a/scripts/gameplay/combat/player_combat.gd.uid b/scripts/gameplay/combat/player_combat.gd.uid new file mode 100644 index 0000000..fde8aeb --- /dev/null +++ b/scripts/gameplay/combat/player_combat.gd.uid @@ -0,0 +1 @@ +uid://deioua7q7grsk diff --git a/scripts/gameplay/combat/training_dummy.gd b/scripts/gameplay/combat/training_dummy.gd new file mode 100644 index 0000000..36d3968 --- /dev/null +++ b/scripts/gameplay/combat/training_dummy.gd @@ -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] diff --git a/scripts/gameplay/combat/training_dummy.gd.uid b/scripts/gameplay/combat/training_dummy.gd.uid new file mode 100644 index 0000000..37107af --- /dev/null +++ b/scripts/gameplay/combat/training_dummy.gd.uid @@ -0,0 +1 @@ +uid://c5thw4lpgdghd