Compare commits
4
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
5fdb9fd221 | ||
|
|
1aa823ea2e | ||
|
|
05626e95c7 | ||
|
|
a74fda07e2 |
@@ -98,8 +98,24 @@ $env:LCP_DRIVER_TRACE = "$env:USERPROFILE\lc_mcp\driver-input.log"
|
||||
模拟器不接管;拖拽、滚动、键盘以及 MCP 的独立 `click` 工具仍使用原后端。
|
||||
当前回归验证覆盖软件接线和异常处理,DLL、实际驱动及游戏响应需在 Windows 实机核验。
|
||||
|
||||
任务运行期间按 **End** 急停,可用 `LCP_KILL_KEY` 改成 `pause`、`scrolllock` 等键名。
|
||||
不要用 F12(Steam 截图键);监听用 `GetAsyncKeyState` 轮询,因为 pynput 钩子在该机器的会话里收不到按键。
|
||||
急停会终止任务子进程,保留游戏窗口;`task_status` 返回 `stopped`、退出码 `130`。
|
||||
刷取循环检测到用户停止后结束本轮,不再导航、升级或重试。急停前会尝试释放驱动
|
||||
按住的鼠标按钮,清理超过 250 毫秒仍强制退出;硬退出留下的临时配置恢复文件由
|
||||
`stop_task` 或下一次 `run_task` 处理。热键监听依赖 AALC 的 `pynput`,安装失败会写日志;
|
||||
也可从 MCP 调用 `stop_task`,或按 Ctrl+Alt+Del 打开任务管理器终止任务进程。
|
||||
此热键只覆盖 `run_task` 子进程,不覆盖独立运行的合成、升级脚本。
|
||||
|
||||
## 工具
|
||||
|
||||
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}` |
|
||||
@@ -129,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),
|
||||
原值和次数一起写入恢复文件,结束或被强杀后都会写回。
|
||||
|
||||
## 无人值守
|
||||
|
||||
@@ -166,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` 时,同步失败会返回非零退出码。
|
||||
|
||||
## 环境变量
|
||||
|
||||
@@ -180,6 +208,7 @@ powershell -ExecutionPolicy Bypass -File scripts\install_convert_task.ps1 -Every
|
||||
| `LCP_PORT` | 8765 | 服务/bridge 端口 |
|
||||
| `LCP_KEEP_SHOTS` | 30 | 截图保留张数 |
|
||||
| `LCP_ALLOW_LUNACY` | 未设置 | 设为 `1` 时允许预检放行 `set_lunacy_to_enkephalin` 不为 0 的配置 |
|
||||
| `LCP_KILL_KEY` | `end` | 任务子进程的急停键,如 `pause` / `scrolllock`;认不出的键名会报错而不是换成默认键 |
|
||||
| `LC_PY` | 当前解释器 | `levelup.py`/`auto_cycle.py` 调用 MCP 用的 Python |
|
||||
|
||||
## 开发 / 测试
|
||||
@@ -223,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
|
||||
# 新开一局:清除上一局的楼层、饰品与领取状态
|
||||
|
||||
@@ -228,5 +228,3 @@ Get-ChildItem "$dir\convert_*.json" | ForEach-Object {
|
||||
if ($m -and $m.secs -eq $r.elapsed_s) { "OK $($r.started)" } else { "MISMATCH $($_.Name)" }
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
|
||||
@@ -96,3 +96,35 @@ OCR 误读;已知读法集合只来自该账号历史观测,不是通用余
|
||||
测试从 vendor AST 提取并执行真实的 `init_input`、交互门与监控点击方法, 不复制其接线逻辑;
|
||||
实际 `aalc_task.run` 的 `all` / `daily` 入口也有覆盖。Windows DLL 和游戏未在本次环境执行。
|
||||
PrintWindow 探测仅表示 API 调用成功, 不保证像素内容有效; 真机仍需检查画面、焦点和点击响应。
|
||||
|
||||
## 合入 main 前的复核与急停补齐
|
||||
|
||||
合并目标为 `main`(原 `073e407`),来源为
|
||||
`codex/feedback-unattended-setup-20261004`。本轮拉取又发现 `8a9495b`:
|
||||
它是一个新增 F12 急停的提交,涉及三个文件,也纳入本次合并。
|
||||
复核覆盖分支相对 main 的运行时、脚本、安装配置和测试变更,结合上述两轮审查记录;
|
||||
AALC 子模块保持已验证的 `e1d1749`,没有追入 develop 的图标提交。
|
||||
|
||||
合并前另修复以下问题:
|
||||
|
||||
- 急停回调先写日志,日志抛错会跳过退出,日志阻塞也会延迟急停。
|
||||
回调改为分发退出工作,不写日志;清理另有 250 毫秒强退兜底。
|
||||
这遵循 [pynput 对 Windows 键盘回调的说明](https://pynput.readthedocs.io/en/latest/keyboard.html#the-keyboard-listener-thread):避免在回调中阻塞。
|
||||
- 硬退出跳过驱动点击的 finally,可能留下按住的鼠标按钮。
|
||||
驱动增加停止标志及输入锁,急停先拒绝新鼠标输入,再释放本实例按住的按钮。
|
||||
驱动本身卡住时仍按时退出;本次离线验证不证明硬件故障下必定释放成功。
|
||||
- `killswitch.stop` 原先未接到任务退出路径;现在正常结束、异常和预检拒绝都会关闭监听器。
|
||||
- 退出码 130 原先显示 failed,镜牢轮询后还会继续导航和升级。
|
||||
现在状态为 stopped,刷取脚本终止整轮并写入用户停止报告,不重试、不继续升级。
|
||||
- 计划任务时限仍按 75 分钟镜牢设置,短于脚本的 100 分钟上限,也未覆盖一次卡死重试。
|
||||
安装脚本改为 daily 45 分钟、每局镜牢 100 分钟、各至多两次尝试,另加 30 分钟收尾预算。
|
||||
此改动只影响后续安装任务,未操作现有 Windows 计划任务。
|
||||
- 纠正合成安装脚本关于注销后运行和固定体力恢复速率的过时注释,清理文档尾部空行。
|
||||
|
||||
验证:Linux / Python 3.12 全套 **437 项通过**(17.112 秒);相对 main 的
|
||||
`git diff --check` 通过。新增回归涵盖真正退出 130 的子进程、保留恢复文件、用户停止后
|
||||
不继续操作、驱动按住时急停、清理卡住仍退出以及正常/预检拒绝后的监听器清理。
|
||||
Windows 热键、驱动及 PowerShell 计划任务仍需实机验收。
|
||||
|
||||
分支清理仅针对完整合入 main 的来源分支。`fix/team-scroll-patch` 仍有独有的
|
||||
`dd4259d` 实验提交,本次不合入也不删除;其历史取舍见上面的 DSH 审查记录。
|
||||
|
||||
@@ -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)。沿用用户配好的队伍、难度、出战顺序,不为了通用攻略改动配置。
|
||||
|
||||
+62
-2
@@ -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())
|
||||
@@ -182,6 +233,10 @@ class DriverClickProxy:
|
||||
handle.setForeground()
|
||||
if foreground_window() != hwnd:
|
||||
raise OSError('无法激活游戏窗口, 未发送驱动输入')
|
||||
# 游戏重启后句柄会变; 每次按当前句柄重新绑定, 免得前台校验拿旧句柄拒绝所有点击。
|
||||
bind = getattr(self._driver, 'bind_window', None)
|
||||
if bind is not None:
|
||||
bind(hwnd)
|
||||
return client_to_screen(hwnd, x, y)
|
||||
|
||||
def _trace(self, msg):
|
||||
@@ -228,8 +283,7 @@ class DriverClickProxy:
|
||||
sx, sy = self._screen_pos(x, y)
|
||||
if not self._driver.move_to(sx, sy):
|
||||
return False
|
||||
self._driver.down(1)
|
||||
return True
|
||||
return self._driver.down(1) is not False
|
||||
|
||||
def mouse_up(self, x, y):
|
||||
try:
|
||||
@@ -282,6 +336,12 @@ def install_driver_click(auto, screen, driver=None, log=print):
|
||||
return drv
|
||||
|
||||
|
||||
def stop_driver_click(auto):
|
||||
handler = auto.input_handler
|
||||
if isinstance(handler, DriverClickProxy):
|
||||
handler._driver.emergency_stop()
|
||||
|
||||
|
||||
@contextmanager
|
||||
def driver_click_tasks(scheme, auto, screen, cfg, log=print):
|
||||
"""每次游戏初始化完成后接管, 包括 all 任务和故障重启。"""
|
||||
|
||||
+88
-56
@@ -9,12 +9,13 @@ import json
|
||||
import os
|
||||
import sys
|
||||
|
||||
from . import preflight
|
||||
from . import killswitch, preflight
|
||||
from .aalc_engine import bootstrap
|
||||
from . import killswitch
|
||||
from .aalc_patches import (WindowGuard, driver_click_tasks, install_default_battle_team,
|
||||
install_exact_team_match, install_robust_set_foreground,
|
||||
install_system_team_selection)
|
||||
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 = {
|
||||
@@ -24,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):
|
||||
@@ -38,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)
|
||||
@@ -68,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
|
||||
@@ -77,55 +110,54 @@ def run(task, params):
|
||||
from tasks.battle import battle
|
||||
from utils.path_manager import path_manager
|
||||
|
||||
# 急停热键: 装得越早越好。驱动级点击期间鼠标被人和程序抢来抢去,
|
||||
# 用户没法用鼠标点停止按钮, 键盘是唯一可靠的中断手段。
|
||||
kill_listener = killswitch.install(log=log)
|
||||
with killswitch.listening(log=log, on_stop=lambda: stop_driver_click(auto)):
|
||||
problems = preflight.check(preflight.collect(cfg), task,
|
||||
desktop=None if cfg.simulator else preflight.desktop_size())
|
||||
if problems:
|
||||
for p in problems:
|
||||
log('[ERROR] [lc_mcp] preflight: %s' % p)
|
||||
return PREFLIGHT_EXIT
|
||||
|
||||
problems = preflight.check(preflight.collect(cfg), task,
|
||||
desktop=None if cfg.simulator else preflight.desktop_size())
|
||||
if problems:
|
||||
for p in problems:
|
||||
log('[ERROR] [lc_mcp] preflight: %s' % p)
|
||||
return PREFLIGHT_EXIT
|
||||
|
||||
install_exact_team_match(auto, log)
|
||||
install_robust_set_foreground(screen, log=log)
|
||||
# 日常本(经验/纽本)不翻队伍列表: 队伍是自定义名字时按名字找必然失败,
|
||||
# 白等 60 秒还会把界面滚乱, 后面 to_battle 就找不到 "进入战斗" 了。
|
||||
if task in ('daily', 'all'):
|
||||
install_default_battle_team(scheme, log=log)
|
||||
# 镜牢: 编队是自定义名字(体系名), AALC 只会找 "编队#N"; 改成按体系名点选。
|
||||
if task in ('mirror', 'all'):
|
||||
install_system_team_selection(log=log)
|
||||
guard = WindowGuard(screen, cfg, log=log)
|
||||
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):
|
||||
try:
|
||||
if task == 'all':
|
||||
scheme.script_task()
|
||||
return 0
|
||||
# 与 script_task() 相同的前置步骤
|
||||
scheme.init_game()
|
||||
path_manager.initialize_paths()
|
||||
auto.clear_img_cache()
|
||||
retry_monitor.start()
|
||||
get_reward = None
|
||||
if auto.click_element('battle/turn_assets.png', take_screenshot=True):
|
||||
print('[lc_mcp] 检测到正在战斗, 先打完', flush=True)
|
||||
get_reward = battle.fight()
|
||||
{
|
||||
'daily': scheme.Daily_task_wrapper(get_reward=get_reward),
|
||||
'reward': scheme.to_get_reward,
|
||||
'enkephalin': scheme.Buy_enkephalin,
|
||||
'mirror': scheme.Mirror_task,
|
||||
}[task]()
|
||||
return 0
|
||||
finally:
|
||||
guard.stop()
|
||||
retry_monitor.stop()
|
||||
restore(cfg, originals, restore_path)
|
||||
install_exact_team_match(auto, log)
|
||||
install_robust_set_foreground(screen, log=log)
|
||||
# 日常本(经验/纽本)不翻队伍列表: 队伍是自定义名字时按名字找必然失败,
|
||||
# 白等 60 秒还会把界面滚乱, 后面 to_battle 就找不到 "进入战斗" 了。
|
||||
if task in ('daily', 'all'):
|
||||
install_default_battle_team(scheme, log=log)
|
||||
# 镜牢: 编队是自定义名字(体系名), AALC 只会找 "编队#N"; 改成按体系名点选。
|
||||
if task in ('mirror', 'all'):
|
||||
install_system_team_selection(log=log)
|
||||
guard = WindowGuard(screen, cfg, log=log)
|
||||
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), \
|
||||
mirror_progress(scheme) as progress:
|
||||
try:
|
||||
if task == 'all':
|
||||
with headless_hdr_warning(scheme, log=log):
|
||||
scheme.script_task()
|
||||
return mirror_result(task, progress)
|
||||
# 与 script_task() 相同的前置步骤
|
||||
scheme.init_game()
|
||||
path_manager.initialize_paths()
|
||||
auto.clear_img_cache()
|
||||
retry_monitor.start()
|
||||
get_reward = None
|
||||
if auto.click_element('battle/turn_assets.png', take_screenshot=True):
|
||||
print('[lc_mcp] 检测到正在战斗, 先打完', flush=True)
|
||||
get_reward = battle.fight()
|
||||
{
|
||||
'daily': scheme.Daily_task_wrapper(get_reward=get_reward),
|
||||
'reward': scheme.to_get_reward,
|
||||
'enkephalin': scheme.Buy_enkephalin,
|
||||
'mirror': scheme.Mirror_task,
|
||||
}[task]()
|
||||
return mirror_result(task, progress)
|
||||
finally:
|
||||
guard.stop()
|
||||
retry_monitor.stop()
|
||||
restore(cfg, originals, restore_path)
|
||||
|
||||
|
||||
def main(argv):
|
||||
|
||||
+48
-22
@@ -22,6 +22,7 @@
|
||||
import ctypes
|
||||
import os
|
||||
import time
|
||||
import threading
|
||||
from ctypes import wintypes
|
||||
from functools import lru_cache
|
||||
|
||||
@@ -60,6 +61,14 @@ def foreground_window():
|
||||
return _api('user32', 'GetForegroundWindow', wintypes.HWND, [])()
|
||||
|
||||
|
||||
def window_title(hwnd, limit=64):
|
||||
"""窗口标题, 只用于报错说明; 取不到返回空串。"""
|
||||
buf = ctypes.create_unicode_buffer(limit)
|
||||
_api('user32', 'GetWindowTextW', ctypes.c_int,
|
||||
[wintypes.HWND, wintypes.LPWSTR, ctypes.c_int])(hwnd, buf, limit)
|
||||
return buf.value
|
||||
|
||||
|
||||
def is_console_session():
|
||||
current = wintypes.DWORD()
|
||||
query = _api('kernel32', 'ProcessIdToSessionId', wintypes.BOOL,
|
||||
@@ -106,6 +115,9 @@ class DriverInput:
|
||||
self.log = log
|
||||
self._dll = None
|
||||
self._open = False
|
||||
self._stopped = False
|
||||
self._input_lock = threading.RLock()
|
||||
self._pressed = set()
|
||||
# 目标窗口句柄。有它才能做句柄级前台校验 —— 几何校验在窗口重叠时没用:
|
||||
# 实测把浏览器切到前台, 点游戏里同一个坐标, 只比矩形的话校验照样通过。
|
||||
self.hwnd = 0
|
||||
@@ -139,7 +151,14 @@ class DriverInput:
|
||||
|
||||
@property
|
||||
def ready(self):
|
||||
return self._open and self._dll is not None
|
||||
return self._open and self._dll is not None and not self._stopped
|
||||
|
||||
def emergency_stop(self):
|
||||
"""拒绝后续鼠标输入并释放本实例按住的按钮。急停线程另有退出超时。"""
|
||||
self._stopped = True
|
||||
with self._input_lock:
|
||||
for button in tuple(self._pressed):
|
||||
self.up(button)
|
||||
|
||||
def preflight(self):
|
||||
"""返回 (能否用, 原因)。用之前调一次, 把不能用的原因说清楚。"""
|
||||
@@ -160,12 +179,13 @@ class DriverInput:
|
||||
# ---------------------------------------------------------------- 移动
|
||||
|
||||
def move_relative(self, dx, dy):
|
||||
if not self.ready:
|
||||
return False
|
||||
if dx == 0 and dy == 0:
|
||||
with self._input_lock:
|
||||
if not self.ready:
|
||||
return False
|
||||
if dx == 0 and dy == 0:
|
||||
return True
|
||||
self._dll.moveR(int(dx), int(dy), True)
|
||||
return True
|
||||
self._dll.moveR(int(dx), int(dy), True)
|
||||
return True
|
||||
|
||||
def move_to(self, sx, sy, tol=1, iters=10, settle=0.03):
|
||||
"""把光标精确移到屏幕坐标 (sx, sy)。返回是否到位。"""
|
||||
@@ -185,12 +205,19 @@ class DriverInput:
|
||||
# ---------------------------------------------------------------- 按键
|
||||
|
||||
def down(self, button=1):
|
||||
if self.ready:
|
||||
self._dll.mouse_down(int(button))
|
||||
with self._input_lock:
|
||||
if not self.ready:
|
||||
return False
|
||||
button = int(button)
|
||||
self._pressed.add(button)
|
||||
self._dll.mouse_down(button)
|
||||
return True
|
||||
|
||||
def up(self, button=1):
|
||||
if self.ready:
|
||||
self._dll.mouse_up(int(button))
|
||||
with self._input_lock:
|
||||
if self._open and self._dll is not None:
|
||||
self._dll.mouse_up(int(button))
|
||||
self._pressed.discard(int(button))
|
||||
|
||||
def click(self, sx, sy, times=1, tol=1, require_foreground=True,
|
||||
press_ms=60, settle=0.05):
|
||||
@@ -222,11 +249,12 @@ class DriverInput:
|
||||
time.sleep(settle)
|
||||
for _ in range(int(times)):
|
||||
try:
|
||||
self._dll.mouse_down(1)
|
||||
if not self.down(1):
|
||||
return False
|
||||
time.sleep(press_ms / 1000.0)
|
||||
finally:
|
||||
self._dll.mouse_up(1)
|
||||
return True
|
||||
self.up(1)
|
||||
return not self._stopped
|
||||
|
||||
def key_down(self, key):
|
||||
if self.ready:
|
||||
@@ -254,22 +282,20 @@ def click_point_is_on_foreground(sx, sy, hwnd=None):
|
||||
所以: 给了 hwnd 就要求前台窗口**就是它**(或是它的子窗口); 没给 hwnd 时
|
||||
退化成"有前台窗口且点在它矩形内", 可用性有限, 仅作兜底。
|
||||
"""
|
||||
user32 = ctypes.windll.user32
|
||||
fg = user32.GetForegroundWindow()
|
||||
fg = foreground_window()
|
||||
if not fg:
|
||||
return False, '当前没有前台窗口(GetForegroundWindow=0)'
|
||||
if hwnd:
|
||||
if fg == hwnd or user32.IsChild(hwnd, fg):
|
||||
if fg == hwnd or _api('user32', 'IsChild', wintypes.BOOL,
|
||||
[wintypes.HWND, wintypes.HWND])(hwnd, fg):
|
||||
return True, 'ok'
|
||||
buf = ctypes.create_unicode_buffer(64)
|
||||
user32.GetWindowTextW(fg, buf, 64)
|
||||
other = ctypes.create_unicode_buffer(64)
|
||||
user32.GetWindowTextW(hwnd, other, 64)
|
||||
return False, ('前台不是目标窗口(前台=%r, 目标=%r) —— 这次点击会打到别的窗口'
|
||||
% (buf.value, other.value))
|
||||
% (window_title(fg), window_title(hwnd)))
|
||||
pt = wintypes.POINT(int(sx), int(sy))
|
||||
rect = wintypes.RECT()
|
||||
if not user32.GetWindowRect(fg, ctypes.byref(rect)):
|
||||
get_rect = _api('user32', 'GetWindowRect', wintypes.BOOL,
|
||||
[wintypes.HWND, ctypes.POINTER(wintypes.RECT)])
|
||||
if not get_rect(fg, ctypes.byref(rect)):
|
||||
return False, '取不到前台窗口的区域'
|
||||
if not (rect.left <= pt.x < rect.right and rect.top <= pt.y < rect.bottom):
|
||||
return False, ('点击点(%d,%d)不在前台窗口内(区域 %d,%d-%d,%d)'
|
||||
|
||||
@@ -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)
|
||||
+78
-21
@@ -18,19 +18,25 @@
|
||||
默认 End(小键盘区右下角, 好按且不冲突), 可用环境变量 LCP_KILL_KEY 改成 pause / scrolllock / f11 等。
|
||||
⛔ 不要用 F12: 那是 Steam 的截图键(用户 2026-10-22 指出), 按下去会弹 Steam 截图
|
||||
覆盖层, 而且可能被 Steam 抢先消费。Esc / F11 也不合适 —— 游戏里分别是关菜单
|
||||
和切全屏。Pause 没有任何软件抢, 是最稳的选择。
|
||||
按下后直接 os._exit —— 任务本来就是子进程, 硬退出不留锁或半截状态, 这与
|
||||
aalc_task.py "停止 = 杀进程树" 的设计前提一致。监听器活在任务进程内,
|
||||
所以即使 MCP 服务出问题、用户联系不上调用方, 按热键仍然能停。
|
||||
和切全屏。
|
||||
|
||||
按下后终止任务子进程, 游戏保留。硬退出不会执行任务的 finally; 临时配置由
|
||||
TaskRunner 的恢复文件机制处理。退出前先给驱动释放按住的鼠标键(on_stop),
|
||||
清理或日志卡住时 STOP_TIMEOUT 后仍强制退出。监听器活在任务进程内, 所以即使
|
||||
MCP 服务出问题、用户联系不上调用方, 按热键仍然能停。
|
||||
"""
|
||||
import ctypes
|
||||
import os
|
||||
import threading
|
||||
import time
|
||||
from contextlib import contextmanager
|
||||
from functools import lru_cache
|
||||
|
||||
DEFAULT_KEY = 'end'
|
||||
EXIT_CODE = 130 # 与 SIGINT 一致, 便于上层识别"被用户中止"
|
||||
POLL_INTERVAL = 0.05 # 50ms 轮询, 人手按一下不会漏
|
||||
STOP_TIMEOUT = 0.25 # 释放鼠标/写日志最多等这么久, 然后强退
|
||||
START_DELAY = 0.3 # 先等一会儿, 避免把启动时按住的键当成急停
|
||||
|
||||
# 常用键 -> 虚拟键码。f12 保留是为了兼容旧配置, 但**不推荐** —— Steam 占用它。
|
||||
VK = {
|
||||
@@ -51,18 +57,28 @@ def resolve_vk(key):
|
||||
return VK.get(name)
|
||||
|
||||
|
||||
@lru_cache(maxsize=None)
|
||||
def _key_state_api():
|
||||
"""独立绑定 GetAsyncKeyState, 不改共用的 ctypes.windll 的类型声明。"""
|
||||
fn = ctypes.WinDLL('user32', use_last_error=True).GetAsyncKeyState
|
||||
fn.argtypes = [ctypes.c_int]
|
||||
fn.restype = ctypes.c_short
|
||||
return fn
|
||||
|
||||
|
||||
def _pressed(vk):
|
||||
"""GetAsyncKeyState 的最高位 = 当前是否按下。"""
|
||||
return bool(ctypes.windll.user32.GetAsyncKeyState(vk) & 0x8000)
|
||||
"""GetAsyncKeyState 的最高位 = 当前是否按下(低位只表示"按过", 不算)。"""
|
||||
return bool(_key_state_api()(vk) & 0x8000)
|
||||
|
||||
|
||||
class KillSwitch:
|
||||
"""轮询线程。按住热键会立刻退出, 不会重复触发。"""
|
||||
|
||||
def __init__(self, vk, log=print, key_name=DEFAULT_KEY):
|
||||
def __init__(self, vk, log=print, key_name=DEFAULT_KEY, on_stop=None):
|
||||
self.vk = vk
|
||||
self.log = log
|
||||
self.key_name = key_name
|
||||
self.on_stop = on_stop
|
||||
self.fired = False
|
||||
self._stopped = threading.Event()
|
||||
self._thread = threading.Thread(target=self._run, daemon=True,
|
||||
@@ -79,28 +95,54 @@ class KillSwitch:
|
||||
self._stopped.set()
|
||||
|
||||
def _run(self):
|
||||
# 先等一会儿, 避免把启动时按住的键当成急停
|
||||
time.sleep(0.3)
|
||||
if self._stopped.wait(START_DELAY):
|
||||
return
|
||||
while not self._stopped.is_set():
|
||||
if _pressed(self.vk):
|
||||
try:
|
||||
pressed = _pressed(self.vk)
|
||||
except Exception as e: # 接口失效: 说清楚后退出, 不刷满异常
|
||||
try:
|
||||
self.log('[lc_mcp] 急停热键失效(%s: %s), 请用 stop_task 或 Ctrl+Alt+Del 停止'
|
||||
% (type(e).__name__, e))
|
||||
except Exception:
|
||||
pass
|
||||
return
|
||||
if pressed:
|
||||
self._fire()
|
||||
return
|
||||
time.sleep(POLL_INTERVAL)
|
||||
self._stopped.wait(POLL_INTERVAL)
|
||||
|
||||
def _fire(self):
|
||||
if self.fired:
|
||||
return
|
||||
self.fired = True
|
||||
# 释放驱动按键或写日志卡住时, 由计时器按时强退。
|
||||
timer = threading.Timer(STOP_TIMEOUT, os._exit, args=(EXIT_CODE,))
|
||||
timer.daemon = True
|
||||
try:
|
||||
self.log('[lc_mcp] ⛔ 急停热键 %s 被按下, 立即终止任务'
|
||||
% self.key_name.upper())
|
||||
self.log('[lc_mcp] 游戏窗口会保留, 可用 run_task 重新开始')
|
||||
timer.start()
|
||||
try:
|
||||
if self.on_stop is not None:
|
||||
self.on_stop()
|
||||
except Exception:
|
||||
pass # 释放失败也必须退出
|
||||
try:
|
||||
self.log('[lc_mcp] ⛔ 急停热键 %s 被按下, 终止任务; 游戏窗口保留, 可用 run_task 重新开始'
|
||||
% self.key_name.upper())
|
||||
except Exception:
|
||||
pass # 日志坏了不能拦住急停
|
||||
finally:
|
||||
os._exit(EXIT_CODE)
|
||||
try:
|
||||
os._exit(EXIT_CODE)
|
||||
finally:
|
||||
timer.cancel() # 仅在测试替换 _exit 时才会走到
|
||||
|
||||
|
||||
def install(log=print, key=None):
|
||||
"""启动急停轮询线程。返回 KillSwitch, 失败返回 None(不抛异常)。"""
|
||||
def install(log=print, key=None, on_stop=None):
|
||||
"""启动急停轮询线程。返回 KillSwitch, 失败返回 None(不抛异常)。
|
||||
|
||||
急停装不上不该让任务起不来, 但必须把原因和应急手段说清楚。
|
||||
"""
|
||||
key = key or os.environ.get('LCP_KILL_KEY') or DEFAULT_KEY
|
||||
vk = resolve_vk(key)
|
||||
if vk is None:
|
||||
@@ -108,21 +150,36 @@ def install(log=print, key=None):
|
||||
% (key, ', '.join(sorted(VK))))
|
||||
return None
|
||||
try:
|
||||
switch = KillSwitch(vk, log=log, key_name=key).start()
|
||||
_key_state_api()
|
||||
except Exception as e: # 非 Windows / user32 不可用
|
||||
log('[lc_mcp] 急停热键不可用(读取键盘状态失败: %s: %s), 请用 Ctrl+Alt+Del 强制停止'
|
||||
% (type(e).__name__, e))
|
||||
return None
|
||||
try:
|
||||
switch = KillSwitch(vk, log=log, key_name=key, on_stop=on_stop).start()
|
||||
except Exception as e:
|
||||
log('[lc_mcp] 急停热键启动失败(%s: %s), 请用 Ctrl+Alt+Del 强制停止'
|
||||
% (type(e).__name__, e))
|
||||
return None
|
||||
log('[lc_mcp] 急停热键已就绪: 按 %s 立即停止任务(键盘可用, 不需要鼠标, '
|
||||
'也不依赖 MCP 服务)' % key.upper())
|
||||
log('[lc_mcp] 急停热键已就绪: 按 %s 终止任务, 游戏窗口保留; 可用 run_task 重新开始'
|
||||
'(键盘可用, 不需要鼠标, 也不依赖 MCP 服务)' % key.upper())
|
||||
return switch
|
||||
|
||||
|
||||
def stop(switch):
|
||||
"""停止轮询(任务正常结束时调用)。"""
|
||||
"""停止轮询(任务结束时调用, 免得线程残留)。"""
|
||||
if switch is None:
|
||||
return
|
||||
try:
|
||||
switch.stop()
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
|
||||
@contextmanager
|
||||
def listening(log=print, on_stop=None):
|
||||
switch = install(log=log, on_stop=on_stop)
|
||||
try:
|
||||
yield switch
|
||||
finally:
|
||||
stop(switch)
|
||||
|
||||
+30
-7
@@ -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
|
||||
|
||||
+36
-7
@@ -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, {})
|
||||
|
||||
+3
-1
@@ -12,6 +12,7 @@ import time
|
||||
from collections import deque
|
||||
|
||||
from .aalc_task import RESTORE_ENV
|
||||
from .killswitch import EXIT_CODE as USER_ABORT_EXIT
|
||||
|
||||
REPO = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
||||
IS_WIN = sys.platform.startswith('win')
|
||||
@@ -186,7 +187,8 @@ class TaskRunner:
|
||||
state = 'running'
|
||||
else:
|
||||
self.info.setdefault('ended', time.time())
|
||||
state = 'stopped' if self.info['stopped_by_user'] else 'succeeded' if code == 0 else 'failed'
|
||||
state = ('stopped' if self.info['stopped_by_user'] or code == USER_ABORT_EXIT
|
||||
else 'succeeded' if code == 0 else 'failed')
|
||||
r = {'ok': True, 'state': state, 'task': self.info['task'], 'params': self.info['params'],
|
||||
'elapsed_s': int((self.info.get('ended') or time.time()) - self.info['started']),
|
||||
'log': self.info['log'], 'log_tail': tail(self.info['log'], max(1, min(int(lines), 200)))}
|
||||
|
||||
@@ -42,6 +42,10 @@ DEFAULT_REPORT_DIR = os.path.expanduser(os.path.join('~', 'lc_mcp', 'cycles'))
|
||||
_log_file = None
|
||||
|
||||
|
||||
class UserAborted(RuntimeError):
|
||||
"""用户主动停止, 结束整轮, 不执行后续导航、升级或重试。"""
|
||||
|
||||
|
||||
def log(msg):
|
||||
line = '[%s] %s' % (time.strftime('%H:%M:%S'), msg)
|
||||
print(line, flush=True)
|
||||
@@ -176,6 +180,8 @@ def poll_task(task, timeout_s, sleep=time.sleep):
|
||||
raise RuntimeError('无法读取任务状态: %s' % st.get('error', st))
|
||||
s = st.get('state')
|
||||
el = int(time.time() - t0)
|
||||
if s == 'stopped' or st.get('exit_code') == 130:
|
||||
raise UserAborted('%s 已被用户停止' % task)
|
||||
if s != 'running':
|
||||
log('%s 结束: state=%s elapsed=%ds exit=%s' % (task, s, el, st.get('exit_code')))
|
||||
# AALC 单次战斗失败后仍会 exit 0, succeeded 还要看 errors
|
||||
@@ -332,6 +338,9 @@ def main(argv=None):
|
||||
|
||||
try:
|
||||
return run_cycle(args, step, finish)
|
||||
except UserAborted as e:
|
||||
step('用户停止', False, str(e))
|
||||
return finish(130, '本轮已由用户停止')
|
||||
except (OSError, RuntimeError, subprocess.SubprocessError) as e:
|
||||
if isinstance(e, subprocess.CalledProcessError):
|
||||
output = (e.stdout or '') + (e.stderr or '')
|
||||
|
||||
@@ -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, '桌面不在出图(会话被断开), 本轮跳过')
|
||||
|
||||
@@ -5,14 +5,8 @@
|
||||
# powershell -ExecutionPolicy Bypass -File scripts\install_convert_task.ps1 -EveryHours 6
|
||||
# powershell -ExecutionPolicy Bypass -File scripts\install_convert_task.ps1 -Uninstall
|
||||
#
|
||||
# 节奏怎么定(体力恢复速度):
|
||||
# Limbus 的体力每 6 分钟回 1 点, 上限 126。
|
||||
# 合成 1 个模块要 20 点体力, 所以:
|
||||
# 每 2 小时 -> 约 20 点 -> 1 个模块
|
||||
# 每 4 小时 -> 约 40 点 -> 2 个模块(默认)
|
||||
# 每 6 小时 -> 约 60 点 -> 3 个模块
|
||||
# 只要不顶到 126 上限就不浪费恢复量, 所以更勤快些也不会亏。
|
||||
# 4 小时是"每次都能换到东西"和"别老折腾游戏启动"之间的折中。
|
||||
# 默认每 4 小时检查一次; 是否合成以本轮实际体力读数为准, 不按固定恢复速率推算。
|
||||
# 合成 1 个模块需要 20 点体力。
|
||||
#
|
||||
# 这个任务和 LcMCPDailyCycle 是分开的: 用户明确要求这次不打任何关卡,
|
||||
# 只挂机攒模块, 所以不能把刷取任务一起打开。
|
||||
@@ -42,7 +36,7 @@ if (-not (Test-Path $script)) {
|
||||
throw "找不到脚本: $script"
|
||||
}
|
||||
|
||||
# 以当前用户运行。无人值守要点: 不要勾"只在用户登录时运行", 否则注销后不跑。
|
||||
# 以当前用户的交互会话运行, 必须保持登录; 注销后没有可供截图/点击的游戏桌面。
|
||||
$principal = New-ScheduledTaskPrincipal -UserId "$env:USERDOMAIN\$env:USERNAME" `
|
||||
-LogonType Interactive -RunLevel Limited
|
||||
|
||||
|
||||
@@ -6,7 +6,7 @@
|
||||
# powershell -ExecutionPolicy Bypass -File scripts\install_unattended.ps1
|
||||
# 可选: -At 05:30 每日运行时间。游戏每日重置为 06:00 (KST), 即北京时间 05:00
|
||||
# -EveryHours 2.5 改成"每 N 小时重复一轮"以持续刷取; 0 = 只按 -At 每天一次
|
||||
# 单轮上限 = 60 + 75*Mirror 分钟, 间隔要大于它, 否则会被跳过
|
||||
# 任务时限包含 daily 45 分钟、每局镜牢 100 分钟、各一次重试及 30 分钟收尾
|
||||
# -Mirror 1 每轮镜牢局数, 0 = 不打镜牢
|
||||
# -Target 34 把队内人格升到的等级
|
||||
# -Python <路径> 默认 vendor\aalc\.venv\Scripts\pythonw.exe (无窗口, 不抢游戏焦点)
|
||||
@@ -66,8 +66,9 @@ if (-not $NoWatchdog) {
|
||||
$cycle = Join-Path $PSScriptRoot "auto_cycle.py"
|
||||
$action = New-ScheduledTaskAction -Execute $Python -WorkingDirectory $Repo `
|
||||
-Argument "-X utf8 `"$cycle`" --mirror $Mirror --target $Target"
|
||||
# 一轮 daily 约 22 分钟, 每局镜牢实测 39~>70 分钟; 超过上限由计划任务强杀
|
||||
$limit = New-TimeSpan -Minutes (60 + 75 * [Math]::Max($Mirror, 0))
|
||||
# 与 auto_cycle.py 的 DAILY_TIMEOUT_S / MIRROR_TIMEOUT_S / STALL_RETRIES 对齐。
|
||||
# 每个任务最多两次尝试, 另留 30 分钟给启动、轮询和升级; 避免外层先杀掉报告进程。
|
||||
$limit = New-TimeSpan -Minutes (30 + 2 * (45 + 100 * [Math]::Max($Mirror, 0)))
|
||||
if ($EveryHours -gt 0) {
|
||||
# 持续刷取: 每 N 小时重复一轮。开始时间取"现在", 装完即进入节奏。
|
||||
# 注意 New-TimeSpan -Hours 的参数是 [int], 传 2.5 会被截断成 2 小时, 所以用 -Minutes。
|
||||
|
||||
@@ -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
|
||||
|
||||
+2
-1
@@ -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" 表)。
|
||||
|
||||
@@ -164,6 +164,35 @@ class RunAalcTest(unittest.TestCase):
|
||||
self.assertIn('preflight', info)
|
||||
self.assertEqual(self.tools(mcp), ['run_task'])
|
||||
|
||||
def test_user_stop_never_retries(self):
|
||||
for status in ({'state': 'stopped', 'exit_code': 130},
|
||||
{'state': 'stopped'}, {'state': 'failed', 'exit_code': 130}):
|
||||
mcp = FakeMcp([status], [DONE])
|
||||
with self.subTest(status=status), self.assertRaises(auto_cycle.UserAborted):
|
||||
self.run_aalc(mcp)
|
||||
self.assertEqual(self.tools(mcp), ['run_task'])
|
||||
|
||||
def test_mirror_emergency_stop_ends_cycle_before_upgrade_or_navigation(self):
|
||||
mcp = FakeMcp([DONE], [{'state': 'stopped', 'exit_code': 130}])
|
||||
poll = auto_cycle.poll_task
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
with mock.patch.object(auto_cycle, 'probe', mcp.probe), \
|
||||
mock.patch.object(auto_cycle, 'poll_task',
|
||||
side_effect=lambda t, s, **kw: poll(t, s, sleep=lambda _: None)), \
|
||||
mock.patch.object(auto_cycle, 'lunacy_guard', return_value=(True, 'ok')), \
|
||||
mock.patch.object(auto_cycle, 'ensure_team1', return_value=True), \
|
||||
mock.patch.object(auto_cycle, 'goto_identities') as navigate, \
|
||||
mock.patch.object(auto_cycle, 'run') as upgrade, \
|
||||
mock.patch('builtins.print'):
|
||||
code = auto_cycle.main(['--mirror', '1', '--report-dir', tmp])
|
||||
report = json.loads(next(Path(tmp).glob('cycle_*.json')).read_text(encoding='utf-8'))
|
||||
self.assertEqual(code, 130)
|
||||
self.assertFalse(report['ok'])
|
||||
self.assertIn('用户停止', report['result'])
|
||||
navigate.assert_not_called()
|
||||
upgrade.assert_not_called()
|
||||
self.assertEqual(self.tools(mcp), ['run_task', 'run_task'])
|
||||
|
||||
def test_exit_zero_with_errors_is_failure(self):
|
||||
mcp = FakeMcp([dict(DONE, errors=['[ERROR] 超出最大尝试次数,未能进入战斗'])])
|
||||
ok, info = self.run_aalc(mcp)
|
||||
|
||||
@@ -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()
|
||||
@@ -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))
|
||||
|
||||
+78
-40
@@ -10,6 +10,7 @@
|
||||
关掉后严格 1:1。所以加速没关时不该给出"差不多"的位置。
|
||||
"""
|
||||
import sys
|
||||
import contextlib
|
||||
import os
|
||||
import ast
|
||||
import inspect
|
||||
@@ -301,8 +302,8 @@ class DriverWiringTest(unittest.TestCase):
|
||||
|
||||
def test_actual_task_entry_enables_driver_for_all_and_daily(self):
|
||||
from lc_mcp import aalc_task
|
||||
for task in ('all', 'daily'):
|
||||
with self.subTest(task=task):
|
||||
for task, problems in [('all', []), ('daily', []), ('all', ['invalid config'])]:
|
||||
with self.subTest(task=task, problems=problems):
|
||||
auto, handler_type = vendor_auto()
|
||||
auto.clear_img_cache = mock.Mock()
|
||||
auto.click_element = mock.Mock(return_value=False)
|
||||
@@ -326,17 +327,29 @@ 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'), \
|
||||
mock.patch.object(aalc_task.killswitch, 'install') as install_hotkey, \
|
||||
mock.patch.object(aalc_task, 'log'), \
|
||||
mock.patch.object(aalc_task.preflight, 'collect', return_value={}), \
|
||||
mock.patch.object(aalc_task.preflight, 'desktop_size', return_value=(1920, 1080)), \
|
||||
mock.patch.object(aalc_task.preflight, 'check', return_value=[]), \
|
||||
mock.patch.object(aalc_task.preflight, 'check', return_value=problems), \
|
||||
mock.patch.object(di, 'DriverInput', return_value=drv), \
|
||||
mock.patch.object(ap.DriverClickProxy, '_screen_pos', return_value=(10, 20)):
|
||||
self.assertEqual(aalc_task.run(task, {}), 0)
|
||||
drv.click.assert_called_once_with(10, 20, times=1)
|
||||
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:
|
||||
drv.click.assert_called_once_with(10, 20, times=1)
|
||||
install_hotkey.call_args.kwargs['on_stop']()
|
||||
drv.emergency_stop.assert_called_once()
|
||||
|
||||
def test_disabled_and_simulator_leave_initialization_unchanged(self):
|
||||
for enabled, simulator in [('0', False), ('1', True)]:
|
||||
@@ -350,6 +363,23 @@ class DriverWiringTest(unittest.TestCase):
|
||||
|
||||
|
||||
class DriverFailureTest(unittest.TestCase):
|
||||
def test_emergency_stop_releases_press_and_blocks_subsequent_clicks(self):
|
||||
drv = di.DriverInput()
|
||||
drv._open, drv._dll = True, mock.Mock()
|
||||
with mock.patch.object(drv, 'move_to', return_value=True), \
|
||||
mock.patch.object(di, 'click_point_is_on_foreground', lambda *a, **k: (True, 'ok')), \
|
||||
mock.patch.object(di.time, 'sleep', side_effect=lambda _: drv.emergency_stop()):
|
||||
# settle=0: 第一次 sleep 是按下后的按住时长, 急停发生在按住期间
|
||||
self.assertFalse(drv.click(10, 20, times=3, settle=0))
|
||||
drv._dll.mouse_down.assert_called_once_with(1)
|
||||
drv._dll.mouse_up.assert_called_with(1)
|
||||
self.assertFalse(drv.ready)
|
||||
self.assertFalse(drv.click(30, 40))
|
||||
self.assertFalse(drv.move_relative(20, 30))
|
||||
self.assertFalse(drv.down())
|
||||
drv._dll.moveR.assert_not_called()
|
||||
self.assertEqual(drv._pressed, set())
|
||||
|
||||
def test_release_even_if_sleep_is_interrupted(self):
|
||||
drv = di.DriverInput()
|
||||
drv._open, drv._dll = True, mock.Mock()
|
||||
@@ -437,8 +467,18 @@ class ForegroundFallbackTest(unittest.TestCase):
|
||||
[mock.call(33, 11, True), mock.call(33, 11, False)])
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
|
||||
def win_api(**functions):
|
||||
"""按 API 名替换 driver_input._api 返回的函数。"""
|
||||
return mock.patch.object(di, '_api', side_effect=lambda library, name, result, args: functions[name])
|
||||
|
||||
|
||||
def window_rect(left, top, right, bottom):
|
||||
def get_window_rect(hwnd, ptr):
|
||||
r = ptr._obj
|
||||
r.left, r.top, r.right, r.bottom = left, top, right, bottom
|
||||
return 1
|
||||
return get_window_rect
|
||||
|
||||
|
||||
class ForegroundCheckTest(unittest.TestCase):
|
||||
@@ -455,37 +495,21 @@ class ForegroundCheckTest(unittest.TestCase):
|
||||
return d
|
||||
|
||||
def test_rejects_when_no_foreground_window(self):
|
||||
with mock.patch.object(di.ctypes.windll.user32, 'GetForegroundWindow',
|
||||
return_value=0):
|
||||
with mock.patch.object(di, 'foreground_window', return_value=None):
|
||||
ok, why = di.click_point_is_on_foreground(100, 100)
|
||||
self.assertFalse(ok)
|
||||
self.assertIn('前台窗口', why)
|
||||
|
||||
def test_rejects_when_point_outside_foreground_window(self):
|
||||
def fake_get_window_rect(hwnd, ptr):
|
||||
r = ptr._obj
|
||||
r.left, r.top, r.right, r.bottom = 0, 0, 50, 50
|
||||
return 1
|
||||
|
||||
with mock.patch.object(di.ctypes.windll.user32, 'GetForegroundWindow',
|
||||
return_value=12345), \
|
||||
mock.patch.object(di.ctypes.windll.user32, 'GetWindowRect',
|
||||
fake_get_window_rect), \
|
||||
mock.patch.object(di.ctypes.windll.user32, 'GetWindowTextW'):
|
||||
with mock.patch.object(di, 'foreground_window', return_value=12345), \
|
||||
win_api(GetWindowRect=window_rect(0, 0, 50, 50)):
|
||||
ok, why = di.click_point_is_on_foreground(999, 999)
|
||||
self.assertFalse(ok)
|
||||
self.assertIn('不在前台窗口内', why)
|
||||
|
||||
def test_accepts_when_point_inside_foreground_window(self):
|
||||
def fake_get_window_rect(hwnd, ptr):
|
||||
r = ptr._obj
|
||||
r.left, r.top, r.right, r.bottom = 0, 0, 1920, 1080
|
||||
return 1
|
||||
|
||||
with mock.patch.object(di.ctypes.windll.user32, 'GetForegroundWindow',
|
||||
return_value=12345), \
|
||||
mock.patch.object(di.ctypes.windll.user32, 'GetWindowRect',
|
||||
fake_get_window_rect):
|
||||
with mock.patch.object(di, 'foreground_window', return_value=12345), \
|
||||
win_api(GetWindowRect=window_rect(0, 0, 1920, 1080)):
|
||||
ok, why = di.click_point_is_on_foreground(500, 500)
|
||||
self.assertTrue(ok)
|
||||
self.assertEqual(why, 'ok')
|
||||
@@ -553,30 +577,29 @@ class HwndForegroundCheckTest(unittest.TestCase):
|
||||
"""
|
||||
|
||||
def test_accepts_when_foreground_is_the_target(self):
|
||||
with mock.patch.object(di.ctypes.windll.user32, 'GetForegroundWindow',
|
||||
return_value=999):
|
||||
with mock.patch.object(di, 'foreground_window', return_value=999):
|
||||
ok, why = di.click_point_is_on_foreground(100, 100, 999)
|
||||
self.assertTrue(ok)
|
||||
self.assertEqual(why, 'ok')
|
||||
|
||||
def test_accepts_child_window_of_target(self):
|
||||
"""游戏可能有子窗口拿到焦点, 也算在目标窗口上。"""
|
||||
with mock.patch.object(di.ctypes.windll.user32, 'GetForegroundWindow',
|
||||
return_value=1000), \
|
||||
mock.patch.object(di.ctypes.windll.user32, 'IsChild',
|
||||
return_value=True):
|
||||
is_child = mock.Mock(return_value=True)
|
||||
with mock.patch.object(di, 'foreground_window', return_value=1000), \
|
||||
win_api(IsChild=is_child):
|
||||
ok, _ = di.click_point_is_on_foreground(100, 100, 999)
|
||||
is_child.assert_called_once_with(999, 1000)
|
||||
self.assertTrue(ok)
|
||||
|
||||
def test_rejects_when_foreground_is_another_window(self):
|
||||
with mock.patch.object(di.ctypes.windll.user32, 'GetForegroundWindow',
|
||||
return_value=1000), \
|
||||
mock.patch.object(di.ctypes.windll.user32, 'IsChild',
|
||||
return_value=False), \
|
||||
mock.patch.object(di.ctypes.windll.user32, 'GetWindowTextW'):
|
||||
titles = {1000: 'Browser', 999: 'LimbusCompany'}
|
||||
with mock.patch.object(di, 'foreground_window', return_value=1000), \
|
||||
win_api(IsChild=mock.Mock(return_value=False)), \
|
||||
mock.patch.object(di, 'window_title', side_effect=titles.get):
|
||||
ok, why = di.click_point_is_on_foreground(100, 100, 999)
|
||||
self.assertFalse(ok)
|
||||
self.assertIn('前台不是目标窗口', why)
|
||||
self.assertIn('Browser', why)
|
||||
|
||||
def test_bind_window_is_used_by_click(self):
|
||||
"""绑定窗口后, click() 必须走句柄级校验。"""
|
||||
@@ -596,4 +619,19 @@ class HwndForegroundCheckTest(unittest.TestCase):
|
||||
mock.patch.object(di.time, 'sleep', lambda s: None):
|
||||
self.assertFalse(d.click(10, 10))
|
||||
self.assertEqual(seen['hwnd'], 4242, 'click 没把绑定的句柄传下去')
|
||||
d._dll.mouse_down.assert_not_called()
|
||||
d._dll.mouse_down.assert_not_called()
|
||||
|
||||
def test_proxy_rebinds_current_window_before_each_click(self):
|
||||
"""游戏重启后句柄会变; 代理复用时若仍拿安装时的旧句柄, 前台校验会拒绝所有点击。"""
|
||||
drv = di.DriverInput(dll_path='X.dll', log=lambda m: None).bind_window(111)
|
||||
handle = SimpleNamespace(hwnd=222, isMinimized=False, setForeground=mock.Mock())
|
||||
proxy = ap.DriverClickProxy(mock.Mock(), drv, SimpleNamespace(handle=handle), log=lambda _: None)
|
||||
with mock.patch.object(di, 'is_console_session', return_value=True), \
|
||||
mock.patch.object(di, 'foreground_window', return_value=222), \
|
||||
mock.patch.object(di, 'client_to_screen', return_value=(5, 6)):
|
||||
self.assertEqual(proxy._screen_pos(1, 2), (5, 6))
|
||||
self.assertEqual(drv.hwnd, 222)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
|
||||
@@ -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()
|
||||
+145
-32
@@ -9,9 +9,12 @@
|
||||
|
||||
实现上踩过一个坑: 先用了 pynput 的 GlobalHotKeys, 静态注册成功、线程也活着, 但
|
||||
keybd_event 和 SendInput 两种注入都触发不了它 —— 钩子在当前会话下收不到键。
|
||||
改成 GetAsyncKeyState 轮询后实测可用。这里的测试守住轮询方案的几个关键性质。
|
||||
改成 GetAsyncKeyState 轮询后实测可用。这里的测试守住轮询方案的几个关键性质,
|
||||
以及急停时"先放开鼠标、卡住也按时退出"的保证。
|
||||
"""
|
||||
import sys
|
||||
import tempfile
|
||||
import threading
|
||||
import unittest
|
||||
from pathlib import Path
|
||||
from unittest import mock
|
||||
@@ -19,10 +22,16 @@ from unittest import mock
|
||||
sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
|
||||
from lc_mcp import killswitch # noqa: E402
|
||||
|
||||
PRESSED = -32768 # SHORT 0x8000: GetAsyncKeyState 的"当前按下"位
|
||||
|
||||
|
||||
def key_state(value):
|
||||
return mock.patch.object(killswitch, '_key_state_api', return_value=lambda vk: value)
|
||||
|
||||
|
||||
class ResolveVkTest(unittest.TestCase):
|
||||
"""键名解析必须严格: 认不出来要返回 None, 不能悄悄用默认值 ——
|
||||
否则用户以为设成了 F11, 实际还在监听 F12。"""
|
||||
否则用户以为设成了 F11, 实际还在监听别的键。"""
|
||||
|
||||
def test_common_keys(self):
|
||||
self.assertEqual(killswitch.resolve_vk('f12'), 0x7B)
|
||||
@@ -30,6 +39,10 @@ class ResolveVkTest(unittest.TestCase):
|
||||
self.assertEqual(killswitch.resolve_vk('esc'), 0x1B)
|
||||
self.assertEqual(killswitch.resolve_vk('pause'), 0x13)
|
||||
|
||||
def test_default_is_end_not_steam_screenshot_key(self):
|
||||
self.assertEqual(killswitch.DEFAULT_KEY, 'end')
|
||||
self.assertEqual(killswitch.resolve_vk(None), 0x23)
|
||||
|
||||
def test_accepts_angle_brackets(self):
|
||||
self.assertEqual(killswitch.resolve_vk('<f12>'), 0x7B)
|
||||
|
||||
@@ -37,14 +50,15 @@ class ResolveVkTest(unittest.TestCase):
|
||||
self.assertEqual(killswitch.resolve_vk(' F12 '), 0x7B)
|
||||
|
||||
def test_empty_uses_default(self):
|
||||
self.assertEqual(killswitch.resolve_vk(''), killswitch.VK[killswitch.DEFAULT_KEY])
|
||||
self.assertEqual(killswitch.resolve_vk(None), killswitch.VK[killswitch.DEFAULT_KEY])
|
||||
for key in ('', None, ' '):
|
||||
self.assertEqual(killswitch.resolve_vk(key), killswitch.VK[killswitch.DEFAULT_KEY])
|
||||
|
||||
def test_unknown_returns_none(self):
|
||||
self.assertIsNone(killswitch.resolve_vk('nosuchkey'))
|
||||
|
||||
|
||||
class InstallTest(unittest.TestCase):
|
||||
"""装不上不能把任务带崩,但必须说清楚怎么应急。"""
|
||||
|
||||
def test_reports_unknown_key_and_suggests_fallback(self):
|
||||
lines = []
|
||||
@@ -54,24 +68,35 @@ class InstallTest(unittest.TestCase):
|
||||
self.assertIn('认不出键名', joined)
|
||||
self.assertIn('Ctrl+Alt+Del', joined, '必须给出应急手段')
|
||||
|
||||
def test_reports_when_keyboard_api_is_unavailable(self):
|
||||
lines = []
|
||||
with mock.patch.object(killswitch, '_key_state_api', side_effect=AttributeError('no user32')):
|
||||
got = killswitch.install(log=lines.append)
|
||||
self.assertIsNone(got)
|
||||
joined = '\n'.join(lines)
|
||||
self.assertIn('急停热键不可用', joined)
|
||||
self.assertIn('Ctrl+Alt+Del', joined)
|
||||
|
||||
def test_installs_and_logs_the_key(self):
|
||||
lines = []
|
||||
with mock.patch.object(killswitch.KillSwitch, 'start', lambda self: self):
|
||||
with key_state(0), mock.patch.object(killswitch.KillSwitch, 'start', lambda self: self):
|
||||
switch = killswitch.install(log=lines.append, key='f11')
|
||||
self.assertIsInstance(switch, killswitch.KillSwitch)
|
||||
self.assertEqual(switch.vk, 0x7A)
|
||||
self.assertIn('F11', '\n'.join(lines))
|
||||
joined = '\n'.join(lines)
|
||||
self.assertIn('F11', joined)
|
||||
self.assertIn('游戏窗口保留', joined)
|
||||
|
||||
def test_env_var_overrides_default(self):
|
||||
with mock.patch.dict(killswitch.os.environ, {'LCP_KILL_KEY': 'esc'}), \
|
||||
with mock.patch.dict(killswitch.os.environ, {'LCP_KILL_KEY': 'esc'}), key_state(0), \
|
||||
mock.patch.object(killswitch.KillSwitch, 'start', lambda self: self):
|
||||
switch = killswitch.install(log=lambda m: None)
|
||||
self.assertEqual(switch.vk, 0x1B)
|
||||
|
||||
def test_start_failure_is_reported_not_raised(self):
|
||||
lines = []
|
||||
with mock.patch.object(killswitch.KillSwitch, 'start',
|
||||
side_effect=RuntimeError('boom')):
|
||||
with key_state(0), mock.patch.object(killswitch.KillSwitch, 'start',
|
||||
side_effect=RuntimeError('boom')):
|
||||
got = killswitch.install(log=lines.append)
|
||||
self.assertIsNone(got)
|
||||
self.assertIn('启动失败', '\n'.join(lines))
|
||||
@@ -81,60 +106,148 @@ class PollingTest(unittest.TestCase):
|
||||
"""轮询判断的核心:0x8000 位。测错位会导致"一直触发"或"永不触发"。"""
|
||||
|
||||
def test_high_bit_means_pressed(self):
|
||||
with mock.patch.object(killswitch.ctypes.windll.user32, 'GetAsyncKeyState',
|
||||
return_value=0x8000):
|
||||
self.assertTrue(killswitch._pressed(0x7B))
|
||||
for value in (PRESSED, PRESSED | 1):
|
||||
with self.subTest(value=value), key_state(value):
|
||||
self.assertTrue(killswitch._pressed(0x7B))
|
||||
|
||||
def test_low_bits_are_not_pressed(self):
|
||||
# 0x0001 表示"上次调用后被按过", 不代表当前按住 —— 不能当成按下
|
||||
with mock.patch.object(killswitch.ctypes.windll.user32, 'GetAsyncKeyState',
|
||||
return_value=0x0001):
|
||||
with key_state(0x0001):
|
||||
self.assertFalse(killswitch._pressed(0x7B))
|
||||
|
||||
def test_zero_is_not_pressed(self):
|
||||
with mock.patch.object(killswitch.ctypes.windll.user32, 'GetAsyncKeyState',
|
||||
return_value=0):
|
||||
with key_state(0):
|
||||
self.assertFalse(killswitch._pressed(0x7B))
|
||||
|
||||
def test_poll_thread_fires_on_press(self):
|
||||
sw = killswitch.KillSwitch(0x23, log=lambda m: None)
|
||||
exited = threading.Event()
|
||||
with key_state(PRESSED), mock.patch.object(killswitch, 'START_DELAY', 0), \
|
||||
mock.patch.object(killswitch.os, '_exit', side_effect=lambda code: exited.set()):
|
||||
sw.start()
|
||||
self.assertTrue(exited.wait(2))
|
||||
sw._thread.join(2)
|
||||
self.assertTrue(sw.fired)
|
||||
|
||||
def test_broken_api_stops_polling_with_a_message(self):
|
||||
lines = []
|
||||
sw = killswitch.KillSwitch(0x23, log=lines.append)
|
||||
with mock.patch.object(killswitch, '_key_state_api', side_effect=OSError('gone')), \
|
||||
mock.patch.object(killswitch, 'START_DELAY', 0), \
|
||||
mock.patch.object(killswitch.os, '_exit') as fake_exit:
|
||||
sw.start()
|
||||
sw._thread.join(2)
|
||||
self.assertFalse(sw.is_alive())
|
||||
fake_exit.assert_not_called()
|
||||
self.assertIn('急停热键失效', '\n'.join(lines))
|
||||
|
||||
|
||||
class FireTest(unittest.TestCase):
|
||||
|
||||
def _switch(self):
|
||||
return killswitch.KillSwitch(0x7B, log=lambda m: None, key_name='f12')
|
||||
def _switch(self, log=lambda m: None, on_stop=None):
|
||||
return killswitch.KillSwitch(0x23, log=log, key_name='end', on_stop=on_stop)
|
||||
|
||||
def test_exits_with_user_abort_code(self):
|
||||
def test_exits_with_user_abort_code_and_only_fires_once(self):
|
||||
sw = self._switch()
|
||||
with mock.patch.object(killswitch.os, '_exit') as fake_exit:
|
||||
sw._fire()
|
||||
sw._fire()
|
||||
sw._fire()
|
||||
fake_exit.assert_called_once_with(killswitch.EXIT_CODE)
|
||||
|
||||
def test_only_fires_once(self):
|
||||
sw = self._switch()
|
||||
with mock.patch.object(killswitch.os, '_exit') as fake_exit:
|
||||
sw._fire()
|
||||
sw._fire()
|
||||
sw._fire()
|
||||
self.assertEqual(fake_exit.call_count, 1, '重复触发不该重复退出')
|
||||
|
||||
def test_logs_that_game_is_kept(self):
|
||||
lines = []
|
||||
sw = killswitch.KillSwitch(0x7B, log=lines.append, key_name='f12')
|
||||
with mock.patch.object(killswitch.os, '_exit'):
|
||||
sw._fire()
|
||||
self._switch(log=lines.append)._fire()
|
||||
joined = '\n'.join(lines)
|
||||
self.assertIn('F12', joined)
|
||||
self.assertIn('END', joined)
|
||||
self.assertIn('重新开始', joined)
|
||||
|
||||
def test_releases_input_before_logging_and_exiting(self):
|
||||
calls = []
|
||||
sw = self._switch(log=lambda m: calls.append('log'), on_stop=lambda: calls.append('release'))
|
||||
with mock.patch.object(killswitch.os, '_exit', side_effect=lambda code: calls.append(code)):
|
||||
sw._fire()
|
||||
self.assertEqual(calls, ['release', 'log', 130])
|
||||
|
||||
def test_broken_cleanup_or_log_cannot_disable_the_hotkey(self):
|
||||
def cleanup():
|
||||
raise OSError('driver disconnected')
|
||||
log = mock.Mock(side_effect=OSError('closed log'))
|
||||
with mock.patch.object(killswitch.os, '_exit') as fake_exit:
|
||||
self._switch(log=log, on_stop=cleanup)._fire()
|
||||
fake_exit.assert_called_once_with(130)
|
||||
|
||||
def test_hung_cleanup_cannot_block_exit_deadline(self):
|
||||
release, exited = threading.Event(), threading.Event()
|
||||
sw = self._switch(on_stop=release.wait)
|
||||
with mock.patch.object(killswitch.os, '_exit', side_effect=lambda code: exited.set()):
|
||||
worker = threading.Thread(target=sw._fire, daemon=True)
|
||||
worker.start()
|
||||
try:
|
||||
self.assertTrue(exited.wait(2), '清理卡住也必须触发强退')
|
||||
finally:
|
||||
release.set()
|
||||
worker.join(2)
|
||||
|
||||
def test_real_emergency_exit_is_reported_as_stopped(self):
|
||||
from lc_mcp.tasks import TaskRunner
|
||||
child = """
|
||||
import json, os, time
|
||||
from lc_mcp import killswitch
|
||||
from lc_mcp.aalc_task import RESTORE_ENV
|
||||
with open(os.environ[RESTORE_ENV], 'w') as f: json.dump({'set_mirror_count': 1}, f)
|
||||
killswitch._key_state_api = lambda: (lambda vk: -32768)
|
||||
killswitch.install(log=lambda msg: None)
|
||||
time.sleep(10)
|
||||
"""
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
runner = TaskRunner(tmp, argv_factory=lambda t, p: [sys.executable, '-c', child])
|
||||
self.assertTrue(runner.start('mirror', {'count': 2})['ok'])
|
||||
self.addCleanup(runner.proc.kill)
|
||||
runner.proc.wait(timeout=5)
|
||||
status = runner.status()
|
||||
self.assertEqual((status['state'], status['exit_code']), ('stopped', 130))
|
||||
self.assertTrue(status['pending_restore'], '强退保留配置恢复文件, 下次启动前由服务处理')
|
||||
|
||||
|
||||
class StopTest(unittest.TestCase):
|
||||
|
||||
def test_stop_is_safe_on_none(self):
|
||||
killswitch.stop(None)
|
||||
killswitch.stop(None) # 不该抛
|
||||
|
||||
def test_stop_calls_switch(self):
|
||||
sw = mock.Mock()
|
||||
killswitch.stop(sw)
|
||||
sw.stop.assert_called_once()
|
||||
|
||||
def test_stop_swallows_errors(self):
|
||||
sw = mock.Mock()
|
||||
sw.stop.side_effect = RuntimeError('boom')
|
||||
killswitch.stop(sw)
|
||||
killswitch.stop(sw) # 不该抛
|
||||
|
||||
def test_stopped_switch_does_not_poll(self):
|
||||
sw = killswitch.KillSwitch(0x23, log=lambda m: None)
|
||||
with key_state(PRESSED), mock.patch.object(killswitch.os, '_exit') as fake_exit:
|
||||
sw.stop()
|
||||
sw.start()
|
||||
sw._thread.join(2)
|
||||
fake_exit.assert_not_called()
|
||||
|
||||
def test_listening_passes_cleanup_and_stops_on_return_and_exception(self):
|
||||
cleanup = object()
|
||||
for failure in (False, True):
|
||||
switch = mock.Mock()
|
||||
with self.subTest(failure=failure), \
|
||||
mock.patch.object(killswitch, 'install', return_value=switch) as install:
|
||||
try:
|
||||
with killswitch.listening(on_stop=cleanup):
|
||||
if failure:
|
||||
raise RuntimeError('task failed')
|
||||
except RuntimeError:
|
||||
pass
|
||||
self.assertIs(install.call_args.kwargs['on_stop'], cleanup)
|
||||
switch.stop.assert_called_once()
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
||||
+21
-7
@@ -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; 强杀后必须写回原值。"""
|
||||
|
||||
@@ -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(), 记录点击。"""
|
||||
|
||||
|
||||
@@ -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):
|
||||
|
||||
|
||||
Reference in New Issue
Block a user