739 lines
36 KiB
GDScript
739 lines
36 KiB
GDScript
extends SceneTree
|
||
|
||
var failures: Array[String] = []
|
||
var started_actions: Array[StringName] = []
|
||
var projectile_requests: Array[Dictionary] = []
|
||
|
||
|
||
func _init() -> void:
|
||
_run.call_deferred()
|
||
|
||
|
||
func _run() -> void:
|
||
await process_frame
|
||
_check_boss_assets()
|
||
await _check_boss_scene_contract()
|
||
_check_boss_action_resources()
|
||
await _check_stage_and_main_contract()
|
||
await _check_stage_camera_follows_player_with_wider_view()
|
||
await _check_visible_ground_alignment()
|
||
await _check_boss_behavior_tree_uses_beat_ticks()
|
||
await _check_boss_entry_clears_precombat_chart_delay()
|
||
await _check_boss_behavior_tree_handles_point_blank_pressure()
|
||
await _check_boss_escapes_after_sustained_hit_chain()
|
||
await _check_boss_driver_starts_beat_anchored_actions()
|
||
await _check_boss_projectile_request_and_visual()
|
||
await _check_bidirectional_damage_flow()
|
||
await _check_boss_death_state_is_terminal()
|
||
_check_boss_script_debt_cleanup()
|
||
_finish()
|
||
|
||
|
||
func _check_boss_assets() -> void:
|
||
var expected_assets := {
|
||
"boss_idle.png": 1,
|
||
"boss_run.png": 8,
|
||
"boss_dash.png": 6,
|
||
"boss_jump_fall.png": 2,
|
||
"boss_take_hit.png": 1,
|
||
"boss_die.png": 4,
|
||
"boss_ground_combo_1.png": 8,
|
||
"boss_ground_combo_2.png": 10,
|
||
"boss_ground_combo_3.png": 14,
|
||
"boss_lunging_stab.png": 15,
|
||
"boss_shoot_1.png": 2,
|
||
"boss_shoot_2.png": 2,
|
||
"boss_2way_shoot_1.png": 2,
|
||
"boss_2way_shoot_2.png": 2,
|
||
}
|
||
for file_name: String in expected_assets:
|
||
var texture: Texture2D = load("res://assets/art/characters/boss/%s" % file_name)
|
||
_expect(texture != null, "Boss asset %s should load" % file_name)
|
||
if texture != null:
|
||
_expect_int(texture.get_width(), 80 * int(expected_assets[file_name]), "%s width should match 80px frames" % file_name)
|
||
_expect_int(texture.get_height(), 48, "%s height should be 48px" % file_name)
|
||
|
||
|
||
func _check_boss_scene_contract() -> void:
|
||
var scene: PackedScene = load("res://scenes/enemies/boss.tscn")
|
||
_expect(scene != null, "Boss scene should load")
|
||
if scene == null:
|
||
return
|
||
var boss := scene.instantiate()
|
||
root.add_child(boss)
|
||
await process_frame
|
||
for node_path: String in [
|
||
"Visual",
|
||
"Visual/CharacterSprite",
|
||
"Visual/FxOverlay",
|
||
"AnimationPlayer",
|
||
"StateMachine",
|
||
"MovementMotor",
|
||
"ActionResolver",
|
||
"ActionExecutor",
|
||
"ActionController",
|
||
"MotionExecutor",
|
||
"EffectContainer",
|
||
"HealthComponent",
|
||
"DamageReceiver",
|
||
"DamageEmitter",
|
||
"EnemyActionDriver",
|
||
"BossBehaviorTree",
|
||
]:
|
||
_expect(boss.get_node_or_null(node_path) != null, "Boss should contain %s" % node_path)
|
||
_expect_int(int(boss.get_node("HealthComponent").get("maximum")), 28000, "Boss HP baseline should live on HealthComponent")
|
||
_expect_float(absf(float(boss.get_node("Visual").scale.x)), 2.0, "Boss Visual should keep the x1 reference scale")
|
||
_expect_float(float(boss.get_node("Visual").scale.y), 2.0, "Boss Visual should keep the x1 reference scale")
|
||
_expect_float(float(boss.get("visual_ground_offset")), -40.0, "Boss Visual offset should match Rthythm_archor_game")
|
||
_expect_float(float(boss.get("projectile_spawn_height")), 74.0, "Boss projectile lane should match Rthythm_archor_game")
|
||
var animation_player: AnimationPlayer = boss.get_node_or_null("AnimationPlayer")
|
||
if animation_player != null:
|
||
for animation_name: StringName in _boss_animation_names():
|
||
_expect(animation_player.has_animation(animation_name), "Boss AnimationPlayer should expose %s" % animation_name)
|
||
boss.queue_free()
|
||
await process_frame
|
||
|
||
|
||
func _check_boss_action_resources() -> void:
|
||
var resolver_script: Script = load("res://scenes/combat/action_resolver.gd")
|
||
_expect(resolver_script != null, "ActionResolver should load")
|
||
if resolver_script == null:
|
||
return
|
||
resolver_script.clear_cache()
|
||
var animation_names := _boss_animation_names()
|
||
for action_id: StringName in [
|
||
&"boss_combo_1",
|
||
&"boss_combo_2",
|
||
&"boss_combo_3",
|
||
&"boss_retreat_dash",
|
||
&"boss_lunging_stab",
|
||
&"boss_dash",
|
||
&"boss_shoot_1",
|
||
&"boss_shoot_2",
|
||
&"boss_2way_shoot",
|
||
]:
|
||
var action: Resource = resolver_script.get_action(action_id)
|
||
_expect(action != null, "%s should be a Boss ActionData resource" % action_id)
|
||
if action == null:
|
||
continue
|
||
_expect_bool(Array(action.get("input_pattern")).is_empty(), true, "%s should not expose a player input pattern" % action_id)
|
||
_expect(animation_names.has(action.get("animation")), "%s animation should exist on Boss AnimationPlayer" % action_id)
|
||
_expect(float(action.get("damage_mult")) >= 0.0, "%s damage should be data-driven on ActionData" % action_id)
|
||
_expect(float(action.get("knockback_mult_x")) >= 0.0, "%s should configure horizontal knockback for player hit reaction" % action_id)
|
||
resolver_script.clear_cache()
|
||
|
||
|
||
func _check_stage_and_main_contract() -> void:
|
||
var stage_scene: PackedScene = load("res://scenes/stage/stage.tscn")
|
||
var main_scene: PackedScene = load("res://scenes/main/main.tscn")
|
||
_expect(stage_scene != null, "Stage scene should load")
|
||
_expect(main_scene != null, "Main scene should load")
|
||
_expect_equal(ProjectSettings.get_setting("application/run/main_scene"), "res://scenes/main/main.tscn", "Project main scene should move to phase-7 main.tscn")
|
||
if stage_scene != null:
|
||
var stage := stage_scene.instantiate()
|
||
root.add_child(stage)
|
||
await process_frame
|
||
_expect(stage.has_node("ActorsContainer/Player"), "Stage should instance Player under ActorsContainer")
|
||
_expect(stage.has_node("ActorsContainer/Boss"), "Stage should instance Boss under ActorsContainer")
|
||
if stage.has_node("ActorsContainer/Player") and stage.has_node("ActorsContainer/Boss"):
|
||
var player := stage.get_node("ActorsContainer/Player") as Node2D
|
||
var boss := stage.get_node("ActorsContainer/Boss")
|
||
var boss_tree := boss.get_node("BossBehaviorTree")
|
||
_expect(boss_tree.get("target") == player, "BossBehaviorTree should resolve the Player target in Stage")
|
||
boss.call("look_at_target", player)
|
||
boss.call("flip_sprites")
|
||
_expect(boss.get("heading") == Vector2.LEFT, "Boss should face left when Player is left of Boss")
|
||
_expect(float(boss.get_node("Visual").scale.x) < 0.0, "Boss visual should flip for a left-facing target because the source art faces right")
|
||
stage.queue_free()
|
||
await process_frame
|
||
if main_scene != null:
|
||
var main: Node = main_scene.instantiate()
|
||
root.add_child(main)
|
||
await process_frame
|
||
_expect(main.has_node("Stage"), "Main should instance Stage")
|
||
_expect(main.has_node("ChartRunner"), "Main should own ChartRunner")
|
||
_expect(main.get_node("ChartRunner").get("chart") != null, "Main ChartRunner should reference the stage-7 boss chart")
|
||
main.queue_free()
|
||
await process_frame
|
||
|
||
|
||
func _check_stage_camera_follows_player_with_wider_view() -> void:
|
||
root.size = Vector2i(1152, 648)
|
||
var stage_scene: PackedScene = load("res://scenes/stage/stage.tscn")
|
||
if stage_scene == null:
|
||
return
|
||
var stage: Node = stage_scene.instantiate()
|
||
root.add_child(stage)
|
||
await process_frame
|
||
var player := stage.get_node_or_null("ActorsContainer/Player") as Node2D
|
||
var camera := stage.get_node_or_null("Camera2D") as Camera2D
|
||
var gate := stage.get_node_or_null("BossRoomGate")
|
||
_expect(player != null, "Stage authored camera check should find Player")
|
||
_expect(camera != null, "Stage authored camera check should find Camera2D")
|
||
_expect(gate != null, "Stage authored camera check should find BossRoomGate")
|
||
if player != null and camera != null and gate != null:
|
||
_expect_bool(bool(stage.get("use_authored_camera_view")), false, "Stage should keep the x1 follow-camera baseline")
|
||
var camera_start := camera.global_position
|
||
_expect_vector(camera_start, Vector2(1180, 395), "Stage Camera2D should start over the left-spawn player (new2)")
|
||
_expect_float(camera.zoom.x, 1.25, "Stage Camera2D should keep the x1 zoom")
|
||
_expect_float(camera.zoom.y, 1.25, "Stage Camera2D should keep the x1 zoom")
|
||
player.global_position = Vector2(float(gate.get("gate_x")), player.global_position.y)
|
||
stage.call("_update_camera_follow")
|
||
var boss_entry_x := float(gate.get("gate_x")) + float(gate.get("wall_thickness"))
|
||
var half_view_width := get_root().size.x / (2.0 * camera.zoom.x)
|
||
_expect_float(camera.global_position.x + half_view_width, boss_entry_x, "Stage Camera2D should not show Boss room while the gate is sealed")
|
||
gate.call("unseal")
|
||
await process_frame
|
||
stage.call("_update_camera_follow")
|
||
_expect_vector(camera.global_position, player.global_position + Vector2(0.0, -165.0), "Stage Camera2D should follow Player after Boss room unlock")
|
||
stage.queue_free()
|
||
await process_frame
|
||
|
||
|
||
func _check_visible_ground_alignment() -> void:
|
||
var stage_scene: PackedScene = load("res://scenes/stage/stage.tscn")
|
||
if stage_scene == null:
|
||
return
|
||
var stage: Node = stage_scene.instantiate()
|
||
root.add_child(stage)
|
||
await process_frame
|
||
var player := stage.get_node_or_null("ActorsContainer/Player") as Node2D
|
||
var melee := stage.get_node_or_null("ActorsContainer/JinZhanMinion") as Node2D
|
||
var boss := stage.get_node_or_null("ActorsContainer/Boss") as Node2D
|
||
_expect(player != null, "Player should exist for anchor alignment check")
|
||
_expect(melee != null, "Initial minion should exist for anchor alignment check")
|
||
_expect(boss != null, "Boss should exist for anchor alignment check")
|
||
if player != null and melee != null and boss != null:
|
||
_expect_float(player.global_position.y, melee.global_position.y, "Player and minion anchors should share one horizontal line")
|
||
_expect_float(player.global_position.y, boss.global_position.y, "Player and Boss anchors should share one horizontal line")
|
||
stage.queue_free()
|
||
await process_frame
|
||
|
||
|
||
func _check_boss_behavior_tree_uses_beat_ticks() -> void:
|
||
var rhythm := root.get_node_or_null("RhythmManager")
|
||
if rhythm != null and rhythm.has_method("stop_manager"):
|
||
rhythm.call("stop_manager")
|
||
var bus := _ensure_event_bus()
|
||
var stage_scene: PackedScene = load("res://scenes/stage/stage.tscn")
|
||
if stage_scene == null:
|
||
return
|
||
var stage: Node = stage_scene.instantiate()
|
||
root.add_child(stage)
|
||
await process_frame
|
||
var boss: Node = stage.get_node("ActorsContainer/Boss")
|
||
var controller: Node = boss.get_node("ActionController")
|
||
var boss_tree: Node = boss.get_node("BossBehaviorTree")
|
||
boss.set("combat_enabled", true)
|
||
boss.set("stationary", false)
|
||
boss_tree.set("enabled", true)
|
||
boss_tree.set("decision_interval_beats", 2.0)
|
||
# 决策间隔在 future 相位会 x0.5（§18.1）。真实 TimeAnchorSystem 在测试
|
||
# 进程里会因锚点 Miss 在随机时刻把相位翻到 future，这里钉回 past，
|
||
# 保证 interval 断言按 1.0 缩放判定。
|
||
var phase_manager := root.get_node_or_null("TimePhaseManager")
|
||
if phase_manager != null and phase_manager.has_method("reset_to_initial"):
|
||
phase_manager.call("reset_to_initial", &"past")
|
||
# 相位钉回会触发 new3 §6.4 的切相位停顿；本段只验证节拍门控本身，
|
||
# 停顿契约由 test_minion_phase_system 覆盖，这里清掉。
|
||
boss_tree.set("_next_decision_beat", 0)
|
||
controller.connect("action_started", _on_action_started)
|
||
started_actions.clear()
|
||
await process_frame
|
||
await process_frame
|
||
_expect(started_actions.is_empty(), "BossBehaviorTree should not start attacks from delta time between beats")
|
||
|
||
bus.emit_signal("beat_ticked", 1)
|
||
await process_frame
|
||
_expect(not started_actions.is_empty(), "BossBehaviorTree should choose attacks on beat_ticked")
|
||
controller.call("_reset_to_idle")
|
||
boss.set("state", StringName("idle"))
|
||
started_actions.clear()
|
||
|
||
bus.emit_signal("beat_ticked", 2)
|
||
await process_frame
|
||
_expect(started_actions.is_empty(), "BossBehaviorTree should respect decision_interval_beats instead of attacking every frame")
|
||
bus.emit_signal("beat_ticked", 3)
|
||
await process_frame
|
||
_expect(not started_actions.is_empty(), "BossBehaviorTree should attack again on the next eligible beat grid")
|
||
stage.queue_free()
|
||
await process_frame
|
||
|
||
|
||
func _check_boss_entry_clears_precombat_chart_delay() -> void:
|
||
var rhythm := root.get_node_or_null("RhythmManager")
|
||
if rhythm != null and rhythm.has_method("stop_manager"):
|
||
rhythm.call("stop_manager")
|
||
var bus := _ensure_event_bus()
|
||
var stage_scene: PackedScene = load("res://scenes/stage/stage.tscn")
|
||
if stage_scene == null:
|
||
return
|
||
var stage: Node = stage_scene.instantiate()
|
||
root.add_child(stage)
|
||
await process_frame
|
||
var boss: Node = stage.get_node("ActorsContainer/Boss")
|
||
var controller: Node = boss.get_node("ActionController")
|
||
var boss_tree: Node = boss.get_node("BossBehaviorTree")
|
||
controller.connect("action_started", _on_action_started)
|
||
started_actions.clear()
|
||
boss.set("combat_enabled", false)
|
||
boss.set("stationary", true)
|
||
boss_tree.set("enabled", true)
|
||
boss_tree.call("_on_chart_event_upcoming", _make_chart_event(100, &"Boss", &"boss_lunging_stab"), 2.0)
|
||
_expect(int(boss_tree.get("_next_decision_beat")) > 1, "test setup should defer Boss decisions before room entry")
|
||
boss.set("combat_enabled", true)
|
||
boss.set("stationary", false)
|
||
bus.emit_signal("beat_ticked", 1)
|
||
await process_frame
|
||
_expect(not started_actions.is_empty(), "Boss should act on the first eligible beat after boss-room entry, even after precombat chart previews")
|
||
stage.queue_free()
|
||
await process_frame
|
||
|
||
|
||
func _check_boss_behavior_tree_handles_point_blank_pressure() -> void:
|
||
var rhythm := root.get_node_or_null("RhythmManager")
|
||
if rhythm != null and rhythm.has_method("stop_manager"):
|
||
rhythm.call("stop_manager")
|
||
var bus := _ensure_event_bus()
|
||
var stage_scene: PackedScene = load("res://scenes/stage/stage.tscn")
|
||
if stage_scene == null:
|
||
return
|
||
var stage: Node = stage_scene.instantiate()
|
||
root.add_child(stage)
|
||
await process_frame
|
||
var player: Node2D = stage.get_node("ActorsContainer/Player")
|
||
var boss: Node2D = stage.get_node("ActorsContainer/Boss")
|
||
var controller: Node = boss.get_node("ActionController")
|
||
var boss_tree: Node = boss.get_node("BossBehaviorTree")
|
||
boss.set("combat_enabled", true)
|
||
player.global_position = Vector2(100.0, 360.0)
|
||
boss.global_position = Vector2(170.0, 360.0)
|
||
boss.set("stationary", false)
|
||
boss_tree.set("enabled", true)
|
||
boss_tree.set("restrict_actions_by_time_phase", false)
|
||
boss_tree.set("decision_interval_beats", 1.0)
|
||
controller.connect("action_started", _on_action_started)
|
||
started_actions.clear()
|
||
bus.emit_signal("beat_ticked", 20)
|
||
await process_frame
|
||
_expect(not started_actions.is_empty(), "BossBehaviorTree should act when trapped at point blank")
|
||
if not started_actions.is_empty():
|
||
_expect(str(started_actions[started_actions.size() - 1]).begins_with("boss_combo"), "BossBehaviorTree should answer point-blank pressure with melee first, not by fleeing")
|
||
|
||
controller.call("_reset_to_idle")
|
||
boss.set("state", StringName("idle"))
|
||
boss_tree.set("_last_melee_beat", 21.0)
|
||
started_actions.clear()
|
||
bus.emit_signal("beat_ticked", 22)
|
||
await process_frame
|
||
_expect(not started_actions.is_empty(), "BossBehaviorTree should still act at point blank while melee is on cooldown")
|
||
if not started_actions.is_empty():
|
||
_expect_equal(started_actions[started_actions.size() - 1], &"boss_2way_shoot", "Point-blank pressure with melee on cooldown should be punished with the 2-way shot")
|
||
|
||
controller.call("_reset_to_idle")
|
||
boss.set("state", StringName("idle"))
|
||
boss_tree.set("_last_melee_beat", 23.0)
|
||
boss_tree.set("_last_two_way_beat", 23.0)
|
||
started_actions.clear()
|
||
bus.emit_signal("beat_ticked", 24)
|
||
await process_frame
|
||
_expect(not started_actions.is_empty(), "BossBehaviorTree should act when both melee and 2-way are on cooldown")
|
||
if not started_actions.is_empty():
|
||
_expect_equal(started_actions[started_actions.size() - 1], &"boss_retreat_dash", "BossBehaviorTree should only retreat once its point-blank answers are on cooldown")
|
||
|
||
controller.call("_reset_to_idle")
|
||
boss.set("state", StringName("idle"))
|
||
player.global_position = Vector2(100.0, 360.0)
|
||
boss.global_position = Vector2(360.0, 360.0)
|
||
started_actions.clear()
|
||
bus.emit_signal("beat_ticked", 25)
|
||
await process_frame
|
||
_expect(not started_actions.is_empty(), "BossBehaviorTree should follow a retreat with ranged pressure")
|
||
if not started_actions.is_empty():
|
||
_expect(str(started_actions[started_actions.size() - 1]).begins_with("boss_shoot"), "BossBehaviorTree should use a shoot action after creating range")
|
||
stage.queue_free()
|
||
await process_frame
|
||
|
||
|
||
func _check_boss_escapes_after_sustained_hit_chain() -> void:
|
||
var combat: Node = _ensure_combat_manager()
|
||
combat.call("_physics_process", 1.0 / 60.0)
|
||
var player: Node = load("res://scenes/characters/player.tscn").instantiate()
|
||
var boss: Node = load("res://scenes/enemies/boss.tscn").instantiate()
|
||
root.add_child(player)
|
||
root.add_child(boss)
|
||
await process_frame
|
||
var controller: Node = boss.get_node("ActionController")
|
||
var state_machine: Node = boss.get_node("StateMachine")
|
||
var escape_threshold := int(boss.get("escape_after_consecutive_hits"))
|
||
_expect(escape_threshold >= 3, "Boss should tolerate a short combo before burning its escape")
|
||
controller.connect("action_started", _on_action_started)
|
||
started_actions.clear()
|
||
boss.get_node("HealthComponent").call("set_values", 8000, 8000)
|
||
var player_action: Resource = load("res://resources/actions/ground_attack_left_1.tres")
|
||
player.get_node("DamageEmitter").call("configure_hit", player_action, {"label": "perfect"})
|
||
for hit_index: int in range(escape_threshold - 1):
|
||
combat.call("_physics_process", 1.0 / 60.0)
|
||
combat.call("resolve_hit", player.get_node("DamageEmitter"), boss.get_node("DamageReceiver"))
|
||
await process_frame
|
||
# 2026-07-05 定案：普攻恒霸体——打不出 Boss 硬直，但受击链照常累计。
|
||
_expect_equal(StringName(str(state_machine.call("build_context").get("life_state", &"Alive"))), &"Alive", "Boss should shrug off normal attacks without hitstun before the escape threshold")
|
||
_expect(not started_actions.has(&"boss_retreat_dash"), "Boss should not burn retreat before the hit chain threshold")
|
||
combat.call("_physics_process", 1.0 / 60.0)
|
||
combat.call("resolve_hit", player.get_node("DamageEmitter"), boss.get_node("DamageReceiver"))
|
||
await process_frame
|
||
_expect(started_actions.has(&"boss_retreat_dash"), "Boss should escape after a sustained hit chain")
|
||
_expect_equal(StringName(str(state_machine.call("build_context").get("life_state", &"Alive"))), &"Alive", "Boss should leave Hitstun when forced retreat starts")
|
||
_expect_int(int(controller.get("phase")), 1, "Boss forced retreat should start through ActionController Startup")
|
||
|
||
started_actions.clear()
|
||
for hit_index: int in range(escape_threshold + 1):
|
||
combat.call("_physics_process", 1.0 / 60.0)
|
||
combat.call("resolve_hit", player.get_node("DamageEmitter"), boss.get_node("DamageReceiver"))
|
||
await process_frame
|
||
_expect(not started_actions.has(&"boss_retreat_dash"), "Boss escape should respect its cooldown instead of chaining escapes")
|
||
player.queue_free()
|
||
boss.queue_free()
|
||
await process_frame
|
||
|
||
|
||
func _check_boss_driver_starts_beat_anchored_actions() -> void:
|
||
started_actions.clear()
|
||
var boss: Node = load("res://scenes/enemies/boss.tscn").instantiate()
|
||
root.add_child(boss)
|
||
await process_frame
|
||
var controller: Node = boss.get_node("ActionController")
|
||
var driver: Node = boss.get_node("EnemyActionDriver")
|
||
controller.connect("action_started", _on_action_started)
|
||
driver.call("start_action", &"boss_combo_1")
|
||
_expect(started_actions.has(&"boss_combo_1"), "Boss driver should start boss actions through ActionController")
|
||
_expect_equal(controller.get("beat_anchor_policy"), &"ANCHOR_ACTIVE", "Boss ActionController should keep Active beat anchoring")
|
||
_expect_int(int(controller.get("phase")), 1, "Boss action should enter Startup before Active")
|
||
boss.queue_free()
|
||
await process_frame
|
||
|
||
|
||
func _check_boss_projectile_request_and_visual() -> void:
|
||
projectile_requests.clear()
|
||
var bus := _ensure_event_bus()
|
||
if not bus.is_connected("projectile_requested", _on_projectile_requested):
|
||
bus.connect("projectile_requested", _on_projectile_requested)
|
||
var boss: Node = load("res://scenes/enemies/boss.tscn").instantiate()
|
||
root.add_child(boss)
|
||
await process_frame
|
||
var shoot: Resource = load("res://resources/actions/enemies/boss_shoot_1.tres")
|
||
_expect(shoot != null, "boss_shoot_1 should load for projectile request")
|
||
if shoot != null:
|
||
_expect_bool(bool(boss.get_node("ActionExecutor").call("execute", shoot, &"perfect", null)), true, "Boss projectile action should execute")
|
||
_expect_int(projectile_requests.size(), 1, "Boss shoot action should request one projectile at Active")
|
||
if not projectile_requests.is_empty():
|
||
var request := projectile_requests[0]
|
||
var spawn_position := request.get("spawn_position", Vector2.ZERO) as Vector2
|
||
var direction := request.get("direction", Vector2.ZERO) as Vector2
|
||
var context := request.get("context", {}) as Dictionary
|
||
_expect(spawn_position.x < boss.global_position.x, "Boss projectile should spawn from the muzzle side when facing left")
|
||
_expect(spawn_position.y < boss.global_position.y, "Boss projectile should spawn above the Boss root, not from the feet")
|
||
_expect(absf((boss.global_position.y - spawn_position.y) - 74.0) <= 2.0, "Boss projectile should spawn at the torso lane of the drawn bodies, got %.2f px above root" % (boss.global_position.y - spawn_position.y))
|
||
_expect(direction.x < 0.0, "Boss projectile should travel toward the current heading")
|
||
_expect_equal(StringName(str(context.get("team", &""))), &"enemy", "Boss projectile request should carry the enemy team context")
|
||
_expect(context.get("action", null) == shoot, "Boss projectile request should carry the shooting ActionData for damage resolution")
|
||
projectile_requests.clear()
|
||
var two_way: Resource = load("res://resources/actions/enemies/boss_2way_shoot.tres")
|
||
if two_way != null:
|
||
_expect_bool(bool(boss.get_node("ActionExecutor").call("execute", two_way, &"perfect", null)), true, "Boss two-way projectile action should execute")
|
||
_expect_int(projectile_requests.size(), 2, "Boss two-way shoot should request left and right projectiles")
|
||
if projectile_requests.size() == 2:
|
||
var first_direction := projectile_requests[0].get("direction", Vector2.ZERO) as Vector2
|
||
var second_direction := projectile_requests[1].get("direction", Vector2.ZERO) as Vector2
|
||
_expect(first_direction.x < 0.0 or second_direction.x < 0.0, "Boss two-way shoot should include a left projectile")
|
||
_expect(first_direction.x > 0.0 or second_direction.x > 0.0, "Boss two-way shoot should include a right projectile")
|
||
var projectile: Node = load("res://scenes/combat/player_projectile.tscn").instantiate()
|
||
root.add_child(projectile)
|
||
# 下面的帧号断言手动喂 _process/_physics_process；关闭引擎自动 tick，
|
||
# 避免 await 帧的真实 delta 混入动画计时造成帧号随墙钟抖动。
|
||
projectile.set_process(false)
|
||
projectile.set_physics_process(false)
|
||
await process_frame
|
||
_expect(projectile.has_method("max_travel_distance"), "Projectile should expose max_travel_distance for Boss spacing checks")
|
||
if projectile.has_method("max_travel_distance"):
|
||
var retreat_action: Resource = load("res://resources/actions/enemies/boss_retreat_dash.tres")
|
||
var beat_time := 0.5
|
||
var retreat_distance := float(boss.get("boss_lunge_speed")) * absf(float(retreat_action.get("move_mult_x"))) * float(retreat_action.get("action_beats")) * beat_time
|
||
_expect(float(projectile.call("max_travel_distance")) > retreat_distance + float(boss.get("projectile_spawn_forward")), "Projectile max range should exceed Boss retreat distance plus muzzle offset")
|
||
var sprite := projectile.get_node_or_null("Sprite") as Sprite2D
|
||
if sprite == null and projectile.get_child_count() > 0:
|
||
sprite = projectile.get_child(0) as Sprite2D
|
||
_expect(sprite != null, "Projectile should create a Sprite2D child")
|
||
if sprite != null:
|
||
_expect_equal(sprite.texture.resource_path, "res://assets/art/effects/effect_sheet.png", "Projectile should use effect_sheet.png")
|
||
_expect_int(sprite.hframes, 6, "effect_sheet is a 6x2 grid of 32px cells, not five columns")
|
||
_expect_int(sprite.vframes, 2, "effect_sheet should be treated as two rows")
|
||
projectile.call("_process", 0.13)
|
||
_expect_int(sprite.frame, 2, "Projectile flight animation should advance through the four flight frames")
|
||
projectile.call("_process", 0.13)
|
||
_expect_int(sprite.frame, 0, "Projectile flight animation should loop while flying instead of vanishing mid-air")
|
||
projectile.set("direction", Vector2.RIGHT)
|
||
for step: int in range(10):
|
||
projectile.call("_physics_process", 0.1)
|
||
_expect_bool(projectile.is_queued_for_deletion(), true, "Projectile should expire by travel range, not by animation time")
|
||
projectile.queue_free()
|
||
|
||
var hit_projectile: Node = load("res://scenes/combat/player_projectile.tscn").instantiate()
|
||
var player: Node = load("res://scenes/characters/player.tscn").instantiate()
|
||
root.add_child(hit_projectile)
|
||
root.add_child(player)
|
||
await process_frame
|
||
_expect(hit_projectile is Area2D, "Projectile root should be an Area2D so it can collide with DamageReceiver")
|
||
player.get_node("HealthComponent").call("set_values", 1000, 1000)
|
||
if hit_projectile is Area2D:
|
||
_ensure_combat_manager()
|
||
hit_projectile.call("_on_area_entered", player.get_node("DamageReceiver"))
|
||
_expect(int(player.get_node("HealthComponent").get("current")) < 1000, "Projectile collision should reduce Player health")
|
||
_expect_bool(bool(hit_projectile.get("visible")), false, "Projectile should hide immediately after a hit instead of appearing to pass through")
|
||
_expect_bool(hit_projectile.is_queued_for_deletion(), true, "Projectile should be queued for deletion after a hit")
|
||
hit_projectile.queue_free()
|
||
|
||
var sweep_projectile: Node = load("res://scenes/combat/player_projectile.tscn").instantiate()
|
||
root.add_child(sweep_projectile)
|
||
await process_frame
|
||
player.global_position = Vector2(100.0, 0.0)
|
||
player.get_node("HealthComponent").call("set_values", 1000, 1000)
|
||
player.get_node("StateMachine").call("set_life_state", &"Alive")
|
||
sweep_projectile.set("direction", Vector2.RIGHT)
|
||
(sweep_projectile as Node2D).global_position = player.global_position + Vector2(-30.0, -72.0)
|
||
await physics_frame
|
||
(sweep_projectile as Node2D).global_position = player.global_position + Vector2(-30.0, -72.0)
|
||
_expect(sweep_projectile.has_method("_physics_process"), "Projectile should move and sweep for hits during physics ticks")
|
||
if sweep_projectile.has_method("_physics_process"):
|
||
sweep_projectile.call("_physics_process", 1.0 / 60.0)
|
||
_expect(int(player.get_node("HealthComponent").get("current")) < 1000, "Projectile sweep should hit before the visual center overlaps Player")
|
||
_expect_bool(bool(sweep_projectile.get("visible")), false, "Projectile sweep hit should hide immediately")
|
||
_expect((sweep_projectile as Node2D).global_position.x < player.global_position.x - 11.0, "Projectile center should still be outside Player hurtbox when sweep hit resolves")
|
||
sweep_projectile.queue_free()
|
||
|
||
var physical_projectile: Node = load("res://scenes/combat/player_projectile.tscn").instantiate()
|
||
root.add_child(physical_projectile)
|
||
await process_frame
|
||
player.global_position = Vector2(100.0, 0.0)
|
||
player.get_node("HealthComponent").call("set_values", 1000, 1000)
|
||
player.get_node("StateMachine").call("set_life_state", &"Alive")
|
||
physical_projectile.set("direction", Vector2.RIGHT)
|
||
(physical_projectile as Node2D).global_position = player.global_position + Vector2(-30.0, -70.0)
|
||
_expect((int((physical_projectile as Area2D).collision_mask) & int(player.get_node("DamageReceiver").collision_layer)) != 0, "Projectile mask should include Player DamageReceiver layer")
|
||
_expect((int(player.get_node("DamageReceiver").collision_mask) & int((physical_projectile as Area2D).collision_layer)) != 0, "Player DamageReceiver mask should include projectile layer")
|
||
for frame: int in range(4):
|
||
await physics_frame
|
||
_expect(int(player.get_node("HealthComponent").get("current")) < 1000, "Boss projectile at muzzle lane should hit Player through real Area2D physics overlap")
|
||
if is_instance_valid(physical_projectile):
|
||
_expect_bool(bool(physical_projectile.get("visible")), false, "Physical projectile hit should hide immediately")
|
||
_expect_bool(physical_projectile.is_queued_for_deletion(), true, "Physical projectile hit should queue deletion")
|
||
physical_projectile.queue_free()
|
||
player.queue_free()
|
||
boss.queue_free()
|
||
await process_frame
|
||
|
||
|
||
func _check_bidirectional_damage_flow() -> void:
|
||
var combat: Node = _ensure_combat_manager()
|
||
var player: Node = load("res://scenes/characters/player.tscn").instantiate()
|
||
var boss: Node = load("res://scenes/enemies/boss.tscn").instantiate()
|
||
root.add_child(player)
|
||
root.add_child(boss)
|
||
await process_frame
|
||
player.get_node("HealthComponent").call("set_values", 1000, 1000)
|
||
boss.get_node("HealthComponent").call("set_values", 8000, 8000)
|
||
var player_action: Resource = load("res://resources/actions/ground_attack_left_1.tres")
|
||
var boss_action: Resource = load("res://resources/actions/enemies/boss_combo_1.tres")
|
||
player.get_node("DamageEmitter").call("configure_hit", player_action, {"label": "perfect"})
|
||
boss.get_node("DamageEmitter").call("configure_hit", boss_action, {"label": "perfect"})
|
||
combat.call("resolve_hit", player.get_node("DamageEmitter"), boss.get_node("DamageReceiver"))
|
||
combat.call("resolve_hit", boss.get_node("DamageEmitter"), player.get_node("DamageReceiver"))
|
||
_expect(int(boss.get_node("HealthComponent").get("current")) < 8000, "Player hitbox should damage Boss HealthComponent through CombatManager")
|
||
_expect(int(player.get_node("HealthComponent").get("current")) < 1000, "Boss hitbox should damage Player HealthComponent through CombatManager")
|
||
player.queue_free()
|
||
boss.queue_free()
|
||
await process_frame
|
||
|
||
|
||
func _check_boss_death_state_is_terminal() -> void:
|
||
var boss: Node = load("res://scenes/enemies/boss.tscn").instantiate()
|
||
root.add_child(boss)
|
||
await process_frame
|
||
var state_machine: Node = boss.get_node("StateMachine")
|
||
var animation_player: AnimationPlayer = boss.get_node("AnimationPlayer")
|
||
var motion: Node = boss.get_node("MotionExecutor")
|
||
var emitter: Area2D = boss.get_node("DamageEmitter")
|
||
var receiver: Area2D = boss.get_node("DamageReceiver")
|
||
var behavior_tree: Node = boss.get_node("BossBehaviorTree")
|
||
var action: Resource = load("res://resources/actions/enemies/boss_lunging_stab.tres")
|
||
emitter.call("configure_hit", action, {"label": "perfect"})
|
||
motion.call("execute", action, Vector2.LEFT, 0.5, 120.0)
|
||
boss.set("velocity", Vector2(80.0, 0.0))
|
||
state_machine.call("set_life_state", &"Dead")
|
||
boss.call("handle_animations")
|
||
_expect_equal(animation_player.current_animation, "boss_die", "Boss should start the death animation when life_state becomes Dead")
|
||
_expect_bool(bool(animation_player.is_playing()), true, "Boss death animation should play when Dead is first observed")
|
||
_expect_bool(bool(emitter.get("monitoring")), false, "Boss death should disable active hitboxes")
|
||
_expect_bool(bool(motion.get("active")), false, "Boss death should cancel active movement")
|
||
_expect_equal(boss.get("velocity"), Vector2.ZERO, "Boss death should stop current velocity")
|
||
_expect_bool(bool(behavior_tree.get("enabled")), false, "Boss death should stop BehaviorTree decisions")
|
||
_expect_int(int(boss.get("collision_layer")), 64, "Boss body collision layer should remain inspectable after death")
|
||
_expect_int(int(boss.get("collision_mask")), 33, "Boss body collision mask should remain restored after death")
|
||
_expect_int(int(receiver.get("collision_layer")), 4, "Boss DamageReceiver layer should remain configured after death")
|
||
animation_player.advance(animation_player.get_animation("boss_die").length + 0.2)
|
||
animation_player.stop()
|
||
boss.call("handle_animations")
|
||
_expect_bool(bool(animation_player.is_playing()), false, "Boss death animation should not restart after it has already played once")
|
||
boss.queue_free()
|
||
await process_frame
|
||
|
||
|
||
func _check_boss_script_debt_cleanup() -> void:
|
||
var boss_source := _read_text("res://scenes/enemies/boss.gd")
|
||
var tree_source := _read_text("res://scenes/enemies/boss_behavior_tree.gd")
|
||
_expect(not boss_source.contains("iron_sentinel"), "boss.gd should not keep iron_sentinel art debt")
|
||
_expect(not boss_source.contains("_knockback_time_left"), "boss.gd should not keep the local knockback timer hack")
|
||
_expect(not tree_source.to_lower().contains("limboai"), "boss_behavior_tree.gd should not reference limboai")
|
||
_expect(not tree_source.contains("skill_"), "boss_behavior_tree.gd should use new boss ActionData ids")
|
||
|
||
|
||
func _boss_animation_names() -> Array[StringName]:
|
||
return [
|
||
&"boss_idle",
|
||
&"boss_run",
|
||
&"boss_dash",
|
||
&"boss_jump_fall",
|
||
&"boss_take_hit",
|
||
&"boss_die",
|
||
&"boss_ground_combo_1",
|
||
&"boss_ground_combo_2",
|
||
&"boss_ground_combo_3",
|
||
&"boss_lunging_stab",
|
||
&"boss_shoot_1",
|
||
&"boss_shoot_2",
|
||
&"boss_2way_shoot",
|
||
]
|
||
|
||
|
||
func _visible_sprite_bottom_global_y(sprite: Sprite2D) -> float:
|
||
if sprite.texture == null:
|
||
failures.append("%s should have a texture" % sprite.get_path())
|
||
return INF
|
||
var image := sprite.texture.get_image()
|
||
if image == null or image.is_empty():
|
||
failures.append("%s texture image should be readable" % sprite.get_path())
|
||
return INF
|
||
var hframes := maxi(1, sprite.hframes)
|
||
var vframes := maxi(1, sprite.vframes)
|
||
var frame_width := image.get_width() / hframes
|
||
var frame_height := image.get_height() / vframes
|
||
var frame_index := clampi(sprite.frame, 0, hframes * vframes - 1)
|
||
var column := frame_index % hframes
|
||
var row := int(frame_index / hframes)
|
||
var bottom := -1
|
||
for y: int in range(frame_height):
|
||
for x: int in range(frame_width):
|
||
var pixel := image.get_pixel(column * frame_width + x, row * frame_height + y)
|
||
if pixel.a > 0.01:
|
||
bottom = y
|
||
if bottom < 0:
|
||
failures.append("%s should contain visible pixels" % sprite.get_path())
|
||
return INF
|
||
return sprite.to_global(sprite.offset + Vector2(0.0, bottom)).y
|
||
|
||
|
||
func _world_to_screen(world_position: Vector2, camera_position: Vector2, zoom: Vector2, viewport_size: Vector2) -> Vector2:
|
||
return (world_position - camera_position) * zoom + viewport_size * 0.5
|
||
|
||
|
||
func _on_action_started(action: Resource, _intent) -> void:
|
||
started_actions.append(StringName(str(action.get("id"))))
|
||
|
||
|
||
func _on_projectile_requested(projectile_scene: PackedScene, spawn_position: Vector2, direction: Vector2, context: Dictionary = {}) -> void:
|
||
projectile_requests.append({
|
||
"scene": projectile_scene,
|
||
"spawn_position": spawn_position,
|
||
"direction": direction,
|
||
"context": context,
|
||
})
|
||
|
||
|
||
func _ensure_event_bus() -> Node:
|
||
var existing := root.get_node_or_null("EventBus")
|
||
if existing != null:
|
||
return existing
|
||
var bus: Node = load("res://autoload/event_bus.gd").new()
|
||
bus.name = "EventBus"
|
||
root.add_child(bus)
|
||
return bus
|
||
|
||
|
||
func _ensure_combat_manager() -> Node:
|
||
var existing := root.get_node_or_null("CombatManager")
|
||
if existing != null:
|
||
return existing
|
||
var combat: Node = load("res://autoload/combat_manager.gd").new()
|
||
combat.name = "CombatManager"
|
||
root.add_child(combat)
|
||
return combat
|
||
|
||
|
||
func _make_chart_event(beat: int, target_id: StringName, action_id: StringName) -> Resource:
|
||
var event_script: Script = load("res://resources/chart_event.gd")
|
||
var event: Resource = event_script.new()
|
||
event.set("event_type", &"enemy_action")
|
||
event.set("beat_index", beat)
|
||
event.set("target_id", target_id)
|
||
event.set("action_id", action_id)
|
||
event.set("lead_beats", 2.0)
|
||
return event
|
||
|
||
|
||
func _read_text(path: String) -> String:
|
||
var file := FileAccess.open(path, FileAccess.READ)
|
||
if file == null:
|
||
failures.append("Could not read %s" % path)
|
||
return ""
|
||
return file.get_as_text()
|
||
|
||
|
||
func _expect(condition: bool, label: String) -> void:
|
||
if not condition:
|
||
failures.append(label)
|
||
|
||
|
||
func _expect_equal(actual: Variant, expected: Variant, label: String) -> void:
|
||
if actual != expected:
|
||
failures.append("%s: expected %s, got %s" % [label, expected, actual])
|
||
|
||
|
||
func _expect_bool(actual: bool, expected: bool, label: String) -> void:
|
||
if actual != expected:
|
||
failures.append("%s: expected %s, got %s" % [label, expected, actual])
|
||
|
||
|
||
func _expect_float(actual: float, expected: float, label: String) -> void:
|
||
if not is_equal_approx(actual, expected):
|
||
failures.append("%s: expected %.3f, got %.3f" % [label, expected, actual])
|
||
|
||
|
||
func _expect_vector(actual: Vector2, expected: Vector2, label: String) -> void:
|
||
if actual.distance_to(expected) > 0.03:
|
||
failures.append("%s: expected %s, got %s" % [label, expected, actual])
|
||
|
||
|
||
func _expect_int(actual: int, expected: int, label: String) -> void:
|
||
if actual != expected:
|
||
failures.append("%s: expected %d, got %d" % [label, expected, actual])
|
||
|
||
|
||
func _finish() -> void:
|
||
if failures.is_empty():
|
||
print("PASS boss integration")
|
||
quit(0)
|
||
else:
|
||
for failure: String in failures:
|
||
push_error(failure)
|
||
quit(1)
|