Comparing changes
Choose two branches or tags to see what’s changed or to start a new pull request.
21
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
dc5bcadd16 | ||
|
|
bda1ffb390 | ||
|
|
a04b443b6a | ||
|
|
348de32807 | ||
|
|
96a31bc1ae | ||
|
|
599282729c | ||
|
|
908713b922 | ||
|
|
d15f5a1bb2 | ||
|
|
40a5af0184 | ||
|
|
72d2ca1a5b | ||
|
|
51525722cd | ||
|
|
4376d9cfb2 | ||
|
|
2f8f15a886 | ||
|
|
e08edda27d | ||
|
|
4c0038d657 | ||
|
|
baa362808c | ||
|
|
5fdb9fd221 | ||
|
|
1aa823ea2e | ||
|
|
c4a42bcfaf | ||
|
|
58cd78cd9c | ||
|
|
13c038a175 |
@@ -98,7 +98,8 @@ $env:LCP_DRIVER_TRACE = "$env:USERPROFILE\lc_mcp\driver-input.log"
|
||||
模拟器不接管;拖拽、滚动、键盘以及 MCP 的独立 `click` 工具仍使用原后端。
|
||||
当前回归验证覆盖软件接线和异常处理,DLL、实际驱动及游戏响应需在 Windows 实机核验。
|
||||
|
||||
任务运行期间按 **F12** 急停,可用 `LCP_KILL_KEY` 改成 `f11`、`pause` 等键名。
|
||||
任务运行期间按 **End** 急停,可用 `LCP_KILL_KEY` 改成 `pause`、`scrolllock` 等键名。
|
||||
不要用 F12(Steam 截图键);监听用 `GetAsyncKeyState` 轮询,因为 pynput 钩子在该机器的会话里收不到按键。
|
||||
急停会终止任务子进程,保留游戏窗口;`task_status` 返回 `stopped`、退出码 `130`。
|
||||
刷取循环检测到用户停止后结束本轮,不再导航、升级或重试。急停前会尝试释放驱动
|
||||
按住的鼠标按钮,清理超过 250 毫秒仍强制退出;硬退出留下的临时配置恢复文件由
|
||||
@@ -108,6 +109,13 @@ $env:LCP_DRIVER_TRACE = "$env:USERPROFILE\lc_mcp\driver-input.log"
|
||||
|
||||
## 工具
|
||||
|
||||
MCP 初始化说明与工具描述均指导 AI 优先使用 AALC:常规日常、领奖、普通镜牢按
|
||||
`task_status` → `run_task` → 轮询 `task_status` 执行。只刷经验本时显式传 `thread: 0`,
|
||||
只刷纽本时传 `exp: 0`,避免沿用另一项配置。主线、特殊速通路线或故障恢复使用逐步输入。
|
||||
只看状态或截图不会启动任务;`all` 只用于明确要求全部任务,`enkephalin` 需要明确授权花狂气。
|
||||
启动成功不等于完成,最终还要检查 `errors` 和 `pending_restore`,用户停止后不自动重跑。
|
||||
更新后重启常驻服务并重连 MCP,客户端才能获取新的初始化说明和工具描述。
|
||||
|
||||
| 工具 | 说明 |
|
||||
|------|------|
|
||||
| `get_state` | 截图 + OCR,返回窗口内全部文字 `{text,x,y,w,h,score}` |
|
||||
@@ -135,16 +143,73 @@ $env:LCP_DRIVER_TRACE = "$env:USERPROFILE\lc_mcp\driver-input.log"
|
||||
任务运行中如果 `task_status` 带 `stall` 字段,说明 AALC 在原地空转(例如选中了空队伍,
|
||||
编队人数检查一直刷屏)。它不会自己报错退出,应当 `stop_task` 后重跑。
|
||||
|
||||
镜牢任务的局内决策逐条写进与日志同名的 `~/lc_mcp/runs/task_*.decisions.jsonl`(每行一个 JSON:
|
||||
`time`/`stage`/`choice`/`reason` 加细节)。`task_status` 的 `decisions.counts` 按阶段统计 `reason`:
|
||||
|
||||
| `stage` | `reason` |
|
||||
|---|---|
|
||||
| `team` | `current` 已是目标队 / `exact` / `prefix` 后缀队名 / `header_unchanged` / `not_found` |
|
||||
| `road` | `lowest` 下一列最优 / `next_best` 更优方向进不去 / `fallback` 退回按 ↑ / `keyboard_off` 连续几个节点按键都没进去,本次任务改走 AALC 常规寻路 |
|
||||
| `theme_pack` | `preferred` 达到优选阈值 / `highest_weight` 刷新后取最高权重 / `event_pack` 最左活动卡包;选中的卡包按体系加过分时带 `system_bonus`(`packs`/`system`/`from`/`to`) |
|
||||
| `gift` | `keyword` 命中体系关键词 / `no_keyword`(记的是交给 AALC 的第一顺位,白棉花、已持有仍由 AALC 处理) |
|
||||
| `event` | `text` 按表选 / `deferred` 认出了表里的事件但交给 AALC / `not_in_table`(带 `options`,可直接拿来补表) |
|
||||
| `battle` | `hollow`:兔子洞模式每回合的结果,`overclock` 超频放上了「空洞」/ `ego` 单击放上了 / `ego_unavailable` 列表还开着(多半资源不够)/ `no_option` 没弹出列表或没认出 |
|
||||
| `gift_confirm` | `repeated` 「获得E.G.O饰品」确认连点不关,改点按钮中心 / `stuck` 还是不关,结束任务 |
|
||||
| `shop` | `name_match` 按中文名找到必买饰品(`choice` 是名字)/ `purchase_clicked` 点到了购买按钮(`choice` 是之前点的商品:`shop_by_name` 按名字、必买模板名、`level_IV_to_buy`、`by_position` 本体系饰品) |
|
||||
|
||||
### 任务进程里的保护
|
||||
|
||||
`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),
|
||||
原值和次数一起写入恢复文件,结束或被强杀后都会写回。
|
||||
- **商店按中文名购买**:必买项先整屏 OCR 商品格下面的饰品名,对上 `lc_mcp/data/shop_gifts.json`(零协汉化名字,
|
||||
靠前的先买)就点那一格,购买/确认仍走 AALC 原循环;AALC 的 5 张图标模板在后面兜底。`LCP_SHOP_NAMES=0` 关闭。
|
||||
(必买/必卖/公式合成清单为空的问题,上游 V1.6.1 已修,本地补丁已删。)
|
||||
- **镜牢按体系名选队**:按 `team_system` 在编队列表里点同名队伍(流血/斩击/…),点完核对顶栏队名。
|
||||
名字先归一(去空白、全角转半角、纠正 `震颐`/`沉论`/`编#` 等误读);精确匹配优先,
|
||||
否则接受这一屏唯一的"名字+后缀"(`流血队`、`流血(X)`),多条就不点。没找到时日志列出每屏看到的名字。
|
||||
AALC 入场时常常直接点「进入」、不走选队,所以点「进入」前也会核对顶栏,不是目标队就先切;
|
||||
切不过去记 `[ERROR]`,这一局按游戏当前编队进入,不再反复翻列表。「星之恩惠」页满屏星星会被认成选队页,
|
||||
出现「恩惠」字样时忽略选队星级模板。
|
||||
- **键盘寻路按节点类型**:开着简单键盘寻路时不再只按 ↑。先识别巴士右侧下一列的节点类型,
|
||||
按上游权重(事件 < 商店 < 战斗 < …)依次按方向键,进不去再退回 ↑;不拖地图。
|
||||
连续 3 个节点按键都没进去,本次任务就不再按键,直接交给 AALC 常规寻路。`LCP_TYPED_ROAD=0` 关闭。
|
||||
- **按键带扫描码、按住再松**:AALC 前台模式用 `pyautogui.press` 按键,扫描码是 0、方向键不带扩展键标志、
|
||||
按下抬起紧挨着;上游注释写明 Unity 6 会校验扫描码和扩展键标志。前台改发带扫描码的 `keybd_event`
|
||||
(游戏窗口不在前台时先激活,激活不了就不发),后台两种模式仍用上游的按键消息;各模式都按住 0.12 秒再松开。
|
||||
MCP 的 `key` 工具前台模式同样处理。`LCP_KEY_HOLD=0` 关闭任务进程里的这项。
|
||||
- **「获得E.G.O饰品」弹窗兜底**:AALC 点的是确认按钮左边的勾号,点了不关时会一直点下去(它的循环计数被
|
||||
`continue` 跳过)。连续第 3 次命中起改点按钮中心;连续 20 次还在就记 `[ERROR]`、按未完成结束任务(退出码 4)。
|
||||
- **饰品选择按体系关键词**:镜牢路上的饰品 N 选一,先整屏 OCR,按卡面上命中当前体系关键词的行数给卡排序,
|
||||
再交给 AALC 原逻辑(跳过白棉花、已持有排后)。三张卡时命中关键词的卡按"认出体系图标"交给 AALC,
|
||||
并抵消它把这类卡逐张插到最前造成的倒序。关键词表在 `lc_mcp/data/gift_keywords.json`。
|
||||
- **事件选项表**:事件出现选项时整屏 OCR,按同一屏其它选项的原文(零协汉化)认出 `lc_mcp/data/event_choices.json`
|
||||
里的事件,就点表里那一项;不靠事件名(汉化数据没有标题)。没收录的事件照旧交给 AALC,
|
||||
日志会打印这一屏的选项文字,便于补表。表里的选择优先于 AALC 的"有 ??? 先点 ???",小指良单通模式也一样。
|
||||
- **卡包按体系加分**:选卡包时把 `lc_mcp/data/theme_pack_systems.json` 里「卡包对当局体系的加分」临时加到 AALC 的
|
||||
权重表上(不改 `theme_pack_list.yaml`):体系包(掉落以该体系饰品为主,如电闪雷鸣/动力渐盈 = 充能)、该体系专属饰品
|
||||
≥3 件、或中文社区攻略推荐这个体系走的卡包 +6,专属 2 件 +4,1 件 +1;速刷攻略说拖时间的(被遗忘者们、自动工厂、
|
||||
当碎之物)所有体系 -3。AALC 原来的 -5 也能被压过,比如充能队会选 WARP快车谋杀案;嫌激进就调小表里的 `bonus`。
|
||||
卡包数据来自 wiki.gg(`scripts/build_theme_pack_systems.py` 生成,换赛季重跑),社区推荐见
|
||||
`docs/feedback/2026-11-15/theme-pack-research.md`。`LCP_THEME_PACK_SYSTEMS=0` 关闭。
|
||||
- **兔子洞速刷**(`run_task` 加 `strategy="rabbit_hole"`):按 `lc_mcp/data/rabbit_hole.json` 的编队名选队;
|
||||
每回合按 P → 长按浮士德打开 E.G.O 列表 → OCR 找「空洞」,每场第一回合长按卡片超频、其余回合单击 → Enter;
|
||||
攻略路线上的卡包(赌徒 → 地狱鸡 → 去·海·边 → 憎恶与绝望 → 2号线)加分。长按点 `press_at` 要在实机上量,没量时不点任何东西、
|
||||
记 `[ERROR]`、照常 P+Enter。说明与校准步骤见 `docs/feedback/2026-11-15/RABBIT-HOLE.md`。
|
||||
- **挂不上就报错**:事件表、饰品排序、商店按名字、前台按键、卡包加分、兔子洞这几个补丁靠拦截 AALC 的某个调用挂进去,安装时先查上游源码;
|
||||
上游改了写法时记 `[ERROR]` 并跳过该补丁,不会悄悄失效。
|
||||
|
||||
## 无人值守
|
||||
|
||||
@@ -174,11 +239,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` 时,同步失败会返回非零退出码。
|
||||
|
||||
## 环境变量
|
||||
|
||||
@@ -188,7 +258,13 @@ 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` | `f12` | 任务子进程的急停键,如 `f11` / `pause` |
|
||||
| `LCP_TYPED_ROAD` | 未设置 | 设为 `0` 时镜牢简单键盘寻路保持上游的"只按 ↑",不按节点类型选方向 |
|
||||
| `LCP_EVENT_CHOICES` | 未设置 | 设为 `0` 时事件不查选项表;设为 JSON 文件路径时用它代替 `lc_mcp/data/event_choices.json` |
|
||||
| `LCP_GIFT_KEYWORDS` | 未设置 | 设为 `0` 时饰品选择不按体系关键词排序;设为 JSON 文件路径时用它代替 `lc_mcp/data/gift_keywords.json` |
|
||||
| `LCP_SHOP_NAMES` | 未设置 | 设为 `0` 时商店必买只用 AALC 图标模板;设为 JSON 文件路径时用它代替 `lc_mcp/data/shop_gifts.json` |
|
||||
| `LCP_THEME_PACK_SYSTEMS` | 未设置 | 设为 `0` 时卡包只按 AALC 原权重选;设为 JSON 文件路径时用它代替 `lc_mcp/data/theme_pack_systems.json` |
|
||||
| `LCP_KEY_HOLD` | 未设置 | 设为 `0` 时任务进程的按键完全走 AALC 原逻辑(前台 `pyautogui.press`、不按住) |
|
||||
| `LCP_KILL_KEY` | `end` | 任务子进程的急停键,如 `pause` / `scrolllock`;认不出的键名会报错而不是换成默认键 |
|
||||
| `LC_PY` | 当前解释器 | `levelup.py`/`auto_cycle.py` 调用 MCP 用的 Python |
|
||||
|
||||
## 开发 / 测试
|
||||
@@ -232,18 +308,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
|
||||
# 新开一局:清除上一局的楼层、饰品与领取状态
|
||||
|
||||
+347
@@ -0,0 +1,347 @@
|
||||
# 待开发计划(BACKLOG)
|
||||
|
||||
按「收益 / 风险」排序。每条都带**证据**和**验收标准**,云端改完直接照着验。
|
||||
最近一次实测记录见 [`feedback/2026-11-14/README.md`](feedback/2026-11-14/README.md),
|
||||
接口与队名表见 [`feedback/2026-11-14/HANDOVER.md`](feedback/2026-11-14/HANDOVER.md),
|
||||
实机回归清单:上一轮 [`feedback/2026-11-14/REGRESSION.md`](feedback/2026-11-14/REGRESSION.md),本轮 [`feedback/2026-11-15/REGRESSION.md`](feedback/2026-11-15/REGRESSION.md)。
|
||||
|
||||
图例:P0 = 现在是坏的/每天都在浪费;P1 = 明显影响质量;P2 = 打磨。
|
||||
|
||||
## 2026-11-14/15 实机回归后的状态
|
||||
|
||||
- 回归结果:[`feedback/2026-11-14/REGRESSION-RESULTS.md`](feedback/2026-11-14/REGRESSION-RESULTS.md)
|
||||
- 问题与需求台账:[`ISSUES.md`](ISSUES.md)(I-xx 问题 / R-xx 需求,带证据和下一步)
|
||||
|
||||
| 条目 | 状态 |
|
||||
|---|---|
|
||||
| P0-1 商店清单 | 上游已修(`5/19/31` 非空),本地补丁已删 |
|
||||
| P0-2 键盘寻路 | 本机键盘进节点 0/24 成功(旧版 32/32 也失败)。11-15 云端:按键改带扫描码并按住(疑似根因),连续 3 个节点进不去就停用 → I-05 待验 |
|
||||
| P1-3 饰品按体系 | 已实机跑通(4 次里 2 次命中),继续攒样本 |
|
||||
| P1-4 事件选项表 | 已挂上,但 17 条事件里 15 条未收录 → 11-15 云端补 3 条(6→9),其余等 `not_in_table` 选项行,见 I-07 / R-02 |
|
||||
| P1-5 选队容错 | 通过;另补了"入场前切队"(I-01)和"选队页守卫"(I-02)。11-15 云端复查修了三处(I-13) |
|
||||
| P2-6 商店按名字 | 已实机跑通(样本少,见 I-10) |
|
||||
| P2-8 决策审计 | 通过(注意部署要重启服务,见 I-09) |
|
||||
| 新增 | 开局「获得E.G.O饰品」弹窗死循环 → 11-15 云端兜底(I-06 / R-04)待验 |
|
||||
| 新增 | 卡包按体系(R-01):11-15 云端用 wiki.gg 数据做了「卡包 → 体系」表并按体系加分,待验 |
|
||||
|
||||
---
|
||||
|
||||
|
||||
## AALC 上游升级到 V1.6.1(2026-11-14 云端)
|
||||
|
||||
`vendor/aalc` 从 `e1d1749`(V1.6.1-beta.11)升到 `2fcb1b4`(V1.6.1,17 个提交)。与本仓库补丁有关的:
|
||||
|
||||
| 上游提交 | 改了什么 | 对本仓库的影响 |
|
||||
|---|---|---|
|
||||
| `8196e72` | 商店三个清单改按 `assets/images/default/share/...` 列目录 | P0-1 上游已修,本地补丁删掉;`tests/test_shop_lists.py` 改成守着上游非空(5/19/31) |
|
||||
| `18deb77` | 事件里找 "???" 改成 `find_element` + 自己点;小指良单通模式改点别的选项 | P1-4 原来挂在 `click_element("event/unknown_event.png")` 上,**升级后会悄悄失效**;已改挂 `find_element`,单通模式也测了 |
|
||||
| `3980b58` | 判定成功率徽章识别前先把红色(低/极低)涂黑 | 不涉及补丁;判定选人更准 |
|
||||
| `a3b6766` | 饰品奖励"选二"先于"选一"判断 | P1-3 只重排卡片顺序,不受影响(单测执行的就是新版 `acquire_ego_gift`) |
|
||||
| `0f456e3` `732002f` | 开局饰品按优先级逐个点,模板 0.8→0.7→锚点坐标兜底 | 不涉及补丁 |
|
||||
| `fb2ef56` | `check_game_alive` 要求进程**和**窗口(`UnityWndClass` + `game_title_name`)都在;进程起来 180 秒还没窗口就杀掉重启 | 实机留意:窗口标题改过或被隐藏时会被当成僵尸进程 |
|
||||
| `d4c9004` | ONNX 寻路模型会话缓存 | P0-2 调的 `identify_nodes` 变快,接口不变 |
|
||||
|
||||
为避免再出现"上游改写法、补丁悄悄失效",事件表、饰品排序、商店按名字三个补丁安装时先查上游源码里还有没有被拦截的那个调用;
|
||||
没有就记 `[ERROR] ... 挂不上` 并跳过,`task_status` 的 `errors` 里能看到。
|
||||
|
||||
---
|
||||
|
||||
## P0-1 商店「必买 / 必卖 / 公式合成」清单恒为空
|
||||
|
||||
**现状**:`tasks/mirror/__init__.py` 用旧路径加载模板:
|
||||
|
||||
```python
|
||||
must_purchase_path = "./assets/images/share/mirror/shop/must_purchase"
|
||||
```
|
||||
|
||||
实际图片在 `./assets/images/default/share/mirror/shop/must_purchase/`(5 张:`carmilla`、`homeward`、
|
||||
`lithograph`、`phlebotomy_pack`、`piece_of_relationship`),`assets/images/share` 根本不存在。
|
||||
运行时实测:
|
||||
|
||||
```
|
||||
must_purchase 0
|
||||
must_be_abandoned 0
|
||||
fusion_result 0
|
||||
```
|
||||
|
||||
后果:`in_shop.py:157` 的购买循环、`:564` 的废弃识别、公式合成全部空转。2026-11-14 进店 51 秒、
|
||||
打印了三次「开始购买必买项」却没买一件。
|
||||
|
||||
**目标**:三个清单按当前 `path_manager` 的图片根(`default/share`、`dark/share`…)加载,且支持中英文资源目录。
|
||||
|
||||
**验收**:
|
||||
|
||||
- [ ] `python -c "import tasks.mirror as m; print(len(m.must_purchase), len(m.must_be_abandoned), len(m.fusion_result))"` → `5 19 31`
|
||||
- [ ] 单测覆盖:清单非空、路径含 `default/share`、`dark` 主题下也能解析
|
||||
- [ ] 实机进店日志能看到真正的购买动作(`购买` 后出现 `ego_gift_get_confirm`),且余额变化
|
||||
|
||||
**涉及**:`tasks/mirror/__init__.py`(`vendor`!)→ 若要遵守「不改 vendor」,就在 `lc_mcp/aalc_patches.py`
|
||||
里于 import 后重建这三个列表,并加一条注释说明上游路径缺陷。
|
||||
|
||||
**风险**:低。纯路径/清单;不改判定逻辑。
|
||||
|
||||
**状态(2026-11-14 云端)**:上游 V1.6.1(`8196e72`)已修,本地补丁 `install_shop_lists()` 已删。
|
||||
`tests/test_shop_lists.py` 执行上游真实的 `tasks/mirror/__init__.py`,守着三个清单是 5/19/31 且每张图都找得到。
|
||||
下面是当初的分析,留作记录。
|
||||
|
||||
- 根因:上游 `ebb6629`(调整图片路径)把图片挪到 `assets/images/<主题>/<语言>/`,`tasks/mirror/__init__.py` 没跟着改。
|
||||
按名字找图那一层(`path_manager` 依次搜各主题/语言目录)没坏,只是列目录列空了。
|
||||
- 修法:`install_shop_lists()` 在 `mirror` / `all` 任务里按 AALC 的六个图片根(`dark|default` × `zh_cn|en|share`)
|
||||
合并去重,**原地** `extend` 这三个列表——`in_shop.py` 用 `from tasks.mirror import ...` 在导入时绑定了列表对象,
|
||||
重新赋值对它无效。上游清单已非空时不动。
|
||||
- 补丁只在任务进程里生效,上面那条 `python -c` 仍会打印 `0 0 0`。离线等价验证是 `tests/test_shop_lists.py`
|
||||
(执行上游真实 `__init__.py` 得到 `0 0 0`,补丁后为 `5 19 31`)。实机看任务日志里这一行:
|
||||
`[lc_mcp] patch: 镜牢商店清单按 assets/images/<主题>/<语言> 补齐: must_purchase=5, must_be_abandoned=19, fusion_result=31`
|
||||
|
||||
---
|
||||
|
||||
## P0-2 镜牢走位被配置降级成「只按 ↑」
|
||||
|
||||
**现状**:`config.yaml` 里 `mirror_keyboard_navigation: true` + `mirror_keyboard_simple_pathfinding: true`,
|
||||
`mirror.py:1128` 因此走 `search_road_simple_keyboard()`:每层按两次 ↑ 进最上面的节点,不看节点类型。
|
||||
Dijkstra 那套(`search_road.py:735`,代价 event 1 / shop 2 / battle 4 / boss·focused 6 / risky 7)完全没跑。
|
||||
|
||||
**目标**(二选一,云端定):
|
||||
|
||||
- A:默认改用 Dijkstra,只在检测到「鼠标拖地图卡死」时降级为简单键盘;
|
||||
- B:保留简单键盘,但把「↑ 的第一个节点」换成「按节点类型挑可达节点」。
|
||||
|
||||
**验收**:
|
||||
|
||||
- [ ] 一局里至少 3 层,日志能打印每层选中的节点类型与理由
|
||||
- [ ] 事件/商店节点占比 ≥ 现状(对比 11-14 这局:3 层只进过 1 次商店)
|
||||
- [ ] 不出现寻路卡死(连续 60 s 无 `enter_assets` 即算失败,应回退简单键盘)
|
||||
|
||||
**涉及**:`tasks/mirror/search_road.py`、`tasks/mirror/mirror.py:1128`、`config.yaml` 默认值(`assets/config/config.example.yaml`)
|
||||
|
||||
**风险**:中。`simple_pathfinding` 当初是为了规避鼠标拖拽卡死加的,去掉要有回退开关。
|
||||
|
||||
**状态(2026-11-14 云端)**:选 **B**,已实现,待实机验收。
|
||||
|
||||
- 不选 A 的原因:常规寻路(`search_road_from_road_map`)先用 `mouse_drag` 把巴士拖到固定位置,第二段拖动只受
|
||||
超时限制、超时还会 `back_init_menu()`;连线识别 `identify_road` 依赖 `my_crop`,HANDOVER 已证实它在本机坐标不对。
|
||||
- 做法:`install_typed_keyboard_road()` 替换 `search_road_simple_keyboard`(`search_road` 和 `mirror` 两个命名空间)。
|
||||
仍只按键、不拖地图:找到巴士 → 用 AALC 自带 ONNX 模型整屏识别(不裁剪)→ 取巴士右侧一列、按相对行映射成
|
||||
U/M/D → 按上游 `all_node_weight`(event 1 < shop 2 < battle 4 < boss/focused 6 < risky 7)依次按 `up/right/down`,
|
||||
每按一次都用原来的 `_keyboard_enter_succeeded()` 确认;都进不去就调用原函数按 ↑。最多 3 次按键,不会循环。
|
||||
- 只看下一列,是一步贪心,不是整层最优路线。
|
||||
- 回滚:任务环境变量 `LCP_TYPED_ROAD=0` 不装补丁;或在 AALC 里关掉简单键盘寻路,回到上游常规寻路。
|
||||
- **待实机确认的假设**:方向上没有连线时按该方向键不会进入别的节点(应当没有"进入"按钮,补丁随即换下一个方向)。
|
||||
回归时对照日志 `[lc_mcp] 键盘寻路: 进入 X 方向的 <类型>` 与实际进入的节点类型;若对不上,说明按键语义与假设不符。
|
||||
- 日志:每一步打印 `下一列 U=event(1) D=shop(2) M=battle(4)` 与最终进入的方向、类型和理由。
|
||||
|
||||
---
|
||||
|
||||
## P1-3 饰品三选一加「体系优先」
|
||||
|
||||
**现状**:`mirror.py:1360 acquire_ego_gift()` 只看两件事——是不是白棉花、是不是「已持有」,
|
||||
然后拿第一张。**完全不看 `team_system`**。
|
||||
|
||||
**目标**:可配置的关键词优先表(例如流血队:`流血 / 出血 / 血迹`),命中则加权;仍旧排除已持有与白棉花。
|
||||
|
||||
**验收**:
|
||||
|
||||
- [ ] 单测:给定候选文本列表 + 体系,选出预期那一张(含「全部已持有」「全是白棉花」边界)
|
||||
- [ ] 实机:流血队一局里,三选一命中体系关键词的比例 > 0(日志统计)
|
||||
- [ ] 关闭该配置时行为与现在完全一致(可回滚)
|
||||
|
||||
**涉及**:`tasks/mirror/mirror.py`、`lc_mcp/aalc_patches.py`(建议做成可配置关键词表,放 `config.yaml` 或独立 yaml)
|
||||
|
||||
**风险**:中。OCR 有误读(`震颐`/`沉论`/`编#16`),关键词要容忍错字。
|
||||
|
||||
**状态(2026-11-14 云端)**:已实现,待实机验收。
|
||||
|
||||
- 核对上游时发现「完全不看体系」只对一张、两张卡成立:三张卡时 `acquire_ego_gift` 会用
|
||||
`acquire_ego_gift/<体系>.png` 图标模板(阈值 0.85)把命中的卡排前面,只是没有日志能证明它在本机生效。
|
||||
- 做法:`install_gift_preference()` 包住 `Mirror.acquire_ego_gift`(只管 `type=1` 的选卡界面,`type=2` 拒绝饰品原样放行)。
|
||||
调用期间临时替换 `auto.find_element`:上游取到卡片列表(`acquire_ego_gift_card.png`,多目标)时,
|
||||
整屏 OCR 一次,按坐标把每行文字归到卡上(范围与上游判断白棉花/已持有的一致),命中体系关键词行数多的排前面。
|
||||
排序稳定,之后上游原逻辑照旧:白棉花跳过、已持有排后。调用结束还原 `find_element`。
|
||||
- 三张及以上(2026-11-14 复查修正):上游逐张看卡,认出体系图标的卡 `my_list.insert(0, ...)`,**后看的排到最前**,其余 append。
|
||||
最初直接把排好的顺序交给上游,两张命中关键词的卡都带图标时会被它倒过来,反而先拿命中少的那张。现在交给上游的顺序是
|
||||
「没命中的(原顺序)+ 命中的(倒着)」,上游查体系图标时对命中关键词的卡答"有";拼出来是
|
||||
命中多的 → 命中少的 → 只认出图标的 → 其余,再按已持有排后。两张卡的分支不看图标,直接按命中多少给。
|
||||
- OCR 直接读引擎的逐行结果,不用 `_run_ocr_for_text` 的 `{文本: 坐标}`(两张卡上同一句会被合并成一条)。不用 `my_crop`。
|
||||
- 关键词表 `lc_mcp/data/gift_keywords.json`(JSON,不加依赖);匹配前做与选队相同的归一(空白/全半角/`震颐` 等误读),
|
||||
英文不分大小写。表读不了记 `[ERROR]` 并不装补丁。
|
||||
- 回滚:`LCP_GIFT_KEYWORDS=0` 不装补丁,行为与上游完全一致;`LCP_GIFT_KEYWORDS=<路径>` 换表。
|
||||
- 关键词按零协汉化核对(`LLC_zh-CN/EgoGiftCategory.json`、`BattleKeywords.json`):烧伤 流血 震颤 破裂 沉沦 呼吸法 充能
|
||||
斩击 突刺 打击。饰品描述里的 `[Combustion]` 等占位符在游戏里就显示成这些名字。原表的 `出血` 在汉化里一次都没出现,已删。
|
||||
- 只按主体系;第二体系仍只由上游的图标匹配处理。
|
||||
- 单测执行上游真实的 `acquire_ego_gift`(`tests/test_gift_preference.py`),覆盖两张/三张卡、选一/选二、
|
||||
已持有、白棉花、全是白棉花、误读、无命中,以及带体系图标的卡(命中的都带图标、命中的没认出图标、只认出图标)。
|
||||
- 实机验收:日志 `[lc_mcp] 饰品选择(体系 bleed): 第1张=0 第2张=1(流血) 第3张=0; 命中体系关键词, 先看第2张`;
|
||||
统计「命中体系关键词」与「未命中体系关键词」的行数即得命中比例。
|
||||
|
||||
---
|
||||
|
||||
## P1-4 事件选项策略可配
|
||||
|
||||
**现状**:`mirror.py:1230 event_handling()` 固定策略——能点「判定 / check」就点,然后**永远点第一个选项**,
|
||||
最后找 `continue/继续`。跟体系、跟当前血量都无关。
|
||||
|
||||
**目标**:支持一张「事件 → 选项」表(JSON/YAML),未收录的退回「第一个选项」。
|
||||
|
||||
**验收**:
|
||||
|
||||
- [ ] 表里命中的事件按配置点;未命中的行为不变
|
||||
- [ ] 单测:事件文本 → 选项索引映射,含缺省分支
|
||||
- [ ] 至少录入 5 个高频事件(可从 `docs/mirror_dungeon_speedrun_notes.md` 的既有结论里抄)
|
||||
|
||||
**涉及**:`tasks/mirror/mirror.py`、新增数据文件(建议 `lc_mcp/data/event_choices.yaml`,不要塞进 vendor)
|
||||
|
||||
**风险**:低-中。选项点错可能拿不到奖励,但不会卡死。
|
||||
|
||||
**状态(2026-11-14 云端)**:已实现,待实机验收。按零协汉化重写过一次(见下)。
|
||||
|
||||
- 做法:`install_event_choices()` 包住 `Mirror.event_handling`,调用期间临时替换 `auto.find_element` 和 `auto.mouse_click`。
|
||||
上游每轮挑选项的第一步是 `find_element("event/unknown_event.png")`,补丁在这一步插一次判断:
|
||||
`event/select_first_option_assets.png` 多目标匹配到选项框(每项的左边缘)时整屏 OCR,把右侧同一行的文字归到各项;
|
||||
选项对上表里某个事件,就点表里那一项的左边缘,并把这个位置当成 "???" 交还上游(`event_chance -= 1`, 重新截图)。
|
||||
上游随后拿这个位置再点一次的那下会被吞掉;小指良单通模式下它会再找一次 "???",这时返回"没有",不会改点别的选项。
|
||||
其余情况(不在选项画面、没认出事件、要点的那项没读到)照常交给上游。
|
||||
- **按选项原文认事件,不按事件名**:零协汉化的事件数据(`LLC_zh-CN/ActionEvents_*.json`)只有叙述和选项,没有标题字段,
|
||||
画面上也不保证有事件名。每条规则写同一屏其它选项的原文(`options`,全部出现才算)和要点的那一项(`text`)。
|
||||
比较前去空白、全角转半角、去标点。一次事件里按表最多点 5 次,点了没反应就交回上游。
|
||||
- 表 `lc_mcp/data/event_choices.json`,6 条,选项原文照抄零协汉化(`LocalizeLimbusCompany@231a8bc`),带事件 id 便于回查;
|
||||
选择依据仍是 `docs/skills/limbus-mirror-speedrun/references/event-choices.md`:
|
||||
|
||||
| 事件 | 汉化 id | 点哪项 | 结果(汉化选项说明) |
|
||||
|---|---|---|---|
|
||||
| 红色坐像 | 901010 | 侧耳倾听。 | 无判定无战斗;2 判定,3 战斗 |
|
||||
| 炸鸡对决 | 971001 | 鸡肉就是鸡肉喽。 | 1 件烧伤 + 1 件破裂饰品 |
|
||||
| 鸡群的激情探戈 | 971003 | 视而不见。 | 1 件泛用饰品 |
|
||||
| 梦中的电子羊 | 901038 | 你不是特别的。 | 1 件泛用饰品 |
|
||||
| 失明巨人递来患者记录 | 901085 | 说上面什么都没有写。 | **判定**(忧郁/怠惰);1 也是判定且门槛更高 |
|
||||
| 破碎罗盘(冻僵的尸体指路) | 901095 | 返回。 | 直接结束(第 4 项) |
|
||||
|
||||
- 核对时删掉的:
|
||||
- `往昔的睡袋`(2)与 `折射的往昔的睡袋`(1):汉化里只有一个睡袋事件(971058,标题"折射的往昔的睡袋"),
|
||||
选项是「聆听喘息声」(傲慢/嫉妒判定)和「捂住耳朵」(无说明);参考文档对两个版本的"2"说法相反(回复 / 降 20 理智),
|
||||
拿不准,交回 AALC 原逻辑(有 "???" 先点 "???",否则点优势判定);实机日志里 `not_in_table` 会记下它的选项,再决定要不要补。
|
||||
- `浸染棉花`(3)、`终末日历`(2):汉化的镜牢事件里找不到对应选项,无法按原文认。
|
||||
- 原来的 `index`(按第几项)规则全部去掉:有了原文就不需要编号,参考文档也提醒过 Wiki 编号与当前顺序可能不同。
|
||||
- 原表说明写的"都是无判定/无战斗"不对:失明巨人两项都要判定,已在表里标 `check: true`。
|
||||
- 巴士 Wiki(wiki.biligame.com/limbuscompany)的接口查了几次后就返回人机验证页,没法自动核对;事件结果仍以参考文档(灰机 Wiki)为准。
|
||||
- 日志:每屏选项只打一次,`[lc_mcp] 事件 <名>: 1=… | 2=…; 按表选第 N 项「…」`;没收录时
|
||||
`事件选项: 1=… | 2=…; 表里没有这个事件, 交给 AALC`,可直接拿来补表(写零协汉化的原文)。
|
||||
- 回滚:`LCP_EVENT_CHOICES=0`;表读不了、或上游不再调用 `find_element("event/unknown_event.png")` 时记 `[ERROR]` 并不装补丁。
|
||||
- 单测执行上游真实的 `event_handling` 和 `click_option_avoiding_unknown`(`tests/test_event_choices.py`),覆盖按表点、
|
||||
只点一次、表优先于 "???"、单通模式、未收录与上游一致、要点的项没读到、第二屏交回上游、点击没反应的次数上限。
|
||||
- **待实机确认**:选项文字与左边缘同一行的假设(`EVENT_OPTION_ROW`);`not_in_table` 的日志里选项文字是否完整。
|
||||
|
||||
---
|
||||
|
||||
## P1-5 选队补丁的鲁棒性
|
||||
|
||||
**现状**:`_select_team_by_name()` 精确匹配 + 4 轮翻页。已知薄弱点:
|
||||
|
||||
- OCR 误读(实测把「震颤」读成「震颐」、「沉沦」读成「沉论」、「编队#16」读成「编#16」)
|
||||
- 队名带后缀(「流血队」「流血(X)」)会失配
|
||||
- 只按「顶栏名字」确认,若顶栏字号变化会误判
|
||||
|
||||
**目标**:别名表 + 归一化(去空格/全半角/常见误读)+ 失败时输出候选列表便于排查。
|
||||
|
||||
**验收**:
|
||||
|
||||
- [ ] 把队名临时改成「流血队」也能选中(别名/前缀匹配,仍需唯一)
|
||||
- [ ] 误读样本(`震颐`→`震颤`、`沉论`→`沉沦`)能正确归一
|
||||
- [ ] 失败日志里打印「这一屏看到了哪些名字」,而不是只说没找到
|
||||
|
||||
**涉及**:`lc_mcp/aalc_patches.py`、`tests/test_system_team_selection.py`
|
||||
|
||||
**风险**:低。只是匹配变宽,需保证「唯一命中」才点,避免选错队。
|
||||
|
||||
**状态(2026-11-14 云端)**:已实现,待实机验收。
|
||||
|
||||
- 归一化 `normalize_team_name()`:去所有空白,NFKC 全角转半角(`#`→`#`、`()`→`()`),再按 `TEAM_OCR_FIXES`
|
||||
改回实测误读(`震颐`→`震颤`、`沉论`→`沉沦`、`编#`→`编队#`)。新误读往这张表里加。
|
||||
- 列表挑选 `pick_team_item()`:先找精确匹配(多个名字时按 `SYSTEM_TEAM_NAMES` 里的顺序);没有再看前缀匹配
|
||||
(名字至少两个字,后面带任意后缀),**这一屏只有一条才点**,两条以上记日志不点、继续翻页。
|
||||
- 选队 OCR 读引擎的逐行结果(2026-11-14 复查修正):原来经 `_run_ocr_for_text` 的 `{文本: 坐标}`,选中某队后顶栏和列表里是同一个名字,顶栏那条会被列表那条覆盖,「已经是这支队」和点完后的确认都会读不到顶栏;旧测试用假的成对结果模拟了重复,真实 dict 做不到,所以没测出来。
|
||||
- 顶栏确认只认归一后的精确匹配:「已经是这支队」的判断和点完后的确认都一样。顶栏是 `流血队` 时会回列表里确认唯一再点一次,
|
||||
避免把 `流血2` 当成 `流血`。
|
||||
- 日志:每屏没命中时打印 `第 N 屏没有 流血; 这一屏的名字: 剧情关卡/斩击/...`;点了但顶栏没变时打印顶栏读到了什么。
|
||||
- 限制:唯一性只按当前这一屏判断;相似队名分在两屏时(例如 `流血队` 在第 2 屏、`流血2` 在第 3 屏)会点先出现的那条。
|
||||
顶栏位置仍是写死的 `TEAM_HEADER`,字号/布局变了要按日志里「顶栏读到」调整。
|
||||
- 实机验收:把「流血」改名成「流血队」跑一局,日志应出现 `编队列表里找到 流血队 @(...), 前缀匹配 流血`
|
||||
和 `已按体系名选中编队 流血队`。
|
||||
|
||||
---
|
||||
|
||||
## P2-6 商店必买清单本地化
|
||||
|
||||
**现状**:必买靠 5 张**英文/图标模板**;汉化后商店里的名称是中文,模板匹配靠图标尚可,但新增饰品无法覆盖。
|
||||
|
||||
**目标**:支持「饰品中文名 → 优先级」的配置表,OCR 命中即买;模板作为兜底。
|
||||
|
||||
**验收**:单测 + 实机一局至少一次由名字命中的购买。
|
||||
|
||||
**涉及**:`lc_mcp/aalc_patches.py`(包一层购买判定)、新增数据文件。
|
||||
|
||||
**状态(2026-11-14 云端)**:已实现,待实机验收。
|
||||
|
||||
- 截图 `docs/feedback/mirror_20261002_181322/special_shop_missed.png` 证实商品格下面写着饰品中文名(`无头肖像`、`辉光变动仪`…),
|
||||
不用点开就能 OCR。
|
||||
- 做法:`install_shop_by_name()` 包住 `Shop.buy_gifts`,调用期间在 `must_purchase` 列表最前面临时插 3 个占位项。
|
||||
上游 `for commodity in must_purchase: auto.click_element(commodity, ...)` 点到占位项时改成:以 `shop_coins_assets.png`
|
||||
(上游 `re_sort_points` 用的同一个锚点)为基准,在商品格范围内整屏 OCR,名字与表里**完全一致**(允许 `+` 后缀)就点名字上方
|
||||
155(1440 标定)的图标;之后"购买 → 确认"仍是上游那段循环。没命中的截图不重复 OCR;同一名字一次进店最多点 4 次
|
||||
(钱不够时上游会反复重点)。调用结束把占位项拿掉、还原 `click_element`。
|
||||
- 表 `lc_mcp/data/shop_gifts.json`:默认就是 AALC 那 5 张必买模板对应的饰品,名字按零协汉化:缘分残片、卡蜜拉、采血包、归途、石版字符
|
||||
(顺序是建议:立即见效的在前)。核对描述发现 AALC 说的"回血饰品"只有后三个是回血。图标模板仍在后面兜底(名字读错时照样买)。
|
||||
- 审计:按名字找到记 `shop` / `name_match`;随后的购买仍记 `purchase_clicked`,`choice` 是 `shop_by_name`。
|
||||
`aalc_task` 里这个补丁装在商店审计之后,审计才看得到占位项那一下。
|
||||
- 回滚:`LCP_SHOP_NAMES=0`;表读不了、或上游不再逐个 `click_element(must_purchase)` 时记 `[ERROR]` 并不装补丁。
|
||||
- 单测执行上游真实的 `Shop.buy_gifts`(`tests/test_shop_by_name.py`):名字命中、表顺序、名字读错时模板兜底、买不起时的点击上限、
|
||||
与审计一起装;坐标按截图实测(金币 (827,206)@1080,名字行在 +409/+716、图标在名字上方 155,均为 1440 标定)。
|
||||
- **待实机确认**:普通商店与截图里的特殊商店布局一致;实机一局至少一次 `shop.name_match`;
|
||||
买不起时上游会在购买框开着时重点商品(模板也一样),按名字重点的那几下落在框上是否无害。
|
||||
|
||||
---
|
||||
|
||||
## P2-7 观测饰品按体系自动勾选
|
||||
|
||||
**现状**:`observe_ego_gift_selected` 要人在 AALC 界面一个个勾;没勾就等于关闭观测。
|
||||
|
||||
**目标**:按 `team_system` 自动勾一组默认饰品(可覆盖),并在开跑前写回配置。
|
||||
|
||||
**验收**:`config.yaml` 里 `observe_ego_gift_selected` 与体系匹配;日志打印勾了哪些。
|
||||
|
||||
**涉及**:`lc_mcp/aalc_task.py`(apply_overrides 类似机制)、`app/observe_ego_gift_selection.py` 的序列化格式(只读参考)。
|
||||
|
||||
**状态(2026-11-14)**:不做。用户确认观测饰品不需要自动勾选。
|
||||
|
||||
---
|
||||
|
||||
## P2-8 决策审计日志
|
||||
|
||||
**现状**:选队/卡包/饰品/商店的决策只散落在 DEBUG 日志里,事后要人肉 grep。
|
||||
|
||||
**目标**:每局写一份 `~/lc_mcp/runs/<task>.decisions.jsonl`:时间、阶段、画面摘要、候选、选中项、理由。
|
||||
|
||||
**验收**:一局结束后能直接统计「卡包选择理由 ×N」「三选一命中体系 ×N」「商店购买 ×N」。
|
||||
|
||||
**涉及**:`lc_mcp/aalc_patches.py`、`lc_mcp/tasks.py`(结果归档)。
|
||||
|
||||
**状态(2026-11-14 云端)**:已实现,待实机验收。
|
||||
|
||||
- 文件与任务日志同名:`~/lc_mcp/runs/task_<时间>_<任务>.decisions.jsonl`。TaskRunner 通过 `LCP_DECISIONS` 把路径传给子进程,
|
||||
清理旧日志时一起删;直接 `python -m lc_mcp.aalc_task` 运行时不写。写失败只丢那一行。
|
||||
- 每行 `time`/`stage`/`choice`/`reason` + 细节(候选、命中、选项文字…);`reason` 是用来计数的短类别,表见 README。
|
||||
`task_status` 返回 `decisions: {path, counts: {stage: {reason: 次数}}}`。
|
||||
- 来源:选队(P1-5)、键盘寻路(P0-2)、饰品(P1-3)、事件(P1-4)直接在补丁里记;
|
||||
商店与卡包是只观察的补丁:`Shop.buy_gifts` 期间看 `purchase_assets` 是否点中、之前点的是哪件商品;
|
||||
`select_theme_pack` 期间临时挂一个 logging handler,从上游自己的 `此次选择卡包关键词:X` 日志取结果和权重列表。
|
||||
- 「画面摘要」只记了各决策用到的文字(选项、队名、命中关键词),没存截图。
|
||||
- 验收对应:卡包理由 = `counts.theme_pack`,三选一命中体系 = `counts.gift.keyword`,商店购买 = `counts.shop.purchase_clicked`。
|
||||
|
||||
---
|
||||
|
||||
## 已知但暂不做的
|
||||
|
||||
| 项 | 原因 |
|
||||
|---|---|
|
||||
| 让 AALC 原生支持自定义队名 | 要改 `vendor/aalc`,submodule 升级会丢;补丁层已够用 |
|
||||
| 自动识别「哪支队是流血队」 | 图像/文本都不可靠,靠命名约定(见 HANDOVER 第 4 节)更稳 |
|
||||
| 改 `mirror_dungeon_speedrun_notes.md` 的路线结论 | 那是人工速通笔记,和 AALC 的自动寻路是两套,别混 |
|
||||
+237
@@ -0,0 +1,237 @@
|
||||
# 问题与需求台账
|
||||
|
||||
所有**实测发现的问题**和**用户提的需求**都记在这里,编号固定,状态跟着实机验证走。
|
||||
比 BACKLOG 更"流水账":BACKLOG 是排期,这里是台账(每条都有证据和下一步)。
|
||||
|
||||
状态:`已修` = 代码改了且实机验证;`已修待验` = 代码改了没实机验证;
|
||||
`待修` = 有确定方案;`待数据` = 卡在缺数据/缺决策;`观察` = 暂不处理,先攒样本;`记录` = 不是缺陷。
|
||||
|
||||
最近更新:2026-11-15 14:10(本机实机:I-05 键盘 4/4 进入、I-06 软件点击兜底关掉弹窗、I-08 卡包按体系加分生效;6 连刷 6/6 完成,见 [`feedback/2026-11-15/README.md`](feedback/2026-11-15/README.md))。
|
||||
上一次:2026-11-15 01:55 本机(6 连刷进行中)。
|
||||
|
||||
---
|
||||
|
||||
## 一、问题清单
|
||||
|
||||
### I-01 镜牢入场不走选队,用游戏记住的旧队伍 【已修】
|
||||
|
||||
- **现象**:`team_number` / 按名字选队完全不执行,入场直接点「进入」。
|
||||
- **证据**:2026-11-14 21:14 日志入场段只有 `mirror/road_to_mir/enter_assets.png` 的匹配,无「寻找队伍」。
|
||||
- **根因**:AALC 只有先命中 `select_team_stars_assets.png`(选队星级)才调 `select_battle_team`;
|
||||
入场这条路上它先看到「进入」。
|
||||
- **修法**:补丁在 `click_element('mirror/road_to_mir/enter_assets.png')` 之前,若检测到选队页且顶栏
|
||||
不是目标队,先切队再进入。
|
||||
- **验证**:2026-11-15 01:51 `入场前切队伍: 充能/震颤` → `精确匹配 充能` → `已按体系名选中编队 充能`。
|
||||
|
||||
### I-02 「星之恩惠」页误命中「选队星级」模板 【已修】
|
||||
|
||||
- **现象**:AALC 在星之恩惠页连喊 6 次「不在编队界面」(20:47 那局)。
|
||||
- **根因**:星之恩惠满屏星星,`select_team_stars_assets.png` 在该页也匹得上。
|
||||
- **修法**:`install_team_screen_guard` —— 只在出现「恩惠」字样时忽略星级模板;其余页面不再拦。
|
||||
- **验证**:01:50 起的 6 连刷前两分钟无「不在编队界面」。
|
||||
|
||||
### I-03 选队扫描步长过大,整屏被跳过 【已修】
|
||||
|
||||
- **现象**:找「充能」时从「剧情关卡..震颤」直接跳到「编队#19..25」。
|
||||
- **修法**:每轮 1 次拖动(原 3 次)、最多 6 轮。
|
||||
- **验证**:01:51 第 2 屏精确命中「充能」。
|
||||
|
||||
### I-04 旧版按 `编队#N` 找队,账号里没有 `#1`~`#12` 【已修】
|
||||
|
||||
- **现象**:翻满 10 页 → 6 轮重试 → `无法寻得队伍`。
|
||||
- **修法**:按 `team_system` 映射的中文队名精确匹配(流血/充能/震颤…),
|
||||
加别名与 OCR 误读归一(震颐→震颤、沉论→沉沦、编#→编队#)。
|
||||
- **验证**:11-14 09:40 选中「流血」;11-15 01:51 选中「充能」。
|
||||
|
||||
### I-05 键盘寻路在本机 0 成功 【已实机验证】
|
||||
|
||||
- **现象**:2026-11-15 01:58 前 24 次键盘尝试全部「没能进入」,全部回退鼠标寻路;
|
||||
今早旧版(只按 ↑)也是 32/32 失败。
|
||||
- **影响**:每次寻路多花约 5 秒(3 个方向 × 2 次),一局约多 2~3 分钟;功能本身没坏。
|
||||
- **下一步(二选一)**:
|
||||
- A. `config.yaml` 设 `mirror_keyboard_navigation: false`,直接走鼠标寻路(省时间);
|
||||
- B. 补丁里加"本次运行键盘连续失败 2 次后不再尝试"(保留可用环境的收益)。
|
||||
- **不选的理由**:还没确认方向键为什么进不去(可能是窗口焦点/Unity 输入),关掉就再也测不出来。
|
||||
- **云端 2026-11-15 结论(推断,待实机确认)**:AALC 前台模式的 `key_press` 是 `pyautogui.press`,
|
||||
`keybd_event` 的扫描码填 0、方向键不带扩展键标志,按下抬起紧挨着;上游后台模式 `_make_key_lparam`
|
||||
的注释写明「Unity 6+ 会校验 scan code 和 extended flag」,本仓库 `aalc_engine` 也记过 Unity 会吞同一帧的 down/up。
|
||||
后台模式的按键消息扫描码是对的,但同样不按住。
|
||||
- **修法**:
|
||||
1. `install_key_hold`:前台改发带扫描码和扩展键标志的 `keybd_event`(不在前台先激活,激活不了就不发),
|
||||
后台两种模式中间按住 0.12 秒。所有任务生效(战斗 P/Enter、Esc 也走这里)。`LCP_KEY_HOLD=0` 关。
|
||||
2. 即 B:连续 3 个节点按键都没进去,本次任务不再按键寻路(记 `road/keyboard_off`),进去一次就清零。
|
||||
A(`mirror_keyboard_navigation: false`)仍可随时手动改配置。
|
||||
- **验证方式**:看 `键盘寻路: 进入 X 方向的 …` 是否出现、`road` 的 `lowest/next_best` 计数;
|
||||
若仍 0 成功,会看到 `road/keyboard_off`,每局只多花 3 个节点的时间。日志开头那行 `patch: 按键按住 120ms …`
|
||||
括号里列出改了哪些后端,用来确认本机走的是哪种输入方式。
|
||||
|
||||
### I-06 开局「获得E.G.O饰品」弹窗点不掉 【已实机验证(软件点击兜底)】
|
||||
|
||||
- **现象**:2026-11-14 18:45:32 起同一屏「确认」连点 5 分钟,`选择藏品识别次数剩余` 走到 **-160**。
|
||||
- **证据**:18:48:41 弹窗「拟伤虫」、18:49:50 弹窗「又小又可能很坏的玩偶」——内容变了但没退出;
|
||||
手动点 `(640,530)` 一次就进到卡包页。AALC 点的是 `(602,525)`。
|
||||
- **根因(两条叠加)**:
|
||||
1. 点击落点与按钮实际位置有偏差(模板匹配点是勾号,按钮中心在右约 38px);
|
||||
2. V1.6.1 把计数挪到循环顶部,但 `if loop_count < 0: break` 仍在循环底部,
|
||||
上面的 `if click_element(确认): continue` 每次绕过它 → 计数再负也不退出。
|
||||
- **修法(云端 2026-11-15)**:`install_gift_confirm_guard` 包在 `click_element` 这一层(开局循环和镜牢主循环都管):
|
||||
确认模板连续第 3 次命中起改点按钮中心(勾号中心 + 76×set_win_size/1440,720 下就是 602→640);
|
||||
连续 20 次还在就记 `[ERROR]`、抛 `TaskAbort` 结束任务(退出码 4)。别的东西点成功、确认找不到、
|
||||
或两次命中隔 60 秒以上都清零。没用回车:没有证据说明游戏认回车。
|
||||
单测执行上游真实的 `select_init_ego_gift`:不加补丁无限空转,加了第 3 次就过。
|
||||
- **验证方式**:下一局从大厅开跑(会经过开局饰品页),看是否 30 秒内过。
|
||||
|
||||
### I-07 事件选项表覆盖不足 【部分补齐,待数据】
|
||||
|
||||
- **现象**:11-14 21:22 那局 17 条事件里 **15 条 `not_in_table`**;6 连刷首局同样在报。
|
||||
- **未收录样本**(可直接补表):
|
||||
| 选项 1 | 选项 2 |
|
||||
|---|---|
|
||||
| 摘下一朵花 | 扯断棘蔓 / 获得EGO饰品偏见 |
|
||||
| 带走这幅画 | 留下这幅画 / 获得EGO饰品归途 |
|
||||
| 告诉它你们很乐意听些故事 | 不听故事离开 |
|
||||
- **下一步**:从零协汉化 `ActionEvents_*.json` 里按事件 id 补 `event_choices.json`;
|
||||
需要"哪一项更优"的结论,否则只能保持交给 AALC 原逻辑(永远选第一个)。
|
||||
- **云端 2026-11-15**:上面三条已补(表 6 → 9 条),结果按 wiki.gg 条目核对:
|
||||
蜘蛛巢 901028 选「摘下一朵花」(饰品「偏见」;另一项 50% 判定、成败都有全体损失);
|
||||
归乡路途 901039 选「告诉它你们很乐意听些故事」→ 第二段 90103901 选「带走这幅画」(饰品「归途」,
|
||||
正是商店必买之一;其余走法降 15~30 理智)。全部 9 条按本机装的零协 release `2026111301` 重新核对唯一性
|
||||
(地狱鸡两条在 `ActionEvents.json` 有选项、结果都相同的复刻,一起命中、选同一项)。
|
||||
- **还要的数据**:其余 `not_in_table` 事件的选项文字。`decisions.jsonl` 里 `event/not_in_table` 那几行带
|
||||
`options`,整行带回来就能补;6 连刷的也要。
|
||||
|
||||
### I-08 卡包权重表没有内容 【已实机验证(按体系加分)】
|
||||
|
||||
> 2026-11-15 云端:不改 `theme_pack_list.yaml`,选卡包时按当局体系临时加分,见 R-01。
|
||||
|
||||
- **现象**:`theme_pack_list.yaml` 几乎全是 0(仅 `chick: 1`),`preferred_thresholds: 0`
|
||||
→ 所有卡包并列最高分 → 每次取最左边;第 5 层五个包全 `-5` → 落 `unknown`。
|
||||
- **证据**(11-14 19:03 局 decisions):
|
||||
```json
|
||||
floor2 工坊 0 / floor3 宅邸 0 / floor4 落的忧 0
|
||||
floor5 unknown -5 weights=[伏行-5, 落的忧0, 骨断-5, 紫罗兰-5, 空转-5]
|
||||
```
|
||||
- **下一步**:见需求 R-01。
|
||||
|
||||
### I-09 拉取后不重启 MCP 服务,新代码不生效 【记录】
|
||||
|
||||
- **现象**:11-14 第一局没生成 `decisions.jsonl`。
|
||||
- **根因**:`TaskRunner` 在常驻服务进程里设 `LCP_DECISIONS`,服务还是旧代码。
|
||||
- **做法**:每次 `git pull` 后 `Stop-ScheduledTask/Start-ScheduledTask LcMCPServer`。
|
||||
|
||||
### I-10 商店"按名字购买"命中率样本太少 【观察】
|
||||
|
||||
- **现象**:11-14 21:22 局 7 次购买点击里只有 1 次 `按名字找到`。
|
||||
- **判断**:必买 5 件本身出现率低(缘分残片/卡蜜拉/采血包/归途/石版字符),不是实现问题。
|
||||
- **下一步**:攒 6 连刷的 `shop/name_match` 计数再判断。
|
||||
|
||||
### I-11 AALC V1.6.1 僵尸进程误杀风险 【观察】
|
||||
|
||||
- 上游 `fb2ef56`:进程起来 180 秒没窗口就杀掉重启,窗口标题被改/被隐藏时会误杀。
|
||||
- 本机窗口标题一直是 `LimbusCompany`、常驻可见,暂未触发。
|
||||
|
||||
### I-12 汉化更新到 2026111301 【记录】
|
||||
|
||||
- 11-14 08:07 完成:旧包 2026101602 → 新包 2026111301(2385 文件,SHA256 全一致,
|
||||
2384 个 JSON 全部可解析),字体沿用 `Font/Context/ChineseFont.ttf`。
|
||||
- 备份:`D:\codex\_limbus_l10n_dl\backup-LLC_zh-CN-2026101602`。
|
||||
|
||||
### I-13 「入场前切队」补丁复查(`5992827`) 【已修待验】
|
||||
|
||||
云端复查本机提交的入场切队/选队页守卫,改了三处:
|
||||
|
||||
1. **每轮多跑一次整屏 OCR**:包装在 AALC 每次问「进入」时都先 OCR 判断是不是选队页;镜牢主循环和
|
||||
`road_to_mir` 几乎每轮都会问。改成先用模板确认「进入」真在画面上(找不到照上游返回 False),再 OCR。
|
||||
2. **选队页重试没重新截图**:`_select_team_by_name` 等选队页加载的 3 次都在认同一张截图。改成每次重新截图。
|
||||
3. **切不过去会每轮重翻**:入场前切队失败后,上游下一轮再点「进入」又从头翻一遍列表(每次最多十几屏)。
|
||||
改成记 `[ERROR] [lc_mcp] 入场前没切到 …, 本局按游戏当前编队进入`,本局不再重试,下一局重新试。
|
||||
|
||||
另:测试文件里 `if __name__ == '__main__'` 挪到末尾(原来夹在中间,直接运行会漏掉后面的用例)。
|
||||
|
||||
---
|
||||
|
||||
### I-14 前台被抢/窗口被遮挡时点击会丢 【记录/操作注意】
|
||||
|
||||
- **现象**:2026-11-15 12:29 的截图里,DSH 聊天窗口正好盖住镜牢弹窗按钮区域(按钮中心 640,532 落在浏览器面板内);同一天出现过"连点 20 次点不掉"。
|
||||
- **证据**:把游戏窗口切到前台后,同一点击位置手动点 2 次就关掉了。
|
||||
- **做法**:跑团期间不要把浏览器/聊天窗口拉到游戏前面。AALC 每次点击前会 setForegroundWindow,但抢回前台的窗口仍会让点击落到别处。
|
||||
- **可选加固**:驱动代理在点击失败率高时增加"点前再确认一次前台"重试(未实现)。
|
||||
|
||||
---
|
||||
## 二、需求清单
|
||||
|
||||
### R-01 卡包按队伍体系选 【已实现,待验】
|
||||
|
||||
- **来源**:用户 2026-11-14「卡包选择也有问题」→ 选 A「按体系配(充能队 → 优先带充能饰品的包)」。
|
||||
- **现状**:权重表全 0,等于没配(I-08)。
|
||||
- **卡点**:本地没有"卡包 → 饰品体系"对照表;`MirrorDungeonTheme-1.json` 只有 id 和名字,
|
||||
`EGOgift_*.json` 只有饰品名/描述,两者不关联;web 搜索在本机不可用(缺 API key)。
|
||||
- **可选实现**:
|
||||
- A1(省事):用户直接给包名优先级,写进 `theme_pack_list.yaml`;
|
||||
- A2(准):进卡包页后逐个点开,OCR 右侧"可获得 E.G.O 饰品"名字,按体系关键词打分再选
|
||||
(每层多 ~10 秒,需一轮实机调)。
|
||||
- **验收**:一局里 ≥3 层的卡包选择理由不是"并列最高分取第一个",`decisions.theme_pack` 的
|
||||
`weights` 有明显区分度。
|
||||
- **云端 2026-11-15 实现**:
|
||||
- **数据**:边狱巴士 BWIKI(`wiki.biligame.com/limbuscompany`)查过,699 个页面里没有卡包条目(只有镜像地牢 1/2
|
||||
时期的事件页),站内搜「卡包」「电闪雷鸣」都是 0 条;B 站的体系卡包攻略都是视频。改用 wiki.gg 的结构化数据:
|
||||
122 个卡包条目的出现楼层、专属饰品,「Featured Gifts」用的饰品分类(体系名 = 体系包),加上 `Module:EgoGift/data`
|
||||
里每件饰品的体系。中文名用零协 `MirrorDungeonTheme-1.json` 按 id 对上,122 个全对上。
|
||||
生成脚本 `scripts/build_theme_pack_systems.py`,结果 `lc_mcp/data/theme_pack_systems.json`。
|
||||
- **规则**:体系包、或该体系专属饰品 ≥3 件 +6;2 件 +4;1 件 +1。加在 AALC 原权重上(普通模式下 WARP快车谋杀案
|
||||
-5 → 充能队 1、开店抢购 -3 → 1;困难模式电闪雷鸣/动力渐盈 0 → 6)。AALC 的短键(「谋杀」)同时命中原版和复刻时取较小的
|
||||
加分,复刻分更高就另加全名键排在前面。每层选卡包时打一行 `卡包按体系 X 加分: …`,选中加过分的卡包时审计带 `system_bonus`。
|
||||
- **社区攻略(用户要求「查体系卡包攻略」)**:云端访问灰机 wiki 一律 403,改用本机 codex CLI 联网检索(Steam 指南、
|
||||
OurPlay、GameMale、TapTap、B 站专栏的文字攻略),记录在 `docs/feedback/2026-11-15/theme-pack-research.md`。
|
||||
并进表的 `community`:按体系推荐的卡包 +6(如充能 WARP/憎恶与绝望/绞丝结线,突刺 赌徒→去·海·边→当贯之物→20区的奇迹,
|
||||
呼吸 地狱鸡/句点/20区的奇迹);速刷拖时间的被遗忘者们、自动工厂、当碎之物所有体系 -3;琥珀色的黄昏对流血不加分。
|
||||
加分只看当前难度会出现的卡包,活动专用包、困难才有的复刻不会挡住普通模式的短键。
|
||||
- **注意**:这会让队伍去打 AALC 原本避开(-5)的剧情包,单局可能更慢;表里 `bonus` 可调,`LCP_THEME_PACK_SYSTEMS=0` 关。
|
||||
- **检索附带发现**:当前赛季是 S8「西西弗之镜」;善意的巡礼活动已结束、卡包已移除(表里留着无害)。
|
||||
|
||||
### R-02 事件选项表扩充 【进行中】
|
||||
|
||||
- **来源**:I-07。
|
||||
- **验收**:6 连刷里 `event/not_in_table` 占比 < 30%;新增条目至少有 1 条实机命中记录。
|
||||
- **进度**:2026-11-15 云端补 3 条(见 I-07),等 `not_in_table` 的完整选项行。
|
||||
|
||||
### R-03 键盘寻路策略定稿 【已实现 B,待验】
|
||||
|
||||
- **来源**:I-05。选项 A(关掉)/ B(失败后停用)。
|
||||
- **2026-11-15 云端**:做了 B(连续 3 个节点进不去就停用到本次任务结束),同时修了疑似根因(按键扫描码/按住)。
|
||||
A 不需要改代码,仍可随时在 config 里关。
|
||||
|
||||
### R-04 开局饰品弹窗兜底 【已实现,待验】
|
||||
|
||||
- **来源**:I-06。
|
||||
- **验收**:从大厅开一局,30 秒内通过开局饰品页,日志无 `选择藏品识别次数剩余-*`。
|
||||
|
||||
### R-05 6 连刷(一次牢 9 箱子 × 6) 【进行中】
|
||||
|
||||
- **来源**:用户 2026-11-15 01:47「一次牢 9 箱子,刷六次先」。
|
||||
- **现状**:`task=mirror count=6`,01:50:49 起;首局已用「充能」队。
|
||||
- **回传**:跑完补局数、每局耗时、`errors`、`decisions.counts`。
|
||||
|
||||
### R-06 文档与会话交接 【已完成(本轮)】
|
||||
|
||||
- `docs/feedback/2026-11-14/README.md`(实测记录)、`HANDOVER.md`(云端对接)、
|
||||
`REGRESSION.md`(云端给的清单)、`REGRESSION-RESULTS.md`(本文件同目录,回归结果)、
|
||||
`docs/BACKLOG.md`(排期)、本台账。
|
||||
|
||||
### R-08 镜牢「兔子洞」速刷 【开发中,待实机校准】
|
||||
|
||||
- **来源**:用户 2026-11-15「开发一个兔子洞速刷的,你联合codex去搞」。
|
||||
- **是什么**:黑兽 - 卯 魁首 浮士德 + 浮士德的 E.G.O「空洞」(英文社区 Mao Hollow Faust)。普通「空洞」第一回合只叠弹孔不打人,
|
||||
每场第一回合**超频**(在 E.G.O 列表里长按卡片)用侵蚀「空洞」直接清场,之后放「填补空洞」。
|
||||
机制和超频操作按零协游戏文本 / 教程核实;编队、路线、星光、商店按 codex 检索到的 OurPlay / Reddit 攻略(见 RABBIT-HOLE.md 1.2)。
|
||||
- **实现**:`run_task(task="mirror", strategy="rabbit_hole")`;配置在 `lc_mcp/data/rabbit_hole.json`(编队名、E.G.O 名、长按点、
|
||||
第一回合超频、路线卡包加分)。长按点出厂未校准,未校准时只记 `[ERROR]`、照常 P+Enter;路线卡包加分照常生效。
|
||||
后期 Boss 换打法、按战斗换人做不到(AALC 没有这一步)。
|
||||
- **下一步**:Windows 端按 [`feedback/2026-11-15/RABBIT-HOLE.md`](feedback/2026-11-15/RABBIT-HOLE.md) 建编队、调 AALC 设置、量长按点、
|
||||
确认 5 件事、跑一局。
|
||||
- **验收**:一局里 `decisions.battle` 的 `overclock` + `ego` 占多数;每层选到路线卡包;单局用时接近攻略自报的 10~15 分钟。
|
||||
|
||||
### R-07 饰品三选一按体系关键词 【已实现,攒样本】
|
||||
|
||||
- 来源:BACKLOG P1-3,云端已实现并实机跑通 4 次(2 次命中)。
|
||||
- 待办:6 连刷里统计命中率;关键词表 `lc_mcp/data/gift_keywords.json` 可按需加词。
|
||||
@@ -0,0 +1,184 @@
|
||||
# 对接说明:镜牢选队(2026-11-14)
|
||||
|
||||
给**云端开发**看的交接文件。目标:云端改代码 → 我这边 `git pull` → 实机回归 → 回传结果。
|
||||
所以这里写清楚「改哪、别动哪、怎么验、验到什么程度算过」。
|
||||
|
||||
---
|
||||
|
||||
## 1. 仓库与运行环境
|
||||
|
||||
| 项 | 值 |
|
||||
|---|---|
|
||||
| 仓库 | `https://git.lingll.icu/yws/lc-mcp` |
|
||||
| 当前分支 | `codex/feedback-unattended-setup-20261004` |
|
||||
| 本机路径 | `D:\lc-mcp`(AALC 在 `vendor/aalc`,**submodule,不要改**) |
|
||||
| Python | `vendor\aalc\.venv\Scripts\python.exe`(3.13) |
|
||||
| 游戏 | `D:\SteamLibrary\steamapps\common\Limbus Company`(Steam build 26593955) |
|
||||
| 汉化 | `LLC_zh-CN` 2026111301(自定义语言,游戏基础语言 = 韩语,OCR 语言识别为 `zh_cn`) |
|
||||
| 分辨率 | 客户区 1280×720,`set_win_size: 720` |
|
||||
| 常驻服务 | 计划任务 `LcMCPServer`,`127.0.0.1:8765`,日志 `~/lc_mcp/server.log` |
|
||||
|
||||
**测试入口**(本机验证统一用这个,不要直接跑 `main.py`):
|
||||
|
||||
```powershell
|
||||
D:\lc-mcp\vendor\aalc\.venv\Scripts\python.exe -X utf8 -c "from lc_mcp import ..." # 单测
|
||||
# 实机:通过 MCP 工具 run_task mirror,或
|
||||
D:\lc-mcp\vendor\aalc\.venv\Scripts\python.exe -X utf8 -m lc_mcp.aalc_task mirror "{\"count\": 1}"
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 2. 本次改动(两个文件,均为增量,不改 vendor)
|
||||
|
||||
### `lc_mcp/aalc_patches.py`
|
||||
|
||||
新增一段(文件末尾,`install_default_battle_team` 之后):
|
||||
|
||||
```python
|
||||
SYSTEM_TEAM_NAMES = {...} # 体系(system 字符串) → 游戏内编队名元组
|
||||
TEAM_LIST_X_MAX / TEAM_LIST_Y_MIN / TEAM_LIST_Y_MAX # 左侧列表命中范围(客户区像素)
|
||||
TEAM_HEADER = (170, 520, 90, 150) # 顶栏队名位置,用来确认选中
|
||||
|
||||
_team_ocr(auto) -> [(text, x, y), ...] # 整屏 OCR 逐行结果(同名保留)清洗,不排序
|
||||
_in_list(x, y) / _in_header(x, y) # 区域判定
|
||||
_scroll_team_list(auto, direction, times, distance) # +1=回顶部, -1=往下翻
|
||||
_header_is(auto, names) / _wait_header(auto, names) # 顶栏确认(3 次 × 1.2s,归一后精确匹配)
|
||||
_select_team_by_name(auto, names, log, rounds=4) # 主流程,返回 bool
|
||||
install_system_team_selection(log=print) # 安装补丁,返回原始 select_battle_team
|
||||
```
|
||||
|
||||
### `lc_mcp/aalc_task.py`
|
||||
|
||||
- import 里加 `install_system_team_selection`
|
||||
- `run()` 里、`install_default_battle_team` 之后:
|
||||
|
||||
```python
|
||||
if task in ('mirror', 'all'):
|
||||
install_system_team_selection(log=log)
|
||||
```
|
||||
|
||||
### 挂载点为什么是 `tasks.mirror.mirror`
|
||||
|
||||
`tasks/mirror/mirror.py` 在模块顶部 `from tasks.teams.team_formation import ... select_battle_team`,
|
||||
之后 `select_mirror_team()` 用的是**模块全局名**。所以补丁必须替换
|
||||
`tasks.mirror.mirror.select_battle_team`;改 `tasks.teams.team_formation.select_battle_team` 对镜牢无效
|
||||
(日常本那条补丁 patch 的是 `scheme` 命名空间,两者互不影响)。
|
||||
|
||||
---
|
||||
|
||||
## 3. 接口契约(改的时候必须保住)
|
||||
|
||||
1. **`select_battle_team(num) -> bool`**:True = 已选中并确认在编队界面;False = 没选上,调用方会重试(最多 6 次)后抛 `unableToFindTeamError`。
|
||||
2. **不能有副作用**:补丁只点击,不写配置文件;`Mirror.__init__` 的包装只读 `team_setting`。
|
||||
3. **坐标空间**:一律按**客户区像素**(当前 1280×720)。缩放用 `cfg.set_win_size / 1440`,跟 AALC 其它地方一致。
|
||||
4. **`auto._run_ocr_for_text(my_crop=None)` 返回 `{text: [cx, cy]}`**:`cx/cy` 是 box 中心;同名文本会互相覆盖。只把它转成列表并不能找回被覆盖的那条——2026-11-14 复查起 `_team_ocr` 直接读 OCR 引擎的逐行结果(`module.ocr.ocr.run(auto.screenshot)`,同一引擎、同样取框中心),引擎导入不了才退回 dict。
|
||||
5. **不要用 `my_crop` 做界面裁剪**:实测裁剪坐标语义不可靠(裁 `(0,0,190,584)` 会读到右侧面板),统一「整屏 OCR + 坐标过滤」。
|
||||
6. **点完必须验顶栏**:只点不验会出现「日志说成功,其实没换队」。
|
||||
|
||||
---
|
||||
|
||||
## 4. 体系队名表(本机账号实际状态,2026-11-14 截图核对)
|
||||
|
||||
左侧编队列表,从上到下:
|
||||
|
||||
| 顺序 | 列表显示 | 说明 | `team_system` |
|
||||
|---|---|---|---|
|
||||
| 1 | 剧情关卡 | 剧情用预设 | — |
|
||||
| 2 | 斩击 | 打击体系队 | 7 |
|
||||
| 3 | 突刺 | 突刺体系队 | 8 |
|
||||
| 4 | 打击 | 打击体系队 | 9 |
|
||||
| 5 | 烧伤 | 烧伤体系队 | 0 |
|
||||
| 6 | 流血 | 流血体系队(**当前镜牢在用**) | 1 |
|
||||
| 7 | 震颤 | 震颤体系队 | 2 |
|
||||
| 8 | 破裂 | 破裂体系队 | 3 |
|
||||
| 9 | 沉沦 | 沉沦体系队 | 5 |
|
||||
| 10 | 呼吸法 | 呼吸体系队(代码里另有别名「呼吸」) | 4 |
|
||||
| 11 | 充能 | 充能体系队 | 6 |
|
||||
| 12+ | 编队#13 … 编队#40 | 默认名残留,未使用 | — |
|
||||
|
||||
> `#1`~`#12` 已不存在。任何按 `编队#N` 找队的逻辑在这个号上都会失败,这是本次问题的根。
|
||||
>
|
||||
> 队名改动后最好同步 `SYSTEM_TEAM_NAMES`。2026-11-14 起(BACKLOG P1-5)名字先归一(空白/全半角/`震颐`→`震颤` 等误读),
|
||||
> 精确匹配优先;没有精确匹配时接受这一屏**唯一**的「名字+后缀」(`流血队`),不做任意子串。顶栏确认仍只认精确。
|
||||
|
||||
---
|
||||
|
||||
## 5. 验证方法
|
||||
|
||||
> 下面 5.2/5.3 是最初选队补丁的回归。2026-11-14 云端交付的整轮(寻路、选队容错、饰品、事件、商店、审计、AALC V1.6.1)
|
||||
> 回归清单见 [REGRESSION.md](REGRESSION.md)。
|
||||
|
||||
### 5.1 单测(不需要游戏)
|
||||
|
||||
```powershell
|
||||
cd D:\lc-mcp
|
||||
vendor\aalc\.venv\Scripts\python.exe -m unittest discover -s tests -t tests -v
|
||||
```
|
||||
|
||||
本次新增 `tests/test_system_team_selection.py`,覆盖:映射表完整性、区域判定边界、
|
||||
`install_system_team_selection` 的挂载/回退行为(用假模块,不依赖 AALC/Windows)。
|
||||
|
||||
### 5.2 实机回归(需要游戏在运行)
|
||||
|
||||
```powershell
|
||||
# 1) 确认补丁挂上
|
||||
# 日志里应有:[lc_mcp] patch: 镜牢按体系名选队
|
||||
# 2) 起一局
|
||||
run_task(task="mirror", count=1)
|
||||
# 3) 看这几行
|
||||
# [lc_mcp] 镜牢体系 bleed -> 目标编队 流血
|
||||
# [lc_mcp] patch: 已按体系名选中编队 流血 (或「当前已经是编队 流血, 无需切换」)
|
||||
# [INFO] 楼层识别结果:当前为第1层
|
||||
```
|
||||
|
||||
### 5.3 验收清单
|
||||
|
||||
- [ ] `select_battle_team` 返回 True 后,顶栏队名 = 目标队名(截图为准,不看日志)
|
||||
- [ ] 连续两局:第二局走「已经是目标队,无需切换」分支
|
||||
- [ ] 把 `team_system` 改成 7(斩击)能选到「斩击」;改回 1 能选回「流血」
|
||||
- [ ] 目标名不存在时(例如临时改成 `编队#999`)能 4 轮内返回 False,不卡死、不乱点
|
||||
- [ ] 列表滚动后不会把队伍页留在错误位置(后续 `罪人编队` 步骤仍能正常执行)
|
||||
|
||||
---
|
||||
|
||||
## 6. 云端开发注意事项
|
||||
|
||||
- **不要改 `vendor/aalc`**:submodule 固定 commit,改了本地能跑、更新就丢。所有行为差异走 `lc_mcp/aalc_patches.py`。
|
||||
- **不要引入本机绝对路径**(`D:\...`、`C:\Users\YWS-HHH\...`);已有代码里 `LC_*` / `LCP_*` 环境变量是既有限制。
|
||||
- **失败要显式**:选队失败返回 False 让上层重试,不要静默 fallback 到 `编队#N`(这号没有 `#N`,会选中错的队)。
|
||||
- **日志格式**:沿用 `[lc_mcp] ...` 前缀,`task_status` 的 `errors` 扫描依赖 `[ERROR]`。
|
||||
- 新增依赖请加到 `pyproject.toml`,并确认 `uv sync` 后 `vendor/aalc/.venv` 能跑。
|
||||
|
||||
---
|
||||
|
||||
## 7. 拉取与回传
|
||||
|
||||
```powershell
|
||||
cd D:\lc-mcp
|
||||
git fetch origin
|
||||
git checkout <云端分支>
|
||||
git pull
|
||||
git submodule update --init --recursive
|
||||
vendor\aalc\.venv\Scripts\python.exe -m unittest discover -s tests -t tests
|
||||
# 实机回归 → 结果写回 docs/feedback/<日期>/
|
||||
```
|
||||
|
||||
我这边回归后会补:跑团日志、截图路径、验收清单勾选结果,以及新发现的问题。
|
||||
本轮要勾的清单在 [REGRESSION.md](REGRESSION.md),勾选结果在 [REGRESSION-RESULTS.md](REGRESSION-RESULTS.md),
|
||||
问题与需求台账在 [`docs/ISSUES.md`](../../ISSUES.md)。
|
||||
2026-11-15 云端按台账交付的下一轮清单在 [`../2026-11-15/REGRESSION.md`](../2026-11-15/REGRESSION.md)。
|
||||
|
||||
---
|
||||
|
||||
## 8. 部署:拉取后必须重启常驻服务
|
||||
|
||||
`TaskRunner` 在**常驻服务进程**里给任务子进程设 `LCP_DECISIONS` 等环境变量。
|
||||
只 `git pull` 不重启,子进程拿到的还是旧环境 → `decisions.jsonl` 不生成、`task_status.decisions` 为空。
|
||||
|
||||
```powershell
|
||||
Stop-ScheduledTask -TaskName LcMCPServer
|
||||
Start-ScheduledTask -TaskName LcMCPServer
|
||||
# 验证:Get-NetTCPConnection -LocalPort 8765 -State Listen
|
||||
```
|
||||
|
||||
2026-11-14 第一局就踩了这个:代码是新的、服务是旧的,`decisions.jsonl` 一直不落盘。
|
||||
@@ -0,0 +1,193 @@
|
||||
# 2026-11-14 汉化更新 + 镜牢选队根因与局内决策实测
|
||||
|
||||
本次两件事:**更新游戏汉化**,以及**把「镜牢一直选不上队」查清楚并修掉**。
|
||||
后半段顺带核了镜牢局内的四类决策(走位 / 卡包 / 饰品 / 商店),发现两处真实缺陷,一并记在
|
||||
[`BACKLOG.md`](../../BACKLOG.md) 里。
|
||||
|
||||
后续:云端按 [`REGRESSION.md`](REGRESSION.md) 交付了 9 个补丁,本机回归结果在
|
||||
[`REGRESSION-RESULTS.md`](REGRESSION-RESULTS.md);所有问题与需求统一记账在
|
||||
[`docs/ISSUES.md`](../../ISSUES.md)。
|
||||
|
||||
## 环境
|
||||
|
||||
| 项 | 值 |
|
||||
|---|---|
|
||||
| 系统 | Windows 10 Pro 19045,远程会话,无人值守 |
|
||||
| 游戏 | Steam 版 Limbus Company,`D:\SteamLibrary\steamapps\common\Limbus Company` |
|
||||
| 游戏版本 | 更新前 build `26318463`(1.118.1,11-05)→ 更新后 build `26593955`(11-14 08:20 落盘) |
|
||||
| 汉化 | `LimbusCompany_Data\Lang\LLC_zh-CN`,2026101602 → **2026111301** |
|
||||
| AALC | `vendor/aalc`(git submodule,未改源码) |
|
||||
| 运行方式 | MCP `run_task mirror`,AALC 子进程,前台点击 + 罗技驱动点击 |
|
||||
|
||||
## 一、汉化更新
|
||||
|
||||
上游:`LocalizeLimbusCompany/LocalizeLimbusCompany` release `2026111301`(2026-11-13 发布)。
|
||||
装法按官方手动流程:**干净重装**(移走旧 `LLC_zh-CN` → 解压新包到游戏根目录),字体包不随
|
||||
release 发布,单独从 `Fonts/LLCCN-Font.7z` 来(自 2025-04 未变,直接沿用旧文件)。
|
||||
|
||||
| 步骤 | 结果 |
|
||||
|---|---|
|
||||
| 旧包备份 | `D:\codex\_limbus_l10n_dl\backup-LLC_zh-CN-2026101602`(2350 文件 / 45.1 MB) |
|
||||
| 下载 | `LimbusLocalize_2026111301.zip` 6,080,228 B,SHA256 `E63782A0…6E14665` |
|
||||
| 解压 | 2385 个文件,全部 SHA256 与 zip 内一致(0 不匹配) |
|
||||
| JSON 校验 | 2384 个 JSON 全部可解析,0 空文件 |
|
||||
| 字体 | `Font\Context\ChineseFont.ttf` 22.8 MB,TTF 头 `00 01 00 00` 正常 |
|
||||
| 配置 | `Lang\config.json` 未动,仍 `"lang": "LLC_zh-CN"` |
|
||||
|
||||
相对旧版新增:`walpu10` 系列事件/敌人/EGO、`Mirror8` 成就与卡包、`StoryData E100X–E103X`、
|
||||
新人格语音(`P10316/P10617/P10717/P11017/P11116`)、`SynergyKeyword`、`EventVerificationUIText` 等 35 个文件。
|
||||
|
||||
> 注:游戏第一次启动时弹「当前游戏客户端不是最新版本」,必须先更 Steam 客户端;更完再跑就正常了。
|
||||
|
||||
## 二、镜牢选队:为什么一直「选不上」
|
||||
|
||||
### 症状
|
||||
|
||||
`run_task mirror` 后 AALC 卡在选队:每 5 秒对左侧列表 OCR 一次,页码一路往上爬,然后重来。
|
||||
|
||||
```text
|
||||
08:34:27 开始执行 寻找队伍
|
||||
08:34:50 OCR: 编队#13 编队#14 编队#15 编#16
|
||||
08:35:00 OCR: 编队#19 编队#20 编队#21 …
|
||||
08:35:15 OCR: 编队#33 编队#34 编队#35 …
|
||||
08:37:00 又回到 编队#19 … ← 第 N 轮
|
||||
```
|
||||
|
||||
### 根因
|
||||
|
||||
`config.yaml` 里 `team_number: 1`,AALC 的 `select_battle_team()` 只会按
|
||||
`编队#N` / `TEAMS #N` 这个**字面名字**去 OCR 找队(`tasks/teams/team_formation.py:167`)。
|
||||
|
||||
而这个号的编队**是按体系命名的**,不是默认名;`编队#1`~`#12` 也已经不存在:
|
||||
|
||||
```text
|
||||
左侧列表(从上到下):
|
||||
剧情关卡
|
||||
斩击 突刺 打击 烧伤 流血 震颤 破裂 沉沦 呼吸法 充能 ← 10 支按体系命名
|
||||
编队#13 … 编队#40 ← 默认名残留
|
||||
```
|
||||
|
||||
所以找 `编队#1` 永远找不到 → 翻满 10 页 → 重试 6 轮 → `无法寻得队伍,请检查队伍名称是否为默认名称`。
|
||||
|
||||
### 修复
|
||||
|
||||
新增 `install_system_team_selection()`(`lc_mcp/aalc_patches.py`),在 `mirror`/`all` 任务里挂载。
|
||||
**不改 `vendor/aalc` 源码**,只替换 `tasks.mirror.mirror` 命名空间里的 `select_battle_team`:
|
||||
|
||||
```
|
||||
team_system → 队名
|
||||
0 烧伤 / 1 流血 / 2 震颤 / 3 破裂 / 4 呼吸法(兼容"呼吸")
|
||||
5 沉沦 / 6 充能 / 7 斩击 / 8 突刺 / 9 打击
|
||||
```
|
||||
|
||||
选队流程:
|
||||
|
||||
1. 先看顶栏是不是已经是这支队(是就直接返回,不动列表)
|
||||
2. 不是 → 点空白、把列表向下拖回顶部
|
||||
3. 整屏 OCR,只保留左侧列表区域(`x<260`,`300<y<640`)里的条目
|
||||
4. **精确匹配**队名 → 点击 → 轮询顶栏最多 3 次 × 1.2 s,顶栏变成该名字才算成功
|
||||
5. 没找到就往下翻(每次 3 拖),最多 4 轮;4 轮都失败返回 False,交给 AALC 原来那层重试
|
||||
|
||||
两个细节是踩出来的:
|
||||
|
||||
- **不能用 `my_crop`**:AALC 里裁剪坐标的语义跟客户区像素对不上(实测裁 `(0,0,190,584)` 会 OCR 出右侧面板的文字),所以改成整屏 OCR 再按坐标过滤。
|
||||
- **点完不能立刻判**:顶栏要 1~2 帧才刷新,实测 0.8 s 时还没变,1.2 s×3 才稳。
|
||||
|
||||
实测日志:
|
||||
|
||||
```text
|
||||
[lc_mcp] 镜牢体系 bleed -> 目标编队 流血
|
||||
[lc_mcp] 编队列表里找到 流血 @(130,492)
|
||||
[lc_mcp] patch: 已按体系名选中编队 流血
|
||||
[INFO] 楼层识别结果:当前为第1层
|
||||
[INFO] 此次选择卡包关键词:信仰
|
||||
```
|
||||
|
||||
(第二次跑因为上一次已经停在「流血」上,直接命中「当前已经是编队 流血, 无需切换」。)
|
||||
|
||||
## 三、局内四类决策:代码实际怎么走
|
||||
|
||||
| 决策 | 现状 | 代码位置 |
|
||||
|---|---|---|
|
||||
| 走位 | **被配置降级成瞎走**:`mirror_keyboard_simple_pathfinding: true` → 每层只按 ↑ 选最上面节点 | `mirror.py:1128` → `search_road.py:145` |
|
||||
| 卡包 | 规则明确:关键词权重表取最高,低于阈值就刷新(≤3 次) | `select_theme_pack.py` |
|
||||
| 饰品三选一 | **不看体系**:排白棉花 → 排「已持有」→ 拿第一张 | `mirror.py:1360` |
|
||||
| 商店 | 必买/必卖清单为 **0**(路径写错),只剩体系强化/刷新/合成/治疗 | `in_shop.py:157`、`tasks/mirror/__init__.py` |
|
||||
| 事件 | 固定:能「判定」就判定,然后永远点第一个选项 | `mirror.py:1230` |
|
||||
|
||||
### 3.1 走位
|
||||
|
||||
```python
|
||||
# search_road.py:145
|
||||
for attempt in range(2):
|
||||
auto.key_press("up")
|
||||
if _keyboard_enter_succeeded():
|
||||
return True
|
||||
```
|
||||
|
||||
关掉 `mirror_keyboard_simple_pathfinding` 才会走 Dijkstra(`search_road.py:735`),节点代价表
|
||||
(`search_road.py:609`,越小越优先):
|
||||
|
||||
| 节点 | 代价 |
|
||||
|---|---|
|
||||
| event | 1 |
|
||||
| shop | 2 |
|
||||
| battle | 4 |
|
||||
| boss / focused / abnormality | 6 |
|
||||
| risky_encounter | 7 |
|
||||
| 未知 | 999(不可达) |
|
||||
|
||||
### 3.2 卡包
|
||||
|
||||
`preferred_thresholds: 0`,权重表在 `theme_pack_list.yaml`(多数 0、`chick: 1`、未知 -5)。
|
||||
本次三次选择:`信仰` → `赌徒` → `情感懒`。
|
||||
|
||||
### 3.3 饰品三选一
|
||||
|
||||
`acquire_ego_gift()`:排除白棉花(除非 `not_skip_whitegossypium`)→ OCR「已持有 / Owned」→
|
||||
优先没持有的 → 都一样拿第一张。**没有任何体系判断**。
|
||||
|
||||
### 3.4 商店(真实缺陷)
|
||||
|
||||
`tasks/mirror/__init__.py` 用的是旧路径:
|
||||
|
||||
```python
|
||||
must_purchase_path = "./assets/images/share/mirror/shop/must_purchase"
|
||||
```
|
||||
|
||||
实际图片在 `./assets/images/default/share/mirror/shop/must_purchase/`,`assets/images/share` 不存在。
|
||||
运行时验证:
|
||||
|
||||
```
|
||||
must_purchase 0
|
||||
must_be_abandoned 0
|
||||
fusion_result 0
|
||||
```
|
||||
|
||||
本次日志实锤(进店 51 秒,一件没买):
|
||||
|
||||
```text
|
||||
10:03:03 开始执行 镜牢商店
|
||||
10:03:16 开始购买必买项
|
||||
10:03:54 结束执行 镜牢商店 耗时 00:00:51
|
||||
```
|
||||
|
||||
## 四、本次跑团(进行中记录)
|
||||
|
||||
```text
|
||||
09:39:53 task mirror start
|
||||
09:40:07 选队 → 流血(已是目标队,跳过切换)
|
||||
09:41:16 第1层
|
||||
09:54:33 第1层结束 13:07,卡包:赌徒
|
||||
09:55:20 寻路出错 → 自动重进镜牢,恢复
|
||||
10:03:54 第2层商店 51 秒(未购买,见 3.4)
|
||||
10:07:32 第2层结束 12:59,卡包:情感懒
|
||||
10:17:37 第3层战斗中
|
||||
```
|
||||
|
||||
## 五、仍未验证的边界
|
||||
|
||||
- 选队补丁只在「流血」上实测过;其它 9 个体系名未实跑(队列切换、`teams_active_queue` 轮转时尤其没验)。
|
||||
- 队名如果被改(比如改成「流血队」),补丁会失配 → 需要同步改 `SYSTEM_TEAM_NAMES`。
|
||||
- `my_crop` 语义不一致这件事只在这个界面验证过,别的界面不一定。
|
||||
- 关掉 `mirror_keyboard_simple_pathfinding` 后 Dijkstra 的稳定性没验(当初开它就是为躲鼠标拖地图卡死)。
|
||||
@@ -0,0 +1,87 @@
|
||||
# 2026-11-14 云端交付:实机回归结果
|
||||
|
||||
对应 [`REGRESSION.md`](REGRESSION.md)(云端给的清单)。本机:Windows 10、1280×720 客户区、
|
||||
游戏 build `26593955`、汉化 `2026111301`、AALC `2fcb1b4`(V1.6.1)。
|
||||
|
||||
## 1. 拉取
|
||||
|
||||
- [x] 单测全过:`Ran 641 tests ... OK`(云端 633;本地多加了选队守卫/队名偏好用例)
|
||||
- [x] `vendor/aalc` = `2fcb1b4`(`git -C vendor/aalc log --oneline -1` 已确认)
|
||||
|
||||
> ⚠️ **部署坑(新增)**:`TaskRunner` 在**常驻服务进程**里给子进程设 `LCP_DECISIONS`,
|
||||
> 服务不重启就用旧代码 → 第一局 `decisions.jsonl` 根本没生成。本轮已重启 `LcMCPServer`。
|
||||
> 以后每次 `git pull` 都要重启服务。
|
||||
|
||||
## 2. 任务开始时的日志
|
||||
|
||||
九行全部出现(云端七行 + 本次新增两行),没有 `挂不上` / `补丁跳过`:
|
||||
|
||||
```text
|
||||
[lc_mcp] patch: 镜牢按体系名选队
|
||||
[lc_mcp] patch: 入场前按体系切队伍
|
||||
[lc_mcp] patch: 选队页守卫(星之恩惠页忽略星级模板)
|
||||
[lc_mcp] patch: 镜牢键盘寻路按节点类型选方向(不拖地图)
|
||||
[lc_mcp] patch: 镜牢饰品选择按体系关键词排序(gift_keywords.json)
|
||||
[lc_mcp] patch: 镜牢事件按选项表选择(event_choices.json, 6 条)
|
||||
[lc_mcp] patch: 商店购买写入决策审计
|
||||
[lc_mcp] patch: 商店必买先按中文名找(shop_gifts.json, 5 个名字), 图标模板兜底
|
||||
[lc_mcp] patch: 卡包选择写入决策审计
|
||||
```
|
||||
|
||||
## 3. 逐项结果
|
||||
|
||||
| 项 | 结果 | 证据 |
|
||||
|---|---|---|
|
||||
| 选队 P1-5 | **通过**(补丁加"入场前切队"后) | `入场前切队伍: 充能/震颤` → `编队列表里找到 充能 @(131,455), 精确匹配 充能` → `已按体系名选中编队 充能`;同一局再次调用走 `当前已经是编队 充能, 无需切换` |
|
||||
| 寻路 P0-2 | **不通过(键盘方案在本机不可用)** | 24 次键盘尝试 **0 成功**、24 次回退;今早旧版也是 32/32 失败。说明这台机器方向键进节点本来就不可用,新补丁不是元凶,但每次多绕 3 个方向 ≈ 多 5 秒 |
|
||||
| 饰品 P1-3 | 部分通过(样本少) | 4 次三选一:2 次 `命中体系关键词`、2 次未命中(`gift/keyword` `gift/no_keyword` 各 2);三选一倒序复查处未再出现 |
|
||||
| 事件 P1-4 | 表覆盖不足 | 17 条事件,**15 条 `not_in_table`**;命中的 2 条按表走 |
|
||||
| 商店 P2-6 | 通过(样本少) | 7 次购买点击,1 次 `按名字找到`;必买清单上游已修(5/19/31 非空) |
|
||||
| 审计 P2-8 | 通过 | `task_status.decisions.counts` 正常:`event/gift/road/shop/theme_pack` 五类都有 |
|
||||
|
||||
### 3.1 选队为什么前四局全都没触发
|
||||
|
||||
不是名字问题,是**根本没走到选队**:
|
||||
|
||||
- 镜牢入场时 AALC 直接点 `mirror/road_to_mir/enter_assets.png`(「进入」),用游戏记住的上一支队;
|
||||
只有它先看到 `select_team_stars_assets.png` 才会调 `select_battle_team`。
|
||||
- 「星之恩惠」页满屏星星,**星级模板在该页也会命中** → AALC 以为到了选队页 → 6 次「不在编队界面」。
|
||||
- 我第一版守卫写成"必须有编队图标或 ≥3 个队名",选队页刚加载时两者都没渲染 → 真选队页被一起跳过
|
||||
(21:03 那局 35 秒直接进第 1 层)。
|
||||
|
||||
修法:守卫只否定「星之恩惠」页(出现"恩惠"才忽略星级模板);在点「进入」之前若检测到选队页且
|
||||
顶栏不是目标队,就先切队再进入。
|
||||
|
||||
### 3.2 选队扫描步长
|
||||
|
||||
旧版每轮连拖 3 次,实测**一次拖动就滚 5~6 行**,3 次直接跳过一整屏:
|
||||
|
||||
```text
|
||||
第 1 屏: 剧情关卡/斩击/突刺/打击/烧伤/流血
|
||||
第 2 屏: 编队#19..25 ← 中间「震颤/破裂/沉沦/呼吸法/充能」整屏被跳过
|
||||
```
|
||||
|
||||
改成每轮 1 次拖动、最多 6 轮;「充能」在第 2 屏被精确命中。
|
||||
|
||||
## 4. 本轮跑团记录
|
||||
|
||||
| 时间 | 任务 | 结果 |
|
||||
|---|---|---|
|
||||
| 09:39 | mirror ×1(升级前) | 完成 01:29:02(含 32/32 键盘回退) |
|
||||
| 18:44 | mirror ×1(V1.6.1 首跑) | **开局饰品弹窗死循环** 5 分钟,手动点一次才过,停 |
|
||||
| 19:03 | mirror ×1 | 手动停在第 5 层;decisions:event 16 / gift 4 / road 24 / shop 4 / theme_pack 4 |
|
||||
| 20:46 | mirror ×1 | 6 次「不在编队界面」,扫描读到星之恩惠页,停 |
|
||||
| 21:03 | mirror ×1 | 守卫过严 → 35 秒进第 1 层,没选队,停 |
|
||||
| 21:22 | mirror ×1 | **完成 00:55:23**(第1~5层 11:04/13:07/12:54/17:17);decisions:event 17(15 不在表)/ gift 4(2 命中)/ road 24 回退 / shop 7(1 按名字)/ theme_pack 4 |
|
||||
| 01:50 | mirror ×6 | 进行中(6 连刷,目标 9 箱子/次 × 6) |
|
||||
|
||||
## 5. 离线确认不了、本机也没验到的
|
||||
|
||||
- 键盘方向键"方向没路时会进到别的节点" —— 本机 0 成功,无法验证。
|
||||
- 事件 `???` 标签落在哪些选项 —— 24 小时样本里没遇到。
|
||||
- 商店普通/特殊布局是否一致 —— 未区分记录。
|
||||
- AALC V1.6.1 的"僵尸进程 180 秒误杀" —— 未触发(窗口标题正常、窗口一直可见)。
|
||||
|
||||
## 6. 关闭开关
|
||||
|
||||
本轮**没有**用 `LCP_*` 关任何补丁(除键盘寻路另议,见 [`../../ISSUES.md`](../../ISSUES.md) I-05)。
|
||||
@@ -0,0 +1,80 @@
|
||||
# 2026-11-14 云端交付:实机回归清单
|
||||
|
||||
分支 `codex/feedback-unattended-setup-20261004`,本轮提交 `5fdb9fd..d15f5a1`(9 个):
|
||||
P0-2 键盘寻路按节点类型、P1-5 选队容错、P1-3 饰品按体系关键词、P1-4 事件选项表、P2-8 决策审计、
|
||||
AALC 升到 V1.6.1、P2-6 商店按中文名购买,以及一轮复查修正。P0-1 上游已修,P2-7 不做。
|
||||
每项的做法与验收标准见 [`docs/BACKLOG.md`](../../BACKLOG.md)。
|
||||
|
||||
## 1. 拉取
|
||||
|
||||
```powershell
|
||||
cd D:\lc-mcp
|
||||
git fetch origin
|
||||
git checkout codex/feedback-unattended-setup-20261004
|
||||
git pull
|
||||
git submodule update --init --recursive # AALC 升到 2fcb1b4(V1.6.1),这一步不能省
|
||||
git -C vendor/aalc log --oneline -1 # 应是 2fcb1b4
|
||||
vendor\aalc\.venv\Scripts\python.exe -m unittest discover -s tests -t tests
|
||||
```
|
||||
|
||||
- [ ] 单测全部通过(云端 Linux 是 633 个)
|
||||
- [ ] `vendor/aalc` 在 `2fcb1b4`。没更新的话事件表补丁会记 `[ERROR] ... 挂不上` 并跳过
|
||||
|
||||
## 2. 任务开始时的日志
|
||||
|
||||
`run_task(task="mirror", count=1)` 启动后,日志里应有:
|
||||
|
||||
```text
|
||||
[lc_mcp] patch: 镜牢按体系名选队
|
||||
[lc_mcp] patch: 镜牢键盘寻路按节点类型选方向(不拖地图)
|
||||
[lc_mcp] patch: 镜牢饰品选择按体系关键词排序(gift_keywords.json)
|
||||
[lc_mcp] patch: 镜牢事件按选项表选择(event_choices.json, 6 条)
|
||||
[lc_mcp] patch: 商店购买写入决策审计
|
||||
[lc_mcp] patch: 商店必买先按中文名找(shop_gifts.json, 5 个名字), 图标模板兜底
|
||||
[lc_mcp] patch: 卡包选择写入决策审计
|
||||
```
|
||||
|
||||
- [ ] 七行都在
|
||||
- [ ] 没有带 `挂不上` 或 `补丁跳过` 的 `[ERROR]`(上游写法和补丁对不上时才会出现)
|
||||
|
||||
## 3. 跑完一局后逐项看
|
||||
|
||||
| 项 | 日志里找 | 怎么判断对不对 |
|
||||
|---|---|---|
|
||||
| 选队 P1-5 | `已按体系名选中编队 流血`,或 `当前已经是编队 流血, 无需切换` | 顶栏队名以截图为准。**连跑两局**,第二局应走「无需切换」:这正是复查修的顶栏与列表同名被覆盖 |
|
||||
| 寻路 P0-2 | `键盘寻路: 下一列 …` 和 `键盘寻路: 进入 X 方向的 <类型>` | 日志说的类型 = 实际进去的节点。频繁出现 `退回按 ↑` 时记下前面那行原因 |
|
||||
| 饰品 P1-3 | `饰品选择(体系 …): 第1张=… ; 命中体系关键词, 先看第N张` | 实际拿到的是第 N 张(白棉花、已持有除外)。**三张卡**时尤其要看,复查修过倒序 |
|
||||
| 事件 P1-4 | `事件 <名>: 1=… \| 2=…; 按表选第 N 项「…」` | 点的就是那一项。没收录的事件会打 `事件选项: …; 表里没有这个事件, 交给 AALC`,把这些行带回来补表 |
|
||||
| 商店 P2-6 | `商店: 按名字找到「…」, 点它的图标` | 只在缘分残片/卡蜜拉/采血包/归途/石版字符出现时才有;确认真的买到了。钱不够时同一个名字最多点 4 次 |
|
||||
| 审计 P2-8 | `task_status` 的 `decisions.counts` | 应有 `team`、`theme_pack`、`gift`;走过键盘寻路有 `road`;碰到才有 `event`、`shop` |
|
||||
|
||||
- [ ] 选队(含连跑第二局)
|
||||
- [ ] 寻路
|
||||
- [ ] 饰品
|
||||
- [ ] 事件(本局没遇到表里的事件就记"未遇到")
|
||||
- [ ] 商店(同上)
|
||||
- [ ] 审计计数
|
||||
|
||||
## 4. 离线确认不了、要重点看的
|
||||
|
||||
- 键盘寻路:方向上没有路时按这个方向键,不会进到别的节点。
|
||||
- 事件:选项文字和选项框左边缘在同一行(`EVENT_OPTION_ROW`);`???` 标签落在哪些选项上。
|
||||
- 商店:普通商店与特殊商店截图的布局一致;钱不够时上游会在购买框开着时重点商品,按名字重点的那几下落在框上应无害。
|
||||
- AALC V1.6.1:游戏进程起来 180 秒还找不到窗口(`UnityWndClass` + 配置里的游戏标题)会被当成僵尸进程杀掉重启,
|
||||
AALC 日志里是 `发现无窗口的僵尸游戏进程`。窗口标题改过或窗口被隐藏时会误杀。
|
||||
|
||||
## 5. 出问题时
|
||||
|
||||
某项先关掉再跑(设在启动 MCP 服务的环境里,任务子进程继承):
|
||||
|
||||
| 变量 | 关掉什么 |
|
||||
|---|---|
|
||||
| `LCP_TYPED_ROAD=0` | 键盘寻路按类型,回到只按 ↑ |
|
||||
| `LCP_GIFT_KEYWORDS=0` | 饰品按体系关键词排序 |
|
||||
| `LCP_EVENT_CHOICES=0` | 事件选项表 |
|
||||
| `LCP_SHOP_NAMES=0` | 商店按中文名购买(图标模板照旧) |
|
||||
|
||||
## 6. 回传
|
||||
|
||||
结果写回 `docs/feedback/<日期>/`:任务日志 `~/lc_mcp/runs/task_*.log` 和同名 `task_*.decisions.jsonl`、
|
||||
相关截图、本清单的勾选结果,以及新发现的问题。
|
||||
@@ -0,0 +1,93 @@
|
||||
# 镜牢「兔子洞」速刷:开发与实机校准(2026-11-15)
|
||||
|
||||
用户需求:「开发一个兔子洞速刷的」。台账 [`docs/ISSUES.md`](../../ISSUES.md) R-08。
|
||||
|
||||
## 1. 「兔子洞」是什么
|
||||
|
||||
### 1.1 机制(零协游戏文本,release 2026111301,已核实)
|
||||
|
||||
| 项 | 内容 | 依据 |
|
||||
|---|---|---|
|
||||
| 叫法 | 中文社区「兔子洞」= 兔浮 + 空洞;英文社区「Mao Hollow Faust」 | codex 联网检索;YouTube 葡语视频标题「O novo método MAIS BARATO E MAIS RÁPIDO de farm Mirror Dungeon (Mao Hollow Faust)」 |
|
||||
| 人格 | id 10212「黑兽 - 卯 魁首 浮士德」 | `Personalities.json` |
|
||||
| E.G.O | id 20211「空洞」(浮士德专属;默尔索另有一个同名的 20510,攻略里也用) | `Egos.json` |
|
||||
| 普通「空洞」 | **不打敌人**(不会命中敌方单位),给自己叠 5 发弹孔、呼吸、充能;本场首次使用打折。自身弹孔不低于 1 发时改用「填补空洞」:每发弹孔拼点威力 +2,硬币最多重复 4 次,只打一个目标时伤害 +100% | `Skills_Ego_Personality-02.json` 2021111 / 2021112 |
|
||||
| 侵蚀「空洞」 | **随机指定目标直接打**;弹孔满 5 发时耗光弹孔,下回合全队加攻击 | 同上 2021121 |
|
||||
| E.G.O 被动「排离空洞」 | 弹孔 5 发时「空洞」(觉醒、侵蚀)不耗 E.G.O 资源;回合开始 +1 发弹孔;友方击杀回 5 理智 | `Passive_Ego.json` 2021111 |
|
||||
| 怎么放 E.G.O | 游戏教程「按住罪人的头像以打开其 E.G.O 列表」(wiki.gg 写的是按住技能格);资源不够的是灰的;再选一次是取消 | `TutorialRenewalDesc.json` tuto_01_09_01_02;[wiki.gg E.G.O/Gameplay](https://limbuscompany.wiki.gg/wiki/E.G.O/Gameplay) |
|
||||
| 超频 | 「在战斗中选择 E.G.O 技能时,可以**长按 E.G.O** 来使用 E.G.O 超频」:强制用侵蚀技能,1.5 倍 E.G.O 资源和理智。资源够 1.5 倍是**稳定超频**(只打敌人),不够是**不稳定超频**(不分敌我,缺的资源扣成负数);普通状态的资源都不够时不能超频 | `TutorialMainUIText.json` tutorial_mainui_04_egoinfo_page_05_desc_01~03;`TutorialDesc0-4.json` tutorial_ego_overclock_1~6 |
|
||||
|
||||
所以「第一回合超频」是关键:普通「空洞」第一回合只叠弹孔不打人,超频的侵蚀「空洞」第一回合就能清场。
|
||||
|
||||
### 1.2 攻略(codex 检索,玩家攻略,未实机验证)
|
||||
|
||||
两份文字攻略,做法不完全一样:
|
||||
|
||||
| 项 | OurPlay [777774](https://www.ourplay.net/planet/thread/777774)(中文,针对「新牢更新」) | Reddit [1x8zr65](https://www.reddit.com/r/LimbusCompanyHelp/comments/1x8zr65/help_me_with_most_time_efficient_md_run/) |
|
||||
|---|---|---|
|
||||
| 编队 | 兔浮 + 四破「空洞」、任意高等级默尔索 + 四破「空洞」、七协会李箱 + 四破「凶弹」,另备 2~3 个弱突刺人格;按战斗换人,不是全程单通 | 兔浮 + 一名高检定角色(作者用小指辛克莱) |
|
||||
| 每场操作 | 前期每战**第一回合超频(侵蚀)「空洞」**,残血敌人靠弱突刺队友和「鸡线」补刀;后期部分 Boss:第一回合普通「空洞」,默尔索用「空洞」拦截打向浮士德的攻击,第二回合浮士德再放;三层起也可换李箱「凶弹」 | 战斗节点直接超频「空洞」 |
|
||||
| 难度 / 路线 | 全程困难:1 层赌徒 → 2 层鸡包 → 3 层海边 → 4 层绝望 → 5 层二号线(变体:绝望提前;末层三号线 / 二十区奇迹复刻);避开加太多生命、减伤的苦难;鸡包别走经济最多的路线 | 前三层普通、四五层困难;优先事件,避开黄色警戒圈节点 |
|
||||
| 星光 / 开局 | 尽量 120 星光开局,加护选 1、3,不勾星光换经济;初始饰品烟斗 / 石冢,观测「王座、鸡线」 | 加护 1、3 不升级;初始 Torn Bandolier,找 Grand Welcome、Sharp Needle & Thread |
|
||||
| 商店 | 买呼吸或三级饰品,优先合呼吸石,再考虑沉沦石、水瓶、止水;后期给浮士德、默尔索回理智 | 买三级饰品、升满 Bandolier,给检定角色补满理智 |
|
||||
| 单局用时 | 约 11 分钟(自报) | 混合难度约 10 分钟,全困难约 15 分钟 |
|
||||
|
||||
- 「空洞」三破能起步,但 4 层起会变慢,推荐四破([Reddit 1x4hhd8](https://www.reddit.com/r/LimbusCompanyHelp/comments/1x4hhd8/who_do_i_shardshould_i_threadspin_hollow_faust_ego/))。
|
||||
- **未找到**:是否先按 P、资源不够时怎么补救、长按哪个键加速动画;本赛季(S8「西西弗之镜」)是否仍有效、有没有被削弱。
|
||||
- 读不到:Reddit 1x74sok、YouTube g9DPhija_LU 的正文。
|
||||
|
||||
## 2. 实现(默认不启用)
|
||||
|
||||
```text
|
||||
run_task(task="mirror", count=1, strategy="rabbit_hole")
|
||||
```
|
||||
|
||||
配置都在 `lc_mcp/data/rabbit_hole.json`:
|
||||
|
||||
| 字段 | 出厂值 | 作用 |
|
||||
|---|---|---|
|
||||
| `team_names` | `["兔子洞"]` | 选队不按体系名,按这个编队名选 |
|
||||
| `ego_names` | `["空洞"]` | E.G.O 列表里要找的名字(归一后完全相等) |
|
||||
| `press_at` | `null` | 长按打开 E.G.O 列表的点(客户区宽、高比例),**必须实机量** |
|
||||
| `hold_seconds` | `1.0` | 长按时长(AALC 松开前还会多按 0.5 秒);长按头像、超频长按卡片都用它 |
|
||||
| `overclock_first_turn` | `true` | 每场战斗第一回合长按卡片(超频),之后单击 |
|
||||
| `theme_packs` | 赌徒 / 地狱鸡 / 去·海·边 +10,憎恶与绝望 +12,2号线 +10 | 攻略路线上的卡包加分,加在 AALC 原权重上,没有体系也加 |
|
||||
|
||||
- **每回合**(替换 AALC 的 `Battle._battle_operation`):按 P(胜率)→ 长按 `press_at` → OCR 找列表里的「空洞」→
|
||||
第一回合长按(超频)、其余回合单击 → 按 Enter。日志 `[lc_mcp] 兔子洞: …`,审计 `battle/hollow` 记
|
||||
`overclock`(超频放上了)/ `ego`(单击放上了)/ `ego_unavailable`(列表还开着,多半资源不够)/ `no_option`(没弹出列表或没认出「空洞」)。
|
||||
按过 P 就一定按 Enter:交回 AALC 会再按一次 P,而 P 在胜率/伤害之间切换。
|
||||
「第一回合」用 AALC 自己的 `first_turn`(看到战斗播片之前都算第一回合);上游去掉这个参数时记 `[ERROR]`,只放普通「空洞」。
|
||||
- **卡包**:路线卡包的加分和「卡包按体系加分」走同一个补丁,日志 `卡包按体系 (无)+兔子洞路线 加分: …`。按 AALC 默认权重
|
||||
(困难 + 中文)模拟,每层选到的依次是 赌徒 → 地狱鸡 → 去·海·边 → 憎恶与绝望 → 2号线(AALC 自己给 10 分的隐藏包凤·皇除外)。
|
||||
憎恶与绝望多加 2 分,是因为它和 2号线都能在 4 层出现,AALC 原分都是 -5。`LCP_THEME_PACK_SYSTEMS=0` 时一起关掉。
|
||||
- **没校准时**:`press_at` 为 `null`(出厂就是),不点任何东西,记一条 `[ERROR]`,照 AALC 原来的 P+Enter 打;卡包加分照常。
|
||||
- **做不到的**(需要识别 Boss、按战斗换人,超出 AALC 现有流程):后期 Boss 第一回合改普通「空洞」、默尔索拦截、换李箱「凶弹」、
|
||||
按战斗换上弱突刺补刀。星光、加护、初始饰品、难度在 AALC 自己的设置里调。
|
||||
|
||||
## 3. Windows 端要做的(按顺序)
|
||||
|
||||
1. **准备编队和 AALC 设置**:
|
||||
- 游戏里建一个叫「兔子洞」的编队:「黑兽 - 卯 魁首 浮士德」+「空洞」(最好四破),能上的话加默尔索 +「空洞」、七协会李箱 +「凶弹」。
|
||||
记下账号有没有这些、各自的破数。
|
||||
- AALC:镜牢用的队伍指向这个编队;困难模式打开(攻略全程困难);加护 1、3;初始饰品按攻略(烟斗 / 石冢)能选就选。
|
||||
2. **量长按点**:开一场镜牢战斗,停在回合界面(不要点开始):
|
||||
1. `keypress p`,再 `get_state` 截图;
|
||||
2. 先试浮士德的**头像**(游戏教程的说法),不弹列表再试她那一列上面的技能格;记客户区坐标 `(x, y)` 和客户区大小 `(w, h)`;
|
||||
3. 用 `drag`(起点 = 终点 = `(x, y)`)长按,确认弹出 E.G.O 列表、里面有「空洞」;
|
||||
4. 把 `press_at` 写成 `[x/w, y/h]`(保留 3 位小数),提交推回。
|
||||
3. **确认这几件事**(截图 + 一句话结论):
|
||||
- 先按 P 再选「空洞」,按 Enter 后浮士德确实放了「空洞」(没被 P 覆盖);
|
||||
- 在列表里**长按**「空洞」卡片是不是超频(卡片或技能变成侵蚀样式),松手后列表是否关掉;
|
||||
- 技能面板的列顺序每回合是否固定(浮士德是不是一直在同一列;队友阵亡后会不会挪位);
|
||||
- 资源不够时「空洞」是不是灰的、点了是否没反应;点客户区左上角 `(1,1)` 能不能关掉列表;
|
||||
- 第二回合起列表里显示的名字是「空洞」还是「填补空洞」(`ego_names` 要不要加「填补空洞」)。
|
||||
4. **跑一局**:`run_task(task="mirror", count=1, strategy="rabbit_hole")`。看:
|
||||
- 日志里的 `兔子洞:` 行;`task_status` 的 `decisions.counts.battle`:`overclock` + `ego` 应占多数;
|
||||
- `卡包按体系 (无)+兔子洞路线 加分` 行和 `decisions.theme_pack`:每层是否选到路线卡包;
|
||||
- 单局用时(攻略自报 10~15 分钟)。
|
||||
|
||||
## 4. 回传
|
||||
|
||||
写回 `docs/feedback/<日期>/`:回合界面截图、长按后的 E.G.O 列表截图、超频长按后的截图、量出来的 `press_at`、
|
||||
第 3 步各项结论、一局的任务日志、`decisions.jsonl` 和单局用时。
|
||||
@@ -0,0 +1,114 @@
|
||||
# 2026-11-15 实机:6 连刷 + 键盘/卡包/弹窗/驱动点击
|
||||
|
||||
接 [`../2026-11-14/REGRESSION-RESULTS.md`](../2026-11-14/REGRESSION-RESULTS.md),验云端 `96a31bc`
|
||||
(键盘按键、弹窗兜底、卡包按体系、事件表 9 条)。本机:build `26593955`、汉化 `2026111301`、
|
||||
AALC `2fcb1b4`(V1.6.1)、客户区 1280×720、`win_input_type: foreground`、驱动输入开。
|
||||
|
||||
## 1. 6 连刷(01:50 → 08:29)
|
||||
|
||||
`run_task(mirror, count=6)`,**6/6 全部完成,exit 0**:
|
||||
|
||||
| 局 | 完成时间 | 耗时 |
|
||||
|---|---|---|
|
||||
| 1 | 03:00:17 | 01:09:27 |
|
||||
| 2 | 04:05:30 | 01:05:11 |
|
||||
| 3 | 05:08:37 | 01:03:05 |
|
||||
| 4 | 06:08:43 | 01:00:05 |
|
||||
| 5 | 07:15:16 | 01:06:31 |
|
||||
| 6 | 08:29:43 | 01:14:26 |
|
||||
|
||||
平均 **1:06:24**。决策计数(6 局累计):
|
||||
|
||||
```
|
||||
team exact 2 / current 6
|
||||
theme_pack preferred 30
|
||||
gift keyword 24 ← 全部命中体系关键词, 没有 no_keyword
|
||||
shop purchase 36 / 按名字命中 9
|
||||
event text 13 / not_in_table 116
|
||||
road fallback 181 ← 当时键盘还没修
|
||||
```
|
||||
|
||||
错误日志 3,225 条,但都集中在 01–02 点(首局窗口一时取不到),之后不再出现;
|
||||
真正影响流程的只有 1 条"返回主界面超时 → 重启游戏"和 1 条"获取剩余金钱失败"。
|
||||
|
||||
## 2. 键盘寻路:修好了(I-05)
|
||||
|
||||
新按键补丁(带扫描码 + 按住 120ms)实机:
|
||||
|
||||
```text
|
||||
[lc_mcp] 键盘寻路: 进入 U 方向的 event(权重 1, 下一列中最低)
|
||||
[lc_mcp] 键盘寻路: 进入 M 方向的 battle(权重 4, 下一列中最低)
|
||||
```
|
||||
|
||||
一局内 **4 次进入 / 0 次失败**,之后 `road/lowest` 计数 29、`fallback` 0。上一版是 24/24 全失败。
|
||||
|
||||
## 3. 卡包按体系:生效(R-01 / I-08)
|
||||
|
||||
```text
|
||||
[lc_mcp] 卡包按体系 tremor 加分: 地狱鸡 1→7, 时间杀人 -5→1, 海·边 0→1, 绝望 -5→1, 遗忘 0→-3 …
|
||||
[INFO] 此次选择卡包关键词:赌徒
|
||||
```
|
||||
|
||||
权重不再是"全 0 取最左",`decisions.theme_pack` 里能看到 `system_bonus`。
|
||||
|
||||
## 4. 事件表:9 条仍不够(I-07 / R-02)
|
||||
|
||||
一天里 `event/not_in_table` 累计 **138 条**,新样本(可直接补表):
|
||||
|
||||
| 选项 1 | 选项 2 | 选项 3 |
|
||||
|---|---|---|
|
||||
| 摘下一朵花 | 扯断棘蔓 | — |
|
||||
| 带走这幅画 | 留下这幅画 | — |
|
||||
| 告诉它你们很乐意听些故事 | 不听故事离开 | — |
|
||||
| 为它指明方向 | 站立不动 | 直接带它去出口 |
|
||||
|
||||
## 5. 开局「获得E.G.O饰品」弹窗(I-06)
|
||||
|
||||
### 现象与排查
|
||||
|
||||
- 11-14 18:45:连点 5 分钟不关,`loop_count` 到 -160。
|
||||
- 11-15 10:34 那局:新兜底"改点按钮中心"也没关,20 次后按设计中止(exit 4)。
|
||||
- **手动验证**:把游戏窗口切到前台,同一点击位置连点 2 次——弹窗一个接一个关掉,第 2 次就进卡包页。
|
||||
说明弹窗是**一支一支来**的,不是点不掉;20 次不关 = 那 20 次点击没送到游戏。
|
||||
|
||||
### 结论
|
||||
|
||||
驱动级"物理点击"与 pyautogui 软件点击在这个界面表现不同;且 12:29 的截图里 DSH 聊天窗口正好盖住
|
||||
按钮区域(按钮中心 640,532 落在浏览器面板内)。两种都会让点击落空。
|
||||
|
||||
### 最终兜底(已实机生效)
|
||||
|
||||
守卫在连续第 3 次命中时**绕过驱动代理、直接调底层 handler 的软件点击**,第 8 次再不行发回车:
|
||||
|
||||
```json
|
||||
{"stage":"gift_confirm","choice":"button_center","reason":"repeated","clicks":2}
|
||||
{"stage":"gift_confirm","choice":"software_click","reason":"driver_bypass","clicks":3}
|
||||
```
|
||||
|
||||
13:16 那局弹窗第 3 次就被关掉,流程继续,`[ERROR]` 0 条。
|
||||
|
||||
## 6. 镜像迷宫队 + 震颤(用户 11-15 指定)
|
||||
|
||||
```
|
||||
config.yaml: team_system 6 → 2(震颤)
|
||||
lc_mcp/data/team_names.json: {"tremor": ["镜像迷宫", "震颤"]}
|
||||
```
|
||||
|
||||
实机:
|
||||
|
||||
```text
|
||||
[lc_mcp] 镜牢体系 tremor -> 目标编队 镜像迷宫/震颤
|
||||
[lc_mcp] patch: 当前已经是编队 镜像迷宫, 无需切换
|
||||
[INFO] 楼层识别结果:当前为第1层
|
||||
```
|
||||
|
||||
`decisions`: `{"stage":"team","choice":"镜像迷宫","reason":"current","wanted":["镜像迷宫","震颤"]}`。
|
||||
|
||||
## 7. 待办(本轮新增/未闭环)
|
||||
|
||||
| 台账 | 事项 |
|
||||
|---|---|
|
||||
| I-06 | 已修并验证;但驱动点击为何在该弹窗无效仍未彻底定位,兜底已够用 |
|
||||
| I-07 | 事件表需补上面 4 条 + 已有 138 条 not_in_table |
|
||||
| I-14(新) | 前台被抢/被遮挡时点击会丢:跑团期间别把浏览器等窗口拉到前台 |
|
||||
| R-05 | 6 连刷已完成(本轮) |
|
||||
@@ -0,0 +1,97 @@
|
||||
# 2026-11-15 云端交付:实机回归清单
|
||||
|
||||
分支 `codex/feedback-unattended-setup-20261004`,接在本机提交 `5992827` 之后。
|
||||
处理的是 [`docs/ISSUES.md`](../../ISSUES.md) 里待修、待数据的几条:
|
||||
|
||||
| 台账 | 改了什么 |
|
||||
|---|---|
|
||||
| I-05 / R-03 键盘寻路 0 成功 | 按键改发带扫描码的按键并按住 0.12 秒(疑似根因);连续 3 个节点进不去就停用到任务结束(即方案 B) |
|
||||
| I-06 / R-04 开局饰品弹窗死循环 | 确认连续第 3 次命中起改点按钮中心;连续 20 次还在就记 `[ERROR]`、结束任务 |
|
||||
| I-07 / R-02 事件表覆盖 | 补蜘蛛巢、归乡路途(两段),6 → 9 条;全表按本机装的零协 `2026111301` 重新核对 |
|
||||
| I-13(新) | 复查 `5992827`:「进入」每轮多跑一次 OCR、选队页重试不重新截图、切队失败每轮重翻列表 |
|
||||
| R-01 / I-08 卡包按体系 | 用 wiki.gg 数据做了 122 个卡包的「卡包 → 体系」表,并入 codex 检索到的中文社区推荐/避开([检索记录](theme-pack-research.md)),选卡包时按当局体系给 AALC 权重加分 |
|
||||
|
||||
`vendor/aalc` 没动,仍是 `2fcb1b4`。
|
||||
|
||||
## 1. 拉取并重启服务
|
||||
|
||||
```powershell
|
||||
cd D:\lc-mcp
|
||||
git pull
|
||||
git submodule update --init --recursive
|
||||
vendor\aalc\.venv\Scripts\python.exe -m unittest discover -s tests -t tests
|
||||
Stop-ScheduledTask -TaskName LcMCPServer # I-09: 不重启, 任务子进程拿到的还是旧环境
|
||||
Start-ScheduledTask -TaskName LcMCPServer
|
||||
```
|
||||
|
||||
- [ ] 单测全部通过(云端 Linux 676 个)
|
||||
- [ ] 服务已重启(`Get-NetTCPConnection -LocalPort 8765 -State Listen` 有监听)
|
||||
|
||||
## 2. 任务开始时的日志
|
||||
|
||||
`run_task(task="mirror", count=1)` 启动后应有这 12 行(按安装顺序;前面还有队伍名精确匹配等原有的 patch 行):
|
||||
|
||||
```text
|
||||
[lc_mcp] patch: 按键按住 120ms 再松开, 前台改发带扫描码的按键(BackgroundInput/Input/WindowMoveInput)
|
||||
[lc_mcp] patch: 入场前按体系切队伍
|
||||
[lc_mcp] patch: 镜牢按体系名选队
|
||||
[lc_mcp] patch: 选队页守卫(星之恩惠页忽略星级模板)
|
||||
[lc_mcp] patch: 「获得E.G.O饰品」确认连点不关时改点按钮中心, 20 次还在就结束任务
|
||||
[lc_mcp] patch: 镜牢键盘寻路按节点类型选方向(不拖地图)
|
||||
[lc_mcp] patch: 镜牢饰品选择按体系关键词排序(gift_keywords.json)
|
||||
[lc_mcp] patch: 镜牢事件按选项表选择(event_choices.json, 9 条)
|
||||
[lc_mcp] patch: 商店购买写入决策审计
|
||||
[lc_mcp] patch: 商店必买先按中文名找(shop_gifts.json, 5 个名字), 图标模板兜底
|
||||
[lc_mcp] patch: 镜牢卡包按体系加分(theme_pack_systems.json, 122 个卡包)
|
||||
[lc_mcp] patch: 卡包选择写入决策审计
|
||||
```
|
||||
|
||||
- [ ] 12 行都在;事件表是 **9 条**,卡包表 **122 个**
|
||||
- [ ] 没有带 `挂不上` 或 `补丁跳过` 的 `[ERROR]`
|
||||
- [ ] 记下 `config.yaml` 的 `win_input_type`(`foreground` / `background` / `window_move`)。
|
||||
按键这项在前台和后台两种模式下改的东西不一样,结果要对着模式看
|
||||
|
||||
## 3. 逐项看
|
||||
|
||||
| 项 | 日志里找 | 怎么判断 |
|
||||
|---|---|---|
|
||||
| **战斗按键(先看这个)** | 每场战斗开头的 `使用P+Enter开始战斗`(AALC 的 debug 行) | 战斗照常开打、能打完。**战斗起不来就立刻 `stop_task`,设 `LCP_KEY_HOLD=0` 重启服务再跑**,并把日志带回来 |
|
||||
| 键盘寻路 I-05 | `键盘寻路: 进入 X 方向的 <类型>` / `… 没能进入, 试下一个` | 出现「进入」= 根因找对了,`road` 计数里 `lowest`/`next_best` 会涨。还是全失败时,每局开头会有一行 `连续 3 个节点按键都没进去, 本次任务不再按键寻路`,`road/keyboard_off` 计数 1,之后不再白按 |
|
||||
| 按键没发 | `按键 X 没发: 游戏窗口不在前台` | 只有前台模式会有。偶尔一两行无所谓;很多就说明窗口经常不在前台,带回来 |
|
||||
| 开局饰品弹窗 I-06 | 从**大厅**开一局(才会经过开局选饰品) | 30 秒内进卡包页。`改点按钮中心 (x,y)` 出现 = 勾号确实点不到、兜底起了作用;`[ERROR] … 确认连点 20 次弹窗还在, 结束任务` = 按钮中心也点不掉,截图回传 |
|
||||
| 入场切队 I-13 | `入场前切队伍: 充能/震颤` → `已按体系名选中编队 充能` | 和上次一样能切。队伍不存在时每局只该有**一行** `[ERROR] [lc_mcp] 入场前没切到 …`,不该刷屏 |
|
||||
| 卡包 R-01 | 每层 `卡包按体系 charge 加分: …, 谋杀 -5→1, 绝望 -5→1, 遗忘 0→-3, …`(长的键排前面),接着 AALC 的 `当前主题包权重列表` | 列表里有充能相关卡包时选的是它(`此次选择卡包关键词:谋杀` 之类),`decisions` 的 `theme_pack` 带 `system_bonus`;没有时和以前一样。记下每层选了什么、单层用时有没有明显变长(WARP 这类剧情包 AALC 原本是避开的) |
|
||||
| 事件 I-07 | `事件 …: 1=… \| 2=…; 按表选第 N 项「…」` | 遇到蜘蛛巢选第 1 项、归乡路途两段都选第 1 项(拿到「归途」)。`not_in_table` 的行全部带回来 |
|
||||
| 其余 | 同 [上一轮清单](../2026-11-14/REGRESSION.md) | 选队、饰品、商店、审计不应变差 |
|
||||
|
||||
- [ ] 战斗按键正常
|
||||
- [ ] 键盘寻路:进得去 / 仍 0 成功但已停用(二选一)
|
||||
- [ ] 开局饰品弹窗 30 秒内过
|
||||
- [ ] 入场切队正常,没有刷屏
|
||||
- [ ] 卡包:有体系卡包时选中它,且没把一层拖得太久;第 1 层有别的选择时不选被遗忘者们
|
||||
- [ ] 事件(没遇到就记"未遇到")
|
||||
- [ ] 其余项不比上轮差
|
||||
|
||||
## 4. 离线确认不了的
|
||||
|
||||
- **按键根因是推断**:上游注释说 Unity 6 校验扫描码和扩展键标志,这里两处都补了,还加了按住。如果前台模式下仍然
|
||||
0 成功,可能游戏读的是原始输入、注入的按键根本收不到,那就要走罗技驱动发键(DLL 的方向键键码还不知道)。
|
||||
- **按钮中心偏移**:76(1440 标定)只在 1280×720 量过一次(手点 (640,530) 生效)。别的分辨率按比例算,没实测。
|
||||
- **结束任务的门槛**:「连续 20 次」是按卡住时约 1.5 秒一次估的,正常一个弹窗点 1~2 次就关;正常流程里
|
||||
如果出现 `改点按钮中心`、但弹窗本来就会关,也无害。
|
||||
|
||||
## 5. 出问题时
|
||||
|
||||
| 变量 | 关掉什么 |
|
||||
|---|---|
|
||||
| `LCP_KEY_HOLD=0` | 按键补丁,回到 AALC 原来的 `pyautogui.press` / 不按住 |
|
||||
| `LCP_TYPED_ROAD=0` | 键盘寻路按类型(连同"3 次后停用"),回到上游只按 ↑ |
|
||||
| `LCP_EVENT_CHOICES=0` | 事件选项表 |
|
||||
| `LCP_THEME_PACK_SYSTEMS=0` | 卡包按体系加分(只想保守一点就改 `lc_mcp/data/theme_pack_systems.json` 的 `bonus`,比如 `featured` 改 4、`unique` 改 `[0, 1, 2, 4]`,-5 的剧情包就压不过 0 分的了) |
|
||||
|
||||
饰品弹窗兜底没有开关:只在同一个确认连续命中 3 次以上时才动作。
|
||||
|
||||
## 6. 回传
|
||||
|
||||
写回 `docs/feedback/<日期>/`:任务日志 `~/lc_mcp/runs/task_*.log`、同名 `task_*.decisions.jsonl`、本清单勾选结果,
|
||||
`config.yaml` 的 `win_input_type`,以及所有 `event/not_in_table` 行(补事件表要用)。
|
||||
@@ -0,0 +1,113 @@
|
||||
# 镜牢卡包:中文社区资料检索(2026-11-15)
|
||||
|
||||
云端直接访问灰机 wiki(limbuscompany.huijiwiki.com)一律 403,边狱巴士 BWIKI 没有卡包条目,所以用本机的
|
||||
codex CLI(`codex --search exec`,联网搜索走 OpenAI 那边)检索中文社区资料,核对 wiki.gg 整理出来的
|
||||
`lc_mcp/data/theme_pack_systems.json`。下面「检索结果」是 codex 的原始输出,没有改动。
|
||||
|
||||
## 合并了什么
|
||||
|
||||
- **社区推荐 / 避开** → `theme_pack_systems.json` 的 `community`:「3. 体系推荐」里普通难度会出现的卡包按体系加
|
||||
`bonus.recommend`;「明确避开」里速刷拖时间的被遗忘者们、自动工厂、当碎之物对所有体系减 `bonus.avoid`;
|
||||
琥珀色的黄昏对流血不加分。每条都带来源链接。
|
||||
- **没合并的**:
|
||||
- 当前赛季是 S8「西西弗之镜」,不是表头写的 S7「名与蛛之镜」。层数只是参考、不参与计算,不影响加分。
|
||||
- 善意的巡礼活动已结束、卡包已移除:留在表里无害(不出现就不会被选)。
|
||||
- WARP快车谋杀案的「流血 1」(血液结晶)中文事件写作泛用饰品:只影响流血队 +1,在表里注明,暂不改。
|
||||
- 「压抑的暴怒 / 压抑的愤怒」:零协汉化(本机装的)是「压抑的暴怒」,以零协为准。
|
||||
- 经验记忆「延后再打」、切磋琢春评价两极:没有可执行的结论,不处理。
|
||||
|
||||
## 检索结果(codex 原始输出)
|
||||
|
||||
**这张表不能直接认定为“当前赛季普通难度54包表”**:中文资料显示它混入了已移除的限时包,以及更晚赛季的内容。以下按你指定的“名与蛛之镜”核对;未取得同版本证据的地方标为“未找到”。
|
||||
|
||||
## 1. 来源
|
||||
|
||||
### 成功打开并读到正文
|
||||
|
||||
| 来源 | 阅读范围 |
|
||||
|---|---|
|
||||
| [Steam《镜像地牢 攻取要略》](https://steamcommunity.com/sharedfiles/filedetails/?id=3010191708) | 明确分列S7“名与蛛之镜”和旧赛季章节;读取了速刷路线、体系选择及避坑说明 |
|
||||
| [OurPlay《镜牢全新轮椅体系队烧震详细使用指南》](https://www.ourplay.net/planet/thread/715281) | 烧伤/震颤队的困难15层路线 |
|
||||
| [OurPlay《一些镜牢单通攻略,好像沉了,重发一遍》](https://www.ourplay.net/planet/thread/758301) | 按体系列出的单通选包建议 |
|
||||
| [OurPlay《有无大佬指点一下小登镜牢》](https://www.ourplay.net/planet/thread/497714) | 2025年7月回复中的体系选包建议,属于旧困牢资料 |
|
||||
| [GameMale《呼吸破裂队15层镜牢指南》](https://www.gamemale.com/thread-177147-1-1.html) | 2026年1月旧版本呼吸/破裂路线;正文可读,部分附件要求登录 |
|
||||
| [TapTap《边狱巴士镜像迷宫指南——普牢速刷(镜5)》](https://www.taptap.cn/moment/664273800250000543) | 旧镜5普通破裂速刷路线,仅作历史参考 |
|
||||
|
||||
### 未能直接打开;部分读到了搜索引擎抓取正文
|
||||
|
||||
**下面的“读到”指搜索结果返回的正文或数据行,不代表网页直开成功。**
|
||||
|
||||
| URL | 直开结果及实际取得的内容 |
|
||||
|---|---|
|
||||
| [名与蛛之镜](https://limbuscompany.huijiwiki.com/wiki/名与蛛之镜)、[西西弗之镜](https://limbuscompany.huijiwiki.com/wiki/西西弗之镜) | 403;搜索抓取文本可读,包含赛季及模式说明 |
|
||||
| [Data:Mirror5.tabx](https://limbuscompany.huijiwiki.com/wiki/Data:Mirror5.tabx)、[数据库列表](https://limbuscompany.huijiwiki.com/wiki/数据库列表) | 403;读到卡包层数数据及“停止更新”标记 |
|
||||
| [E.G.O饰品](https://limbuscompany.huijiwiki.com/wiki/E.G.O饰品)、[事件-义体关节伺服电机](https://limbuscompany.huijiwiki.com/wiki/事件-义体关节伺服电机) | 403;读到部分完整饰品记录、所属卡包及事件选项 |
|
||||
| [WARP快车谋杀案](https://limbuscompany.huijiwiki.com/wiki/WARP快车谋杀案)、[LCB定期体检](https://limbuscompany.huijiwiki.com/wiki/LCB定期体检)、[切磋琢春](https://limbuscompany.huijiwiki.com/wiki/切磋琢春) | 403;取得部分活动介绍,饰品主要通过总表交叉查询 |
|
||||
| [善意的巡礼](https://limbuscompany.huijiwiki.com/wiki/善意的巡礼)、[继黎明后贯穿而来的楔子](https://limbuscompany.huijiwiki.com/wiki/瓦尔普吉斯之夜-继黎明后贯穿而来的楔子) | 403;搜索抓取正文包含活动时间、开放或移除说明 |
|
||||
| [镜像迷宫-敌方数据](https://limbuscompany.huijiwiki.com/wiki/镜像迷宫-敌方数据) | 403;未能直接使用其交互筛选列表 |
|
||||
| [B站《最新镜牢纯P突刺队攻略》](https://www.bilibili.com/opus/1200031368835235848) | 直开为验证码页;搜索抓取提供了2026年5月8日的文字攻略正文 |
|
||||
| [NGA](https://nga.178.com/) | 403;未找到可核验正文的相关帖子 |
|
||||
| [英文wiki:Mirror of Names and Spiders](https://limbuscompany.wiki.gg/wiki/Mirror_of_Names_and_Spiders) | 403;仅取得部分搜索抓取内容,用于对照,未据此补写中文来源缺失的数据 |
|
||||
|
||||
另读到了灰机[个人名片装饰](https://limbuscompany.huijiwiki.com/wiki/个人名片装饰)的搜索抓取文本,用于交叉确认赛季归属。
|
||||
|
||||
## 2. 与表不一致
|
||||
|
||||
### 可以明确指出的差异
|
||||
|
||||
| 项目 | 中文来源中的记录 | 对原表的影响 |
|
||||
|---|---|---|
|
||||
| **“当前赛季=名与蛛之镜”** | 名与蛛之镜属于第7赛季;检索时中文维基已有第8赛季“西西弗之镜”的说明。 | 按本次检索日期2026年11月15日,“当前赛季”的表头需要更正;若研究S7,应明确标成历史版本。[名与蛛之镜](https://limbuscompany.huijiwiki.com/wiki/名与蛛之镜)、[西西弗之镜](https://limbuscompany.huijiwiki.com/wiki/西西弗之镜) |
|
||||
| **善意的巡礼:仍列作可出现卡包** | 活动页明确规定活动结束后移除主题卡包、选项事件和E.G.O饰品;活动结束时间为2025年10月23日。旧卡包数据也标为“无法观测”。 | 不能继续计入当前可出现的普通卡包。原表的普通4、5层及对应饰品只能作为活动期间历史记录,不能作为现行可获得内容。[活动页](https://limbuscompany.huijiwiki.com/wiki/善意的巡礼)、[卡包数据](https://limbuscompany.huijiwiki.com/wiki/Data:Mirror5.tabx) |
|
||||
| **黎明后贯穿而来之楔:混入S7表** | 中文活动名称为“继黎明后贯穿而来的楔子”,活动时间为2026年11月12日至26日;名片资料将相关内容列在第8赛季。 | 不应无说明地归入“名与蛛之镜”表;其所填普通/困难层数,未找到同版本中文依据。[活动页](https://limbuscompany.huijiwiki.com/wiki/瓦尔普吉斯之夜-继黎明后贯穿而来的楔子)、[赛季交叉记录](https://limbuscompany.huijiwiki.com/wiki/个人名片装饰) |
|
||||
| **压抑的暴怒:中文名称** | 中文卡包数据使用“压抑的愤怒”。 | 属于名称差异;普通4、5层、困难3、4层没有发现差异。[卡包数据](https://limbuscompany.huijiwiki.com/wiki/Data:Mirror5.tabx) |
|
||||
|
||||
### 饰品分类存在口径差异,暂不能直接改数
|
||||
|
||||
**WARP快车谋杀案的“流血1”需要复核。**中文事件把获得“血液结晶”的选项称为获得“泛用E.G.O饰品”,而原表将其所在包统计为“流血1”。这是来源分类口径不一致的证据;但未取得同一版本的完整关键词数据,**不能据此直接把流血1改成0**。[事件-义体关节伺服电机](https://limbuscompany.huijiwiki.com/wiki/事件-义体关节伺服电机)
|
||||
|
||||
### 其余核对结果与缺口
|
||||
|
||||
- **层数:**读到的51个表内普通卡包,其普通及困难1~5层记录均与原表一致。这51个不包含“善意的巡礼”“开店抢购”和“黎明后贯穿而来之楔”。但该数据表已被中文维基列入停止更新的数据,不能当作现行版本的完整证明。[卡包数据](https://limbuscompany.huijiwiki.com/wiki/Data:Mirror5.tabx)、[更新状态](https://limbuscompany.huijiwiki.com/wiki/数据库列表)
|
||||
- **困难6~10层:**中文数据使用“平行叠加”标记;模式说明确认平行叠加扩展至10层。但这不足以逐一证明每个包在6、7、8、9、10层均可出现,完整逐层限制为**未找到**。[名与蛛之镜](https://limbuscompany.huijiwiki.com/wiki/名与蛛之镜)
|
||||
- **开店抢购:**未找到足以核验该中文名称、层数及“充能2”的中文记录。
|
||||
- **Featured列:**未找到与英文wiki Featured字段逐项对应的中文定义及完整表,不能把“社区推荐某队去”直接视为Featured应有该体系。
|
||||
- **54包专属饰品件数:**未完成全部逐件确认,不能写“全部一致”。
|
||||
|
||||
以下几组能够从中文饰品记录中对应到具体名称;这里核对的是所属卡包和效果涉及体系,**不等同于完整验证英文分类标签**。[中文饰品总表](https://limbuscompany.huijiwiki.com/wiki/E.G.O饰品)
|
||||
|
||||
| 卡包 | 能对应到的体系饰品 |
|
||||
|---|---|
|
||||
| LCB定期体检 | 烧伤3:点火手套、重燃火花塞、余火;破裂3:荆棘战斗靴、强化剂Mk.4、细枝 |
|
||||
| WARP快车谋杀案 | 充能5:E型次元短剑、便携式力场电池、生物发电电池、心脏反应模块、义体关节伺服电机 |
|
||||
| 切磋琢春 | 烧伤1:血炎刀;震颤1:黑铁马胄;斩击1:蒙蔽心扉的红布;破裂3:品德-智、勇、仁 |
|
||||
|
||||
## 3. 体系推荐
|
||||
|
||||
**以下只保留原表中普通难度会出现的卡包名称。**来源若讨论困难15层、单通或旧版本,已注明;它们不能直接等同于普通速刷最优路线。“复刻”包没有并入同名普通包。
|
||||
|
||||
| 体系 | 社区明确推荐的普通可出现卡包 | 适用范围与来源 |
|
||||
|---|---|---|
|
||||
| **烧伤** | **地狱鸡、憎恶与绝望**;旧攻略另推荐**LCB定期体检** | 前两者来自S7烧震速刷路线,分别安排在2、3层;体检来自2025年旧困牢回复。[S7攻略](https://steamcommunity.com/sharedfiles/filedetails/?id=3010191708)、[旧攻略](https://www.ourplay.net/planet/thread/497714) |
|
||||
| **流血** | **绞丝结线** | 单通攻略列为可选,环指人格则列为必走。[单通攻略](https://www.ourplay.net/planet/thread/758301) |
|
||||
| **震颤** | **时间杀人时间**;烧震速刷另选**地狱鸡、憎恶与绝望** | 时间杀人时间来自困难15层烧震攻略,理由是专属震颤饰品提升大;后两者属于S7速刷路线。[烧震攻略](https://www.ourplay.net/planet/thread/715281)、[S7攻略](https://steamcommunity.com/sharedfiles/filedetails/?id=3010191708) |
|
||||
| **破裂** | **无归属者、地狱鸡**;呼破旧攻略另列**深夜清扫、LCB定期体检、切磋琢春** | 前两者为旧镜5普通速刷路线;后三者为旧版本呼吸/破裂困难15层路线。[旧普牢攻略](https://www.taptap.cn/moment/664273800250000543)、[呼破攻略](https://www.gamemale.com/thread-177147-1-1.html) |
|
||||
| **沉沦** | **琥珀色的黄昏、憎恶与绝望** | 单通攻略把琥珀列为沉沦可选包;通用路线也推荐绝望包,并明确提到拿取泪锋之剑、未被选中之人。[单通攻略](https://www.ourplay.net/planet/thread/758301) |
|
||||
| **呼吸** | **地狱鸡、由子弹画下的句点、20区的奇迹** | 地狱鸡来自S7呼吸追击速刷;句点、普通20区来自2025年旧困牢回复。这里不把20区复刻混入。[S7攻略](https://steamcommunity.com/sharedfiles/filedetails/?id=3010191708)、[旧攻略](https://www.ourplay.net/planet/thread/497714) |
|
||||
| **充能** | **WARP快车谋杀案、憎恶与绝望、绞丝结线** | 旧攻略明确推荐WARP;单通攻略推荐绝望包拿充能饰品,绞丝列为可选、血充必走。[旧攻略](https://www.ourplay.net/planet/thread/497714)、[单通攻略](https://www.ourplay.net/planet/thread/758301) |
|
||||
| **斩击** | **经验记忆** | 单通攻略列为必走;这是困难单通建议,未找到同样明确的普通速刷推荐。[单通攻略](https://www.ourplay.net/planet/thread/758301) |
|
||||
| **突刺** | **身无分文的赌徒 → 去·海·边 → 当贯之物**;4层优先**20区的奇迹**,备选**沉迷的色欲、堕落的忧郁、吞噬的暴食** | B站文字攻略给出的1~4层路线。原文5层转困难选3号线,因不属于普通卡包,此处不列入。[B站文字攻略](https://www.bilibili.com/opus/1200031368835235848) |
|
||||
| **打击** | **未找到** | 找到的明确推荐是“深夜清扫复刻”,不符合本次只列普通可出现包的限制。[单通攻略](https://www.ourplay.net/planet/thread/758301) |
|
||||
|
||||
上述推荐也说明:**推荐去某包,并不一定是因为它以该体系掉落为主。**例如S7烧震攻略选择地狱鸡、憎恶与绝望,明确考虑了免判定事件和战斗数量;不能据此把它们直接改标成烧伤/震颤Featured包。[S7攻略](https://steamcommunity.com/sharedfiles/filedetails/?id=3010191708)
|
||||
|
||||
### 明确避开或延后选择的包
|
||||
|
||||
| 卡包 | 攻略中的理由 | 限定场景 |
|
||||
|---|---|---|
|
||||
| **被遗忘者们** | 可能遇到时钟及不断出现的小怪,分散自动攻击伤害,作者估计常拖到5回合以上。 | S7速刷。[来源](https://steamcommunity.com/sharedfiles/filedetails/?id=3010191708) |
|
||||
| **自动工厂、当碎之物** | 可能遇到机器人,拖延通关时间。 | S7速刷。原文混用普通/困难路线,不能照搬其“1层”表述到普通层数表。[来源](https://steamcommunity.com/sharedfiles/filedetails/?id=3010191708) |
|
||||
| **琥珀色的黄昏** | 流血部分认为有效收益主要只有“泛音”,因此不建议走。 | 流血单通;同文对沉沦仍列为可选。[来源](https://www.ourplay.net/planet/thread/758301) |
|
||||
| **经验记忆** | 建议关键饰品基本齐全后再打:林庆业血量高、施加流血能力强。 | 困难烧震路线,是“延后”而非一律避开;原文的万血描述不能套到普通难度。[来源](https://www.ourplay.net/planet/thread/715281) |
|
||||
|
||||
“切磋琢春”在单通攻略中评价很低,但没有给出可核验的“太慢/太难”解释;另一篇旧呼破攻略反而推荐它。因此其明确避坑理由记为**未找到**,不据此下通用结论。[单通攻略](https://www.ourplay.net/planet/thread/758301)、[呼破攻略](https://www.gamemale.com/thread-177147-1-1.html)
|
||||
@@ -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)。沿用用户配好的队伍、难度、出战顺序,不为了通用攻略改动配置。
|
||||
|
||||
@@ -47,7 +47,8 @@
|
||||
| 员工证、夜视镜、止痛片、贪婪之锤 | 2 | 安全直出,避开判定或损失分支 |
|
||||
| 巫毒娃娃 | 3;需要饰品时 2 | 安全直出或免费饰品 |
|
||||
| 生存的里程标、异想狩猎 | 分别 2、1 | 安全直出;另一项都是免费饰品 |
|
||||
| 归乡路途 | 1→分支 1 | 免费饰品,其他路径可能大量降理智 |
|
||||
| 归乡路途 | 1→分支 1 | 免费饰品「归途」,其他路径可能大量降理智 |
|
||||
| 蜘蛛巢(结婚蜘蛛) | 1:摘下一朵花。 | 免费饰品「偏见」,非傲慢人格扣 5 体力;2 是 50% 判定,成败都有全体损失。[条目](https://limbuscompany.wiki.gg/wiki/Spider_of_Marriage) |
|
||||
| 终末日历 | 2 | 安全直出 |
|
||||
| 破碎罗盘 | 4;缺经费时 1→分支 1 | 直接结束;另一条拿 50 经费,但增加分支 |
|
||||
| 拉·曼却领嘉年华游行、旋转木马、折射的四百朵玫瑰 | 2 | 安全直出 |
|
||||
@@ -109,4 +110,4 @@
|
||||
|
||||
本文为速通摘要,不覆盖主线探索。Wiki 结果是依据;版本变化或文字不符时回查对应事件,不能套用到同名活动变体。
|
||||
|
||||
归因:[边狱公司中文 Wiki 社区「探索事件」](https://limbuscompany.huijiwiki.com/wiki/%E6%8E%A2%E7%B4%A2%E4%BA%8B%E4%BB%B6)。对结果做了节选、概括,并添加速通判断;相关 Wiki 改编内容按 [CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/) 署名及相同方式共享。
|
||||
归因:[边狱公司中文 Wiki 社区「探索事件」](https://limbuscompany.huijiwiki.com/wiki/%E6%8E%A2%E7%B4%A2%E4%BA%8B%E4%BB%B6)。对结果做了节选、概括,并添加速通判断;相关 Wiki 改编内容按 [CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/) 署名及相同方式共享。标注了「条目」链接的行另参考 [Limbus Company Wiki(wiki.gg)](https://limbuscompany.wiki.gg/),同为 CC BY-SA 4.0。
|
||||
|
||||
@@ -300,12 +300,13 @@ class AalcEngine(Engine):
|
||||
finally:
|
||||
handler.key_up(k)
|
||||
elif not self.cfg.simulator and self.cfg.win_input_type == 'foreground':
|
||||
import pyautogui
|
||||
pyautogui.keyDown(k)
|
||||
try:
|
||||
time.sleep(0.12)
|
||||
finally:
|
||||
pyautogui.keyUp(k)
|
||||
# pyautogui 发的按键扫描码是 0、方向键不带扩展键标志, Unity 6 会忽略(ISSUES I-05);
|
||||
# 与任务子进程的按键补丁用同一个 press_vk, 同样按住 0.12 秒。
|
||||
import ctypes
|
||||
from module.automation.input_handlers.input import EXTENDED_KEY_VKS, key_list
|
||||
from .aalc_patches import press_vk
|
||||
vk = key_list[k]
|
||||
press_vk(ctypes.windll.user32, vk, vk in EXTENDED_KEY_VKS, hold=0.12)
|
||||
else:
|
||||
self.auto.key_press(k)
|
||||
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
+106
-10
@@ -11,8 +11,16 @@ import sys
|
||||
|
||||
from . import killswitch, preflight
|
||||
from .aalc_engine import bootstrap
|
||||
from .aalc_patches import (WindowGuard, driver_click_tasks, install_exact_team_match,
|
||||
install_robust_set_foreground, stop_driver_click)
|
||||
from .aalc_patches import (TaskAbort, WindowGuard, driver_click_tasks, headless_hdr_warning, install_rabbit_hole,
|
||||
load_rabbit_hole,
|
||||
install_default_battle_team, install_event_choices, install_exact_team_match,
|
||||
install_gift_confirm_guard, install_gift_preference, install_image_error_guard, install_key_hold,
|
||||
install_robust_set_foreground, install_shop_audit, install_shop_by_name,
|
||||
install_system_team_selection, install_team_screen_guard,
|
||||
install_theme_pack_audit, install_theme_pack_systems, install_typed_keyboard_road,
|
||||
mirror_progress, stop_driver_click)
|
||||
from .decisions import decisions
|
||||
from .game_lock import GameBusyError, exclusive_game
|
||||
|
||||
# 任务 -> {参数名: AALC 配置项}; 参数只在本次运行内生效
|
||||
TASKS = {
|
||||
@@ -22,8 +30,15 @@ TASKS = {
|
||||
'enkephalin': {'times': 'set_lunacy_to_enkephalin'},
|
||||
'mirror': {'count': 'set_mirror_count'},
|
||||
}
|
||||
# 任务 -> {选项名: 允许的值}; 不对应 AALC 配置项, 只决定本次装哪些补丁
|
||||
TASK_OPTIONS = {
|
||||
'mirror': {'strategy': ('rabbit_hole',)}, # rabbit_hole: 兔子洞速刷, 见 lc_mcp/data/rabbit_hole.json
|
||||
}
|
||||
# 用户给了镜牢次数时一并临时关闭的配置: 开着无限刷牢, 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):
|
||||
@@ -36,17 +51,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)
|
||||
@@ -66,6 +101,31 @@ 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 split_options(task, params):
|
||||
"""把任务选项(TASK_OPTIONS)从参数里拆出来, 返回 (次数类参数, 选项)。"""
|
||||
allowed = TASK_OPTIONS.get(task, {})
|
||||
params = dict(params)
|
||||
options = {k: params.pop(k) for k in list(params) if k in allowed}
|
||||
return params, options
|
||||
|
||||
|
||||
def _run(task, params):
|
||||
params, options = split_options(task, params)
|
||||
rabbit = None
|
||||
if options.get('strategy') == 'rabbit_hole':
|
||||
try:
|
||||
rabbit = load_rabbit_hole()
|
||||
except (OSError, ValueError) as e:
|
||||
log('[ERROR] [lc_mcp] 兔子洞配置读不了: %s' % e)
|
||||
return PREFLIGHT_EXIT
|
||||
bootstrap()
|
||||
from module.automation import auto
|
||||
from module.config import cfg
|
||||
@@ -83,17 +143,44 @@ def run(task, params):
|
||||
log('[ERROR] [lc_mcp] preflight: %s' % p)
|
||||
return PREFLIGHT_EXIT
|
||||
|
||||
decisions.open() # TaskRunner 给的 .decisions.jsonl; 直接运行时不写
|
||||
install_exact_team_match(auto, log)
|
||||
install_robust_set_foreground(screen, log=log)
|
||||
if not cfg.simulator:
|
||||
install_key_hold(log=log) # 前台按键带扫描码、各模式按住再松开(ISSUES I-05)
|
||||
# 日常本(经验/纽本)不翻队伍列表: 队伍是自定义名字时按名字找必然失败,
|
||||
# 白等 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, names=rabbit['team_names'] if rabbit else None)
|
||||
install_team_screen_guard(log=log)
|
||||
install_gift_confirm_guard(log=log) # 「获得E.G.O饰品」点不关时换落点/结束任务(ISSUES I-06)
|
||||
install_image_error_guard(log=log) # 截图连续识别失败即结束任务(防窗口没了还空转)
|
||||
install_typed_keyboard_road(log=log)
|
||||
install_gift_preference(log=log)
|
||||
install_event_choices(log=log)
|
||||
install_shop_audit(log=log)
|
||||
install_shop_by_name(log=log) # 装在审计之后(包在外层), 审计才看得到按名字点的那一下
|
||||
if rabbit: # 卡包按体系加分(BACKLOG R-01); 兔子洞再给攻略路线上的卡包加分
|
||||
install_theme_pack_systems(log=log, route=rabbit['theme_packs'], route_name='兔子洞路线')
|
||||
else:
|
||||
install_theme_pack_systems(log=log)
|
||||
install_theme_pack_audit(log=log) # 装在加分之后(包在外层), 审计记得到加分
|
||||
if rabbit:
|
||||
install_rabbit_hole(log=log, config=rabbit)
|
||||
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):
|
||||
with driver_click_tasks(scheme, auto, screen, cfg, log=log), \
|
||||
mirror_progress(scheme) as progress:
|
||||
try:
|
||||
if task == 'all':
|
||||
scheme.script_task()
|
||||
return 0
|
||||
with headless_hdr_warning(scheme, log=log):
|
||||
scheme.script_task()
|
||||
return mirror_result(task, progress)
|
||||
# 与 script_task() 相同的前置步骤
|
||||
scheme.init_game()
|
||||
path_manager.initialize_paths()
|
||||
@@ -109,7 +196,10 @@ def run(task, params):
|
||||
'enkephalin': scheme.Buy_enkephalin,
|
||||
'mirror': scheme.Mirror_task,
|
||||
}[task]()
|
||||
return 0
|
||||
return mirror_result(task, progress)
|
||||
except TaskAbort as e:
|
||||
log('[ERROR] [lc_mcp] 任务中止: %s' % e)
|
||||
return INCOMPLETE_EXIT
|
||||
finally:
|
||||
guard.stop()
|
||||
retry_monitor.stop()
|
||||
@@ -126,10 +216,16 @@ def main(argv):
|
||||
return 2
|
||||
task = argv[1]
|
||||
params = json.loads(argv[2]) if len(argv) > 2 else {}
|
||||
unknown = set(params) - set(TASKS[task])
|
||||
options = TASK_OPTIONS.get(task, {})
|
||||
unknown = set(params) - set(TASKS[task]) - set(options)
|
||||
if unknown:
|
||||
print('unknown params for %s: %s' % (task, ', '.join(sorted(unknown))), file=sys.stderr)
|
||||
return 2
|
||||
bad = {k: v for k, v in params.items() if k in options and v not in options[k]}
|
||||
if bad:
|
||||
print('bad option for %s: %s' % (task, ', '.join('%s=%r' % kv for kv in sorted(bad.items()))),
|
||||
file=sys.stderr)
|
||||
return 2
|
||||
print('[lc_mcp] task %s start %s' % (task, json.dumps(params)), flush=True)
|
||||
code = run(task, params)
|
||||
if code:
|
||||
|
||||
@@ -0,0 +1,43 @@
|
||||
{
|
||||
"_说明": [
|
||||
"镜牢事件选项表(BACKLOG P1-4)。只在事件出现选项时生效; 认不出的事件、或要点的那项没读到时, 交给 AALC 原逻辑。",
|
||||
"认事件: options 里的每一句都出现在这一屏的选项里, 才算这个事件(按表顺序, 先命中的生效); 然后点包含 text 的那一项。",
|
||||
"零协汉化的事件数据没有标题字段, 画面上也不保证有事件名, 所以不按事件名认; name 只用于日志。",
|
||||
"文字都先归一再比较: 去空白、全角转半角、去标点、改回常见误读。整表关闭: 任务环境变量 LCP_EVENT_CHOICES=0。",
|
||||
"id 是零协汉化 LLC_zh-CN/ActionEvents_*.json 里的事件 id; options/text 照抄那里的选项原文(2026-11-15 按本机装的 release 2026111301 核对)。",
|
||||
"同一套选项在别的文件里有复刻(如 ActionEvents.json 910301/910302 与地狱鸡两条选项、结果都相同)时会一起命中, 选的是同一项。",
|
||||
"check=true 表示选了之后还要罪人判定(由 AALC 原逻辑挑成功率最高的人格); 其余都是无判定、无战斗的直出。",
|
||||
"选择依据: docs/skills/limbus-mirror-speedrun/references/event-choices.md(依据边狱公司中文 Wiki 社区「探索事件」, CC BY-SA 4.0)。",
|
||||
"蜘蛛巢、归乡路途两条的结果依据 Limbus Company Wiki(wiki.gg) Spider of Marriage / Smokey Old Man 条目(CC BY-SA 4.0), 2026-11-15 核对。",
|
||||
"选项原文来自零协汉化 LocalizeLimbusCompany(https://github.com/LocalizeLimbusCompany/LocalizeLimbusCompany, CC BY-NC-SA 4.0)。"
|
||||
],
|
||||
"events": [
|
||||
{"name": "红色坐像", "id": 901010, "file": "ActionEvents_Mirror.json",
|
||||
"options": ["摘下黄铜戒指。", "放上钱币。"], "text": "侧耳倾听。",
|
||||
"note": "2 是色欲/暴食优势判定, 3 是战斗; 1 无判定"},
|
||||
{"name": "炸鸡对决", "id": 971001, "file": "ActionEvents_Mirror4.json",
|
||||
"options": ["绝对是鸡腿,满满的汁液。", "鸡胸,肯定的,纯净无瑕。"], "text": "鸡肉就是鸡肉喽。",
|
||||
"note": "选择后获得 1 件烧伤和 1 件破裂 E.G.O 饰品"},
|
||||
{"name": "鸡群的激情探戈", "id": 971003, "file": "ActionEvents_Mirror4.json",
|
||||
"options": ["真心提醒。", "暗暗提示。"], "text": "视而不见。",
|
||||
"note": "选择后获得 1 件泛用 E.G.O 饰品; 1 要看后续选项, 3 只有 50% 概率"},
|
||||
{"name": "梦中的电子羊", "id": 901038, "file": "ActionEvents_Mirror.json",
|
||||
"options": ["你是特别的。"], "text": "你不是特别的。",
|
||||
"note": "选择后获得 1 件泛用 E.G.O 饰品"},
|
||||
{"name": "失明巨人递来患者记录", "id": 901085, "file": "ActionEvents_Mirror3.json",
|
||||
"options": ["如实回答。"], "text": "说上面什么都没有写。", "check": true,
|
||||
"note": "两项都是判定: 1 忧郁/色欲(门槛 16), 2 忧郁/怠惰(门槛 14, 成功获得打击饰品); AALC 不区分两项, 点它认出的那个优势判定"},
|
||||
{"name": "破碎罗盘(冻僵的尸体指路)", "id": 901095, "file": "ActionEvents_Mirror3.json",
|
||||
"options": ["向裂开的手所指的北方。", "向警告的手所指的东方。", "向折断的手所指的西方。"], "text": "返回。",
|
||||
"note": "第 4 项直接结束; 其余方向都还有后续分支"},
|
||||
{"name": "蜘蛛巢(结婚蜘蛛)", "id": 901028, "file": "ActionEvents_Mirror.json",
|
||||
"options": ["扯断棘蔓。"], "text": "摘下一朵花。",
|
||||
"note": "1 直接给饰品「偏见」, 非傲慢人格扣 5 体力、傲慢人格回 15; 2 是 50% 判定, 成功全体降 10 理智, 失败全体扣 10 体力"},
|
||||
{"name": "归乡路途(烟雾老人)", "id": 901039, "file": "ActionEvents_Mirror.json",
|
||||
"options": ["不听故事离开。"], "text": "告诉它你们很乐意听些故事。",
|
||||
"note": "1 进入下一段选择; 2 直接离开但全体降 30 理智"},
|
||||
{"name": "归乡路途(第二段: 那幅画)", "id": 90103901, "file": "ActionEvents_Mirror.json",
|
||||
"options": ["留下这幅画。"], "text": "带走这幅画。",
|
||||
"note": "1 获得饰品「归途」(商店必买之一); 2 得 50 经费但全体降 15 理智"}
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,20 @@
|
||||
{
|
||||
"_说明": [
|
||||
"镜牢饰品三选一/二选一按体系关键词排序(BACKLOG P1-3)。键是 AALC 的体系名(all_systems), 值是关键词。",
|
||||
"卡面 OCR 文本先归一(去空白、全角转半角、改回 震颐/沉论 等实测误读), 英文不分大小写, 子串命中即算。",
|
||||
"命中行数多的卡排前面; 白棉花、已持有仍按 AALC 原逻辑处理。整表关闭: 任务环境变量 LCP_GIFT_KEYWORDS=0。",
|
||||
"以 _ 开头的键会被忽略。",
|
||||
"中文关键词按零协汉化核对(LLC_zh-CN/EgoGiftCategory.json、BattleKeywords.json, 2026-11-14): 烧伤 流血 震颤 破裂 沉沦 呼吸法 充能 斩击 突刺 打击。",
|
||||
"饰品描述里的 [Combustion] 等占位符在游戏里显示成上面的名字; 呼吸法写成 呼吸, 漏读 法 也能命中。"
|
||||
],
|
||||
"burn": ["烧伤", "burn"],
|
||||
"bleed": ["流血", "bleed"],
|
||||
"tremor": ["震颤", "tremor"],
|
||||
"rupture": ["破裂", "rupture"],
|
||||
"sinking": ["沉沦", "sinking"],
|
||||
"poise": ["呼吸", "poise"],
|
||||
"charge": ["充能", "charge"],
|
||||
"slash": ["斩击", "slash"],
|
||||
"pierce": ["突刺", "pierce"],
|
||||
"blunt": ["打击", "blunt"]
|
||||
}
|
||||
@@ -0,0 +1,21 @@
|
||||
{
|
||||
"_说明": [
|
||||
"镜牢「兔子洞」速刷(Mao Hollow Faust): 黑兽 - 卯 魁首 浮士德 + 浮士德的 E.G.O「空洞」。run_task(task=\"mirror\", strategy=\"rabbit_hole\") 时生效。",
|
||||
"每回合: 按 P(胜率) → 长按浮士德(press_at)打开 E.G.O 列表 → OCR 找 ego_names 里的名字, 单击放 E.G.O(每场第一回合长按 = 超频) → 按 Enter。",
|
||||
"游戏数据(零协 release 2026111301): 人格 id 10212; E.G.O id 20211「空洞」。普通「空洞」不打敌人, 只给自己叠 5 发弹孔; 弹孔不低于 1 发时改用「填补空洞」(大伤害);",
|
||||
"超频(侵蚀)的「空洞」直接随机打人。E.G.O 被动「排离空洞」: 弹孔满 5 发时「空洞」(觉醒、侵蚀)不耗 E.G.O 资源, 每回合开始 +1 发弹孔。",
|
||||
"超频: 游戏教程「在战斗中选择 E.G.O 技能时, 可以长按 E.G.O 来使用 E.G.O 超频」, 1.5 倍 E.G.O 资源和理智; 资源够 1.5 倍是稳定超频(只打敌人), 不够是不稳定超频(不分敌我, 缺的资源扣成负数)。",
|
||||
"overclock_first_turn: 每场战斗第一回合超频(OurPlay 攻略「前期每战第一回合侵蚀空洞」), 之后的回合单击。后期 Boss 攻略改成第一回合普通「空洞」, 这里不区分。",
|
||||
"press_at 是长按点在游戏客户区里的位置(宽、高的比例, 0~1), 必须在实机上量。游戏教程是「按住罪人的头像以打开其 E.G.O 列表」, wiki.gg 写的是按住技能格, 以实机为准。",
|
||||
"press_at 为 null 时不点任何东西, 记一条 [ERROR] 后按 AALC 原来的 P+Enter 打。team_names 是这套打法用的编队名(游戏里自己建)。",
|
||||
"hold_seconds 是 AALC mouse_drag 的停留时间, 它松开前还会再按住 0.5 秒, 实际按住约 hold_seconds+0.5 秒; 长按头像和超频长按卡片都用它。",
|
||||
"theme_packs: 攻略路线上的卡包 {中文名: 加分}, 加在 AALC 原权重上(没有体系也加)。OurPlay 全程困难路线: 1 层身无分文的赌徒 → 2 层地狱鸡 → 3 层去·海·边 → 4 层憎恶与绝望 → 5 层 2号线。",
|
||||
"AALC 默认权重(困难 + 中文): 赌徒 0、地狱鸡 1、海边 0、绝望 -5、号线 -5; 憎恶与绝望多加 2 分, 4 层和 2号线同时出现时先选它(2号线 4、5 层都会出)。LCP_THEME_PACK_SYSTEMS=0 时路线加分一起关掉。"
|
||||
],
|
||||
"team_names": ["兔子洞"],
|
||||
"ego_names": ["空洞"],
|
||||
"press_at": null,
|
||||
"hold_seconds": 1.0,
|
||||
"overclock_first_turn": true,
|
||||
"theme_packs": {"身无分文的赌徒": 10, "地狱鸡": 10, "去·海·边": 10, "憎恶与绝望": 12, "2号线": 10}
|
||||
}
|
||||
@@ -0,0 +1,17 @@
|
||||
{
|
||||
"_说明": [
|
||||
"镜牢商店按中文名购买(BACKLOG P2-6)。AALC 必买项之前先按这张表 OCR 商店格子下面的名字, 命中就买; 靠前的先买。",
|
||||
"只认与名字完全一致的格子(去空白、标点, 允许强化后缀 +); AALC 的 5 张必买图标模板仍在后面兜底。整表关闭: 任务环境变量 LCP_SHOP_NAMES=0。",
|
||||
"默认 5 个就是 AALC 必买模板(assets/images/default/share/mirror/shop/must_purchase/*.png)对应的饰品, 中文名按零协汉化 LLC_zh-CN/EGOgift_MirrorDungeon.json(2026-11-14 核对 LocalizeLimbusCompany@231a8bc)。",
|
||||
"AALC 日志把必买项叫'回血饰品', 核对描述后只有 采血包/归途/石版字符 是回血; 缘分残片 是全队 +5 级, 卡蜜拉 是每场非集中战先削敌人 20% 体力。",
|
||||
"顺序是建议: 立即见效的放前面, 再按回血量。可以加别的饰品名, 写零协汉化里的名字原文。",
|
||||
"饰品名来自零协汉化 LocalizeLimbusCompany(https://github.com/LocalizeLimbusCompany/LocalizeLimbusCompany, CC BY-NC-SA 4.0)。"
|
||||
],
|
||||
"gifts": [
|
||||
{"name": "缘分残片", "id": 9082, "template": "piece_of_relationship.png", "note": "获得时编队所有人格提升 5 级"},
|
||||
{"name": "卡蜜拉", "id": 9036, "template": "carmilla.png", "note": "非集中遭遇战开始时, 对全体敌人造成体力上限 20% 的固定伤害"},
|
||||
{"name": "采血包", "id": 9004, "template": "phlebotomy_pack.png", "note": "技能造成伤害时恢复已失去体力的 12.5%(暴怒技能 25%)"},
|
||||
{"name": "归途", "id": 9039, "template": "homeward.png", "note": "关卡开始时全体恢复体力上限 12% 的体力"},
|
||||
{"name": "石版字符", "id": 9017, "template": "lithograph.png", "note": "敌人陷入混乱时, 体力最低的人格恢复体力上限 5%(有暴食攻击技能 10%)"}
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
{
|
||||
"_说明": [
|
||||
"体系 -> 优先队名(按顺序试), 覆盖 SYSTEM_TEAM_NAMES 里的默认名。2026-11-16 用户指定: 走震颤队, 不要再选镜像迷宫。",
|
||||
"改名或换队就改这里; 整表关闭: 任务环境变量 LCP_TEAM_NAMES=0。",
|
||||
"体系本身跟着 config.yaml 的 team_system 走(现在 = 2 震颤), 商店/饰品的体系判断也按它。"
|
||||
],
|
||||
"tremor": ["震颤"]
|
||||
}
|
||||
@@ -0,0 +1,175 @@
|
||||
{
|
||||
"_说明": [
|
||||
"镜牢卡包按当局队伍体系加分(BACKLOG R-01 / ISSUES I-08)。只在选卡包时临时加到 AALC 的权重上, 不改 theme_pack_list.yaml。",
|
||||
"featured: 这个卡包「Featured Gifts」掉的是哪个体系的饰品(体系包, 如 电闪雷鸣/动力渐盈 = 充能); unique: 专属饰品里各体系各几件。",
|
||||
"加分 = max(bonus.featured(体系包), bonus.unique[专属饰品件数, 超过按最后一档], bonus.recommend(社区推荐)); 社区说这个体系不划算的不加; 速刷要避开的再减 bonus.avoid。AALC 原权重 + 加分 = 这一局的权重。",
|
||||
"社区推荐/避开写在 community 里(带来源), 重新生成 packs 时保留。",
|
||||
"默认档位让体系包和专属饰品 ≥3 件的包压过 AALC 的 -5(比如充能队会选 WARP快车谋杀案), 2 件的压过 -3 以内; 想保守就把数字调小。",
|
||||
"normal/hard 是出现楼层, 只做参考, 不参与计算。没有 featured/unique 的卡包不加分。",
|
||||
"数据由 scripts/build_theme_pack_systems.py 生成: 卡包条目与饰品体系来自 Limbus Company Wiki(https://limbuscompany.wiki.gg, CC BY-SA 4.0), 2026-11-15 抓取;",
|
||||
"中文名来自零协汉化 LLC_zh-CN/MirrorDungeonTheme-1.json(release 2026111301, CC BY-NC-SA 4.0)。边狱巴士 BWIKI 没有卡包条目。",
|
||||
"整表关闭: 任务环境变量 LCP_THEME_PACK_SYSTEMS=0; 设为 JSON 文件路径时用它代替本表。"
|
||||
],
|
||||
"bonus": {"featured": 6, "unique": [0, 1, 4, 6], "recommend": 6, "avoid": 3},
|
||||
"community": {
|
||||
"_说明": [
|
||||
"社区攻略的选包建议(2026-11-15 用 codex CLI 联网检索整理, 检索记录见 docs/feedback/2026-11-15/theme-pack-research.md)。",
|
||||
"recommend: 攻略推荐这个体系走这个卡包, 加 bonus.recommend(和 featured/unique 取大的)。只收普通难度会出现的卡包。",
|
||||
"avoid: systems 为 [\"*\"] 的是速刷攻略说拖时间的卡包, 所有体系都减 bonus.avoid; 写了具体体系的只是对该体系不划算, 那个体系不加分。",
|
||||
"来源多是旧赛季或困难/单通路线, 只当倾向用; 灰机 wiki 的卡包数据表已标「停止更新」, 层数以 packs 里 wiki.gg 的为准。",
|
||||
"WARP快车谋杀案 的「流血 1」是 wiki.gg 把血液结晶归为流血, 中文事件文本说是泛用饰品; 只影响流血队 +1, 暂不改。"
|
||||
],
|
||||
"recommend": [
|
||||
{"pack": "地狱鸡", "systems": ["burn", "tremor", "poise"], "source": "https://steamcommunity.com/sharedfiles/filedetails/?id=3010191708", "note": "S7 速刷路线 2 层"},
|
||||
{"pack": "地狱鸡", "systems": ["rupture"], "source": "https://www.taptap.cn/moment/664273800250000543", "note": "旧镜5 普牢破裂速刷"},
|
||||
{"pack": "憎恶与绝望", "systems": ["burn", "tremor"], "source": "https://steamcommunity.com/sharedfiles/filedetails/?id=3010191708", "note": "S7 烧震速刷 3 层: 免判定事件、战斗少"},
|
||||
{"pack": "憎恶与绝望", "systems": ["sinking", "charge"], "source": "https://www.ourplay.net/planet/thread/758301", "note": "单通: 拿沉沦/充能饰品(泪锋之剑、未被选中之人)"},
|
||||
{"pack": "LCB定期体检", "systems": ["burn"], "source": "https://www.ourplay.net/planet/thread/497714", "note": "旧困牢"},
|
||||
{"pack": "LCB定期体检", "systems": ["rupture"], "source": "https://www.gamemale.com/thread-177147-1-1.html", "note": "旧版呼破 15 层"},
|
||||
{"pack": "绞丝结线", "systems": ["bleed", "charge"], "source": "https://www.ourplay.net/planet/thread/758301", "note": "单通可选"},
|
||||
{"pack": "时间杀人时间", "systems": ["tremor"], "source": "https://www.ourplay.net/planet/thread/715281", "note": "专属震颤饰品提升大"},
|
||||
{"pack": "无归属者", "systems": ["rupture"], "source": "https://www.taptap.cn/moment/664273800250000543", "note": "旧镜5 普牢破裂速刷"},
|
||||
{"pack": "深夜清扫", "systems": ["rupture"], "source": "https://www.gamemale.com/thread-177147-1-1.html", "note": "旧版呼破 15 层"},
|
||||
{"pack": "切磋琢春", "systems": ["rupture"], "source": "https://www.gamemale.com/thread-177147-1-1.html", "note": "旧版呼破 15 层; 另一篇单通攻略评价低"},
|
||||
{"pack": "琥珀色的黄昏", "systems": ["sinking"], "source": "https://www.ourplay.net/planet/thread/758301", "note": "单通可选"},
|
||||
{"pack": "由子弹画下的句点", "systems": ["poise"], "source": "https://www.ourplay.net/planet/thread/497714", "note": "旧困牢"},
|
||||
{"pack": "20区的奇迹", "systems": ["poise"], "source": "https://www.ourplay.net/planet/thread/497714", "note": "旧困牢"},
|
||||
{"pack": "WARP快车谋杀案", "systems": ["charge"], "source": "https://www.ourplay.net/planet/thread/497714", "note": "旧困牢"},
|
||||
{"pack": "经验记忆", "systems": ["slash"], "source": "https://www.ourplay.net/planet/thread/758301", "note": "单通必走"},
|
||||
{"pack": "身无分文的赌徒", "systems": ["pierce"], "source": "https://www.bilibili.com/opus/1200031368835235848", "note": "纯P突刺 1 层"},
|
||||
{"pack": "去·海·边", "systems": ["pierce"], "source": "https://www.bilibili.com/opus/1200031368835235848", "note": "纯P突刺 2 层"},
|
||||
{"pack": "当贯之物", "systems": ["pierce"], "source": "https://www.bilibili.com/opus/1200031368835235848", "note": "纯P突刺 3 层"},
|
||||
{"pack": "20区的奇迹", "systems": ["pierce"], "source": "https://www.bilibili.com/opus/1200031368835235848", "note": "纯P突刺 4 层优先"}
|
||||
],
|
||||
"avoid": [
|
||||
{"pack": "被遗忘者们", "systems": ["*"], "source": "https://steamcommunity.com/sharedfiles/filedetails/?id=3010191708", "note": "时钟加不断出现的小怪, 自动战斗常拖到 5 回合以上"},
|
||||
{"pack": "自动工厂", "systems": ["*"], "source": "https://steamcommunity.com/sharedfiles/filedetails/?id=3010191708", "note": "可能遇到机器人, 拖时间"},
|
||||
{"pack": "当碎之物", "systems": ["*"], "source": "https://steamcommunity.com/sharedfiles/filedetails/?id=3010191708", "note": "可能遇到机器人, 拖时间"},
|
||||
{"pack": "琥珀色的黄昏", "systems": ["bleed"], "source": "https://www.ourplay.net/planet/thread/758301", "note": "流血有效收益只有「泛音」"}
|
||||
]
|
||||
},
|
||||
"packs": [
|
||||
{"id": 1001, "zh": "被遗忘者们", "en": "The Forgotten", "normal": "1F", "hard": "1F", "featured": [], "unique": {}},
|
||||
{"id": 1002, "zh": "无归属者", "en": "The Outcast", "normal": "1F", "hard": "1F", "featured": [], "unique": {"bleed": 1, "rupture": 1}},
|
||||
{"id": 1003, "zh": "身无分文的赌徒", "en": "Flat-broke Gamblers", "normal": "1F,2F", "hard": "1F", "featured": [], "unique": {}},
|
||||
{"id": 1004, "zh": "自动工厂", "en": "Automated Factory", "normal": "1F,2F", "hard": "1F,2F", "featured": [], "unique": {"sinking": 1, "tremor": 1}},
|
||||
{"id": 1005, "zh": "无法去爱", "en": "The Unloving", "normal": "1F,2F", "hard": "1F,2F", "featured": [], "unique": {"sinking": 1}},
|
||||
{"id": 1006, "zh": "钉与锤", "en": "Nagel und Hammer", "normal": "1F", "hard": "1F", "featured": [], "unique": {}},
|
||||
{"id": 1007, "zh": "信仰与侵蚀", "en": "Faith & Erosion", "normal": "1F,2F", "hard": "1F", "featured": [], "unique": {"bleed": 1}},
|
||||
{"id": 1008, "zh": "未曾面对", "en": "The Unconfronting", "normal": "3F", "hard": "2F,3F", "featured": [], "unique": {"bleed": 1}},
|
||||
{"id": 1009, "zh": "巢、工坊、技术", "en": "Nest, Workshop, and Technology", "normal": "1F,2F", "hard": "1F", "featured": [], "unique": {}},
|
||||
{"id": 1010, "zh": "落花", "en": "Falling Flowers", "normal": "3F", "hard": "2F,3F", "featured": [], "unique": {}},
|
||||
{"id": 1011, "zh": "落泪者们", "en": "Tearful Things", "normal": "4F,5F", "hard": "3F,4F", "featured": [], "unique": {}},
|
||||
{"id": 1012, "zh": "无改变者", "en": "The Unchanging", "normal": "", "hard": "4F,5F,6F-10F", "featured": [], "unique": {}},
|
||||
{"id": 1013, "zh": "湖的世界", "en": "Lake World", "normal": "2F", "hard": "1F", "featured": [], "unique": {}},
|
||||
{"id": 1014, "zh": "伏行深渊", "en": "Crawling Abyss", "normal": "4F,5F", "hard": "3F,4F", "featured": [], "unique": {"poise": 1}},
|
||||
{"id": 1015, "zh": "定义为恶", "en": "The Evil Defining", "normal": "", "hard": "4F,5F,6F-10F", "featured": [], "unique": {"poise": 1}},
|
||||
{"id": 1016, "zh": "宅邸的副产物", "en": "Dregs of the Manor", "normal": "3F", "hard": "1F", "featured": [], "unique": {"sinking": 1}},
|
||||
{"id": 1017, "zh": "某个世界", "en": "A Certain World", "normal": "4F,5F", "hard": "3F,4F", "featured": [], "unique": {}},
|
||||
{"id": 1018, "zh": "心意相悖", "en": "The Heartbreaking", "normal": "", "hard": "5F,6F-10F", "featured": [], "unique": {"sinking": 1}},
|
||||
{"id": 1019, "zh": "重新开园的拉·曼却领", "en": "La Manchaland Re-opening", "normal": "", "hard": "5F,6F-10F", "featured": [], "unique": {"bleed": 5}},
|
||||
{"id": 1020, "zh": "无尽的游行", "en": "The Infinite Procession", "normal": "", "hard": "5F,6F-10F", "featured": [], "unique": {"bleed": 5}},
|
||||
{"id": 1021, "zh": "梦之终焉", "en": "The Dream Ending", "normal": "", "hard": "5F,6F-10F", "featured": [], "unique": {"bleed": 5}},
|
||||
{"id": 1022, "zh": "四大家族与欲念", "en": "Four Houses and Greed", "normal": "", "hard": "5F,6F-10F", "featured": [], "unique": {"charge": 1}},
|
||||
{"id": 1023, "zh": "不思观望", "en": "The Surrendered Witnessing", "normal": "", "hard": "5F,6F-10F", "featured": [], "unique": {"poise": 1, "rupture": 1}},
|
||||
{"id": 1024, "zh": "魅惑、彷徨、猜疑", "en": "Charm, Wander, Doubt", "normal": "4F,5F", "hard": "3F,4F", "featured": [], "unique": {"bleed": 1, "blunt": 1}},
|
||||
{"id": 1025, "zh": "教材", "en": "Textbook", "normal": "", "hard": "5F,6F-10F", "featured": [], "unique": {"burn": 1, "tremor": 2}},
|
||||
{"id": 1026, "zh": "刀与作品", "en": "Blade and Artwork", "normal": "", "hard": "5F,6F-10F", "featured": [], "unique": {"bleed": 2, "poise": 1}},
|
||||
{"id": 1027, "zh": "无割舍者", "en": "The Unsevering", "normal": "", "hard": "5F,6F-10F", "featured": [], "unique": {"poise": 1, "sinking": 1}},
|
||||
{"id": 1028, "zh": "开店抢购", "en": "Storefront Campout", "normal": "3F,4F", "hard": "3F,4F", "featured": [], "unique": {"charge": 2}},
|
||||
{"id": 1029, "zh": "纷繁的色彩", "en": "An Anarchy of Colors", "normal": "", "hard": "4F,5F,6-10F", "featured": [], "unique": {"charge": 2}},
|
||||
{"id": 1030, "zh": "保存的信念", "en": "Creed of Preservation", "normal": "", "hard": "4F,5F,6-10F", "featured": [], "unique": {"charge": 1, "tremor": 1}},
|
||||
{"id": 1031, "zh": "暴食重临", "en": "Readvent of Gluttony", "normal": "", "hard": "4F,5F,6-10F", "featured": [], "unique": {}},
|
||||
{"id": 1101, "zh": "地狱鸡", "en": "Hell's Chicken", "normal": "2F", "hard": "2F", "featured": [], "unique": {"bleed": 1, "burn": 1, "rupture": 1}},
|
||||
{"id": 1102, "zh": "去·海·边", "en": "S.E.A.", "normal": "2F", "hard": "2F,3F", "featured": [], "unique": {"rupture": 1, "tremor": 1}},
|
||||
{"id": 1103, "zh": "20区的奇迹", "en": "Miracle in District 20", "normal": "4F", "hard": "3F,4F", "featured": [], "unique": {"poise": 2}},
|
||||
{"id": 1104, "zh": "肉斩骨断", "en": "Yield My Flesh to Claim Their Bones", "normal": "4F,5F", "hard": "3F,4F", "featured": [], "unique": {"bleed": 1, "poise": 2}},
|
||||
{"id": 1105, "zh": "时间杀人时间", "en": "Timekilling Time", "normal": "4F,5F", "hard": "4F,5F,6F-10F", "featured": [], "unique": {"tremor": 5}},
|
||||
{"id": 1106, "zh": "WARP快车谋杀案", "en": "Murder on the WARP Express", "normal": "4F,5F", "hard": "4F,5F,6F-10F", "featured": [], "unique": {"bleed": 1, "charge": 5}},
|
||||
{"id": 1107, "zh": "紫罗兰的正午", "en": "The Noon of Violet", "normal": "4F", "hard": "3F,4F", "featured": [], "unique": {"bleed": 1, "charge": 1, "sinking": 3}},
|
||||
{"id": 1108, "zh": "1号线", "en": "Line 1", "normal": "", "hard": "5F,6F-10F", "featured": [], "unique": {}},
|
||||
{"id": 1109, "zh": "2号线", "en": "Line 2", "normal": "", "hard": "4F,5F,6F-10F", "featured": [], "unique": {}},
|
||||
{"id": 1110, "zh": "3号线", "en": "Line 3", "normal": "", "hard": "5F,6F-10F", "featured": [], "unique": {"burn": 1}},
|
||||
{"id": 1111, "zh": "4号线 - 第3区段", "en": "Line 4 - Section 3", "normal": "", "hard": "5F,6F-10F", "featured": [], "unique": {}},
|
||||
{"id": 1112, "zh": "4号线 - 第4区段", "en": "Line 4 - Section 4", "normal": "", "hard": "5F,6F-10F", "featured": [], "unique": {}},
|
||||
{"id": 1113, "zh": "20区的奇迹 复刻", "en": "Miracle in District 20 BokGak", "normal": "", "hard": "4F,5F,6F-10F", "featured": [], "unique": {"poise": 2, "tremor": 1}},
|
||||
{"id": 1114, "zh": "由子弹画下的句点", "en": "Full-Stopped by a Bullet", "normal": "4F", "hard": "3F,4F", "featured": [], "unique": {"pierce": 2, "poise": 2}},
|
||||
{"id": 1115, "zh": "LCB定期体检", "en": "LCB Regular Check-up", "normal": "5F", "hard": "4F,5F,6F-10F", "featured": ["burn", "rupture"], "unique": {"burn": 3, "rupture": 3}},
|
||||
{"id": 1116, "zh": "肉斩骨断 复刻", "en": "Yield My Flesh to Claim Their Bones BokGak", "normal": "", "hard": "4F,5F,6F-10F", "featured": [], "unique": {"bleed": 1, "poise": 2, "slash": 2}},
|
||||
{"id": 1117, "zh": "深夜清扫", "en": "Nocturnal Sweeping", "normal": "5F", "hard": "4F,5F,6F-10F", "featured": ["rupture"], "unique": {"blunt": 2, "rupture": 3, "slash": 1}},
|
||||
{"id": 1118, "zh": "5号线", "en": "Line 5", "normal": "", "hard": "5F,6F-10F", "featured": [], "unique": {"bleed": 1, "poise": 1}},
|
||||
{"id": 1119, "zh": "憎恶与绝望", "en": "Hatred and Despair", "normal": "3F,4F", "hard": "3F,4F", "featured": [], "unique": {"charge": 2, "sinking": 2}},
|
||||
{"id": 1120, "zh": "时间杀人时间 复刻", "en": "Timekilling Time BokGak", "normal": "", "hard": "4F,5F,6F-10F", "featured": [], "unique": {"tremor": 8}},
|
||||
{"id": 1121, "zh": "切磋琢春", "en": "Spring Cultivation", "normal": "5F", "hard": "5F,6F-10F", "featured": [], "unique": {"burn": 1, "rupture": 3, "slash": 1, "tremor": 1}},
|
||||
{"id": 1122, "zh": "善意的巡礼", "en": "Pilgrimage of Compassion", "normal": "4F,5F", "hard": "4F,5F,6-10F", "featured": [], "unique": {"poise": 1, "rupture": 1, "sinking": 1, "tremor": 1}},
|
||||
{"id": 1123, "zh": "WARP快车谋杀案 复刻", "en": "Murder on the WARP Express BokGak", "normal": "", "hard": "4F,5F,6F-10F", "featured": [], "unique": {"bleed": 3, "charge": 7}},
|
||||
{"id": 1124, "zh": "琥珀色的黄昏", "en": "The Dusk of Amber", "normal": "4F,5F", "hard": "4F,5F,6F-10F", "featured": [], "unique": {"bleed": 3, "burn": 1, "sinking": 2}},
|
||||
{"id": 1125, "zh": "LCB定期体检 复刻", "en": "LCB Regular Check-up BokGak", "normal": "", "hard": "4F,5F,6F-10F", "featured": ["burn", "rupture"], "unique": {"burn": 4, "charge": 1, "rupture": 4}},
|
||||
{"id": 1126, "zh": "绞丝结线", "en": "Twining Threads", "normal": "5F", "hard": "5F,6F-10F", "featured": [], "unique": {"bleed": 2, "blunt": 1, "charge": 1, "sinking": 1}},
|
||||
{"id": 1127, "zh": "深夜清扫 复刻", "en": "Nocturnal Sweeping BokGak", "normal": "", "hard": "4F,5F,6F-10F", "featured": ["rupture"], "unique": {"blunt": 3, "rupture": 4, "slash": 1}},
|
||||
{"id": 1128, "zh": "经验记忆", "en": "Mnestic Experience", "normal": "5F", "hard": "5F,6F-10F", "featured": [], "unique": {"bleed": 1, "poise": 1, "slash": 3}},
|
||||
{"id": 1129, "zh": "黎明后贯穿而来之楔", "en": "The Wedge in the Wake of Dawnbreak", "normal": "5F", "hard": "5F,6F-10F", "featured": [], "unique": {"pierce": 3, "tremor": 2}},
|
||||
{"id": 1201, "zh": "斩切者们", "en": "Slicers & Dicers", "normal": "5F", "hard": "4F", "featured": ["slash"], "unique": {}},
|
||||
{"id": 1202, "zh": "当斩之物", "en": "To be Cleaved", "normal": "2F,3F", "hard": "1F,2F", "featured": ["slash"], "unique": {}},
|
||||
{"id": 1203, "zh": "穿刺者们", "en": "Piercers & Penetrators", "normal": "5F", "hard": "4F", "featured": ["pierce"], "unique": {}},
|
||||
{"id": 1204, "zh": "当贯之物", "en": "To be Pierced", "normal": "2F,3F", "hard": "1F,2F", "featured": ["pierce"], "unique": {}},
|
||||
{"id": 1205, "zh": "粉碎者们", "en": "Crushers & Breakers", "normal": "5F", "hard": "4F", "featured": ["blunt"], "unique": {}},
|
||||
{"id": 1206, "zh": "当碎之物", "en": "To be Crushed", "normal": "2F,3F", "hard": "1F,2F", "featured": ["blunt"], "unique": {}},
|
||||
{"id": 1301, "zh": "压抑的暴怒", "en": "Repressed Wrath", "normal": "4F,5F", "hard": "3F,4F", "featured": [], "unique": {}},
|
||||
{"id": 1302, "zh": "解放的暴怒", "en": "Unbound Wrath", "normal": "", "hard": "5F,6F-10F", "featured": [], "unique": {"burn": 2}},
|
||||
{"id": 1303, "zh": "受情感压迫者", "en": "Emotional Repression", "normal": "3F", "hard": "2F", "featured": [], "unique": {}},
|
||||
{"id": 1304, "zh": "沉迷的色欲", "en": "Addicting Lust", "normal": "4F,5F", "hard": "3F,4F", "featured": [], "unique": {}},
|
||||
{"id": 1305, "zh": "束缚的色欲", "en": "Tangling Lust", "normal": "", "hard": "5F,6F-10F", "featured": [], "unique": {}},
|
||||
{"id": 1306, "zh": "因情感困惑者", "en": "Emotional Seduction", "normal": "3F", "hard": "2F", "featured": [], "unique": {}},
|
||||
{"id": 1307, "zh": "空转的怠惰", "en": "Treadwheel Sloth", "normal": "4F,5F", "hard": "3F,4F", "featured": [], "unique": {}},
|
||||
{"id": 1308, "zh": "停滞的怠惰", "en": "Inert Sloth", "normal": "", "hard": "5F,6F-10F", "featured": [], "unique": {}},
|
||||
{"id": 1309, "zh": "待情感懒惰者", "en": "Emotional Indolence", "normal": "3F", "hard": "2F", "featured": [], "unique": {}},
|
||||
{"id": 1310, "zh": "吞噬的暴食", "en": "Devoured Gluttony", "normal": "4F,5F", "hard": "3F,4F", "featured": [], "unique": {}},
|
||||
{"id": 1311, "zh": "漫溢的暴食", "en": "Excessive Gluttony", "normal": "", "hard": "5F,6F-10F", "featured": [], "unique": {}},
|
||||
{"id": 1312, "zh": "对情感饥渴者", "en": "Emotional Craving", "normal": "3F", "hard": "2F", "featured": [], "unique": {}},
|
||||
{"id": 1313, "zh": "堕落的忧郁", "en": "Degraded Gloom", "normal": "4F,5F", "hard": "3F,4F", "featured": [], "unique": {}},
|
||||
{"id": 1314, "zh": "沉溺的忧郁", "en": "Sunk Gloom", "normal": "", "hard": "5F,6F-10F", "featured": [], "unique": {"sinking": 1}},
|
||||
{"id": 1315, "zh": "于情感沉溺者", "en": "Emotional Flood", "normal": "3F", "hard": "2F", "featured": [], "unique": {}},
|
||||
{"id": 1316, "zh": "虚张声势的傲慢", "en": "Vain Pride", "normal": "4F,5F", "hard": "3F,4F", "featured": [], "unique": {}},
|
||||
{"id": 1317, "zh": "自以为是的傲慢", "en": "Tyrannical Pride", "normal": "", "hard": "5F,6F-10F", "featured": [], "unique": {}},
|
||||
{"id": 1318, "zh": "向情感屈从者", "en": "Emotional Subservience", "normal": "3F", "hard": "2F", "featured": [], "unique": {}},
|
||||
{"id": 1319, "zh": "寒微的嫉妒", "en": "Insignificant Envy", "normal": "4F,5F", "hard": "3F,4F", "featured": [], "unique": {}},
|
||||
{"id": 1320, "zh": "凄惨的嫉妒", "en": "Pitiful Envy", "normal": "", "hard": "5F,6F-10F", "featured": [], "unique": {}},
|
||||
{"id": 1321, "zh": "被情感评判者", "en": "Emotional Judgment", "normal": "3F", "hard": "2F", "featured": [], "unique": {}},
|
||||
{"id": 1401, "zh": "燃烧的摇曳", "en": "Burning Haze", "normal": "", "hard": "3F", "featured": ["burn"], "unique": {}},
|
||||
{"id": 1402, "zh": "盛火时节", "en": "Season of the Flame", "normal": "", "hard": "4F,5F,6F-10F", "featured": ["burn"], "unique": {"burn": 2}},
|
||||
{"id": 1403, "zh": "渗出的赤血", "en": "Trickled Sanguine Blood", "normal": "", "hard": "3F", "featured": ["bleed"], "unique": {}},
|
||||
{"id": 1404, "zh": "尸山血海", "en": "Mountain of Corpses, Sea of Blood", "normal": "", "hard": "4F,5F,6F-10F", "featured": ["bleed"], "unique": {}},
|
||||
{"id": 1405, "zh": "缭乱的波动", "en": "Dizzying Waves", "normal": "", "hard": "3F", "featured": ["tremor"], "unique": {}},
|
||||
{"id": 1406, "zh": "异常地震带", "en": "Abnormal Seismic Zone", "normal": "", "hard": "4F,5F,6F-10F", "featured": ["tremor"], "unique": {}},
|
||||
{"id": 1407, "zh": "破坏性外力", "en": "Crushing External Force", "normal": "", "hard": "3F", "featured": ["rupture"], "unique": {}},
|
||||
{"id": 1408, "zh": "破竹之势", "en": "Unrelenting Might", "normal": "", "hard": "4F,5F,6F-10F", "featured": ["rupture"], "unique": {}},
|
||||
{"id": 1409, "zh": "沉于苦痛", "en": "Sinking Pang", "normal": "", "hard": "3F", "featured": ["sinking"], "unique": {}},
|
||||
{"id": 1410, "zh": "沉沦泛滥", "en": "Sinking Deluge", "normal": "", "hard": "4F,5F,6F-10F", "featured": ["sinking"], "unique": {"sinking": 1}},
|
||||
{"id": 1411, "zh": "深沉叹息", "en": "Deep Sigh", "normal": "", "hard": "3F", "featured": ["poise"], "unique": {}},
|
||||
{"id": 1412, "zh": "循环呼吸", "en": "Poised Breathing", "normal": "", "hard": "4F,5F,6F-10F", "featured": ["poise"], "unique": {}},
|
||||
{"id": 1413, "zh": "动力渐盈", "en": "Rising Power Supply", "normal": "", "hard": "3F", "featured": ["charge"], "unique": {}},
|
||||
{"id": 1414, "zh": "电闪雷鸣", "en": "Thunder and Lightning", "normal": "", "hard": "4F,5F,6F-10F", "featured": ["charge"], "unique": {}},
|
||||
{"id": 1501, "zh": "N公司 新九人会", "en": "N Corp. New League of Nine Littérateurs", "normal": "", "hard": "", "featured": [], "unique": {}},
|
||||
{"id": 1502, "zh": "绽放的绿林", "en": "Efflorescing Greenery", "normal": "", "hard": "", "featured": [], "unique": {}},
|
||||
{"id": 1503, "zh": "3号线 - 终点站", "en": "Line 3 - Terminus", "normal": "", "hard": "", "featured": [], "unique": {}},
|
||||
{"id": 1504, "zh": "永劫的枷锁", "en": "Bridle of Infinity", "normal": "", "hard": "", "featured": [], "unique": {}},
|
||||
{"id": 1505, "zh": "去·海·边·激·蟹", "en": "S.E.A. C.R", "normal": "", "hard": "", "featured": [], "unique": {}},
|
||||
{"id": 1506, "zh": "无尽的死路", "en": "Impenetrable Path", "normal": "", "hard": "", "featured": [], "unique": {}},
|
||||
{"id": 1507, "zh": "无法成为血魔的人们", "en": "Who Couldn't Be Bloodfiends", "normal": "", "hard": "", "featured": [], "unique": {}},
|
||||
{"id": 1508, "zh": "美妙的嗓音", "en": "A Beautiful Voice", "normal": "", "hard": "", "featured": [], "unique": {}},
|
||||
{"id": 1509, "zh": "绿色的黎明", "en": "The Dawn of Green", "normal": "", "hard": "", "featured": [], "unique": {}},
|
||||
{"id": 1510, "zh": "进入某座图书馆的某本藏书", "en": "Into a Certain Library's Book", "normal": "", "hard": "", "featured": [], "unique": {}},
|
||||
{"id": 1511, "zh": "紫色编码", "en": "Code Purple", "normal": "", "hard": "", "featured": [], "unique": {}},
|
||||
{"id": 1512, "zh": "身负重担者们", "en": "Bearers of Weight", "normal": "", "hard": "", "featured": [], "unique": {}},
|
||||
{"id": 1513, "zh": "1号线 : 疯狂", "en": "Line 1 : MADNESS", "normal": "", "hard": "", "featured": [], "unique": {}},
|
||||
{"id": 1514, "zh": "充满祝福的嘉年华", "en": "Blessed Carnival", "normal": "", "hard": "", "featured": [], "unique": {"bleed": 1}},
|
||||
{"id": 1515, "zh": "精灵童话", "en": "Fairy Tale", "normal": "", "hard": "", "featured": [], "unique": {}},
|
||||
{"id": 1516, "zh": "血腥味", "en": "Bloodtinged Ichthyic Odor", "normal": "", "hard": "", "featured": [], "unique": {}},
|
||||
{"id": 1517, "zh": "即刻处刑时间", "en": "Complete & Total Extermination", "normal": "", "hard": "", "featured": [], "unique": {}},
|
||||
{"id": 1518, "zh": "拉·曼却领之主", "en": "The Master of La Manchaland", "normal": "", "hard": "", "featured": [], "unique": {"bleed": 1}},
|
||||
{"id": 1519, "zh": "插翅虎", "en": "Chachihu", "normal": "", "hard": "", "featured": [], "unique": {}},
|
||||
{"id": 1520, "zh": "仲春夜之梦2", "en": "A Midspring Night's Dream 2", "normal": "", "hard": "", "featured": [], "unique": {}},
|
||||
{"id": 3001, "zh": "凤·皇", "en": "The B.E.", "normal": "", "hard": "3F,4F,5F,6F-10F", "featured": [], "unique": {}}
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,62 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""决策审计日志(BACKLOG P2-8)。
|
||||
|
||||
任务子进程把选队/寻路/卡包/饰品/事件/商店的每个决策追加成一行 JSON, 写到 TaskRunner 给的路径
|
||||
(和任务日志同名, 后缀 .decisions.jsonl)。每行至少有 time / stage / choice / reason:
|
||||
reason 是用来计数的短类别(例如 gift 的 keyword / no_keyword), 细节放在其余字段。
|
||||
写失败只丢这一行, 不影响任务。
|
||||
"""
|
||||
import json
|
||||
import os
|
||||
import threading
|
||||
import time
|
||||
from collections import Counter
|
||||
|
||||
DECISIONS_ENV = 'LCP_DECISIONS'
|
||||
SUFFIX = '.decisions.jsonl'
|
||||
|
||||
|
||||
class DecisionLog:
|
||||
|
||||
def __init__(self, path=None):
|
||||
self.path = path
|
||||
self._lock = threading.Lock()
|
||||
|
||||
def open(self, env=None):
|
||||
"""按环境变量决定写到哪; 没设置时 record 什么也不做。"""
|
||||
env = os.environ if env is None else env
|
||||
self.path = env.get(DECISIONS_ENV) or None
|
||||
return self.path
|
||||
|
||||
def record(self, stage, choice, reason, **detail):
|
||||
if not self.path:
|
||||
return
|
||||
entry = {'time': time.strftime('%Y-%m-%dT%H:%M:%S'), 'stage': stage, 'choice': choice, 'reason': reason}
|
||||
entry.update(detail)
|
||||
line = json.dumps(entry, ensure_ascii=False, default=str) + '\n'
|
||||
try:
|
||||
with self._lock, open(self.path, 'a', encoding='utf-8') as f:
|
||||
f.write(line)
|
||||
except OSError:
|
||||
pass
|
||||
|
||||
|
||||
decisions = DecisionLog()
|
||||
|
||||
|
||||
def summarize(path):
|
||||
"""{stage: {reason: 次数}}; 文件不存在返回 None, 坏行跳过。"""
|
||||
try:
|
||||
with open(path, encoding='utf-8') as f:
|
||||
lines = f.readlines()
|
||||
except OSError:
|
||||
return None
|
||||
counts = {}
|
||||
for line in lines:
|
||||
try:
|
||||
entry = json.loads(line)
|
||||
stage, reason = str(entry['stage']), str(entry['reason'])
|
||||
except (ValueError, KeyError, TypeError):
|
||||
continue
|
||||
counts.setdefault(stage, Counter())[reason] += 1
|
||||
return {stage: dict(counter) for stage, counter in sorted(counts.items())}
|
||||
+106
-3
@@ -33,6 +33,20 @@ SPI_GETMOUSESPEED = 0x0070
|
||||
DEFAULT_DLL = r'E:\罗技键鼠驱动\logitech.driver.dll'
|
||||
|
||||
|
||||
def _env_int(name, default):
|
||||
try:
|
||||
return int(os.environ.get(name, '') or default)
|
||||
except ValueError:
|
||||
return default
|
||||
|
||||
|
||||
# 点击参数(可被环境变量覆盖, 见 DriverInput.click 的注释 4)
|
||||
PRESS_MS = _env_int('LCP_DRIVER_PRESS_MS', 100) # 按下保持时长; 原 60ms 偏短
|
||||
SETTLE_SECONDS = _env_int('LCP_DRIVER_SETTLE_MS', 80) / 1000.0 # 到位后、按下前
|
||||
WIGGLE_PIXELS = _env_int('LCP_DRIVER_WIGGLE_PX', 10)
|
||||
WIGGLE_ENABLED = os.environ.get('LCP_DRIVER_WIGGLE', '1').strip() != '0'
|
||||
|
||||
|
||||
class Cursor(ctypes.Structure):
|
||||
_fields_ = [('x', ctypes.c_long), ('y', ctypes.c_long)]
|
||||
|
||||
@@ -61,6 +75,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,
|
||||
@@ -110,6 +132,15 @@ class DriverInput:
|
||||
self._stopped = False
|
||||
self._input_lock = threading.RLock()
|
||||
self._pressed = set()
|
||||
self._last_click = None # 上一次点击的屏幕坐标: 原地连点时才做抖动
|
||||
# 目标窗口句柄。有它才能做句柄级前台校验 —— 几何校验在窗口重叠时没用:
|
||||
# 实测把浏览器切到前台, 点游戏里同一个坐标, 只比矩形的话校验照样通过。
|
||||
self.hwnd = 0
|
||||
|
||||
def bind_window(self, hwnd):
|
||||
"""绑定目标窗口。绑定后 click() 会做句柄级前台校验。"""
|
||||
self.hwnd = int(hwnd or 0)
|
||||
return self
|
||||
|
||||
# ---------------------------------------------------------------- 生命周期
|
||||
|
||||
@@ -203,20 +234,58 @@ class DriverInput:
|
||||
self._dll.mouse_up(int(button))
|
||||
self._pressed.discard(int(button))
|
||||
|
||||
def click(self, sx, sy, times=1, tol=1):
|
||||
"""先确认到位置, 再按下抬起。没到位就不点, 免得点错地方。"""
|
||||
def click(self, sx, sy, times=1, tol=1, require_foreground=True,
|
||||
press_ms=None, settle=None, wiggle=None):
|
||||
"""先确认到位置, 再按下抬起。
|
||||
|
||||
⛔ 三个已验证的"位置对却点不上"原因(2026-10-23 实测):
|
||||
1. **前台不是游戏** —— 点击会送给当前前台窗口。实测: 窗口位置正确、坐标
|
||||
换算正确, 但前台是别的窗口, 结果点了个寂寞, 而旧版这里照样返回 True。
|
||||
现在用 require_foreground 检查: 点击点必须落在**前台窗口的客户区**内,
|
||||
否则拒绝并报错 —— 宁可失败也不要静默点错地方。
|
||||
2. **移动后立刻按下** —— 游戏按帧采样, 移动还没被处理就点击, 会算在旧位置。
|
||||
所以定位成功后先 settle 再按。
|
||||
3. **按下时间太短** —— 默认 30ms 在掉帧时会漏; 改成 60ms。
|
||||
实测 30/60/120ms 在干净环境下都能中, 但 60ms 对负载高的情况更稳。
|
||||
|
||||
4. **光标已经停在目标上时不会产生 MOUSEMOVE**(2026-11-15 实测) ——
|
||||
`move_to` 发现已在目标(tol=1)就直接返回, 游戏收不到任何移动事件;
|
||||
镜牢「获得E.G.O饰品」弹窗在这种"原地连点"下会吞掉点击
|
||||
(同坐标改用 pyautogui 的软件点击, 一次就过)。所以移动前先挪开 10px,
|
||||
保证有一次真实的移动事件。环境变量: LCP_DRIVER_WIGGLE=0 关闭,
|
||||
LCP_DRIVER_PRESS_MS 改按下时长。
|
||||
"""
|
||||
press_ms = PRESS_MS if press_ms is None else press_ms
|
||||
settle = SETTLE_SECONDS if settle is None else settle
|
||||
wiggle = WIGGLE_ENABLED if wiggle is None else wiggle
|
||||
if not self.ready:
|
||||
return False
|
||||
# 只在"原地连点"时抖动: 目标与上一次点击几乎同一点时, move_to 会直接返回、
|
||||
# 不发移动事件。其余点击保持原样, 免得改变正常流程的手感
|
||||
# (2026-11-15 实测: 每次点击都抖动时, 镜牢入场流程卡住过一次)。
|
||||
repeat = (self._last_click is not None
|
||||
and abs(sx - self._last_click[0]) <= 4
|
||||
and abs(sy - self._last_click[1]) <= 4)
|
||||
self._last_click = (sx, sy)
|
||||
if wiggle and repeat:
|
||||
self.move_relative(-WIGGLE_PIXELS, -WIGGLE_PIXELS)
|
||||
if not self.move_to(sx, sy, tol=tol):
|
||||
cx, cy = get_cursor()
|
||||
self.log('[driver] 定位失败: 目标(%d,%d) 实际(%d,%d), 不点击'
|
||||
% (sx, sy, cx, cy))
|
||||
return False
|
||||
if require_foreground:
|
||||
ok, why = click_point_is_on_foreground(sx, sy, self.hwnd or None)
|
||||
if not ok:
|
||||
self.log('[driver] 拒绝点击(%d,%d): %s' % (sx, sy, why))
|
||||
return False
|
||||
if settle:
|
||||
time.sleep(settle)
|
||||
for _ in range(int(times)):
|
||||
try:
|
||||
if not self.down(1):
|
||||
return False
|
||||
time.sleep(0.03)
|
||||
time.sleep(press_ms / 1000.0)
|
||||
finally:
|
||||
self.up(1)
|
||||
return not self._stopped
|
||||
@@ -234,6 +303,40 @@ class DriverInput:
|
||||
self._dll.scroll(int(amount))
|
||||
|
||||
|
||||
def click_point_is_on_foreground(sx, sy, hwnd=None):
|
||||
"""(屏幕坐标) 是否安全可点。
|
||||
|
||||
返回 (是否安全, 原因)。
|
||||
|
||||
⛔ 为什么必须比对句柄而不是比对矩形(2026-10-23 实测教训):
|
||||
最初只判断"点击点落在前台窗口的矩形内", 结果把浏览器切到前台、点游戏里
|
||||
同一个坐标, 校验**照样通过** —— 因为那个屏幕坐标同时也落在浏览器窗口的
|
||||
矩形里。几何判断在窗口互相重叠时毫无意义。
|
||||
|
||||
所以: 给了 hwnd 就要求前台窗口**就是它**(或是它的子窗口); 没给 hwnd 时
|
||||
退化成"有前台窗口且点在它矩形内", 可用性有限, 仅作兜底。
|
||||
"""
|
||||
fg = foreground_window()
|
||||
if not fg:
|
||||
return False, '当前没有前台窗口(GetForegroundWindow=0)'
|
||||
if hwnd:
|
||||
if fg == hwnd or _api('user32', 'IsChild', wintypes.BOOL,
|
||||
[wintypes.HWND, wintypes.HWND])(hwnd, fg):
|
||||
return True, 'ok'
|
||||
return False, ('前台不是目标窗口(前台=%r, 目标=%r) —— 这次点击会打到别的窗口'
|
||||
% (window_title(fg), window_title(hwnd)))
|
||||
pt = wintypes.POINT(int(sx), int(sy))
|
||||
rect = wintypes.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)'
|
||||
% (pt.x, pt.y, rect.left, rect.top, rect.right, rect.bottom))
|
||||
return True, 'ok'
|
||||
|
||||
|
||||
def client_to_screen(hwnd, x, y):
|
||||
"""游戏客户区坐标 -> 屏幕坐标。"""
|
||||
if not hwnd:
|
||||
|
||||
@@ -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)
|
||||
+148
-72
@@ -1,109 +1,185 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""全局急停热键。
|
||||
|
||||
为什么需要: 驱动级点击是闭环定位的 —— 手一动,下一次点击前会读到新位置、
|
||||
算出偏差、再把你推回目标点。所以任务运行期间鼠标和人是"拔河"状态,用户没法
|
||||
用鼠标去点停止按钮。键盘不受影响,所以用键盘热键做急停。
|
||||
为什么需要: 驱动级点击是闭环定位的 —— 手一动, 下一次点击前会读到新位置、算出
|
||||
偏差、再把你推回目标点。所以任务运行期间鼠标是"拔河"状态, 用户没法用鼠标去点
|
||||
停止按钮。键盘不受影响, 所以急停必须走键盘。
|
||||
|
||||
⛔ AALC 自带的 pause_hotkey 帮不上忙: 那个配置项只在 GUI(app/farming_interface.py)
|
||||
里注册, lc_mcp 走的是命令行子进程, 那条路径上没有热键监听。
|
||||
⛔ 为什么不用 pynput / 全局钩子(2026-10-22 实测):
|
||||
pynput 的 GlobalHotKeys 在这台机器上**收不到任何键盘事件** —— 静态注册成功、
|
||||
线程也活着, 但 keybd_event 和 SendInput 两种注入都触发不了它。钩子依赖
|
||||
WH_KEYBOARD_LL, 在当前会话下不工作。
|
||||
改用 GetAsyncKeyState 轮询: 不装钩子、不需要消息循环, 实测能正确看到注入的
|
||||
按键。用 0x8000 位判断"当前按下"。
|
||||
|
||||
默认 F12, 可用环境变量 LCP_KILL_KEY 改(取 pynput 的键名, 如 f11 / pause / esc)。
|
||||
按下后终止任务子进程, 游戏保留。硬退出不会执行任务的 finally;
|
||||
临时配置由 TaskRunner 的恢复文件机制处理。退出前给驱动释放鼠标的短暂机会,
|
||||
清理卡住时仍强制退出。
|
||||
另外 AALC 自带的 pause_hotkey 也帮不上忙: 那个配置项只在 GUI
|
||||
(app/farming_interface.py) 里注册, lc_mcp 走命令行子进程, 那条路径上没有监听。
|
||||
|
||||
默认 End(小键盘区右下角, 好按且不冲突), 可用环境变量 LCP_KILL_KEY 改成 pause / scrolllock / f11 等。
|
||||
⛔ 不要用 F12: 那是 Steam 的截图键(用户 2026-10-22 指出), 按下去会弹 Steam 截图
|
||||
覆盖层, 而且可能被 Steam 抢先消费。Esc / F11 也不合适 —— 游戏里分别是关菜单
|
||||
和切全屏。
|
||||
|
||||
按下后终止任务子进程, 游戏保留。硬退出不会执行任务的 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 = 'f12'
|
||||
EXIT_CODE = 130 # 与 SIGINT 一致, 便于上层识别"被用户中止"
|
||||
STOP_TIMEOUT = 0.25
|
||||
DEFAULT_KEY = 'end'
|
||||
EXIT_CODE = 130 # 与 SIGINT 一致, 便于上层识别"被用户中止"
|
||||
POLL_INTERVAL = 0.05 # 50ms 轮询, 人手按一下不会漏
|
||||
STOP_TIMEOUT = 0.25 # 释放鼠标/写日志最多等这么久, 然后强退
|
||||
START_DELAY = 0.3 # 先等一会儿, 避免把启动时按住的键当成急停
|
||||
|
||||
# 常用键 -> 虚拟键码。f12 保留是为了兼容旧配置, 但**不推荐** —— Steam 占用它。
|
||||
VK = {
|
||||
'f1': 0x70, 'f2': 0x71, 'f3': 0x72, 'f4': 0x73, 'f5': 0x74, 'f6': 0x75,
|
||||
'f7': 0x76, 'f8': 0x77, 'f9': 0x78, 'f10': 0x79, 'f11': 0x7A, 'f12': 0x7B,
|
||||
'esc': 0x1B, 'escape': 0x1B,
|
||||
'pause': 0x13, 'break': 0x13,
|
||||
'end': 0x23, 'home': 0x24, 'delete': 0x2E, 'insert': 0x2D,
|
||||
'scrolllock': 0x91, 'numlock': 0x90, 'capslock': 0x14,
|
||||
}
|
||||
|
||||
|
||||
def _key_spec(name):
|
||||
"""'f12' -> '<f12>',pynput 的 GlobalHotKeys 要求尖括号形式。"""
|
||||
name = (name or '').strip().lower() or DEFAULT_KEY
|
||||
if name.startswith('<') and name.endswith('>'):
|
||||
return name
|
||||
return '<%s>' % name
|
||||
def resolve_vk(key):
|
||||
"""键名 -> 虚拟键码。认不出返回 None(调用方负责报错, 不要静默用默认值)。"""
|
||||
name = (key or '').strip().lower().strip('<>')
|
||||
if not name:
|
||||
name = DEFAULT_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(_key_state_api()(vk) & 0x8000)
|
||||
|
||||
|
||||
class KillSwitch:
|
||||
"""轮询线程。按住热键会立刻退出, 不会重复触发。"""
|
||||
|
||||
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,
|
||||
name='lc_mcp-killswitch')
|
||||
|
||||
def start(self):
|
||||
self._thread.start()
|
||||
return self
|
||||
|
||||
def is_alive(self):
|
||||
return self._thread.is_alive()
|
||||
|
||||
def stop(self):
|
||||
self._stopped.set()
|
||||
|
||||
def _run(self):
|
||||
if self._stopped.wait(START_DELAY):
|
||||
return
|
||||
while not self._stopped.is_set():
|
||||
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
|
||||
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:
|
||||
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:
|
||||
try:
|
||||
os._exit(EXIT_CODE)
|
||||
finally:
|
||||
timer.cancel() # 仅在测试替换 _exit 时才会走到
|
||||
|
||||
|
||||
def install(log=print, key=None, on_stop=None):
|
||||
"""启动急停监听线程。返回监听器对象(可用于测试), 失败返回 None。
|
||||
"""启动急停轮询线程。返回 KillSwitch, 失败返回 None(不抛异常)。
|
||||
|
||||
任何异常都不向外抛 —— 急停装不上不该让任务起不来, 但必须把原因说清楚。
|
||||
急停装不上不该让任务起不来, 但必须把原因和应急手段说清楚。
|
||||
"""
|
||||
key = key or os.environ.get('LCP_KILL_KEY') or DEFAULT_KEY
|
||||
spec = _key_spec(key)
|
||||
|
||||
vk = resolve_vk(key)
|
||||
if vk is None:
|
||||
log('[lc_mcp] 急停热键不可用: 认不出键名 %r(可用: %s), 请用 Ctrl+Alt+Del 强制停止'
|
||||
% (key, ', '.join(sorted(VK))))
|
||||
return None
|
||||
try:
|
||||
from pynput import keyboard
|
||||
except Exception as e: # pynput 缺失/无显示环境
|
||||
log('[lc_mcp] 急停热键不可用(pynput 加载失败: %s: %s), 请用 Ctrl+Alt+Del 强制停止'
|
||||
_key_state_api()
|
||||
except Exception as e: # 非 Windows / user32 不可用
|
||||
log('[lc_mcp] 急停热键不可用(读取键盘状态失败: %s: %s), 请用 Ctrl+Alt+Del 强制停止'
|
||||
% (type(e).__name__, e))
|
||||
return None
|
||||
|
||||
state = {'fired': False}
|
||||
|
||||
def on_activate():
|
||||
if state['fired']:
|
||||
return
|
||||
state['fired'] = True
|
||||
# Windows 在系统输入线程上调用此函数, 不在这里写日志或等待清理。
|
||||
# 即使日志锁/驱动清理卡住, 也必须按时退出。
|
||||
timer = threading.Timer(STOP_TIMEOUT, os._exit, args=(EXIT_CODE,))
|
||||
timer.daemon = True
|
||||
|
||||
def shutdown():
|
||||
try:
|
||||
if on_stop is not None:
|
||||
on_stop()
|
||||
finally:
|
||||
try:
|
||||
os._exit(EXIT_CODE)
|
||||
finally:
|
||||
timer.cancel() # 仅供 _exit 被测试替换的情况
|
||||
|
||||
try:
|
||||
timer.start()
|
||||
worker = threading.Thread(target=shutdown, name='lc-mcp-emergency-stop', daemon=True)
|
||||
state['worker'] = worker
|
||||
worker.start()
|
||||
except Exception:
|
||||
timer.cancel()
|
||||
os._exit(EXIT_CODE)
|
||||
|
||||
try:
|
||||
listener = keyboard.GlobalHotKeys({spec: on_activate})
|
||||
listener.daemon = True
|
||||
listener.start()
|
||||
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 强制停止'
|
||||
log('[lc_mcp] 急停热键启动失败(%s: %s), 请用 Ctrl+Alt+Del 强制停止'
|
||||
% (type(e).__name__, e))
|
||||
return None
|
||||
|
||||
log('[lc_mcp] 急停监听已启动: 按 %s 终止任务, 游戏窗口保留; 可用 run_task 重新开始'
|
||||
% key.upper())
|
||||
listener._lc_state = state
|
||||
return listener
|
||||
log('[lc_mcp] 急停热键已就绪: 按 %s 终止任务, 游戏窗口保留; 可用 run_task 重新开始'
|
||||
'(键盘可用, 不需要鼠标, 也不依赖 MCP 服务)' % key.upper())
|
||||
return switch
|
||||
|
||||
|
||||
def stop(listener):
|
||||
"""停止监听(任务正常结束时调用, 免得线程残留)。"""
|
||||
if listener is None:
|
||||
def stop(switch):
|
||||
"""停止轮询(任务结束时调用, 免得线程残留)。"""
|
||||
if switch is None:
|
||||
return
|
||||
try:
|
||||
listener.stop()
|
||||
switch.stop()
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
|
||||
@contextmanager
|
||||
def listening(log=print, on_stop=None):
|
||||
listener = install(log=log, on_stop=on_stop)
|
||||
switch = install(log=log, on_stop=on_stop)
|
||||
try:
|
||||
yield listener
|
||||
yield switch
|
||||
finally:
|
||||
stop(listener)
|
||||
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
|
||||
|
||||
+51
-9
@@ -6,7 +6,7 @@ import threading
|
||||
import time
|
||||
|
||||
from . import VERSION
|
||||
from .aalc_task import TASKS
|
||||
from .aalc_task import TASK_OPTIONS, TASKS
|
||||
from .engine import find_hits
|
||||
|
||||
MAX_WAIT = 300.0
|
||||
@@ -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,26 @@ 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,用户停止后不自动重跑。'
|
||||
'mirror 可加 strategy="rabbit_hole":兔子洞速刷(黑兽-卯 浮士德每回合放 E.G.O「空洞」,每场第一回合超频),'
|
||||
'编队、长按点、路线卡包见 lc_mcp/data/rabbit_hole.json。'),
|
||||
'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',
|
||||
'exp': _NUM, 'thread': _NUM, 'times': _NUM, 'count': _NUM,
|
||||
'strategy': {'type': 'string', 'enum': sorted({v for o in TASK_OPTIONS.values()
|
||||
for v in o['strategy']})}},
|
||||
['task'])},
|
||||
{'name': 'task_status', 'description': '启动 run_task 前检查占用,启动后轮询此工具监控,避免逐帧截图和重复启动。'
|
||||
'返回 idle/running/succeeded/failed/stopped、日志及异常;'
|
||||
'decisions.counts 按阶段统计选队/寻路/卡包/饰品/事件/商店的决策理由。'
|
||||
'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 +130,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, {})
|
||||
@@ -128,6 +163,13 @@ class Server:
|
||||
if task not in TASKS:
|
||||
raise ValueError('unknown task %r' % task)
|
||||
params = {k: int(a[k]) for k in TASKS[task] if a.get(k) is not None}
|
||||
options = TASK_OPTIONS.get(task, {})
|
||||
for key in ('strategy',):
|
||||
if a.get(key) is None:
|
||||
continue
|
||||
if a[key] not in options.get(key, ()):
|
||||
raise ValueError('%s 不支持 %s=%r' % (task, key, a[key]))
|
||||
params[key] = a[key]
|
||||
# Starting must not race a click that has already checked running().
|
||||
# Reject promptly when busy instead of waiting behind a long OCR poll.
|
||||
if not self.lock.acquire(blocking=False):
|
||||
|
||||
+11
-4
@@ -12,6 +12,7 @@ import time
|
||||
from collections import deque
|
||||
|
||||
from .aalc_task import RESTORE_ENV
|
||||
from .decisions import DECISIONS_ENV, SUFFIX as DECISIONS_SUFFIX, summarize as summarize_decisions
|
||||
from .killswitch import EXIT_CODE as USER_ABORT_EXIT
|
||||
|
||||
REPO = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
||||
@@ -168,11 +169,13 @@ class TaskRunner:
|
||||
base = os.path.join(self.run_dir, 'task_%s_%s' % (stamp, task))
|
||||
env = self._env()
|
||||
env[RESTORE_ENV] = base + RESTORE_SUFFIX
|
||||
env[DECISIONS_ENV] = base + DECISIONS_SUFFIX
|
||||
kw = {'creationflags': subprocess.CREATE_NEW_PROCESS_GROUP} if IS_WIN else {'start_new_session': True}
|
||||
with open(base + '.log', 'wb') as logf:
|
||||
self.proc = subprocess.Popen(self.argv_factory(task, params), cwd=REPO, env=env,
|
||||
stdin=subprocess.DEVNULL, stdout=logf, stderr=subprocess.STDOUT, **kw)
|
||||
self.info = {'task': task, 'params': params, 'log': (base + '.log').replace('\\', '/'),
|
||||
'decisions': (base + DECISIONS_SUFFIX).replace('\\', '/'),
|
||||
'restore': env[RESTORE_ENV], 'started': time.time(), 'stopped_by_user': False}
|
||||
self._prune()
|
||||
return {'ok': True, 'task': task, 'pid': self.proc.pid, 'log': self.info['log']}
|
||||
@@ -192,6 +195,9 @@ class TaskRunner:
|
||||
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)))}
|
||||
counts = summarize_decisions(self.info['decisions'])
|
||||
if counts:
|
||||
r['decisions'] = {'path': self.info['decisions'], 'counts': counts}
|
||||
if code is None:
|
||||
stalls = log_stalls(self.info['log'])
|
||||
if stalls:
|
||||
@@ -238,7 +244,8 @@ class TaskRunner:
|
||||
def _prune(self):
|
||||
logs = sorted(glob.glob(os.path.join(self.run_dir, 'task_*.log')), key=os.path.getmtime)
|
||||
for p in logs[:-self.keep_logs]:
|
||||
try:
|
||||
os.remove(p)
|
||||
except OSError:
|
||||
pass
|
||||
for path in (p, p[:-len('.log')] + DECISIONS_SUFFIX):
|
||||
try:
|
||||
os.remove(path)
|
||||
except OSError:
|
||||
pass
|
||||
|
||||
@@ -0,0 +1,157 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""生成 lc_mcp/data/theme_pack_systems.json: 镜牢卡包 → 体系(BACKLOG R-01)。
|
||||
|
||||
用法:
|
||||
python scripts/build_theme_pack_systems.py <LLC_zh-CN 目录> <LLC EN 目录> [-o 输出文件]
|
||||
|
||||
两个目录分别是零协汉化的中文包(游戏里的 LimbusCompany_Data/Lang/LLC_zh-CN, 或 release 解压出来的同名目录)
|
||||
和 LocalizeLimbusCompany 仓库里的 EN 目录, 只用其中的 MirrorDungeonTheme*.json(卡包 id → 名字)。
|
||||
|
||||
卡包数据来自 Limbus Company Wiki(https://limbuscompany.wiki.gg, CC BY-SA 4.0), 运行时在线读取:
|
||||
- 各卡包条目的 {{ThemePackInfo}}: 出现楼层(normal/hard)、专属饰品(unique);
|
||||
- 条目里「Featured Gifts」用的饰品分类: 是体系名(Burn/Charge/...)的就是体系包;
|
||||
- Module:EgoGift/data: 每件饰品的体系(category)。
|
||||
|
||||
边狱巴士 BWIKI(wiki.biligame.com/limbuscompany)2026-11-15 查过: 699 个页面里没有卡包条目, 所以不用它。
|
||||
"""
|
||||
import argparse
|
||||
import glob
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import sys
|
||||
import time
|
||||
import urllib.parse
|
||||
import urllib.request
|
||||
|
||||
API = 'https://limbuscompany.wiki.gg/api.php'
|
||||
RAW = 'https://limbuscompany.wiki.gg/index.php'
|
||||
USER_AGENT = 'research-script/1.0 (python-urllib)'
|
||||
CATEGORY = 'Category:Floor Theme Pack Pages'
|
||||
SYSTEMS = {'Burn': 'burn', 'Bleed': 'bleed', 'Tremor': 'tremor', 'Rupture': 'rupture', 'Sinking': 'sinking',
|
||||
'Poise': 'poise', 'Charge': 'charge', 'Slash': 'slash', 'Pierce': 'pierce', 'Blunt': 'blunt'}
|
||||
# 零协 EN 文件里还没有英文名、或者写法和 wiki 条目名不一样的卡包
|
||||
EN_OVERRIDES = {
|
||||
1028: 'Storefront Campout', 1029: 'An Anarchy of Colors', 1030: 'Creed of Preservation',
|
||||
1031: 'Readvent of Gluttony', 1111: 'Line 4 - Section 3', 1112: 'Line 4 - Section 4',
|
||||
1129: 'The Wedge in the Wake of Dawnbreak',
|
||||
}
|
||||
|
||||
|
||||
def fetch(url, params):
|
||||
request = urllib.request.Request(url + '?' + urllib.parse.urlencode(params), headers={'User-Agent': USER_AGENT})
|
||||
with urllib.request.urlopen(request, timeout=60) as response:
|
||||
return response.read().decode('utf-8')
|
||||
|
||||
|
||||
def theme_pack_pages():
|
||||
titles, cont = [], {}
|
||||
while True:
|
||||
data = json.loads(fetch(API, {'action': 'query', 'list': 'categorymembers', 'cmtitle': CATEGORY,
|
||||
'cmlimit': '500', 'format': 'json', **cont}))
|
||||
titles += [m['title'] for m in data['query']['categorymembers'] if m['title'].endswith(' Theme Pack')]
|
||||
if 'continue' not in data:
|
||||
break
|
||||
cont = {'cmcontinue': data['continue']['cmcontinue']}
|
||||
pages = {}
|
||||
for i in range(0, len(titles), 40):
|
||||
data = json.loads(fetch(API, {'action': 'query', 'prop': 'revisions', 'rvprop': 'content', 'rvslots': 'main',
|
||||
'titles': '|'.join(titles[i:i + 40]), 'format': 'json', 'formatversion': '2'}))
|
||||
for page in data['query']['pages']:
|
||||
if 'revisions' in page:
|
||||
pages[page['title'][:-len(' Theme Pack')]] = page['revisions'][0]['slots']['main']['content']
|
||||
time.sleep(1)
|
||||
return pages
|
||||
|
||||
|
||||
def gift_categories():
|
||||
lua = fetch(RAW, {'title': 'Module:EgoGift/data', 'action': 'raw'})
|
||||
gifts = {}
|
||||
for match in re.finditer(r'^\s*\["([^"]+)"\]\s*=\s*\{(.*)\},?\s*$', lua, re.M):
|
||||
category = re.search(r'category\s*=\s*"([^"]*)"', match.group(2))
|
||||
gifts[match.group(1)] = category.group(1) if category else None
|
||||
return gifts
|
||||
|
||||
|
||||
def parse_pack(text, gifts):
|
||||
info = re.search(r'\{\{ThemePackInfo(.*?)\n\}\}', text, re.S)
|
||||
fields = dict(re.findall(r'\|\s*(\w+)\s*=\s*([^\n|]*)', info.group(1))) if info else {}
|
||||
unique = {}
|
||||
for gift in (g.strip() for g in fields.get('unique', '').split(';')):
|
||||
category = gifts.get(gift, gifts.get(gift.replace("'", '’'))) if gift else None
|
||||
if category in SYSTEMS:
|
||||
unique[SYSTEMS[category]] = unique.get(SYSTEMS[category], 0) + 1
|
||||
featured = sorted({SYSTEMS[c] for c in re.findall(r'\{\{#invoke:GiftList\|Category\|([^}|]+)\}\}', text)
|
||||
if c in SYSTEMS})
|
||||
return {'normal': fields.get('normal', '').replace(' ', ''), 'hard': fields.get('hard', '').replace(' ', ''),
|
||||
'featured': featured, 'unique': dict(sorted(unique.items()))}
|
||||
|
||||
|
||||
def theme_names(directory):
|
||||
names = {}
|
||||
for path in glob.glob(os.path.join(directory, 'MirrorDungeonTheme*.json')):
|
||||
with open(path, encoding='utf-8-sig') as fh:
|
||||
for entry in json.load(fh).get('dataList', []):
|
||||
names[entry['id']] = entry.get('name', '')
|
||||
return names
|
||||
|
||||
|
||||
def key(name):
|
||||
return re.sub(r'[^0-9a-z]', '', name.lower())
|
||||
|
||||
|
||||
def build(zh_dir, en_dir):
|
||||
zh, en = theme_names(zh_dir), theme_names(en_dir)
|
||||
en.update(EN_OVERRIDES)
|
||||
gifts = gift_categories()
|
||||
wiki = {key(title): (title, parse_pack(text, gifts)) for title, text in theme_pack_pages().items()}
|
||||
packs, unmatched = [], []
|
||||
for pack_id in sorted(zh):
|
||||
title, data = wiki.get(key(en.get(pack_id, '')), (None, None))
|
||||
if data is None:
|
||||
unmatched.append('%d %s' % (pack_id, zh[pack_id]))
|
||||
continue
|
||||
packs.append({'id': pack_id, 'zh': zh[pack_id], 'en': title, **data})
|
||||
return packs, unmatched
|
||||
|
||||
|
||||
def _rows(items, indent):
|
||||
return ['%s%s%s' % (indent, json.dumps(item, ensure_ascii=False), ',' if i < len(items) - 1 else '')
|
||||
for i, item in enumerate(items)]
|
||||
|
||||
|
||||
def dump_table(table):
|
||||
"""写回 JSON: 卡包和社区条目每条一行, 好看 diff。"""
|
||||
notes = json.dumps(table['_说明'], ensure_ascii=False, indent=1).replace('\n', '\n ')
|
||||
lines = ['{', ' "_说明": %s,' % notes, ' "bonus": %s,' % json.dumps(table['bonus'], ensure_ascii=False)]
|
||||
community = table.get('community')
|
||||
if community:
|
||||
lines += [' "community": {',
|
||||
' "_说明": %s,' % json.dumps(community['_说明'], ensure_ascii=False, indent=1).replace('\n', '\n '),
|
||||
' "recommend": ['] + _rows(community['recommend'], ' ') + \
|
||||
[' ],', ' "avoid": ['] + _rows(community['avoid'], ' ') + [' ]', ' },']
|
||||
lines += [' "packs": ['] + _rows(table['packs'], ' ') + [' ]', '}']
|
||||
return '\n'.join(lines) + '\n'
|
||||
|
||||
|
||||
def main(argv):
|
||||
parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
|
||||
parser.add_argument('zh_dir')
|
||||
parser.add_argument('en_dir')
|
||||
parser.add_argument('-o', '--output', default=os.path.join(os.path.dirname(__file__), '..', 'lc_mcp', 'data',
|
||||
'theme_pack_systems.json'))
|
||||
args = parser.parse_args(argv)
|
||||
packs, unmatched = build(args.zh_dir, args.en_dir)
|
||||
with open(args.output, encoding='utf-8') as fh:
|
||||
table = json.load(fh) # 保留手写的 _说明、bonus、community, 只换 packs
|
||||
table['packs'] = packs
|
||||
with open(args.output, 'w', encoding='utf-8') as fh:
|
||||
fh.write(dump_table(table))
|
||||
print('卡包 %d 个写入 %s' % (len(packs), args.output))
|
||||
if unmatched:
|
||||
print('wiki 上没对上的: %s' % ', '.join(unmatched))
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
sys.exit(main(sys.argv[1:]))
|
||||
@@ -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, '桌面不在出图(会话被断开), 本轮跳过')
|
||||
|
||||
@@ -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" 表)。
|
||||
|
||||
@@ -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))
|
||||
|
||||
@@ -0,0 +1,256 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""决策审计日志(BACKLOG P2-8): 写入、统计、TaskRunner 归档, 以及商店/卡包两处只观察的审计。"""
|
||||
import ast
|
||||
import json
|
||||
import logging
|
||||
import os
|
||||
import sys
|
||||
import tempfile
|
||||
import time
|
||||
import types
|
||||
import unittest
|
||||
from pathlib import Path
|
||||
from types import SimpleNamespace
|
||||
from unittest import mock
|
||||
|
||||
REPO = Path(__file__).resolve().parents[1]
|
||||
sys.path.insert(0, str(REPO))
|
||||
from lc_mcp import aalc_patches as ap # noqa: E402
|
||||
from lc_mcp.decisions import DECISIONS_ENV, SUFFIX, DecisionLog, summarize # noqa: E402
|
||||
from lc_mcp.tasks import TaskRunner # noqa: E402
|
||||
|
||||
THEME = REPO / 'vendor' / 'aalc' / 'tasks' / 'mirror' / 'select_theme_pack.py'
|
||||
|
||||
|
||||
def read(path):
|
||||
with open(path, encoding='utf-8') as f:
|
||||
return [json.loads(line) for line in f]
|
||||
|
||||
|
||||
class DecisionLogTest(unittest.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
tmp = tempfile.TemporaryDirectory()
|
||||
self.addCleanup(tmp.cleanup)
|
||||
self.path = os.path.join(tmp.name, 'run' + SUFFIX)
|
||||
|
||||
def test_without_env_nothing_is_written(self):
|
||||
log = DecisionLog()
|
||||
self.assertIsNone(log.open(env={}))
|
||||
log.record('gift', 1, 'keyword')
|
||||
self.assertFalse(os.path.exists(self.path))
|
||||
|
||||
def test_records_and_counts(self):
|
||||
log = DecisionLog()
|
||||
self.assertEqual(log.open(env={DECISIONS_ENV: self.path}), self.path)
|
||||
log.record('gift', 2, 'keyword', system='bleed', hits=[[], ['流血']])
|
||||
log.record('gift', 1, 'no_keyword', system='bleed', hits=[[], []])
|
||||
log.record('gift', 1, 'keyword', system='bleed', hits=[['出血'], []])
|
||||
log.record('shop', 'carmilla', 'purchase_clicked')
|
||||
entries = read(self.path)
|
||||
self.assertEqual(entries[0]['hits'], [[], ['流血']])
|
||||
self.assertEqual(set(entries[0]), {'time', 'stage', 'choice', 'reason', 'system', 'hits'})
|
||||
self.assertEqual(summarize(self.path), {'gift': {'keyword': 2, 'no_keyword': 1},
|
||||
'shop': {'purchase_clicked': 1}})
|
||||
|
||||
def test_bad_lines_are_skipped_and_missing_file_is_none(self):
|
||||
with open(self.path, 'w', encoding='utf-8') as f:
|
||||
f.write('{"stage": "road", "reason": "lowest"}\nnot json\n{"stage": "road"}\n[]\n')
|
||||
self.assertEqual(summarize(self.path), {'road': {'lowest': 1}})
|
||||
self.assertIsNone(summarize(self.path + '.missing'))
|
||||
|
||||
def test_write_failure_does_not_raise(self):
|
||||
DecisionLog(os.path.dirname(self.path)).record('gift', 1, 'keyword') # 路径是目录
|
||||
|
||||
|
||||
class TaskRunnerDecisionsTest(unittest.TestCase):
|
||||
|
||||
CHILD = ('import os\n'
|
||||
'from lc_mcp.decisions import decisions\n'
|
||||
'decisions.open()\n'
|
||||
'decisions.record("theme_pack", "信仰", "preferred")\n'
|
||||
'decisions.record("gift", 2, "keyword")\n'
|
||||
'decisions.record("gift", 1, "no_keyword")\n'
|
||||
'print("[lc_mcp] done")\n')
|
||||
|
||||
def wait(self, runner):
|
||||
deadline = time.time() + 15
|
||||
while time.time() < deadline and runner.running():
|
||||
time.sleep(0.05)
|
||||
|
||||
def test_child_writes_next_to_its_log_and_status_counts_it(self):
|
||||
with tempfile.TemporaryDirectory() as d:
|
||||
runner = TaskRunner(d, argv_factory=lambda t, p: [sys.executable, '-c', self.CHILD])
|
||||
started = runner.start('mirror', {'count': 1})
|
||||
self.assertTrue(started['ok'], started)
|
||||
self.wait(runner)
|
||||
status = runner.status()
|
||||
self.assertEqual(status['state'], 'succeeded', status)
|
||||
self.assertEqual(status['decisions']['path'], started['log'][:-len('.log')] + SUFFIX)
|
||||
self.assertEqual(status['decisions']['counts'],
|
||||
{'gift': {'keyword': 1, 'no_keyword': 1}, 'theme_pack': {'preferred': 1}})
|
||||
|
||||
def test_no_decisions_field_when_nothing_was_recorded(self):
|
||||
with tempfile.TemporaryDirectory() as d:
|
||||
runner = TaskRunner(d, argv_factory=lambda t, p: [sys.executable, '-c', 'print(1)'])
|
||||
runner.start('daily', {})
|
||||
self.wait(runner)
|
||||
self.assertNotIn('decisions', runner.status())
|
||||
|
||||
def test_prune_removes_decisions_with_their_log(self):
|
||||
with tempfile.TemporaryDirectory() as d:
|
||||
runner = TaskRunner(d, argv_factory=lambda t, p: [sys.executable, '-c', 'print(1)'], keep_logs=1)
|
||||
old = os.path.join(d, 'task_20260101_000000_mirror')
|
||||
for path in (old + '.log', old + SUFFIX):
|
||||
with open(path, 'w') as f:
|
||||
f.write('{}\n')
|
||||
os.utime(old + '.log', (1, 1))
|
||||
runner.start('daily', {})
|
||||
self.wait(runner)
|
||||
self.assertFalse(os.path.exists(old + '.log'))
|
||||
self.assertFalse(os.path.exists(old + SUFFIX))
|
||||
|
||||
|
||||
class RecordingTest(unittest.TestCase):
|
||||
"""把模块级 decisions 指到临时文件。"""
|
||||
|
||||
def setUp(self):
|
||||
tmp = tempfile.TemporaryDirectory()
|
||||
self.addCleanup(tmp.cleanup)
|
||||
self.path = os.path.join(tmp.name, 'run' + SUFFIX)
|
||||
patcher = mock.patch.object(ap.decisions, 'path', self.path)
|
||||
patcher.start()
|
||||
self.addCleanup(patcher.stop)
|
||||
self.lines = []
|
||||
|
||||
def entries(self):
|
||||
return read(self.path) if os.path.exists(self.path) else []
|
||||
|
||||
|
||||
class ShopAuditTest(RecordingTest):
|
||||
|
||||
def setUp(self):
|
||||
super().setUp()
|
||||
self.auto = SimpleNamespace(click_element=mock.Mock(return_value=True),
|
||||
mouse_action_with_pos=mock.Mock())
|
||||
self.shop_cls = type('Shop', (), {'system': 'bleed'})
|
||||
in_shop = types.ModuleType('tasks.mirror.in_shop')
|
||||
in_shop.Shop = self.shop_cls
|
||||
modules = {'tasks': types.ModuleType('tasks'), 'tasks.mirror': types.ModuleType('tasks.mirror'),
|
||||
'tasks.mirror.in_shop': in_shop, 'module': types.ModuleType('module'),
|
||||
'module.automation': SimpleNamespace(auto=self.auto)}
|
||||
patcher = mock.patch.dict(sys.modules, modules)
|
||||
patcher.start()
|
||||
self.addCleanup(patcher.stop)
|
||||
|
||||
def test_purchases_are_recorded_with_the_item_clicked_before(self):
|
||||
auto = self.auto
|
||||
|
||||
def buy_gifts(shop):
|
||||
# 上游的三条购买路径: 必买项、四级素材、本体系饰品(按坐标)
|
||||
auto.click_element('mirror/shop/must_purchase/carmilla.png', threshold=0.85)
|
||||
auto.click_element(ap.SHOP_PURCHASE)
|
||||
auto.click_element(ap.SHOP_CONFIRM)
|
||||
auto.click_element('mirror/shop/level_IV_to_buy.png', threshold=0.82)
|
||||
auto.click_element(ap.SHOP_PURCHASE)
|
||||
auto.mouse_action_with_pos((300, 400), offset=True)
|
||||
auto.click_element(ap.SHOP_PURCHASE, take_screenshot=True)
|
||||
return 'done'
|
||||
|
||||
self.shop_cls.buy_gifts = buy_gifts
|
||||
click, position = auto.click_element, auto.mouse_action_with_pos
|
||||
ap.install_shop_audit(log=self.lines.append)
|
||||
self.assertEqual(self.shop_cls().buy_gifts(), 'done')
|
||||
self.assertEqual([(e['choice'], e['reason'], e['system']) for e in self.entries()],
|
||||
[('carmilla', 'purchase_clicked', 'bleed'),
|
||||
('level_IV_to_buy', 'purchase_clicked', 'bleed'),
|
||||
('by_position', 'purchase_clicked', 'bleed')])
|
||||
self.assertIs(auto.click_element, click)
|
||||
self.assertIs(auto.mouse_action_with_pos, position)
|
||||
position.assert_called_once_with((300, 400), offset=True)
|
||||
|
||||
def test_failed_purchase_click_is_not_recorded(self):
|
||||
auto, real = self.auto, self.auto.click_element
|
||||
|
||||
def buy_gifts(shop):
|
||||
auto.click_element('mirror/shop/must_purchase/carmilla.png')
|
||||
real.return_value = False # 钱不够: 购买按钮匹配不上
|
||||
auto.click_element(ap.SHOP_PURCHASE)
|
||||
|
||||
self.shop_cls.buy_gifts = buy_gifts
|
||||
ap.install_shop_audit(log=self.lines.append)
|
||||
self.shop_cls().buy_gifts()
|
||||
self.assertEqual(self.entries(), [])
|
||||
|
||||
|
||||
class ThemePackDecisionTest(unittest.TestCase):
|
||||
|
||||
def test_messages_to_decision(self):
|
||||
weights = "当前主题包权重列表:[('信仰', 0), ('unknown', -5)]"
|
||||
self.assertEqual(ap.theme_pack_decision([weights, '此次选择卡包关键词:信仰']),
|
||||
('信仰', 'preferred', "[('信仰', 0), ('unknown', -5)]"))
|
||||
self.assertEqual(ap.theme_pack_decision(['无匹配最低阈值的主题包,选择最高权重主题包\n此次选择卡包关键词:赌徒'])[:2],
|
||||
('赌徒', 'highest_weight'))
|
||||
self.assertEqual(ap.theme_pack_decision(['此次主题包选择了最左边的(活动)卡包'])[:2],
|
||||
('最左边的活动卡包', 'event_pack'))
|
||||
self.assertIsNone(ap.theme_pack_decision(['选择卡包: (1, 2)']))
|
||||
|
||||
|
||||
@unittest.skipUnless(THEME.is_file(), 'vendor/aalc 子模块未检出')
|
||||
class UpstreamThemePackAuditTest(RecordingTest):
|
||||
"""执行上游真实的 select_theme_pack, 审计从它自己的日志里取结果。"""
|
||||
|
||||
class Match:
|
||||
def __init__(self, value, text):
|
||||
self.value, self.text, self.position = value, text, [0, 0]
|
||||
|
||||
def run_upstream(self, packs, thresholds=0):
|
||||
tree = ast.parse(THEME.read_text(encoding='utf-8'))
|
||||
node = next(n for n in tree.body if isinstance(n, ast.FunctionDef) and n.name == 'select_theme_pack')
|
||||
node.decorator_list = []
|
||||
positions = [(300 + 300 * i, 300) for i in range(len(packs))]
|
||||
weights = {name: weight for name, weight in packs if name}
|
||||
|
||||
def find_language_text(zh, en, crop):
|
||||
x = (crop[0] + crop[2]) / 2
|
||||
name = packs[min(range(len(packs)), key=lambda i: abs(positions[i][0] - x))][0]
|
||||
return self.Match(weights[name], name) if name else False
|
||||
|
||||
auto = SimpleNamespace(
|
||||
model=None, take_screenshot=lambda: object(), mouse_to_blank=lambda *a, **k: None,
|
||||
find_element=lambda target, **kw: list(positions) if 'theme_pack_features' in target else False,
|
||||
find_language_text=find_language_text, mouse_drag_down=mock.Mock(),
|
||||
click_element=lambda *a, **k: False)
|
||||
ns = dict(auto=auto, TextMatchResult=self.Match, sleep=lambda *a: None, back_init_menu=mock.Mock(),
|
||||
log=logging.getLogger('AALC'),
|
||||
cfg=SimpleNamespace(set_win_size=720, select_event_pack=False, skip_event_pack=False),
|
||||
path_manager=SimpleNamespace(current_language='zh_cn'),
|
||||
theme_list=SimpleNamespace(preferred_thresholds=thresholds,
|
||||
get_effective_theme_pack_list=lambda *a: dict(weights)))
|
||||
exec(compile(ast.Module(body=[node], type_ignores=[]), str(THEME), 'exec'), ns)
|
||||
mirror_mod = types.ModuleType('tasks.mirror.mirror')
|
||||
mirror_mod.select_theme_pack = ns['select_theme_pack']
|
||||
package = types.ModuleType('tasks.mirror')
|
||||
package.mirror = mirror_mod
|
||||
logger = logging.getLogger('AALC')
|
||||
with mock.patch.dict(sys.modules, {'tasks': types.ModuleType('tasks'), 'tasks.mirror': package,
|
||||
'tasks.mirror.mirror': mirror_mod}), \
|
||||
mock.patch.object(logger, 'level', logging.DEBUG), \
|
||||
mock.patch.object(logger, 'propagate', False):
|
||||
ap.install_theme_pack_audit(log=self.lines.append)
|
||||
handlers = list(logger.handlers)
|
||||
mirror_mod.select_theme_pack(False, 2, 1, False)
|
||||
self.assertEqual(logger.handlers, handlers, '临时 handler 必须移除')
|
||||
return auto.mouse_drag_down
|
||||
|
||||
def test_preferred_pack_is_recorded(self):
|
||||
drag = self.run_upstream([('赌徒', -1), ('信仰', 2), (None, None)])
|
||||
drag.assert_called_once_with(600, 300)
|
||||
entry, = self.entries()
|
||||
self.assertEqual((entry['stage'], entry['choice'], entry['reason'], entry['floor']),
|
||||
('theme_pack', '信仰', 'preferred', 2))
|
||||
self.assertIn("('信仰', 2)", entry['weights'])
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
+185
-5
@@ -10,6 +10,7 @@
|
||||
关掉后严格 1:1。所以加速没关时不该给出"差不多"的位置。
|
||||
"""
|
||||
import sys
|
||||
import contextlib
|
||||
import os
|
||||
import ast
|
||||
import inspect
|
||||
@@ -132,7 +133,8 @@ class ClickTest(unittest.TestCase):
|
||||
{'v': (pos['v'][0] + dx, pos['v'][1] + dy)})
|
||||
with mock.patch.object(di, 'get_cursor', lambda: pos['v']), \
|
||||
mock.patch.object(di.time, 'sleep', lambda s: None):
|
||||
self.assertTrue(d.click(500, 400))
|
||||
# 这里只测定位逻辑, 前台校验另有 ForegroundCheckTest
|
||||
self.assertTrue(d.click(500, 400, require_foreground=False))
|
||||
self.assertEqual(pos['v'], (500, 400))
|
||||
d._dll.mouse_down.assert_called_once_with(1)
|
||||
d._dll.mouse_up.assert_called_once_with(1)
|
||||
@@ -141,7 +143,7 @@ class ClickTest(unittest.TestCase):
|
||||
d = self._drv(False)
|
||||
with mock.patch.object(di, 'get_cursor', lambda: (0, 0)), \
|
||||
mock.patch.object(di.time, 'sleep', lambda s: None):
|
||||
self.assertFalse(d.click(500, 400))
|
||||
self.assertFalse(d.click(500, 400, require_foreground=False))
|
||||
d._dll.mouse_down.assert_not_called()
|
||||
d._dll.mouse_up.assert_not_called()
|
||||
|
||||
@@ -325,6 +327,10 @@ class DriverWiringTest(unittest.TestCase):
|
||||
with mock.patch.dict(sys.modules, modules), \
|
||||
mock.patch.dict(os.environ, LCP_DRIVER_INPUT='1', LCP_RESTORE_FILE=''), \
|
||||
mock.patch.object(aalc_task, 'bootstrap'), \
|
||||
mock.patch.object(aalc_task, 'exclusive_game'), \
|
||||
mock.patch.object(aalc_task, 'headless_hdr_warning') as hdr_warning, \
|
||||
mock.patch.object(aalc_task, 'mirror_progress',
|
||||
lambda scheme: contextlib.nullcontext(ap.MirrorProgress())), \
|
||||
mock.patch.object(aalc_task, 'install_exact_team_match'), \
|
||||
mock.patch.object(aalc_task, 'install_robust_set_foreground'), \
|
||||
mock.patch.object(aalc_task, 'WindowGuard'), \
|
||||
@@ -337,6 +343,7 @@ class DriverWiringTest(unittest.TestCase):
|
||||
mock.patch.object(ap.DriverClickProxy, '_screen_pos', return_value=(10, 20)):
|
||||
self.assertEqual(aalc_task.run(task, {}), 3 if problems else 0)
|
||||
install_hotkey.return_value.stop.assert_called_once()
|
||||
self.assertEqual(hdr_warning.call_count, int(task == 'all' and not problems))
|
||||
if problems:
|
||||
drv.click.assert_not_called()
|
||||
else:
|
||||
@@ -360,24 +367,31 @@ class DriverFailureTest(unittest.TestCase):
|
||||
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()):
|
||||
self.assertFalse(drv.click(10, 20, times=3))
|
||||
# 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))
|
||||
# 急停前的"抖动"移动(见 DriverInput.click 注释 4)允许存在, 急停之后不能再有输入
|
||||
moves = drv._dll.moveR.call_count
|
||||
self.assertFalse(drv.move_relative(20, 30))
|
||||
self.assertFalse(drv.down())
|
||||
drv._dll.moveR.assert_not_called()
|
||||
self.assertEqual(drv._dll.moveR.call_count, moves)
|
||||
self.assertEqual(drv._pressed, set())
|
||||
|
||||
def test_release_even_if_sleep_is_interrupted(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, '')), \
|
||||
mock.patch.object(di.time, 'sleep', side_effect=InterruptedError):
|
||||
with self.assertRaises(InterruptedError):
|
||||
drv.click(1, 2)
|
||||
# settle=0 让第一个 sleep 出现在按下之后, 测的才是 try/finally
|
||||
drv.click(1, 2, require_foreground=False, settle=0)
|
||||
drv._dll.mouse_up.assert_called_once_with(1)
|
||||
|
||||
def test_release_even_if_coordinate_lookup_fails(self):
|
||||
@@ -455,5 +469,171 @@ class ForegroundFallbackTest(unittest.TestCase):
|
||||
[mock.call(33, 11, True), mock.call(33, 11, False)])
|
||||
|
||||
|
||||
|
||||
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):
|
||||
"""位置对却点不上 —— 头号原因是前台不是游戏。
|
||||
|
||||
2026-10-23 实测: 窗口位置和坐标换算都正确, 但前台是浏览器, 点击全部落到
|
||||
浏览器里, 而旧版 click() 照样返回 True。这组测试守住"必须拒绝"这一条。
|
||||
"""
|
||||
|
||||
def _drv(self):
|
||||
d = di.DriverInput(dll_path='X.dll', log=lambda m: None)
|
||||
d._dll = mock.Mock()
|
||||
d._open = True
|
||||
return d
|
||||
|
||||
def test_rejects_when_no_foreground_window(self):
|
||||
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):
|
||||
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):
|
||||
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')
|
||||
|
||||
def test_click_refuses_when_check_fails(self):
|
||||
"""校验不过 -> 一个按键都不许发。"""
|
||||
pos = {'v': (500, 400)}
|
||||
d = self._drv()
|
||||
d._dll.moveR.side_effect = lambda dx, dy, _: None
|
||||
with mock.patch.object(di, 'get_cursor', lambda: pos['v']), \
|
||||
mock.patch.object(di.time, 'sleep', lambda s: None), \
|
||||
mock.patch.object(di, 'click_point_is_on_foreground',
|
||||
lambda *a, **k: (False, '')):
|
||||
self.assertFalse(d.click(500, 400))
|
||||
d._dll.mouse_down.assert_not_called()
|
||||
d._dll.mouse_up.assert_not_called()
|
||||
|
||||
def test_click_proceeds_when_check_passes(self):
|
||||
pos = {'v': (500, 400)}
|
||||
d = self._drv()
|
||||
with mock.patch.object(di, 'get_cursor', lambda: pos['v']), \
|
||||
mock.patch.object(di.time, 'sleep', lambda s: None), \
|
||||
mock.patch.object(di, 'click_point_is_on_foreground',
|
||||
lambda *a, **k: (True, '')):
|
||||
self.assertTrue(d.click(500, 400))
|
||||
d._dll.mouse_down.assert_called_once_with(1)
|
||||
d._dll.mouse_up.assert_called_once_with(1)
|
||||
|
||||
def test_press_duration_is_passed_through(self):
|
||||
"""按下时长必须真的用上 —— 30ms 在掉帧时会漏点。"""
|
||||
pos = {'v': (500, 400)}
|
||||
d = self._drv()
|
||||
slept = []
|
||||
with mock.patch.object(di, 'get_cursor', lambda: pos['v']), \
|
||||
mock.patch.object(di.time, 'sleep', lambda s: slept.append(s)), \
|
||||
mock.patch.object(di, 'click_point_is_on_foreground',
|
||||
lambda *a, **k: (True, '')):
|
||||
d.click(500, 400, press_ms=120, settle=0)
|
||||
self.assertIn(0.12, slept, '按下时长没生效')
|
||||
|
||||
def test_settle_delay_happens_before_press(self):
|
||||
"""定位成功到按下之间要有间隔, 否则游戏把这次点击算在旧位置。"""
|
||||
pos = {'v': (500, 400)}
|
||||
d = self._drv()
|
||||
order = []
|
||||
d._dll.mouse_down.side_effect = lambda b: order.append('down')
|
||||
with mock.patch.object(di, 'get_cursor', lambda: pos['v']), \
|
||||
mock.patch.object(di, 'click_point_is_on_foreground',
|
||||
lambda *a, **k: (True, '')), \
|
||||
mock.patch.object(di.time, 'sleep',
|
||||
lambda s: order.append('sleep%.2f' % s)):
|
||||
d.click(500, 400, settle=0.08)
|
||||
self.assertIn('down', order)
|
||||
self.assertTrue(any(x.startswith('sleep') for x in order[:order.index('down')]),
|
||||
'按下之前必须有 sleep')
|
||||
|
||||
class HwndForegroundCheckTest(unittest.TestCase):
|
||||
"""句柄级前台校验。
|
||||
|
||||
⛔ 为什么不能只比矩形(2026-10-23 实测): 把浏览器切到前台, 点游戏里同一个
|
||||
坐标, 只判断"点在不在前台窗口矩形内"的话**照样通过** —— 因为那个屏幕坐标
|
||||
同时也落在浏览器窗口的矩形里。窗口重叠时几何判断毫无意义。
|
||||
|
||||
给了 hwnd 就必须要求前台窗口就是它。
|
||||
"""
|
||||
|
||||
def test_accepts_when_foreground_is_the_target(self):
|
||||
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):
|
||||
"""游戏可能有子窗口拿到焦点, 也算在目标窗口上。"""
|
||||
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):
|
||||
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() 必须走句柄级校验。"""
|
||||
d = di.DriverInput(dll_path='X.dll', log=lambda m: None)
|
||||
d._dll = mock.Mock()
|
||||
d._open = True
|
||||
d.bind_window(4242)
|
||||
self.assertEqual(d.hwnd, 4242)
|
||||
seen = {}
|
||||
|
||||
def fake_check(sx, sy, hwnd=None):
|
||||
seen['hwnd'] = hwnd
|
||||
return False, '前台不是目标窗口'
|
||||
|
||||
with mock.patch.object(di, 'get_cursor', lambda: (10, 10)), \
|
||||
mock.patch.object(di, 'click_point_is_on_foreground', fake_check), \
|
||||
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()
|
||||
|
||||
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,383 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""镜牢事件按选项表选择(BACKLOG P1-4)。
|
||||
|
||||
2026-11-14 核对: Mirror.event_handling() 不认事件, 有 "???"/直接拿饰品/优势判定就选它, 否则点第一个选项。
|
||||
补丁在上游每轮挑选项前按选项原文认事件、按表点; 端到端用例执行上游真实的 event_handling
|
||||
(以及小指良单通模式用的 click_option_avoiding_unknown)。
|
||||
"""
|
||||
import ast
|
||||
import functools
|
||||
import json
|
||||
import os
|
||||
import sys
|
||||
import tempfile
|
||||
import time
|
||||
import types
|
||||
import unittest
|
||||
from pathlib import Path
|
||||
from types import SimpleNamespace
|
||||
from unittest import mock
|
||||
|
||||
REPO = Path(__file__).resolve().parents[1]
|
||||
sys.path.insert(0, str(REPO))
|
||||
from lc_mcp import aalc_patches as ap # noqa: E402
|
||||
|
||||
MIRROR = REPO / 'vendor' / 'aalc' / 'tasks' / 'mirror' / 'mirror.py'
|
||||
EVENT = REPO / 'vendor' / 'aalc' / 'tasks' / 'event' / 'event_handling.py'
|
||||
SCALE = 720 / 1440
|
||||
MARKER_X = 699 # 选项框左边缘(1280x720, 由 2560 模板换算)
|
||||
ROW_GAP = 60
|
||||
|
||||
SHEEP = ['你是特别的。', '你不是特别的。']
|
||||
CHICKEN = ['鸡肉就是鸡肉喽。', '绝对是鸡腿,满满的汁液。', '鸡胸,肯定的,纯净无瑕。']
|
||||
STATUE = ['侧耳倾听。', '摘下黄铜戒指。', '放上钱币。']
|
||||
|
||||
|
||||
def markers(count):
|
||||
return [(MARKER_X, 200 + ROW_GAP * i) for i in range(count)]
|
||||
|
||||
|
||||
def rule(name='e', options=('别的选项',), text='要点的'):
|
||||
return {'name': name, 'id': None, 'options': tuple(options), 'text': text}
|
||||
|
||||
|
||||
def upstream_function(path, name, cls=None):
|
||||
tree = ast.parse(path.read_text(encoding='utf-8'))
|
||||
body = tree.body
|
||||
if cls:
|
||||
body = next(n for n in body if isinstance(n, ast.ClassDef) and n.name == cls).body
|
||||
return next(n for n in body if isinstance(n, ast.FunctionDef) and n.name == name)
|
||||
|
||||
|
||||
class NormalizeEventTextTest(unittest.TestCase):
|
||||
|
||||
def test_punctuation_width_and_spaces_are_ignored(self):
|
||||
self.assertEqual(ap.normalize_event_text('鸡胸,肯定的, 纯净 无瑕。'), '鸡胸肯定的纯净无瑕')
|
||||
self.assertEqual(ap.normalize_event_text('“我不特别吗?”'), '我不特别吗')
|
||||
self.assertEqual(ap.normalize_event_text('施加震颐'), '施加震颤')
|
||||
|
||||
|
||||
class EventOptionsTest(unittest.TestCase):
|
||||
|
||||
def test_lines_attach_to_the_nearest_option_on_the_right(self):
|
||||
lines = [('你是特别的', 900, 200),
|
||||
('你不是', 900, 255), ('特别的。', 1000, 265), # 一项换成两行
|
||||
('离开', 900, 322),
|
||||
('侧耳倾听', 300, 260), # 左边的叙述文字不算选项
|
||||
('梦中的电子羊', 200, 60)] # 标题
|
||||
options = ap.event_options(list(reversed(markers(3))), lines, SCALE)
|
||||
self.assertEqual([text for _, text in options], ['你是特别的', '你不是特别的', '离开'])
|
||||
self.assertEqual([pos for pos, _ in options], markers(3))
|
||||
|
||||
def test_text_far_below_the_last_option_is_ignored(self):
|
||||
options = ap.event_options(markers(1), [('继续', 900, 200 + 31)], SCALE)
|
||||
self.assertEqual(options[0][1], '')
|
||||
|
||||
|
||||
class ChooseEventOptionTest(unittest.TestCase):
|
||||
|
||||
def test_event_is_recognised_by_its_other_options(self):
|
||||
rules = [rule('羊', ['你是特别的'], '你不是特别的')]
|
||||
self.assertEqual(ap.choose_event_option(rules, ('你是特别的', '你不是特别的')), (rules[0], 1))
|
||||
self.assertEqual(ap.choose_event_option(rules, ('你不是特别的', '离开')), (None, None))
|
||||
|
||||
def test_all_listed_options_must_be_on_screen(self):
|
||||
rules = [rule('鸡', ['绝对是鸡腿', '鸡胸肯定的'], '鸡肉就是鸡肉喽')]
|
||||
self.assertEqual(ap.choose_event_option(rules, ('鸡肉就是鸡肉喽', '绝对是鸡腿满满的汁液')), (None, None))
|
||||
|
||||
def test_recognised_but_target_not_read(self):
|
||||
rules = [rule('鸡', ['绝对是鸡腿'], '鸡肉就是鸡肉喽')]
|
||||
self.assertEqual(ap.choose_event_option(rules, ('鸡肉就是鸡', '绝对是鸡腿')), (rules[0], None))
|
||||
|
||||
def test_first_matching_rule_wins(self):
|
||||
rules = [rule('a', ['离开'], '战斗'), rule('b', ['离开'], '交谈')]
|
||||
self.assertEqual(ap.choose_event_option(rules, ('交谈', '战斗', '离开')), (rules[0], 1))
|
||||
|
||||
|
||||
class EventTableTest(unittest.TestCase):
|
||||
|
||||
def test_shipped_table_is_valid(self):
|
||||
rules = ap.load_event_choices()
|
||||
self.assertGreaterEqual(len(rules), 5)
|
||||
for r in rules:
|
||||
with self.subTest(event=r['name']):
|
||||
self.assertIsInstance(r['id'], int) # 零协汉化 ActionEvents 的事件 id, 方便回查
|
||||
|
||||
def test_shipped_events_come_from_the_event_reference(self):
|
||||
reference = (REPO / 'docs/skills/limbus-mirror-speedrun/references/event-choices.md').read_text(encoding='utf-8')
|
||||
for r in ap.load_event_choices():
|
||||
with self.subTest(event=r['name']):
|
||||
self.assertIn(r['name'].split('(')[0], reference)
|
||||
|
||||
def test_each_shipped_event_picks_its_own_option(self):
|
||||
rules = ap.load_event_choices()
|
||||
for r in rules:
|
||||
with self.subTest(event=r['name']):
|
||||
screen = (r['text'],) + r['options']
|
||||
self.assertEqual(ap.choose_event_option(rules, screen), (r, 0))
|
||||
|
||||
def test_bad_tables_raise_value_error(self):
|
||||
bad = ['[]', '{"events": {}}', '{"events": [1]}',
|
||||
'{"events": [{"name": "a", "options": ["x"]}]}',
|
||||
'{"events": [{"name": "a", "options": [], "text": "y"}]}',
|
||||
'{"events": [{"name": "a", "options": "x", "text": "y"}]}',
|
||||
'{"events": [{"name": "a", "options": ["x"], "text": ["y"]}]}',
|
||||
'{"events": [{"name": "a", "options": ["。"], "text": "y"}]}',
|
||||
'{"events": [{"name": "a", "options": ["离开"], "text": "离开。"}]}',
|
||||
'{"events": [{"name": "a", "match": ["x"], "index": 2}]}']
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
path = os.path.join(tmp, 'e.json')
|
||||
for content in bad:
|
||||
with self.subTest(content=content):
|
||||
with open(path, 'w', encoding='utf-8') as f:
|
||||
f.write(content)
|
||||
with self.assertRaises(ValueError):
|
||||
ap.load_event_choices(path)
|
||||
|
||||
|
||||
class EventScreen:
|
||||
"""事件界面: 依次几屏选项, 点了一项就进下一屏, 最后回到地图。unknown 是带 "???" 标签的那一项。"""
|
||||
|
||||
def __init__(self, screens, unknown=None, ignore_clicks=0):
|
||||
self.screens = [list(s) for s in screens]
|
||||
self.unknown = unknown
|
||||
self.stage = 0
|
||||
self.ignore_clicks = ignore_clicks
|
||||
self.chosen = []
|
||||
self.model = None
|
||||
self.screenshot = object()
|
||||
self.ocr_runs = 0
|
||||
|
||||
@property
|
||||
def options(self):
|
||||
return self.screens[self.stage] if self.stage < len(self.screens) else None
|
||||
|
||||
def take_screenshot(self, *args, **kwargs):
|
||||
self.screenshot = object() # 每次截图都是新对象, 与 AALC 一致
|
||||
return self.screenshot
|
||||
|
||||
def mouse_to_blank(self, *args, **kwargs):
|
||||
pass
|
||||
|
||||
def find_element(self, target, find_type='image', threshold=0.8, **kwargs):
|
||||
options = self.options
|
||||
if target == 'mirror/road_in_mir/legend_assets.png':
|
||||
return options is None
|
||||
if target == ap.EVENT_OPTION and options:
|
||||
return markers(len(options)) if find_type == 'image_with_multiple_targets' else markers(1)[0]
|
||||
if target == ap.EVENT_HOOK and options and self.stage == 0 and self.unknown is not None:
|
||||
x, y = markers(len(options))[self.unknown]
|
||||
return (x + 300, y + 20) # 标签画在所属选项框里面, 比左边缘靠下
|
||||
if target == 'event/choices_assets.png':
|
||||
return bool(options)
|
||||
return [] if find_type == 'image_with_multiple_targets' else False
|
||||
|
||||
def click_element(self, target, **kwargs):
|
||||
if target == ap.EVENT_OPTION and self.options:
|
||||
self.mouse_click(*markers(1)[0])
|
||||
return True
|
||||
return False
|
||||
|
||||
def mouse_click(self, x, y, *args, **kwargs):
|
||||
if not self.options:
|
||||
return
|
||||
rows = markers(len(self.options))
|
||||
above = [i for i, (_, my) in enumerate(rows) if my <= y]
|
||||
self.chosen.append(max(above) if above else 0)
|
||||
if self.ignore_clicks:
|
||||
self.ignore_clicks -= 1
|
||||
return
|
||||
self.stage += 1
|
||||
|
||||
def find_language_text(self, *args, **kwargs):
|
||||
return False
|
||||
|
||||
def find_text_element(self, *args, **kwargs):
|
||||
return False
|
||||
|
||||
def run(self, image):
|
||||
self.ocr_runs += 1
|
||||
lines = [('事件叙述文字', 200, 60)]
|
||||
for (x, y), text in zip(markers(len(self.options or ())), self.options or ()):
|
||||
lines.append((text, x + 200, y))
|
||||
return SimpleNamespace(txts=tuple(t for t, _, _ in lines),
|
||||
boxes=[[[x - 10, y - 5], [x + 10, y - 5], [x + 10, y + 5], [x - 10, y + 5]]
|
||||
for _, x, y in lines])
|
||||
|
||||
|
||||
@unittest.skipUnless(MIRROR.is_file() and EVENT.is_file(), 'vendor/aalc 子模块未检出')
|
||||
class UpstreamEventHandlingTest(unittest.TestCase):
|
||||
"""执行上游真实的 Mirror.event_handling, 看每屏点了第几项。"""
|
||||
|
||||
def setUp(self):
|
||||
self.lines = []
|
||||
self.fn_node = upstream_function(MIRROR, 'event_handling', cls='Mirror')
|
||||
self.avoid_node = upstream_function(EVENT, 'click_option_avoiding_unknown', cls='EventHandling')
|
||||
|
||||
def play(self, screens, patched=True, env=None, unknown=None, solo=False, ignore_clicks=0):
|
||||
screen = EventScreen(screens, unknown=unknown, ignore_clicks=ignore_clicks)
|
||||
cfg = SimpleNamespace(set_win_size=720)
|
||||
avoid_ns = dict(auto=screen, log=mock.Mock())
|
||||
exec(compile(ast.Module(body=[self.avoid_node], type_ignores=[]), str(EVENT), 'exec'), avoid_ns)
|
||||
ns = dict(auto=screen, retry=lambda: True, log=mock.Mock(), time=time, back_init_menu=mock.Mock(),
|
||||
ImageUtils=SimpleNamespace(get_bbox=lambda image: (0, 0, 10, 10), load_image=lambda path: None))
|
||||
exec(compile(ast.Module(body=[self.fn_node], type_ignores=[]), str(MIRROR), 'exec'), ns)
|
||||
method = ns['event_handling']
|
||||
ns['event_handling'] = SimpleNamespace( # 上游模块 tasks.event.event_handling 的同名单例
|
||||
decision_event_handling=lambda: False,
|
||||
click_option_avoiding_unknown=functools.partial(avoid_ns['click_option_avoiding_unknown'], None))
|
||||
mirror_cls = type('Mirror', (), {'event_handling': method})
|
||||
mirror_mod = types.ModuleType('tasks.mirror.mirror')
|
||||
mirror_mod.Mirror = mirror_cls
|
||||
package = types.ModuleType('tasks.mirror')
|
||||
package.mirror = mirror_mod
|
||||
modules = {'tasks': types.ModuleType('tasks'), 'tasks.mirror': package, 'tasks.mirror.mirror': mirror_mod,
|
||||
'module': types.ModuleType('module'),
|
||||
'module.automation': SimpleNamespace(auto=screen),
|
||||
'module.config': SimpleNamespace(cfg=cfg),
|
||||
'module.ocr': SimpleNamespace(ocr=screen)}
|
||||
with mock.patch.dict(sys.modules, modules):
|
||||
if patched:
|
||||
self.assertIsNotNone(ap.install_event_choices(log=self.lines.append, env=env or {}))
|
||||
mirror = mirror_cls()
|
||||
mirror.event_total_time, mirror.event_times = 0, 0
|
||||
mirror.defense_for_solo = solo
|
||||
mirror.event_handling()
|
||||
self.assertEqual(mirror.event_times, 1)
|
||||
self.assertNotIn('find_element', vars(screen), 'find_element 必须还原')
|
||||
self.assertNotIn('mouse_click', vars(screen), 'mouse_click 必须还原')
|
||||
self.screen = screen
|
||||
return screen.chosen
|
||||
|
||||
@property
|
||||
def log(self):
|
||||
return '\n'.join(self.lines)
|
||||
|
||||
def test_patch_hooks_into_the_current_upstream(self):
|
||||
self.play([SHEEP])
|
||||
self.assertIn('patch: 镜牢事件按选项表选择', self.log)
|
||||
self.assertNotIn('[ERROR]', self.log)
|
||||
|
||||
def test_table_choice_is_clicked_exactly_once(self):
|
||||
self.assertEqual(self.play([SHEEP], patched=False), [0])
|
||||
self.assertEqual(self.play([SHEEP]), [1]) # 上游拿返回的位置再点一次会被吞掉
|
||||
self.assertIn('事件 梦中的电子羊: 1=你是特别的 | 2=你不是特别的; 按表选第 2 项「你不是特别的」', self.log)
|
||||
|
||||
def test_table_beats_the_unknown_tag(self):
|
||||
# 上游有 "???" 就点 "???"; 表里的事件按表点
|
||||
self.assertEqual(self.play([CHICKEN[::-1]], unknown=0, patched=False), [0])
|
||||
self.assertEqual(self.play([CHICKEN[::-1]], unknown=0), [2])
|
||||
|
||||
def test_solo_mode_does_not_click_a_second_option(self):
|
||||
# 小指良单通模式会再找一次 "???" 并改点别的选项; 已按表点过时它必须什么也不做
|
||||
self.assertEqual(self.play([STATUE], unknown=0, solo=True, patched=False), [1])
|
||||
self.assertEqual(self.play([STATUE], unknown=0, solo=True), [0])
|
||||
|
||||
def test_unknown_event_behaves_like_upstream(self):
|
||||
for kwargs in ({}, {'unknown': 1}, {'unknown': 1, 'solo': True}):
|
||||
with self.subTest(**kwargs):
|
||||
options = [['战斗', '离开']]
|
||||
self.assertEqual(self.play(options, **kwargs), self.play(options, patched=False, **kwargs))
|
||||
self.assertIn('事件选项: 1=战斗 | 2=离开; 表里没有这个事件, 交给 AALC', self.log)
|
||||
|
||||
def test_one_ocr_per_screenshot_in_solo_mode(self):
|
||||
# 单通模式下上游会再找一次 "???"; 同一张截图不再整屏 OCR 第二遍
|
||||
self.assertEqual(self.play([['战斗', '离开']], unknown=1, solo=True), [0])
|
||||
self.assertEqual(self.screen.ocr_runs, 1)
|
||||
|
||||
def test_misread_target_falls_back_to_upstream(self):
|
||||
options = [['鸡肉就是鸡', CHICKEN[1], CHICKEN[2]]]
|
||||
self.assertEqual(self.play(options), [0])
|
||||
self.assertIn('表里要点的「鸡肉就是鸡肉喽」没读到, 交给 AALC', self.log)
|
||||
|
||||
def test_later_screens_not_in_the_table_go_to_upstream(self):
|
||||
self.assertEqual(self.play([CHICKEN[::-1], ['好', '不好']]), [2, 0])
|
||||
|
||||
def test_unresponsive_clicks_are_capped(self):
|
||||
chosen = self.play([SHEEP], ignore_clicks=ap.EVENT_TEXT_CLICKS + 1)
|
||||
self.assertEqual(chosen[:ap.EVENT_TEXT_CLICKS + 1], [1] * ap.EVENT_TEXT_CLICKS + [0])
|
||||
self.assertIn('这次事件已按表点了 %d 次, 交给 AALC' % ap.EVENT_TEXT_CLICKS, self.log)
|
||||
|
||||
def test_decisions_are_recorded_once_per_screen(self):
|
||||
with mock.patch.object(ap.decisions, 'record') as record:
|
||||
self.play([SHEEP])
|
||||
self.play([['战斗', '离开']])
|
||||
self.assertEqual(record.call_args_list, [
|
||||
mock.call('event', 2, 'text', event='梦中的电子羊', event_id=901038, options=['你是特别的', '你不是特别的']),
|
||||
mock.call('event', None, 'not_in_table', options=['战斗', '离开'])])
|
||||
|
||||
def test_env_zero_keeps_upstream(self):
|
||||
self.assertIsNone(ap.install_event_choices(log=self.lines.append, env={ap.EVENT_CHOICES_ENV: '0'}))
|
||||
|
||||
|
||||
class InstallEventChoicesTest(unittest.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
self.lines = []
|
||||
self.original = mock.Mock(side_effect=RuntimeError('boom'))
|
||||
self.mirror_cls = type('Mirror', (), {'event_handling': self.original})
|
||||
mirror_mod = types.ModuleType('tasks.mirror.mirror')
|
||||
mirror_mod.Mirror = self.mirror_cls
|
||||
package = types.ModuleType('tasks.mirror')
|
||||
package.mirror = mirror_mod
|
||||
self.auto = SimpleNamespace(find_element=mock.Mock(return_value=False), mouse_click=mock.Mock())
|
||||
modules = {'tasks': types.ModuleType('tasks'), 'tasks.mirror': package, 'tasks.mirror.mirror': mirror_mod,
|
||||
'module': types.ModuleType('module'),
|
||||
'module.automation': SimpleNamespace(auto=self.auto),
|
||||
'module.config': SimpleNamespace(cfg=SimpleNamespace(set_win_size=720))}
|
||||
patcher = mock.patch.dict(sys.modules, modules)
|
||||
patcher.start()
|
||||
self.addCleanup(patcher.stop)
|
||||
|
||||
def test_methods_are_restored_after_an_exception(self):
|
||||
find, click = self.auto.find_element, self.auto.mouse_click
|
||||
ap.install_event_choices(log=self.lines.append, env={})
|
||||
with self.assertRaises(RuntimeError):
|
||||
self.mirror_cls().event_handling()
|
||||
self.assertIs(self.auto.find_element, find)
|
||||
self.assertIs(self.auto.mouse_click, click)
|
||||
|
||||
def test_unreadable_table_is_an_error(self):
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
path = os.path.join(tmp, 'e.json')
|
||||
with open(path, 'w', encoding='utf-8') as f:
|
||||
json.dump({'events': [{'name': 'a', 'match': ['x'], 'index': 1}]}, f)
|
||||
self.assertIsNone(ap.install_event_choices(log=self.lines.append, env={ap.EVENT_CHOICES_ENV: path}))
|
||||
self.assertIs(self.mirror_cls.event_handling, self.original)
|
||||
self.assertTrue(self.lines[0].startswith('[ERROR] [lc_mcp] 事件选项表补丁跳过'))
|
||||
|
||||
def test_upstream_without_the_hook_is_an_error(self):
|
||||
auto = self.auto
|
||||
|
||||
def event_handling(mirror):
|
||||
return auto.click_element("event/unknown_event.png") # 旧写法: 补丁挂不上
|
||||
|
||||
self.mirror_cls.event_handling = event_handling
|
||||
self.assertIsNone(ap.install_event_choices(log=self.lines.append, env={}))
|
||||
self.assertIs(self.mirror_cls.event_handling, event_handling)
|
||||
self.assertIn('[ERROR] [lc_mcp] 事件选项表补丁跳过: 上游 Mirror.event_handling 不再调用 find_element',
|
||||
'\n'.join(self.lines))
|
||||
|
||||
def test_decision_error_falls_back_to_upstream_find(self):
|
||||
calls = []
|
||||
auto = self.auto
|
||||
|
||||
def find(target, *args, **kwargs):
|
||||
if target == ap.EVENT_OPTION:
|
||||
raise RuntimeError('template')
|
||||
return False
|
||||
|
||||
def event_handling(mirror):
|
||||
calls.append(auto.find_element("event/unknown_event.png"))
|
||||
|
||||
self.auto.find_element = mock.Mock(side_effect=find)
|
||||
self.mirror_cls.event_handling = event_handling
|
||||
ap.install_event_choices(log=self.lines.append, env={})
|
||||
self.mirror_cls().event_handling()
|
||||
self.assertEqual(calls, [False])
|
||||
self.assertEqual(self.auto.find_element.call_args_list[-1], mock.call(ap.EVENT_HOOK))
|
||||
self.assertIn('事件选项表出错(RuntimeError: template)', '\n'.join(self.lines))
|
||||
|
||||
|
||||
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()
|
||||
@@ -0,0 +1,261 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""「获得E.G.O饰品」确认弹窗兜底(ISSUES I-06 / R-04)。
|
||||
|
||||
2026-11-14 18:45: AALC 一直点确认模板的匹配点(勾号), 弹窗不关, 连点 5 分钟; 手动点按钮中心一次就过。
|
||||
上游 select_init_ego_gift 点到确认就 continue, 循环底部的 loop_count 退出判断永远走不到。
|
||||
端到端用例执行上游真实的 select_init_ego_gift。
|
||||
"""
|
||||
import ast
|
||||
import sys
|
||||
import types
|
||||
import unittest
|
||||
from pathlib import Path
|
||||
from types import SimpleNamespace
|
||||
from unittest import mock
|
||||
|
||||
REPO = Path(__file__).resolve().parents[1]
|
||||
sys.path.insert(0, str(REPO))
|
||||
from lc_mcp import aalc_patches as ap # noqa: E402
|
||||
|
||||
MIRROR = REPO / 'vendor' / 'aalc' / 'tasks' / 'mirror' / 'mirror.py'
|
||||
CONFIRM = ap.GIFT_CONFIRM
|
||||
TICK = (602.0, 531.75) # 1280x720 下确认模板(勾号)的中心
|
||||
BUTTON = (640, 532) # 按钮中心: 勾号 + 76 * 720/1440
|
||||
|
||||
|
||||
class Popup:
|
||||
"""只有确认弹窗的假 auto: 点按钮中心才关(closes_on_button), 点勾号永远不关。"""
|
||||
|
||||
def __init__(self, closes_on_button=True):
|
||||
self.open = True
|
||||
self.closes_on_button = closes_on_button
|
||||
self.template_clicks = 0
|
||||
self.button_clicks = []
|
||||
self.other_ok = False
|
||||
|
||||
def click_element(self, target, *args, click=True, **kwargs):
|
||||
if target == CONFIRM and self.open:
|
||||
if not click:
|
||||
return TICK
|
||||
self.template_clicks += 1
|
||||
return True
|
||||
if target == 'other' and self.other_ok:
|
||||
return True if click else (1, 1)
|
||||
return False
|
||||
|
||||
def mouse_click(self, x, y, *args, **kwargs):
|
||||
self.button_clicks.append((x, y))
|
||||
if self.closes_on_button and abs(x - BUTTON[0]) <= 15 and abs(y - BUTTON[1]) <= 15:
|
||||
self.open = False
|
||||
return True
|
||||
|
||||
|
||||
class GuardTest(unittest.TestCase):
|
||||
|
||||
def install(self, auto, clock=None):
|
||||
self.lines = []
|
||||
self.now = [0.0]
|
||||
modules = {'module': types.ModuleType('module'),
|
||||
'module.automation': SimpleNamespace(auto=auto),
|
||||
'module.config': SimpleNamespace(cfg=SimpleNamespace(set_win_size=720))}
|
||||
with mock.patch.dict(sys.modules, modules):
|
||||
self.assertIsNotNone(ap.install_gift_confirm_guard(
|
||||
log=self.lines.append, clock=clock or (lambda: self.now[0])))
|
||||
return auto
|
||||
|
||||
def hit(self, auto, times=1, step=1.5):
|
||||
results = []
|
||||
for _ in range(times):
|
||||
self.now[0] += step
|
||||
results.append(auto.click_element(CONFIRM))
|
||||
return results
|
||||
|
||||
def test_first_two_hits_are_upstream_clicks(self):
|
||||
auto = self.install(Popup())
|
||||
self.assertEqual(self.hit(auto, 2), [True, True])
|
||||
self.assertEqual(auto.template_clicks, 2)
|
||||
self.assertEqual(auto.button_clicks, [])
|
||||
|
||||
def test_third_hit_clicks_the_button_center_and_closes_it(self):
|
||||
auto = self.install(Popup())
|
||||
with mock.patch.object(ap.decisions, 'record') as record:
|
||||
self.assertEqual(self.hit(auto, 3), [True, True, True])
|
||||
self.assertEqual(auto.button_clicks, [BUTTON])
|
||||
self.assertFalse(auto.open)
|
||||
self.assertIn('确认点了 2 次还在, 改点按钮中心 (640,532)', '\n'.join(self.lines))
|
||||
record.assert_called_once_with('gift_confirm', 'button_center', 'repeated', clicks=2)
|
||||
self.assertEqual(auto.click_element(CONFIRM), False) # 关了就找不到
|
||||
|
||||
def test_repeat_clicks_bypass_the_driver_proxy(self):
|
||||
# 2026-11-15: 罗技驱动的物理点击点不掉这个弹窗, 同一坐标用 pyautogui 软件点击可以。
|
||||
# 第 3 次起必须绕过驱动代理, 直接调底层 handler。
|
||||
auto = self.install(Popup(closes_on_button=False))
|
||||
inner = []
|
||||
auto.input_handler = SimpleNamespace(
|
||||
_handler=SimpleNamespace(mouse_click=lambda x, y, *a, **k: inner.append((x, y))))
|
||||
self.hit(auto, 3)
|
||||
self.assertEqual(len(inner), 1)
|
||||
self.assertEqual(inner[0], BUTTON)
|
||||
self.assertEqual(auto.button_clicks, []) # 没再走驱动代理的 mouse_click
|
||||
|
||||
def test_enter_fallback_when_software_click_also_fails(self):
|
||||
auto = self.install(Popup(closes_on_button=False))
|
||||
inner = []
|
||||
auto.input_handler = SimpleNamespace(
|
||||
_handler=SimpleNamespace(mouse_click=lambda x, y, *a, **k: inner.append((x, y))))
|
||||
auto.key_press = mock.Mock()
|
||||
self.hit(auto, ap.GIFT_CONFIRM_ENTER_AT)
|
||||
auto.key_press.assert_called_once_with('enter')
|
||||
def test_stuck_popup_ends_the_task(self):
|
||||
auto = self.install(Popup(closes_on_button=False))
|
||||
with mock.patch.object(ap.decisions, 'record'), self.assertRaises(ap.TaskAbort):
|
||||
self.hit(auto, ap.GIFT_CONFIRM_LIMIT)
|
||||
self.assertEqual(len(auto.button_clicks), ap.GIFT_CONFIRM_LIMIT - ap.GIFT_CONFIRM_SHIFT_AT)
|
||||
self.assertIn('[ERROR] [lc_mcp] 「获得E.G.O饰品」确认连点 20 次弹窗还在, 结束任务', '\n'.join(self.lines))
|
||||
# 不是 Exception: AALC 的 onetime_mir_process 吞不掉它
|
||||
self.assertFalse(issubclass(ap.TaskAbort, Exception))
|
||||
|
||||
def test_other_successful_click_resets_the_streak(self):
|
||||
auto = self.install(Popup(closes_on_button=False))
|
||||
self.hit(auto, 2)
|
||||
auto.other_ok = True
|
||||
self.assertTrue(auto.click_element('other'))
|
||||
self.hit(auto, 2)
|
||||
self.assertEqual(auto.button_clicks, [])
|
||||
self.assertEqual(auto.template_clicks, 4)
|
||||
|
||||
def test_other_lookup_or_failed_click_does_not_reset(self):
|
||||
auto = self.install(Popup())
|
||||
self.hit(auto, 2)
|
||||
auto.click_element('missing')
|
||||
auto.other_ok = True
|
||||
auto.click_element('other', click=False) # 只查不点
|
||||
self.hit(auto, 1)
|
||||
self.assertEqual(auto.button_clicks, [BUTTON])
|
||||
|
||||
def test_missing_popup_resets_the_streak(self):
|
||||
auto = self.install(Popup())
|
||||
self.hit(auto, 2)
|
||||
auto.open = False
|
||||
self.assertEqual(self.hit(auto, 1), [False])
|
||||
auto.open = True
|
||||
self.hit(auto, 2)
|
||||
self.assertEqual(auto.button_clicks, [])
|
||||
|
||||
def test_hits_far_apart_are_not_a_streak(self):
|
||||
auto = self.install(Popup())
|
||||
self.hit(auto, 2)
|
||||
self.hit(auto, 1, step=ap.GIFT_CONFIRM_GAP + 1)
|
||||
self.assertEqual(auto.button_clicks, [])
|
||||
self.assertEqual(auto.template_clicks, 3)
|
||||
|
||||
def test_confirm_lookup_without_click_is_untouched(self):
|
||||
auto = self.install(Popup())
|
||||
for _ in range(5):
|
||||
self.assertEqual(auto.click_element(CONFIRM, click=False), TICK)
|
||||
self.assertEqual(auto.template_clicks, 0)
|
||||
self.assertEqual(self.hit(auto, 2), [True, True])
|
||||
self.assertEqual(auto.button_clicks, [])
|
||||
|
||||
|
||||
class Spinning(Exception):
|
||||
pass
|
||||
|
||||
|
||||
class InitGiftScreen:
|
||||
"""开局选饰品后的「获得E.G.O饰品」弹窗。点勾号不关, 点按钮中心才关, 关了就是卡包页。"""
|
||||
|
||||
def __init__(self, closes_on_button=True, max_shots=200):
|
||||
self.state = 'popup'
|
||||
self.closes_on_button = closes_on_button
|
||||
self.max_shots = max_shots
|
||||
self.shots = 0
|
||||
self.model = 'clam'
|
||||
self.template_clicks = 0
|
||||
|
||||
def take_screenshot(self, *args, **kwargs):
|
||||
self.shots += 1
|
||||
if self.shots > self.max_shots:
|
||||
raise Spinning(self.shots)
|
||||
return object()
|
||||
|
||||
def find_element(self, target, *args, **kwargs):
|
||||
if target == 'mirror/theme_pack/feature_theme_pack_assets.png':
|
||||
return (640, 100) if self.state == 'theme' else None
|
||||
if target == CONFIRM and self.state == 'popup':
|
||||
return TICK
|
||||
return None
|
||||
|
||||
def click_element(self, target, *args, click=True, **kwargs):
|
||||
pos = self.find_element(target)
|
||||
if not pos:
|
||||
return False
|
||||
if not click:
|
||||
return pos
|
||||
self.template_clicks += 1 # 上游点的是匹配点(勾号) ±10 像素, 点不到按钮
|
||||
return True
|
||||
|
||||
def mouse_click(self, x, y, *args, **kwargs):
|
||||
if self.closes_on_button and abs(x - BUTTON[0]) <= 15 and abs(y - BUTTON[1]) <= 15:
|
||||
self.state = 'theme'
|
||||
return True
|
||||
|
||||
def mouse_to_blank(self, *args, **kwargs):
|
||||
pass
|
||||
|
||||
def mouse_drag(self, *args, **kwargs):
|
||||
pass
|
||||
|
||||
|
||||
@unittest.skipUnless(MIRROR.is_file(), 'vendor/aalc 子模块未检出')
|
||||
class UpstreamInitGiftTest(unittest.TestCase):
|
||||
"""执行上游真实的 Mirror.select_init_ego_gift。"""
|
||||
|
||||
def setUp(self):
|
||||
tree = ast.parse(MIRROR.read_text(encoding='utf-8'))
|
||||
cls = next(n for n in tree.body if isinstance(n, ast.ClassDef) and n.name == 'Mirror')
|
||||
self.fn_node = next(n for n in cls.body
|
||||
if isinstance(n, ast.FunctionDef) and n.name == 'select_init_ego_gift')
|
||||
self.lines = []
|
||||
|
||||
def play(self, screen, patched=True):
|
||||
cfg = SimpleNamespace(set_win_size=720)
|
||||
ns = dict(auto=screen, cfg=cfg, log=mock.Mock(), sleep=lambda *a: None, retry=lambda: True,
|
||||
back_init_menu=mock.Mock(), all_systems={}, start_gift={})
|
||||
exec(compile(ast.Module(body=[self.fn_node], type_ignores=[]), str(MIRROR), 'exec'), ns)
|
||||
mirror = SimpleNamespace(system='bleed', opening_items=False, observe_ego_gift=False,
|
||||
observe_ego_gift_selected=[], observe_bbox=None,
|
||||
_click_init_gift_row=lambda gift_id: False)
|
||||
if patched:
|
||||
modules = {'module': types.ModuleType('module'),
|
||||
'module.automation': SimpleNamespace(auto=screen),
|
||||
'module.config': SimpleNamespace(cfg=cfg)}
|
||||
with mock.patch.dict(sys.modules, modules):
|
||||
ap.install_gift_confirm_guard(log=self.lines.append)
|
||||
with mock.patch.object(ap.decisions, 'record'):
|
||||
return ns['select_init_ego_gift'](mirror)
|
||||
|
||||
def test_upstream_spins_on_a_popup_its_click_cannot_close(self):
|
||||
screen = InitGiftScreen()
|
||||
with self.assertRaises(Spinning):
|
||||
self.play(screen, patched=False)
|
||||
self.assertEqual(screen.state, 'popup')
|
||||
self.assertGreater(screen.template_clicks, 100) # 计数早就负了, 照点不误
|
||||
|
||||
def test_guard_clicks_the_button_and_the_loop_moves_on(self):
|
||||
screen = InitGiftScreen()
|
||||
self.play(screen)
|
||||
self.assertEqual(screen.state, 'theme')
|
||||
self.assertEqual(screen.template_clicks, ap.GIFT_CONFIRM_SHIFT_AT - 1)
|
||||
self.assertLess(screen.shots, 10)
|
||||
|
||||
def test_guard_ends_the_task_when_nothing_closes_it(self):
|
||||
screen = InitGiftScreen(closes_on_button=False)
|
||||
with self.assertRaises(ap.TaskAbort):
|
||||
self.play(screen)
|
||||
self.assertLessEqual(screen.shots, ap.GIFT_CONFIRM_LIMIT + 1)
|
||||
self.assertIn('[ERROR]', '\n'.join(self.lines))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@@ -0,0 +1,362 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""镜牢饰品选择按体系关键词排序(BACKLOG P1-3)。
|
||||
|
||||
2026-11-14 核对: acquire_ego_gift() 两张卡时只排白棉花和已持有然后拿第一张, 不看 team_system。
|
||||
补丁在上游挑选前按卡面 OCR 的体系关键词给卡排序; 端到端用例执行上游真实的 acquire_ego_gift。
|
||||
"""
|
||||
import ast
|
||||
import json
|
||||
import os
|
||||
import sys
|
||||
import tempfile
|
||||
import types
|
||||
import unittest
|
||||
from pathlib import Path
|
||||
from types import SimpleNamespace
|
||||
from unittest import mock
|
||||
|
||||
REPO = Path(__file__).resolve().parents[1]
|
||||
sys.path.insert(0, str(REPO))
|
||||
from lc_mcp import aalc_patches as ap # noqa: E402
|
||||
|
||||
AALC = REPO / 'vendor' / 'aalc'
|
||||
MIRROR = AALC / 'tasks' / 'mirror' / 'mirror.py'
|
||||
SCALE = 720 / 1440
|
||||
|
||||
|
||||
def line_at(card, row):
|
||||
"""卡面第 row 行文字的位置(在上游判断范围内)。"""
|
||||
return card[0] + 100 * SCALE * 2, card[1] + 40 * row
|
||||
|
||||
|
||||
class GiftCardHitsTest(unittest.TestCase):
|
||||
|
||||
CARDS = [(300, 300), (600, 300), (900, 300)]
|
||||
|
||||
def hits(self, lines, keywords=('流血', '出血', 'bleed')):
|
||||
return ap.gift_card_hits(self.CARDS, lines, keywords, SCALE)
|
||||
|
||||
def test_lines_are_assigned_to_the_card_they_sit_on(self):
|
||||
lines = [('施加3层流血', *line_at(self.CARDS[1], 0)),
|
||||
('出血时伤害提高', *line_at(self.CARDS[1], 1)),
|
||||
('烧伤', *line_at(self.CARDS[0], 0)),
|
||||
('选择EGO饰品', 600, 40)] # 标题不在任何卡上
|
||||
self.assertEqual(self.hits(lines), [[], ['流血', '出血'], []])
|
||||
|
||||
def test_english_is_case_insensitive_and_spaces_are_ignored(self):
|
||||
lines = [('Inflict BLEED', *line_at(self.CARDS[2], 0)), ('流 血', *line_at(self.CARDS[0], 0))]
|
||||
self.assertEqual(self.hits(lines), [['流血'], [], ['bleed']])
|
||||
|
||||
def test_known_ocr_misreads_still_hit(self):
|
||||
lines = [('施加震颐', *line_at(self.CARDS[0], 0)), ('沉论层数', *line_at(self.CARDS[1], 0))]
|
||||
self.assertEqual(ap.gift_card_hits(self.CARDS, lines, ('震颤',), SCALE), [['震颤'], [], []])
|
||||
self.assertEqual(ap.gift_card_hits(self.CARDS, lines, ('沉沦',), SCALE), [[], ['沉沦'], []])
|
||||
|
||||
def test_overlapping_ranges_go_to_the_nearest_card(self):
|
||||
cards = [(300, 300), (450, 300)] # 两张卡的范围在 x=425..525 重叠
|
||||
lines = [('流血', 440, 300), ('流血', 500, 300)]
|
||||
self.assertEqual(ap.gift_card_hits(cards, lines, ('流血',), SCALE), [['流血'], ['流血']])
|
||||
|
||||
def test_upstream_order_undoes_the_icon_insertion(self):
|
||||
# 两张卡上游按给的顺序挑; 三张时命中的卡被上游逐张 insert(0), 所以倒着给、放在最后
|
||||
self.assertEqual(ap.gift_upstream_order([[], ['x']]), [1, 0])
|
||||
self.assertEqual(ap.gift_upstream_order([['x'], [], ['x', 'y']]), [1, 0, 2])
|
||||
self.assertEqual(ap.gift_upstream_order([[], [], []]), [0, 1, 2])
|
||||
|
||||
def test_rank_is_stable(self):
|
||||
cards = ['a', 'b', 'c']
|
||||
self.assertEqual(ap.rank_gift_cards(cards, [[], ['x'], []]), ['b', 'a', 'c'])
|
||||
self.assertEqual(ap.rank_gift_cards(cards, [[], [], []]), cards)
|
||||
self.assertEqual(ap.rank_gift_cards(cards, [['x'], ['x', 'y'], ['x']]), ['b', 'a', 'c'])
|
||||
|
||||
|
||||
class KeywordTableTest(unittest.TestCase):
|
||||
|
||||
def test_shipped_table_covers_every_upstream_system(self):
|
||||
table = ap.load_gift_keywords()
|
||||
source = AALC / 'tasks' / '__init__.py'
|
||||
if source.is_file():
|
||||
tree = ast.parse(source.read_text(encoding='utf-8'))
|
||||
node = next(n for n in tree.body if isinstance(n, ast.Assign)
|
||||
and getattr(n.targets[0], 'id', None) == 'all_systems')
|
||||
self.assertEqual(set(table), set(ast.literal_eval(node.value).values()))
|
||||
for system, words in table.items():
|
||||
self.assertTrue(words, system)
|
||||
|
||||
def test_bad_files_raise_value_error(self):
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
path = os.path.join(tmp, 'k.json')
|
||||
for content in ('[]', '{"bleed": "流血"}', '{"bleed": [1]}', '{'):
|
||||
with self.subTest(content=content):
|
||||
with open(path, 'w', encoding='utf-8') as f:
|
||||
f.write(content)
|
||||
with self.assertRaises(ValueError):
|
||||
ap.load_gift_keywords(path)
|
||||
|
||||
def test_notes_are_ignored(self):
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
path = os.path.join(tmp, 'k.json')
|
||||
with open(path, 'w', encoding='utf-8') as f:
|
||||
json.dump({'_说明': ['x'], 'bleed': ['流血', ' ']}, f, ensure_ascii=False)
|
||||
self.assertEqual(ap.load_gift_keywords(path), {'bleed': ('流血',)})
|
||||
|
||||
|
||||
class GiftScreen:
|
||||
"""饰品选择界面: 每张卡 {'pos', 'lines', 'icon'}; icon 为 True 的卡体系图标模板能匹配上
|
||||
(本机日志里没见它匹配上过, 默认 False)。"""
|
||||
|
||||
def __init__(self, cards, pick='0/1'):
|
||||
self.cards = cards
|
||||
self.pick = pick
|
||||
self.clicks = []
|
||||
self.ocr_runs = 0
|
||||
self.model = None
|
||||
self.screenshot = object()
|
||||
|
||||
def lines(self):
|
||||
return [(text, *line_at(card['pos'], row))
|
||||
for card in self.cards for row, text in enumerate(card['lines'])]
|
||||
|
||||
def take_screenshot(self):
|
||||
return self.screenshot
|
||||
|
||||
def mouse_to_blank(self):
|
||||
pass
|
||||
|
||||
def click_element(self, target, **kwargs):
|
||||
return target.endswith('acquire_ego_gift_select_assets.png')
|
||||
|
||||
def find_element(self, target, find_type='image', threshold=0.8, my_crop=None, **kwargs):
|
||||
if target == ap.GIFT_CARD and find_type == 'image_with_multiple_targets':
|
||||
return [card['pos'] for card in self.cards]
|
||||
if target.startswith('mirror/road_in_mir/acquire_ego_gift/') and my_crop:
|
||||
x1, y1, x2, y2 = my_crop
|
||||
for card in self.cards:
|
||||
if card.get('icon') and x1 <= card['pos'][0] <= x2 and y1 <= card['pos'][1] <= y2:
|
||||
return card['pos']
|
||||
return False
|
||||
|
||||
def find_language_text(self, zh_text, en_text, my_crop=None, **kwargs):
|
||||
words = [zh_text] if isinstance(zh_text, str) else zh_text
|
||||
x1, y1, x2, y2 = my_crop
|
||||
for text, x, y in self.lines():
|
||||
if x1 <= x <= x2 and y1 <= y <= y2 and any(w in text for w in words):
|
||||
return [x, y]
|
||||
return False
|
||||
|
||||
def find_text_element(self, targets, my_crop=None, **kwargs):
|
||||
return self.pick in targets
|
||||
|
||||
def mouse_click(self, x, y):
|
||||
self.clicks.append((x, y))
|
||||
|
||||
def run(self, image):
|
||||
self.ocr_runs += 1
|
||||
lines = self.lines()
|
||||
return SimpleNamespace(txts=tuple(t for t, _, _ in lines),
|
||||
boxes=[[[x - 10, y - 5], [x + 10, y - 5], [x + 10, y + 5], [x - 10, y + 5]]
|
||||
for _, x, y in lines])
|
||||
|
||||
|
||||
def card(x, *lines, icon=False):
|
||||
return {'pos': (x, 300), 'lines': list(lines), 'icon': icon}
|
||||
|
||||
|
||||
@unittest.skipUnless(MIRROR.is_file(), 'vendor/aalc 子模块未检出')
|
||||
class UpstreamAcquireEgoGiftTest(unittest.TestCase):
|
||||
"""执行上游真实的 Mirror.acquire_ego_gift, 看最后点了哪张卡。"""
|
||||
|
||||
def setUp(self):
|
||||
self.lines = []
|
||||
tree = ast.parse(MIRROR.read_text(encoding='utf-8'))
|
||||
cls = next(n for n in tree.body if isinstance(n, ast.ClassDef) and n.name == 'Mirror')
|
||||
self.fn_node = next(n for n in cls.body if isinstance(n, ast.FunctionDef) and n.name == 'acquire_ego_gift')
|
||||
|
||||
def choose(self, cards, system='bleed', patched=True, pick='0/1', env=None):
|
||||
screen = GiftScreen(cards, pick=pick)
|
||||
cfg = SimpleNamespace(set_win_size=720, not_skip_whitegossypium=False, mouse_action_interval=0)
|
||||
ns = dict(cfg=cfg, auto=screen, sleep=lambda *a: None, time=SimpleNamespace(sleep=lambda *a: None),
|
||||
retry=lambda: True, log=mock.Mock(),
|
||||
ImageUtils=SimpleNamespace(get_bbox=lambda image: None, load_image=lambda path: None),
|
||||
all_systems={0: 'burn', 1: 'bleed'})
|
||||
exec(compile(ast.Module(body=[self.fn_node], type_ignores=[]), str(MIRROR), 'exec'), ns)
|
||||
mirror_cls = type('Mirror', (), {'acquire_ego_gift': ns['acquire_ego_gift']})
|
||||
mirror_mod = types.ModuleType('tasks.mirror.mirror')
|
||||
mirror_mod.Mirror = mirror_cls
|
||||
package = types.ModuleType('tasks.mirror')
|
||||
package.mirror = mirror_mod
|
||||
modules = {'tasks': types.ModuleType('tasks'), 'tasks.mirror': package, 'tasks.mirror.mirror': mirror_mod,
|
||||
'module': types.ModuleType('module'),
|
||||
'module.automation': SimpleNamespace(auto=screen),
|
||||
'module.config': SimpleNamespace(cfg=cfg),
|
||||
'module.ocr': SimpleNamespace(ocr=screen)}
|
||||
with mock.patch.dict(sys.modules, modules):
|
||||
if patched:
|
||||
self.assertIsNotNone(ap.install_gift_preference(log=self.lines.append, env=env or {}))
|
||||
mirror = mirror_cls()
|
||||
mirror.system, mirror.second_system = system, False
|
||||
mirror.acquire_ego_gift()
|
||||
self.assertNotIn('find_element', vars(screen), 'find_element 必须还原')
|
||||
return [next(i for i, c in enumerate(cards) if c['pos'] == pos) for pos in screen.clicks], screen
|
||||
|
||||
@property
|
||||
def log(self):
|
||||
return '\n'.join(self.lines)
|
||||
|
||||
def test_two_cards_prefers_the_system_keyword(self):
|
||||
cards = [card(300, '烧伤层数+1'), card(600, '施加2层流血')]
|
||||
self.assertEqual(self.choose(cards, patched=False)[0], [0])
|
||||
self.assertEqual(self.choose(cards)[0], [1])
|
||||
self.assertIn('第1张=0 第2张=1(流血); 命中体系关键词, 先看第2张', self.log)
|
||||
|
||||
def test_owned_keyword_card_still_loses_to_an_unowned_one(self):
|
||||
cards = [card(300, '烧伤层数+1'), card(600, '施加2层流血', '已持有')]
|
||||
self.assertEqual(self.choose(cards)[0], [0])
|
||||
|
||||
def test_all_owned_falls_back_to_keyword_order(self):
|
||||
cards = [card(300, '烧伤', '已持有'), card(600, '流血', '已持有')]
|
||||
self.assertEqual(self.choose(cards)[0], [1])
|
||||
|
||||
def test_white_gossypium_is_still_skipped(self):
|
||||
cards = [card(300, '烧伤层数+1'), card(600, '白棉花', '流血')]
|
||||
self.assertEqual(self.choose(cards)[0], [0])
|
||||
|
||||
def test_all_white_gossypium_behaves_like_upstream(self):
|
||||
cards = [card(300, '白棉花'), card(600, '白棉花', '流血')]
|
||||
self.assertEqual(self.choose(cards)[0], self.choose(cards, patched=False)[0])
|
||||
|
||||
def test_three_cards_pick_one(self):
|
||||
cards = [card(300, '烧伤'), card(600, '震颤'), card(900, '流血伤害提高', '施加流血')]
|
||||
self.assertEqual(self.choose(cards, patched=False)[0], [0])
|
||||
self.assertEqual(self.choose(cards)[0], [2])
|
||||
|
||||
def test_three_cards_pick_two(self):
|
||||
cards = [card(300, '烧伤'), card(600, '流血'), card(900, '流血', '施加流血')]
|
||||
self.assertEqual(self.choose(cards, pick='0/2')[0], [2, 1])
|
||||
|
||||
def test_icon_cards_keep_the_keyword_order(self):
|
||||
# 上游把认出体系图标的卡逐张 insert(0), 后认出的反而排前面; 补丁要抵消这一步
|
||||
cards = [card(300, '施加流血', icon=True), card(600, '流血', '施加流血', '流血层数', icon=True), card(900, '烧伤')]
|
||||
self.assertEqual(self.choose(cards)[0], [1])
|
||||
self.assertEqual(self.choose(cards, pick='0/2')[0], [1, 0])
|
||||
|
||||
def test_keyword_card_without_icon_still_beats_an_icon_card(self):
|
||||
cards = [card(300, '流血', '施加流血', '流血层数'), card(600, '施加流血', icon=True), card(900, '烧伤')]
|
||||
self.assertEqual(self.choose(cards)[0], [0])
|
||||
|
||||
def test_icon_only_card_comes_after_keyword_cards_but_before_the_rest(self):
|
||||
cards = [card(300, '烧伤'), card(600, '没读出关键词', icon=True), card(900, '施加流血')]
|
||||
self.assertEqual(self.choose(cards, patched=False)[0], [1])
|
||||
self.assertEqual(self.choose(cards, pick='0/2')[0], [2, 1])
|
||||
|
||||
def test_without_keywords_icons_behave_like_upstream(self):
|
||||
cards = [card(300, '烧伤', icon=True), card(600, '震颤', icon=True), card(900, '充能')]
|
||||
self.assertEqual(self.choose(cards, pick='0/2')[0], self.choose(cards, pick='0/2', patched=False)[0])
|
||||
|
||||
def test_misread_keyword_for_tremor(self):
|
||||
cards = [card(300, '流血'), card(600, '施加震颐')]
|
||||
self.assertEqual(self.choose(cards, system='tremor')[0], [1])
|
||||
|
||||
def test_no_hits_keeps_upstream_choice(self):
|
||||
cards = [card(300, '烧伤'), card(600, '充能')]
|
||||
self.assertEqual(self.choose(cards)[0], [0])
|
||||
self.assertIn('未命中体系关键词, 保持原顺序', self.log)
|
||||
|
||||
def test_duplicate_lines_on_two_cards_both_count(self):
|
||||
# {文本: 坐标} 会把两张卡上的同一句合并成一条; 补丁直接读 OCR 引擎的逐行结果
|
||||
cards = [card(300, '流血'), card(600, '流血', '施加流血')]
|
||||
self.assertEqual(self.choose(cards)[0], [1])
|
||||
self.assertIn('第1张=1(流血) 第2张=2(流血/流血)', self.log)
|
||||
|
||||
def test_decision_is_recorded_left_to_right(self):
|
||||
cards = [card(300, '烧伤层数+1'), card(600, '施加2层流血')]
|
||||
with mock.patch.object(ap.decisions, 'record') as record:
|
||||
self.choose(cards)
|
||||
record.assert_called_once_with('gift', 2, 'keyword', system='bleed', hits=[[], ['流血']])
|
||||
|
||||
def test_unknown_system_skips_ocr(self):
|
||||
cards = [card(300, '烧伤'), card(600, '流血')]
|
||||
chosen, screen = self.choose(cards, system='unknown')
|
||||
self.assertEqual((chosen, screen.ocr_runs), ([0], 0))
|
||||
|
||||
|
||||
class InstallGiftPreferenceTest(unittest.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
self.lines = []
|
||||
self.original = mock.Mock(return_value='done')
|
||||
self.mirror_cls = type('Mirror', (), {'acquire_ego_gift': self.original})
|
||||
mirror_mod = types.ModuleType('tasks.mirror.mirror')
|
||||
mirror_mod.Mirror = self.mirror_cls
|
||||
package = types.ModuleType('tasks.mirror')
|
||||
package.mirror = mirror_mod
|
||||
self.auto = SimpleNamespace(find_element=mock.Mock(return_value=[(300, 300), (600, 300)]))
|
||||
modules = {'tasks': types.ModuleType('tasks'), 'tasks.mirror': package, 'tasks.mirror.mirror': mirror_mod,
|
||||
'module': types.ModuleType('module'),
|
||||
'module.automation': SimpleNamespace(auto=self.auto),
|
||||
'module.config': SimpleNamespace(cfg=SimpleNamespace(set_win_size=720))}
|
||||
patcher = mock.patch.dict(sys.modules, modules)
|
||||
patcher.start()
|
||||
self.addCleanup(patcher.stop)
|
||||
|
||||
def install(self, env=None):
|
||||
return ap.install_gift_preference(log=self.lines.append, env=env or {})
|
||||
|
||||
def test_env_zero_leaves_upstream_untouched(self):
|
||||
self.assertIsNone(self.install({ap.GIFT_KEYWORDS_ENV: '0'}))
|
||||
self.assertIs(self.mirror_cls.acquire_ego_gift, self.original)
|
||||
|
||||
def test_unreadable_table_is_an_error_and_not_installed(self):
|
||||
self.assertIsNone(self.install({ap.GIFT_KEYWORDS_ENV: '/nonexistent/k.json'}))
|
||||
self.assertIs(self.mirror_cls.acquire_ego_gift, self.original)
|
||||
self.assertTrue(self.lines[0].startswith('[ERROR] [lc_mcp] 饰品体系优先补丁跳过'))
|
||||
|
||||
def test_refuse_screen_passes_through(self):
|
||||
self.install()
|
||||
mirror = self.mirror_cls()
|
||||
mirror.system = 'bleed'
|
||||
self.assertEqual(mirror.acquire_ego_gift(type=2), 'done')
|
||||
self.original.assert_called_once_with(mirror, type=2)
|
||||
|
||||
def test_find_element_is_restored_after_an_exception(self):
|
||||
real = self.auto.find_element
|
||||
self.original.side_effect = RuntimeError('boom')
|
||||
self.install()
|
||||
mirror = self.mirror_cls()
|
||||
mirror.system = 'bleed'
|
||||
with self.assertRaises(RuntimeError):
|
||||
mirror.acquire_ego_gift()
|
||||
self.assertIs(self.auto.find_element, real)
|
||||
|
||||
def test_ranking_error_keeps_upstream_order(self):
|
||||
cards = [(300, 300), (600, 300)]
|
||||
|
||||
auto = self.auto
|
||||
|
||||
def original(mirror):
|
||||
return auto.find_element("mirror/road_in_mir/acquire_ego_gift_card.png",
|
||||
find_type='image_with_multiple_targets')
|
||||
|
||||
self.mirror_cls.acquire_ego_gift = original
|
||||
self.install()
|
||||
mirror = self.mirror_cls()
|
||||
mirror.system = 'bleed'
|
||||
with mock.patch.object(ap, '_ocr_lines', side_effect=RuntimeError('ocr down')):
|
||||
self.assertEqual(mirror.acquire_ego_gift(), cards)
|
||||
self.assertIn('关键词排序出错(RuntimeError: ocr down)', '\n'.join(self.lines))
|
||||
|
||||
def test_upstream_without_the_card_lookup_is_an_error(self):
|
||||
auto = self.auto
|
||||
|
||||
def original(mirror):
|
||||
return auto.find_element("mirror/road_in_mir/some_other_card.png")
|
||||
|
||||
self.mirror_cls.acquire_ego_gift = original
|
||||
self.install()
|
||||
self.assertIs(self.mirror_cls.acquire_ego_gift, original)
|
||||
self.assertIn('[ERROR] [lc_mcp] 饰品体系优先补丁跳过: 上游 Mirror.acquire_ego_gift 不再调用 find_element',
|
||||
'\n'.join(self.lines))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@@ -0,0 +1,82 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""截图连续识别失败熔断。
|
||||
|
||||
2026-11-16 实测: 游戏窗口被最小化/关掉后, AALC 每帧在 cv2.matchTemplate 上抛
|
||||
「corr.rows <= img.rows + templ.rows - 1」断言, 只记 ERROR 继续跑, 第 2 局空转 4.5 小时。
|
||||
"""
|
||||
import sys
|
||||
import types
|
||||
import unittest
|
||||
from pathlib import Path
|
||||
from unittest import mock
|
||||
|
||||
REPO = Path(__file__).resolve().parents[1]
|
||||
sys.path.insert(0, str(REPO))
|
||||
from lc_mcp import aalc_patches as ap # noqa: E402
|
||||
|
||||
|
||||
class FakeImageUtils:
|
||||
"""按顺序返回给定结果; None = 上游的识别失败分支。"""
|
||||
|
||||
def __init__(self, results):
|
||||
self.results = list(results)
|
||||
self.calls = 0
|
||||
|
||||
def match_template(self, screenshot, template, threshold, *args, **kwargs):
|
||||
self.calls += 1
|
||||
if self.results:
|
||||
return self.results.pop(0)
|
||||
return (1, 1), 0.9
|
||||
|
||||
|
||||
class ImageErrorGuardTest(unittest.TestCase):
|
||||
|
||||
def install(self, fake, clock=None, window=120, limit=3):
|
||||
self.lines = []
|
||||
module = types.ModuleType('utils.image_utils')
|
||||
module.ImageUtils = fake
|
||||
with mock.patch.dict(sys.modules, {'utils': types.ModuleType('utils'),
|
||||
'utils.image_utils': module}):
|
||||
self.assertIsNotNone(ap.install_image_error_guard(
|
||||
log=self.lines.append, clock=clock or (lambda: self.now[0]),
|
||||
window=window, limit=limit))
|
||||
return fake
|
||||
|
||||
def setUp(self):
|
||||
self.now = [0.0]
|
||||
|
||||
def test_ok_results_never_abort(self):
|
||||
fake = self.install(FakeImageUtils([((5, 5), 0.9)] * 10))
|
||||
for _ in range(10):
|
||||
self.now[0] += 0.1
|
||||
self.assertEqual(fake.match_template(None, None, 0.8), ((5, 5), 0.9))
|
||||
|
||||
def test_sparse_failures_do_not_abort(self):
|
||||
fake = self.install(FakeImageUtils([None, None] + [((1, 1), 0.9)] * 5))
|
||||
self.lines.clear() # 安装时那行 "patch: 截图连续识别失败…" 不算
|
||||
fake.match_template(None, None, 0.8)
|
||||
fake.match_template(None, None, 0.8)
|
||||
self.now[0] += 200 # 窗口滑过去
|
||||
fake.match_template(None, None, 0.8)
|
||||
self.assertEqual(len(self.lines), 0)
|
||||
|
||||
def test_storm_aborts_with_clear_message(self):
|
||||
fake = self.install(FakeImageUtils([None] * 10), limit=3)
|
||||
with mock.patch.object(ap.decisions, 'record') as record:
|
||||
with self.assertRaises(ap.TaskAbort):
|
||||
for _ in range(3):
|
||||
self.now[0] += 0.05
|
||||
fake.match_template(None, None, 0.8)
|
||||
self.assertIn('截图连续识别失败', '\n'.join(self.lines))
|
||||
record.assert_called_once()
|
||||
|
||||
def test_abort_is_not_a_normal_exception(self):
|
||||
# AALC 的 onetime_mir_process 会吞 Exception 再开一局, 熔断必须穿透
|
||||
self.assertFalse(issubclass(ap.TaskAbort, Exception))
|
||||
|
||||
def test_restores_nothing_when_upstream_has_no_match_template(self):
|
||||
module = types.ModuleType('utils.image_utils')
|
||||
module.ImageUtils = object()
|
||||
with mock.patch.dict(sys.modules, {'utils': types.ModuleType('utils'),
|
||||
'utils.image_utils': module}):
|
||||
self.assertIsNone(ap.install_image_error_guard(log=lambda *_: None))
|
||||
@@ -0,0 +1,211 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""按键补丁(ISSUES I-05): 前台按键带扫描码和扩展键标志, 各模式按住再松开。
|
||||
|
||||
2026-11-14 镜牢键盘寻路 24/24 没进去。AALC 前台 key_press 是 pyautogui.press: 扫描码 0、方向键没有
|
||||
扩展键标志、down/up 紧挨着; 上游后台模式的注释写明 Unity 6+ 会校验扫描码和扩展键标志。
|
||||
"""
|
||||
import ast
|
||||
import sys
|
||||
import types
|
||||
import unittest
|
||||
from pathlib import Path
|
||||
from types import SimpleNamespace
|
||||
from unittest import mock
|
||||
|
||||
REPO = Path(__file__).resolve().parents[1]
|
||||
sys.path.insert(0, str(REPO))
|
||||
from lc_mcp import aalc_patches as ap # noqa: E402
|
||||
|
||||
INPUT = REPO / 'vendor' / 'aalc' / 'module' / 'automation' / 'input_handlers' / 'input.py'
|
||||
VK_UP, VK_P, VK_RETURN = 0x26, 0x50, 0x0D
|
||||
SCANS = {VK_UP: 0x48, VK_P: 0x19, VK_RETURN: 0x1C}
|
||||
|
||||
pyautogui = SimpleNamespace(press=mock.Mock()) # 假 Input.key_press 的源码里要有 pyautogui.press
|
||||
|
||||
|
||||
class User32:
|
||||
|
||||
def __init__(self, events):
|
||||
self.events = events
|
||||
|
||||
def MapVirtualKeyW(self, vk, kind):
|
||||
assert kind == 0
|
||||
return SCANS.get(vk, 0)
|
||||
|
||||
def keybd_event(self, vk, scan, flags, extra):
|
||||
self.events.append(('keybd', vk, scan, flags))
|
||||
|
||||
|
||||
class Handle:
|
||||
|
||||
def __init__(self, active=True, activates=True):
|
||||
self.active = active
|
||||
self.activates = activates
|
||||
self.foreground_calls = 0
|
||||
|
||||
@property
|
||||
def isActive(self):
|
||||
return self.active
|
||||
|
||||
def setForeground(self):
|
||||
self.foreground_calls += 1
|
||||
self.active = self.activates
|
||||
|
||||
|
||||
def fake_input_module(events):
|
||||
class Input:
|
||||
def key_press(self, key):
|
||||
return pyautogui.press(key)
|
||||
|
||||
class BackgroundInput:
|
||||
def set_active(self):
|
||||
events.append(('active',))
|
||||
|
||||
def key_down(self, key):
|
||||
events.append(('down', key))
|
||||
|
||||
def key_up(self, key):
|
||||
events.append(('up', key))
|
||||
|
||||
def key_press(self, key):
|
||||
self.set_active()
|
||||
self.key_down(key)
|
||||
self.key_up(key)
|
||||
|
||||
class WindowMoveInput(BackgroundInput):
|
||||
def key_press(self, key):
|
||||
self.set_active()
|
||||
self.key_down(key)
|
||||
self.key_up(key)
|
||||
|
||||
module = types.ModuleType('module.automation.input_handlers.input')
|
||||
module.key_list = {'up': VK_UP, 'p': VK_P, 'enter': VK_RETURN}
|
||||
module.EXTENDED_KEY_VKS = frozenset({VK_UP})
|
||||
module.Input, module.BackgroundInput, module.WindowMoveInput = Input, BackgroundInput, WindowMoveInput
|
||||
return module
|
||||
|
||||
|
||||
class KeyHoldTest(unittest.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
self.events = []
|
||||
self.lines = []
|
||||
self.input_mod = fake_input_module(self.events)
|
||||
self.handle = Handle()
|
||||
pyautogui.press.reset_mock()
|
||||
sleep = mock.patch.object(ap.time, 'sleep', side_effect=lambda s: self.events.append(('sleep', s)))
|
||||
sleep.start()
|
||||
self.addCleanup(sleep.stop)
|
||||
|
||||
def install(self, env=None):
|
||||
handlers = types.ModuleType('module.automation.input_handlers')
|
||||
handlers.input = self.input_mod
|
||||
modules = {'module': types.ModuleType('module'),
|
||||
'module.automation': types.ModuleType('module.automation'),
|
||||
'module.automation.input_handlers': handlers,
|
||||
'module.automation.input_handlers.input': self.input_mod,
|
||||
'module.game_and_screen': SimpleNamespace(screen=SimpleNamespace(handle=self.handle))}
|
||||
with mock.patch.dict(sys.modules, modules):
|
||||
return ap.install_key_hold(log=self.lines.append, env=env or {}, user32=User32(self.events))
|
||||
|
||||
def test_arrow_key_has_scan_code_extended_flag_and_is_held(self):
|
||||
self.assertEqual(sorted(self.install()), ['BackgroundInput', 'Input', 'WindowMoveInput'])
|
||||
self.input_mod.Input().key_press('UP')
|
||||
self.assertEqual(self.events, [('keybd', VK_UP, 0x48, 0x1), ('sleep', ap.KEY_HOLD),
|
||||
('keybd', VK_UP, 0x48, 0x3)])
|
||||
pyautogui.press.assert_not_called()
|
||||
|
||||
def test_letter_key_has_scan_code_without_extended_flag(self):
|
||||
self.install()
|
||||
self.input_mod.Input().key_press('p')
|
||||
self.assertEqual(self.events, [('keybd', VK_P, 0x19, 0x0), ('sleep', ap.KEY_HOLD),
|
||||
('keybd', VK_P, 0x19, 0x2)])
|
||||
|
||||
def test_inactive_game_window_is_activated_first(self):
|
||||
self.handle.active = False
|
||||
self.install()
|
||||
self.input_mod.Input().key_press('enter')
|
||||
self.assertEqual(self.handle.foreground_calls, 1)
|
||||
self.assertEqual([e for e in self.events if e[0] == 'keybd'],
|
||||
[('keybd', VK_RETURN, 0x1C, 0x0), ('keybd', VK_RETURN, 0x1C, 0x2)])
|
||||
|
||||
def test_key_is_not_sent_to_another_window(self):
|
||||
self.handle = Handle(active=False, activates=False)
|
||||
self.install()
|
||||
self.input_mod.Input().key_press('enter')
|
||||
self.assertEqual([e for e in self.events if e[0] == 'keybd'], [])
|
||||
pyautogui.press.assert_not_called()
|
||||
self.assertIn('按键 enter 没发: 游戏窗口不在前台', '\n'.join(self.lines))
|
||||
|
||||
def test_unknown_key_goes_to_upstream(self):
|
||||
self.install()
|
||||
self.input_mod.Input().key_press('f13')
|
||||
pyautogui.press.assert_called_once_with('f13')
|
||||
self.assertEqual(self.events, [])
|
||||
|
||||
def test_background_modes_hold_between_down_and_up(self):
|
||||
self.install()
|
||||
for cls in (self.input_mod.BackgroundInput, self.input_mod.WindowMoveInput):
|
||||
self.events.clear()
|
||||
cls().key_press('up')
|
||||
self.assertEqual(self.events, [('active',), ('down', 'up'), ('sleep', ap.KEY_HOLD), ('up', 'up')])
|
||||
|
||||
def test_background_key_is_released_even_if_interrupted(self):
|
||||
self.install()
|
||||
with mock.patch.object(ap.time, 'sleep', side_effect=InterruptedError):
|
||||
with self.assertRaises(InterruptedError):
|
||||
self.input_mod.BackgroundInput().key_press('p')
|
||||
self.assertEqual(self.events[-1], ('up', 'p'))
|
||||
|
||||
def test_foreground_key_is_released_even_if_interrupted(self):
|
||||
self.install()
|
||||
with mock.patch.object(ap.time, 'sleep', side_effect=InterruptedError):
|
||||
with self.assertRaises(InterruptedError):
|
||||
self.input_mod.Input().key_press('up')
|
||||
self.assertEqual(self.events[-1], ('keybd', VK_UP, 0x48, 0x3))
|
||||
|
||||
def test_env_zero_keeps_upstream(self):
|
||||
original = self.input_mod.Input.key_press
|
||||
self.assertIsNone(self.install(env={ap.KEY_HOLD_ENV: '0'}))
|
||||
self.assertIs(self.input_mod.Input.key_press, original)
|
||||
|
||||
def test_changed_upstream_foreground_is_reported_not_patched(self):
|
||||
def key_press(self, key):
|
||||
return None
|
||||
|
||||
self.input_mod.Input.key_press = key_press
|
||||
self.assertEqual(sorted(self.install()), ['BackgroundInput', 'WindowMoveInput'])
|
||||
self.assertIs(self.input_mod.Input.key_press, key_press)
|
||||
self.assertIn('[ERROR] [lc_mcp] 按键补丁: 上游前台 Input.key_press 不再用 pyautogui.press', '\n'.join(self.lines))
|
||||
|
||||
|
||||
@unittest.skipUnless(INPUT.is_file(), 'vendor/aalc 子模块未检出')
|
||||
class UpstreamInputTest(unittest.TestCase):
|
||||
"""补丁依赖的上游写法: 前台 pyautogui.press, 后台 set_active + key_down + key_up, 方向键在扩展键表里。"""
|
||||
|
||||
def setUp(self):
|
||||
self.source = INPUT.read_text(encoding='utf-8')
|
||||
self.tree = ast.parse(self.source)
|
||||
|
||||
def method_source(self, cls_name, name):
|
||||
cls = next(n for n in self.tree.body if isinstance(n, ast.ClassDef) and n.name == cls_name)
|
||||
node = next(n for n in cls.body if isinstance(n, ast.FunctionDef) and n.name == name)
|
||||
return ast.get_source_segment(self.source, node)
|
||||
|
||||
def test_foreground_uses_pyautogui_press(self):
|
||||
self.assertIn('pyautogui.press(key)', self.method_source('Input', 'key_press'))
|
||||
|
||||
def test_background_modes_send_down_up_back_to_back(self):
|
||||
for cls in ('BackgroundInput', 'WindowMoveInput'):
|
||||
body = self.method_source(cls, 'key_press')
|
||||
self.assertIn('self.set_active()', body)
|
||||
self.assertLess(body.index('self.key_down(key)'), body.index('self.key_up(key)'))
|
||||
self.assertNotIn('sleep', body)
|
||||
|
||||
def test_arrow_keys_are_extended(self):
|
||||
for vk in ('VK_UP', 'VK_DOWN', 'VK_LEFT', 'VK_RIGHT'):
|
||||
self.assertIn('win32con.%s' % vk, self.source.split('EXTENDED_KEY_VKS', 1)[1].split(')', 1)[0])
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
+163
-104
@@ -7,14 +7,14 @@
|
||||
目标点。所以任务跑起来时鼠标是"拔河"状态, 用户没法用鼠标去点停止按钮。键盘不受
|
||||
影响, 所以急停必须走键盘。
|
||||
|
||||
AALC 自带的 pause_hotkey 帮不上忙: 那个配置项只在 GUI(app/farming_interface.py)
|
||||
里注册, lc_mcp 走命令行子进程, 那条路径上没有热键监听。这是本模块存在的原因。
|
||||
实现上踩过一个坑: 先用了 pynput 的 GlobalHotKeys, 静态注册成功、线程也活着, 但
|
||||
keybd_event 和 SendInput 两种注入都触发不了它 —— 钩子在当前会话下收不到键。
|
||||
改成 GetAsyncKeyState 轮询后实测可用。这里的测试守住轮询方案的几个关键性质,
|
||||
以及急停时"先放开鼠标、卡住也按时退出"的保证。
|
||||
"""
|
||||
import os
|
||||
import sys
|
||||
import threading
|
||||
import tempfile
|
||||
import time
|
||||
import threading
|
||||
import unittest
|
||||
from pathlib import Path
|
||||
from unittest import mock
|
||||
@@ -22,134 +22,183 @@ 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 的"当前按下"位
|
||||
|
||||
class KeySpecTest(unittest.TestCase):
|
||||
|
||||
def test_wraps_plain_name(self):
|
||||
self.assertEqual(killswitch._key_spec('f12'), '<f12>')
|
||||
def key_state(value):
|
||||
return mock.patch.object(killswitch, '_key_state_api', return_value=lambda vk: value)
|
||||
|
||||
def test_keeps_already_wrapped(self):
|
||||
self.assertEqual(killswitch._key_spec('<f11>'), '<f11>')
|
||||
|
||||
def test_lowercases_and_trims(self):
|
||||
self.assertEqual(killswitch._key_spec(' F12 '), '<f12>')
|
||||
class ResolveVkTest(unittest.TestCase):
|
||||
"""键名解析必须严格: 认不出来要返回 None, 不能悄悄用默认值 ——
|
||||
否则用户以为设成了 F11, 实际还在监听别的键。"""
|
||||
|
||||
def test_empty_falls_back_to_default(self):
|
||||
self.assertEqual(killswitch._key_spec(''), '<f12>')
|
||||
self.assertEqual(killswitch._key_spec(None), '<f12>')
|
||||
self.assertEqual(killswitch._key_spec(' '), '<f12>')
|
||||
def test_common_keys(self):
|
||||
self.assertEqual(killswitch.resolve_vk('f12'), 0x7B)
|
||||
self.assertEqual(killswitch.resolve_vk('F11'), 0x7A)
|
||||
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)
|
||||
|
||||
def test_trims_whitespace(self):
|
||||
self.assertEqual(killswitch.resolve_vk(' F12 '), 0x7B)
|
||||
|
||||
def test_empty_uses_default(self):
|
||||
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_when_pynput_is_missing(self):
|
||||
def test_reports_unknown_key_and_suggests_fallback(self):
|
||||
lines = []
|
||||
with mock.patch.dict(sys.modules, {'pynput': None}):
|
||||
got = killswitch.install(log=lines.append, key='f12')
|
||||
got = killswitch.install(log=lines.append, key='nosuchkey')
|
||||
self.assertIsNone(got)
|
||||
joined = '\n'.join(lines)
|
||||
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, '必须给出应急手段')
|
||||
self.assertIn('Ctrl+Alt+Del', joined)
|
||||
|
||||
def test_registers_the_configured_key(self):
|
||||
listener = mock.Mock()
|
||||
listener.daemon = False
|
||||
fake_keyboard = mock.Mock()
|
||||
fake_keyboard.GlobalHotKeys.return_value = listener
|
||||
with mock.patch.dict(sys.modules, {'pynput': mock.Mock(keyboard=fake_keyboard),
|
||||
'pynput.keyboard': fake_keyboard}):
|
||||
got = killswitch.install(log=lambda m: None, key='f11')
|
||||
self.assertIs(got, listener)
|
||||
fake_keyboard.GlobalHotKeys.assert_called_once()
|
||||
self.assertIn('<f11>', fake_keyboard.GlobalHotKeys.call_args[0][0])
|
||||
listener.start.assert_called_once()
|
||||
self.assertTrue(listener.daemon)
|
||||
def test_installs_and_logs_the_key(self):
|
||||
lines = []
|
||||
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)
|
||||
joined = '\n'.join(lines)
|
||||
self.assertIn('F11', joined)
|
||||
self.assertIn('游戏窗口保留', joined)
|
||||
|
||||
def test_env_var_overrides_default_key(self):
|
||||
listener = mock.Mock()
|
||||
fake_keyboard = mock.Mock()
|
||||
fake_keyboard.GlobalHotKeys.return_value = listener
|
||||
with mock.patch.dict(os.environ, {'LCP_KILL_KEY': 'pause'}), \
|
||||
mock.patch.dict(sys.modules, {'pynput': mock.Mock(keyboard=fake_keyboard),
|
||||
'pynput.keyboard': fake_keyboard}):
|
||||
killswitch.install(log=lambda m: None)
|
||||
self.assertIn('<pause>', fake_keyboard.GlobalHotKeys.call_args[0][0])
|
||||
def test_env_var_overrides_default(self):
|
||||
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 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))
|
||||
|
||||
|
||||
class ActivateTest(unittest.TestCase):
|
||||
def _grab_handler(self, log=lambda _: None, on_stop=None):
|
||||
listener = mock.Mock()
|
||||
keyboard = mock.Mock()
|
||||
keyboard.GlobalHotKeys.return_value = listener
|
||||
with mock.patch.dict(sys.modules, {'pynput': mock.Mock(keyboard=keyboard)}):
|
||||
killswitch.install(log=log, on_stop=on_stop)
|
||||
return next(iter(keyboard.GlobalHotKeys.call_args.args[0].values())), listener
|
||||
class PollingTest(unittest.TestCase):
|
||||
"""轮询判断的核心:0x8000 位。测错位会导致"一直触发"或"永不触发"。"""
|
||||
|
||||
def fire(self, handler, listener):
|
||||
handler()
|
||||
listener._lc_state['worker'].join(2)
|
||||
self.assertFalse(listener._lc_state['worker'].is_alive())
|
||||
def test_high_bit_means_pressed(self):
|
||||
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 key_state(0x0001):
|
||||
self.assertFalse(killswitch._pressed(0x7B))
|
||||
|
||||
def test_zero_is_not_pressed(self):
|
||||
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, 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_and_only_fires_once(self):
|
||||
handler, listener = self._grab_handler()
|
||||
sw = self._switch()
|
||||
with mock.patch.object(killswitch.os, '_exit') as fake_exit:
|
||||
self.fire(handler, listener)
|
||||
handler()
|
||||
sw._fire()
|
||||
sw._fire()
|
||||
sw._fire()
|
||||
fake_exit.assert_called_once_with(killswitch.EXIT_CODE)
|
||||
|
||||
def test_broken_log_cannot_disable_the_hotkey(self):
|
||||
log = mock.Mock()
|
||||
handler, listener = self._grab_handler(log=log)
|
||||
log.reset_mock()
|
||||
log.side_effect = OSError('closed log')
|
||||
with mock.patch.object(killswitch.os, '_exit') as fake_exit:
|
||||
self.fire(handler, listener)
|
||||
fake_exit.assert_called_once_with(130)
|
||||
log.assert_not_called()
|
||||
def test_logs_that_game_is_kept(self):
|
||||
lines = []
|
||||
with mock.patch.object(killswitch.os, '_exit'):
|
||||
self._switch(log=lines.append)._fire()
|
||||
joined = '\n'.join(lines)
|
||||
self.assertIn('END', joined)
|
||||
self.assertIn('重新开始', joined)
|
||||
|
||||
def test_releases_input_before_exiting_even_when_cleanup_raises(self):
|
||||
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():
|
||||
calls.append('release')
|
||||
raise OSError('driver disconnected')
|
||||
handler, listener = self._grab_handler(on_stop=cleanup)
|
||||
# 不让测试线程输出预期的异常 traceback。
|
||||
with mock.patch.object(killswitch.os, '_exit', side_effect=lambda code: calls.append(code)), \
|
||||
mock.patch.object(threading, 'excepthook'):
|
||||
self.fire(handler, listener)
|
||||
self.assertEqual(calls, ['release', 130])
|
||||
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()
|
||||
handler, listener = self._grab_handler(on_stop=release.wait)
|
||||
sw = self._switch(on_stop=release.wait)
|
||||
with mock.patch.object(killswitch.os, '_exit', side_effect=lambda code: exited.set()):
|
||||
handler()
|
||||
worker = threading.Thread(target=sw._fire, daemon=True)
|
||||
worker.start()
|
||||
try:
|
||||
self.assertTrue(exited.wait(2), '清理卡住也必须触发强退')
|
||||
finally:
|
||||
release.set()
|
||||
listener._lc_state['worker'].join(2)
|
||||
|
||||
def test_startup_message_explains_game_is_kept(self):
|
||||
lines = []
|
||||
self._grab_handler(log=lines.append)
|
||||
self.assertIn('游戏窗口保留', '\n'.join(lines))
|
||||
worker.join(2)
|
||||
|
||||
def test_real_emergency_exit_is_reported_as_stopped(self):
|
||||
from lc_mcp.tasks import TaskRunner
|
||||
child = """
|
||||
import json, os, sys, time
|
||||
from types import SimpleNamespace
|
||||
import json, os, time
|
||||
from lc_mcp import killswitch
|
||||
from lc_mcp.aalc_task import RESTORE_ENV
|
||||
class Listener:
|
||||
def __init__(self, bindings): self.activate = next(iter(bindings.values()))
|
||||
def start(self): pass
|
||||
sys.modules['pynput'] = SimpleNamespace(keyboard=SimpleNamespace(GlobalHotKeys=Listener))
|
||||
listener = killswitch.install(log=lambda msg: None)
|
||||
with open(os.environ[RESTORE_ENV], 'w') as f: json.dump({'set_mirror_count': 1}, f)
|
||||
listener.activate()
|
||||
killswitch._key_state_api = lambda: (lambda vk: -32768)
|
||||
killswitch.install(log=lambda msg: None)
|
||||
time.sleep(10)
|
||||
"""
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
@@ -167,28 +216,38 @@ class StopTest(unittest.TestCase):
|
||||
def test_stop_is_safe_on_none(self):
|
||||
killswitch.stop(None) # 不该抛
|
||||
|
||||
def test_stop_calls_listener(self):
|
||||
listener = mock.Mock()
|
||||
killswitch.stop(listener)
|
||||
listener.stop.assert_called_once()
|
||||
def test_stop_calls_switch(self):
|
||||
sw = mock.Mock()
|
||||
killswitch.stop(sw)
|
||||
sw.stop.assert_called_once()
|
||||
|
||||
def test_listening_stops_on_return_and_exception(self):
|
||||
def test_stop_swallows_errors(self):
|
||||
sw = mock.Mock()
|
||||
sw.stop.side_effect = RuntimeError('boom')
|
||||
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):
|
||||
listener = mock.Mock()
|
||||
switch = mock.Mock()
|
||||
with self.subTest(failure=failure), \
|
||||
mock.patch.object(killswitch, 'install', return_value=listener):
|
||||
mock.patch.object(killswitch, 'install', return_value=switch) as install:
|
||||
try:
|
||||
with killswitch.listening():
|
||||
with killswitch.listening(on_stop=cleanup):
|
||||
if failure:
|
||||
raise RuntimeError('task failed')
|
||||
except RuntimeError:
|
||||
pass
|
||||
listener.stop.assert_called_once()
|
||||
|
||||
def test_stop_swallows_listener_errors(self):
|
||||
listener = mock.Mock()
|
||||
listener.stop.side_effect = RuntimeError('boom')
|
||||
killswitch.stop(listener) # 不该抛
|
||||
self.assertIs(install.call_args.kwargs['on_stop'], cleanup)
|
||||
switch.stop.assert_called_once()
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
||||
+44
-10
@@ -9,7 +9,9 @@ import sys
|
||||
import tempfile
|
||||
import threading
|
||||
import time
|
||||
import types
|
||||
import unittest
|
||||
from types import SimpleNamespace
|
||||
from unittest import mock
|
||||
|
||||
REPO = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
||||
@@ -18,7 +20,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 +69,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'}))
|
||||
@@ -188,6 +191,17 @@ class ProtocolTest(unittest.TestCase):
|
||||
self.assertTrue(call(self.s, 'click', x=1, y=1)['ok'])
|
||||
self.assertFalse(call(self.s, 'run_task', task='bogus')['ok'])
|
||||
|
||||
def test_run_task_strategy_option(self):
|
||||
self.assertIn('rabbit_hole', next(t for t in TOOLS if t['name'] == 'run_task')
|
||||
['inputSchema']['properties']['strategy']['enum'])
|
||||
self.assertIn('不支持 strategy', call(self.s, 'run_task', task='mirror', strategy='fast')['error'])
|
||||
self.assertIn('不支持 strategy', call(self.s, 'run_task', task='daily', strategy='rabbit_hole')['error'])
|
||||
self.assertEqual(call(self.s, 'task_status')['state'], 'idle')
|
||||
r = call(self.s, 'run_task', task='mirror', count=1, strategy='rabbit_hole')
|
||||
self.assertTrue(r['ok'], r)
|
||||
self.assertEqual(call(self.s, 'task_status')['params'], {'count': 1, 'strategy': 'rabbit_hole'})
|
||||
self.assertEqual(call(self.s, 'stop_task')['state'], 'stopped')
|
||||
|
||||
def test_task_exit_codes(self):
|
||||
self.tasks.argv_factory = lambda t, p: [sys.executable, '-c', 'import sys; sys.exit(3)']
|
||||
call(self.s, 'run_task', task='reward')
|
||||
@@ -213,7 +227,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 +242,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; 强杀后必须写回原值。"""
|
||||
@@ -373,12 +400,19 @@ class RuntimeTest(unittest.TestCase):
|
||||
mock.patch('lc_mcp.aalc_engine.time.sleep', side_effect=[None, RuntimeError('interrupted')]):
|
||||
with self.assertRaises(RuntimeError):
|
||||
engine.click(100, 200)
|
||||
with mock.patch.dict(sys.modules, pyautogui=pointer), \
|
||||
mock.patch('lc_mcp.aalc_engine.time.sleep', side_effect=RuntimeError('interrupted')):
|
||||
user32 = mock.Mock()
|
||||
user32.MapVirtualKeyW.return_value = 0x1C
|
||||
tables = types.ModuleType('module.automation.input_handlers.input')
|
||||
tables.key_list, tables.EXTENDED_KEY_VKS = {'enter': 0x0D}, frozenset({0x26})
|
||||
with mock.patch.dict(sys.modules, {'module.automation.input_handlers.input': tables}), \
|
||||
mock.patch('ctypes.windll', SimpleNamespace(user32=user32), create=True), \
|
||||
mock.patch('time.sleep', side_effect=RuntimeError('interrupted')):
|
||||
with self.assertRaises(RuntimeError):
|
||||
engine.keypress('enter')
|
||||
pointer.mouseUp.assert_called_once_with(580, 657)
|
||||
pointer.keyUp.assert_called_once_with('enter')
|
||||
# 前台按键带扫描码; 按住期间被打断也要抬起
|
||||
self.assertEqual(user32.keybd_event.call_args_list, [mock.call(0x0D, 0x1C, 0, 0), mock.call(0x0D, 0x1C, 2, 0)])
|
||||
pointer.keyDown.assert_not_called()
|
||||
|
||||
def test_foreground_move_settle_failure_sends_no_button_press(self):
|
||||
from lc_mcp.aalc_engine import AalcEngine
|
||||
|
||||
@@ -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):
|
||||
|
||||
|
||||
@@ -0,0 +1,342 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""镜牢「兔子洞」速刷: 黑兽 - 卯 魁首 浮士德每回合放 E.G.O「空洞」。
|
||||
|
||||
AALC 战斗只会 P+Enter; 补丁接管一回合: P → 长按浮士德打开 E.G.O 列表 → OCR 找「空洞」→ Enter。
|
||||
每场第一回合长按卡片(超频, 直接打人), 之后单击(弹孔不低于 1 发时游戏改用「填补空洞」)。
|
||||
长按点(press_at)要在实机上量, 没量时不点任何东西, 照 AALC 原来的 P+Enter 打。
|
||||
"""
|
||||
import ast
|
||||
import json
|
||||
import os
|
||||
import sys
|
||||
import tempfile
|
||||
import types
|
||||
import unittest
|
||||
from pathlib import Path
|
||||
from types import SimpleNamespace
|
||||
from unittest import mock
|
||||
|
||||
REPO = Path(__file__).resolve().parents[1]
|
||||
sys.path.insert(0, str(REPO))
|
||||
from lc_mcp import aalc_patches as ap # noqa: E402
|
||||
from lc_mcp import aalc_task # noqa: E402
|
||||
|
||||
BATTLE = REPO / 'vendor' / 'aalc' / 'tasks' / 'battle' / 'battle.py'
|
||||
CONFIG = {'team_names': ('兔子洞',), 'ego_names': ('空洞',), 'press_at': (0.25, 0.8), 'hold_seconds': 1.0}
|
||||
PRESS = (0.25 * 1280, 0.8 * 720)
|
||||
|
||||
|
||||
class BattleScreen:
|
||||
"""战斗面板: 长按到浮士德(±20 像素)才弹出 E.G.O 列表; 点到或长按可用的「空洞」列表就关。"""
|
||||
|
||||
def __init__(self, usable=True, popup_text='空洞', press=PRESS):
|
||||
self.usable = usable
|
||||
self.popup_text = popup_text
|
||||
self.press = press
|
||||
self.popup = False
|
||||
self.selected = False
|
||||
self.overclocked = False
|
||||
self.calls = []
|
||||
|
||||
@property
|
||||
def screenshot(self):
|
||||
return self
|
||||
|
||||
def take_screenshot(self):
|
||||
return self
|
||||
|
||||
def read(self):
|
||||
lines = [('回合 1', 640, 30), ('胜率', 1100, 600)]
|
||||
if self.popup:
|
||||
lines += [(self.popup_text, self.press[0] + 40, self.press[1] - 160), ('表象放射体', self.press[0] + 40, self.press[1] - 220)]
|
||||
return SimpleNamespace(txts=tuple(t for t, _, _ in lines),
|
||||
boxes=[[[x - 10, y - 5], [x + 10, y - 5], [x + 10, y + 5], [x - 10, y + 5]]
|
||||
for _, x, y in lines])
|
||||
|
||||
def key_press(self, key):
|
||||
self.calls.append(('key', key))
|
||||
|
||||
def on_card(self, x, y):
|
||||
return abs(x - (self.press[0] + 40)) <= 10 and abs(y - (self.press[1] - 160)) <= 10
|
||||
|
||||
def mouse_drag(self, x, y, drag_time=0.1, dx=0, dy=0):
|
||||
self.calls.append(('hold', round(x), round(y), drag_time, dx, dy))
|
||||
if self.popup and self.on_card(x, y):
|
||||
if self.usable:
|
||||
self.popup, self.selected, self.overclocked = False, True, True
|
||||
elif abs(x - self.press[0]) <= 20 and abs(y - self.press[1]) <= 20:
|
||||
self.popup = True
|
||||
|
||||
def mouse_click(self, x, y, *args, **kwargs):
|
||||
self.calls.append(('click', round(x), round(y)))
|
||||
if self.popup and self.usable and self.on_card(x, y):
|
||||
self.popup, self.selected = False, True
|
||||
|
||||
def mouse_click_blank(self, *args, **kwargs):
|
||||
self.calls.append(('blank',))
|
||||
self.popup = False
|
||||
|
||||
|
||||
class RabbitHoleTurnTest(unittest.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
self.lines = []
|
||||
engine = SimpleNamespace(ocr=SimpleNamespace(run=lambda screen: screen.read()))
|
||||
for patcher in (mock.patch.dict(sys.modules, {'module': types.ModuleType('module'), 'module.ocr': engine}),
|
||||
mock.patch.object(ap.time, 'sleep')):
|
||||
patcher.start()
|
||||
self.addCleanup(patcher.stop)
|
||||
record = mock.patch.object(ap.decisions, 'record')
|
||||
self.record = record.start()
|
||||
self.addCleanup(record.stop)
|
||||
self.cfg = SimpleNamespace(set_win_size=720)
|
||||
|
||||
def turn(self, screen, config=CONFIG, overclock=False):
|
||||
return ap.rabbit_hole_turn(screen, self.cfg, config, log=self.lines.append, overclock=overclock)
|
||||
|
||||
def test_selects_hollow_between_p_and_enter(self):
|
||||
screen = BattleScreen()
|
||||
self.assertEqual(self.turn(screen), 'ego')
|
||||
self.assertTrue(screen.selected)
|
||||
self.assertEqual(screen.calls, [('key', 'p'), ('hold', 320, 576, 1.0, 0, 0), ('click', 360, 416), ('key', 'enter')])
|
||||
self.record.assert_called_once_with('battle', 'hollow', 'ego')
|
||||
|
||||
def test_overclock_holds_the_card_instead_of_clicking(self):
|
||||
# 游戏教程: 选择 E.G.O 技能时长按 E.G.O 卡片 = 超频
|
||||
screen = BattleScreen()
|
||||
self.assertEqual(self.turn(screen, overclock=True), 'overclock')
|
||||
self.assertTrue(screen.overclocked)
|
||||
self.assertEqual(screen.calls, [('key', 'p'), ('hold', 320, 576, 1.0, 0, 0), ('hold', 360, 416, 1.0, 0, 0),
|
||||
('key', 'enter')])
|
||||
self.record.assert_called_once_with('battle', 'hollow', 'overclock')
|
||||
|
||||
def test_overclock_on_a_greyed_out_card_closes_the_list(self):
|
||||
screen = BattleScreen(usable=False)
|
||||
self.assertEqual(self.turn(screen, overclock=True), 'ego_unavailable')
|
||||
self.assertFalse(screen.overclocked)
|
||||
self.assertEqual(screen.calls[-2:], [('blank',), ('key', 'enter')])
|
||||
self.assertIn('兔子洞: 长按「空洞」后列表还在', '\n'.join(self.lines))
|
||||
|
||||
def test_fill_in_name_is_matched_after_normalising(self):
|
||||
screen = BattleScreen(popup_text='空 洞')
|
||||
self.assertEqual(self.turn(screen), 'ego')
|
||||
|
||||
def test_greyed_out_hollow_closes_the_list_and_still_fights(self):
|
||||
screen = BattleScreen(usable=False)
|
||||
self.assertEqual(self.turn(screen), 'ego_unavailable')
|
||||
self.assertEqual(screen.calls[-2:], [('blank',), ('key', 'enter')])
|
||||
self.assertIn('兔子洞: 点了「空洞」后列表还在(可能 E.G.O 资源不够)', '\n'.join(self.lines))
|
||||
|
||||
def test_wrong_press_point_reports_what_was_on_screen(self):
|
||||
screen = BattleScreen(press=(900, 500))
|
||||
self.assertEqual(self.turn(screen), 'no_option')
|
||||
self.assertEqual(screen.calls[-2:], [('blank',), ('key', 'enter')])
|
||||
self.assertIn('长按 (320,576) 后没找到 E.G.O「空洞」; 这一屏: 回合 1/胜率', '\n'.join(self.lines))
|
||||
|
||||
def test_error_after_p_still_presses_enter(self):
|
||||
# 交回 AALC 会再按一次 P, 而 P 在胜率/伤害之间切换
|
||||
screen = BattleScreen()
|
||||
screen.mouse_drag = mock.Mock(side_effect=RuntimeError('input lost'))
|
||||
with self.assertRaises(RuntimeError):
|
||||
self.turn(screen)
|
||||
self.assertEqual(screen.calls, [('key', 'p'), ('key', 'enter')])
|
||||
|
||||
|
||||
class LoadRabbitHoleTest(unittest.TestCase):
|
||||
|
||||
def test_shipped_config_is_uncalibrated(self):
|
||||
config = ap.load_rabbit_hole()
|
||||
self.assertEqual(config['team_names'], ('兔子洞',))
|
||||
self.assertEqual(config['ego_names'], ('空洞',))
|
||||
self.assertIsNone(config['press_at'])
|
||||
self.assertIs(config['overclock_first_turn'], True)
|
||||
self.assertEqual(config['theme_packs'], {'身无分文的赌徒': 10, '地狱鸡': 10, '去·海·边': 10,
|
||||
'憎恶与绝望': 12, '2号线': 10})
|
||||
|
||||
def test_shipped_route_packs_are_in_the_pack_table(self):
|
||||
_, packs = ap.load_theme_pack_systems()
|
||||
floors = {pack['zh']: pack['hard'].split(',') for pack in packs}
|
||||
route = ap.load_rabbit_hole()['theme_packs']
|
||||
# OurPlay 全程困难路线: 1~5 层各一个
|
||||
for floor, name in enumerate(route, 1):
|
||||
with self.subTest(name=name):
|
||||
self.assertIn('%dF' % floor, floors[name])
|
||||
|
||||
def test_bad_configs(self):
|
||||
base = {'team_names': ['兔子洞'], 'ego_names': ['空洞'], 'press_at': None, 'hold_seconds': 1}
|
||||
for change in ({'team_names': []}, {'ego_names': ['']}, {'press_at': [0.5]}, {'press_at': [1.2, 0.5]},
|
||||
{'press_at': [0, 0.5]}, {'hold_seconds': 9}, {'hold_seconds': True},
|
||||
{'overclock_first_turn': 'yes'}, {'theme_packs': ['地狱鸡']}, {'theme_packs': {'地狱鸡': 0}},
|
||||
{'theme_packs': {'地狱鸡': True}}, {'theme_packs': {' ': 3}}):
|
||||
with self.subTest(change=change), tempfile.TemporaryDirectory() as d:
|
||||
path = os.path.join(d, 'r.json')
|
||||
with open(path, 'w', encoding='utf-8') as fh:
|
||||
json.dump(dict(base, **change), fh)
|
||||
with self.assertRaises(ValueError):
|
||||
ap.load_rabbit_hole(path)
|
||||
|
||||
def test_calibrated_point(self):
|
||||
with tempfile.TemporaryDirectory() as d:
|
||||
path = os.path.join(d, 'r.json')
|
||||
with open(path, 'w', encoding='utf-8') as fh:
|
||||
json.dump({'team_names': ['兔子洞'], 'ego_names': ['空洞'], 'press_at': [0.3, 0.85]}, fh)
|
||||
config = ap.load_rabbit_hole(path)
|
||||
self.assertEqual(config['press_at'], (0.3, 0.85))
|
||||
self.assertEqual((config['overclock_first_turn'], config['theme_packs']), (False, {}))
|
||||
|
||||
|
||||
class FakeBattle:
|
||||
def _battle_operation(self, first_turn, defense_first_round, avoid_skill_3, **kwargs):
|
||||
if kwargs.get('never'): # 只给安装时的源码检查看, 测试里走不到
|
||||
auto.key_press("p") # noqa: F821
|
||||
auto.key_press("enter") # noqa: F821
|
||||
return 'upstream'
|
||||
|
||||
|
||||
class InstallRabbitHoleTest(unittest.TestCase):
|
||||
|
||||
def install(self, config, battle_cls=None):
|
||||
self.lines = []
|
||||
self.battle_cls = battle_cls or type('Battle', (FakeBattle,), {})
|
||||
self.original = self.battle_cls._battle_operation
|
||||
self.original_calls = []
|
||||
original = self.original
|
||||
|
||||
def counted(this, *args, **kwargs):
|
||||
self.original_calls.append(args)
|
||||
return original(this, *args, **kwargs)
|
||||
|
||||
counted.__wrapped__ = original
|
||||
self.battle_cls._battle_operation = counted
|
||||
battle_mod = types.ModuleType('tasks.battle.battle')
|
||||
battle_mod.Battle = self.battle_cls
|
||||
self.auto = SimpleNamespace()
|
||||
modules = {'tasks': types.ModuleType('tasks'), 'tasks.battle': types.ModuleType('tasks.battle'),
|
||||
'tasks.battle.battle': battle_mod, 'module': types.ModuleType('module'),
|
||||
'module.automation': SimpleNamespace(auto=self.auto),
|
||||
'module.config': SimpleNamespace(cfg=SimpleNamespace(set_win_size=720))}
|
||||
patcher = mock.patch.dict(sys.modules, modules)
|
||||
patcher.start()
|
||||
self.addCleanup(patcher.stop)
|
||||
return ap.install_rabbit_hole(log=self.lines.append, config=config)
|
||||
|
||||
def test_uncalibrated_keeps_upstream_and_says_so_once(self):
|
||||
self.assertIsNotNone(self.install(dict(CONFIG, press_at=None)))
|
||||
battle = self.battle_cls()
|
||||
with mock.patch.object(ap, 'rabbit_hole_turn') as turn:
|
||||
self.assertEqual(battle._battle_operation(True, False, False), 'upstream')
|
||||
self.assertEqual(battle._battle_operation(False, False, False), 'upstream')
|
||||
turn.assert_not_called()
|
||||
log = '\n'.join(self.lines)
|
||||
self.assertEqual(log.count('[ERROR] [lc_mcp] 兔子洞: rabbit_hole.json 的 press_at 还没在实机上量'), 1)
|
||||
self.assertIn('patch: 镜牢兔子洞: 每回合给浮士德放 E.G.O「空洞」(长按点未校准, 先按 P+Enter)', log)
|
||||
|
||||
def test_calibrated_turn_replaces_upstream(self):
|
||||
self.install(CONFIG)
|
||||
with mock.patch.object(ap, 'rabbit_hole_turn', return_value='ego') as turn:
|
||||
self.assertIs(self.battle_cls()._battle_operation(True, False, False), False)
|
||||
turn.assert_called_once()
|
||||
self.assertEqual(self.original_calls, [])
|
||||
|
||||
def test_overclock_only_on_the_first_turn(self):
|
||||
self.install(dict(CONFIG, overclock_first_turn=True))
|
||||
battle = self.battle_cls()
|
||||
with mock.patch.object(ap, 'rabbit_hole_turn', return_value='ego') as turn:
|
||||
battle._battle_operation(True, False, False) # 上游 fight 按关键字传, 位置参数也要认
|
||||
battle._battle_operation(first_turn=False, defense_first_round=False, avoid_skill_3=False)
|
||||
battle._battle_operation(first_turn=True, defense_first_round=False, avoid_skill_3=False,
|
||||
prioritize_skill_3=False)
|
||||
self.assertEqual([c.kwargs['overclock'] for c in turn.call_args_list], [True, False, True])
|
||||
self.assertIn('每回合给浮士德放 E.G.O「空洞」, 每场第一回合超频(长按 0.250,0.800)', '\n'.join(self.lines))
|
||||
|
||||
def test_overclock_off_never_holds_the_card(self):
|
||||
self.install(dict(CONFIG, overclock_first_turn=False))
|
||||
with mock.patch.object(ap, 'rabbit_hole_turn', return_value='ego') as turn:
|
||||
self.battle_cls()._battle_operation(True, False, False)
|
||||
self.assertIs(turn.call_args.kwargs['overclock'], False)
|
||||
|
||||
def test_upstream_without_first_turn_disables_overclock(self):
|
||||
class NoFirstTurn:
|
||||
def _battle_operation(self, *args, **kwargs):
|
||||
if kwargs.get('never'):
|
||||
auto.key_press("p") # noqa: F821
|
||||
auto.key_press("enter") # noqa: F821
|
||||
|
||||
self.install(dict(CONFIG, overclock_first_turn=True), battle_cls=NoFirstTurn)
|
||||
with mock.patch.object(ap, 'rabbit_hole_turn', return_value='ego') as turn:
|
||||
NoFirstTurn()._battle_operation(True, False, False)
|
||||
self.assertIs(turn.call_args.kwargs['overclock'], False)
|
||||
self.assertIn('[ERROR] [lc_mcp] 上游 Battle._battle_operation 没有 first_turn 参数', '\n'.join(self.lines))
|
||||
|
||||
def test_turn_error_is_contained(self):
|
||||
self.install(CONFIG)
|
||||
with mock.patch.object(ap, 'rabbit_hole_turn', side_effect=RuntimeError('ocr down')):
|
||||
self.assertIs(self.battle_cls()._battle_operation(True, False, False), False)
|
||||
self.assertIn('兔子洞: 这回合出错(RuntimeError: ocr down), 已按 Enter', '\n'.join(self.lines))
|
||||
|
||||
def test_interrupt_is_not_swallowed(self):
|
||||
self.install(CONFIG)
|
||||
with mock.patch.object(ap, 'rabbit_hole_turn', side_effect=InterruptedError):
|
||||
with self.assertRaises(InterruptedError):
|
||||
self.battle_cls()._battle_operation(True, False, False)
|
||||
|
||||
def test_upstream_without_p_enter_is_an_error(self):
|
||||
class Other:
|
||||
def _battle_operation(self, *args):
|
||||
return None
|
||||
|
||||
self.assertIsNone(self.install(CONFIG, battle_cls=Other))
|
||||
self.assertIn('[ERROR] [lc_mcp] 上游 Battle._battle_operation 不再是 P+Enter 出手', '\n'.join(self.lines))
|
||||
|
||||
@unittest.skipUnless(BATTLE.is_file(), 'vendor/aalc 子模块未检出')
|
||||
def test_current_upstream_turn_is_p_then_enter(self):
|
||||
source = BATTLE.read_text(encoding='utf-8')
|
||||
cls = next(n for n in ast.parse(source).body if isinstance(n, ast.ClassDef) and n.name == 'Battle')
|
||||
node = next(n for n in cls.body if isinstance(n, ast.FunctionDef) and n.name == '_battle_operation')
|
||||
body = ast.get_source_segment(source, node)
|
||||
self.assertIn('auto.key_press("p")', body)
|
||||
self.assertIn('auto.key_press("enter")', body)
|
||||
self.assertEqual(node.args.args[1].arg, 'first_turn')
|
||||
fight = next(n for n in cls.body if isinstance(n, ast.FunctionDef) and n.name == 'fight')
|
||||
self.assertIn('first_turn=first_turn', ast.get_source_segment(source, fight))
|
||||
|
||||
|
||||
class StrategyOptionTest(unittest.TestCase):
|
||||
|
||||
def test_options_are_split_from_counts(self):
|
||||
self.assertEqual(aalc_task.split_options('mirror', {'count': 2, 'strategy': 'rabbit_hole'}),
|
||||
({'count': 2}, {'strategy': 'rabbit_hole'}))
|
||||
self.assertEqual(aalc_task.split_options('daily', {'exp': 1}), ({'exp': 1}, {}))
|
||||
|
||||
def test_cli_rejects_unknown_strategy_and_strategy_on_other_tasks(self):
|
||||
for argv in (['x', 'mirror', '{"strategy": "fast"}'], ['x', 'daily', '{"strategy": "rabbit_hole"}']):
|
||||
with self.subTest(argv=argv), mock.patch.object(aalc_task, 'run') as run, \
|
||||
mock.patch('sys.stderr'):
|
||||
self.assertEqual(aalc_task.main(argv), 2)
|
||||
run.assert_not_called()
|
||||
|
||||
def test_cli_passes_the_strategy_through(self):
|
||||
with mock.patch.object(aalc_task, 'run', return_value=0) as run, mock.patch('builtins.print'):
|
||||
self.assertEqual(aalc_task.main(['x', 'mirror', '{"count": 1, "strategy": "rabbit_hole"}']), 0)
|
||||
run.assert_called_once_with('mirror', {'count': 1, 'strategy': 'rabbit_hole'})
|
||||
|
||||
def test_team_names_override_the_system(self):
|
||||
mirror_mod = types.ModuleType('tasks.mirror.mirror')
|
||||
mirror_mod.Mirror = type('Mirror', (), {'__init__': lambda self, setting, num: setattr(self, 'system', 'bleed')})
|
||||
mirror_mod.select_battle_team = lambda num: False
|
||||
package = types.ModuleType('tasks.mirror')
|
||||
package.mirror = mirror_mod
|
||||
modules = {'tasks': types.ModuleType('tasks'), 'tasks.mirror': package, 'tasks.mirror.mirror': mirror_mod,
|
||||
'module': types.ModuleType('module'), 'module.automation': SimpleNamespace(auto=mock.Mock())}
|
||||
lines = []
|
||||
with mock.patch.dict(sys.modules, modules):
|
||||
ap.install_system_team_selection(log=lines.append, names=('兔子洞',))
|
||||
mirror_mod.Mirror({}, 1)
|
||||
with mock.patch.object(ap, '_select_team_by_name', return_value=True) as select:
|
||||
mirror_mod.select_battle_team(1)
|
||||
self.assertEqual(select.call_args[0][1], ('兔子洞',))
|
||||
self.assertIn('镜牢体系 bleed -> 目标编队 兔子洞', '\n'.join(lines))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@@ -0,0 +1,313 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""镜牢商店按中文名购买(BACKLOG P2-6)。
|
||||
|
||||
上游必买只认 5 张图标模板; 汉化后商店每一格下面写着饰品中文名。补丁在上游必买循环最前面临时插占位项,
|
||||
点到占位项时按名字表 OCR, 命中就点那一格的图标, 之后的购买/确认仍是上游原来那段循环。
|
||||
端到端用例执行上游真实的 Shop.buy_gifts。
|
||||
"""
|
||||
import ast
|
||||
import json
|
||||
import os
|
||||
import sys
|
||||
import tempfile
|
||||
import types
|
||||
import unittest
|
||||
from pathlib import Path
|
||||
from types import SimpleNamespace
|
||||
from unittest import mock
|
||||
|
||||
REPO = Path(__file__).resolve().parents[1]
|
||||
sys.path.insert(0, str(REPO))
|
||||
from lc_mcp import aalc_patches as ap # noqa: E402
|
||||
|
||||
IN_SHOP = REPO / 'vendor' / 'aalc' / 'tasks' / 'mirror' / 'in_shop.py'
|
||||
MUST_PURCHASE = REPO / 'vendor' / 'aalc' / 'assets' / 'images' / 'default' / 'share' / 'mirror' / 'shop' / 'must_purchase'
|
||||
SCALE = 720 / 1440
|
||||
COINS = (551, 137) # 金币图标(1280x720)
|
||||
|
||||
|
||||
def icon_at(col, row):
|
||||
"""第 row 行第 col 列商品的图标中心; 列距 300、名字行在金币下方 +409/+716(1440 标定)。"""
|
||||
return (COINS[0] + (147 + 300 * col) * SCALE, COINS[1] + (409 + 307 * row - ap.SHOP_NAME_TO_ICON) * SCALE)
|
||||
|
||||
|
||||
class ShopNameHitsTest(unittest.TestCase):
|
||||
|
||||
def test_real_screenshot_layout(self):
|
||||
# docs/feedback/mirror_20261002_181322/special_shop_missed.png(1920x1080): 金币模板匹配在 (827, 206),
|
||||
# 名字行与图标中心是对着截图量的
|
||||
lines = [('人格技能观测', 937, 513), ('替换格里高尔的技能', 1162, 513), ('辉光变动仪', 1627, 513),
|
||||
('无头肖像', 937, 743), ('梦中的电子羊', 1162, 743), ('黏性淤浆', 1627, 743),
|
||||
('特殊商店', 383, 185), ('强化饰品', 265, 588), ('刷新', 1521, 183), ('离开', 1698, 970)]
|
||||
names = ('无头肖像', '辉光变动仪', '离开', '强化饰品')
|
||||
hits = ap.shop_name_hits(lines, names, (827, 206), 1080 / 1440)
|
||||
self.assertEqual([name for name, _ in hits], ['无头肖像', '辉光变动仪'])
|
||||
for (_, (x, y)), icon in zip(hits, [(937, 627), (1627, 397)]):
|
||||
self.assertAlmostEqual(x, icon[0], delta=3)
|
||||
self.assertAlmostEqual(y, icon[1], delta=3)
|
||||
|
||||
def test_only_whole_names_match(self):
|
||||
x, y = icon_at(0, 0)
|
||||
y += ap.SHOP_NAME_TO_ICON * SCALE
|
||||
names = ('缘分残片', '归途')
|
||||
hit = lambda text: [n for n, _ in ap.shop_name_hits([(text, x, y)], names, COINS, SCALE)]
|
||||
self.assertEqual(hit('缘分 残片'), ['缘分残片'])
|
||||
self.assertEqual(hit('缘分残片+'), ['缘分残片'])
|
||||
self.assertEqual(hit('缘分残片++'), ['缘分残片'])
|
||||
self.assertEqual(hit('归途。'), ['归途'])
|
||||
self.assertEqual(hit('残片'), [])
|
||||
self.assertEqual(hit('缘分残片的回忆'), [])
|
||||
|
||||
def test_table_order_wins_over_screen_order(self):
|
||||
lines = [('归途', *icon_at(0, 0)), ('缘分残片', *icon_at(3, 1))]
|
||||
lines = [(t, x, y + ap.SHOP_NAME_TO_ICON * SCALE) for t, x, y in lines]
|
||||
hits = ap.shop_name_hits(lines, ('缘分残片', '归途'), COINS, SCALE)
|
||||
self.assertEqual(hits, [('缘分残片', icon_at(3, 1)), ('归途', icon_at(0, 0))])
|
||||
|
||||
|
||||
class ShopGiftsTableTest(unittest.TestCase):
|
||||
|
||||
def test_shipped_table(self):
|
||||
names = ap.load_shop_gifts()
|
||||
self.assertEqual(names, ('缘分残片', '卡蜜拉', '采血包', '归途', '石版字符'))
|
||||
|
||||
@unittest.skipUnless(MUST_PURCHASE.is_dir(), 'vendor/aalc 子模块未检出')
|
||||
def test_shipped_table_covers_every_upstream_template(self):
|
||||
with open(ap.SHOP_NAMES_FILE, encoding='utf-8') as f:
|
||||
templates = {item['template'] for item in json.load(f)['gifts']}
|
||||
self.assertEqual(templates, set(os.listdir(MUST_PURCHASE)))
|
||||
|
||||
def test_bad_tables_raise_value_error(self):
|
||||
bad = ['[]', '{"gifts": []}', '{"gifts": {}}', '{"gifts": ["归途"]}', '{"gifts": [{"name": ""}]}',
|
||||
'{"gifts": [{"name": "。"}]}', '{"gifts": [{"name": "归途"}, {"name": "归 途"}]}']
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
path = os.path.join(tmp, 's.json')
|
||||
for content in bad:
|
||||
with self.subTest(content=content):
|
||||
with open(path, 'w', encoding='utf-8') as f:
|
||||
f.write(content)
|
||||
with self.assertRaises(ValueError):
|
||||
ap.load_shop_gifts(path)
|
||||
|
||||
|
||||
class ShopScreen:
|
||||
"""商店界面: 一格格商品(图标 + 下面的名字), 点图标弹购买框, 点购买扣钱, 再点确认。"""
|
||||
|
||||
def __init__(self, items, money=1000, price=150):
|
||||
self.items = [dict(item) for item in items]
|
||||
self.money, self.price = money, price
|
||||
self.popup, self.confirm = None, False
|
||||
self.bought, self.icon_clicks = [], []
|
||||
self.screenshot = object()
|
||||
self.model = None
|
||||
|
||||
def icon(self, item):
|
||||
return icon_at(item['col'], item['row'])
|
||||
|
||||
def take_screenshot(self, *args, **kwargs):
|
||||
self.screenshot = object()
|
||||
return self.screenshot
|
||||
|
||||
def find_element(self, target, find_type='image', **kwargs):
|
||||
if target == ap.SHOP_COINS:
|
||||
return COINS
|
||||
if target.startswith('mirror/shop/must_purchase/'):
|
||||
template = target.rsplit('/', 1)[1]
|
||||
return next((self.icon(i) for i in self.items if i.get('template') == template), False)
|
||||
return [] if find_type == 'image_with_multiple_targets' else False
|
||||
|
||||
def click_element(self, target, *args, **kwargs):
|
||||
if target == ap.SHOP_PURCHASE:
|
||||
if self.popup is None or self.money < self.price:
|
||||
return False
|
||||
self.money -= self.price
|
||||
self.bought.append(self.popup['name'])
|
||||
self.items.remove(self.popup)
|
||||
self.popup, self.confirm = None, True
|
||||
return True
|
||||
if target == ap.SHOP_CONFIRM:
|
||||
done, self.confirm = self.confirm, False
|
||||
return done
|
||||
position = self.find_element(target)
|
||||
if position:
|
||||
self.mouse_click(*position)
|
||||
return True
|
||||
return False
|
||||
|
||||
def mouse_click(self, x, y, *args, **kwargs):
|
||||
for item in self.items:
|
||||
ix, iy = self.icon(item)
|
||||
if abs(ix - x) < 30 and abs(iy - y) < 30:
|
||||
self.popup = item
|
||||
self.icon_clicks.append(item['name'])
|
||||
return True
|
||||
|
||||
def mouse_click_blank(self, *args, **kwargs):
|
||||
self.popup = None
|
||||
|
||||
def mouse_action_with_pos(self, *args, **kwargs):
|
||||
pass
|
||||
|
||||
def find_language_text(self, *args, **kwargs):
|
||||
return False
|
||||
|
||||
def run(self, image):
|
||||
lines = [('刷新', COINS[0] + 520 * SCALE, COINS[1] - 30 * SCALE),
|
||||
('强化饰品', COINS[0] - 750 * SCALE, COINS[1] + 500 * SCALE)]
|
||||
for item in self.items:
|
||||
x, y = self.icon(item)
|
||||
lines.append((item.get('label', item['name']), x, y + ap.SHOP_NAME_TO_ICON * SCALE))
|
||||
return SimpleNamespace(txts=tuple(t for t, _, _ in lines),
|
||||
boxes=[[[x - 10, y - 5], [x + 10, y - 5], [x + 10, y + 5], [x - 10, y + 5]]
|
||||
for _, x, y in lines])
|
||||
|
||||
|
||||
@unittest.skipUnless(IN_SHOP.is_file(), 'vendor/aalc 子模块未检出')
|
||||
class UpstreamBuyGiftsTest(unittest.TestCase):
|
||||
"""执行上游真实的 Shop.buy_gifts: 买完必买项, 钱读成 0 不刷新, 一轮就结束。"""
|
||||
|
||||
def setUp(self):
|
||||
self.lines = []
|
||||
tree = ast.parse(IN_SHOP.read_text(encoding='utf-8'))
|
||||
cls = next(n for n in tree.body if isinstance(n, ast.ClassDef) and n.name == 'Shop')
|
||||
self.fn_node = next(n for n in cls.body if isinstance(n, ast.FunctionDef) and n.name == 'buy_gifts')
|
||||
self.templates = ['mirror/shop/must_purchase/%s' % name for name in
|
||||
('carmilla.png', 'homeward.png', 'lithograph.png', 'phlebotomy_pack.png',
|
||||
'piece_of_relationship.png')]
|
||||
|
||||
def play(self, items, patched=True, audit=False, env=None, **screen_kwargs):
|
||||
screen = ShopScreen(items, **screen_kwargs)
|
||||
must = list(self.templates)
|
||||
ns = dict(auto=screen, must_purchase=must, sleep=lambda *a: None, retry=lambda: True, log=mock.Mock(),
|
||||
cfg=SimpleNamespace(set_win_size=720, not_skip_whitegossypium=False))
|
||||
exec(compile(ast.Module(body=[self.fn_node], type_ignores=[]), str(IN_SHOP), 'exec'), ns)
|
||||
shop_cls = type('Shop', (), {'buy_gifts': ns['buy_gifts'], 'RestartGame': RuntimeError})
|
||||
in_shop = types.ModuleType('tasks.mirror.in_shop')
|
||||
in_shop.Shop, in_shop.must_purchase = shop_cls, must
|
||||
package = types.ModuleType('tasks.mirror')
|
||||
package.in_shop = in_shop
|
||||
modules = {'tasks': types.ModuleType('tasks'), 'tasks.mirror': package, 'tasks.mirror.in_shop': in_shop,
|
||||
'module': types.ModuleType('module'),
|
||||
'module.automation': SimpleNamespace(auto=screen),
|
||||
'module.config': SimpleNamespace(cfg=ns['cfg']),
|
||||
'module.ocr': SimpleNamespace(ocr=screen)}
|
||||
with mock.patch.dict(sys.modules, modules):
|
||||
if audit:
|
||||
ap.install_shop_audit(log=self.lines.append)
|
||||
if patched:
|
||||
self.assertIsNotNone(ap.install_shop_by_name(log=self.lines.append, env=env or {}))
|
||||
shop = shop_cls()
|
||||
shop.system, shop.shopping_strategy, shop.fuse_aggressive_switch = 'bleed', False, False
|
||||
shop.second_system, shop.max_keyword_refresh, shop.max_normal_refresh = False, 0, 0
|
||||
shop._get_cost = lambda: 0
|
||||
shop.buy_gifts()
|
||||
self.assertEqual(must, self.templates, '占位项必须拿掉')
|
||||
self.assertNotIn('click_element', vars(screen), 'click_element 必须还原')
|
||||
return screen
|
||||
|
||||
@property
|
||||
def log(self):
|
||||
return '\n'.join(self.lines)
|
||||
|
||||
def test_patch_hooks_into_the_current_upstream(self):
|
||||
self.play([])
|
||||
self.assertIn('patch: 商店必买先按中文名找(shop_gifts.json, 5 个名字)', self.log)
|
||||
self.assertNotIn('[ERROR]', self.log)
|
||||
|
||||
def test_name_on_the_grid_is_bought(self):
|
||||
items = [{'name': '缘分残片', 'col': 2, 'row': 1}, {'name': '黏性淤浆', 'col': 0, 'row': 0}]
|
||||
self.assertEqual(self.play(items, patched=False).bought, []) # 图标模板没认出来
|
||||
self.assertEqual(self.play(items).bought, ['缘分残片'])
|
||||
self.assertIn('商店: 按名字找到「缘分残片」, 点它的图标', self.log)
|
||||
|
||||
def test_table_order_decides_when_money_is_short(self):
|
||||
items = [{'name': '归途', 'col': 0, 'row': 0}, {'name': '缘分残片', 'col': 3, 'row': 1}]
|
||||
self.assertEqual(self.play(items, money=150).bought, ['缘分残片'])
|
||||
self.assertEqual(self.play(items, money=1000).bought, ['缘分残片', '归途'])
|
||||
|
||||
def test_templates_still_back_up_a_misread_name(self):
|
||||
items = [{'name': '卡蜜拉', 'label': '卡密拉', 'template': 'carmilla.png', 'col': 1, 'row': 0}]
|
||||
self.assertEqual(self.play(items).bought, ['卡蜜拉'])
|
||||
|
||||
def test_unaffordable_item_is_not_clicked_forever(self):
|
||||
screen = self.play([{'name': '采血包', 'col': 1, 'row': 1}], money=0)
|
||||
self.assertEqual(screen.bought, [])
|
||||
self.assertEqual(screen.icon_clicks, ['采血包'] * ap.SHOP_NAME_CLICKS)
|
||||
|
||||
def test_audit_sees_the_name_purchase(self):
|
||||
with mock.patch.object(ap.decisions, 'record') as record:
|
||||
self.play([{'name': '缘分残片', 'col': 2, 'row': 1}], audit=True)
|
||||
self.assertEqual(record.call_args_list, [
|
||||
mock.call('shop', '缘分残片', 'name_match', on_screen=['缘分残片']),
|
||||
mock.call('shop', 'shop_by_name', 'purchase_clicked', system='bleed')])
|
||||
|
||||
def test_env_zero_keeps_upstream(self):
|
||||
self.assertIsNone(ap.install_shop_by_name(log=self.lines.append, env={ap.SHOP_NAMES_ENV: '0'}))
|
||||
|
||||
|
||||
class InstallShopByNameTest(unittest.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
self.lines = []
|
||||
self.must = ['mirror/shop/must_purchase/a.png']
|
||||
self.auto = SimpleNamespace(click_element=mock.Mock(return_value=False), find_element=mock.Mock())
|
||||
self.shop_cls = type('Shop', (), {'buy_gifts': mock.Mock(side_effect=RuntimeError('boom'))})
|
||||
in_shop = types.ModuleType('tasks.mirror.in_shop')
|
||||
in_shop.Shop, in_shop.must_purchase = self.shop_cls, self.must
|
||||
package = types.ModuleType('tasks.mirror')
|
||||
package.in_shop = in_shop
|
||||
modules = {'tasks': types.ModuleType('tasks'), 'tasks.mirror': package, 'tasks.mirror.in_shop': in_shop,
|
||||
'module': types.ModuleType('module'),
|
||||
'module.automation': SimpleNamespace(auto=self.auto),
|
||||
'module.config': SimpleNamespace(cfg=SimpleNamespace(set_win_size=720))}
|
||||
patcher = mock.patch.dict(sys.modules, modules)
|
||||
patcher.start()
|
||||
self.addCleanup(patcher.stop)
|
||||
|
||||
def test_placeholders_and_click_are_restored_after_an_exception(self):
|
||||
real = self.auto.click_element
|
||||
ap.install_shop_by_name(log=self.lines.append, env={})
|
||||
with self.assertRaises(RuntimeError):
|
||||
self.shop_cls().buy_gifts()
|
||||
self.assertEqual(self.must, ['mirror/shop/must_purchase/a.png'])
|
||||
self.assertIs(self.auto.click_element, real)
|
||||
|
||||
def test_upstream_without_the_must_purchase_loop_is_an_error(self):
|
||||
def buy_gifts(shop):
|
||||
return shop # 不再逐个点 must_purchase
|
||||
|
||||
self.shop_cls.buy_gifts = buy_gifts
|
||||
self.assertIsNone(ap.install_shop_by_name(log=self.lines.append, env={}))
|
||||
self.assertIs(self.shop_cls.buy_gifts, buy_gifts)
|
||||
self.assertIn('[ERROR] [lc_mcp] 商店按名字购买跳过: 上游 Shop.buy_gifts 不再逐个', '\n'.join(self.lines))
|
||||
|
||||
def test_unreadable_table_is_an_error(self):
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
path = os.path.join(tmp, 's.json')
|
||||
with open(path, 'w', encoding='utf-8') as f:
|
||||
f.write('{"gifts": []}')
|
||||
self.assertIsNone(ap.install_shop_by_name(log=self.lines.append, env={ap.SHOP_NAMES_ENV: path}))
|
||||
self.assertTrue(self.lines[0].startswith('[ERROR] [lc_mcp] 商店按名字购买跳过'))
|
||||
|
||||
def test_ocr_error_falls_back_to_templates(self):
|
||||
calls = []
|
||||
auto = self.auto
|
||||
|
||||
def buy_gifts(shop):
|
||||
for commodity in must_purchase():
|
||||
calls.append((commodity, auto.click_element(commodity, threshold=0.85)))
|
||||
auto.click_element('mirror/shop/purchase_assets.png')
|
||||
|
||||
must_purchase = lambda: list(self.must) # noqa: E731
|
||||
self.shop_cls.buy_gifts = buy_gifts
|
||||
self.auto.screenshot = object()
|
||||
self.auto.find_element = mock.Mock(side_effect=RuntimeError('ocr'))
|
||||
ap.install_shop_by_name(log=self.lines.append, env={})
|
||||
self.shop_cls().buy_gifts()
|
||||
self.assertEqual(calls, [(ap.SHOP_BY_NAME, False)] * ap.SHOP_BY_NAME_SLOTS
|
||||
+ [('mirror/shop/must_purchase/a.png', False)])
|
||||
self.assertIn('商店按名字购买出错(RuntimeError: ocr), 只用图标模板', '\n'.join(self.lines))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@@ -0,0 +1,62 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""镜牢商店"必买 / 必卖 / 公式合成"清单(BACKLOG P0-1)。
|
||||
|
||||
2026-11-14 实测: 上游 tasks/mirror/__init__.py 按旧路径 ./assets/images/share/... 列目录, 三个清单恒为空,
|
||||
进店 51 秒一件没买。上游 8196e72(V1.6.1) 改成按 assets/images/default/share/... 列, 本地补丁随之删掉;
|
||||
这里守着上游别再退回空清单。
|
||||
"""
|
||||
import os
|
||||
import types
|
||||
import unittest
|
||||
from contextlib import contextmanager
|
||||
from pathlib import Path
|
||||
|
||||
REPO = Path(__file__).resolve().parents[1]
|
||||
AALC = REPO / 'vendor' / 'aalc'
|
||||
INIT = AALC / 'tasks' / 'mirror' / '__init__.py'
|
||||
SHOP_LISTS = ('must_purchase', 'must_be_abandoned', 'fusion_result')
|
||||
IMAGE_ROOTS = ('dark/zh_cn', 'dark/en', 'dark/share', 'default/zh_cn', 'default/en', 'default/share')
|
||||
|
||||
|
||||
@contextmanager
|
||||
def chdir(path):
|
||||
old = os.getcwd()
|
||||
os.chdir(path)
|
||||
try:
|
||||
yield
|
||||
finally:
|
||||
os.chdir(old)
|
||||
|
||||
|
||||
def upstream_mirror_package():
|
||||
"""在 AALC 目录下执行上游 tasks/mirror/__init__.py(任务进程的工作目录也是这里)。"""
|
||||
module = types.ModuleType('tasks.mirror')
|
||||
with chdir(AALC):
|
||||
exec(compile(INIT.read_text(encoding='utf-8'), str(INIT), 'exec'), module.__dict__)
|
||||
return module
|
||||
|
||||
|
||||
@unittest.skipUnless(INIT.is_file(), 'vendor/aalc 子模块未检出')
|
||||
class UpstreamShopListTest(unittest.TestCase):
|
||||
|
||||
def test_upstream_lists_are_filled(self):
|
||||
package = upstream_mirror_package()
|
||||
self.assertEqual([len(getattr(package, k)) for k in SHOP_LISTS], [5, 19, 31])
|
||||
self.assertIn('mirror/shop/must_purchase/carmilla.png', package.must_purchase)
|
||||
|
||||
def test_every_listed_name_resolves_under_some_image_root(self):
|
||||
package = upstream_mirror_package()
|
||||
images = AALC / 'assets' / 'images'
|
||||
for kind in SHOP_LISTS:
|
||||
for name in getattr(package, kind):
|
||||
with self.subTest(name=name):
|
||||
self.assertTrue(any((images / root / name).is_file() for root in IMAGE_ROOTS))
|
||||
|
||||
def test_roots_match_aalc_path_manager(self):
|
||||
source = (AALC / 'utils' / 'path_manager.py').read_text(encoding='utf-8')
|
||||
for root in IMAGE_ROOTS:
|
||||
self.assertIn('"%s"' % root, source)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@@ -0,0 +1,664 @@
|
||||
import os
|
||||
import sys
|
||||
import types
|
||||
import unittest
|
||||
from types import SimpleNamespace
|
||||
from unittest import mock
|
||||
|
||||
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
|
||||
from lc_mcp import aalc_patches # noqa: E402
|
||||
|
||||
|
||||
class SystemTeamNamesTest(unittest.TestCase):
|
||||
|
||||
def test_all_ten_systems_are_mapped(self):
|
||||
expected = {'burn', 'bleed', 'tremor', 'rupture', 'poise',
|
||||
'sinking', 'charge', 'slash', 'pierce', 'blunt'}
|
||||
self.assertEqual(set(aalc_patches.SYSTEM_TEAM_NAMES), expected)
|
||||
|
||||
def test_names_are_non_empty_strings(self):
|
||||
for system, names in aalc_patches.SYSTEM_TEAM_NAMES.items():
|
||||
self.assertIsInstance(names, tuple, system)
|
||||
self.assertTrue(names, system)
|
||||
for name in names:
|
||||
self.assertIsInstance(name, str)
|
||||
self.assertTrue(name.strip(), system)
|
||||
|
||||
def test_poise_accepts_both_spellings(self):
|
||||
# 游戏里叫「呼吸法」, system_cn_zh 里叫「呼吸」, 两个都要能命中
|
||||
self.assertIn('呼吸法', aalc_patches.SYSTEM_TEAM_NAMES['poise'])
|
||||
self.assertIn('呼吸', aalc_patches.SYSTEM_TEAM_NAMES['poise'])
|
||||
|
||||
def test_preferences_point_at_real_systems_and_names(self):
|
||||
# 2026-11-14 用户指定: 充能优先, 没有就退到震颤
|
||||
for system, names in aalc_patches.TEAM_PREFERENCES.items():
|
||||
self.assertIn(system, aalc_patches.SYSTEM_TEAM_NAMES)
|
||||
self.assertTrue(names, system)
|
||||
for name in names:
|
||||
self.assertIsInstance(name, str)
|
||||
self.assertTrue(name.strip())
|
||||
self.assertEqual(aalc_patches.TEAM_PREFERENCES['charge'], ('震颤',))
|
||||
|
||||
|
||||
class RegionTest(unittest.TestCase):
|
||||
|
||||
def test_team_list_region(self):
|
||||
self.assertTrue(aalc_patches._in_list(130, 493)) # 实测「流血」的位置
|
||||
self.assertTrue(aalc_patches._in_list(255, 305))
|
||||
self.assertFalse(aalc_patches._in_list(130, 120)) # 顶栏不算列表
|
||||
self.assertFalse(aalc_patches._in_list(600, 493)) # 右侧面板
|
||||
self.assertFalse(aalc_patches._in_list(130, 700))
|
||||
|
||||
def test_header_region(self):
|
||||
self.assertTrue(aalc_patches._in_header(242, 125)) # 实测顶栏「流血」
|
||||
self.assertFalse(aalc_patches._in_header(130, 493))
|
||||
self.assertFalse(aalc_patches._in_header(900, 125))
|
||||
|
||||
def test_regions_do_not_overlap(self):
|
||||
for x, y in [(130, 493), (242, 125), (600, 300), (1200, 600)]:
|
||||
self.assertFalse(
|
||||
aalc_patches._in_list(x, y) and aalc_patches._in_header(x, y),
|
||||
(x, y),
|
||||
)
|
||||
|
||||
|
||||
def ocr_engine(lines):
|
||||
"""假的 module.ocr: 引擎按 [(文本, x, y)] 逐行返回, 同名文本可以出现多次(真实引擎就是这样)。"""
|
||||
result = SimpleNamespace(txts=tuple(t for t, _, _ in lines),
|
||||
boxes=[[[x - 10, y - 5], [x + 10, y - 5], [x + 10, y + 5], [x - 10, y + 5]]
|
||||
for _, x, y in lines])
|
||||
return SimpleNamespace(ocr=SimpleNamespace(run=lambda image: result))
|
||||
|
||||
|
||||
class TeamOcrTest(unittest.TestCase):
|
||||
|
||||
def test_engine_lines_keep_duplicate_names(self):
|
||||
# 选中「流血」后顶栏和列表都是「流血」; 经 {文本: 坐标} 只会剩一条
|
||||
engine = ocr_engine([('流血', 242.0, 125.0), (' 流血 ', 130.0, 493.0), ('', 1.0, 1.0)])
|
||||
auto = mock.Mock()
|
||||
with mock.patch.dict(sys.modules, {'module': types.ModuleType('module'), 'module.ocr': engine}):
|
||||
self.assertEqual(aalc_patches._team_ocr(auto), [('流血', 242.0, 125.0), ('流血', 130.0, 493.0)])
|
||||
auto._run_ocr_for_text.assert_not_called()
|
||||
|
||||
|
||||
class TeamOcrFallbackTest(unittest.TestCase):
|
||||
"""OCR 引擎导入不了时退回 AALC 的 _run_ocr_for_text。"""
|
||||
|
||||
def setUp(self):
|
||||
patcher = mock.patch.dict(sys.modules, {'module.ocr': None})
|
||||
patcher.start()
|
||||
self.addCleanup(patcher.stop)
|
||||
|
||||
def test_returns_list_and_strips_spaces(self):
|
||||
auto = mock.Mock()
|
||||
auto._run_ocr_for_text.return_value = {
|
||||
'编队#20': [132.0, 340.5],
|
||||
' 流血 ': [130.5, 493.0],
|
||||
'': [0, 0],
|
||||
}
|
||||
items = aalc_patches._team_ocr(auto)
|
||||
self.assertIn(('编队#20', 132.0, 340.5), items)
|
||||
self.assertIn(('流血', 130.5, 493.0), items)
|
||||
self.assertEqual(len(items), 2) # 空串被丢掉
|
||||
|
||||
def test_empty_ocr_gives_empty_list(self):
|
||||
auto = mock.Mock()
|
||||
auto._run_ocr_for_text.return_value = {}
|
||||
self.assertEqual(aalc_patches._team_ocr(auto), [])
|
||||
|
||||
def test_bad_position_is_skipped_not_fatal(self):
|
||||
auto = mock.Mock()
|
||||
auto._run_ocr_for_text.return_value = {'流血': [], '斩击': [1.0, 2.0]}
|
||||
self.assertEqual(aalc_patches._team_ocr(auto), [('斩击', 1.0, 2.0)])
|
||||
|
||||
|
||||
class NormalizeTeamNameTest(unittest.TestCase):
|
||||
|
||||
def test_known_ocr_misreads_are_fixed(self):
|
||||
# 2026-11-14 实测误读样本
|
||||
self.assertEqual(aalc_patches.normalize_team_name('震颐'), '震颤')
|
||||
self.assertEqual(aalc_patches.normalize_team_name('沉论'), '沉沦')
|
||||
self.assertEqual(aalc_patches.normalize_team_name('编#16'), '编队#16')
|
||||
self.assertEqual(aalc_patches.normalize_team_name('编队#16'), '编队#16')
|
||||
|
||||
def test_spaces_and_full_width_forms(self):
|
||||
self.assertEqual(aalc_patches.normalize_team_name(' 流\u3000血 '), '流血')
|
||||
self.assertEqual(aalc_patches.normalize_team_name('流血(X)'), '流血(X)')
|
||||
self.assertEqual(aalc_patches.normalize_team_name('编队#20'), '编队#20')
|
||||
|
||||
|
||||
class TeamNameMatchTest(unittest.TestCase):
|
||||
|
||||
def test_exact_prefix_and_miss(self):
|
||||
match = aalc_patches.team_name_match
|
||||
self.assertEqual(match('流血', ('流血',)), 'exact')
|
||||
self.assertEqual(match('流血队', ('流血',)), 'prefix')
|
||||
self.assertEqual(match('流血(X)', ('流血',)), 'prefix')
|
||||
self.assertIsNone(match('编队#13', ('流血',)))
|
||||
self.assertIsNone(match('出血', ('流血',)))
|
||||
self.assertIsNone(match('血', ('流血',)))
|
||||
|
||||
def test_misread_text_matches_configured_name(self):
|
||||
self.assertEqual(aalc_patches.team_name_match('震颐', aalc_patches.SYSTEM_TEAM_NAMES['tremor']), 'exact')
|
||||
self.assertEqual(aalc_patches.team_name_match('沉论队', aalc_patches.SYSTEM_TEAM_NAMES['sinking']),
|
||||
'prefix')
|
||||
|
||||
def test_single_character_names_never_prefix_match(self):
|
||||
self.assertIsNone(aalc_patches.team_name_match('流血', ('流',)))
|
||||
self.assertEqual(aalc_patches.team_name_match('流', ('流',)), 'exact')
|
||||
|
||||
|
||||
class PickTeamItemTest(unittest.TestCase):
|
||||
|
||||
def test_exact_beats_prefix(self):
|
||||
items = [('流血队', 130, 400), ('流血', 130, 450)]
|
||||
self.assertEqual(aalc_patches.pick_team_item(items, ('流血',))[0], ('流血', 130, 450))
|
||||
|
||||
def test_names_order_decides_between_exact_hits(self):
|
||||
items = [('呼吸', 130, 400), ('呼吸法', 130, 450)]
|
||||
self.assertEqual(aalc_patches.pick_team_item(items, ('呼吸法', '呼吸'))[0], ('呼吸法', 130, 450))
|
||||
|
||||
def test_unique_prefix_is_picked(self):
|
||||
hit, reason = aalc_patches.pick_team_item([('斩击', 130, 330), ('流血队', 130, 490)], ('流血',))
|
||||
self.assertEqual(hit, ('流血队', 130, 490))
|
||||
self.assertIn('前缀', reason)
|
||||
|
||||
def test_one_team_matching_two_names_is_still_unique(self):
|
||||
hit, _ = aalc_patches.pick_team_item([('呼吸法队', 130, 400)], ('呼吸法', '呼吸'))
|
||||
self.assertEqual(hit, ('呼吸法队', 130, 400))
|
||||
|
||||
def test_ambiguous_prefix_is_not_clicked(self):
|
||||
hit, reason = aalc_patches.pick_team_item([('流血队', 130, 400), ('流血2', 130, 450)], ('流血',))
|
||||
self.assertIsNone(hit)
|
||||
self.assertIn('流血2/流血队', reason)
|
||||
|
||||
def test_nothing_matches(self):
|
||||
self.assertEqual(aalc_patches.pick_team_item([('斩击', 130, 330)], ('流血',)), (None, ''))
|
||||
|
||||
|
||||
class _FakeTeamScreen:
|
||||
"""编队界面: 每下拖一次翻一屏(实测一次拖动 ≈ 5~6 行), 点哪条顶栏就变成哪条。"""
|
||||
|
||||
def __init__(self, screens, header='剧情关卡', click_changes_header=True):
|
||||
self.screens = screens
|
||||
self.header = header
|
||||
self.click_changes_header = click_changes_header
|
||||
self.swipes_down = 0
|
||||
self.clicks = []
|
||||
|
||||
@property
|
||||
def page(self):
|
||||
return min(self.swipes_down, len(self.screens) - 1)
|
||||
|
||||
def take_screenshot(self):
|
||||
return object()
|
||||
|
||||
@property
|
||||
def screenshot(self):
|
||||
return self # 交给假 OCR 引擎的"截图"就是这块界面
|
||||
|
||||
def find_element(self, *args, **kwargs):
|
||||
return True
|
||||
|
||||
def mouse_click(self, *args):
|
||||
pass
|
||||
|
||||
def mouse_swipe_for_team_scroll(self, x, y, dy, duration):
|
||||
self.swipes_down = 0 if dy > 0 else self.swipes_down + 1
|
||||
|
||||
def read(self):
|
||||
"""OCR 引擎逐行结果: 顶栏在上、列表在下; 同名条目各出现一次。"""
|
||||
lines = [(self.header, 242.0, 125.0)] if self.header else []
|
||||
lines += [(text, 130.0, 320.0 + 50 * row) for row, text in enumerate(self.screens[self.page])]
|
||||
return SimpleNamespace(txts=tuple(t for t, _, _ in lines),
|
||||
boxes=[[[x - 10, y - 5], [x + 10, y - 5], [x + 10, y + 5], [x - 10, y + 5]]
|
||||
for _, x, y in lines])
|
||||
|
||||
def mouse_action_with_pos(self, pos, offset=False):
|
||||
self.clicks.append(tuple(pos))
|
||||
if self.click_changes_header:
|
||||
row = int(round((pos[1] - 320.0) / 50))
|
||||
self.header = self.screens[self.page][row]
|
||||
|
||||
|
||||
class SelectTeamByNameTest(unittest.TestCase):
|
||||
|
||||
TOP = ['剧情关卡', '斩击', '突刺', '打击', '烧伤']
|
||||
MIDDLE = ['流血', '震颤', '破裂', '沉沦', '呼吸法']
|
||||
BOTTOM = ['充能', '编队#13', '编队#14']
|
||||
|
||||
def setUp(self):
|
||||
self.lines = []
|
||||
engine = SimpleNamespace(ocr=SimpleNamespace(run=lambda screen: screen.read()))
|
||||
modules = mock.patch.dict(sys.modules, {'module': types.ModuleType('module'), 'module.ocr': engine})
|
||||
modules.start()
|
||||
self.addCleanup(modules.stop)
|
||||
for patcher in (mock.patch.object(aalc_patches.time, 'sleep'),
|
||||
mock.patch.object(aalc_patches.decisions, 'record')):
|
||||
self.records = patcher.start()
|
||||
self.addCleanup(patcher.stop)
|
||||
|
||||
def select(self, auto, names):
|
||||
return aalc_patches._select_team_by_name(auto, names, log=self.lines.append)
|
||||
|
||||
@property
|
||||
def log(self):
|
||||
return '\n'.join(self.lines)
|
||||
|
||||
def test_renamed_team_with_suffix_is_selected(self):
|
||||
auto = _FakeTeamScreen([self.TOP, ['流血队', '震颤', '破裂'], self.BOTTOM])
|
||||
self.assertTrue(self.select(auto, ('流血',)))
|
||||
self.assertEqual(auto.header, '流血队')
|
||||
self.assertEqual(len(auto.clicks), 1)
|
||||
self.assertIn('已按体系名选中编队 流血队', self.log)
|
||||
|
||||
def test_misread_list_entry_is_selected(self):
|
||||
auto = _FakeTeamScreen([self.TOP, ['流血', '震颐', '破裂', '沉论'], self.BOTTOM])
|
||||
self.assertTrue(self.select(auto, ('沉沦',)))
|
||||
self.assertEqual(auto.header, '沉论')
|
||||
self.assertIn('选中编队 沉沦', self.log)
|
||||
|
||||
def test_current_team_needs_no_switch(self):
|
||||
auto = _FakeTeamScreen([self.TOP, self.MIDDLE], header='沉论')
|
||||
self.assertTrue(self.select(auto, ('沉沦',)))
|
||||
self.assertEqual(auto.clicks, [])
|
||||
self.assertIn('当前已经是编队 沉沦', self.log)
|
||||
|
||||
def test_current_team_that_is_also_in_the_list(self):
|
||||
# 列表这一屏里也有「流血」: 顶栏那条不能被列表那条盖掉
|
||||
auto = _FakeTeamScreen([self.MIDDLE], header='流血')
|
||||
self.assertTrue(self.select(auto, ('流血',)))
|
||||
self.assertEqual(auto.clicks, [])
|
||||
self.assertIn('当前已经是编队 流血', self.log)
|
||||
|
||||
def test_current_team_with_suffix_is_confirmed_in_the_list(self):
|
||||
# 顶栏 "流血队" 只是前缀命中, 不能直接当成目标; 列表里唯一后再点一次
|
||||
auto = _FakeTeamScreen([self.TOP, ['流血队', '震颤']], header='流血队')
|
||||
self.assertTrue(self.select(auto, ('流血',)))
|
||||
self.assertEqual(len(auto.clicks), 1)
|
||||
self.assertNotIn('无需切换', self.log)
|
||||
|
||||
def test_exact_team_wins_over_current_suffixed_team(self):
|
||||
auto = _FakeTeamScreen([self.TOP, ['流血2', '流血', '震颤']], header='流血2')
|
||||
self.assertTrue(self.select(auto, ('流血',)))
|
||||
self.assertEqual(auto.header, '流血')
|
||||
|
||||
def test_name_order_is_priority_not_screen_order(self):
|
||||
# 首选项「充能」在最后一屏, 次选「震颤」在第二屏 —— 应先翻到充能
|
||||
auto = _FakeTeamScreen([self.TOP, self.MIDDLE, self.BOTTOM])
|
||||
self.assertTrue(self.select(auto, ('充能', '震颤')))
|
||||
self.assertEqual(auto.header, '充能')
|
||||
|
||||
def test_falls_back_to_second_name(self):
|
||||
# 列表里没有「充能」, 第二顺位「震颤」应该被选中
|
||||
auto = _FakeTeamScreen([self.TOP, ['流血', '震颤', '破裂'], ['编队#13', '编队#14']])
|
||||
self.assertTrue(self.select(auto, ('充能', '震颤')))
|
||||
self.assertEqual(auto.header, '震颤')
|
||||
|
||||
def test_missing_team_logs_every_screen_and_never_clicks(self):
|
||||
auto = _FakeTeamScreen([self.TOP, self.MIDDLE, self.BOTTOM])
|
||||
self.assertFalse(self.select(auto, ('编队#999',)))
|
||||
self.assertEqual(auto.clicks, [])
|
||||
self.assertIn('第 1 屏没有 编队#999; 这一屏的名字: 剧情关卡/斩击/突刺/打击/烧伤', self.log)
|
||||
self.assertIn('第 3 屏没有 编队#999; 这一屏的名字: 充能/编队#13/编队#14', self.log)
|
||||
self.assertIn('没找到 编队#999(共 6 轮)', self.log)
|
||||
|
||||
def test_ambiguous_suffixes_are_not_clicked(self):
|
||||
auto = _FakeTeamScreen([['流血队', '流血2', '斩击']])
|
||||
self.assertFalse(self.select(auto, ('流血',)))
|
||||
self.assertEqual(auto.clicks, [])
|
||||
self.assertIn('前缀匹配到多条(流血2/流血队), 不点', self.log)
|
||||
|
||||
def test_decisions_are_recorded(self):
|
||||
self.select(_FakeTeamScreen([self.TOP, ['流血队', '震颤']]), ('流血',))
|
||||
self.records.assert_called_with('team', '流血队', 'prefix', wanted=['流血'])
|
||||
self.select(_FakeTeamScreen([self.TOP], header='流血'), ('流血',))
|
||||
self.records.assert_called_with('team', '流血', 'current', wanted=['流血'])
|
||||
self.select(_FakeTeamScreen([self.TOP, self.BOTTOM]), ('编队#999',))
|
||||
args, kwargs = self.records.call_args
|
||||
self.assertEqual(args, ('team', None, 'not_found'))
|
||||
self.assertEqual(kwargs['seen'][0], self.TOP)
|
||||
self.assertEqual(len(kwargs['seen']), 6)
|
||||
|
||||
def test_header_not_changing_is_reported(self):
|
||||
auto = _FakeTeamScreen([self.TOP, self.MIDDLE], click_changes_header=False)
|
||||
self.assertFalse(self.select(auto, ('流血',)))
|
||||
self.assertIn('点了 流血 但顶栏没变(顶栏读到: 剧情关卡)', self.log)
|
||||
|
||||
|
||||
class _FakeMirror:
|
||||
def __init__(self, team_setting, team_num):
|
||||
self.system = team_setting['system']
|
||||
self.team_number = team_num
|
||||
|
||||
|
||||
class InstallSystemTeamSelectionTest(unittest.TestCase):
|
||||
"""用假模块验证挂载点与回退行为, 不依赖 AALC / Windows。"""
|
||||
|
||||
def setUp(self):
|
||||
self.calls = []
|
||||
|
||||
def original(num):
|
||||
self.calls.append(num)
|
||||
return 'fallback'
|
||||
|
||||
self.original = original
|
||||
self.mirror_mod = types.ModuleType('tasks.mirror.mirror')
|
||||
self.mirror_mod.Mirror = _FakeMirror
|
||||
self.mirror_mod.select_battle_team = original
|
||||
|
||||
self.auto = mock.Mock()
|
||||
auto_mod = types.ModuleType('module.automation')
|
||||
auto_mod.auto = self.auto
|
||||
|
||||
tasks_pkg = types.ModuleType('tasks')
|
||||
tasks_pkg.__path__ = []
|
||||
mirror_pkg = types.ModuleType('tasks.mirror')
|
||||
mirror_pkg.__path__ = []
|
||||
mirror_pkg.mirror = self.mirror_mod
|
||||
module_pkg = types.ModuleType('module')
|
||||
module_pkg.__path__ = []
|
||||
|
||||
self._patcher = mock.patch.dict(sys.modules, {
|
||||
'tasks': tasks_pkg,
|
||||
'tasks.mirror': mirror_pkg,
|
||||
'tasks.mirror.mirror': self.mirror_mod,
|
||||
'module': module_pkg,
|
||||
'module.automation': auto_mod,
|
||||
})
|
||||
self._patcher.start()
|
||||
self.addCleanup(self._patcher.stop)
|
||||
|
||||
def install(self):
|
||||
return aalc_patches.install_system_team_selection(log=lambda *_: None)
|
||||
|
||||
def test_returns_original_and_replaces_module_global(self):
|
||||
original = self.install()
|
||||
self.assertIs(original, self.original)
|
||||
self.assertIsNot(self.mirror_mod.select_battle_team, self.original)
|
||||
# __init__ 也被包装, 但仍然正常构造
|
||||
mirror = self.mirror_mod.Mirror({'system': 'bleed'}, 1)
|
||||
self.assertEqual(mirror.system, 'bleed')
|
||||
|
||||
def test_known_system_uses_name_search(self):
|
||||
self.install()
|
||||
self.mirror_mod.Mirror({'system': 'bleed'}, 1)
|
||||
with mock.patch.object(aalc_patches, '_select_team_by_name', return_value=True) as sel:
|
||||
self.assertIs(self.mirror_mod.select_battle_team(1), True)
|
||||
self.assertEqual(sel.call_args[0][1], ('流血',))
|
||||
self.assertEqual(self.calls, []) # 成功后不再走编号回退
|
||||
|
||||
def test_charge_looks_for_charge_then_tremor(self):
|
||||
self.install()
|
||||
self.mirror_mod.Mirror({'system': 'charge'}, 1)
|
||||
with mock.patch.object(aalc_patches, '_select_team_by_name', return_value=True) as sel:
|
||||
self.mirror_mod.select_battle_team(1)
|
||||
self.assertEqual(sel.call_args[0][1], ('充能', '震颤'))
|
||||
|
||||
def test_name_search_failure_does_not_fall_back_to_number(self):
|
||||
# 这号没有 编队#1, 静默回退到编号会选中错的队, 必须显式失败
|
||||
self.install()
|
||||
self.mirror_mod.Mirror({'system': 'bleed'}, 1)
|
||||
with mock.patch.object(aalc_patches, '_select_team_by_name', return_value=False):
|
||||
self.assertIs(self.mirror_mod.select_battle_team(1), False)
|
||||
self.assertEqual(self.calls, [])
|
||||
|
||||
def test_exception_in_name_search_is_contained(self):
|
||||
self.install()
|
||||
self.mirror_mod.Mirror({'system': 'bleed'}, 1)
|
||||
boom = mock.Mock(side_effect=RuntimeError('ocr down'))
|
||||
with mock.patch.object(aalc_patches, '_select_team_by_name', boom):
|
||||
self.assertIs(self.mirror_mod.select_battle_team(1), False)
|
||||
|
||||
def test_unknown_system_falls_back_to_original(self):
|
||||
self.install()
|
||||
self.mirror_mod.Mirror({'system': 'unknown_system'}, 3)
|
||||
self.assertEqual(self.mirror_mod.select_battle_team(3), 'fallback')
|
||||
self.assertEqual(self.calls, [3])
|
||||
|
||||
def test_missing_mirror_module_is_not_fatal(self):
|
||||
with mock.patch.dict(sys.modules, {'tasks.mirror': None, 'tasks.mirror.mirror': None}):
|
||||
self.assertIsNone(self.install())
|
||||
|
||||
|
||||
class TeamScreenDetectionTest(unittest.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
engine = SimpleNamespace(ocr=SimpleNamespace(run=lambda screen: screen.read()))
|
||||
modules = mock.patch.dict(sys.modules, {'module': types.ModuleType('module'), 'module.ocr': engine})
|
||||
modules.start()
|
||||
self.addCleanup(modules.stop)
|
||||
|
||||
def test_team_screen_detected_by_names(self):
|
||||
auto = _FakeTeamScreen([['剧情关卡', '斩击', '突刺', '打击', '烧伤']])
|
||||
self.assertTrue(aalc_patches._looks_like_team_screen(auto))
|
||||
|
||||
def test_starlight_screen_is_not_team_screen(self):
|
||||
# 星之恩惠页: 满屏星星会让「选队星级」模板命中, 但左侧不是队名列表
|
||||
auto = _FakeTeamScreen([['+', '卫星商店', '可免费进行商店关键词刷新1次', '获得1件1级饰品']],
|
||||
header='西西弗的星之恩惠')
|
||||
self.assertFalse(aalc_patches._looks_like_team_screen(auto))
|
||||
|
||||
|
||||
class TeamScreenGuardTest(unittest.TestCase):
|
||||
|
||||
def install(self):
|
||||
auto = mock.Mock()
|
||||
|
||||
def fake_find(target, *args, **kwargs):
|
||||
return (640, 360) if target == aalc_patches.TEAM_SCREEN_STARS else False
|
||||
|
||||
auto.find_element = fake_find
|
||||
auto_mod = types.ModuleType('module.automation')
|
||||
auto_mod.auto = auto
|
||||
patcher = mock.patch.dict(sys.modules, {'module': types.ModuleType('module'),
|
||||
'module.automation': auto_mod})
|
||||
patcher.start()
|
||||
self.addCleanup(patcher.stop)
|
||||
aalc_patches.install_team_screen_guard(log=lambda *_: None)
|
||||
return auto
|
||||
|
||||
def test_stars_ignored_on_starlight_screen(self):
|
||||
auto = self.install()
|
||||
with mock.patch.object(aalc_patches, '_is_starlight_screen', return_value=True):
|
||||
self.assertFalse(auto.find_element(aalc_patches.TEAM_SCREEN_STARS))
|
||||
|
||||
def test_stars_kept_on_real_team_screen(self):
|
||||
auto = self.install()
|
||||
with mock.patch.object(aalc_patches, '_is_starlight_screen', return_value=False):
|
||||
self.assertEqual(auto.find_element(aalc_patches.TEAM_SCREEN_STARS), (640, 360))
|
||||
self.assertFalse(auto.find_element('mirror/other.png'))
|
||||
|
||||
|
||||
class _LoadingTeamScreen(_FakeTeamScreen):
|
||||
"""选队页刚加载: 第 loaded_at 张截图之前编队图标和列表都还没出来。"""
|
||||
|
||||
def __init__(self, screens, loaded_at=2, **kwargs):
|
||||
super().__init__(screens, **kwargs)
|
||||
self.loaded_at = loaded_at
|
||||
self.shots = 0
|
||||
|
||||
def take_screenshot(self):
|
||||
self.shots += 1
|
||||
return object()
|
||||
|
||||
@property
|
||||
def loaded(self):
|
||||
return self.shots >= self.loaded_at
|
||||
|
||||
def find_element(self, *args, **kwargs):
|
||||
return self.loaded
|
||||
|
||||
def read(self):
|
||||
if not self.loaded:
|
||||
return SimpleNamespace(txts=(), boxes=[])
|
||||
return super().read()
|
||||
|
||||
|
||||
class SelectTeamScreenWaitTest(unittest.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
self.lines = []
|
||||
engine = SimpleNamespace(ocr=SimpleNamespace(run=lambda screen: screen.read()))
|
||||
for patcher in (mock.patch.dict(sys.modules, {'module': types.ModuleType('module'), 'module.ocr': engine}),
|
||||
mock.patch.object(aalc_patches.time, 'sleep'),
|
||||
mock.patch.object(aalc_patches.decisions, 'record')):
|
||||
patcher.start()
|
||||
self.addCleanup(patcher.stop)
|
||||
|
||||
def test_waits_for_a_fresh_screenshot_of_the_team_screen(self):
|
||||
# 旧写法对着同一张截图认 3 次, 页面加载慢一点就报"不在编队界面"
|
||||
auto = _LoadingTeamScreen([['剧情关卡', '流血', '震颤']], loaded_at=3)
|
||||
self.assertTrue(aalc_patches._select_team_by_name(auto, ('流血',), log=self.lines.append))
|
||||
self.assertEqual(auto.header, '流血')
|
||||
|
||||
def test_gives_up_when_the_team_screen_never_shows(self):
|
||||
auto = _LoadingTeamScreen([['剧情关卡', '流血']], loaded_at=99)
|
||||
self.assertFalse(aalc_patches._select_team_by_name(auto, ('流血',), log=self.lines.append))
|
||||
self.assertIn('不在编队界面, 跳过按名字选队', '\n'.join(self.lines))
|
||||
self.assertEqual(auto.clicks, [])
|
||||
|
||||
|
||||
class _EnterScreen(_FakeTeamScreen):
|
||||
"""选队页右下角有「进入」; 记下点「进入」时顶栏是哪支队, 以及整屏 OCR 跑了几次。"""
|
||||
|
||||
def __init__(self, screens, enter=True, **kwargs):
|
||||
super().__init__(screens, **kwargs)
|
||||
self.enter = enter
|
||||
self.entered_with = []
|
||||
self.ocr_runs = 0
|
||||
|
||||
def click_element(self, target, *args, click=True, **kwargs):
|
||||
if target != aalc_patches.ENTER_ASSET or not self.enter:
|
||||
return False
|
||||
if not click:
|
||||
return (1100, 650)
|
||||
self.entered_with.append(self.header)
|
||||
return True
|
||||
|
||||
def read(self):
|
||||
self.ocr_runs += 1
|
||||
return super().read()
|
||||
|
||||
|
||||
class EnterSwitchTest(unittest.TestCase):
|
||||
"""镜牢入场时 AALC 直接点「进入」, 不走 select_battle_team; 补丁在点之前切队。"""
|
||||
|
||||
TOP = ['剧情关卡', '斩击', '突刺', '打击', '烧伤']
|
||||
MIDDLE = ['流血', '震颤', '破裂', '沉沦', '呼吸法']
|
||||
|
||||
def install(self, auto, system='bleed'):
|
||||
self.lines = []
|
||||
self.mirror_mod = types.ModuleType('tasks.mirror.mirror')
|
||||
self.mirror_mod.Mirror = type('Mirror', (_FakeMirror,), {})
|
||||
self.mirror_mod.select_battle_team = lambda num: False
|
||||
tasks_pkg, mirror_pkg = types.ModuleType('tasks'), types.ModuleType('tasks.mirror')
|
||||
mirror_pkg.mirror = self.mirror_mod
|
||||
engine = SimpleNamespace(ocr=SimpleNamespace(run=lambda screen: screen.read()))
|
||||
for patcher in (mock.patch.dict(sys.modules, {
|
||||
'tasks': tasks_pkg, 'tasks.mirror': mirror_pkg, 'tasks.mirror.mirror': self.mirror_mod,
|
||||
'module': types.ModuleType('module'), 'module.ocr': engine,
|
||||
'module.automation': SimpleNamespace(auto=auto)}),
|
||||
mock.patch.object(aalc_patches.time, 'sleep'),
|
||||
mock.patch.object(aalc_patches.decisions, 'record')):
|
||||
patcher.start()
|
||||
self.addCleanup(patcher.stop)
|
||||
aalc_patches.install_system_team_selection(log=self.lines.append)
|
||||
self.mirror_mod.Mirror({'system': system}, 1)
|
||||
return auto
|
||||
|
||||
@property
|
||||
def log(self):
|
||||
return '\n'.join(self.lines)
|
||||
|
||||
def test_no_enter_button_means_no_ocr(self):
|
||||
# 主循环每轮都会问一次「进入」; 按钮不在画面上时不该为它跑整屏 OCR
|
||||
auto = self.install(_EnterScreen([self.TOP], enter=False))
|
||||
for _ in range(5):
|
||||
self.assertFalse(auto.click_element(aalc_patches.ENTER_ASSET))
|
||||
self.assertEqual(auto.ocr_runs, 0)
|
||||
|
||||
def test_switches_to_the_system_team_before_entering(self):
|
||||
auto = self.install(_EnterScreen([self.TOP, self.MIDDLE]))
|
||||
self.assertTrue(auto.click_element(aalc_patches.ENTER_ASSET))
|
||||
self.assertEqual(auto.entered_with, ['流血'])
|
||||
self.assertIn('入场前切队伍: 流血', self.log)
|
||||
|
||||
def test_already_on_the_team_just_enters(self):
|
||||
auto = self.install(_EnterScreen([self.TOP, self.MIDDLE], header='流血'))
|
||||
self.assertTrue(auto.click_element(aalc_patches.ENTER_ASSET))
|
||||
self.assertEqual(auto.entered_with, ['流血'])
|
||||
self.assertEqual(auto.clicks, [])
|
||||
self.assertNotIn('入场前切队伍:', self.log)
|
||||
|
||||
def test_failed_switch_is_an_error_and_is_not_retried_this_run(self):
|
||||
auto = self.install(_EnterScreen([self.TOP, ['破裂', '沉沦', '编队#13']]))
|
||||
self.assertTrue(auto.click_element(aalc_patches.ENTER_ASSET))
|
||||
self.assertEqual(auto.entered_with, ['剧情关卡'])
|
||||
self.assertIn('[ERROR] [lc_mcp] 入场前没切到 流血, 本局按游戏当前编队进入', self.log)
|
||||
runs = auto.ocr_runs
|
||||
self.assertTrue(auto.click_element(aalc_patches.ENTER_ASSET)) # 上游再点一次「进入」
|
||||
self.assertEqual(auto.ocr_runs, runs) # 不再从头翻列表
|
||||
self.mirror_mod.Mirror({'system': 'bleed'}, 1) # 下一局重新试
|
||||
auto.click_element(aalc_patches.ENTER_ASSET)
|
||||
self.assertGreater(auto.ocr_runs, runs)
|
||||
|
||||
def test_lookup_without_click_is_passed_through(self):
|
||||
auto = self.install(_EnterScreen([self.TOP, self.MIDDLE]))
|
||||
self.assertEqual(auto.click_element(aalc_patches.ENTER_ASSET, click=False), (1100, 650))
|
||||
self.assertEqual((auto.ocr_runs, auto.entered_with), (0, []))
|
||||
|
||||
def test_other_targets_are_untouched(self):
|
||||
auto = self.install(_EnterScreen([self.TOP]))
|
||||
self.assertFalse(auto.click_element('mirror/road_to_mir/resume_assets.png'))
|
||||
self.assertEqual(auto.ocr_runs, 0)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
|
||||
class TeamNamesFileTest(unittest.TestCase):
|
||||
|
||||
def _write(self, data):
|
||||
import json
|
||||
import tempfile
|
||||
fh = tempfile.NamedTemporaryFile('w', suffix='.json', delete=False, encoding='utf-8')
|
||||
json.dump(data, fh, ensure_ascii=False)
|
||||
fh.close()
|
||||
self.addCleanup(lambda: os.unlink(fh.name))
|
||||
return fh.name
|
||||
|
||||
def test_reads_overrides(self):
|
||||
path = self._write({'_说明': ['x'], 'tremor': ['镜像迷宫', '震颤']})
|
||||
self.assertEqual(aalc_patches.load_team_names(path, log=lambda *_: None),
|
||||
{'tremor': ('镜像迷宫', '震颤')})
|
||||
|
||||
def test_bad_file_falls_back_to_empty(self):
|
||||
path = self._write(['not', 'a', 'dict'])
|
||||
self.assertEqual(aalc_patches.load_team_names(path, log=lambda *_: None), {})
|
||||
|
||||
def test_missing_file_falls_back_to_empty(self):
|
||||
self.assertEqual(
|
||||
aalc_patches.load_team_names(os.path.join(os.path.dirname(__file__), 'no-such.json'),
|
||||
log=lambda *_: None), {})
|
||||
|
||||
def test_override_goes_first_then_defaults(self):
|
||||
path = self._write({'tremor': ['镜像迷宫']})
|
||||
module = types.ModuleType('tasks.mirror.mirror')
|
||||
module.Mirror = _FakeMirror
|
||||
module.select_battle_team = lambda num: True
|
||||
auto_mod = types.ModuleType('module.automation')
|
||||
auto_mod.auto = mock.Mock()
|
||||
tasks_pkg = types.ModuleType('tasks'); tasks_pkg.__path__ = []
|
||||
mirror_pkg = types.ModuleType('tasks.mirror'); mirror_pkg.__path__ = []
|
||||
mirror_pkg.mirror = module
|
||||
with mock.patch.dict(sys.modules, {'tasks': tasks_pkg, 'tasks.mirror': mirror_pkg,
|
||||
'tasks.mirror.mirror': module,
|
||||
'module': types.ModuleType('module'),
|
||||
'module.automation': auto_mod}):
|
||||
aalc_patches.install_system_team_selection(log=lambda *_: None,
|
||||
env={'LCP_TEAM_NAMES': path})
|
||||
module.Mirror({'system': 'tremor'}, 1)
|
||||
with mock.patch.object(aalc_patches, '_select_team_by_name', return_value=True) as sel:
|
||||
module.select_battle_team(1)
|
||||
self.assertEqual(sel.call_args[0][1], ('镜像迷宫', '震颤'))
|
||||
@@ -0,0 +1,390 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""镜牢卡包按体系加分(BACKLOG R-01 / ISSUES I-08)。
|
||||
|
||||
theme_pack_list.yaml 几乎全是 0, 所有卡包并列最高分, 每层拿最左边那个。补丁在 AALC 选卡包时把
|
||||
「卡包对当局体系的加分」(lc_mcp/data/theme_pack_systems.json, 数据来自 wiki.gg)临时加到权重表上。
|
||||
端到端用例执行上游真实的 select_theme_pack, 卡面按 AALC 的规则(按表顺序取第一个子串命中的键)认。
|
||||
"""
|
||||
import ast
|
||||
import json
|
||||
import logging
|
||||
import os
|
||||
import re
|
||||
import sys
|
||||
import tempfile
|
||||
import types
|
||||
import unittest
|
||||
from pathlib import Path
|
||||
from types import SimpleNamespace
|
||||
from unittest import mock
|
||||
|
||||
REPO = Path(__file__).resolve().parents[1]
|
||||
sys.path.insert(0, str(REPO))
|
||||
from lc_mcp import aalc_patches as ap # noqa: E402
|
||||
|
||||
THEME = REPO / 'vendor' / 'aalc' / 'tasks' / 'mirror' / 'select_theme_pack.py'
|
||||
EXAMPLE = REPO / 'vendor' / 'aalc' / 'assets' / 'config' / 'theme_pack_list.example.yaml'
|
||||
BONUS = {'featured': 6, 'unique': (0, 1, 4, 6), 'recommend': 6, 'avoid': 3}
|
||||
BUILD = REPO / 'scripts' / 'build_theme_pack_systems.py'
|
||||
|
||||
|
||||
def example_weights(*sections):
|
||||
"""读 AALC 自带的 theme_pack_list.example.yaml(只认 `键: 整数` 这种行)。"""
|
||||
found, current = {}, None
|
||||
for line in EXAMPLE.read_text(encoding='utf-8').splitlines():
|
||||
header = re.match(r'^(\w+):\s*$', line)
|
||||
if header:
|
||||
current = header.group(1)
|
||||
continue
|
||||
item = re.match(r'^\s+(\S.*?):\s*(-?\d+)', line)
|
||||
if item and current in sections:
|
||||
found[item.group(1)] = int(item.group(2))
|
||||
return found
|
||||
|
||||
|
||||
def pack(zh, en='x', featured=(), recommend=(), avoid=(), normal='1F', hard='1F', **unique):
|
||||
return {'zh': zh, 'en': en, 'featured': list(featured), 'unique': unique, 'recommend': set(recommend),
|
||||
'avoid': set(avoid), 'normal': normal, 'hard': hard}
|
||||
|
||||
|
||||
class ThemePackTableTest(unittest.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
self.bonus, self.packs = ap.load_theme_pack_systems()
|
||||
self.by_name = {p['zh']: p for p in self.packs}
|
||||
|
||||
def test_table_covers_the_current_theme_packs(self):
|
||||
self.assertEqual(len(self.packs), len({p['id'] for p in self.packs}))
|
||||
self.assertGreaterEqual(len(self.packs), 120)
|
||||
self.assertEqual(self.bonus, BONUS)
|
||||
|
||||
def test_keyword_packs_and_story_packs(self):
|
||||
# wiki.gg: Featured Gifts 用体系分类的就是体系包; 专属饰品按体系计数
|
||||
self.assertEqual(self.by_name['电闪雷鸣']['featured'], ['charge'])
|
||||
self.assertEqual(self.by_name['动力渐盈']['featured'], ['charge'])
|
||||
self.assertEqual(self.by_name['尸山血海']['featured'], ['bleed'])
|
||||
self.assertEqual(self.by_name['LCB定期体检']['featured'], ['burn', 'rupture'])
|
||||
self.assertEqual(self.by_name['当斩之物']['featured'], ['slash'])
|
||||
self.assertEqual(self.by_name['WARP快车谋杀案']['unique']['charge'], 5)
|
||||
self.assertEqual(self.by_name['时间杀人时间']['unique']['tremor'], 5)
|
||||
self.assertEqual(self.by_name['被遗忘者们']['unique'], {})
|
||||
|
||||
def test_community_entries_are_attached(self):
|
||||
self.assertEqual(self.by_name['憎恶与绝望']['recommend'], {'burn', 'tremor', 'sinking', 'charge'})
|
||||
self.assertEqual(self.by_name['被遗忘者们']['avoid'], {'*'})
|
||||
self.assertEqual(self.by_name['琥珀色的黄昏']['avoid'], {'bleed'})
|
||||
self.assertEqual(self.by_name['琥珀色的黄昏']['recommend'], {'sinking'})
|
||||
|
||||
def test_community_tiers(self):
|
||||
b = self.bonus
|
||||
self.assertEqual(ap.theme_pack_bonus(self.by_name['憎恶与绝望'], 'charge', b), 6) # 专属 2 件 4, 推荐 6
|
||||
self.assertEqual(ap.theme_pack_bonus(self.by_name['地狱鸡'], 'poise', b), 6)
|
||||
self.assertEqual(ap.theme_pack_bonus(self.by_name['琥珀色的黄昏'], 'bleed', b), 0) # 专属 3 件, 但攻略说不划算
|
||||
self.assertEqual(ap.theme_pack_bonus(self.by_name['被遗忘者们'], 'charge', b), -3)
|
||||
self.assertEqual(ap.theme_pack_bonus(self.by_name['当碎之物'], 'blunt', b), 3) # 体系包 6, 拖时间 -3
|
||||
|
||||
def test_route_bonus_ignores_system_and_avoid(self):
|
||||
b = self.bonus
|
||||
self.assertEqual(ap.theme_pack_bonus(dict(self.by_name['被遗忘者们'], route=5), None, b), 5)
|
||||
self.assertEqual(ap.theme_pack_bonus(dict(self.by_name['憎恶与绝望'], route=2), 'charge', b), 6) # 取大的
|
||||
self.assertEqual(ap.theme_pack_bonus(self.by_name['憎恶与绝望'], None, b), 0)
|
||||
|
||||
def test_bonus_tiers(self):
|
||||
self.assertEqual(ap.theme_pack_bonus(self.by_name['电闪雷鸣'], 'charge', self.bonus), 6)
|
||||
self.assertEqual(ap.theme_pack_bonus(self.by_name['WARP快车谋杀案'], 'charge', self.bonus), 6)
|
||||
self.assertEqual(ap.theme_pack_bonus(self.by_name['开店抢购'], 'charge', self.bonus), 4)
|
||||
self.assertEqual(ap.theme_pack_bonus(self.by_name['WARP快车谋杀案'], 'bleed', self.bonus), 1)
|
||||
self.assertEqual(ap.theme_pack_bonus(self.by_name['电闪雷鸣'], 'bleed', self.bonus), 0)
|
||||
|
||||
def test_bad_tables_are_rejected(self):
|
||||
for data in ({'bonus': {'featured': 6, 'unique': []}, 'packs': [pack('a')]},
|
||||
{'bonus': BONUS | {'unique': [0, 1]}, 'packs': []},
|
||||
{'bonus': {'featured': 6, 'unique': [0, 1]}, 'packs': [pack('a', featured=['fire'])]},
|
||||
{'bonus': {'featured': 6, 'unique': [0, 1]}, 'packs': [pack('a', burn=0)]},
|
||||
{'bonus': {'featured': 6, 'unique': [0, 1]}, 'packs': [pack('', 'x')]},
|
||||
{'bonus': {'featured': 6, 'unique': [0, 1]}, 'packs': [pack('a')],
|
||||
'community': {'recommend': [{'pack': '不存在', 'systems': ['burn']}]}},
|
||||
{'bonus': {'featured': 6, 'unique': [0, 1]}, 'packs': [pack('a')],
|
||||
'community': {'recommend': [{'pack': 'a', 'systems': ['*']}]}},
|
||||
{'bonus': {'featured': 6, 'unique': [0, 1]}, 'packs': [pack('a')],
|
||||
'community': {'avoid': [{'pack': 'a', 'systems': []}]}}):
|
||||
with self.subTest(data=data), tempfile.TemporaryDirectory() as d:
|
||||
path = os.path.join(d, 't.json')
|
||||
with open(path, 'w', encoding='utf-8') as fh:
|
||||
json.dump(data, fh, ensure_ascii=False, default=list)
|
||||
with self.assertRaises(ValueError):
|
||||
ap.load_theme_pack_systems(path)
|
||||
|
||||
|
||||
class BoostTest(unittest.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
self.bonus, self.packs = ap.load_theme_pack_systems()
|
||||
|
||||
def boost(self, weights, system, language='zh_cn', packs=None):
|
||||
return ap.boost_theme_pack_weights(dict(weights), packs or self.packs, system, self.bonus, language)
|
||||
|
||||
@unittest.skipUnless(EXAMPLE.is_file(), 'vendor/aalc 子模块未检出')
|
||||
def test_charge_team_in_normal_mode(self):
|
||||
weights = example_weights('theme_pack_list_cn')
|
||||
result, info = self.boost(weights, 'charge')
|
||||
self.assertEqual((result['谋杀'], result['开店']), (1, 1)) # WARP 专属 5 件充能, 开店 2 件
|
||||
self.assertEqual((result['绝望'], result['绞丝']), (1, 1)) # 社区推荐
|
||||
self.assertEqual(result['赌徒'], 0)
|
||||
self.assertEqual((result['遗忘'], result['自动']), (-3, -5)) # 速刷攻略说拖时间
|
||||
self.assertEqual(result['地狱鸡'], 1)
|
||||
self.assertEqual(info['谋杀'], {'packs': ['WARP快车谋杀案', 'WARP快车谋杀案 复刻'], 'system': 'charge',
|
||||
'from': -5, 'to': 1})
|
||||
self.assertEqual(set(result), set(weights) | {k for k in info if k not in weights})
|
||||
# 加过分的键排在最前面
|
||||
self.assertEqual(list(result)[:len(info)], list(info))
|
||||
|
||||
@unittest.skipUnless(EXAMPLE.is_file(), 'vendor/aalc 子模块未检出')
|
||||
def test_keyword_packs_in_hard_mode(self):
|
||||
weights = example_weights('theme_pack_list_cn', 'theme_pack_list_hard_cn')
|
||||
result, _ = self.boost(weights, 'charge')
|
||||
self.assertEqual((result['电闪雷鸣'], result['动力']), (6, 6))
|
||||
result, _ = self.boost(weights, 'bleed')
|
||||
self.assertEqual(result['渗出的'], 6)
|
||||
|
||||
@unittest.skipUnless(EXAMPLE.is_file(), 'vendor/aalc 子模块未检出')
|
||||
def test_shared_key_takes_the_smaller_bonus_and_the_reprint_gets_its_full_name(self):
|
||||
# 「谋杀」同时命中原版(流血 1 件)和复刻(流血 3 件)
|
||||
result, info = self.boost(example_weights('theme_pack_list_cn'), 'bleed')
|
||||
self.assertEqual(result['谋杀'], -4)
|
||||
self.assertEqual(result['WARP快车谋杀案 复刻'], 1)
|
||||
order = list(result)
|
||||
self.assertLess(order.index('WARP快车谋杀案 复刻'), order.index('谋杀'))
|
||||
|
||||
@unittest.skipUnless(EXAMPLE.is_file(), 'vendor/aalc 子模块未检出')
|
||||
def test_key_shared_with_an_unrelated_pack_is_left_alone(self):
|
||||
# 「区的奇」= 20区的奇迹 + 复刻; 只有复刻有震颤专属饰品
|
||||
result, info = self.boost(example_weights('theme_pack_list_cn'), 'tremor')
|
||||
self.assertEqual(result['区的奇'], 0)
|
||||
self.assertEqual(result['20区的奇迹 复刻'], 1)
|
||||
self.assertNotIn('区的奇', info)
|
||||
|
||||
def test_pack_unknown_to_aalc_starts_from_the_unknown_weight(self):
|
||||
packs = [pack('黎明后贯穿而来之楔', pierce=3)]
|
||||
result, info = self.boost({'遗忘': 0, '未知': -5}, 'pierce', packs=packs)
|
||||
self.assertEqual(result['黎明后贯穿而来之楔'], 1)
|
||||
self.assertEqual(result['未知'], -5)
|
||||
|
||||
def test_english_keys(self):
|
||||
packs = [pack('WARP快车谋杀案', 'Murder on the WARP Express', charge=5),
|
||||
pack('电闪雷鸣', 'Thunder and Lightning', featured=['charge']),
|
||||
pack('被遗忘者们', 'The Forgotten')]
|
||||
result, _ = self.boost({'forgot': 0, 'warp': -5, 'thunder': 0, 'unknown': -5}, 'charge', 'en', packs)
|
||||
self.assertEqual(result, {'thunder': 6, 'warp': 1, 'forgot': 0, 'unknown': -5})
|
||||
|
||||
def test_unrelated_keys_keep_their_weight(self):
|
||||
weights = {'信仰': 0, '赌徒': -1}
|
||||
result, info = self.boost(weights, 'charge')
|
||||
self.assertEqual((result['信仰'], result['赌徒']), (0, -1))
|
||||
self.assertNotIn('信仰', info)
|
||||
# 表里没有的充能卡包补全名键, 从「未知」(表里也没有就 -5)起算
|
||||
self.assertEqual(result['电闪雷鸣'], 1)
|
||||
|
||||
@unittest.skipUnless(EXAMPLE.is_file(), 'vendor/aalc 子模块未检出')
|
||||
def test_packs_missing_from_the_difficulty_do_not_block_a_key(self):
|
||||
# 「海·边」也是活动专用包 去·海·边·激·蟹 的一部分; 普通/困难都不会出现它, 不算冲突
|
||||
weights = example_weights('theme_pack_list_cn')
|
||||
self.assertEqual(self.boost(weights, 'pierce')[0]['海·边'], 0)
|
||||
result, _ = ap.boost_theme_pack_weights(dict(weights), self.packs, 'pierce', self.bonus, 'zh_cn', False)
|
||||
self.assertEqual((result['海·边'], result['区的奇'], result['赌徒']), (6, 6, 6))
|
||||
# 困难模式 20区的奇迹 复刻 也会出现, 它和突刺无关, 「区的奇」就不动
|
||||
weights = example_weights('theme_pack_list_cn', 'theme_pack_list_hard_cn')
|
||||
result, _ = ap.boost_theme_pack_weights(dict(weights), self.packs, 'pierce', self.bonus, 'zh_cn', True)
|
||||
self.assertEqual(result['区的奇'], 0)
|
||||
|
||||
def test_penalties_follow_the_same_shared_key_rule(self):
|
||||
packs = [pack('被遗忘者们', avoid=['*']), pack('自动工厂', avoid=['*']), pack('遗忘的工厂')]
|
||||
result, info = self.boost({'遗忘': 0, '工厂': -2}, 'charge', packs=packs)
|
||||
self.assertEqual(result['遗忘'], 0) # 遗忘的工厂 不减分, 有加有不加就不动短键
|
||||
self.assertEqual(result['被遗忘者们'], -3) # 改用全名
|
||||
self.assertEqual(result['工厂'], -2)
|
||||
self.assertEqual(result['自动工厂'], -5)
|
||||
|
||||
def test_system_without_any_pack_changes_nothing(self):
|
||||
packs = [pack('被遗忘者们'), pack('电闪雷鸣', featured=['charge'])]
|
||||
weights = {'遗忘': 0, '电闪雷鸣': -5}
|
||||
self.assertEqual(self.boost(weights, 'burn', packs=packs), (weights, {}))
|
||||
|
||||
|
||||
@unittest.skipUnless(BUILD.is_file(), 'scripts 目录缺失')
|
||||
class GeneratorFormatTest(unittest.TestCase):
|
||||
|
||||
def test_generator_writes_the_shipped_file_byte_for_byte(self):
|
||||
import importlib.util
|
||||
spec = importlib.util.spec_from_file_location('build_theme_pack_systems', BUILD)
|
||||
module = importlib.util.module_from_spec(spec)
|
||||
spec.loader.exec_module(module)
|
||||
text = Path(ap.THEME_PACK_SYSTEMS_FILE).read_text(encoding='utf-8')
|
||||
self.assertEqual(module.dump_table(json.loads(text)), text)
|
||||
|
||||
|
||||
class Match:
|
||||
def __init__(self, value, text):
|
||||
self.value, self.text, self.position = value, text, [0, 0]
|
||||
|
||||
|
||||
@unittest.skipUnless(THEME.is_file(), 'vendor/aalc 子模块未检出')
|
||||
class UpstreamSelectThemePackTest(unittest.TestCase):
|
||||
"""执行上游真实的 select_theme_pack(普通模式, 中文)。"""
|
||||
|
||||
def setUp(self):
|
||||
self.lines = []
|
||||
tree = ast.parse(THEME.read_text(encoding='utf-8'))
|
||||
self.node = next(n for n in tree.body if isinstance(n, ast.FunctionDef) and n.name == 'select_theme_pack')
|
||||
self.node.decorator_list = []
|
||||
|
||||
def play(self, cards, system, patched=True, audit=False, env=None, hard=False, route=None):
|
||||
positions = [(300 + 300 * i, 300) for i in range(len(cards))]
|
||||
weights = example_weights('theme_pack_list_cn', *(('theme_pack_list_hard_cn',) if hard else ()))
|
||||
lookups = []
|
||||
|
||||
def find_language_text(zh, en, crop):
|
||||
# AALC: 按表的顺序, 第一个(去空格、不分大小写)是卡面文字子串的键
|
||||
x = (crop[0] + crop[2]) / 2
|
||||
text = cards[min(range(len(cards)), key=lambda i: abs(positions[i][0] - x))].replace(' ', '').lower()
|
||||
lookups.append(zh)
|
||||
for key, value in zh.items():
|
||||
if key.replace(' ', '').lower() in text:
|
||||
return Match(value, key)
|
||||
return None
|
||||
|
||||
auto = SimpleNamespace(
|
||||
model=None, take_screenshot=lambda: object(), mouse_to_blank=lambda *a, **k: None,
|
||||
find_element=lambda target, **kw: list(positions) if 'theme_pack_features' in target else False,
|
||||
find_language_text=find_language_text, mouse_drag_down=mock.Mock(),
|
||||
click_element=lambda *a, **k: False)
|
||||
theme_list = SimpleNamespace(preferred_thresholds=0, get_effective_theme_pack_list=lambda *a: dict(weights))
|
||||
ns = dict(auto=auto, TextMatchResult=Match, sleep=lambda *a: None, back_init_menu=mock.Mock(),
|
||||
log=logging.getLogger('AALC'), theme_list=theme_list,
|
||||
cfg=SimpleNamespace(set_win_size=720, select_event_pack=False, skip_event_pack=False),
|
||||
path_manager=SimpleNamespace(current_language='zh_cn'))
|
||||
exec(compile(ast.Module(body=[self.node], type_ignores=[]), str(THEME), 'exec'), ns)
|
||||
theme_mod = types.ModuleType('tasks.mirror.select_theme_pack')
|
||||
theme_mod.theme_list = theme_list
|
||||
mirror_mod = types.ModuleType('tasks.mirror.mirror')
|
||||
mirror_mod.select_theme_pack = ns['select_theme_pack']
|
||||
mirror_mod.Mirror = type('Mirror', (), {'__init__': lambda self, system: setattr(self, 'system', system)})
|
||||
package = types.ModuleType('tasks.mirror')
|
||||
package.mirror, package.select_theme_pack = mirror_mod, theme_mod
|
||||
logger = logging.getLogger('AALC')
|
||||
with mock.patch.dict(sys.modules, {'tasks': types.ModuleType('tasks'), 'tasks.mirror': package,
|
||||
'tasks.mirror.mirror': mirror_mod,
|
||||
'tasks.mirror.select_theme_pack': theme_mod}), \
|
||||
mock.patch.object(logger, 'level', logging.DEBUG), mock.patch.object(logger, 'propagate', False), \
|
||||
mock.patch.object(ap.decisions, 'record') as record:
|
||||
if patched:
|
||||
self.assertIsNotNone(ap.install_theme_pack_systems(log=self.lines.append, env=env or {},
|
||||
route=route, route_name='兔子洞路线'))
|
||||
if audit:
|
||||
ap.install_theme_pack_audit(log=self.lines.append)
|
||||
mirror_mod.Mirror(system)
|
||||
mirror_mod.select_theme_pack(hard, 4, 1, False)
|
||||
self.assertEqual(theme_list.get_effective_theme_pack_list(), weights, '权重表的原方法必须还原')
|
||||
drag = auto.mouse_drag_down.call_args[0]
|
||||
picked = cards[positions.index(drag)]
|
||||
return picked, record, lookups
|
||||
|
||||
@property
|
||||
def log(self):
|
||||
return '\n'.join(self.lines)
|
||||
|
||||
FLOOR4 = ['伏行深渊', '落泪者们', 'WARP快车谋杀案', '堕落的忧郁']
|
||||
|
||||
def test_upstream_takes_the_leftmost_of_equal_weights(self):
|
||||
self.assertEqual(self.play(self.FLOOR4, 'charge', patched=False)[0], '落泪者们')
|
||||
|
||||
def test_charge_team_takes_the_charge_pack(self):
|
||||
picked, _, _ = self.play(self.FLOOR4, 'charge')
|
||||
self.assertEqual(picked, 'WARP快车谋杀案')
|
||||
self.assertIn('patch: 镜牢卡包按体系加分(theme_pack_systems.json', self.log)
|
||||
self.assertIn('卡包按体系 charge 加分: ', self.log)
|
||||
self.assertIn('谋杀 -5→1', self.log)
|
||||
|
||||
FLOOR1 = ['被遗忘者们', '身无分文的赌徒', '钉与锤']
|
||||
|
||||
def test_slow_pack_is_avoided_and_pierce_takes_its_route(self):
|
||||
self.assertEqual(self.play(self.FLOOR1, 'charge', patched=False)[0], '被遗忘者们')
|
||||
self.assertEqual(self.play(self.FLOOR1, 'charge')[0], '身无分文的赌徒') # 被遗忘者们 -3
|
||||
self.assertEqual(self.play(['钉与锤', '身无分文的赌徒'], 'pierce')[0], '身无分文的赌徒')
|
||||
|
||||
def test_bleed_team_does_not_take_the_original_warp(self):
|
||||
# 原版 WARP 只有 1 件流血专属饰品, 加 1 分仍然低于 0 分的卡包
|
||||
self.assertEqual(self.play(self.FLOOR4, 'bleed')[0], '落泪者们')
|
||||
|
||||
def test_audit_records_the_system_bonus(self):
|
||||
picked, record, _ = self.play(self.FLOOR4, 'charge', audit=True)
|
||||
args, kwargs = record.call_args
|
||||
self.assertEqual(args, ('theme_pack', '谋杀', 'preferred'))
|
||||
# 普通模式: 复刻只在困难出现, 不算进「谋杀」这个键
|
||||
self.assertEqual(kwargs['system_bonus'], {'packs': ['WARP快车谋杀案'], 'system': 'charge', 'from': -5, 'to': 1})
|
||||
|
||||
def test_audit_keeps_a_key_with_a_space(self):
|
||||
# 困难模式流血队: 复刻 WARP 专属流血 3 件, 用全名键「WARP快车谋杀案 复刻」; 审计不能截在空格前
|
||||
picked, record, _ = self.play(['钉与锤', 'WARP快车谋杀案 复刻'], 'bleed', audit=True, hard=True)
|
||||
self.assertEqual(picked, 'WARP快车谋杀案 复刻')
|
||||
args, kwargs = record.call_args
|
||||
self.assertEqual(args, ('theme_pack', 'WARP快车谋杀案 复刻', 'preferred'))
|
||||
self.assertEqual(kwargs['system_bonus']['to'], 1)
|
||||
|
||||
def test_audit_without_bonus_has_no_system_field(self):
|
||||
_, record, _ = self.play(self.FLOOR4, 'bleed', audit=True)
|
||||
self.assertNotIn('system_bonus', record.call_args[1])
|
||||
|
||||
def test_unknown_system_keeps_upstream_weights(self):
|
||||
picked, _, lookups = self.play(self.FLOOR4, 'unknown_system')
|
||||
self.assertEqual(picked, '落泪者们')
|
||||
self.assertEqual(lookups[0], example_weights('theme_pack_list_cn'))
|
||||
|
||||
def test_rabbit_hole_route_without_a_system(self):
|
||||
# 兔子洞编队没有体系; 困难模式 AALC 默认「绝望」「号线」都是 -5, 不加分拿 0 分的落泪者们
|
||||
route = ap.load_rabbit_hole()['theme_packs']
|
||||
floor4 = ['2号线', '憎恶与绝望', '落泪者们']
|
||||
self.assertEqual(self.play(floor4, None, hard=True)[0], '落泪者们')
|
||||
self.assertEqual(self.play(floor4, None, hard=True, route=route)[0], '憎恶与绝望') # 2号线留给 5 层
|
||||
self.assertIn('卡包按体系 (无)+兔子洞路线 加分: ', self.log)
|
||||
self.assertIn('兔子洞路线 身无分文的赌徒+10 地狱鸡+10 去·海·边+10 憎恶与绝望+12 2号线+10', self.log)
|
||||
self.assertEqual(self.play(['电闪雷鸣', '2号线'], None, hard=True, route=route)[0], '2号线')
|
||||
self.assertEqual(self.play(['地狱鸡', '去·海·边'], None, hard=True, route=route)[0], '地狱鸡')
|
||||
self.assertEqual(self.play(['憎恶与绝望', '去·海·边'], None, hard=True, route=route)[0], '去·海·边')
|
||||
|
||||
def test_route_beats_the_system_bonus_and_unknown_names_are_errors(self):
|
||||
picked, _, _ = self.play(self.FLOOR4, 'charge', route={'落泪者们': 20, '不存在的包': 5})
|
||||
self.assertEqual(picked, '落泪者们')
|
||||
self.assertIn('[ERROR] [lc_mcp] 兔子洞路线卡包不在卡包表里, 不加分: 不存在的包', self.log)
|
||||
|
||||
def test_env_zero_and_bad_table(self):
|
||||
self.assertIsNone(ap.install_theme_pack_systems(log=self.lines.append, env={ap.THEME_PACK_SYSTEMS_ENV: '0'}))
|
||||
with tempfile.TemporaryDirectory() as d:
|
||||
path = os.path.join(d, 'bad.json')
|
||||
with open(path, 'w', encoding='utf-8') as fh:
|
||||
fh.write('{}')
|
||||
self.assertIsNone(ap.install_theme_pack_systems(log=self.lines.append,
|
||||
env={ap.THEME_PACK_SYSTEMS_ENV: path}))
|
||||
self.assertIn('[ERROR] [lc_mcp] 卡包体系表读不了', self.log)
|
||||
|
||||
def test_upstream_without_the_weight_lookup_is_an_error(self):
|
||||
with mock.patch('inspect.getsource', return_value='def select_theme_pack(): pass'):
|
||||
theme_mod = types.ModuleType('tasks.mirror.select_theme_pack')
|
||||
theme_mod.theme_list = SimpleNamespace()
|
||||
mirror_mod = types.ModuleType('tasks.mirror.mirror')
|
||||
mirror_mod.select_theme_pack = lambda *a: None
|
||||
package = types.ModuleType('tasks.mirror')
|
||||
package.mirror, package.select_theme_pack = mirror_mod, theme_mod
|
||||
with mock.patch.dict(sys.modules, {'tasks': types.ModuleType('tasks'), 'tasks.mirror': package,
|
||||
'tasks.mirror.mirror': mirror_mod,
|
||||
'tasks.mirror.select_theme_pack': theme_mod}):
|
||||
self.assertIsNone(ap.install_theme_pack_systems(log=self.lines.append, env={}))
|
||||
self.assertIn('[ERROR] [lc_mcp] 上游 select_theme_pack 不再从 theme_list.get_effective_theme_pack_list 取权重',
|
||||
self.log)
|
||||
|
||||
def test_current_upstream_source_has_the_weight_lookup(self):
|
||||
self.assertIn('theme_list.get_effective_theme_pack_list(', THEME.read_text(encoding='utf-8'))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@@ -0,0 +1,220 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""镜牢键盘寻路按节点类型选方向(BACKLOG P0-2)。
|
||||
|
||||
2026-11-14: config 开着简单键盘寻路, AALC 每步只按 ↑, 3 层只进过 1 次商店。
|
||||
补丁仍只按键、不拖地图, 但先识别下一列节点类型, 按上游权重表挑方向。
|
||||
"""
|
||||
import ast
|
||||
import sys
|
||||
import types
|
||||
import unittest
|
||||
from pathlib import Path
|
||||
from types import SimpleNamespace
|
||||
from unittest import mock
|
||||
|
||||
REPO = Path(__file__).resolve().parents[1]
|
||||
sys.path.insert(0, str(REPO))
|
||||
from lc_mcp import aalc_patches as ap # noqa: E402
|
||||
|
||||
SEARCH_ROAD = REPO / 'vendor' / 'aalc' / 'tasks' / 'mirror' / 'search_road.py'
|
||||
SCALE = 720 / 1440 # 本机 set_win_size=720
|
||||
GAP_X = ap.UPSTREAM_ROAD_COLUMN_GAP * SCALE
|
||||
GAP_Y = ap.UPSTREAM_ROAD_ROW_GAP * SCALE
|
||||
BUS = (100, 400)
|
||||
|
||||
|
||||
def node(kind, columns=1, rows=0):
|
||||
"""相对巴士偏 columns 列、rows 行(向上为正)的节点。"""
|
||||
return [kind, (BUS[0] + columns * GAP_X, BUS[1] - rows * GAP_Y)]
|
||||
|
||||
|
||||
class RankNextNodesTest(unittest.TestCase):
|
||||
|
||||
def test_orders_next_column_by_upstream_weight(self):
|
||||
nodes = [node('battle', rows=0), node('event', rows=1), node('shop', rows=-1),
|
||||
node('event', columns=2), node('event', columns=0.3)]
|
||||
self.assertEqual(ap.rank_next_nodes(BUS, nodes, SCALE),
|
||||
[('U', 'event', 1), ('D', 'shop', 2), ('M', 'battle', 4)])
|
||||
|
||||
def test_ties_prefer_up_then_middle(self):
|
||||
nodes = [node('battle', rows=-1), node('battle', rows=0), node('battle', rows=1)]
|
||||
self.assertEqual([d for d, _, _ in ap.rank_next_nodes(BUS, nodes, SCALE)], ['U', 'M', 'D'])
|
||||
|
||||
def test_tolerates_detection_offsets_within_a_quarter_gap(self):
|
||||
kind, (x, y) = node('shop', rows=1)
|
||||
shifted = [kind, (x + GAP_X / 5, y + GAP_Y / 3)]
|
||||
self.assertEqual(ap.rank_next_nodes(BUS, [shifted], SCALE), [('U', 'shop', 2)])
|
||||
|
||||
def test_keeps_the_better_detection_per_direction(self):
|
||||
nodes = [node('risky_encounter', rows=0), node('event', rows=0)]
|
||||
self.assertEqual(ap.rank_next_nodes(BUS, nodes, SCALE), [('M', 'event', 1)])
|
||||
|
||||
def test_rows_beyond_neighbours_and_unknown_types_are_ignored(self):
|
||||
nodes = [node('event', rows=2), node('mystery', rows=0)]
|
||||
self.assertEqual(ap.rank_next_nodes(BUS, nodes, SCALE), [])
|
||||
|
||||
def test_no_bus_or_no_nodes(self):
|
||||
self.assertEqual(ap.rank_next_nodes(None, [node('event')], SCALE), [])
|
||||
self.assertEqual(ap.rank_next_nodes(BUS, None, SCALE), [])
|
||||
|
||||
|
||||
@unittest.skipUnless(SEARCH_ROAD.is_file(), 'vendor/aalc 子模块未检出')
|
||||
class UpstreamConstantsTest(unittest.TestCase):
|
||||
"""本地兜底常量必须与上游一致(运行时优先读上游的值)。"""
|
||||
|
||||
def setUp(self):
|
||||
self.tree = ast.parse(SEARCH_ROAD.read_text(encoding='utf-8'))
|
||||
|
||||
def assignment(self, name):
|
||||
for item in self.tree.body:
|
||||
if isinstance(item, ast.Assign) and any(getattr(t, 'id', None) == name for t in item.targets):
|
||||
return ast.literal_eval(item.value)
|
||||
self.fail('上游没有 %s' % name)
|
||||
|
||||
def test_weights_and_grid_match_upstream(self):
|
||||
self.assertEqual(self.assignment('all_node_weight'), ap.UPSTREAM_NODE_WEIGHT)
|
||||
self.assertEqual(self.assignment('ROAD_COLUMN_GAP'), ap.UPSTREAM_ROAD_COLUMN_GAP)
|
||||
self.assertEqual(self.assignment('ROAD_ROW_GAP'), ap.UPSTREAM_ROAD_ROW_GAP)
|
||||
|
||||
def test_direction_keys_match_upstream_keyboard_navigation(self):
|
||||
source = SEARCH_ROAD.read_text(encoding='utf-8')
|
||||
for direction, key in ap.ROAD_KEYS.items():
|
||||
self.assertIn('if next_step == "%s":\n auto.key_press("%s")' % (direction, key)
|
||||
if direction == 'U' else
|
||||
'elif next_step == "%s":\n auto.key_press("%s")' % (direction, key),
|
||||
source)
|
||||
|
||||
|
||||
class TypedKeyboardRoadTest(unittest.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
self.lines = []
|
||||
self.keys = []
|
||||
self.original = mock.Mock(return_value='original')
|
||||
self.entered = []
|
||||
self.road = types.ModuleType('tasks.mirror.search_road')
|
||||
self.road.search_road_simple_keyboard = self.original
|
||||
self.road.identify_nodes = mock.Mock(return_value=[node('battle', rows=0), node('event', rows=1),
|
||||
node('shop', rows=-1)])
|
||||
self.road._keyboard_enter_succeeded = lambda: self.entered.pop(0)
|
||||
self.mirror = types.ModuleType('tasks.mirror.mirror')
|
||||
self.mirror.search_road_simple_keyboard = self.original
|
||||
self.auto = SimpleNamespace(mouse_to_blank=mock.Mock(), key_press=self.keys.append,
|
||||
find_element=mock.Mock(return_value=BUS))
|
||||
self.cfg = SimpleNamespace(mirror_keyboard_navigation=True, set_win_size=720)
|
||||
package = types.ModuleType('tasks.mirror')
|
||||
package.mirror, package.search_road = self.mirror, self.road
|
||||
tasks = types.ModuleType('tasks')
|
||||
tasks.mirror = package
|
||||
modules = {'tasks': tasks, 'tasks.mirror': package, 'tasks.mirror.mirror': self.mirror,
|
||||
'tasks.mirror.search_road': self.road,
|
||||
'module': types.ModuleType('module'),
|
||||
'module.automation': SimpleNamespace(auto=self.auto),
|
||||
'module.config': SimpleNamespace(cfg=self.cfg)}
|
||||
for patch in (mock.patch.dict(sys.modules, modules), mock.patch.object(ap.time, 'sleep')):
|
||||
patch.start()
|
||||
self.addCleanup(patch.stop)
|
||||
patch = mock.patch.object(ap.decisions, 'record')
|
||||
self.records = patch.start()
|
||||
self.addCleanup(patch.stop)
|
||||
|
||||
def install(self, env=None):
|
||||
return ap.install_typed_keyboard_road(log=self.lines.append, env=env or {})
|
||||
|
||||
def test_replaces_both_namespaces_and_enters_the_best_direction(self):
|
||||
self.assertIs(self.install(), self.original)
|
||||
self.assertIs(self.mirror.search_road_simple_keyboard, self.road.search_road_simple_keyboard)
|
||||
self.entered = [True]
|
||||
self.assertTrue(self.mirror.search_road_simple_keyboard())
|
||||
self.assertEqual(self.keys, ['up'])
|
||||
self.original.assert_not_called()
|
||||
log = '\n'.join(self.lines)
|
||||
self.assertIn('U=event(1) D=shop(2) M=battle(4)', log)
|
||||
self.assertIn('进入 U 方向的 event', log)
|
||||
|
||||
def test_tries_next_direction_when_one_cannot_be_entered(self):
|
||||
self.install()
|
||||
self.entered = [False, True]
|
||||
self.assertTrue(self.road.search_road_simple_keyboard())
|
||||
self.assertEqual(self.keys, ['up', 'down'])
|
||||
self.assertIn('更优的方向没能进入', '\n'.join(self.lines))
|
||||
|
||||
def test_decisions_are_recorded(self):
|
||||
self.install()
|
||||
self.entered = [False, True]
|
||||
self.road.search_road_simple_keyboard()
|
||||
self.records.assert_called_once_with('road', 'D:shop', 'next_best',
|
||||
candidates=['U=event(1)', 'D=shop(2)', 'M=battle(4)'])
|
||||
self.records.reset_mock()
|
||||
self.auto.find_element.return_value = None
|
||||
self.road.search_road_simple_keyboard()
|
||||
self.records.assert_called_once_with('road', 'up', 'fallback', why='没找到巴士')
|
||||
|
||||
def test_falls_back_to_original_when_nothing_can_be_entered(self):
|
||||
self.install()
|
||||
self.entered = [False, False, False]
|
||||
self.assertEqual(self.road.search_road_simple_keyboard(), 'original')
|
||||
self.assertEqual(self.keys, ['up', 'down', 'right'])
|
||||
self.original.assert_called_once_with()
|
||||
|
||||
def test_falls_back_without_pressing_when_bus_or_nodes_are_missing(self):
|
||||
self.install()
|
||||
for bus, nodes in ((None, []), (BUS, None), (BUS, [])):
|
||||
with self.subTest(bus=bus, nodes=nodes):
|
||||
self.original.reset_mock()
|
||||
self.auto.find_element.return_value = bus
|
||||
self.road.identify_nodes.return_value = nodes
|
||||
self.assertEqual(self.road.search_road_simple_keyboard(), 'original')
|
||||
self.original.assert_called_once_with()
|
||||
self.assertEqual(self.keys, [])
|
||||
|
||||
def test_recognition_error_falls_back(self):
|
||||
self.install()
|
||||
self.road.identify_nodes.side_effect = RuntimeError('onnx missing')
|
||||
self.assertEqual(self.road.search_road_simple_keyboard(), 'original')
|
||||
self.assertIn('RuntimeError', '\n'.join(self.lines))
|
||||
|
||||
def test_keyboard_navigation_off_keeps_upstream_behaviour(self):
|
||||
self.install()
|
||||
self.cfg.mirror_keyboard_navigation = False
|
||||
self.assertEqual(self.road.search_road_simple_keyboard(), 'original')
|
||||
self.road.identify_nodes.assert_not_called()
|
||||
|
||||
def test_gives_up_keyboard_after_consecutive_failed_nodes(self):
|
||||
# 2026-11-14 实机 24/24 没进去: 每个节点白按 5 次键。连续 3 个节点都不行就别再按了
|
||||
self.install()
|
||||
self.original.return_value = False
|
||||
self.entered = [False] * 3 * ap.ROAD_KEY_GIVE_UP
|
||||
for _ in range(ap.ROAD_KEY_GIVE_UP):
|
||||
self.assertFalse(self.road.search_road_simple_keyboard())
|
||||
self.assertIn('连续 3 个节点按键都没进去, 本次任务不再按键寻路', '\n'.join(self.lines))
|
||||
self.records.assert_any_call('road', None, 'keyboard_off', fails=3)
|
||||
pressed, recognised = len(self.keys), self.road.identify_nodes.call_count
|
||||
self.original.reset_mock()
|
||||
self.assertIs(self.road.search_road_simple_keyboard(), False) # 上游接着走常规寻路
|
||||
self.assertEqual((len(self.keys), self.road.identify_nodes.call_count), (pressed, recognised))
|
||||
self.original.assert_not_called()
|
||||
|
||||
def test_entering_once_resets_the_failure_count(self):
|
||||
self.install()
|
||||
self.original.return_value = False
|
||||
self.entered = [False] * 6 + [True] + [False] * 6
|
||||
results = [bool(self.road.search_road_simple_keyboard()) for _ in range(5)]
|
||||
self.assertEqual(results, [False, False, True, False, False])
|
||||
self.assertNotIn('不再按键寻路', '\n'.join(self.lines))
|
||||
|
||||
def test_falling_back_to_up_and_entering_counts_as_success(self):
|
||||
self.install()
|
||||
self.entered = [False] * 3 * (ap.ROAD_KEY_GIVE_UP + 1)
|
||||
for _ in range(ap.ROAD_KEY_GIVE_UP + 1):
|
||||
self.assertEqual(self.road.search_road_simple_keyboard(), 'original') # 原 ↑ 进去了
|
||||
self.assertNotIn('不再按键寻路', '\n'.join(self.lines))
|
||||
|
||||
def test_env_switch_leaves_upstream_untouched(self):
|
||||
self.assertIsNone(self.install(env={ap.TYPED_ROAD_ENV: '0'}))
|
||||
self.assertIs(self.road.search_road_simple_keyboard, self.original)
|
||||
self.assertIs(self.mirror.search_road_simple_keyboard, self.original)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
Vendored
+1
-1
Submodule vendor/aalc updated: e1d1749905...2fcb1b4620
Reference in New Issue
Block a user