Compare commits
9
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
d15f5a1bb2 | ||
|
|
40a5af0184 | ||
|
|
72d2ca1a5b | ||
|
|
51525722cd | ||
|
|
4376d9cfb2 | ||
|
|
2f8f15a886 | ||
|
|
e08edda27d | ||
|
|
4c0038d657 | ||
|
|
baa362808c |
@@ -143,6 +143,18 @@ MCP 初始化说明与工具描述均指导 AI 优先使用 AALC:常规日常
|
||||
任务运行中如果 `task_status` 带 `stall` 字段,说明 AALC 在原地空转(例如选中了空队伍,
|
||||
编队人数检查一直刷屏)。它不会自己报错退出,应当 `stop_task` 后重跑。
|
||||
|
||||
镜牢任务的局内决策逐条写进与日志同名的 `~/lc_mcp/runs/task_*.decisions.jsonl`(每行一个 JSON:
|
||||
`time`/`stage`/`choice`/`reason` 加细节)。`task_status` 的 `decisions.counts` 按阶段统计 `reason`:
|
||||
|
||||
| `stage` | `reason` |
|
||||
|---|---|
|
||||
| `team` | `current` 已是目标队 / `exact` / `prefix` 后缀队名 / `header_unchanged` / `not_found` |
|
||||
| `road` | `lowest` 下一列最优 / `next_best` 更优方向进不去 / `fallback` 退回按 ↑ |
|
||||
| `theme_pack` | `preferred` 达到优选阈值 / `highest_weight` 刷新后取最高权重 / `event_pack` 最左活动卡包 |
|
||||
| `gift` | `keyword` 命中体系关键词 / `no_keyword`(记的是交给 AALC 的第一顺位,白棉花、已持有仍由 AALC 处理) |
|
||||
| `event` | `text` 按表选 / `deferred` 认出了表里的事件但交给 AALC / `not_in_table`(带 `options`,可直接拿来补表) |
|
||||
| `shop` | `name_match` 按中文名找到必买饰品(`choice` 是名字)/ `purchase_clicked` 点到了购买按钮(`choice` 是之前点的商品:`shop_by_name` 按名字、必买模板名、`level_IV_to_buy`、`by_position` 本体系饰品) |
|
||||
|
||||
### 任务进程里的保护
|
||||
|
||||
`run_task` 启动的任务子进程会做以下处理,都不改 `vendor/aalc` 源码:
|
||||
@@ -160,6 +172,22 @@ MCP 初始化说明与工具描述均指导 AI 优先使用 AALC:常规日常
|
||||
并以退出码 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)`),多条就不点。没找到时日志列出每屏看到的名字。
|
||||
- **键盘寻路按节点类型**:开着简单键盘寻路时不再只按 ↑。先识别巴士右侧下一列的节点类型,
|
||||
按上游权重(事件 < 商店 < 战斗 < …)依次按方向键,进不去再退回 ↑;不拖地图。`LCP_TYPED_ROAD=0` 关闭。
|
||||
- **饰品选择按体系关键词**:镜牢路上的饰品 N 选一,先整屏 OCR,按卡面上命中当前体系关键词的行数给卡排序,
|
||||
再交给 AALC 原逻辑(跳过白棉花、已持有排后)。三张卡时命中关键词的卡按"认出体系图标"交给 AALC,
|
||||
并抵消它把这类卡逐张插到最前造成的倒序。关键词表在 `lc_mcp/data/gift_keywords.json`。
|
||||
- **事件选项表**:事件出现选项时整屏 OCR,按同一屏其它选项的原文(零协汉化)认出 `lc_mcp/data/event_choices.json`
|
||||
里的事件,就点表里那一项;不靠事件名(汉化数据没有标题)。没收录的事件照旧交给 AALC,
|
||||
日志会打印这一屏的选项文字,便于补表。表里的选择优先于 AALC 的"有 ??? 先点 ???",小指良单通模式也一样。
|
||||
- **挂不上就报错**:事件表、饰品排序、商店按名字这三个补丁靠拦截 AALC 的某个调用挂进去,安装时先查上游源码;
|
||||
上游改了写法时记 `[ERROR]` 并跳过该补丁,不会悄悄失效。
|
||||
|
||||
## 无人值守
|
||||
|
||||
@@ -208,6 +236,10 @@ powershell -ExecutionPolicy Bypass -File scripts\install_convert_task.ps1 -Every
|
||||
| `LCP_PORT` | 8765 | 服务/bridge 端口 |
|
||||
| `LCP_KEEP_SHOTS` | 30 | 截图保留张数 |
|
||||
| `LCP_ALLOW_LUNACY` | 未设置 | 设为 `1` 时允许预检放行 `set_lunacy_to_enkephalin` 不为 0 的配置 |
|
||||
| `LCP_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_KILL_KEY` | `end` | 任务子进程的急停键,如 `pause` / `scrolllock`;认不出的键名会报错而不是换成默认键 |
|
||||
| `LC_PY` | 当前解释器 | `levelup.py`/`auto_cycle.py` 调用 MCP 用的 Python |
|
||||
|
||||
|
||||
+156
@@ -8,6 +8,25 @@
|
||||
|
||||
---
|
||||
|
||||
## 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` 用旧路径加载模板:
|
||||
@@ -42,6 +61,19 @@ fusion_result 0
|
||||
|
||||
**风险**:低。纯路径/清单;不改判定逻辑。
|
||||
|
||||
**状态(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 镜牢走位被配置降级成「只按 ↑」
|
||||
@@ -65,6 +97,20 @@ Dijkstra 那套(`search_road.py:735`,代价 event 1 / shop 2 / battle 4 / bo
|
||||
|
||||
**风险**:中。`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 饰品三选一加「体系优先」
|
||||
@@ -84,6 +130,30 @@ Dijkstra 那套(`search_road.py:735`,代价 event 1 / shop 2 / battle 4 / bo
|
||||
|
||||
**风险**:中。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 事件选项策略可配
|
||||
@@ -103,6 +173,44 @@ Dijkstra 那套(`search_road.py:735`,代价 event 1 / shop 2 / battle 4 / bo
|
||||
|
||||
**风险**:低-中。选项点错可能拿不到奖励,但不会卡死。
|
||||
|
||||
**状态(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 选队补丁的鲁棒性
|
||||
@@ -125,6 +233,21 @@ Dijkstra 那套(`search_road.py:735`,代价 event 1 / shop 2 / battle 4 / bo
|
||||
|
||||
**风险**:低。只是匹配变宽,需保证「唯一命中」才点,避免选错队。
|
||||
|
||||
**状态(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 商店必买清单本地化
|
||||
@@ -137,6 +260,25 @@ Dijkstra 那套(`search_road.py:735`,代价 event 1 / shop 2 / battle 4 / bo
|
||||
|
||||
**涉及**:`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 观测饰品按体系自动勾选
|
||||
@@ -149,6 +291,8 @@ Dijkstra 那套(`search_road.py:735`,代价 event 1 / shop 2 / battle 4 / bo
|
||||
|
||||
**涉及**:`lc_mcp/aalc_task.py`(apply_overrides 类似机制)、`app/observe_ego_gift_selection.py` 的序列化格式(只读参考)。
|
||||
|
||||
**状态(2026-11-14)**:不做。用户确认观测饰品不需要自动勾选。
|
||||
|
||||
---
|
||||
|
||||
## P2-8 决策审计日志
|
||||
@@ -161,6 +305,18 @@ Dijkstra 那套(`search_road.py:735`,代价 event 1 / shop 2 / battle 4 / bo
|
||||
|
||||
**涉及**:`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`。
|
||||
|
||||
---
|
||||
|
||||
## 已知但暂不做的
|
||||
|
||||
@@ -39,10 +39,10 @@ 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 后清洗,不排序
|
||||
_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, name) / _wait_header(auto, name) # 顶栏确认(3 次 × 1.2s)
|
||||
_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
|
||||
```
|
||||
@@ -71,7 +71,7 @@ if task in ('mirror', 'all'):
|
||||
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 中心;同名文本会互相覆盖,**因此 `_team_ocr` 改成返回列表**,别再退回 dict。
|
||||
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. **点完必须验顶栏**:只点不验会出现「日志说成功,其实没换队」。
|
||||
|
||||
@@ -98,7 +98,8 @@ if task in ('mirror', 'all'):
|
||||
|
||||
> `#1`~`#12` 已不存在。任何按 `编队#N` 找队的逻辑在这个号上都会失败,这是本次问题的根。
|
||||
>
|
||||
> 队名改动后必须同步 `SYSTEM_TEAM_NAMES`;补丁只做**精确匹配**(`text == name`),不做子串。
|
||||
> 队名改动后最好同步 `SYSTEM_TEAM_NAMES`。2026-11-14 起(BACKLOG P1-5)名字先归一(空白/全半角/`震颐`→`震颤` 等误读),
|
||||
> 精确匹配优先;没有精确匹配时接受这一屏**唯一**的「名字+后缀」(`流血队`),不做任意子串。顶栏确认仍只认精确。
|
||||
|
||||
---
|
||||
|
||||
|
||||
+875
-35
@@ -12,12 +12,17 @@
|
||||
一次, 之后全部模板匹配分数掉到阈值以下, 表现为原地空转、不报错。这里在后台定期
|
||||
检查客户区尺寸, 偏离 set_win_size 时调回去。
|
||||
"""
|
||||
import json
|
||||
import logging
|
||||
import os
|
||||
import re
|
||||
import threading
|
||||
import time
|
||||
import unicodedata
|
||||
from contextlib import contextmanager
|
||||
|
||||
from .decisions import decisions
|
||||
|
||||
TEAM_TARGET = re.compile(r'(?:TEAMS|TFAMS|编队)#(\d+)', re.IGNORECASE)
|
||||
|
||||
|
||||
@@ -477,18 +482,16 @@ TEAM_HEADER = (170, 520, 90, 150)
|
||||
|
||||
|
||||
def _team_ocr(auto):
|
||||
"""整屏 OCR, 返回 [(文本, x, y), ...]。用列表而不是 dict: 同名条目(列表里的队名和顶栏队名)
|
||||
落在不同位置, dict 会把它们覆盖成一条。不用 my_crop: 裁剪区的坐标系不可靠。"""
|
||||
ocr = auto._run_ocr_for_text(my_crop=None)
|
||||
"""整屏 OCR, 返回 [(去空白的文本, x, y), ...], 空串丢掉。
|
||||
|
||||
读 OCR 引擎的逐行结果(_ocr_lines): 选中某队后顶栏和左侧列表里是同一个名字, AALC 的
|
||||
_run_ocr_for_text 返回 {文本: 坐标}, 同名只留一条, 顶栏那条可能被列表那条盖掉。
|
||||
不用 my_crop: 裁剪区的坐标系不可靠。
|
||||
"""
|
||||
result = []
|
||||
for text, pos in (ocr or {}).items():
|
||||
for text, x, y in _ocr_lines(auto):
|
||||
clean = str(text).replace(' ', '').strip()
|
||||
if not clean:
|
||||
continue
|
||||
try:
|
||||
x, y = float(pos[0]), float(pos[1])
|
||||
except (TypeError, IndexError, ValueError):
|
||||
continue
|
||||
if clean:
|
||||
result.append((clean, x, y))
|
||||
return result
|
||||
|
||||
@@ -509,58 +512,124 @@ def _scroll_team_list(auto, direction, times=6, distance=250):
|
||||
time.sleep(0.35)
|
||||
|
||||
|
||||
def _header_is(auto, name):
|
||||
"""顶栏当前队伍名就是 name。"""
|
||||
# OCR 实测误读(2026-11-14): 震颤→震颐, 沉沦→沉论, 编队#16→编#16。归一化时按子串改回来。
|
||||
TEAM_OCR_FIXES = (('震颐', '震颤'), ('沉论', '沉沦'), ('编#', '编队#'))
|
||||
TEAM_PREFIX_MIN = 2 # 前缀匹配的队名至少两个字, 免得单字名把一片都吃进来
|
||||
|
||||
|
||||
def normalize_team_name(text):
|
||||
"""去空白、全角转半角(NFKC: #→#、()→()、全角空格)、改回常见误读。"""
|
||||
text = ''.join(unicodedata.normalize('NFKC', str(text)).split())
|
||||
for wrong, right in TEAM_OCR_FIXES:
|
||||
text = text.replace(wrong, right)
|
||||
return text
|
||||
|
||||
|
||||
def team_name_match(text, names):
|
||||
"""'exact' = 归一后等于某个名字; 'prefix' = 某个名字后面带了后缀(流血队、流血(X)); 否则 None。"""
|
||||
text = normalize_team_name(text)
|
||||
wanted = [normalize_team_name(name) for name in names]
|
||||
if text in wanted:
|
||||
return 'exact'
|
||||
if any(len(name) >= TEAM_PREFIX_MIN and text.startswith(name) for name in wanted):
|
||||
return 'prefix'
|
||||
return None
|
||||
|
||||
|
||||
def pick_team_item(items, names):
|
||||
"""从列表条目 [(文本, x, y)] 里挑要点的那条, 返回 (条目, 理由) 或 (None, 理由)。
|
||||
|
||||
精确匹配优先, 多个名字时按 names 的顺序; 没有精确匹配才看前缀, 且这一屏只能有一条,
|
||||
两条以上宁可不点(点错队比没选上更糟: 后面整局都用错的队)。
|
||||
"""
|
||||
for name in names:
|
||||
for item in items:
|
||||
if team_name_match(item[0], (name,)) == 'exact':
|
||||
return item, '精确匹配 %s' % name
|
||||
prefixed = {}
|
||||
for item in items:
|
||||
if team_name_match(item[0], names) == 'prefix':
|
||||
prefixed.setdefault(normalize_team_name(item[0]), item)
|
||||
if len(prefixed) == 1:
|
||||
return next(iter(prefixed.values())), '前缀匹配 %s' % '/'.join(names)
|
||||
if prefixed:
|
||||
return None, '前缀匹配到多条(%s), 不点' % '/'.join(sorted(prefixed))
|
||||
return None, ''
|
||||
|
||||
|
||||
def _list_names(items):
|
||||
"""这一屏列表里的名字, 从上到下(失败日志用)。"""
|
||||
return [normalize_team_name(text) for text, x, y in sorted(items, key=lambda item: item[2])]
|
||||
|
||||
|
||||
def _header_texts(auto):
|
||||
"""顶栏区域读到的文字; 截图失败返回 None。"""
|
||||
if auto.take_screenshot() is None:
|
||||
return False
|
||||
return any(text == name and _in_header(x, y) for text, x, y in _team_ocr(auto))
|
||||
return None
|
||||
return [text for text, x, y in _team_ocr(auto) if _in_header(x, y)]
|
||||
|
||||
|
||||
def _wait_header(auto, name, tries=3, delay=1.2):
|
||||
def _header_is(auto, names):
|
||||
"""顶栏当前队伍名(归一后)恰好是 names 之一。只认精确: 顶栏是 "流血2" 时不能当成 "流血"。"""
|
||||
return any(team_name_match(text, names) == 'exact' for text in _header_texts(auto) or ())
|
||||
|
||||
|
||||
def _wait_header(auto, names, tries=3, delay=1.2):
|
||||
"""点完之后顶栏要过一两帧才刷新, 多等几次。"""
|
||||
for _ in range(tries):
|
||||
time.sleep(delay)
|
||||
if _header_is(auto, name):
|
||||
if _header_is(auto, names):
|
||||
return True
|
||||
return False
|
||||
|
||||
|
||||
def _select_team_by_name(auto, names, log=print, rounds=4):
|
||||
"""在编队列表里按名字点选。成功返回 True, 没找到返回 False。"""
|
||||
"""在编队列表里按名字点选。成功返回 True, 没找到返回 False。
|
||||
|
||||
名字先归一化(空白/全半角/常见误读); 精确匹配优先, 否则接受唯一的"名字+后缀"。
|
||||
没找到时把每一屏看到的名字打进日志。
|
||||
"""
|
||||
if auto.take_screenshot() is None:
|
||||
return False
|
||||
if not auto.find_element('teams/identify_assets.png'):
|
||||
log('[lc_mcp] 不在编队界面, 跳过按名字选队')
|
||||
return False
|
||||
for name in names: # 已经是这支队就不用动列表
|
||||
if _header_is(auto, name):
|
||||
log('[lc_mcp] patch: 当前已经是编队 %s, 无需切换' % name)
|
||||
current = [normalize_team_name(t) for t in _header_texts(auto) or ()
|
||||
if team_name_match(t, names) == 'exact']
|
||||
if current: # 已经是这支队就不用动列表; 带后缀的队名要回列表里确认唯一后再点
|
||||
log('[lc_mcp] patch: 当前已经是编队 %s, 无需切换' % current[0])
|
||||
decisions.record('team', current[0], 'current', wanted=list(names))
|
||||
return True
|
||||
seen = []
|
||||
auto.mouse_click(1, 1)
|
||||
time.sleep(0.3)
|
||||
_scroll_team_list(auto, +1) # 先回到顶部
|
||||
for round_index in range(rounds):
|
||||
for round_index in range(1, rounds + 1):
|
||||
if auto.take_screenshot() is None:
|
||||
log('[lc_mcp] 第 %d 屏截图失败' % round_index)
|
||||
continue
|
||||
items = _team_ocr(auto)
|
||||
hit = None
|
||||
for name in names:
|
||||
for text, x, y in items:
|
||||
if text == name and _in_list(x, y):
|
||||
hit = (name, x, y)
|
||||
break
|
||||
items = [item for item in _team_ocr(auto) if _in_list(item[1], item[2])]
|
||||
seen.append(_list_names(items))
|
||||
hit, reason = pick_team_item(items, names)
|
||||
if hit:
|
||||
break
|
||||
if hit:
|
||||
name, x, y = hit
|
||||
log('[lc_mcp] 编队列表里找到 %s @(%d,%d)' % (name, x, y))
|
||||
text, x, y = hit
|
||||
label = normalize_team_name(text)
|
||||
log('[lc_mcp] 编队列表里找到 %s @(%d,%d), %s' % (label, x, y, reason))
|
||||
auto.mouse_action_with_pos([x, y], offset=False)
|
||||
if _wait_header(auto, name):
|
||||
log('[lc_mcp] patch: 已按体系名选中编队 %s' % name)
|
||||
if _wait_header(auto, (label,)):
|
||||
log('[lc_mcp] patch: 已按体系名选中编队 %s' % label)
|
||||
decisions.record('team', label, team_name_match(label, names), wanted=list(names))
|
||||
return True
|
||||
log('[lc_mcp] 点了 %s 但顶栏没变, 继续往下翻' % name)
|
||||
header = [normalize_team_name(t) for t in _header_texts(auto) or ()]
|
||||
log('[lc_mcp] 点了 %s 但顶栏没变(顶栏读到: %s), 继续往下翻' % (label, '/'.join(header) or '无'))
|
||||
decisions.record('team', label, 'header_unchanged', wanted=list(names), header=header)
|
||||
else:
|
||||
log('[lc_mcp] 第 %d 屏没有 %s%s; 这一屏的名字: %s'
|
||||
% (round_index, '/'.join(names), ', ' + reason if reason else '',
|
||||
'/'.join(_list_names(items)) or '(空)'))
|
||||
_scroll_team_list(auto, -1, times=3)
|
||||
log('[lc_mcp] 编队列表里没找到 %s(共 %d 轮)' % ('/'.join(names), rounds))
|
||||
decisions.record('team', None, 'not_found', wanted=list(names), seen=seen)
|
||||
return False
|
||||
|
||||
|
||||
@@ -603,3 +672,774 @@ def install_system_team_selection(log=print):
|
||||
mirror_mod.select_battle_team = select_battle_team
|
||||
log('[lc_mcp] patch: 镜牢按体系名选队')
|
||||
return original
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- 镜牢键盘寻路按节点类型
|
||||
|
||||
# config.yaml 开着 mirror_keyboard_simple_pathfinding 时, AALC 每一步只按 ↑ 进最上面的节点,
|
||||
# 完全不看节点类型(2026-11-14: 3 层只进过 1 次商店)。关掉它会走常规寻路, 那条路先用
|
||||
# mouse_drag 把地图拖到固定位置(当初开简单模式就是为了躲拖地图卡死), 连线识别还依赖
|
||||
# my_crop(交接文档实测在这台机器上坐标对不上)。
|
||||
# 这里保持"只按键、不拖地图": 用 AALC 自带的 ONNX 模型整屏识别巴士右侧下一列节点的类型,
|
||||
# 按上游 all_node_weight 从低到高依次按方向键, 每次都确认进得去; 都不行再退回原来的 ↑。
|
||||
ROAD_KEYS = {'U': 'up', 'M': 'right', 'D': 'down'} # 与上游 MirrorMap.enter_next_node 一致
|
||||
ROAD_TIE_ORDER = ('U', 'M', 'D') # 同类型时先试 ↑, 尽量贴近原简单模式
|
||||
UPSTREAM_ROAD_COLUMN_GAP = 520 # 上游 search_road 的网格参数(2560x1440 标定)
|
||||
UPSTREAM_ROAD_ROW_GAP = 437
|
||||
UPSTREAM_NODE_WEIGHT = {
|
||||
'battle': 4, 'boss_battle': 6, 'event': 1, 'focused_encounter': 6,
|
||||
'risky_encounter': 7, 'shop': 2, 'abnormality_focused_encounter': 6,
|
||||
}
|
||||
TYPED_ROAD_ENV = 'LCP_TYPED_ROAD' # 设为 0 时不装这个补丁, 完全回到原简单键盘寻路
|
||||
|
||||
|
||||
def rank_next_nodes(bus, nodes, scale, weights=UPSTREAM_NODE_WEIGHT,
|
||||
column_gap=UPSTREAM_ROAD_COLUMN_GAP, row_gap=UPSTREAM_ROAD_ROW_GAP):
|
||||
"""巴士右侧下一列的节点 -> [(方向, 类型, 权重), ...], 权重小的在前。
|
||||
|
||||
nodes 是 identify_nodes() 的输出 [[类型, (x, y)], ...]; 只取与巴士相隔一列的节点,
|
||||
按相对巴士的行差映射成 U/M/D。同一方向识别出多个时保留权重最小的那个。
|
||||
"""
|
||||
if not bus or not nodes:
|
||||
return []
|
||||
gap_x, gap_y = column_gap * scale, row_gap * scale
|
||||
best = {}
|
||||
for kind, (x, y) in nodes:
|
||||
if abs((x - bus[0]) - gap_x) > gap_x / 4:
|
||||
continue
|
||||
direction = {1: 'U', 0: 'M', -1: 'D'}.get(round((bus[1] - y) / gap_y))
|
||||
if direction is None:
|
||||
continue
|
||||
weight = weights.get(kind)
|
||||
if weight is None:
|
||||
continue
|
||||
if direction not in best or weight < best[direction][1]:
|
||||
best[direction] = (kind, weight)
|
||||
return sorted(((d, kind, w) for d, (kind, w) in best.items()),
|
||||
key=lambda item: (item[2], ROAD_TIE_ORDER.index(item[0])))
|
||||
|
||||
|
||||
def install_typed_keyboard_road(log=print, env=None):
|
||||
"""替换简单键盘寻路: 按节点类型挑方向, 失败时退回原 ↑ 逻辑。返回原函数, 未安装返回 None。"""
|
||||
env = os.environ if env is None else env
|
||||
if env.get(TYPED_ROAD_ENV) == '0':
|
||||
log('[lc_mcp] 键盘寻路按类型补丁已关闭(%s=0), 沿用原简单键盘寻路' % TYPED_ROAD_ENV)
|
||||
return None
|
||||
try:
|
||||
from tasks.mirror import mirror as mirror_mod
|
||||
from tasks.mirror import search_road as road
|
||||
from module.automation import auto
|
||||
from module.config import cfg
|
||||
except Exception as e:
|
||||
log('[lc_mcp] 键盘寻路按类型补丁跳过: 无法导入 %s' % e)
|
||||
return None
|
||||
original = getattr(road, 'search_road_simple_keyboard', None)
|
||||
if original is None or not hasattr(road, 'identify_nodes'):
|
||||
log('[lc_mcp] 键盘寻路按类型补丁跳过: 上游没有简单键盘寻路或节点识别')
|
||||
return None
|
||||
weights = getattr(road, 'all_node_weight', UPSTREAM_NODE_WEIGHT)
|
||||
column_gap = getattr(road, 'ROAD_COLUMN_GAP', UPSTREAM_ROAD_COLUMN_GAP)
|
||||
row_gap = getattr(road, 'ROAD_ROW_GAP', UPSTREAM_ROAD_ROW_GAP)
|
||||
|
||||
def search_road_simple_keyboard():
|
||||
if not cfg.mirror_keyboard_navigation:
|
||||
return original() # 上游会说明需要开启键盘寻路
|
||||
try:
|
||||
auto.mouse_to_blank()
|
||||
time.sleep(0.3)
|
||||
bus = auto.find_element('mirror/mybus_default_distance.png', take_screenshot=True)
|
||||
nodes = road.identify_nodes(bus[0]) if bus else None
|
||||
ranked = rank_next_nodes(bus, nodes, cfg.set_win_size / 1440, weights, column_gap, row_gap)
|
||||
except Exception as e:
|
||||
log('[lc_mcp] 键盘寻路: 识别下一列节点出错(%s: %s), 退回按 ↑' % (type(e).__name__, e))
|
||||
decisions.record('road', 'up', 'fallback', why='%s: %s' % (type(e).__name__, e))
|
||||
return original()
|
||||
if not ranked:
|
||||
why = '没找到巴士' if not bus else '下一列没识别到节点'
|
||||
log('[lc_mcp] 键盘寻路: %s, 退回按 ↑' % why)
|
||||
decisions.record('road', 'up', 'fallback', why=why)
|
||||
return original()
|
||||
candidates = ['%s=%s(%d)' % item for item in ranked]
|
||||
log('[lc_mcp] 键盘寻路: 下一列 %s, 按权重从低到高依次尝试' % ' '.join(candidates))
|
||||
for direction, kind, weight in ranked:
|
||||
auto.key_press(ROAD_KEYS[direction])
|
||||
time.sleep(1)
|
||||
if road._keyboard_enter_succeeded():
|
||||
best = direction == ranked[0][0]
|
||||
reason = '下一列中最低' if best else '更优的方向没能进入'
|
||||
log('[lc_mcp] 键盘寻路: 进入 %s 方向的 %s(权重 %d, %s)' % (direction, kind, weight, reason))
|
||||
decisions.record('road', '%s:%s' % (direction, kind), 'lowest' if best else 'next_best',
|
||||
candidates=candidates)
|
||||
return True
|
||||
log('[lc_mcp] 键盘寻路: %s 方向的 %s 没能进入, 试下一个' % (direction, kind))
|
||||
log('[lc_mcp] 键盘寻路: 按类型都没进入, 退回按 ↑')
|
||||
decisions.record('road', 'up', 'fallback', why='按类型都没进入', candidates=candidates)
|
||||
return original()
|
||||
|
||||
road.search_road_simple_keyboard = search_road_simple_keyboard
|
||||
mirror_mod.search_road_simple_keyboard = search_road_simple_keyboard
|
||||
log('[lc_mcp] patch: 镜牢键盘寻路按节点类型选方向(不拖地图)')
|
||||
return original
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- 临时替换 auto 的方法
|
||||
|
||||
_MISSING = object()
|
||||
|
||||
|
||||
@contextmanager
|
||||
def _override(obj, name, value):
|
||||
"""在 with 期间把 obj.name 换成 value(实例属性), 结束时还原成原来的实例属性或类方法。"""
|
||||
own = vars(obj).get(name, _MISSING)
|
||||
setattr(obj, name, value)
|
||||
try:
|
||||
yield
|
||||
finally:
|
||||
if own is _MISSING:
|
||||
vars(obj).pop(name, None)
|
||||
else:
|
||||
setattr(obj, name, own)
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- 饰品选择按体系关键词
|
||||
|
||||
# 2026-11-14 核对: acquire_ego_gift() 两张卡时只看白棉花和已持有, 拿第一张; 三张卡时虽然用
|
||||
# acquire_ego_gift/<体系>.png 做图标匹配(阈值 0.85), 但日志里从没见它起作用。这里在上游挑选之前,
|
||||
# 按卡面 OCR 文本里的体系关键词把卡重新排序; 白棉花、已持有、体系图标仍由上游处理(排序稳定)。
|
||||
GIFT_KEYWORDS_ENV = 'LCP_GIFT_KEYWORDS' # 0 = 关闭; 文件路径 = 用这张表代替默认表
|
||||
GIFT_KEYWORDS_FILE = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'data', 'gift_keywords.json')
|
||||
GIFT_CARD = 'mirror/road_in_mir/acquire_ego_gift_card.png'
|
||||
GIFT_ICON = 'mirror/road_in_mir/acquire_ego_gift/%s.png' # 上游三张卡时按体系图标挑卡用的模板
|
||||
GIFT_CARD_BOX = (-50, -300, 450, 350) # 上游判断白棉花/已持有时每张卡的范围(相对卡片匹配点, 1440 标定)
|
||||
|
||||
|
||||
def load_gift_keywords(path=GIFT_KEYWORDS_FILE):
|
||||
"""读关键词表 {体系: (关键词, ...)}; 以 _ 开头的键是说明。格式不对抛 ValueError。"""
|
||||
with open(path, encoding='utf-8') as f:
|
||||
raw = json.load(f)
|
||||
if not isinstance(raw, dict):
|
||||
raise ValueError('顶层应是 {体系: [关键词]}')
|
||||
table = {}
|
||||
for system, words in raw.items():
|
||||
if str(system).startswith('_'):
|
||||
continue
|
||||
if not isinstance(words, list) or not all(isinstance(w, str) for w in words):
|
||||
raise ValueError('%s 的值应是字符串列表' % system)
|
||||
table[str(system)] = tuple(w for w in words if normalize_team_name(w))
|
||||
return table
|
||||
|
||||
|
||||
def _dict_ocr_lines(auto):
|
||||
"""经 AALC 的 _run_ocr_for_text 读整屏: {文本: 坐标}, 同名文本只剩一条。只在 OCR 引擎导入不了时用。"""
|
||||
lines = []
|
||||
for text, pos in (auto._run_ocr_for_text(my_crop=None) or {}).items():
|
||||
try:
|
||||
lines.append((str(text), float(pos[0]), float(pos[1])))
|
||||
except (TypeError, IndexError, ValueError):
|
||||
continue
|
||||
return lines
|
||||
|
||||
|
||||
def _ocr_lines(auto):
|
||||
"""整屏 OCR 的每一行 [(文本, x, y)]。直接用 OCR 引擎(与 _run_ocr_for_text 同一个引擎、同一张截图、
|
||||
同样取框的中心), 不经它的 {文本: 坐标}: 同一句出现在两处(两张卡、顶栏和列表)时 dict 只留一条。"""
|
||||
try:
|
||||
from module.ocr import ocr as engine
|
||||
except Exception:
|
||||
return _dict_ocr_lines(auto)
|
||||
result = engine.run(auto.screenshot)
|
||||
texts, boxes = getattr(result, 'txts', None), getattr(result, 'boxes', None)
|
||||
if texts is None or boxes is None:
|
||||
return []
|
||||
lines = []
|
||||
for text, box in zip(texts, boxes):
|
||||
try:
|
||||
lines.append((str(text), (float(box[0][0]) + float(box[2][0])) / 2,
|
||||
(float(box[0][1]) + float(box[2][1])) / 2))
|
||||
except (TypeError, IndexError, ValueError):
|
||||
continue
|
||||
return lines
|
||||
|
||||
|
||||
def gift_card_hits(cards, lines, keywords, scale):
|
||||
"""每张卡上命中关键词的行: [[关键词, ...], ...], 与 cards 一一对应。
|
||||
|
||||
行按坐标归到卡上(范围与上游一致); 落在两张卡的范围里时归给水平方向更近的那张。
|
||||
"""
|
||||
left, top, right, bottom = (v * scale for v in GIFT_CARD_BOX)
|
||||
boxes = [(float(c[0]) + left, float(c[1]) + top, float(c[0]) + right, float(c[1]) + bottom) for c in cards]
|
||||
words = [(w, normalize_team_name(w).lower()) for w in keywords]
|
||||
hits = [[] for _ in cards]
|
||||
for text, x, y in lines:
|
||||
clean = normalize_team_name(text).lower()
|
||||
found = [w for w, key in words if key and key in clean]
|
||||
if not found:
|
||||
continue
|
||||
inside = [i for i, (x1, y1, x2, y2) in enumerate(boxes) if x1 <= x <= x2 and y1 <= y <= y2]
|
||||
if inside:
|
||||
i = min(inside, key=lambda i: abs(x - (boxes[i][0] + boxes[i][2]) / 2))
|
||||
hits[i].append(found[0])
|
||||
return hits
|
||||
|
||||
|
||||
def gift_card_order(hits):
|
||||
"""卡的下标, 命中行数多的排前面, 一样多保持原顺序。"""
|
||||
return sorted(range(len(hits)), key=lambda i: -len(hits[i]))
|
||||
|
||||
|
||||
def gift_upstream_order(hits):
|
||||
"""交给上游的卡顺序(下标), 使上游拼出来的候选顺序等于 gift_card_order。
|
||||
|
||||
两张卡: 上游按给的顺序挑(只把白棉花/已持有排后), 直接给 gift_card_order。
|
||||
三张及以上: 上游逐张看, 认出体系图标的卡 insert(0)(后看的排到最前), 其余 append。
|
||||
所以先给没命中的卡(原顺序), 再把命中的卡倒着给, 并让上游的图标判断对命中的卡返回"有":
|
||||
拼出来就是 命中多的 → 命中少的 → 只认出图标的 → 其余。
|
||||
"""
|
||||
order = gift_card_order(hits)
|
||||
if len(hits) <= 2:
|
||||
return order
|
||||
keyed = [i for i in order if hits[i]]
|
||||
return [i for i in range(len(hits)) if not hits[i]] + keyed[::-1]
|
||||
|
||||
|
||||
def rank_gift_cards(cards, hits):
|
||||
return [cards[i] for i in gift_card_order(hits)]
|
||||
|
||||
|
||||
def install_gift_preference(log=print, env=None):
|
||||
"""饰品选择(镜牢路上的 N 选一)先按体系关键词给卡排序。返回原方法, 未安装返回 None。"""
|
||||
env = os.environ if env is None else env
|
||||
setting = (env.get(GIFT_KEYWORDS_ENV) or '').strip()
|
||||
if setting == '0':
|
||||
log('[lc_mcp] 饰品体系优先补丁已关闭(%s=0), 沿用 AALC 原逻辑' % GIFT_KEYWORDS_ENV)
|
||||
return None
|
||||
path = setting or GIFT_KEYWORDS_FILE
|
||||
try:
|
||||
table = load_gift_keywords(path)
|
||||
except (OSError, ValueError) as e:
|
||||
log('[ERROR] [lc_mcp] 饰品体系优先补丁跳过: 关键词表 %s 读不了(%s: %s)' % (path, type(e).__name__, e))
|
||||
return None
|
||||
try:
|
||||
from tasks.mirror import mirror as mirror_mod
|
||||
from module.automation import auto
|
||||
from module.config import cfg
|
||||
except Exception as e:
|
||||
log('[lc_mcp] 饰品体系优先补丁跳过: 无法导入 %s' % e)
|
||||
return None
|
||||
original = getattr(getattr(mirror_mod, 'Mirror', None), 'acquire_ego_gift', None)
|
||||
if original is None:
|
||||
log('[lc_mcp] 饰品体系优先补丁跳过: 上游没有 Mirror.acquire_ego_gift')
|
||||
return None
|
||||
if _source_calls(original, 'find_element', GIFT_CARD) is False:
|
||||
log('[ERROR] [lc_mcp] 饰品体系优先补丁跳过: 上游 Mirror.acquire_ego_gift 不再调用 find_element(%r), 挂不上'
|
||||
% GIFT_CARD)
|
||||
return None
|
||||
|
||||
def prefer(cards, system, keywords):
|
||||
"""返回 (交给上游的卡顺序, 要当作认出体系图标的卡的范围左上角)。"""
|
||||
scale = cfg.set_win_size / 1440
|
||||
hits = gift_card_hits(cards, _ocr_lines(auto), keywords, scale)
|
||||
order = gift_card_order(hits)
|
||||
by_x = sorted(range(len(cards)), key=lambda i: float(cards[i][0])) # 日志按从左到右编号
|
||||
detail = ' '.join('第%d张=%d%s' % (n + 1, len(hits[i]), '(%s)' % '/'.join(hits[i]) if hits[i] else '')
|
||||
for n, i in enumerate(by_x))
|
||||
first = by_x.index(order[0]) + 1
|
||||
if any(hits):
|
||||
log('[lc_mcp] 饰品选择(体系 %s): %s; 命中体系关键词, 先看第%d张' % (system, detail, first))
|
||||
else:
|
||||
log('[lc_mcp] 饰品选择(体系 %s): %s; 未命中体系关键词, 保持原顺序' % (system, detail))
|
||||
# 上游随后还会跳过白棉花、把已持有排后, 这里记的是交给上游的第一顺位
|
||||
decisions.record('gift', first, 'keyword' if any(hits) else 'no_keyword', system=system,
|
||||
hits=[hits[i] for i in by_x])
|
||||
keyed = []
|
||||
if len(cards) > 2:
|
||||
left, top = GIFT_CARD_BOX[0] * scale, GIFT_CARD_BOX[1] * scale
|
||||
keyed = [(float(cards[i][0]) + left, float(cards[i][1]) + top) for i in order if hits[i]]
|
||||
return [cards[i] for i in gift_upstream_order(hits)], keyed
|
||||
|
||||
def acquire_ego_gift(self, *args, **kwargs):
|
||||
system = getattr(self, 'system', '')
|
||||
keywords = table.get(system, ())
|
||||
if kwargs.get('type', args[0] if args else 1) != 1 or not keywords: # type=2 是"拒绝饰品"界面
|
||||
return original(self, *args, **kwargs)
|
||||
real = auto.find_element
|
||||
icon = GIFT_ICON % system
|
||||
keyed = [] # 这一屏命中关键词的卡(上游 bbox 的左上角); 上游查体系图标时对它们答"有"
|
||||
|
||||
def is_keyed(crop):
|
||||
try:
|
||||
x, y = float(crop[0]), float(crop[1])
|
||||
except (TypeError, IndexError, ValueError):
|
||||
return False
|
||||
return any(abs(x - kx) < 1 and abs(y - ky) < 1 for kx, ky in keyed)
|
||||
|
||||
def find_element(target, *a, **kw):
|
||||
if target == icon and keyed and is_keyed(kw.get('my_crop')):
|
||||
crop = kw['my_crop']
|
||||
return ((float(crop[0]) + float(crop[2])) / 2, (float(crop[1]) + float(crop[3])) / 2)
|
||||
found = real(target, *a, **kw)
|
||||
find_type = kw.get('find_type', a[0] if a else 'image')
|
||||
if target == GIFT_CARD and find_type == 'image_with_multiple_targets':
|
||||
keyed.clear()
|
||||
if found and len(found) > 1:
|
||||
try:
|
||||
ordered, keyed[:] = prefer(list(found), system, keywords)
|
||||
return ordered
|
||||
except Exception as e:
|
||||
keyed.clear()
|
||||
log('[lc_mcp] 饰品选择: 关键词排序出错(%s: %s), 沿用原顺序' % (type(e).__name__, e))
|
||||
return found
|
||||
|
||||
with _override(auto, 'find_element', find_element):
|
||||
return original(self, *args, **kwargs)
|
||||
|
||||
acquire_ego_gift.__wrapped__ = original # 让后装的补丁查得到上游源码
|
||||
mirror_mod.Mirror.acquire_ego_gift = acquire_ego_gift
|
||||
log('[lc_mcp] patch: 镜牢饰品选择按体系关键词排序(%s)' % os.path.basename(path))
|
||||
return original
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- 事件选项表
|
||||
|
||||
# 2026-11-14 核对: Mirror.event_handling() 不认事件, 有 "???"/直接拿饰品/优势判定就选它, 否则点第一个选项。
|
||||
# 这里在上游每轮挑选项之前(它先 find_element("event/unknown_event.png"))插一步: 画面上有选项时整屏 OCR,
|
||||
# 选项文字对上表里某个事件就点表里那一项; 对不上交给上游原逻辑。
|
||||
# 零协汉化的事件数据没有标题字段, 画面上也不保证有事件名, 所以按同一屏其它选项的原文认事件。
|
||||
EVENT_CHOICES_ENV = 'LCP_EVENT_CHOICES' # 0 = 关闭; 文件路径 = 用这张表代替默认表
|
||||
EVENT_CHOICES_FILE = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'data', 'event_choices.json')
|
||||
EVENT_OPTION = 'event/select_first_option_assets.png' # 每个选项框的左边缘, 多目标匹配得到每一项
|
||||
EVENT_HOOK = 'event/unknown_event.png' # 上游每轮挑选项的第一步
|
||||
EVENT_OPTION_ROW = 60 # 选项文字与选项框左边缘的最大纵向距离(1440 标定; 选项框高约 107)
|
||||
EVENT_OPTION_LEFT = 20 # 选项文字至多比左边缘再靠左这么多
|
||||
EVENT_TEXT_CLICKS = 5 # 一次事件里按表最多点几次(点了没反应时不死循环)
|
||||
|
||||
|
||||
def normalize_event_text(text):
|
||||
"""选项文字归一: 与队名相同的归一, 再去掉标点(OCR 常漏句号, 全角半角也不一)。"""
|
||||
return ''.join(ch for ch in normalize_team_name(text) if not unicodedata.category(ch).startswith('P'))
|
||||
|
||||
|
||||
def _upstream_source(func):
|
||||
"""上游函数的源码; 先顺着 __wrapped__ 剥掉本模块包的几层。拿不到返回 None。"""
|
||||
import inspect
|
||||
try:
|
||||
return inspect.getsource(inspect.unwrap(func))
|
||||
except (OSError, TypeError, ValueError):
|
||||
return None
|
||||
|
||||
|
||||
def _source_calls(func, method, target):
|
||||
"""上游函数源码里有没有 auto.<method>("<target>" 这样的调用; 拿不到源码返回 None。
|
||||
|
||||
补丁靠拦截这类调用挂进上游流程, 上游改了写法就挂不上; 安装时查一下, 免得悄悄失效。
|
||||
"""
|
||||
source = _upstream_source(func)
|
||||
if source is None:
|
||||
return None
|
||||
return re.search(r'\.%s\(\s*["\']%s["\']' % (re.escape(method), re.escape(target)), source) is not None
|
||||
|
||||
|
||||
def _source_mentions(func, *needles):
|
||||
"""上游函数源码里是否都有这些片段; 拿不到源码返回 None。"""
|
||||
source = _upstream_source(func)
|
||||
return None if source is None else all(needle in source for needle in needles)
|
||||
|
||||
|
||||
def load_event_choices(path=EVENT_CHOICES_FILE):
|
||||
"""读事件表, 返回 [{'name', 'id', 'options', 'text'}]; 格式不对抛 ValueError。
|
||||
|
||||
options 是同一屏其它选项的原文, 全部出现在画面上才认定是这个事件; text 是要点的那一项。
|
||||
"""
|
||||
with open(path, encoding='utf-8') as f:
|
||||
raw = json.load(f)
|
||||
events = raw.get('events') if isinstance(raw, dict) else None
|
||||
if not isinstance(events, list):
|
||||
raise ValueError('顶层应是 {"events": [...]}')
|
||||
rules = []
|
||||
for item in events:
|
||||
if not isinstance(item, dict):
|
||||
raise ValueError('events 的每一项应是对象')
|
||||
name = str(item.get('name') or '?')
|
||||
text, others = item.get('text'), item.get('options')
|
||||
if not isinstance(text, str) or not normalize_event_text(text):
|
||||
raise ValueError('%s 的 text 应是非空字符串(要点的选项原文)' % name)
|
||||
if not isinstance(others, list) or not others or \
|
||||
not all(isinstance(w, str) and normalize_event_text(w) for w in others):
|
||||
raise ValueError('%s 的 options 应是非空字符串列表(同一屏其它选项的原文)' % name)
|
||||
rule = {'name': name, 'id': item.get('id'), 'text': normalize_event_text(text),
|
||||
'options': tuple(normalize_event_text(w) for w in others)}
|
||||
if any(w in rule['text'] or rule['text'] in w for w in rule['options']):
|
||||
raise ValueError('%s 的 options 与 text 互相包含, 认不出是哪一项' % name)
|
||||
rules.append(rule)
|
||||
return rules
|
||||
|
||||
|
||||
def event_options(markers, lines, scale):
|
||||
"""选项框左边缘(从上到下)与各自的文字: [(位置, 归一后的文字), ...]。"""
|
||||
markers = sorted(markers, key=lambda m: float(m[1]))
|
||||
texts = [[] for _ in markers]
|
||||
for text, x, y in lines:
|
||||
rows = [i for i, m in enumerate(markers)
|
||||
if x >= float(m[0]) - EVENT_OPTION_LEFT * scale and abs(y - float(m[1])) <= EVENT_OPTION_ROW * scale]
|
||||
if rows:
|
||||
texts[min(rows, key=lambda i: abs(y - float(markers[i][1])))].append(normalize_event_text(text))
|
||||
return [(m, ''.join(t)) for m, t in zip(markers, texts)]
|
||||
|
||||
|
||||
def choose_event_option(rules, texts):
|
||||
"""按画面上的选项认事件: 返回 (规则, 要点第几项(0 起))。
|
||||
|
||||
没认出返回 (None, None); 认出了但要点的那项没读到返回 (规则, None)。
|
||||
"""
|
||||
for rule in rules:
|
||||
if all(any(word in text for text in texts) for word in rule['options']):
|
||||
return rule, next((i for i, text in enumerate(texts) if rule['text'] in text), None)
|
||||
return None, None
|
||||
|
||||
|
||||
def install_event_choices(log=print, env=None):
|
||||
"""镜牢事件按表选项。返回原 Mirror.event_handling, 未安装返回 None。"""
|
||||
env = os.environ if env is None else env
|
||||
setting = (env.get(EVENT_CHOICES_ENV) or '').strip()
|
||||
if setting == '0':
|
||||
log('[lc_mcp] 事件选项表已关闭(%s=0), 沿用 AALC 原逻辑' % EVENT_CHOICES_ENV)
|
||||
return None
|
||||
path = setting or EVENT_CHOICES_FILE
|
||||
try:
|
||||
rules = load_event_choices(path)
|
||||
except (OSError, ValueError) as e:
|
||||
log('[ERROR] [lc_mcp] 事件选项表补丁跳过: %s 读不了(%s: %s)' % (path, type(e).__name__, e))
|
||||
return None
|
||||
try:
|
||||
from tasks.mirror import mirror as mirror_mod
|
||||
from module.automation import auto
|
||||
from module.config import cfg
|
||||
except Exception as e:
|
||||
log('[lc_mcp] 事件选项表补丁跳过: 无法导入 %s' % e)
|
||||
return None
|
||||
original = getattr(getattr(mirror_mod, 'Mirror', None), 'event_handling', None)
|
||||
if original is None:
|
||||
log('[lc_mcp] 事件选项表补丁跳过: 上游没有 Mirror.event_handling')
|
||||
return None
|
||||
if _source_calls(original, 'find_element', EVENT_HOOK) is False:
|
||||
log('[ERROR] [lc_mcp] 事件选项表补丁跳过: 上游 Mirror.event_handling 不再调用 find_element(%r), 挂不上'
|
||||
% EVENT_HOOK)
|
||||
return None
|
||||
|
||||
def decide(state):
|
||||
"""按表点了一个选项返回点的位置; 其余情况返回 None 交给上游。"""
|
||||
markers = auto.find_element(EVENT_OPTION, find_type='image_with_multiple_targets', threshold=0.75)
|
||||
if not markers:
|
||||
return None
|
||||
options = event_options(markers, _ocr_lines(auto), cfg.set_win_size / 1440)
|
||||
texts = tuple(text for _, text in options)
|
||||
shown = ' | '.join('%d=%s' % (i + 1, text or '?') for i, text in enumerate(texts))
|
||||
|
||||
def once(message):
|
||||
if (texts, message) in state['logged']:
|
||||
return False
|
||||
state['logged'].add((texts, message))
|
||||
log(message)
|
||||
return True
|
||||
|
||||
rule, i = choose_event_option(rules, texts)
|
||||
if rule is None:
|
||||
if once('[lc_mcp] 事件选项: %s; 表里没有这个事件, 交给 AALC' % shown):
|
||||
decisions.record('event', None, 'not_in_table', options=list(texts))
|
||||
return None
|
||||
why = None
|
||||
if i is None:
|
||||
why = '表里要点的「%s」没读到' % rule['text']
|
||||
elif state['clicks'] >= EVENT_TEXT_CLICKS:
|
||||
why = '这次事件已按表点了 %d 次' % EVENT_TEXT_CLICKS
|
||||
if why:
|
||||
if once('[lc_mcp] 事件 %s: %s; %s, 交给 AALC' % (rule['name'], shown, why)):
|
||||
decisions.record('event', None, 'deferred', event=rule['name'], event_id=rule['id'],
|
||||
options=list(texts), why=why)
|
||||
return None
|
||||
state['clicks'] += 1
|
||||
log('[lc_mcp] 事件 %s: %s; 按表选第 %d 项「%s」' % (rule['name'], shown, i + 1, rule['text']))
|
||||
decisions.record('event', i + 1, 'text', event=rule['name'], event_id=rule['id'], options=list(texts))
|
||||
position = (float(options[i][0][0]), float(options[i][0][1]))
|
||||
auto.mouse_click(position[0], position[1])
|
||||
return position
|
||||
|
||||
def event_handling(self, *args, **kwargs):
|
||||
state = {'clicks': 0, 'logged': set(), 'clicked': None, 'passed': None}
|
||||
real_find, real_click = auto.find_element, auto.mouse_click
|
||||
|
||||
def find_element(target, *a, **kw):
|
||||
if target != EVENT_HOOK:
|
||||
return real_find(target, *a, **kw)
|
||||
if state['clicked'] is not None:
|
||||
# 刚按表点过: 小指良单通模式的 click_option_avoiding_unknown 会再找一次 "???", 别让它再点
|
||||
state['clicked'] = None
|
||||
return None
|
||||
shot = getattr(auto, 'screenshot', None)
|
||||
clicked = None
|
||||
if shot is None or shot is not state['passed']: # 同一张截图只判断一次(单通模式会再找一次 "???")
|
||||
try:
|
||||
clicked = decide(state)
|
||||
except Exception as e:
|
||||
log('[lc_mcp] 事件选项表出错(%s: %s), 交给 AALC' % (type(e).__name__, e))
|
||||
state['passed'] = shot if clicked is None else None
|
||||
if clicked is None:
|
||||
return real_find(target, *a, **kw)
|
||||
state['clicked'] = clicked
|
||||
return clicked # 上游当作找到了 "???": event_chance -= 1, 重新截图
|
||||
|
||||
def mouse_click(x, y, *a, **kw):
|
||||
if state['clicked'] is not None and (x, y) == state['clicked']:
|
||||
state['clicked'] = None # 上游拿返回的位置再点一次; 已经点过了, 吞掉
|
||||
return True
|
||||
return real_click(x, y, *a, **kw)
|
||||
|
||||
with _override(auto, 'find_element', find_element), _override(auto, 'mouse_click', mouse_click):
|
||||
return original(self, *args, **kwargs)
|
||||
|
||||
event_handling.__wrapped__ = original # 让后装的补丁查得到上游源码
|
||||
mirror_mod.Mirror.event_handling = event_handling
|
||||
log('[lc_mcp] patch: 镜牢事件按选项表选择(%s, %d 条)' % (os.path.basename(path), len(rules)))
|
||||
return original
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- 决策审计: 商店购买、卡包选择
|
||||
|
||||
SHOP_PURCHASE = 'mirror/shop/purchase_assets.png'
|
||||
SHOP_CONFIRM = 'mirror/road_in_mir/ego_gift_get_confirm_assets.png'
|
||||
|
||||
|
||||
def install_shop_audit(log=print):
|
||||
"""商店买东西时记一条审计。只观察, 不改上游的购买逻辑。"""
|
||||
try:
|
||||
from tasks.mirror.in_shop import Shop
|
||||
from module.automation import auto
|
||||
except Exception as e:
|
||||
log('[lc_mcp] 商店审计跳过: 无法导入 %s' % e)
|
||||
return None
|
||||
original = getattr(Shop, 'buy_gifts', None)
|
||||
if original is None:
|
||||
log('[lc_mcp] 商店审计跳过: 上游没有 Shop.buy_gifts')
|
||||
return None
|
||||
|
||||
def buy_gifts(self, *args, **kwargs):
|
||||
last = {'item': None}
|
||||
real_click, real_pos = auto.click_element, auto.mouse_action_with_pos
|
||||
|
||||
def click_element(target, *a, **kw):
|
||||
result = real_click(target, *a, **kw)
|
||||
if result and target == SHOP_PURCHASE:
|
||||
# 点到"购买"按钮; 钱不够时按钮匹配不上, 不会走到这里
|
||||
decisions.record('shop', last['item'] or 'unknown', 'purchase_clicked',
|
||||
system=getattr(self, 'system', None))
|
||||
last['item'] = None
|
||||
elif result and target != SHOP_CONFIRM:
|
||||
last['item'] = os.path.splitext(os.path.basename(str(target)))[0] # 必买项/四级/三级素材
|
||||
return result
|
||||
|
||||
def mouse_action_with_pos(*a, **kw):
|
||||
last['item'] = 'by_position' # 本体系饰品是按模板坐标点的
|
||||
return real_pos(*a, **kw)
|
||||
|
||||
with _override(auto, 'click_element', click_element), \
|
||||
_override(auto, 'mouse_action_with_pos', mouse_action_with_pos):
|
||||
return original(self, *args, **kwargs)
|
||||
|
||||
buy_gifts.__wrapped__ = original # 让后装的补丁查得到上游源码
|
||||
Shop.buy_gifts = buy_gifts
|
||||
log('[lc_mcp] patch: 商店购买写入决策审计')
|
||||
return original
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- 商店按中文名购买
|
||||
|
||||
# 上游必买只认 mirror/shop/must_purchase/ 下 5 张图标模板(阈值 0.85)。汉化后商店每一格下面写着饰品中文名
|
||||
# (docs/feedback/mirror_20261002_181322/special_shop_missed.png), 这里按名字表 OCR, 命中就点那一格的图标;
|
||||
# 之后的"购买 -> 确认"仍是上游同一段循环, 模板留在后面兜底。
|
||||
# 挂法: buy_gifts 期间在 must_purchase 最前面临时插几个占位项; 上游 for commodity in must_purchase:
|
||||
# auto.click_element(commodity, ...) 点到占位项时改成按名字找。
|
||||
SHOP_NAMES_ENV = 'LCP_SHOP_NAMES' # 0 = 关闭; 文件路径 = 用这张表代替默认表
|
||||
SHOP_NAMES_FILE = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'data', 'shop_gifts.json')
|
||||
SHOP_BY_NAME = 'lc_mcp/shop_by_name' # 占位项; 不是图片, 只在补丁里认
|
||||
SHOP_BY_NAME_SLOTS = 3 # 每轮必买最多按名字买几件
|
||||
SHOP_NAME_CLICKS = 4 # 一次进店同一个名字最多点几次(钱不够时上游会重点)
|
||||
SHOP_COINS = 'mirror/shop/shop_coins_assets.png' # 上游 re_sort_points 也拿它当商品格的锚点
|
||||
SHOP_GRID_BOX = (0, 300, 1250, 900) # 名字行相对金币图标的范围(1440 标定; 实测两行名字在 +409/+716)
|
||||
SHOP_NAME_TO_ICON = 155 # 名字行中心到图标中心的纵向距离(1440 标定, 1080 截图实测 116)
|
||||
|
||||
|
||||
def load_shop_gifts(path=SHOP_NAMES_FILE):
|
||||
"""读按名字购买的表, 返回归一后的名字元组(靠前的先买); 格式不对抛 ValueError。"""
|
||||
with open(path, encoding='utf-8') as f:
|
||||
raw = json.load(f)
|
||||
gifts = raw.get('gifts') if isinstance(raw, dict) else None
|
||||
if not isinstance(gifts, list) or not gifts:
|
||||
raise ValueError('顶层应是 {"gifts": [{"name": ...}, ...]}')
|
||||
names = []
|
||||
for item in gifts:
|
||||
name = item.get('name') if isinstance(item, dict) else None
|
||||
if not isinstance(name, str) or not normalize_event_text(name):
|
||||
raise ValueError('gifts 的每一项应有非空的 name')
|
||||
if normalize_event_text(name) in names:
|
||||
raise ValueError('%s 重复' % name)
|
||||
names.append(normalize_event_text(name))
|
||||
return tuple(names)
|
||||
|
||||
|
||||
def shop_name_hits(lines, names, coins, scale):
|
||||
"""商品格里名字对上表的行, 按表里的顺序: [(名字, 图标位置), ...]。
|
||||
|
||||
只认金币图标右下方商品格范围内、与名字完全一致的行(允许强化后缀 +); 子串不算, 免得半截名字误买。
|
||||
"""
|
||||
left, top, right, bottom = (v * scale for v in SHOP_GRID_BOX)
|
||||
x0, y0 = float(coins[0]), float(coins[1])
|
||||
found = {}
|
||||
for text, x, y in lines:
|
||||
if not (x0 + left <= x <= x0 + right and y0 + top <= y <= y0 + bottom):
|
||||
continue
|
||||
clean = normalize_event_text(text).rstrip('+')
|
||||
if clean in names and clean not in found:
|
||||
found[clean] = (x, y - SHOP_NAME_TO_ICON * scale)
|
||||
return [(name, found[name]) for name in names if name in found]
|
||||
|
||||
|
||||
def install_shop_by_name(log=print, env=None):
|
||||
"""商店必买先按中文名找。返回原 Shop.buy_gifts, 未安装返回 None。"""
|
||||
env = os.environ if env is None else env
|
||||
setting = (env.get(SHOP_NAMES_ENV) or '').strip()
|
||||
if setting == '0':
|
||||
log('[lc_mcp] 商店按名字购买已关闭(%s=0), 只用 AALC 的图标模板' % SHOP_NAMES_ENV)
|
||||
return None
|
||||
path = setting or SHOP_NAMES_FILE
|
||||
try:
|
||||
names = load_shop_gifts(path)
|
||||
except (OSError, ValueError) as e:
|
||||
log('[ERROR] [lc_mcp] 商店按名字购买跳过: %s 读不了(%s: %s)' % (path, type(e).__name__, e))
|
||||
return None
|
||||
try:
|
||||
from tasks.mirror import in_shop
|
||||
from module.automation import auto
|
||||
from module.config import cfg
|
||||
except Exception as e:
|
||||
log('[lc_mcp] 商店按名字购买跳过: 无法导入 %s' % e)
|
||||
return None
|
||||
shop_cls, must = getattr(in_shop, 'Shop', None), getattr(in_shop, 'must_purchase', None)
|
||||
original = getattr(shop_cls, 'buy_gifts', None)
|
||||
if original is None or not isinstance(must, list):
|
||||
log('[ERROR] [lc_mcp] 商店按名字购买跳过: 上游没有 Shop.buy_gifts 或 must_purchase 列表')
|
||||
return None
|
||||
if _source_calls(original, 'click_element', 'mirror/shop/purchase_assets.png') is False or \
|
||||
_source_mentions(original, 'for commodity in must_purchase', 'auto.click_element(commodity') is False:
|
||||
log('[ERROR] [lc_mcp] 商店按名字购买跳过: 上游 Shop.buy_gifts 不再逐个 click_element(must_purchase), 挂不上')
|
||||
return None
|
||||
|
||||
def pick(state, real_find):
|
||||
"""按名字点一格返回 True; 画面上没有表里的名字返回 False。"""
|
||||
shot = auto.screenshot
|
||||
if shot is not None and shot is state['empty_shot']:
|
||||
return False # 这张截图刚 OCR 过且没有命中, 后面几个占位项不用再跑
|
||||
coins = real_find(SHOP_COINS)
|
||||
hits = []
|
||||
if coins:
|
||||
scale = cfg.set_win_size / 1440
|
||||
hits = [(name, pos) for name, pos in shop_name_hits(_ocr_lines(auto), names, coins, scale)
|
||||
if state['clicks'].get(name, 0) < SHOP_NAME_CLICKS]
|
||||
if not hits:
|
||||
state['empty_shot'] = shot
|
||||
return False
|
||||
name, (x, y) = hits[0]
|
||||
state['clicks'][name] = state['clicks'].get(name, 0) + 1
|
||||
if state['clicks'][name] == 1:
|
||||
log('[lc_mcp] 商店: 按名字找到「%s」, 点它的图标' % name)
|
||||
decisions.record('shop', name, 'name_match', on_screen=[n for n, _ in hits])
|
||||
auto.mouse_click(x, y)
|
||||
return True
|
||||
|
||||
def buy_gifts(self, *args, **kwargs):
|
||||
state = {'clicks': {}, 'empty_shot': None}
|
||||
real_find, real_click = auto.find_element, auto.click_element
|
||||
|
||||
def click_element(target, *a, **kw):
|
||||
if target != SHOP_BY_NAME:
|
||||
return real_click(target, *a, **kw)
|
||||
try:
|
||||
return pick(state, real_find)
|
||||
except Exception as e:
|
||||
log('[lc_mcp] 商店按名字购买出错(%s: %s), 只用图标模板' % (type(e).__name__, e))
|
||||
return False
|
||||
|
||||
must[0:0] = [SHOP_BY_NAME] * SHOP_BY_NAME_SLOTS
|
||||
try:
|
||||
with _override(auto, 'click_element', click_element):
|
||||
return original(self, *args, **kwargs)
|
||||
finally:
|
||||
must[:] = [item for item in must if item != SHOP_BY_NAME]
|
||||
|
||||
buy_gifts.__wrapped__ = original # 让后装的补丁查得到上游源码
|
||||
shop_cls.buy_gifts = buy_gifts
|
||||
log('[lc_mcp] patch: 商店必买先按中文名找(%s, %d 个名字), 图标模板兜底' % (os.path.basename(path), len(names)))
|
||||
return original
|
||||
|
||||
|
||||
THEME_PACK_PICK = re.compile(r'此次选择卡包关键词[::]\s*(\S+)')
|
||||
THEME_PACK_WEIGHTS = '当前主题包权重列表'
|
||||
THEME_PACK_SOURCE = 'select_theme_pack.py'
|
||||
|
||||
|
||||
class _LogCapture(logging.Handler):
|
||||
"""收集某个源文件打出的 AALC 日志。"""
|
||||
|
||||
def __init__(self, source):
|
||||
super().__init__(logging.DEBUG)
|
||||
self.source = source
|
||||
self.messages = []
|
||||
|
||||
def emit(self, record):
|
||||
if os.path.basename(record.pathname or '') == self.source:
|
||||
try:
|
||||
self.messages.append(record.getMessage())
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
|
||||
def theme_pack_decision(messages):
|
||||
"""从上游 select_theme_pack 的日志里取 (卡包, 理由, 权重列表); 没选就返回 None。"""
|
||||
weights = next((m.split(':', 1)[-1] for m in reversed(messages) if m.startswith(THEME_PACK_WEIGHTS)), None)
|
||||
for message in reversed(messages):
|
||||
if '最左边的(活动)卡包' in message:
|
||||
return '最左边的活动卡包', 'event_pack', weights
|
||||
match = THEME_PACK_PICK.search(message)
|
||||
if match:
|
||||
return match.group(1), 'highest_weight' if '无匹配最低阈值' in message else 'preferred', weights
|
||||
return None
|
||||
|
||||
|
||||
def install_theme_pack_audit(log=print):
|
||||
"""卡包选完后按上游自己的日志记一条审计。只观察, 不改选择。"""
|
||||
try:
|
||||
from tasks.mirror import mirror as mirror_mod
|
||||
except Exception as e:
|
||||
log('[lc_mcp] 卡包审计跳过: 无法导入 %s' % e)
|
||||
return None
|
||||
original = getattr(mirror_mod, 'select_theme_pack', None)
|
||||
if original is None:
|
||||
log('[lc_mcp] 卡包审计跳过: mirror 模块没有 select_theme_pack')
|
||||
return None
|
||||
|
||||
def select_theme_pack(*args, **kwargs):
|
||||
capture = _LogCapture(THEME_PACK_SOURCE)
|
||||
logger = logging.getLogger('AALC')
|
||||
logger.addHandler(capture)
|
||||
try:
|
||||
return original(*args, **kwargs)
|
||||
finally:
|
||||
logger.removeHandler(capture)
|
||||
decision = theme_pack_decision(capture.messages)
|
||||
if decision:
|
||||
pack, reason, weights = decision
|
||||
decisions.record('theme_pack', pack, reason, weights=weights,
|
||||
floor=kwargs.get('floor', args[1] if len(args) > 1 else None))
|
||||
|
||||
mirror_mod.select_theme_pack = select_theme_pack
|
||||
log('[lc_mcp] patch: 卡包选择写入决策审计')
|
||||
return original
|
||||
|
||||
+12
-3
@@ -12,9 +12,11 @@ import sys
|
||||
from . import killswitch, preflight
|
||||
from .aalc_engine import bootstrap
|
||||
from .aalc_patches import (WindowGuard, driver_click_tasks, headless_hdr_warning,
|
||||
install_default_battle_team, install_exact_team_match,
|
||||
install_robust_set_foreground, install_system_team_selection,
|
||||
mirror_progress, stop_driver_click)
|
||||
install_default_battle_team, install_event_choices, install_exact_team_match,
|
||||
install_gift_preference, install_robust_set_foreground, install_shop_audit,
|
||||
install_shop_by_name, install_system_team_selection, install_theme_pack_audit,
|
||||
install_typed_keyboard_road, mirror_progress, stop_driver_click)
|
||||
from .decisions import decisions
|
||||
from .game_lock import GameBusyError, exclusive_game
|
||||
|
||||
# 任务 -> {参数名: AALC 配置项}; 参数只在本次运行内生效
|
||||
@@ -118,6 +120,7 @@ def _run(task, params):
|
||||
log('[ERROR] [lc_mcp] preflight: %s' % p)
|
||||
return PREFLIGHT_EXIT
|
||||
|
||||
decisions.open() # TaskRunner 给的 .decisions.jsonl; 直接运行时不写
|
||||
install_exact_team_match(auto, log)
|
||||
install_robust_set_foreground(screen, log=log)
|
||||
# 日常本(经验/纽本)不翻队伍列表: 队伍是自定义名字时按名字找必然失败,
|
||||
@@ -127,6 +130,12 @@ def _run(task, params):
|
||||
# 镜牢: 编队是自定义名字(体系名), AALC 只会找 "编队#N"; 改成按体系名点选。
|
||||
if task in ('mirror', 'all'):
|
||||
install_system_team_selection(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) # 装在审计之后(包在外层), 审计才看得到按名字点的那一下
|
||||
install_theme_pack_audit(log=log)
|
||||
guard = WindowGuard(screen, cfg, log=log)
|
||||
guard.start()
|
||||
restore_path = os.environ.get(RESTORE_ENV)
|
||||
|
||||
@@ -0,0 +1,32 @@
|
||||
{
|
||||
"_说明": [
|
||||
"镜牢事件选项表(BACKLOG P1-4)。只在事件出现选项时生效; 认不出的事件、或要点的那项没读到时, 交给 AALC 原逻辑。",
|
||||
"认事件: options 里的每一句都出现在这一屏的选项里, 才算这个事件(按表顺序, 先命中的生效); 然后点包含 text 的那一项。",
|
||||
"零协汉化的事件数据没有标题字段, 画面上也不保证有事件名, 所以不按事件名认; name 只用于日志。",
|
||||
"文字都先归一再比较: 去空白、全角转半角、去标点、改回常见误读。整表关闭: 任务环境变量 LCP_EVENT_CHOICES=0。",
|
||||
"id 是零协汉化 LLC_zh-CN/ActionEvents_*.json 里的事件 id; options/text 照抄那里的选项原文(2026-11-14 核对 LocalizeLimbusCompany@231a8bc)。",
|
||||
"check=true 表示选了之后还要罪人判定(由 AALC 原逻辑挑成功率最高的人格); 其余都是无判定、无战斗的直出。",
|
||||
"选择依据: docs/skills/limbus-mirror-speedrun/references/event-choices.md(依据边狱公司中文 Wiki 社区「探索事件」, CC BY-SA 4.0)。",
|
||||
"选项原文来自零协汉化 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 项直接结束; 其余方向都还有后续分支"}
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,20 @@
|
||||
{
|
||||
"_说明": [
|
||||
"镜牢饰品三选一/二选一按体系关键词排序(BACKLOG P1-3)。键是 AALC 的体系名(all_systems), 值是关键词。",
|
||||
"卡面 OCR 文本先归一(去空白、全角转半角、改回 震颐/沉论 等实测误读), 英文不分大小写, 子串命中即算。",
|
||||
"命中行数多的卡排前面; 白棉花、已持有仍按 AALC 原逻辑处理。整表关闭: 任务环境变量 LCP_GIFT_KEYWORDS=0。",
|
||||
"以 _ 开头的键会被忽略。",
|
||||
"中文关键词按零协汉化核对(LLC_zh-CN/EgoGiftCategory.json、BattleKeywords.json, 2026-11-14): 烧伤 流血 震颤 破裂 沉沦 呼吸法 充能 斩击 突刺 打击。",
|
||||
"饰品描述里的 [Combustion] 等占位符在游戏里显示成上面的名字; 呼吸法写成 呼吸, 漏读 法 也能命中。"
|
||||
],
|
||||
"burn": ["烧伤", "burn"],
|
||||
"bleed": ["流血", "bleed"],
|
||||
"tremor": ["震颤", "tremor"],
|
||||
"rupture": ["破裂", "rupture"],
|
||||
"sinking": ["沉沦", "sinking"],
|
||||
"poise": ["呼吸", "poise"],
|
||||
"charge": ["充能", "charge"],
|
||||
"slash": ["斩击", "slash"],
|
||||
"pierce": ["突刺", "pierce"],
|
||||
"blunt": ["打击", "blunt"]
|
||||
}
|
||||
@@ -0,0 +1,17 @@
|
||||
{
|
||||
"_说明": [
|
||||
"镜牢商店按中文名购买(BACKLOG P2-6)。AALC 必买项之前先按这张表 OCR 商店格子下面的名字, 命中就买; 靠前的先买。",
|
||||
"只认与名字完全一致的格子(去空白、标点, 允许强化后缀 +); AALC 的 5 张必买图标模板仍在后面兜底。整表关闭: 任务环境变量 LCP_SHOP_NAMES=0。",
|
||||
"默认 5 个就是 AALC 必买模板(assets/images/default/share/mirror/shop/must_purchase/*.png)对应的饰品, 中文名按零协汉化 LLC_zh-CN/EGOgift_MirrorDungeon.json(2026-11-14 核对 LocalizeLimbusCompany@231a8bc)。",
|
||||
"AALC 日志把必买项叫'回血饰品', 核对描述后只有 采血包/归途/石版字符 是回血; 缘分残片 是全队 +5 级, 卡蜜拉 是每场非集中战先削敌人 20% 体力。",
|
||||
"顺序是建议: 立即见效的放前面, 再按回血量。可以加别的饰品名, 写零协汉化里的名字原文。",
|
||||
"饰品名来自零协汉化 LocalizeLimbusCompany(https://github.com/LocalizeLimbusCompany/LocalizeLimbusCompany, CC BY-NC-SA 4.0)。"
|
||||
],
|
||||
"gifts": [
|
||||
{"name": "缘分残片", "id": 9082, "template": "piece_of_relationship.png", "note": "获得时编队所有人格提升 5 级"},
|
||||
{"name": "卡蜜拉", "id": 9036, "template": "carmilla.png", "note": "非集中遭遇战开始时, 对全体敌人造成体力上限 20% 的固定伤害"},
|
||||
{"name": "采血包", "id": 9004, "template": "phlebotomy_pack.png", "note": "技能造成伤害时恢复已失去体力的 12.5%(暴怒技能 25%)"},
|
||||
{"name": "归途", "id": 9039, "template": "homeward.png", "note": "关卡开始时全体恢复体力上限 12% 的体力"},
|
||||
{"name": "石版字符", "id": 9017, "template": "lithograph.png", "note": "敌人陷入混乱时, 体力最低的人格恢复体力上限 5%(有暴食攻击技能 10%)"}
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,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())}
|
||||
+2
-1
@@ -87,7 +87,8 @@ TOOLS = [
|
||||
'inputSchema': _obj({'task': {'type': 'string', 'enum': sorted(TASKS)},
|
||||
'exp': _NUM, 'thread': _NUM, 'times': _NUM, 'count': _NUM}, ['task'])},
|
||||
{'name': 'task_status', 'description': '启动 run_task 前检查占用,启动后轮询此工具监控,避免逐帧截图和重复启动。'
|
||||
'返回 idle/running/succeeded/failed/stopped、日志及异常。'
|
||||
'返回 idle/running/succeeded/failed/stopped、日志及异常;'
|
||||
'decisions.counts 按阶段统计选队/寻路/卡包/饰品/事件/商店的决策理由。'
|
||||
'succeeded 也要看 errors 和 pending_restore;running 出现 stall 应 stop_task 并确认停止后排障;'
|
||||
'stopped/退出码130 表示用户停止,不自动重跑。',
|
||||
'inputSchema': _obj({'lines': {'type': 'number', 'default': 30}})},
|
||||
|
||||
+8
-1
@@ -12,6 +12,7 @@ import time
|
||||
from collections import deque
|
||||
|
||||
from .aalc_task import RESTORE_ENV
|
||||
from .decisions import DECISIONS_ENV, SUFFIX as DECISIONS_SUFFIX, summarize as summarize_decisions
|
||||
from .killswitch import EXIT_CODE as USER_ABORT_EXIT
|
||||
|
||||
REPO = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
||||
@@ -168,11 +169,13 @@ class TaskRunner:
|
||||
base = os.path.join(self.run_dir, 'task_%s_%s' % (stamp, task))
|
||||
env = self._env()
|
||||
env[RESTORE_ENV] = base + RESTORE_SUFFIX
|
||||
env[DECISIONS_ENV] = base + DECISIONS_SUFFIX
|
||||
kw = {'creationflags': subprocess.CREATE_NEW_PROCESS_GROUP} if IS_WIN else {'start_new_session': True}
|
||||
with open(base + '.log', 'wb') as logf:
|
||||
self.proc = subprocess.Popen(self.argv_factory(task, params), cwd=REPO, env=env,
|
||||
stdin=subprocess.DEVNULL, stdout=logf, stderr=subprocess.STDOUT, **kw)
|
||||
self.info = {'task': task, 'params': params, 'log': (base + '.log').replace('\\', '/'),
|
||||
'decisions': (base + DECISIONS_SUFFIX).replace('\\', '/'),
|
||||
'restore': env[RESTORE_ENV], 'started': time.time(), 'stopped_by_user': False}
|
||||
self._prune()
|
||||
return {'ok': True, 'task': task, 'pid': self.proc.pid, 'log': self.info['log']}
|
||||
@@ -192,6 +195,9 @@ class TaskRunner:
|
||||
r = {'ok': True, 'state': state, 'task': self.info['task'], 'params': self.info['params'],
|
||||
'elapsed_s': int((self.info.get('ended') or time.time()) - self.info['started']),
|
||||
'log': self.info['log'], 'log_tail': tail(self.info['log'], max(1, min(int(lines), 200)))}
|
||||
counts = summarize_decisions(self.info['decisions'])
|
||||
if counts:
|
||||
r['decisions'] = {'path': self.info['decisions'], 'counts': counts}
|
||||
if code is None:
|
||||
stalls = log_stalls(self.info['log'])
|
||||
if stalls:
|
||||
@@ -238,7 +244,8 @@ class TaskRunner:
|
||||
def _prune(self):
|
||||
logs = sorted(glob.glob(os.path.join(self.run_dir, 'task_*.log')), key=os.path.getmtime)
|
||||
for p in logs[:-self.keep_logs]:
|
||||
for path in (p, p[:-len('.log')] + DECISIONS_SUFFIX):
|
||||
try:
|
||||
os.remove(p)
|
||||
os.remove(path)
|
||||
except OSError:
|
||||
pass
|
||||
|
||||
@@ -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()
|
||||
@@ -0,0 +1,383 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""镜牢事件按选项表选择(BACKLOG P1-4)。
|
||||
|
||||
2026-11-14 核对: Mirror.event_handling() 不认事件, 有 "???"/直接拿饰品/优势判定就选它, 否则点第一个选项。
|
||||
补丁在上游每轮挑选项前按选项原文认事件、按表点; 端到端用例执行上游真实的 event_handling
|
||||
(以及小指良单通模式用的 click_option_avoiding_unknown)。
|
||||
"""
|
||||
import ast
|
||||
import functools
|
||||
import json
|
||||
import os
|
||||
import sys
|
||||
import tempfile
|
||||
import time
|
||||
import types
|
||||
import unittest
|
||||
from pathlib import Path
|
||||
from types import SimpleNamespace
|
||||
from unittest import mock
|
||||
|
||||
REPO = Path(__file__).resolve().parents[1]
|
||||
sys.path.insert(0, str(REPO))
|
||||
from lc_mcp import aalc_patches as ap # noqa: E402
|
||||
|
||||
MIRROR = REPO / 'vendor' / 'aalc' / 'tasks' / 'mirror' / 'mirror.py'
|
||||
EVENT = REPO / 'vendor' / 'aalc' / 'tasks' / 'event' / 'event_handling.py'
|
||||
SCALE = 720 / 1440
|
||||
MARKER_X = 699 # 选项框左边缘(1280x720, 由 2560 模板换算)
|
||||
ROW_GAP = 60
|
||||
|
||||
SHEEP = ['你是特别的。', '你不是特别的。']
|
||||
CHICKEN = ['鸡肉就是鸡肉喽。', '绝对是鸡腿,满满的汁液。', '鸡胸,肯定的,纯净无瑕。']
|
||||
STATUE = ['侧耳倾听。', '摘下黄铜戒指。', '放上钱币。']
|
||||
|
||||
|
||||
def markers(count):
|
||||
return [(MARKER_X, 200 + ROW_GAP * i) for i in range(count)]
|
||||
|
||||
|
||||
def rule(name='e', options=('别的选项',), text='要点的'):
|
||||
return {'name': name, 'id': None, 'options': tuple(options), 'text': text}
|
||||
|
||||
|
||||
def upstream_function(path, name, cls=None):
|
||||
tree = ast.parse(path.read_text(encoding='utf-8'))
|
||||
body = tree.body
|
||||
if cls:
|
||||
body = next(n for n in body if isinstance(n, ast.ClassDef) and n.name == cls).body
|
||||
return next(n for n in body if isinstance(n, ast.FunctionDef) and n.name == name)
|
||||
|
||||
|
||||
class NormalizeEventTextTest(unittest.TestCase):
|
||||
|
||||
def test_punctuation_width_and_spaces_are_ignored(self):
|
||||
self.assertEqual(ap.normalize_event_text('鸡胸,肯定的, 纯净 无瑕。'), '鸡胸肯定的纯净无瑕')
|
||||
self.assertEqual(ap.normalize_event_text('“我不特别吗?”'), '我不特别吗')
|
||||
self.assertEqual(ap.normalize_event_text('施加震颐'), '施加震颤')
|
||||
|
||||
|
||||
class EventOptionsTest(unittest.TestCase):
|
||||
|
||||
def test_lines_attach_to_the_nearest_option_on_the_right(self):
|
||||
lines = [('你是特别的', 900, 200),
|
||||
('你不是', 900, 255), ('特别的。', 1000, 265), # 一项换成两行
|
||||
('离开', 900, 322),
|
||||
('侧耳倾听', 300, 260), # 左边的叙述文字不算选项
|
||||
('梦中的电子羊', 200, 60)] # 标题
|
||||
options = ap.event_options(list(reversed(markers(3))), lines, SCALE)
|
||||
self.assertEqual([text for _, text in options], ['你是特别的', '你不是特别的', '离开'])
|
||||
self.assertEqual([pos for pos, _ in options], markers(3))
|
||||
|
||||
def test_text_far_below_the_last_option_is_ignored(self):
|
||||
options = ap.event_options(markers(1), [('继续', 900, 200 + 31)], SCALE)
|
||||
self.assertEqual(options[0][1], '')
|
||||
|
||||
|
||||
class ChooseEventOptionTest(unittest.TestCase):
|
||||
|
||||
def test_event_is_recognised_by_its_other_options(self):
|
||||
rules = [rule('羊', ['你是特别的'], '你不是特别的')]
|
||||
self.assertEqual(ap.choose_event_option(rules, ('你是特别的', '你不是特别的')), (rules[0], 1))
|
||||
self.assertEqual(ap.choose_event_option(rules, ('你不是特别的', '离开')), (None, None))
|
||||
|
||||
def test_all_listed_options_must_be_on_screen(self):
|
||||
rules = [rule('鸡', ['绝对是鸡腿', '鸡胸肯定的'], '鸡肉就是鸡肉喽')]
|
||||
self.assertEqual(ap.choose_event_option(rules, ('鸡肉就是鸡肉喽', '绝对是鸡腿满满的汁液')), (None, None))
|
||||
|
||||
def test_recognised_but_target_not_read(self):
|
||||
rules = [rule('鸡', ['绝对是鸡腿'], '鸡肉就是鸡肉喽')]
|
||||
self.assertEqual(ap.choose_event_option(rules, ('鸡肉就是鸡', '绝对是鸡腿')), (rules[0], None))
|
||||
|
||||
def test_first_matching_rule_wins(self):
|
||||
rules = [rule('a', ['离开'], '战斗'), rule('b', ['离开'], '交谈')]
|
||||
self.assertEqual(ap.choose_event_option(rules, ('交谈', '战斗', '离开')), (rules[0], 1))
|
||||
|
||||
|
||||
class EventTableTest(unittest.TestCase):
|
||||
|
||||
def test_shipped_table_is_valid(self):
|
||||
rules = ap.load_event_choices()
|
||||
self.assertGreaterEqual(len(rules), 5)
|
||||
for r in rules:
|
||||
with self.subTest(event=r['name']):
|
||||
self.assertIsInstance(r['id'], int) # 零协汉化 ActionEvents 的事件 id, 方便回查
|
||||
|
||||
def test_shipped_events_come_from_the_event_reference(self):
|
||||
reference = (REPO / 'docs/skills/limbus-mirror-speedrun/references/event-choices.md').read_text(encoding='utf-8')
|
||||
for r in ap.load_event_choices():
|
||||
with self.subTest(event=r['name']):
|
||||
self.assertIn(r['name'].split('(')[0], reference)
|
||||
|
||||
def test_each_shipped_event_picks_its_own_option(self):
|
||||
rules = ap.load_event_choices()
|
||||
for r in rules:
|
||||
with self.subTest(event=r['name']):
|
||||
screen = (r['text'],) + r['options']
|
||||
self.assertEqual(ap.choose_event_option(rules, screen), (r, 0))
|
||||
|
||||
def test_bad_tables_raise_value_error(self):
|
||||
bad = ['[]', '{"events": {}}', '{"events": [1]}',
|
||||
'{"events": [{"name": "a", "options": ["x"]}]}',
|
||||
'{"events": [{"name": "a", "options": [], "text": "y"}]}',
|
||||
'{"events": [{"name": "a", "options": "x", "text": "y"}]}',
|
||||
'{"events": [{"name": "a", "options": ["x"], "text": ["y"]}]}',
|
||||
'{"events": [{"name": "a", "options": ["。"], "text": "y"}]}',
|
||||
'{"events": [{"name": "a", "options": ["离开"], "text": "离开。"}]}',
|
||||
'{"events": [{"name": "a", "match": ["x"], "index": 2}]}']
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
path = os.path.join(tmp, 'e.json')
|
||||
for content in bad:
|
||||
with self.subTest(content=content):
|
||||
with open(path, 'w', encoding='utf-8') as f:
|
||||
f.write(content)
|
||||
with self.assertRaises(ValueError):
|
||||
ap.load_event_choices(path)
|
||||
|
||||
|
||||
class EventScreen:
|
||||
"""事件界面: 依次几屏选项, 点了一项就进下一屏, 最后回到地图。unknown 是带 "???" 标签的那一项。"""
|
||||
|
||||
def __init__(self, screens, unknown=None, ignore_clicks=0):
|
||||
self.screens = [list(s) for s in screens]
|
||||
self.unknown = unknown
|
||||
self.stage = 0
|
||||
self.ignore_clicks = ignore_clicks
|
||||
self.chosen = []
|
||||
self.model = None
|
||||
self.screenshot = object()
|
||||
self.ocr_runs = 0
|
||||
|
||||
@property
|
||||
def options(self):
|
||||
return self.screens[self.stage] if self.stage < len(self.screens) else None
|
||||
|
||||
def take_screenshot(self, *args, **kwargs):
|
||||
self.screenshot = object() # 每次截图都是新对象, 与 AALC 一致
|
||||
return self.screenshot
|
||||
|
||||
def mouse_to_blank(self, *args, **kwargs):
|
||||
pass
|
||||
|
||||
def find_element(self, target, find_type='image', threshold=0.8, **kwargs):
|
||||
options = self.options
|
||||
if target == 'mirror/road_in_mir/legend_assets.png':
|
||||
return options is None
|
||||
if target == ap.EVENT_OPTION and options:
|
||||
return markers(len(options)) if find_type == 'image_with_multiple_targets' else markers(1)[0]
|
||||
if target == ap.EVENT_HOOK and options and self.stage == 0 and self.unknown is not None:
|
||||
x, y = markers(len(options))[self.unknown]
|
||||
return (x + 300, y + 20) # 标签画在所属选项框里面, 比左边缘靠下
|
||||
if target == 'event/choices_assets.png':
|
||||
return bool(options)
|
||||
return [] if find_type == 'image_with_multiple_targets' else False
|
||||
|
||||
def click_element(self, target, **kwargs):
|
||||
if target == ap.EVENT_OPTION and self.options:
|
||||
self.mouse_click(*markers(1)[0])
|
||||
return True
|
||||
return False
|
||||
|
||||
def mouse_click(self, x, y, *args, **kwargs):
|
||||
if not self.options:
|
||||
return
|
||||
rows = markers(len(self.options))
|
||||
above = [i for i, (_, my) in enumerate(rows) if my <= y]
|
||||
self.chosen.append(max(above) if above else 0)
|
||||
if self.ignore_clicks:
|
||||
self.ignore_clicks -= 1
|
||||
return
|
||||
self.stage += 1
|
||||
|
||||
def find_language_text(self, *args, **kwargs):
|
||||
return False
|
||||
|
||||
def find_text_element(self, *args, **kwargs):
|
||||
return False
|
||||
|
||||
def run(self, image):
|
||||
self.ocr_runs += 1
|
||||
lines = [('事件叙述文字', 200, 60)]
|
||||
for (x, y), text in zip(markers(len(self.options or ())), self.options or ()):
|
||||
lines.append((text, x + 200, y))
|
||||
return SimpleNamespace(txts=tuple(t for t, _, _ in lines),
|
||||
boxes=[[[x - 10, y - 5], [x + 10, y - 5], [x + 10, y + 5], [x - 10, y + 5]]
|
||||
for _, x, y in lines])
|
||||
|
||||
|
||||
@unittest.skipUnless(MIRROR.is_file() and EVENT.is_file(), 'vendor/aalc 子模块未检出')
|
||||
class UpstreamEventHandlingTest(unittest.TestCase):
|
||||
"""执行上游真实的 Mirror.event_handling, 看每屏点了第几项。"""
|
||||
|
||||
def setUp(self):
|
||||
self.lines = []
|
||||
self.fn_node = upstream_function(MIRROR, 'event_handling', cls='Mirror')
|
||||
self.avoid_node = upstream_function(EVENT, 'click_option_avoiding_unknown', cls='EventHandling')
|
||||
|
||||
def play(self, screens, patched=True, env=None, unknown=None, solo=False, ignore_clicks=0):
|
||||
screen = EventScreen(screens, unknown=unknown, ignore_clicks=ignore_clicks)
|
||||
cfg = SimpleNamespace(set_win_size=720)
|
||||
avoid_ns = dict(auto=screen, log=mock.Mock())
|
||||
exec(compile(ast.Module(body=[self.avoid_node], type_ignores=[]), str(EVENT), 'exec'), avoid_ns)
|
||||
ns = dict(auto=screen, retry=lambda: True, log=mock.Mock(), time=time, back_init_menu=mock.Mock(),
|
||||
ImageUtils=SimpleNamespace(get_bbox=lambda image: (0, 0, 10, 10), load_image=lambda path: None))
|
||||
exec(compile(ast.Module(body=[self.fn_node], type_ignores=[]), str(MIRROR), 'exec'), ns)
|
||||
method = ns['event_handling']
|
||||
ns['event_handling'] = SimpleNamespace( # 上游模块 tasks.event.event_handling 的同名单例
|
||||
decision_event_handling=lambda: False,
|
||||
click_option_avoiding_unknown=functools.partial(avoid_ns['click_option_avoiding_unknown'], None))
|
||||
mirror_cls = type('Mirror', (), {'event_handling': method})
|
||||
mirror_mod = types.ModuleType('tasks.mirror.mirror')
|
||||
mirror_mod.Mirror = mirror_cls
|
||||
package = types.ModuleType('tasks.mirror')
|
||||
package.mirror = mirror_mod
|
||||
modules = {'tasks': types.ModuleType('tasks'), 'tasks.mirror': package, 'tasks.mirror.mirror': mirror_mod,
|
||||
'module': types.ModuleType('module'),
|
||||
'module.automation': SimpleNamespace(auto=screen),
|
||||
'module.config': SimpleNamespace(cfg=cfg),
|
||||
'module.ocr': SimpleNamespace(ocr=screen)}
|
||||
with mock.patch.dict(sys.modules, modules):
|
||||
if patched:
|
||||
self.assertIsNotNone(ap.install_event_choices(log=self.lines.append, env=env or {}))
|
||||
mirror = mirror_cls()
|
||||
mirror.event_total_time, mirror.event_times = 0, 0
|
||||
mirror.defense_for_solo = solo
|
||||
mirror.event_handling()
|
||||
self.assertEqual(mirror.event_times, 1)
|
||||
self.assertNotIn('find_element', vars(screen), 'find_element 必须还原')
|
||||
self.assertNotIn('mouse_click', vars(screen), 'mouse_click 必须还原')
|
||||
self.screen = screen
|
||||
return screen.chosen
|
||||
|
||||
@property
|
||||
def log(self):
|
||||
return '\n'.join(self.lines)
|
||||
|
||||
def test_patch_hooks_into_the_current_upstream(self):
|
||||
self.play([SHEEP])
|
||||
self.assertIn('patch: 镜牢事件按选项表选择', self.log)
|
||||
self.assertNotIn('[ERROR]', self.log)
|
||||
|
||||
def test_table_choice_is_clicked_exactly_once(self):
|
||||
self.assertEqual(self.play([SHEEP], patched=False), [0])
|
||||
self.assertEqual(self.play([SHEEP]), [1]) # 上游拿返回的位置再点一次会被吞掉
|
||||
self.assertIn('事件 梦中的电子羊: 1=你是特别的 | 2=你不是特别的; 按表选第 2 项「你不是特别的」', self.log)
|
||||
|
||||
def test_table_beats_the_unknown_tag(self):
|
||||
# 上游有 "???" 就点 "???"; 表里的事件按表点
|
||||
self.assertEqual(self.play([CHICKEN[::-1]], unknown=0, patched=False), [0])
|
||||
self.assertEqual(self.play([CHICKEN[::-1]], unknown=0), [2])
|
||||
|
||||
def test_solo_mode_does_not_click_a_second_option(self):
|
||||
# 小指良单通模式会再找一次 "???" 并改点别的选项; 已按表点过时它必须什么也不做
|
||||
self.assertEqual(self.play([STATUE], unknown=0, solo=True, patched=False), [1])
|
||||
self.assertEqual(self.play([STATUE], unknown=0, solo=True), [0])
|
||||
|
||||
def test_unknown_event_behaves_like_upstream(self):
|
||||
for kwargs in ({}, {'unknown': 1}, {'unknown': 1, 'solo': True}):
|
||||
with self.subTest(**kwargs):
|
||||
options = [['战斗', '离开']]
|
||||
self.assertEqual(self.play(options, **kwargs), self.play(options, patched=False, **kwargs))
|
||||
self.assertIn('事件选项: 1=战斗 | 2=离开; 表里没有这个事件, 交给 AALC', self.log)
|
||||
|
||||
def test_one_ocr_per_screenshot_in_solo_mode(self):
|
||||
# 单通模式下上游会再找一次 "???"; 同一张截图不再整屏 OCR 第二遍
|
||||
self.assertEqual(self.play([['战斗', '离开']], unknown=1, solo=True), [0])
|
||||
self.assertEqual(self.screen.ocr_runs, 1)
|
||||
|
||||
def test_misread_target_falls_back_to_upstream(self):
|
||||
options = [['鸡肉就是鸡', CHICKEN[1], CHICKEN[2]]]
|
||||
self.assertEqual(self.play(options), [0])
|
||||
self.assertIn('表里要点的「鸡肉就是鸡肉喽」没读到, 交给 AALC', self.log)
|
||||
|
||||
def test_later_screens_not_in_the_table_go_to_upstream(self):
|
||||
self.assertEqual(self.play([CHICKEN[::-1], ['好', '不好']]), [2, 0])
|
||||
|
||||
def test_unresponsive_clicks_are_capped(self):
|
||||
chosen = self.play([SHEEP], ignore_clicks=ap.EVENT_TEXT_CLICKS + 1)
|
||||
self.assertEqual(chosen[:ap.EVENT_TEXT_CLICKS + 1], [1] * ap.EVENT_TEXT_CLICKS + [0])
|
||||
self.assertIn('这次事件已按表点了 %d 次, 交给 AALC' % ap.EVENT_TEXT_CLICKS, self.log)
|
||||
|
||||
def test_decisions_are_recorded_once_per_screen(self):
|
||||
with mock.patch.object(ap.decisions, 'record') as record:
|
||||
self.play([SHEEP])
|
||||
self.play([['战斗', '离开']])
|
||||
self.assertEqual(record.call_args_list, [
|
||||
mock.call('event', 2, 'text', event='梦中的电子羊', event_id=901038, options=['你是特别的', '你不是特别的']),
|
||||
mock.call('event', None, 'not_in_table', options=['战斗', '离开'])])
|
||||
|
||||
def test_env_zero_keeps_upstream(self):
|
||||
self.assertIsNone(ap.install_event_choices(log=self.lines.append, env={ap.EVENT_CHOICES_ENV: '0'}))
|
||||
|
||||
|
||||
class InstallEventChoicesTest(unittest.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
self.lines = []
|
||||
self.original = mock.Mock(side_effect=RuntimeError('boom'))
|
||||
self.mirror_cls = type('Mirror', (), {'event_handling': self.original})
|
||||
mirror_mod = types.ModuleType('tasks.mirror.mirror')
|
||||
mirror_mod.Mirror = self.mirror_cls
|
||||
package = types.ModuleType('tasks.mirror')
|
||||
package.mirror = mirror_mod
|
||||
self.auto = SimpleNamespace(find_element=mock.Mock(return_value=False), mouse_click=mock.Mock())
|
||||
modules = {'tasks': types.ModuleType('tasks'), 'tasks.mirror': package, 'tasks.mirror.mirror': mirror_mod,
|
||||
'module': types.ModuleType('module'),
|
||||
'module.automation': SimpleNamespace(auto=self.auto),
|
||||
'module.config': SimpleNamespace(cfg=SimpleNamespace(set_win_size=720))}
|
||||
patcher = mock.patch.dict(sys.modules, modules)
|
||||
patcher.start()
|
||||
self.addCleanup(patcher.stop)
|
||||
|
||||
def test_methods_are_restored_after_an_exception(self):
|
||||
find, click = self.auto.find_element, self.auto.mouse_click
|
||||
ap.install_event_choices(log=self.lines.append, env={})
|
||||
with self.assertRaises(RuntimeError):
|
||||
self.mirror_cls().event_handling()
|
||||
self.assertIs(self.auto.find_element, find)
|
||||
self.assertIs(self.auto.mouse_click, click)
|
||||
|
||||
def test_unreadable_table_is_an_error(self):
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
path = os.path.join(tmp, 'e.json')
|
||||
with open(path, 'w', encoding='utf-8') as f:
|
||||
json.dump({'events': [{'name': 'a', 'match': ['x'], 'index': 1}]}, f)
|
||||
self.assertIsNone(ap.install_event_choices(log=self.lines.append, env={ap.EVENT_CHOICES_ENV: path}))
|
||||
self.assertIs(self.mirror_cls.event_handling, self.original)
|
||||
self.assertTrue(self.lines[0].startswith('[ERROR] [lc_mcp] 事件选项表补丁跳过'))
|
||||
|
||||
def test_upstream_without_the_hook_is_an_error(self):
|
||||
auto = self.auto
|
||||
|
||||
def event_handling(mirror):
|
||||
return auto.click_element("event/unknown_event.png") # 旧写法: 补丁挂不上
|
||||
|
||||
self.mirror_cls.event_handling = event_handling
|
||||
self.assertIsNone(ap.install_event_choices(log=self.lines.append, env={}))
|
||||
self.assertIs(self.mirror_cls.event_handling, event_handling)
|
||||
self.assertIn('[ERROR] [lc_mcp] 事件选项表补丁跳过: 上游 Mirror.event_handling 不再调用 find_element',
|
||||
'\n'.join(self.lines))
|
||||
|
||||
def test_decision_error_falls_back_to_upstream_find(self):
|
||||
calls = []
|
||||
auto = self.auto
|
||||
|
||||
def find(target, *args, **kwargs):
|
||||
if target == ap.EVENT_OPTION:
|
||||
raise RuntimeError('template')
|
||||
return False
|
||||
|
||||
def event_handling(mirror):
|
||||
calls.append(auto.find_element("event/unknown_event.png"))
|
||||
|
||||
self.auto.find_element = mock.Mock(side_effect=find)
|
||||
self.mirror_cls.event_handling = event_handling
|
||||
ap.install_event_choices(log=self.lines.append, env={})
|
||||
self.mirror_cls().event_handling()
|
||||
self.assertEqual(calls, [False])
|
||||
self.assertEqual(self.auto.find_element.call_args_list[-1], mock.call(ap.EVENT_HOOK))
|
||||
self.assertIn('事件选项表出错(RuntimeError: template)', '\n'.join(self.lines))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@@ -0,0 +1,362 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""镜牢饰品选择按体系关键词排序(BACKLOG P1-3)。
|
||||
|
||||
2026-11-14 核对: acquire_ego_gift() 两张卡时只排白棉花和已持有然后拿第一张, 不看 team_system。
|
||||
补丁在上游挑选前按卡面 OCR 的体系关键词给卡排序; 端到端用例执行上游真实的 acquire_ego_gift。
|
||||
"""
|
||||
import ast
|
||||
import json
|
||||
import os
|
||||
import sys
|
||||
import tempfile
|
||||
import types
|
||||
import unittest
|
||||
from pathlib import Path
|
||||
from types import SimpleNamespace
|
||||
from unittest import mock
|
||||
|
||||
REPO = Path(__file__).resolve().parents[1]
|
||||
sys.path.insert(0, str(REPO))
|
||||
from lc_mcp import aalc_patches as ap # noqa: E402
|
||||
|
||||
AALC = REPO / 'vendor' / 'aalc'
|
||||
MIRROR = AALC / 'tasks' / 'mirror' / 'mirror.py'
|
||||
SCALE = 720 / 1440
|
||||
|
||||
|
||||
def line_at(card, row):
|
||||
"""卡面第 row 行文字的位置(在上游判断范围内)。"""
|
||||
return card[0] + 100 * SCALE * 2, card[1] + 40 * row
|
||||
|
||||
|
||||
class GiftCardHitsTest(unittest.TestCase):
|
||||
|
||||
CARDS = [(300, 300), (600, 300), (900, 300)]
|
||||
|
||||
def hits(self, lines, keywords=('流血', '出血', 'bleed')):
|
||||
return ap.gift_card_hits(self.CARDS, lines, keywords, SCALE)
|
||||
|
||||
def test_lines_are_assigned_to_the_card_they_sit_on(self):
|
||||
lines = [('施加3层流血', *line_at(self.CARDS[1], 0)),
|
||||
('出血时伤害提高', *line_at(self.CARDS[1], 1)),
|
||||
('烧伤', *line_at(self.CARDS[0], 0)),
|
||||
('选择EGO饰品', 600, 40)] # 标题不在任何卡上
|
||||
self.assertEqual(self.hits(lines), [[], ['流血', '出血'], []])
|
||||
|
||||
def test_english_is_case_insensitive_and_spaces_are_ignored(self):
|
||||
lines = [('Inflict BLEED', *line_at(self.CARDS[2], 0)), ('流 血', *line_at(self.CARDS[0], 0))]
|
||||
self.assertEqual(self.hits(lines), [['流血'], [], ['bleed']])
|
||||
|
||||
def test_known_ocr_misreads_still_hit(self):
|
||||
lines = [('施加震颐', *line_at(self.CARDS[0], 0)), ('沉论层数', *line_at(self.CARDS[1], 0))]
|
||||
self.assertEqual(ap.gift_card_hits(self.CARDS, lines, ('震颤',), SCALE), [['震颤'], [], []])
|
||||
self.assertEqual(ap.gift_card_hits(self.CARDS, lines, ('沉沦',), SCALE), [[], ['沉沦'], []])
|
||||
|
||||
def test_overlapping_ranges_go_to_the_nearest_card(self):
|
||||
cards = [(300, 300), (450, 300)] # 两张卡的范围在 x=425..525 重叠
|
||||
lines = [('流血', 440, 300), ('流血', 500, 300)]
|
||||
self.assertEqual(ap.gift_card_hits(cards, lines, ('流血',), SCALE), [['流血'], ['流血']])
|
||||
|
||||
def test_upstream_order_undoes_the_icon_insertion(self):
|
||||
# 两张卡上游按给的顺序挑; 三张时命中的卡被上游逐张 insert(0), 所以倒着给、放在最后
|
||||
self.assertEqual(ap.gift_upstream_order([[], ['x']]), [1, 0])
|
||||
self.assertEqual(ap.gift_upstream_order([['x'], [], ['x', 'y']]), [1, 0, 2])
|
||||
self.assertEqual(ap.gift_upstream_order([[], [], []]), [0, 1, 2])
|
||||
|
||||
def test_rank_is_stable(self):
|
||||
cards = ['a', 'b', 'c']
|
||||
self.assertEqual(ap.rank_gift_cards(cards, [[], ['x'], []]), ['b', 'a', 'c'])
|
||||
self.assertEqual(ap.rank_gift_cards(cards, [[], [], []]), cards)
|
||||
self.assertEqual(ap.rank_gift_cards(cards, [['x'], ['x', 'y'], ['x']]), ['b', 'a', 'c'])
|
||||
|
||||
|
||||
class KeywordTableTest(unittest.TestCase):
|
||||
|
||||
def test_shipped_table_covers_every_upstream_system(self):
|
||||
table = ap.load_gift_keywords()
|
||||
source = AALC / 'tasks' / '__init__.py'
|
||||
if source.is_file():
|
||||
tree = ast.parse(source.read_text(encoding='utf-8'))
|
||||
node = next(n for n in tree.body if isinstance(n, ast.Assign)
|
||||
and getattr(n.targets[0], 'id', None) == 'all_systems')
|
||||
self.assertEqual(set(table), set(ast.literal_eval(node.value).values()))
|
||||
for system, words in table.items():
|
||||
self.assertTrue(words, system)
|
||||
|
||||
def test_bad_files_raise_value_error(self):
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
path = os.path.join(tmp, 'k.json')
|
||||
for content in ('[]', '{"bleed": "流血"}', '{"bleed": [1]}', '{'):
|
||||
with self.subTest(content=content):
|
||||
with open(path, 'w', encoding='utf-8') as f:
|
||||
f.write(content)
|
||||
with self.assertRaises(ValueError):
|
||||
ap.load_gift_keywords(path)
|
||||
|
||||
def test_notes_are_ignored(self):
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
path = os.path.join(tmp, 'k.json')
|
||||
with open(path, 'w', encoding='utf-8') as f:
|
||||
json.dump({'_说明': ['x'], 'bleed': ['流血', ' ']}, f, ensure_ascii=False)
|
||||
self.assertEqual(ap.load_gift_keywords(path), {'bleed': ('流血',)})
|
||||
|
||||
|
||||
class GiftScreen:
|
||||
"""饰品选择界面: 每张卡 {'pos', 'lines', 'icon'}; icon 为 True 的卡体系图标模板能匹配上
|
||||
(本机日志里没见它匹配上过, 默认 False)。"""
|
||||
|
||||
def __init__(self, cards, pick='0/1'):
|
||||
self.cards = cards
|
||||
self.pick = pick
|
||||
self.clicks = []
|
||||
self.ocr_runs = 0
|
||||
self.model = None
|
||||
self.screenshot = object()
|
||||
|
||||
def lines(self):
|
||||
return [(text, *line_at(card['pos'], row))
|
||||
for card in self.cards for row, text in enumerate(card['lines'])]
|
||||
|
||||
def take_screenshot(self):
|
||||
return self.screenshot
|
||||
|
||||
def mouse_to_blank(self):
|
||||
pass
|
||||
|
||||
def click_element(self, target, **kwargs):
|
||||
return target.endswith('acquire_ego_gift_select_assets.png')
|
||||
|
||||
def find_element(self, target, find_type='image', threshold=0.8, my_crop=None, **kwargs):
|
||||
if target == ap.GIFT_CARD and find_type == 'image_with_multiple_targets':
|
||||
return [card['pos'] for card in self.cards]
|
||||
if target.startswith('mirror/road_in_mir/acquire_ego_gift/') and my_crop:
|
||||
x1, y1, x2, y2 = my_crop
|
||||
for card in self.cards:
|
||||
if card.get('icon') and x1 <= card['pos'][0] <= x2 and y1 <= card['pos'][1] <= y2:
|
||||
return card['pos']
|
||||
return False
|
||||
|
||||
def find_language_text(self, zh_text, en_text, my_crop=None, **kwargs):
|
||||
words = [zh_text] if isinstance(zh_text, str) else zh_text
|
||||
x1, y1, x2, y2 = my_crop
|
||||
for text, x, y in self.lines():
|
||||
if x1 <= x <= x2 and y1 <= y <= y2 and any(w in text for w in words):
|
||||
return [x, y]
|
||||
return False
|
||||
|
||||
def find_text_element(self, targets, my_crop=None, **kwargs):
|
||||
return self.pick in targets
|
||||
|
||||
def mouse_click(self, x, y):
|
||||
self.clicks.append((x, y))
|
||||
|
||||
def run(self, image):
|
||||
self.ocr_runs += 1
|
||||
lines = self.lines()
|
||||
return SimpleNamespace(txts=tuple(t for t, _, _ in lines),
|
||||
boxes=[[[x - 10, y - 5], [x + 10, y - 5], [x + 10, y + 5], [x - 10, y + 5]]
|
||||
for _, x, y in lines])
|
||||
|
||||
|
||||
def card(x, *lines, icon=False):
|
||||
return {'pos': (x, 300), 'lines': list(lines), 'icon': icon}
|
||||
|
||||
|
||||
@unittest.skipUnless(MIRROR.is_file(), 'vendor/aalc 子模块未检出')
|
||||
class UpstreamAcquireEgoGiftTest(unittest.TestCase):
|
||||
"""执行上游真实的 Mirror.acquire_ego_gift, 看最后点了哪张卡。"""
|
||||
|
||||
def setUp(self):
|
||||
self.lines = []
|
||||
tree = ast.parse(MIRROR.read_text(encoding='utf-8'))
|
||||
cls = next(n for n in tree.body if isinstance(n, ast.ClassDef) and n.name == 'Mirror')
|
||||
self.fn_node = next(n for n in cls.body if isinstance(n, ast.FunctionDef) and n.name == 'acquire_ego_gift')
|
||||
|
||||
def choose(self, cards, system='bleed', patched=True, pick='0/1', env=None):
|
||||
screen = GiftScreen(cards, pick=pick)
|
||||
cfg = SimpleNamespace(set_win_size=720, not_skip_whitegossypium=False, mouse_action_interval=0)
|
||||
ns = dict(cfg=cfg, auto=screen, sleep=lambda *a: None, time=SimpleNamespace(sleep=lambda *a: None),
|
||||
retry=lambda: True, log=mock.Mock(),
|
||||
ImageUtils=SimpleNamespace(get_bbox=lambda image: None, load_image=lambda path: None),
|
||||
all_systems={0: 'burn', 1: 'bleed'})
|
||||
exec(compile(ast.Module(body=[self.fn_node], type_ignores=[]), str(MIRROR), 'exec'), ns)
|
||||
mirror_cls = type('Mirror', (), {'acquire_ego_gift': ns['acquire_ego_gift']})
|
||||
mirror_mod = types.ModuleType('tasks.mirror.mirror')
|
||||
mirror_mod.Mirror = mirror_cls
|
||||
package = types.ModuleType('tasks.mirror')
|
||||
package.mirror = mirror_mod
|
||||
modules = {'tasks': types.ModuleType('tasks'), 'tasks.mirror': package, 'tasks.mirror.mirror': mirror_mod,
|
||||
'module': types.ModuleType('module'),
|
||||
'module.automation': SimpleNamespace(auto=screen),
|
||||
'module.config': SimpleNamespace(cfg=cfg),
|
||||
'module.ocr': SimpleNamespace(ocr=screen)}
|
||||
with mock.patch.dict(sys.modules, modules):
|
||||
if patched:
|
||||
self.assertIsNotNone(ap.install_gift_preference(log=self.lines.append, env=env or {}))
|
||||
mirror = mirror_cls()
|
||||
mirror.system, mirror.second_system = system, False
|
||||
mirror.acquire_ego_gift()
|
||||
self.assertNotIn('find_element', vars(screen), 'find_element 必须还原')
|
||||
return [next(i for i, c in enumerate(cards) if c['pos'] == pos) for pos in screen.clicks], screen
|
||||
|
||||
@property
|
||||
def log(self):
|
||||
return '\n'.join(self.lines)
|
||||
|
||||
def test_two_cards_prefers_the_system_keyword(self):
|
||||
cards = [card(300, '烧伤层数+1'), card(600, '施加2层流血')]
|
||||
self.assertEqual(self.choose(cards, patched=False)[0], [0])
|
||||
self.assertEqual(self.choose(cards)[0], [1])
|
||||
self.assertIn('第1张=0 第2张=1(流血); 命中体系关键词, 先看第2张', self.log)
|
||||
|
||||
def test_owned_keyword_card_still_loses_to_an_unowned_one(self):
|
||||
cards = [card(300, '烧伤层数+1'), card(600, '施加2层流血', '已持有')]
|
||||
self.assertEqual(self.choose(cards)[0], [0])
|
||||
|
||||
def test_all_owned_falls_back_to_keyword_order(self):
|
||||
cards = [card(300, '烧伤', '已持有'), card(600, '流血', '已持有')]
|
||||
self.assertEqual(self.choose(cards)[0], [1])
|
||||
|
||||
def test_white_gossypium_is_still_skipped(self):
|
||||
cards = [card(300, '烧伤层数+1'), card(600, '白棉花', '流血')]
|
||||
self.assertEqual(self.choose(cards)[0], [0])
|
||||
|
||||
def test_all_white_gossypium_behaves_like_upstream(self):
|
||||
cards = [card(300, '白棉花'), card(600, '白棉花', '流血')]
|
||||
self.assertEqual(self.choose(cards)[0], self.choose(cards, patched=False)[0])
|
||||
|
||||
def test_three_cards_pick_one(self):
|
||||
cards = [card(300, '烧伤'), card(600, '震颤'), card(900, '流血伤害提高', '施加流血')]
|
||||
self.assertEqual(self.choose(cards, patched=False)[0], [0])
|
||||
self.assertEqual(self.choose(cards)[0], [2])
|
||||
|
||||
def test_three_cards_pick_two(self):
|
||||
cards = [card(300, '烧伤'), card(600, '流血'), card(900, '流血', '施加流血')]
|
||||
self.assertEqual(self.choose(cards, pick='0/2')[0], [2, 1])
|
||||
|
||||
def test_icon_cards_keep_the_keyword_order(self):
|
||||
# 上游把认出体系图标的卡逐张 insert(0), 后认出的反而排前面; 补丁要抵消这一步
|
||||
cards = [card(300, '施加流血', icon=True), card(600, '流血', '施加流血', '流血层数', icon=True), card(900, '烧伤')]
|
||||
self.assertEqual(self.choose(cards)[0], [1])
|
||||
self.assertEqual(self.choose(cards, pick='0/2')[0], [1, 0])
|
||||
|
||||
def test_keyword_card_without_icon_still_beats_an_icon_card(self):
|
||||
cards = [card(300, '流血', '施加流血', '流血层数'), card(600, '施加流血', icon=True), card(900, '烧伤')]
|
||||
self.assertEqual(self.choose(cards)[0], [0])
|
||||
|
||||
def test_icon_only_card_comes_after_keyword_cards_but_before_the_rest(self):
|
||||
cards = [card(300, '烧伤'), card(600, '没读出关键词', icon=True), card(900, '施加流血')]
|
||||
self.assertEqual(self.choose(cards, patched=False)[0], [1])
|
||||
self.assertEqual(self.choose(cards, pick='0/2')[0], [2, 1])
|
||||
|
||||
def test_without_keywords_icons_behave_like_upstream(self):
|
||||
cards = [card(300, '烧伤', icon=True), card(600, '震颤', icon=True), card(900, '充能')]
|
||||
self.assertEqual(self.choose(cards, pick='0/2')[0], self.choose(cards, pick='0/2', patched=False)[0])
|
||||
|
||||
def test_misread_keyword_for_tremor(self):
|
||||
cards = [card(300, '流血'), card(600, '施加震颐')]
|
||||
self.assertEqual(self.choose(cards, system='tremor')[0], [1])
|
||||
|
||||
def test_no_hits_keeps_upstream_choice(self):
|
||||
cards = [card(300, '烧伤'), card(600, '充能')]
|
||||
self.assertEqual(self.choose(cards)[0], [0])
|
||||
self.assertIn('未命中体系关键词, 保持原顺序', self.log)
|
||||
|
||||
def test_duplicate_lines_on_two_cards_both_count(self):
|
||||
# {文本: 坐标} 会把两张卡上的同一句合并成一条; 补丁直接读 OCR 引擎的逐行结果
|
||||
cards = [card(300, '流血'), card(600, '流血', '施加流血')]
|
||||
self.assertEqual(self.choose(cards)[0], [1])
|
||||
self.assertIn('第1张=1(流血) 第2张=2(流血/流血)', self.log)
|
||||
|
||||
def test_decision_is_recorded_left_to_right(self):
|
||||
cards = [card(300, '烧伤层数+1'), card(600, '施加2层流血')]
|
||||
with mock.patch.object(ap.decisions, 'record') as record:
|
||||
self.choose(cards)
|
||||
record.assert_called_once_with('gift', 2, 'keyword', system='bleed', hits=[[], ['流血']])
|
||||
|
||||
def test_unknown_system_skips_ocr(self):
|
||||
cards = [card(300, '烧伤'), card(600, '流血')]
|
||||
chosen, screen = self.choose(cards, system='unknown')
|
||||
self.assertEqual((chosen, screen.ocr_runs), ([0], 0))
|
||||
|
||||
|
||||
class InstallGiftPreferenceTest(unittest.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
self.lines = []
|
||||
self.original = mock.Mock(return_value='done')
|
||||
self.mirror_cls = type('Mirror', (), {'acquire_ego_gift': self.original})
|
||||
mirror_mod = types.ModuleType('tasks.mirror.mirror')
|
||||
mirror_mod.Mirror = self.mirror_cls
|
||||
package = types.ModuleType('tasks.mirror')
|
||||
package.mirror = mirror_mod
|
||||
self.auto = SimpleNamespace(find_element=mock.Mock(return_value=[(300, 300), (600, 300)]))
|
||||
modules = {'tasks': types.ModuleType('tasks'), 'tasks.mirror': package, 'tasks.mirror.mirror': mirror_mod,
|
||||
'module': types.ModuleType('module'),
|
||||
'module.automation': SimpleNamespace(auto=self.auto),
|
||||
'module.config': SimpleNamespace(cfg=SimpleNamespace(set_win_size=720))}
|
||||
patcher = mock.patch.dict(sys.modules, modules)
|
||||
patcher.start()
|
||||
self.addCleanup(patcher.stop)
|
||||
|
||||
def install(self, env=None):
|
||||
return ap.install_gift_preference(log=self.lines.append, env=env or {})
|
||||
|
||||
def test_env_zero_leaves_upstream_untouched(self):
|
||||
self.assertIsNone(self.install({ap.GIFT_KEYWORDS_ENV: '0'}))
|
||||
self.assertIs(self.mirror_cls.acquire_ego_gift, self.original)
|
||||
|
||||
def test_unreadable_table_is_an_error_and_not_installed(self):
|
||||
self.assertIsNone(self.install({ap.GIFT_KEYWORDS_ENV: '/nonexistent/k.json'}))
|
||||
self.assertIs(self.mirror_cls.acquire_ego_gift, self.original)
|
||||
self.assertTrue(self.lines[0].startswith('[ERROR] [lc_mcp] 饰品体系优先补丁跳过'))
|
||||
|
||||
def test_refuse_screen_passes_through(self):
|
||||
self.install()
|
||||
mirror = self.mirror_cls()
|
||||
mirror.system = 'bleed'
|
||||
self.assertEqual(mirror.acquire_ego_gift(type=2), 'done')
|
||||
self.original.assert_called_once_with(mirror, type=2)
|
||||
|
||||
def test_find_element_is_restored_after_an_exception(self):
|
||||
real = self.auto.find_element
|
||||
self.original.side_effect = RuntimeError('boom')
|
||||
self.install()
|
||||
mirror = self.mirror_cls()
|
||||
mirror.system = 'bleed'
|
||||
with self.assertRaises(RuntimeError):
|
||||
mirror.acquire_ego_gift()
|
||||
self.assertIs(self.auto.find_element, real)
|
||||
|
||||
def test_ranking_error_keeps_upstream_order(self):
|
||||
cards = [(300, 300), (600, 300)]
|
||||
|
||||
auto = self.auto
|
||||
|
||||
def original(mirror):
|
||||
return auto.find_element("mirror/road_in_mir/acquire_ego_gift_card.png",
|
||||
find_type='image_with_multiple_targets')
|
||||
|
||||
self.mirror_cls.acquire_ego_gift = original
|
||||
self.install()
|
||||
mirror = self.mirror_cls()
|
||||
mirror.system = 'bleed'
|
||||
with mock.patch.object(ap, '_ocr_lines', side_effect=RuntimeError('ocr down')):
|
||||
self.assertEqual(mirror.acquire_ego_gift(), cards)
|
||||
self.assertIn('关键词排序出错(RuntimeError: ocr down)', '\n'.join(self.lines))
|
||||
|
||||
def test_upstream_without_the_card_lookup_is_an_error(self):
|
||||
auto = self.auto
|
||||
|
||||
def original(mirror):
|
||||
return auto.find_element("mirror/road_in_mir/some_other_card.png")
|
||||
|
||||
self.mirror_cls.acquire_ego_gift = original
|
||||
self.install()
|
||||
self.assertIs(self.mirror_cls.acquire_ego_gift, original)
|
||||
self.assertIn('[ERROR] [lc_mcp] 饰品体系优先补丁跳过: 上游 Mirror.acquire_ego_gift 不再调用 find_element',
|
||||
'\n'.join(self.lines))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@@ -0,0 +1,313 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""镜牢商店按中文名购买(BACKLOG P2-6)。
|
||||
|
||||
上游必买只认 5 张图标模板; 汉化后商店每一格下面写着饰品中文名。补丁在上游必买循环最前面临时插占位项,
|
||||
点到占位项时按名字表 OCR, 命中就点那一格的图标, 之后的购买/确认仍是上游原来那段循环。
|
||||
端到端用例执行上游真实的 Shop.buy_gifts。
|
||||
"""
|
||||
import ast
|
||||
import json
|
||||
import os
|
||||
import sys
|
||||
import tempfile
|
||||
import types
|
||||
import unittest
|
||||
from pathlib import Path
|
||||
from types import SimpleNamespace
|
||||
from unittest import mock
|
||||
|
||||
REPO = Path(__file__).resolve().parents[1]
|
||||
sys.path.insert(0, str(REPO))
|
||||
from lc_mcp import aalc_patches as ap # noqa: E402
|
||||
|
||||
IN_SHOP = REPO / 'vendor' / 'aalc' / 'tasks' / 'mirror' / 'in_shop.py'
|
||||
MUST_PURCHASE = REPO / 'vendor' / 'aalc' / 'assets' / 'images' / 'default' / 'share' / 'mirror' / 'shop' / 'must_purchase'
|
||||
SCALE = 720 / 1440
|
||||
COINS = (551, 137) # 金币图标(1280x720)
|
||||
|
||||
|
||||
def icon_at(col, row):
|
||||
"""第 row 行第 col 列商品的图标中心; 列距 300、名字行在金币下方 +409/+716(1440 标定)。"""
|
||||
return (COINS[0] + (147 + 300 * col) * SCALE, COINS[1] + (409 + 307 * row - ap.SHOP_NAME_TO_ICON) * SCALE)
|
||||
|
||||
|
||||
class ShopNameHitsTest(unittest.TestCase):
|
||||
|
||||
def test_real_screenshot_layout(self):
|
||||
# docs/feedback/mirror_20261002_181322/special_shop_missed.png(1920x1080): 金币模板匹配在 (827, 206),
|
||||
# 名字行与图标中心是对着截图量的
|
||||
lines = [('人格技能观测', 937, 513), ('替换格里高尔的技能', 1162, 513), ('辉光变动仪', 1627, 513),
|
||||
('无头肖像', 937, 743), ('梦中的电子羊', 1162, 743), ('黏性淤浆', 1627, 743),
|
||||
('特殊商店', 383, 185), ('强化饰品', 265, 588), ('刷新', 1521, 183), ('离开', 1698, 970)]
|
||||
names = ('无头肖像', '辉光变动仪', '离开', '强化饰品')
|
||||
hits = ap.shop_name_hits(lines, names, (827, 206), 1080 / 1440)
|
||||
self.assertEqual([name for name, _ in hits], ['无头肖像', '辉光变动仪'])
|
||||
for (_, (x, y)), icon in zip(hits, [(937, 627), (1627, 397)]):
|
||||
self.assertAlmostEqual(x, icon[0], delta=3)
|
||||
self.assertAlmostEqual(y, icon[1], delta=3)
|
||||
|
||||
def test_only_whole_names_match(self):
|
||||
x, y = icon_at(0, 0)
|
||||
y += ap.SHOP_NAME_TO_ICON * SCALE
|
||||
names = ('缘分残片', '归途')
|
||||
hit = lambda text: [n for n, _ in ap.shop_name_hits([(text, x, y)], names, COINS, SCALE)]
|
||||
self.assertEqual(hit('缘分 残片'), ['缘分残片'])
|
||||
self.assertEqual(hit('缘分残片+'), ['缘分残片'])
|
||||
self.assertEqual(hit('缘分残片++'), ['缘分残片'])
|
||||
self.assertEqual(hit('归途。'), ['归途'])
|
||||
self.assertEqual(hit('残片'), [])
|
||||
self.assertEqual(hit('缘分残片的回忆'), [])
|
||||
|
||||
def test_table_order_wins_over_screen_order(self):
|
||||
lines = [('归途', *icon_at(0, 0)), ('缘分残片', *icon_at(3, 1))]
|
||||
lines = [(t, x, y + ap.SHOP_NAME_TO_ICON * SCALE) for t, x, y in lines]
|
||||
hits = ap.shop_name_hits(lines, ('缘分残片', '归途'), COINS, SCALE)
|
||||
self.assertEqual(hits, [('缘分残片', icon_at(3, 1)), ('归途', icon_at(0, 0))])
|
||||
|
||||
|
||||
class ShopGiftsTableTest(unittest.TestCase):
|
||||
|
||||
def test_shipped_table(self):
|
||||
names = ap.load_shop_gifts()
|
||||
self.assertEqual(names, ('缘分残片', '卡蜜拉', '采血包', '归途', '石版字符'))
|
||||
|
||||
@unittest.skipUnless(MUST_PURCHASE.is_dir(), 'vendor/aalc 子模块未检出')
|
||||
def test_shipped_table_covers_every_upstream_template(self):
|
||||
with open(ap.SHOP_NAMES_FILE, encoding='utf-8') as f:
|
||||
templates = {item['template'] for item in json.load(f)['gifts']}
|
||||
self.assertEqual(templates, set(os.listdir(MUST_PURCHASE)))
|
||||
|
||||
def test_bad_tables_raise_value_error(self):
|
||||
bad = ['[]', '{"gifts": []}', '{"gifts": {}}', '{"gifts": ["归途"]}', '{"gifts": [{"name": ""}]}',
|
||||
'{"gifts": [{"name": "。"}]}', '{"gifts": [{"name": "归途"}, {"name": "归 途"}]}']
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
path = os.path.join(tmp, 's.json')
|
||||
for content in bad:
|
||||
with self.subTest(content=content):
|
||||
with open(path, 'w', encoding='utf-8') as f:
|
||||
f.write(content)
|
||||
with self.assertRaises(ValueError):
|
||||
ap.load_shop_gifts(path)
|
||||
|
||||
|
||||
class ShopScreen:
|
||||
"""商店界面: 一格格商品(图标 + 下面的名字), 点图标弹购买框, 点购买扣钱, 再点确认。"""
|
||||
|
||||
def __init__(self, items, money=1000, price=150):
|
||||
self.items = [dict(item) for item in items]
|
||||
self.money, self.price = money, price
|
||||
self.popup, self.confirm = None, False
|
||||
self.bought, self.icon_clicks = [], []
|
||||
self.screenshot = object()
|
||||
self.model = None
|
||||
|
||||
def icon(self, item):
|
||||
return icon_at(item['col'], item['row'])
|
||||
|
||||
def take_screenshot(self, *args, **kwargs):
|
||||
self.screenshot = object()
|
||||
return self.screenshot
|
||||
|
||||
def find_element(self, target, find_type='image', **kwargs):
|
||||
if target == ap.SHOP_COINS:
|
||||
return COINS
|
||||
if target.startswith('mirror/shop/must_purchase/'):
|
||||
template = target.rsplit('/', 1)[1]
|
||||
return next((self.icon(i) for i in self.items if i.get('template') == template), False)
|
||||
return [] if find_type == 'image_with_multiple_targets' else False
|
||||
|
||||
def click_element(self, target, *args, **kwargs):
|
||||
if target == ap.SHOP_PURCHASE:
|
||||
if self.popup is None or self.money < self.price:
|
||||
return False
|
||||
self.money -= self.price
|
||||
self.bought.append(self.popup['name'])
|
||||
self.items.remove(self.popup)
|
||||
self.popup, self.confirm = None, True
|
||||
return True
|
||||
if target == ap.SHOP_CONFIRM:
|
||||
done, self.confirm = self.confirm, False
|
||||
return done
|
||||
position = self.find_element(target)
|
||||
if position:
|
||||
self.mouse_click(*position)
|
||||
return True
|
||||
return False
|
||||
|
||||
def mouse_click(self, x, y, *args, **kwargs):
|
||||
for item in self.items:
|
||||
ix, iy = self.icon(item)
|
||||
if abs(ix - x) < 30 and abs(iy - y) < 30:
|
||||
self.popup = item
|
||||
self.icon_clicks.append(item['name'])
|
||||
return True
|
||||
|
||||
def mouse_click_blank(self, *args, **kwargs):
|
||||
self.popup = None
|
||||
|
||||
def mouse_action_with_pos(self, *args, **kwargs):
|
||||
pass
|
||||
|
||||
def find_language_text(self, *args, **kwargs):
|
||||
return False
|
||||
|
||||
def run(self, image):
|
||||
lines = [('刷新', COINS[0] + 520 * SCALE, COINS[1] - 30 * SCALE),
|
||||
('强化饰品', COINS[0] - 750 * SCALE, COINS[1] + 500 * SCALE)]
|
||||
for item in self.items:
|
||||
x, y = self.icon(item)
|
||||
lines.append((item.get('label', item['name']), x, y + ap.SHOP_NAME_TO_ICON * SCALE))
|
||||
return SimpleNamespace(txts=tuple(t for t, _, _ in lines),
|
||||
boxes=[[[x - 10, y - 5], [x + 10, y - 5], [x + 10, y + 5], [x - 10, y + 5]]
|
||||
for _, x, y in lines])
|
||||
|
||||
|
||||
@unittest.skipUnless(IN_SHOP.is_file(), 'vendor/aalc 子模块未检出')
|
||||
class UpstreamBuyGiftsTest(unittest.TestCase):
|
||||
"""执行上游真实的 Shop.buy_gifts: 买完必买项, 钱读成 0 不刷新, 一轮就结束。"""
|
||||
|
||||
def setUp(self):
|
||||
self.lines = []
|
||||
tree = ast.parse(IN_SHOP.read_text(encoding='utf-8'))
|
||||
cls = next(n for n in tree.body if isinstance(n, ast.ClassDef) and n.name == 'Shop')
|
||||
self.fn_node = next(n for n in cls.body if isinstance(n, ast.FunctionDef) and n.name == 'buy_gifts')
|
||||
self.templates = ['mirror/shop/must_purchase/%s' % name for name in
|
||||
('carmilla.png', 'homeward.png', 'lithograph.png', 'phlebotomy_pack.png',
|
||||
'piece_of_relationship.png')]
|
||||
|
||||
def play(self, items, patched=True, audit=False, env=None, **screen_kwargs):
|
||||
screen = ShopScreen(items, **screen_kwargs)
|
||||
must = list(self.templates)
|
||||
ns = dict(auto=screen, must_purchase=must, sleep=lambda *a: None, retry=lambda: True, log=mock.Mock(),
|
||||
cfg=SimpleNamespace(set_win_size=720, not_skip_whitegossypium=False))
|
||||
exec(compile(ast.Module(body=[self.fn_node], type_ignores=[]), str(IN_SHOP), 'exec'), ns)
|
||||
shop_cls = type('Shop', (), {'buy_gifts': ns['buy_gifts'], 'RestartGame': RuntimeError})
|
||||
in_shop = types.ModuleType('tasks.mirror.in_shop')
|
||||
in_shop.Shop, in_shop.must_purchase = shop_cls, must
|
||||
package = types.ModuleType('tasks.mirror')
|
||||
package.in_shop = in_shop
|
||||
modules = {'tasks': types.ModuleType('tasks'), 'tasks.mirror': package, 'tasks.mirror.in_shop': in_shop,
|
||||
'module': types.ModuleType('module'),
|
||||
'module.automation': SimpleNamespace(auto=screen),
|
||||
'module.config': SimpleNamespace(cfg=ns['cfg']),
|
||||
'module.ocr': SimpleNamespace(ocr=screen)}
|
||||
with mock.patch.dict(sys.modules, modules):
|
||||
if audit:
|
||||
ap.install_shop_audit(log=self.lines.append)
|
||||
if patched:
|
||||
self.assertIsNotNone(ap.install_shop_by_name(log=self.lines.append, env=env or {}))
|
||||
shop = shop_cls()
|
||||
shop.system, shop.shopping_strategy, shop.fuse_aggressive_switch = 'bleed', False, False
|
||||
shop.second_system, shop.max_keyword_refresh, shop.max_normal_refresh = False, 0, 0
|
||||
shop._get_cost = lambda: 0
|
||||
shop.buy_gifts()
|
||||
self.assertEqual(must, self.templates, '占位项必须拿掉')
|
||||
self.assertNotIn('click_element', vars(screen), 'click_element 必须还原')
|
||||
return screen
|
||||
|
||||
@property
|
||||
def log(self):
|
||||
return '\n'.join(self.lines)
|
||||
|
||||
def test_patch_hooks_into_the_current_upstream(self):
|
||||
self.play([])
|
||||
self.assertIn('patch: 商店必买先按中文名找(shop_gifts.json, 5 个名字)', self.log)
|
||||
self.assertNotIn('[ERROR]', self.log)
|
||||
|
||||
def test_name_on_the_grid_is_bought(self):
|
||||
items = [{'name': '缘分残片', 'col': 2, 'row': 1}, {'name': '黏性淤浆', 'col': 0, 'row': 0}]
|
||||
self.assertEqual(self.play(items, patched=False).bought, []) # 图标模板没认出来
|
||||
self.assertEqual(self.play(items).bought, ['缘分残片'])
|
||||
self.assertIn('商店: 按名字找到「缘分残片」, 点它的图标', self.log)
|
||||
|
||||
def test_table_order_decides_when_money_is_short(self):
|
||||
items = [{'name': '归途', 'col': 0, 'row': 0}, {'name': '缘分残片', 'col': 3, 'row': 1}]
|
||||
self.assertEqual(self.play(items, money=150).bought, ['缘分残片'])
|
||||
self.assertEqual(self.play(items, money=1000).bought, ['缘分残片', '归途'])
|
||||
|
||||
def test_templates_still_back_up_a_misread_name(self):
|
||||
items = [{'name': '卡蜜拉', 'label': '卡密拉', 'template': 'carmilla.png', 'col': 1, 'row': 0}]
|
||||
self.assertEqual(self.play(items).bought, ['卡蜜拉'])
|
||||
|
||||
def test_unaffordable_item_is_not_clicked_forever(self):
|
||||
screen = self.play([{'name': '采血包', 'col': 1, 'row': 1}], money=0)
|
||||
self.assertEqual(screen.bought, [])
|
||||
self.assertEqual(screen.icon_clicks, ['采血包'] * ap.SHOP_NAME_CLICKS)
|
||||
|
||||
def test_audit_sees_the_name_purchase(self):
|
||||
with mock.patch.object(ap.decisions, 'record') as record:
|
||||
self.play([{'name': '缘分残片', 'col': 2, 'row': 1}], audit=True)
|
||||
self.assertEqual(record.call_args_list, [
|
||||
mock.call('shop', '缘分残片', 'name_match', on_screen=['缘分残片']),
|
||||
mock.call('shop', 'shop_by_name', 'purchase_clicked', system='bleed')])
|
||||
|
||||
def test_env_zero_keeps_upstream(self):
|
||||
self.assertIsNone(ap.install_shop_by_name(log=self.lines.append, env={ap.SHOP_NAMES_ENV: '0'}))
|
||||
|
||||
|
||||
class InstallShopByNameTest(unittest.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
self.lines = []
|
||||
self.must = ['mirror/shop/must_purchase/a.png']
|
||||
self.auto = SimpleNamespace(click_element=mock.Mock(return_value=False), find_element=mock.Mock())
|
||||
self.shop_cls = type('Shop', (), {'buy_gifts': mock.Mock(side_effect=RuntimeError('boom'))})
|
||||
in_shop = types.ModuleType('tasks.mirror.in_shop')
|
||||
in_shop.Shop, in_shop.must_purchase = self.shop_cls, self.must
|
||||
package = types.ModuleType('tasks.mirror')
|
||||
package.in_shop = in_shop
|
||||
modules = {'tasks': types.ModuleType('tasks'), 'tasks.mirror': package, 'tasks.mirror.in_shop': in_shop,
|
||||
'module': types.ModuleType('module'),
|
||||
'module.automation': SimpleNamespace(auto=self.auto),
|
||||
'module.config': SimpleNamespace(cfg=SimpleNamespace(set_win_size=720))}
|
||||
patcher = mock.patch.dict(sys.modules, modules)
|
||||
patcher.start()
|
||||
self.addCleanup(patcher.stop)
|
||||
|
||||
def test_placeholders_and_click_are_restored_after_an_exception(self):
|
||||
real = self.auto.click_element
|
||||
ap.install_shop_by_name(log=self.lines.append, env={})
|
||||
with self.assertRaises(RuntimeError):
|
||||
self.shop_cls().buy_gifts()
|
||||
self.assertEqual(self.must, ['mirror/shop/must_purchase/a.png'])
|
||||
self.assertIs(self.auto.click_element, real)
|
||||
|
||||
def test_upstream_without_the_must_purchase_loop_is_an_error(self):
|
||||
def buy_gifts(shop):
|
||||
return shop # 不再逐个点 must_purchase
|
||||
|
||||
self.shop_cls.buy_gifts = buy_gifts
|
||||
self.assertIsNone(ap.install_shop_by_name(log=self.lines.append, env={}))
|
||||
self.assertIs(self.shop_cls.buy_gifts, buy_gifts)
|
||||
self.assertIn('[ERROR] [lc_mcp] 商店按名字购买跳过: 上游 Shop.buy_gifts 不再逐个', '\n'.join(self.lines))
|
||||
|
||||
def test_unreadable_table_is_an_error(self):
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
path = os.path.join(tmp, 's.json')
|
||||
with open(path, 'w', encoding='utf-8') as f:
|
||||
f.write('{"gifts": []}')
|
||||
self.assertIsNone(ap.install_shop_by_name(log=self.lines.append, env={ap.SHOP_NAMES_ENV: path}))
|
||||
self.assertTrue(self.lines[0].startswith('[ERROR] [lc_mcp] 商店按名字购买跳过'))
|
||||
|
||||
def test_ocr_error_falls_back_to_templates(self):
|
||||
calls = []
|
||||
auto = self.auto
|
||||
|
||||
def buy_gifts(shop):
|
||||
for commodity in must_purchase():
|
||||
calls.append((commodity, auto.click_element(commodity, threshold=0.85)))
|
||||
auto.click_element('mirror/shop/purchase_assets.png')
|
||||
|
||||
must_purchase = lambda: list(self.must) # noqa: E731
|
||||
self.shop_cls.buy_gifts = buy_gifts
|
||||
self.auto.screenshot = object()
|
||||
self.auto.find_element = mock.Mock(side_effect=RuntimeError('ocr'))
|
||||
ap.install_shop_by_name(log=self.lines.append, env={})
|
||||
self.shop_cls().buy_gifts()
|
||||
self.assertEqual(calls, [(ap.SHOP_BY_NAME, False)] * ap.SHOP_BY_NAME_SLOTS
|
||||
+ [('mirror/shop/must_purchase/a.png', False)])
|
||||
self.assertIn('商店按名字购买出错(RuntimeError: ocr), 只用图标模板', '\n'.join(self.lines))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@@ -0,0 +1,62 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""镜牢商店"必买 / 必卖 / 公式合成"清单(BACKLOG P0-1)。
|
||||
|
||||
2026-11-14 实测: 上游 tasks/mirror/__init__.py 按旧路径 ./assets/images/share/... 列目录, 三个清单恒为空,
|
||||
进店 51 秒一件没买。上游 8196e72(V1.6.1) 改成按 assets/images/default/share/... 列, 本地补丁随之删掉;
|
||||
这里守着上游别再退回空清单。
|
||||
"""
|
||||
import os
|
||||
import types
|
||||
import unittest
|
||||
from contextlib import contextmanager
|
||||
from pathlib import Path
|
||||
|
||||
REPO = Path(__file__).resolve().parents[1]
|
||||
AALC = REPO / 'vendor' / 'aalc'
|
||||
INIT = AALC / 'tasks' / 'mirror' / '__init__.py'
|
||||
SHOP_LISTS = ('must_purchase', 'must_be_abandoned', 'fusion_result')
|
||||
IMAGE_ROOTS = ('dark/zh_cn', 'dark/en', 'dark/share', 'default/zh_cn', 'default/en', 'default/share')
|
||||
|
||||
|
||||
@contextmanager
|
||||
def chdir(path):
|
||||
old = os.getcwd()
|
||||
os.chdir(path)
|
||||
try:
|
||||
yield
|
||||
finally:
|
||||
os.chdir(old)
|
||||
|
||||
|
||||
def upstream_mirror_package():
|
||||
"""在 AALC 目录下执行上游 tasks/mirror/__init__.py(任务进程的工作目录也是这里)。"""
|
||||
module = types.ModuleType('tasks.mirror')
|
||||
with chdir(AALC):
|
||||
exec(compile(INIT.read_text(encoding='utf-8'), str(INIT), 'exec'), module.__dict__)
|
||||
return module
|
||||
|
||||
|
||||
@unittest.skipUnless(INIT.is_file(), 'vendor/aalc 子模块未检出')
|
||||
class UpstreamShopListTest(unittest.TestCase):
|
||||
|
||||
def test_upstream_lists_are_filled(self):
|
||||
package = upstream_mirror_package()
|
||||
self.assertEqual([len(getattr(package, k)) for k in SHOP_LISTS], [5, 19, 31])
|
||||
self.assertIn('mirror/shop/must_purchase/carmilla.png', package.must_purchase)
|
||||
|
||||
def test_every_listed_name_resolves_under_some_image_root(self):
|
||||
package = upstream_mirror_package()
|
||||
images = AALC / 'assets' / 'images'
|
||||
for kind in SHOP_LISTS:
|
||||
for name in getattr(package, kind):
|
||||
with self.subTest(name=name):
|
||||
self.assertTrue(any((images / root / name).is_file() for root in IMAGE_ROOTS))
|
||||
|
||||
def test_roots_match_aalc_path_manager(self):
|
||||
source = (AALC / 'utils' / 'path_manager.py').read_text(encoding='utf-8')
|
||||
for root in IMAGE_ROOTS:
|
||||
self.assertIn('"%s"' % root, source)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@@ -2,6 +2,7 @@ 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__))))
|
||||
@@ -51,8 +52,33 @@ class RegionTest(unittest.TestCase):
|
||||
)
|
||||
|
||||
|
||||
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 = {
|
||||
@@ -76,6 +102,208 @@ class TeamOcrTest(unittest.TestCase):
|
||||
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:
|
||||
"""编队界面: 列表按 3 次下拖翻一屏, 点哪条顶栏就变成哪条。"""
|
||||
|
||||
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 // 3, 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_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(共 4 轮)', 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']), 4)
|
||||
|
||||
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']
|
||||
|
||||
@@ -0,0 +1,190 @@
|
||||
# -*- 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_env_switch_leaves_upstream_untouched(self):
|
||||
self.assertIsNone(self.install(env={ap.TYPED_ROAD_ENV: '0'}))
|
||||
self.assertIs(self.road.search_road_simple_keyboard, self.original)
|
||||
self.assertIs(self.mirror.search_road_simple_keyboard, self.original)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
Vendored
+1
-1
Submodule vendor/aalc updated: e1d1749905...2fcb1b4620
Reference in New Issue
Block a user