转交与互斥(原未提交改动,合入选队分支后提交): - MCP 初始化说明和工具描述引导常规日常/领奖/普通镜牢走 task_status -> run_task -> 轮询;jev_mirror_agent 默认转交 AALC, 明确的速通配置、决策模型或未完成速通局仍走逐步模式。 - 新增 ~/lc_mcp/game.lock:run_task 子进程与模块合成脚本互斥, 合成脚本另查 task_status,状态不明时不接管游戏。 - all 任务的 HDR 提示无 GUI 时直接确认并记录;预检按窗口位置 决定是否计标题栏,set_windows=false 跳过;levelup card/weakest 同步失败返回非零。急停提示改为 End 键。 镜牢结果(对接文档指出的缺口): - 预检拒绝空队列和没有适用当前难度队伍的配置:AALC 会一局不打 就以 0 退出。可用判定与 Mirror_task 的固定用途规则一致。 - 监听 mirror_signal 统计实际完成局数;少于应打局数记 [ERROR] 并以退出码 4 结束,task_status 为 failed。 - mirror 指定 count 时临时关闭 infinite_dungeons(否则次数变成 9999),原值写入恢复文件,结束或强杀后写回。 验证:Linux / Python 3.12 全套 507 项通过;git diff --check 通过。 用上游真实 Mirror_task 回放了无可用队伍和正常完成两种情况; Windows 实机仍需回归。 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
350 lines
16 KiB
Python
350 lines
16 KiB
Python
import ast
|
|
import os
|
|
import sys
|
|
import threading
|
|
import unittest
|
|
from pathlib import Path
|
|
from types import SimpleNamespace
|
|
from unittest import mock
|
|
|
|
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
|
|
from lc_mcp import aalc_patches, preflight # noqa: E402
|
|
|
|
|
|
def values(**over):
|
|
v = {'simulator': False, 'mirror': True, 'set_win_size': 720, 'set_lunacy_to_enkephalin': 0,
|
|
'teams_active_queue': [1],
|
|
'teams': {'1': {'sinner_order': [1, 2, 3, 4, 5, 6, 7, 0, 0, 0, 0, 0]}}}
|
|
v.update(over)
|
|
return v
|
|
|
|
|
|
class PreflightTest(unittest.TestCase):
|
|
|
|
def test_healthy_config_passes(self):
|
|
self.assertEqual(preflight.check(values(), 'mirror', desktop=(1600, 900), env={}), [])
|
|
|
|
def test_default_all_zero_sinner_order_is_rejected_for_mirror(self):
|
|
v = values(teams={'1': {'sinner_order': [0] * 12}})
|
|
problems = preflight.check(v, 'mirror', env={})
|
|
self.assertEqual(len(problems), 1)
|
|
self.assertIn('sinner_order', problems[0])
|
|
# 日常本只按预设编号选队, 不用 sinner_order
|
|
self.assertEqual(preflight.check(v, 'daily', env={}), [])
|
|
# all 只在勾选了镜牢时检查
|
|
self.assertEqual(preflight.check(dict(v, mirror=False), 'all', env={}), [])
|
|
self.assertEqual(len(preflight.check(v, 'all', env={})), 1)
|
|
|
|
def test_missing_team_in_queue(self):
|
|
problems = preflight.check(values(teams_active_queue=[2]), 'mirror', env={})
|
|
self.assertIn('队伍 2', problems[0])
|
|
self.assertIn('没有可用队伍', problems[-1])
|
|
|
|
def test_empty_queue_is_rejected_because_aalc_would_exit_zero(self):
|
|
problems = preflight.check(values(teams_active_queue=[]), 'mirror', env={})
|
|
self.assertEqual(len(problems), 1)
|
|
self.assertIn('没有可用队伍', problems[0])
|
|
self.assertEqual(preflight.check(values(teams_active_queue=[]), 'daily', env={}), [])
|
|
self.assertEqual(preflight.check(values(teams_active_queue=[], mirror=False), 'all', env={}), [])
|
|
|
|
def test_fixed_team_use_must_match_current_difficulty(self):
|
|
order = [1, 2, 3, 4, 5, 6, 7, 0, 0, 0, 0, 0]
|
|
hard_only = {'sinner_order': order, 'fixed_team_use': True, 'fixed_team_use_select': 0}
|
|
normal_only = dict(hard_only, fixed_team_use_select=1)
|
|
for team, hard, ok in [(hard_only, False, False), (hard_only, True, True),
|
|
(normal_only, False, True), (normal_only, True, False),
|
|
(dict(hard_only, fixed_team_use=False), False, True)]:
|
|
with self.subTest(team=team, hard=hard):
|
|
problems = preflight.check(values(teams={'1': team}, hard_mirror=hard), 'mirror', env={})
|
|
self.assertEqual(problems == [], ok, problems)
|
|
# 只要队列里有一支适用当前难度, AALC 就会轮转到它
|
|
v = values(teams_active_queue=[1, 2], teams={'1': hard_only, '2': normal_only})
|
|
self.assertEqual(preflight.check(v, 'mirror', env={}), [])
|
|
|
|
def test_lunacy_spending_is_rejected_unless_explicit(self):
|
|
v = values(set_lunacy_to_enkephalin=2)
|
|
self.assertIn('狂气', preflight.check(v, 'daily', env={})[0])
|
|
self.assertEqual(preflight.check(v, 'enkephalin', env={}), [])
|
|
self.assertEqual(preflight.check(v, 'daily', env={preflight.ALLOW_LUNACY_ENV: '1'}), [])
|
|
|
|
def test_window_that_cannot_fit_desktop_is_rejected(self):
|
|
# 10-04 坑 4: 900 高的客户区加标题栏放不进 1600x900 桌面
|
|
problems = preflight.check(values(set_win_size=900), 'daily', desktop=(1600, 900), env={})
|
|
self.assertIn('1616x940', problems[0])
|
|
self.assertEqual(preflight.check(values(set_win_size=900), 'daily', desktop=(1920, 1080), env={}), [])
|
|
self.assertEqual(preflight.check(values(set_win_size=900, simulator=True), 'daily',
|
|
desktop=(1600, 900), env={}), [])
|
|
|
|
def test_collect_reads_pydantic_teams(self):
|
|
class Team:
|
|
def model_dump(self):
|
|
return {'sinner_order': [1]}
|
|
|
|
class Cfg:
|
|
data = {'simulator': False, 'mirror': True, 'set_win_size': 720,
|
|
'set_windows': False, 'set_win_position': 'center',
|
|
'set_lunacy_to_enkephalin': None, 'hard_mirror': 1,
|
|
'teams_active_queue': [1], 'teams': {1: Team()}}
|
|
|
|
def get_value(self, key):
|
|
return self.data[key]
|
|
|
|
v = preflight.collect(Cfg())
|
|
self.assertEqual(v['teams'], {'1': {'sinner_order': [1]}})
|
|
self.assertIs(v['hard_mirror'], True)
|
|
self.assertEqual(v['set_lunacy_to_enkephalin'], 0)
|
|
self.assertFalse(v['set_windows'])
|
|
self.assertEqual(v['set_win_position'], 'center')
|
|
|
|
def test_user_managed_window_skips_configured_size_check(self):
|
|
self.assertEqual(preflight.check(values(set_windows=False, set_win_size=2160),
|
|
'daily', desktop=(1920, 1080), env={}), [])
|
|
|
|
def test_borderless_window_can_fill_the_desktop(self):
|
|
for position in ('center', 'left_top', 'right_top', 'left_bottom', 'right_bottom'):
|
|
with self.subTest(position=position):
|
|
v = values(set_windows=True, set_win_size=1080, set_win_position=position)
|
|
self.assertEqual(preflight.check(v, 'daily', desktop=(1920, 1080), env={}), [])
|
|
self.assertTrue(preflight.check(v, 'daily', desktop=(1600, 900), env={}))
|
|
|
|
|
|
class HeadlessHdrTest(unittest.TestCase):
|
|
def test_upstream_prompt_is_acknowledged_without_an_event_loop(self):
|
|
# Run the pinned upstream detector; Event.wait would block without a receiver.
|
|
path = Path(__file__).resolve().parents[1] / 'vendor/aalc/tasks/base/script_task_scheme.py'
|
|
tree = ast.parse(path.read_text(encoding='utf-8'))
|
|
node = next(n for n in tree.body if isinstance(n, ast.FunctionDef)
|
|
and n.name == '_warn_if_game_monitor_hdr_enabled')
|
|
direct = object()
|
|
|
|
class Signal:
|
|
callback = None
|
|
|
|
def connect(self, callback, mode):
|
|
self.callback = callback if mode is direct else None
|
|
|
|
def disconnect(self, callback):
|
|
self.callback = None
|
|
|
|
def emit(self, event):
|
|
if self.callback:
|
|
self.callback(event)
|
|
|
|
signal = Signal()
|
|
events = []
|
|
|
|
def event_factory():
|
|
event = threading.Event()
|
|
events.append(event)
|
|
return event
|
|
|
|
ns = dict(cfg=SimpleNamespace(simulator=False, get_value=lambda *a: True),
|
|
screen=SimpleNamespace(handle=SimpleNamespace(hwnd=1)),
|
|
win32api=SimpleNamespace(MonitorFromWindow=lambda *a: 1),
|
|
win32con=SimpleNamespace(MONITOR_DEFAULTTONEAREST=2),
|
|
get_monitor_hdr_info=lambda *a: SimpleNamespace(hdr_enabled=True),
|
|
Event=event_factory, mediator=SimpleNamespace(hdr_warning=signal), log=mock.Mock())
|
|
exec(compile(ast.Module(body=[node], type_ignores=[]), str(path), 'exec'), ns)
|
|
qt = SimpleNamespace(Qt=SimpleNamespace(ConnectionType=SimpleNamespace(DirectConnection=direct)))
|
|
messages = []
|
|
with mock.patch.dict(sys.modules, {'PySide6.QtCore': qt}):
|
|
with aalc_patches.headless_hdr_warning(SimpleNamespace(**ns), log=messages.append):
|
|
worker = threading.Thread(target=ns[node.name], daemon=True)
|
|
worker.start()
|
|
worker.join(1)
|
|
try:
|
|
self.assertFalse(worker.is_alive(), 'HDR prompt blocked the task')
|
|
self.assertTrue(events[0].is_set())
|
|
self.assertIn('HDR', messages[0])
|
|
finally:
|
|
for event in events:
|
|
event.set()
|
|
worker.join(1)
|
|
self.assertIsNone(signal.callback)
|
|
|
|
def test_exception_disconnects_the_receiver(self):
|
|
signal = mock.Mock()
|
|
scheme = SimpleNamespace(mediator=SimpleNamespace(hdr_warning=signal))
|
|
qt = SimpleNamespace(Qt=SimpleNamespace(ConnectionType=SimpleNamespace(DirectConnection=1)))
|
|
with mock.patch.dict(sys.modules, {'PySide6.QtCore': qt}):
|
|
with self.assertRaisesRegex(RuntimeError, 'task failed'):
|
|
with aalc_patches.headless_hdr_warning(scheme):
|
|
raise RuntimeError('task failed')
|
|
signal.disconnect.assert_called_once_with(signal.connect.call_args.args[0])
|
|
|
|
|
|
|
|
class MirrorCompletionTest(unittest.TestCase):
|
|
"""AALC 退出码 0 不代表打完镜牢; 用上游真实 Mirror_task 核对完成局数。"""
|
|
|
|
class Signal:
|
|
def __init__(self):
|
|
self.callbacks = []
|
|
|
|
def connect(self, callback, mode):
|
|
self.callbacks.append(callback)
|
|
|
|
def disconnect(self, callback):
|
|
self.callbacks.remove(callback)
|
|
|
|
def emit(self, *args):
|
|
for callback in list(self.callbacks):
|
|
callback(*args)
|
|
|
|
def run_upstream_mirror(self, queue, team, count=1):
|
|
path = Path(__file__).resolve().parents[1] / 'vendor/aalc/tasks/base/script_task_scheme.py'
|
|
tree = ast.parse(path.read_text(encoding='utf-8'))
|
|
node = next(n for n in tree.body if isinstance(n, ast.FunctionDef) and n.name == 'Mirror_task')
|
|
signal = self.Signal()
|
|
mediator = SimpleNamespace(mirror_signal=signal, mirror_bar_kill_signal=mock.Mock())
|
|
state = {'teams_active_queue': list(queue),
|
|
'teams_be_select': [num in queue for num in (1,)]}
|
|
cfg = SimpleNamespace(
|
|
set_mirror_count=count, infinite_dungeons=False, save_rewards=False, hard_mirror=False,
|
|
auto_hard_mirror=False, re_claim_rewards=False, teams_active_queue=state['teams_active_queue'],
|
|
config=SimpleNamespace(teams={'1': team}), get_value=state.get,
|
|
normalize_and_sync_team_state=lambda persist=True: None, rotate_team_queue=mock.Mock())
|
|
ns = dict(cfg=cfg, mediator=mediator, log=mock.Mock(), to_get_reward=mock.Mock(),
|
|
onetime_mir_process=mock.Mock(return_value=True))
|
|
exec(compile(ast.Module(body=[node], type_ignores=[]), str(path), 'exec'), ns)
|
|
scheme = SimpleNamespace(mediator=mediator, Mirror_task=ns['Mirror_task'])
|
|
qt = SimpleNamespace(Qt=SimpleNamespace(ConnectionType=SimpleNamespace(DirectConnection=1)))
|
|
with mock.patch.dict(sys.modules, {'PySide6.QtCore': qt}), \
|
|
aalc_patches.mirror_progress(scheme) as progress:
|
|
scheme.Mirror_task()
|
|
self.assertEqual(signal.callbacks, [], 'receiver must be disconnected')
|
|
return progress, ns['onetime_mir_process']
|
|
|
|
def test_unusable_team_returns_normally_but_is_reported_incomplete(self):
|
|
from lc_mcp import aalc_task
|
|
hard_only = SimpleNamespace(fixed_team_use=True, fixed_team_use_select=0)
|
|
progress, play = self.run_upstream_mirror([1], hard_only)
|
|
play.assert_not_called()
|
|
self.assertEqual((progress.finished, progress.total), (0, 1))
|
|
lines = []
|
|
with mock.patch.object(aalc_task, 'log', lines.append):
|
|
self.assertEqual(aalc_task.mirror_result('mirror', progress), aalc_task.INCOMPLETE_EXIT)
|
|
self.assertTrue(any(line.startswith('[ERROR]') and '0/1' in line for line in lines))
|
|
|
|
def test_completed_run_is_success(self):
|
|
from lc_mcp import aalc_task
|
|
progress, play = self.run_upstream_mirror([1], SimpleNamespace(fixed_team_use=False))
|
|
play.assert_called_once()
|
|
self.assertEqual((progress.finished, progress.total), (1, 1))
|
|
with mock.patch.object(aalc_task, 'log'):
|
|
self.assertEqual(aalc_task.mirror_result('mirror', progress), 0)
|
|
|
|
def test_missing_progress_only_fails_explicit_mirror_task(self):
|
|
from lc_mcp import aalc_task
|
|
with mock.patch.object(aalc_task, 'log'):
|
|
self.assertEqual(aalc_task.mirror_result('all', aalc_patches.MirrorProgress()), 0)
|
|
self.assertEqual(aalc_task.mirror_result('daily', aalc_patches.MirrorProgress()), 0)
|
|
self.assertEqual(aalc_task.mirror_result('mirror', aalc_patches.MirrorProgress()),
|
|
aalc_task.INCOMPLETE_EXIT)
|
|
|
|
def test_receiver_is_disconnected_on_exception(self):
|
|
signal = mock.Mock()
|
|
scheme = SimpleNamespace(mediator=SimpleNamespace(mirror_signal=signal))
|
|
qt = SimpleNamespace(Qt=SimpleNamespace(ConnectionType=SimpleNamespace(DirectConnection=1)))
|
|
with mock.patch.dict(sys.modules, {'PySide6.QtCore': qt}):
|
|
with self.assertRaisesRegex(RuntimeError, 'task failed'):
|
|
with aalc_patches.mirror_progress(scheme):
|
|
raise RuntimeError('task failed')
|
|
signal.disconnect.assert_called_once_with(signal.connect.call_args.args[0])
|
|
|
|
class ExactTeamMatchTest(unittest.TestCase):
|
|
|
|
class Auto:
|
|
def find_str_in_text(self, target, ocr_dict):
|
|
# AALC 原逻辑: 子串匹配
|
|
for text, pos in ocr_dict.items():
|
|
if target.replace(' ', '').lower() in text.replace(' ', '').lower():
|
|
return pos
|
|
return False
|
|
|
|
def setUp(self):
|
|
self.auto = self.Auto()
|
|
aalc_patches.install_exact_team_match(self.auto, log=lambda m: None)
|
|
|
|
def test_team_1_does_not_match_team_10(self):
|
|
ocr = {'TEAMS #10': [10, 10], 'TEAMS #11': [10, 20], 'TEAMS #1': [10, 30]}
|
|
self.assertEqual(self.auto.find_str_in_text('TEAMS #1', ocr), [10, 30])
|
|
self.assertFalse(self.auto.find_str_in_text('TEAMS #1', {'TEAMS #10': [1, 1]}))
|
|
|
|
def test_ocr_variants_and_chinese(self):
|
|
self.assertEqual(self.auto.find_str_in_text('TFAMS#1', {'TEAMS # 1': [5, 5]}), [5, 5])
|
|
self.assertEqual(self.auto.find_str_in_text('编队#1', {'编队#12': [1, 1], '编队#1': [2, 2]}), [2, 2])
|
|
self.assertEqual(self.auto.find_str_in_text('TEAMS #12', {'TEAMS #12': [3, 3]}), [3, 3])
|
|
|
|
def test_other_targets_keep_aalc_substring_logic(self):
|
|
self.assertEqual(self.auto.find_str_in_text('Hong Lu', {'W HongLu': [7, 7]}), [7, 7])
|
|
|
|
|
|
class FakeHandle:
|
|
def __init__(self, size):
|
|
self._hwnd = 1
|
|
self.size = size
|
|
self.isMinimized = False
|
|
|
|
def width(self, client=False):
|
|
return self.size[0]
|
|
|
|
def height(self, client=False):
|
|
return self.size[1]
|
|
|
|
|
|
class FakeScreen:
|
|
def __init__(self, size, resizable=True):
|
|
self.handle = FakeHandle(size)
|
|
self.resizable = resizable
|
|
self.calls = []
|
|
|
|
def adjust_win_size(self, want):
|
|
self.calls.append(want)
|
|
if self.resizable:
|
|
self.handle.size = want
|
|
|
|
|
|
class Cfg:
|
|
simulator = False
|
|
set_windows = True
|
|
set_win_size = 720
|
|
|
|
|
|
class WindowGuardTest(unittest.TestCase):
|
|
|
|
def guard(self, screen, cfg=Cfg):
|
|
self.logs = []
|
|
return aalc_patches.WindowGuard(screen, cfg, log=self.logs.append)
|
|
|
|
def test_correct_size_is_left_alone(self):
|
|
screen = FakeScreen((1280, 720))
|
|
self.assertEqual(self.guard(screen).check_once(), 'ok')
|
|
self.assertEqual(screen.calls, [])
|
|
|
|
def test_stretched_window_is_restored(self):
|
|
# 10-04 坑 5: RDP 重连后被拉伸成 1872x898
|
|
screen = FakeScreen((1872, 898))
|
|
with mock.patch.object(aalc_patches.time, 'sleep'):
|
|
self.assertEqual(self.guard(screen).check_once(), 'fixed')
|
|
self.assertEqual(screen.calls, [(1280, 720)])
|
|
|
|
def test_unfixable_size_is_reported_once(self):
|
|
screen = FakeScreen((1600, 877), resizable=False)
|
|
guard = self.guard(screen)
|
|
with mock.patch.object(aalc_patches.time, 'sleep'):
|
|
self.assertEqual(guard.check_once(), 'failed')
|
|
self.assertEqual(guard.check_once(), 'failed')
|
|
self.assertEqual(len([m for m in self.logs if '[ERROR]' in m]), 1)
|
|
|
|
def test_user_managed_window_is_not_touched(self):
|
|
class Manual(Cfg):
|
|
set_windows = False
|
|
screen = FakeScreen((1872, 898))
|
|
self.assertIsNone(self.guard(screen, Manual).check_once())
|
|
self.assertEqual(screen.calls, [])
|
|
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main()
|