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
ywsandClaude Opus 5.5 d15f5a1bb2 复查修正: 饰品三选一被上游倒序、选队顶栏同名被覆盖
- 饰品(P1-3): 三张及以上时上游把认出体系图标的卡逐张 insert(0), 后看的排到最前,
  两张命中关键词的卡都带图标时补丁的顺序会被倒过来, 先拿命中少的。现在交给上游
  "没命中的(原顺序) + 命中的(倒着)", 上游查体系图标时对命中的卡答"有", 拼出来是
  命中多 -> 命中少 -> 只认出图标 -> 其余。测试的假界面加上体系图标, 先复现再修。
- 选队(P1-5): _team_ocr 经 _run_ocr_for_text 的 {文本: 坐标} 取结果, 选中某队后
  顶栏和列表同名, 顶栏那条会被覆盖; 旧测试用成对结果模拟重复, 真实 dict 做不到。
  改读 OCR 引擎逐行结果(同一引擎、同一截图), 引擎导入不了才退回 dict。
- 事件(P1-4): 同一张截图只判断一次, 单通模式再找 "???" 时不再整屏 OCR 第二遍。
- 文档: 修正 BACKLOG/README/交接文档对应描述, 去掉两处没核实的推断。

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-14 09:04:37 +00:00
ywsandClaude Opus 5.5 40a5af0184 P2-6 镜牢商店必买先按中文名购买, 取消 P2-7
- 商店每一格下面写着饰品中文名(实机截图可见)。install_shop_by_name 在
  buy_gifts 期间往 must_purchase 最前面临时插 3 个占位项, 上游逐个 click_element
  点到占位项时: 以 shop_coins_assets 为锚点在商品格范围内 OCR, 名字完全一致
  (允许 + 后缀)就点上方的图标, 之后购买/确认仍走上游循环; 图标模板在后面兜底。
- 名字表 lc_mcp/data/shop_gifts.json: AALC 5 张必买模板对应的饰品, 中文名按零协
  汉化; 同一名字一次进店最多点 4 次; 没命中的截图不重复 OCR。
- 审计记 shop/name_match; 装在商店审计之后, 购买仍记 purchase_clicked。
- LCP_SHOP_NAMES=0 关闭; 表读不了或上游不再逐个点 must_purchase 时记 [ERROR]。
- 单测执行上游真实的 Shop.buy_gifts, 坐标按截图实测。
- P2-7 观测饰品自动勾选按用户意见不做。

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-14 08:44:09 +00:00
ywsandClaude Opus 5.5 72d2ca1a5b AALC 升级到 V1.6.1 并按零协汉化核对镜牢补丁
- vendor/aalc: e1d1749 -> 2fcb1b4(V1.6.1)。上游 8196e72 修好了商店三个清单的
  路径, 删掉本地 install_shop_lists, test_shop_lists 改成守着上游 5/19/31。
- 上游 18deb77 把事件里找 "???" 改成 find_element 后自己点, 原事件表补丁挂在
  click_element 上会悄悄失效。改挂 find_element, 上游拿返回位置再点的那下吞掉;
  小指良单通模式再找 "???" 时返回没有, 不会改点别的选项。
- 事件表改成按同一屏其它选项的原文认事件(零协汉化的事件数据没有标题), 选项原文
  照抄 LLC_zh-CN/ActionEvents_*.json 并带事件 id; 去掉 index 规则。核对后保留
  6 条, 删掉汉化里对不上或说法矛盾的 4 条(两个睡袋、浸染棉花、终末日历); 失明巨人
  是判定, 标 check。选项比较前去标点。
- 饰品关键词按零协汉化体系名核对, 删掉汉化里从未出现的 出血。
- 事件表、饰品排序安装时检查上游源码里还有被拦截的调用, 没有就记 [ERROR] 跳过;
  包装函数带 __wrapped__, 叠装时也能查到上游源码。
- BACKLOG 记录这次升级对各补丁的影响和核对结果。

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-14 08:43:27 +00:00
ywsandClaude Opus 5.5 51525722cd P2-8 镜牢局内决策写入审计日志
- 新增 lc_mcp/decisions.py:每个决策追加一行 JSON(time/stage/choice/reason + 细节),
  写失败只丢该行;summarize 按 stage/reason 计数
- TaskRunner 用 LCP_DECISIONS 把 task_*.decisions.jsonl 路径交给子进程,
  task_status 返回 decisions.counts,清理旧日志时一并删除
- 选队/键盘寻路/饰品/事件补丁记录各自决策;商店购买与卡包选择用只观察的补丁记录
  (购买按钮点中前的商品;卡包取自上游日志里的选择结果与权重)
- 抽出 _override 统一临时替换 auto 方法并在结束时还原

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-14 07:11:30 +00:00
ywsandClaude Opus 5.5 4376d9cfb2 P1-4 镜牢事件按选项表选择
- 包住 Mirror.event_handling:上游每轮挑选项前(找 unknown_event 那一步),
  画面有选项框时整屏 OCR,按行把文字归到各选项;认出表里的事件就点对应选项,
  没收录/选项不在画面上照常交给上游,调用结束还原 click_element
- 表 lc_mcp/data/event_choices.json 10 条,取自事件速查里的直出/免费奖励;
  按选项文字优先,按编号只用于第一屏、画面没变时最多重试 3 次
- 每屏选项打一次日志(含未收录事件的选项文字,便于补表)
- LCP_EVENT_CHOICES=0 关闭,=<路径> 换表;表读不了记 [ERROR] 不装
- 单测执行上游真实 event_handling

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-14 07:04:59 +00:00
ywsandClaude Opus 5.5 2f8f15a886 P1-3 镜牢饰品选择按体系关键词排序
- 包住 Mirror.acquire_ego_gift(type=1):上游取到卡片列表时整屏 OCR 一次,
  按坐标把文字归到卡上,命中当前体系关键词行数多的排前面;排序稳定,
  白棉花、已持有、体系图标仍由上游原逻辑处理,调用结束还原 find_element
- OCR 读引擎逐行结果,不用会合并同名文本的 {文本: 坐标},也不用 my_crop
- 关键词表 lc_mcp/data/gift_keywords.json,匹配前做与选队相同的归一(含震颐/沉论误读)
- LCP_GIFT_KEYWORDS=0 关闭(与上游完全一致),=<路径> 换表;表读不了记 [ERROR] 不装
- 单测执行上游真实 acquire_ego_gift,覆盖两张/三张卡、选一/选二、已持有、白棉花、误读

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-14 07:00:24 +00:00
ywsandClaude Opus 5.5 e08edda27d P1-5 镜牢选队容忍 OCR 误读与队名后缀
- 队名先归一:去空白、NFKC 全角转半角、改回实测误读(震颐→震颤、沉论→沉沦、编#→编队#)
- 精确匹配优先;否则接受这一屏唯一的「名字+后缀」(流血队、流血(X)),多条不点
- 顶栏确认只认精确,避免把 流血2 当成 流血
- 没命中时日志打印每屏看到的名字,点了没变时打印顶栏读到的文字

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-14 06:54:27 +00:00
ywsandClaude Opus 5.5 4c0038d657 P0-2 镜牢简单键盘寻路改为按节点类型选方向
config 开着 mirror_keyboard_simple_pathfinding 时 AALC 每步只按 ↑ 进
最上面的节点(11-14:3 层只进过 1 次商店)。常规寻路要 mouse_drag 拖
地图,第二段拖动只受超时限制且超时会退回主界面;连线识别还依赖本机
坐标不对的 my_crop,所以不改用常规寻路(BACKLOG 方案 B)。

install_typed_keyboard_road() 替换 search_road/mirror 两处的简单键盘
寻路:仍只按键不拖地图,用 AALC 自带 ONNX 模型整屏识别巴士右侧一列
节点,按上游 all_node_weight 从低到高按 up/right/down,每次用原
_keyboard_enter_succeeded 确认,最多 3 次,都不行调用原函数按 ↑。
每步记录下一列候选和进入的方向、类型、理由。LCP_TYPED_ROAD=0 关闭。

README 同时补上 P0-1 商店清单与本补丁的说明。

验证:排序、方向映射、逐个回退、识别失败与开关均有单测,复制的权重
表和网格参数与上游源码比对一致;全套 529 项通过。方向上无连线时按键
不会进错节点这一点需实机确认,BACKLOG 已写明对照方法。

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-14 05:51:36 +00:00
ywsandClaude Opus 5.5 baa362808c P0-1 补齐镜牢商店必买/必卖/公式合成清单
上游 ebb6629 把图片挪到 assets/images/<主题>/<语言>/ 下,
tasks/mirror/__init__.py 仍按 ./assets/images/share/... 列目录,三个
清单恒为空:11-14 实测进店 51 秒一件没买,弃用饰品识别和公式合成
一起空转。按名字找图的 path_manager 那层没坏。

install_shop_lists() 在 mirror/all 任务里按 AALC 六个图片根合并去重,
原地 extend 三个列表(in_shop 在导入时绑定了列表对象,重新赋值无效);
上游清单已非空时不动,不改 vendor。

验证:执行上游真实 __init__.py 得到 0/0/0,补丁后 5/19/31,且每个
图片名都能在某个图片根下找到;全套 514 项通过。实机待看补丁日志与
进店后的购买动作。

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-14 05:45:03 +00:00
ywsandClaude Opus 5.5 5fdb9fd221 普通镜牢转交 AALC,核对镜牢实际完成局数,合成与任务互斥
转交与互斥(原未提交改动,合入选队分支后提交):
- MCP 初始化说明和工具描述引导常规日常/领奖/普通镜牢走
  task_status -> run_task -> 轮询;jev_mirror_agent 默认转交 AALC,
  明确的速通配置、决策模型或未完成速通局仍走逐步模式。
- 新增 ~/lc_mcp/game.lock:run_task 子进程与模块合成脚本互斥,
  合成脚本另查 task_status,状态不明时不接管游戏。
- all 任务的 HDR 提示无 GUI 时直接确认并记录;预检按窗口位置
  决定是否计标题栏,set_windows=false 跳过;levelup card/weakest
  同步失败返回非零。急停提示改为 End 键。

镜牢结果(对接文档指出的缺口):
- 预检拒绝空队列和没有适用当前难度队伍的配置:AALC 会一局不打
  就以 0 退出。可用判定与 Mirror_task 的固定用途规则一致。
- 监听 mirror_signal 统计实际完成局数;少于应打局数记 [ERROR]
  并以退出码 4 结束,task_status 为 failed。
- mirror 指定 count 时临时关闭 infinite_dungeons(否则次数变成
  9999),原值写入恢复文件,结束或强杀后写回。

验证:Linux / Python 3.12 全套 507 项通过;git diff --check 通过。
用上游真实 Mirror_task 回放了无可用队伍和正常完成两种情况;
Windows 实机仍需回归。

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-14 03:27:03 +00:00
ywsandClaude Opus 5.5 1aa823ea2e 合并 main 的合并前复核修复到镜牢选队分支
分支从 8a9495b 分出,缺 main 上 a74fda0 的急停与驱动复核修复。
两边都保留,不取单边:

- 急停:沿用分支的 GetAsyncKeyState 轮询与 End 键(pynput 钩子在该
  机器收不到键,F12 是 Steam 截图键);移植 main 的 on_stop 释放驱动
  按住的鼠标键、250 毫秒强退兜底、listening() 管理监听生命周期。
  按键状态改为独立绑定(SHORT 返回值),接口不可用时启动即报告。
- 驱动输入:同时保留句柄级前台校验、press_ms/settle 与 main 的
  停止标志、输入锁和按键记录;点击经 down()/up() 以便急停释放。
  前台校验改用本模块的类型化 _api 绑定。
- 代理每次点击按当前句柄重新 bind_window:代理复用时不再拿安装时
  的旧句柄拒绝游戏重启后的全部点击。
- aalc_task:listening() 包住整个任务,内部安装两个选队补丁。
- 分支新增测试改为替换模块接口,不再直接 patch ctypes.windll
  (Linux 上 9 项报错);README 急停键改为 End。

验证:Linux / Python 3.12 全套 474 项通过;git diff --check 通过。
Windows 热键、驱动和选队仍需实机回归。

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-14 03:19:53 +00:00
Codex Agent c4a42bcfaf 镜牢选队改为按体系名点选;补交接文档、待开发计划与单测
本机账号的编队按体系命名(流血/斩击/突刺/…),AALC 只认 编队#N,导致镜牢永远
报「无法寻得队伍」。新增 install_system_team_selection:按 team_system 映射的
中文队名在列表里精确匹配并点选,点完用顶栏队名确认;失败显式返回 False,
不静默回退到编号(该账号没有 编队#1~#12)。

- lc_mcp/aalc_patches.py: 新增选队补丁与区域/OCR 辅助
- lc_mcp/aalc_task.py: mirror/all 任务挂载该补丁
- tests/test_system_team_selection.py: 15 个用例,不依赖 AALC/Windows
- docs/feedback/2026-11-14/: 实测记录 + 云端开发交接文件(含体系队名表)
- docs/BACKLOG.md: 待开发计划(商店清单路径 bug、走位降级、三选一按体系等)

单测:460 passed。
2026-11-14 10:22:35 +08:00
Codex Agent 58cd78cd9c 修复"位置正确却点不上":点击前做句柄级前台校验
用户反馈: 点击有时候一直点也没点上, 位置明明正确。

---

## 实测排查过程

第一版假设是两个时序问题(按下 30ms 太短 / 移动后立刻按下)。实测否决:

    press= 30ms -> 画面切换 4/4
    press= 60ms -> 画面切换 4/4
    press=120ms -> 画面切换 4/4

在干净环境里三种时长全中, 所以时长不是元凶。

    (第一版测试本身有缺陷: 它只验证 click() 返回 True, 而 True 只代表"定位
     到了", 不代表游戏收到点击。改成截图前后比对画面是否变化才有意义。)

真实原因: **前台不是游戏**。现场证据:

    窗口位置: (-7, 0)                       ← 出界
    前台窗口: '...DeepSeek Harness'          ← 不是游戏
    点击结果: True                           ← 但光标最后在 (204,1063), 没到目标

排查中还否定了一个想当然的结论: 窗口出界**本身不致命**(坐标按实际窗口位置
算, 目标只要还在屏幕内就能点中) —— 实测窗口在 (-8,0) 时画面照样切换成功。
真正致命的是前台窗口不是游戏。

## 修复

click() 加 require_foreground 校验。**关键是比对句柄而不是比对矩形**:

第一版只判断"点击点是否落在前台窗口矩形内", 结果把浏览器切到前台、点游戏里
同一个坐标, 校验**照样通过** —— 那个屏幕坐标同时也落在浏览器窗口的矩形里。
窗口重叠时几何判断毫无意义。

现在给了 hwnd 就要求前台窗口就是它(或是它的子窗口), 否则拒绝并说明"这次点击
会打到别的窗口"。DriverInput 新增 bind_window(), 代理安装时自动绑定游戏句柄。

拒绝比静默失败好: 以前"点了个寂寞"也返回 True, AALC 无从知道要重试。

## 顺带调整

press_ms 30 -> 60, 定位成功后加 settle 间隔。这两项实测在干净环境下不是必需,
但负载高/掉帧时更稳, 成本只有几十毫秒。

## 验证

真机(游戏窗口 133358):
    [1] 前台是 DSH      -> False | 前台不是目标窗口(前台='...DeepSeek Harness',
                                  目标='LimbusCompany') —— 这次点击会打到别的窗口
    [2] DSH 在前台同点  -> False | 同上(正确拒绝)
    [3] 游戏在前台      -> True  | ok

测试新增 HwndForegroundCheckTest 4 个 + ForegroundCheckTest 6 个, 全套 441 通过。
2026-10-23 09:41:46 +08:00
Codex Agent 13c038a175 WindowGuard 补上窗口位置纠正(窗口出界会让抓图整体错位)
现象: 任务日志一直在动、进程正常,但几乎不点击 —— 实测 30 秒只点了 1 次。
      同时图像匹配相似度全在 0.2~0.5(AALC 阈值通常 0.8)。

排查: 游戏窗口位置是 (-8, 39) —— 左边 8 像素在屏幕外。

原因: 前台模式(background_click=false)下 AALC 从**屏幕**抓图(BitBlt 屏幕 DC),
      窗口一出界, 抓到的画面就整体偏移, 模板匹配自然全部失败; 而 AALC 的
      set_win_position=free 表示它不碰窗口位置, 所以没人管这件事。

      手动把窗口挪到 (0,0) 后, 30 秒内点击立刻恢复到 5 次 —— 确认因果。

修复: WindowGuard 原来只纠正客户区尺寸, 现在先纠正位置:
      用 monitor_info["Work"](工作区, 已扣任务栏)判断窗口是否完整落在里面,
      不在就用 SetWindowPos 夹回边界内(保留尺寸、不夺焦点)。
      位置放在尺寸检查之前 —— 出界时尺寸检查本身也没意义。

游戏每次启动都会恢复自己保存的位置, 所以这个纠正必须常驻, 不能只在启动时做一次。
2026-10-22 17:15:35 +08:00
yws 05626e95c7 合并自动化与驱动输入修复分支,完成审查和急停回归 2026-10-22 07:33:05 +00:00
yws a74fda07e2 合并前复核:补齐急停释放、整轮中止和计划任务时限 2026-10-22 07:32:58 +00:00
Codex Agent 8a9495b185 加急停热键 F12(驱动级点击期间用户没法用鼠标停止)
用户提问: "你执行脚本的时候我鼠标没法动,我怎么停止呢"

这不是小问题 —— 驱动级点击是闭环定位的: 手一动, 下一次点击前会读到新位置算出
偏差, 再把你推回目标点。所以任务跑起来时鼠标是"拔河"状态, 用户根本没法用鼠标
去点停止按钮。而 AALC 自带的 pause_hotkey 只在 GUI(app/farming_interface.py)
里注册, lc_mcp 走命令行子进程, 那条路径上没有热键监听 —— 等于跑任务时没有急停手段。

   唯一可靠的中断通道是键盘, 所以做成全局热键。

实现: lc_mcp/killswitch.py, pynput 的 GlobalHotKeys 监听, 默认 F12
(环境变量 LCP_KILL_KEY 可改)。按下后 os._exit(130) —— 任务本来就是子进程,
硬退出不留锁和半截状态, 这与 aalc_task.py "停止 = 杀进程树" 的设计一致。

装在 aalc_task.py 的 preflight 之前(尽早), 装不上只记日志不抛异常, 并明确提示
改用 Ctrl+Alt+Del —— 急停装不上不该让任务起不来, 但必须告诉用户应急手段。

验证: 13 个测试通过(键名归一化 / pynput 缺失时给应急手段 / 只触发一次 /
不重复退出 / 环境变量覆盖), 真机注册与停止均正常。全套 412 通过。
2026-10-22 15:18:11 +08:00
yws 46b5af01cd 复核驱动输入与窗口补丁,修复接管互斥和异常清理 2026-10-22 06:52:39 +00:00
Codex Agent e2de126687 修复 background_click=false 时 setForeground 崩溃
现象: 改 set_win_size 后任务在 init_game() 里直接崩, exit code 3, traceback:
  screen.py:343 _set_win -> handle.setForeground()
  -> win32gui.SetForegroundWindow(hwnd)
  -> pywintypes.error: (0, 'SetForegroundWindow', 'No error message is available')

原因: screen.py:342 在 cfg.background_click=False 时才调 setForeground, 而原生
实现(screen.py:167-171)只有一句裸调用, 没有任何兜底。Windows 不允许非前台进程
抢占前台, 失败就抛异常, 这个异常在 set_win() 里没被捕获, 整个任务崩掉。

  也就是说: 我为了修抓图黑屏把 background_click 改成 false, 反而踩出了这条
  一直存在但从没被走到的崩溃路径。

修复: install_robust_set_foreground —— 先试原生调用, 失败则用 MSDN 认可的标准
手法兜底: 把自己的线程输入队列 AttachThreadInput 到当前前台窗口线程上, 借它的
前台权限 BringWindowToTop + SetForegroundWindow, 完成后解挂。兜底也失败只记日志
不抛异常 —— 抢不到前台不该让整个任务死掉。

验证: 同样的 set_win_size=720 配置, 修复前 exit 3 崩溃, 修复后正常走到"一次镜牢"。

附带发现: 驱动级输入这次被 preflight 正确拒绝了(GetForegroundWindow=0)。
用户改用 ToDesk 连接后桌面变成独立会话(主屏是 Todesk Virtual Display Adapter),
驱动级注入在这种会话里本来就不生效 —— 拒绝并回退普通注入是正确行为。
2026-10-22 13:27:12 +08:00
Codex Agent 7eafbdd651 修复驱动点击接管被 init_game() 覆盖(补追踪)
问题: 日志里能看到 "鼠标点击已切到罗技驱动级输入", 但驱动点击一次都没发生
(追踪文件只有 2 行 install 记录, [driver] 日志 0 条, 而 automation.py:152 的
点击日志有 58 次)。

原因: 安装在 scheme.init_game() **之前**。init_game() 会重建 auto.input_handler
(automation.py:46/65/72/77/84/89/94/98 多处赋值), 把装好的代理覆盖掉。所以
patch 日志打了, 但真正点击时 getattr(self.input_handler, 'mouse_click') 取到的
是原来的 handler。

修复: 把安装挪到 init_game() 之后。

另外加了 LCP_DRIVER_TRACE 文件追踪(install 时记录原 handler 与 auto.mouse_click
的原绑定, mouse_click 每次调用都记一行) —— 普通日志会被 AALC 的 logger 吞掉,
文件追踪是这次能定位到根因的关键。

这个问题说明测试覆盖不足: 单元测试用 Mock 造 auto, 没有复现 automation.py 真实的
别名/gate 接线, 所以没能发现"装完被覆盖"。后续要补一个贴近真实接线的测试。
2026-10-22 11:55:58 +08:00
Codex Agent 2902cf5dbf 驱动级输入接管 AALC 任务流的鼠标点击(LCP_DRIVER_INPUT=1 开关)
按"应该在输入层接管"的思路做的: 不是只改 lc_mcp 自己的 click, 而是把 AALC 任务流里
所有鼠标点击都转到罗技驱动上 —— 这样镜牢/日常的点击也走物理输入。

一、lc_mcp/driver_input.py(新)
   DriverInput 封装 logitech.driver.dll(device_open/moveR/mouse_down/mouse_up)。
   定位用**闭环**: 发相对位移 -> 读回实际坐标 -> 不够再发, 收敛到 <=1px 才认。
   不依赖任何标定常数, 也不怕偶发坐标跳变。

   preflight() 有三条硬性拒绝, 每条都对应一个实测过的失败条件:
     * device_open() != 1            -> 罗技驱动没就绪
     * GetForegroundWindow() == 0    -> 当前不是物理交互会话(RDP 独立会话里驱动级无效;
                                        实测那时 22 次采样光标纹丝不动, 切到 console 立刻正常)
     * 指针加速开着                  -> counts 与像素不成比例(实测 +100/+200/+400 对应
                                        -45/-3/-3 像素), 关掉后严格 1:1

二、aalc_patches.py: DriverClickProxy + install_driver_click
   只接管 mouse_click / mouse_down / mouse_up, 其余(拖拽/滑动/滚轮/等待)一律透传。
   拖拽类不接管: 那些行为差异大, 用相对位移复现更容易出错。

   ⛔ 关键细节: automation.py 初始化时把方法绑成了别名
   (self.mouse_click = self.input_handler.mouse_click), 所以**换 handler 不够**,
   必须把别名一起重绑, 否则任务流里调的还是老方法。测试里专门守这一条。

   条件不满足时**一个都不改** —— 宁可继续用原来的注入方式, 也不要半吊子接管。

三、aalc_task.py: 环境变量 LCP_DRIVER_INPUT=1 时才安装; 默认关闭。

验证(真机, 物理 console 会话):
  preflight: True | ok        前台窗口存在 True   指针加速 False
  move_to (400,300) / (1200,700) / (800,500) -> 误差全部 (0,0)
  click(600,400) -> True

测试 15 个, 重点在"各种条件不满足时必须拒绝"。全套 399/399 通过。
2026-10-22 11:09:42 +08:00
Codex Agent a6e987e796 修复点击时画面抽搐, 并把截屏自检改成走 AALC 实际用的采集路径
一、为什么"我用脚本点击时画面一直抽搐, AALC 点击不抽搐"

链条查清了:
  * lc_mcp/aalc_engine.py 的 click 每次先 set_window_transparent(True)
  * 而这个方法的实现是 SetLayeredWindowAttributes(hwnd, 0, 0, LWA_ALPHA)
    —— alpha=0, 整个游戏窗口**完全透明(看不见)**
  * 它原来**只有 background_screenshot 会恢复成 False**(screenshot.py:194)
  * 我的脚本是"点击 -> 截图 -> 点击 -> 截图"高频交替
    => 窗口在不可见/可见之间反复切换 => 肉眼看就是一直抽搐

AALC 自己的 WindowMoveInput.mouse_click 只搬窗口、**根本不碰透明度**, 所以它最多
"跳一下", 不会闪 —— 这就是两边观感不同的原因。

改法: 透明度在**本次点击/拖动结束时立刻还原**, 并且放在嵌套 try/finally 里 ——
还原位置那步也可能抛错(任务被停), 不能让它把透明度还原跳过去, 否则窗口会一直隐形。
(第一版就是把还原排在 finally 里的 sleep 之后, 测试里"异常路径"那条立刻抓到了。)

二、render_ok() 改成测 AALC 真正走的那条路

原来只测屏幕 BitBlt(GetDC(0))。2026-10-22 实测它在 RDP 会话下会瞬时失败, 而 AALC
走的是 background_screenshot(窗口 DC + PrintWindow), 那条路照样能截到图 —— 我的自检
把本来能干活的轮次判成"截不到图"跳过了(10-17 02:23 就白丢过一轮)。
现在优先测窗口能否采集, 窗口不在或不可采才回退到屏幕。

测试: 新增 3 个(点击内还原/异常也还原/前台模式不碰透明度) + 4 个 render_ok 分支。
全套 384/384 通过。
2026-10-22 09:34:29 +08:00
61 changed files with 10733 additions and 160 deletions
+139 -6
View File
@@ -72,8 +72,50 @@ codex mcp add limbus --env PYTHONUTF8=1 -- D:\lc-mcp\vendor\aalc\.venv\Scripts\p
部分 Unity 界面仍读取系统指针位置,实测标题页按钮需使用 `window_move`。 部分 Unity 界面仍读取系统指针位置,实测标题页按钮需使用 `window_move`。
战斗按键有按下/释放间隔;隐藏启动后可用 `show_game_background` 恢复渲染。 战斗按键有按下/释放间隔;隐藏启动后可用 `show_game_background` 恢复渲染。
## 可选:任务流使用罗技驱动鼠标输入
驱动接入代码已随仓库提交:`lc_mcp/driver_input.py`、`lc_mcp/aalc_patches.py`、
`lc_mcp/aalc_task.py`,回归测试在 `tests/test_driver_input.py`。
**仓库不包含 `logitech.driver.dll`、罗技驱动安装包或 `logitech.test.py`。**
需要在 Windows 目标机安装配套驱动并提供 DLL;仅拉取本仓库不能启用这套输入。
在启动 MCP 服务的进程环境中设置(路径替换为本机实际位置):
```powershell
$env:LCP_DRIVER_INPUT = '1'
$env:LCP_LOGITECH_DLL = 'E:\罗技键鼠驱动\logitech.driver.dll'
# 可选,目录需已存在:
$env:LCP_DRIVER_TRACE = "$env:USERPROFILE\lc_mcp\driver-input.log"
```
`LCP_DRIVER_INPUT` 默认关闭,DLL 路径未设置时默认使用上面的 E 盘路径。
服务已经运行时,需要让服务以这些环境变量重新启动;只给 SSH bridge 设置无效。
任务子进程必须在物理 console 会话内,且关闭“提高指针精确度”。预检失败会记录原因,
继续使用原输入后端,不修改系统设置。驱动模式会移动真实系统光标并尝试激活游戏;
激活或坐标转换失败时拒绝本次点击。
接管范围是 `run_task` 的鼠标点击(含空白点击、`all` 和游戏重启后的点击)。
模拟器不接管;拖拽、滚动、键盘以及 MCP 的独立 `click` 工具仍使用原后端。
当前回归验证覆盖软件接线和异常处理,DLL、实际驱动及游戏响应需在 Windows 实机核验。
任务运行期间按 **End** 急停,可用 `LCP_KILL_KEY` 改成 `pause`、`scrolllock` 等键名。
不要用 F12(Steam 截图键);监听用 `GetAsyncKeyState` 轮询,因为 pynput 钩子在该机器的会话里收不到按键。
急停会终止任务子进程,保留游戏窗口;`task_status` 返回 `stopped`、退出码 `130`。
刷取循环检测到用户停止后结束本轮,不再导航、升级或重试。急停前会尝试释放驱动
按住的鼠标按钮,清理超过 250 毫秒仍强制退出;硬退出留下的临时配置恢复文件由
`stop_task` 或下一次 `run_task` 处理。热键监听依赖 AALC 的 `pynput`,安装失败会写日志;
也可从 MCP 调用 `stop_task`,或按 Ctrl+Alt+Del 打开任务管理器终止任务进程。
此热键只覆盖 `run_task` 子进程,不覆盖独立运行的合成、升级脚本。
## 工具 ## 工具
MCP 初始化说明与工具描述均指导 AI 优先使用 AALC:常规日常、领奖、普通镜牢按
`task_status` → `run_task` → 轮询 `task_status` 执行。只刷经验本时显式传 `thread: 0`,
只刷纽本时传 `exp: 0`,避免沿用另一项配置。主线、特殊速通路线或故障恢复使用逐步输入。
只看状态或截图不会启动任务;`all` 只用于明确要求全部任务,`enkephalin` 需要明确授权花狂气。
启动成功不等于完成,最终还要检查 `errors` 和 `pending_restore`,用户停止后不自动重跑。
更新后重启常驻服务并重连 MCP,客户端才能获取新的初始化说明和工具描述。
| 工具 | 说明 | | 工具 | 说明 |
|------|------| |------|------|
| `get_state` | 截图 + OCR,返回窗口内全部文字 `{text,x,y,w,h,score}` | | `get_state` | 截图 + OCR,返回窗口内全部文字 `{text,x,y,w,h,score}` |
@@ -101,16 +143,73 @@ codex mcp add limbus --env PYTHONUTF8=1 -- D:\lc-mcp\vendor\aalc\.venv\Scripts\p
任务运行中如果 `task_status` 带 `stall` 字段,说明 AALC 在原地空转(例如选中了空队伍, 任务运行中如果 `task_status` 带 `stall` 字段,说明 AALC 在原地空转(例如选中了空队伍,
编队人数检查一直刷屏)。它不会自己报错退出,应当 `stop_task` 后重跑。 编队人数检查一直刷屏)。它不会自己报错退出,应当 `stop_task` 后重跑。
镜牢任务的局内决策逐条写进与日志同名的 `~/lc_mcp/runs/task_*.decisions.jsonl`(每行一个 JSON:
`time`/`stage`/`choice`/`reason` 加细节)。`task_status` 的 `decisions.counts` 按阶段统计 `reason`:
| `stage` | `reason` |
|---|---|
| `team` | `current` 已是目标队 / `exact` / `prefix` 后缀队名 / `header_unchanged` / `not_found` |
| `road` | `lowest` 下一列最优 / `next_best` 更优方向进不去 / `fallback` 退回按 ↑ / `keyboard_off` 连续几个节点按键都没进去,本次任务改走 AALC 常规寻路 |
| `theme_pack` | `preferred` 达到优选阈值 / `highest_weight` 刷新后取最高权重 / `event_pack` 最左活动卡包;选中的卡包按体系加过分时带 `system_bonus`(`packs`/`system`/`from`/`to`) |
| `gift` | `keyword` 命中体系关键词 / `no_keyword`(记的是交给 AALC 的第一顺位,白棉花、已持有仍由 AALC 处理) |
| `event` | `text` 按表选 / `deferred` 认出了表里的事件但交给 AALC / `not_in_table`(带 `options`,可直接拿来补表) |
| `battle` | `hollow`:兔子洞模式每回合的结果,`overclock` 超频放上了「空洞」/ `ego` 单击放上了 / `ego_unavailable` 列表还开着(多半资源不够)/ `no_option` 没弹出列表或没认出 |
| `gift_confirm` | `repeated` 「获得E.G.O饰品」确认连点不关,改点按钮中心 / `stuck` 还是不关,结束任务 |
| `shop` | `name_match` 按中文名找到必买饰品(`choice` 是名字)/ `purchase_clicked` 点到了购买按钮(`choice` 是之前点的商品:`shop_by_name` 按名字、必买模板名、`level_IV_to_buy`、`by_position` 本体系饰品) |
### 任务进程里的保护 ### 任务进程里的保护
`run_task` 启动的任务子进程在调用 AALC 之前会做三件事,都不改 `vendor/aalc` 源码: `run_task` 启动的任务子进程会做以下处理,都不改 `vendor/aalc` 源码:
- **配置预检**:发现下列问题就直接拒绝启动(退出码 3,原因写在 `errors` 里): - **配置预检**:发现下列问题就直接拒绝启动(退出码 3,原因写在 `errors` 里):
- 镜牢队伍的 `sinner_order` 全是 0:这会让 AALC 选出空队伍,然后无限重试编队; - 镜牢队伍的 `sinner_order` 全是 0:这会让 AALC 选出空队伍,然后无限重试编队;
- 镜牢队列为空,或队列里没有适用当前难度的队伍(按"固定用途"判断):AALC 会一局不打就以 0 退出;
- `set_lunacy_to_enkephalin` 不为 0:体力不足时会花狂气换体力。确需使用时设 `LCP_ALLOW_LUNACY=1`; - `set_lunacy_to_enkephalin` 不为 0:体力不足时会花狂气换体力。确需使用时设 `LCP_ALLOW_LUNACY=1`;
- `set_win_size` 加上标题栏后放不进当前桌面:窗口会被压扁成非 16:9。 - 自动设置窗口时,目标尺寸放不进当前桌面:窗口会被压扁成非 16:9。
`free` 位置计入标题栏,自动定位的无边框窗口只计客户区;`set_windows: false` 跳过此项。
- **队伍名精确匹配**:AALC 按子串找队伍,`TEAMS #1` 会命中 `TEAMS #10`。补丁要求编号完全相同。 - **队伍名精确匹配**:AALC 按子串找队伍,`TEAMS #1` 会命中 `TEAMS #10`。补丁要求编号完全相同。
- **窗口比例守护**:每 15 秒检查一次客户区。RDP 重连后窗口被拉伸时,自动调回 `set_win_size` 对应的 16:9 尺寸。 - **窗口比例守护**:每 15 秒检查一次客户区。RDP 重连后窗口被拉伸时,自动调回 `set_win_size` 对应的 16:9 尺寸。
- **HDR 提示**:`all` 任务检测到 HDR 时记录警告并继续,不等待 GUI 确认。
- **镜牢完成核对**:监听 AALC 的镜牢进度信号统计实际完成局数。少于应打局数时记一条 `[ERROR]`
并以退出码 4 结束,`task_status` 显示 `failed`;AALC 正常返回不再被当成打完。
- **指定次数**:`mirror` 传 `count` 时本次临时关闭 `infinite_dungeons`(开着时 AALC 会把次数改成 9999),
原值和次数一起写入恢复文件,结束或被强杀后都会写回。
- **商店按中文名购买**:必买项先整屏 OCR 商品格下面的饰品名,对上 `lc_mcp/data/shop_gifts.json`(零协汉化名字,
靠前的先买)就点那一格,购买/确认仍走 AALC 原循环;AALC 的 5 张图标模板在后面兜底。`LCP_SHOP_NAMES=0` 关闭。
(必买/必卖/公式合成清单为空的问题,上游 V1.6.1 已修,本地补丁已删。)
- **镜牢按体系名选队**:按 `team_system` 在编队列表里点同名队伍(流血/斩击/…),点完核对顶栏队名。
名字先归一(去空白、全角转半角、纠正 `震颐`/`沉论`/`编#` 等误读);精确匹配优先,
否则接受这一屏唯一的"名字+后缀"(`流血队`、`流血(X)`),多条就不点。没找到时日志列出每屏看到的名字。
AALC 入场时常常直接点「进入」、不走选队,所以点「进入」前也会核对顶栏,不是目标队就先切;
切不过去记 `[ERROR]`,这一局按游戏当前编队进入,不再反复翻列表。「星之恩惠」页满屏星星会被认成选队页,
出现「恩惠」字样时忽略选队星级模板。
- **键盘寻路按节点类型**:开着简单键盘寻路时不再只按 ↑。先识别巴士右侧下一列的节点类型,
按上游权重(事件 < 商店 < 战斗 < …)依次按方向键,进不去再退回 ↑;不拖地图。
连续 3 个节点按键都没进去,本次任务就不再按键,直接交给 AALC 常规寻路。`LCP_TYPED_ROAD=0` 关闭。
- **按键带扫描码、按住再松**:AALC 前台模式用 `pyautogui.press` 按键,扫描码是 0、方向键不带扩展键标志、
按下抬起紧挨着;上游注释写明 Unity 6 会校验扫描码和扩展键标志。前台改发带扫描码的 `keybd_event`
(游戏窗口不在前台时先激活,激活不了就不发),后台两种模式仍用上游的按键消息;各模式都按住 0.12 秒再松开。
MCP 的 `key` 工具前台模式同样处理。`LCP_KEY_HOLD=0` 关闭任务进程里的这项。
- **「获得E.G.O饰品」弹窗兜底**:AALC 点的是确认按钮左边的勾号,点了不关时会一直点下去(它的循环计数被
`continue` 跳过)。连续第 3 次命中起改点按钮中心;连续 20 次还在就记 `[ERROR]`、按未完成结束任务(退出码 4)。
- **饰品选择按体系关键词**:镜牢路上的饰品 N 选一,先整屏 OCR,按卡面上命中当前体系关键词的行数给卡排序,
再交给 AALC 原逻辑(跳过白棉花、已持有排后)。三张卡时命中关键词的卡按"认出体系图标"交给 AALC,
并抵消它把这类卡逐张插到最前造成的倒序。关键词表在 `lc_mcp/data/gift_keywords.json`。
- **事件选项表**:事件出现选项时整屏 OCR,按同一屏其它选项的原文(零协汉化)认出 `lc_mcp/data/event_choices.json`
里的事件,就点表里那一项;不靠事件名(汉化数据没有标题)。没收录的事件照旧交给 AALC,
日志会打印这一屏的选项文字,便于补表。表里的选择优先于 AALC 的"有 ??? 先点 ???",小指良单通模式也一样。
- **卡包按体系加分**:选卡包时把 `lc_mcp/data/theme_pack_systems.json` 里「卡包对当局体系的加分」临时加到 AALC 的
权重表上(不改 `theme_pack_list.yaml`):体系包(掉落以该体系饰品为主,如电闪雷鸣/动力渐盈 = 充能)、该体系专属饰品
≥3 件、或中文社区攻略推荐这个体系走的卡包 +6,专属 2 件 +4,1 件 +1;速刷攻略说拖时间的(被遗忘者们、自动工厂、
当碎之物)所有体系 -3。AALC 原来的 -5 也能被压过,比如充能队会选 WARP快车谋杀案;嫌激进就调小表里的 `bonus`。
卡包数据来自 wiki.gg(`scripts/build_theme_pack_systems.py` 生成,换赛季重跑),社区推荐见
`docs/feedback/2026-11-15/theme-pack-research.md`。`LCP_THEME_PACK_SYSTEMS=0` 关闭。
- **兔子洞速刷**(`run_task` 加 `strategy="rabbit_hole"`):按 `lc_mcp/data/rabbit_hole.json` 的编队名选队;
每回合按 P → 长按浮士德打开 E.G.O 列表 → OCR 找「空洞」,每场第一回合长按卡片超频、其余回合单击 → Enter;
攻略路线上的卡包(赌徒 → 地狱鸡 → 去·海·边 → 憎恶与绝望 → 2号线)加分。长按点 `press_at` 要在实机上量,没量时不点任何东西、
记 `[ERROR]`、照常 P+Enter。说明与校准步骤见 `docs/feedback/2026-11-15/RABBIT-HOLE.md`。
- **挂不上就报错**:事件表、饰品排序、商店按名字、前台按键、卡包加分、兔子洞这几个补丁靠拦截 AALC 的某个调用挂进去,安装时先查上游源码;
上游改了写法时记 `[ERROR]` 并跳过该补丁,不会悄悄失效。
## 无人值守 ## 无人值守
@@ -140,11 +239,16 @@ powershell -ExecutionPolicy Bypass -File scripts\install_convert_task.ps1 -Every
看历史:`python scripts/modules_status.py` 看历史:`python scripts/modules_status.py`
合成脚本与 `run_task` 子进程通过 `~/lc_mcp/game.lock` 互斥,锁一直保持到操作和关闭游戏结束。
已有任务占用时,后来启动的一方报告失败;合成脚本无法确认任务状态时也会退出,不接管游戏。
进程退出后锁由系统释放,文件保留,无需手动删除。
**⚠️ 挂机值守前先读 [`docs/WATCH.md`](docs/WATCH.md)** —— 那里记着环境事实、 **⚠️ 挂机值守前先读 [`docs/WATCH.md`](docs/WATCH.md)** —— 那里记着环境事实、
界面坐标、狂气的三道防线、六种已知失败模式及处置,以及几条踩过的坑 界面坐标、狂气的三道防线、六种已知失败模式及处置,以及几条踩过的坑
(比如 OCR 会把 `LUNACY` 读成 `UNACY`,曾让整条狂气防线静默失效)。 (比如 OCR 会把 `LUNACY` 读成 `UNACY`,曾让整条狂气防线静默失效)。
`scripts/levelup.py` 和 `auto_cycle.py` 里的坐标都按 1600×900 客户区书写,运行时会按实际客户区大小缩放。 `scripts/levelup.py` 和 `auto_cycle.py` 里的坐标都按 1600×900 客户区书写,运行时会按实际客户区大小缩放。
`levelup.py card`、`weakest` 和 `progress` 带 `--uptie` 时,同步失败会返回非零退出码。
## 环境变量 ## 环境变量
@@ -154,6 +258,13 @@ powershell -ExecutionPolicy Bypass -File scripts\install_convert_task.ps1 -Every
| `LCP_PORT` | 8765 | 服务/bridge 端口 | | `LCP_PORT` | 8765 | 服务/bridge 端口 |
| `LCP_KEEP_SHOTS` | 30 | 截图保留张数 | | `LCP_KEEP_SHOTS` | 30 | 截图保留张数 |
| `LCP_ALLOW_LUNACY` | 未设置 | 设为 `1` 时允许预检放行 `set_lunacy_to_enkephalin` 不为 0 的配置 | | `LCP_ALLOW_LUNACY` | 未设置 | 设为 `1` 时允许预检放行 `set_lunacy_to_enkephalin` 不为 0 的配置 |
| `LCP_TYPED_ROAD` | 未设置 | 设为 `0` 时镜牢简单键盘寻路保持上游的"只按 ↑",不按节点类型选方向 |
| `LCP_EVENT_CHOICES` | 未设置 | 设为 `0` 时事件不查选项表;设为 JSON 文件路径时用它代替 `lc_mcp/data/event_choices.json` |
| `LCP_GIFT_KEYWORDS` | 未设置 | 设为 `0` 时饰品选择不按体系关键词排序;设为 JSON 文件路径时用它代替 `lc_mcp/data/gift_keywords.json` |
| `LCP_SHOP_NAMES` | 未设置 | 设为 `0` 时商店必买只用 AALC 图标模板;设为 JSON 文件路径时用它代替 `lc_mcp/data/shop_gifts.json` |
| `LCP_THEME_PACK_SYSTEMS` | 未设置 | 设为 `0` 时卡包只按 AALC 原权重选;设为 JSON 文件路径时用它代替 `lc_mcp/data/theme_pack_systems.json` |
| `LCP_KEY_HOLD` | 未设置 | 设为 `0` 时任务进程的按键完全走 AALC 原逻辑(前台 `pyautogui.press`、不按住) |
| `LCP_KILL_KEY` | `end` | 任务子进程的急停键,如 `pause` / `scrolllock`;认不出的键名会报错而不是换成默认键 |
| `LC_PY` | 当前解释器 | `levelup.py`/`auto_cycle.py` 调用 MCP 用的 Python | | `LC_PY` | 当前解释器 | `levelup.py`/`auto_cycle.py` 调用 MCP 用的 Python |
## 开发 / 测试 ## 开发 / 测试
@@ -197,18 +308,40 @@ vendor\aalc\.venv\Scripts\python.exe -X utf8 scripts\mcp_probe.py find_image '{"
## Jev 镜牢执行器与真实反馈 ## Jev 镜牢执行器与真实反馈
`scripts/jev_mirror_agent.py` 通过 MCP bridge 操作游戏,普通分支经统一接口交给 Jev 或执行模型;战斗采用 P → 回车宏,事件先 SKIP,回车失效时使用当前按钮。它保留用户已配好的队伍,商店无可替换出战角色时至多刷新 4 次,加载期间不读取旧库存继续操作。 `scripts/jev_mirror_agent.py` 的 `--workflow auto` 默认把普通镜牢交给 AALC。
没有配置、决策模型要求或未完成速通记录时,先查 `task_status`,空闲后调用
`run_task({"task":"mirror","count":1})`,随即返回 `delegated` 和后续监控调用。
调用方继续轮询 `task_status`;脚本退出不代表通关。已有镜牢任务时返回 `monitoring`,
其他任务占用、用户停止、报错或状态不明时不会自动抢占或重试。
```powershell
# 普通镜牢:默认转交 AALC,不需要 Jev 配置
vendor\aalc\.venv\Scripts\python.exe -X utf8 scripts\jev_mirror_agent.py
# 明确启动新任务;先前有用户停止或失败时也需明确提出新任务
vendor\aalc\.venv\Scripts\python.exe -X utf8 scripts\jev_mirror_agent.py --workflow aalc --new-run
# 查看已交给 AALC 的任务结果,不启动下一局
vendor\aalc\.venv\Scripts\python.exe -X utf8 scripts\jev_mirror_agent.py --workflow aalc --resume
```
AALC 交接结果写入运行目录的 `aalc_mirror_status.json`;停止已交接的任务使用 `stop_task` 或急停键(默认 End)。
`JEV_STOP` 会阻止新的交接,但交接后不再由此脚本监听。`--steps` / `--seconds` 仅限制逐步模式。
`--workflow speedrun` 使用原有的特殊速通流程。为兼容现有调用,提供 Jev 配置、
`--decision-engine`、执行模型回调、`LC_FIXED_FALLBACK=1` 或未完成速通记录时,`auto` 保留逐步模式。
`--resume` 沿用已保存的流程;已有未完成速通局时,切换 AALC 必须明确指定 `--new-run`。
逐步模式通过 MCP bridge 操作游戏,路线等分支交给 Jev 或执行模型;战斗采用 P → 回车宏,事件先 SKIP,回车失效时使用当前按钮。它保留用户已配好的队伍,商店无可替换出战角色时至多刷新 4 次,加载期间不读取旧库存继续操作。
安装 AALC 依赖并启动常驻服务后,把 `OPENCODE_API_KEY` 设为自己的凭据,再运行: 安装 AALC 依赖并启动常驻服务后,把 `OPENCODE_API_KEY` 设为自己的凭据,再运行:
```powershell ```powershell
vendor\aalc\.venv\Scripts\python.exe -X utf8 scripts\jev_mirror_agent.py scripts\jev_config.example.json --steps 250 --seconds 1800 vendor\aalc\.venv\Scripts\python.exe -X utf8 scripts\jev_mirror_agent.py scripts\jev_config.example.json --workflow speedrun --steps 250 --seconds 1800
``` ```
运行数据默认写到 `~/lc_mcp/jev`,可用 `LC_JEV_HOME` 指定其他目录。创建该目录下的 `JEV_STOP` 文件即可停止;续跑前移除它。不要与 AALC 完整任务或另一个游戏执行器同时操作。 运行数据默认写到 `~/lc_mcp/jev`,可用 `LC_JEV_HOME` 指定其他目录。逐步模式下创建该目录的 `JEV_STOP` 文件即可停止;续跑前移除它。不要与 AALC 完整任务或另一个游戏执行器同时操作。
工具调用失败(截图暂不可用、按钮已消失等)会记入日志并重新观察画面,同一画面上同一动作最多尝试两次,不会因单次失败整局退出。 工具调用失败(截图暂不可用、按钮已消失等)会记入日志并重新观察画面,同一画面上同一动作最多尝试两次,不会因单次失败整局退出。
每局运行现在有独立标识。默认续跑尚未结束且上下文一致的当前局;已完成或没有运行记录时建立新局。重新开一局时使用 `--new-run`,明确要求续跑时使用 `--resume`。旧版本未完成记录会保留楼层和强化进度,但旧的领取及战斗标记不会作为本局完成证据;只有上下文而没有运行记录时会重置它。领取截图和返回大厅截图必须属于当前局,才能记录完成。 逐步模式每局运行有独立标识。默认续跑尚未结束且上下文一致的当前局;已完成或没有运行记录时建立新局。重新开一局时使用 `--new-run`,明确要求续跑时使用 `--resume`。旧版本未完成记录会保留楼层和强化进度,但旧的领取及战斗标记不会作为本局完成证据;只有上下文而没有运行记录时会重置它。领取截图和返回大厅截图必须属于当前局,才能记录完成。
```powershell ```powershell
# 新开一局:清除上一局的楼层、饰品与领取状态 # 新开一局:清除上一局的楼层、饰品与领取状态
+347
View File
@@ -0,0 +1,347 @@
# 待开发计划(BACKLOG)
按「收益 / 风险」排序。每条都带**证据**和**验收标准**,云端改完直接照着验。
最近一次实测记录见 [`feedback/2026-11-14/README.md`](feedback/2026-11-14/README.md),
接口与队名表见 [`feedback/2026-11-14/HANDOVER.md`](feedback/2026-11-14/HANDOVER.md),
实机回归清单:上一轮 [`feedback/2026-11-14/REGRESSION.md`](feedback/2026-11-14/REGRESSION.md),本轮 [`feedback/2026-11-15/REGRESSION.md`](feedback/2026-11-15/REGRESSION.md)。
图例:P0 = 现在是坏的/每天都在浪费;P1 = 明显影响质量;P2 = 打磨。
## 2026-11-14/15 实机回归后的状态
- 回归结果:[`feedback/2026-11-14/REGRESSION-RESULTS.md`](feedback/2026-11-14/REGRESSION-RESULTS.md)
- 问题与需求台账:[`ISSUES.md`](ISSUES.md)(I-xx 问题 / R-xx 需求,带证据和下一步)
| 条目 | 状态 |
|---|---|
| P0-1 商店清单 | 上游已修(`5/19/31` 非空),本地补丁已删 |
| P0-2 键盘寻路 | 本机键盘进节点 0/24 成功(旧版 32/32 也失败)。11-15 云端:按键改带扫描码并按住(疑似根因),连续 3 个节点进不去就停用 → I-05 待验 |
| P1-3 饰品按体系 | 已实机跑通(4 次里 2 次命中),继续攒样本 |
| P1-4 事件选项表 | 已挂上,但 17 条事件里 15 条未收录 → 11-15 云端补 3 条(6→9),其余等 `not_in_table` 选项行,见 I-07 / R-02 |
| P1-5 选队容错 | 通过;另补了"入场前切队"(I-01)和"选队页守卫"(I-02)。11-15 云端复查修了三处(I-13) |
| P2-6 商店按名字 | 已实机跑通(样本少,见 I-10) |
| P2-8 决策审计 | 通过(注意部署要重启服务,见 I-09) |
| 新增 | 开局「获得E.G.O饰品」弹窗死循环 → 11-15 云端兜底(I-06 / R-04)待验 |
| 新增 | 卡包按体系(R-01):11-15 云端用 wiki.gg 数据做了「卡包 → 体系」表并按体系加分,待验 |
---
## AALC 上游升级到 V1.6.1(2026-11-14 云端)
`vendor/aalc` 从 `e1d1749`(V1.6.1-beta.11)升到 `2fcb1b4`(V1.6.1,17 个提交)。与本仓库补丁有关的:
| 上游提交 | 改了什么 | 对本仓库的影响 |
|---|---|---|
| `8196e72` | 商店三个清单改按 `assets/images/default/share/...` 列目录 | P0-1 上游已修,本地补丁删掉;`tests/test_shop_lists.py` 改成守着上游非空(5/19/31) |
| `18deb77` | 事件里找 "???" 改成 `find_element` + 自己点;小指良单通模式改点别的选项 | P1-4 原来挂在 `click_element("event/unknown_event.png")` 上,**升级后会悄悄失效**;已改挂 `find_element`,单通模式也测了 |
| `3980b58` | 判定成功率徽章识别前先把红色(低/极低)涂黑 | 不涉及补丁;判定选人更准 |
| `a3b6766` | 饰品奖励"选二"先于"选一"判断 | P1-3 只重排卡片顺序,不受影响(单测执行的就是新版 `acquire_ego_gift`) |
| `0f456e3` `732002f` | 开局饰品按优先级逐个点,模板 0.8→0.7→锚点坐标兜底 | 不涉及补丁 |
| `fb2ef56` | `check_game_alive` 要求进程**和**窗口(`UnityWndClass` + `game_title_name`)都在;进程起来 180 秒还没窗口就杀掉重启 | 实机留意:窗口标题改过或被隐藏时会被当成僵尸进程 |
| `d4c9004` | ONNX 寻路模型会话缓存 | P0-2 调的 `identify_nodes` 变快,接口不变 |
为避免再出现"上游改写法、补丁悄悄失效",事件表、饰品排序、商店按名字三个补丁安装时先查上游源码里还有没有被拦截的那个调用;
没有就记 `[ERROR] ... 挂不上` 并跳过,`task_status` 的 `errors` 里能看到。
---
## P0-1 商店「必买 / 必卖 / 公式合成」清单恒为空
**现状**:`tasks/mirror/__init__.py` 用旧路径加载模板:
```python
must_purchase_path = "./assets/images/share/mirror/shop/must_purchase"
```
实际图片在 `./assets/images/default/share/mirror/shop/must_purchase/`(5 张:`carmilla`、`homeward`、
`lithograph`、`phlebotomy_pack`、`piece_of_relationship`),`assets/images/share` 根本不存在。
运行时实测:
```
must_purchase 0
must_be_abandoned 0
fusion_result 0
```
后果:`in_shop.py:157` 的购买循环、`:564` 的废弃识别、公式合成全部空转。2026-11-14 进店 51 秒、
打印了三次「开始购买必买项」却没买一件。
**目标**:三个清单按当前 `path_manager` 的图片根(`default/share`、`dark/share`…)加载,且支持中英文资源目录。
**验收**:
- [ ] `python -c "import tasks.mirror as m; print(len(m.must_purchase), len(m.must_be_abandoned), len(m.fusion_result))"` → `5 19 31`
- [ ] 单测覆盖:清单非空、路径含 `default/share`、`dark` 主题下也能解析
- [ ] 实机进店日志能看到真正的购买动作(`购买` 后出现 `ego_gift_get_confirm`),且余额变化
**涉及**:`tasks/mirror/__init__.py`(`vendor`!)→ 若要遵守「不改 vendor」,就在 `lc_mcp/aalc_patches.py`
里于 import 后重建这三个列表,并加一条注释说明上游路径缺陷。
**风险**:低。纯路径/清单;不改判定逻辑。
**状态(2026-11-14 云端)**:上游 V1.6.1(`8196e72`)已修,本地补丁 `install_shop_lists()` 已删。
`tests/test_shop_lists.py` 执行上游真实的 `tasks/mirror/__init__.py`,守着三个清单是 5/19/31 且每张图都找得到。
下面是当初的分析,留作记录。
- 根因:上游 `ebb6629`(调整图片路径)把图片挪到 `assets/images/<主题>/<语言>/`,`tasks/mirror/__init__.py` 没跟着改。
按名字找图那一层(`path_manager` 依次搜各主题/语言目录)没坏,只是列目录列空了。
- 修法:`install_shop_lists()` 在 `mirror` / `all` 任务里按 AALC 的六个图片根(`dark|default` × `zh_cn|en|share`)
合并去重,**原地** `extend` 这三个列表——`in_shop.py` 用 `from tasks.mirror import ...` 在导入时绑定了列表对象,
重新赋值对它无效。上游清单已非空时不动。
- 补丁只在任务进程里生效,上面那条 `python -c` 仍会打印 `0 0 0`。离线等价验证是 `tests/test_shop_lists.py`
(执行上游真实 `__init__.py` 得到 `0 0 0`,补丁后为 `5 19 31`)。实机看任务日志里这一行:
`[lc_mcp] patch: 镜牢商店清单按 assets/images/<主题>/<语言> 补齐: must_purchase=5, must_be_abandoned=19, fusion_result=31`
---
## P0-2 镜牢走位被配置降级成「只按 ↑」
**现状**:`config.yaml` 里 `mirror_keyboard_navigation: true` + `mirror_keyboard_simple_pathfinding: true`,
`mirror.py:1128` 因此走 `search_road_simple_keyboard()`:每层按两次 ↑ 进最上面的节点,不看节点类型。
Dijkstra 那套(`search_road.py:735`,代价 event 1 / shop 2 / battle 4 / boss·focused 6 / risky 7)完全没跑。
**目标**(二选一,云端定):
- A:默认改用 Dijkstra,只在检测到「鼠标拖地图卡死」时降级为简单键盘;
- B:保留简单键盘,但把「↑ 的第一个节点」换成「按节点类型挑可达节点」。
**验收**:
- [ ] 一局里至少 3 层,日志能打印每层选中的节点类型与理由
- [ ] 事件/商店节点占比 ≥ 现状(对比 11-14 这局:3 层只进过 1 次商店)
- [ ] 不出现寻路卡死(连续 60 s 无 `enter_assets` 即算失败,应回退简单键盘)
**涉及**:`tasks/mirror/search_road.py`、`tasks/mirror/mirror.py:1128`、`config.yaml` 默认值(`assets/config/config.example.yaml`)
**风险**:中。`simple_pathfinding` 当初是为了规避鼠标拖拽卡死加的,去掉要有回退开关。
**状态(2026-11-14 云端)**:选 **B**,已实现,待实机验收。
- 不选 A 的原因:常规寻路(`search_road_from_road_map`)先用 `mouse_drag` 把巴士拖到固定位置,第二段拖动只受
超时限制、超时还会 `back_init_menu()`;连线识别 `identify_road` 依赖 `my_crop`,HANDOVER 已证实它在本机坐标不对。
- 做法:`install_typed_keyboard_road()` 替换 `search_road_simple_keyboard`(`search_road` 和 `mirror` 两个命名空间)。
仍只按键、不拖地图:找到巴士 → 用 AALC 自带 ONNX 模型整屏识别(不裁剪)→ 取巴士右侧一列、按相对行映射成
U/M/D → 按上游 `all_node_weight`(event 1 < shop 2 < battle 4 < boss/focused 6 < risky 7)依次按 `up/right/down`,
每按一次都用原来的 `_keyboard_enter_succeeded()` 确认;都进不去就调用原函数按 ↑。最多 3 次按键,不会循环。
- 只看下一列,是一步贪心,不是整层最优路线。
- 回滚:任务环境变量 `LCP_TYPED_ROAD=0` 不装补丁;或在 AALC 里关掉简单键盘寻路,回到上游常规寻路。
- **待实机确认的假设**:方向上没有连线时按该方向键不会进入别的节点(应当没有"进入"按钮,补丁随即换下一个方向)。
回归时对照日志 `[lc_mcp] 键盘寻路: 进入 X 方向的 <类型>` 与实际进入的节点类型;若对不上,说明按键语义与假设不符。
- 日志:每一步打印 `下一列 U=event(1) D=shop(2) M=battle(4)` 与最终进入的方向、类型和理由。
---
## P1-3 饰品三选一加「体系优先」
**现状**:`mirror.py:1360 acquire_ego_gift()` 只看两件事——是不是白棉花、是不是「已持有」,
然后拿第一张。**完全不看 `team_system`**。
**目标**:可配置的关键词优先表(例如流血队:`流血 / 出血 / 血迹`),命中则加权;仍旧排除已持有与白棉花。
**验收**:
- [ ] 单测:给定候选文本列表 + 体系,选出预期那一张(含「全部已持有」「全是白棉花」边界)
- [ ] 实机:流血队一局里,三选一命中体系关键词的比例 > 0(日志统计)
- [ ] 关闭该配置时行为与现在完全一致(可回滚)
**涉及**:`tasks/mirror/mirror.py`、`lc_mcp/aalc_patches.py`(建议做成可配置关键词表,放 `config.yaml` 或独立 yaml)
**风险**:中。OCR 有误读(`震颐`/`沉论`/`编#16`),关键词要容忍错字。
**状态(2026-11-14 云端)**:已实现,待实机验收。
- 核对上游时发现「完全不看体系」只对一张、两张卡成立:三张卡时 `acquire_ego_gift` 会用
`acquire_ego_gift/<体系>.png` 图标模板(阈值 0.85)把命中的卡排前面,只是没有日志能证明它在本机生效。
- 做法:`install_gift_preference()` 包住 `Mirror.acquire_ego_gift`(只管 `type=1` 的选卡界面,`type=2` 拒绝饰品原样放行)。
调用期间临时替换 `auto.find_element`:上游取到卡片列表(`acquire_ego_gift_card.png`,多目标)时,
整屏 OCR 一次,按坐标把每行文字归到卡上(范围与上游判断白棉花/已持有的一致),命中体系关键词行数多的排前面。
排序稳定,之后上游原逻辑照旧:白棉花跳过、已持有排后。调用结束还原 `find_element`。
- 三张及以上(2026-11-14 复查修正):上游逐张看卡,认出体系图标的卡 `my_list.insert(0, ...)`,**后看的排到最前**,其余 append。
最初直接把排好的顺序交给上游,两张命中关键词的卡都带图标时会被它倒过来,反而先拿命中少的那张。现在交给上游的顺序是
「没命中的(原顺序)+ 命中的(倒着)」,上游查体系图标时对命中关键词的卡答"有";拼出来是
命中多的 → 命中少的 → 只认出图标的 → 其余,再按已持有排后。两张卡的分支不看图标,直接按命中多少给。
- OCR 直接读引擎的逐行结果,不用 `_run_ocr_for_text` 的 `{文本: 坐标}`(两张卡上同一句会被合并成一条)。不用 `my_crop`。
- 关键词表 `lc_mcp/data/gift_keywords.json`(JSON,不加依赖);匹配前做与选队相同的归一(空白/全半角/`震颐` 等误读),
英文不分大小写。表读不了记 `[ERROR]` 并不装补丁。
- 回滚:`LCP_GIFT_KEYWORDS=0` 不装补丁,行为与上游完全一致;`LCP_GIFT_KEYWORDS=<路径>` 换表。
- 关键词按零协汉化核对(`LLC_zh-CN/EgoGiftCategory.json`、`BattleKeywords.json`):烧伤 流血 震颤 破裂 沉沦 呼吸法 充能
斩击 突刺 打击。饰品描述里的 `[Combustion]` 等占位符在游戏里就显示成这些名字。原表的 `出血` 在汉化里一次都没出现,已删。
- 只按主体系;第二体系仍只由上游的图标匹配处理。
- 单测执行上游真实的 `acquire_ego_gift`(`tests/test_gift_preference.py`),覆盖两张/三张卡、选一/选二、
已持有、白棉花、全是白棉花、误读、无命中,以及带体系图标的卡(命中的都带图标、命中的没认出图标、只认出图标)。
- 实机验收:日志 `[lc_mcp] 饰品选择(体系 bleed): 第1张=0 第2张=1(流血) 第3张=0; 命中体系关键词, 先看第2张`;
统计「命中体系关键词」与「未命中体系关键词」的行数即得命中比例。
---
## P1-4 事件选项策略可配
**现状**:`mirror.py:1230 event_handling()` 固定策略——能点「判定 / check」就点,然后**永远点第一个选项**,
最后找 `continue/继续`。跟体系、跟当前血量都无关。
**目标**:支持一张「事件 → 选项」表(JSON/YAML),未收录的退回「第一个选项」。
**验收**:
- [ ] 表里命中的事件按配置点;未命中的行为不变
- [ ] 单测:事件文本 → 选项索引映射,含缺省分支
- [ ] 至少录入 5 个高频事件(可从 `docs/mirror_dungeon_speedrun_notes.md` 的既有结论里抄)
**涉及**:`tasks/mirror/mirror.py`、新增数据文件(建议 `lc_mcp/data/event_choices.yaml`,不要塞进 vendor)
**风险**:低-中。选项点错可能拿不到奖励,但不会卡死。
**状态(2026-11-14 云端)**:已实现,待实机验收。按零协汉化重写过一次(见下)。
- 做法:`install_event_choices()` 包住 `Mirror.event_handling`,调用期间临时替换 `auto.find_element` 和 `auto.mouse_click`。
上游每轮挑选项的第一步是 `find_element("event/unknown_event.png")`,补丁在这一步插一次判断:
`event/select_first_option_assets.png` 多目标匹配到选项框(每项的左边缘)时整屏 OCR,把右侧同一行的文字归到各项;
选项对上表里某个事件,就点表里那一项的左边缘,并把这个位置当成 "???" 交还上游(`event_chance -= 1`, 重新截图)。
上游随后拿这个位置再点一次的那下会被吞掉;小指良单通模式下它会再找一次 "???",这时返回"没有",不会改点别的选项。
其余情况(不在选项画面、没认出事件、要点的那项没读到)照常交给上游。
- **按选项原文认事件,不按事件名**:零协汉化的事件数据(`LLC_zh-CN/ActionEvents_*.json`)只有叙述和选项,没有标题字段,
画面上也不保证有事件名。每条规则写同一屏其它选项的原文(`options`,全部出现才算)和要点的那一项(`text`)。
比较前去空白、全角转半角、去标点。一次事件里按表最多点 5 次,点了没反应就交回上游。
- 表 `lc_mcp/data/event_choices.json`,6 条,选项原文照抄零协汉化(`LocalizeLimbusCompany@231a8bc`),带事件 id 便于回查;
选择依据仍是 `docs/skills/limbus-mirror-speedrun/references/event-choices.md`:
| 事件 | 汉化 id | 点哪项 | 结果(汉化选项说明) |
|---|---|---|---|
| 红色坐像 | 901010 | 侧耳倾听。 | 无判定无战斗;2 判定,3 战斗 |
| 炸鸡对决 | 971001 | 鸡肉就是鸡肉喽。 | 1 件烧伤 + 1 件破裂饰品 |
| 鸡群的激情探戈 | 971003 | 视而不见。 | 1 件泛用饰品 |
| 梦中的电子羊 | 901038 | 你不是特别的。 | 1 件泛用饰品 |
| 失明巨人递来患者记录 | 901085 | 说上面什么都没有写。 | **判定**(忧郁/怠惰);1 也是判定且门槛更高 |
| 破碎罗盘(冻僵的尸体指路) | 901095 | 返回。 | 直接结束(第 4 项) |
- 核对时删掉的:
- `往昔的睡袋`(2)与 `折射的往昔的睡袋`(1):汉化里只有一个睡袋事件(971058,标题"折射的往昔的睡袋"),
选项是「聆听喘息声」(傲慢/嫉妒判定)和「捂住耳朵」(无说明);参考文档对两个版本的"2"说法相反(回复 / 降 20 理智),
拿不准,交回 AALC 原逻辑(有 "???" 先点 "???",否则点优势判定);实机日志里 `not_in_table` 会记下它的选项,再决定要不要补。
- `浸染棉花`(3)、`终末日历`(2):汉化的镜牢事件里找不到对应选项,无法按原文认。
- 原来的 `index`(按第几项)规则全部去掉:有了原文就不需要编号,参考文档也提醒过 Wiki 编号与当前顺序可能不同。
- 原表说明写的"都是无判定/无战斗"不对:失明巨人两项都要判定,已在表里标 `check: true`。
- 巴士 Wiki(wiki.biligame.com/limbuscompany)的接口查了几次后就返回人机验证页,没法自动核对;事件结果仍以参考文档(灰机 Wiki)为准。
- 日志:每屏选项只打一次,`[lc_mcp] 事件 <名>: 1=… | 2=…; 按表选第 N 项「…」`;没收录时
`事件选项: 1=… | 2=…; 表里没有这个事件, 交给 AALC`,可直接拿来补表(写零协汉化的原文)。
- 回滚:`LCP_EVENT_CHOICES=0`;表读不了、或上游不再调用 `find_element("event/unknown_event.png")` 时记 `[ERROR]` 并不装补丁。
- 单测执行上游真实的 `event_handling` 和 `click_option_avoiding_unknown`(`tests/test_event_choices.py`),覆盖按表点、
只点一次、表优先于 "???"、单通模式、未收录与上游一致、要点的项没读到、第二屏交回上游、点击没反应的次数上限。
- **待实机确认**:选项文字与左边缘同一行的假设(`EVENT_OPTION_ROW`);`not_in_table` 的日志里选项文字是否完整。
---
## P1-5 选队补丁的鲁棒性
**现状**:`_select_team_by_name()` 精确匹配 + 4 轮翻页。已知薄弱点:
- OCR 误读(实测把「震颤」读成「震颐」、「沉沦」读成「沉论」、「编队#16」读成「编#16」)
- 队名带后缀(「流血队」「流血(X)」)会失配
- 只按「顶栏名字」确认,若顶栏字号变化会误判
**目标**:别名表 + 归一化(去空格/全半角/常见误读)+ 失败时输出候选列表便于排查。
**验收**:
- [ ] 把队名临时改成「流血队」也能选中(别名/前缀匹配,仍需唯一)
- [ ] 误读样本(`震颐`→`震颤`、`沉论`→`沉沦`)能正确归一
- [ ] 失败日志里打印「这一屏看到了哪些名字」,而不是只说没找到
**涉及**:`lc_mcp/aalc_patches.py`、`tests/test_system_team_selection.py`
**风险**:低。只是匹配变宽,需保证「唯一命中」才点,避免选错队。
**状态(2026-11-14 云端)**:已实现,待实机验收。
- 归一化 `normalize_team_name()`:去所有空白,NFKC 全角转半角(`#`→`#`、`()`→`()`),再按 `TEAM_OCR_FIXES`
改回实测误读(`震颐`→`震颤`、`沉论`→`沉沦`、`编#`→`编队#`)。新误读往这张表里加。
- 列表挑选 `pick_team_item()`:先找精确匹配(多个名字时按 `SYSTEM_TEAM_NAMES` 里的顺序);没有再看前缀匹配
(名字至少两个字,后面带任意后缀),**这一屏只有一条才点**,两条以上记日志不点、继续翻页。
- 选队 OCR 读引擎的逐行结果(2026-11-14 复查修正):原来经 `_run_ocr_for_text` 的 `{文本: 坐标}`,选中某队后顶栏和列表里是同一个名字,顶栏那条会被列表那条覆盖,「已经是这支队」和点完后的确认都会读不到顶栏;旧测试用假的成对结果模拟了重复,真实 dict 做不到,所以没测出来。
- 顶栏确认只认归一后的精确匹配:「已经是这支队」的判断和点完后的确认都一样。顶栏是 `流血队` 时会回列表里确认唯一再点一次,
避免把 `流血2` 当成 `流血`。
- 日志:每屏没命中时打印 `第 N 屏没有 流血; 这一屏的名字: 剧情关卡/斩击/...`;点了但顶栏没变时打印顶栏读到了什么。
- 限制:唯一性只按当前这一屏判断;相似队名分在两屏时(例如 `流血队` 在第 2 屏、`流血2` 在第 3 屏)会点先出现的那条。
顶栏位置仍是写死的 `TEAM_HEADER`,字号/布局变了要按日志里「顶栏读到」调整。
- 实机验收:把「流血」改名成「流血队」跑一局,日志应出现 `编队列表里找到 流血队 @(...), 前缀匹配 流血`
和 `已按体系名选中编队 流血队`。
---
## P2-6 商店必买清单本地化
**现状**:必买靠 5 张**英文/图标模板**;汉化后商店里的名称是中文,模板匹配靠图标尚可,但新增饰品无法覆盖。
**目标**:支持「饰品中文名 → 优先级」的配置表,OCR 命中即买;模板作为兜底。
**验收**:单测 + 实机一局至少一次由名字命中的购买。
**涉及**:`lc_mcp/aalc_patches.py`(包一层购买判定)、新增数据文件。
**状态(2026-11-14 云端)**:已实现,待实机验收。
- 截图 `docs/feedback/mirror_20261002_181322/special_shop_missed.png` 证实商品格下面写着饰品中文名(`无头肖像`、`辉光变动仪`…),
不用点开就能 OCR。
- 做法:`install_shop_by_name()` 包住 `Shop.buy_gifts`,调用期间在 `must_purchase` 列表最前面临时插 3 个占位项。
上游 `for commodity in must_purchase: auto.click_element(commodity, ...)` 点到占位项时改成:以 `shop_coins_assets.png`
(上游 `re_sort_points` 用的同一个锚点)为基准,在商品格范围内整屏 OCR,名字与表里**完全一致**(允许 `+` 后缀)就点名字上方
155(1440 标定)的图标;之后"购买 → 确认"仍是上游那段循环。没命中的截图不重复 OCR;同一名字一次进店最多点 4 次
(钱不够时上游会反复重点)。调用结束把占位项拿掉、还原 `click_element`。
- 表 `lc_mcp/data/shop_gifts.json`:默认就是 AALC 那 5 张必买模板对应的饰品,名字按零协汉化:缘分残片、卡蜜拉、采血包、归途、石版字符
(顺序是建议:立即见效的在前)。核对描述发现 AALC 说的"回血饰品"只有后三个是回血。图标模板仍在后面兜底(名字读错时照样买)。
- 审计:按名字找到记 `shop` / `name_match`;随后的购买仍记 `purchase_clicked`,`choice` 是 `shop_by_name`。
`aalc_task` 里这个补丁装在商店审计之后,审计才看得到占位项那一下。
- 回滚:`LCP_SHOP_NAMES=0`;表读不了、或上游不再逐个 `click_element(must_purchase)` 时记 `[ERROR]` 并不装补丁。
- 单测执行上游真实的 `Shop.buy_gifts`(`tests/test_shop_by_name.py`):名字命中、表顺序、名字读错时模板兜底、买不起时的点击上限、
与审计一起装;坐标按截图实测(金币 (827,206)@1080,名字行在 +409/+716、图标在名字上方 155,均为 1440 标定)。
- **待实机确认**:普通商店与截图里的特殊商店布局一致;实机一局至少一次 `shop.name_match`;
买不起时上游会在购买框开着时重点商品(模板也一样),按名字重点的那几下落在框上是否无害。
---
## P2-7 观测饰品按体系自动勾选
**现状**:`observe_ego_gift_selected` 要人在 AALC 界面一个个勾;没勾就等于关闭观测。
**目标**:按 `team_system` 自动勾一组默认饰品(可覆盖),并在开跑前写回配置。
**验收**:`config.yaml` 里 `observe_ego_gift_selected` 与体系匹配;日志打印勾了哪些。
**涉及**:`lc_mcp/aalc_task.py`(apply_overrides 类似机制)、`app/observe_ego_gift_selection.py` 的序列化格式(只读参考)。
**状态(2026-11-14)**:不做。用户确认观测饰品不需要自动勾选。
---
## P2-8 决策审计日志
**现状**:选队/卡包/饰品/商店的决策只散落在 DEBUG 日志里,事后要人肉 grep。
**目标**:每局写一份 `~/lc_mcp/runs/<task>.decisions.jsonl`:时间、阶段、画面摘要、候选、选中项、理由。
**验收**:一局结束后能直接统计「卡包选择理由 ×N」「三选一命中体系 ×N」「商店购买 ×N」。
**涉及**:`lc_mcp/aalc_patches.py`、`lc_mcp/tasks.py`(结果归档)。
**状态(2026-11-14 云端)**:已实现,待实机验收。
- 文件与任务日志同名:`~/lc_mcp/runs/task_<时间>_<任务>.decisions.jsonl`。TaskRunner 通过 `LCP_DECISIONS` 把路径传给子进程,
清理旧日志时一起删;直接 `python -m lc_mcp.aalc_task` 运行时不写。写失败只丢那一行。
- 每行 `time`/`stage`/`choice`/`reason` + 细节(候选、命中、选项文字…);`reason` 是用来计数的短类别,表见 README。
`task_status` 返回 `decisions: {path, counts: {stage: {reason: 次数}}}`。
- 来源:选队(P1-5)、键盘寻路(P0-2)、饰品(P1-3)、事件(P1-4)直接在补丁里记;
商店与卡包是只观察的补丁:`Shop.buy_gifts` 期间看 `purchase_assets` 是否点中、之前点的是哪件商品;
`select_theme_pack` 期间临时挂一个 logging handler,从上游自己的 `此次选择卡包关键词:X` 日志取结果和权重列表。
- 「画面摘要」只记了各决策用到的文字(选项、队名、命中关键词),没存截图。
- 验收对应:卡包理由 = `counts.theme_pack`,三选一命中体系 = `counts.gift.keyword`,商店购买 = `counts.shop.purchase_clicked`。
---
## 已知但暂不做的
| 项 | 原因 |
|---|---|
| 让 AALC 原生支持自定义队名 | 要改 `vendor/aalc`,submodule 升级会丢;补丁层已够用 |
| 自动识别「哪支队是流血队」 | 图像/文本都不可靠,靠命名约定(见 HANDOVER 第 4 节)更稳 |
| 改 `mirror_dungeon_speedrun_notes.md` 的路线结论 | 那是人工速通笔记,和 AALC 的自动寻路是两套,别混 |
+237
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` 可按需加词。
-2
View File
@@ -228,5 +228,3 @@ Get-ChildItem "$dir\convert_*.json" | ForEach-Object {
if ($m -and $m.secs -eq $r.elapsed_s) { "OK $($r.started)" } else { "MISMATCH $($_.Name)" } if ($m -and $m.secs -eq $r.elapsed_s) { "OK $($r.started)" } else { "MISMATCH $($_.Name)" }
} }
``` ```
+184
View File
@@ -0,0 +1,184 @@
# 对接说明:镜牢选队(2026-11-14)
给**云端开发**看的交接文件。目标:云端改代码 → 我这边 `git pull` → 实机回归 → 回传结果。
所以这里写清楚「改哪、别动哪、怎么验、验到什么程度算过」。
---
## 1. 仓库与运行环境
| 项 | 值 |
|---|---|
| 仓库 | `https://git.lingll.icu/yws/lc-mcp` |
| 当前分支 | `codex/feedback-unattended-setup-20261004` |
| 本机路径 | `D:\lc-mcp`(AALC 在 `vendor/aalc`,**submodule,不要改**) |
| Python | `vendor\aalc\.venv\Scripts\python.exe`(3.13) |
| 游戏 | `D:\SteamLibrary\steamapps\common\Limbus Company`(Steam build 26593955) |
| 汉化 | `LLC_zh-CN` 2026111301(自定义语言,游戏基础语言 = 韩语,OCR 语言识别为 `zh_cn`) |
| 分辨率 | 客户区 1280×720,`set_win_size: 720` |
| 常驻服务 | 计划任务 `LcMCPServer`,`127.0.0.1:8765`,日志 `~/lc_mcp/server.log` |
**测试入口**(本机验证统一用这个,不要直接跑 `main.py`):
```powershell
D:\lc-mcp\vendor\aalc\.venv\Scripts\python.exe -X utf8 -c "from lc_mcp import ..." # 单测
# 实机:通过 MCP 工具 run_task mirror,或
D:\lc-mcp\vendor\aalc\.venv\Scripts\python.exe -X utf8 -m lc_mcp.aalc_task mirror "{\"count\": 1}"
```
---
## 2. 本次改动(两个文件,均为增量,不改 vendor)
### `lc_mcp/aalc_patches.py`
新增一段(文件末尾,`install_default_battle_team` 之后):
```python
SYSTEM_TEAM_NAMES = {...} # 体系(system 字符串) → 游戏内编队名元组
TEAM_LIST_X_MAX / TEAM_LIST_Y_MIN / TEAM_LIST_Y_MAX # 左侧列表命中范围(客户区像素)
TEAM_HEADER = (170, 520, 90, 150) # 顶栏队名位置,用来确认选中
_team_ocr(auto) -> [(text, x, y), ...] # 整屏 OCR 逐行结果(同名保留)清洗,不排序
_in_list(x, y) / _in_header(x, y) # 区域判定
_scroll_team_list(auto, direction, times, distance) # +1=回顶部, -1=往下翻
_header_is(auto, names) / _wait_header(auto, names) # 顶栏确认(3 次 × 1.2s,归一后精确匹配)
_select_team_by_name(auto, names, log, rounds=4) # 主流程,返回 bool
install_system_team_selection(log=print) # 安装补丁,返回原始 select_battle_team
```
### `lc_mcp/aalc_task.py`
- import 里加 `install_system_team_selection`
- `run()` 里、`install_default_battle_team` 之后:
```python
if task in ('mirror', 'all'):
install_system_team_selection(log=log)
```
### 挂载点为什么是 `tasks.mirror.mirror`
`tasks/mirror/mirror.py` 在模块顶部 `from tasks.teams.team_formation import ... select_battle_team`,
之后 `select_mirror_team()` 用的是**模块全局名**。所以补丁必须替换
`tasks.mirror.mirror.select_battle_team`;改 `tasks.teams.team_formation.select_battle_team` 对镜牢无效
(日常本那条补丁 patch 的是 `scheme` 命名空间,两者互不影响)。
---
## 3. 接口契约(改的时候必须保住)
1. **`select_battle_team(num) -> bool`**:True = 已选中并确认在编队界面;False = 没选上,调用方会重试(最多 6 次)后抛 `unableToFindTeamError`。
2. **不能有副作用**:补丁只点击,不写配置文件;`Mirror.__init__` 的包装只读 `team_setting`。
3. **坐标空间**:一律按**客户区像素**(当前 1280×720)。缩放用 `cfg.set_win_size / 1440`,跟 AALC 其它地方一致。
4. **`auto._run_ocr_for_text(my_crop=None)` 返回 `{text: [cx, cy]}`**:`cx/cy` 是 box 中心;同名文本会互相覆盖。只把它转成列表并不能找回被覆盖的那条——2026-11-14 复查起 `_team_ocr` 直接读 OCR 引擎的逐行结果(`module.ocr.ocr.run(auto.screenshot)`,同一引擎、同样取框中心),引擎导入不了才退回 dict。
5. **不要用 `my_crop` 做界面裁剪**:实测裁剪坐标语义不可靠(裁 `(0,0,190,584)` 会读到右侧面板),统一「整屏 OCR + 坐标过滤」。
6. **点完必须验顶栏**:只点不验会出现「日志说成功,其实没换队」。
---
## 4. 体系队名表(本机账号实际状态,2026-11-14 截图核对)
左侧编队列表,从上到下:
| 顺序 | 列表显示 | 说明 | `team_system` |
|---|---|---|---|
| 1 | 剧情关卡 | 剧情用预设 | — |
| 2 | 斩击 | 打击体系队 | 7 |
| 3 | 突刺 | 突刺体系队 | 8 |
| 4 | 打击 | 打击体系队 | 9 |
| 5 | 烧伤 | 烧伤体系队 | 0 |
| 6 | 流血 | 流血体系队(**当前镜牢在用**) | 1 |
| 7 | 震颤 | 震颤体系队 | 2 |
| 8 | 破裂 | 破裂体系队 | 3 |
| 9 | 沉沦 | 沉沦体系队 | 5 |
| 10 | 呼吸法 | 呼吸体系队(代码里另有别名「呼吸」) | 4 |
| 11 | 充能 | 充能体系队 | 6 |
| 12+ | 编队#13 … 编队#40 | 默认名残留,未使用 | — |
> `#1`~`#12` 已不存在。任何按 `编队#N` 找队的逻辑在这个号上都会失败,这是本次问题的根。
>
> 队名改动后最好同步 `SYSTEM_TEAM_NAMES`。2026-11-14 起(BACKLOG P1-5)名字先归一(空白/全半角/`震颐`→`震颤` 等误读),
> 精确匹配优先;没有精确匹配时接受这一屏**唯一**的「名字+后缀」(`流血队`),不做任意子串。顶栏确认仍只认精确。
---
## 5. 验证方法
> 下面 5.2/5.3 是最初选队补丁的回归。2026-11-14 云端交付的整轮(寻路、选队容错、饰品、事件、商店、审计、AALC V1.6.1)
> 回归清单见 [REGRESSION.md](REGRESSION.md)。
### 5.1 单测(不需要游戏)
```powershell
cd D:\lc-mcp
vendor\aalc\.venv\Scripts\python.exe -m unittest discover -s tests -t tests -v
```
本次新增 `tests/test_system_team_selection.py`,覆盖:映射表完整性、区域判定边界、
`install_system_team_selection` 的挂载/回退行为(用假模块,不依赖 AALC/Windows)。
### 5.2 实机回归(需要游戏在运行)
```powershell
# 1) 确认补丁挂上
# 日志里应有:[lc_mcp] patch: 镜牢按体系名选队
# 2) 起一局
run_task(task="mirror", count=1)
# 3) 看这几行
# [lc_mcp] 镜牢体系 bleed -> 目标编队 流血
# [lc_mcp] patch: 已按体系名选中编队 流血 (或「当前已经是编队 流血, 无需切换」)
# [INFO] 楼层识别结果:当前为第1层
```
### 5.3 验收清单
- [ ] `select_battle_team` 返回 True 后,顶栏队名 = 目标队名(截图为准,不看日志)
- [ ] 连续两局:第二局走「已经是目标队,无需切换」分支
- [ ] 把 `team_system` 改成 7(斩击)能选到「斩击」;改回 1 能选回「流血」
- [ ] 目标名不存在时(例如临时改成 `编队#999`)能 4 轮内返回 False,不卡死、不乱点
- [ ] 列表滚动后不会把队伍页留在错误位置(后续 `罪人编队` 步骤仍能正常执行)
---
## 6. 云端开发注意事项
- **不要改 `vendor/aalc`**:submodule 固定 commit,改了本地能跑、更新就丢。所有行为差异走 `lc_mcp/aalc_patches.py`。
- **不要引入本机绝对路径**(`D:\...`、`C:\Users\YWS-HHH\...`);已有代码里 `LC_*` / `LCP_*` 环境变量是既有限制。
- **失败要显式**:选队失败返回 False 让上层重试,不要静默 fallback 到 `编队#N`(这号没有 `#N`,会选中错的队)。
- **日志格式**:沿用 `[lc_mcp] ...` 前缀,`task_status` 的 `errors` 扫描依赖 `[ERROR]`。
- 新增依赖请加到 `pyproject.toml`,并确认 `uv sync` 后 `vendor/aalc/.venv` 能跑。
---
## 7. 拉取与回传
```powershell
cd D:\lc-mcp
git fetch origin
git checkout <云端分支>
git pull
git submodule update --init --recursive
vendor\aalc\.venv\Scripts\python.exe -m unittest discover -s tests -t tests
# 实机回归 → 结果写回 docs/feedback/<日期>/
```
我这边回归后会补:跑团日志、截图路径、验收清单勾选结果,以及新发现的问题。
本轮要勾的清单在 [REGRESSION.md](REGRESSION.md),勾选结果在 [REGRESSION-RESULTS.md](REGRESSION-RESULTS.md),
问题与需求台账在 [`docs/ISSUES.md`](../../ISSUES.md)。
2026-11-15 云端按台账交付的下一轮清单在 [`../2026-11-15/REGRESSION.md`](../2026-11-15/REGRESSION.md)。
---
## 8. 部署:拉取后必须重启常驻服务
`TaskRunner` 在**常驻服务进程**里给任务子进程设 `LCP_DECISIONS` 等环境变量。
只 `git pull` 不重启,子进程拿到的还是旧环境 → `decisions.jsonl` 不生成、`task_status.decisions` 为空。
```powershell
Stop-ScheduledTask -TaskName LcMCPServer
Start-ScheduledTask -TaskName LcMCPServer
# 验证:Get-NetTCPConnection -LocalPort 8765 -State Listen
```
2026-11-14 第一局就踩了这个:代码是新的、服务是旧的,`decisions.jsonl` 一直不落盘。
+193
View File
@@ -0,0 +1,193 @@
# 2026-11-14 汉化更新 + 镜牢选队根因与局内决策实测
本次两件事:**更新游戏汉化**,以及**把「镜牢一直选不上队」查清楚并修掉**。
后半段顺带核了镜牢局内的四类决策(走位 / 卡包 / 饰品 / 商店),发现两处真实缺陷,一并记在
[`BACKLOG.md`](../../BACKLOG.md) 里。
后续:云端按 [`REGRESSION.md`](REGRESSION.md) 交付了 9 个补丁,本机回归结果在
[`REGRESSION-RESULTS.md`](REGRESSION-RESULTS.md);所有问题与需求统一记账在
[`docs/ISSUES.md`](../../ISSUES.md)。
## 环境
| 项 | 值 |
|---|---|
| 系统 | Windows 10 Pro 19045,远程会话,无人值守 |
| 游戏 | Steam 版 Limbus Company,`D:\SteamLibrary\steamapps\common\Limbus Company` |
| 游戏版本 | 更新前 build `26318463`(1.118.1,11-05)→ 更新后 build `26593955`(11-14 08:20 落盘) |
| 汉化 | `LimbusCompany_Data\Lang\LLC_zh-CN`,2026101602 → **2026111301** |
| AALC | `vendor/aalc`(git submodule,未改源码) |
| 运行方式 | MCP `run_task mirror`,AALC 子进程,前台点击 + 罗技驱动点击 |
## 一、汉化更新
上游:`LocalizeLimbusCompany/LocalizeLimbusCompany` release `2026111301`(2026-11-13 发布)。
装法按官方手动流程:**干净重装**(移走旧 `LLC_zh-CN` → 解压新包到游戏根目录),字体包不随
release 发布,单独从 `Fonts/LLCCN-Font.7z` 来(自 2025-04 未变,直接沿用旧文件)。
| 步骤 | 结果 |
|---|---|
| 旧包备份 | `D:\codex\_limbus_l10n_dl\backup-LLC_zh-CN-2026101602`(2350 文件 / 45.1 MB) |
| 下载 | `LimbusLocalize_2026111301.zip` 6,080,228 B,SHA256 `E63782A0…6E14665` |
| 解压 | 2385 个文件,全部 SHA256 与 zip 内一致(0 不匹配) |
| JSON 校验 | 2384 个 JSON 全部可解析,0 空文件 |
| 字体 | `Font\Context\ChineseFont.ttf` 22.8 MB,TTF 头 `00 01 00 00` 正常 |
| 配置 | `Lang\config.json` 未动,仍 `"lang": "LLC_zh-CN"` |
相对旧版新增:`walpu10` 系列事件/敌人/EGO、`Mirror8` 成就与卡包、`StoryData E100X–E103X`、
新人格语音(`P10316/P10617/P10717/P11017/P11116`)、`SynergyKeyword`、`EventVerificationUIText` 等 35 个文件。
> 注:游戏第一次启动时弹「当前游戏客户端不是最新版本」,必须先更 Steam 客户端;更完再跑就正常了。
## 二、镜牢选队:为什么一直「选不上」
### 症状
`run_task mirror` 后 AALC 卡在选队:每 5 秒对左侧列表 OCR 一次,页码一路往上爬,然后重来。
```text
08:34:27 开始执行 寻找队伍
08:34:50 OCR: 编队#13 编队#14 编队#15 编#16
08:35:00 OCR: 编队#19 编队#20 编队#21 …
08:35:15 OCR: 编队#33 编队#34 编队#35 …
08:37:00 又回到 编队#19 … ← 第 N 轮
```
### 根因
`config.yaml` 里 `team_number: 1`,AALC 的 `select_battle_team()` 只会按
`编队#N` / `TEAMS #N` 这个**字面名字**去 OCR 找队(`tasks/teams/team_formation.py:167`)。
而这个号的编队**是按体系命名的**,不是默认名;`编队#1`~`#12` 也已经不存在:
```text
左侧列表(从上到下):
剧情关卡
斩击 突刺 打击 烧伤 流血 震颤 破裂 沉沦 呼吸法 充能 ← 10 支按体系命名
编队#13 … 编队#40 ← 默认名残留
```
所以找 `编队#1` 永远找不到 → 翻满 10 页 → 重试 6 轮 → `无法寻得队伍,请检查队伍名称是否为默认名称`。
### 修复
新增 `install_system_team_selection()`(`lc_mcp/aalc_patches.py`),在 `mirror`/`all` 任务里挂载。
**不改 `vendor/aalc` 源码**,只替换 `tasks.mirror.mirror` 命名空间里的 `select_battle_team`:
```
team_system → 队名
0 烧伤 / 1 流血 / 2 震颤 / 3 破裂 / 4 呼吸法(兼容"呼吸")
5 沉沦 / 6 充能 / 7 斩击 / 8 突刺 / 9 打击
```
选队流程:
1. 先看顶栏是不是已经是这支队(是就直接返回,不动列表)
2. 不是 → 点空白、把列表向下拖回顶部
3. 整屏 OCR,只保留左侧列表区域(`x<260`,`300<y<640`)里的条目
4. **精确匹配**队名 → 点击 → 轮询顶栏最多 3 次 × 1.2 s,顶栏变成该名字才算成功
5. 没找到就往下翻(每次 3 拖),最多 4 轮;4 轮都失败返回 False,交给 AALC 原来那层重试
两个细节是踩出来的:
- **不能用 `my_crop`**:AALC 里裁剪坐标的语义跟客户区像素对不上(实测裁 `(0,0,190,584)` 会 OCR 出右侧面板的文字),所以改成整屏 OCR 再按坐标过滤。
- **点完不能立刻判**:顶栏要 1~2 帧才刷新,实测 0.8 s 时还没变,1.2 s×3 才稳。
实测日志:
```text
[lc_mcp] 镜牢体系 bleed -> 目标编队 流血
[lc_mcp] 编队列表里找到 流血 @(130,492)
[lc_mcp] patch: 已按体系名选中编队 流血
[INFO] 楼层识别结果:当前为第1层
[INFO] 此次选择卡包关键词:信仰
```
(第二次跑因为上一次已经停在「流血」上,直接命中「当前已经是编队 流血, 无需切换」。)
## 三、局内四类决策:代码实际怎么走
| 决策 | 现状 | 代码位置 |
|---|---|---|
| 走位 | **被配置降级成瞎走**:`mirror_keyboard_simple_pathfinding: true` → 每层只按 ↑ 选最上面节点 | `mirror.py:1128` → `search_road.py:145` |
| 卡包 | 规则明确:关键词权重表取最高,低于阈值就刷新(≤3 次) | `select_theme_pack.py` |
| 饰品三选一 | **不看体系**:排白棉花 → 排「已持有」→ 拿第一张 | `mirror.py:1360` |
| 商店 | 必买/必卖清单为 **0**(路径写错),只剩体系强化/刷新/合成/治疗 | `in_shop.py:157`、`tasks/mirror/__init__.py` |
| 事件 | 固定:能「判定」就判定,然后永远点第一个选项 | `mirror.py:1230` |
### 3.1 走位
```python
# search_road.py:145
for attempt in range(2):
auto.key_press("up")
if _keyboard_enter_succeeded():
return True
```
关掉 `mirror_keyboard_simple_pathfinding` 才会走 Dijkstra(`search_road.py:735`),节点代价表
(`search_road.py:609`,越小越优先):
| 节点 | 代价 |
|---|---|
| event | 1 |
| shop | 2 |
| battle | 4 |
| boss / focused / abnormality | 6 |
| risky_encounter | 7 |
| 未知 | 999(不可达) |
### 3.2 卡包
`preferred_thresholds: 0`,权重表在 `theme_pack_list.yaml`(多数 0、`chick: 1`、未知 -5)。
本次三次选择:`信仰` → `赌徒` → `情感懒`。
### 3.3 饰品三选一
`acquire_ego_gift()`:排除白棉花(除非 `not_skip_whitegossypium`)→ OCR「已持有 / Owned」→
优先没持有的 → 都一样拿第一张。**没有任何体系判断**。
### 3.4 商店(真实缺陷)
`tasks/mirror/__init__.py` 用的是旧路径:
```python
must_purchase_path = "./assets/images/share/mirror/shop/must_purchase"
```
实际图片在 `./assets/images/default/share/mirror/shop/must_purchase/`,`assets/images/share` 不存在。
运行时验证:
```
must_purchase 0
must_be_abandoned 0
fusion_result 0
```
本次日志实锤(进店 51 秒,一件没买):
```text
10:03:03 开始执行 镜牢商店
10:03:16 开始购买必买项
10:03:54 结束执行 镜牢商店 耗时 00:00:51
```
## 四、本次跑团(进行中记录)
```text
09:39:53 task mirror start
09:40:07 选队 → 流血(已是目标队,跳过切换)
09:41:16 第1层
09:54:33 第1层结束 13:07,卡包:赌徒
09:55:20 寻路出错 → 自动重进镜牢,恢复
10:03:54 第2层商店 51 秒(未购买,见 3.4)
10:07:32 第2层结束 12:59,卡包:情感懒
10:17:37 第3层战斗中
```
## 五、仍未验证的边界
- 选队补丁只在「流血」上实测过;其它 9 个体系名未实跑(队列切换、`teams_active_queue` 轮转时尤其没验)。
- 队名如果被改(比如改成「流血队」),补丁会失配 → 需要同步改 `SYSTEM_TEAM_NAMES`。
- `my_crop` 语义不一致这件事只在这个界面验证过,别的界面不一定。
- 关掉 `mirror_keyboard_simple_pathfinding` 后 Dijkstra 的稳定性没验(当初开它就是为躲鼠标拖地图卡死)。
@@ -0,0 +1,87 @@
# 2026-11-14 云端交付:实机回归结果
对应 [`REGRESSION.md`](REGRESSION.md)(云端给的清单)。本机:Windows 10、1280×720 客户区、
游戏 build `26593955`、汉化 `2026111301`、AALC `2fcb1b4`(V1.6.1)。
## 1. 拉取
- [x] 单测全过:`Ran 641 tests ... OK`(云端 633;本地多加了选队守卫/队名偏好用例)
- [x] `vendor/aalc` = `2fcb1b4`(`git -C vendor/aalc log --oneline -1` 已确认)
> ⚠️ **部署坑(新增)**:`TaskRunner` 在**常驻服务进程**里给子进程设 `LCP_DECISIONS`,
> 服务不重启就用旧代码 → 第一局 `decisions.jsonl` 根本没生成。本轮已重启 `LcMCPServer`。
> 以后每次 `git pull` 都要重启服务。
## 2. 任务开始时的日志
九行全部出现(云端七行 + 本次新增两行),没有 `挂不上` / `补丁跳过`:
```text
[lc_mcp] patch: 镜牢按体系名选队
[lc_mcp] patch: 入场前按体系切队伍
[lc_mcp] patch: 选队页守卫(星之恩惠页忽略星级模板)
[lc_mcp] patch: 镜牢键盘寻路按节点类型选方向(不拖地图)
[lc_mcp] patch: 镜牢饰品选择按体系关键词排序(gift_keywords.json)
[lc_mcp] patch: 镜牢事件按选项表选择(event_choices.json, 6 条)
[lc_mcp] patch: 商店购买写入决策审计
[lc_mcp] patch: 商店必买先按中文名找(shop_gifts.json, 5 个名字), 图标模板兜底
[lc_mcp] patch: 卡包选择写入决策审计
```
## 3. 逐项结果
| 项 | 结果 | 证据 |
|---|---|---|
| 选队 P1-5 | **通过**(补丁加"入场前切队"后) | `入场前切队伍: 充能/震颤` → `编队列表里找到 充能 @(131,455), 精确匹配 充能` → `已按体系名选中编队 充能`;同一局再次调用走 `当前已经是编队 充能, 无需切换` |
| 寻路 P0-2 | **不通过(键盘方案在本机不可用)** | 24 次键盘尝试 **0 成功**、24 次回退;今早旧版也是 32/32 失败。说明这台机器方向键进节点本来就不可用,新补丁不是元凶,但每次多绕 3 个方向 ≈ 多 5 秒 |
| 饰品 P1-3 | 部分通过(样本少) | 4 次三选一:2 次 `命中体系关键词`、2 次未命中(`gift/keyword` `gift/no_keyword` 各 2);三选一倒序复查处未再出现 |
| 事件 P1-4 | 表覆盖不足 | 17 条事件,**15 条 `not_in_table`**;命中的 2 条按表走 |
| 商店 P2-6 | 通过(样本少) | 7 次购买点击,1 次 `按名字找到`;必买清单上游已修(5/19/31 非空) |
| 审计 P2-8 | 通过 | `task_status.decisions.counts` 正常:`event/gift/road/shop/theme_pack` 五类都有 |
### 3.1 选队为什么前四局全都没触发
不是名字问题,是**根本没走到选队**:
- 镜牢入场时 AALC 直接点 `mirror/road_to_mir/enter_assets.png`(「进入」),用游戏记住的上一支队;
只有它先看到 `select_team_stars_assets.png` 才会调 `select_battle_team`。
- 「星之恩惠」页满屏星星,**星级模板在该页也会命中** → AALC 以为到了选队页 → 6 次「不在编队界面」。
- 我第一版守卫写成"必须有编队图标或 ≥3 个队名",选队页刚加载时两者都没渲染 → 真选队页被一起跳过
(21:03 那局 35 秒直接进第 1 层)。
修法:守卫只否定「星之恩惠」页(出现"恩惠"才忽略星级模板);在点「进入」之前若检测到选队页且
顶栏不是目标队,就先切队再进入。
### 3.2 选队扫描步长
旧版每轮连拖 3 次,实测**一次拖动就滚 5~6 行**,3 次直接跳过一整屏:
```text
第 1 屏: 剧情关卡/斩击/突刺/打击/烧伤/流血
第 2 屏: 编队#19..25 ← 中间「震颤/破裂/沉沦/呼吸法/充能」整屏被跳过
```
改成每轮 1 次拖动、最多 6 轮;「充能」在第 2 屏被精确命中。
## 4. 本轮跑团记录
| 时间 | 任务 | 结果 |
|---|---|---|
| 09:39 | mirror ×1(升级前) | 完成 01:29:02(含 32/32 键盘回退) |
| 18:44 | mirror ×1(V1.6.1 首跑) | **开局饰品弹窗死循环** 5 分钟,手动点一次才过,停 |
| 19:03 | mirror ×1 | 手动停在第 5 层;decisions:event 16 / gift 4 / road 24 / shop 4 / theme_pack 4 |
| 20:46 | mirror ×1 | 6 次「不在编队界面」,扫描读到星之恩惠页,停 |
| 21:03 | mirror ×1 | 守卫过严 → 35 秒进第 1 层,没选队,停 |
| 21:22 | mirror ×1 | **完成 00:55:23**(第1~5层 11:04/13:07/12:54/17:17);decisions:event 17(15 不在表)/ gift 4(2 命中)/ road 24 回退 / shop 7(1 按名字)/ theme_pack 4 |
| 01:50 | mirror ×6 | 进行中(6 连刷,目标 9 箱子/次 × 6) |
## 5. 离线确认不了、本机也没验到的
- 键盘方向键"方向没路时会进到别的节点" —— 本机 0 成功,无法验证。
- 事件 `???` 标签落在哪些选项 —— 24 小时样本里没遇到。
- 商店普通/特殊布局是否一致 —— 未区分记录。
- AALC V1.6.1 的"僵尸进程 180 秒误杀" —— 未触发(窗口标题正常、窗口一直可见)。
## 6. 关闭开关
本轮**没有**用 `LCP_*` 关任何补丁(除键盘寻路另议,见 [`../../ISSUES.md`](../../ISSUES.md) I-05)。
+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)
+65
View File
@@ -63,3 +63,68 @@ OCR 误读;已知读法集合只来自该账号历史观测,不是通用余
`state`;`errors` 表示本次日志出现过错误,不代表所有步骤都失败。新任务重新计算自己的结果。 `state`;`errors` 表示本次日志出现过错误,不代表所有步骤都失败。新任务重新计算自己的结果。
回归覆盖早期错误被大量日志挤出、错误条数上限、日志删除后的结果保留和下一轮状态清理。 回归覆盖早期错误被大量日志挤出、错误条数上限、日志删除后的结果保留和下一轮状态清理。
补充修复后的全套测试:377 项通过(18.235 秒);`git diff --check` 通过。 补充修复后的全套测试:377 项通过(18.235 秒);`git diff --check` 通过。
## 补充:远程驱动输入与窗口补丁复核
本次审查范围是远程新增的 `a6e987e`、`2902cf5`、`7eafbdd`、`e2de126`。
从 `e2de126` 开始修复;未修改 AALC 子模块或目标机配置。
| 优先级 | 已确认问题 | 修复 |
|---|---|---|
| P1 | 直接把 `auto.mouse_click` 绑到代理, 覆盖了真实 `Automation.init_input()` 后续安装的交互门和输入锁, 业务线程可能与监控线程同时点击 | 通过 `_run_business_interaction` 重建入口, 继续使用相同的门与锁 |
| P1 | `task=all` 提前进入 `script_task()` 跳过安装; 游戏异常重启后 `init_game()` 再次重建后端也会丢失代理 | 在任务作用域包装 `scheme.init_game`, 每次初始化结束后安装, 退出恢复原入口; 模拟器和未启用时保持原流程 |
| P1 | `mouse_click_blank` 仍绑定原后端; 物理点击未确认游戏焦点, 失败的坐标转换也被当作有效坐标 | 接管空白点击; 校验 console 会话、游戏焦点、Win32 查询结果; 失败拒绝点击, 保留暂停和 `move_back` 参数 |
| P1 | 驱动按下后异常没有保证抬起; 代理抬起时坐标查询失败也会跳过释放 | 将释放置于 `finally`; 任务中断继续向上抛出 |
| P1 | 前台补丁把 pywin32 `AttachThreadInput` 成功返回的 `None` 转为 `False`, 导致未解除线程绑定 | 无异常即记录已绑定, 前台设置成功或失败都解除绑定 |
| P2 | `GetForegroundWindow()!=0` 被误当作 console 会话依据, RDP 内也可能存在前台窗口; 查询失败被当作加速关闭或坐标 `(0,0)` | 比较进程会话 ID 与活动 console ID; 显式检查查询返回值, 设置指针宽度正确的 API 类型; 使用独立 DLL 绑定避免影响其他库 |
| P2 | 点击/拖动的窗口设置、激活、按下前等待位于清理范围之外; 鼠标释放失败也能跳过位置恢复 | 共用覆盖完整操作的窗口作用域, 透明度和已取得的原位置分别保证恢复 |
| P2 | 截图自检只对窗口 DC 执行 BitBlt, 与提交说明声称的 PrintWindow 路径不符; 位图仍选在 DC 内时尝试删除 | 窗口自检调用 PrintWindow(flags=3), 按客户区大小创建位图, 恢复旧对象后释放 GDI 资源; 屏幕 BitBlt 作为后备 |
| P3 | 新增测试直接导入 pyautogui 和 ctypes.windll, 在 Linux 上 399 项中有 2 项报错 | 隔离平台接口, 补充真实 AALC 接线、任务入口、故障清理和采集 API 的回归测试 |
会话判断依据 Microsoft 的 [GetForegroundWindow 文档](https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-getforegroundwindow)
和 [WTSGetActiveConsoleSessionId 文档](https://learn.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-wtsgetactiveconsolesessionid)。
线程绑定接口核对了 [pywin32 源码](https://github.com/mhammond/pywin32/blob/main/win32/src/win32process.i)
及 [接口文档](https://mhammond.github.io/pywin32/win32process__AttachThreadInput_meth.html)。
文件核查:`lc_mcp/driver_input.py`、`lc_mcp/aalc_patches.py`、`lc_mcp/aalc_task.py`
和 `tests/test_driver_input.py` 已存在于远程 `e2de126`。仓库没有 `logitech.driver.dll`、
罗技驱动安装包或注释提到的 `logitech.test.py`。README 已补充外部依赖、环境变量和接管范围。
驱动只接管任务流点击, 不将拖拽、滚动、键盘或独立 MCP `click` 工具改为驱动输入。
验证:Linux / Python 3.12 全套 **417 项通过**(16.832 秒);随后将 Win32 类型声明改为
独立 DLL 绑定, 驱动相关 **29 项回归通过**。`git diff --check` 通过。
测试从 vendor AST 提取并执行真实的 `init_input`、交互门与监控点击方法, 不复制其接线逻辑;
实际 `aalc_task.run` 的 `all` / `daily` 入口也有覆盖。Windows DLL 和游戏未在本次环境执行。
PrintWindow 探测仅表示 API 调用成功, 不保证像素内容有效; 真机仍需检查画面、焦点和点击响应。
## 合入 main 前的复核与急停补齐
合并目标为 `main`(原 `073e407`),来源为
`codex/feedback-unattended-setup-20261004`。本轮拉取又发现 `8a9495b`:
它是一个新增 F12 急停的提交,涉及三个文件,也纳入本次合并。
复核覆盖分支相对 main 的运行时、脚本、安装配置和测试变更,结合上述两轮审查记录;
AALC 子模块保持已验证的 `e1d1749`,没有追入 develop 的图标提交。
合并前另修复以下问题:
- 急停回调先写日志,日志抛错会跳过退出,日志阻塞也会延迟急停。
回调改为分发退出工作,不写日志;清理另有 250 毫秒强退兜底。
这遵循 [pynput 对 Windows 键盘回调的说明](https://pynput.readthedocs.io/en/latest/keyboard.html#the-keyboard-listener-thread):避免在回调中阻塞。
- 硬退出跳过驱动点击的 finally,可能留下按住的鼠标按钮。
驱动增加停止标志及输入锁,急停先拒绝新鼠标输入,再释放本实例按住的按钮。
驱动本身卡住时仍按时退出;本次离线验证不证明硬件故障下必定释放成功。
- `killswitch.stop` 原先未接到任务退出路径;现在正常结束、异常和预检拒绝都会关闭监听器。
- 退出码 130 原先显示 failed,镜牢轮询后还会继续导航和升级。
现在状态为 stopped,刷取脚本终止整轮并写入用户停止报告,不重试、不继续升级。
- 计划任务时限仍按 75 分钟镜牢设置,短于脚本的 100 分钟上限,也未覆盖一次卡死重试。
安装脚本改为 daily 45 分钟、每局镜牢 100 分钟、各至多两次尝试,另加 30 分钟收尾预算。
此改动只影响后续安装任务,未操作现有 Windows 计划任务。
- 纠正合成安装脚本关于注销后运行和固定体力恢复速率的过时注释,清理文档尾部空行。
验证:Linux / Python 3.12 全套 **437 项通过**(17.112 秒);相对 main 的
`git diff --check` 通过。新增回归涵盖真正退出 130 的子进程、保留恢复文件、用户停止后
不继续操作、驱动按住时急停、清理卡住仍退出以及正常/预检拒绝后的监听器清理。
Windows 热键、驱动及 PowerShell 计划任务仍需实机验收。
分支清理仅针对完整合入 main 的来源分支。`fix/team-scroll-patch` 仍有独有的
`dd4259d` 实验提交,本次不合入也不删除;其历史取舍见上面的 DSH 审查记录。
+12 -1
View File
@@ -1,12 +1,23 @@
--- ---
name: limbus-mirror-speedrun name: limbus-mirror-speedrun
description: 继续或重开边狱公司(Limbus Company)的镜像迷宫/镜牢,按破裂黎明与黑兽纯 P 攻略追求整局通关速度;处理开局配置、卡包、事件、必要强化、技能替换与战斗快捷键。用于用户要求代打镜牢或优化此速通流程时,不用于一般配队讨论或主线事件。 description: 执行或优化边狱公司(Limbus Company)的特殊镜牢速通,按用户指定的破裂黎明、黑兽纯 P 或具体路线逐步控制,并续跑该速通的未完成局。普通刷镜牢、日常和领奖使用 AALC run_task;一般配队讨论和主线事件不使用本 skill。
--- ---
# 镜牢破裂纯 P 速通 # 镜牢破裂纯 P 速通
目标是尽快完成用户授权的一局镜牢。接着当前画面推进;只有用户明确要求重开时才放弃当前局。用户后续纠正覆盖本 skill 的默认配置。 目标是尽快完成用户授权的一局镜牢。接着当前画面推进;只有用户明确要求重开时才放弃当前局。用户后续纠正覆盖本 skill 的默认配置。
## 选择执行方式
用户只要求普通刷镜牢且没有特殊路线时,先查 MCP `task_status`;空闲后用 `run_task`,
例如一局为 `{"task":"mirror","count":1}`,随后轮询 `task_status` 并检查 `errors`、
`pending_restore`,不进入下方逐步速通规则。完成局数不足时任务报 `failed`,不能当作已通关。
已有任务时监控它;用户停止后不自动重跑。
日常与领奖分别用 `daily`、`reward`,`all` 和花狂气的 `enkephalin` 必须符合明确要求。
只有特殊速通要求或续跑该速通局时使用下方规则,调用执行器时指定 `--workflow speedrun`。
自动流程卡住时,先 `stop_task` 并确认停止,再观察画面恢复;不同时运行两个执行器。
## 读取与续局 ## 读取与续局
- 执行前读取 [破裂黎明配置与楼层规划](references/rupture-route.md)。沿用用户配好的队伍、难度、出战顺序,不为了通用攻略改动配置。 - 执行前读取 [破裂黎明配置与楼层规划](references/rupture-route.md)。沿用用户配好的队伍、难度、出战顺序,不为了通用攻略改动配置。
@@ -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。
+33 -25
View File
@@ -8,6 +8,7 @@ import glob
import os import os
import sys import sys
import time import time
from contextlib import contextmanager
from .engine import Engine from .engine import Engine
@@ -228,28 +229,41 @@ class AalcEngine(Engine):
win32con.SWP_NOSIZE | win32con.SWP_NOZORDER | win32con.SWP_NOSIZE | win32con.SWP_NOZORDER |
win32con.SWP_NOACTIVATE) win32con.SWP_NOACTIVATE)
@contextmanager
def _background_target(self, x, y):
position = None
transparent = self.cfg.win_input_type == 'window_move'
try:
if transparent:
self.screen.handle.set_window_transparent(True)
position = self.auto.input_handler._set_window_pos(int(x), int(y))
self.auto.input_handler.set_active()
yield position
finally:
try:
if position is not None:
try:
time.sleep(0.12)
finally:
self._restore_background_position(position)
finally:
if transparent:
self.screen.handle.set_window_transparent(False)
def click(self, x, y, times=1): def click(self, x, y, times=1):
self._prepare_input() self._prepare_input()
if not self.cfg.simulator and self.cfg.win_input_type in ('background', 'window_move'): if not self.cfg.simulator and self.cfg.win_input_type in ('background', 'window_move'):
import win32con import win32con
handler = self.auto.input_handler
self.auto.wait_pause() self.auto.wait_pause()
for _ in range(int(times)): for _ in range(int(times)):
position = None with self._background_target(x, y):
if self.cfg.win_input_type == 'window_move':
self.screen.handle.set_window_transparent(True)
position = handler._set_window_pos(int(x), int(y))
handler.set_active()
self._background_mouse(win32con.WM_MOUSEMOVE, x, y) self._background_mouse(win32con.WM_MOUSEMOVE, x, y)
time.sleep(0.12) time.sleep(0.12)
self._background_mouse(win32con.WM_LBUTTONDOWN, x, y, held=True)
try: try:
self._background_mouse(win32con.WM_LBUTTONDOWN, x, y, held=True)
time.sleep(0.12) time.sleep(0.12)
finally: finally:
self._background_mouse(win32con.WM_LBUTTONUP, x, y) self._background_mouse(win32con.WM_LBUTTONUP, x, y)
if position is not None:
time.sleep(0.12)
self._restore_background_position(position)
# Let Unity consume the release before another target is selected. # Let Unity consume the release before another target is selected.
time.sleep(0.12) time.sleep(0.12)
elif not self.cfg.simulator and self.cfg.win_input_type == 'foreground': elif not self.cfg.simulator and self.cfg.win_input_type == 'foreground':
@@ -286,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)
@@ -304,16 +319,12 @@ class AalcEngine(Engine):
if not self.cfg.simulator and self.cfg.win_input_type in ('background', 'window_move'): if not self.cfg.simulator and self.cfg.win_input_type in ('background', 'window_move'):
import win32con import win32con
self.auto.wait_pause() self.auto.wait_pause()
position = None with self._background_target(from_x, from_y) as position:
if self.cfg.win_input_type == 'window_move':
self.screen.handle.set_window_transparent(True)
position = self.auto.input_handler._set_window_pos(int(from_x), int(from_y))
self.auto.input_handler.set_active()
self._background_mouse(win32con.WM_MOUSEMOVE, from_x, from_y) self._background_mouse(win32con.WM_MOUSEMOVE, from_x, from_y)
time.sleep(0.12) time.sleep(0.12)
self._background_mouse(win32con.WM_LBUTTONDOWN, from_x, from_y, held=True)
last_x, last_y = from_x, from_y last_x, last_y = from_x, from_y
try: try:
self._background_mouse(win32con.WM_LBUTTONDOWN, from_x, from_y, held=True)
time.sleep(0.12) time.sleep(0.12)
steps = max(1, int(float(duration) / 0.02)) steps = max(1, int(float(duration) / 0.02))
for step in range(1, steps + 1): for step in range(1, steps + 1):
@@ -326,9 +337,6 @@ class AalcEngine(Engine):
time.sleep(0.12) time.sleep(0.12)
finally: finally:
self._background_mouse(win32con.WM_LBUTTONUP, last_x, last_y) self._background_mouse(win32con.WM_LBUTTONUP, last_x, last_y)
if position is not None:
time.sleep(0.12)
self._restore_background_position(position)
return return
if not self.cfg.simulator and self.cfg.win_input_type == 'foreground': if not self.cfg.simulator and self.cfg.win_input_type == 'foreground':
import pyautogui import pyautogui
File diff suppressed because it is too large Load Diff
+108 -8
View File
@@ -9,9 +9,18 @@ import json
import os import os
import sys import sys
from . import preflight from . import killswitch, preflight
from .aalc_engine import bootstrap from .aalc_engine import bootstrap
from .aalc_patches import WindowGuard, install_exact_team_match from .aalc_patches import (TaskAbort, WindowGuard, driver_click_tasks, headless_hdr_warning, install_rabbit_hole,
load_rabbit_hole,
install_default_battle_team, install_event_choices, install_exact_team_match,
install_gift_confirm_guard, install_gift_preference, install_image_error_guard, install_key_hold,
install_robust_set_foreground, install_shop_audit, install_shop_by_name,
install_system_team_selection, install_team_screen_guard,
install_theme_pack_audit, install_theme_pack_systems, install_typed_keyboard_road,
mirror_progress, stop_driver_click)
from .decisions import decisions
from .game_lock import GameBusyError, exclusive_game
# 任务 -> {参数名: AALC 配置项}; 参数只在本次运行内生效 # 任务 -> {参数名: AALC 配置项}; 参数只在本次运行内生效
TASKS = { TASKS = {
@@ -21,8 +30,15 @@ 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
EXPLICIT_COUNT_OVERRIDES = {'mirror': {'count': {'infinite_dungeons': False}}}
RESTORE_ENV = 'LCP_RESTORE_FILE' RESTORE_ENV = 'LCP_RESTORE_FILE'
PREFLIGHT_EXIT = 3 PREFLIGHT_EXIT = 3
INCOMPLETE_EXIT = 4 # AALC 正常返回, 但镜牢完成局数少于应打局数
def log(msg): def log(msg):
@@ -35,17 +51,37 @@ def apply_overrides(cfg, task, params, restore_path=None):
AALC 运行中会整份保存配置(如镜牢后 rotate_team_queue), 覆盖值会被写进 config.yaml。 AALC 运行中会整份保存配置(如镜牢后 rotate_team_queue), 覆盖值会被写进 config.yaml。
所以先把原值落盘: 进程被 stop_task 强杀、finally 来不及执行时, TaskRunner 据此写回。 所以先把原值落盘: 进程被 stop_task 强杀、finally 来不及执行时, TaskRunner 据此写回。
""" """
originals = {TASKS[task][name]: cfg.get_value(TASKS[task][name]) for name in params} overrides = {TASKS[task][name]: int(value) for name, value in params.items()}
for name in params:
overrides.update(EXPLICIT_COUNT_OVERRIDES.get(task, {}).get(name, {}))
originals = {key: cfg.get_value(key) for key in overrides}
if originals and restore_path: if originals and restore_path:
tmp = restore_path + '.tmp' tmp = restore_path + '.tmp'
with open(tmp, 'w', encoding='utf-8') as f: with open(tmp, 'w', encoding='utf-8') as f:
json.dump(originals, f, ensure_ascii=False) json.dump(originals, f, ensure_ascii=False)
os.replace(tmp, restore_path) os.replace(tmp, restore_path)
for name, value in params.items(): for key, value in overrides.items():
cfg.unsaved_set_value(TASKS[task][name], int(value)) if key == 'infinite_dungeons' and originals.get(key):
log('[lc_mcp] 本次按指定次数运行镜牢, 临时关闭无限刷牢, 结束后恢复')
cfg.unsaved_set_value(key, value)
return originals return originals
def mirror_result(task, progress):
"""按 AALC 实际完成局数给出退出码; 退出码 0 不再代表"一局没打"。"""
if progress.total is None:
if task != 'mirror':
return 0 # all 没勾选镜牢
log('[ERROR] [lc_mcp] 镜牢任务结束, 但没收到 AALC 的镜牢进度, 不能确认完成局数')
return INCOMPLETE_EXIT
log('[lc_mcp] 镜牢完成 %d/%d 局' % (progress.finished, progress.total))
if progress.finished < progress.total:
log('[ERROR] [lc_mcp] 镜牢只完成 %d/%d 局: AALC 正常返回, 但没有打完'
'(常见原因: 没有适用当前难度的队伍、队列为空)' % (progress.finished, progress.total))
return INCOMPLETE_EXIT
return 0
def restore(cfg, originals, restore_path=None): def restore(cfg, originals, restore_path=None):
for key, value in originals.items(): for key, value in originals.items():
cfg.set_value(key, value) cfg.set_value(key, value)
@@ -65,6 +101,31 @@ def restore_file(path, cfg=None):
def run(task, params): def run(task, params):
try:
with exclusive_game():
return _run(task, params)
except GameBusyError as e:
log('[ERROR] [lc_mcp] %s' % e)
return PREFLIGHT_EXIT
def split_options(task, params):
"""把任务选项(TASK_OPTIONS)从参数里拆出来, 返回 (次数类参数, 选项)。"""
allowed = TASK_OPTIONS.get(task, {})
params = dict(params)
options = {k: params.pop(k) for k in list(params) if k in allowed}
return params, options
def _run(task, params):
params, options = split_options(task, params)
rabbit = None
if options.get('strategy') == 'rabbit_hole':
try:
rabbit = load_rabbit_hole()
except (OSError, ValueError) as e:
log('[ERROR] [lc_mcp] 兔子洞配置读不了: %s' % e)
return PREFLIGHT_EXIT
bootstrap() bootstrap()
from module.automation import auto from module.automation import auto
from module.config import cfg from module.config import cfg
@@ -74,6 +135,7 @@ def run(task, params):
from tasks.battle import battle from tasks.battle import battle
from utils.path_manager import path_manager from utils.path_manager import path_manager
with killswitch.listening(log=log, on_stop=lambda: stop_driver_click(auto)):
problems = preflight.check(preflight.collect(cfg), task, problems = preflight.check(preflight.collect(cfg), task,
desktop=None if cfg.simulator else preflight.desktop_size()) desktop=None if cfg.simulator else preflight.desktop_size())
if problems: if problems:
@@ -81,15 +143,44 @@ def run(task, params):
log('[ERROR] [lc_mcp] preflight: %s' % p) log('[ERROR] [lc_mcp] preflight: %s' % p)
return PREFLIGHT_EXIT return PREFLIGHT_EXIT
decisions.open() # TaskRunner 给的 .decisions.jsonl; 直接运行时不写
install_exact_team_match(auto, log) install_exact_team_match(auto, log)
install_robust_set_foreground(screen, log=log)
if not cfg.simulator:
install_key_hold(log=log) # 前台按键带扫描码、各模式按住再松开(ISSUES I-05)
# 日常本(经验/纽本)不翻队伍列表: 队伍是自定义名字时按名字找必然失败,
# 白等 60 秒还会把界面滚乱, 后面 to_battle 就找不到 "进入战斗" 了。
if task in ('daily', 'all'):
install_default_battle_team(scheme, log=log)
# 镜牢: 编队是自定义名字(体系名), AALC 只会找 "编队#N"; 改成按体系名点选。
if task in ('mirror', 'all'):
install_system_team_selection(log=log, names=rabbit['team_names'] if rabbit else None)
install_team_screen_guard(log=log)
install_gift_confirm_guard(log=log) # 「获得E.G.O饰品」点不关时换落点/结束任务(ISSUES I-06)
install_image_error_guard(log=log) # 截图连续识别失败即结束任务(防窗口没了还空转)
install_typed_keyboard_road(log=log)
install_gift_preference(log=log)
install_event_choices(log=log)
install_shop_audit(log=log)
install_shop_by_name(log=log) # 装在审计之后(包在外层), 审计才看得到按名字点的那一下
if rabbit: # 卡包按体系加分(BACKLOG R-01); 兔子洞再给攻略路线上的卡包加分
install_theme_pack_systems(log=log, route=rabbit['theme_packs'], route_name='兔子洞路线')
else:
install_theme_pack_systems(log=log)
install_theme_pack_audit(log=log) # 装在加分之后(包在外层), 审计记得到加分
if rabbit:
install_rabbit_hole(log=log, config=rabbit)
guard = WindowGuard(screen, cfg, log=log) guard = WindowGuard(screen, cfg, log=log)
guard.start() guard.start()
restore_path = os.environ.get(RESTORE_ENV) restore_path = os.environ.get(RESTORE_ENV)
originals = apply_overrides(cfg, task, params, restore_path) originals = apply_overrides(cfg, task, params, restore_path)
with driver_click_tasks(scheme, auto, screen, cfg, log=log), \
mirror_progress(scheme) as progress:
try: try:
if task == 'all': if task == 'all':
with headless_hdr_warning(scheme, log=log):
scheme.script_task() scheme.script_task()
return 0 return mirror_result(task, progress)
# 与 script_task() 相同的前置步骤 # 与 script_task() 相同的前置步骤
scheme.init_game() scheme.init_game()
path_manager.initialize_paths() path_manager.initialize_paths()
@@ -105,7 +196,10 @@ def run(task, params):
'enkephalin': scheme.Buy_enkephalin, 'enkephalin': scheme.Buy_enkephalin,
'mirror': scheme.Mirror_task, 'mirror': scheme.Mirror_task,
}[task]() }[task]()
return 0 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()
@@ -122,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:
+43
View File
@@ -0,0 +1,43 @@
{
"_说明": [
"镜牢事件选项表(BACKLOG P1-4)。只在事件出现选项时生效; 认不出的事件、或要点的那项没读到时, 交给 AALC 原逻辑。",
"认事件: options 里的每一句都出现在这一屏的选项里, 才算这个事件(按表顺序, 先命中的生效); 然后点包含 text 的那一项。",
"零协汉化的事件数据没有标题字段, 画面上也不保证有事件名, 所以不按事件名认; name 只用于日志。",
"文字都先归一再比较: 去空白、全角转半角、去标点、改回常见误读。整表关闭: 任务环境变量 LCP_EVENT_CHOICES=0。",
"id 是零协汉化 LLC_zh-CN/ActionEvents_*.json 里的事件 id; options/text 照抄那里的选项原文(2026-11-15 按本机装的 release 2026111301 核对)。",
"同一套选项在别的文件里有复刻(如 ActionEvents.json 910301/910302 与地狱鸡两条选项、结果都相同)时会一起命中, 选的是同一项。",
"check=true 表示选了之后还要罪人判定(由 AALC 原逻辑挑成功率最高的人格); 其余都是无判定、无战斗的直出。",
"选择依据: docs/skills/limbus-mirror-speedrun/references/event-choices.md(依据边狱公司中文 Wiki 社区「探索事件」, CC BY-SA 4.0)。",
"蜘蛛巢、归乡路途两条的结果依据 Limbus Company Wiki(wiki.gg) Spider of Marriage / Smokey Old Man 条目(CC BY-SA 4.0), 2026-11-15 核对。",
"选项原文来自零协汉化 LocalizeLimbusCompany(https://github.com/LocalizeLimbusCompany/LocalizeLimbusCompany, CC BY-NC-SA 4.0)。"
],
"events": [
{"name": "红色坐像", "id": 901010, "file": "ActionEvents_Mirror.json",
"options": ["摘下黄铜戒指。", "放上钱币。"], "text": "侧耳倾听。",
"note": "2 是色欲/暴食优势判定, 3 是战斗; 1 无判定"},
{"name": "炸鸡对决", "id": 971001, "file": "ActionEvents_Mirror4.json",
"options": ["绝对是鸡腿,满满的汁液。", "鸡胸,肯定的,纯净无瑕。"], "text": "鸡肉就是鸡肉喽。",
"note": "选择后获得 1 件烧伤和 1 件破裂 E.G.O 饰品"},
{"name": "鸡群的激情探戈", "id": 971003, "file": "ActionEvents_Mirror4.json",
"options": ["真心提醒。", "暗暗提示。"], "text": "视而不见。",
"note": "选择后获得 1 件泛用 E.G.O 饰品; 1 要看后续选项, 3 只有 50% 概率"},
{"name": "梦中的电子羊", "id": 901038, "file": "ActionEvents_Mirror.json",
"options": ["你是特别的。"], "text": "你不是特别的。",
"note": "选择后获得 1 件泛用 E.G.O 饰品"},
{"name": "失明巨人递来患者记录", "id": 901085, "file": "ActionEvents_Mirror3.json",
"options": ["如实回答。"], "text": "说上面什么都没有写。", "check": true,
"note": "两项都是判定: 1 忧郁/色欲(门槛 16), 2 忧郁/怠惰(门槛 14, 成功获得打击饰品); AALC 不区分两项, 点它认出的那个优势判定"},
{"name": "破碎罗盘(冻僵的尸体指路)", "id": 901095, "file": "ActionEvents_Mirror3.json",
"options": ["向裂开的手所指的北方。", "向警告的手所指的东方。", "向折断的手所指的西方。"], "text": "返回。",
"note": "第 4 项直接结束; 其余方向都还有后续分支"},
{"name": "蜘蛛巢(结婚蜘蛛)", "id": 901028, "file": "ActionEvents_Mirror.json",
"options": ["扯断棘蔓。"], "text": "摘下一朵花。",
"note": "1 直接给饰品「偏见」, 非傲慢人格扣 5 体力、傲慢人格回 15; 2 是 50% 判定, 成功全体降 10 理智, 失败全体扣 10 体力"},
{"name": "归乡路途(烟雾老人)", "id": 901039, "file": "ActionEvents_Mirror.json",
"options": ["不听故事离开。"], "text": "告诉它你们很乐意听些故事。",
"note": "1 进入下一段选择; 2 直接离开但全体降 30 理智"},
{"name": "归乡路途(第二段: 那幅画)", "id": 90103901, "file": "ActionEvents_Mirror.json",
"options": ["留下这幅画。"], "text": "带走这幅画。",
"note": "1 获得饰品「归途」(商店必买之一); 2 得 50 经费但全体降 15 理智"}
]
}
+20
View File
@@ -0,0 +1,20 @@
{
"_说明": [
"镜牢饰品三选一/二选一按体系关键词排序(BACKLOG P1-3)。键是 AALC 的体系名(all_systems), 值是关键词。",
"卡面 OCR 文本先归一(去空白、全角转半角、改回 震颐/沉论 等实测误读), 英文不分大小写, 子串命中即算。",
"命中行数多的卡排前面; 白棉花、已持有仍按 AALC 原逻辑处理。整表关闭: 任务环境变量 LCP_GIFT_KEYWORDS=0。",
"以 _ 开头的键会被忽略。",
"中文关键词按零协汉化核对(LLC_zh-CN/EgoGiftCategory.json、BattleKeywords.json, 2026-11-14): 烧伤 流血 震颤 破裂 沉沦 呼吸法 充能 斩击 突刺 打击。",
"饰品描述里的 [Combustion] 等占位符在游戏里显示成上面的名字; 呼吸法写成 呼吸, 漏读 法 也能命中。"
],
"burn": ["烧伤", "burn"],
"bleed": ["流血", "bleed"],
"tremor": ["震颤", "tremor"],
"rupture": ["破裂", "rupture"],
"sinking": ["沉沦", "sinking"],
"poise": ["呼吸", "poise"],
"charge": ["充能", "charge"],
"slash": ["斩击", "slash"],
"pierce": ["突刺", "pierce"],
"blunt": ["打击", "blunt"]
}
+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}
}
+17
View File
@@ -0,0 +1,17 @@
{
"_说明": [
"镜牢商店按中文名购买(BACKLOG P2-6)。AALC 必买项之前先按这张表 OCR 商店格子下面的名字, 命中就买; 靠前的先买。",
"只认与名字完全一致的格子(去空白、标点, 允许强化后缀 +); AALC 的 5 张必买图标模板仍在后面兜底。整表关闭: 任务环境变量 LCP_SHOP_NAMES=0。",
"默认 5 个就是 AALC 必买模板(assets/images/default/share/mirror/shop/must_purchase/*.png)对应的饰品, 中文名按零协汉化 LLC_zh-CN/EGOgift_MirrorDungeon.json(2026-11-14 核对 LocalizeLimbusCompany@231a8bc)。",
"AALC 日志把必买项叫'回血饰品', 核对描述后只有 采血包/归途/石版字符 是回血; 缘分残片 是全队 +5 级, 卡蜜拉 是每场非集中战先削敌人 20% 体力。",
"顺序是建议: 立即见效的放前面, 再按回血量。可以加别的饰品名, 写零协汉化里的名字原文。",
"饰品名来自零协汉化 LocalizeLimbusCompany(https://github.com/LocalizeLimbusCompany/LocalizeLimbusCompany, CC BY-NC-SA 4.0)。"
],
"gifts": [
{"name": "缘分残片", "id": 9082, "template": "piece_of_relationship.png", "note": "获得时编队所有人格提升 5 级"},
{"name": "卡蜜拉", "id": 9036, "template": "carmilla.png", "note": "非集中遭遇战开始时, 对全体敌人造成体力上限 20% 的固定伤害"},
{"name": "采血包", "id": 9004, "template": "phlebotomy_pack.png", "note": "技能造成伤害时恢复已失去体力的 12.5%(暴怒技能 25%)"},
{"name": "归途", "id": 9039, "template": "homeward.png", "note": "关卡开始时全体恢复体力上限 12% 的体力"},
{"name": "石版字符", "id": 9017, "template": "lithograph.png", "note": "敌人陷入混乱时, 体力最低的人格恢复体力上限 5%(有暴食攻击技能 10%)"}
]
}
+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": {}}
]
}
+62
View File
@@ -0,0 +1,62 @@
# -*- coding: utf-8 -*-
"""决策审计日志(BACKLOG P2-8)。
任务子进程把选队/寻路/卡包/饰品/事件/商店的每个决策追加成一行 JSON, 写到 TaskRunner 给的路径
(和任务日志同名, 后缀 .decisions.jsonl)。每行至少有 time / stage / choice / reason:
reason 是用来计数的短类别(例如 gift 的 keyword / no_keyword), 细节放在其余字段。
写失败只丢这一行, 不影响任务。
"""
import json
import os
import threading
import time
from collections import Counter
DECISIONS_ENV = 'LCP_DECISIONS'
SUFFIX = '.decisions.jsonl'
class DecisionLog:
def __init__(self, path=None):
self.path = path
self._lock = threading.Lock()
def open(self, env=None):
"""按环境变量决定写到哪; 没设置时 record 什么也不做。"""
env = os.environ if env is None else env
self.path = env.get(DECISIONS_ENV) or None
return self.path
def record(self, stage, choice, reason, **detail):
if not self.path:
return
entry = {'time': time.strftime('%Y-%m-%dT%H:%M:%S'), 'stage': stage, 'choice': choice, 'reason': reason}
entry.update(detail)
line = json.dumps(entry, ensure_ascii=False, default=str) + '\n'
try:
with self._lock, open(self.path, 'a', encoding='utf-8') as f:
f.write(line)
except OSError:
pass
decisions = DecisionLog()
def summarize(path):
"""{stage: {reason: 次数}}; 文件不存在返回 None, 坏行跳过。"""
try:
with open(path, encoding='utf-8') as f:
lines = f.readlines()
except OSError:
return None
counts = {}
for line in lines:
try:
entry = json.loads(line)
stage, reason = str(entry['stage']), str(entry['reason'])
except (ValueError, KeyError, TypeError):
continue
counts.setdefault(stage, Counter())[reason] += 1
return {stage: dict(counter) for stage, counter in sorted(counts.items())}
+349
View File
@@ -0,0 +1,349 @@
# -*- coding: utf-8 -*-
"""罗技驱动级输入(logitech.driver.dll)。
为什么需要它: 用 SendInput/mouse_event 注入的点击, 游戏侧仍可能识别为"模拟"。
这个 DLL 通过罗技驱动的虚拟 HID 设备发事件。
⛔ 两个必须知道的前提(2026-10-22 实测):
1. **会话必须是物理 console**
RDP 新建的是独立会话, 和物理桌面隔离。在 RDP 会话里调 `moveR` 光标纹丝不动
(实测 22 次采样全程 (1043,758) 不动), 切到 console 会话后立刻正常。
比较当前进程会话与 WTSGetActiveConsoleSessionId; 前台窗口句柄不能判定会话类型。
2. **必须关掉指针加速**
加速开着时 counts→像素是非线性的(实测 +100/+200/+400 对应 -45/-3/-3 像素),
当时的速度设置下关闭后比值为 1.0000。没关的话本模块会报警并拒绝定位,
而不是给出一个不准的位置。
接口只用 `device_open / moveR / mouse_down / mouse_up / key_down / key_up / scroll`,
这是 logitech.test.py 里验证过的那几个。
"""
import ctypes
import os
import time
import threading
from ctypes import wintypes
from functools import lru_cache
# win32 SPI 常量
SPI_GETMOUSE = 0x0003
SPI_GETMOUSESPEED = 0x0070
DEFAULT_DLL = r'E:\罗技键鼠驱动\logitech.driver.dll'
def _env_int(name, default):
try:
return int(os.environ.get(name, '') or default)
except ValueError:
return default
# 点击参数(可被环境变量覆盖, 见 DriverInput.click 的注释 4)
PRESS_MS = _env_int('LCP_DRIVER_PRESS_MS', 100) # 按下保持时长; 原 60ms 偏短
SETTLE_SECONDS = _env_int('LCP_DRIVER_SETTLE_MS', 80) / 1000.0 # 到位后、按下前
WIGGLE_PIXELS = _env_int('LCP_DRIVER_WIGGLE_PX', 10)
WIGGLE_ENABLED = os.environ.get('LCP_DRIVER_WIGGLE', '1').strip() != '0'
class Cursor(ctypes.Structure):
_fields_ = [('x', ctypes.c_long), ('y', ctypes.c_long)]
@lru_cache(maxsize=None)
def _win_library(name):
# 使用独立绑定, 避免 argtypes 污染 AALC/pyautogui 共用的 ctypes.windll。
return ctypes.WinDLL(name, use_last_error=True)
def _api(library, name, result, args):
fn = getattr(_win_library(library), name)
fn.restype, fn.argtypes = result, args
return fn
def get_cursor():
c = Cursor()
fn = _api('user32', 'GetCursorPos', wintypes.BOOL, [ctypes.POINTER(Cursor)])
if not fn(ctypes.byref(c)):
raise OSError('GetCursorPos 失败')
return (c.x, c.y)
def foreground_window():
return _api('user32', 'GetForegroundWindow', wintypes.HWND, [])()
def window_title(hwnd, limit=64):
"""窗口标题, 只用于报错说明; 取不到返回空串。"""
buf = ctypes.create_unicode_buffer(limit)
_api('user32', 'GetWindowTextW', ctypes.c_int,
[wintypes.HWND, wintypes.LPWSTR, ctypes.c_int])(hwnd, buf, limit)
return buf.value
def is_console_session():
current = wintypes.DWORD()
query = _api('kernel32', 'ProcessIdToSessionId', wintypes.BOOL,
[wintypes.DWORD, ctypes.POINTER(wintypes.DWORD)])
if not query(os.getpid(), ctypes.byref(current)):
raise OSError('ProcessIdToSessionId 失败')
console = _api('kernel32', 'WTSGetActiveConsoleSessionId', wintypes.DWORD, [])()
return console != 0xFFFFFFFF and current.value == console
def has_foreground():
"""当前是否存在前台窗口; 激活切换时也可能短暂为 0。"""
return bool(foreground_window())
def acceleration_on():
"""指针加速是否开着。开着就别指望 counts 和像素成线性。"""
a = (ctypes.c_int * 3)()
fn = _api('user32', 'SystemParametersInfoA', wintypes.BOOL,
[wintypes.UINT, wintypes.UINT, ctypes.c_void_p, wintypes.UINT])
if not fn(SPI_GETMOUSE, 0, ctypes.byref(a), 0):
raise OSError('读取指针加速设置失败')
return bool(a[2])
def mouse_speed():
s = ctypes.c_int()
fn = _api('user32', 'SystemParametersInfoA', wintypes.BOOL,
[wintypes.UINT, wintypes.UINT, ctypes.c_void_p, wintypes.UINT])
if not fn(SPI_GETMOUSESPEED, 0, ctypes.byref(s), 0):
raise OSError('读取指针速度失败')
return s.value
class DriverInput:
"""罗技驱动级鼠标/键盘。
定位采用**闭环**: 发相对位移 -> 读回实际位置 -> 不够就再发, 直到误差 <= tol。
这样不依赖任何标定常数, 也能对抗偶发的坐标跳变。
"""
def __init__(self, dll_path=None, log=print):
self.dll_path = dll_path or os.environ.get('LCP_LOGITECH_DLL') or DEFAULT_DLL
self.log = log
self._dll = None
self._open = False
self._stopped = False
self._input_lock = threading.RLock()
self._pressed = set()
self._last_click = None # 上一次点击的屏幕坐标: 原地连点时才做抖动
# 目标窗口句柄。有它才能做句柄级前台校验 —— 几何校验在窗口重叠时没用:
# 实测把浏览器切到前台, 点游戏里同一个坐标, 只比矩形的话校验照样通过。
self.hwnd = 0
def bind_window(self, hwnd):
"""绑定目标窗口。绑定后 click() 会做句柄级前台校验。"""
self.hwnd = int(hwnd or 0)
return self
# ---------------------------------------------------------------- 生命周期
def open(self):
if self._open:
return True
if not os.path.exists(self.dll_path):
self.log('[driver] 找不到 %s' % self.dll_path)
return False
try:
self._dll = ctypes.CDLL(self.dll_path)
for name in ('device_open', 'moveR', 'mouse_down', 'mouse_up'):
getattr(self._dll, name)
ok = self._dll.device_open() == 1
except (OSError, AttributeError) as e:
self.log('[driver] 加载 DLL 失败: %s' % e)
self._dll = None
return False
self._open = bool(ok)
if not ok:
self.log('[driver] device_open() != 1, 罗技驱动未就绪')
return self._open
@property
def ready(self):
return self._open and self._dll is not None and not self._stopped
def emergency_stop(self):
"""拒绝后续鼠标输入并释放本实例按住的按钮。急停线程另有退出超时。"""
self._stopped = True
with self._input_lock:
for button in tuple(self._pressed):
self.up(button)
def preflight(self):
"""返回 (能否用, 原因)。用之前调一次, 把不能用的原因说清楚。"""
if not self.open():
return False, '罗技驱动不可用(device_open 失败)'
try:
if not is_console_session():
return False, '当前进程不在物理 console 会话, 不启用驱动输入'
if not has_foreground():
return False, '当前会话没有前台窗口(GetForegroundWindow=0), 暂不启用驱动输入'
if acceleration_on():
return False, ('指针加速开着, counts 与像素不成比例, 定位会不准 —— '
'关掉"提高指针精确度"后重试')
except (OSError, AttributeError) as e:
return False, '无法确认输入环境: %s' % e
return True, 'ok'
# ---------------------------------------------------------------- 移动
def move_relative(self, dx, dy):
with self._input_lock:
if not self.ready:
return False
if dx == 0 and dy == 0:
return True
self._dll.moveR(int(dx), int(dy), True)
return True
def move_to(self, sx, sy, tol=1, iters=10, settle=0.03):
"""把光标精确移到屏幕坐标 (sx, sy)。返回是否到位。"""
if not self.ready:
return False
for _ in range(iters):
cx, cy = get_cursor()
dx, dy = int(sx) - cx, int(sy) - cy
if abs(dx) <= tol and abs(dy) <= tol:
return True
if self.move_relative(dx, dy) is False:
return False
time.sleep(settle)
cx, cy = get_cursor()
return abs(int(sx) - cx) <= tol and abs(int(sy) - cy) <= tol
# ---------------------------------------------------------------- 按键
def down(self, button=1):
with self._input_lock:
if not self.ready:
return False
button = int(button)
self._pressed.add(button)
self._dll.mouse_down(button)
return True
def up(self, button=1):
with self._input_lock:
if self._open and self._dll is not None:
self._dll.mouse_up(int(button))
self._pressed.discard(int(button))
def click(self, sx, sy, times=1, tol=1, require_foreground=True,
press_ms=None, settle=None, wiggle=None):
"""先确认到位置, 再按下抬起。
⛔ 三个已验证的"位置对却点不上"原因(2026-10-23 实测):
1. **前台不是游戏** —— 点击会送给当前前台窗口。实测: 窗口位置正确、坐标
换算正确, 但前台是别的窗口, 结果点了个寂寞, 而旧版这里照样返回 True。
现在用 require_foreground 检查: 点击点必须落在**前台窗口的客户区**内,
否则拒绝并报错 —— 宁可失败也不要静默点错地方。
2. **移动后立刻按下** —— 游戏按帧采样, 移动还没被处理就点击, 会算在旧位置。
所以定位成功后先 settle 再按。
3. **按下时间太短** —— 默认 30ms 在掉帧时会漏; 改成 60ms。
实测 30/60/120ms 在干净环境下都能中, 但 60ms 对负载高的情况更稳。
4. **光标已经停在目标上时不会产生 MOUSEMOVE**(2026-11-15 实测) ——
`move_to` 发现已在目标(tol=1)就直接返回, 游戏收不到任何移动事件;
镜牢「获得E.G.O饰品」弹窗在这种"原地连点"下会吞掉点击
(同坐标改用 pyautogui 的软件点击, 一次就过)。所以移动前先挪开 10px,
保证有一次真实的移动事件。环境变量: LCP_DRIVER_WIGGLE=0 关闭,
LCP_DRIVER_PRESS_MS 改按下时长。
"""
press_ms = PRESS_MS if press_ms is None else press_ms
settle = SETTLE_SECONDS if settle is None else settle
wiggle = WIGGLE_ENABLED if wiggle is None else wiggle
if not self.ready:
return False
# 只在"原地连点"时抖动: 目标与上一次点击几乎同一点时, move_to 会直接返回、
# 不发移动事件。其余点击保持原样, 免得改变正常流程的手感
# (2026-11-15 实测: 每次点击都抖动时, 镜牢入场流程卡住过一次)。
repeat = (self._last_click is not None
and abs(sx - self._last_click[0]) <= 4
and abs(sy - self._last_click[1]) <= 4)
self._last_click = (sx, sy)
if wiggle and repeat:
self.move_relative(-WIGGLE_PIXELS, -WIGGLE_PIXELS)
if not self.move_to(sx, sy, tol=tol):
cx, cy = get_cursor()
self.log('[driver] 定位失败: 目标(%d,%d) 实际(%d,%d), 不点击'
% (sx, sy, cx, cy))
return False
if require_foreground:
ok, why = click_point_is_on_foreground(sx, sy, self.hwnd or None)
if not ok:
self.log('[driver] 拒绝点击(%d,%d): %s' % (sx, sy, why))
return False
if settle:
time.sleep(settle)
for _ in range(int(times)):
try:
if not self.down(1):
return False
time.sleep(press_ms / 1000.0)
finally:
self.up(1)
return not self._stopped
def key_down(self, key):
if self.ready:
self._dll.key_down(key)
def key_up(self, key):
if self.ready:
self._dll.key_up(key)
def scroll(self, amount):
if self.ready:
self._dll.scroll(int(amount))
def click_point_is_on_foreground(sx, sy, hwnd=None):
"""(屏幕坐标) 是否安全可点。
返回 (是否安全, 原因)。
⛔ 为什么必须比对句柄而不是比对矩形(2026-10-23 实测教训):
最初只判断"点击点落在前台窗口的矩形内", 结果把浏览器切到前台、点游戏里
同一个坐标, 校验**照样通过** —— 因为那个屏幕坐标同时也落在浏览器窗口的
矩形里。几何判断在窗口互相重叠时毫无意义。
所以: 给了 hwnd 就要求前台窗口**就是它**(或是它的子窗口); 没给 hwnd 时
退化成"有前台窗口且点在它矩形内", 可用性有限, 仅作兜底。
"""
fg = foreground_window()
if not fg:
return False, '当前没有前台窗口(GetForegroundWindow=0)'
if hwnd:
if fg == hwnd or _api('user32', 'IsChild', wintypes.BOOL,
[wintypes.HWND, wintypes.HWND])(hwnd, fg):
return True, 'ok'
return False, ('前台不是目标窗口(前台=%r, 目标=%r) —— 这次点击会打到别的窗口'
% (window_title(fg), window_title(hwnd)))
pt = wintypes.POINT(int(sx), int(sy))
rect = wintypes.RECT()
get_rect = _api('user32', 'GetWindowRect', wintypes.BOOL,
[wintypes.HWND, ctypes.POINTER(wintypes.RECT)])
if not get_rect(fg, ctypes.byref(rect)):
return False, '取不到前台窗口的区域'
if not (rect.left <= pt.x < rect.right and rect.top <= pt.y < rect.bottom):
return False, ('点击点(%d,%d)不在前台窗口内(区域 %d,%d-%d,%d)'
% (pt.x, pt.y, rect.left, rect.top, rect.right, rect.bottom))
return True, 'ok'
def client_to_screen(hwnd, x, y):
"""游戏客户区坐标 -> 屏幕坐标。"""
if not hwnd:
raise OSError('没有游戏窗口句柄')
pt = wintypes.POINT(int(x), int(y))
fn = _api('user32', 'ClientToScreen', wintypes.BOOL,
[wintypes.HWND, ctypes.POINTER(wintypes.POINT)])
if not fn(hwnd, ctypes.byref(pt)):
raise OSError('ClientToScreen 失败, 未发送输入')
return (pt.x, pt.y)
+44
View File
@@ -0,0 +1,44 @@
"""Cross-process ownership of the game during tasks and module conversion."""
import errno
import os
from contextlib import contextmanager
class GameBusyError(RuntimeError):
pass
def default_lock_path():
return os.path.expanduser('~/lc_mcp/game.lock')
@contextmanager
def exclusive_game(path=None):
"""Acquire without waiting; closing the file also releases a crashed owner's lock.
Keep the file in place: unlinking it would let another process lock a different
inode. The OS owns the lock, so a leftover file is not a stale reservation.
"""
path = os.path.abspath(path or default_lock_path())
os.makedirs(os.path.dirname(path), exist_ok=True)
with open(path, 'a+b') as lock:
lock.seek(0)
try:
if os.name == 'nt':
import msvcrt
msvcrt.locking(lock.fileno(), msvcrt.LK_NBLCK, 1)
else:
import fcntl
fcntl.flock(lock.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
except OSError as e:
if e.errno in (errno.EACCES, errno.EAGAIN, errno.EDEADLK):
raise GameBusyError('游戏正由其他任务或合成脚本使用,本次不接管') from e
raise
try:
yield
finally:
if os.name == 'nt':
lock.seek(0)
msvcrt.locking(lock.fileno(), msvcrt.LK_UNLCK, 1)
else:
fcntl.flock(lock.fileno(), fcntl.LOCK_UN)
+185
View File
@@ -0,0 +1,185 @@
# -*- coding: utf-8 -*-
"""全局急停热键。
为什么需要: 驱动级点击是闭环定位的 —— 手一动, 下一次点击前会读到新位置、算出
偏差、再把你推回目标点。所以任务运行期间鼠标是"拔河"状态, 用户没法用鼠标去点
停止按钮。键盘不受影响, 所以急停必须走键盘。
⛔ 为什么不用 pynput / 全局钩子(2026-10-22 实测):
pynput 的 GlobalHotKeys 在这台机器上**收不到任何键盘事件** —— 静态注册成功、
线程也活着, 但 keybd_event 和 SendInput 两种注入都触发不了它。钩子依赖
WH_KEYBOARD_LL, 在当前会话下不工作。
改用 GetAsyncKeyState 轮询: 不装钩子、不需要消息循环, 实测能正确看到注入的
按键。用 0x8000 位判断"当前按下"。
另外 AALC 自带的 pause_hotkey 也帮不上忙: 那个配置项只在 GUI
(app/farming_interface.py) 里注册, lc_mcp 走命令行子进程, 那条路径上没有监听。
默认 End(小键盘区右下角, 好按且不冲突), 可用环境变量 LCP_KILL_KEY 改成 pause / scrolllock / f11 等。
⛔ 不要用 F12: 那是 Steam 的截图键(用户 2026-10-22 指出), 按下去会弹 Steam 截图
覆盖层, 而且可能被 Steam 抢先消费。Esc / F11 也不合适 —— 游戏里分别是关菜单
和切全屏。
按下后终止任务子进程, 游戏保留。硬退出不会执行任务的 finally; 临时配置由
TaskRunner 的恢复文件机制处理。退出前先给驱动释放按住的鼠标键(on_stop),
清理或日志卡住时 STOP_TIMEOUT 后仍强制退出。监听器活在任务进程内, 所以即使
MCP 服务出问题、用户联系不上调用方, 按热键仍然能停。
"""
import ctypes
import os
import threading
import time
from contextlib import contextmanager
from functools import lru_cache
DEFAULT_KEY = 'end'
EXIT_CODE = 130 # 与 SIGINT 一致, 便于上层识别"被用户中止"
POLL_INTERVAL = 0.05 # 50ms 轮询, 人手按一下不会漏
STOP_TIMEOUT = 0.25 # 释放鼠标/写日志最多等这么久, 然后强退
START_DELAY = 0.3 # 先等一会儿, 避免把启动时按住的键当成急停
# 常用键 -> 虚拟键码。f12 保留是为了兼容旧配置, 但**不推荐** —— Steam 占用它。
VK = {
'f1': 0x70, 'f2': 0x71, 'f3': 0x72, 'f4': 0x73, 'f5': 0x74, 'f6': 0x75,
'f7': 0x76, 'f8': 0x77, 'f9': 0x78, 'f10': 0x79, 'f11': 0x7A, 'f12': 0x7B,
'esc': 0x1B, 'escape': 0x1B,
'pause': 0x13, 'break': 0x13,
'end': 0x23, 'home': 0x24, 'delete': 0x2E, 'insert': 0x2D,
'scrolllock': 0x91, 'numlock': 0x90, 'capslock': 0x14,
}
def resolve_vk(key):
"""键名 -> 虚拟键码。认不出返回 None(调用方负责报错, 不要静默用默认值)。"""
name = (key or '').strip().lower().strip('<>')
if not name:
name = DEFAULT_KEY
return VK.get(name)
@lru_cache(maxsize=None)
def _key_state_api():
"""独立绑定 GetAsyncKeyState, 不改共用的 ctypes.windll 的类型声明。"""
fn = ctypes.WinDLL('user32', use_last_error=True).GetAsyncKeyState
fn.argtypes = [ctypes.c_int]
fn.restype = ctypes.c_short
return fn
def _pressed(vk):
"""GetAsyncKeyState 的最高位 = 当前是否按下(低位只表示"按过", 不算)。"""
return bool(_key_state_api()(vk) & 0x8000)
class KillSwitch:
"""轮询线程。按住热键会立刻退出, 不会重复触发。"""
def __init__(self, vk, log=print, key_name=DEFAULT_KEY, on_stop=None):
self.vk = vk
self.log = log
self.key_name = key_name
self.on_stop = on_stop
self.fired = False
self._stopped = threading.Event()
self._thread = threading.Thread(target=self._run, daemon=True,
name='lc_mcp-killswitch')
def start(self):
self._thread.start()
return self
def is_alive(self):
return self._thread.is_alive()
def stop(self):
self._stopped.set()
def _run(self):
if self._stopped.wait(START_DELAY):
return
while not self._stopped.is_set():
try:
pressed = _pressed(self.vk)
except Exception as e: # 接口失效: 说清楚后退出, 不刷满异常
try:
self.log('[lc_mcp] 急停热键失效(%s: %s), 请用 stop_task 或 Ctrl+Alt+Del 停止'
% (type(e).__name__, e))
except Exception:
pass
return
if pressed:
self._fire()
return
self._stopped.wait(POLL_INTERVAL)
def _fire(self):
if self.fired:
return
self.fired = True
# 释放驱动按键或写日志卡住时, 由计时器按时强退。
timer = threading.Timer(STOP_TIMEOUT, os._exit, args=(EXIT_CODE,))
timer.daemon = True
try:
timer.start()
try:
if self.on_stop is not None:
self.on_stop()
except Exception:
pass # 释放失败也必须退出
try:
self.log('[lc_mcp] ⛔ 急停热键 %s 被按下, 终止任务; 游戏窗口保留, 可用 run_task 重新开始'
% self.key_name.upper())
except Exception:
pass # 日志坏了不能拦住急停
finally:
try:
os._exit(EXIT_CODE)
finally:
timer.cancel() # 仅在测试替换 _exit 时才会走到
def install(log=print, key=None, on_stop=None):
"""启动急停轮询线程。返回 KillSwitch, 失败返回 None(不抛异常)。
急停装不上不该让任务起不来, 但必须把原因和应急手段说清楚。
"""
key = key or os.environ.get('LCP_KILL_KEY') or DEFAULT_KEY
vk = resolve_vk(key)
if vk is None:
log('[lc_mcp] 急停热键不可用: 认不出键名 %r(可用: %s), 请用 Ctrl+Alt+Del 强制停止'
% (key, ', '.join(sorted(VK))))
return None
try:
_key_state_api()
except Exception as e: # 非 Windows / user32 不可用
log('[lc_mcp] 急停热键不可用(读取键盘状态失败: %s: %s), 请用 Ctrl+Alt+Del 强制停止'
% (type(e).__name__, e))
return None
try:
switch = KillSwitch(vk, log=log, key_name=key, on_stop=on_stop).start()
except Exception as e:
log('[lc_mcp] 急停热键启动失败(%s: %s), 请用 Ctrl+Alt+Del 强制停止'
% (type(e).__name__, e))
return None
log('[lc_mcp] 急停热键已就绪: 按 %s 终止任务, 游戏窗口保留; 可用 run_task 重新开始'
'(键盘可用, 不需要鼠标, 也不依赖 MCP 服务)' % key.upper())
return switch
def stop(switch):
"""停止轮询(任务结束时调用, 免得线程残留)。"""
if switch is None:
return
try:
switch.stop()
except Exception:
pass
@contextmanager
def listening(log=print, on_stop=None):
switch = install(log=log, on_stop=on_stop)
try:
yield switch
finally:
stop(switch)
+30 -7
View File
@@ -21,13 +21,23 @@ def collect(cfg):
return { return {
'simulator': bool(cfg.get_value('simulator')), 'simulator': bool(cfg.get_value('simulator')),
'mirror': bool(cfg.get_value('mirror')), 'mirror': bool(cfg.get_value('mirror')),
'set_windows': bool(cfg.get_value('set_windows')),
'set_win_position': cfg.get_value('set_win_position') or 'free',
'set_win_size': int(cfg.get_value('set_win_size')), 'set_win_size': int(cfg.get_value('set_win_size')),
'set_lunacy_to_enkephalin': int(cfg.get_value('set_lunacy_to_enkephalin') or 0), 'set_lunacy_to_enkephalin': int(cfg.get_value('set_lunacy_to_enkephalin') or 0),
'hard_mirror': bool(cfg.get_value('hard_mirror')),
'teams_active_queue': list(cfg.get_value('teams_active_queue') or []), 'teams_active_queue': list(cfg.get_value('teams_active_queue') or []),
'teams': teams, 'teams': teams,
} }
def team_fits_difficulty(team, hard):
"""与 AALC Mirror_task 的可用判定一致: 固定用途 0=只打困难, 1=只打普通。"""
if not team.get('fixed_team_use'):
return True
return int(team.get('fixed_team_use_select') or 0) == (0 if hard else 1)
def desktop_size(): def desktop_size():
"""主显示器分辨率(进程已由 bootstrap 设为 DPI aware, 取到的是物理像素)。""" """主显示器分辨率(进程已由 bootstrap 设为 DPI aware, 取到的是物理像素)。"""
from ctypes import windll from ctypes import windll
@@ -48,25 +58,38 @@ def check(values, task, desktop=None, env=None):
# all 只在 AALC 里勾选了镜牢时才会编队 # all 只在 AALC 里勾选了镜牢时才会编队
if task == 'mirror' or (task == 'all' and values.get('mirror')): if task == 'mirror' or (task == 'all' and values.get('mirror')):
teams = values.get('teams', {}) teams = values.get('teams', {})
for num in values.get('teams_active_queue', []): queue = list(values.get('teams_active_queue', []))
hard = bool(values.get('hard_mirror'))
usable = []
for num in queue:
team = teams.get(str(num)) team = teams.get(str(num))
if team is None: # AALC 归一化队列时丢弃非整数和不存在的编号
if team is None or type(num) is not int:
problems.append('teams_active_queue 里的队伍 %s 没有配置' % num) problems.append('teams_active_queue 里的队伍 %s 没有配置' % num)
continue continue
if team_fits_difficulty(team, hard):
usable.append(num)
order = list(team.get('sinner_order') or []) order = list(team.get('sinner_order') or [])
# team_formation 从 1 开始按顺序找罪人, 缺 1 就一个都不选, 然后无限重试编队 # team_formation 从 1 开始按顺序找罪人, 缺 1 就一个都不选, 然后无限重试编队
if 1 not in order: if 1 not in order:
problems.append( problems.append(
'队伍 %s 的 sinner_order 没有罪人(全是 0): 镜牢编队会选空队伍并无限重试。' '队伍 %s 的 sinner_order 没有罪人(全是 0): 镜牢编队会选空队伍并无限重试。'
'在 AALC 队伍设置里勾选罪人并排序' % num) '在 AALC 队伍设置里勾选罪人并排序' % num)
# 没有可用队伍时 Mirror_task 直接跳出循环, 进程照样 exit 0 报 succeeded
if not usable:
problems.append(
'镜牢没有可用队伍(teams_active_queue=%s, 当前%s镜牢): AALC 会一局不打就正常退出。'
'在 AALC 里启用队伍, 或调整队伍的"固定用途"' % (queue, '困难' if hard else '普通'))
if not values.get('simulator') and desktop: if not values.get('simulator') and values.get('set_windows', True) and desktop:
size = values.get('set_win_size', 0) size = values.get('set_win_size', 0)
need_w = int(size * 16 / 9) + FRAME_W # AALC removes the title bar and borders for every automatic position.
need_h = size + FRAME_H framed = values.get('set_win_position', 'free') == 'free'
need_w = int(size * 16 / 9) + (FRAME_W if framed else 0)
need_h = size + (FRAME_H if framed else 0)
if need_w > desktop[0] or need_h > desktop[1]: if need_w > desktop[0] or need_h > desktop[1]:
problems.append( problems.append(
'set_win_size=%s 需要 %sx%s 的窗口(含标题栏), 桌面只有 %sx%s: 窗口会被压扁成非 16:9,' 'set_win_size=%s 需要 %sx%s 的窗口(%s), 桌面只有 %sx%s: 窗口会被压扁成非 16:9,'
' 模板匹配全部失效。改小 set_win_size(如 720)或调大桌面分辨率' ' 模板匹配全部失效。改小 set_win_size(如 720)或调大桌面分辨率'
% (size, need_w, need_h, desktop[0], desktop[1])) % (size, need_w, need_h, '含标题栏' if framed else '无边框', desktop[0], desktop[1]))
return problems return problems
+51 -9
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
@@ -14,6 +14,23 @@ WAIT_INTERVAL = 1.0
INPUT_TOOLS = {'click', 'click_text', 'click_image', 'keypress', 'type_text', 'drag', 'show_game_background'} INPUT_TOOLS = {'click', 'click_text', 'click_image', 'keypress', 'type_text', 'drag', 'show_game_background'}
TASK_TOOLS = {'run_task', 'task_status', 'stop_task'} TASK_TOOLS = {'run_task', 'task_status', 'stop_task'}
AUTOMATION_INSTRUCTIONS = (
'常规日常刷取、领奖励、普通镜牢优先使用 AALC 的 run_task 自动流程。'
'先用 task_status 检查是否已有任务;已有任务时查看进度,不重复启动或为抢占而停止它。'
'日常用 task="daily",领奖用 task="reward",镜牢用 task="mirror";次数按用户要求传入。'
'例如一局镜牢调用 run_task({"task":"mirror","count":1});'
'只刷经验本时传 exp 次数和 thread=0,只刷纽本时传 thread 次数和 exp=0,避免沿用另一项配置。'
'启动成功仅表示任务已启动,随后轮询 task_status,最终同时检查 state、errors 和 pending_restore;'
'succeeded 带 errors 不能报告完整成功;镜牢完成局数不足时报 failed 并在 errors 写明 已完成/应打 局数。'
'运行中不用逐帧 get_state/click/keypress 重做流程。'
'出现 stall 时先 stop_task 并确认停止,再 get_state 排障;停止失败不发送输入。'
'用户停止或退出码130时结束,不自动重试。'
'主线、特殊速通路线、用户明确要求逐步控制或自动流程不支持的操作,才使用低层观察与输入;'
'这时先 get_state 核对当前画面。只查看状态或截图的请求不启动任务。'
'all 仅用于用户明确要求按配置运行全部任务;enkephalin 会花狂气,仅在明确授权消费时使用。'
'免费体力合成模块不属于 enkephalin;不把它改派为刷取或花狂气。'
)
def _obj(props=None, required=()): def _obj(props=None, required=()):
s = {'type': 'object', 'properties': props or {}} s = {'type': 'object', 'properties': props or {}}
@@ -33,9 +50,11 @@ _IMG = {'name': {'type': 'string', 'description': 'AALC 模板图相对路径,
TOOLS = [ TOOLS = [
{'name': 'show_game_background', 'description': '后台显示/恢复游戏窗口,使隐藏窗口继续渲染;不激活前台、不发送鼠标或键盘输入。', {'name': 'show_game_background', 'description': '后台显示/恢复游戏窗口,使隐藏窗口继续渲染;不激活前台、不发送鼠标或键盘输入。',
'inputSchema': _obj()}, 'inputSchema': _obj()},
{'name': 'get_state', 'description': '截图 + OCR, 返回游戏窗口内全部文字(含坐标/置信度)。决策前先调这个, 不要猜坐标', {'name': 'get_state', 'description': '截图 + OCR,返回窗口文字、坐标和置信度。用于观察、故障诊断和逐步控制前核对画面。'
'常规日常/领奖/普通镜牢优先 run_task,运行进度用 task_status,无需逐帧操作。',
'inputSchema': _obj()}, 'inputSchema': _obj()},
{'name': 'click_text', 'description': '按文字点击: OCR 定位后点中心。子串匹配、忽略空格, 完全相同的优先; index 选第几个命中', {'name': 'click_text', 'description': '逐步控制/故障恢复用:按文字定位后点中心,完全匹配优先,index 选命中。'
'常规日常/领奖/普通镜牢优先 run_task。',
'inputSchema': _obj({'text': _STR, 'index': {'type': 'number', 'default': 0}}, ['text'])}, 'inputSchema': _obj({'text': _STR, 'index': {'type': 'number', 'default': 0}}, ['text'])},
{'name': 'wait_for_text', 'description': '轮询 OCR 直到文字出现', 'inputSchema': _obj({'text': _STR, 'timeout': _TIMEOUT}, ['text'])}, {'name': 'wait_for_text', 'description': '轮询 OCR 直到文字出现', 'inputSchema': _obj({'text': _STR, 'timeout': _TIMEOUT}, ['text'])},
{'name': 'wait_for_text_gone', 'description': '轮询 OCR 直到文字消失', 'inputSchema': _obj({'text': _STR, 'timeout': _TIMEOUT}, ['text'])}, {'name': 'wait_for_text_gone', 'description': '轮询 OCR 直到文字消失', 'inputSchema': _obj({'text': _STR, 'timeout': _TIMEOUT}, ['text'])},
@@ -45,9 +64,11 @@ TOOLS = [
{'name': 'list_images', 'description': '列出 AALC 模板图(按前缀过滤, 如 mirror/ battle/ home/)', {'name': 'list_images', 'description': '列出 AALC 模板图(按前缀过滤, 如 mirror/ battle/ home/)',
'inputSchema': _obj({'prefix': {'type': 'string', 'default': ''}})}, 'inputSchema': _obj({'prefix': {'type': 'string', 'default': ''}})},
{'name': 'screenshot', 'description': '截游戏窗口, 返回 PNG 路径和尺寸', 'inputSchema': _obj()}, {'name': 'screenshot', 'description': '截游戏窗口, 返回 PNG 路径和尺寸', 'inputSchema': _obj()},
{'name': 'click', 'description': '按窗口截图像素坐标点击(优先用 click_text / click_image)', {'name': 'click', 'description': '逐步控制/故障恢复用:按最新窗口截图的像素坐标点击,优先 click_text / click_image。'
'常规日常/领奖/普通镜牢优先 run_task。',
'inputSchema': _obj({'x': _NUM, 'y': _NUM, 'times': {'type': 'number', 'default': 1}}, ['x', 'y'])}, 'inputSchema': _obj({'x': _NUM, 'y': _NUM, 'times': {'type': 'number', 'default': 1}}, ['x', 'y'])},
{'name': 'keypress', 'description': '按一次键: a-z 0-9 enter esc space tab shift ctrl alt up down left right', {'name': 'keypress', 'description': '逐步控制/故障恢复用:按一次 a-z 0-9 enter esc space tab shift ctrl alt up down left right。'
'常规日常/领奖/普通镜牢优先 run_task,无需自行循环战斗按键。',
'inputSchema': _obj({'key': _STR}, ['key'])}, 'inputSchema': _obj({'key': _STR}, ['key'])},
{'name': 'drag', 'description': '在游戏客户区保持左键按下并缓慢拖动,适用于卡包下拉;duration 是移动秒数,0.1–10,默认 1。先 get_state 核对坐标', {'name': 'drag', 'description': '在游戏客户区保持左键按下并缓慢拖动,适用于卡包下拉;duration 是移动秒数,0.1–10,默认 1。先 get_state 核对坐标',
'inputSchema': _obj({'from_x': _NUM, 'from_y': _NUM, 'to_x': _NUM, 'to_y': _NUM, 'inputSchema': _obj({'from_x': _NUM, 'from_y': _NUM, 'to_x': _NUM, 'to_y': _NUM,
@@ -55,13 +76,26 @@ TOOLS = [
['from_x', 'from_y', 'to_x', 'to_y'])}, ['from_x', 'from_y', 'to_x', 'to_y'])},
{'name': 'type_text', 'description': '向游戏窗口输入文本', 'inputSchema': _obj({'text': _STR}, ['text'])}, {'name': 'type_text', 'description': '向游戏窗口输入文本', 'inputSchema': _obj({'text': _STR}, ['text'])},
{'name': 'run_task', 'description': ( {'name': 'run_task', 'description': (
'常规日常刷取、领奖励、普通镜牢的首选工具;自动完成流程,无需逐按钮点击。先 task_status 确认没有任务在跑。'
'后台运行 AALC 现成的完整任务流程(会自动启动游戏、处理战斗/掉线重试)。立即返回, 用 task_status 看进度。' '后台运行 AALC 现成的完整任务流程(会自动启动游戏、处理战斗/掉线重试)。立即返回, 用 task_status 看进度。'
'all=按 AALC config.yaml 勾选的全部任务; daily=经验本+纽本(exp/thread 次数); reward=领奖励; ' 'all=按 AALC config.yaml 勾选的全部任务; daily=经验本+纽本(exp/thread 次数); reward=领奖励; '
'enkephalin=狂气换体力(times); mirror=镜牢(count 次数)。任务运行期间禁止手动点击类工具'), 'enkephalin=狂气换体力(times); mirror=镜牢(count 次数)。一局镜牢传 task=mirror,count=1;'
'传 count 时本次临时关闭 AALC 无限刷牢,结束后恢复;完成局数不足时任务报 failed。'
'只刷一种日常时把另一种次数显式设为0,省略次数沿用配置。'
'all 需明确要求全部任务;enkephalin 需明确授权花狂气,免费合成模块不能用它。'
'任务运行期间禁止手动点击类工具;最终 succeeded 也要检查 errors,用户停止后不自动重跑。'
'mirror 可加 strategy="rabbit_hole":兔子洞速刷(黑兽-卯 浮士德每回合放 E.G.O「空洞」,每场第一回合超频),'
'编队、长按点、路线卡包见 lc_mcp/data/rabbit_hole.json。'),
'inputSchema': _obj({'task': {'type': 'string', 'enum': sorted(TASKS)}, '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,
{'name': 'task_status', 'description': '查看任务状态(idle/running/succeeded/failed/stopped)和日志尾部。' 'strategy': {'type': 'string', 'enum': sorted({v for o in TASK_OPTIONS.values()
'succeeded 也要看 errors; running 时出现 stall 说明 AALC 在空转(如选中空队伍), 应 stop_task', for v in o['strategy']})}},
['task'])},
{'name': 'task_status', 'description': '启动 run_task 前检查占用,启动后轮询此工具监控,避免逐帧截图和重复启动。'
'返回 idle/running/succeeded/failed/stopped、日志及异常;'
'decisions.counts 按阶段统计选队/寻路/卡包/饰品/事件/商店的决策理由。'
'succeeded 也要看 errors 和 pending_restore;running 出现 stall 应 stop_task 并确认停止后排障;'
'stopped/退出码130 表示用户停止,不自动重跑。',
'inputSchema': _obj({'lines': {'type': 'number', 'default': 30}})}, 'inputSchema': _obj({'lines': {'type': 'number', 'default': 30}})},
{'name': 'stop_task', 'description': '强制停止当前任务(杀掉任务进程)', 'inputSchema': _obj()}, {'name': 'stop_task', 'description': '强制停止当前任务(杀掉任务进程)', 'inputSchema': _obj()},
] ]
@@ -96,6 +130,7 @@ class Server:
if method == 'initialize': if method == 'initialize':
return _ok(mid, {'protocolVersion': '2024-11-05', return _ok(mid, {'protocolVersion': '2024-11-05',
'capabilities': {'tools': {'listChanged': False}}, 'capabilities': {'tools': {'listChanged': False}},
'instructions': AUTOMATION_INSTRUCTIONS,
'serverInfo': {'name': 'lc-mcp', 'version': VERSION}}) 'serverInfo': {'name': 'lc-mcp', 'version': VERSION}})
if method == 'ping': if method == 'ping':
return _ok(mid, {}) return _ok(mid, {})
@@ -128,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):
+11 -2
View File
@@ -12,6 +12,8 @@ import time
from collections import deque from collections import deque
from .aalc_task import RESTORE_ENV from .aalc_task import RESTORE_ENV
from .decisions import DECISIONS_ENV, SUFFIX as DECISIONS_SUFFIX, summarize as summarize_decisions
from .killswitch import EXIT_CODE as USER_ABORT_EXIT
REPO = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) REPO = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
IS_WIN = sys.platform.startswith('win') IS_WIN = sys.platform.startswith('win')
@@ -167,11 +169,13 @@ class TaskRunner:
base = os.path.join(self.run_dir, 'task_%s_%s' % (stamp, task)) base = os.path.join(self.run_dir, 'task_%s_%s' % (stamp, task))
env = self._env() env = self._env()
env[RESTORE_ENV] = base + RESTORE_SUFFIX env[RESTORE_ENV] = base + RESTORE_SUFFIX
env[DECISIONS_ENV] = base + DECISIONS_SUFFIX
kw = {'creationflags': subprocess.CREATE_NEW_PROCESS_GROUP} if IS_WIN else {'start_new_session': True} kw = {'creationflags': subprocess.CREATE_NEW_PROCESS_GROUP} if IS_WIN else {'start_new_session': True}
with open(base + '.log', 'wb') as logf: with open(base + '.log', 'wb') as logf:
self.proc = subprocess.Popen(self.argv_factory(task, params), cwd=REPO, env=env, self.proc = subprocess.Popen(self.argv_factory(task, params), cwd=REPO, env=env,
stdin=subprocess.DEVNULL, stdout=logf, stderr=subprocess.STDOUT, **kw) stdin=subprocess.DEVNULL, stdout=logf, stderr=subprocess.STDOUT, **kw)
self.info = {'task': task, 'params': params, 'log': (base + '.log').replace('\\', '/'), self.info = {'task': task, 'params': params, 'log': (base + '.log').replace('\\', '/'),
'decisions': (base + DECISIONS_SUFFIX).replace('\\', '/'),
'restore': env[RESTORE_ENV], 'started': time.time(), 'stopped_by_user': False} 'restore': env[RESTORE_ENV], 'started': time.time(), 'stopped_by_user': False}
self._prune() self._prune()
return {'ok': True, 'task': task, 'pid': self.proc.pid, 'log': self.info['log']} return {'ok': True, 'task': task, 'pid': self.proc.pid, 'log': self.info['log']}
@@ -186,10 +190,14 @@ class TaskRunner:
state = 'running' state = 'running'
else: else:
self.info.setdefault('ended', time.time()) self.info.setdefault('ended', time.time())
state = 'stopped' if self.info['stopped_by_user'] else 'succeeded' if code == 0 else 'failed' state = ('stopped' if self.info['stopped_by_user'] or code == USER_ABORT_EXIT
else 'succeeded' if code == 0 else 'failed')
r = {'ok': True, 'state': state, 'task': self.info['task'], 'params': self.info['params'], r = {'ok': True, 'state': state, 'task': self.info['task'], 'params': self.info['params'],
'elapsed_s': int((self.info.get('ended') or time.time()) - self.info['started']), 'elapsed_s': int((self.info.get('ended') or time.time()) - self.info['started']),
'log': self.info['log'], 'log_tail': tail(self.info['log'], max(1, min(int(lines), 200)))} 'log': self.info['log'], 'log_tail': tail(self.info['log'], max(1, min(int(lines), 200)))}
counts = summarize_decisions(self.info['decisions'])
if counts:
r['decisions'] = {'path': self.info['decisions'], 'counts': counts}
if code is None: if code is None:
stalls = log_stalls(self.info['log']) stalls = log_stalls(self.info['log'])
if stalls: if stalls:
@@ -236,7 +244,8 @@ class TaskRunner:
def _prune(self): def _prune(self):
logs = sorted(glob.glob(os.path.join(self.run_dir, 'task_*.log')), key=os.path.getmtime) logs = sorted(glob.glob(os.path.join(self.run_dir, 'task_*.log')), key=os.path.getmtime)
for p in logs[:-self.keep_logs]: for p in logs[:-self.keep_logs]:
for path in (p, p[:-len('.log')] + DECISIONS_SUFFIX):
try: try:
os.remove(p) os.remove(path)
except OSError: except OSError:
pass pass
+9
View File
@@ -42,6 +42,10 @@ DEFAULT_REPORT_DIR = os.path.expanduser(os.path.join('~', 'lc_mcp', 'cycles'))
_log_file = None _log_file = None
class UserAborted(RuntimeError):
"""用户主动停止, 结束整轮, 不执行后续导航、升级或重试。"""
def log(msg): def log(msg):
line = '[%s] %s' % (time.strftime('%H:%M:%S'), msg) line = '[%s] %s' % (time.strftime('%H:%M:%S'), msg)
print(line, flush=True) print(line, flush=True)
@@ -176,6 +180,8 @@ def poll_task(task, timeout_s, sleep=time.sleep):
raise RuntimeError('无法读取任务状态: %s' % st.get('error', st)) raise RuntimeError('无法读取任务状态: %s' % st.get('error', st))
s = st.get('state') s = st.get('state')
el = int(time.time() - t0) el = int(time.time() - t0)
if s == 'stopped' or st.get('exit_code') == 130:
raise UserAborted('%s 已被用户停止' % task)
if s != 'running': if s != 'running':
log('%s 结束: state=%s elapsed=%ds exit=%s' % (task, s, el, st.get('exit_code'))) log('%s 结束: state=%s elapsed=%ds exit=%s' % (task, s, el, st.get('exit_code')))
# AALC 单次战斗失败后仍会 exit 0, succeeded 还要看 errors # AALC 单次战斗失败后仍会 exit 0, succeeded 还要看 errors
@@ -332,6 +338,9 @@ def main(argv=None):
try: try:
return run_cycle(args, step, finish) return run_cycle(args, step, finish)
except UserAborted as e:
step('用户停止', False, str(e))
return finish(130, '本轮已由用户停止')
except (OSError, RuntimeError, subprocess.SubprocessError) as e: except (OSError, RuntimeError, subprocess.SubprocessError) as e:
if isinstance(e, subprocess.CalledProcessError): if isinstance(e, subprocess.CalledProcessError):
output = (e.stdout or '') + (e.stderr or '') output = (e.stdout or '') + (e.stderr or '')
+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:]))
+103 -12
View File
@@ -33,6 +33,10 @@ from lc_ui import HERE, click, items, keypress, probe, screen_text
GAME_EXE = r'D:\SteamLibrary\steamapps\common\Limbus Company\LimbusCompany.exe' GAME_EXE = r'D:\SteamLibrary\steamapps\common\Limbus Company\LimbusCompany.exe'
GAME_PROC = 'LimbusCompany' GAME_PROC = 'LimbusCompany'
REPO = os.path.dirname(HERE) if os.path.basename(HERE) == 'scripts' else HERE REPO = os.path.dirname(HERE) if os.path.basename(HERE) == 'scripts' else HERE
if REPO not in sys.path:
sys.path.insert(0, REPO)
from lc_mcp.game_lock import exclusive_game
PYW = os.path.join(REPO, 'vendor', 'aalc', '.venv', 'Scripts', 'pythonw.exe') PYW = os.path.join(REPO, 'vendor', 'aalc', '.venv', 'Scripts', 'pythonw.exe')
SERVER_PORT = 8765 SERVER_PORT = 8765
@@ -110,19 +114,94 @@ def ensure_server(timeout_s=90):
# ---------------------------------------------------------------- 桌面渲染 # ---------------------------------------------------------------- 桌面渲染
def _blit_ok(hdc, hwnd=None):
"""探测采集 API, 窗口走 AALC 的 PrintWindow(flags=3)。不验证画面内容。"""
if not hdc:
return False
import ctypes
from ctypes import wintypes
import win32gui
import win32ui
source = target = bitmap = old = bitmap_handle = None
try:
width, height = 64, 64
if hwnd:
left, top, right, bottom = win32gui.GetClientRect(hwnd)
width, height = right - left, bottom - top
if width <= 0 or height <= 0:
return False
source = win32ui.CreateDCFromHandle(hdc)
target = source.CreateCompatibleDC()
bitmap = win32ui.CreateBitmap()
bitmap.CreateCompatibleBitmap(source, width, height)
bitmap_handle = bitmap.GetHandle()
old = target.SelectObject(bitmap)
if hwnd:
capture = ctypes.windll.user32.PrintWindow
capture.argtypes = [wintypes.HWND, wintypes.HDC, wintypes.UINT]
capture.restype = wintypes.BOOL
return bool(capture(hwnd, target.GetSafeHdc(), 3))
target.BitBlt((0, 0), (width, height), source, (0, 0), 0x00CC0020)
return True
except Exception:
return False
finally:
try:
if old is not None:
target.SelectObject(old)
finally:
try:
if target is not None:
target.DeleteDC()
finally:
if bitmap_handle is not None:
win32gui.DeleteObject(bitmap_handle)
# source 只包装调用者的 DC, 由调用者 ReleaseDC, 不能 DeleteDC。
def screen_blit_ok():
import win32gui
hdc = None
try:
hdc = win32gui.GetDC(0)
return _blit_ok(hdc)
except Exception:
return False
finally:
if hdc:
win32gui.ReleaseDC(0, hdc)
def window_blit_ok(hwnd):
import win32gui
hdc = None
try:
if win32gui.IsIconic(hwnd):
return False
hdc = win32gui.GetWindowDC(hwnd)
return _blit_ok(hdc, hwnd=hwnd)
except Exception:
return False
finally:
if hdc:
win32gui.ReleaseDC(hwnd, hdc)
def render_ok(): def render_ok():
"""桌面是否在出图(BitBlt 能否成功)。""" """游戏画面是否可采集。
from ctypes import windll
u, g = windll.user32, windll.gdi32 ⛔ 原来只测屏幕 BitBlt(GetDC(0))。2026-10-22 实测它在 RDP 会话下会瞬时失败,
hdc = u.GetDC(0) 而 AALC 走的是 background_screenshot(窗口 DC + PrintWindow), 那条路照样能截到图
mem = g.CreateCompatibleDC(hdc) —— 结果是我的自检把本来能干活的轮次判成"截不到图"给跳过了(10-17 02:23 就这样
bmp = g.CreateCompatibleBitmap(hdc, 64, 64) 白丢过一轮)。
g.SelectObject(mem, bmp)
r = g.BitBlt(mem, 0, 0, 64, 64, hdc, 0, 0, 0x00CC0020) 现在优先按 AALC 的方式测**窗口**能否采集, 窗口不在或不可采时才回退到屏幕。
g.DeleteObject(bmp) """
g.DeleteDC(mem) hwnd = _find_hwnd()
u.ReleaseDC(0, hdc) if hwnd and window_blit_ok(hwnd):
return bool(r) return True
return screen_blit_ok()
def parse_session_table(text): def parse_session_table(text):
@@ -685,8 +764,20 @@ def main(argv=None):
log('=== 开始: 体力换模块 ===') log('=== 开始: 体力换模块 ===')
try:
with exclusive_game():
return run_conversion(args, done)
except (OSError, RuntimeError, subprocess.SubprocessError) as e:
return done(1, '%s: %s' % (type(e).__name__, e))
def run_conversion(args, done):
if not ensure_server(): if not ensure_server():
return done(1, 'MCP 服务连不上, 也没能拉起来') return done(1, 'MCP 服务连不上, 也没能拉起来')
# Also refuse older task processes started before the shared lock was added.
status = probe('task_status', {'lines': 1})
if not status.get('ok') or status.get('state') not in ('idle', 'succeeded', 'failed', 'stopped'):
return done(1, 'AALC 任务仍在运行或状态无法确认,本轮不接管游戏')
# 断线会让截图全黑, 那之后什么都做不了 —— 先确认桌面在出图再动游戏 # 断线会让截图全黑, 那之后什么都做不了 —— 先确认桌面在出图再动游戏
if not ensure_display(): if not ensure_display():
return done(1, '桌面不在出图(会话被断开), 本轮跳过') return done(1, '桌面不在出图(会话被断开), 本轮跳过')
+3 -9
View File
@@ -5,14 +5,8 @@
# powershell -ExecutionPolicy Bypass -File scripts\install_convert_task.ps1 -EveryHours 6 # powershell -ExecutionPolicy Bypass -File scripts\install_convert_task.ps1 -EveryHours 6
# powershell -ExecutionPolicy Bypass -File scripts\install_convert_task.ps1 -Uninstall # powershell -ExecutionPolicy Bypass -File scripts\install_convert_task.ps1 -Uninstall
# #
# 节奏怎么定(体力恢复速度): # 默认每 4 小时检查一次; 是否合成以本轮实际体力读数为准, 不按固定恢复速率推算。
# Limbus 的体力每 6 分钟回 1 点, 上限 126。 # 合成 1 个模块需要 20 点体力。
# 合成 1 个模块要 20 点体力, 所以:
# 每 2 小时 -> 约 20 点 -> 1 个模块
# 每 4 小时 -> 约 40 点 -> 2 个模块(默认)
# 每 6 小时 -> 约 60 点 -> 3 个模块
# 只要不顶到 126 上限就不浪费恢复量, 所以更勤快些也不会亏。
# 4 小时是"每次都能换到东西"和"别老折腾游戏启动"之间的折中。
# #
# 这个任务和 LcMCPDailyCycle 是分开的: 用户明确要求这次不打任何关卡, # 这个任务和 LcMCPDailyCycle 是分开的: 用户明确要求这次不打任何关卡,
# 只挂机攒模块, 所以不能把刷取任务一起打开。 # 只挂机攒模块, 所以不能把刷取任务一起打开。
@@ -42,7 +36,7 @@ if (-not (Test-Path $script)) {
throw "找不到脚本: $script" throw "找不到脚本: $script"
} }
# 以当前用户运行。无人值守要点: 不要勾"只在用户登录时运行", 否则注销后不跑。 # 以当前用户的交互会话运行, 必须保持登录; 注销后没有可供截图/点击的游戏桌面。
$principal = New-ScheduledTaskPrincipal -UserId "$env:USERDOMAIN\$env:USERNAME" ` $principal = New-ScheduledTaskPrincipal -UserId "$env:USERDOMAIN\$env:USERNAME" `
-LogonType Interactive -RunLevel Limited -LogonType Interactive -RunLevel Limited
+4 -3
View File
@@ -6,7 +6,7 @@
# powershell -ExecutionPolicy Bypass -File scripts\install_unattended.ps1 # powershell -ExecutionPolicy Bypass -File scripts\install_unattended.ps1
# 可选: -At 05:30 每日运行时间。游戏每日重置为 06:00 (KST), 即北京时间 05:00 # 可选: -At 05:30 每日运行时间。游戏每日重置为 06:00 (KST), 即北京时间 05:00
# -EveryHours 2.5 改成"每 N 小时重复一轮"以持续刷取; 0 = 只按 -At 每天一次 # -EveryHours 2.5 改成"每 N 小时重复一轮"以持续刷取; 0 = 只按 -At 每天一次
# 单轮上限 = 60 + 75*Mirror 分钟, 间隔要大于它, 否则会被跳过 # 任务时限包含 daily 45 分钟、每局镜牢 100 分钟、各一次重试及 30 分钟收尾
# -Mirror 1 每轮镜牢局数, 0 = 不打镜牢 # -Mirror 1 每轮镜牢局数, 0 = 不打镜牢
# -Target 34 把队内人格升到的等级 # -Target 34 把队内人格升到的等级
# -Python <路径> 默认 vendor\aalc\.venv\Scripts\pythonw.exe (无窗口, 不抢游戏焦点) # -Python <路径> 默认 vendor\aalc\.venv\Scripts\pythonw.exe (无窗口, 不抢游戏焦点)
@@ -66,8 +66,9 @@ if (-not $NoWatchdog) {
$cycle = Join-Path $PSScriptRoot "auto_cycle.py" $cycle = Join-Path $PSScriptRoot "auto_cycle.py"
$action = New-ScheduledTaskAction -Execute $Python -WorkingDirectory $Repo ` $action = New-ScheduledTaskAction -Execute $Python -WorkingDirectory $Repo `
-Argument "-X utf8 `"$cycle`" --mirror $Mirror --target $Target" -Argument "-X utf8 `"$cycle`" --mirror $Mirror --target $Target"
# 一轮 daily 约 22 分钟, 每局镜牢实测 39~>70 分钟; 超过上限由计划任务强杀 # 与 auto_cycle.py 的 DAILY_TIMEOUT_S / MIRROR_TIMEOUT_S / STALL_RETRIES 对齐。
$limit = New-TimeSpan -Minutes (60 + 75 * [Math]::Max($Mirror, 0)) # 每个任务最多两次尝试, 另留 30 分钟给启动、轮询和升级; 避免外层先杀掉报告进程。
$limit = New-TimeSpan -Minutes (30 + 2 * (45 + 100 * [Math]::Max($Mirror, 0)))
if ($EveryHours -gt 0) { if ($EveryHours -gt 0) {
# 持续刷取: 每 N 小时重复一轮。开始时间取"现在", 装完即进入节奏。 # 持续刷取: 每 N 小时重复一轮。开始时间取"现在", 装完即进入节奏。
# 注意 New-TimeSpan -Hours 的参数是 [int], 传 2.5 会被截断成 2 小时, 所以用 -Minutes。 # 注意 New-TimeSpan -Hours 的参数是 [int], 传 2.5 会被截断成 2 小时, 所以用 -Minutes。
+88 -5
View File
@@ -1,4 +1,4 @@
"""Validated scene actions for Jev decisions and fixed speedrun macros.""" """Delegate ordinary mirror runs to AALC; retain Jev control for special speedruns."""
import argparse import argparse
import functools import functools
import json import json
@@ -9,7 +9,8 @@ from pathlib import Path
from mcp_session import Session as Bridge, SessionCancelled, SessionTimeout from mcp_session import Session as Bridge, SessionCancelled, SessionTimeout
from game_scenes import battle_is_terminal, battle_is_visible, death_retry_screen from game_scenes import battle_is_terminal, battle_is_visible, death_retry_screen
from run_state import prepare_run, save_json, record_claim, claim_is_current, complete_run from run_state import (RESUMABLE, load_json, prepare_run, save_json, record_claim,
claim_is_current, complete_run)
from decision_router import DecisionRouter, DecisionRequired from decision_router import DecisionRouter, DecisionRequired
from jev_client import request_answer from jev_client import request_answer
from lc_scene_aliases import normalize from lc_scene_aliases import normalize
@@ -797,22 +798,104 @@ def acquire_single_instance():
return lambda: kernel.CloseHandle(lease) return lambda: kernel.CloseHandle(lease)
def execution_workflow(args, executor_decider=None):
"""Keep explicit speedrun requirements and unfinished runs on their old path."""
if args.workflow != 'auto':
return args.workflow
if (args.config or args.decision_engine or executor_decider is not None
or os.environ.get('LC_FIXED_FALLBACK') == '1'):
return 'speedrun'
previous = None if args.new_run else load_json(RUNTIME_HOME / 'mirror_current_run.json')
if previous and previous.get('workflow') == 'aalc':
return 'aalc'
if args.resume or previous and previous.get('status') in RESUMABLE:
return 'speedrun'
return 'aalc'
def delegate_mirror(new_run=False, resume=False):
"""Start or inspect AALC once; the calling agent monitors task_status afterward."""
record = {'workflow': 'aalc', 'next_call': {'tool': 'task_status', 'args': {'lines': 30}},
'note': '启动或接管监控不代表通关。继续轮询 task_status,检查 errors 和 pending_restore;'
'停止用 stop_task 或急停键(默认 End)。调用超时或用户停止后不自动重试或转为逐步输入。'}
bridge = None
try:
if STOP_FILE.exists():
return dict(record, state='stopped', reason='stop_requested')
# An explicit workflow switch must not silently discard a special route.
previous = None if new_run else load_json(RUNTIME_HOME / 'mirror_current_run.json')
if previous and previous.get('status') in RESUMABLE:
return dict(record, state='requires_analysis', reason='unfinished_speedrun',
error='存在未完成的速通局;使用 --workflow speedrun --resume,明确新开任务时用 --new-run')
bridge = Bridge(cancelled=STOP_FILE.exists, raise_on_error=False)
current = bridge.call('task_status', {'lines': 30})
state = current.get('state')
if not current.get('ok') or state not in ('idle', 'running', 'succeeded', 'failed', 'stopped'):
return dict(record, state='requires_analysis', task_status=current)
if (resume and previous and previous.get('workflow') == 'aalc' and previous.get('task_log')
and current.get('log') != previous['task_log']):
return dict(record, state='requires_analysis', reason='task_changed', task_status=current)
if state == 'running':
return dict(record, state='monitoring' if current.get('task') == 'mirror' else 'busy',
task_status=current)
if state == 'stopped' or current.get('exit_code') == 130:
if not new_run:
return dict(record, state='stopped', task_status=current, reason='user_stopped')
if resume:
return dict(record, state='requires_analysis' if current.get('errors') or current.get('pending_restore')
or current.get('task') != 'mirror' else state, task_status=current)
if state == 'failed' or current.get('errors') or current.get('pending_restore'):
if not new_run or current.get('pending_restore'):
return dict(record, state='requires_analysis', task_status=current)
started = bridge.call('run_task', {'task': 'mirror', 'count': 1})
if not started.get('ok'):
return dict(record, state='requires_analysis', result=started)
record['result'] = started
run, _ = prepare_run(RUNTIME_HOME, new_run=True)
run.update(status='delegated', workflow='aalc', task_log=started.get('log'))
save_json(RUNTIME_HOME / 'mirror_current_run.json', run)
return dict(record, state='delegated')
except Exception as error:
record.update(state='stopped' if isinstance(error, SessionCancelled) else 'requires_analysis',
error='%s: %s' % (type(error).__name__, error))
if isinstance(error, (SessionCancelled, SessionTimeout)):
record.update(outcome_unknown=error.outcome_unknown, pending_tool=getattr(error, 'tool', None))
return record
finally:
if bridge is not None:
bridge.close()
def main(executor_decider=None): def main(executor_decider=None):
parser = argparse.ArgumentParser() parser = argparse.ArgumentParser()
parser.add_argument('config', nargs='?', help='Optional Jev JSON config; omit for execution-model handoff') parser.add_argument('config', nargs='?', help='Optional Jev JSON config for stepwise speedrun control')
parser.add_argument('--workflow', choices=('auto', 'aalc', 'speedrun'), default='auto',
help='Default: AALC for ordinary mirror runs; explicit model/config or unfinished speedrun keeps stepwise control')
parser.add_argument('--decision-engine', choices=('auto', 'jev', 'executor', 'fixed')) parser.add_argument('--decision-engine', choices=('auto', 'jev', 'executor', 'fixed'))
parser.add_argument('--steps', type=int, default=250) parser.add_argument('--steps', type=int, default=250, help='Stepwise speedrun action budget')
parser.add_argument('--seconds', type=int, default=1200) parser.add_argument('--seconds', type=int, default=1200, help='Stepwise speedrun time budget')
mode = parser.add_mutually_exclusive_group() mode = parser.add_mutually_exclusive_group()
mode.add_argument('--new-run', action='store_true', help='Start fresh state for a new dungeon') mode.add_argument('--new-run', action='store_true', help='Start fresh state for a new dungeon')
mode.add_argument('--resume', action='store_true', help='Require an unfinished run with matching state') mode.add_argument('--resume', action='store_true', help='Require an unfinished run with matching state')
args = parser.parse_args() args = parser.parse_args()
if args.steps <= 0 or args.seconds <= 0: if args.steps <= 0 or args.seconds <= 0:
parser.error('--steps and --seconds must be positive') parser.error('--steps and --seconds must be positive')
try:
workflow = execution_workflow(args, executor_decider)
except (OSError, ValueError) as error:
parser.error(str(error))
release = acquire_single_instance() release = acquire_single_instance()
if release is None: if release is None:
print(json.dumps({'state':'already_running'}), flush=True) print(json.dumps({'state':'already_running'}), flush=True)
return return
if workflow == 'aalc':
try:
record = delegate_mirror(new_run=args.new_run, resume=args.resume)
save_json(RUNTIME_HOME / 'aalc_mirror_status.json', record)
print(json.dumps(record, ensure_ascii=False), flush=True)
finally:
release()
return
log = RUNTIME_HOME / 'jev_mirror_log.jsonl' log = RUNTIME_HOME / 'jev_mirror_log.jsonl'
status = RUNTIME_HOME / 'jev_mirror_status.json' status = RUNTIME_HOME / 'jev_mirror_status.json'
deadline = time.monotonic() + args.seconds deadline = time.monotonic() + args.seconds
+2 -1
View File
@@ -297,6 +297,7 @@ def cmd_card(ci, ri, uptie=False):
print('详情页已打开') print('详情页已打开')
ok, desc = do_level_up() ok, desc = do_level_up()
print('升级: %s (%s)' % ('OK' if ok else 'FAIL', desc)) print('升级: %s (%s)' % ('OK' if ok else 'FAIL', desc))
ok2 = True
if uptie: if uptie:
ok2, desc2 = do_uptie() ok2, desc2 = do_uptie()
print('同步: %s (%s)' % ('OK' if ok2 else 'FAIL', desc2)) print('同步: %s (%s)' % ('OK' if ok2 else 'FAIL', desc2))
@@ -318,7 +319,7 @@ def cmd_card(ci, ri, uptie=False):
txt = screen_text(items) txt = screen_text(items)
if not ('IDENTITIES' in txt and 'Facades' in txt): if not ('IDENTITIES' in txt and 'Facades' in txt):
print('[warn] 未能回到 Identities 网格, 当前: ' + txt[:160]) print('[warn] 未能回到 Identities 网格, 当前: ' + txt[:160])
return 0 if ok else 1 return 0 if ok and ok2 else 1
# 每级升级所需经验(来源 wiki "EXP per Level" 表)。 # 每级升级所需经验(来源 wiki "EXP per Level" 表)。
+29
View File
@@ -164,6 +164,35 @@ class RunAalcTest(unittest.TestCase):
self.assertIn('preflight', info) self.assertIn('preflight', info)
self.assertEqual(self.tools(mcp), ['run_task']) self.assertEqual(self.tools(mcp), ['run_task'])
def test_user_stop_never_retries(self):
for status in ({'state': 'stopped', 'exit_code': 130},
{'state': 'stopped'}, {'state': 'failed', 'exit_code': 130}):
mcp = FakeMcp([status], [DONE])
with self.subTest(status=status), self.assertRaises(auto_cycle.UserAborted):
self.run_aalc(mcp)
self.assertEqual(self.tools(mcp), ['run_task'])
def test_mirror_emergency_stop_ends_cycle_before_upgrade_or_navigation(self):
mcp = FakeMcp([DONE], [{'state': 'stopped', 'exit_code': 130}])
poll = auto_cycle.poll_task
with tempfile.TemporaryDirectory() as tmp:
with mock.patch.object(auto_cycle, 'probe', mcp.probe), \
mock.patch.object(auto_cycle, 'poll_task',
side_effect=lambda t, s, **kw: poll(t, s, sleep=lambda _: None)), \
mock.patch.object(auto_cycle, 'lunacy_guard', return_value=(True, 'ok')), \
mock.patch.object(auto_cycle, 'ensure_team1', return_value=True), \
mock.patch.object(auto_cycle, 'goto_identities') as navigate, \
mock.patch.object(auto_cycle, 'run') as upgrade, \
mock.patch('builtins.print'):
code = auto_cycle.main(['--mirror', '1', '--report-dir', tmp])
report = json.loads(next(Path(tmp).glob('cycle_*.json')).read_text(encoding='utf-8'))
self.assertEqual(code, 130)
self.assertFalse(report['ok'])
self.assertIn('用户停止', report['result'])
navigate.assert_not_called()
upgrade.assert_not_called()
self.assertEqual(self.tools(mcp), ['run_task', 'run_task'])
def test_exit_zero_with_errors_is_failure(self): def test_exit_zero_with_errors_is_failure(self):
mcp = FakeMcp([dict(DONE, errors=['[ERROR] 超出最大尝试次数,未能进入战斗'])]) mcp = FakeMcp([dict(DONE, errors=['[ERROR] 超出最大尝试次数,未能进入战斗'])])
ok, info = self.run_aalc(mcp) ok, info = self.run_aalc(mcp)
+154
View File
@@ -0,0 +1,154 @@
"""Ordinary mirror requests delegate to AALC without entering the click loop."""
import contextlib
import io
import json
import os
from pathlib import Path
import sys
import tempfile
from types import SimpleNamespace
import unittest
from unittest import mock
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'scripts'))
import jev_mirror_agent as agent
from mcp_session import SessionTimeout
from run_state import save_json
class AutomationDispatchTest(unittest.TestCase):
def setUp(self):
folder = tempfile.TemporaryDirectory()
self.addCleanup(folder.cleanup)
self.home = Path(folder.name)
for patch in (mock.patch.object(agent, 'RUNTIME_HOME', self.home),
mock.patch.object(agent, 'STOP_FILE', self.home / 'JEV_STOP'),
mock.patch.dict(os.environ, {'LC_FIXED_FALLBACK': '0'})):
patch.start()
self.addCleanup(patch.stop)
def workflow(self, **overrides):
args = dict(workflow='auto', config=None, decision_engine=None, new_run=False, resume=False)
args.update(overrides)
return agent.execution_workflow(SimpleNamespace(**args))
def test_ordinary_request_defaults_to_aalc(self):
self.assertEqual(self.workflow(), 'aalc')
def test_special_requirements_preserve_speedrun(self):
for args in ({'config': 'jev.json'}, {'decision_engine': 'executor'}, {'resume': True},
{'workflow': 'speedrun'}):
with self.subTest(args=args):
self.assertEqual(self.workflow(**args), 'speedrun')
save_json(self.home / 'mirror_current_run.json', {'status': 'requires_decision'})
self.assertEqual(self.workflow(), 'speedrun')
self.assertEqual(self.workflow(new_run=True), 'aalc')
def delegate(self, current, started=None, **kwargs):
bridge = mock.Mock()
bridge.call.side_effect = [current, started or {'ok': True, 'log': 'new.log', 'task': 'mirror'}]
with mock.patch.object(agent, 'Bridge', return_value=bridge):
result = agent.delegate_mirror(**kwargs)
bridge.close.assert_called_once()
return result, bridge
def test_launches_only_mirror_and_returns_monitoring_contract(self):
result, bridge = self.delegate({'ok': True, 'state': 'idle'})
self.assertEqual(result['state'], 'delegated')
self.assertEqual(result['next_call']['tool'], 'task_status')
self.assertEqual(bridge.call.call_args_list, [mock.call('task_status', {'lines': 30}),
mock.call('run_task', {'task': 'mirror', 'count': 1})])
run = json.loads((self.home / 'mirror_current_run.json').read_text())
self.assertFalse(run['dungeon_completed'])
self.assertFalse(run['final_reward_claimed'])
self.assertEqual(self.workflow(resume=True), 'aalc')
def test_running_mirror_is_monitored_without_duplicate_start(self):
result, bridge = self.delegate({'ok': True, 'state': 'running', 'task': 'mirror'})
self.assertEqual(result['state'], 'monitoring')
self.assertEqual(bridge.call.call_count, 1)
def test_other_running_task_is_not_stopped_or_replaced(self):
result, bridge = self.delegate({'ok': True, 'state': 'running', 'task': 'daily'})
self.assertEqual(result['state'], 'busy')
self.assertEqual(bridge.call.call_count, 1)
def test_user_stop_never_restarts_without_new_request(self):
for current in ({'ok': True, 'state': 'stopped', 'task': 'mirror'},
{'ok': True, 'state': 'failed', 'exit_code': 130}):
with self.subTest(current=current):
result, bridge = self.delegate(current)
self.assertEqual(result['state'], 'stopped')
self.assertEqual(bridge.call.call_count, 1)
result, bridge = self.delegate({'ok': True, 'state': 'stopped'}, new_run=True)
self.assertEqual(result['state'], 'delegated')
def test_unknown_or_failed_status_never_triggers_blind_retry(self):
for current in ({}, {'ok': False, 'error': 'offline'}, {'ok': True, 'state': 'unexpected'},
{'ok': True, 'state': 'failed'},
{'ok': True, 'state': 'succeeded', 'errors': ['battle failed']},
{'ok': True, 'state': 'succeeded', 'pending_restore': ['x.restore.json']}):
with self.subTest(current=current):
result, bridge = self.delegate(current)
self.assertEqual(result['state'], 'requires_analysis')
self.assertEqual(bridge.call.call_count, 1)
def test_resume_checks_errors_without_launching_another_run(self):
current = {'ok': True, 'state': 'succeeded', 'task': 'mirror', 'errors': ['battle failed']}
result, bridge = self.delegate(current, resume=True)
self.assertEqual(result['state'], 'requires_analysis')
self.assertEqual(bridge.call.call_count, 1)
def test_resume_does_not_accept_a_different_task_as_its_result(self):
save_json(self.home / 'mirror_current_run.json', {
'workflow': 'aalc', 'status': 'delegated', 'task_log': 'original.log'})
result, bridge = self.delegate({'ok': True, 'state': 'succeeded', 'task': 'mirror',
'log': 'another.log'}, resume=True)
self.assertEqual(result['reason'], 'task_changed')
self.assertEqual(bridge.call.call_count, 1)
def test_unfinished_speedrun_blocks_unrequested_workflow_switch(self):
save_json(self.home / 'mirror_current_run.json', {'status': 'requires_decision'})
with mock.patch.object(agent, 'Bridge') as factory:
result = agent.delegate_mirror()
self.assertEqual(result['reason'], 'unfinished_speedrun')
factory.assert_not_called()
def test_stop_marker_prevents_even_connecting(self):
agent.STOP_FILE.touch()
with mock.patch.object(agent, 'Bridge') as factory:
self.assertEqual(agent.delegate_mirror()['state'], 'stopped')
factory.assert_not_called()
def test_timeout_after_start_is_reported_without_retry_or_clicks(self):
bridge = mock.Mock()
error = SessionTimeout('reply lost')
error.tool = 'run_task'
bridge.call.side_effect = [{'ok': True, 'state': 'idle'}, error]
with mock.patch.object(agent, 'Bridge', return_value=bridge):
result = agent.delegate_mirror()
self.assertEqual(result['state'], 'requires_analysis')
self.assertTrue(result['outcome_unknown'])
self.assertEqual(result['pending_tool'], 'run_task')
self.assertEqual(bridge.call.call_count, 2)
bridge.close.assert_called_once()
def test_plain_cli_takes_aalc_path_without_model_or_ocr(self):
bridge = mock.Mock()
bridge.call.side_effect = [{'ok': True, 'state': 'idle'}, {'ok': True, 'log': 'mirror.log'}]
release = mock.Mock()
with mock.patch.object(sys, 'argv', ['agent']), \
mock.patch.object(agent, 'Bridge', return_value=bridge), \
mock.patch.object(agent, 'acquire_single_instance', return_value=release), \
mock.patch.object(agent, 'DecisionRouter') as router, \
contextlib.redirect_stdout(io.StringIO()):
agent.main()
router.assert_not_called()
release.assert_called_once()
result = json.loads((self.home / 'aalc_mirror_status.json').read_text())
self.assertEqual(result['state'], 'delegated')
self.assertEqual([call.args[0] for call in bridge.call.call_args_list], ['task_status', 'run_task'])
if __name__ == '__main__':
unittest.main()
+103 -1
View File
@@ -48,7 +48,109 @@ class BackgroundRestoreTest(unittest.TestCase):
engine.click(100, 200) engine.click(100, 200)
engine._restore_background_position.assert_called_once_with((20, 30)) engine._restore_background_position.assert_called_once_with((20, 30))
engine.auto.input_handler.set_mouse_pos.assert_not_called() engine.auto.input_handler.set_mouse_pos.assert_not_called()
engine.screen.handle.set_window_transparent.assert_called_once_with(True)
def test_click_restores_transparency_within_the_same_click(self):
"""⛔ 透明度必须在本次点击内还原, 不能留给下一次截图。
以前只在 background_screenshot 里恢复, 于是"点击 -> 截图 -> 点击 -> 截图"
的高频交替会让游戏窗口在不可见/可见之间反复切换 —— 肉眼看就是画面一直抽搐。
AALC 自己的 WindowMoveInput.mouse_click 根本不碰透明度, 所以它只"跳一下"。
"""
engine = AalcEngine.__new__(AalcEngine)
engine.cfg = SimpleNamespace(simulator=False, win_input_type='window_move')
engine.auto = mock.Mock()
engine.screen = mock.Mock()
engine.auto.input_handler._set_window_pos.return_value = (20, 30)
engine._background_mouse = mock.Mock()
engine._restore_background_position = mock.Mock()
engine._prepare_input = mock.Mock()
constants = SimpleNamespace(WM_MOUSEMOVE=512, WM_LBUTTONDOWN=513, WM_LBUTTONUP=514)
with mock.patch.dict(sys.modules, win32con=constants), \
mock.patch('lc_mcp.aalc_engine.time.sleep'):
engine.click(100, 200)
calls = [c.args[0] for c in engine.screen.handle.set_window_transparent.call_args_list]
self.assertEqual(calls, [True, False], '应当先设透明再立刻还原, 实际: %s' % calls)
def test_click_leaves_no_transparency_when_it_raises(self):
"""中途抛异常也必须把透明度还原, 否则窗口会一直隐形。"""
engine = AalcEngine.__new__(AalcEngine)
engine.cfg = SimpleNamespace(simulator=False, win_input_type='window_move')
engine.auto = mock.Mock()
engine.screen = mock.Mock()
engine.auto.input_handler._set_window_pos.return_value = (20, 30)
engine._background_mouse = mock.Mock()
engine._restore_background_position = mock.Mock()
engine._prepare_input = mock.Mock()
constants = SimpleNamespace(WM_MOUSEMOVE=512, WM_LBUTTONDOWN=513, WM_LBUTTONUP=514)
# 第二次 sleep 时抛错 —— 那一步在按下之后的 try 里, finally 必须照常还原
calls = {'n': 0}
def sleep_then_fail(_):
calls['n'] += 1
if calls['n'] >= 2:
raise RuntimeError('stopped')
with mock.patch.dict(sys.modules, win32con=constants), \
mock.patch('lc_mcp.aalc_engine.time.sleep', sleep_then_fail):
with self.assertRaises(RuntimeError):
engine.click(100, 200)
seen = [c.args[0] for c in engine.screen.handle.set_window_transparent.call_args_list]
self.assertIn(True, seen, '点击前应当设过透明')
self.assertEqual(seen[-1], False, '异常路径也要还原透明度, 实际: %s' % seen)
def test_foreground_mode_never_touches_transparency(self):
"""前台模式不需要搬窗口, 也就不该动透明度。"""
engine = AalcEngine.__new__(AalcEngine)
engine.cfg = SimpleNamespace(simulator=False, win_input_type='foreground')
engine.auto = mock.Mock()
engine.screen = mock.Mock()
engine.auto.input_handler.pos_offset.return_value = (100, 200)
engine._prepare_input = mock.Mock()
with mock.patch.dict(sys.modules, pyautogui=mock.Mock()), \
mock.patch('lc_mcp.aalc_engine.time.sleep'):
engine.click(100, 200)
engine.screen.handle.set_window_transparent.assert_not_called()
def test_window_cleanup_covers_setup_release_and_restore_failures(self):
constants = SimpleNamespace(WM_MOUSEMOVE=512, WM_LBUTTONDOWN=513, WM_LBUTTONUP=514)
for action in ('click', 'drag'):
for stage in ('move_window', 'activate', 'move_message', 'pre_press_sleep',
'release', 'restore'):
with self.subTest(action=action, stage=stage):
engine = AalcEngine.__new__(AalcEngine)
engine.cfg = SimpleNamespace(simulator=False, win_input_type='window_move')
engine.auto, engine.screen = mock.Mock(), mock.Mock()
engine.auto.input_handler._set_window_pos.return_value = (20, 30)
engine._grab = mock.Mock(return_value=SimpleNamespace(width=800, height=600))
engine._background_mouse = mock.Mock()
engine._restore_background_position = mock.Mock()
failure = RuntimeError(stage)
if stage == 'move_window':
engine.auto.input_handler._set_window_pos.side_effect = failure
elif stage == 'activate':
engine.auto.input_handler.set_active.side_effect = failure
elif stage == 'restore':
engine._restore_background_position.side_effect = failure
elif stage in ('move_message', 'release'):
message = 512 if stage == 'move_message' else 514
def send(kind, *args, **kwargs):
if kind == message:
raise failure
engine._background_mouse.side_effect = send
with mock.patch.dict(sys.modules, win32con=constants), \
mock.patch('lc_mcp.aalc_engine.time.sleep') as sleep:
if stage == 'pre_press_sleep':
sleep.side_effect = failure
with self.assertRaises(RuntimeError):
if action == 'click':
engine.click(100, 200)
else:
engine.drag(100, 100, 100, 300)
self.assertEqual(engine.screen.handle.set_window_transparent.call_args_list,
[mock.call(True), mock.call(False)])
if stage != 'move_window':
engine._restore_background_position.assert_called_once_with((20, 30))
def test_restore_uses_noactivate_and_preserves_foreground(self): def test_restore_uses_noactivate_and_preserves_foreground(self):
gui = mock.Mock() gui = mock.Mock()
+147 -1
View File
@@ -14,6 +14,7 @@ from unittest import mock
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'scripts')) sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'scripts'))
import convert_modules as cm # noqa: E402 import convert_modules as cm # noqa: E402
from lc_mcp import game_lock
class QuietLogMixin: class QuietLogMixin:
@@ -28,6 +29,62 @@ class QuietLogMixin:
patcher = mock.patch.object(cm, 'log', lambda m: None) patcher = mock.patch.object(cm, 'log', lambda m: None)
patcher.start() patcher.start()
self.addCleanup(patcher.stop) self.addCleanup(patcher.stop)
tmp = tempfile.TemporaryDirectory()
self.addCleanup(tmp.cleanup)
patcher = mock.patch.object(game_lock, 'default_lock_path',
return_value=os.path.join(tmp.name, 'game.lock'))
patcher.start()
self.addCleanup(patcher.stop)
patcher = mock.patch.object(cm, 'probe', return_value={'ok': True, 'state': 'idle'})
patcher.start()
self.addCleanup(patcher.stop)
class GameOwnershipTest(QuietLogMixin, unittest.TestCase):
def test_running_task_is_not_navigated_or_closed(self):
from lc_mcp.fake_engine import FakeEngine
from lc_mcp.protocol import Server
from lc_mcp.tasks import TaskRunner
with tempfile.TemporaryDirectory() as tmp:
runner = TaskRunner(tmp, argv_factory=lambda *a: [
sys.executable, '-c', 'import time; time.sleep(30)'])
server = Server(FakeEngine(), runner)
runner.start('daily', {}) # Emulate an older process without the shared lock.
try:
with mock.patch.object(cm, 'probe', side_effect=server.call_tool), \
mock.patch.object(cm, 'ensure_server', return_value=True), \
mock.patch.object(cm, 'ensure_display') as display, \
mock.patch.object(cm, 'launch_game') as launch, \
mock.patch.object(cm, 'close_game') as close:
self.assertEqual(cm.main(['--report-dir', tmp]), 1)
display.assert_not_called()
launch.assert_not_called()
close.assert_not_called()
self.assertTrue(runner.running())
self.assertEqual(server.engine.actions, [])
finally:
runner.stop()
def test_unknown_status_does_not_touch_the_game(self):
for status in ({}, {'ok': False}, {'ok': True, 'state': 'unknown'}):
with self.subTest(status=status), tempfile.TemporaryDirectory() as tmp, \
mock.patch.object(cm, 'probe', return_value=status), \
mock.patch.object(cm, 'ensure_server', return_value=True), \
mock.patch.object(cm, 'ensure_display') as display, \
mock.patch.object(cm, 'close_game') as close:
self.assertEqual(cm.main(['--report-dir', tmp]), 1)
display.assert_not_called()
close.assert_not_called()
def test_existing_owner_prevents_even_service_startup(self):
with tempfile.TemporaryDirectory() as tmp, \
mock.patch.object(cm, 'ensure_server') as server, \
mock.patch.object(cm, 'close_game') as close, \
game_lock.exclusive_game():
self.assertEqual(cm.main(['--report-dir', tmp]), 1)
server.assert_not_called()
close.assert_not_called()
class ScreenDetectTest(QuietLogMixin, unittest.TestCase): class ScreenDetectTest(QuietLogMixin, unittest.TestCase):
@@ -603,6 +660,14 @@ class CliRoutingTest(QuietLogMixin, unittest.TestCase):
done = [] done = []
tmp = tempfile.mkdtemp() tmp = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, tmp, True) self.addCleanup(shutil.rmtree, tmp, True)
def close_owned_game():
# Ownership must cover shutdown too, so a new task cannot start here.
with self.assertRaises(game_lock.GameBusyError):
with game_lock.exclusive_game():
pass
closed.append(1)
with mock.patch.object(cm, 'read_enkephalin', lambda: 4), \ with mock.patch.object(cm, 'read_enkephalin', lambda: 4), \
mock.patch.object(cm, 'read_lunacy', lambda **k: 9699), \ mock.patch.object(cm, 'read_lunacy', lambda **k: 9699), \
mock.patch.object(cm, 'ensure_server', lambda *a: True), \ mock.patch.object(cm, 'ensure_server', lambda *a: True), \
@@ -611,7 +676,7 @@ class CliRoutingTest(QuietLogMixin, unittest.TestCase):
mock.patch.object(cm, 'wait_main_menu', lambda *a: True), \ mock.patch.object(cm, 'wait_main_menu', lambda *a: True), \
mock.patch.object(cm, 'ensure_window_size', lambda *a: (1600, 900)), \ mock.patch.object(cm, 'ensure_window_size', lambda *a: (1600, 900)), \
mock.patch.object(cm, 'close_panel', lambda: True), \ mock.patch.object(cm, 'close_panel', lambda: True), \
mock.patch.object(cm, 'close_game', lambda: closed.append(1)), \ mock.patch.object(cm, 'close_game', close_owned_game), \
mock.patch.object(cm.time, 'sleep', lambda s: None): mock.patch.object(cm.time, 'sleep', lambda s: None):
code = cm.main(argv + ['--report-dir', tmp]) code = cm.main(argv + ['--report-dir', tmp])
done.append(os.listdir(tmp)) done.append(os.listdir(tmp))
@@ -669,6 +734,87 @@ class CliRoutingTest(QuietLogMixin, unittest.TestCase):
self.assertEqual(code, 0) self.assertEqual(code, 0)
class RenderCheckTest(QuietLogMixin, unittest.TestCase):
"""⛔ render_ok() 必须测 AALC 真正走的那条采集路径。
原来只测屏幕 BitBlt(GetDC(0))。2026-10-22 实测它在 RDP 会话下会瞬时失败, 而
AALC 走的是 background_screenshot(窗口 DC + PrintWindow), 那条路照样能截到图 ——
结果是我的自检把本来能干活的轮次判成"截不到图"跳过了。
"""
def test_window_capture_alone_is_enough(self):
"""窗口能采到就算能干活 —— 不该再去看屏幕那一路。"""
with mock.patch.object(cm, '_find_hwnd', lambda: 123), \
mock.patch.object(cm, 'window_blit_ok', lambda hwnd: True), \
mock.patch.object(cm, 'screen_blit_ok',
lambda: self.fail('窗口能采就不该再测屏幕')):
self.assertTrue(cm.render_ok())
def test_falls_back_to_screen_when_window_is_missing(self):
with mock.patch.object(cm, '_find_hwnd', lambda: 0), \
mock.patch.object(cm, 'screen_blit_ok', lambda: True):
self.assertTrue(cm.render_ok())
def test_falls_back_to_screen_when_window_blit_fails(self):
with mock.patch.object(cm, '_find_hwnd', lambda: 123), \
mock.patch.object(cm, 'window_blit_ok', lambda hwnd: False), \
mock.patch.object(cm, 'screen_blit_ok', lambda: True):
self.assertTrue(cm.render_ok())
def test_reports_false_only_when_both_paths_fail(self):
with mock.patch.object(cm, '_find_hwnd', lambda: 123), \
mock.patch.object(cm, 'window_blit_ok', lambda hwnd: False), \
mock.patch.object(cm, 'screen_blit_ok', lambda: False):
self.assertFalse(cm.render_ok())
class CaptureApiTest(QuietLogMixin, unittest.TestCase):
def test_window_capture_uses_printwindow_and_releases_gdi_objects(self):
import ctypes
for outcome in (1, 0, OSError('capture failed')):
with self.subTest(outcome=outcome):
api, gui, ui = mock.Mock(), mock.Mock(), mock.Mock()
gui.GetClientRect.return_value = (0, 0, 1280, 720)
gui.IsIconic.return_value = False
source = ui.CreateDCFromHandle.return_value
target = source.CreateCompatibleDC.return_value
bitmap = ui.CreateBitmap.return_value
previous = target.SelectObject.return_value
if isinstance(outcome, Exception):
api.user32.PrintWindow.side_effect = outcome
else:
api.user32.PrintWindow.return_value = outcome
with mock.patch.dict(sys.modules, win32gui=gui, win32ui=ui), \
mock.patch.object(ctypes, 'windll', api, create=True):
self.assertEqual(cm.window_blit_ok(123), outcome == 1)
api.user32.PrintWindow.assert_called_once_with(123, target.GetSafeHdc(), 3)
target.BitBlt.assert_not_called()
bitmap.CreateCompatibleBitmap.assert_called_once_with(source, 1280, 720)
self.assertEqual(target.SelectObject.call_args_list,
[mock.call(bitmap), mock.call(previous)])
target.DeleteDC.assert_called_once()
gui.DeleteObject.assert_called_once_with(bitmap.GetHandle())
source.DeleteDC.assert_not_called()
gui.ReleaseDC.assert_called_once_with(123, gui.GetWindowDC())
def test_missing_dc_and_minimized_window_cannot_pass_capture(self):
gui = mock.Mock()
gui.IsIconic.return_value = True
with mock.patch.dict(sys.modules, win32gui=gui):
self.assertFalse(cm.window_blit_ok(123))
gui.GetWindowDC.assert_not_called()
self.assertFalse(cm._blit_ok(0))
def test_screen_fallback_uses_bitblt(self):
gui, ui = mock.Mock(), mock.Mock()
source = ui.CreateDCFromHandle.return_value
target = source.CreateCompatibleDC.return_value
with mock.patch.dict(sys.modules, win32gui=gui, win32ui=ui):
self.assertTrue(cm.screen_blit_ok())
target.BitBlt.assert_called_once_with((0, 0), (64, 64), source, (0, 0), 0x00CC0020)
gui.ReleaseDC.assert_called_once_with(0, gui.GetDC())
class SessionTableTest(QuietLogMixin, unittest.TestCase): class SessionTableTest(QuietLogMixin, unittest.TestCase):
"""解析 `query session` —— 用来区分"截不到图"到底是哪种情况。 """解析 `query session` —— 用来区分"截不到图"到底是哪种情况。
+256
View File
@@ -0,0 +1,256 @@
# -*- coding: utf-8 -*-
"""决策审计日志(BACKLOG P2-8): 写入、统计、TaskRunner 归档, 以及商店/卡包两处只观察的审计。"""
import ast
import json
import logging
import os
import sys
import tempfile
import time
import types
import unittest
from pathlib import Path
from types import SimpleNamespace
from unittest import mock
REPO = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(REPO))
from lc_mcp import aalc_patches as ap # noqa: E402
from lc_mcp.decisions import DECISIONS_ENV, SUFFIX, DecisionLog, summarize # noqa: E402
from lc_mcp.tasks import TaskRunner # noqa: E402
THEME = REPO / 'vendor' / 'aalc' / 'tasks' / 'mirror' / 'select_theme_pack.py'
def read(path):
with open(path, encoding='utf-8') as f:
return [json.loads(line) for line in f]
class DecisionLogTest(unittest.TestCase):
def setUp(self):
tmp = tempfile.TemporaryDirectory()
self.addCleanup(tmp.cleanup)
self.path = os.path.join(tmp.name, 'run' + SUFFIX)
def test_without_env_nothing_is_written(self):
log = DecisionLog()
self.assertIsNone(log.open(env={}))
log.record('gift', 1, 'keyword')
self.assertFalse(os.path.exists(self.path))
def test_records_and_counts(self):
log = DecisionLog()
self.assertEqual(log.open(env={DECISIONS_ENV: self.path}), self.path)
log.record('gift', 2, 'keyword', system='bleed', hits=[[], ['流血']])
log.record('gift', 1, 'no_keyword', system='bleed', hits=[[], []])
log.record('gift', 1, 'keyword', system='bleed', hits=[['出血'], []])
log.record('shop', 'carmilla', 'purchase_clicked')
entries = read(self.path)
self.assertEqual(entries[0]['hits'], [[], ['流血']])
self.assertEqual(set(entries[0]), {'time', 'stage', 'choice', 'reason', 'system', 'hits'})
self.assertEqual(summarize(self.path), {'gift': {'keyword': 2, 'no_keyword': 1},
'shop': {'purchase_clicked': 1}})
def test_bad_lines_are_skipped_and_missing_file_is_none(self):
with open(self.path, 'w', encoding='utf-8') as f:
f.write('{"stage": "road", "reason": "lowest"}\nnot json\n{"stage": "road"}\n[]\n')
self.assertEqual(summarize(self.path), {'road': {'lowest': 1}})
self.assertIsNone(summarize(self.path + '.missing'))
def test_write_failure_does_not_raise(self):
DecisionLog(os.path.dirname(self.path)).record('gift', 1, 'keyword') # 路径是目录
class TaskRunnerDecisionsTest(unittest.TestCase):
CHILD = ('import os\n'
'from lc_mcp.decisions import decisions\n'
'decisions.open()\n'
'decisions.record("theme_pack", "信仰", "preferred")\n'
'decisions.record("gift", 2, "keyword")\n'
'decisions.record("gift", 1, "no_keyword")\n'
'print("[lc_mcp] done")\n')
def wait(self, runner):
deadline = time.time() + 15
while time.time() < deadline and runner.running():
time.sleep(0.05)
def test_child_writes_next_to_its_log_and_status_counts_it(self):
with tempfile.TemporaryDirectory() as d:
runner = TaskRunner(d, argv_factory=lambda t, p: [sys.executable, '-c', self.CHILD])
started = runner.start('mirror', {'count': 1})
self.assertTrue(started['ok'], started)
self.wait(runner)
status = runner.status()
self.assertEqual(status['state'], 'succeeded', status)
self.assertEqual(status['decisions']['path'], started['log'][:-len('.log')] + SUFFIX)
self.assertEqual(status['decisions']['counts'],
{'gift': {'keyword': 1, 'no_keyword': 1}, 'theme_pack': {'preferred': 1}})
def test_no_decisions_field_when_nothing_was_recorded(self):
with tempfile.TemporaryDirectory() as d:
runner = TaskRunner(d, argv_factory=lambda t, p: [sys.executable, '-c', 'print(1)'])
runner.start('daily', {})
self.wait(runner)
self.assertNotIn('decisions', runner.status())
def test_prune_removes_decisions_with_their_log(self):
with tempfile.TemporaryDirectory() as d:
runner = TaskRunner(d, argv_factory=lambda t, p: [sys.executable, '-c', 'print(1)'], keep_logs=1)
old = os.path.join(d, 'task_20260101_000000_mirror')
for path in (old + '.log', old + SUFFIX):
with open(path, 'w') as f:
f.write('{}\n')
os.utime(old + '.log', (1, 1))
runner.start('daily', {})
self.wait(runner)
self.assertFalse(os.path.exists(old + '.log'))
self.assertFalse(os.path.exists(old + SUFFIX))
class RecordingTest(unittest.TestCase):
"""把模块级 decisions 指到临时文件。"""
def setUp(self):
tmp = tempfile.TemporaryDirectory()
self.addCleanup(tmp.cleanup)
self.path = os.path.join(tmp.name, 'run' + SUFFIX)
patcher = mock.patch.object(ap.decisions, 'path', self.path)
patcher.start()
self.addCleanup(patcher.stop)
self.lines = []
def entries(self):
return read(self.path) if os.path.exists(self.path) else []
class ShopAuditTest(RecordingTest):
def setUp(self):
super().setUp()
self.auto = SimpleNamespace(click_element=mock.Mock(return_value=True),
mouse_action_with_pos=mock.Mock())
self.shop_cls = type('Shop', (), {'system': 'bleed'})
in_shop = types.ModuleType('tasks.mirror.in_shop')
in_shop.Shop = self.shop_cls
modules = {'tasks': types.ModuleType('tasks'), 'tasks.mirror': types.ModuleType('tasks.mirror'),
'tasks.mirror.in_shop': in_shop, 'module': types.ModuleType('module'),
'module.automation': SimpleNamespace(auto=self.auto)}
patcher = mock.patch.dict(sys.modules, modules)
patcher.start()
self.addCleanup(patcher.stop)
def test_purchases_are_recorded_with_the_item_clicked_before(self):
auto = self.auto
def buy_gifts(shop):
# 上游的三条购买路径: 必买项、四级素材、本体系饰品(按坐标)
auto.click_element('mirror/shop/must_purchase/carmilla.png', threshold=0.85)
auto.click_element(ap.SHOP_PURCHASE)
auto.click_element(ap.SHOP_CONFIRM)
auto.click_element('mirror/shop/level_IV_to_buy.png', threshold=0.82)
auto.click_element(ap.SHOP_PURCHASE)
auto.mouse_action_with_pos((300, 400), offset=True)
auto.click_element(ap.SHOP_PURCHASE, take_screenshot=True)
return 'done'
self.shop_cls.buy_gifts = buy_gifts
click, position = auto.click_element, auto.mouse_action_with_pos
ap.install_shop_audit(log=self.lines.append)
self.assertEqual(self.shop_cls().buy_gifts(), 'done')
self.assertEqual([(e['choice'], e['reason'], e['system']) for e in self.entries()],
[('carmilla', 'purchase_clicked', 'bleed'),
('level_IV_to_buy', 'purchase_clicked', 'bleed'),
('by_position', 'purchase_clicked', 'bleed')])
self.assertIs(auto.click_element, click)
self.assertIs(auto.mouse_action_with_pos, position)
position.assert_called_once_with((300, 400), offset=True)
def test_failed_purchase_click_is_not_recorded(self):
auto, real = self.auto, self.auto.click_element
def buy_gifts(shop):
auto.click_element('mirror/shop/must_purchase/carmilla.png')
real.return_value = False # 钱不够: 购买按钮匹配不上
auto.click_element(ap.SHOP_PURCHASE)
self.shop_cls.buy_gifts = buy_gifts
ap.install_shop_audit(log=self.lines.append)
self.shop_cls().buy_gifts()
self.assertEqual(self.entries(), [])
class ThemePackDecisionTest(unittest.TestCase):
def test_messages_to_decision(self):
weights = "当前主题包权重列表:[('信仰', 0), ('unknown', -5)]"
self.assertEqual(ap.theme_pack_decision([weights, '此次选择卡包关键词:信仰']),
('信仰', 'preferred', "[('信仰', 0), ('unknown', -5)]"))
self.assertEqual(ap.theme_pack_decision(['无匹配最低阈值的主题包,选择最高权重主题包\n此次选择卡包关键词:赌徒'])[:2],
('赌徒', 'highest_weight'))
self.assertEqual(ap.theme_pack_decision(['此次主题包选择了最左边的(活动)卡包'])[:2],
('最左边的活动卡包', 'event_pack'))
self.assertIsNone(ap.theme_pack_decision(['选择卡包: (1, 2)']))
@unittest.skipUnless(THEME.is_file(), 'vendor/aalc 子模块未检出')
class UpstreamThemePackAuditTest(RecordingTest):
"""执行上游真实的 select_theme_pack, 审计从它自己的日志里取结果。"""
class Match:
def __init__(self, value, text):
self.value, self.text, self.position = value, text, [0, 0]
def run_upstream(self, packs, thresholds=0):
tree = ast.parse(THEME.read_text(encoding='utf-8'))
node = next(n for n in tree.body if isinstance(n, ast.FunctionDef) and n.name == 'select_theme_pack')
node.decorator_list = []
positions = [(300 + 300 * i, 300) for i in range(len(packs))]
weights = {name: weight for name, weight in packs if name}
def find_language_text(zh, en, crop):
x = (crop[0] + crop[2]) / 2
name = packs[min(range(len(packs)), key=lambda i: abs(positions[i][0] - x))][0]
return self.Match(weights[name], name) if name else False
auto = SimpleNamespace(
model=None, take_screenshot=lambda: object(), mouse_to_blank=lambda *a, **k: None,
find_element=lambda target, **kw: list(positions) if 'theme_pack_features' in target else False,
find_language_text=find_language_text, mouse_drag_down=mock.Mock(),
click_element=lambda *a, **k: False)
ns = dict(auto=auto, TextMatchResult=self.Match, sleep=lambda *a: None, back_init_menu=mock.Mock(),
log=logging.getLogger('AALC'),
cfg=SimpleNamespace(set_win_size=720, select_event_pack=False, skip_event_pack=False),
path_manager=SimpleNamespace(current_language='zh_cn'),
theme_list=SimpleNamespace(preferred_thresholds=thresholds,
get_effective_theme_pack_list=lambda *a: dict(weights)))
exec(compile(ast.Module(body=[node], type_ignores=[]), str(THEME), 'exec'), ns)
mirror_mod = types.ModuleType('tasks.mirror.mirror')
mirror_mod.select_theme_pack = ns['select_theme_pack']
package = types.ModuleType('tasks.mirror')
package.mirror = mirror_mod
logger = logging.getLogger('AALC')
with mock.patch.dict(sys.modules, {'tasks': types.ModuleType('tasks'), 'tasks.mirror': package,
'tasks.mirror.mirror': mirror_mod}), \
mock.patch.object(logger, 'level', logging.DEBUG), \
mock.patch.object(logger, 'propagate', False):
ap.install_theme_pack_audit(log=self.lines.append)
handlers = list(logger.handlers)
mirror_mod.select_theme_pack(False, 2, 1, False)
self.assertEqual(logger.handlers, handlers, '临时 handler 必须移除')
return auto.mouse_drag_down
def test_preferred_pack_is_recorded(self):
drag = self.run_upstream([('赌徒', -1), ('信仰', 2), (None, None)])
drag.assert_called_once_with(600, 300)
entry, = self.entries()
self.assertEqual((entry['stage'], entry['choice'], entry['reason'], entry['floor']),
('theme_pack', '信仰', 'preferred', 2))
self.assertIn("('信仰', 2)", entry['weights'])
if __name__ == '__main__':
unittest.main()
+639
View File
@@ -0,0 +1,639 @@
# -*- coding: utf-8 -*-
"""驱动级输入接管。
⛔ 这个模块的每一条"拒绝"都比"接管"更重要: 接管错了会让任务点错地方,
而拒绝只是继续用原来的注入方式。所以测试重点放在 preflight 的各种拒绝条件上。
背景(2026-10-22 实测):
* RDP 独立会话不能靠前台窗口判定, 必须核对进程与 console 会话 ID。
* 指针加速开着时 counts 和像素不成比例(+100/+200/+400 -> -45/-3/-3 像素),
关掉后严格 1:1。所以加速没关时不该给出"差不多"的位置。
"""
import sys
import contextlib
import os
import ast
import inspect
import threading
import unittest
from pathlib import Path
from types import SimpleNamespace
from unittest import mock
sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
from lc_mcp import driver_input as di # noqa: E402
from lc_mcp import aalc_patches as ap # noqa: E402
class PreflightTest(unittest.TestCase):
"""能不能用, 必须说得清楚; 不能用时一条都不能含糊。"""
def _drv(self, dll_ok=True, fg=True, accel=False, console=True):
d = di.DriverInput(dll_path='X.dll', log=lambda m: None)
d._dll = mock.Mock()
d._open = dll_ok
with mock.patch.object(di, 'has_foreground', lambda: fg), \
mock.patch.object(di, 'is_console_session', lambda: console), \
mock.patch.object(di, 'acceleration_on', lambda: accel):
return d.preflight()
def test_ok_when_everything_is_right(self):
ok, why = self._drv()
self.assertTrue(ok)
self.assertEqual(why, 'ok')
def test_refuses_without_driver(self):
ok, why = self._drv(dll_ok=False)
self.assertFalse(ok)
self.assertIn('device_open', why)
def test_refuses_in_a_session_without_foreground(self):
"""RDP 独立会话的典型特征 —— 这种会话里驱动级输入无效。"""
ok, why = self._drv(fg=False)
self.assertFalse(ok)
self.assertIn('前台窗口', why)
def test_remote_session_is_rejected_even_with_foreground(self):
ok, why = self._drv(console=False, fg=True)
self.assertFalse(ok)
self.assertIn('console', why)
def test_refuses_when_acceleration_is_on(self):
ok, why = self._drv(accel=True)
self.assertFalse(ok)
self.assertIn('加速', why)
def test_refuses_missing_dll_file(self):
d = di.DriverInput(dll_path=r'Z:\nope\nope.dll', log=lambda m: None)
self.assertFalse(d.open())
self.assertFalse(d.ready)
class MoveToTest(unittest.TestCase):
"""定位必须是闭环: 发位移 -> 读回 -> 不够再发。不依赖标定常数。"""
def test_converges_when_moves_are_exact(self):
pos = {'v': (0, 0)}
d = di.DriverInput(dll_path='X.dll', log=lambda m: None)
d._dll = mock.Mock()
d._open = True
def moveR(dx, dy, _):
pos['v'] = (pos['v'][0] + dx, pos['v'][1] + dy)
d._dll.moveR.side_effect = moveR
with mock.patch.object(di, 'get_cursor', lambda: pos['v']), \
mock.patch.object(di.time, 'sleep', lambda s: None):
self.assertTrue(d.move_to(300, 200))
self.assertEqual(pos['v'], (300, 200))
def test_gives_up_when_moves_do_nothing(self):
"""驱动不理人时不能假称到位 —— 那样会点错地方。"""
d = di.DriverInput(dll_path='X.dll', log=lambda m: None)
d._dll = mock.Mock()
d._open = True
with mock.patch.object(di, 'get_cursor', lambda: (0, 0)), \
mock.patch.object(di.time, 'sleep', lambda s: None):
self.assertFalse(d.move_to(300, 200, iters=4))
def test_tolerance_is_respected(self):
"""已经在容差内就不该再发位移 —— 白折腾还容易引入抖动。"""
d = di.DriverInput(dll_path='X.dll', log=lambda m: None)
d._dll = mock.Mock()
d._open = True
with mock.patch.object(di, 'get_cursor', lambda: (100, 100)), \
mock.patch.object(di.time, 'sleep', lambda s: None):
self.assertTrue(d.move_to(101, 101, tol=1))
self.assertEqual(d._dll.moveR.call_count, 0, '容差内不该发位移')
def test_out_of_tolerance_does_move(self):
"""超出容差就必须尝试移动, 只是驱动不动时要如实返回失败。"""
d = di.DriverInput(dll_path='X.dll', log=lambda m: None)
d._dll = mock.Mock()
d._open = True
with mock.patch.object(di, 'get_cursor', lambda: (100, 100)), \
mock.patch.object(di.time, 'sleep', lambda s: None):
self.assertFalse(d.move_to(105, 105, tol=1, iters=3))
self.assertGreater(d._dll.moveR.call_count, 0)
class ClickTest(unittest.TestCase):
"""没到位置就绝不点。"""
def _drv(self, reachable):
d = di.DriverInput(dll_path='X.dll', log=lambda m: None)
d._dll = mock.Mock()
d._open = True
return d
def test_clicks_only_after_positioning(self):
pos = {'v': (0, 0)}
d = self._drv(True)
d._dll.moveR.side_effect = lambda dx, dy, _: pos.update(
{'v': (pos['v'][0] + dx, pos['v'][1] + dy)})
with mock.patch.object(di, 'get_cursor', lambda: pos['v']), \
mock.patch.object(di.time, 'sleep', lambda s: None):
# 这里只测定位逻辑, 前台校验另有 ForegroundCheckTest
self.assertTrue(d.click(500, 400, require_foreground=False))
self.assertEqual(pos['v'], (500, 400))
d._dll.mouse_down.assert_called_once_with(1)
d._dll.mouse_up.assert_called_once_with(1)
def test_never_clicks_when_positioning_fails(self):
d = self._drv(False)
with mock.patch.object(di, 'get_cursor', lambda: (0, 0)), \
mock.patch.object(di.time, 'sleep', lambda s: None):
self.assertFalse(d.click(500, 400, require_foreground=False))
d._dll.mouse_down.assert_not_called()
d._dll.mouse_up.assert_not_called()
class InstallTest(unittest.TestCase):
"""接管 AALC 的点击: 条件不满足时**一个都不许改**。"""
def _auto(self):
auto = SimpleNamespace()
auto.input_handler = mock.Mock()
auto.mouse_click = auto.input_handler.mouse_click
return auto
def test_refuses_quietly_when_preflight_fails(self):
auto = self._auto()
before = auto.input_handler
drv = mock.Mock()
drv.preflight.return_value = (False, '不是物理会话')
got = ap.install_driver_click(auto, mock.Mock(), driver=drv, log=lambda m: None)
self.assertIsNone(got)
self.assertIs(auto.input_handler, before, '条件不满足就不该换 handler')
def test_rebinds_the_aliases_captured_at_init(self):
"""automation.py 初始化时把方法绑成了别名, 光换 handler 影响不到那些别名。"""
auto = self._auto()
old_click = auto.mouse_click
drv = mock.Mock()
drv.preflight.return_value = (True, 'ok')
got = ap.install_driver_click(auto, mock.Mock(), driver=drv, log=lambda m: None)
self.assertIs(got, drv)
self.assertIsNot(auto.mouse_click, old_click, '别名必须重绑')
def test_proxy_other_methods_fall_through(self):
"""拖拽/滑动/滚轮等仍走 AALC 原逻辑, 不能被吞掉。"""
handler = mock.Mock()
proxy = ap.DriverClickProxy(handler, mock.Mock(), mock.Mock(), log=lambda m: None)
proxy.mouse_drag(10, 20, 0.5, 0, 100, True)
handler.mouse_drag.assert_called_once()
proxy.wait_pause()
handler.wait_pause.assert_called_once()
class ClientToScreenTest(unittest.TestCase):
def test_uses_client_to_screen(self):
def fake(hwnd, byref_pt):
ptr = byref_pt._obj
ptr.x, ptr.y = ptr.x + 100, ptr.y + 50
return 1
api = mock.Mock()
api.user32.ClientToScreen.side_effect = fake
with mock.patch.object(di, '_win_library', side_effect=lambda name: getattr(api, name)):
self.assertEqual(di.client_to_screen(123, 7, 9), (107, 59))
def vendor_auto():
"""执行 vendor 的真实接线与交互门方法, 只隔离 Windows 输入后端。"""
root = Path(__file__).resolve().parents[1] / 'vendor/aalc/module/automation'
abstract = ast.parse((root / 'input_handlers/__init__.py').read_text())
abstract.body = [n for n in abstract.body if isinstance(n, ast.ClassDef)]
namespace = {'log': mock.Mock(), 'sleep': lambda _: None, 'time': lambda: 0}
exec(compile(abstract, str(root / 'input_handlers/__init__.py'), 'exec'), namespace)
base = namespace['AbstractInput']
class Handler(base):
def mouse_click(self, *args, **kwargs):
raise AssertionError('旧点击后端不应被调用')
def mouse_click_blank(self, *args, **kwargs):
raise AssertionError('空白点击不应回落到旧后端')
source = ast.parse((root / 'automation.py').read_text())
cls = next(n for n in source.body if isinstance(n, ast.ClassDef) and n.name == 'Automation')
keep = {'init_input', '_run_business_interaction', 'monitor_mouse_click',
'suspend_interactions', 'resume_interactions'}
cls.body = [n for n in cls.body if isinstance(n, ast.FunctionDef) and n.name in keep]
cls.keywords = []
namespace = {'__name__': 'module.automation.automation', '__package__': 'module.automation',
'inspect': inspect, 'AbstractInput': base, 'log': mock.Mock(),
'cfg': SimpleNamespace(simulator=False, win_input_type='foreground',
memory_protection=False), 'GATE_WAIT_TIMEOUT': 30}
exec(compile(ast.Module(body=[cls], type_ignores=[]), str(root / 'automation.py'), 'exec'), namespace)
auto = namespace['Automation']()
auto.input_handler = None
auto._input_lock = threading.RLock()
auto._interaction_gate = threading.Event()
auto._interaction_gate.set()
with mock.patch.dict(sys.modules, {'module.automation.input_handlers.input':
SimpleNamespace(Input=Handler)}):
auto.init_input()
return auto, Handler
class DriverWiringTest(unittest.TestCase):
def test_real_business_gate_and_monitor_share_the_input_lock(self):
auto, _ = vendor_auto()
drv = mock.Mock()
drv.preflight.return_value = (True, 'ok')
locked = []
drv.click.side_effect = lambda *a, **k: locked.append(auto._input_lock._is_owned()) or True
ap.install_driver_click(auto, mock.Mock(), driver=drv, log=lambda _: None)
auto.suspend_interactions()
entered = threading.Event()
wait = auto._interaction_gate.wait
def waiting(*args, **kwargs):
entered.set()
return wait(*args, **kwargs)
with mock.patch.object(auto.input_handler, '_screen_pos', return_value=(10, 20)), \
mock.patch.object(auto._interaction_gate, 'wait', side_effect=waiting):
worker = threading.Thread(target=auto.mouse_click, args=(10, 20), daemon=True)
worker.start()
try:
self.assertTrue(entered.wait(1), '业务点击必须等待交互门')
drv.click.assert_not_called()
# 监控点击允许绕过门, 但仍必须持有同一把锁。
auto.monitor_mouse_click(10, 20)
finally:
auto.resume_interactions()
worker.join(2)
self.assertFalse(worker.is_alive())
self.assertEqual(locked, [True, True])
def test_blank_click_uses_driver_and_move_back_is_honored(self):
auto, _ = vendor_auto()
drv = mock.Mock()
drv.preflight.return_value = (True, 'ok')
ap.install_driver_click(auto, mock.Mock(), driver=drv, log=lambda _: None)
with mock.patch.object(auto.input_handler, '_screen_pos', return_value=(10, 20)), \
mock.patch.object(di, 'get_cursor', return_value=(90, 80)):
self.assertTrue(auto.mouse_click_blank((1, 2), times=2, move_back=True))
drv.click.assert_called_once_with(10, 20, times=2)
drv.move_to.assert_called_once_with(90, 80)
def test_all_task_and_reinitialization_reinstall_after_init(self):
auto, handler_type = vendor_auto()
scheme = SimpleNamespace(init_game=auto.init_input)
scheme.script_task = lambda: (scheme.init_game(), auto.mouse_click_blank())
original = scheme.init_game
drv = mock.Mock()
drv.preflight.return_value = (True, 'ok')
with mock.patch.dict(os.environ, LCP_DRIVER_INPUT='1'), \
mock.patch.dict(sys.modules, {'module.automation.input_handlers.input':
SimpleNamespace(Input=handler_type)}), \
mock.patch.object(di, 'DriverInput', return_value=drv), \
mock.patch.object(ap.DriverClickProxy, '_screen_pos', return_value=(10, 20)):
with ap.driver_click_tasks(scheme, auto, mock.Mock(),
SimpleNamespace(simulator=False), log=lambda _: None):
scheme.script_task()
first = auto.input_handler
scheme.script_task()
self.assertIsNot(auto.input_handler, first)
self.assertIsInstance(auto.input_handler, ap.DriverClickProxy)
self.assertEqual(drv.click.call_count, 2)
self.assertIs(scheme.init_game, original)
def test_actual_task_entry_enables_driver_for_all_and_daily(self):
from lc_mcp import aalc_task
for task, problems in [('all', []), ('daily', []), ('all', ['invalid config'])]:
with self.subTest(task=task, problems=problems):
auto, handler_type = vendor_auto()
auto.clear_img_cache = mock.Mock()
auto.click_element = mock.Mock(return_value=False)
cfg = SimpleNamespace(simulator=False)
scheme = SimpleNamespace(init_game=auto.init_input)
scheme.script_task = lambda: (scheme.init_game(), auto.mouse_click(10, 20))
scheme.Daily_task_wrapper = lambda **kw: lambda: auto.mouse_click(10, 20)
scheme.to_get_reward = scheme.Buy_enkephalin = scheme.Mirror_task = mock.Mock()
drv = mock.Mock()
drv.preflight.return_value = (True, 'ok')
modules = {
'module.automation': SimpleNamespace(auto=auto),
'module.automation.input_handlers.input': SimpleNamespace(Input=handler_type),
'module.config': SimpleNamespace(cfg=cfg),
'module.game_and_screen': SimpleNamespace(screen=mock.Mock()),
'tasks.base': SimpleNamespace(script_task_scheme=scheme),
'tasks.base.retry_monitor': SimpleNamespace(retry_monitor=mock.Mock()),
'tasks.battle': SimpleNamespace(battle=mock.Mock()),
'utils.path_manager': SimpleNamespace(path_manager=mock.Mock()),
}
with mock.patch.dict(sys.modules, modules), \
mock.patch.dict(os.environ, LCP_DRIVER_INPUT='1', LCP_RESTORE_FILE=''), \
mock.patch.object(aalc_task, 'bootstrap'), \
mock.patch.object(aalc_task, 'exclusive_game'), \
mock.patch.object(aalc_task, 'headless_hdr_warning') as hdr_warning, \
mock.patch.object(aalc_task, 'mirror_progress',
lambda scheme: contextlib.nullcontext(ap.MirrorProgress())), \
mock.patch.object(aalc_task, 'install_exact_team_match'), \
mock.patch.object(aalc_task, 'install_robust_set_foreground'), \
mock.patch.object(aalc_task, 'WindowGuard'), \
mock.patch.object(aalc_task.killswitch, 'install') as install_hotkey, \
mock.patch.object(aalc_task, 'log'), \
mock.patch.object(aalc_task.preflight, 'collect', return_value={}), \
mock.patch.object(aalc_task.preflight, 'desktop_size', return_value=(1920, 1080)), \
mock.patch.object(aalc_task.preflight, 'check', return_value=problems), \
mock.patch.object(di, 'DriverInput', return_value=drv), \
mock.patch.object(ap.DriverClickProxy, '_screen_pos', return_value=(10, 20)):
self.assertEqual(aalc_task.run(task, {}), 3 if problems else 0)
install_hotkey.return_value.stop.assert_called_once()
self.assertEqual(hdr_warning.call_count, int(task == 'all' and not problems))
if problems:
drv.click.assert_not_called()
else:
drv.click.assert_called_once_with(10, 20, times=1)
install_hotkey.call_args.kwargs['on_stop']()
drv.emergency_stop.assert_called_once()
def test_disabled_and_simulator_leave_initialization_unchanged(self):
for enabled, simulator in [('0', False), ('1', True)]:
with self.subTest(enabled=enabled, simulator=simulator):
scheme = SimpleNamespace(init_game=mock.Mock())
original = scheme.init_game
with mock.patch.dict(os.environ, LCP_DRIVER_INPUT=enabled):
with ap.driver_click_tasks(scheme, mock.Mock(), mock.Mock(),
SimpleNamespace(simulator=simulator)):
self.assertIs(scheme.init_game, original)
class DriverFailureTest(unittest.TestCase):
def test_emergency_stop_releases_press_and_blocks_subsequent_clicks(self):
drv = di.DriverInput()
drv._open, drv._dll = True, mock.Mock()
with mock.patch.object(drv, 'move_to', return_value=True), \
mock.patch.object(di, 'click_point_is_on_foreground', lambda *a, **k: (True, 'ok')), \
mock.patch.object(di.time, 'sleep', side_effect=lambda _: drv.emergency_stop()):
# settle=0: 第一次 sleep 是按下后的按住时长, 急停发生在按住期间
self.assertFalse(drv.click(10, 20, times=3, settle=0))
drv._dll.mouse_down.assert_called_once_with(1)
drv._dll.mouse_up.assert_called_with(1)
self.assertFalse(drv.ready)
self.assertFalse(drv.click(30, 40))
# 急停前的"抖动"移动(见 DriverInput.click 注释 4)允许存在, 急停之后不能再有输入
moves = drv._dll.moveR.call_count
self.assertFalse(drv.move_relative(20, 30))
self.assertFalse(drv.down())
self.assertEqual(drv._dll.moveR.call_count, moves)
self.assertEqual(drv._pressed, set())
def test_release_even_if_sleep_is_interrupted(self):
drv = di.DriverInput()
drv._open, drv._dll = True, mock.Mock()
with mock.patch.object(drv, 'move_to', return_value=True), \
mock.patch.object(di, 'click_point_is_on_foreground',
lambda *a, **k: (True, '')), \
mock.patch.object(di.time, 'sleep', side_effect=InterruptedError):
with self.assertRaises(InterruptedError):
# settle=0 让第一个 sleep 出现在按下之后, 测的才是 try/finally
drv.click(1, 2, require_foreground=False, settle=0)
drv._dll.mouse_up.assert_called_once_with(1)
def test_release_even_if_coordinate_lookup_fails(self):
drv = mock.Mock()
proxy = ap.DriverClickProxy(mock.Mock(), drv, mock.Mock())
with mock.patch.object(proxy, '_screen_pos', side_effect=OSError('closed')):
with self.assertRaises(OSError):
proxy.mouse_up(1, 2)
drv.up.assert_called_once_with(1)
def test_no_physical_click_if_game_cannot_get_foreground(self):
drv = mock.Mock()
handle = SimpleNamespace(hwnd=123, isMinimized=False, setForeground=mock.Mock())
proxy = ap.DriverClickProxy(mock.Mock(), drv, SimpleNamespace(handle=handle), log=lambda _: None)
with mock.patch.object(di, 'is_console_session', return_value=True), \
mock.patch.object(di, 'foreground_window', return_value=999):
self.assertFalse(proxy.mouse_click(1, 2))
drv.click.assert_not_called()
handle.setForeground.assert_called_once()
def test_failed_windows_reads_do_not_become_zero_coordinates(self):
api = mock.Mock()
api.user32.ClientToScreen.return_value = 0
api.user32.GetCursorPos.return_value = 0
api.user32.SystemParametersInfoA.return_value = 0
with mock.patch.object(di, '_win_library', side_effect=lambda name: getattr(api, name)):
for fn, args in [(di.client_to_screen, (123, 1, 2)), (di.get_cursor, ()),
(di.acceleration_on, ())]:
with self.subTest(function=fn.__name__), self.assertRaises(OSError):
fn(*args)
def test_failed_environment_query_refuses_installation(self):
drv = di.DriverInput()
drv._open, drv._dll = True, mock.Mock()
with mock.patch.object(di, 'is_console_session', side_effect=OSError('session query failed')):
ok, reason = drv.preflight()
self.assertFalse(ok)
self.assertIn('session query failed', reason)
def test_dll_without_mouse_exports_is_rejected(self):
drv = di.DriverInput()
with mock.patch.object(di.os.path, 'exists', return_value=True), \
mock.patch.object(di.ctypes, 'CDLL', return_value=SimpleNamespace(device_open=lambda: 1)):
self.assertFalse(drv.open())
self.assertFalse(drv.ready)
def test_console_session_ids_are_compared(self):
api = mock.Mock()
def query(pid, sid):
sid._obj.value = 2
return 1
api.kernel32.ProcessIdToSessionId.side_effect = query
with mock.patch.object(di, '_win_library', side_effect=lambda name: getattr(api, name)):
for console, expected in [(2, True), (3, False), (0xFFFFFFFF, False)]:
api.kernel32.WTSGetActiveConsoleSessionId.return_value = console
self.assertEqual(di.is_console_session(), expected)
class ForegroundFallbackTest(unittest.TestCase):
def test_none_on_success_still_detaches_after_success_or_failure(self):
for failed in (False, True):
with self.subTest(failed=failed):
handle = SimpleNamespace(hwnd=123, setForeground=mock.Mock(side_effect=OSError))
gui = mock.Mock()
gui.GetForegroundWindow.return_value = 456
gui.SetForegroundWindow.side_effect = OSError if failed else None
process = mock.Mock()
process.GetWindowThreadProcessId.return_value = (11, 22)
process.AttachThreadInput.return_value = None
api = SimpleNamespace(GetCurrentThreadId=lambda: 33)
with mock.patch.dict(sys.modules, win32api=api, win32gui=gui, win32process=process):
ap.install_robust_set_foreground(SimpleNamespace(handle=handle), log=lambda _: None)
handle.setForeground()
self.assertEqual(process.AttachThreadInput.call_args_list,
[mock.call(33, 11, True), mock.call(33, 11, False)])
def win_api(**functions):
"""按 API 名替换 driver_input._api 返回的函数。"""
return mock.patch.object(di, '_api', side_effect=lambda library, name, result, args: functions[name])
def window_rect(left, top, right, bottom):
def get_window_rect(hwnd, ptr):
r = ptr._obj
r.left, r.top, r.right, r.bottom = left, top, right, bottom
return 1
return get_window_rect
class ForegroundCheckTest(unittest.TestCase):
"""位置对却点不上 —— 头号原因是前台不是游戏。
2026-10-23 实测: 窗口位置和坐标换算都正确, 但前台是浏览器, 点击全部落到
浏览器里, 而旧版 click() 照样返回 True。这组测试守住"必须拒绝"这一条。
"""
def _drv(self):
d = di.DriverInput(dll_path='X.dll', log=lambda m: None)
d._dll = mock.Mock()
d._open = True
return d
def test_rejects_when_no_foreground_window(self):
with mock.patch.object(di, 'foreground_window', return_value=None):
ok, why = di.click_point_is_on_foreground(100, 100)
self.assertFalse(ok)
self.assertIn('前台窗口', why)
def test_rejects_when_point_outside_foreground_window(self):
with mock.patch.object(di, 'foreground_window', return_value=12345), \
win_api(GetWindowRect=window_rect(0, 0, 50, 50)):
ok, why = di.click_point_is_on_foreground(999, 999)
self.assertFalse(ok)
self.assertIn('不在前台窗口内', why)
def test_accepts_when_point_inside_foreground_window(self):
with mock.patch.object(di, 'foreground_window', return_value=12345), \
win_api(GetWindowRect=window_rect(0, 0, 1920, 1080)):
ok, why = di.click_point_is_on_foreground(500, 500)
self.assertTrue(ok)
self.assertEqual(why, 'ok')
def test_click_refuses_when_check_fails(self):
"""校验不过 -> 一个按键都不许发。"""
pos = {'v': (500, 400)}
d = self._drv()
d._dll.moveR.side_effect = lambda dx, dy, _: None
with mock.patch.object(di, 'get_cursor', lambda: pos['v']), \
mock.patch.object(di.time, 'sleep', lambda s: None), \
mock.patch.object(di, 'click_point_is_on_foreground',
lambda *a, **k: (False, '')):
self.assertFalse(d.click(500, 400))
d._dll.mouse_down.assert_not_called()
d._dll.mouse_up.assert_not_called()
def test_click_proceeds_when_check_passes(self):
pos = {'v': (500, 400)}
d = self._drv()
with mock.patch.object(di, 'get_cursor', lambda: pos['v']), \
mock.patch.object(di.time, 'sleep', lambda s: None), \
mock.patch.object(di, 'click_point_is_on_foreground',
lambda *a, **k: (True, '')):
self.assertTrue(d.click(500, 400))
d._dll.mouse_down.assert_called_once_with(1)
d._dll.mouse_up.assert_called_once_with(1)
def test_press_duration_is_passed_through(self):
"""按下时长必须真的用上 —— 30ms 在掉帧时会漏点。"""
pos = {'v': (500, 400)}
d = self._drv()
slept = []
with mock.patch.object(di, 'get_cursor', lambda: pos['v']), \
mock.patch.object(di.time, 'sleep', lambda s: slept.append(s)), \
mock.patch.object(di, 'click_point_is_on_foreground',
lambda *a, **k: (True, '')):
d.click(500, 400, press_ms=120, settle=0)
self.assertIn(0.12, slept, '按下时长没生效')
def test_settle_delay_happens_before_press(self):
"""定位成功到按下之间要有间隔, 否则游戏把这次点击算在旧位置。"""
pos = {'v': (500, 400)}
d = self._drv()
order = []
d._dll.mouse_down.side_effect = lambda b: order.append('down')
with mock.patch.object(di, 'get_cursor', lambda: pos['v']), \
mock.patch.object(di, 'click_point_is_on_foreground',
lambda *a, **k: (True, '')), \
mock.patch.object(di.time, 'sleep',
lambda s: order.append('sleep%.2f' % s)):
d.click(500, 400, settle=0.08)
self.assertIn('down', order)
self.assertTrue(any(x.startswith('sleep') for x in order[:order.index('down')]),
'按下之前必须有 sleep')
class HwndForegroundCheckTest(unittest.TestCase):
"""句柄级前台校验。
⛔ 为什么不能只比矩形(2026-10-23 实测): 把浏览器切到前台, 点游戏里同一个
坐标, 只判断"点在不在前台窗口矩形内"的话**照样通过** —— 因为那个屏幕坐标
同时也落在浏览器窗口的矩形里。窗口重叠时几何判断毫无意义。
给了 hwnd 就必须要求前台窗口就是它。
"""
def test_accepts_when_foreground_is_the_target(self):
with mock.patch.object(di, 'foreground_window', return_value=999):
ok, why = di.click_point_is_on_foreground(100, 100, 999)
self.assertTrue(ok)
self.assertEqual(why, 'ok')
def test_accepts_child_window_of_target(self):
"""游戏可能有子窗口拿到焦点, 也算在目标窗口上。"""
is_child = mock.Mock(return_value=True)
with mock.patch.object(di, 'foreground_window', return_value=1000), \
win_api(IsChild=is_child):
ok, _ = di.click_point_is_on_foreground(100, 100, 999)
is_child.assert_called_once_with(999, 1000)
self.assertTrue(ok)
def test_rejects_when_foreground_is_another_window(self):
titles = {1000: 'Browser', 999: 'LimbusCompany'}
with mock.patch.object(di, 'foreground_window', return_value=1000), \
win_api(IsChild=mock.Mock(return_value=False)), \
mock.patch.object(di, 'window_title', side_effect=titles.get):
ok, why = di.click_point_is_on_foreground(100, 100, 999)
self.assertFalse(ok)
self.assertIn('前台不是目标窗口', why)
self.assertIn('Browser', why)
def test_bind_window_is_used_by_click(self):
"""绑定窗口后, click() 必须走句柄级校验。"""
d = di.DriverInput(dll_path='X.dll', log=lambda m: None)
d._dll = mock.Mock()
d._open = True
d.bind_window(4242)
self.assertEqual(d.hwnd, 4242)
seen = {}
def fake_check(sx, sy, hwnd=None):
seen['hwnd'] = hwnd
return False, '前台不是目标窗口'
with mock.patch.object(di, 'get_cursor', lambda: (10, 10)), \
mock.patch.object(di, 'click_point_is_on_foreground', fake_check), \
mock.patch.object(di.time, 'sleep', lambda s: None):
self.assertFalse(d.click(10, 10))
self.assertEqual(seen['hwnd'], 4242, 'click 没把绑定的句柄传下去')
d._dll.mouse_down.assert_not_called()
def test_proxy_rebinds_current_window_before_each_click(self):
"""游戏重启后句柄会变; 代理复用时若仍拿安装时的旧句柄, 前台校验会拒绝所有点击。"""
drv = di.DriverInput(dll_path='X.dll', log=lambda m: None).bind_window(111)
handle = SimpleNamespace(hwnd=222, isMinimized=False, setForeground=mock.Mock())
proxy = ap.DriverClickProxy(mock.Mock(), drv, SimpleNamespace(handle=handle), log=lambda _: None)
with mock.patch.object(di, 'is_console_session', return_value=True), \
mock.patch.object(di, 'foreground_window', return_value=222), \
mock.patch.object(di, 'client_to_screen', return_value=(5, 6)):
self.assertEqual(proxy._screen_pos(1, 2), (5, 6))
self.assertEqual(drv.hwnd, 222)
if __name__ == '__main__':
unittest.main()
+383
View File
@@ -0,0 +1,383 @@
# -*- coding: utf-8 -*-
"""镜牢事件按选项表选择(BACKLOG P1-4)。
2026-11-14 核对: Mirror.event_handling() 不认事件, 有 "???"/直接拿饰品/优势判定就选它, 否则点第一个选项。
补丁在上游每轮挑选项前按选项原文认事件、按表点; 端到端用例执行上游真实的 event_handling
(以及小指良单通模式用的 click_option_avoiding_unknown)。
"""
import ast
import functools
import json
import os
import sys
import tempfile
import time
import types
import unittest
from pathlib import Path
from types import SimpleNamespace
from unittest import mock
REPO = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(REPO))
from lc_mcp import aalc_patches as ap # noqa: E402
MIRROR = REPO / 'vendor' / 'aalc' / 'tasks' / 'mirror' / 'mirror.py'
EVENT = REPO / 'vendor' / 'aalc' / 'tasks' / 'event' / 'event_handling.py'
SCALE = 720 / 1440
MARKER_X = 699 # 选项框左边缘(1280x720, 由 2560 模板换算)
ROW_GAP = 60
SHEEP = ['你是特别的。', '你不是特别的。']
CHICKEN = ['鸡肉就是鸡肉喽。', '绝对是鸡腿,满满的汁液。', '鸡胸,肯定的,纯净无瑕。']
STATUE = ['侧耳倾听。', '摘下黄铜戒指。', '放上钱币。']
def markers(count):
return [(MARKER_X, 200 + ROW_GAP * i) for i in range(count)]
def rule(name='e', options=('别的选项',), text='要点的'):
return {'name': name, 'id': None, 'options': tuple(options), 'text': text}
def upstream_function(path, name, cls=None):
tree = ast.parse(path.read_text(encoding='utf-8'))
body = tree.body
if cls:
body = next(n for n in body if isinstance(n, ast.ClassDef) and n.name == cls).body
return next(n for n in body if isinstance(n, ast.FunctionDef) and n.name == name)
class NormalizeEventTextTest(unittest.TestCase):
def test_punctuation_width_and_spaces_are_ignored(self):
self.assertEqual(ap.normalize_event_text('鸡胸,肯定的, 纯净 无瑕。'), '鸡胸肯定的纯净无瑕')
self.assertEqual(ap.normalize_event_text('“我不特别吗?”'), '我不特别吗')
self.assertEqual(ap.normalize_event_text('施加震颐'), '施加震颤')
class EventOptionsTest(unittest.TestCase):
def test_lines_attach_to_the_nearest_option_on_the_right(self):
lines = [('你是特别的', 900, 200),
('你不是', 900, 255), ('特别的。', 1000, 265), # 一项换成两行
('离开', 900, 322),
('侧耳倾听', 300, 260), # 左边的叙述文字不算选项
('梦中的电子羊', 200, 60)] # 标题
options = ap.event_options(list(reversed(markers(3))), lines, SCALE)
self.assertEqual([text for _, text in options], ['你是特别的', '你不是特别的', '离开'])
self.assertEqual([pos for pos, _ in options], markers(3))
def test_text_far_below_the_last_option_is_ignored(self):
options = ap.event_options(markers(1), [('继续', 900, 200 + 31)], SCALE)
self.assertEqual(options[0][1], '')
class ChooseEventOptionTest(unittest.TestCase):
def test_event_is_recognised_by_its_other_options(self):
rules = [rule('羊', ['你是特别的'], '你不是特别的')]
self.assertEqual(ap.choose_event_option(rules, ('你是特别的', '你不是特别的')), (rules[0], 1))
self.assertEqual(ap.choose_event_option(rules, ('你不是特别的', '离开')), (None, None))
def test_all_listed_options_must_be_on_screen(self):
rules = [rule('鸡', ['绝对是鸡腿', '鸡胸肯定的'], '鸡肉就是鸡肉喽')]
self.assertEqual(ap.choose_event_option(rules, ('鸡肉就是鸡肉喽', '绝对是鸡腿满满的汁液')), (None, None))
def test_recognised_but_target_not_read(self):
rules = [rule('鸡', ['绝对是鸡腿'], '鸡肉就是鸡肉喽')]
self.assertEqual(ap.choose_event_option(rules, ('鸡肉就是鸡', '绝对是鸡腿')), (rules[0], None))
def test_first_matching_rule_wins(self):
rules = [rule('a', ['离开'], '战斗'), rule('b', ['离开'], '交谈')]
self.assertEqual(ap.choose_event_option(rules, ('交谈', '战斗', '离开')), (rules[0], 1))
class EventTableTest(unittest.TestCase):
def test_shipped_table_is_valid(self):
rules = ap.load_event_choices()
self.assertGreaterEqual(len(rules), 5)
for r in rules:
with self.subTest(event=r['name']):
self.assertIsInstance(r['id'], int) # 零协汉化 ActionEvents 的事件 id, 方便回查
def test_shipped_events_come_from_the_event_reference(self):
reference = (REPO / 'docs/skills/limbus-mirror-speedrun/references/event-choices.md').read_text(encoding='utf-8')
for r in ap.load_event_choices():
with self.subTest(event=r['name']):
self.assertIn(r['name'].split('(')[0], reference)
def test_each_shipped_event_picks_its_own_option(self):
rules = ap.load_event_choices()
for r in rules:
with self.subTest(event=r['name']):
screen = (r['text'],) + r['options']
self.assertEqual(ap.choose_event_option(rules, screen), (r, 0))
def test_bad_tables_raise_value_error(self):
bad = ['[]', '{"events": {}}', '{"events": [1]}',
'{"events": [{"name": "a", "options": ["x"]}]}',
'{"events": [{"name": "a", "options": [], "text": "y"}]}',
'{"events": [{"name": "a", "options": "x", "text": "y"}]}',
'{"events": [{"name": "a", "options": ["x"], "text": ["y"]}]}',
'{"events": [{"name": "a", "options": ["。"], "text": "y"}]}',
'{"events": [{"name": "a", "options": ["离开"], "text": "离开。"}]}',
'{"events": [{"name": "a", "match": ["x"], "index": 2}]}']
with tempfile.TemporaryDirectory() as tmp:
path = os.path.join(tmp, 'e.json')
for content in bad:
with self.subTest(content=content):
with open(path, 'w', encoding='utf-8') as f:
f.write(content)
with self.assertRaises(ValueError):
ap.load_event_choices(path)
class EventScreen:
"""事件界面: 依次几屏选项, 点了一项就进下一屏, 最后回到地图。unknown 是带 "???" 标签的那一项。"""
def __init__(self, screens, unknown=None, ignore_clicks=0):
self.screens = [list(s) for s in screens]
self.unknown = unknown
self.stage = 0
self.ignore_clicks = ignore_clicks
self.chosen = []
self.model = None
self.screenshot = object()
self.ocr_runs = 0
@property
def options(self):
return self.screens[self.stage] if self.stage < len(self.screens) else None
def take_screenshot(self, *args, **kwargs):
self.screenshot = object() # 每次截图都是新对象, 与 AALC 一致
return self.screenshot
def mouse_to_blank(self, *args, **kwargs):
pass
def find_element(self, target, find_type='image', threshold=0.8, **kwargs):
options = self.options
if target == 'mirror/road_in_mir/legend_assets.png':
return options is None
if target == ap.EVENT_OPTION and options:
return markers(len(options)) if find_type == 'image_with_multiple_targets' else markers(1)[0]
if target == ap.EVENT_HOOK and options and self.stage == 0 and self.unknown is not None:
x, y = markers(len(options))[self.unknown]
return (x + 300, y + 20) # 标签画在所属选项框里面, 比左边缘靠下
if target == 'event/choices_assets.png':
return bool(options)
return [] if find_type == 'image_with_multiple_targets' else False
def click_element(self, target, **kwargs):
if target == ap.EVENT_OPTION and self.options:
self.mouse_click(*markers(1)[0])
return True
return False
def mouse_click(self, x, y, *args, **kwargs):
if not self.options:
return
rows = markers(len(self.options))
above = [i for i, (_, my) in enumerate(rows) if my <= y]
self.chosen.append(max(above) if above else 0)
if self.ignore_clicks:
self.ignore_clicks -= 1
return
self.stage += 1
def find_language_text(self, *args, **kwargs):
return False
def find_text_element(self, *args, **kwargs):
return False
def run(self, image):
self.ocr_runs += 1
lines = [('事件叙述文字', 200, 60)]
for (x, y), text in zip(markers(len(self.options or ())), self.options or ()):
lines.append((text, x + 200, y))
return SimpleNamespace(txts=tuple(t for t, _, _ in lines),
boxes=[[[x - 10, y - 5], [x + 10, y - 5], [x + 10, y + 5], [x - 10, y + 5]]
for _, x, y in lines])
@unittest.skipUnless(MIRROR.is_file() and EVENT.is_file(), 'vendor/aalc 子模块未检出')
class UpstreamEventHandlingTest(unittest.TestCase):
"""执行上游真实的 Mirror.event_handling, 看每屏点了第几项。"""
def setUp(self):
self.lines = []
self.fn_node = upstream_function(MIRROR, 'event_handling', cls='Mirror')
self.avoid_node = upstream_function(EVENT, 'click_option_avoiding_unknown', cls='EventHandling')
def play(self, screens, patched=True, env=None, unknown=None, solo=False, ignore_clicks=0):
screen = EventScreen(screens, unknown=unknown, ignore_clicks=ignore_clicks)
cfg = SimpleNamespace(set_win_size=720)
avoid_ns = dict(auto=screen, log=mock.Mock())
exec(compile(ast.Module(body=[self.avoid_node], type_ignores=[]), str(EVENT), 'exec'), avoid_ns)
ns = dict(auto=screen, retry=lambda: True, log=mock.Mock(), time=time, back_init_menu=mock.Mock(),
ImageUtils=SimpleNamespace(get_bbox=lambda image: (0, 0, 10, 10), load_image=lambda path: None))
exec(compile(ast.Module(body=[self.fn_node], type_ignores=[]), str(MIRROR), 'exec'), ns)
method = ns['event_handling']
ns['event_handling'] = SimpleNamespace( # 上游模块 tasks.event.event_handling 的同名单例
decision_event_handling=lambda: False,
click_option_avoiding_unknown=functools.partial(avoid_ns['click_option_avoiding_unknown'], None))
mirror_cls = type('Mirror', (), {'event_handling': method})
mirror_mod = types.ModuleType('tasks.mirror.mirror')
mirror_mod.Mirror = mirror_cls
package = types.ModuleType('tasks.mirror')
package.mirror = mirror_mod
modules = {'tasks': types.ModuleType('tasks'), 'tasks.mirror': package, 'tasks.mirror.mirror': mirror_mod,
'module': types.ModuleType('module'),
'module.automation': SimpleNamespace(auto=screen),
'module.config': SimpleNamespace(cfg=cfg),
'module.ocr': SimpleNamespace(ocr=screen)}
with mock.patch.dict(sys.modules, modules):
if patched:
self.assertIsNotNone(ap.install_event_choices(log=self.lines.append, env=env or {}))
mirror = mirror_cls()
mirror.event_total_time, mirror.event_times = 0, 0
mirror.defense_for_solo = solo
mirror.event_handling()
self.assertEqual(mirror.event_times, 1)
self.assertNotIn('find_element', vars(screen), 'find_element 必须还原')
self.assertNotIn('mouse_click', vars(screen), 'mouse_click 必须还原')
self.screen = screen
return screen.chosen
@property
def log(self):
return '\n'.join(self.lines)
def test_patch_hooks_into_the_current_upstream(self):
self.play([SHEEP])
self.assertIn('patch: 镜牢事件按选项表选择', self.log)
self.assertNotIn('[ERROR]', self.log)
def test_table_choice_is_clicked_exactly_once(self):
self.assertEqual(self.play([SHEEP], patched=False), [0])
self.assertEqual(self.play([SHEEP]), [1]) # 上游拿返回的位置再点一次会被吞掉
self.assertIn('事件 梦中的电子羊: 1=你是特别的 | 2=你不是特别的; 按表选第 2 项「你不是特别的」', self.log)
def test_table_beats_the_unknown_tag(self):
# 上游有 "???" 就点 "???"; 表里的事件按表点
self.assertEqual(self.play([CHICKEN[::-1]], unknown=0, patched=False), [0])
self.assertEqual(self.play([CHICKEN[::-1]], unknown=0), [2])
def test_solo_mode_does_not_click_a_second_option(self):
# 小指良单通模式会再找一次 "???" 并改点别的选项; 已按表点过时它必须什么也不做
self.assertEqual(self.play([STATUE], unknown=0, solo=True, patched=False), [1])
self.assertEqual(self.play([STATUE], unknown=0, solo=True), [0])
def test_unknown_event_behaves_like_upstream(self):
for kwargs in ({}, {'unknown': 1}, {'unknown': 1, 'solo': True}):
with self.subTest(**kwargs):
options = [['战斗', '离开']]
self.assertEqual(self.play(options, **kwargs), self.play(options, patched=False, **kwargs))
self.assertIn('事件选项: 1=战斗 | 2=离开; 表里没有这个事件, 交给 AALC', self.log)
def test_one_ocr_per_screenshot_in_solo_mode(self):
# 单通模式下上游会再找一次 "???"; 同一张截图不再整屏 OCR 第二遍
self.assertEqual(self.play([['战斗', '离开']], unknown=1, solo=True), [0])
self.assertEqual(self.screen.ocr_runs, 1)
def test_misread_target_falls_back_to_upstream(self):
options = [['鸡肉就是鸡', CHICKEN[1], CHICKEN[2]]]
self.assertEqual(self.play(options), [0])
self.assertIn('表里要点的「鸡肉就是鸡肉喽」没读到, 交给 AALC', self.log)
def test_later_screens_not_in_the_table_go_to_upstream(self):
self.assertEqual(self.play([CHICKEN[::-1], ['好', '不好']]), [2, 0])
def test_unresponsive_clicks_are_capped(self):
chosen = self.play([SHEEP], ignore_clicks=ap.EVENT_TEXT_CLICKS + 1)
self.assertEqual(chosen[:ap.EVENT_TEXT_CLICKS + 1], [1] * ap.EVENT_TEXT_CLICKS + [0])
self.assertIn('这次事件已按表点了 %d 次, 交给 AALC' % ap.EVENT_TEXT_CLICKS, self.log)
def test_decisions_are_recorded_once_per_screen(self):
with mock.patch.object(ap.decisions, 'record') as record:
self.play([SHEEP])
self.play([['战斗', '离开']])
self.assertEqual(record.call_args_list, [
mock.call('event', 2, 'text', event='梦中的电子羊', event_id=901038, options=['你是特别的', '你不是特别的']),
mock.call('event', None, 'not_in_table', options=['战斗', '离开'])])
def test_env_zero_keeps_upstream(self):
self.assertIsNone(ap.install_event_choices(log=self.lines.append, env={ap.EVENT_CHOICES_ENV: '0'}))
class InstallEventChoicesTest(unittest.TestCase):
def setUp(self):
self.lines = []
self.original = mock.Mock(side_effect=RuntimeError('boom'))
self.mirror_cls = type('Mirror', (), {'event_handling': self.original})
mirror_mod = types.ModuleType('tasks.mirror.mirror')
mirror_mod.Mirror = self.mirror_cls
package = types.ModuleType('tasks.mirror')
package.mirror = mirror_mod
self.auto = SimpleNamespace(find_element=mock.Mock(return_value=False), mouse_click=mock.Mock())
modules = {'tasks': types.ModuleType('tasks'), 'tasks.mirror': package, 'tasks.mirror.mirror': mirror_mod,
'module': types.ModuleType('module'),
'module.automation': SimpleNamespace(auto=self.auto),
'module.config': SimpleNamespace(cfg=SimpleNamespace(set_win_size=720))}
patcher = mock.patch.dict(sys.modules, modules)
patcher.start()
self.addCleanup(patcher.stop)
def test_methods_are_restored_after_an_exception(self):
find, click = self.auto.find_element, self.auto.mouse_click
ap.install_event_choices(log=self.lines.append, env={})
with self.assertRaises(RuntimeError):
self.mirror_cls().event_handling()
self.assertIs(self.auto.find_element, find)
self.assertIs(self.auto.mouse_click, click)
def test_unreadable_table_is_an_error(self):
with tempfile.TemporaryDirectory() as tmp:
path = os.path.join(tmp, 'e.json')
with open(path, 'w', encoding='utf-8') as f:
json.dump({'events': [{'name': 'a', 'match': ['x'], 'index': 1}]}, f)
self.assertIsNone(ap.install_event_choices(log=self.lines.append, env={ap.EVENT_CHOICES_ENV: path}))
self.assertIs(self.mirror_cls.event_handling, self.original)
self.assertTrue(self.lines[0].startswith('[ERROR] [lc_mcp] 事件选项表补丁跳过'))
def test_upstream_without_the_hook_is_an_error(self):
auto = self.auto
def event_handling(mirror):
return auto.click_element("event/unknown_event.png") # 旧写法: 补丁挂不上
self.mirror_cls.event_handling = event_handling
self.assertIsNone(ap.install_event_choices(log=self.lines.append, env={}))
self.assertIs(self.mirror_cls.event_handling, event_handling)
self.assertIn('[ERROR] [lc_mcp] 事件选项表补丁跳过: 上游 Mirror.event_handling 不再调用 find_element',
'\n'.join(self.lines))
def test_decision_error_falls_back_to_upstream_find(self):
calls = []
auto = self.auto
def find(target, *args, **kwargs):
if target == ap.EVENT_OPTION:
raise RuntimeError('template')
return False
def event_handling(mirror):
calls.append(auto.find_element("event/unknown_event.png"))
self.auto.find_element = mock.Mock(side_effect=find)
self.mirror_cls.event_handling = event_handling
ap.install_event_choices(log=self.lines.append, env={})
self.mirror_cls().event_handling()
self.assertEqual(calls, [False])
self.assertEqual(self.auto.find_element.call_args_list[-1], mock.call(ap.EVENT_HOOK))
self.assertIn('事件选项表出错(RuntimeError: template)', '\n'.join(self.lines))
if __name__ == '__main__':
unittest.main()
+67
View File
@@ -0,0 +1,67 @@
import os
from pathlib import Path
import subprocess
import sys
import tempfile
import time
import unittest
from unittest import mock
sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
from lc_mcp import aalc_task, game_lock
class GameLockTest(unittest.TestCase):
def setUp(self):
tmp = tempfile.TemporaryDirectory()
self.addCleanup(tmp.cleanup)
self.path = os.path.join(tmp.name, 'game.lock')
def test_exception_releases_lock_without_deleting_file(self):
with self.assertRaisesRegex(RuntimeError, 'failed'):
with game_lock.exclusive_game(self.path):
raise RuntimeError('failed')
self.assertTrue(os.path.exists(self.path))
with game_lock.exclusive_game(self.path):
with self.assertRaises(game_lock.GameBusyError):
with game_lock.exclusive_game(self.path):
self.fail('second owner acquired the game')
def test_process_lock_is_released_after_hard_exit(self):
ready = self.path + '.ready'
code = '''
import os, sys, time
from lc_mcp.game_lock import exclusive_game
with exclusive_game(sys.argv[1]):
with open(sys.argv[2], 'w') as marker:
marker.write('ready')
time.sleep(30)
'''
with subprocess.Popen([sys.executable, '-c', code, self.path, ready],
cwd=Path(__file__).resolve().parents[1],
stdout=subprocess.PIPE, stderr=subprocess.PIPE) as proc:
try:
deadline = time.monotonic() + 5
while not os.path.exists(ready) and proc.poll() is None and time.monotonic() < deadline:
time.sleep(.01)
self.assertTrue(os.path.exists(ready), 'child did not acquire the lock')
with self.assertRaises(game_lock.GameBusyError):
with game_lock.exclusive_game(self.path):
self.fail('parent acquired a live child lock')
finally:
proc.kill()
proc.communicate(timeout=5)
with game_lock.exclusive_game(self.path):
pass
def test_task_refuses_converter_lock_before_bootstrap(self):
with mock.patch.object(game_lock, 'default_lock_path', return_value=self.path), \
mock.patch.object(aalc_task, 'bootstrap') as bootstrap, \
mock.patch.object(aalc_task, 'log'):
with game_lock.exclusive_game():
self.assertEqual(aalc_task.run('daily', {}), aalc_task.PREFLIGHT_EXIT)
bootstrap.assert_not_called()
if __name__ == '__main__':
unittest.main()
+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()
+362
View File
@@ -0,0 +1,362 @@
# -*- coding: utf-8 -*-
"""镜牢饰品选择按体系关键词排序(BACKLOG P1-3)。
2026-11-14 核对: acquire_ego_gift() 两张卡时只排白棉花和已持有然后拿第一张, 不看 team_system。
补丁在上游挑选前按卡面 OCR 的体系关键词给卡排序; 端到端用例执行上游真实的 acquire_ego_gift。
"""
import ast
import json
import os
import sys
import tempfile
import types
import unittest
from pathlib import Path
from types import SimpleNamespace
from unittest import mock
REPO = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(REPO))
from lc_mcp import aalc_patches as ap # noqa: E402
AALC = REPO / 'vendor' / 'aalc'
MIRROR = AALC / 'tasks' / 'mirror' / 'mirror.py'
SCALE = 720 / 1440
def line_at(card, row):
"""卡面第 row 行文字的位置(在上游判断范围内)。"""
return card[0] + 100 * SCALE * 2, card[1] + 40 * row
class GiftCardHitsTest(unittest.TestCase):
CARDS = [(300, 300), (600, 300), (900, 300)]
def hits(self, lines, keywords=('流血', '出血', 'bleed')):
return ap.gift_card_hits(self.CARDS, lines, keywords, SCALE)
def test_lines_are_assigned_to_the_card_they_sit_on(self):
lines = [('施加3层流血', *line_at(self.CARDS[1], 0)),
('出血时伤害提高', *line_at(self.CARDS[1], 1)),
('烧伤', *line_at(self.CARDS[0], 0)),
('选择EGO饰品', 600, 40)] # 标题不在任何卡上
self.assertEqual(self.hits(lines), [[], ['流血', '出血'], []])
def test_english_is_case_insensitive_and_spaces_are_ignored(self):
lines = [('Inflict BLEED', *line_at(self.CARDS[2], 0)), ('流 血', *line_at(self.CARDS[0], 0))]
self.assertEqual(self.hits(lines), [['流血'], [], ['bleed']])
def test_known_ocr_misreads_still_hit(self):
lines = [('施加震颐', *line_at(self.CARDS[0], 0)), ('沉论层数', *line_at(self.CARDS[1], 0))]
self.assertEqual(ap.gift_card_hits(self.CARDS, lines, ('震颤',), SCALE), [['震颤'], [], []])
self.assertEqual(ap.gift_card_hits(self.CARDS, lines, ('沉沦',), SCALE), [[], ['沉沦'], []])
def test_overlapping_ranges_go_to_the_nearest_card(self):
cards = [(300, 300), (450, 300)] # 两张卡的范围在 x=425..525 重叠
lines = [('流血', 440, 300), ('流血', 500, 300)]
self.assertEqual(ap.gift_card_hits(cards, lines, ('流血',), SCALE), [['流血'], ['流血']])
def test_upstream_order_undoes_the_icon_insertion(self):
# 两张卡上游按给的顺序挑; 三张时命中的卡被上游逐张 insert(0), 所以倒着给、放在最后
self.assertEqual(ap.gift_upstream_order([[], ['x']]), [1, 0])
self.assertEqual(ap.gift_upstream_order([['x'], [], ['x', 'y']]), [1, 0, 2])
self.assertEqual(ap.gift_upstream_order([[], [], []]), [0, 1, 2])
def test_rank_is_stable(self):
cards = ['a', 'b', 'c']
self.assertEqual(ap.rank_gift_cards(cards, [[], ['x'], []]), ['b', 'a', 'c'])
self.assertEqual(ap.rank_gift_cards(cards, [[], [], []]), cards)
self.assertEqual(ap.rank_gift_cards(cards, [['x'], ['x', 'y'], ['x']]), ['b', 'a', 'c'])
class KeywordTableTest(unittest.TestCase):
def test_shipped_table_covers_every_upstream_system(self):
table = ap.load_gift_keywords()
source = AALC / 'tasks' / '__init__.py'
if source.is_file():
tree = ast.parse(source.read_text(encoding='utf-8'))
node = next(n for n in tree.body if isinstance(n, ast.Assign)
and getattr(n.targets[0], 'id', None) == 'all_systems')
self.assertEqual(set(table), set(ast.literal_eval(node.value).values()))
for system, words in table.items():
self.assertTrue(words, system)
def test_bad_files_raise_value_error(self):
with tempfile.TemporaryDirectory() as tmp:
path = os.path.join(tmp, 'k.json')
for content in ('[]', '{"bleed": "流血"}', '{"bleed": [1]}', '{'):
with self.subTest(content=content):
with open(path, 'w', encoding='utf-8') as f:
f.write(content)
with self.assertRaises(ValueError):
ap.load_gift_keywords(path)
def test_notes_are_ignored(self):
with tempfile.TemporaryDirectory() as tmp:
path = os.path.join(tmp, 'k.json')
with open(path, 'w', encoding='utf-8') as f:
json.dump({'_说明': ['x'], 'bleed': ['流血', ' ']}, f, ensure_ascii=False)
self.assertEqual(ap.load_gift_keywords(path), {'bleed': ('流血',)})
class GiftScreen:
"""饰品选择界面: 每张卡 {'pos', 'lines', 'icon'}; icon 为 True 的卡体系图标模板能匹配上
(本机日志里没见它匹配上过, 默认 False)。"""
def __init__(self, cards, pick='0/1'):
self.cards = cards
self.pick = pick
self.clicks = []
self.ocr_runs = 0
self.model = None
self.screenshot = object()
def lines(self):
return [(text, *line_at(card['pos'], row))
for card in self.cards for row, text in enumerate(card['lines'])]
def take_screenshot(self):
return self.screenshot
def mouse_to_blank(self):
pass
def click_element(self, target, **kwargs):
return target.endswith('acquire_ego_gift_select_assets.png')
def find_element(self, target, find_type='image', threshold=0.8, my_crop=None, **kwargs):
if target == ap.GIFT_CARD and find_type == 'image_with_multiple_targets':
return [card['pos'] for card in self.cards]
if target.startswith('mirror/road_in_mir/acquire_ego_gift/') and my_crop:
x1, y1, x2, y2 = my_crop
for card in self.cards:
if card.get('icon') and x1 <= card['pos'][0] <= x2 and y1 <= card['pos'][1] <= y2:
return card['pos']
return False
def find_language_text(self, zh_text, en_text, my_crop=None, **kwargs):
words = [zh_text] if isinstance(zh_text, str) else zh_text
x1, y1, x2, y2 = my_crop
for text, x, y in self.lines():
if x1 <= x <= x2 and y1 <= y <= y2 and any(w in text for w in words):
return [x, y]
return False
def find_text_element(self, targets, my_crop=None, **kwargs):
return self.pick in targets
def mouse_click(self, x, y):
self.clicks.append((x, y))
def run(self, image):
self.ocr_runs += 1
lines = self.lines()
return SimpleNamespace(txts=tuple(t for t, _, _ in lines),
boxes=[[[x - 10, y - 5], [x + 10, y - 5], [x + 10, y + 5], [x - 10, y + 5]]
for _, x, y in lines])
def card(x, *lines, icon=False):
return {'pos': (x, 300), 'lines': list(lines), 'icon': icon}
@unittest.skipUnless(MIRROR.is_file(), 'vendor/aalc 子模块未检出')
class UpstreamAcquireEgoGiftTest(unittest.TestCase):
"""执行上游真实的 Mirror.acquire_ego_gift, 看最后点了哪张卡。"""
def setUp(self):
self.lines = []
tree = ast.parse(MIRROR.read_text(encoding='utf-8'))
cls = next(n for n in tree.body if isinstance(n, ast.ClassDef) and n.name == 'Mirror')
self.fn_node = next(n for n in cls.body if isinstance(n, ast.FunctionDef) and n.name == 'acquire_ego_gift')
def choose(self, cards, system='bleed', patched=True, pick='0/1', env=None):
screen = GiftScreen(cards, pick=pick)
cfg = SimpleNamespace(set_win_size=720, not_skip_whitegossypium=False, mouse_action_interval=0)
ns = dict(cfg=cfg, auto=screen, sleep=lambda *a: None, time=SimpleNamespace(sleep=lambda *a: None),
retry=lambda: True, log=mock.Mock(),
ImageUtils=SimpleNamespace(get_bbox=lambda image: None, load_image=lambda path: None),
all_systems={0: 'burn', 1: 'bleed'})
exec(compile(ast.Module(body=[self.fn_node], type_ignores=[]), str(MIRROR), 'exec'), ns)
mirror_cls = type('Mirror', (), {'acquire_ego_gift': ns['acquire_ego_gift']})
mirror_mod = types.ModuleType('tasks.mirror.mirror')
mirror_mod.Mirror = mirror_cls
package = types.ModuleType('tasks.mirror')
package.mirror = mirror_mod
modules = {'tasks': types.ModuleType('tasks'), 'tasks.mirror': package, 'tasks.mirror.mirror': mirror_mod,
'module': types.ModuleType('module'),
'module.automation': SimpleNamespace(auto=screen),
'module.config': SimpleNamespace(cfg=cfg),
'module.ocr': SimpleNamespace(ocr=screen)}
with mock.patch.dict(sys.modules, modules):
if patched:
self.assertIsNotNone(ap.install_gift_preference(log=self.lines.append, env=env or {}))
mirror = mirror_cls()
mirror.system, mirror.second_system = system, False
mirror.acquire_ego_gift()
self.assertNotIn('find_element', vars(screen), 'find_element 必须还原')
return [next(i for i, c in enumerate(cards) if c['pos'] == pos) for pos in screen.clicks], screen
@property
def log(self):
return '\n'.join(self.lines)
def test_two_cards_prefers_the_system_keyword(self):
cards = [card(300, '烧伤层数+1'), card(600, '施加2层流血')]
self.assertEqual(self.choose(cards, patched=False)[0], [0])
self.assertEqual(self.choose(cards)[0], [1])
self.assertIn('第1张=0 第2张=1(流血); 命中体系关键词, 先看第2张', self.log)
def test_owned_keyword_card_still_loses_to_an_unowned_one(self):
cards = [card(300, '烧伤层数+1'), card(600, '施加2层流血', '已持有')]
self.assertEqual(self.choose(cards)[0], [0])
def test_all_owned_falls_back_to_keyword_order(self):
cards = [card(300, '烧伤', '已持有'), card(600, '流血', '已持有')]
self.assertEqual(self.choose(cards)[0], [1])
def test_white_gossypium_is_still_skipped(self):
cards = [card(300, '烧伤层数+1'), card(600, '白棉花', '流血')]
self.assertEqual(self.choose(cards)[0], [0])
def test_all_white_gossypium_behaves_like_upstream(self):
cards = [card(300, '白棉花'), card(600, '白棉花', '流血')]
self.assertEqual(self.choose(cards)[0], self.choose(cards, patched=False)[0])
def test_three_cards_pick_one(self):
cards = [card(300, '烧伤'), card(600, '震颤'), card(900, '流血伤害提高', '施加流血')]
self.assertEqual(self.choose(cards, patched=False)[0], [0])
self.assertEqual(self.choose(cards)[0], [2])
def test_three_cards_pick_two(self):
cards = [card(300, '烧伤'), card(600, '流血'), card(900, '流血', '施加流血')]
self.assertEqual(self.choose(cards, pick='0/2')[0], [2, 1])
def test_icon_cards_keep_the_keyword_order(self):
# 上游把认出体系图标的卡逐张 insert(0), 后认出的反而排前面; 补丁要抵消这一步
cards = [card(300, '施加流血', icon=True), card(600, '流血', '施加流血', '流血层数', icon=True), card(900, '烧伤')]
self.assertEqual(self.choose(cards)[0], [1])
self.assertEqual(self.choose(cards, pick='0/2')[0], [1, 0])
def test_keyword_card_without_icon_still_beats_an_icon_card(self):
cards = [card(300, '流血', '施加流血', '流血层数'), card(600, '施加流血', icon=True), card(900, '烧伤')]
self.assertEqual(self.choose(cards)[0], [0])
def test_icon_only_card_comes_after_keyword_cards_but_before_the_rest(self):
cards = [card(300, '烧伤'), card(600, '没读出关键词', icon=True), card(900, '施加流血')]
self.assertEqual(self.choose(cards, patched=False)[0], [1])
self.assertEqual(self.choose(cards, pick='0/2')[0], [2, 1])
def test_without_keywords_icons_behave_like_upstream(self):
cards = [card(300, '烧伤', icon=True), card(600, '震颤', icon=True), card(900, '充能')]
self.assertEqual(self.choose(cards, pick='0/2')[0], self.choose(cards, pick='0/2', patched=False)[0])
def test_misread_keyword_for_tremor(self):
cards = [card(300, '流血'), card(600, '施加震颐')]
self.assertEqual(self.choose(cards, system='tremor')[0], [1])
def test_no_hits_keeps_upstream_choice(self):
cards = [card(300, '烧伤'), card(600, '充能')]
self.assertEqual(self.choose(cards)[0], [0])
self.assertIn('未命中体系关键词, 保持原顺序', self.log)
def test_duplicate_lines_on_two_cards_both_count(self):
# {文本: 坐标} 会把两张卡上的同一句合并成一条; 补丁直接读 OCR 引擎的逐行结果
cards = [card(300, '流血'), card(600, '流血', '施加流血')]
self.assertEqual(self.choose(cards)[0], [1])
self.assertIn('第1张=1(流血) 第2张=2(流血/流血)', self.log)
def test_decision_is_recorded_left_to_right(self):
cards = [card(300, '烧伤层数+1'), card(600, '施加2层流血')]
with mock.patch.object(ap.decisions, 'record') as record:
self.choose(cards)
record.assert_called_once_with('gift', 2, 'keyword', system='bleed', hits=[[], ['流血']])
def test_unknown_system_skips_ocr(self):
cards = [card(300, '烧伤'), card(600, '流血')]
chosen, screen = self.choose(cards, system='unknown')
self.assertEqual((chosen, screen.ocr_runs), ([0], 0))
class InstallGiftPreferenceTest(unittest.TestCase):
def setUp(self):
self.lines = []
self.original = mock.Mock(return_value='done')
self.mirror_cls = type('Mirror', (), {'acquire_ego_gift': self.original})
mirror_mod = types.ModuleType('tasks.mirror.mirror')
mirror_mod.Mirror = self.mirror_cls
package = types.ModuleType('tasks.mirror')
package.mirror = mirror_mod
self.auto = SimpleNamespace(find_element=mock.Mock(return_value=[(300, 300), (600, 300)]))
modules = {'tasks': types.ModuleType('tasks'), 'tasks.mirror': package, 'tasks.mirror.mirror': mirror_mod,
'module': types.ModuleType('module'),
'module.automation': SimpleNamespace(auto=self.auto),
'module.config': SimpleNamespace(cfg=SimpleNamespace(set_win_size=720))}
patcher = mock.patch.dict(sys.modules, modules)
patcher.start()
self.addCleanup(patcher.stop)
def install(self, env=None):
return ap.install_gift_preference(log=self.lines.append, env=env or {})
def test_env_zero_leaves_upstream_untouched(self):
self.assertIsNone(self.install({ap.GIFT_KEYWORDS_ENV: '0'}))
self.assertIs(self.mirror_cls.acquire_ego_gift, self.original)
def test_unreadable_table_is_an_error_and_not_installed(self):
self.assertIsNone(self.install({ap.GIFT_KEYWORDS_ENV: '/nonexistent/k.json'}))
self.assertIs(self.mirror_cls.acquire_ego_gift, self.original)
self.assertTrue(self.lines[0].startswith('[ERROR] [lc_mcp] 饰品体系优先补丁跳过'))
def test_refuse_screen_passes_through(self):
self.install()
mirror = self.mirror_cls()
mirror.system = 'bleed'
self.assertEqual(mirror.acquire_ego_gift(type=2), 'done')
self.original.assert_called_once_with(mirror, type=2)
def test_find_element_is_restored_after_an_exception(self):
real = self.auto.find_element
self.original.side_effect = RuntimeError('boom')
self.install()
mirror = self.mirror_cls()
mirror.system = 'bleed'
with self.assertRaises(RuntimeError):
mirror.acquire_ego_gift()
self.assertIs(self.auto.find_element, real)
def test_ranking_error_keeps_upstream_order(self):
cards = [(300, 300), (600, 300)]
auto = self.auto
def original(mirror):
return auto.find_element("mirror/road_in_mir/acquire_ego_gift_card.png",
find_type='image_with_multiple_targets')
self.mirror_cls.acquire_ego_gift = original
self.install()
mirror = self.mirror_cls()
mirror.system = 'bleed'
with mock.patch.object(ap, '_ocr_lines', side_effect=RuntimeError('ocr down')):
self.assertEqual(mirror.acquire_ego_gift(), cards)
self.assertIn('关键词排序出错(RuntimeError: ocr down)', '\n'.join(self.lines))
def test_upstream_without_the_card_lookup_is_an_error(self):
auto = self.auto
def original(mirror):
return auto.find_element("mirror/road_in_mir/some_other_card.png")
self.mirror_cls.acquire_ego_gift = original
self.install()
self.assertIs(self.mirror_cls.acquire_ego_gift, original)
self.assertIn('[ERROR] [lc_mcp] 饰品体系优先补丁跳过: 上游 Mirror.acquire_ego_gift 不再调用 find_element',
'\n'.join(self.lines))
if __name__ == '__main__':
unittest.main()
+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()
+254
View File
@@ -0,0 +1,254 @@
# -*- coding: utf-8 -*-
"""急停热键。
背景(2026-10-22, 用户提问"你执行脚本的时候我鼠标没法动,我怎么停止呢"):
驱动级点击是闭环定位 —— 手一动, 下一次点击前会读到新位置、算出偏差、再把你推回
目标点。所以任务跑起来时鼠标是"拔河"状态, 用户没法用鼠标去点停止按钮。键盘不受
影响, 所以急停必须走键盘。
实现上踩过一个坑: 先用了 pynput 的 GlobalHotKeys, 静态注册成功、线程也活着, 但
keybd_event 和 SendInput 两种注入都触发不了它 —— 钩子在当前会话下收不到键。
改成 GetAsyncKeyState 轮询后实测可用。这里的测试守住轮询方案的几个关键性质,
以及急停时"先放开鼠标、卡住也按时退出"的保证。
"""
import sys
import tempfile
import threading
import unittest
from pathlib import Path
from unittest import mock
sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
from lc_mcp import killswitch # noqa: E402
PRESSED = -32768 # SHORT 0x8000: GetAsyncKeyState 的"当前按下"位
def key_state(value):
return mock.patch.object(killswitch, '_key_state_api', return_value=lambda vk: value)
class ResolveVkTest(unittest.TestCase):
"""键名解析必须严格: 认不出来要返回 None, 不能悄悄用默认值 ——
否则用户以为设成了 F11, 实际还在监听别的键。"""
def test_common_keys(self):
self.assertEqual(killswitch.resolve_vk('f12'), 0x7B)
self.assertEqual(killswitch.resolve_vk('F11'), 0x7A)
self.assertEqual(killswitch.resolve_vk('esc'), 0x1B)
self.assertEqual(killswitch.resolve_vk('pause'), 0x13)
def test_default_is_end_not_steam_screenshot_key(self):
self.assertEqual(killswitch.DEFAULT_KEY, 'end')
self.assertEqual(killswitch.resolve_vk(None), 0x23)
def test_accepts_angle_brackets(self):
self.assertEqual(killswitch.resolve_vk('<f12>'), 0x7B)
def test_trims_whitespace(self):
self.assertEqual(killswitch.resolve_vk(' F12 '), 0x7B)
def test_empty_uses_default(self):
for key in ('', None, ' '):
self.assertEqual(killswitch.resolve_vk(key), killswitch.VK[killswitch.DEFAULT_KEY])
def test_unknown_returns_none(self):
self.assertIsNone(killswitch.resolve_vk('nosuchkey'))
class InstallTest(unittest.TestCase):
"""装不上不能把任务带崩,但必须说清楚怎么应急。"""
def test_reports_unknown_key_and_suggests_fallback(self):
lines = []
got = killswitch.install(log=lines.append, key='nosuchkey')
self.assertIsNone(got)
joined = '\n'.join(lines)
self.assertIn('认不出键名', joined)
self.assertIn('Ctrl+Alt+Del', joined, '必须给出应急手段')
def test_reports_when_keyboard_api_is_unavailable(self):
lines = []
with mock.patch.object(killswitch, '_key_state_api', side_effect=AttributeError('no user32')):
got = killswitch.install(log=lines.append)
self.assertIsNone(got)
joined = '\n'.join(lines)
self.assertIn('急停热键不可用', joined)
self.assertIn('Ctrl+Alt+Del', joined)
def test_installs_and_logs_the_key(self):
lines = []
with key_state(0), mock.patch.object(killswitch.KillSwitch, 'start', lambda self: self):
switch = killswitch.install(log=lines.append, key='f11')
self.assertIsInstance(switch, killswitch.KillSwitch)
self.assertEqual(switch.vk, 0x7A)
joined = '\n'.join(lines)
self.assertIn('F11', joined)
self.assertIn('游戏窗口保留', joined)
def test_env_var_overrides_default(self):
with mock.patch.dict(killswitch.os.environ, {'LCP_KILL_KEY': 'esc'}), key_state(0), \
mock.patch.object(killswitch.KillSwitch, 'start', lambda self: self):
switch = killswitch.install(log=lambda m: None)
self.assertEqual(switch.vk, 0x1B)
def test_start_failure_is_reported_not_raised(self):
lines = []
with key_state(0), mock.patch.object(killswitch.KillSwitch, 'start',
side_effect=RuntimeError('boom')):
got = killswitch.install(log=lines.append)
self.assertIsNone(got)
self.assertIn('启动失败', '\n'.join(lines))
class PollingTest(unittest.TestCase):
"""轮询判断的核心:0x8000 位。测错位会导致"一直触发"或"永不触发"。"""
def test_high_bit_means_pressed(self):
for value in (PRESSED, PRESSED | 1):
with self.subTest(value=value), key_state(value):
self.assertTrue(killswitch._pressed(0x7B))
def test_low_bits_are_not_pressed(self):
# 0x0001 表示"上次调用后被按过", 不代表当前按住 —— 不能当成按下
with key_state(0x0001):
self.assertFalse(killswitch._pressed(0x7B))
def test_zero_is_not_pressed(self):
with key_state(0):
self.assertFalse(killswitch._pressed(0x7B))
def test_poll_thread_fires_on_press(self):
sw = killswitch.KillSwitch(0x23, log=lambda m: None)
exited = threading.Event()
with key_state(PRESSED), mock.patch.object(killswitch, 'START_DELAY', 0), \
mock.patch.object(killswitch.os, '_exit', side_effect=lambda code: exited.set()):
sw.start()
self.assertTrue(exited.wait(2))
sw._thread.join(2)
self.assertTrue(sw.fired)
def test_broken_api_stops_polling_with_a_message(self):
lines = []
sw = killswitch.KillSwitch(0x23, log=lines.append)
with mock.patch.object(killswitch, '_key_state_api', side_effect=OSError('gone')), \
mock.patch.object(killswitch, 'START_DELAY', 0), \
mock.patch.object(killswitch.os, '_exit') as fake_exit:
sw.start()
sw._thread.join(2)
self.assertFalse(sw.is_alive())
fake_exit.assert_not_called()
self.assertIn('急停热键失效', '\n'.join(lines))
class FireTest(unittest.TestCase):
def _switch(self, log=lambda m: None, on_stop=None):
return killswitch.KillSwitch(0x23, log=log, key_name='end', on_stop=on_stop)
def test_exits_with_user_abort_code_and_only_fires_once(self):
sw = self._switch()
with mock.patch.object(killswitch.os, '_exit') as fake_exit:
sw._fire()
sw._fire()
sw._fire()
fake_exit.assert_called_once_with(killswitch.EXIT_CODE)
def test_logs_that_game_is_kept(self):
lines = []
with mock.patch.object(killswitch.os, '_exit'):
self._switch(log=lines.append)._fire()
joined = '\n'.join(lines)
self.assertIn('END', joined)
self.assertIn('重新开始', joined)
def test_releases_input_before_logging_and_exiting(self):
calls = []
sw = self._switch(log=lambda m: calls.append('log'), on_stop=lambda: calls.append('release'))
with mock.patch.object(killswitch.os, '_exit', side_effect=lambda code: calls.append(code)):
sw._fire()
self.assertEqual(calls, ['release', 'log', 130])
def test_broken_cleanup_or_log_cannot_disable_the_hotkey(self):
def cleanup():
raise OSError('driver disconnected')
log = mock.Mock(side_effect=OSError('closed log'))
with mock.patch.object(killswitch.os, '_exit') as fake_exit:
self._switch(log=log, on_stop=cleanup)._fire()
fake_exit.assert_called_once_with(130)
def test_hung_cleanup_cannot_block_exit_deadline(self):
release, exited = threading.Event(), threading.Event()
sw = self._switch(on_stop=release.wait)
with mock.patch.object(killswitch.os, '_exit', side_effect=lambda code: exited.set()):
worker = threading.Thread(target=sw._fire, daemon=True)
worker.start()
try:
self.assertTrue(exited.wait(2), '清理卡住也必须触发强退')
finally:
release.set()
worker.join(2)
def test_real_emergency_exit_is_reported_as_stopped(self):
from lc_mcp.tasks import TaskRunner
child = """
import json, os, time
from lc_mcp import killswitch
from lc_mcp.aalc_task import RESTORE_ENV
with open(os.environ[RESTORE_ENV], 'w') as f: json.dump({'set_mirror_count': 1}, f)
killswitch._key_state_api = lambda: (lambda vk: -32768)
killswitch.install(log=lambda msg: None)
time.sleep(10)
"""
with tempfile.TemporaryDirectory() as tmp:
runner = TaskRunner(tmp, argv_factory=lambda t, p: [sys.executable, '-c', child])
self.assertTrue(runner.start('mirror', {'count': 2})['ok'])
self.addCleanup(runner.proc.kill)
runner.proc.wait(timeout=5)
status = runner.status()
self.assertEqual((status['state'], status['exit_code']), ('stopped', 130))
self.assertTrue(status['pending_restore'], '强退保留配置恢复文件, 下次启动前由服务处理')
class StopTest(unittest.TestCase):
def test_stop_is_safe_on_none(self):
killswitch.stop(None) # 不该抛
def test_stop_calls_switch(self):
sw = mock.Mock()
killswitch.stop(sw)
sw.stop.assert_called_once()
def test_stop_swallows_errors(self):
sw = mock.Mock()
sw.stop.side_effect = RuntimeError('boom')
killswitch.stop(sw) # 不该抛
def test_stopped_switch_does_not_poll(self):
sw = killswitch.KillSwitch(0x23, log=lambda m: None)
with key_state(PRESSED), mock.patch.object(killswitch.os, '_exit') as fake_exit:
sw.stop()
sw.start()
sw._thread.join(2)
fake_exit.assert_not_called()
def test_listening_passes_cleanup_and_stops_on_return_and_exception(self):
cleanup = object()
for failure in (False, True):
switch = mock.Mock()
with self.subTest(failure=failure), \
mock.patch.object(killswitch, 'install', return_value=switch) as install:
try:
with killswitch.listening(on_stop=cleanup):
if failure:
raise RuntimeError('task failed')
except RuntimeError:
pass
self.assertIs(install.call_args.kwargs['on_stop'], cleanup)
switch.stop.assert_called_once()
if __name__ == '__main__':
unittest.main()
+44 -10
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__)))
@@ -18,7 +20,7 @@ sys.path.insert(0, REPO)
from lc_mcp import server as srv_mod # noqa: E402 from lc_mcp import server as srv_mod # noqa: E402
from lc_mcp.engine import find_hits # noqa: E402 from lc_mcp.engine import find_hits # noqa: E402
from lc_mcp.fake_engine import FakeEngine # noqa: E402 from lc_mcp.fake_engine import FakeEngine # noqa: E402
from lc_mcp.protocol import Server, TOOLS # noqa: E402 from lc_mcp.protocol import AUTOMATION_INSTRUCTIONS, Server, TOOLS # noqa: E402
from lc_mcp.tasks import TaskRunner # noqa: E402 from lc_mcp.tasks import TaskRunner # noqa: E402
START = {'text': '开始', 'x': 100, 'y': 200, 'w': 40, 'h': 20} START = {'text': '开始', 'x': 100, 'y': 200, 'w': 40, 'h': 20}
@@ -67,6 +69,7 @@ class ProtocolTest(unittest.TestCase):
def test_initialize_and_list(self): def test_initialize_and_list(self):
r = self.s.handle({'jsonrpc': '2.0', 'id': 7, 'method': 'initialize', 'params': {}}) r = self.s.handle({'jsonrpc': '2.0', 'id': 7, 'method': 'initialize', 'params': {}})
self.assertEqual(r['id'], 7) self.assertEqual(r['id'], 7)
self.assertEqual(r['result']['instructions'], AUTOMATION_INSTRUCTIONS)
names = [t['name'] for t in self.s.handle({'jsonrpc': '2.0', 'id': 8, 'method': 'tools/list'})['result']['tools']] names = [t['name'] for t in self.s.handle({'jsonrpc': '2.0', 'id': 8, 'method': 'tools/list'})['result']['tools']]
self.assertEqual(names, [t['name'] for t in TOOLS]) self.assertEqual(names, [t['name'] for t in TOOLS])
self.assertIsNone(self.s.handle({'jsonrpc': '2.0', 'method': 'notifications/initialized'})) self.assertIsNone(self.s.handle({'jsonrpc': '2.0', 'method': 'notifications/initialized'}))
@@ -188,6 +191,17 @@ class ProtocolTest(unittest.TestCase):
self.assertTrue(call(self.s, 'click', x=1, y=1)['ok']) self.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')
@@ -213,7 +227,7 @@ class AalcTaskArgsTest(unittest.TestCase):
class Cfg: class Cfg:
def __init__(self): def __init__(self):
self.values, self.saved, self.flushes = {'set_mirror_count': 1}, {}, 0 self.values, self.saved, self.flushes = {'set_mirror_count': 1, 'infinite_dungeons': True}, {}, 0
def get_value(self, key): def get_value(self, key):
return self.values[key] return self.values[key]
@@ -228,20 +242,33 @@ class AalcTaskArgsTest(unittest.TestCase):
self.flushes += 1 self.flushes += 1
cfg = Cfg() cfg = Cfg()
with tempfile.TemporaryDirectory() as d: before = {'set_mirror_count': 1, 'infinite_dungeons': True}
lines = []
with tempfile.TemporaryDirectory() as d, mock.patch.object(aalc_task, 'log', lines.append):
path = os.path.join(d, 'x.restore.json') path = os.path.join(d, 'x.restore.json')
originals = aalc_task.apply_overrides(cfg, 'mirror', {'count': 5}, path) originals = aalc_task.apply_overrides(cfg, 'mirror', {'count': 5}, path)
self.assertEqual(cfg.values['set_mirror_count'], 5) # 指定次数时无限刷牢必须关掉, 否则 AALC 把次数改成 9999
self.assertEqual(cfg.values, {'set_mirror_count': 5, 'infinite_dungeons': False})
self.assertIn('无限刷牢', '\n'.join(lines))
with open(path, encoding='utf-8') as f: with open(path, encoding='utf-8') as f:
self.assertEqual(json.load(f), {'set_mirror_count': 1}) self.assertEqual(json.load(f), before)
self.assertEqual(originals, {'set_mirror_count': 1}) self.assertEqual(originals, before)
# 任务进程被强杀后, TaskRunner 用 --restore 读文件写回 # 任务进程被强杀后, TaskRunner 用 --restore 读文件写回
aalc_task.restore_file(path, cfg) aalc_task.restore_file(path, cfg)
self.assertEqual((cfg.saved, cfg.flushes), ({'set_mirror_count': 1}, 1)) self.assertEqual((cfg.saved, cfg.flushes), (before, 1))
self.assertFalse(os.path.exists(path)) self.assertFalse(os.path.exists(path))
self.assertEqual(aalc_task.apply_overrides(cfg, 'reward', {}, path), {}) self.assertEqual(aalc_task.apply_overrides(cfg, 'reward', {}, path), {})
self.assertFalse(os.path.exists(path)) # 没有覆盖就不留恢复文件 self.assertFalse(os.path.exists(path)) # 没有覆盖就不留恢复文件
def test_mirror_without_count_keeps_configured_infinite_mode(self):
from lc_mcp import aalc_task
cfg = mock.Mock()
cfg.get_value.side_effect = {'set_EXP_count': 3}.get
self.assertEqual(aalc_task.apply_overrides(cfg, 'mirror', {}), {})
cfg.unsaved_set_value.assert_not_called()
self.assertEqual(aalc_task.apply_overrides(cfg, 'daily', {'exp': 1}), {'set_EXP_count': 3})
cfg.unsaved_set_value.assert_called_once_with('set_EXP_count', 1)
class TaskRestoreTest(unittest.TestCase): class TaskRestoreTest(unittest.TestCase):
"""run_task 的临时次数会随 AALC 中途存盘写进 config.yaml; 强杀后必须写回原值。""" """run_task 的临时次数会随 AALC 中途存盘写进 config.yaml; 强杀后必须写回原值。"""
@@ -373,12 +400,19 @@ class RuntimeTest(unittest.TestCase):
mock.patch('lc_mcp.aalc_engine.time.sleep', side_effect=[None, RuntimeError('interrupted')]): 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
+31
View File
@@ -80,6 +80,37 @@ class ProgressResultTest(unittest.TestCase):
self.assertEqual(self.run_progress(level=30), (0, 1)) self.assertEqual(self.run_progress(level=30), (0, 1))
class CardResultTest(unittest.TestCase):
def run_command(self, command, upgrade=True, sync=True, uptie=True):
argv = ['levelup.py'] + command + (['--uptie'] if uptie else [])
with mock.patch.object(sys, 'argv', argv), \
mock.patch.object(levelup, 'state', return_value={
'items': [{'text': 'Level Up IDENTITIES Facades'}]}), \
mock.patch.object(levelup, 'scan_grid', return_value=[
(0, 0, 335, 260, 20, True, 'identity')]), \
mock.patch.object(levelup, 'dismiss_modal'), \
mock.patch.object(levelup, 'long_press'), \
mock.patch.object(levelup, 'click'), \
mock.patch.object(levelup, 'do_level_up', return_value=(upgrade, '升级结果')), \
mock.patch.object(levelup, 'do_uptie', return_value=(sync, '同步结果')) as synchronize, \
mock.patch.object(levelup.time, 'sleep'), \
mock.patch('builtins.print'):
code = levelup.main()
return code, synchronize.call_count
def test_failed_uptie_fails_both_cli_commands(self):
for command in (['card', '0', '0'], ['weakest']):
with self.subTest(command=command):
self.assertEqual(self.run_command(command, sync=False), (1, 1))
def test_both_operations_must_succeed(self):
self.assertEqual(self.run_command(['card', '0', '0']), (0, 1))
self.assertEqual(self.run_command(['card', '0', '0'], upgrade=False), (1, 1))
def test_upgrade_without_uptie_keeps_its_result(self):
self.assertEqual(self.run_command(['card', '0', '0'], uptie=False), (0, 0))
class Screens: class Screens:
"""按顺序返回预设画面的假 state(), 记录点击。""" """按顺序返回预设画面的假 state(), 记录点击。"""
+187 -1
View File
@@ -1,6 +1,10 @@
import ast
import os import os
import sys import sys
import threading
import unittest import unittest
from pathlib import Path
from types import SimpleNamespace
from unittest import mock from unittest import mock
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
@@ -34,6 +38,28 @@ class PreflightTest(unittest.TestCase):
def test_missing_team_in_queue(self): def test_missing_team_in_queue(self):
problems = preflight.check(values(teams_active_queue=[2]), 'mirror', env={}) problems = preflight.check(values(teams_active_queue=[2]), 'mirror', env={})
self.assertIn('队伍 2', problems[0]) self.assertIn('队伍 2', problems[0])
self.assertIn('没有可用队伍', problems[-1])
def test_empty_queue_is_rejected_because_aalc_would_exit_zero(self):
problems = preflight.check(values(teams_active_queue=[]), 'mirror', env={})
self.assertEqual(len(problems), 1)
self.assertIn('没有可用队伍', problems[0])
self.assertEqual(preflight.check(values(teams_active_queue=[]), 'daily', env={}), [])
self.assertEqual(preflight.check(values(teams_active_queue=[], mirror=False), 'all', env={}), [])
def test_fixed_team_use_must_match_current_difficulty(self):
order = [1, 2, 3, 4, 5, 6, 7, 0, 0, 0, 0, 0]
hard_only = {'sinner_order': order, 'fixed_team_use': True, 'fixed_team_use_select': 0}
normal_only = dict(hard_only, fixed_team_use_select=1)
for team, hard, ok in [(hard_only, False, False), (hard_only, True, True),
(normal_only, False, True), (normal_only, True, False),
(dict(hard_only, fixed_team_use=False), False, True)]:
with self.subTest(team=team, hard=hard):
problems = preflight.check(values(teams={'1': team}, hard_mirror=hard), 'mirror', env={})
self.assertEqual(problems == [], ok, problems)
# 只要队列里有一支适用当前难度, AALC 就会轮转到它
v = values(teams_active_queue=[1, 2], teams={'1': hard_only, '2': normal_only})
self.assertEqual(preflight.check(v, 'mirror', env={}), [])
def test_lunacy_spending_is_rejected_unless_explicit(self): def test_lunacy_spending_is_rejected_unless_explicit(self):
v = values(set_lunacy_to_enkephalin=2) v = values(set_lunacy_to_enkephalin=2)
@@ -56,15 +82,175 @@ class PreflightTest(unittest.TestCase):
class Cfg: class Cfg:
data = {'simulator': False, 'mirror': True, 'set_win_size': 720, data = {'simulator': False, 'mirror': True, 'set_win_size': 720,
'set_lunacy_to_enkephalin': None, 'teams_active_queue': [1], 'teams': {1: Team()}} 'set_windows': False, 'set_win_position': 'center',
'set_lunacy_to_enkephalin': None, 'hard_mirror': 1,
'teams_active_queue': [1], 'teams': {1: Team()}}
def get_value(self, key): def get_value(self, key):
return self.data[key] return self.data[key]
v = preflight.collect(Cfg()) v = preflight.collect(Cfg())
self.assertEqual(v['teams'], {'1': {'sinner_order': [1]}}) self.assertEqual(v['teams'], {'1': {'sinner_order': [1]}})
self.assertIs(v['hard_mirror'], True)
self.assertEqual(v['set_lunacy_to_enkephalin'], 0) self.assertEqual(v['set_lunacy_to_enkephalin'], 0)
self.assertFalse(v['set_windows'])
self.assertEqual(v['set_win_position'], 'center')
def test_user_managed_window_skips_configured_size_check(self):
self.assertEqual(preflight.check(values(set_windows=False, set_win_size=2160),
'daily', desktop=(1920, 1080), env={}), [])
def test_borderless_window_can_fill_the_desktop(self):
for position in ('center', 'left_top', 'right_top', 'left_bottom', 'right_bottom'):
with self.subTest(position=position):
v = values(set_windows=True, set_win_size=1080, set_win_position=position)
self.assertEqual(preflight.check(v, 'daily', desktop=(1920, 1080), env={}), [])
self.assertTrue(preflight.check(v, 'daily', desktop=(1600, 900), env={}))
class HeadlessHdrTest(unittest.TestCase):
def test_upstream_prompt_is_acknowledged_without_an_event_loop(self):
# Run the pinned upstream detector; Event.wait would block without a receiver.
path = Path(__file__).resolve().parents[1] / 'vendor/aalc/tasks/base/script_task_scheme.py'
tree = ast.parse(path.read_text(encoding='utf-8'))
node = next(n for n in tree.body if isinstance(n, ast.FunctionDef)
and n.name == '_warn_if_game_monitor_hdr_enabled')
direct = object()
class Signal:
callback = None
def connect(self, callback, mode):
self.callback = callback if mode is direct else None
def disconnect(self, callback):
self.callback = None
def emit(self, event):
if self.callback:
self.callback(event)
signal = Signal()
events = []
def event_factory():
event = threading.Event()
events.append(event)
return event
ns = dict(cfg=SimpleNamespace(simulator=False, get_value=lambda *a: True),
screen=SimpleNamespace(handle=SimpleNamespace(hwnd=1)),
win32api=SimpleNamespace(MonitorFromWindow=lambda *a: 1),
win32con=SimpleNamespace(MONITOR_DEFAULTTONEAREST=2),
get_monitor_hdr_info=lambda *a: SimpleNamespace(hdr_enabled=True),
Event=event_factory, mediator=SimpleNamespace(hdr_warning=signal), log=mock.Mock())
exec(compile(ast.Module(body=[node], type_ignores=[]), str(path), 'exec'), ns)
qt = SimpleNamespace(Qt=SimpleNamespace(ConnectionType=SimpleNamespace(DirectConnection=direct)))
messages = []
with mock.patch.dict(sys.modules, {'PySide6.QtCore': qt}):
with aalc_patches.headless_hdr_warning(SimpleNamespace(**ns), log=messages.append):
worker = threading.Thread(target=ns[node.name], daemon=True)
worker.start()
worker.join(1)
try:
self.assertFalse(worker.is_alive(), 'HDR prompt blocked the task')
self.assertTrue(events[0].is_set())
self.assertIn('HDR', messages[0])
finally:
for event in events:
event.set()
worker.join(1)
self.assertIsNone(signal.callback)
def test_exception_disconnects_the_receiver(self):
signal = mock.Mock()
scheme = SimpleNamespace(mediator=SimpleNamespace(hdr_warning=signal))
qt = SimpleNamespace(Qt=SimpleNamespace(ConnectionType=SimpleNamespace(DirectConnection=1)))
with mock.patch.dict(sys.modules, {'PySide6.QtCore': qt}):
with self.assertRaisesRegex(RuntimeError, 'task failed'):
with aalc_patches.headless_hdr_warning(scheme):
raise RuntimeError('task failed')
signal.disconnect.assert_called_once_with(signal.connect.call_args.args[0])
class MirrorCompletionTest(unittest.TestCase):
"""AALC 退出码 0 不代表打完镜牢; 用上游真实 Mirror_task 核对完成局数。"""
class Signal:
def __init__(self):
self.callbacks = []
def connect(self, callback, mode):
self.callbacks.append(callback)
def disconnect(self, callback):
self.callbacks.remove(callback)
def emit(self, *args):
for callback in list(self.callbacks):
callback(*args)
def run_upstream_mirror(self, queue, team, count=1):
path = Path(__file__).resolve().parents[1] / 'vendor/aalc/tasks/base/script_task_scheme.py'
tree = ast.parse(path.read_text(encoding='utf-8'))
node = next(n for n in tree.body if isinstance(n, ast.FunctionDef) and n.name == 'Mirror_task')
signal = self.Signal()
mediator = SimpleNamespace(mirror_signal=signal, mirror_bar_kill_signal=mock.Mock())
state = {'teams_active_queue': list(queue),
'teams_be_select': [num in queue for num in (1,)]}
cfg = SimpleNamespace(
set_mirror_count=count, infinite_dungeons=False, save_rewards=False, hard_mirror=False,
auto_hard_mirror=False, re_claim_rewards=False, teams_active_queue=state['teams_active_queue'],
config=SimpleNamespace(teams={'1': team}), get_value=state.get,
normalize_and_sync_team_state=lambda persist=True: None, rotate_team_queue=mock.Mock())
ns = dict(cfg=cfg, mediator=mediator, log=mock.Mock(), to_get_reward=mock.Mock(),
onetime_mir_process=mock.Mock(return_value=True))
exec(compile(ast.Module(body=[node], type_ignores=[]), str(path), 'exec'), ns)
scheme = SimpleNamespace(mediator=mediator, Mirror_task=ns['Mirror_task'])
qt = SimpleNamespace(Qt=SimpleNamespace(ConnectionType=SimpleNamespace(DirectConnection=1)))
with mock.patch.dict(sys.modules, {'PySide6.QtCore': qt}), \
aalc_patches.mirror_progress(scheme) as progress:
scheme.Mirror_task()
self.assertEqual(signal.callbacks, [], 'receiver must be disconnected')
return progress, ns['onetime_mir_process']
def test_unusable_team_returns_normally_but_is_reported_incomplete(self):
from lc_mcp import aalc_task
hard_only = SimpleNamespace(fixed_team_use=True, fixed_team_use_select=0)
progress, play = self.run_upstream_mirror([1], hard_only)
play.assert_not_called()
self.assertEqual((progress.finished, progress.total), (0, 1))
lines = []
with mock.patch.object(aalc_task, 'log', lines.append):
self.assertEqual(aalc_task.mirror_result('mirror', progress), aalc_task.INCOMPLETE_EXIT)
self.assertTrue(any(line.startswith('[ERROR]') and '0/1' in line for line in lines))
def test_completed_run_is_success(self):
from lc_mcp import aalc_task
progress, play = self.run_upstream_mirror([1], SimpleNamespace(fixed_team_use=False))
play.assert_called_once()
self.assertEqual((progress.finished, progress.total), (1, 1))
with mock.patch.object(aalc_task, 'log'):
self.assertEqual(aalc_task.mirror_result('mirror', progress), 0)
def test_missing_progress_only_fails_explicit_mirror_task(self):
from lc_mcp import aalc_task
with mock.patch.object(aalc_task, 'log'):
self.assertEqual(aalc_task.mirror_result('all', aalc_patches.MirrorProgress()), 0)
self.assertEqual(aalc_task.mirror_result('daily', aalc_patches.MirrorProgress()), 0)
self.assertEqual(aalc_task.mirror_result('mirror', aalc_patches.MirrorProgress()),
aalc_task.INCOMPLETE_EXIT)
def test_receiver_is_disconnected_on_exception(self):
signal = mock.Mock()
scheme = SimpleNamespace(mediator=SimpleNamespace(mirror_signal=signal))
qt = SimpleNamespace(Qt=SimpleNamespace(ConnectionType=SimpleNamespace(DirectConnection=1)))
with mock.patch.dict(sys.modules, {'PySide6.QtCore': qt}):
with self.assertRaisesRegex(RuntimeError, 'task failed'):
with aalc_patches.mirror_progress(scheme):
raise RuntimeError('task failed')
signal.disconnect.assert_called_once_with(signal.connect.call_args.args[0])
class ExactTeamMatchTest(unittest.TestCase): class ExactTeamMatchTest(unittest.TestCase):
+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()
+313
View File
@@ -0,0 +1,313 @@
# -*- coding: utf-8 -*-
"""镜牢商店按中文名购买(BACKLOG P2-6)。
上游必买只认 5 张图标模板; 汉化后商店每一格下面写着饰品中文名。补丁在上游必买循环最前面临时插占位项,
点到占位项时按名字表 OCR, 命中就点那一格的图标, 之后的购买/确认仍是上游原来那段循环。
端到端用例执行上游真实的 Shop.buy_gifts。
"""
import ast
import json
import os
import sys
import tempfile
import types
import unittest
from pathlib import Path
from types import SimpleNamespace
from unittest import mock
REPO = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(REPO))
from lc_mcp import aalc_patches as ap # noqa: E402
IN_SHOP = REPO / 'vendor' / 'aalc' / 'tasks' / 'mirror' / 'in_shop.py'
MUST_PURCHASE = REPO / 'vendor' / 'aalc' / 'assets' / 'images' / 'default' / 'share' / 'mirror' / 'shop' / 'must_purchase'
SCALE = 720 / 1440
COINS = (551, 137) # 金币图标(1280x720)
def icon_at(col, row):
"""第 row 行第 col 列商品的图标中心; 列距 300、名字行在金币下方 +409/+716(1440 标定)。"""
return (COINS[0] + (147 + 300 * col) * SCALE, COINS[1] + (409 + 307 * row - ap.SHOP_NAME_TO_ICON) * SCALE)
class ShopNameHitsTest(unittest.TestCase):
def test_real_screenshot_layout(self):
# docs/feedback/mirror_20261002_181322/special_shop_missed.png(1920x1080): 金币模板匹配在 (827, 206),
# 名字行与图标中心是对着截图量的
lines = [('人格技能观测', 937, 513), ('替换格里高尔的技能', 1162, 513), ('辉光变动仪', 1627, 513),
('无头肖像', 937, 743), ('梦中的电子羊', 1162, 743), ('黏性淤浆', 1627, 743),
('特殊商店', 383, 185), ('强化饰品', 265, 588), ('刷新', 1521, 183), ('离开', 1698, 970)]
names = ('无头肖像', '辉光变动仪', '离开', '强化饰品')
hits = ap.shop_name_hits(lines, names, (827, 206), 1080 / 1440)
self.assertEqual([name for name, _ in hits], ['无头肖像', '辉光变动仪'])
for (_, (x, y)), icon in zip(hits, [(937, 627), (1627, 397)]):
self.assertAlmostEqual(x, icon[0], delta=3)
self.assertAlmostEqual(y, icon[1], delta=3)
def test_only_whole_names_match(self):
x, y = icon_at(0, 0)
y += ap.SHOP_NAME_TO_ICON * SCALE
names = ('缘分残片', '归途')
hit = lambda text: [n for n, _ in ap.shop_name_hits([(text, x, y)], names, COINS, SCALE)]
self.assertEqual(hit('缘分 残片'), ['缘分残片'])
self.assertEqual(hit('缘分残片+'), ['缘分残片'])
self.assertEqual(hit('缘分残片++'), ['缘分残片'])
self.assertEqual(hit('归途。'), ['归途'])
self.assertEqual(hit('残片'), [])
self.assertEqual(hit('缘分残片的回忆'), [])
def test_table_order_wins_over_screen_order(self):
lines = [('归途', *icon_at(0, 0)), ('缘分残片', *icon_at(3, 1))]
lines = [(t, x, y + ap.SHOP_NAME_TO_ICON * SCALE) for t, x, y in lines]
hits = ap.shop_name_hits(lines, ('缘分残片', '归途'), COINS, SCALE)
self.assertEqual(hits, [('缘分残片', icon_at(3, 1)), ('归途', icon_at(0, 0))])
class ShopGiftsTableTest(unittest.TestCase):
def test_shipped_table(self):
names = ap.load_shop_gifts()
self.assertEqual(names, ('缘分残片', '卡蜜拉', '采血包', '归途', '石版字符'))
@unittest.skipUnless(MUST_PURCHASE.is_dir(), 'vendor/aalc 子模块未检出')
def test_shipped_table_covers_every_upstream_template(self):
with open(ap.SHOP_NAMES_FILE, encoding='utf-8') as f:
templates = {item['template'] for item in json.load(f)['gifts']}
self.assertEqual(templates, set(os.listdir(MUST_PURCHASE)))
def test_bad_tables_raise_value_error(self):
bad = ['[]', '{"gifts": []}', '{"gifts": {}}', '{"gifts": ["归途"]}', '{"gifts": [{"name": ""}]}',
'{"gifts": [{"name": "。"}]}', '{"gifts": [{"name": "归途"}, {"name": "归 途"}]}']
with tempfile.TemporaryDirectory() as tmp:
path = os.path.join(tmp, 's.json')
for content in bad:
with self.subTest(content=content):
with open(path, 'w', encoding='utf-8') as f:
f.write(content)
with self.assertRaises(ValueError):
ap.load_shop_gifts(path)
class ShopScreen:
"""商店界面: 一格格商品(图标 + 下面的名字), 点图标弹购买框, 点购买扣钱, 再点确认。"""
def __init__(self, items, money=1000, price=150):
self.items = [dict(item) for item in items]
self.money, self.price = money, price
self.popup, self.confirm = None, False
self.bought, self.icon_clicks = [], []
self.screenshot = object()
self.model = None
def icon(self, item):
return icon_at(item['col'], item['row'])
def take_screenshot(self, *args, **kwargs):
self.screenshot = object()
return self.screenshot
def find_element(self, target, find_type='image', **kwargs):
if target == ap.SHOP_COINS:
return COINS
if target.startswith('mirror/shop/must_purchase/'):
template = target.rsplit('/', 1)[1]
return next((self.icon(i) for i in self.items if i.get('template') == template), False)
return [] if find_type == 'image_with_multiple_targets' else False
def click_element(self, target, *args, **kwargs):
if target == ap.SHOP_PURCHASE:
if self.popup is None or self.money < self.price:
return False
self.money -= self.price
self.bought.append(self.popup['name'])
self.items.remove(self.popup)
self.popup, self.confirm = None, True
return True
if target == ap.SHOP_CONFIRM:
done, self.confirm = self.confirm, False
return done
position = self.find_element(target)
if position:
self.mouse_click(*position)
return True
return False
def mouse_click(self, x, y, *args, **kwargs):
for item in self.items:
ix, iy = self.icon(item)
if abs(ix - x) < 30 and abs(iy - y) < 30:
self.popup = item
self.icon_clicks.append(item['name'])
return True
def mouse_click_blank(self, *args, **kwargs):
self.popup = None
def mouse_action_with_pos(self, *args, **kwargs):
pass
def find_language_text(self, *args, **kwargs):
return False
def run(self, image):
lines = [('刷新', COINS[0] + 520 * SCALE, COINS[1] - 30 * SCALE),
('强化饰品', COINS[0] - 750 * SCALE, COINS[1] + 500 * SCALE)]
for item in self.items:
x, y = self.icon(item)
lines.append((item.get('label', item['name']), x, y + ap.SHOP_NAME_TO_ICON * SCALE))
return SimpleNamespace(txts=tuple(t for t, _, _ in lines),
boxes=[[[x - 10, y - 5], [x + 10, y - 5], [x + 10, y + 5], [x - 10, y + 5]]
for _, x, y in lines])
@unittest.skipUnless(IN_SHOP.is_file(), 'vendor/aalc 子模块未检出')
class UpstreamBuyGiftsTest(unittest.TestCase):
"""执行上游真实的 Shop.buy_gifts: 买完必买项, 钱读成 0 不刷新, 一轮就结束。"""
def setUp(self):
self.lines = []
tree = ast.parse(IN_SHOP.read_text(encoding='utf-8'))
cls = next(n for n in tree.body if isinstance(n, ast.ClassDef) and n.name == 'Shop')
self.fn_node = next(n for n in cls.body if isinstance(n, ast.FunctionDef) and n.name == 'buy_gifts')
self.templates = ['mirror/shop/must_purchase/%s' % name for name in
('carmilla.png', 'homeward.png', 'lithograph.png', 'phlebotomy_pack.png',
'piece_of_relationship.png')]
def play(self, items, patched=True, audit=False, env=None, **screen_kwargs):
screen = ShopScreen(items, **screen_kwargs)
must = list(self.templates)
ns = dict(auto=screen, must_purchase=must, sleep=lambda *a: None, retry=lambda: True, log=mock.Mock(),
cfg=SimpleNamespace(set_win_size=720, not_skip_whitegossypium=False))
exec(compile(ast.Module(body=[self.fn_node], type_ignores=[]), str(IN_SHOP), 'exec'), ns)
shop_cls = type('Shop', (), {'buy_gifts': ns['buy_gifts'], 'RestartGame': RuntimeError})
in_shop = types.ModuleType('tasks.mirror.in_shop')
in_shop.Shop, in_shop.must_purchase = shop_cls, must
package = types.ModuleType('tasks.mirror')
package.in_shop = in_shop
modules = {'tasks': types.ModuleType('tasks'), 'tasks.mirror': package, 'tasks.mirror.in_shop': in_shop,
'module': types.ModuleType('module'),
'module.automation': SimpleNamespace(auto=screen),
'module.config': SimpleNamespace(cfg=ns['cfg']),
'module.ocr': SimpleNamespace(ocr=screen)}
with mock.patch.dict(sys.modules, modules):
if audit:
ap.install_shop_audit(log=self.lines.append)
if patched:
self.assertIsNotNone(ap.install_shop_by_name(log=self.lines.append, env=env or {}))
shop = shop_cls()
shop.system, shop.shopping_strategy, shop.fuse_aggressive_switch = 'bleed', False, False
shop.second_system, shop.max_keyword_refresh, shop.max_normal_refresh = False, 0, 0
shop._get_cost = lambda: 0
shop.buy_gifts()
self.assertEqual(must, self.templates, '占位项必须拿掉')
self.assertNotIn('click_element', vars(screen), 'click_element 必须还原')
return screen
@property
def log(self):
return '\n'.join(self.lines)
def test_patch_hooks_into_the_current_upstream(self):
self.play([])
self.assertIn('patch: 商店必买先按中文名找(shop_gifts.json, 5 个名字)', self.log)
self.assertNotIn('[ERROR]', self.log)
def test_name_on_the_grid_is_bought(self):
items = [{'name': '缘分残片', 'col': 2, 'row': 1}, {'name': '黏性淤浆', 'col': 0, 'row': 0}]
self.assertEqual(self.play(items, patched=False).bought, []) # 图标模板没认出来
self.assertEqual(self.play(items).bought, ['缘分残片'])
self.assertIn('商店: 按名字找到「缘分残片」, 点它的图标', self.log)
def test_table_order_decides_when_money_is_short(self):
items = [{'name': '归途', 'col': 0, 'row': 0}, {'name': '缘分残片', 'col': 3, 'row': 1}]
self.assertEqual(self.play(items, money=150).bought, ['缘分残片'])
self.assertEqual(self.play(items, money=1000).bought, ['缘分残片', '归途'])
def test_templates_still_back_up_a_misread_name(self):
items = [{'name': '卡蜜拉', 'label': '卡密拉', 'template': 'carmilla.png', 'col': 1, 'row': 0}]
self.assertEqual(self.play(items).bought, ['卡蜜拉'])
def test_unaffordable_item_is_not_clicked_forever(self):
screen = self.play([{'name': '采血包', 'col': 1, 'row': 1}], money=0)
self.assertEqual(screen.bought, [])
self.assertEqual(screen.icon_clicks, ['采血包'] * ap.SHOP_NAME_CLICKS)
def test_audit_sees_the_name_purchase(self):
with mock.patch.object(ap.decisions, 'record') as record:
self.play([{'name': '缘分残片', 'col': 2, 'row': 1}], audit=True)
self.assertEqual(record.call_args_list, [
mock.call('shop', '缘分残片', 'name_match', on_screen=['缘分残片']),
mock.call('shop', 'shop_by_name', 'purchase_clicked', system='bleed')])
def test_env_zero_keeps_upstream(self):
self.assertIsNone(ap.install_shop_by_name(log=self.lines.append, env={ap.SHOP_NAMES_ENV: '0'}))
class InstallShopByNameTest(unittest.TestCase):
def setUp(self):
self.lines = []
self.must = ['mirror/shop/must_purchase/a.png']
self.auto = SimpleNamespace(click_element=mock.Mock(return_value=False), find_element=mock.Mock())
self.shop_cls = type('Shop', (), {'buy_gifts': mock.Mock(side_effect=RuntimeError('boom'))})
in_shop = types.ModuleType('tasks.mirror.in_shop')
in_shop.Shop, in_shop.must_purchase = self.shop_cls, self.must
package = types.ModuleType('tasks.mirror')
package.in_shop = in_shop
modules = {'tasks': types.ModuleType('tasks'), 'tasks.mirror': package, 'tasks.mirror.in_shop': in_shop,
'module': types.ModuleType('module'),
'module.automation': SimpleNamespace(auto=self.auto),
'module.config': SimpleNamespace(cfg=SimpleNamespace(set_win_size=720))}
patcher = mock.patch.dict(sys.modules, modules)
patcher.start()
self.addCleanup(patcher.stop)
def test_placeholders_and_click_are_restored_after_an_exception(self):
real = self.auto.click_element
ap.install_shop_by_name(log=self.lines.append, env={})
with self.assertRaises(RuntimeError):
self.shop_cls().buy_gifts()
self.assertEqual(self.must, ['mirror/shop/must_purchase/a.png'])
self.assertIs(self.auto.click_element, real)
def test_upstream_without_the_must_purchase_loop_is_an_error(self):
def buy_gifts(shop):
return shop # 不再逐个点 must_purchase
self.shop_cls.buy_gifts = buy_gifts
self.assertIsNone(ap.install_shop_by_name(log=self.lines.append, env={}))
self.assertIs(self.shop_cls.buy_gifts, buy_gifts)
self.assertIn('[ERROR] [lc_mcp] 商店按名字购买跳过: 上游 Shop.buy_gifts 不再逐个', '\n'.join(self.lines))
def test_unreadable_table_is_an_error(self):
with tempfile.TemporaryDirectory() as tmp:
path = os.path.join(tmp, 's.json')
with open(path, 'w', encoding='utf-8') as f:
f.write('{"gifts": []}')
self.assertIsNone(ap.install_shop_by_name(log=self.lines.append, env={ap.SHOP_NAMES_ENV: path}))
self.assertTrue(self.lines[0].startswith('[ERROR] [lc_mcp] 商店按名字购买跳过'))
def test_ocr_error_falls_back_to_templates(self):
calls = []
auto = self.auto
def buy_gifts(shop):
for commodity in must_purchase():
calls.append((commodity, auto.click_element(commodity, threshold=0.85)))
auto.click_element('mirror/shop/purchase_assets.png')
must_purchase = lambda: list(self.must) # noqa: E731
self.shop_cls.buy_gifts = buy_gifts
self.auto.screenshot = object()
self.auto.find_element = mock.Mock(side_effect=RuntimeError('ocr'))
ap.install_shop_by_name(log=self.lines.append, env={})
self.shop_cls().buy_gifts()
self.assertEqual(calls, [(ap.SHOP_BY_NAME, False)] * ap.SHOP_BY_NAME_SLOTS
+ [('mirror/shop/must_purchase/a.png', False)])
self.assertIn('商店按名字购买出错(RuntimeError: ocr), 只用图标模板', '\n'.join(self.lines))
if __name__ == '__main__':
unittest.main()
+62
View File
@@ -0,0 +1,62 @@
# -*- coding: utf-8 -*-
"""镜牢商店"必买 / 必卖 / 公式合成"清单(BACKLOG P0-1)。
2026-11-14 实测: 上游 tasks/mirror/__init__.py 按旧路径 ./assets/images/share/... 列目录, 三个清单恒为空,
进店 51 秒一件没买。上游 8196e72(V1.6.1) 改成按 assets/images/default/share/... 列, 本地补丁随之删掉;
这里守着上游别再退回空清单。
"""
import os
import types
import unittest
from contextlib import contextmanager
from pathlib import Path
REPO = Path(__file__).resolve().parents[1]
AALC = REPO / 'vendor' / 'aalc'
INIT = AALC / 'tasks' / 'mirror' / '__init__.py'
SHOP_LISTS = ('must_purchase', 'must_be_abandoned', 'fusion_result')
IMAGE_ROOTS = ('dark/zh_cn', 'dark/en', 'dark/share', 'default/zh_cn', 'default/en', 'default/share')
@contextmanager
def chdir(path):
old = os.getcwd()
os.chdir(path)
try:
yield
finally:
os.chdir(old)
def upstream_mirror_package():
"""在 AALC 目录下执行上游 tasks/mirror/__init__.py(任务进程的工作目录也是这里)。"""
module = types.ModuleType('tasks.mirror')
with chdir(AALC):
exec(compile(INIT.read_text(encoding='utf-8'), str(INIT), 'exec'), module.__dict__)
return module
@unittest.skipUnless(INIT.is_file(), 'vendor/aalc 子模块未检出')
class UpstreamShopListTest(unittest.TestCase):
def test_upstream_lists_are_filled(self):
package = upstream_mirror_package()
self.assertEqual([len(getattr(package, k)) for k in SHOP_LISTS], [5, 19, 31])
self.assertIn('mirror/shop/must_purchase/carmilla.png', package.must_purchase)
def test_every_listed_name_resolves_under_some_image_root(self):
package = upstream_mirror_package()
images = AALC / 'assets' / 'images'
for kind in SHOP_LISTS:
for name in getattr(package, kind):
with self.subTest(name=name):
self.assertTrue(any((images / root / name).is_file() for root in IMAGE_ROOTS))
def test_roots_match_aalc_path_manager(self):
source = (AALC / 'utils' / 'path_manager.py').read_text(encoding='utf-8')
for root in IMAGE_ROOTS:
self.assertIn('"%s"' % root, source)
if __name__ == '__main__':
unittest.main()
+664
View File
@@ -0,0 +1,664 @@
import os
import sys
import types
import unittest
from types import SimpleNamespace
from unittest import mock
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
from lc_mcp import aalc_patches # noqa: E402
class SystemTeamNamesTest(unittest.TestCase):
def test_all_ten_systems_are_mapped(self):
expected = {'burn', 'bleed', 'tremor', 'rupture', 'poise',
'sinking', 'charge', 'slash', 'pierce', 'blunt'}
self.assertEqual(set(aalc_patches.SYSTEM_TEAM_NAMES), expected)
def test_names_are_non_empty_strings(self):
for system, names in aalc_patches.SYSTEM_TEAM_NAMES.items():
self.assertIsInstance(names, tuple, system)
self.assertTrue(names, system)
for name in names:
self.assertIsInstance(name, str)
self.assertTrue(name.strip(), system)
def test_poise_accepts_both_spellings(self):
# 游戏里叫「呼吸法」, system_cn_zh 里叫「呼吸」, 两个都要能命中
self.assertIn('呼吸法', aalc_patches.SYSTEM_TEAM_NAMES['poise'])
self.assertIn('呼吸', aalc_patches.SYSTEM_TEAM_NAMES['poise'])
def test_preferences_point_at_real_systems_and_names(self):
# 2026-11-14 用户指定: 充能优先, 没有就退到震颤
for system, names in aalc_patches.TEAM_PREFERENCES.items():
self.assertIn(system, aalc_patches.SYSTEM_TEAM_NAMES)
self.assertTrue(names, system)
for name in names:
self.assertIsInstance(name, str)
self.assertTrue(name.strip())
self.assertEqual(aalc_patches.TEAM_PREFERENCES['charge'], ('震颤',))
class RegionTest(unittest.TestCase):
def test_team_list_region(self):
self.assertTrue(aalc_patches._in_list(130, 493)) # 实测「流血」的位置
self.assertTrue(aalc_patches._in_list(255, 305))
self.assertFalse(aalc_patches._in_list(130, 120)) # 顶栏不算列表
self.assertFalse(aalc_patches._in_list(600, 493)) # 右侧面板
self.assertFalse(aalc_patches._in_list(130, 700))
def test_header_region(self):
self.assertTrue(aalc_patches._in_header(242, 125)) # 实测顶栏「流血」
self.assertFalse(aalc_patches._in_header(130, 493))
self.assertFalse(aalc_patches._in_header(900, 125))
def test_regions_do_not_overlap(self):
for x, y in [(130, 493), (242, 125), (600, 300), (1200, 600)]:
self.assertFalse(
aalc_patches._in_list(x, y) and aalc_patches._in_header(x, y),
(x, y),
)
def ocr_engine(lines):
"""假的 module.ocr: 引擎按 [(文本, x, y)] 逐行返回, 同名文本可以出现多次(真实引擎就是这样)。"""
result = SimpleNamespace(txts=tuple(t for t, _, _ in lines),
boxes=[[[x - 10, y - 5], [x + 10, y - 5], [x + 10, y + 5], [x - 10, y + 5]]
for _, x, y in lines])
return SimpleNamespace(ocr=SimpleNamespace(run=lambda image: result))
class TeamOcrTest(unittest.TestCase):
def test_engine_lines_keep_duplicate_names(self):
# 选中「流血」后顶栏和列表都是「流血」; 经 {文本: 坐标} 只会剩一条
engine = ocr_engine([('流血', 242.0, 125.0), (' 流血 ', 130.0, 493.0), ('', 1.0, 1.0)])
auto = mock.Mock()
with mock.patch.dict(sys.modules, {'module': types.ModuleType('module'), 'module.ocr': engine}):
self.assertEqual(aalc_patches._team_ocr(auto), [('流血', 242.0, 125.0), ('流血', 130.0, 493.0)])
auto._run_ocr_for_text.assert_not_called()
class TeamOcrFallbackTest(unittest.TestCase):
"""OCR 引擎导入不了时退回 AALC 的 _run_ocr_for_text。"""
def setUp(self):
patcher = mock.patch.dict(sys.modules, {'module.ocr': None})
patcher.start()
self.addCleanup(patcher.stop)
def test_returns_list_and_strips_spaces(self):
auto = mock.Mock()
auto._run_ocr_for_text.return_value = {
'编队#20': [132.0, 340.5],
' 流血 ': [130.5, 493.0],
'': [0, 0],
}
items = aalc_patches._team_ocr(auto)
self.assertIn(('编队#20', 132.0, 340.5), items)
self.assertIn(('流血', 130.5, 493.0), items)
self.assertEqual(len(items), 2) # 空串被丢掉
def test_empty_ocr_gives_empty_list(self):
auto = mock.Mock()
auto._run_ocr_for_text.return_value = {}
self.assertEqual(aalc_patches._team_ocr(auto), [])
def test_bad_position_is_skipped_not_fatal(self):
auto = mock.Mock()
auto._run_ocr_for_text.return_value = {'流血': [], '斩击': [1.0, 2.0]}
self.assertEqual(aalc_patches._team_ocr(auto), [('斩击', 1.0, 2.0)])
class NormalizeTeamNameTest(unittest.TestCase):
def test_known_ocr_misreads_are_fixed(self):
# 2026-11-14 实测误读样本
self.assertEqual(aalc_patches.normalize_team_name('震颐'), '震颤')
self.assertEqual(aalc_patches.normalize_team_name('沉论'), '沉沦')
self.assertEqual(aalc_patches.normalize_team_name('编#16'), '编队#16')
self.assertEqual(aalc_patches.normalize_team_name('编队#16'), '编队#16')
def test_spaces_and_full_width_forms(self):
self.assertEqual(aalc_patches.normalize_team_name(' 流\u3000血 '), '流血')
self.assertEqual(aalc_patches.normalize_team_name('流血(X)'), '流血(X)')
self.assertEqual(aalc_patches.normalize_team_name('编队#20'), '编队#20')
class TeamNameMatchTest(unittest.TestCase):
def test_exact_prefix_and_miss(self):
match = aalc_patches.team_name_match
self.assertEqual(match('流血', ('流血',)), 'exact')
self.assertEqual(match('流血队', ('流血',)), 'prefix')
self.assertEqual(match('流血(X)', ('流血',)), 'prefix')
self.assertIsNone(match('编队#13', ('流血',)))
self.assertIsNone(match('出血', ('流血',)))
self.assertIsNone(match('血', ('流血',)))
def test_misread_text_matches_configured_name(self):
self.assertEqual(aalc_patches.team_name_match('震颐', aalc_patches.SYSTEM_TEAM_NAMES['tremor']), 'exact')
self.assertEqual(aalc_patches.team_name_match('沉论队', aalc_patches.SYSTEM_TEAM_NAMES['sinking']),
'prefix')
def test_single_character_names_never_prefix_match(self):
self.assertIsNone(aalc_patches.team_name_match('流血', ('流',)))
self.assertEqual(aalc_patches.team_name_match('流', ('流',)), 'exact')
class PickTeamItemTest(unittest.TestCase):
def test_exact_beats_prefix(self):
items = [('流血队', 130, 400), ('流血', 130, 450)]
self.assertEqual(aalc_patches.pick_team_item(items, ('流血',))[0], ('流血', 130, 450))
def test_names_order_decides_between_exact_hits(self):
items = [('呼吸', 130, 400), ('呼吸法', 130, 450)]
self.assertEqual(aalc_patches.pick_team_item(items, ('呼吸法', '呼吸'))[0], ('呼吸法', 130, 450))
def test_unique_prefix_is_picked(self):
hit, reason = aalc_patches.pick_team_item([('斩击', 130, 330), ('流血队', 130, 490)], ('流血',))
self.assertEqual(hit, ('流血队', 130, 490))
self.assertIn('前缀', reason)
def test_one_team_matching_two_names_is_still_unique(self):
hit, _ = aalc_patches.pick_team_item([('呼吸法队', 130, 400)], ('呼吸法', '呼吸'))
self.assertEqual(hit, ('呼吸法队', 130, 400))
def test_ambiguous_prefix_is_not_clicked(self):
hit, reason = aalc_patches.pick_team_item([('流血队', 130, 400), ('流血2', 130, 450)], ('流血',))
self.assertIsNone(hit)
self.assertIn('流血2/流血队', reason)
def test_nothing_matches(self):
self.assertEqual(aalc_patches.pick_team_item([('斩击', 130, 330)], ('流血',)), (None, ''))
class _FakeTeamScreen:
"""编队界面: 每下拖一次翻一屏(实测一次拖动 ≈ 5~6 行), 点哪条顶栏就变成哪条。"""
def __init__(self, screens, header='剧情关卡', click_changes_header=True):
self.screens = screens
self.header = header
self.click_changes_header = click_changes_header
self.swipes_down = 0
self.clicks = []
@property
def page(self):
return min(self.swipes_down, len(self.screens) - 1)
def take_screenshot(self):
return object()
@property
def screenshot(self):
return self # 交给假 OCR 引擎的"截图"就是这块界面
def find_element(self, *args, **kwargs):
return True
def mouse_click(self, *args):
pass
def mouse_swipe_for_team_scroll(self, x, y, dy, duration):
self.swipes_down = 0 if dy > 0 else self.swipes_down + 1
def read(self):
"""OCR 引擎逐行结果: 顶栏在上、列表在下; 同名条目各出现一次。"""
lines = [(self.header, 242.0, 125.0)] if self.header else []
lines += [(text, 130.0, 320.0 + 50 * row) for row, text in enumerate(self.screens[self.page])]
return SimpleNamespace(txts=tuple(t for t, _, _ in lines),
boxes=[[[x - 10, y - 5], [x + 10, y - 5], [x + 10, y + 5], [x - 10, y + 5]]
for _, x, y in lines])
def mouse_action_with_pos(self, pos, offset=False):
self.clicks.append(tuple(pos))
if self.click_changes_header:
row = int(round((pos[1] - 320.0) / 50))
self.header = self.screens[self.page][row]
class SelectTeamByNameTest(unittest.TestCase):
TOP = ['剧情关卡', '斩击', '突刺', '打击', '烧伤']
MIDDLE = ['流血', '震颤', '破裂', '沉沦', '呼吸法']
BOTTOM = ['充能', '编队#13', '编队#14']
def setUp(self):
self.lines = []
engine = SimpleNamespace(ocr=SimpleNamespace(run=lambda screen: screen.read()))
modules = mock.patch.dict(sys.modules, {'module': types.ModuleType('module'), 'module.ocr': engine})
modules.start()
self.addCleanup(modules.stop)
for patcher in (mock.patch.object(aalc_patches.time, 'sleep'),
mock.patch.object(aalc_patches.decisions, 'record')):
self.records = patcher.start()
self.addCleanup(patcher.stop)
def select(self, auto, names):
return aalc_patches._select_team_by_name(auto, names, log=self.lines.append)
@property
def log(self):
return '\n'.join(self.lines)
def test_renamed_team_with_suffix_is_selected(self):
auto = _FakeTeamScreen([self.TOP, ['流血队', '震颤', '破裂'], self.BOTTOM])
self.assertTrue(self.select(auto, ('流血',)))
self.assertEqual(auto.header, '流血队')
self.assertEqual(len(auto.clicks), 1)
self.assertIn('已按体系名选中编队 流血队', self.log)
def test_misread_list_entry_is_selected(self):
auto = _FakeTeamScreen([self.TOP, ['流血', '震颐', '破裂', '沉论'], self.BOTTOM])
self.assertTrue(self.select(auto, ('沉沦',)))
self.assertEqual(auto.header, '沉论')
self.assertIn('选中编队 沉沦', self.log)
def test_current_team_needs_no_switch(self):
auto = _FakeTeamScreen([self.TOP, self.MIDDLE], header='沉论')
self.assertTrue(self.select(auto, ('沉沦',)))
self.assertEqual(auto.clicks, [])
self.assertIn('当前已经是编队 沉沦', self.log)
def test_current_team_that_is_also_in_the_list(self):
# 列表这一屏里也有「流血」: 顶栏那条不能被列表那条盖掉
auto = _FakeTeamScreen([self.MIDDLE], header='流血')
self.assertTrue(self.select(auto, ('流血',)))
self.assertEqual(auto.clicks, [])
self.assertIn('当前已经是编队 流血', self.log)
def test_current_team_with_suffix_is_confirmed_in_the_list(self):
# 顶栏 "流血队" 只是前缀命中, 不能直接当成目标; 列表里唯一后再点一次
auto = _FakeTeamScreen([self.TOP, ['流血队', '震颤']], header='流血队')
self.assertTrue(self.select(auto, ('流血',)))
self.assertEqual(len(auto.clicks), 1)
self.assertNotIn('无需切换', self.log)
def test_exact_team_wins_over_current_suffixed_team(self):
auto = _FakeTeamScreen([self.TOP, ['流血2', '流血', '震颤']], header='流血2')
self.assertTrue(self.select(auto, ('流血',)))
self.assertEqual(auto.header, '流血')
def test_name_order_is_priority_not_screen_order(self):
# 首选项「充能」在最后一屏, 次选「震颤」在第二屏 —— 应先翻到充能
auto = _FakeTeamScreen([self.TOP, self.MIDDLE, self.BOTTOM])
self.assertTrue(self.select(auto, ('充能', '震颤')))
self.assertEqual(auto.header, '充能')
def test_falls_back_to_second_name(self):
# 列表里没有「充能」, 第二顺位「震颤」应该被选中
auto = _FakeTeamScreen([self.TOP, ['流血', '震颤', '破裂'], ['编队#13', '编队#14']])
self.assertTrue(self.select(auto, ('充能', '震颤')))
self.assertEqual(auto.header, '震颤')
def test_missing_team_logs_every_screen_and_never_clicks(self):
auto = _FakeTeamScreen([self.TOP, self.MIDDLE, self.BOTTOM])
self.assertFalse(self.select(auto, ('编队#999',)))
self.assertEqual(auto.clicks, [])
self.assertIn('第 1 屏没有 编队#999; 这一屏的名字: 剧情关卡/斩击/突刺/打击/烧伤', self.log)
self.assertIn('第 3 屏没有 编队#999; 这一屏的名字: 充能/编队#13/编队#14', self.log)
self.assertIn('没找到 编队#999(共 6 轮)', self.log)
def test_ambiguous_suffixes_are_not_clicked(self):
auto = _FakeTeamScreen([['流血队', '流血2', '斩击']])
self.assertFalse(self.select(auto, ('流血',)))
self.assertEqual(auto.clicks, [])
self.assertIn('前缀匹配到多条(流血2/流血队), 不点', self.log)
def test_decisions_are_recorded(self):
self.select(_FakeTeamScreen([self.TOP, ['流血队', '震颤']]), ('流血',))
self.records.assert_called_with('team', '流血队', 'prefix', wanted=['流血'])
self.select(_FakeTeamScreen([self.TOP], header='流血'), ('流血',))
self.records.assert_called_with('team', '流血', 'current', wanted=['流血'])
self.select(_FakeTeamScreen([self.TOP, self.BOTTOM]), ('编队#999',))
args, kwargs = self.records.call_args
self.assertEqual(args, ('team', None, 'not_found'))
self.assertEqual(kwargs['seen'][0], self.TOP)
self.assertEqual(len(kwargs['seen']), 6)
def test_header_not_changing_is_reported(self):
auto = _FakeTeamScreen([self.TOP, self.MIDDLE], click_changes_header=False)
self.assertFalse(self.select(auto, ('流血',)))
self.assertIn('点了 流血 但顶栏没变(顶栏读到: 剧情关卡)', self.log)
class _FakeMirror:
def __init__(self, team_setting, team_num):
self.system = team_setting['system']
self.team_number = team_num
class InstallSystemTeamSelectionTest(unittest.TestCase):
"""用假模块验证挂载点与回退行为, 不依赖 AALC / Windows。"""
def setUp(self):
self.calls = []
def original(num):
self.calls.append(num)
return 'fallback'
self.original = original
self.mirror_mod = types.ModuleType('tasks.mirror.mirror')
self.mirror_mod.Mirror = _FakeMirror
self.mirror_mod.select_battle_team = original
self.auto = mock.Mock()
auto_mod = types.ModuleType('module.automation')
auto_mod.auto = self.auto
tasks_pkg = types.ModuleType('tasks')
tasks_pkg.__path__ = []
mirror_pkg = types.ModuleType('tasks.mirror')
mirror_pkg.__path__ = []
mirror_pkg.mirror = self.mirror_mod
module_pkg = types.ModuleType('module')
module_pkg.__path__ = []
self._patcher = mock.patch.dict(sys.modules, {
'tasks': tasks_pkg,
'tasks.mirror': mirror_pkg,
'tasks.mirror.mirror': self.mirror_mod,
'module': module_pkg,
'module.automation': auto_mod,
})
self._patcher.start()
self.addCleanup(self._patcher.stop)
def install(self):
return aalc_patches.install_system_team_selection(log=lambda *_: None)
def test_returns_original_and_replaces_module_global(self):
original = self.install()
self.assertIs(original, self.original)
self.assertIsNot(self.mirror_mod.select_battle_team, self.original)
# __init__ 也被包装, 但仍然正常构造
mirror = self.mirror_mod.Mirror({'system': 'bleed'}, 1)
self.assertEqual(mirror.system, 'bleed')
def test_known_system_uses_name_search(self):
self.install()
self.mirror_mod.Mirror({'system': 'bleed'}, 1)
with mock.patch.object(aalc_patches, '_select_team_by_name', return_value=True) as sel:
self.assertIs(self.mirror_mod.select_battle_team(1), True)
self.assertEqual(sel.call_args[0][1], ('流血',))
self.assertEqual(self.calls, []) # 成功后不再走编号回退
def test_charge_looks_for_charge_then_tremor(self):
self.install()
self.mirror_mod.Mirror({'system': 'charge'}, 1)
with mock.patch.object(aalc_patches, '_select_team_by_name', return_value=True) as sel:
self.mirror_mod.select_battle_team(1)
self.assertEqual(sel.call_args[0][1], ('充能', '震颤'))
def test_name_search_failure_does_not_fall_back_to_number(self):
# 这号没有 编队#1, 静默回退到编号会选中错的队, 必须显式失败
self.install()
self.mirror_mod.Mirror({'system': 'bleed'}, 1)
with mock.patch.object(aalc_patches, '_select_team_by_name', return_value=False):
self.assertIs(self.mirror_mod.select_battle_team(1), False)
self.assertEqual(self.calls, [])
def test_exception_in_name_search_is_contained(self):
self.install()
self.mirror_mod.Mirror({'system': 'bleed'}, 1)
boom = mock.Mock(side_effect=RuntimeError('ocr down'))
with mock.patch.object(aalc_patches, '_select_team_by_name', boom):
self.assertIs(self.mirror_mod.select_battle_team(1), False)
def test_unknown_system_falls_back_to_original(self):
self.install()
self.mirror_mod.Mirror({'system': 'unknown_system'}, 3)
self.assertEqual(self.mirror_mod.select_battle_team(3), 'fallback')
self.assertEqual(self.calls, [3])
def test_missing_mirror_module_is_not_fatal(self):
with mock.patch.dict(sys.modules, {'tasks.mirror': None, 'tasks.mirror.mirror': None}):
self.assertIsNone(self.install())
class TeamScreenDetectionTest(unittest.TestCase):
def setUp(self):
engine = SimpleNamespace(ocr=SimpleNamespace(run=lambda screen: screen.read()))
modules = mock.patch.dict(sys.modules, {'module': types.ModuleType('module'), 'module.ocr': engine})
modules.start()
self.addCleanup(modules.stop)
def test_team_screen_detected_by_names(self):
auto = _FakeTeamScreen([['剧情关卡', '斩击', '突刺', '打击', '烧伤']])
self.assertTrue(aalc_patches._looks_like_team_screen(auto))
def test_starlight_screen_is_not_team_screen(self):
# 星之恩惠页: 满屏星星会让「选队星级」模板命中, 但左侧不是队名列表
auto = _FakeTeamScreen([['+', '卫星商店', '可免费进行商店关键词刷新1次', '获得1件1级饰品']],
header='西西弗的星之恩惠')
self.assertFalse(aalc_patches._looks_like_team_screen(auto))
class TeamScreenGuardTest(unittest.TestCase):
def install(self):
auto = mock.Mock()
def fake_find(target, *args, **kwargs):
return (640, 360) if target == aalc_patches.TEAM_SCREEN_STARS else False
auto.find_element = fake_find
auto_mod = types.ModuleType('module.automation')
auto_mod.auto = auto
patcher = mock.patch.dict(sys.modules, {'module': types.ModuleType('module'),
'module.automation': auto_mod})
patcher.start()
self.addCleanup(patcher.stop)
aalc_patches.install_team_screen_guard(log=lambda *_: None)
return auto
def test_stars_ignored_on_starlight_screen(self):
auto = self.install()
with mock.patch.object(aalc_patches, '_is_starlight_screen', return_value=True):
self.assertFalse(auto.find_element(aalc_patches.TEAM_SCREEN_STARS))
def test_stars_kept_on_real_team_screen(self):
auto = self.install()
with mock.patch.object(aalc_patches, '_is_starlight_screen', return_value=False):
self.assertEqual(auto.find_element(aalc_patches.TEAM_SCREEN_STARS), (640, 360))
self.assertFalse(auto.find_element('mirror/other.png'))
class _LoadingTeamScreen(_FakeTeamScreen):
"""选队页刚加载: 第 loaded_at 张截图之前编队图标和列表都还没出来。"""
def __init__(self, screens, loaded_at=2, **kwargs):
super().__init__(screens, **kwargs)
self.loaded_at = loaded_at
self.shots = 0
def take_screenshot(self):
self.shots += 1
return object()
@property
def loaded(self):
return self.shots >= self.loaded_at
def find_element(self, *args, **kwargs):
return self.loaded
def read(self):
if not self.loaded:
return SimpleNamespace(txts=(), boxes=[])
return super().read()
class SelectTeamScreenWaitTest(unittest.TestCase):
def setUp(self):
self.lines = []
engine = SimpleNamespace(ocr=SimpleNamespace(run=lambda screen: screen.read()))
for patcher in (mock.patch.dict(sys.modules, {'module': types.ModuleType('module'), 'module.ocr': engine}),
mock.patch.object(aalc_patches.time, 'sleep'),
mock.patch.object(aalc_patches.decisions, 'record')):
patcher.start()
self.addCleanup(patcher.stop)
def test_waits_for_a_fresh_screenshot_of_the_team_screen(self):
# 旧写法对着同一张截图认 3 次, 页面加载慢一点就报"不在编队界面"
auto = _LoadingTeamScreen([['剧情关卡', '流血', '震颤']], loaded_at=3)
self.assertTrue(aalc_patches._select_team_by_name(auto, ('流血',), log=self.lines.append))
self.assertEqual(auto.header, '流血')
def test_gives_up_when_the_team_screen_never_shows(self):
auto = _LoadingTeamScreen([['剧情关卡', '流血']], loaded_at=99)
self.assertFalse(aalc_patches._select_team_by_name(auto, ('流血',), log=self.lines.append))
self.assertIn('不在编队界面, 跳过按名字选队', '\n'.join(self.lines))
self.assertEqual(auto.clicks, [])
class _EnterScreen(_FakeTeamScreen):
"""选队页右下角有「进入」; 记下点「进入」时顶栏是哪支队, 以及整屏 OCR 跑了几次。"""
def __init__(self, screens, enter=True, **kwargs):
super().__init__(screens, **kwargs)
self.enter = enter
self.entered_with = []
self.ocr_runs = 0
def click_element(self, target, *args, click=True, **kwargs):
if target != aalc_patches.ENTER_ASSET or not self.enter:
return False
if not click:
return (1100, 650)
self.entered_with.append(self.header)
return True
def read(self):
self.ocr_runs += 1
return super().read()
class EnterSwitchTest(unittest.TestCase):
"""镜牢入场时 AALC 直接点「进入」, 不走 select_battle_team; 补丁在点之前切队。"""
TOP = ['剧情关卡', '斩击', '突刺', '打击', '烧伤']
MIDDLE = ['流血', '震颤', '破裂', '沉沦', '呼吸法']
def install(self, auto, system='bleed'):
self.lines = []
self.mirror_mod = types.ModuleType('tasks.mirror.mirror')
self.mirror_mod.Mirror = type('Mirror', (_FakeMirror,), {})
self.mirror_mod.select_battle_team = lambda num: False
tasks_pkg, mirror_pkg = types.ModuleType('tasks'), types.ModuleType('tasks.mirror')
mirror_pkg.mirror = self.mirror_mod
engine = SimpleNamespace(ocr=SimpleNamespace(run=lambda screen: screen.read()))
for patcher in (mock.patch.dict(sys.modules, {
'tasks': tasks_pkg, 'tasks.mirror': mirror_pkg, 'tasks.mirror.mirror': self.mirror_mod,
'module': types.ModuleType('module'), 'module.ocr': engine,
'module.automation': SimpleNamespace(auto=auto)}),
mock.patch.object(aalc_patches.time, 'sleep'),
mock.patch.object(aalc_patches.decisions, 'record')):
patcher.start()
self.addCleanup(patcher.stop)
aalc_patches.install_system_team_selection(log=self.lines.append)
self.mirror_mod.Mirror({'system': system}, 1)
return auto
@property
def log(self):
return '\n'.join(self.lines)
def test_no_enter_button_means_no_ocr(self):
# 主循环每轮都会问一次「进入」; 按钮不在画面上时不该为它跑整屏 OCR
auto = self.install(_EnterScreen([self.TOP], enter=False))
for _ in range(5):
self.assertFalse(auto.click_element(aalc_patches.ENTER_ASSET))
self.assertEqual(auto.ocr_runs, 0)
def test_switches_to_the_system_team_before_entering(self):
auto = self.install(_EnterScreen([self.TOP, self.MIDDLE]))
self.assertTrue(auto.click_element(aalc_patches.ENTER_ASSET))
self.assertEqual(auto.entered_with, ['流血'])
self.assertIn('入场前切队伍: 流血', self.log)
def test_already_on_the_team_just_enters(self):
auto = self.install(_EnterScreen([self.TOP, self.MIDDLE], header='流血'))
self.assertTrue(auto.click_element(aalc_patches.ENTER_ASSET))
self.assertEqual(auto.entered_with, ['流血'])
self.assertEqual(auto.clicks, [])
self.assertNotIn('入场前切队伍:', self.log)
def test_failed_switch_is_an_error_and_is_not_retried_this_run(self):
auto = self.install(_EnterScreen([self.TOP, ['破裂', '沉沦', '编队#13']]))
self.assertTrue(auto.click_element(aalc_patches.ENTER_ASSET))
self.assertEqual(auto.entered_with, ['剧情关卡'])
self.assertIn('[ERROR] [lc_mcp] 入场前没切到 流血, 本局按游戏当前编队进入', self.log)
runs = auto.ocr_runs
self.assertTrue(auto.click_element(aalc_patches.ENTER_ASSET)) # 上游再点一次「进入」
self.assertEqual(auto.ocr_runs, runs) # 不再从头翻列表
self.mirror_mod.Mirror({'system': 'bleed'}, 1) # 下一局重新试
auto.click_element(aalc_patches.ENTER_ASSET)
self.assertGreater(auto.ocr_runs, runs)
def test_lookup_without_click_is_passed_through(self):
auto = self.install(_EnterScreen([self.TOP, self.MIDDLE]))
self.assertEqual(auto.click_element(aalc_patches.ENTER_ASSET, click=False), (1100, 650))
self.assertEqual((auto.ocr_runs, auto.entered_with), (0, []))
def test_other_targets_are_untouched(self):
auto = self.install(_EnterScreen([self.TOP]))
self.assertFalse(auto.click_element('mirror/road_to_mir/resume_assets.png'))
self.assertEqual(auto.ocr_runs, 0)
if __name__ == '__main__':
unittest.main()
class TeamNamesFileTest(unittest.TestCase):
def _write(self, data):
import json
import tempfile
fh = tempfile.NamedTemporaryFile('w', suffix='.json', delete=False, encoding='utf-8')
json.dump(data, fh, ensure_ascii=False)
fh.close()
self.addCleanup(lambda: os.unlink(fh.name))
return fh.name
def test_reads_overrides(self):
path = self._write({'_说明': ['x'], 'tremor': ['镜像迷宫', '震颤']})
self.assertEqual(aalc_patches.load_team_names(path, log=lambda *_: None),
{'tremor': ('镜像迷宫', '震颤')})
def test_bad_file_falls_back_to_empty(self):
path = self._write(['not', 'a', 'dict'])
self.assertEqual(aalc_patches.load_team_names(path, log=lambda *_: None), {})
def test_missing_file_falls_back_to_empty(self):
self.assertEqual(
aalc_patches.load_team_names(os.path.join(os.path.dirname(__file__), 'no-such.json'),
log=lambda *_: None), {})
def test_override_goes_first_then_defaults(self):
path = self._write({'tremor': ['镜像迷宫']})
module = types.ModuleType('tasks.mirror.mirror')
module.Mirror = _FakeMirror
module.select_battle_team = lambda num: True
auto_mod = types.ModuleType('module.automation')
auto_mod.auto = mock.Mock()
tasks_pkg = types.ModuleType('tasks'); tasks_pkg.__path__ = []
mirror_pkg = types.ModuleType('tasks.mirror'); mirror_pkg.__path__ = []
mirror_pkg.mirror = module
with mock.patch.dict(sys.modules, {'tasks': tasks_pkg, 'tasks.mirror': mirror_pkg,
'tasks.mirror.mirror': module,
'module': types.ModuleType('module'),
'module.automation': auto_mod}):
aalc_patches.install_system_team_selection(log=lambda *_: None,
env={'LCP_TEAM_NAMES': path})
module.Mirror({'system': 'tremor'}, 1)
with mock.patch.object(aalc_patches, '_select_team_by_name', return_value=True) as sel:
module.select_battle_team(1)
self.assertEqual(sel.call_args[0][1], ('镜像迷宫', '震颤'))
+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()
+220
View File
@@ -0,0 +1,220 @@
# -*- coding: utf-8 -*-
"""镜牢键盘寻路按节点类型选方向(BACKLOG P0-2)。
2026-11-14: config 开着简单键盘寻路, AALC 每步只按 ↑, 3 层只进过 1 次商店。
补丁仍只按键、不拖地图, 但先识别下一列节点类型, 按上游权重表挑方向。
"""
import ast
import sys
import types
import unittest
from pathlib import Path
from types import SimpleNamespace
from unittest import mock
REPO = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(REPO))
from lc_mcp import aalc_patches as ap # noqa: E402
SEARCH_ROAD = REPO / 'vendor' / 'aalc' / 'tasks' / 'mirror' / 'search_road.py'
SCALE = 720 / 1440 # 本机 set_win_size=720
GAP_X = ap.UPSTREAM_ROAD_COLUMN_GAP * SCALE
GAP_Y = ap.UPSTREAM_ROAD_ROW_GAP * SCALE
BUS = (100, 400)
def node(kind, columns=1, rows=0):
"""相对巴士偏 columns 列、rows 行(向上为正)的节点。"""
return [kind, (BUS[0] + columns * GAP_X, BUS[1] - rows * GAP_Y)]
class RankNextNodesTest(unittest.TestCase):
def test_orders_next_column_by_upstream_weight(self):
nodes = [node('battle', rows=0), node('event', rows=1), node('shop', rows=-1),
node('event', columns=2), node('event', columns=0.3)]
self.assertEqual(ap.rank_next_nodes(BUS, nodes, SCALE),
[('U', 'event', 1), ('D', 'shop', 2), ('M', 'battle', 4)])
def test_ties_prefer_up_then_middle(self):
nodes = [node('battle', rows=-1), node('battle', rows=0), node('battle', rows=1)]
self.assertEqual([d for d, _, _ in ap.rank_next_nodes(BUS, nodes, SCALE)], ['U', 'M', 'D'])
def test_tolerates_detection_offsets_within_a_quarter_gap(self):
kind, (x, y) = node('shop', rows=1)
shifted = [kind, (x + GAP_X / 5, y + GAP_Y / 3)]
self.assertEqual(ap.rank_next_nodes(BUS, [shifted], SCALE), [('U', 'shop', 2)])
def test_keeps_the_better_detection_per_direction(self):
nodes = [node('risky_encounter', rows=0), node('event', rows=0)]
self.assertEqual(ap.rank_next_nodes(BUS, nodes, SCALE), [('M', 'event', 1)])
def test_rows_beyond_neighbours_and_unknown_types_are_ignored(self):
nodes = [node('event', rows=2), node('mystery', rows=0)]
self.assertEqual(ap.rank_next_nodes(BUS, nodes, SCALE), [])
def test_no_bus_or_no_nodes(self):
self.assertEqual(ap.rank_next_nodes(None, [node('event')], SCALE), [])
self.assertEqual(ap.rank_next_nodes(BUS, None, SCALE), [])
@unittest.skipUnless(SEARCH_ROAD.is_file(), 'vendor/aalc 子模块未检出')
class UpstreamConstantsTest(unittest.TestCase):
"""本地兜底常量必须与上游一致(运行时优先读上游的值)。"""
def setUp(self):
self.tree = ast.parse(SEARCH_ROAD.read_text(encoding='utf-8'))
def assignment(self, name):
for item in self.tree.body:
if isinstance(item, ast.Assign) and any(getattr(t, 'id', None) == name for t in item.targets):
return ast.literal_eval(item.value)
self.fail('上游没有 %s' % name)
def test_weights_and_grid_match_upstream(self):
self.assertEqual(self.assignment('all_node_weight'), ap.UPSTREAM_NODE_WEIGHT)
self.assertEqual(self.assignment('ROAD_COLUMN_GAP'), ap.UPSTREAM_ROAD_COLUMN_GAP)
self.assertEqual(self.assignment('ROAD_ROW_GAP'), ap.UPSTREAM_ROAD_ROW_GAP)
def test_direction_keys_match_upstream_keyboard_navigation(self):
source = SEARCH_ROAD.read_text(encoding='utf-8')
for direction, key in ap.ROAD_KEYS.items():
self.assertIn('if next_step == "%s":\n auto.key_press("%s")' % (direction, key)
if direction == 'U' else
'elif next_step == "%s":\n auto.key_press("%s")' % (direction, key),
source)
class TypedKeyboardRoadTest(unittest.TestCase):
def setUp(self):
self.lines = []
self.keys = []
self.original = mock.Mock(return_value='original')
self.entered = []
self.road = types.ModuleType('tasks.mirror.search_road')
self.road.search_road_simple_keyboard = self.original
self.road.identify_nodes = mock.Mock(return_value=[node('battle', rows=0), node('event', rows=1),
node('shop', rows=-1)])
self.road._keyboard_enter_succeeded = lambda: self.entered.pop(0)
self.mirror = types.ModuleType('tasks.mirror.mirror')
self.mirror.search_road_simple_keyboard = self.original
self.auto = SimpleNamespace(mouse_to_blank=mock.Mock(), key_press=self.keys.append,
find_element=mock.Mock(return_value=BUS))
self.cfg = SimpleNamespace(mirror_keyboard_navigation=True, set_win_size=720)
package = types.ModuleType('tasks.mirror')
package.mirror, package.search_road = self.mirror, self.road
tasks = types.ModuleType('tasks')
tasks.mirror = package
modules = {'tasks': tasks, 'tasks.mirror': package, 'tasks.mirror.mirror': self.mirror,
'tasks.mirror.search_road': self.road,
'module': types.ModuleType('module'),
'module.automation': SimpleNamespace(auto=self.auto),
'module.config': SimpleNamespace(cfg=self.cfg)}
for patch in (mock.patch.dict(sys.modules, modules), mock.patch.object(ap.time, 'sleep')):
patch.start()
self.addCleanup(patch.stop)
patch = mock.patch.object(ap.decisions, 'record')
self.records = patch.start()
self.addCleanup(patch.stop)
def install(self, env=None):
return ap.install_typed_keyboard_road(log=self.lines.append, env=env or {})
def test_replaces_both_namespaces_and_enters_the_best_direction(self):
self.assertIs(self.install(), self.original)
self.assertIs(self.mirror.search_road_simple_keyboard, self.road.search_road_simple_keyboard)
self.entered = [True]
self.assertTrue(self.mirror.search_road_simple_keyboard())
self.assertEqual(self.keys, ['up'])
self.original.assert_not_called()
log = '\n'.join(self.lines)
self.assertIn('U=event(1) D=shop(2) M=battle(4)', log)
self.assertIn('进入 U 方向的 event', log)
def test_tries_next_direction_when_one_cannot_be_entered(self):
self.install()
self.entered = [False, True]
self.assertTrue(self.road.search_road_simple_keyboard())
self.assertEqual(self.keys, ['up', 'down'])
self.assertIn('更优的方向没能进入', '\n'.join(self.lines))
def test_decisions_are_recorded(self):
self.install()
self.entered = [False, True]
self.road.search_road_simple_keyboard()
self.records.assert_called_once_with('road', 'D:shop', 'next_best',
candidates=['U=event(1)', 'D=shop(2)', 'M=battle(4)'])
self.records.reset_mock()
self.auto.find_element.return_value = None
self.road.search_road_simple_keyboard()
self.records.assert_called_once_with('road', 'up', 'fallback', why='没找到巴士')
def test_falls_back_to_original_when_nothing_can_be_entered(self):
self.install()
self.entered = [False, False, False]
self.assertEqual(self.road.search_road_simple_keyboard(), 'original')
self.assertEqual(self.keys, ['up', 'down', 'right'])
self.original.assert_called_once_with()
def test_falls_back_without_pressing_when_bus_or_nodes_are_missing(self):
self.install()
for bus, nodes in ((None, []), (BUS, None), (BUS, [])):
with self.subTest(bus=bus, nodes=nodes):
self.original.reset_mock()
self.auto.find_element.return_value = bus
self.road.identify_nodes.return_value = nodes
self.assertEqual(self.road.search_road_simple_keyboard(), 'original')
self.original.assert_called_once_with()
self.assertEqual(self.keys, [])
def test_recognition_error_falls_back(self):
self.install()
self.road.identify_nodes.side_effect = RuntimeError('onnx missing')
self.assertEqual(self.road.search_road_simple_keyboard(), 'original')
self.assertIn('RuntimeError', '\n'.join(self.lines))
def test_keyboard_navigation_off_keeps_upstream_behaviour(self):
self.install()
self.cfg.mirror_keyboard_navigation = False
self.assertEqual(self.road.search_road_simple_keyboard(), 'original')
self.road.identify_nodes.assert_not_called()
def test_gives_up_keyboard_after_consecutive_failed_nodes(self):
# 2026-11-14 实机 24/24 没进去: 每个节点白按 5 次键。连续 3 个节点都不行就别再按了
self.install()
self.original.return_value = False
self.entered = [False] * 3 * ap.ROAD_KEY_GIVE_UP
for _ in range(ap.ROAD_KEY_GIVE_UP):
self.assertFalse(self.road.search_road_simple_keyboard())
self.assertIn('连续 3 个节点按键都没进去, 本次任务不再按键寻路', '\n'.join(self.lines))
self.records.assert_any_call('road', None, 'keyboard_off', fails=3)
pressed, recognised = len(self.keys), self.road.identify_nodes.call_count
self.original.reset_mock()
self.assertIs(self.road.search_road_simple_keyboard(), False) # 上游接着走常规寻路
self.assertEqual((len(self.keys), self.road.identify_nodes.call_count), (pressed, recognised))
self.original.assert_not_called()
def test_entering_once_resets_the_failure_count(self):
self.install()
self.original.return_value = False
self.entered = [False] * 6 + [True] + [False] * 6
results = [bool(self.road.search_road_simple_keyboard()) for _ in range(5)]
self.assertEqual(results, [False, False, True, False, False])
self.assertNotIn('不再按键寻路', '\n'.join(self.lines))
def test_falling_back_to_up_and_entering_counts_as_success(self):
self.install()
self.entered = [False] * 3 * (ap.ROAD_KEY_GIVE_UP + 1)
for _ in range(ap.ROAD_KEY_GIVE_UP + 1):
self.assertEqual(self.road.search_road_simple_keyboard(), 'original') # 原 ↑ 进去了
self.assertNotIn('不再按键寻路', '\n'.join(self.lines))
def test_env_switch_leaves_upstream_untouched(self):
self.assertIsNone(self.install(env={ap.TYPED_ROAD_ENV: '0'}))
self.assertIs(self.road.search_road_simple_keyboard, self.original)
self.assertIs(self.mirror.search_road_simple_keyboard, self.original)
if __name__ == '__main__':
unittest.main()
Vendored
+1 -1