diff --git a/scenes/ui/combat_hud.tscn b/scenes/ui/combat_hud.tscn new file mode 100644 index 0000000..3bdbffc --- /dev/null +++ b/scenes/ui/combat_hud.tscn @@ -0,0 +1,69 @@ +[gd_scene load_steps=2 format=3] + +[ext_resource type="Script" path="res://scripts/ui/combat_hud.gd" id="1_hud"] + +[node name="CombatHud" type="CanvasLayer"] +layer = 3 +script = ExtResource("1_hud") + +[node name="Root" type="Control" parent="."] +anchors_preset = 15 +anchor_right = 1.0 +anchor_bottom = 1.0 +grow_horizontal = 2 +grow_vertical = 2 +mouse_filter = 2 + +[node name="PlayerBox" type="VBoxContainer" parent="Root"] +anchors_preset = 2 +anchor_top = 1.0 +anchor_bottom = 1.0 +offset_left = 24.0 +offset_top = -96.0 +offset_right = 344.0 +offset_bottom = -24.0 +grow_vertical = 0 +theme_override_constants/separation = 6 + +[node name="NameLabel" type="Label" parent="Root/PlayerBox"] +theme_override_font_sizes/font_size = 15 +text = "Tyrveil" + +[node name="HealthBar" type="ProgressBar" parent="Root/PlayerBox"] +custom_minimum_size = Vector2(320, 18) +modulate = Color(0.35, 0.7, 0.4, 1) +max_value = 100.0 +value = 100.0 +show_percentage = false + +[node name="StaminaBar" type="ProgressBar" parent="Root/PlayerBox"] +custom_minimum_size = Vector2(320, 12) +modulate = Color(0.85, 0.75, 0.35, 1) +max_value = 100.0 +value = 100.0 +show_percentage = false + +[node name="EnemyBox" type="VBoxContainer" parent="Root"] +anchors_preset = 5 +anchor_left = 0.5 +anchor_right = 0.5 +offset_left = -160.0 +offset_top = 24.0 +offset_right = 160.0 +offset_bottom = 120.0 +grow_horizontal = 2 +theme_override_constants/separation = 8 + +[node name="WeaponLabel" type="Label" parent="Root"] +anchors_preset = 1 +anchor_left = 1.0 +anchor_right = 1.0 +offset_left = -300.0 +offset_top = 24.0 +offset_right = -24.0 +offset_bottom = 50.0 +grow_horizontal = 0 +theme_override_colors/font_color = Color(1, 0.9, 0.6, 1) +theme_override_font_sizes/font_size = 18 +text = "" +horizontal_alignment = 2 diff --git a/scripts/gameplay/cassian_ambush.gd b/scripts/gameplay/cassian_ambush.gd index 5db44e4..16b1065 100644 --- a/scripts/gameplay/cassian_ambush.gd +++ b/scripts/gameplay/cassian_ambush.gd @@ -5,10 +5,12 @@ extends Node ## zwischen den Regalen kesseln Cassian und zwei Schergen sie ein. Aktiv ## nur an Tag 9, solange der Cassian-Ausgang offen ist; an allen anderen ## Tagen bleiben die Akteure unsichtbar. Ablauf: nicht abbrechbarer -## Auftakt -> taktisches Sparring als QTE-Kette (Scheitern ist der Tod -## und führt auf den letzten Spielstand, CR 16 — die story-kritische -## Weiche geht dabei nicht verloren, der Tag wird erneut gespielt) -> -## Herz/Klinge-Weiche als Dialog. Konsequenzen: HERZ = Wren bedingungslos loyal (Vertrauen +## Auftakt -> **echter Kampf** gegen Cassian und seine beiden Schergen +## (CR 8d, CombatEncounter: Tyrveil bewegt sich frei und nutzt die volle +## Kampf-Grammatik aus 8a–8c; das alte QTE ist ersetzt). Scheitern ist +## der Tod und führt auf den letzten Spielstand (CR 16) — die +## story-kritische Weiche geht dabei nicht verloren, der Tag wird erneut +## gespielt -> Herz/Klinge-Weiche als Dialog. Konsequenzen: HERZ = Wren bedingungslos loyal (Vertrauen ## max), temporärer Stat-Malus durch Verletzungen, Menschlichkeit ## steigt, Cassian lebt. KLINGE = Cassian final ausgeschaltet, Wren hat ## Angst (Vertrauen bricht ein), Menschlichkeit kippt. Der Ausgang liegt @@ -20,15 +22,12 @@ signal ambush_finished(outcome: String) const INTRO_PATH := "res://data/dialogue/cassian_ambush_intro.json" const FAIL_PATH := "res://data/dialogue/cassian_ambush_fail.json" const CHOICE_PATH := "res://data/dialogue/cassian_ambush_choice.json" -const QTE_STAGES := 4 -const QTE_WINDOW_SECONDS := 1.3 -const QTE_STAGE_GAP_SECONDS := 0.3 -const QTE_ACTIONS := [ - { "action": "block", "label": "PARIEREN" }, - { "action": "attack", "label": "KONTERN" }, - { "action": "slide", "label": "AUSWEICHEN" }, - { "action": "jump", "label": "ÜBER DIE KISTE" }, -] +const ENEMY_SCRIPT := preload("res://scripts/gameplay/combat/enemy_combatant.gd") +const ENCOUNTER_SCRIPT := preload("res://scripts/gameplay/combat/combat_encounter.gd") +const CASSIAN_HITPOINTS := 120 +const CASSIAN_DAMAGE := 14 +const SCHERGE_HITPOINTS := 70 +const SCHERGE_DAMAGE := 9 const AMBUSH_DAY := 9 const HEART_STAT_MALUS := 2 @@ -39,19 +38,19 @@ const HEART_STAT_MALUS := 2 var is_ambush_active := false -var _qte_expected_action := "" -var _is_stage_passed := false -var _is_stage_failed := false var _has_run := false -var _qte_layer: CanvasLayer -var _qte_label: Label +var _encounter: CombatEncounter @onready var _cassian: Node3D = get_node(cassian_path) @onready var _wren: Node3D = get_node(wren_path) -## Richtet die Akteure nach Tag/Ausgang aus und verbindet den Auslöser. +## Richtet die Akteure nach Tag/Ausgang aus, legt den Encounter-Rahmen +## an und verbindet den Auslöser. func _ready() -> void: + _encounter = ENCOUNTER_SCRIPT.new() + _encounter.name = "AmbushEncounter" + add_child(_encounter) var is_armed: bool = TimeSystem.day_count == AMBUSH_DAY and StorySystem.get_cassian_outcome() == "none" _set_actors_visible(is_armed) if is_armed: @@ -59,21 +58,6 @@ func _ready() -> void: trigger.body_entered.connect(_on_trigger_entered) -## Bewertet die QTE-Eingabe; während einer aktiven Stufe wird sämtlicher -## übriger Input geschluckt. -func _unhandled_input(event: InputEvent) -> void: - if _qte_expected_action.is_empty(): - return - for stage in QTE_ACTIONS: - if event.is_action_pressed(str(stage["action"])): - if stage["action"] == _qte_expected_action: - _is_stage_passed = true - else: - _is_stage_failed = true - break - get_viewport().set_input_as_handled() - - ## Startet den Hinterhalt, sobald Tyrveil zwischen die Regale läuft. func _on_trigger_entered(body: Node3D) -> void: if not body.is_in_group("player") or _has_run: @@ -85,7 +69,7 @@ func _on_trigger_entered(body: Node3D) -> void: _run_ambush(body) -## Spielt den kompletten Hinterhalt als Coroutine: Auftakt, QTE-Kette +## Spielt den kompletten Hinterhalt als Coroutine: Auftakt, echter Kampf ## (Scheitern = Tod, letzter Spielstand), Herz/Klinge-Weiche, Konsequenzen. func _run_ambush(player: CharacterBody3D) -> void: DialogueSystem.start_dialogue(INTRO_PATH, { @@ -94,23 +78,16 @@ func _run_ambush(player: CharacterBody3D) -> void: DialogueSystem.PLAYER_SPEAKER_ID: player, }) await DialogueSystem.dialogue_finished - player.set_control_locked(true) - while true: - var is_success := await _run_qte() - if is_success: - break - player.set_control_locked(false) - print("Tod im Materialraum — zurück zum letzten Spielstand.") - SaveSystem.reload_last_save() - return - player.set_control_locked(false) + var is_won := await run_fight() + if not is_won: DialogueSystem.start_dialogue(FAIL_PATH, { "cassian": _cassian, DialogueSystem.PLAYER_SPEAKER_ID: player, }) await DialogueSystem.dialogue_finished - player.set_control_locked(true) - player.set_control_locked(false) + print("Tod im Materialraum — zurück zum letzten Spielstand.") + SaveSystem.reload_last_save() + return DialogueSystem.start_dialogue(CHOICE_PATH, { "cassian": _cassian, "wren": _wren, @@ -148,28 +125,44 @@ func apply_outcome(choice: String) -> void: _hide_schergen() -## Führt die QTE-Stufen aus; true, wenn alle bestanden wurden. -func _run_qte() -> bool: - _ensure_qte_ui() - _qte_layer.visible = true - var is_all_passed := true - for i in QTE_STAGES: - var stage: Dictionary = QTE_ACTIONS.pick_random() - _is_stage_passed = false - _is_stage_failed = false - _qte_label.text = "%s — %s" % [str(stage["label"]), InputPrompts.prompt(str(stage["action"]))] - _qte_expected_action = str(stage["action"]) - var timer := get_tree().create_timer(QTE_WINDOW_SECONDS) - while timer.time_left > 0.0 and not _is_stage_passed and not _is_stage_failed: - await get_tree().process_frame - _qte_expected_action = "" - if not _is_stage_passed: - is_all_passed = false - break - _qte_label.text = "!" - await get_tree().create_timer(QTE_STAGE_GAP_SECONDS).timeout - _qte_layer.visible = false - return is_all_passed +## Führt den eigentlichen Kampf als echten Encounter (CR 8d): Cassian +## und seine beiden Schergen greifen gemeinsam an, Tyrveil bewegt sich +## frei und nutzt die volle Grammatik. Liefert true bei Sieg. Öffentlich, +## damit Sonden den Ausgang deterministisch setzen können. +func run_fight() -> bool: + var enemies := _build_enemies() + if enemies.is_empty() or not _encounter.start(enemies): + return true + var is_won: bool = await _encounter.finished + return is_won + + +## Legt für Cassian und die Schergen je einen Kampf-Knoten an (einmalig) +## und liefert die Liste der lebenden Gegner. +func _build_enemies() -> Array: + var enemies: Array = [] + enemies.append(_ensure_combatant(_cassian, "Cassian", CASSIAN_HITPOINTS, CASSIAN_DAMAGE)) + for path in scherge_paths: + var scherge := get_node_or_null(path) as Node3D + if scherge != null: + enemies.append(_ensure_combatant(scherge, "Scherge", SCHERGE_HITPOINTS, SCHERGE_DAMAGE)) + for enemy in enemies: + enemy.reset_combat_values() + return enemies + + +## Hängt einem Akteur einen EnemyCombatant an, falls er noch keinen hat. +func _ensure_combatant(body: Node3D, display_name: String, hitpoints: int, damage: int) -> CombatActor: + var existing := body.get_node_or_null("AmbushCombat") as CombatActor + if existing != null: + return existing + var enemy: CombatActor = ENEMY_SCRIPT.new() + enemy.name = "AmbushCombat" + enemy.enemy_name = display_name + enemy.max_hitpoints = hitpoints + enemy.strike_damage = damage + body.add_child(enemy) + return enemy ## Legt Cassians Mesh in Liegeposition (Klinge-Ausgang); der Root bleibt @@ -199,23 +192,3 @@ func _set_actors_visible(is_visible_now: bool) -> void: scherge.visible = is_visible_now -## Baut die QTE-Anzeige beim ersten Bedarf. -func _ensure_qte_ui() -> void: - if _qte_layer != null: - return - _qte_layer = CanvasLayer.new() - _qte_layer.layer = 3 - var root := Control.new() - root.set_anchors_preset(Control.PRESET_FULL_RECT) - root.mouse_filter = Control.MOUSE_FILTER_IGNORE - _qte_label = Label.new() - _qte_label.set_anchors_preset(Control.PRESET_CENTER) - _qte_label.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER - _qte_label.add_theme_font_size_override("font_size", 42) - _qte_label.add_theme_color_override("font_color", Color(1, 0.85, 0.4)) - _qte_label.add_theme_color_override("font_outline_color", Color.BLACK) - _qte_label.add_theme_constant_override("outline_size", 8) - root.add_child(_qte_label) - _qte_layer.add_child(root) - add_child(_qte_layer) - _qte_layer.visible = false diff --git a/scripts/gameplay/combat/combat_encounter.gd b/scripts/gameplay/combat/combat_encounter.gd new file mode 100644 index 0000000..10389c1 --- /dev/null +++ b/scripts/gameplay/combat/combat_encounter.gd @@ -0,0 +1,84 @@ +class_name CombatEncounter +extends Node +## Ablauf-Steuerung eines Kampf-Encounters (CR 8d). +## +## Gemeinsamer Rahmen für Sparring und den Tag-9-Hinterhalt: schaltet +## Tyrveils Kampf-Kern scharf, aktiviert die Gegner-KI, baut das +## Kampf-HUD auf und beendet den Encounter, sobald alle Gegner am Boden +## sind (Sieg) oder Tyrveil fällt (Niederlage). Die **Bewegung bleibt +## frei** — der Spieler ist nicht gesperrt, das ist der Unterschied zum +## alten QTE. Was aus Sieg oder Niederlage folgt (Dialog, Tod, Weiche), +## entscheidet die aufrufende Szene über das finished-Signal; hier gibt +## es bewusst keine Story-Logik. + +signal finished(is_won: bool) + +const HUD_SCENE := preload("res://scenes/ui/combat_hud.tscn") + +var is_running := false + +var _enemies: Array = [] +var _player: CharacterBody3D +var _player_combat: CombatActor +var _hud: CanvasLayer + + +## Startet den Encounter mit den übergebenen Gegner-Knoten +## (EnemyCombatant). Liefert false, wenn kein Spieler gefunden wurde. +func start(enemies: Array) -> bool: + if is_running: + return false + _player = get_tree().get_first_node_in_group("player") as CharacterBody3D + if _player == null: + push_warning("Kein Spieler für den Encounter gefunden.") + return false + _player_combat = _player.get_node_or_null("PlayerCombat") as CombatActor + if _player_combat == null: + push_warning("Spieler hat keinen PlayerCombat-Knoten.") + return false + _enemies = enemies + is_running = true + _player_combat.set_encounter_active(true) + _player_combat.died.connect(_on_player_died, CONNECT_ONE_SHOT) + for enemy in _enemies: + enemy.set_active(true) + enemy.died.connect(_on_enemy_died) + _hud = HUD_SCENE.instantiate() + add_child(_hud) + _hud.setup(_player_combat, _enemies) + return true + + +## Beendet den Encounter vorzeitig (Abbruch durch die Szene). +func stop() -> void: + if not is_running: + return + is_running = false + _player_combat.set_encounter_active(false) + for enemy in _enemies: + if is_instance_valid(enemy): + enemy.set_active(false) + if _hud != null: + _hud.queue_free() + _hud = null + + +## Prüft nach jedem Gegner-Tod, ob der Encounter gewonnen ist. +func _on_enemy_died() -> void: + for enemy in _enemies: + if is_instance_valid(enemy) and enemy.is_alive(): + return + _end(true) + + +## Tyrveil ist gefallen — der Encounter ist verloren. +func _on_player_died() -> void: + _end(false) + + +## Räumt auf und meldet den Ausgang. +func _end(is_won: bool) -> void: + if not is_running: + return + stop() + finished.emit(is_won) diff --git a/scripts/gameplay/combat/enemy_combatant.gd b/scripts/gameplay/combat/enemy_combatant.gd new file mode 100644 index 0000000..f838723 --- /dev/null +++ b/scripts/gameplay/combat/enemy_combatant.gd @@ -0,0 +1,147 @@ +extends CombatActor +## Gegner mit einfacher Kampf-KI (CR 8d) — Node an einem Körper. +## +## Bewegt seinen Elternkörper Richtung Tyrveil, hält Schlagdistanz und +## fährt **sichtbar telegrafierte** Angriffe: kurzer Rückzug, Ausholen +## (Mesh färbt sich), dann der Schlag. Genau dieses Fenster ist das +## Angebot an den Spieler — ausweichen, durchrollen, blocken oder +## parieren (8a). Zwischen den Schlägen blockt er gelegentlich selbst, +## damit schwere Angriffe und Kombos einen Zweck haben (8b/8c). +## Aggression, Härte und Tempo kommen aus den Export-Werten, damit +## Sparringspartner und Hinterhalt-Schergen dieselbe Klasse mit anderen +## Zahlen nutzen können. Wird der Gegner gestaggert (Parry), steht er +## offen. Der Tod meldet nur das Signal — was daraus folgt, entscheidet +## die Encounter-Szene. + +signal telegraph_started +signal strike_resolved(did_hit: bool) + +const TURN_SPEED := 8.0 + +@export var enemy_name := "Gegner" +@export var max_hitpoints := 90 +@export var strike_damage := 10 +@export var strike_range := 2.4 +@export var move_speed := 2.6 +@export var telegraph_seconds := 0.9 +@export var strike_cooldown := 1.8 +@export var block_chance := 0.25 +@export var block_seconds := 1.2 +@export var is_active := false + +var _cooldown := 0.0 +var _telegraph := 0.0 +var _block_timer := 0.0 +var _gravity: float = ProjectSettings.get_setting("physics/3d/default_gravity") + +@onready var _body: Node3D = get_parent() as Node3D +@onready var _mesh: MeshInstance3D = _body.get_node_or_null("MeshInstance3D") + + +## Meldet sich als Kampfziel an und setzt die Werte. +func _ready() -> void: + add_to_group("combat_actor") + max_health = max_hitpoints + max_stamina = 100.0 + reset_combat_values() + _cooldown = strike_cooldown + + +## Schaltet die KI scharf oder ab (Encounter-Start/-Ende). +func set_active(active: bool) -> void: + is_active = active + _telegraph = 0.0 + _block_timer = 0.0 + _cooldown = strike_cooldown + _paint(false) + + +## Gegner blocken, solange ihr Block-Timer läuft. +func is_blocking() -> bool: + return _block_timer > 0.0 + + +## Treibt Annäherung, Telegraph, Schlag und Block an. +func _physics_process(delta: float) -> void: + tick_combat(delta) + if not is_active or not is_alive() or _body == null: + return + var player := get_tree().get_first_node_in_group("player") as Node3D + if player == null or DialogueSystem.is_dialogue_active: + return + _block_timer = maxf(_block_timer - delta, 0.0) + if is_staggered(): + _paint(false) + _telegraph = 0.0 + return + _face(player, delta) + if _telegraph > 0.0: + _telegraph -= delta + if _telegraph <= 0.0: + _resolve_strike(player) + return + var distance := _body.global_position.distance_to(player.global_position) + if distance > strike_range: + _step_towards(player, delta) + _cooldown = maxf(_cooldown - delta, 0.0) + if _cooldown > 0.0 or distance > strike_range: + return + if randf() < block_chance: + _block_timer = block_seconds + _cooldown = block_seconds + return + _begin_telegraph() + + +## Geht einen Schritt auf Tyrveil zu (Greybox: direkte Bewegung, kein +## Pathfinding — die Encounter-Arenen sind offen). +func _step_towards(player: Node3D, delta: float) -> void: + var to_player := player.global_position - _body.global_position + to_player.y = 0.0 + if to_player.length_squared() < 0.01: + return + _body.global_position += to_player.normalized() * move_speed * delta + + +## Dreht den Gegner zum Spieler. +func _face(player: Node3D, delta: float) -> void: + if _mesh == null: + return + var to_player := player.global_position - _body.global_position + to_player.y = 0.0 + if to_player.length_squared() < 0.01: + return + var target_yaw := atan2(-to_player.x, -to_player.z) + _mesh.rotation.y = lerp_angle(_mesh.rotation.y, target_yaw, minf(TURN_SPEED * delta, 1.0)) + + +## Kündigt den Schlag sichtbar an — das Fenster für Ausweichen, Rollen, +## Blocken und Parieren. +func _begin_telegraph() -> void: + _telegraph = telegraph_seconds + _paint(true) + telegraph_started.emit() + + +## Führt den Schlag aus, wenn Tyrveil noch in Reichweite steht. +func _resolve_strike(player: Node3D) -> void: + _paint(false) + _cooldown = strike_cooldown + if _body.global_position.distance_to(player.global_position) > strike_range + 0.4: + strike_resolved.emit(false) + return + var combat := player.get_node_or_null("PlayerCombat") as CombatActor + if combat == null: + strike_resolved.emit(false) + return + var result: String = combat.take_hit(strike_damage, false, self) + strike_resolved.emit(result == "hit") + + +## Färbt das Mesh während des Telegraphs. +func _paint(is_telegraphing: bool) -> void: + if _mesh == null: + return + var material := StandardMaterial3D.new() + material.albedo_color = Color(0.85, 0.35, 0.3) if is_telegraphing else Color(0.45, 0.4, 0.45) + _mesh.material_override = material diff --git a/scripts/gameplay/sparring_fight.gd b/scripts/gameplay/sparring_fight.gd index cf6c468..47e2024 100644 --- a/scripts/gameplay/sparring_fight.gd +++ b/scripts/gameplay/sparring_fight.gd @@ -1,87 +1,67 @@ extends StaticBody3D -## Echtes Sparring-Kampfsystem (Change Request + SPEC.md Roadmap Phase 4: -## stat-basiertes, taktisches Sparring). +## Sparring auf dem echten Kampfsystem (CR 8d — ersetzt das alte +## Timing-Duell; SPEC.md §1/§5.1, Roadmap Phase 4). ## -## Interact startet den Kampf und verbraucht einen Tages-Slot. Linksklick -## bzw. R2 schlägt (attack), Rechtsklick bzw. ▢/Ⓧ blockt (block). Kraft -## skaliert den Schaden pro Treffer: BASE_DAMAGE + 1 je volle 10 Kraft -## über 30 — der Gegner fällt also je nach Training in 3–5 Treffern. -## Schnelligkeit weitet das Block-Fenster (Telegraph-Dauer des Gegners). -## Ausdauer Tyrveils: Schlagen kostet ATTACK_COST, erfolgreiches Blocken -## BLOCK_COST, Regeneration STAMINA_REGEN pro Sekunde; unter -## GUARD_BREAK_THRESHOLD ist kein Block möglich (Guard-Break), unter -## WEAK_ATTACK_THRESHOLD halbiert sich der Schlagschaden. Der Gegner hat -## eine interne Ausdauer OHNE sichtbaren Balken, die sein Angriffstempo -## steuert (Angriff nur bei genug Ausdauer). HUD: HP-Balken beider -## Kämpfer plus Ausdauer-Balken Tyrveils (Laufzeit-CanvasLayer). -## Sparring ist nie tödlich: Sieg führt -## in den Klinge/Herz-Abschluss (sparring_win.json — Gegner überwältigt: -## fertigmachen oder aufhelfen), Niederlage in sparring_loss.json. +## Interact startet die Übungsrunde und verbraucht einen Tages-Slot. +## Danach läuft ein **echter Encounter** (CombatEncounter): Tyrveil +## bewegt sich frei, schlägt leicht und schwer, weicht aus, rollt, +## blockt und pariert (8a), wechselt die Waffe (8b) und kettet Kombos +## (8c); der Partner ist ein EnemyCombatant mit telegrafierten +## Schlägen. Der Gegner wird als Kind-Knoten zur Laufzeit angelegt, die +## Szene muss nichts vorbereiten. +## +## Sparring ist **nie tödlich** (SPEC §6): Fällt Tyrveil, endet die +## Runde als Niederlage mit sparring_loss.json statt mit einem Tod — +## der CR-16-Respawn greift hier bewusst nicht. Sieg führt in die +## Klinge/Herz-Weiche (sparring_win.json). Die Paarung zieht ihren Namen +## weiterhin aus Tyrveils Staffel (CR 5). -enum FightState { WAITING, FIGHTING, RESOLVING } - -const PLAYER_MAX_HP := 5 -const ENEMY_MAX_HP := 20 -const BASE_DAMAGE := 4 -const STAMINA_MAX := 100.0 -const ATTACK_COST := 20.0 -const BLOCK_COST := 15.0 -const STAMINA_REGEN := 25.0 -const GUARD_BREAK_THRESHOLD := 15.0 -const WEAK_ATTACK_THRESHOLD := 20.0 -const ENEMY_STAMINA_MAX := 100.0 -const ENEMY_ATTACK_COST := 30.0 -const ENEMY_STAMINA_REGEN := 20.0 -const ENEMY_STRIKE_COOLDOWN := 1.2 -const ENEMY_STAGGER_SECONDS := 1.0 -const PLAYER_ATTACK_COOLDOWN := 0.5 -const TELEGRAPH_SCALE := 1.18 +const ENEMY_SCRIPT := preload("res://scripts/gameplay/combat/enemy_combatant.gd") +const ENCOUNTER_SCRIPT := preload("res://scripts/gameplay/combat/combat_encounter.gd") const INPUT_COOLDOWN_MS := 800 +const PARTNER_HITPOINTS := 90 +const PARTNER_DAMAGE := 9 @export_file("*.json") var win_dialogue_path := "res://data/dialogue/sparring_win.json" @export_file("*.json") var loss_dialogue_path := "res://data/dialogue/sparring_loss.json" @export var exhausted_line := "Für heute reicht es — der Schlafsaal wartet." -var _state := FightState.WAITING -var _player_hp := PLAYER_MAX_HP -var _enemy_hp := ENEMY_MAX_HP -var _stamina := STAMINA_MAX -var _enemy_stamina := ENEMY_STAMINA_MAX -var _attack_cooldown := 0.0 -var _enemy_cooldown := 0.0 -var _telegraph_remaining := 0.0 -var _stagger_remaining := 0.0 -var _is_enemy_telegraphing := false +var is_fighting := false + var _is_player_in_range := false var _last_use_ms := -INPUT_COOLDOWN_MS -var _hud: CanvasLayer -var _player_hp_bar: ProgressBar -var _stamina_bar: ProgressBar -var _enemy_hp_bar: ProgressBar - var _partner_name := "Sparringspartner" +var _home_position := Vector3.ZERO +var _enemy: CombatActor +var _encounter: CombatEncounter @onready var _prompt_label: Label3D = $PromptLabel @onready var _interaction_area: Area3D = $InteractionArea @onready var _bubble: Node3D = $SpeechBubble -@onready var _mesh: MeshInstance3D = $MeshInstance3D @onready var _name_label: Label3D = $NameLabel -## Verbindet die Reichweiten-Signale des Interaktions-Triggers. +## Legt Gegner-Knoten und Encounter-Rahmen an und verbindet die +## Reichweiten-Signale. func _ready() -> void: + _home_position = global_position _interaction_area.body_entered.connect(_on_body_entered) _interaction_area.body_exited.connect(_on_body_exited) + _enemy = ENEMY_SCRIPT.new() + _enemy.name = "PartnerCombat" + _enemy.enemy_name = _partner_name + _enemy.max_hitpoints = PARTNER_HITPOINTS + _enemy.strike_damage = PARTNER_DAMAGE + add_child(_enemy) + _encounter = ENCOUNTER_SCRIPT.new() + _encounter.name = "SparringEncounter" + add_child(_encounter) + _encounter.finished.connect(_on_encounter_finished) -## Startet den Kampf per interact bzw. wertet Schläge während des Kampfes. +## Startet die Übungsrunde per interact in Reichweite. func _unhandled_input(event: InputEvent) -> void: - if _state == FightState.FIGHTING: - if event.is_action_pressed("attack"): - _player_attack() - get_viewport().set_input_as_handled() - return - if _state != FightState.WAITING or not _is_player_in_range: + if is_fighting or not _is_player_in_range: return if DialogueSystem.is_dialogue_active: return @@ -90,187 +70,56 @@ func _unhandled_input(event: InputEvent) -> void: if Time.get_ticks_msec() - _last_use_ms < INPUT_COOLDOWN_MS: return _last_use_ms = Time.get_ticks_msec() - _try_start_fight() + try_start_fight() -## Treibt Ausdauer-Regeneration, Cooldowns und die Gegner-KI an. -func _physics_process(delta: float) -> void: - if _state != FightState.FIGHTING: - return - _stamina = minf(_stamina + STAMINA_REGEN * delta, STAMINA_MAX) - _enemy_stamina = minf(_enemy_stamina + ENEMY_STAMINA_REGEN * delta, ENEMY_STAMINA_MAX) - _attack_cooldown = maxf(_attack_cooldown - delta, 0.0) - if _is_enemy_telegraphing: - _telegraph_remaining -= delta - if _telegraph_remaining <= 0.0: - _resolve_enemy_strike() - elif _stagger_remaining > 0.0: - _stagger_remaining -= delta - else: - _enemy_cooldown = maxf(_enemy_cooldown - delta, 0.0) - if _enemy_cooldown <= 0.0 and _enemy_stamina >= ENEMY_ATTACK_COST: - _begin_enemy_telegraph() - _update_hud() - - -## Startet den Kampf: verbraucht den Tages-Slot, initialisiert Werte, -## sperrt die Bewegung und blendet das HUD ein. -func _try_start_fight() -> void: +## Verbraucht den Tages-Slot und startet den Encounter; liefert false, +## wenn der Slot schon weg ist oder kein Spieler da ist. +func try_start_fight() -> bool: + if is_fighting: + return false if not TimeSystem.try_spend_slot(): _bubble.show_line(exhausted_line) - return - var player := get_tree().get_first_node_in_group("player") - if player == null: - push_warning("Kein Spieler für das Sparring gefunden.") - return - _player_hp = PLAYER_MAX_HP - _enemy_hp = ENEMY_MAX_HP - _stamina = STAMINA_MAX - _enemy_stamina = ENEMY_STAMINA_MAX - _attack_cooldown = 0.0 - _enemy_cooldown = ENEMY_STRIKE_COOLDOWN - _is_enemy_telegraphing = false - _stagger_remaining = 0.0 - player.set_control_locked(true) - _prompt_label.visible = false + return false _draw_partner() - _ensure_hud() - _update_hud() - _hud.visible = true - _state = FightState.FIGHTING + _enemy.reset_combat_values() + global_position = _home_position + if not _encounter.start([_enemy]): + return false + is_fighting = true + _prompt_label.visible = false + return true -## Zieht die heutige Sparring-Paarung aus der Staffel-Liste (CR 5) und -## beschriftet Gegner-Label und HUD-Balken mit dem Namen. +## Zieht die heutige Sparring-Paarung aus der Staffel-Liste (CR 5). func _draw_partner() -> void: _partner_name = StorySystem.get_staffel_partner() _name_label.text = _partner_name - if _enemy_hp_bar != null: - var label := _enemy_hp_bar.get_parent().get_child(0) as Label - if label != null: - label.text = _partner_name + _enemy.enemy_name = _partner_name -## Führt einen Schlag aus: Kraft bestimmt den Schaden, knappe Ausdauer -## halbiert ihn (schwache Schläge), Treffer reduzieren die Gegner-HP. -func _player_attack() -> void: - if _attack_cooldown > 0.0: - return - _attack_cooldown = PLAYER_ATTACK_COOLDOWN - var damage := maxi(1, BASE_DAMAGE + (GameState.strength - 30) / 10) - if _stamina < WEAK_ATTACK_THRESHOLD: - damage = maxi(1, damage / 2) - _stamina = maxf(_stamina - ATTACK_COST, 0.0) - _enemy_hp = maxi(_enemy_hp - damage, 0) - _update_hud() - if _enemy_hp <= 0: - _end_fight(true) - - -## Beginnt den Angriffs-Telegraph des Gegners; die Dauer ist zugleich das -## Block-Fenster und wächst mit Tyrveils Schnelligkeit. -func _begin_enemy_telegraph() -> void: - _enemy_stamina -= ENEMY_ATTACK_COST - _is_enemy_telegraphing = true - _telegraph_remaining = clampf(0.5 + (GameState.agility - 35) * 0.015, 0.4, 0.9) - _mesh.scale = Vector3.ONE * TELEGRAPH_SCALE - - -## Löst den Schlag des Gegners aus: Wird gerade geblockt (block gehalten -## und genug Ausdauer), taumelt der Gegner; sonst verliert Tyrveil einen -## Trefferpunkt. -func _resolve_enemy_strike() -> void: - _is_enemy_telegraphing = false - _mesh.scale = Vector3.ONE - _enemy_cooldown = ENEMY_STRIKE_COOLDOWN - if Input.is_action_pressed("block") and _stamina >= GUARD_BREAK_THRESHOLD: - _stamina = maxf(_stamina - BLOCK_COST, 0.0) - _stagger_remaining = ENEMY_STAGGER_SECONDS - _update_hud() - return - _player_hp = maxi(_player_hp - 1, 0) - _update_hud() - if _player_hp <= 0: - _end_fight(false) - - -## Beendet den Kampf und führt in den passenden Abschluss-Dialog; danach -## ist die Station für den nächsten Slot wieder bereit. Nie tödlich. -func _end_fight(is_won: bool) -> void: - _state = FightState.RESOLVING - _hud.visible = false - _mesh.scale = Vector3.ONE +## Wertet den Ausgang aus: Sieg oder Niederlage führen in den passenden +## Abschluss-Dialog. Nie tödlich — Tyrveil steht danach wieder auf. +func _on_encounter_finished(is_won: bool) -> void: + is_fighting = false var player := get_tree().get_first_node_in_group("player") if player != null: - player.set_control_locked(false) + var combat := player.get_node_or_null("PlayerCombat") as CombatActor + if combat != null: + combat.reset_combat_values() + global_position = _home_position DialogueSystem.start_dialogue(win_dialogue_path if is_won else loss_dialogue_path, { "sparring": self, DialogueSystem.PLAYER_SPEAKER_ID: player, }) await DialogueSystem.dialogue_finished - _state = FightState.WAITING _prompt_label.visible = _is_player_in_range -## Baut das Kampf-HUD (HP beider Kämpfer, Ausdauer Tyrveils) beim ersten -## Bedarf. -func _ensure_hud() -> void: - if _hud != null: - return - _hud = CanvasLayer.new() - _hud.layer = 3 - var root := Control.new() - root.set_anchors_preset(Control.PRESET_FULL_RECT) - root.mouse_filter = Control.MOUSE_FILTER_IGNORE - _enemy_hp_bar = _build_bar(root, Vector2(-150, 24), Color(0.75, 0.3, 0.3), _partner_name, ENEMY_MAX_HP) - _player_hp_bar = _build_bar(root, Vector2(-320, -80), Color(0.35, 0.65, 0.35), "Tyrveil", PLAYER_MAX_HP) - _stamina_bar = _build_bar(root, Vector2(-320, -46), Color(0.85, 0.75, 0.35), "Ausdauer", int(STAMINA_MAX)) - _hud.add_child(root) - add_child(_hud) - _hud.visible = false - - -## Erzeugt einen beschrifteten Balken; offset relativ zur Ankerkante -## (negative y-Werte hängen an der Unterkante). -func _build_bar(root: Control, offset: Vector2, color: Color, label_text: String, max_value: int) -> ProgressBar: - var container := VBoxContainer.new() - if offset.y < 0.0: - container.set_anchors_preset(Control.PRESET_BOTTOM_LEFT) - container.position = Vector2(24, 0) - container.offset_top = offset.y - container.offset_left = 24.0 - else: - container.set_anchors_preset(Control.PRESET_CENTER_TOP) - container.offset_left = offset.x - container.offset_top = offset.y - var label := Label.new() - label.text = label_text - label.add_theme_font_size_override("font_size", 14) - container.add_child(label) - var bar := ProgressBar.new() - bar.custom_minimum_size = Vector2(300, 18) - bar.max_value = max_value - bar.value = max_value - bar.show_percentage = false - bar.modulate = color - container.add_child(bar) - root.add_child(container) - return bar - - -## Spiegelt die Kampfwerte in die HUD-Balken. -func _update_hud() -> void: - if _hud == null: - return - _player_hp_bar.value = _player_hp - _stamina_bar.value = _stamina - _enemy_hp_bar.value = _enemy_hp - - ## Blendet den Prompt ein, sobald der Spieler die Reichweite betritt. func _on_body_entered(_body: Node3D) -> void: _is_player_in_range = true - _prompt_label.visible = _state == FightState.WAITING + _prompt_label.visible = not is_fighting ## Blendet den Prompt aus, wenn der Spieler die Reichweite verlässt. diff --git a/scripts/ui/combat_hud.gd b/scripts/ui/combat_hud.gd new file mode 100644 index 0000000..2285228 --- /dev/null +++ b/scripts/ui/combat_hud.gd @@ -0,0 +1,67 @@ +extends CanvasLayer +## Kampf-HUD der Encounter (CR 8d). +## +## Zeigt Tyrveils Trefferpunkte und Ausdauer unten links, die Gegner +## oben mittig (ein Balken je Gegner) und rechts die geführte Waffe samt +## Waffenskill. Alle Balken hängen an den Signalen der CombatActors — +## das HUD rechnet nichts selbst. Läuft als Greybox-UI zur Laufzeit +## aufgebaut, damit Encounter-Szenen nichts vorbereiten müssen. + +var _player: CombatActor +var _enemy_bars: Dictionary = {} + +@onready var _root: Control = $Root +@onready var _health_bar: ProgressBar = $Root/PlayerBox/HealthBar +@onready var _stamina_bar: ProgressBar = $Root/PlayerBox/StaminaBar +@onready var _weapon_label: Label = $Root/WeaponLabel +@onready var _enemy_box: VBoxContainer = $Root/EnemyBox + + +## Hängt sich an Spieler und Gegner und baut je einen Gegner-Balken. +func setup(player: CombatActor, enemies: Array) -> void: + _player = player + _health_bar.max_value = player.max_health + _stamina_bar.max_value = player.max_stamina + player.health_changed.connect(func(current: int, _maximum: int) -> void: _health_bar.value = current) + player.stamina_changed.connect(func(current: float, _maximum: float) -> void: _stamina_bar.value = current) + _health_bar.value = player.health + _stamina_bar.value = player.stamina + if player.has_signal("weapon_changed"): + player.weapon_changed.connect(func(_id: String, _name: String) -> void: _refresh_weapon()) + GameState.weapon_skill_changed.connect(func(_id: String, _value: int) -> void: _refresh_weapon()) + _refresh_weapon() + for enemy in enemies: + _add_enemy_bar(enemy) + + +## Baut einen beschrifteten Balken für einen Gegner. +func _add_enemy_bar(enemy: CombatActor) -> void: + var container := VBoxContainer.new() + var label := Label.new() + label.text = str(enemy.get("enemy_name")) + label.add_theme_font_size_override("font_size", 15) + label.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER + container.add_child(label) + var bar := ProgressBar.new() + bar.custom_minimum_size = Vector2(320, 16) + bar.max_value = enemy.max_health + bar.value = enemy.health + bar.show_percentage = false + bar.modulate = Color(0.8, 0.35, 0.32) + container.add_child(bar) + _enemy_box.add_child(container) + _enemy_bars[enemy] = bar + enemy.health_changed.connect(func(current: int, _maximum: int) -> void: bar.value = current) + enemy.died.connect(func() -> void: container.modulate = Color(1, 1, 1, 0.35)) + + +## Schreibt Waffe und Waffenskill ins Label. +func _refresh_weapon() -> void: + if _player == null or not _player.has_method("get_weapon"): + _weapon_label.text = "" + return + var weapon: Dictionary = _player.get_weapon() + if weapon.is_empty(): + _weapon_label.text = "" + return + _weapon_label.text = "%s Skill %d [Q]" % [str(weapon.get("name", "?")), _player.get_weapon_skill()]