AALC 升级到 V1.6.1 并按零协汉化核对镜牢补丁

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

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
yws
2026-11-14 08:43:27 +00:00
co-authored by Claude Opus 5.5
parent 51525722cd
commit 72d2ca1a5b
10 changed files with 410 additions and 345 deletions
+7 -5
View File
@@ -152,7 +152,7 @@ MCP 初始化说明与工具描述均指导 AI 优先使用 AALC:常规日常
| `road` | `lowest` 下一列最优 / `next_best` 更优方向进不去 / `fallback` 退回按 ↑ |
| `theme_pack` | `preferred` 达到优选阈值 / `highest_weight` 刷新后取最高权重 / `event_pack` 最左活动卡包 |
| `gift` | `keyword` 命中体系关键词 / `no_keyword`(记的是交给 AALC 的第一顺位,白棉花、已持有仍由 AALC 处理) |
| `event` | `text` / `index` 按表选 / `deferred` 表里有但交给 AALC / `not_in_table`(带 `options`,可直接拿来补表) |
| `event` | `text` 按表选 / `deferred` 认出了表里的事件但交给 AALC / `not_in_table`(带 `options`,可直接拿来补表) |
| `shop` | `purchase_clicked` 点到了购买按钮(`choice` 是之前点的商品:必买项名、`level_IV_to_buy`、`by_position` 本体系饰品) |
### 任务进程里的保护
@@ -172,8 +172,7 @@ MCP 初始化说明与工具描述均指导 AI 优先使用 AALC:常规日常
并以退出码 4 结束,`task_status` 显示 `failed`;AALC 正常返回不再被当成打完。
- **指定次数**:`mirror` 传 `count` 时本次临时关闭 `infinite_dungeons`(开着时 AALC 会把次数改成 9999),
原值和次数一起写入恢复文件,结束或被强杀后都会写回。
- **商店清单**:上游按已不存在的 `assets/images/share/...` 列目录,必买/必卖/公式合成清单恒为空。
`mirror`/`all` 任务按各主题/语言图片根补齐(当前 5/19/31 项)。
- **商店清单**:必买/必卖/公式合成清单为空的问题,上游 V1.6.1 已修,本地补丁已删。
- **镜牢按体系名选队**:按 `team_system` 在编队列表里点同名队伍(流血/斩击/…),点完核对顶栏队名。
名字先归一(去空白、全角转半角、纠正 `震颐`/`沉论`/`编#` 等误读);精确匹配优先,
否则接受这一屏唯一的"名字+后缀"(`流血队`、`流血(X)`),多条就不点。没找到时日志列出每屏看到的名字。
@@ -181,8 +180,11 @@ MCP 初始化说明与工具描述均指导 AI 优先使用 AALC:常规日常
按上游权重(事件 < 商店 < 战斗 < …)依次按方向键,进不去再退回 ↑;不拖地图。`LCP_TYPED_ROAD=0` 关闭。
- **饰品选择按体系关键词**:镜牢路上的饰品 N 选一,先整屏 OCR,按卡面上命中当前体系关键词的行数给卡排序,
再交给 AALC 原逻辑(跳过白棉花、已持有排后)。关键词表在 `lc_mcp/data/gift_keywords.json`。
- **事件选项表**:事件出现选项时整屏 OCR,认出 `lc_mcp/data/event_choices.json` 里的事件就按选项文字(或第几项)点;
没收录的事件照旧交给 AALC,日志会打印这一屏的选项文字,便于补表。
- **事件选项表**:事件出现选项时整屏 OCR,按同一屏其它选项的原文(零协汉化)认出 `lc_mcp/data/event_choices.json`
里的事件,就点表里那一项;不靠事件名(汉化数据没有标题)。没收录的事件照旧交给 AALC,
日志会打印这一屏的选项文字,便于补表。表里的选择优先于 AALC 的"有 ??? 先点 ???",小指良单通模式也一样。
- **挂不上就报错**:事件表、饰品排序这两个补丁靠拦截 AALC 的某个调用挂进去,安装时先查上游源码;
上游改了写法时记 `[ERROR]` 并跳过该补丁,不会悄悄失效。
## 无人值守
+61 -19
View File
@@ -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,7 +61,9 @@ fusion_result 0
**风险**:低。纯路径/清单;不改判定逻辑。
**状态(2026-11-14 云端)**:已实现,待实机验收。
**状态(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` 依次搜各主题/语言目录)没坏,只是列目录列空了。
@@ -121,6 +142,8 @@ Dijkstra 那套(`search_road.py:735`,代价 event 1 / shop 2 / battle 4 / bo
- 关键词表 `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`),覆盖两张/三张卡、选一/选二、
已持有、白棉花、全是白棉花、误读、无命中。
@@ -146,26 +169,43 @@ Dijkstra 那套(`search_road.py:735`,代价 event 1 / shop 2 / battle 4 / bo
**风险**:低-中。选项点错可能拿不到奖励,但不会卡死。
**状态(2026-11-14 云端)**:已实现,待实机验收。
**状态(2026-11-14 云端)**:已实现,待实机验收。按零协汉化重写过一次(见下)。
- 做法:`install_event_choices()` 包住 `Mirror.event_handling`,调用期间临时替换 `auto.click_element`。
上游每轮挑选项的第一步是 `click_element("event/unknown_event.png")`,补丁在这一步之前插一次判断:
- 做法:`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`)。
其余情况(不在选项画面、事件没收录、表里的选项不在画面上)照常交给上游。
- 表 `lc_mcp/data/event_choices.json`(JSON,不加依赖),10 条,全部取自
`docs/skills/limbus-mirror-speedrun/references/event-choices.md` 里无判定/无战斗的直出或免费奖励。
- `text`(按选项文字)优先:红色坐像「侧耳倾听」、炸鸡对决「鸡肉就是鸡肉」、梦中的电子羊「你不是特别的」、失明巨人「什么都没有写」。
- `index`(按第几项)只用于事件的第一屏选项;画面没变时最多重试 3 次,之后的分支交给上游。参考文档提醒过
Wiki 编号可能与当前顺序不同,所以编号规则一律以实机日志核对。
- 规则按顺序匹配,`折射的往昔的睡袋`(1)排在 `往昔的睡袋`(2)前面。
- 日志:每屏选项只打一次,`[lc_mcp] 事件 <名>: 1=… | 2=…; 选第 N 项(理由)`;没收录时
`事件选项: 1=… | 2=…; 表里没有这个事件, 交给 AALC`,可直接拿来补表。
- 回滚:`LCP_EVENT_CHOICES=0`;表读不了记 `[ERROR]` 并不装补丁。
- 单测执行上游真实的 `event_handling`(`tests/test_event_choices.py`),覆盖按文字、按编号、编号超出、规则顺序、
第二屏交回上游、点击没生效时重试、未收录与上游一致。
- **待实机确认**:事件名是否出现在选项画面上(不出现则规则永远不命中,只会退回上游,不会点错);
选项文字与左边缘同一行的假设(`EVENT_OPTION_ROW`)。
选项对上表里某个事件,就点表里那一项的左边缘,并把这个位置当成 "???" 交还上游(`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(它会点有"优势判定"的 1,与参考文档对折射版的建议一致)。
- `浸染棉花`(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` 的日志里选项文字是否完整。
---
@@ -227,6 +267,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 决策审计日志
+105 -129
View File
@@ -676,62 +676,6 @@ def install_system_team_selection(log=print):
return original
# ---------------------------------------------------------------- 镜牢商店清单
# 上游 ebb6629 把图片挪到 assets/images/<主题>/<语言>/ 下, tasks/mirror/__init__.py 却仍按
# ./assets/images/share/mirror/shop/... 列目录, 三个清单恒为空。2026-11-14 实测进店 51 秒,
# 打印三次 "开始购买必买项" 一件没买; 弃用饰品识别与公式合成也一起空转。
# 按名字找图(mirror/shop/<清单>/<文件>)由 path_manager 依次搜各主题/语言目录, 那一层没坏。
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')
def shop_list_images(kind, images_dir=os.path.join('assets', 'images'), roots=IMAGE_ROOTS):
"""各主题/语言目录下 mirror/shop/<kind> 的图片, 按 AALC 图片名格式去重排序。"""
names = set()
for root in roots:
folder = os.path.join(images_dir, *root.split('/'), 'mirror', 'shop', kind)
try:
entries = os.listdir(folder)
except OSError:
continue
names.update(name for name in entries
if name.lower().endswith('.png') and os.path.isfile(os.path.join(folder, name)))
return ['mirror/shop/%s/%s' % (kind, name) for name in sorted(names)]
def install_shop_lists(log=print, images_dir=os.path.join('assets', 'images')):
"""原地补齐 tasks.mirror 的三个商店清单; 上游清单已非空时不动。
in_shop 用 from tasks.mirror import ... 在导入时绑定列表对象, 所以必须原地 extend,
给模块属性重新赋值对它无效。
"""
try:
import tasks.mirror as mirror_pkg
except Exception as e:
log('[lc_mcp] 商店清单补丁跳过: 无法导入 tasks.mirror: %s' % e)
return {}
try:
from utils.path_manager import PathManager
roots = tuple(PathManager.DEFAULT_ACTIVE_PATHS)
except Exception:
roots = IMAGE_ROOTS
filled = {}
for kind in SHOP_LISTS:
current = getattr(mirror_pkg, kind, None)
if not isinstance(current, list):
log('[lc_mcp] 商店清单补丁跳过 %s: 上游没有这个列表' % kind)
continue
if current:
continue # 上游已修好或已补过
current.extend(shop_list_images(kind, images_dir, roots))
filled[kind] = len(current)
if filled:
log('[lc_mcp] patch: 镜牢商店清单按 assets/images/<主题>/<语言> 补齐: %s'
% ', '.join('%s=%d' % item for item in filled.items()))
return filled
# ---------------------------------------------------------------- 镜牢键盘寻路按节点类型
# config.yaml 开着 mirror_keyboard_simple_pathfinding 时, AALC 每一步只按 ↑ 进最上面的节点,
@@ -961,6 +905,10 @@ def install_gift_preference(log=print, env=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):
hits = gift_card_hits(cards, _ocr_lines(auto), keywords, cfg.set_win_size / 1440)
@@ -998,6 +946,7 @@ def install_gift_preference(log=print, env=None):
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
@@ -1006,45 +955,68 @@ def install_gift_preference(log=print, env=None):
# ---------------------------------------------------------------- 事件选项表
# 2026-11-14 核对: Mirror.event_handling() 不认事件, 有 "???"/直接拿饰品/优势判定就选它, 否则点第一个选项。
# 这里在上游每轮挑选项之前(它先找 event/unknown_event.png)插一步: 画面上有选项时整屏 OCR,
# 认出表里的事件就按选项文字(或第几项)点; 没认出、或表里的选项不在画面上, 交给上游原逻辑。
# 这里在上游每轮挑选项之前(它先 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 # 一次事件里按文字最多点几次
EVENT_INDEX_TRIES = 3 # 按编号点: 只在第一屏选项, 画面没变时最多重试几次
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 load_event_choices(path=EVENT_CHOICES_FILE):
"""读事件表, 返回 [{'name', 'match', 'text', 'index'}]; 格式不对抛 ValueError。"""
"""读事件表, 返回 [{'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": [...]}')
def words(item, key):
value = item.get(key, [])
if not isinstance(value, list) or not all(isinstance(w, str) for w in value):
raise ValueError('%s 的 %s 应是字符串列表' % (item.get('name', '?'), key))
return tuple(normalize_team_name(w) for w in value if normalize_team_name(w))
rules = []
for item in events:
if not isinstance(item, dict):
raise ValueError('events 的每一项应是对象')
name = str(item.get('name') or '?')
index = item.get('index')
if index is not None and (isinstance(index, bool) or not isinstance(index, int) or index < 1):
raise ValueError('%s 的 index 应是 >= 1 的整数' % name)
rule = {'name': name, 'match': words(item, 'match'), 'text': words(item, 'text'), 'index': index}
if not rule['match']:
raise ValueError('%s 缺少 match' % name)
if not rule['text'] and index is None:
raise ValueError('%s 至少要有 text 或 index' % name)
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
@@ -1057,30 +1029,19 @@ def event_options(markers, lines, scale):
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_team_name(text))
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 match_event_rule(rules, lines):
"""画面上的文字命中的第一条规则; 没有返回 None。"""
screen = [normalize_team_name(text) for text, _, _ in lines]
def choose_event_option(rules, texts):
"""按画面上的选项认事件: 返回 (规则, 要点第几项(0 起))。
没认出返回 (None, None); 认出了但要点的那项没读到返回 (规则, None)。
"""
for rule in rules:
if any(word in text for word in rule['match'] for text in screen):
return rule
return None
def choose_event_option(rule, texts):
"""返回 (第几项(0 起), 'text'|'index', 理由); 选不出返回 (None, None, 理由)。"""
for word in rule['text']:
for i, text in enumerate(texts):
if word in text:
return i, 'text', '选项文字含「%s」' % word
if rule['index'] is not None:
if rule['index'] <= len(texts):
return rule['index'] - 1, 'index', '按表选第 %d 项' % rule['index']
return None, None, '表里是第 %d 项, 画面上只有 %d 项' % (rule['index'], len(texts))
return None, None, '表里的选项文字不在画面上'
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):
@@ -1107,17 +1068,18 @@ def install_event_choices(log=print, env=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):
"""按表点了一个选项返回 True; 其余情况返回 False 交给上游。"""
"""按表点了一个选项返回点的位置; 其余情况返回 None 交给上游。"""
markers = auto.find_element(EVENT_OPTION, find_type='image_with_multiple_targets', threshold=0.75)
if not markers:
return False
lines = _ocr_lines(auto)
options = event_options(markers, lines, cfg.set_win_size / 1440)
return None
options = event_options(markers, _ocr_lines(auto), cfg.set_win_size / 1440)
texts = tuple(text for _, text in options)
state['rule'] = state['rule'] or match_event_rule(rules, lines)
rule = state['rule']
shown = ' | '.join('%d=%s' % (i + 1, text or '?') for i, text in enumerate(texts))
def once(message):
@@ -1127,46 +1089,59 @@ def install_event_choices(log=print, env=None):
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 False
i, how, reason = choose_event_option(rule, texts)
if how == 'text' and state['text_clicks'] >= EVENT_TEXT_CLICKS:
how, reason = None, '按文字已点 %d 次' % EVENT_TEXT_CLICKS
if how == 'index' and (state['signature'] not in (None, texts) or state['index_tries'] >= EVENT_INDEX_TRIES):
how, reason = None, '编号只用于第一屏选项'
if how is None:
if once('[lc_mcp] 事件 %s: %s; %s, 交给 AALC' % (rule['name'], shown, reason)):
decisions.record('event', None, 'deferred', event=rule['name'], options=list(texts), why=reason)
return False
if how == 'text':
state['text_clicks'] += 1
else:
state['index_tries'] += 1
state['signature'] = texts
log('[lc_mcp] 事件 %s: %s; 选第 %d 项(%s)' % (rule['name'], shown, i + 1, reason))
decisions.record('event', i + 1, how, event=rule['name'], options=list(texts), why=reason)
position = options[i][0]
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 True
return position
def event_handling(self, *args, **kwargs):
state = {'rule': None, 'signature': None, 'index_tries': 0, 'text_clicks': 0, 'logged': set()}
real = auto.click_element
state = {'clicks': 0, 'logged': set(), 'clicked': None}
real_find, real_click = auto.find_element, auto.mouse_click
def click_element(target, *a, **kw):
if target == EVENT_HOOK:
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
try:
if decide(state):
return True # 上游当作点到了选项: event_chance -= 1, 重新截图
clicked = decide(state)
except Exception as e:
log('[lc_mcp] 事件选项表出错(%s: %s), 交给 AALC' % (type(e).__name__, e))
return real(target, *a, **kw)
clicked = None
if clicked is None:
return real_find(target, *a, **kw)
state['clicked'] = clicked
return clicked # 上游当作找到了 "???": event_chance -= 1, 重新截图
with _override(auto, 'click_element', click_element):
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
@@ -1214,6 +1189,7 @@ def install_shop_audit(log=print):
_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
+1 -2
View File
@@ -14,7 +14,7 @@ from .aalc_engine import bootstrap
from .aalc_patches import (WindowGuard, driver_click_tasks, headless_hdr_warning,
install_default_battle_team, install_event_choices, install_exact_team_match,
install_gift_preference, install_robust_set_foreground, install_shop_audit,
install_shop_lists, install_system_team_selection, install_theme_pack_audit,
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
@@ -130,7 +130,6 @@ def _run(task, params):
# 镜牢: 编队是自定义名字(体系名), AALC 只会找 "编队#N"; 改成按体系名点选。
if task in ('mirror', 'all'):
install_system_team_selection(log=log)
install_shop_lists(log=log)
install_typed_keyboard_road(log=log)
install_gift_preference(log=log)
install_event_choices(log=log)
+26 -17
View File
@@ -1,23 +1,32 @@
{
"_说明": [
"镜牢事件选项表(BACKLOG P1-4)。只在事件出现选项时生效; 没收录的事件、或表里的选项不在画面上时, 交给 AALC 原逻辑。",
"match: 画面上任一行文字包含其中一个词就认定是这个事件(按表顺序, 先命中的规则生效, 所以 '折射的往昔的睡袋' 要排在 '往昔的睡袋' 前面)。",
"text: 按选项文字选, 优先于 index; 推荐用, 因为 Wiki 编号和当前游戏顺序可能不同。",
"index: 按从上往下第几项选(1 起), 只用于事件的第一屏选项; 后续分支交给 AALC。",
"文字都先做与选队相同的归一(去空白、全角转半角、改回常见误读)。整表关闭: 任务环境变量 LCP_EVENT_CHOICES=0。",
"来源: docs/skills/limbus-mirror-speedrun/references/event-choices.md(2026-10-01 按 Wiki 核对), 都是无判定/无战斗的直出或免费奖励。",
"事件结果依据边狱公司中文 Wiki 社区「探索事件」(https://limbuscompany.huijiwiki.com/wiki/探索事件), 改编内容按 CC BY-SA 4.0 署名及相同方式共享。"
"镜牢事件选项表(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": "红色坐像", "match": ["无我入定", "红色坐像"], "text": ["侧耳倾听"]},
{"name": "炸鸡对决", "match": ["炸鸡对决"], "text": ["鸡肉就是鸡肉"]},
{"name": "梦中的电子羊", "match": ["梦中的电子羊"], "text": ["你不是特别的"]},
{"name": "失明巨人递来患者记录", "match": ["失明巨人", "患者记录"], "text": ["什么都没有写"]},
{"name": "鸡群的激情探戈", "match": ["激情探戈"], "index": 2},
{"name": "折射的往昔的睡袋", "match": ["折射的往昔的睡袋"], "index": 1},
{"name": "往昔的睡袋", "match": ["往昔的睡袋"], "index": 2},
{"name": "浸染棉花", "match": ["浸染棉花"], "index": 3},
{"name": "破碎罗盘", "match": ["破碎罗盘"], "index": 4},
{"name": "终末日历", "match": ["终末日历"], "index": 2}
{"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 默认点最上面的 1"},
{"name": "破碎罗盘(冻僵的尸体指路)", "id": 901095, "file": "ActionEvents_Mirror3.json",
"options": ["向裂开的手所指的北方。", "向警告的手所指的东方。", "向折断的手所指的西方。"], "text": "返回。",
"note": "第 4 项直接结束; 其余方向都还有后续分支"}
]
}
+4 -2
View File
@@ -3,10 +3,12 @@
"镜牢饰品三选一/二选一按体系关键词排序(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"],
"bleed": ["流血", "bleed"],
"tremor": ["震颤", "tremor"],
"rupture": ["破裂", "rupture"],
"sinking": ["沉沦", "sinking"],
+162 -85
View File
@@ -1,10 +1,12 @@
# -*- coding: utf-8 -*-
"""镜牢事件按选项表选择(BACKLOG P1-4)。
2026-11-14 核对: Mirror.event_handling() 不认事件, 最后总是点第一个选项。补丁在上游每轮挑选项前
认事件、按表点; 端到端用例执行上游真实的 event_handling。
2026-11-14 核对: Mirror.event_handling() 不认事件, 有 "???"/直接拿饰品/优势判定就选它, 否则点第一个选项。
补丁在上游每轮挑选项前按选项原文认事件、按表点; 端到端用例执行上游真实的 event_handling
(以及小指良单通模式用的 click_option_avoiding_unknown)。
"""
import ast
import functools
import json
import os
import sys
@@ -21,17 +23,38 @@ 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', match=('事件名',), text=(), index=None):
return {'name': name, 'match': tuple(match), 'text': tuple(text), 'index': index}
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):
@@ -43,49 +66,65 @@ class EventOptionsTest(unittest.TestCase):
('侧耳倾听', 300, 260), # 左边的叙述文字不算选项
('梦中的电子羊', 200, 60)] # 标题
options = ap.event_options(list(reversed(markers(3))), lines, SCALE)
self.assertEqual([text for _, text in options], ['你是特别的', '你不是特别的。', '离开'])
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], '')
def test_first_matching_rule_wins(self):
rules = [rule('折射', ('折射的往昔的睡袋',), index=1), rule('睡袋', ('往昔的睡袋',), index=2)]
self.assertEqual(ap.match_event_rule(rules, [('折射的往昔的睡袋', 200, 60)])['name'], '折射')
self.assertEqual(ap.match_event_rule(rules, [('往昔的 睡袋', 200, 60)])['name'], '睡袋')
self.assertIsNone(ap.match_event_rule(rules, [('别的事件', 200, 60)]))
def test_text_beats_index(self):
self.assertEqual(ap.choose_event_option(rule(text=('不是特别',), index=1), ('是特别', '不是特别的')),
(1, 'text', '选项文字含「不是特别」'))
self.assertEqual(ap.choose_event_option(rule(text=('没有',), index=2), ('a', 'b'))[:2], (1, 'index'))
self.assertEqual(ap.choose_event_option(rule(index=4), ('a', 'b', 'c')),
(None, None, '表里是第 4 项, 画面上只有 3 项'))
self.assertEqual(ap.choose_event_option(rule(text=('没有',)), ('a',))[:2], (None, None))
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_and_has_at_least_five_events(self):
def test_shipped_table_is_valid(self):
rules = ap.load_event_choices()
self.assertGreaterEqual(len(rules), 5)
names = [r['name'] for r in rules]
self.assertLess(names.index('折射的往昔的睡袋'), names.index('往昔的睡袋'))
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.assertTrue(any(word in reference for word in r['match']))
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", "match": ["x"]}]}',
'{"events": [{"name": "a", "match": [], "index": 1}]}',
'{"events": [{"name": "a", "match": ["x"], "index": 0}]}',
'{"events": [{"name": "a", "match": ["x"], "index": true}]}',
'{"events": [{"name": "a", "match": "x", "index": 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:
@@ -97,11 +136,11 @@ class EventTableTest(unittest.TestCase):
class EventScreen:
"""事件界面: 依次几屏选项, 点了一项就进下一屏, 最后回到地图。"""
"""事件界面: 依次几屏选项, 点了一项就进下一屏, 最后回到地图。unknown 是带 "???" 标签的那一项。"""
def __init__(self, title, screens, ignore_clicks=0):
self.title = title
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 = []
@@ -112,7 +151,7 @@ class EventScreen:
def options(self):
return self.screens[self.stage] if self.stage < len(self.screens) else None
def take_screenshot(self):
def take_screenshot(self, *args, **kwargs):
return self.screenshot
def mouse_to_blank(self, *args, **kwargs):
@@ -124,6 +163,9 @@ class EventScreen:
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
@@ -134,10 +176,12 @@ class EventScreen:
return True
return False
def mouse_click(self, x, y):
def mouse_click(self, x, y, *args, **kwargs):
if not self.options:
return
self.chosen.append(markers(len(self.options)).index((x, y)))
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
@@ -150,7 +194,7 @@ class EventScreen:
return False
def run(self, image):
lines = [(self.title, 200, 60)]
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),
@@ -158,24 +202,27 @@ class EventScreen:
for _, x, y in lines])
@unittest.skipUnless(MIRROR.is_file(), 'vendor/aalc 子模块未检出')
@unittest.skipUnless(MIRROR.is_file() and EVENT.is_file(), 'vendor/aalc 子模块未检出')
class UpstreamEventHandlingTest(unittest.TestCase):
"""执行上游真实的 Mirror.event_handling, 看每屏点了第几项。"""
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 == 'event_handling')
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, title, screens, patched=True, env=None, ignore_clicks=0):
screen = EventScreen(title, screens, ignore_clicks=ignore_clicks)
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(decision_event_handling=lambda: False) # 上游模块同名
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
@@ -191,54 +238,65 @@ class UpstreamEventHandlingTest(unittest.TestCase):
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('click_element', vars(screen), 'click_element 必须还原')
self.assertNotIn('find_element', vars(screen), 'find_element 必须还原')
self.assertNotIn('mouse_click', vars(screen), 'mouse_click 必须还原')
return screen.chosen
@property
def log(self):
return '\n'.join(self.lines)
def test_option_text_overrides_the_first_option(self):
options = [['你是特别的', '你不是特别的。', '离开']]
self.assertEqual(self.play('梦中的电子羊', options, patched=False), [0])
self.assertEqual(self.play('梦中的电子羊', options), [1])
self.assertIn('事件 梦中的电子羊: 1=你是特别的 | 2=你不是特别的。 | 3=离开; 选第 2 项(选项文字含「你不是特别的」)',
self.log)
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_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('梦中的电子羊', [['你是特别的', '你不是特别的。']])
self.play('没见过的事件', [['战斗', '离开']])
self.play([SHEEP])
self.play([['战斗', '离开']])
self.assertEqual(record.call_args_list, [
mock.call('event', 2, 'text', event='梦中的电子羊', options=['你是特别的', '你不是特别的。'],
why='选项文字含「你不是特别的」'),
mock.call('event', 2, 'text', event='梦中的电子羊', event_id=901038, options=['你是特别的', '你不是特别的']),
mock.call('event', None, 'not_in_table', options=['战斗', '离开'])])
def test_unknown_event_behaves_like_upstream(self):
options = [['战斗', '离开']]
self.assertEqual(self.play('没见过的事件', options), self.play('没见过的事件', options, patched=False))
self.assertIn('事件选项: 1=战斗 | 2=离开; 表里没有这个事件, 交给 AALC', self.log)
def test_index_rule(self):
self.assertEqual(self.play('浸染棉花', [['判定', '战斗', '离开']]), [2])
def test_index_beyond_the_options_falls_back(self):
self.assertEqual(self.play('破碎罗盘', [['a', 'b', 'c']]), [0])
self.assertIn('表里是第 4 项, 画面上只有 3 项, 交给 AALC', self.log)
def test_refracted_variant_is_matched_first(self):
self.assertEqual(self.play('折射的往昔的睡袋', [['判定', '全体降理智']]), [0])
self.assertEqual(self.play('往昔的睡袋', [['判定', '恢复']]), [1])
def test_index_only_applies_to_the_first_screen(self):
self.assertEqual(self.play('鸡群的激情探戈', [['判定', '探戈蘸酱'], ['好', '不好']]), [1, 0])
self.assertIn('编号只用于第一屏选项', self.log)
def test_index_click_is_retried_while_the_screen_is_unchanged(self):
self.assertEqual(self.play('终末日历', [['判定', '离开']], ignore_clicks=1), [1, 1])
def test_env_zero_keeps_upstream(self):
self.assertIsNone(ap.install_event_choices(log=self.lines.append, env={ap.EVENT_CHOICES_ENV: '0'}))
@@ -253,7 +311,7 @@ class InstallEventChoicesTest(unittest.TestCase):
mirror_mod.Mirror = self.mirror_cls
package = types.ModuleType('tasks.mirror')
package.mirror = mirror_mod
self.auto = SimpleNamespace(click_element=mock.Mock(return_value=False))
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),
@@ -262,34 +320,53 @@ class InstallEventChoicesTest(unittest.TestCase):
patcher.start()
self.addCleanup(patcher.stop)
def test_click_element_is_restored_after_an_exception(self):
real = self.auto.click_element
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.click_element, real)
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']}]}, 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_decision_error_falls_back_to_upstream_click(self):
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 original(mirror):
calls.append(self.auto.click_element(ap.EVENT_HOOK))
def find(target, *args, **kwargs):
if target == ap.EVENT_OPTION:
raise RuntimeError('template')
return False
self.mirror_cls.event_handling = original
self.auto.find_element = mock.Mock(side_effect=RuntimeError('template'))
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.auto.click_element.assert_called_once_with(ap.EVENT_HOOK)
self.assertEqual(self.auto.find_element.call_args_list[-1], mock.call(ap.EVENT_HOOK))
self.assertIn('事件选项表出错(RuntimeError: template)', '\n'.join(self.lines))
+20 -5
View File
@@ -214,12 +214,12 @@ class UpstreamAcquireEgoGiftTest(unittest.TestCase):
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, '流血伤害提高', '出血')]
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, '流血', '出血')]
cards = [card(300, '烧伤'), card(600, '流血'), card(900, '流血', '施加流血')]
self.assertEqual(self.choose(cards, pick='0/2')[0], [2, 1])
def test_misread_keyword_for_tremor(self):
@@ -233,9 +233,9 @@ class UpstreamAcquireEgoGiftTest(unittest.TestCase):
def test_duplicate_lines_on_two_cards_both_count(self):
# {文本: 坐标} 会把两张卡上的同一句合并成一条; 补丁直接读 OCR 引擎的逐行结果
cards = [card(300, '流血'), card(600, '流血', '出血')]
cards = [card(300, '流血'), card(600, '流血', '施加流血')]
self.assertEqual(self.choose(cards)[0], [1])
self.assertIn('第1张=1(流血) 第2张=2(流血/出血)', self.log)
self.assertIn('第1张=1(流血) 第2张=2(流血/流血)', self.log)
def test_decision_is_recorded_left_to_right(self):
cards = [card(300, '烧伤层数+1'), card(600, '施加2层流血')]
@@ -300,8 +300,11 @@ class InstallGiftPreferenceTest(unittest.TestCase):
def test_ranking_error_keeps_upstream_order(self):
cards = [(300, 300), (600, 300)]
auto = self.auto
def original(mirror):
return self.auto.find_element(ap.GIFT_CARD, find_type='image_with_multiple_targets')
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()
@@ -311,6 +314,18 @@ class InstallGiftPreferenceTest(unittest.TestCase):
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()
+20 -77
View File
@@ -1,24 +1,21 @@
# -*- coding: utf-8 -*-
"""镜牢商店"必买 / 必卖 / 公式合成"清单。
"""镜牢商店"必买 / 必卖 / 公式合成"清单(BACKLOG P0-1)。
2026-11-14 实测: 上游 tasks/mirror/__init__.py 仍按 ./assets/images/share/... 列目录,
图片早已挪到 assets/images/<主题>/<语言>/ 下, 三个清单恒为空, 进店 51 秒一件没买。
2026-11-14 实测: 上游 tasks/mirror/__init__.py 按旧路径 ./assets/images/share/... 列目录, 三个清单恒为空,
进店 51 秒一件没买。上游 8196e72(V1.6.1) 改成按 assets/images/default/share/... 列, 本地补丁随之删掉;
这里守着上游别再退回空清单。
"""
import os
import sys
import tempfile
import types
import unittest
from contextlib import contextmanager
from pathlib import Path
from unittest import mock
REPO = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(REPO))
from lc_mcp import aalc_patches # noqa: E402
AALC = REPO / 'vendor' / 'aalc'
IMAGES = AALC / 'assets' / 'images'
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
@@ -31,89 +28,35 @@ def chdir(path):
os.chdir(old)
def as_tasks_mirror(package):
"""让 import tasks.mirror 拿到给定模块(父包也要在 sys.modules 里)。"""
parent = types.ModuleType('tasks')
parent.mirror = package
return mock.patch.dict(sys.modules, {'tasks': parent, 'tasks.mirror': package})
def upstream_mirror_package():
"""在 AALC 目录下执行上游 tasks/mirror/__init__.py, 得到它真实生成的三个列表。"""
"""在 AALC 目录下执行上游 tasks/mirror/__init__.py(任务进程的工作目录也是这里)。"""
module = types.ModuleType('tasks.mirror')
source = (AALC / 'tasks' / 'mirror' / '__init__.py').read_text(encoding='utf-8')
with chdir(AALC):
exec(compile(source, str(AALC / 'tasks' / 'mirror' / '__init__.py'), 'exec'), module.__dict__)
exec(compile(INIT.read_text(encoding='utf-8'), str(INIT), 'exec'), module.__dict__)
return module
@unittest.skipUnless(IMAGES.is_dir(), 'vendor/aalc 子模块未检出')
@unittest.skipUnless(INIT.is_file(), 'vendor/aalc 子模块未检出')
class UpstreamShopListTest(unittest.TestCase):
def test_upstream_lists_are_empty_and_patch_fills_them(self):
def test_upstream_lists_are_filled(self):
package = upstream_mirror_package()
self.assertEqual([len(getattr(package, k)) for k in aalc_patches.SHOP_LISTS], [0, 0, 0],
'上游已修好时可以删掉这个补丁')
# in_shop 在导入时绑定的就是这几个列表对象
in_shop = types.SimpleNamespace(**{k: getattr(package, k) for k in aalc_patches.SHOP_LISTS})
lines = []
with as_tasks_mirror(package), chdir(AALC):
filled = aalc_patches.install_shop_lists(log=lines.append)
self.assertEqual(filled, {'must_purchase': 5, 'must_be_abandoned': 19, 'fusion_result': 31})
self.assertEqual([len(getattr(in_shop, k)) for k in aalc_patches.SHOP_LISTS], [5, 19, 31])
self.assertIn('mirror/shop/must_purchase/carmilla.png', in_shop.must_purchase)
self.assertIn('must_purchase=5', '\n'.join(lines))
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):
for kind in aalc_patches.SHOP_LISTS:
for name in aalc_patches.shop_list_images(kind, str(IMAGES)):
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 aalc_patches.IMAGE_ROOTS))
self.assertTrue(any((images / root / name).is_file() for root in IMAGE_ROOTS))
def test_local_roots_match_aalc_path_manager(self):
def test_roots_match_aalc_path_manager(self):
source = (AALC / 'utils' / 'path_manager.py').read_text(encoding='utf-8')
for root in aalc_patches.IMAGE_ROOTS:
for root in IMAGE_ROOTS:
self.assertIn('"%s"' % root, source)
class ShopListImagesTest(unittest.TestCase):
def setUp(self):
tmp = tempfile.TemporaryDirectory()
self.addCleanup(tmp.cleanup)
self.images = tmp.name
def put(self, root, kind, name):
folder = os.path.join(self.images, *root.split('/'), 'mirror', 'shop', kind)
os.makedirs(folder, exist_ok=True)
open(os.path.join(folder, name), 'wb').close()
def test_merges_themes_and_languages_without_duplicates(self):
self.put('default/share', 'must_purchase', 'b.png')
self.put('dark/share', 'must_purchase', 'b.png')
self.put('default/zh_cn', 'must_purchase', 'a.png')
self.put('default/share', 'must_purchase', 'notes.txt')
os.makedirs(os.path.join(self.images, 'default', 'share', 'mirror', 'shop', 'must_purchase', 'x.png'))
self.assertEqual(aalc_patches.shop_list_images('must_purchase', self.images),
['mirror/shop/must_purchase/a.png', 'mirror/shop/must_purchase/b.png'])
def test_missing_folders_give_an_empty_list(self):
self.assertEqual(aalc_patches.shop_list_images('fusion_result', self.images), [])
def test_non_empty_upstream_list_is_left_alone(self):
self.put('default/share', 'must_purchase', 'a.png')
package = types.SimpleNamespace(must_purchase=['upstream.png'], must_be_abandoned=[], fusion_result=[])
with as_tasks_mirror(package):
filled = aalc_patches.install_shop_lists(log=lambda m: None, images_dir=self.images)
self.assertEqual(package.must_purchase, ['upstream.png'])
self.assertEqual(filled, {'must_be_abandoned': 0, 'fusion_result': 0})
def test_import_failure_is_reported_not_raised(self):
lines = []
with mock.patch.dict(sys.modules, {'tasks': types.ModuleType('tasks'), 'tasks.mirror': None}):
self.assertEqual(aalc_patches.install_shop_lists(log=lines.append), {})
self.assertIn('商店清单补丁跳过', '\n'.join(lines))
if __name__ == '__main__':
unittest.main()
Vendored
+1 -1