diff --git a/runtime/compat/p9_0_root_facade.gd b/runtime/compat/p9_0_root_facade.gd index 89b0a4e8..5fe2e59c 100644 --- a/runtime/compat/p9_0_root_facade.gd +++ b/runtime/compat/p9_0_root_facade.gd @@ -2309,7 +2309,21 @@ func commit_phase_impact(phase: int, refresh_runtime := true) -> void: var event: Dictionary = result["events"][0] play_cue(String(event["cue"])) var feedback_target := legacy_feedback_target(String(event["target_member_id"])) - emit_battle_feedback(phase, feedback_target, int(event["delta"]), String(event["qualifier_zh"]), String(event["qualifier_en"]), String(event["tier"])) + emit_battle_feedback( + phase, + feedback_target, + int(event["delta"]), + String(event["qualifier_zh"]), + String(event["qualifier_en"]), + String(event["tier"]), + { + "encounter_id": String(event["encounter_id"]), + "source_member_id": String(event["source_member_id"]), + "target_member_id": String(event["target_member_id"]), + "cue": String(event["cue"]), + "vfx": battle_feedback_vfx_kind(event), + } + ) if refresh_runtime and page in [AppPage.BATTLE, AppPage.SECOND_BATTLE, AppPage.THIRD_BATTLE, AppPage.FOURTH_BATTLE, AppPage.FIFTH_BATTLE]: render() @@ -2321,6 +2335,15 @@ func legacy_feedback_target(member_id: String) -> String: return slot if not slot.is_empty() else member_id +func battle_feedback_vfx_kind(event: Dictionary) -> String: + if int(event.get("delta", 0)) > 0: + return "heal" + var target_id := String(event.get("target_member_id", "")) + if target_id == visible_member_id(0) and profession_defense_state(target_id) != "idle": + return "guard" + return "hit" + + func commit_second_phase_impact(phase: int, refresh_runtime := true) -> void: commit_phase_impact(phase, refresh_runtime) @@ -2338,15 +2361,18 @@ func commit_fifth_phase_impact(phase: int, refresh_runtime := true) -> void: -func emit_battle_feedback(phase: int, target: String, delta: int, qualifier_zh: String, qualifier_en: String, tier: String) -> void: - feedback_presenter.present({ +func emit_battle_feedback(phase: int, target: String, delta: int, qualifier_zh: String, qualifier_en: String, tier: String, binding: Dictionary = {}) -> void: + var payload := { "phase": phase, "target": target, "delta": delta, "qualifier_zh": qualifier_zh, "qualifier_en": qualifier_en, "tier": tier, - }) + } + for key in binding: + payload[key] = binding[key] + feedback_presenter.present(payload) func reset_battle_feedback() -> void: @@ -3246,7 +3272,8 @@ func render_battle_feedback(actor_width: float, actor_height: float) -> void: battle_feedback_label.add_theme_constant_override("shadow_offset_y", 3) display_root.add_child(battle_feedback_label) - var vfx_texture: Texture2D = VFX["heal"] if delta > 0 else (VFX["guard"] if int(active_battle_feedback["phase"]) == 2 else VFX["hit"]) + var vfx_kind := String(active_battle_feedback.get("vfx", "heal" if delta > 0 else ("guard" if int(active_battle_feedback["phase"]) == 2 else "hit"))) + var vfx_texture: Texture2D = VFX.get(vfx_kind, VFX["hit"]) var vfx_diameter := actor_height * (0.31 if active_battle_feedback["tier"] == "large" else 0.25) battle_feedback_vfx = add_vfx( vfx_texture, @@ -3254,6 +3281,10 @@ func render_battle_feedback(actor_width: float, actor_height: float) -> void: vfx_diameter ) battle_feedback_vfx.name = "BattleFeedbackVFX" + for key in ["encounter_id", "source_member_id", "target_member_id", "cue", "vfx"]: + if active_battle_feedback.has(key): + battle_feedback_label.set_meta(key, active_battle_feedback[key]) + battle_feedback_vfx.set_meta(key, active_battle_feedback[key]) func update_battle_feedback_visual() -> void: @@ -3281,6 +3312,8 @@ func update_battle_feedback_visual() -> void: front_sprite.position.x = front_base_position.x - recoil elif active_battle_feedback["target"] == "rear" and rear_sprite != null and is_instance_valid(rear_sprite): rear_sprite.position.x = rear_base_position.x - recoil + elif active_battle_feedback["target"] == "added" and added_rear_sprite != null and is_instance_valid(added_rear_sprite): + added_rear_sprite.position.x = added_rear_base_position.x - recoil elif active_battle_feedback["target"] == "enemy" and enemy_sprite != null and is_instance_valid(enemy_sprite): enemy_sprite.position.x = enemy_base_position.x + recoil diff --git a/runtime/tests/p9_1/battle_readability_continuity_test.gd b/runtime/tests/p9_1/battle_readability_continuity_test.gd new file mode 100644 index 00000000..eba60192 --- /dev/null +++ b/runtime/tests/p9_1/battle_readability_continuity_test.gd @@ -0,0 +1,248 @@ +extends SceneTree + +const MainScene = preload("res://main.tscn") +const VIEWPORT_SIZE := Vector2i(844, 390) + +var failures: Array[String] = [] +var viewport: SubViewport +var capture_root := "" +var verified_events := 0 + + +func _initialize() -> void: + call_deferred("run_test") + + +func run_test() -> void: + viewport = SubViewport.new() + viewport.size = VIEWPORT_SIZE + viewport.render_target_update_mode = SubViewport.UPDATE_ALWAYS + root.add_child(viewport) + capture_root = OS.get_environment("ABG_P9_1_BATTLE_CAPTURE_ROOT") + if not capture_root.is_empty(): + DirAccess.make_dir_recursive_absolute(capture_root) + + var game := await create_game() + await prepare_exceptional_battle_three(game) + verify_approach(game, ["Hearthguard", "Farstring", "Kindhand"]) + game.advance_battle_phase() + expect(game.facade.enemy_animation_state() == "telegraph", "battle three pressure is telegraphed") + expect(game.facade.battle_event_text().contains("艾连"), "battle three telegraph names the current lead") + game.advance_battle_phase() + await verify_bound_impact(game, 2, "", "Hearthguard", "guard", "guard", "front") + game.advance_battle_phase() + verify_accessibility_invariance(game, "Farstring", "draw_release") + await verify_bound_impact(game, 3, "Farstring", "enemy", "draw_release", "hit", "enemy") + await capture_state("01-battle-three-farstring") + game.advance_battle_phase() + await verify_bound_impact(game, 4, "Kindhand", "Hearthguard", "lantern_heal", "heal", "front") + await capture_state("02-battle-three-kindhand") + game.advance_battle_phase() + expect(game.facade.later_battle_animation_state("Hearthguard") == "basic_attack", "battle three lead performs the finishing action") + game.advance_battle_phase() + expect(game.facade.enemy_animation_state() == "death", "battle three enemy uses the death animation") + game.advance_battle_phase() + expect(game.page == game.AppPage.SESSION_RESULT, "battle three reaches its victory result") + + game.open_route_board() + game.choose_route("R6-03") + game.open_route_review() + game.commit_route() + game.advance_battle_phase() + expect(game.facade.enemy_animation_state() == "telegraph", "route pressure is telegraphed before impact") + game.advance_battle_phase() + await verify_bound_impact(game, 2, "", "Kindhand", "idle", "hit", "added") + expect(game.facade.added_rear_sprite.position.x < game.facade.added_rear_base_position.x, "third-position damage recoils the correct actor") + await capture_state("03-battle-four-marked-third") + game.advance_battle_phase() + await verify_bound_impact(game, 3, "Farstring", "enemy", "draw_release", "hit", "enemy") + game.advance_battle_phase() + await verify_bound_impact(game, 4, "Kindhand", "Kindhand", "lantern_heal", "heal", "added") + resolve_remaining_battle(game, 4, 7) + expect(game.page == game.AppPage.SECOND_CYCLE_RESULT, "battle four reaches its victory result") + + game.open_training() + game.choose_training("rear") + game.open_training_review() + game.commit_training() + verify_approach(game, ["Hearthguard", "Farstring", "Kindhand"]) + game.advance_battle_phase() + await verify_bound_impact(game, 1, "Farstring", "enemy", "draw_release", "hit", "enemy") + await capture_state("04-battle-five-trained-farstring") + resolve_remaining_battle(game, 1, 7) + expect(game.page == game.AppPage.THIRD_CYCLE_RESULT, "trained Farstring path reaches the final result") + await destroy_game(game) + + await verify_training_action("front", 2, "Hearthguard", "", "Hearthguard", "guard", "guard", "front") + await verify_training_action("added", 5, "Kindhand", "Kindhand", "Kindhand", "lantern_heal", "heal", "added") + + viewport.queue_free() + await settle(90) + if failures.is_empty(): + print("ABG_P9_1_BATTLE_READABILITY_CONTINUITY_OK battles=3,4,5 events=%d formation=HG,FS,KH training=HG,FS,KH reduced_motion=true mute_captions=true low_power=true vfx=guard,hit,heal added_recoil=true bounds=844x390" % verified_events) + quit(0) + else: + for failure in failures: + push_error(failure) + quit(1) + + +func create_game() -> Control: + var game := MainScene.instantiate() + game.auto_boot = false + game.audio_enabled = false + viewport.add_child(game) + await settle(10) + game.locale = "zh_CN" + game.muted = true + game.boot_verified = true + game.page = game.AppPage.MAIN_MENU + game.render() + return game + + +func prepare_exceptional_battle_three(game: Control) -> void: + start_pair(game, "Farstring", "Kindhand") + resolve_remaining_battle(game, 0, 6) + game.open_adaptation() + game.choose_adaptation("EQ-002") + game.begin_second_battle() + resolve_remaining_battle(game, 0, 6) + game.open_guild_return() + game.choose_guild_option("recruit_rear") + game.begin_third_battle() + expect(game.facade.visible_member_ids() == ["Hearthguard", "Farstring", "Kindhand"], "Guild re-formation creates the declared visible order") + + +func prepare_exceptional_battle_five(game: Control, training_slot: String) -> void: + await prepare_exceptional_battle_three(game) + resolve_remaining_battle(game, 0, 7) + game.open_route_board() + game.choose_route("R6-03") + game.open_route_review() + game.commit_route() + resolve_remaining_battle(game, 0, 7) + game.open_training() + game.choose_training(training_slot) + game.open_training_review() + game.commit_training() + + +func verify_training_action(slot: String, phase: int, member_id: String, source_id: String, target_id: String, expected_state: String, expected_vfx: String, expected_slot: String) -> void: + var game := await create_game() + await prepare_exceptional_battle_five(game, slot) + for current_phase in range(phase): + game.advance_battle_phase() + expect(game.battle_phase == phase, "%s training reaches phase %d" % [member_id, phase]) + await verify_bound_impact(game, phase, source_id, target_id, expected_state, expected_vfx, expected_slot) + await destroy_game(game) + + +func verify_approach(game: Control, members: Array[String]) -> void: + expect(game.battle_phase == 0, "battle opens in the approach phase") + expect(game.facade.enemy_animation_state() == "advance", "enemy advances during approach") + for member_id in members: + expect(game.facade.later_battle_animation_state(member_id) == "advance", "%s advances without an identity swap" % member_id) + var caption: String = game.facade.battle_event_text() + expect(caption.contains("推进") or caption.contains("进入"), "approach phase has a readable caption") + + +func verify_accessibility_invariance(game: Control, member_id: String, expected_state: String) -> void: + var snapshot: Dictionary = game.facade.session_state.snapshot() + var caption: String = game.facade.battle_event_text() + var duration: float = game.phase_duration(game.battle_phase) + var state: String = game.facade.later_battle_animation_state(member_id) + game.reduced_motion = true + game.muted = true + game.facade.presentation_settings.low_power = true + game.render() + expect(game.facade.session_state.snapshot() == snapshot, "presentation settings do not mutate the domain snapshot") + expect(game.facade.battle_event_text() == caption, "mute/captions preserve the event caption") + expect(is_equal_approx(game.phase_duration(game.battle_phase), duration), "low power preserves battle duration") + expect(game.facade.later_battle_animation_state(member_id) == state and state == expected_state, "reduced motion preserves authored action state") + expect(game.facade.animation_frame_index(member_id, expected_state, 0.25) > 0, "reduced motion keeps essential action frames") + game.reduced_motion = false + game.facade.presentation_settings.low_power = false + game.render() + + +func verify_bound_impact(game: Control, phase: int, source_id: String, target_id: String, expected_state: String, expected_vfx: String, expected_slot: String) -> void: + expect(game.battle_phase == phase, "impact is checked in phase %d" % phase) + var action_member := source_id if not source_id.is_empty() else target_id + var actual_state: String = game.facade.enemy_animation_state() if action_member == "enemy" else game.facade.later_battle_animation_state(action_member) + expect(actual_state == expected_state, "phase %d binds %s to %s" % [phase, action_member, expected_state]) + var facts_before: int = game.facade.session_state.facts.size() + game.commit_phase_impact(phase) + expect(game.facade.session_state.facts.size() == facts_before + 1, "phase %d commits one semantic event" % phase) + if game.facade.session_state.facts.size() <= facts_before: + return + var event: Dictionary = game.facade.session_state.facts[-1] + var feedback: Dictionary = game.active_battle_feedback + expect(String(event.get("source_member_id", "")) == source_id, "phase %d semantic source is stable" % phase) + expect(String(event.get("target_member_id", "")) == target_id, "phase %d semantic target is stable" % phase) + expect(String(feedback.get("source_member_id", "")) == source_id, "phase %d feedback preserves source identity" % phase) + expect(String(feedback.get("target_member_id", "")) == target_id, "phase %d feedback preserves target identity" % phase) + expect(String(feedback.get("target", "")) == expected_slot, "phase %d feedback targets the current visible slot" % phase) + expect(String(feedback.get("cue", "")) == String(event.get("cue", "")), "phase %d feedback preserves the impact cue" % phase) + expect(String(feedback.get("vfx", "")) == expected_vfx, "phase %d uses %s VFX" % [phase, expected_vfx]) + var label := find_control(game, "BattleFeedbackLabel") + var vfx := find_control(game, "BattleFeedbackVFX") + expect(label != null and vfx != null, "phase %d renders number and VFX" % phase) + if label != null: + expect(String(label.get_meta("target_member_id", "")) == target_id, "phase %d number remains bound to target identity" % phase) + expect(label.get_global_rect().position.y >= 164.0, "phase %d number does not cover the event ribbon") + if vfx != null: + expect(String(vfx.get_meta("vfx", "")) == expected_vfx, "phase %d rendered VFX matches payload" % phase) + game.battle_feedback_clock = 0.10 + game.update_battle_feedback_visual() + verified_events += 1 + + +func start_pair(game: Control, first: String, second: String) -> void: + game.start_new_game() + game.open_recruit_selection() + game.toggle_recruit(first) + game.toggle_recruit(second) + game.review_automatic_formation() + game.commit_formation() + + +func resolve_remaining_battle(game: Control, current_phase: int, phase_count: int) -> void: + for phase in range(current_phase, phase_count): + game.advance_battle_phase() + + +func capture_state(state_name: String) -> void: + if capture_root.is_empty(): + return + await settle(7) + await RenderingServer.frame_post_draw + var image := viewport.get_texture().get_image() + var error := image.save_png(capture_root.path_join(state_name + ".png")) + if error != OK: + failures.append("capture %s failed with %s" % [state_name, error]) + + +func destroy_game(game: Control) -> void: + game.queue_free() + await settle(60) + + +func find_control(node: Node, node_name: String) -> Control: + if node.name == node_name and node is Control and not node.is_queued_for_deletion(): + return node + for child in node.get_children(): + var found := find_control(child, node_name) + if found != null: + return found + return null + + +func settle(frames: int) -> void: + for frame in range(frames): + await process_frame + + +func expect(condition: bool, message: String) -> void: + if not condition: + failures.append("P9.1 battle readability/continuity: %s" % message)