Author SHA1 Message Date
Codex Agent dc5bcadd16 截图连续识别失败熔断 + 卡包低分先刷新;震颤队名
- aalc_patches: install_image_error_guard — ImageUtils.match_template 返回 None(上游异常分支)
  在 120 秒内累计 20 次即 TaskAbort, 避免窗口没了还空转 4.5 小时(2026-11-16 实测)
- 卡包优选阈值: preferred_thresholds 0→1(LCP_THEME_PACK_THRESHOLD 可调), 低于 1 分先刷新, 上游最多 3 次
- data/team_names.json: tremor -> [震颤](用户 11-16 指定, 不再选镜像迷宫)
- tests: 新增 test_image_error_guard 5 例

单测: 743 passed。
2026-11-16 23:41:45 +08:00
Codex Agent bda1ffb390 驱动点击兜底 + 队名可配置;补 11-15 实机记录
- driver_input: 只在"原地连点"(与上次点击相差<=4px)时先挪开 10px 再点, 强制产生 MOUSEMOVE;
  按下 60→100ms, 到位等待 50→80ms (LCP_DRIVER_PRESS_MS / SETTLE_MS / WIGGLE 可调)
- aalc_patches: 「获得E.G.O饰品」弹窗第 3 次起绕过驱动代理改软件点击(pyautogui),
  第 8 次发回车, 20 次才中止; 新增 data/team_names.json 覆盖体系默认队名
  (LCP_TEAM_NAMES=0 关闭)
- docs: 2026-11-15 实测(6 连刷 6/6、键盘 4/4 进入、卡包按体系、镜像迷宫+震颤),
  ISSUES 状态更新 + I-14 前台被抢

单测: 709 passed。
2026-11-15 14:15:02 +08:00
ywsandClaude Opus 5.5 a04b443b6a 镜牢兔子洞速刷: 每场第一回合超频「空洞」、攻略路线卡包加分
run_task(task="mirror", strategy="rabbit_hole") 时生效, 不带 strategy 时不装:
- 选队按 rabbit_hole.json 的编队名(默认「兔子洞」);
- 每回合 P → 长按浮士德打开 E.G.O 列表 → OCR 找「空洞」, 第一回合长按卡片超频
  (侵蚀「空洞」直接打人; 普通「空洞」只叠弹孔), 其余回合单击 → Enter;
  审计 battle/hollow 记 overclock/ego/ego_unavailable/no_option;
- 路线卡包加分: 赌徒 → 地狱鸡 → 去·海·边 → 憎恶与绝望 → 2号线(OurPlay 全程困难路线),
  按 AALC 默认权重模拟每层都选到路线卡包。
长按点 press_at 出厂未校准: 只记 [ERROR], 照常 P+Enter。
机制和超频操作按零协游戏文本/教程核实; 编队、路线按 codex 检索的 OurPlay/Reddit 攻略。
实机校准步骤见 docs/feedback/2026-11-15/RABBIT-HOLE.md, 台账 R-08。

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-15 05:12:23 +00:00
ywsandClaude Opus 5.5 348de32807 复查修正: 卡包审计把带空格的键截在空格前
卡包按体系加分会加带空格的全名键(如「WARP快车谋杀案 复刻」), 审计从 AALC 日志取
「此次选择卡包关键词:X」时用 \S+, 截成「WARP快车谋杀案」, system_bonus 也对不上。
改成取到行尾; 补端到端用例(困难模式流血队选中复刻 WARP), 旧正则下该用例失败。

单测 704 个全过。

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-15 01:50:12 +00:00
ywsandClaude Opus 5.5 96a31bc1ae 按台账修镜牢: 饰品弹窗兜底、按键扫描码、卡包按体系加分
按 docs/ISSUES.md 处理本机回归后待修/待数据的条目:

- I-06/R-04 开局「获得E.G.O饰品」弹窗死循环: 确认模板连续第 3 次命中起改点
  按钮中心(勾号 +76/1440), 连续 20 次还在就记 [ERROR]、抛 TaskAbort 结束任务
  (上游 continue 跳过了循环计数)。单测执行上游真实 select_init_ego_gift。
- I-05/R-03 键盘寻路 0 成功: 前台按键改发带扫描码和扩展键标志的 keybd_event,
  各模式按住 0.12 秒(上游注释: Unity 6 校验扫描码/扩展键); 连续 3 个节点进不去
  就本次任务停用键盘寻路(方案 B)。MCP key 工具前台同样处理。LCP_KEY_HOLD=0 关。
- I-07/R-02 事件表 6 -> 9 条: 蜘蛛巢、归乡路途两段(拿「归途」), 按 wiki.gg 核对结果;
  全表按本机装的零协 release 2026111301 重新核对唯一性。
- I-13 复查 5992827: 「进入」先模板确认再 OCR(原来每轮都跑一次整屏 OCR);
  选队页重试重新截图; 入场切队失败记 [ERROR] 且本局不再重翻列表。
- R-01/I-08 卡包按体系加分: wiki.gg 122 个卡包(楼层/专属饰品/Featured 分类) +
  零协中文名生成 lc_mcp/data/theme_pack_systems.json(scripts/build_theme_pack_systems.py);
  灰机 wiki 对云端 403、BWIKI 无卡包条目, 中文社区攻略用 codex CLI 联网检索,
  推荐/避开并入表的 community。选卡包时临时加到 AALC 权重上, 按当前难度只看会出现
  的卡包; 审计记 system_bonus。LCP_THEME_PACK_SYSTEMS=0 关。
- 文档: ISSUES/BACKLOG/README 更新, 新增 docs/feedback/2026-11-15/REGRESSION.md
  (本轮回归清单)和 theme-pack-research.md(检索记录)。

单测 703 个全过(Linux)。实机未验。

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-15 01:24:46 +00:00
Codex Agent 599282729c 镜牢入场前切队 + 选队页守卫;补回归结果与问题需求台账
实机回归发现: 镜牢入场时 AALC 直接点「进入」, 根本不走 select_battle_team,
用的是游戏记住的旧队伍; 「星之恩惠」页满屏星星又会让「选队星级」模板误命中。

- aalc_patches: 点「进入」前若在选队页且顶栏不是目标队, 先按体系名切队(充能优先,
  没有就震颤); 新增选队页守卫(只有出现「恩惠」字样才忽略星级模板); 选队扫描从每轮
  3 次拖动改为 1 次(3 次会整屏跳过, 实测漏掉「充能」)
- tests: 44→45 个用例, 覆盖偏好顺序、星之恩惠判定、守卫行为
- docs: REGRESSION-RESULTS.md(勾选结果), ISSUES.md(问题/需求台账),
  BACKLOG 状态表, HANDOVER 补「拉取后必须重启服务」

