CR 8d: Encounter-Umbau — Sparring und Tag-9 auf dem echten Kampfsystem
- EnemyCombatant: Gegner-KI auf CombatActor-Basis, nähert sich, hält Distanz, kündigt Schläge sichtbar an und blockt gelegentlich; Werte über Exports, damit Partner und Schergen dieselbe Klasse nutzen - CombatEncounter: gemeinsamer Rahmen (Kampf-Kern scharf, Gegner aktiv, HUD, Sieg/Niederlage über finished) — bewusst ohne Story-Logik - Kampf-HUD (scenes/ui/combat_hud.tscn): HP + Ausdauer, ein Balken je Gegner, Waffe und Waffenskill - Sparring: Timing-Duell ersetzt durch echten Encounter gegen den Staffel-Partner; Bewegung bleibt frei, nie tödlich (Niederlage führt in sparring_loss statt in den Respawn) - Tag-9-Hinterhalt: QTE-Kette samt UI entfernt, Cassian und beide Schergen kämpfen gleichzeitig; Niederlage = Tod → letzter Spielstand (CR 16), Sieg führt unverändert in die Herz/Klinge-Weiche - Option B gewahrt: keine Kampf-Gegner im Hub - Buchführung: 8d nach CHANGEREQUESTS_DONE, ROADMAP nachgezogen Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
This commit is contained in:
parent
e662648522
commit
b96b07b7d9
6 changed files with 493 additions and 304 deletions
69
scenes/ui/combat_hud.tscn
Normal file
69
scenes/ui/combat_hud.tscn
Normal file
|
|
@ -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
|
||||
|
|
@ -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
|
||||
|
|
|
|||
84
scripts/gameplay/combat/combat_encounter.gd
Normal file
84
scripts/gameplay/combat/combat_encounter.gd
Normal file
|
|
@ -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)
|
||||
147
scripts/gameplay/combat/enemy_combatant.gd
Normal file
147
scripts/gameplay/combat/enemy_combatant.gd
Normal file
|
|
@ -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
|
||||
|
|
@ -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.
|
||||
|
|
|
|||
67
scripts/ui/combat_hud.gd
Normal file
67
scripts/ui/combat_hud.gd
Normal file
|
|
@ -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()]
|
||||
Loading…
Add table
Add a link
Reference in a new issue