diff --git a/README.md b/README.md index 3898d9c..9ce40d6 100644 --- a/README.md +++ b/README.md @@ -109,6 +109,13 @@ $env:LCP_DRIVER_TRACE = "$env:USERPROFILE\lc_mcp\driver-input.log" ## 工具 +MCP 初始化说明与工具描述均指导 AI 优先使用 AALC:常规日常、领奖、普通镜牢按 +`task_status` → `run_task` → 轮询 `task_status` 执行。只刷经验本时显式传 `thread: 0`, +只刷纽本时传 `exp: 0`,避免沿用另一项配置。主线、特殊速通路线或故障恢复使用逐步输入。 +只看状态或截图不会启动任务;`all` 只用于明确要求全部任务,`enkephalin` 需要明确授权花狂气。 +启动成功不等于完成,最终还要检查 `errors` 和 `pending_restore`,用户停止后不自动重跑。 +更新后重启常驻服务并重连 MCP,客户端才能获取新的初始化说明和工具描述。 + | 工具 | 说明 | |------|------| | `get_state` | 截图 + OCR,返回窗口内全部文字 `{text,x,y,w,h,score}` | @@ -138,14 +145,21 @@ $env:LCP_DRIVER_TRACE = "$env:USERPROFILE\lc_mcp\driver-input.log" ### 任务进程里的保护 -`run_task` 启动的任务子进程在调用 AALC 之前会做三件事,都不改 `vendor/aalc` 源码: +`run_task` 启动的任务子进程会做以下处理,都不改 `vendor/aalc` 源码: - **配置预检**:发现下列问题就直接拒绝启动(退出码 3,原因写在 `errors` 里): - 镜牢队伍的 `sinner_order` 全是 0:这会让 AALC 选出空队伍,然后无限重试编队; + - 镜牢队列为空,或队列里没有适用当前难度的队伍(按"固定用途"判断):AALC 会一局不打就以 0 退出; - `set_lunacy_to_enkephalin` 不为 0:体力不足时会花狂气换体力。确需使用时设 `LCP_ALLOW_LUNACY=1`; - - `set_win_size` 加上标题栏后放不进当前桌面:窗口会被压扁成非 16:9。 + - 自动设置窗口时,目标尺寸放不进当前桌面:窗口会被压扁成非 16:9。 + `free` 位置计入标题栏,自动定位的无边框窗口只计客户区;`set_windows: false` 跳过此项。 - **队伍名精确匹配**:AALC 按子串找队伍,`TEAMS #1` 会命中 `TEAMS #10`。补丁要求编号完全相同。 - **窗口比例守护**:每 15 秒检查一次客户区。RDP 重连后窗口被拉伸时,自动调回 `set_win_size` 对应的 16:9 尺寸。 +- **HDR 提示**:`all` 任务检测到 HDR 时记录警告并继续,不等待 GUI 确认。 +- **镜牢完成核对**:监听 AALC 的镜牢进度信号统计实际完成局数。少于应打局数时记一条 `[ERROR]` + 并以退出码 4 结束,`task_status` 显示 `failed`;AALC 正常返回不再被当成打完。 +- **指定次数**:`mirror` 传 `count` 时本次临时关闭 `infinite_dungeons`(开着时 AALC 会把次数改成 9999), + 原值和次数一起写入恢复文件,结束或被强杀后都会写回。 ## 无人值守 @@ -175,11 +189,16 @@ powershell -ExecutionPolicy Bypass -File scripts\install_convert_task.ps1 -Every 看历史:`python scripts/modules_status.py` +合成脚本与 `run_task` 子进程通过 `~/lc_mcp/game.lock` 互斥,锁一直保持到操作和关闭游戏结束。 +已有任务占用时,后来启动的一方报告失败;合成脚本无法确认任务状态时也会退出,不接管游戏。 +进程退出后锁由系统释放,文件保留,无需手动删除。 + **⚠️ 挂机值守前先读 [`docs/WATCH.md`](docs/WATCH.md)** —— 那里记着环境事实、 界面坐标、狂气的三道防线、六种已知失败模式及处置,以及几条踩过的坑 (比如 OCR 会把 `LUNACY` 读成 `UNACY`,曾让整条狂气防线静默失效)。 `scripts/levelup.py` 和 `auto_cycle.py` 里的坐标都按 1600×900 客户区书写,运行时会按实际客户区大小缩放。 +`levelup.py card`、`weakest` 和 `progress` 带 `--uptie` 时,同步失败会返回非零退出码。 ## 环境变量 @@ -233,18 +252,40 @@ vendor\aalc\.venv\Scripts\python.exe -X utf8 scripts\mcp_probe.py find_image '{" ## Jev 镜牢执行器与真实反馈 -`scripts/jev_mirror_agent.py` 通过 MCP bridge 操作游戏,普通分支经统一接口交给 Jev 或执行模型;战斗采用 P → 回车宏,事件先 SKIP,回车失效时使用当前按钮。它保留用户已配好的队伍,商店无可替换出战角色时至多刷新 4 次,加载期间不读取旧库存继续操作。 +`scripts/jev_mirror_agent.py` 的 `--workflow auto` 默认把普通镜牢交给 AALC。 +没有配置、决策模型要求或未完成速通记录时,先查 `task_status`,空闲后调用 +`run_task({"task":"mirror","count":1})`,随即返回 `delegated` 和后续监控调用。 +调用方继续轮询 `task_status`;脚本退出不代表通关。已有镜牢任务时返回 `monitoring`, +其他任务占用、用户停止、报错或状态不明时不会自动抢占或重试。 + +```powershell +# 普通镜牢:默认转交 AALC,不需要 Jev 配置 +vendor\aalc\.venv\Scripts\python.exe -X utf8 scripts\jev_mirror_agent.py +# 明确启动新任务;先前有用户停止或失败时也需明确提出新任务 +vendor\aalc\.venv\Scripts\python.exe -X utf8 scripts\jev_mirror_agent.py --workflow aalc --new-run +# 查看已交给 AALC 的任务结果,不启动下一局 +vendor\aalc\.venv\Scripts\python.exe -X utf8 scripts\jev_mirror_agent.py --workflow aalc --resume +``` + +AALC 交接结果写入运行目录的 `aalc_mirror_status.json`;停止已交接的任务使用 `stop_task` 或急停键(默认 End)。 +`JEV_STOP` 会阻止新的交接,但交接后不再由此脚本监听。`--steps` / `--seconds` 仅限制逐步模式。 + +`--workflow speedrun` 使用原有的特殊速通流程。为兼容现有调用,提供 Jev 配置、 +`--decision-engine`、执行模型回调、`LC_FIXED_FALLBACK=1` 或未完成速通记录时,`auto` 保留逐步模式。 +`--resume` 沿用已保存的流程;已有未完成速通局时,切换 AALC 必须明确指定 `--new-run`。 + +逐步模式通过 MCP bridge 操作游戏,路线等分支交给 Jev 或执行模型;战斗采用 P → 回车宏,事件先 SKIP,回车失效时使用当前按钮。它保留用户已配好的队伍,商店无可替换出战角色时至多刷新 4 次,加载期间不读取旧库存继续操作。 安装 AALC 依赖并启动常驻服务后,把 `OPENCODE_API_KEY` 设为自己的凭据,再运行: ```powershell -vendor\aalc\.venv\Scripts\python.exe -X utf8 scripts\jev_mirror_agent.py scripts\jev_config.example.json --steps 250 --seconds 1800 +vendor\aalc\.venv\Scripts\python.exe -X utf8 scripts\jev_mirror_agent.py scripts\jev_config.example.json --workflow speedrun --steps 250 --seconds 1800 ``` -运行数据默认写到 `~/lc_mcp/jev`,可用 `LC_JEV_HOME` 指定其他目录。创建该目录下的 `JEV_STOP` 文件即可停止;续跑前移除它。不要与 AALC 完整任务或另一个游戏执行器同时操作。 +运行数据默认写到 `~/lc_mcp/jev`,可用 `LC_JEV_HOME` 指定其他目录。逐步模式下创建该目录的 `JEV_STOP` 文件即可停止;续跑前移除它。不要与 AALC 完整任务或另一个游戏执行器同时操作。 工具调用失败(截图暂不可用、按钮已消失等)会记入日志并重新观察画面,同一画面上同一动作最多尝试两次,不会因单次失败整局退出。 -每局运行现在有独立标识。默认续跑尚未结束且上下文一致的当前局;已完成或没有运行记录时建立新局。重新开一局时使用 `--new-run`,明确要求续跑时使用 `--resume`。旧版本未完成记录会保留楼层和强化进度,但旧的领取及战斗标记不会作为本局完成证据;只有上下文而没有运行记录时会重置它。领取截图和返回大厅截图必须属于当前局,才能记录完成。 +逐步模式每局运行有独立标识。默认续跑尚未结束且上下文一致的当前局;已完成或没有运行记录时建立新局。重新开一局时使用 `--new-run`,明确要求续跑时使用 `--resume`。旧版本未完成记录会保留楼层和强化进度,但旧的领取及战斗标记不会作为本局完成证据;只有上下文而没有运行记录时会重置它。领取截图和返回大厅截图必须属于当前局,才能记录完成。 ```powershell # 新开一局:清除上一局的楼层、饰品与领取状态 diff --git a/docs/skills/limbus-mirror-speedrun/SKILL.md b/docs/skills/limbus-mirror-speedrun/SKILL.md index 643f6ac..281d27b 100644 --- a/docs/skills/limbus-mirror-speedrun/SKILL.md +++ b/docs/skills/limbus-mirror-speedrun/SKILL.md @@ -1,12 +1,23 @@ --- name: limbus-mirror-speedrun -description: 继续或重开边狱公司(Limbus Company)的镜像迷宫/镜牢,按破裂黎明与黑兽纯 P 攻略追求整局通关速度;处理开局配置、卡包、事件、必要强化、技能替换与战斗快捷键。用于用户要求代打镜牢或优化此速通流程时,不用于一般配队讨论或主线事件。 +description: 执行或优化边狱公司(Limbus Company)的特殊镜牢速通,按用户指定的破裂黎明、黑兽纯 P 或具体路线逐步控制,并续跑该速通的未完成局。普通刷镜牢、日常和领奖使用 AALC run_task;一般配队讨论和主线事件不使用本 skill。 --- # 镜牢破裂纯 P 速通 目标是尽快完成用户授权的一局镜牢。接着当前画面推进;只有用户明确要求重开时才放弃当前局。用户后续纠正覆盖本 skill 的默认配置。 +## 选择执行方式 + +用户只要求普通刷镜牢且没有特殊路线时,先查 MCP `task_status`;空闲后用 `run_task`, +例如一局为 `{"task":"mirror","count":1}`,随后轮询 `task_status` 并检查 `errors`、 +`pending_restore`,不进入下方逐步速通规则。完成局数不足时任务报 `failed`,不能当作已通关。 +已有任务时监控它;用户停止后不自动重跑。 +日常与领奖分别用 `daily`、`reward`,`all` 和花狂气的 `enkephalin` 必须符合明确要求。 + +只有特殊速通要求或续跑该速通局时使用下方规则,调用执行器时指定 `--workflow speedrun`。 +自动流程卡住时,先 `stop_task` 并确认停止,再观察画面恢复;不同时运行两个执行器。 + ## 读取与续局 - 执行前读取 [破裂黎明配置与楼层规划](references/rupture-route.md)。沿用用户配好的队伍、难度、出战顺序,不为了通用攻略改动配置。 diff --git a/lc_mcp/aalc_patches.py b/lc_mcp/aalc_patches.py index 8f0ad55..800355c 100644 --- a/lc_mcp/aalc_patches.py +++ b/lc_mcp/aalc_patches.py @@ -21,6 +21,57 @@ from contextlib import contextmanager TEAM_TARGET = re.compile(r'(?:TEAMS|TFAMS|编队)#(\d+)', re.IGNORECASE) +@contextmanager +def headless_hdr_warning(scheme, log=print): + """Acknowledge upstream's GUI-only HDR prompt without a Qt event loop.""" + from PySide6.QtCore import Qt + + def acknowledge(event): + try: + log('[lc_mcp] HDR 已开启,可能影响图像识别;命令行任务继续运行') + finally: + event.set() + + signal = scheme.mediator.hdr_warning + signal.connect(acknowledge, Qt.ConnectionType.DirectConnection) + try: + yield + finally: + signal.disconnect(acknowledge) + + +class MirrorProgress: + """AALC 镜牢的实际完成局数。total 为 None 表示本次没有进入镜牢循环。""" + + def __init__(self): + self.total = None + self.finished = 0 + + def record(self, finished, remaining): + # Mirror_task 开始时发 (0, 总局数), 每完成一局发 (已完成, 剩余) + if self.total is None: + self.total = finished + remaining + self.finished = max(self.finished, finished) + + +@contextmanager +def mirror_progress(scheme): + """监听 mirror_signal 统计完成局数。 + + AALC 没有可用队伍或队列为空时 Mirror_task 直接跳出循环, 进程仍以 0 退出; + 只看退出码会把"一局没打"报成 succeeded。 + """ + from PySide6.QtCore import Qt + + progress = MirrorProgress() + signal = scheme.mediator.mirror_signal + signal.connect(progress.record, Qt.ConnectionType.DirectConnection) + try: + yield progress + finally: + signal.disconnect(progress.record) + + def team_number(text): """'TEAMS #12' / 'TFAMS#3' / '编队#1' -> '12' / '3' / '1'; 不是队伍名返回 None。""" m = TEAM_TARGET.fullmatch(text.replace(' ', '').strip()) diff --git a/lc_mcp/aalc_task.py b/lc_mcp/aalc_task.py index ea88e86..dcd0cd1 100644 --- a/lc_mcp/aalc_task.py +++ b/lc_mcp/aalc_task.py @@ -11,9 +11,11 @@ import sys from . import killswitch, preflight from .aalc_engine import bootstrap -from .aalc_patches import (WindowGuard, driver_click_tasks, install_default_battle_team, - install_exact_team_match, install_robust_set_foreground, - install_system_team_selection, stop_driver_click) +from .aalc_patches import (WindowGuard, driver_click_tasks, headless_hdr_warning, + install_default_battle_team, install_exact_team_match, + install_robust_set_foreground, install_system_team_selection, + mirror_progress, stop_driver_click) +from .game_lock import GameBusyError, exclusive_game # 任务 -> {参数名: AALC 配置项}; 参数只在本次运行内生效 TASKS = { @@ -23,8 +25,11 @@ TASKS = { 'enkephalin': {'times': 'set_lunacy_to_enkephalin'}, 'mirror': {'count': 'set_mirror_count'}, } +# 用户给了镜牢次数时一并临时关闭的配置: 开着无限刷牢, AALC 会把次数改成 9999 +EXPLICIT_COUNT_OVERRIDES = {'mirror': {'count': {'infinite_dungeons': False}}} RESTORE_ENV = 'LCP_RESTORE_FILE' PREFLIGHT_EXIT = 3 +INCOMPLETE_EXIT = 4 # AALC 正常返回, 但镜牢完成局数少于应打局数 def log(msg): @@ -37,17 +42,37 @@ def apply_overrides(cfg, task, params, restore_path=None): AALC 运行中会整份保存配置(如镜牢后 rotate_team_queue), 覆盖值会被写进 config.yaml。 所以先把原值落盘: 进程被 stop_task 强杀、finally 来不及执行时, TaskRunner 据此写回。 """ - originals = {TASKS[task][name]: cfg.get_value(TASKS[task][name]) for name in params} + overrides = {TASKS[task][name]: int(value) for name, value in params.items()} + for name in params: + overrides.update(EXPLICIT_COUNT_OVERRIDES.get(task, {}).get(name, {})) + originals = {key: cfg.get_value(key) for key in overrides} if originals and restore_path: tmp = restore_path + '.tmp' with open(tmp, 'w', encoding='utf-8') as f: json.dump(originals, f, ensure_ascii=False) os.replace(tmp, restore_path) - for name, value in params.items(): - cfg.unsaved_set_value(TASKS[task][name], int(value)) + for key, value in overrides.items(): + if key == 'infinite_dungeons' and originals.get(key): + log('[lc_mcp] 本次按指定次数运行镜牢, 临时关闭无限刷牢, 结束后恢复') + cfg.unsaved_set_value(key, value) return originals +def mirror_result(task, progress): + """按 AALC 实际完成局数给出退出码; 退出码 0 不再代表"一局没打"。""" + if progress.total is None: + if task != 'mirror': + return 0 # all 没勾选镜牢 + log('[ERROR] [lc_mcp] 镜牢任务结束, 但没收到 AALC 的镜牢进度, 不能确认完成局数') + return INCOMPLETE_EXIT + log('[lc_mcp] 镜牢完成 %d/%d 局' % (progress.finished, progress.total)) + if progress.finished < progress.total: + log('[ERROR] [lc_mcp] 镜牢只完成 %d/%d 局: AALC 正常返回, 但没有打完' + '(常见原因: 没有适用当前难度的队伍、队列为空)' % (progress.finished, progress.total)) + return INCOMPLETE_EXIT + return 0 + + def restore(cfg, originals, restore_path=None): for key, value in originals.items(): cfg.set_value(key, value) @@ -67,6 +92,15 @@ def restore_file(path, cfg=None): def run(task, params): + try: + with exclusive_game(): + return _run(task, params) + except GameBusyError as e: + log('[ERROR] [lc_mcp] %s' % e) + return PREFLIGHT_EXIT + + +def _run(task, params): bootstrap() from module.automation import auto from module.config import cfg @@ -97,11 +131,13 @@ def run(task, params): guard.start() restore_path = os.environ.get(RESTORE_ENV) originals = apply_overrides(cfg, task, params, restore_path) - with driver_click_tasks(scheme, auto, screen, cfg, log=log): + with driver_click_tasks(scheme, auto, screen, cfg, log=log), \ + mirror_progress(scheme) as progress: try: if task == 'all': - scheme.script_task() - return 0 + with headless_hdr_warning(scheme, log=log): + scheme.script_task() + return mirror_result(task, progress) # 与 script_task() 相同的前置步骤 scheme.init_game() path_manager.initialize_paths() @@ -117,7 +153,7 @@ def run(task, params): 'enkephalin': scheme.Buy_enkephalin, 'mirror': scheme.Mirror_task, }[task]() - return 0 + return mirror_result(task, progress) finally: guard.stop() retry_monitor.stop() diff --git a/lc_mcp/game_lock.py b/lc_mcp/game_lock.py new file mode 100644 index 0000000..f01bb18 --- /dev/null +++ b/lc_mcp/game_lock.py @@ -0,0 +1,44 @@ +"""Cross-process ownership of the game during tasks and module conversion.""" +import errno +import os +from contextlib import contextmanager + + +class GameBusyError(RuntimeError): + pass + + +def default_lock_path(): + return os.path.expanduser('~/lc_mcp/game.lock') + + +@contextmanager +def exclusive_game(path=None): + """Acquire without waiting; closing the file also releases a crashed owner's lock. + + Keep the file in place: unlinking it would let another process lock a different + inode. The OS owns the lock, so a leftover file is not a stale reservation. + """ + path = os.path.abspath(path or default_lock_path()) + os.makedirs(os.path.dirname(path), exist_ok=True) + with open(path, 'a+b') as lock: + lock.seek(0) + try: + if os.name == 'nt': + import msvcrt + msvcrt.locking(lock.fileno(), msvcrt.LK_NBLCK, 1) + else: + import fcntl + fcntl.flock(lock.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB) + except OSError as e: + if e.errno in (errno.EACCES, errno.EAGAIN, errno.EDEADLK): + raise GameBusyError('游戏正由其他任务或合成脚本使用,本次不接管') from e + raise + try: + yield + finally: + if os.name == 'nt': + lock.seek(0) + msvcrt.locking(lock.fileno(), msvcrt.LK_UNLCK, 1) + else: + fcntl.flock(lock.fileno(), fcntl.LOCK_UN) diff --git a/lc_mcp/preflight.py b/lc_mcp/preflight.py index eabd55f..6f9abc6 100644 --- a/lc_mcp/preflight.py +++ b/lc_mcp/preflight.py @@ -21,13 +21,23 @@ def collect(cfg): return { 'simulator': bool(cfg.get_value('simulator')), 'mirror': bool(cfg.get_value('mirror')), + 'set_windows': bool(cfg.get_value('set_windows')), + 'set_win_position': cfg.get_value('set_win_position') or 'free', 'set_win_size': int(cfg.get_value('set_win_size')), 'set_lunacy_to_enkephalin': int(cfg.get_value('set_lunacy_to_enkephalin') or 0), + 'hard_mirror': bool(cfg.get_value('hard_mirror')), 'teams_active_queue': list(cfg.get_value('teams_active_queue') or []), 'teams': teams, } +def team_fits_difficulty(team, hard): + """与 AALC Mirror_task 的可用判定一致: 固定用途 0=只打困难, 1=只打普通。""" + if not team.get('fixed_team_use'): + return True + return int(team.get('fixed_team_use_select') or 0) == (0 if hard else 1) + + def desktop_size(): """主显示器分辨率(进程已由 bootstrap 设为 DPI aware, 取到的是物理像素)。""" from ctypes import windll @@ -48,25 +58,38 @@ def check(values, task, desktop=None, env=None): # all 只在 AALC 里勾选了镜牢时才会编队 if task == 'mirror' or (task == 'all' and values.get('mirror')): teams = values.get('teams', {}) - for num in values.get('teams_active_queue', []): + queue = list(values.get('teams_active_queue', [])) + hard = bool(values.get('hard_mirror')) + usable = [] + for num in queue: team = teams.get(str(num)) - if team is None: + # AALC 归一化队列时丢弃非整数和不存在的编号 + if team is None or type(num) is not int: problems.append('teams_active_queue 里的队伍 %s 没有配置' % num) continue + if team_fits_difficulty(team, hard): + usable.append(num) order = list(team.get('sinner_order') or []) # team_formation 从 1 开始按顺序找罪人, 缺 1 就一个都不选, 然后无限重试编队 if 1 not in order: problems.append( '队伍 %s 的 sinner_order 没有罪人(全是 0): 镜牢编队会选空队伍并无限重试。' '在 AALC 队伍设置里勾选罪人并排序' % num) + # 没有可用队伍时 Mirror_task 直接跳出循环, 进程照样 exit 0 报 succeeded + if not usable: + problems.append( + '镜牢没有可用队伍(teams_active_queue=%s, 当前%s镜牢): AALC 会一局不打就正常退出。' + '在 AALC 里启用队伍, 或调整队伍的"固定用途"' % (queue, '困难' if hard else '普通')) - if not values.get('simulator') and desktop: + if not values.get('simulator') and values.get('set_windows', True) and desktop: size = values.get('set_win_size', 0) - need_w = int(size * 16 / 9) + FRAME_W - need_h = size + FRAME_H + # AALC removes the title bar and borders for every automatic position. + framed = values.get('set_win_position', 'free') == 'free' + need_w = int(size * 16 / 9) + (FRAME_W if framed else 0) + need_h = size + (FRAME_H if framed else 0) if need_w > desktop[0] or need_h > desktop[1]: problems.append( - 'set_win_size=%s 需要 %sx%s 的窗口(含标题栏), 桌面只有 %sx%s: 窗口会被压扁成非 16:9,' + 'set_win_size=%s 需要 %sx%s 的窗口(%s), 桌面只有 %sx%s: 窗口会被压扁成非 16:9,' ' 模板匹配全部失效。改小 set_win_size(如 720)或调大桌面分辨率' - % (size, need_w, need_h, desktop[0], desktop[1])) + % (size, need_w, need_h, '含标题栏' if framed else '无边框', desktop[0], desktop[1])) return problems diff --git a/lc_mcp/protocol.py b/lc_mcp/protocol.py index b3e65ec..07782ea 100644 --- a/lc_mcp/protocol.py +++ b/lc_mcp/protocol.py @@ -14,6 +14,23 @@ WAIT_INTERVAL = 1.0 INPUT_TOOLS = {'click', 'click_text', 'click_image', 'keypress', 'type_text', 'drag', 'show_game_background'} TASK_TOOLS = {'run_task', 'task_status', 'stop_task'} +AUTOMATION_INSTRUCTIONS = ( + '常规日常刷取、领奖励、普通镜牢优先使用 AALC 的 run_task 自动流程。' + '先用 task_status 检查是否已有任务;已有任务时查看进度,不重复启动或为抢占而停止它。' + '日常用 task="daily",领奖用 task="reward",镜牢用 task="mirror";次数按用户要求传入。' + '例如一局镜牢调用 run_task({"task":"mirror","count":1});' + '只刷经验本时传 exp 次数和 thread=0,只刷纽本时传 thread 次数和 exp=0,避免沿用另一项配置。' + '启动成功仅表示任务已启动,随后轮询 task_status,最终同时检查 state、errors 和 pending_restore;' + 'succeeded 带 errors 不能报告完整成功;镜牢完成局数不足时报 failed 并在 errors 写明 已完成/应打 局数。' + '运行中不用逐帧 get_state/click/keypress 重做流程。' + '出现 stall 时先 stop_task 并确认停止,再 get_state 排障;停止失败不发送输入。' + '用户停止或退出码130时结束,不自动重试。' + '主线、特殊速通路线、用户明确要求逐步控制或自动流程不支持的操作,才使用低层观察与输入;' + '这时先 get_state 核对当前画面。只查看状态或截图的请求不启动任务。' + 'all 仅用于用户明确要求按配置运行全部任务;enkephalin 会花狂气,仅在明确授权消费时使用。' + '免费体力合成模块不属于 enkephalin;不把它改派为刷取或花狂气。' +) + def _obj(props=None, required=()): s = {'type': 'object', 'properties': props or {}} @@ -33,9 +50,11 @@ _IMG = {'name': {'type': 'string', 'description': 'AALC 模板图相对路径, TOOLS = [ {'name': 'show_game_background', 'description': '后台显示/恢复游戏窗口,使隐藏窗口继续渲染;不激活前台、不发送鼠标或键盘输入。', 'inputSchema': _obj()}, - {'name': 'get_state', 'description': '截图 + OCR, 返回游戏窗口内全部文字(含坐标/置信度)。决策前先调这个, 不要猜坐标', + {'name': 'get_state', 'description': '截图 + OCR,返回窗口文字、坐标和置信度。用于观察、故障诊断和逐步控制前核对画面。' + '常规日常/领奖/普通镜牢优先 run_task,运行进度用 task_status,无需逐帧操作。', 'inputSchema': _obj()}, - {'name': 'click_text', 'description': '按文字点击: OCR 定位后点中心。子串匹配、忽略空格, 完全相同的优先; index 选第几个命中', + {'name': 'click_text', 'description': '逐步控制/故障恢复用:按文字定位后点中心,完全匹配优先,index 选命中。' + '常规日常/领奖/普通镜牢优先 run_task。', 'inputSchema': _obj({'text': _STR, 'index': {'type': 'number', 'default': 0}}, ['text'])}, {'name': 'wait_for_text', 'description': '轮询 OCR 直到文字出现', 'inputSchema': _obj({'text': _STR, 'timeout': _TIMEOUT}, ['text'])}, {'name': 'wait_for_text_gone', 'description': '轮询 OCR 直到文字消失', 'inputSchema': _obj({'text': _STR, 'timeout': _TIMEOUT}, ['text'])}, @@ -45,9 +64,11 @@ TOOLS = [ {'name': 'list_images', 'description': '列出 AALC 模板图(按前缀过滤, 如 mirror/ battle/ home/)', 'inputSchema': _obj({'prefix': {'type': 'string', 'default': ''}})}, {'name': 'screenshot', 'description': '截游戏窗口, 返回 PNG 路径和尺寸', 'inputSchema': _obj()}, - {'name': 'click', 'description': '按窗口截图像素坐标点击(优先用 click_text / click_image)', + {'name': 'click', 'description': '逐步控制/故障恢复用:按最新窗口截图的像素坐标点击,优先 click_text / click_image。' + '常规日常/领奖/普通镜牢优先 run_task。', 'inputSchema': _obj({'x': _NUM, 'y': _NUM, 'times': {'type': 'number', 'default': 1}}, ['x', 'y'])}, - {'name': 'keypress', 'description': '按一次键: a-z 0-9 enter esc space tab shift ctrl alt up down left right', + {'name': 'keypress', 'description': '逐步控制/故障恢复用:按一次 a-z 0-9 enter esc space tab shift ctrl alt up down left right。' + '常规日常/领奖/普通镜牢优先 run_task,无需自行循环战斗按键。', 'inputSchema': _obj({'key': _STR}, ['key'])}, {'name': 'drag', 'description': '在游戏客户区保持左键按下并缓慢拖动,适用于卡包下拉;duration 是移动秒数,0.1–10,默认 1。先 get_state 核对坐标', 'inputSchema': _obj({'from_x': _NUM, 'from_y': _NUM, 'to_x': _NUM, 'to_y': _NUM, @@ -55,13 +76,20 @@ TOOLS = [ ['from_x', 'from_y', 'to_x', 'to_y'])}, {'name': 'type_text', 'description': '向游戏窗口输入文本', 'inputSchema': _obj({'text': _STR}, ['text'])}, {'name': 'run_task', 'description': ( + '常规日常刷取、领奖励、普通镜牢的首选工具;自动完成流程,无需逐按钮点击。先 task_status 确认没有任务在跑。' '后台运行 AALC 现成的完整任务流程(会自动启动游戏、处理战斗/掉线重试)。立即返回, 用 task_status 看进度。' 'all=按 AALC config.yaml 勾选的全部任务; daily=经验本+纽本(exp/thread 次数); reward=领奖励; ' - 'enkephalin=狂气换体力(times); mirror=镜牢(count 次数)。任务运行期间禁止手动点击类工具'), + 'enkephalin=狂气换体力(times); mirror=镜牢(count 次数)。一局镜牢传 task=mirror,count=1;' + '传 count 时本次临时关闭 AALC 无限刷牢,结束后恢复;完成局数不足时任务报 failed。' + '只刷一种日常时把另一种次数显式设为0,省略次数沿用配置。' + 'all 需明确要求全部任务;enkephalin 需明确授权花狂气,免费合成模块不能用它。' + '任务运行期间禁止手动点击类工具;最终 succeeded 也要检查 errors,用户停止后不自动重跑。'), 'inputSchema': _obj({'task': {'type': 'string', 'enum': sorted(TASKS)}, 'exp': _NUM, 'thread': _NUM, 'times': _NUM, 'count': _NUM}, ['task'])}, - {'name': 'task_status', 'description': '查看任务状态(idle/running/succeeded/failed/stopped)和日志尾部。' - 'succeeded 也要看 errors; running 时出现 stall 说明 AALC 在空转(如选中空队伍), 应 stop_task', + {'name': 'task_status', 'description': '启动 run_task 前检查占用,启动后轮询此工具监控,避免逐帧截图和重复启动。' + '返回 idle/running/succeeded/failed/stopped、日志及异常。' + 'succeeded 也要看 errors 和 pending_restore;running 出现 stall 应 stop_task 并确认停止后排障;' + 'stopped/退出码130 表示用户停止,不自动重跑。', 'inputSchema': _obj({'lines': {'type': 'number', 'default': 30}})}, {'name': 'stop_task', 'description': '强制停止当前任务(杀掉任务进程)', 'inputSchema': _obj()}, ] @@ -96,6 +124,7 @@ class Server: if method == 'initialize': return _ok(mid, {'protocolVersion': '2024-11-05', 'capabilities': {'tools': {'listChanged': False}}, + 'instructions': AUTOMATION_INSTRUCTIONS, 'serverInfo': {'name': 'lc-mcp', 'version': VERSION}}) if method == 'ping': return _ok(mid, {}) diff --git a/scripts/convert_modules.py b/scripts/convert_modules.py index eb576cd..713e9c8 100644 --- a/scripts/convert_modules.py +++ b/scripts/convert_modules.py @@ -33,6 +33,10 @@ from lc_ui import HERE, click, items, keypress, probe, screen_text GAME_EXE = r'D:\SteamLibrary\steamapps\common\Limbus Company\LimbusCompany.exe' GAME_PROC = 'LimbusCompany' REPO = os.path.dirname(HERE) if os.path.basename(HERE) == 'scripts' else HERE +if REPO not in sys.path: + sys.path.insert(0, REPO) +from lc_mcp.game_lock import exclusive_game + PYW = os.path.join(REPO, 'vendor', 'aalc', '.venv', 'Scripts', 'pythonw.exe') SERVER_PORT = 8765 @@ -760,8 +764,20 @@ def main(argv=None): log('=== 开始: 体力换模块 ===') + try: + with exclusive_game(): + return run_conversion(args, done) + except (OSError, RuntimeError, subprocess.SubprocessError) as e: + return done(1, '%s: %s' % (type(e).__name__, e)) + + +def run_conversion(args, done): if not ensure_server(): return done(1, 'MCP 服务连不上, 也没能拉起来') + # Also refuse older task processes started before the shared lock was added. + status = probe('task_status', {'lines': 1}) + if not status.get('ok') or status.get('state') not in ('idle', 'succeeded', 'failed', 'stopped'): + return done(1, 'AALC 任务仍在运行或状态无法确认,本轮不接管游戏') # 断线会让截图全黑, 那之后什么都做不了 —— 先确认桌面在出图再动游戏 if not ensure_display(): return done(1, '桌面不在出图(会话被断开), 本轮跳过') diff --git a/scripts/jev_mirror_agent.py b/scripts/jev_mirror_agent.py index da33aa8..4ded24a 100644 --- a/scripts/jev_mirror_agent.py +++ b/scripts/jev_mirror_agent.py @@ -1,4 +1,4 @@ -"""Validated scene actions for Jev decisions and fixed speedrun macros.""" +"""Delegate ordinary mirror runs to AALC; retain Jev control for special speedruns.""" import argparse import functools import json @@ -9,7 +9,8 @@ from pathlib import Path from mcp_session import Session as Bridge, SessionCancelled, SessionTimeout from game_scenes import battle_is_terminal, battle_is_visible, death_retry_screen -from run_state import prepare_run, save_json, record_claim, claim_is_current, complete_run +from run_state import (RESUMABLE, load_json, prepare_run, save_json, record_claim, + claim_is_current, complete_run) from decision_router import DecisionRouter, DecisionRequired from jev_client import request_answer from lc_scene_aliases import normalize @@ -797,22 +798,104 @@ def acquire_single_instance(): return lambda: kernel.CloseHandle(lease) +def execution_workflow(args, executor_decider=None): + """Keep explicit speedrun requirements and unfinished runs on their old path.""" + if args.workflow != 'auto': + return args.workflow + if (args.config or args.decision_engine or executor_decider is not None + or os.environ.get('LC_FIXED_FALLBACK') == '1'): + return 'speedrun' + previous = None if args.new_run else load_json(RUNTIME_HOME / 'mirror_current_run.json') + if previous and previous.get('workflow') == 'aalc': + return 'aalc' + if args.resume or previous and previous.get('status') in RESUMABLE: + return 'speedrun' + return 'aalc' + + +def delegate_mirror(new_run=False, resume=False): + """Start or inspect AALC once; the calling agent monitors task_status afterward.""" + record = {'workflow': 'aalc', 'next_call': {'tool': 'task_status', 'args': {'lines': 30}}, + 'note': '启动或接管监控不代表通关。继续轮询 task_status,检查 errors 和 pending_restore;' + '停止用 stop_task 或急停键(默认 End)。调用超时或用户停止后不自动重试或转为逐步输入。'} + bridge = None + try: + if STOP_FILE.exists(): + return dict(record, state='stopped', reason='stop_requested') + # An explicit workflow switch must not silently discard a special route. + previous = None if new_run else load_json(RUNTIME_HOME / 'mirror_current_run.json') + if previous and previous.get('status') in RESUMABLE: + return dict(record, state='requires_analysis', reason='unfinished_speedrun', + error='存在未完成的速通局;使用 --workflow speedrun --resume,明确新开任务时用 --new-run') + bridge = Bridge(cancelled=STOP_FILE.exists, raise_on_error=False) + current = bridge.call('task_status', {'lines': 30}) + state = current.get('state') + if not current.get('ok') or state not in ('idle', 'running', 'succeeded', 'failed', 'stopped'): + return dict(record, state='requires_analysis', task_status=current) + if (resume and previous and previous.get('workflow') == 'aalc' and previous.get('task_log') + and current.get('log') != previous['task_log']): + return dict(record, state='requires_analysis', reason='task_changed', task_status=current) + if state == 'running': + return dict(record, state='monitoring' if current.get('task') == 'mirror' else 'busy', + task_status=current) + if state == 'stopped' or current.get('exit_code') == 130: + if not new_run: + return dict(record, state='stopped', task_status=current, reason='user_stopped') + if resume: + return dict(record, state='requires_analysis' if current.get('errors') or current.get('pending_restore') + or current.get('task') != 'mirror' else state, task_status=current) + if state == 'failed' or current.get('errors') or current.get('pending_restore'): + if not new_run or current.get('pending_restore'): + return dict(record, state='requires_analysis', task_status=current) + started = bridge.call('run_task', {'task': 'mirror', 'count': 1}) + if not started.get('ok'): + return dict(record, state='requires_analysis', result=started) + record['result'] = started + run, _ = prepare_run(RUNTIME_HOME, new_run=True) + run.update(status='delegated', workflow='aalc', task_log=started.get('log')) + save_json(RUNTIME_HOME / 'mirror_current_run.json', run) + return dict(record, state='delegated') + except Exception as error: + record.update(state='stopped' if isinstance(error, SessionCancelled) else 'requires_analysis', + error='%s: %s' % (type(error).__name__, error)) + if isinstance(error, (SessionCancelled, SessionTimeout)): + record.update(outcome_unknown=error.outcome_unknown, pending_tool=getattr(error, 'tool', None)) + return record + finally: + if bridge is not None: + bridge.close() + + def main(executor_decider=None): parser = argparse.ArgumentParser() - parser.add_argument('config', nargs='?', help='Optional Jev JSON config; omit for execution-model handoff') + parser.add_argument('config', nargs='?', help='Optional Jev JSON config for stepwise speedrun control') + parser.add_argument('--workflow', choices=('auto', 'aalc', 'speedrun'), default='auto', + help='Default: AALC for ordinary mirror runs; explicit model/config or unfinished speedrun keeps stepwise control') parser.add_argument('--decision-engine', choices=('auto', 'jev', 'executor', 'fixed')) - parser.add_argument('--steps', type=int, default=250) - parser.add_argument('--seconds', type=int, default=1200) + parser.add_argument('--steps', type=int, default=250, help='Stepwise speedrun action budget') + parser.add_argument('--seconds', type=int, default=1200, help='Stepwise speedrun time budget') mode = parser.add_mutually_exclusive_group() mode.add_argument('--new-run', action='store_true', help='Start fresh state for a new dungeon') mode.add_argument('--resume', action='store_true', help='Require an unfinished run with matching state') args = parser.parse_args() if args.steps <= 0 or args.seconds <= 0: parser.error('--steps and --seconds must be positive') + try: + workflow = execution_workflow(args, executor_decider) + except (OSError, ValueError) as error: + parser.error(str(error)) release = acquire_single_instance() if release is None: print(json.dumps({'state':'already_running'}), flush=True) return + if workflow == 'aalc': + try: + record = delegate_mirror(new_run=args.new_run, resume=args.resume) + save_json(RUNTIME_HOME / 'aalc_mirror_status.json', record) + print(json.dumps(record, ensure_ascii=False), flush=True) + finally: + release() + return log = RUNTIME_HOME / 'jev_mirror_log.jsonl' status = RUNTIME_HOME / 'jev_mirror_status.json' deadline = time.monotonic() + args.seconds diff --git a/scripts/levelup.py b/scripts/levelup.py index 77f554d..3ab1dcb 100644 --- a/scripts/levelup.py +++ b/scripts/levelup.py @@ -297,6 +297,7 @@ def cmd_card(ci, ri, uptie=False): print('详情页已打开') ok, desc = do_level_up() print('升级: %s (%s)' % ('OK' if ok else 'FAIL', desc)) + ok2 = True if uptie: ok2, desc2 = do_uptie() print('同步: %s (%s)' % ('OK' if ok2 else 'FAIL', desc2)) @@ -318,7 +319,7 @@ def cmd_card(ci, ri, uptie=False): txt = screen_text(items) if not ('IDENTITIES' in txt and 'Facades' in txt): print('[warn] 未能回到 Identities 网格, 当前: ' + txt[:160]) - return 0 if ok else 1 + return 0 if ok and ok2 else 1 # 每级升级所需经验(来源 wiki "EXP per Level" 表)。 diff --git a/tests/test_automation_dispatch.py b/tests/test_automation_dispatch.py new file mode 100644 index 0000000..a65b948 --- /dev/null +++ b/tests/test_automation_dispatch.py @@ -0,0 +1,154 @@ +"""Ordinary mirror requests delegate to AALC without entering the click loop.""" +import contextlib +import io +import json +import os +from pathlib import Path +import sys +import tempfile +from types import SimpleNamespace +import unittest +from unittest import mock + +sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'scripts')) +import jev_mirror_agent as agent +from mcp_session import SessionTimeout +from run_state import save_json + + +class AutomationDispatchTest(unittest.TestCase): + def setUp(self): + folder = tempfile.TemporaryDirectory() + self.addCleanup(folder.cleanup) + self.home = Path(folder.name) + for patch in (mock.patch.object(agent, 'RUNTIME_HOME', self.home), + mock.patch.object(agent, 'STOP_FILE', self.home / 'JEV_STOP'), + mock.patch.dict(os.environ, {'LC_FIXED_FALLBACK': '0'})): + patch.start() + self.addCleanup(patch.stop) + + def workflow(self, **overrides): + args = dict(workflow='auto', config=None, decision_engine=None, new_run=False, resume=False) + args.update(overrides) + return agent.execution_workflow(SimpleNamespace(**args)) + + def test_ordinary_request_defaults_to_aalc(self): + self.assertEqual(self.workflow(), 'aalc') + + def test_special_requirements_preserve_speedrun(self): + for args in ({'config': 'jev.json'}, {'decision_engine': 'executor'}, {'resume': True}, + {'workflow': 'speedrun'}): + with self.subTest(args=args): + self.assertEqual(self.workflow(**args), 'speedrun') + save_json(self.home / 'mirror_current_run.json', {'status': 'requires_decision'}) + self.assertEqual(self.workflow(), 'speedrun') + self.assertEqual(self.workflow(new_run=True), 'aalc') + + def delegate(self, current, started=None, **kwargs): + bridge = mock.Mock() + bridge.call.side_effect = [current, started or {'ok': True, 'log': 'new.log', 'task': 'mirror'}] + with mock.patch.object(agent, 'Bridge', return_value=bridge): + result = agent.delegate_mirror(**kwargs) + bridge.close.assert_called_once() + return result, bridge + + def test_launches_only_mirror_and_returns_monitoring_contract(self): + result, bridge = self.delegate({'ok': True, 'state': 'idle'}) + self.assertEqual(result['state'], 'delegated') + self.assertEqual(result['next_call']['tool'], 'task_status') + self.assertEqual(bridge.call.call_args_list, [mock.call('task_status', {'lines': 30}), + mock.call('run_task', {'task': 'mirror', 'count': 1})]) + run = json.loads((self.home / 'mirror_current_run.json').read_text()) + self.assertFalse(run['dungeon_completed']) + self.assertFalse(run['final_reward_claimed']) + self.assertEqual(self.workflow(resume=True), 'aalc') + + def test_running_mirror_is_monitored_without_duplicate_start(self): + result, bridge = self.delegate({'ok': True, 'state': 'running', 'task': 'mirror'}) + self.assertEqual(result['state'], 'monitoring') + self.assertEqual(bridge.call.call_count, 1) + + def test_other_running_task_is_not_stopped_or_replaced(self): + result, bridge = self.delegate({'ok': True, 'state': 'running', 'task': 'daily'}) + self.assertEqual(result['state'], 'busy') + self.assertEqual(bridge.call.call_count, 1) + + def test_user_stop_never_restarts_without_new_request(self): + for current in ({'ok': True, 'state': 'stopped', 'task': 'mirror'}, + {'ok': True, 'state': 'failed', 'exit_code': 130}): + with self.subTest(current=current): + result, bridge = self.delegate(current) + self.assertEqual(result['state'], 'stopped') + self.assertEqual(bridge.call.call_count, 1) + result, bridge = self.delegate({'ok': True, 'state': 'stopped'}, new_run=True) + self.assertEqual(result['state'], 'delegated') + + def test_unknown_or_failed_status_never_triggers_blind_retry(self): + for current in ({}, {'ok': False, 'error': 'offline'}, {'ok': True, 'state': 'unexpected'}, + {'ok': True, 'state': 'failed'}, + {'ok': True, 'state': 'succeeded', 'errors': ['battle failed']}, + {'ok': True, 'state': 'succeeded', 'pending_restore': ['x.restore.json']}): + with self.subTest(current=current): + result, bridge = self.delegate(current) + self.assertEqual(result['state'], 'requires_analysis') + self.assertEqual(bridge.call.call_count, 1) + + def test_resume_checks_errors_without_launching_another_run(self): + current = {'ok': True, 'state': 'succeeded', 'task': 'mirror', 'errors': ['battle failed']} + result, bridge = self.delegate(current, resume=True) + self.assertEqual(result['state'], 'requires_analysis') + self.assertEqual(bridge.call.call_count, 1) + + def test_resume_does_not_accept_a_different_task_as_its_result(self): + save_json(self.home / 'mirror_current_run.json', { + 'workflow': 'aalc', 'status': 'delegated', 'task_log': 'original.log'}) + result, bridge = self.delegate({'ok': True, 'state': 'succeeded', 'task': 'mirror', + 'log': 'another.log'}, resume=True) + self.assertEqual(result['reason'], 'task_changed') + self.assertEqual(bridge.call.call_count, 1) + + def test_unfinished_speedrun_blocks_unrequested_workflow_switch(self): + save_json(self.home / 'mirror_current_run.json', {'status': 'requires_decision'}) + with mock.patch.object(agent, 'Bridge') as factory: + result = agent.delegate_mirror() + self.assertEqual(result['reason'], 'unfinished_speedrun') + factory.assert_not_called() + + def test_stop_marker_prevents_even_connecting(self): + agent.STOP_FILE.touch() + with mock.patch.object(agent, 'Bridge') as factory: + self.assertEqual(agent.delegate_mirror()['state'], 'stopped') + factory.assert_not_called() + + def test_timeout_after_start_is_reported_without_retry_or_clicks(self): + bridge = mock.Mock() + error = SessionTimeout('reply lost') + error.tool = 'run_task' + bridge.call.side_effect = [{'ok': True, 'state': 'idle'}, error] + with mock.patch.object(agent, 'Bridge', return_value=bridge): + result = agent.delegate_mirror() + self.assertEqual(result['state'], 'requires_analysis') + self.assertTrue(result['outcome_unknown']) + self.assertEqual(result['pending_tool'], 'run_task') + self.assertEqual(bridge.call.call_count, 2) + bridge.close.assert_called_once() + + def test_plain_cli_takes_aalc_path_without_model_or_ocr(self): + bridge = mock.Mock() + bridge.call.side_effect = [{'ok': True, 'state': 'idle'}, {'ok': True, 'log': 'mirror.log'}] + release = mock.Mock() + with mock.patch.object(sys, 'argv', ['agent']), \ + mock.patch.object(agent, 'Bridge', return_value=bridge), \ + mock.patch.object(agent, 'acquire_single_instance', return_value=release), \ + mock.patch.object(agent, 'DecisionRouter') as router, \ + contextlib.redirect_stdout(io.StringIO()): + agent.main() + router.assert_not_called() + release.assert_called_once() + result = json.loads((self.home / 'aalc_mirror_status.json').read_text()) + self.assertEqual(result['state'], 'delegated') + self.assertEqual([call.args[0] for call in bridge.call.call_args_list], ['task_status', 'run_task']) + + +if __name__ == '__main__': + unittest.main() diff --git a/tests/test_convert_modules.py b/tests/test_convert_modules.py index 1787b4a..cce2ee8 100644 --- a/tests/test_convert_modules.py +++ b/tests/test_convert_modules.py @@ -14,6 +14,7 @@ from unittest import mock sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'scripts')) import convert_modules as cm # noqa: E402 +from lc_mcp import game_lock class QuietLogMixin: @@ -28,6 +29,62 @@ class QuietLogMixin: patcher = mock.patch.object(cm, 'log', lambda m: None) patcher.start() self.addCleanup(patcher.stop) + tmp = tempfile.TemporaryDirectory() + self.addCleanup(tmp.cleanup) + patcher = mock.patch.object(game_lock, 'default_lock_path', + return_value=os.path.join(tmp.name, 'game.lock')) + patcher.start() + self.addCleanup(patcher.stop) + patcher = mock.patch.object(cm, 'probe', return_value={'ok': True, 'state': 'idle'}) + patcher.start() + self.addCleanup(patcher.stop) + + +class GameOwnershipTest(QuietLogMixin, unittest.TestCase): + def test_running_task_is_not_navigated_or_closed(self): + from lc_mcp.fake_engine import FakeEngine + from lc_mcp.protocol import Server + from lc_mcp.tasks import TaskRunner + + with tempfile.TemporaryDirectory() as tmp: + runner = TaskRunner(tmp, argv_factory=lambda *a: [ + sys.executable, '-c', 'import time; time.sleep(30)']) + server = Server(FakeEngine(), runner) + runner.start('daily', {}) # Emulate an older process without the shared lock. + try: + with mock.patch.object(cm, 'probe', side_effect=server.call_tool), \ + mock.patch.object(cm, 'ensure_server', return_value=True), \ + mock.patch.object(cm, 'ensure_display') as display, \ + mock.patch.object(cm, 'launch_game') as launch, \ + mock.patch.object(cm, 'close_game') as close: + self.assertEqual(cm.main(['--report-dir', tmp]), 1) + display.assert_not_called() + launch.assert_not_called() + close.assert_not_called() + self.assertTrue(runner.running()) + self.assertEqual(server.engine.actions, []) + finally: + runner.stop() + + def test_unknown_status_does_not_touch_the_game(self): + for status in ({}, {'ok': False}, {'ok': True, 'state': 'unknown'}): + with self.subTest(status=status), tempfile.TemporaryDirectory() as tmp, \ + mock.patch.object(cm, 'probe', return_value=status), \ + mock.patch.object(cm, 'ensure_server', return_value=True), \ + mock.patch.object(cm, 'ensure_display') as display, \ + mock.patch.object(cm, 'close_game') as close: + self.assertEqual(cm.main(['--report-dir', tmp]), 1) + display.assert_not_called() + close.assert_not_called() + + def test_existing_owner_prevents_even_service_startup(self): + with tempfile.TemporaryDirectory() as tmp, \ + mock.patch.object(cm, 'ensure_server') as server, \ + mock.patch.object(cm, 'close_game') as close, \ + game_lock.exclusive_game(): + self.assertEqual(cm.main(['--report-dir', tmp]), 1) + server.assert_not_called() + close.assert_not_called() class ScreenDetectTest(QuietLogMixin, unittest.TestCase): @@ -603,6 +660,14 @@ class CliRoutingTest(QuietLogMixin, unittest.TestCase): done = [] tmp = tempfile.mkdtemp() self.addCleanup(shutil.rmtree, tmp, True) + + def close_owned_game(): + # Ownership must cover shutdown too, so a new task cannot start here. + with self.assertRaises(game_lock.GameBusyError): + with game_lock.exclusive_game(): + pass + closed.append(1) + with mock.patch.object(cm, 'read_enkephalin', lambda: 4), \ mock.patch.object(cm, 'read_lunacy', lambda **k: 9699), \ mock.patch.object(cm, 'ensure_server', lambda *a: True), \ @@ -611,7 +676,7 @@ class CliRoutingTest(QuietLogMixin, unittest.TestCase): mock.patch.object(cm, 'wait_main_menu', lambda *a: True), \ mock.patch.object(cm, 'ensure_window_size', lambda *a: (1600, 900)), \ mock.patch.object(cm, 'close_panel', lambda: True), \ - mock.patch.object(cm, 'close_game', lambda: closed.append(1)), \ + mock.patch.object(cm, 'close_game', close_owned_game), \ mock.patch.object(cm.time, 'sleep', lambda s: None): code = cm.main(argv + ['--report-dir', tmp]) done.append(os.listdir(tmp)) diff --git a/tests/test_driver_input.py b/tests/test_driver_input.py index 672ad7a..904694e 100644 --- a/tests/test_driver_input.py +++ b/tests/test_driver_input.py @@ -10,6 +10,7 @@ 关掉后严格 1:1。所以加速没关时不该给出"差不多"的位置。 """ import sys +import contextlib import os import ast import inspect @@ -326,6 +327,10 @@ class DriverWiringTest(unittest.TestCase): with mock.patch.dict(sys.modules, modules), \ mock.patch.dict(os.environ, LCP_DRIVER_INPUT='1', LCP_RESTORE_FILE=''), \ mock.patch.object(aalc_task, 'bootstrap'), \ + mock.patch.object(aalc_task, 'exclusive_game'), \ + mock.patch.object(aalc_task, 'headless_hdr_warning') as hdr_warning, \ + mock.patch.object(aalc_task, 'mirror_progress', + lambda scheme: contextlib.nullcontext(ap.MirrorProgress())), \ mock.patch.object(aalc_task, 'install_exact_team_match'), \ mock.patch.object(aalc_task, 'install_robust_set_foreground'), \ mock.patch.object(aalc_task, 'WindowGuard'), \ @@ -338,6 +343,7 @@ class DriverWiringTest(unittest.TestCase): mock.patch.object(ap.DriverClickProxy, '_screen_pos', return_value=(10, 20)): self.assertEqual(aalc_task.run(task, {}), 3 if problems else 0) install_hotkey.return_value.stop.assert_called_once() + self.assertEqual(hdr_warning.call_count, int(task == 'all' and not problems)) if problems: drv.click.assert_not_called() else: diff --git a/tests/test_game_lock.py b/tests/test_game_lock.py new file mode 100644 index 0000000..3126459 --- /dev/null +++ b/tests/test_game_lock.py @@ -0,0 +1,67 @@ +import os +from pathlib import Path +import subprocess +import sys +import tempfile +import time +import unittest +from unittest import mock + +sys.path.insert(0, str(Path(__file__).resolve().parents[1])) +from lc_mcp import aalc_task, game_lock + + +class GameLockTest(unittest.TestCase): + def setUp(self): + tmp = tempfile.TemporaryDirectory() + self.addCleanup(tmp.cleanup) + self.path = os.path.join(tmp.name, 'game.lock') + + def test_exception_releases_lock_without_deleting_file(self): + with self.assertRaisesRegex(RuntimeError, 'failed'): + with game_lock.exclusive_game(self.path): + raise RuntimeError('failed') + self.assertTrue(os.path.exists(self.path)) + with game_lock.exclusive_game(self.path): + with self.assertRaises(game_lock.GameBusyError): + with game_lock.exclusive_game(self.path): + self.fail('second owner acquired the game') + + def test_process_lock_is_released_after_hard_exit(self): + ready = self.path + '.ready' + code = ''' +import os, sys, time +from lc_mcp.game_lock import exclusive_game +with exclusive_game(sys.argv[1]): + with open(sys.argv[2], 'w') as marker: + marker.write('ready') + time.sleep(30) +''' + with subprocess.Popen([sys.executable, '-c', code, self.path, ready], + cwd=Path(__file__).resolve().parents[1], + stdout=subprocess.PIPE, stderr=subprocess.PIPE) as proc: + try: + deadline = time.monotonic() + 5 + while not os.path.exists(ready) and proc.poll() is None and time.monotonic() < deadline: + time.sleep(.01) + self.assertTrue(os.path.exists(ready), 'child did not acquire the lock') + with self.assertRaises(game_lock.GameBusyError): + with game_lock.exclusive_game(self.path): + self.fail('parent acquired a live child lock') + finally: + proc.kill() + proc.communicate(timeout=5) + with game_lock.exclusive_game(self.path): + pass + + def test_task_refuses_converter_lock_before_bootstrap(self): + with mock.patch.object(game_lock, 'default_lock_path', return_value=self.path), \ + mock.patch.object(aalc_task, 'bootstrap') as bootstrap, \ + mock.patch.object(aalc_task, 'log'): + with game_lock.exclusive_game(): + self.assertEqual(aalc_task.run('daily', {}), aalc_task.PREFLIGHT_EXIT) + bootstrap.assert_not_called() + + +if __name__ == '__main__': + unittest.main() diff --git a/tests/test_lc_mcp.py b/tests/test_lc_mcp.py index fc50425..3555728 100644 --- a/tests/test_lc_mcp.py +++ b/tests/test_lc_mcp.py @@ -18,7 +18,7 @@ sys.path.insert(0, REPO) from lc_mcp import server as srv_mod # noqa: E402 from lc_mcp.engine import find_hits # noqa: E402 from lc_mcp.fake_engine import FakeEngine # noqa: E402 -from lc_mcp.protocol import Server, TOOLS # noqa: E402 +from lc_mcp.protocol import AUTOMATION_INSTRUCTIONS, Server, TOOLS # noqa: E402 from lc_mcp.tasks import TaskRunner # noqa: E402 START = {'text': '开始', 'x': 100, 'y': 200, 'w': 40, 'h': 20} @@ -67,6 +67,7 @@ class ProtocolTest(unittest.TestCase): def test_initialize_and_list(self): r = self.s.handle({'jsonrpc': '2.0', 'id': 7, 'method': 'initialize', 'params': {}}) self.assertEqual(r['id'], 7) + self.assertEqual(r['result']['instructions'], AUTOMATION_INSTRUCTIONS) names = [t['name'] for t in self.s.handle({'jsonrpc': '2.0', 'id': 8, 'method': 'tools/list'})['result']['tools']] self.assertEqual(names, [t['name'] for t in TOOLS]) self.assertIsNone(self.s.handle({'jsonrpc': '2.0', 'method': 'notifications/initialized'})) @@ -213,7 +214,7 @@ class AalcTaskArgsTest(unittest.TestCase): class Cfg: def __init__(self): - self.values, self.saved, self.flushes = {'set_mirror_count': 1}, {}, 0 + self.values, self.saved, self.flushes = {'set_mirror_count': 1, 'infinite_dungeons': True}, {}, 0 def get_value(self, key): return self.values[key] @@ -228,20 +229,33 @@ class AalcTaskArgsTest(unittest.TestCase): self.flushes += 1 cfg = Cfg() - with tempfile.TemporaryDirectory() as d: + before = {'set_mirror_count': 1, 'infinite_dungeons': True} + lines = [] + with tempfile.TemporaryDirectory() as d, mock.patch.object(aalc_task, 'log', lines.append): path = os.path.join(d, 'x.restore.json') originals = aalc_task.apply_overrides(cfg, 'mirror', {'count': 5}, path) - self.assertEqual(cfg.values['set_mirror_count'], 5) + # 指定次数时无限刷牢必须关掉, 否则 AALC 把次数改成 9999 + self.assertEqual(cfg.values, {'set_mirror_count': 5, 'infinite_dungeons': False}) + self.assertIn('无限刷牢', '\n'.join(lines)) with open(path, encoding='utf-8') as f: - self.assertEqual(json.load(f), {'set_mirror_count': 1}) - self.assertEqual(originals, {'set_mirror_count': 1}) + self.assertEqual(json.load(f), before) + self.assertEqual(originals, before) # 任务进程被强杀后, TaskRunner 用 --restore 读文件写回 aalc_task.restore_file(path, cfg) - self.assertEqual((cfg.saved, cfg.flushes), ({'set_mirror_count': 1}, 1)) + self.assertEqual((cfg.saved, cfg.flushes), (before, 1)) self.assertFalse(os.path.exists(path)) self.assertEqual(aalc_task.apply_overrides(cfg, 'reward', {}, path), {}) self.assertFalse(os.path.exists(path)) # 没有覆盖就不留恢复文件 + def test_mirror_without_count_keeps_configured_infinite_mode(self): + from lc_mcp import aalc_task + cfg = mock.Mock() + cfg.get_value.side_effect = {'set_EXP_count': 3}.get + self.assertEqual(aalc_task.apply_overrides(cfg, 'mirror', {}), {}) + cfg.unsaved_set_value.assert_not_called() + self.assertEqual(aalc_task.apply_overrides(cfg, 'daily', {'exp': 1}), {'set_EXP_count': 3}) + cfg.unsaved_set_value.assert_called_once_with('set_EXP_count', 1) + class TaskRestoreTest(unittest.TestCase): """run_task 的临时次数会随 AALC 中途存盘写进 config.yaml; 强杀后必须写回原值。""" diff --git a/tests/test_levelup.py b/tests/test_levelup.py index 875aca4..76b8089 100644 --- a/tests/test_levelup.py +++ b/tests/test_levelup.py @@ -80,6 +80,37 @@ class ProgressResultTest(unittest.TestCase): self.assertEqual(self.run_progress(level=30), (0, 1)) +class CardResultTest(unittest.TestCase): + def run_command(self, command, upgrade=True, sync=True, uptie=True): + argv = ['levelup.py'] + command + (['--uptie'] if uptie else []) + with mock.patch.object(sys, 'argv', argv), \ + mock.patch.object(levelup, 'state', return_value={ + 'items': [{'text': 'Level Up IDENTITIES Facades'}]}), \ + mock.patch.object(levelup, 'scan_grid', return_value=[ + (0, 0, 335, 260, 20, True, 'identity')]), \ + mock.patch.object(levelup, 'dismiss_modal'), \ + mock.patch.object(levelup, 'long_press'), \ + mock.patch.object(levelup, 'click'), \ + mock.patch.object(levelup, 'do_level_up', return_value=(upgrade, '升级结果')), \ + mock.patch.object(levelup, 'do_uptie', return_value=(sync, '同步结果')) as synchronize, \ + mock.patch.object(levelup.time, 'sleep'), \ + mock.patch('builtins.print'): + code = levelup.main() + return code, synchronize.call_count + + def test_failed_uptie_fails_both_cli_commands(self): + for command in (['card', '0', '0'], ['weakest']): + with self.subTest(command=command): + self.assertEqual(self.run_command(command, sync=False), (1, 1)) + + def test_both_operations_must_succeed(self): + self.assertEqual(self.run_command(['card', '0', '0']), (0, 1)) + self.assertEqual(self.run_command(['card', '0', '0'], upgrade=False), (1, 1)) + + def test_upgrade_without_uptie_keeps_its_result(self): + self.assertEqual(self.run_command(['card', '0', '0'], uptie=False), (0, 0)) + + class Screens: """按顺序返回预设画面的假 state(), 记录点击。""" diff --git a/tests/test_preflight_patches.py b/tests/test_preflight_patches.py index c3e8b40..2bb2437 100644 --- a/tests/test_preflight_patches.py +++ b/tests/test_preflight_patches.py @@ -1,6 +1,10 @@ +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__)))) @@ -34,6 +38,28 @@ class PreflightTest(unittest.TestCase): 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) @@ -56,15 +82,175 @@ class PreflightTest(unittest.TestCase): class Cfg: data = {'simulator': False, 'mirror': True, 'set_win_size': 720, - 'set_lunacy_to_enkephalin': None, 'teams_active_queue': [1], 'teams': {1: Team()}} + '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):