单测: 641 passed。实机: 2026-11-15 01:51 入场精确选中「充能」。
2026-11-15 02:03:27 +08:00
ywsandClaude Opus 5.5 908713b922 补本轮实机回归清单
docs/feedback/2026-11-14/REGRESSION.md: 拉取步骤(含 submodule 升到 2fcb1b4)、
任务开始时应出现的七行补丁日志、跑完一局逐项要看的日志与判断方法、离线确认不了的
假设、各功能的关闭开关和回传内容。交接文档第 5、7 节和 BACKLOG 开头链到它。

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-14 09:34:00 +00:00
31 changed files with 3867 additions and 68 deletions
+28 -4
View File
@@ -149,10 +149,12 @@ MCP 初始化说明与工具描述均指导 AI 优先使用 AALC:常规日常
| `stage` | `reason` | | `stage` | `reason` |
|---|---| |---|---|
| `team` | `current` 已是目标队 / `exact` / `prefix` 后缀队名 / `header_unchanged` / `not_found` | | `team` | `current` 已是目标队 / `exact` / `prefix` 后缀队名 / `header_unchanged` / `not_found` |
| `road` | `lowest` 下一列最优 / `next_best` 更优方向进不去 / `fallback` 退回按 ↑ | | `road` | `lowest` 下一列最优 / `next_best` 更优方向进不去 / `fallback` 退回按 ↑ / `keyboard_off` 连续几个节点按键都没进去,本次任务改走 AALC 常规寻路 |
| `theme_pack` | `preferred` 达到优选阈值 / `highest_weight` 刷新后取最高权重 / `event_pack` 最左活动卡包 | | `theme_pack` | `preferred` 达到优选阈值 / `highest_weight` 刷新后取最高权重 / `event_pack` 最左活动卡包;选中的卡包按体系加过分时带 `system_bonus`(`packs`/`system`/`from`/`to`) |
| `gift` | `keyword` 命中体系关键词 / `no_keyword`(记的是交给 AALC 的第一顺位,白棉花、已持有仍由 AALC 处理) | | `gift` | `keyword` 命中体系关键词 / `no_keyword`(记的是交给 AALC 的第一顺位,白棉花、已持有仍由 AALC 处理) |
| `event` | `text` 按表选 / `deferred` 认出了表里的事件但交给 AALC / `not_in_table`(带 `options`,可直接拿来补表) | | `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` 本体系饰品) | | `shop` | `name_match` 按中文名找到必买饰品(`choice` 是名字)/ `purchase_clicked` 点到了购买按钮(`choice` 是之前点的商品:`shop_by_name` 按名字、必买模板名、`level_IV_to_buy`、`by_position` 本体系饰品) |
### 任务进程里的保护 ### 任务进程里的保护
@@ -178,15 +180,35 @@ MCP 初始化说明与工具描述均指导 AI 优先使用 AALC:常规日常
- **镜牢按体系名选队**:按 `team_system` 在编队列表里点同名队伍(流血/斩击/…),点完核对顶栏队名。 - **镜牢按体系名选队**:按 `team_system` 在编队列表里点同名队伍(流血/斩击/…),点完核对顶栏队名。
名字先归一(去空白、全角转半角、纠正 `震颐`/`沉论`/`编#` 等误读);精确匹配优先, 名字先归一(去空白、全角转半角、纠正 `震颐`/`沉论`/`编#` 等误读);精确匹配优先,
否则接受这一屏唯一的"名字+后缀"(`流血队`、`流血(X)`),多条就不点。没找到时日志列出每屏看到的名字。 否则接受这一屏唯一的"名字+后缀"(`流血队`、`流血(X)`),多条就不点。没找到时日志列出每屏看到的名字。
AALC 入场时常常直接点「进入」、不走选队,所以点「进入」前也会核对顶栏,不是目标队就先切;
切不过去记 `[ERROR]`,这一局按游戏当前编队进入,不再反复翻列表。「星之恩惠」页满屏星星会被认成选队页,
出现「恩惠」字样时忽略选队星级模板。
- **键盘寻路按节点类型**:开着简单键盘寻路时不再只按 ↑。先识别巴士右侧下一列的节点类型, - **键盘寻路按节点类型**:开着简单键盘寻路时不再只按 ↑。先识别巴士右侧下一列的节点类型,
按上游权重(事件 < 商店 < 战斗 < …)依次按方向键,进不去再退回 ↑;不拖地图。`LCP_TYPED_ROAD=0` 关闭。 按上游权重(事件 < 商店 < 战斗 < …)依次按方向键,进不去再退回 ↑;不拖地图。
连续 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,按卡面上命中当前体系关键词的行数给卡排序, - **饰品选择按体系关键词**:镜牢路上的饰品 N 选一,先整屏 OCR,按卡面上命中当前体系关键词的行数给卡排序,
再交给 AALC 原逻辑(跳过白棉花、已持有排后)。三张卡时命中关键词的卡按"认出体系图标"交给 AALC, 再交给 AALC 原逻辑(跳过白棉花、已持有排后)。三张卡时命中关键词的卡按"认出体系图标"交给 AALC,
并抵消它把这类卡逐张插到最前造成的倒序。关键词表在 `lc_mcp/data/gift_keywords.json`。 并抵消它把这类卡逐张插到最前造成的倒序。关键词表在 `lc_mcp/data/gift_keywords.json`。
- **事件选项表**:事件出现选项时整屏 OCR,按同一屏其它选项的原文(零协汉化)认出 `lc_mcp/data/event_choices.json` - **事件选项表**:事件出现选项时整屏 OCR,按同一屏其它选项的原文(零协汉化)认出 `lc_mcp/data/event_choices.json`
里的事件,就点表里那一项;不靠事件名(汉化数据没有标题)。没收录的事件照旧交给 AALC, 里的事件,就点表里那一项;不靠事件名(汉化数据没有标题)。没收录的事件照旧交给 AALC,
日志会打印这一屏的选项文字,便于补表。表里的选择优先于 AALC 的"有 ??? 先点 ???",小指良单通模式也一样。 日志会打印这一屏的选项文字,便于补表。表里的选择优先于 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]` 并跳过该补丁,不会悄悄失效。 上游改了写法时记 `[ERROR]` 并跳过该补丁,不会悄悄失效。
## 无人值守 ## 无人值守
@@ -240,6 +262,8 @@ powershell -ExecutionPolicy Bypass -File scripts\install_convert_task.ps1 -Every
| `LCP_EVENT_CHOICES` | 未设置 | 设为 `0` 时事件不查选项表;设为 JSON 文件路径时用它代替 `lc_mcp/data/event_choices.json` | | `LCP_EVENT_CHOICES` | 未设置 | 设为 `0` 时事件不查选项表;设为 JSON 文件路径时用它代替 `lc_mcp/data/event_choices.json` |
| `LCP_GIFT_KEYWORDS` | 未设置 | 设为 `0` 时饰品选择不按体系关键词排序;设为 JSON 文件路径时用它代替 `lc_mcp/data/gift_keywords.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_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`;认不出的键名会报错而不是换成默认键 | | `LCP_KILL_KEY` | `end` | 任务子进程的急停键,如 `pause` / `scrolllock`;认不出的键名会报错而不是换成默认键 |
| `LC_PY` | 当前解释器 | `levelup.py`/`auto_cycle.py` 调用 MCP 用的 Python | | `LC_PY` | 当前解释器 | `levelup.py`/`auto_cycle.py` 调用 MCP 用的 Python |
+20 -1
View File
@@ -2,12 +2,31 @@
按「收益 / 风险」排序。每条都带**证据**和**验收标准**,云端改完直接照着验。 按「收益 / 风险」排序。每条都带**证据**和**验收标准**,云端改完直接照着验。
最近一次实测记录见 [`feedback/2026-11-14/README.md`](feedback/2026-11-14/README.md), 最近一次实测记录见 [`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/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 = 打磨。 图例: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 云端) ## AALC 上游升级到 V1.6.1(2026-11-14 云端)
`vendor/aalc` 从 `e1d1749`(V1.6.1-beta.11)升到 `2fcb1b4`(V1.6.1,17 个提交)。与本仓库补丁有关的: `vendor/aalc` 从 `e1d1749`(V1.6.1-beta.11)升到 `2fcb1b4`(V1.6.1,17 个提交)。与本仓库补丁有关的:
+237
View File
@@ -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` 可按需加词。
+21
View File
@@ -105,6 +105,9 @@ if task in ('mirror', 'all'):
## 5. 验证方法 ## 5. 验证方法
> 下面 5.2/5.3 是最初选队补丁的回归。2026-11-14 云端交付的整轮(寻路、选队容错、饰品、事件、商店、审计、AALC V1.6.1)
> 回归清单见 [REGRESSION.md](REGRESSION.md)。
### 5.1 单测(不需要游戏) ### 5.1 单测(不需要游戏)
```powershell ```powershell
@@ -161,3 +164,21 @@ vendor\aalc\.venv\Scripts\python.exe -m unittest discover -s tests -t tests
``` ```
我这边回归后会补:跑团日志、截图路径、验收清单勾选结果,以及新发现的问题。 我这边回归后会补:跑团日志、截图路径、验收清单勾选结果,以及新发现的问题。
本轮要勾的清单在 [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` 一直不落盘。
+4
View File
@@ -4,6 +4,10 @@
后半段顺带核了镜牢局内的四类决策(走位 / 卡包 / 饰品 / 商店),发现两处真实缺陷,一并记在 后半段顺带核了镜牢局内的四类决策(走位 / 卡包 / 饰品 / 商店),发现两处真实缺陷,一并记在
[`BACKLOG.md`](../../BACKLOG.md) 里。 [`BACKLOG.md`](../../BACKLOG.md) 里。
后续:云端按 [`REGRESSION.md`](REGRESSION.md) 交付了 9 个补丁,本机回归结果在
[`REGRESSION-RESULTS.md`](REGRESSION-RESULTS.md);所有问题与需求统一记账在
[`docs/ISSUES.md`](../../ISSUES.md)。
## 环境 ## 环境
| 项 | 值 | | 项 | 值 |
@@ -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)。
+80
View File
@@ -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`、
相关截图、本清单的勾选结果,以及新发现的问题。
+93
View File
@@ -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` 和单局用时。
+114
View File
@@ -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 连刷已完成(本轮) |
+97
View File
@@ -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)
@@ -47,7 +47,8 @@
| 员工证、夜视镜、止痛片、贪婪之锤 | 2 | 安全直出,避开判定或损失分支 | | 员工证、夜视镜、止痛片、贪婪之锤 | 2 | 安全直出,避开判定或损失分支 |
| 巫毒娃娃 | 3;需要饰品时 2 | 安全直出或免费饰品 | | 巫毒娃娃 | 3;需要饰品时 2 | 安全直出或免费饰品 |
| 生存的里程标、异想狩猎 | 分别 2、1 | 安全直出;另一项都是免费饰品 | | 生存的里程标、异想狩猎 | 分别 2、1 | 安全直出;另一项都是免费饰品 |
| 归乡路途 | 1→分支 1 | 免费饰品,其他路径可能大量降理智 | | 归乡路途 | 1→分支 1 | 免费饰品「归途」,其他路径可能大量降理智 |
| 蜘蛛巢(结婚蜘蛛) | 1:摘下一朵花。 | 免费饰品「偏见」,非傲慢人格扣 5 体力;2 是 50% 判定,成败都有全体损失。[条目](https://limbuscompany.wiki.gg/wiki/Spider_of_Marriage) |
| 终末日历 | 2 | 安全直出 | | 终末日历 | 2 | 安全直出 |
| 破碎罗盘 | 4;缺经费时 1→分支 1 | 直接结束;另一条拿 50 经费,但增加分支 | | 破碎罗盘 | 4;缺经费时 1→分支 1 | 直接结束;另一条拿 50 经费,但增加分支 |
| 拉·曼却领嘉年华游行、旋转木马、折射的四百朵玫瑰 | 2 | 安全直出 | | 拉·曼却领嘉年华游行、旋转木马、折射的四百朵玫瑰 | 2 | 安全直出 |
@@ -109,4 +110,4 @@
本文为速通摘要,不覆盖主线探索。Wiki 结果是依据;版本变化或文字不符时回查对应事件,不能套用到同名活动变体。 本文为速通摘要,不覆盖主线探索。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。
+7 -6
View File
@@ -300,12 +300,13 @@ class AalcEngine(Engine):
finally: finally:
handler.key_up(k) handler.key_up(k)
elif not self.cfg.simulator and self.cfg.win_input_type == 'foreground': elif not self.cfg.simulator and self.cfg.win_input_type == 'foreground':
import pyautogui # pyautogui 发的按键扫描码是 0、方向键不带扩展键标志, Unity 6 会忽略(ISSUES I-05);
pyautogui.keyDown(k) # 与任务子进程的按键补丁用同一个 press_vk, 同样按住 0.12 秒。
try: import ctypes
time.sleep(0.12) from module.automation.input_handlers.input import EXTENDED_KEY_VKS, key_list
finally: from .aalc_patches import press_vk
pyautogui.keyUp(k) vk = key_list[k]
press_vk(ctypes.windll.user32, vk, vk in EXTENDED_KEY_VKS, hold=0.12)
else: else:
self.auto.key_press(k) self.auto.key_press(k)
+875 -34
View File
@@ -473,6 +473,12 @@ SYSTEM_TEAM_NAMES = {
'blunt': ('打击',), 'blunt': ('打击',),
} }
# 体系名之外还想按顺序再试的队名(2026-11-14 用户指定: 充能优先, 没有就退到震颤)。
# 注意: 体系本身仍按 team_system 算, 商店/饰品的体系判断不会跟着换。
TEAM_PREFERENCES = {
'charge': ('震颤',),
}
# 左侧编队列表的 OCR 命中范围(客户区像素, 1280x720 实测) # 左侧编队列表的 OCR 命中范围(客户区像素, 1280x720 实测)
TEAM_LIST_X_MAX = 260 TEAM_LIST_X_MAX = 260
TEAM_LIST_Y_MIN = 300 TEAM_LIST_Y_MIN = 300
@@ -512,6 +518,69 @@ def _scroll_team_list(auto, direction, times=6, distance=250):
time.sleep(0.35) time.sleep(0.35)
# 「星之恩惠」页满屏星星, 会命中「选队星级」模板(2026-11-14 实测: 连喊 6 次"不在编队界面",
# AALC 以为在选队页, 实际在星之恩惠页)。只有编队图标在、或者左侧列表真的是队名, 才算选队页。
TEAM_SCREEN_STARS = 'mirror/road_to_mir/select_team_stars_assets.png'
ENTER_ASSET = 'mirror/road_to_mir/enter_assets.png'
TEAM_SCREEN_ICON = 'teams/identify_assets.png'
TEAM_SCREEN_KNOWN = frozenset(
{'剧情关卡'}
| {name for names in SYSTEM_TEAM_NAMES.values() for name in names}
| {name for names in TEAM_PREFERENCES.values() for name in names}
)
def _looks_like_team_screen(auto):
"""左侧列表里至少 3 条像队名(已知队名或 编队#N)才算选队页。"""
try:
names = _list_names([item for item in _team_ocr(auto) if _in_list(item[1], item[2])])
except Exception:
return False
hits = sum(1 for name in names if name in TEAM_SCREEN_KNOWN or name.startswith('编队#'))
return hits >= 3
STARLIGHT_MARKERS = ('恩惠',)
def _is_starlight_screen(auto):
"""「星之恩惠」页: 有「恩惠」字样, 满屏星星; 选队页没有。
守卫只用它做否定条件, 比「必须有编队图标/队名列表」宽松: 选队页刚加载时图标和列表
可能还没出来, 严格条件会把真的选队页一起跳过(2026-11-14 21:03 实测)。
"""
try:
return any(marker in text for text, x, y in _team_ocr(auto) for marker in STARLIGHT_MARKERS)
except Exception:
return False
def install_team_screen_guard(log=print):
"""选队页守卫: 星级模板在「星之恩惠」页上的命中不算数。"""
try:
from module.automation import auto
except Exception as e:
log('[lc_mcp] 选队页守卫补丁跳过: 无法导入 auto %s' % e)
return None
original = getattr(auto, 'find_element', None)
if original is None:
log('[lc_mcp] 选队页守卫补丁跳过: auto 没有 find_element')
return None
def find_element(target, *args, **kwargs):
result = original(target, *args, **kwargs)
if result and isinstance(target, str) and target == TEAM_SCREEN_STARS:
if _is_starlight_screen(auto):
log('[lc_mcp] 星级模板在星之恩惠页命中, 不是选队页, 忽略')
return False
return result
find_element.__wrapped__ = original
auto.find_element = find_element
log('[lc_mcp] patch: 选队页守卫(星之恩惠页忽略星级模板)')
return original
# OCR 实测误读(2026-11-14): 震颤→震颐, 沉沦→沉论, 编队#16→编#16。归一化时按子串改回来。 # OCR 实测误读(2026-11-14): 震颤→震颐, 沉沦→沉论, 编队#16→编#16。归一化时按子串改回来。
TEAM_OCR_FIXES = (('震颐', '震颤'), ('沉论', '沉沦'), ('编#', '编队#')) TEAM_OCR_FIXES = (('震颐', '震颤'), ('沉论', '沉沦'), ('编#', '编队#'))
TEAM_PREFIX_MIN = 2 # 前缀匹配的队名至少两个字, 免得单字名把一片都吃进来 TEAM_PREFIX_MIN = 2 # 前缀匹配的队名至少两个字, 免得单字名把一片都吃进来
@@ -583,15 +652,26 @@ def _wait_header(auto, names, tries=3, delay=1.2):
return False return False
def _select_team_by_name(auto, names, log=print, rounds=4): def _select_team_by_name(auto, names, log=print, rounds=6):
"""在编队列表里按名字点选。成功返回 True, 没找到返回 False。 """在编队列表里按名字点选。成功返回 True, 没找到返回 False。
名字先归一化(空白/全半角/常见误读); 精确匹配优先, 否则接受唯一的"名字+后缀"。 名字先归一化(空白/全半角/常见误读); 精确匹配优先, 否则接受唯一的"名字+后缀"。
没找到时把每一屏看到的名字打进日志。 没找到时把每一屏看到的名字打进日志。
每轮只往下拖 1 次: 实测一次拖动能滚 5~6 行、可见 7 行, 3 次一起拖会直接跳过
一整屏(2026-11-14 实测: 从「剧情关卡..震颤」一次跳到「编队#19..25」, 漏掉「充能」)。
""" """
if auto.take_screenshot() is None: if auto.take_screenshot() is None:
return False return False
if not auto.find_element('teams/identify_assets.png'): for attempt in range(3):
# 选队页刚加载时图标和列表可能还没出来: 等一下、重新截图再认, 别对着同一张图认三次
if attempt:
time.sleep(0.8)
if auto.take_screenshot() is None:
continue
if auto.find_element(TEAM_SCREEN_ICON) or _looks_like_team_screen(auto):
break
else:
log('[lc_mcp] 不在编队界面, 跳过按名字选队') log('[lc_mcp] 不在编队界面, 跳过按名字选队')
return False return False
current = [normalize_team_name(t) for t in _header_texts(auto) or () current = [normalize_team_name(t) for t in _header_texts(auto) or ()
@@ -603,41 +683,83 @@ def _select_team_by_name(auto, names, log=print, rounds=4):
seen = [] seen = []
auto.mouse_click(1, 1) auto.mouse_click(1, 1)
time.sleep(0.3) time.sleep(0.3)
_scroll_team_list(auto, +1) # 先回到顶部 # 逐个名字找: 每个名字都从列表顶部重新翻, 保证 names 的顺序就是优先级。
for round_index in range(1, rounds + 1): # (不能只用一屏的命中顺序——名字都可见时随屏幕位置, 靠后的优先项会被漏掉)
if auto.take_screenshot() is None: for name in names:
log('[lc_mcp] 第 %d 屏截图失败' % round_index) _scroll_team_list(auto, +1) # 回到顶部
continue for round_index in range(1, rounds + 1):
items = [item for item in _team_ocr(auto) if _in_list(item[1], item[2])] if auto.take_screenshot() is None:
seen.append(_list_names(items)) log('[lc_mcp] 第 %d 屏截图失败' % round_index)
hit, reason = pick_team_item(items, names) continue
if hit: items = [item for item in _team_ocr(auto) if _in_list(item[1], item[2])]
text, x, y = hit seen.append(_list_names(items))
label = normalize_team_name(text) hit, reason = pick_team_item(items, (name,))
log('[lc_mcp] 编队列表里找到 %s @(%d,%d), %s' % (label, x, y, reason)) if hit:
auto.mouse_action_with_pos([x, y], offset=False) text, x, y = hit
if _wait_header(auto, (label,)): label = normalize_team_name(text)
log('[lc_mcp] patch: 已按体系名选中编队 %s' % label) log('[lc_mcp] 编队列表里找到 %s @(%d,%d), %s' % (label, x, y, reason))
decisions.record('team', label, team_name_match(label, names), wanted=list(names)) auto.mouse_action_with_pos([x, y], offset=False)
return True if _wait_header(auto, (label,)):
header = [normalize_team_name(t) for t in _header_texts(auto) or ()] log('[lc_mcp] patch: 已按体系名选中编队 %s' % label)
log('[lc_mcp] 点了 %s 但顶栏没变(顶栏读到: %s), 继续往下翻' % (label, '/'.join(header) or '无')) decisions.record('team', label, team_name_match(label, names), wanted=list(names))
decisions.record('team', label, 'header_unchanged', wanted=list(names), header=header) return True
else: header = [normalize_team_name(t) for t in _header_texts(auto) or ()]
log('[lc_mcp] 第 %d 屏没有 %s%s; 这一屏的名字: %s' log('[lc_mcp] 点了 %s 但顶栏没变(顶栏读到: %s), 继续往下翻' % (label, '/'.join(header) or '无'))
% (round_index, '/'.join(names), ', ' + reason if reason else '', decisions.record('team', label, 'header_unchanged', wanted=list(names), header=header)
'/'.join(_list_names(items)) or '(空)')) else:
_scroll_team_list(auto, -1, times=3) log('[lc_mcp] 第 %d 屏没有 %s%s; 这一屏的名字: %s'
log('[lc_mcp] 编队列表里没找到 %s(共 %d 轮)' % ('/'.join(names), rounds)) % (round_index, name, ', ' + reason if reason else '',
'/'.join(_list_names(items)) or '(空)'))
_scroll_team_list(auto, -1, times=1)
log('[lc_mcp] 编队列表里没找到 %s(共 %d 轮)' % ('/'.join(names), rounds * max(len(names), 1)))
decisions.record('team', None, 'not_found', wanted=list(names), seen=seen) decisions.record('team', None, 'not_found', wanted=list(names), seen=seen)
return False return False
def install_system_team_selection(log=print): def load_team_names(path, log=print):
"""读「体系 → 优先队名」表 {体系: [队名...]}; 以 _ 开头的键是说明。
用来覆盖 SYSTEM_TEAM_NAMES 里的默认名(本机把镜像迷宫用的那支队起了自己的名字)。
读不了就返回 {}, 不影响默认逻辑。
"""
try:
with open(path, encoding='utf-8') as f:
raw = json.load(f)
except (OSError, ValueError) as e:
log('[lc_mcp] 队名表 %s 读不了(%s: %s), 用默认队名' % (path, type(e).__name__, e))
return {}
if not isinstance(raw, dict):
log('[lc_mcp] 队名表 %s 顶层应是 {体系: [队名]}, 用默认队名' % path)
return {}
table = {}
for system, names in raw.items():
if str(system).startswith('_'):
continue
if not isinstance(names, list) or not all(isinstance(n, str) for n in names):
log('[lc_mcp] 队名表 %s 的 %s 应是字符串列表, 忽略' % (path, system))
continue
cleaned = tuple(n.strip() for n in names if n.strip())
if cleaned:
table[str(system)] = cleaned
return table
TEAM_NAMES_ENV = 'LCP_TEAM_NAMES' # 0 = 关闭覆盖; 文件路径 = 用别的表
TEAM_NAMES_FILE = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'data', 'team_names.json')
def install_system_team_selection(log=print, names=None, env=None):
"""镜牢选队改成"按队伍体系对应的中文名"在列表里点。 """镜牢选队改成"按队伍体系对应的中文名"在列表里点。
AALC 原生只认 编队#N; 本账号的编队是自定义名字(流血/斩击/...), 原生逻辑永远选不上。 AALC 原生只认 编队#N; 本账号的编队是自定义名字(流血/斩击/...), 原生逻辑永远选不上。
names 给了就不看体系, 直接按这些名字选(兔子洞这类固定编队的打法用);
否则按 data/team_names.json 的覆盖 > SYSTEM_TEAM_NAMES > TEAM_PREFERENCES 的顺序。
""" """
env = os.environ if env is None else env
overrides = {}
setting = (env.get(TEAM_NAMES_ENV) or '').strip()
if setting != '0':
overrides = load_team_names(setting or TEAM_NAMES_FILE, log=log)
try: try:
from tasks.mirror import mirror as mirror_mod from tasks.mirror import mirror as mirror_mod
from module.automation import auto from module.automation import auto
@@ -648,14 +770,22 @@ def install_system_team_selection(log=print):
if original is None: if original is None:
log('[lc_mcp] 体系选队补丁跳过: mirror 模块没有 select_battle_team') log('[lc_mcp] 体系选队补丁跳过: mirror 模块没有 select_battle_team')
return None return None
wanted = {'names': ()} wanted = {'names': (), 'enter_failed': False}
original_init = mirror_mod.Mirror.__init__ original_init = mirror_mod.Mirror.__init__
def __init__(self, team_setting, team_num): def __init__(self, team_setting, team_num):
original_init(self, team_setting, team_num) original_init(self, team_setting, team_num)
wanted['names'] = SYSTEM_TEAM_NAMES.get(getattr(self, 'system', ''), ()) system = getattr(self, 'system', '')
base = []
for name in (overrides.get(system, ())
+ SYSTEM_TEAM_NAMES.get(system, ())
+ TEAM_PREFERENCES.get(system, ())):
if name not in base:
base.append(name)
wanted['names'] = tuple(names) if names else tuple(base)
wanted['enter_failed'] = False
log('[lc_mcp] 镜牢体系 %s -> 目标编队 %s' log('[lc_mcp] 镜牢体系 %s -> 目标编队 %s'
% (getattr(self, 'system', '?'), '/'.join(wanted['names']) or '(无配置)')) % (system or '?', '/'.join(wanted['names']) or '(无配置)'))
def select_battle_team(num): def select_battle_team(num):
names = wanted['names'] names = wanted['names']
@@ -668,6 +798,35 @@ def install_system_team_selection(log=print):
return False return False
return original(num) return original(num)
# 2026-11-14 实测: 镜牢入场时 AALC 直接点「进入」, 根本不经过 select_battle_team
# (只有它先看到星级模板才会走选队)。所以在点「进入」之前补一次切队。
original_click = getattr(auto, 'click_element', None)
if original_click is not None:
def click_element(target, *args, **kwargs):
names = wanted['names']
if (target != ENTER_ASSET or not names or wanted['enter_failed']
or kwargs.get('click') is False):
return original_click(target, *args, **kwargs)
# 镜牢主循环和 road_to_mir 每轮都会问一次「进入」; 先用模板确认按钮真在画面上,
# 再做整屏 OCR, 不然每轮白跑一次 OCR。没找到时上游也是返回 False。
if not original_click(target, *args, **dict(kwargs, click=False)):
return False
try:
if _looks_like_team_screen(auto) and not _header_is(auto, names):
log('[lc_mcp] 入场前切队伍: %s' % '/'.join(names))
if not _select_team_by_name(auto, names, log=log):
# 显式报错, 但不拦着进入: 拦住的话上游会一直点「进入」、一直重翻列表。
# 本局不再重试, 免得每一轮都把列表从头翻一遍。
wanted['enter_failed'] = True
log('[ERROR] [lc_mcp] 入场前没切到 %s, 本局按游戏当前编队进入' % '/'.join(names))
except Exception as e:
log('[lc_mcp] 入场前切队伍出错: %s: %s' % (type(e).__name__, e))
return original_click(target, *args, **kwargs)
click_element.__wrapped__ = original_click
auto.click_element = click_element
log('[lc_mcp] patch: 入场前按体系切队伍')
mirror_mod.Mirror.__init__ = __init__ mirror_mod.Mirror.__init__ = __init__
mirror_mod.select_battle_team = select_battle_team mirror_mod.select_battle_team = select_battle_team
log('[lc_mcp] patch: 镜牢按体系名选队') log('[lc_mcp] patch: 镜牢按体系名选队')
@@ -691,6 +850,9 @@ UPSTREAM_NODE_WEIGHT = {
'risky_encounter': 7, 'shop': 2, 'abnormality_focused_encounter': 6, 'risky_encounter': 7, 'shop': 2, 'abnormality_focused_encounter': 6,
} }
TYPED_ROAD_ENV = 'LCP_TYPED_ROAD' # 设为 0 时不装这个补丁, 完全回到原简单键盘寻路 TYPED_ROAD_ENV = 'LCP_TYPED_ROAD' # 设为 0 时不装这个补丁, 完全回到原简单键盘寻路
# 连续这么多个节点按键都没进去, 本次任务就不再按键寻路(直接交给 AALC 的常规寻路)。
# 2026-11-14 实机 24/24 失败, 每个节点白按 5 次键 ≈ 5 秒; 进去一次就清零重新计。
ROAD_KEY_GIVE_UP = 3
def rank_next_nodes(bus, nodes, scale, weights=UPSTREAM_NODE_WEIGHT, def rank_next_nodes(bus, nodes, scale, weights=UPSTREAM_NODE_WEIGHT,
@@ -741,9 +903,26 @@ def install_typed_keyboard_road(log=print, env=None):
column_gap = getattr(road, 'ROAD_COLUMN_GAP', UPSTREAM_ROAD_COLUMN_GAP) column_gap = getattr(road, 'ROAD_COLUMN_GAP', UPSTREAM_ROAD_COLUMN_GAP)
row_gap = getattr(road, 'ROAD_ROW_GAP', UPSTREAM_ROAD_ROW_GAP) row_gap = getattr(road, 'ROAD_ROW_GAP', UPSTREAM_ROAD_ROW_GAP)
state = {'fails': 0, 'off': False}
def search_road_simple_keyboard(): def search_road_simple_keyboard():
if not cfg.mirror_keyboard_navigation: if not cfg.mirror_keyboard_navigation:
return original() # 上游会说明需要开启键盘寻路 return original() # 上游会说明需要开启键盘寻路
if state['off']:
return False # 上游接着走常规寻路
entered = _typed_keyboard_road()
if entered:
state['fails'] = 0
return entered
state['fails'] += 1
if state['fails'] >= ROAD_KEY_GIVE_UP:
state['off'] = True
log('[lc_mcp] 键盘寻路: 连续 %d 个节点按键都没进去, 本次任务不再按键寻路, 交给 AALC 常规寻路'
% state['fails'])
decisions.record('road', None, 'keyboard_off', fails=state['fails'])
return entered
def _typed_keyboard_road():
try: try:
auto.mouse_to_blank() auto.mouse_to_blank()
time.sleep(0.3) time.sleep(0.3)
@@ -1381,7 +1560,8 @@ def install_shop_by_name(log=print, env=None):
return original return original
THEME_PACK_PICK = re.compile(r'此次选择卡包关键词[::]\s*(\S+)') # 取到行尾: 卡包按体系加分会加带空格的全名键(如「WARP快车谋杀案 复刻」), \S+ 会截在空格前
THEME_PACK_PICK = re.compile(r'此次选择卡包关键词[::]\s*(.+?)\s*$', re.M)
THEME_PACK_WEIGHTS = '当前主题包权重列表' THEME_PACK_WEIGHTS = '当前主题包权重列表'
THEME_PACK_SOURCE = 'select_theme_pack.py' THEME_PACK_SOURCE = 'select_theme_pack.py'
@@ -1437,9 +1617,670 @@ def install_theme_pack_audit(log=print):
decision = theme_pack_decision(capture.messages) decision = theme_pack_decision(capture.messages)
if decision: if decision:
pack, reason, weights = decision pack, reason, weights = decision
extra = {}
if pack in THEME_PACK_BOOSTED: # 选中的是按体系加过分的卡包
extra['system_bonus'] = THEME_PACK_BOOSTED[pack]
decisions.record('theme_pack', pack, reason, weights=weights, decisions.record('theme_pack', pack, reason, weights=weights,
floor=kwargs.get('floor', args[1] if len(args) > 1 else None)) floor=kwargs.get('floor', args[1] if len(args) > 1 else None), **extra)
select_theme_pack.__wrapped__ = original
mirror_mod.select_theme_pack = select_theme_pack mirror_mod.select_theme_pack = select_theme_pack
log('[lc_mcp] patch: 卡包选择写入决策审计') log('[lc_mcp] patch: 卡包选择写入决策审计')
return original return original
# ---------------------------------------------------------------- 卡包按体系加分
# BACKLOG R-01 / ISSUES I-08: theme_pack_list.yaml 几乎全是 0, 所有卡包并列最高分, 每层都拿最左边那个。
# 这里在 AALC 选卡包时把它的权重表临时加上「卡包对当局体系的加分」(lc_mcp/data/theme_pack_systems.json),
# 不改配置文件。AALC 拿卡包卡面 OCR 文字按权重表的键做子串匹配、取第一个命中的键, 所以加过分的键排在最前面。
THEME_PACK_SYSTEMS_ENV = 'LCP_THEME_PACK_SYSTEMS' # 0 = 关闭; 文件路径 = 用这张表代替默认表
THEME_PACK_THRESHOLD_ENV = 'LCP_THEME_PACK_THRESHOLD' # 优选阈值; 默认抬到 1, 让低分楼层先刷新卡包
THEME_PACK_SYSTEMS_FILE = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'data', 'theme_pack_systems.json')
THEME_PACK_UNKNOWN_KEYS = ('未知', 'unknown') # AALC 认不出卡包时的兜底权重键, 不当卡包名用
THEME_PACK_BOOSTED = {} # 本次选卡包加过分的键 → {pack, system, from, to}; 卡包审计记到 decisions 里
def load_theme_pack_systems(path=THEME_PACK_SYSTEMS_FILE):
"""读卡包体系表, 返回 (bonus, packs); 格式不对抛 ValueError。
community 里的推荐/避开按卡包中文名挂到对应卡包上(recommend / avoid 两个体系集合, avoid 里 '*' 表示所有体系)。
"""
with open(path, encoding='utf-8') as fh:
data = json.load(fh)
bonus = data.get('bonus') if isinstance(data, dict) else None
if not isinstance(bonus, dict) or not isinstance(bonus.get('featured'), int) \
or not isinstance(bonus.get('unique'), list) or not bonus['unique'] \
or not all(isinstance(v, int) for v in bonus['unique']) \
or not all(isinstance(bonus.get(k, 0), int) for k in ('recommend', 'avoid')):
raise ValueError('bonus 要有整数 featured、非空整数列表 unique, recommend/avoid 也要是整数')
packs = data.get('packs')
if not isinstance(packs, list) or not packs:
raise ValueError('packs 必须是非空列表')
systems = set(SYSTEM_TEAM_NAMES)
loaded = {}
for pack in packs:
if not isinstance(pack, dict) or not str(pack.get('zh') or '').strip() or not str(pack.get('en') or '').strip():
raise ValueError('卡包要有 zh 和 en 名字: %r' % (pack,))
if not set(pack.get('featured') or ()) <= systems or not set(pack.get('unique') or {}) <= systems:
raise ValueError('卡包 %s 的体系名不认识' % pack['zh'])
if not all(isinstance(n, int) and n > 0 for n in (pack.get('unique') or {}).values()):
raise ValueError('卡包 %s 的专属饰品件数必须是正整数' % pack['zh'])
loaded[pack['zh']] = dict(pack, recommend=set(), avoid=set())
community = data.get('community') or {}
for field, allowed in (('recommend', systems), ('avoid', systems | {'*'})):
for entry in community.get(field) or ():
name = entry.get('pack') if isinstance(entry, dict) else None
wanted = set(entry.get('systems') or ()) if isinstance(entry, dict) else set()
if name not in loaded:
raise ValueError('community.%s 里的卡包 %r 不在 packs 里' % (field, name))
if not wanted or not wanted <= allowed:
raise ValueError('community.%s 里 %s 的体系不对: %r' % (field, name, sorted(wanted)))
loaded[name][field] |= wanted
result = {'featured': bonus['featured'], 'unique': tuple(bonus['unique']),
'recommend': bonus.get('recommend', 0), 'avoid': bonus.get('avoid', 0)}
return result, list(loaded.values())
def theme_pack_bonus(pack, system, bonus):
"""卡包对体系的加分(可以是负的)。
体系包给 featured 档, 有这个体系的专属饰品按件数给 unique 档, 社区推荐给 recommend 档, 取最大;
社区说这个体系走它不划算(avoid 里有这个体系)就不加; 速刷要避开的(avoid 里有 '*')再减 avoid。
打法指定的路线卡包(pack['route'] 是它的加分, 如兔子洞)最后算, 至少给这么多, 不受体系和 avoid 影响。
"""
score = bonus['featured'] if system in (pack.get('featured') or ()) else 0
count = (pack.get('unique') or {}).get(system, 0)
if count:
score = max(score, bonus['unique'][min(count, len(bonus['unique']) - 1)])
if system in (pack.get('recommend') or ()):
score = max(score, bonus.get('recommend', 0))
avoid = pack.get('avoid') or ()
if system in avoid:
score = min(score, 0)
if '*' in avoid:
score -= bonus.get('avoid', 0)
if pack.get('route'):
score = max(score, pack['route'])
return score
def _pack_text(text):
"""AALC find_str_in_text 的比较方式: 去空格、不分大小写。"""
return str(text).replace(' ', '').lower()
def boost_theme_pack_weights(weights, packs, system, bonus, language='zh_cn', hard_mode=None):
"""把体系加分加进 AALC 的卡包权重表。返回 (新表, {键: {packs, system, from, to}})。
hard_mode 给了(True/False)时, 只看这个难度会出现的卡包(表里 hard/normal 楼层不为空的): 活动专用包、
只在困难出现的复刻不会出现在普通模式, 不该拿来和同名短键的普通卡包「冲突」。
一个键会命中所有名字里含有它的卡包(AALC 的「谋杀」同时是 WARP快车谋杀案 原版和复刻), 所以键的加分
取这些卡包里离 0 最近的那个(都加分取最少的, 都减分取减得最少的); 有一个不变、或者有加有减, 就不动这个键,
免得连带改了别的卡包。某个卡包的分没被已有的键表达出来(复刻比原版多、或者 AALC 表里没有它)时,
再用卡包全名做键。原权重: 键在表里就用表里的; 全名键用这个卡包被 AALC 认成的那个键的分, 认不出来按
「未知」。改过分的键按长度从长到短排在最前面: AALC 按表的顺序取第一个命中的键, 全名(更具体)要先于短片段。
"""
field = 'en' if language == 'en' else 'zh'
unknown = next((weights[k] for k in THEME_PACK_UNKNOWN_KEYS if k in weights), -5)
if hard_mode is not None:
packs = [pack for pack in packs if pack.get('hard' if hard_mode else 'normal')]
scored = [(pack, theme_pack_bonus(pack, system, bonus), _pack_text(pack[field])) for pack in packs]
aalc_keys = [k for k in weights if k not in THEME_PACK_UNKNOWN_KEYS and _pack_text(k)]
def holders(key):
return [(pack, extra) for pack, extra, name in scored if _pack_text(key) in name]
def key_bonus(key):
extras = [extra for _, extra in holders(key)]
if extras and all(e > 0 for e in extras):
return min(extras)
if extras and all(e < 0 for e in extras):
return max(extras)
return 0
changed, info = {}, {}
def add(key, start, extra):
changed[key] = start + extra
info[key] = {'packs': [pack['zh'] for pack, _ in holders(key)], 'system': system,
'from': start, 'to': start + extra}
for key in aalc_keys:
extra = key_bonus(key)
if extra:
add(key, weights[key], extra)
for pack, extra, name in scored:
if not extra:
continue
own = [k for k in aalc_keys if _pack_text(k) in name]
if any(key_bonus(k) == extra for k in own):
continue # 已有的键已经表达了这个卡包的分
full = pack[field]
full_extra = key_bonus(full)
if full_extra and full not in changed:
add(full, weights.get(full, weights[own[0]] if own else unknown), full_extra)
ordered = sorted(changed, key=lambda k: -len(_pack_text(k)))
result = {k: changed[k] for k in ordered}
result.update((k, v) for k, v in weights.items() if k not in changed)
return result, {k: info[k] for k in ordered}
def install_theme_pack_systems(log=print, env=None, route=None, route_name='路线'):
"""镜牢选卡包时按当局体系给卡包加分。返回原 select_theme_pack, 未安装返回 None。
route 是打法指定的路线卡包 {中文名: 加分}(如兔子洞的 rabbit_hole.json theme_packs), 每个至少加这么多,
当局没有体系也照加。
"""
env = os.environ if env is None else env
setting = env.get(THEME_PACK_SYSTEMS_ENV, '').strip()
if setting == '0':
log('[lc_mcp] 卡包按体系加分已关闭(%s=0)' % THEME_PACK_SYSTEMS_ENV)
return None
path = setting or THEME_PACK_SYSTEMS_FILE
try:
bonus, packs = load_theme_pack_systems(path)
except (OSError, ValueError) as e:
log('[ERROR] [lc_mcp] 卡包体系表读不了(%s): %s, 卡包按 AALC 原权重选' % (path, e))
return None
route = dict(route or {})
if route:
known = {pack['zh'] for pack in packs}
missing = [name for name in route if name not in known]
if missing:
log('[ERROR] [lc_mcp] %s卡包不在卡包表里, 不加分: %s' % (route_name, '/'.join(missing)))
route = {name: extra for name, extra in route.items() if name in known}
packs = [dict(pack, route=route[pack['zh']]) if pack['zh'] in route else pack for pack in packs]
try:
import inspect
from tasks.mirror import mirror as mirror_mod
from tasks.mirror import select_theme_pack as theme_pack_mod
except Exception as e:
log('[lc_mcp] 卡包按体系加分跳过: 无法导入 %s' % e)
return None
original = getattr(mirror_mod, 'select_theme_pack', None)
theme_list = getattr(theme_pack_mod, 'theme_list', None)
try:
source = inspect.getsource(theme_pack_mod) # 上游装饰器没用 functools.wraps, 只能看整个模块
except (OSError, TypeError):
source = None
if original is None or theme_list is None or (
source is not None and 'theme_list.get_effective_theme_pack_list(' not in source):
log('[ERROR] [lc_mcp] 上游 select_theme_pack 不再从 theme_list.get_effective_theme_pack_list 取权重, '
'卡包按体系加分挂不上, 跳过')
return None
state = {'system': None}
original_init = mirror_mod.Mirror.__init__
def __init__(self, *args, **kwargs):
original_init(self, *args, **kwargs)
state['system'] = getattr(self, 'system', None)
def select_theme_pack(*args, **kwargs):
THEME_PACK_BOOSTED.clear()
system = state['system']
if system not in SYSTEM_TEAM_NAMES:
if not route:
return original(*args, **kwargs)
system = None # 没有体系: 只加路线分(体系包、专属饰品、社区推荐都按 None 算 0)
real = theme_list.get_effective_theme_pack_list
def get_effective_theme_pack_list(hard_mode, language, *more, **kw):
weights = real(hard_mode, language, *more, **kw)
try:
result, info = boost_theme_pack_weights(dict(weights), packs, system, bonus, language,
bool(hard_mode))
except Exception as e:
log('[lc_mcp] 卡包按体系加分出错(%s: %s), 用 AALC 原权重' % (type(e).__name__, e))
return weights
if info:
log('[lc_mcp] 卡包按体系 %s%s 加分: %s' % (
system or '(无)', ('+' + route_name) if route else '', ', '.join(
'%s %d→%d' % (key, item['from'], item['to']) for key, item in info.items())))
THEME_PACK_BOOSTED.update(info)
return result
with _override(theme_list, 'get_effective_theme_pack_list', get_effective_theme_pack_list):
return original(*args, **kwargs)
select_theme_pack.__wrapped__ = original
mirror_mod.Mirror.__init__ = __init__
mirror_mod.select_theme_pack = select_theme_pack
# 2026-11-16 用户要求: 卡包均分低就刷新。AALC 只在「最高分 < preferred_thresholds」时刷新,
# 而主题包表里 preferred_thresholds 是 0 → 0 分也当优选, 永远不刷新。
# 这里把它抬到 1(可用 LCP_THEME_PACK_THRESHOLD 调), 让"没有本体系卡包"的楼层先刷新(上游最多 3 次),
# 刷完仍不达标还是选最高分那一个。
try:
want = int((env.get(THEME_PACK_THRESHOLD_ENV) or '').strip() or 0) # 默认不改上游行为
except ValueError:
want = 0
try:
current = int(getattr(theme_list, 'preferred_thresholds', 0) or 0)
except (TypeError, ValueError):
current = 0
if want > current:
theme_list.preferred_thresholds = want
log('[lc_mcp] 卡包优选阈值 %d → %d(低于它先刷新卡包, 上游最多刷 3 次)'
% (current, want))
log('[lc_mcp] patch: 镜牢卡包按体系加分(%s, %d 个卡包%s)' % (
os.path.basename(path), len(packs),
', %s %s' % (route_name, ' '.join('%s+%d' % item for item in route.items())) if route else ''))
return original
# ---------------------------------------------------------------- 「获得E.G.O饰品」确认弹窗兜底
# ISSUES I-06(2026-11-14 18:45): 开局「获得E.G.O饰品」弹窗上 AALC 一直点确认模板的匹配点(模板是勾号,
# 1280x720 下约 (602,525)), 弹窗不关, 连点了 5 分钟; 手动点按钮中心 (640,530) 一次就过。
# 上游 select_init_ego_gift 的 loop_count 退出判断在循环底部, 点到确认就 continue, 永远走不到;
# 镜牢主循环点到确认也是 continue, 同样不减计数。所以兜底放在 click_element 这一层, 两处都管:
# 连续命中第 3 次起改点按钮中心, 连续 20 次还在就记 [ERROR] 结束任务。
GIFT_CONFIRM = 'mirror/road_in_mir/ego_gift_get_confirm_assets.png'
GIFT_CONFIRM_BUTTON_DX = 76 # 勾号模板中心 → 按钮中心的横向距离(1440 标定; 1280x720 实测 602 → 640)
GIFT_CONFIRM_SHIFT_AT = 3 # 连续第几次命中起改点按钮中心(正常一个弹窗点 1~2 次就关)
GIFT_CONFIRM_ENTER_AT = 8 # 软件点击也不关时, 第 8 次改发回车
GIFT_CONFIRM_LIMIT = 20 # 连续命中这么多次弹窗还在: 记 [ERROR] 并结束任务(卡住时约 1.5 秒一次)
GIFT_CONFIRM_GAP = 60 # 两次命中隔了这么多秒就不算连续
class TaskAbort(BaseException):
"""补丁判断再跑只会空转时抛出; aalc_task 在最外层接住, 记 [ERROR] 后按未完成退出。
不继承 Exception: AALC 的 onetime_mir_process 会吞掉 Exception 再开一局, 弹窗还在, 新的一局接着空转。
"""
# ---------------------------------------------------------------- 截图连续失败熔断
# 2026-11-16: 游戏窗口被最小化/关掉之后, AALC 每帧都在 cv2.matchTemplate 上抛
# 「corr.rows <= img.rows + templ.rows - 1」断言, 只记一条 ERROR 继续跑 —— 第 2 局
# 就这样空转 4.5 小时(68 次/秒), 直到手动停任务。这里统计"识别返回 None"(上游异常分支)的频率,
# 超过阈值就抛 TaskAbort 结束任务, 让 task_status 里能看见明确原因。
IMAGE_ERROR_WINDOW = 120 # 统计窗口(秒)
IMAGE_ERROR_LIMIT = 20 # 窗口内达到这个次数就熔断
def install_image_error_guard(log=print, clock=time.monotonic,
window=IMAGE_ERROR_WINDOW, limit=IMAGE_ERROR_LIMIT):
"""截图持续识别失败时结束任务。返回原 match_template, 未安装返回 None。"""
try:
from utils.image_utils import ImageUtils
except Exception as e:
log('[lc_mcp] 截图熔断跳过: 无法导入 %s' % e)
return None
original = getattr(ImageUtils, 'match_template', None)
if original is None:
log('[lc_mcp] 截图熔断跳过: ImageUtils 没有 match_template')
return None
state = {'times': []}
def match_template(screenshot, template, threshold, *args, **kwargs):
result = original(screenshot, template, threshold, *args, **kwargs)
if result is not None:
return result
now = clock()
times = state['times']
times.append(now)
cutoff = now - window
while times and times[0] < cutoff:
times.pop(0)
if len(times) >= limit:
log('[ERROR] [lc_mcp] %d 秒内 %d 次图片识别出错, 判定画面不可用, 结束任务'
% (window, len(times)))
decisions.record('image_error', None, 'abort', count=len(times))
raise TaskAbort('截图连续识别失败(%d 次/%d 秒), 游戏窗口可能被最小化或已关闭'
% (len(times), window))
return result
ImageUtils.match_template = staticmethod(match_template)
log('[lc_mcp] patch: 截图连续识别失败 %d 次/%d 秒即结束任务' % (limit, window))
return original
def install_gift_confirm_guard(log=print, clock=time.monotonic):
"""「获得E.G.O饰品」确认点了不关时换落点, 再不行就结束任务。返回原 click_element, 未安装返回 None。
"连续"= 中间没有别的 click_element 点成功过、确认也一直找得到。别的东西点成功、确认没找到、
或者隔了 GIFT_CONFIRM_GAP 秒, 都清零重新计。
"""
try:
from module.automation import auto
from module.config import cfg
except Exception as e:
log('[lc_mcp] 饰品确认兜底跳过: 无法导入 %s' % e)
return None
real_click = getattr(auto, 'click_element', None)
if real_click is None:
log('[lc_mcp] 饰品确认兜底跳过: auto 没有 click_element')
return None
state = {'streak': 0, 'last': None}
def click_element(target, *args, **kwargs):
lookup_only = kwargs.get('click') is False
if target != GIFT_CONFIRM or lookup_only:
result = real_click(target, *args, **kwargs)
if result and not lookup_only:
state['streak'] = 0
return result
now = clock()
if state['last'] is not None and now - state['last'] > GIFT_CONFIRM_GAP:
state['streak'] = 0
shifting = state['streak'] + 1 >= GIFT_CONFIRM_SHIFT_AT
result = real_click(target, *args, **(dict(kwargs, click=False) if shifting else kwargs))
if not result:
state['streak'] = 0
return result
state['streak'] += 1
state['last'] = now
streak = state['streak']
if not shifting:
return result
if streak >= GIFT_CONFIRM_LIMIT:
log('[ERROR] [lc_mcp] 「获得E.G.O饰品」确认连点 %d 次弹窗还在, 结束任务(免得空转到超时)' % streak)
decisions.record('gift_confirm', None, 'stuck', clicks=streak)
raise TaskAbort('「获得E.G.O饰品」弹窗关不掉(连点 %d 次)' % streak)
x = int(round(result[0] + GIFT_CONFIRM_BUTTON_DX * cfg.set_win_size / 1440))
y = int(round(result[1]))
if streak == GIFT_CONFIRM_SHIFT_AT:
log('[lc_mcp] 「获得E.G.O饰品」确认点了 %d 次还在, 改点按钮中心 (%d,%d)' % (streak - 1, x, y))
decisions.record('gift_confirm', 'button_center', 'repeated', clicks=streak - 1)
# 2026-11-15 实测: 罗技驱动的物理点击(即使挪开 10px 再回来)在这个弹窗上仍然无效,
# 同一坐标改用 pyautogui 的软件点击一次就过。所以这里绕过驱动代理, 直接调底层 handler。
if streak >= GIFT_CONFIRM_SHIFT_AT:
handler = getattr(auto, 'input_handler', None)
inner = getattr(handler, '_handler', None)
if inner is not None and hasattr(inner, 'mouse_click'):
inner.mouse_click(x, y)
decisions.record('gift_confirm', 'software_click', 'driver_bypass', clicks=streak)
else:
auto.mouse_click(x, y)
else:
auto.mouse_click(x, y)
if streak == GIFT_CONFIRM_ENTER_AT:
# 软件点击也不行就发一次回车: 该弹窗的「确认」是默认焦点
log('[lc_mcp] 「获得E.G.O饰品」软件点击也没关, 发一次回车')
try:
auto.key_press('enter')
except Exception as e:
log('[lc_mcp] 回车兜底失败: %s' % e)
decisions.record('gift_confirm', 'enter', 'fallback', clicks=streak)
return True
click_element.__wrapped__ = real_click
auto.click_element = click_element
log('[lc_mcp] patch: 「获得E.G.O饰品」确认连点不关时改点按钮中心, %d 次还在就结束任务' % GIFT_CONFIRM_LIMIT)
return real_click
# ---------------------------------------------------------------- 按键: 带扫描码、按住再松开
# ISSUES I-05: 2026-11-14 镜牢键盘寻路 24/24 没进去(旧版只按 ↑ 也是 32/32)。AALC 前台模式的 key_press
# 是 pyautogui.press: keybd_event 的扫描码填 0、方向键不带扩展键标志, 按下抬起紧挨着。上游在后台模式的
# _make_key_lparam 注释里写了"Unity 6+ 会校验 scan code 和 extended flag", 本仓库 aalc_engine 也记过
# Unity 会吞掉同一帧里的 down/up。这里把前台按键换成带扫描码和扩展键标志的 keybd_event,
# 各模式都按住 KEY_HOLD 秒再松开。
KEY_HOLD = 0.12 # 与 aalc_engine 的 key 工具一致
KEY_HOLD_ENV = 'LCP_KEY_HOLD' # 0 = 不装, 按键完全走 AALC 原逻辑
KEYEVENTF_EXTENDEDKEY = 0x0001
KEYEVENTF_KEYUP = 0x0002
MAPVK_VK_TO_VSC = 0
def press_vk(user32, vk, extended, hold=KEY_HOLD):
"""向前台窗口按一次键: keybd_event 带扫描码(方向键等再带扩展键标志), 按住 hold 秒再松开。"""
scan = user32.MapVirtualKeyW(vk, MAPVK_VK_TO_VSC) & 0xFF
flags = KEYEVENTF_EXTENDEDKEY if extended else 0
user32.keybd_event(vk, scan, flags, 0)
try:
time.sleep(hold)
finally:
user32.keybd_event(vk, scan, flags | KEYEVENTF_KEYUP, 0)
return scan
def install_key_hold(log=print, env=None, user32=None):
"""改 AALC 各 Windows 输入后端的 key_press。返回 {类名: 原 key_press}, 未安装返回 None。
前台(Input): 先确认游戏窗口在前台(不在就激活一次, 还不在就不发, 免得按到别的程序里),
再用 press_vk 发。后台(BackgroundInput / WindowMoveInput): 仍用上游自己的 key_down/key_up
消息(扫描码上游已经填对), 只在中间按住 KEY_HOLD 秒。不认识的键名交回原逻辑。模拟器不动。
"""
env = os.environ if env is None else env
if env.get(KEY_HOLD_ENV) == '0':
log('[lc_mcp] 按键补丁已关闭(%s=0), 按键走 AALC 原逻辑' % KEY_HOLD_ENV)
return None
try:
from module.automation.input_handlers import input as input_mod
from module.game_and_screen import screen
except Exception as e:
log('[lc_mcp] 按键补丁跳过: 无法导入 %s' % e)
return None
key_list = getattr(input_mod, 'key_list', None)
extended_vks = getattr(input_mod, 'EXTENDED_KEY_VKS', None)
if not key_list or extended_vks is None:
log('[lc_mcp] 按键补丁跳过: 上游没有 key_list / EXTENDED_KEY_VKS')
return None
originals = {}
foreground = getattr(input_mod, 'Input', None)
if foreground is not None:
original_fg = foreground.key_press
if _source_mentions(original_fg, 'pyautogui.press') is False:
log('[ERROR] [lc_mcp] 按键补丁: 上游前台 Input.key_press 不再用 pyautogui.press, 挂不上, 前台按键照旧')
else:
if user32 is None:
import ctypes
user32 = ctypes.windll.user32
def key_press(self, key):
name = str(key).lower()
vk = key_list.get(name)
if vk is None:
return original_fg(self, key)
handle = screen.handle
if not handle.isActive:
try:
handle.setForeground()
except Exception as e:
log('[lc_mcp] 按键前激活游戏窗口出错: %s: %s' % (type(e).__name__, e))
time.sleep(0.15)
if not handle.isActive:
log('[lc_mcp] 按键 %s 没发: 游戏窗口不在前台(避免按到别的程序里)' % name)
return None
press_vk(user32, vk, vk in extended_vks)
return None
key_press.__wrapped__ = original_fg
foreground.key_press = key_press
originals['Input'] = original_fg
for name in ('BackgroundInput', 'WindowMoveInput'):
cls = getattr(input_mod, name, None)
if cls is None or not all(hasattr(cls, m) for m in ('set_active', 'key_down', 'key_up')):
continue
original_bg = cls.key_press
def key_press(self, key, _original=original_bg):
if str(key).lower() not in key_list:
return _original(self, key)
self.set_active()
self.key_down(key)
try:
time.sleep(KEY_HOLD)
finally:
self.key_up(key)
key_press.__wrapped__ = original_bg
cls.key_press = key_press
originals[name] = original_bg
if not originals:
log('[lc_mcp] 按键补丁跳过: 没有可改的 Windows 输入后端')
return None
log('[lc_mcp] patch: 按键按住 %dms 再松开, 前台改发带扫描码的按键(%s)'
% (KEY_HOLD * 1000, '/'.join(sorted(originals))))
return originals
# ---------------------------------------------------------------- 镜牢「兔子洞」速刷: 每回合给浮士德放「空洞」
# 「兔子洞」(英文社区 Mao Hollow Faust) = 黑兽 - 卯 魁首 浮士德 + 浮士德的 E.G.O「空洞」。游戏数据(零协 2026111301):
# 普通「空洞」不打敌人, 只给自己叠 5 发弹孔; 弹孔不低于 1 发时改用「填补空洞」(大伤害); 侵蚀「空洞」随机打人。
# E.G.O 被动: 弹孔满 5 发时「空洞」(觉醒、侵蚀)不耗 E.G.O 资源, 每回合开始 +1 发。攻略(OurPlay 777774): 每场第一回合
# 超频(强制用侵蚀技能)直接清场。AALC 战斗只会 P+Enter, 不会放 E.G.O。游戏教程: 按住罪人的头像打开 E.G.O 列表
# (wiki.gg 写的是按住技能格), 单击 E.G.O 是普通放, 长按 E.G.O 是超频。完整依据见 docs/feedback/2026-11-15/RABBIT-HOLE.md。
RABBIT_HOLE_FILE = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'data', 'rabbit_hole.json')
RABBIT_HOLE_POPUP_WAIT = 0.6 # 长按松开后等 E.G.O 列表弹出
RABBIT_HOLE_SETTLE = 0.4 # 点完 E.G.O 等界面刷新
def load_rabbit_hole(path=RABBIT_HOLE_FILE):
"""读兔子洞配置; 格式不对抛 ValueError。"""
with open(path, encoding='utf-8') as fh:
data = json.load(fh)
if not isinstance(data, dict):
raise ValueError('配置必须是 JSON 对象')
def names(field):
value = data.get(field)
if not isinstance(value, list) or not value or \
not all(isinstance(v, str) and normalize_team_name(v) for v in value):
raise ValueError('%s 必须是非空字符串列表' % field)
return tuple(normalize_team_name(v) for v in value)
press_at = data.get('press_at')
if press_at is not None:
if not isinstance(press_at, list) or len(press_at) != 2 or \
not all(isinstance(v, (int, float)) and 0 < v < 1 for v in press_at):
raise ValueError('press_at 必须是 null 或 [宽比例, 高比例], 都在 0~1 之间')
press_at = (float(press_at[0]), float(press_at[1]))
hold = data.get('hold_seconds', 1.0)
if isinstance(hold, bool) or not isinstance(hold, (int, float)) or not 0.2 <= hold <= 5:
raise ValueError('hold_seconds 必须在 0.2~5 秒之间')
overclock = data.get('overclock_first_turn', False)
if not isinstance(overclock, bool):
raise ValueError('overclock_first_turn 必须是 true/false')
packs = data.get('theme_packs', {})
if not isinstance(packs, dict) or not all(
isinstance(k, str) and k.strip() and not isinstance(v, bool) and isinstance(v, int) and 0 < v <= 50
for k, v in packs.items()):
raise ValueError('theme_packs 必须是 {卡包中文名: 加分(1~50 的整数)}')
return {'team_names': names('team_names'), 'ego_names': names('ego_names'),
'press_at': press_at, 'hold_seconds': float(hold), 'overclock_first_turn': overclock,
'theme_packs': {k.strip(): v for k, v in packs.items()}}
def find_ego_option(lines, ego_names, near=None):
"""OCR 逐行结果里找 E.G.O 名字(归一后完全相等); 有几条取离长按点最近的。返回 (文本, x, y) 或 None。"""
hits = [(text, x, y) for text, x, y in lines if normalize_team_name(text) in ego_names]
if not hits:
return None
if near is None:
return hits[0]
return min(hits, key=lambda hit: (hit[1] - near[0]) ** 2 + (hit[2] - near[1]) ** 2)
def rabbit_hole_turn(auto, cfg, config, log=print, overclock=False):
"""接管一回合: P → 长按浮士德(press_at)打开 E.G.O 列表 → 选「空洞」→ Enter。
overclock=True 时长按 E.G.O 卡片(超频: 1.5 倍资源和理智, 强制用侵蚀技能), 否则单击。
返回结果: ego / overclock / ego_unavailable / no_option。
按过 P 就一定按 Enter(中途出错也一样): 交回 AALC 会再按一次 P, 而 P 是在胜率/伤害之间切换。
"""
width, height = cfg.set_win_size * 16 / 9, cfg.set_win_size
x, y = config['press_at'][0] * width, config['press_at'][1] * height
names = config['ego_names']
result = 'no_option'
auto.key_press('p')
try:
time.sleep(0.5)
auto.mouse_drag(x, y, drag_time=config['hold_seconds'], dx=0, dy=0)
time.sleep(RABBIT_HOLE_POPUP_WAIT)
auto.take_screenshot()
lines = _ocr_lines(auto)
hit = find_ego_option(lines, names, near=(x, y))
if hit is None:
log('[lc_mcp] 兔子洞: 长按 (%d,%d) 后没找到 E.G.O「%s」; 这一屏: %s'
% (x, y, '/'.join(names), '/'.join(str(t) for t, _, _ in lines[:20]) or '(空)'))
else:
if overclock:
auto.mouse_drag(hit[1], hit[2], drag_time=config['hold_seconds'], dx=0, dy=0)
else:
auto.mouse_click(hit[1], hit[2])
time.sleep(RABBIT_HOLE_SETTLE)
auto.take_screenshot()
if find_ego_option(_ocr_lines(auto), names) is None:
result = 'overclock' if overclock else 'ego'
else:
result = 'ego_unavailable' # 列表还开着: 资源不够(灰的)或没点上
log('[lc_mcp] 兔子洞: %s「%s」后列表还在(可能 E.G.O 资源不够), 这回合按胜率打'
% ('长按' if overclock else '点了', hit[0]))
if result not in ('ego', 'overclock'):
auto.mouse_click_blank() # 关掉弹出的列表
time.sleep(RABBIT_HOLE_SETTLE)
finally:
auto.key_press('enter')
decisions.record('battle', 'hollow', result)
return result
def install_rabbit_hole(log=print, config=None):
"""镜牢战斗每回合给浮士德放「空洞」。返回原 Battle._battle_operation, 未安装返回 None。"""
try:
config = config or load_rabbit_hole()
except (OSError, ValueError) as e:
log('[ERROR] [lc_mcp] 兔子洞配置读不了(%s): %s' % (RABBIT_HOLE_FILE, e))
return None
try:
from tasks.battle.battle import Battle
from module.automation import auto
from module.config import cfg
except Exception as e:
log('[lc_mcp] 兔子洞补丁跳过: 无法导入 %s' % e)
return None
original = getattr(Battle, '_battle_operation', None)
if original is None or _source_mentions(original, 'auto.key_press("p")', 'auto.key_press("enter")') is False:
log('[ERROR] [lc_mcp] 上游 Battle._battle_operation 不再是 P+Enter 出手, 兔子洞补丁挂不上, 跳过')
return None
state = {'warned': False}
overclock = config.get('overclock_first_turn', False)
signature = None
if overclock:
import inspect
try:
signature = inspect.signature(original)
except (TypeError, ValueError):
signature = None
if signature is None or 'first_turn' not in signature.parameters:
log('[ERROR] [lc_mcp] 上游 Battle._battle_operation 没有 first_turn 参数, 兔子洞第一回合不超频, 只放普通「空洞」')
overclock = False
def first_turn(self, args, kwargs):
try:
return bool(signature.bind(self, *args, **kwargs).arguments.get('first_turn'))
except TypeError:
return False
def _battle_operation(self, *args, **kwargs):
if config['press_at'] is None:
if not state['warned']:
state['warned'] = True
log('[ERROR] [lc_mcp] 兔子洞: rabbit_hole.json 的 press_at 还没在实机上量, 本次按 AALC 原来的 P+Enter 打')
return original(self, *args, **kwargs)
try:
rabbit_hole_turn(auto, cfg, config, log=log,
overclock=overclock and first_turn(self, args, kwargs))
except InterruptedError:
raise # AALC 的暂停/停止
except Exception as e: # Enter 已经在 rabbit_hole_turn 的 finally 里按过, 这回合照常打
log('[lc_mcp] 兔子洞: 这回合出错(%s: %s), 已按 Enter' % (type(e).__name__, e))
return False # 上游的返回值是「小指良单通的连续防御是否执行」
_battle_operation.__wrapped__ = original
Battle._battle_operation = _battle_operation
log('[lc_mcp] patch: 镜牢兔子洞: 每回合给浮士德放 E.G.O「%s」%s(%s)'
% ('/'.join(config['ego_names']), ', 每场第一回合超频' if overclock else '',
'长按点未校准, 先按 P+Enter' if config['press_at'] is None else '长按 %.3f,%.3f' % config['press_at']))
return original
+50 -7
View File
@@ -11,11 +11,14 @@ import sys
from . import killswitch, preflight from . import killswitch, preflight
from .aalc_engine import bootstrap from .aalc_engine import bootstrap
from .aalc_patches import (WindowGuard, driver_click_tasks, headless_hdr_warning, 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_default_battle_team, install_event_choices, install_exact_team_match,
install_gift_preference, install_robust_set_foreground, install_shop_audit, install_gift_confirm_guard, install_gift_preference, install_image_error_guard, install_key_hold,
install_shop_by_name, install_system_team_selection, install_theme_pack_audit, install_robust_set_foreground, install_shop_audit, install_shop_by_name,
install_typed_keyboard_road, mirror_progress, stop_driver_click) 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 .decisions import decisions
from .game_lock import GameBusyError, exclusive_game from .game_lock import GameBusyError, exclusive_game
@@ -27,6 +30,10 @@ TASKS = {
'enkephalin': {'times': 'set_lunacy_to_enkephalin'}, 'enkephalin': {'times': 'set_lunacy_to_enkephalin'},
'mirror': {'count': 'set_mirror_count'}, 'mirror': {'count': 'set_mirror_count'},
} }
# 任务 -> {选项名: 允许的值}; 不对应 AALC 配置项, 只决定本次装哪些补丁
TASK_OPTIONS = {
'mirror': {'strategy': ('rabbit_hole',)}, # rabbit_hole: 兔子洞速刷, 见 lc_mcp/data/rabbit_hole.json
}
# 用户给了镜牢次数时一并临时关闭的配置: 开着无限刷牢, AALC 会把次数改成 9999 # 用户给了镜牢次数时一并临时关闭的配置: 开着无限刷牢, AALC 会把次数改成 9999
EXPLICIT_COUNT_OVERRIDES = {'mirror': {'count': {'infinite_dungeons': False}}} EXPLICIT_COUNT_OVERRIDES = {'mirror': {'count': {'infinite_dungeons': False}}}
RESTORE_ENV = 'LCP_RESTORE_FILE' RESTORE_ENV = 'LCP_RESTORE_FILE'
@@ -102,7 +109,23 @@ def run(task, params):
return PREFLIGHT_EXIT 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): 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() bootstrap()
from module.automation import auto from module.automation import auto
from module.config import cfg from module.config import cfg
@@ -123,19 +146,30 @@ def _run(task, params):
decisions.open() # TaskRunner 给的 .decisions.jsonl; 直接运行时不写 decisions.open() # TaskRunner 给的 .decisions.jsonl; 直接运行时不写
install_exact_team_match(auto, log) install_exact_team_match(auto, log)
install_robust_set_foreground(screen, log=log) install_robust_set_foreground(screen, log=log)
if not cfg.simulator:
install_key_hold(log=log) # 前台按键带扫描码、各模式按住再松开(ISSUES I-05)
# 日常本(经验/纽本)不翻队伍列表: 队伍是自定义名字时按名字找必然失败, # 日常本(经验/纽本)不翻队伍列表: 队伍是自定义名字时按名字找必然失败,
# 白等 60 秒还会把界面滚乱, 后面 to_battle 就找不到 "进入战斗" 了。 # 白等 60 秒还会把界面滚乱, 后面 to_battle 就找不到 "进入战斗" 了。
if task in ('daily', 'all'): if task in ('daily', 'all'):
install_default_battle_team(scheme, log=log) install_default_battle_team(scheme, log=log)
# 镜牢: 编队是自定义名字(体系名), AALC 只会找 "编队#N"; 改成按体系名点选。 # 镜牢: 编队是自定义名字(体系名), AALC 只会找 "编队#N"; 改成按体系名点选。
if task in ('mirror', 'all'): if task in ('mirror', 'all'):
install_system_team_selection(log=log) 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_typed_keyboard_road(log=log)
install_gift_preference(log=log) install_gift_preference(log=log)
install_event_choices(log=log) install_event_choices(log=log)
install_shop_audit(log=log) install_shop_audit(log=log)
install_shop_by_name(log=log) # 装在审计之后(包在外层), 审计才看得到按名字点的那一下 install_shop_by_name(log=log) # 装在审计之后(包在外层), 审计才看得到按名字点的那一下
install_theme_pack_audit(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 = WindowGuard(screen, cfg, log=log)
guard.start() guard.start()
restore_path = os.environ.get(RESTORE_ENV) restore_path = os.environ.get(RESTORE_ENV)
@@ -163,6 +197,9 @@ def _run(task, params):
'mirror': scheme.Mirror_task, 'mirror': scheme.Mirror_task,
}[task]() }[task]()
return mirror_result(task, progress) return mirror_result(task, progress)
except TaskAbort as e:
log('[ERROR] [lc_mcp] 任务中止: %s' % e)
return INCOMPLETE_EXIT
finally: finally:
guard.stop() guard.stop()
retry_monitor.stop() retry_monitor.stop()
@@ -179,10 +216,16 @@ def main(argv):
return 2 return 2
task = argv[1] task = argv[1]
params = json.loads(argv[2]) if len(argv) > 2 else {} 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: if unknown:
print('unknown params for %s: %s' % (task, ', '.join(sorted(unknown))), file=sys.stderr) print('unknown params for %s: %s' % (task, ', '.join(sorted(unknown))), file=sys.stderr)
return 2 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) print('[lc_mcp] task %s start %s' % (task, json.dumps(params)), flush=True)
code = run(task, params) code = run(task, params)
if code: if code:
+13 -2
View File
@@ -4,9 +4,11 @@
"认事件: options 里的每一句都出现在这一屏的选项里, 才算这个事件(按表顺序, 先命中的生效); 然后点包含 text 的那一项。", "认事件: options 里的每一句都出现在这一屏的选项里, 才算这个事件(按表顺序, 先命中的生效); 然后点包含 text 的那一项。",
"零协汉化的事件数据没有标题字段, 画面上也不保证有事件名, 所以不按事件名认; name 只用于日志。", "零协汉化的事件数据没有标题字段, 画面上也不保证有事件名, 所以不按事件名认; name 只用于日志。",
"文字都先归一再比较: 去空白、全角转半角、去标点、改回常见误读。整表关闭: 任务环境变量 LCP_EVENT_CHOICES=0。", "文字都先归一再比较: 去空白、全角转半角、去标点、改回常见误读。整表关闭: 任务环境变量 LCP_EVENT_CHOICES=0。",
"id 是零协汉化 LLC_zh-CN/ActionEvents_*.json 里的事件 id; options/text 照抄那里的选项原文(2026-11-14 核对 LocalizeLimbusCompany@231a8bc)。", "id 是零协汉化 LLC_zh-CN/ActionEvents_*.json 里的事件 id; options/text 照抄那里的选项原文(2026-11-15 按本机装的 release 2026111301 核对)。",
"同一套选项在别的文件里有复刻(如 ActionEvents.json 910301/910302 与地狱鸡两条选项、结果都相同)时会一起命中, 选的是同一项。",
"check=true 表示选了之后还要罪人判定(由 AALC 原逻辑挑成功率最高的人格); 其余都是无判定、无战斗的直出。", "check=true 表示选了之后还要罪人判定(由 AALC 原逻辑挑成功率最高的人格); 其余都是无判定、无战斗的直出。",
"选择依据: docs/skills/limbus-mirror-speedrun/references/event-choices.md(依据边狱公司中文 Wiki 社区「探索事件」, CC BY-SA 4.0)。", "选择依据: 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)。" "选项原文来自零协汉化 LocalizeLimbusCompany(https://github.com/LocalizeLimbusCompany/LocalizeLimbusCompany, CC BY-NC-SA 4.0)。"
], ],
"events": [ "events": [
@@ -27,6 +29,15 @@
"note": "两项都是判定: 1 忧郁/色欲(门槛 16), 2 忧郁/怠惰(门槛 14, 成功获得打击饰品); AALC 不区分两项, 点它认出的那个优势判定"}, "note": "两项都是判定: 1 忧郁/色欲(门槛 16), 2 忧郁/怠惰(门槛 14, 成功获得打击饰品); AALC 不区分两项, 点它认出的那个优势判定"},
{"name": "破碎罗盘(冻僵的尸体指路)", "id": 901095, "file": "ActionEvents_Mirror3.json", {"name": "破碎罗盘(冻僵的尸体指路)", "id": 901095, "file": "ActionEvents_Mirror3.json",
"options": ["向裂开的手所指的北方。", "向警告的手所指的东方。", "向折断的手所指的西方。"], "text": "返回。", "options": ["向裂开的手所指的北方。", "向警告的手所指的东方。", "向折断的手所指的西方。"], "text": "返回。",
"note": "第 4 项直接结束; 其余方向都还有后续分支"} "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 理智"}
] ]
} }
+21
View File
@@ -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}
}
+8
View File
@@ -0,0 +1,8 @@
{
"_说明": [
"体系 -> 优先队名(按顺序试), 覆盖 SYSTEM_TEAM_NAMES 里的默认名。2026-11-16 用户指定: 走震颤队, 不要再选镜像迷宫。",
"改名或换队就改这里; 整表关闭: 任务环境变量 LCP_TEAM_NAMES=0。",
"体系本身跟着 config.yaml 的 team_system 走(现在 = 2 震颤), 商店/饰品的体系判断也按它。"
],
"tremor": ["震颤"]
}
+175
View File
@@ -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": {}}
]
}
+35 -1
View File
@@ -33,6 +33,20 @@ SPI_GETMOUSESPEED = 0x0070
DEFAULT_DLL = r'E:\罗技键鼠驱动\logitech.driver.dll' 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): class Cursor(ctypes.Structure):
_fields_ = [('x', ctypes.c_long), ('y', ctypes.c_long)] _fields_ = [('x', ctypes.c_long), ('y', ctypes.c_long)]
@@ -118,6 +132,7 @@ class DriverInput:
self._stopped = False self._stopped = False
self._input_lock = threading.RLock() self._input_lock = threading.RLock()
self._pressed = set() self._pressed = set()
self._last_click = None # 上一次点击的屏幕坐标: 原地连点时才做抖动
# 目标窗口句柄。有它才能做句柄级前台校验 —— 几何校验在窗口重叠时没用: # 目标窗口句柄。有它才能做句柄级前台校验 —— 几何校验在窗口重叠时没用:
# 实测把浏览器切到前台, 点游戏里同一个坐标, 只比矩形的话校验照样通过。 # 实测把浏览器切到前台, 点游戏里同一个坐标, 只比矩形的话校验照样通过。
self.hwnd = 0 self.hwnd = 0
@@ -220,7 +235,7 @@ class DriverInput:
self._pressed.discard(int(button)) self._pressed.discard(int(button))
def click(self, sx, sy, times=1, tol=1, require_foreground=True, def click(self, sx, sy, times=1, tol=1, require_foreground=True,
press_ms=60, settle=0.05): press_ms=None, settle=None, wiggle=None):
"""先确认到位置, 再按下抬起。 """先确认到位置, 再按下抬起。
⛔ 三个已验证的"位置对却点不上"原因(2026-10-23 实测): ⛔ 三个已验证的"位置对却点不上"原因(2026-10-23 实测):
@@ -232,9 +247,28 @@ class DriverInput:
所以定位成功后先 settle 再按。 所以定位成功后先 settle 再按。
3. **按下时间太短** —— 默认 30ms 在掉帧时会漏; 改成 60ms。 3. **按下时间太短** —— 默认 30ms 在掉帧时会漏; 改成 60ms。
实测 30/60/120ms 在干净环境下都能中, 但 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: if not self.ready:
return False 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): if not self.move_to(sx, sy, tol=tol):
cx, cy = get_cursor() cx, cy = get_cursor()
self.log('[driver] 定位失败: 目标(%d,%d) 实际(%d,%d), 不点击' self.log('[driver] 定位失败: 目标(%d,%d) 实际(%d,%d), 不点击'
+15 -3
View File
@@ -6,7 +6,7 @@ import threading
import time import time
from . import VERSION from . import VERSION
from .aalc_task import TASKS from .aalc_task import TASK_OPTIONS, TASKS
from .engine import find_hits from .engine import find_hits
MAX_WAIT = 300.0 MAX_WAIT = 300.0
@@ -83,9 +83,14 @@ TOOLS = [
'传 count 时本次临时关闭 AALC 无限刷牢,结束后恢复;完成局数不足时任务报 failed。' '传 count 时本次临时关闭 AALC 无限刷牢,结束后恢复;完成局数不足时任务报 failed。'
'只刷一种日常时把另一种次数显式设为0,省略次数沿用配置。' '只刷一种日常时把另一种次数显式设为0,省略次数沿用配置。'
'all 需明确要求全部任务;enkephalin 需明确授权花狂气,免费合成模块不能用它。' 'all 需明确要求全部任务;enkephalin 需明确授权花狂气,免费合成模块不能用它。'
'任务运行期间禁止手动点击类工具;最终 succeeded 也要检查 errors,用户停止后不自动重跑。'), '任务运行期间禁止手动点击类工具;最终 succeeded 也要检查 errors,用户停止后不自动重跑。'
'mirror 可加 strategy="rabbit_hole":兔子洞速刷(黑兽-卯 浮士德每回合放 E.G.O「空洞」,每场第一回合超频),'
'编队、长按点、路线卡包见 lc_mcp/data/rabbit_hole.json。'),
'inputSchema': _obj({'task': {'type': 'string', 'enum': sorted(TASKS)}, 'inputSchema': _obj({'task': {'type': 'string', 'enum': sorted(TASKS)},
'exp': _NUM, 'thread': _NUM, 'times': _NUM, 'count': _NUM}, ['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 前检查占用,启动后轮询此工具监控,避免逐帧截图和重复启动。' {'name': 'task_status', 'description': '启动 run_task 前检查占用,启动后轮询此工具监控,避免逐帧截图和重复启动。'
'返回 idle/running/succeeded/failed/stopped、日志及异常;' '返回 idle/running/succeeded/failed/stopped、日志及异常;'
'decisions.counts 按阶段统计选队/寻路/卡包/饰品/事件/商店的决策理由。' 'decisions.counts 按阶段统计选队/寻路/卡包/饰品/事件/商店的决策理由。'
@@ -158,6 +163,13 @@ class Server:
if task not in TASKS: if task not in TASKS:
raise ValueError('unknown task %r' % task) raise ValueError('unknown task %r' % task)
params = {k: int(a[k]) for k in TASKS[task] if a.get(k) is not None} 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(). # Starting must not race a click that has already checked running().
# Reject promptly when busy instead of waiting behind a long OCR poll. # Reject promptly when busy instead of waiting behind a long OCR poll.
if not self.lock.acquire(blocking=False): if not self.lock.acquire(blocking=False):
+157
View File
@@ -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:]))
+3 -1
View File
@@ -375,9 +375,11 @@ class DriverFailureTest(unittest.TestCase):
drv._dll.mouse_up.assert_called_with(1) drv._dll.mouse_up.assert_called_with(1)
self.assertFalse(drv.ready) self.assertFalse(drv.ready)
self.assertFalse(drv.click(30, 40)) 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.move_relative(20, 30))
self.assertFalse(drv.down()) self.assertFalse(drv.down())
drv._dll.moveR.assert_not_called() self.assertEqual(drv._dll.moveR.call_count, moves)
self.assertEqual(drv._pressed, set()) self.assertEqual(drv._pressed, set())
def test_release_even_if_sleep_is_interrupted(self): def test_release_even_if_sleep_is_interrupted(self):
+261
View File
@@ -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()
+82
View File
@@ -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))
+211
View File
@@ -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()
+23 -3
View File
@@ -9,7 +9,9 @@ import sys
import tempfile import tempfile
import threading import threading
import time import time
import types
import unittest import unittest
from types import SimpleNamespace
from unittest import mock from unittest import mock
REPO = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) REPO = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
@@ -189,6 +191,17 @@ class ProtocolTest(unittest.TestCase):
self.assertTrue(call(self.s, 'click', x=1, y=1)['ok']) self.assertTrue(call(self.s, 'click', x=1, y=1)['ok'])
self.assertFalse(call(self.s, 'run_task', task='bogus')['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): def test_task_exit_codes(self):
self.tasks.argv_factory = lambda t, p: [sys.executable, '-c', 'import sys; sys.exit(3)'] self.tasks.argv_factory = lambda t, p: [sys.executable, '-c', 'import sys; sys.exit(3)']
call(self.s, 'run_task', task='reward') call(self.s, 'run_task', task='reward')
@@ -387,12 +400,19 @@ class RuntimeTest(unittest.TestCase):
mock.patch('lc_mcp.aalc_engine.time.sleep', side_effect=[None, RuntimeError('interrupted')]): mock.patch('lc_mcp.aalc_engine.time.sleep', side_effect=[None, RuntimeError('interrupted')]):
with self.assertRaises(RuntimeError): with self.assertRaises(RuntimeError):
engine.click(100, 200) engine.click(100, 200)
with mock.patch.dict(sys.modules, pyautogui=pointer), \ user32 = mock.Mock()
mock.patch('lc_mcp.aalc_engine.time.sleep', side_effect=RuntimeError('interrupted')): 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): with self.assertRaises(RuntimeError):
engine.keypress('enter') engine.keypress('enter')
pointer.mouseUp.assert_called_once_with(580, 657) 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): def test_foreground_move_settle_failure_sends_no_button_press(self):
from lc_mcp.aalc_engine import AalcEngine from lc_mcp.aalc_engine import AalcEngine
+342
View File
@@ -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()
+272 -4
View File
@@ -29,6 +29,16 @@ class SystemTeamNamesTest(unittest.TestCase):
self.assertIn('呼吸法', aalc_patches.SYSTEM_TEAM_NAMES['poise']) self.assertIn('呼吸法', aalc_patches.SYSTEM_TEAM_NAMES['poise'])
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): class RegionTest(unittest.TestCase):
@@ -167,7 +177,7 @@ class PickTeamItemTest(unittest.TestCase):
class _FakeTeamScreen: class _FakeTeamScreen:
"""编队界面: 列表按 3 次下拖翻一屏, 点哪条顶栏就变成哪条。""" """编队界面: 每下拖一次翻一屏(实测一次拖动 ≈ 5~6 行), 点哪条顶栏就变成哪条。"""
def __init__(self, screens, header='剧情关卡', click_changes_header=True): def __init__(self, screens, header='剧情关卡', click_changes_header=True):
self.screens = screens self.screens = screens
@@ -178,7 +188,7 @@ class _FakeTeamScreen:
@property @property
def page(self): def page(self):
return min(self.swipes_down // 3, len(self.screens) - 1) return min(self.swipes_down, len(self.screens) - 1)
def take_screenshot(self): def take_screenshot(self):
return object() return object()
@@ -273,13 +283,25 @@ class SelectTeamByNameTest(unittest.TestCase):
self.assertTrue(self.select(auto, ('流血',))) self.assertTrue(self.select(auto, ('流血',)))
self.assertEqual(auto.header, '流血') 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): def test_missing_team_logs_every_screen_and_never_clicks(self):
auto = _FakeTeamScreen([self.TOP, self.MIDDLE, self.BOTTOM]) auto = _FakeTeamScreen([self.TOP, self.MIDDLE, self.BOTTOM])
self.assertFalse(self.select(auto, ('编队#999',))) self.assertFalse(self.select(auto, ('编队#999',)))
self.assertEqual(auto.clicks, []) self.assertEqual(auto.clicks, [])
self.assertIn('第 1 屏没有 编队#999; 这一屏的名字: 剧情关卡/斩击/突刺/打击/烧伤', self.log) self.assertIn('第 1 屏没有 编队#999; 这一屏的名字: 剧情关卡/斩击/突刺/打击/烧伤', self.log)
self.assertIn('第 3 屏没有 编队#999; 这一屏的名字: 充能/编队#13/编队#14', self.log) self.assertIn('第 3 屏没有 编队#999; 这一屏的名字: 充能/编队#13/编队#14', self.log)
self.assertIn('没找到 编队#999(共 4 轮)', self.log) self.assertIn('没找到 编队#999(共 6 轮)', self.log)
def test_ambiguous_suffixes_are_not_clicked(self): def test_ambiguous_suffixes_are_not_clicked(self):
auto = _FakeTeamScreen([['流血队', '流血2', '斩击']]) auto = _FakeTeamScreen([['流血队', '流血2', '斩击']])
@@ -296,7 +318,7 @@ class SelectTeamByNameTest(unittest.TestCase):
args, kwargs = self.records.call_args args, kwargs = self.records.call_args
self.assertEqual(args, ('team', None, 'not_found')) self.assertEqual(args, ('team', None, 'not_found'))
self.assertEqual(kwargs['seen'][0], self.TOP) self.assertEqual(kwargs['seen'][0], self.TOP)
self.assertEqual(len(kwargs['seen']), 4) self.assertEqual(len(kwargs['seen']), 6)
def test_header_not_changing_is_reported(self): def test_header_not_changing_is_reported(self):
auto = _FakeTeamScreen([self.TOP, self.MIDDLE], click_changes_header=False) auto = _FakeTeamScreen([self.TOP, self.MIDDLE], click_changes_header=False)
@@ -366,6 +388,13 @@ class InstallSystemTeamSelectionTest(unittest.TestCase):
self.assertEqual(sel.call_args[0][1], ('流血',)) self.assertEqual(sel.call_args[0][1], ('流血',))
self.assertEqual(self.calls, []) # 成功后不再走编号回退 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): def test_name_search_failure_does_not_fall_back_to_number(self):
# 这号没有 编队#1, 静默回退到编号会选中错的队, 必须显式失败 # 这号没有 编队#1, 静默回退到编号会选中错的队, 必须显式失败
self.install() self.install()
@@ -392,5 +421,244 @@ class InstallSystemTeamSelectionTest(unittest.TestCase):
self.assertIsNone(self.install()) 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__': if __name__ == '__main__':
unittest.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], ('镜像迷宫', '震颤'))
+390
View File
@@ -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()
+30
View File
@@ -180,6 +180,36 @@ class TypedKeyboardRoadTest(unittest.TestCase):
self.assertEqual(self.road.search_road_simple_keyboard(), 'original') self.assertEqual(self.road.search_road_simple_keyboard(), 'original')
self.road.identify_nodes.assert_not_called() 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): def test_env_switch_leaves_upstream_untouched(self):
self.assertIsNone(self.install(env={ap.TYPED_ROAD_ENV: '0'})) self.assertIsNone(self.install(env={ap.TYPED_ROAD_ENV: '0'}))
self.assertIs(self.road.search_road_simple_keyboard, self.original) self.assertIs(self.road.search_road_simple_keyboard, self.original)