extends SceneTree ## new1 定案 (2026-07-05): 节奏点一次性消耗 + 双击容错 + 空按 MISS 触发 0.5s ## 输入锁定，锁定期间按键完全无效；预置判定（测试/AI）绕过门控。 var failures: Array[String] = [] var started: Array[StringName] = [] var rejected: Array[StringName] = [] var judged: Array[Dictionary] = [] func _init() -> void: _run.call_deferred() func _run() -> void: _run_rhythm_gate_unit() await _run_controller_integration() _finish() func _run_rhythm_gate_unit() -> void: var rhythm_script: Script = load("res://autoload/rhythm_manager.gd") _expect(rhythm_script != null, "RhythmManager script should load") if rhythm_script == null: return var rhythm: Node = rhythm_script.new() rhythm.set("starts_on_ready", false) # 钉住时钟：running + 冻结 song_position，锁定时长可被推进的时间跨过。 rhythm.set("running", true) rhythm.set("_clock_paused", true) rhythm.set("_paused_song_position", 2.0) rhythm.set("input_lockout_seconds", 0.5) _expect_string(str(rhythm.call("gate_judged_input", _rating("perfect", 4))), "ok", "first press on beat 4 should pass") _expect_string(str(rhythm.call("gate_judged_input", _rating("good", 4))), "ignored", "double-tap on consumed beat 4 should be ignored once") _expect_string(str(rhythm.call("gate_judged_input", _rating("good", 4))), "miss", "third press on consumed beat 4 should downgrade to miss") _expect_bool(bool(rhythm.call("is_input_locked")), true, "downgraded miss should start the input lockout") _expect_string(str(rhythm.call("gate_judged_input", _rating("perfect", 5))), "ignored", "press during lockout should be ignored even if on-time") rhythm.set("_paused_song_position", 2.6) _expect_bool(bool(rhythm.call("is_input_locked")), false, "lockout should expire after input_lockout_seconds") _expect_string(str(rhythm.call("gate_judged_input", _rating("perfect", 5))), "ok", "beat 5 should be consumable after lockout expires") _expect_string(str(rhythm.call("gate_judged_input", _rating("miss", 6))), "miss", "off-window press should stay miss") _expect_bool(bool(rhythm.call("is_input_locked")), true, "off-window miss should start the input lockout") rhythm.set("_paused_song_position", 3.2) _expect_string(str(rhythm.call("gate_judged_input", _rating("bad", 7))), "ok", "fresh beat after lockout should pass") rhythm.call("start") rhythm.set("running", true) rhythm.set("_clock_paused", true) rhythm.set("_paused_song_position", 2.0) _expect_string(str(rhythm.call("gate_judged_input", _rating("perfect", 4))), "ok", "start() should clear consumed beats and lockout") rhythm.free() func _run_controller_integration() -> void: var autoload_rhythm := root.get_node_or_null("RhythmManager") _expect(autoload_rhythm != null, "RhythmManager autoload should exist") if autoload_rhythm == null: return # 钉住全局时钟，让门控/锁定完全确定。 if bool(autoload_rhythm.get("playing")): autoload_rhythm.call("stop") autoload_rhythm.set("running", true) autoload_rhythm.set("_clock_paused", true) autoload_rhythm.set("_paused_song_position", 10.0) autoload_rhythm.set("_lockout_until", -1.0) autoload_rhythm.call("_prune_consumed_beats", 0) (autoload_rhythm.get("_consumed_beats") as Dictionary).clear() autoload_rhythm.set("input_lockout_seconds", 0.5) var fixture := await _controller_fixture() if fixture.is_empty(): return var controller: Node = fixture["controller"] var combo: Node = fixture["combo"] controller.connect("action_started", _on_action_started) controller.connect("action_rejected", _on_action_rejected) _event_bus().connect("judgement_made", _on_judgement_made) controller.call("submit_intent", _live_intent(&"A", &"a", "perfect", 20)) _expect_array(combo.call("get_slots"), [&"A"], "live perfect should enter ComboWindow") _expect_int(started.size(), 1, "live perfect should start an action") controller.call("_reset_to_idle") var judged_before := judged.size() controller.call("submit_intent", _live_intent(&"A", &"a", "perfect", 20)) _expect_array(combo.call("get_slots"), [&"A"], "double-tap on consumed beat should leave slots untouched") _expect_int(started.size(), 1, "double-tap on consumed beat should not start an action") _expect_string(str(rejected[rejected.size() - 1]), "input_ignored", "double-tap should reject as input_ignored") _expect_int(judged.size(), judged_before, "ignored input should emit no judgement feedback") controller.call("_reset_to_idle") controller.call("submit_intent", _live_intent(&"A", &"a", "perfect", 20)) _expect_array(combo.call("get_slots"), [&"A", &"Ø"], "third press on consumed beat should record a miss slot") _expect_string(str(judged[judged.size() - 1].get("quality")), "miss", "third press should emit a miss judgement") _expect_bool(bool(autoload_rhythm.call("is_input_locked")), true, "downgraded miss should lock input") controller.call("_reset_to_idle") controller.call("submit_intent", _live_intent(&"A", &"a", "perfect", 21)) _expect_string(str(rejected[rejected.size() - 1]), "input_locked", "press during lockout should reject as input_locked") _expect_array(combo.call("get_slots"), [&"A", &"Ø"], "locked press should leave no trace in ComboWindow") _expect_int(started.size(), 1, "locked press should not start an action") autoload_rhythm.set("_paused_song_position", 10.6) controller.call("_reset_to_idle") controller.call("submit_intent", _live_intent(&"A", &"a", "perfect", 21)) _expect_int(started.size(), 2, "press after lockout expiry should start an action") # 预置判定（无 live 标记）必须绕过门控：已消耗的拍也照常执行。 controller.call("_reset_to_idle") controller.call("submit_intent", _pinned_intent(&"A", &"a", "perfect", 20)) _expect_int(started.size(), 3, "pinned judgement should bypass the gate even on a consumed beat") autoload_rhythm.set("_lockout_until", -1.0) (autoload_rhythm.get("_consumed_beats") as Dictionary).clear() fixture["root"].free() func _rating(label: String, beat: int) -> Dictionary: return {"label": label, "diff": 0.0, "abs_diff": 0.0, "nearest_beat": beat} func _live_intent(symbol: StringName, rhythm_action: StringName, label: String, beat: int) -> RefCounted: var intent := _pinned_intent(symbol, rhythm_action, label, beat) var judgement: Dictionary = intent.get("judgement") judgement["live"] = true intent.set("judgement", judgement) return intent func _pinned_intent(symbol: StringName, rhythm_action: StringName, label: String, beat: int) -> RefCounted: var intent_script: Script = load("res://scenes/components/input_intent.gd") var intent: RefCounted = intent_script.call("create", symbol, rhythm_action, &"pressed", float(Time.get_ticks_msec())) intent.set("judgement", _rating(label, beat)) return intent func _controller_fixture() -> Dictionary: var combo_script: Script = load("res://scenes/components/combo_window.gd") var resolver_script: Script = load("res://scenes/combat/action_resolver.gd") var state_script: Script = load("res://scenes/components/state_machine.gd") var energy_script: Script = load("res://scenes/components/energy_component.gd") var controller_script: Script = load("res://scenes/components/action_controller.gd") if combo_script == null or resolver_script == null or state_script == null or energy_script == null or controller_script == null: _expect(false, "fixture scripts should load") return {} var fixture_root := Node.new() root.add_child(fixture_root) var combo: Node = combo_script.new() combo.name = "ComboWindow" fixture_root.add_child(combo) var resolver: Node = resolver_script.new() resolver.name = "ActionResolver" fixture_root.add_child(resolver) var state: Node = state_script.new() state.name = "StateMachine" fixture_root.add_child(state) var energy: Node = energy_script.new() energy.name = "EnergyComponent" fixture_root.add_child(energy) var controller: Node = controller_script.new() controller.name = "ActionController" controller.set("combo_window_path", NodePath("../ComboWindow")) controller.set("action_resolver_path", NodePath("../ActionResolver")) controller.set("state_machine_path", NodePath("../StateMachine")) fixture_root.add_child(controller) await process_frame energy.call("set_values", 99, 99) return { "root": fixture_root, "combo": combo, "controller": controller, } func _on_action_started(action: Resource, _intent) -> void: started.append(StringName(str(action.get("id")))) func _on_action_rejected(_intent, reason: StringName) -> void: rejected.append(reason) func _on_judgement_made(quality: StringName, offset_ms: float, beat_index: int) -> void: judged.append({"quality": quality, "offset_ms": offset_ms, "beat": beat_index}) func _event_bus() -> Node: var bus := root.get_node_or_null("EventBus") if bus == null: bus = load("res://autoload/event_bus.gd").new() bus.name = "EventBus" root.add_child(bus) return bus func _expect(condition: bool, label: String) -> void: if not condition: failures.append(label) 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_int(actual: int, expected: int, label: String) -> void: if actual != expected: failures.append("%s: expected %d, got %d" % [label, expected, actual]) func _expect_array(actual: Array, expected: Array, label: String) -> void: if actual != expected: failures.append("%s: expected %s, got %s" % [label, expected, actual]) func _expect_string(actual: String, expected: String, label: String) -> void: if actual != expected: failures.append("%s: expected %s, got %s" % [label, expected, actual]) func _finish() -> void: if failures.is_empty(): print("PASS input gate (new1 consume/lockout)") quit(0) else: for failure: String in failures: push_error(failure) quit(1)