2 Commits
18 changed files with 429 additions and 1444 deletions
+9
View File
@@ -98,6 +98,14 @@ $env:LCP_DRIVER_TRACE = "$env:USERPROFILE\lc_mcp\driver-input.log"
模拟器不接管;拖拽、滚动、键盘以及 MCP 的独立 `click` 工具仍使用原后端。 模拟器不接管;拖拽、滚动、键盘以及 MCP 的独立 `click` 工具仍使用原后端。
当前回归验证覆盖软件接线和异常处理,DLL、实际驱动及游戏响应需在 Windows 实机核验。 当前回归验证覆盖软件接线和异常处理,DLL、实际驱动及游戏响应需在 Windows 实机核验。
任务运行期间按 **F12** 急停,可用 `LCP_KILL_KEY` 改成 `f11`、`pause` 等键名。
急停会终止任务子进程,保留游戏窗口;`task_status` 返回 `stopped`、退出码 `130`。
刷取循环检测到用户停止后结束本轮,不再导航、升级或重试。急停前会尝试释放驱动
按住的鼠标按钮,清理超过 250 毫秒仍强制退出;硬退出留下的临时配置恢复文件由
`stop_task` 或下一次 `run_task` 处理。热键监听依赖 AALC 的 `pynput`,安装失败会写日志;
也可从 MCP 调用 `stop_task`,或按 Ctrl+Alt+Del 打开任务管理器终止任务进程。
此热键只覆盖 `run_task` 子进程,不覆盖独立运行的合成、升级脚本。
## 工具 ## 工具
| 工具 | 说明 | | 工具 | 说明 |
@@ -180,6 +188,7 @@ powershell -ExecutionPolicy Bypass -File scripts\install_convert_task.ps1 -Every
| `LCP_PORT` | 8765 | 服务/bridge 端口 | | `LCP_PORT` | 8765 | 服务/bridge 端口 |
| `LCP_KEEP_SHOTS` | 30 | 截图保留张数 | | `LCP_KEEP_SHOTS` | 30 | 截图保留张数 |
| `LCP_ALLOW_LUNACY` | 未设置 | 设为 `1` 时允许预检放行 `set_lunacy_to_enkephalin` 不为 0 的配置 | | `LCP_ALLOW_LUNACY` | 未设置 | 设为 `1` 时允许预检放行 `set_lunacy_to_enkephalin` 不为 0 的配置 |
| `LCP_KILL_KEY` | `f12` | 任务子进程的急停键,如 `f11` / `pause` |
| `LC_PY` | 当前解释器 | `levelup.py`/`auto_cycle.py` 调用 MCP 用的 Python | | `LC_PY` | 当前解释器 | `levelup.py`/`auto_cycle.py` 调用 MCP 用的 Python |
## 开发 / 测试 ## 开发 / 测试
-172
View File
@@ -1,172 +0,0 @@
# 待开发计划(BACKLOG)
按「收益 / 风险」排序。每条都带**证据**和**验收标准**,云端改完直接照着验。
最近一次实测记录见 [`feedback/2026-11-14/README.md`](feedback/2026-11-14/README.md),
接口与队名表见 [`feedback/2026-11-14/HANDOVER.md`](feedback/2026-11-14/HANDOVER.md)。
图例:P0 = 现在是坏的/每天都在浪费;P1 = 明显影响质量;P2 = 打磨。
---
## P0-1 商店「必买 / 必卖 / 公式合成」清单恒为空
**现状**:`tasks/mirror/__init__.py` 用旧路径加载模板:
```python
must_purchase_path = "./assets/images/share/mirror/shop/must_purchase"
```
实际图片在 `./assets/images/default/share/mirror/shop/must_purchase/`(5 张:`carmilla`、`homeward`、
`lithograph`、`phlebotomy_pack`、`piece_of_relationship`),`assets/images/share` 根本不存在。
运行时实测:
```
must_purchase 0
must_be_abandoned 0
fusion_result 0
```
后果:`in_shop.py:157` 的购买循环、`:564` 的废弃识别、公式合成全部空转。2026-11-14 进店 51 秒、
打印了三次「开始购买必买项」却没买一件。
**目标**:三个清单按当前 `path_manager` 的图片根(`default/share`、`dark/share`…)加载,且支持中英文资源目录。
**验收**:
- [ ] `python -c "import tasks.mirror as m; print(len(m.must_purchase), len(m.must_be_abandoned), len(m.fusion_result))"` → `5 19 31`
- [ ] 单测覆盖:清单非空、路径含 `default/share`、`dark` 主题下也能解析
- [ ] 实机进店日志能看到真正的购买动作(`购买` 后出现 `ego_gift_get_confirm`),且余额变化
**涉及**:`tasks/mirror/__init__.py`(`vendor`!)→ 若要遵守「不改 vendor」,就在 `lc_mcp/aalc_patches.py`
里于 import 后重建这三个列表,并加一条注释说明上游路径缺陷。
**风险**:低。纯路径/清单;不改判定逻辑。
---
## P0-2 镜牢走位被配置降级成「只按 ↑」
**现状**:`config.yaml` 里 `mirror_keyboard_navigation: true` + `mirror_keyboard_simple_pathfinding: true`,
`mirror.py:1128` 因此走 `search_road_simple_keyboard()`:每层按两次 ↑ 进最上面的节点,不看节点类型。
Dijkstra 那套(`search_road.py:735`,代价 event 1 / shop 2 / battle 4 / boss·focused 6 / risky 7)完全没跑。
**目标**(二选一,云端定):
- A:默认改用 Dijkstra,只在检测到「鼠标拖地图卡死」时降级为简单键盘;
- B:保留简单键盘,但把「↑ 的第一个节点」换成「按节点类型挑可达节点」。
**验收**:
- [ ] 一局里至少 3 层,日志能打印每层选中的节点类型与理由
- [ ] 事件/商店节点占比 ≥ 现状(对比 11-14 这局:3 层只进过 1 次商店)
- [ ] 不出现寻路卡死(连续 60 s 无 `enter_assets` 即算失败,应回退简单键盘)
**涉及**:`tasks/mirror/search_road.py`、`tasks/mirror/mirror.py:1128`、`config.yaml` 默认值(`assets/config/config.example.yaml`)
**风险**:中。`simple_pathfinding` 当初是为了规避鼠标拖拽卡死加的,去掉要有回退开关。
---
## P1-3 饰品三选一加「体系优先」
**现状**:`mirror.py:1360 acquire_ego_gift()` 只看两件事——是不是白棉花、是不是「已持有」,
然后拿第一张。**完全不看 `team_system`**。
**目标**:可配置的关键词优先表(例如流血队:`流血 / 出血 / 血迹`),命中则加权;仍旧排除已持有与白棉花。
**验收**:
- [ ] 单测:给定候选文本列表 + 体系,选出预期那一张(含「全部已持有」「全是白棉花」边界)
- [ ] 实机:流血队一局里,三选一命中体系关键词的比例 > 0(日志统计)
- [ ] 关闭该配置时行为与现在完全一致(可回滚)
**涉及**:`tasks/mirror/mirror.py`、`lc_mcp/aalc_patches.py`(建议做成可配置关键词表,放 `config.yaml` 或独立 yaml)
**风险**:中。OCR 有误读(`震颐`/`沉论`/`编#16`),关键词要容忍错字。
---
## P1-4 事件选项策略可配
**现状**:`mirror.py:1230 event_handling()` 固定策略——能点「判定 / check」就点,然后**永远点第一个选项**,
最后找 `continue/继续`。跟体系、跟当前血量都无关。
**目标**:支持一张「事件 → 选项」表(JSON/YAML),未收录的退回「第一个选项」。
**验收**:
- [ ] 表里命中的事件按配置点;未命中的行为不变
- [ ] 单测:事件文本 → 选项索引映射,含缺省分支
- [ ] 至少录入 5 个高频事件(可从 `docs/mirror_dungeon_speedrun_notes.md` 的既有结论里抄)
**涉及**:`tasks/mirror/mirror.py`、新增数据文件(建议 `lc_mcp/data/event_choices.yaml`,不要塞进 vendor)
**风险**:低-中。选项点错可能拿不到奖励,但不会卡死。
---
## P1-5 选队补丁的鲁棒性
**现状**:`_select_team_by_name()` 精确匹配 + 4 轮翻页。已知薄弱点:
- OCR 误读(实测把「震颤」读成「震颐」、「沉沦」读成「沉论」、「编队#16」读成「编#16」)
- 队名带后缀(「流血队」「流血(X)」)会失配
- 只按「顶栏名字」确认,若顶栏字号变化会误判
**目标**:别名表 + 归一化(去空格/全半角/常见误读)+ 失败时输出候选列表便于排查。
**验收**:
- [ ] 把队名临时改成「流血队」也能选中(别名/前缀匹配,仍需唯一)
- [ ] 误读样本(`震颐`→`震颤`、`沉论`→`沉沦`)能正确归一
- [ ] 失败日志里打印「这一屏看到了哪些名字」,而不是只说没找到
**涉及**:`lc_mcp/aalc_patches.py`、`tests/test_system_team_selection.py`
**风险**:低。只是匹配变宽,需保证「唯一命中」才点,避免选错队。
---
## P2-6 商店必买清单本地化
**现状**:必买靠 5 张**英文/图标模板**;汉化后商店里的名称是中文,模板匹配靠图标尚可,但新增饰品无法覆盖。
**目标**:支持「饰品中文名 → 优先级」的配置表,OCR 命中即买;模板作为兜底。
**验收**:单测 + 实机一局至少一次由名字命中的购买。
**涉及**:`lc_mcp/aalc_patches.py`(包一层购买判定)、新增数据文件。
---
## P2-7 观测饰品按体系自动勾选
**现状**:`observe_ego_gift_selected` 要人在 AALC 界面一个个勾;没勾就等于关闭观测。
**目标**:按 `team_system` 自动勾一组默认饰品(可覆盖),并在开跑前写回配置。
**验收**:`config.yaml` 里 `observe_ego_gift_selected` 与体系匹配;日志打印勾了哪些。
**涉及**:`lc_mcp/aalc_task.py`(apply_overrides 类似机制)、`app/observe_ego_gift_selection.py` 的序列化格式(只读参考)。
---
## P2-8 决策审计日志
**现状**:选队/卡包/饰品/商店的决策只散落在 DEBUG 日志里,事后要人肉 grep。
**目标**:每局写一份 `~/lc_mcp/runs/<task>.decisions.jsonl`:时间、阶段、画面摘要、候选、选中项、理由。
**验收**:一局结束后能直接统计「卡包选择理由 ×N」「三选一命中体系 ×N」「商店购买 ×N」。
**涉及**:`lc_mcp/aalc_patches.py`、`lc_mcp/tasks.py`(结果归档)。
---
## 已知但暂不做的
| 项 | 原因 |
|---|---|
| 让 AALC 原生支持自定义队名 | 要改 `vendor/aalc`,submodule 升级会丢;补丁层已够用 |
| 自动识别「哪支队是流血队」 | 图像/文本都不可靠,靠命名约定(见 HANDOVER 第 4 节)更稳 |
| 改 `mirror_dungeon_speedrun_notes.md` 的路线结论 | 那是人工速通笔记,和 AALC 的自动寻路是两套,别混 |
-2
View File
@@ -228,5 +228,3 @@ Get-ChildItem "$dir\convert_*.json" | ForEach-Object {
if ($m -and $m.secs -eq $r.elapsed_s) { "OK $($r.started)" } else { "MISMATCH $($_.Name)" } if ($m -and $m.secs -eq $r.elapsed_s) { "OK $($r.started)" } else { "MISMATCH $($_.Name)" }
} }
``` ```
-162
View File
@@ -1,162 +0,0 @@
# 对接说明:镜牢选队(2026-11-14)
给**云端开发**看的交接文件。目标:云端改代码 → 我这边 `git pull` → 实机回归 → 回传结果。
所以这里写清楚「改哪、别动哪、怎么验、验到什么程度算过」。
---
## 1. 仓库与运行环境
| 项 | 值 |
|---|---|
| 仓库 | `https://git.lingll.icu/yws/lc-mcp` |
| 当前分支 | `codex/feedback-unattended-setup-20261004` |
| 本机路径 | `D:\lc-mcp`(AALC 在 `vendor/aalc`,**submodule,不要改**) |
| Python | `vendor\aalc\.venv\Scripts\python.exe`(3.13) |
| 游戏 | `D:\SteamLibrary\steamapps\common\Limbus Company`(Steam build 26593955) |
| 汉化 | `LLC_zh-CN` 2026111301(自定义语言,游戏基础语言 = 韩语,OCR 语言识别为 `zh_cn`) |
| 分辨率 | 客户区 1280×720,`set_win_size: 720` |
| 常驻服务 | 计划任务 `LcMCPServer`,`127.0.0.1:8765`,日志 `~/lc_mcp/server.log` |
**测试入口**(本机验证统一用这个,不要直接跑 `main.py`):
```powershell
D:\lc-mcp\vendor\aalc\.venv\Scripts\python.exe -X utf8 -c "from lc_mcp import ..." # 单测
# 实机:通过 MCP 工具 run_task mirror,或
D:\lc-mcp\vendor\aalc\.venv\Scripts\python.exe -X utf8 -m lc_mcp.aalc_task mirror "{\"count\": 1}"
```
---
## 2. 本次改动(两个文件,均为增量,不改 vendor)
### `lc_mcp/aalc_patches.py`
新增一段(文件末尾,`install_default_battle_team` 之后):
```python
SYSTEM_TEAM_NAMES = {...} # 体系(system 字符串) → 游戏内编队名元组
TEAM_LIST_X_MAX / TEAM_LIST_Y_MIN / TEAM_LIST_Y_MAX # 左侧列表命中范围(客户区像素)
TEAM_HEADER = (170, 520, 90, 150) # 顶栏队名位置,用来确认选中
_team_ocr(auto) -> [(text, x, y), ...] # 整屏 OCR 后清洗,不排序
_in_list(x, y) / _in_header(x, y) # 区域判定
_scroll_team_list(auto, direction, times, distance) # +1=回顶部, -1=往下翻
_header_is(auto, name) / _wait_header(auto, name) # 顶栏确认(3 次 × 1.2s)
_select_team_by_name(auto, names, log, rounds=4) # 主流程,返回 bool
install_system_team_selection(log=print) # 安装补丁,返回原始 select_battle_team
```
### `lc_mcp/aalc_task.py`
- import 里加 `install_system_team_selection`
- `run()` 里、`install_default_battle_team` 之后:
```python
if task in ('mirror', 'all'):
install_system_team_selection(log=log)
```
### 挂载点为什么是 `tasks.mirror.mirror`
`tasks/mirror/mirror.py` 在模块顶部 `from tasks.teams.team_formation import ... select_battle_team`,
之后 `select_mirror_team()` 用的是**模块全局名**。所以补丁必须替换
`tasks.mirror.mirror.select_battle_team`;改 `tasks.teams.team_formation.select_battle_team` 对镜牢无效
(日常本那条补丁 patch 的是 `scheme` 命名空间,两者互不影响)。
---
## 3. 接口契约(改的时候必须保住)
1. **`select_battle_team(num) -> bool`**:True = 已选中并确认在编队界面;False = 没选上,调用方会重试(最多 6 次)后抛 `unableToFindTeamError`。
2. **不能有副作用**:补丁只点击,不写配置文件;`Mirror.__init__` 的包装只读 `team_setting`。
3. **坐标空间**:一律按**客户区像素**(当前 1280×720)。缩放用 `cfg.set_win_size / 1440`,跟 AALC 其它地方一致。
4. **`auto._run_ocr_for_text(my_crop=None)` 返回 `{text: [cx, cy]}`**:`cx/cy` 是 box 中心;同名文本会互相覆盖,**因此 `_team_ocr` 改成返回列表**,别再退回 dict。
5. **不要用 `my_crop` 做界面裁剪**:实测裁剪坐标语义不可靠(裁 `(0,0,190,584)` 会读到右侧面板),统一「整屏 OCR + 坐标过滤」。
6. **点完必须验顶栏**:只点不验会出现「日志说成功,其实没换队」。
---
## 4. 体系队名表(本机账号实际状态,2026-11-14 截图核对)
左侧编队列表,从上到下:
| 顺序 | 列表显示 | 说明 | `team_system` |
|---|---|---|---|
| 1 | 剧情关卡 | 剧情用预设 | — |
| 2 | 斩击 | 打击体系队 | 7 |
| 3 | 突刺 | 突刺体系队 | 8 |
| 4 | 打击 | 打击体系队 | 9 |
| 5 | 烧伤 | 烧伤体系队 | 0 |
| 6 | 流血 | 流血体系队(**当前镜牢在用**) | 1 |
| 7 | 震颤 | 震颤体系队 | 2 |
| 8 | 破裂 | 破裂体系队 | 3 |
| 9 | 沉沦 | 沉沦体系队 | 5 |
| 10 | 呼吸法 | 呼吸体系队(代码里另有别名「呼吸」) | 4 |
| 11 | 充能 | 充能体系队 | 6 |
| 12+ | 编队#13 … 编队#40 | 默认名残留,未使用 | — |
> `#1`~`#12` 已不存在。任何按 `编队#N` 找队的逻辑在这个号上都会失败,这是本次问题的根。
>
> 队名改动后必须同步 `SYSTEM_TEAM_NAMES`;补丁只做**精确匹配**(`text == name`),不做子串。
---
## 5. 验证方法
### 5.1 单测(不需要游戏)
```powershell
cd D:\lc-mcp
vendor\aalc\.venv\Scripts\python.exe -m unittest discover -s tests -t tests -v
```
本次新增 `tests/test_system_team_selection.py`,覆盖:映射表完整性、区域判定边界、
`install_system_team_selection` 的挂载/回退行为(用假模块,不依赖 AALC/Windows)。
### 5.2 实机回归(需要游戏在运行)
```powershell
# 1) 确认补丁挂上
# 日志里应有:[lc_mcp] patch: 镜牢按体系名选队
# 2) 起一局
run_task(task="mirror", count=1)
# 3) 看这几行
# [lc_mcp] 镜牢体系 bleed -> 目标编队 流血
# [lc_mcp] patch: 已按体系名选中编队 流血 (或「当前已经是编队 流血, 无需切换」)
# [INFO] 楼层识别结果:当前为第1层
```
### 5.3 验收清单
- [ ] `select_battle_team` 返回 True 后,顶栏队名 = 目标队名(截图为准,不看日志)
- [ ] 连续两局:第二局走「已经是目标队,无需切换」分支
- [ ] 把 `team_system` 改成 7(斩击)能选到「斩击」;改回 1 能选回「流血」
- [ ] 目标名不存在时(例如临时改成 `编队#999`)能 4 轮内返回 False,不卡死、不乱点
- [ ] 列表滚动后不会把队伍页留在错误位置(后续 `罪人编队` 步骤仍能正常执行)
---
## 6. 云端开发注意事项
- **不要改 `vendor/aalc`**:submodule 固定 commit,改了本地能跑、更新就丢。所有行为差异走 `lc_mcp/aalc_patches.py`。
- **不要引入本机绝对路径**(`D:\...`、`C:\Users\YWS-HHH\...`);已有代码里 `LC_*` / `LCP_*` 环境变量是既有限制。
- **失败要显式**:选队失败返回 False 让上层重试,不要静默 fallback 到 `编队#N`(这号没有 `#N`,会选中错的队)。
- **日志格式**:沿用 `[lc_mcp] ...` 前缀,`task_status` 的 `errors` 扫描依赖 `[ERROR]`。
- 新增依赖请加到 `pyproject.toml`,并确认 `uv sync` 后 `vendor/aalc/.venv` 能跑。
---
## 7. 拉取与回传
```powershell
cd D:\lc-mcp
git fetch origin
git checkout <云端分支>
git pull
git submodule update --init --recursive
vendor\aalc\.venv\Scripts\python.exe -m unittest discover -s tests -t tests
# 实机回归 → 结果写回 docs/feedback/<日期>/
```
我这边回归后会补:跑团日志、截图路径、验收清单勾选结果,以及新发现的问题。
-189
View File
@@ -1,189 +0,0 @@
# 2026-11-14 汉化更新 + 镜牢选队根因与局内决策实测
本次两件事:**更新游戏汉化**,以及**把「镜牢一直选不上队」查清楚并修掉**。
后半段顺带核了镜牢局内的四类决策(走位 / 卡包 / 饰品 / 商店),发现两处真实缺陷,一并记在
[`BACKLOG.md`](../../BACKLOG.md) 里。
## 环境
| 项 | 值 |
|---|---|
| 系统 | Windows 10 Pro 19045,远程会话,无人值守 |
| 游戏 | Steam 版 Limbus Company,`D:\SteamLibrary\steamapps\common\Limbus Company` |
| 游戏版本 | 更新前 build `26318463`(1.118.1,11-05)→ 更新后 build `26593955`(11-14 08:20 落盘) |
| 汉化 | `LimbusCompany_Data\Lang\LLC_zh-CN`,2026101602 → **2026111301** |
| AALC | `vendor/aalc`(git submodule,未改源码) |
| 运行方式 | MCP `run_task mirror`,AALC 子进程,前台点击 + 罗技驱动点击 |
## 一、汉化更新
上游:`LocalizeLimbusCompany/LocalizeLimbusCompany` release `2026111301`(2026-11-13 发布)。
装法按官方手动流程:**干净重装**(移走旧 `LLC_zh-CN` → 解压新包到游戏根目录),字体包不随
release 发布,单独从 `Fonts/LLCCN-Font.7z` 来(自 2025-04 未变,直接沿用旧文件)。
| 步骤 | 结果 |
|---|---|
| 旧包备份 | `D:\codex\_limbus_l10n_dl\backup-LLC_zh-CN-2026101602`(2350 文件 / 45.1 MB) |
| 下载 | `LimbusLocalize_2026111301.zip` 6,080,228 B,SHA256 `E63782A0…6E14665` |
| 解压 | 2385 个文件,全部 SHA256 与 zip 内一致(0 不匹配) |
| JSON 校验 | 2384 个 JSON 全部可解析,0 空文件 |
| 字体 | `Font\Context\ChineseFont.ttf` 22.8 MB,TTF 头 `00 01 00 00` 正常 |
| 配置 | `Lang\config.json` 未动,仍 `"lang": "LLC_zh-CN"` |
相对旧版新增:`walpu10` 系列事件/敌人/EGO、`Mirror8` 成就与卡包、`StoryData E100X–E103X`、
新人格语音(`P10316/P10617/P10717/P11017/P11116`)、`SynergyKeyword`、`EventVerificationUIText` 等 35 个文件。
> 注:游戏第一次启动时弹「当前游戏客户端不是最新版本」,必须先更 Steam 客户端;更完再跑就正常了。
## 二、镜牢选队:为什么一直「选不上」
### 症状
`run_task mirror` 后 AALC 卡在选队:每 5 秒对左侧列表 OCR 一次,页码一路往上爬,然后重来。
```text
08:34:27 开始执行 寻找队伍
08:34:50 OCR: 编队#13 编队#14 编队#15 编#16
08:35:00 OCR: 编队#19 编队#20 编队#21 …
08:35:15 OCR: 编队#33 编队#34 编队#35 …
08:37:00 又回到 编队#19 … ← 第 N 轮
```
### 根因
`config.yaml` 里 `team_number: 1`,AALC 的 `select_battle_team()` 只会按
`编队#N` / `TEAMS #N` 这个**字面名字**去 OCR 找队(`tasks/teams/team_formation.py:167`)。
而这个号的编队**是按体系命名的**,不是默认名;`编队#1`~`#12` 也已经不存在:
```text
左侧列表(从上到下):
剧情关卡
斩击 突刺 打击 烧伤 流血 震颤 破裂 沉沦 呼吸法 充能 ← 10 支按体系命名
编队#13 … 编队#40 ← 默认名残留
```
所以找 `编队#1` 永远找不到 → 翻满 10 页 → 重试 6 轮 → `无法寻得队伍,请检查队伍名称是否为默认名称`。
### 修复
新增 `install_system_team_selection()`(`lc_mcp/aalc_patches.py`),在 `mirror`/`all` 任务里挂载。
**不改 `vendor/aalc` 源码**,只替换 `tasks.mirror.mirror` 命名空间里的 `select_battle_team`:
```
team_system → 队名
0 烧伤 / 1 流血 / 2 震颤 / 3 破裂 / 4 呼吸法(兼容"呼吸")
5 沉沦 / 6 充能 / 7 斩击 / 8 突刺 / 9 打击
```
选队流程:
1. 先看顶栏是不是已经是这支队(是就直接返回,不动列表)
2. 不是 → 点空白、把列表向下拖回顶部
3. 整屏 OCR,只保留左侧列表区域(`x<260`,`300<y<640`)里的条目
4. **精确匹配**队名 → 点击 → 轮询顶栏最多 3 次 × 1.2 s,顶栏变成该名字才算成功
5. 没找到就往下翻(每次 3 拖),最多 4 轮;4 轮都失败返回 False,交给 AALC 原来那层重试
两个细节是踩出来的:
- **不能用 `my_crop`**:AALC 里裁剪坐标的语义跟客户区像素对不上(实测裁 `(0,0,190,584)` 会 OCR 出右侧面板的文字),所以改成整屏 OCR 再按坐标过滤。
- **点完不能立刻判**:顶栏要 1~2 帧才刷新,实测 0.8 s 时还没变,1.2 s×3 才稳。
实测日志:
```text
[lc_mcp] 镜牢体系 bleed -> 目标编队 流血
[lc_mcp] 编队列表里找到 流血 @(130,492)
[lc_mcp] patch: 已按体系名选中编队 流血
[INFO] 楼层识别结果:当前为第1层
[INFO] 此次选择卡包关键词:信仰
```
(第二次跑因为上一次已经停在「流血」上,直接命中「当前已经是编队 流血, 无需切换」。)
## 三、局内四类决策:代码实际怎么走
| 决策 | 现状 | 代码位置 |
|---|---|---|
| 走位 | **被配置降级成瞎走**:`mirror_keyboard_simple_pathfinding: true` → 每层只按 ↑ 选最上面节点 | `mirror.py:1128` → `search_road.py:145` |
| 卡包 | 规则明确:关键词权重表取最高,低于阈值就刷新(≤3 次) | `select_theme_pack.py` |
| 饰品三选一 | **不看体系**:排白棉花 → 排「已持有」→ 拿第一张 | `mirror.py:1360` |
| 商店 | 必买/必卖清单为 **0**(路径写错),只剩体系强化/刷新/合成/治疗 | `in_shop.py:157`、`tasks/mirror/__init__.py` |
| 事件 | 固定:能「判定」就判定,然后永远点第一个选项 | `mirror.py:1230` |
### 3.1 走位
```python
# search_road.py:145
for attempt in range(2):
auto.key_press("up")
if _keyboard_enter_succeeded():
return True
```
关掉 `mirror_keyboard_simple_pathfinding` 才会走 Dijkstra(`search_road.py:735`),节点代价表
(`search_road.py:609`,越小越优先):
| 节点 | 代价 |
|---|---|
| event | 1 |
| shop | 2 |
| battle | 4 |
| boss / focused / abnormality | 6 |
| risky_encounter | 7 |
| 未知 | 999(不可达) |
### 3.2 卡包
`preferred_thresholds: 0`,权重表在 `theme_pack_list.yaml`(多数 0、`chick: 1`、未知 -5)。
本次三次选择:`信仰` → `赌徒` → `情感懒`。
### 3.3 饰品三选一
`acquire_ego_gift()`:排除白棉花(除非 `not_skip_whitegossypium`)→ OCR「已持有 / Owned」→
优先没持有的 → 都一样拿第一张。**没有任何体系判断**。
### 3.4 商店(真实缺陷)
`tasks/mirror/__init__.py` 用的是旧路径:
```python
must_purchase_path = "./assets/images/share/mirror/shop/must_purchase"
```
实际图片在 `./assets/images/default/share/mirror/shop/must_purchase/`,`assets/images/share` 不存在。
运行时验证:
```
must_purchase 0
must_be_abandoned 0
fusion_result 0
```
本次日志实锤(进店 51 秒,一件没买):
```text
10:03:03 开始执行 镜牢商店
10:03:16 开始购买必买项
10:03:54 结束执行 镜牢商店 耗时 00:00:51
```
## 四、本次跑团(进行中记录)
```text
09:39:53 task mirror start
09:40:07 选队 → 流血(已是目标队,跳过切换)
09:41:16 第1层
09:54:33 第1层结束 13:07,卡包:赌徒
09:55:20 寻路出错 → 自动重进镜牢,恢复
10:03:54 第2层商店 51 秒(未购买,见 3.4)
10:07:32 第2层结束 12:59,卡包:情感懒
10:17:37 第3层战斗中
```
## 五、仍未验证的边界
- 选队补丁只在「流血」上实测过;其它 9 个体系名未实跑(队列切换、`teams_active_queue` 轮转时尤其没验)。
- 队名如果被改(比如改成「流血队」),补丁会失配 → 需要同步改 `SYSTEM_TEAM_NAMES`。
- `my_crop` 语义不一致这件事只在这个界面验证过,别的界面不一定。
- 关掉 `mirror_keyboard_simple_pathfinding` 后 Dijkstra 的稳定性没验(当初开它就是为躲鼠标拖地图卡死)。
+32
View File
@@ -96,3 +96,35 @@ OCR 误读;已知读法集合只来自该账号历史观测,不是通用余
测试从 vendor AST 提取并执行真实的 `init_input`、交互门与监控点击方法, 不复制其接线逻辑; 测试从 vendor AST 提取并执行真实的 `init_input`、交互门与监控点击方法, 不复制其接线逻辑;
实际 `aalc_task.run` 的 `all` / `daily` 入口也有覆盖。Windows DLL 和游戏未在本次环境执行。 实际 `aalc_task.run` 的 `all` / `daily` 入口也有覆盖。Windows DLL 和游戏未在本次环境执行。
PrintWindow 探测仅表示 API 调用成功, 不保证像素内容有效; 真机仍需检查画面、焦点和点击响应。 PrintWindow 探测仅表示 API 调用成功, 不保证像素内容有效; 真机仍需检查画面、焦点和点击响应。
## 合入 main 前的复核与急停补齐
合并目标为 `main`(原 `073e407`),来源为
`codex/feedback-unattended-setup-20261004`。本轮拉取又发现 `8a9495b`:
它是一个新增 F12 急停的提交,涉及三个文件,也纳入本次合并。
复核覆盖分支相对 main 的运行时、脚本、安装配置和测试变更,结合上述两轮审查记录;
AALC 子模块保持已验证的 `e1d1749`,没有追入 develop 的图标提交。
合并前另修复以下问题:
- 急停回调先写日志,日志抛错会跳过退出,日志阻塞也会延迟急停。
回调改为分发退出工作,不写日志;清理另有 250 毫秒强退兜底。
这遵循 [pynput 对 Windows 键盘回调的说明](https://pynput.readthedocs.io/en/latest/keyboard.html#the-keyboard-listener-thread):避免在回调中阻塞。
- 硬退出跳过驱动点击的 finally,可能留下按住的鼠标按钮。
驱动增加停止标志及输入锁,急停先拒绝新鼠标输入,再释放本实例按住的按钮。
驱动本身卡住时仍按时退出;本次离线验证不证明硬件故障下必定释放成功。
- `killswitch.stop` 原先未接到任务退出路径;现在正常结束、异常和预检拒绝都会关闭监听器。
- 退出码 130 原先显示 failed,镜牢轮询后还会继续导航和升级。
现在状态为 stopped,刷取脚本终止整轮并写入用户停止报告,不重试、不继续升级。
- 计划任务时限仍按 75 分钟镜牢设置,短于脚本的 100 分钟上限,也未覆盖一次卡死重试。
安装脚本改为 daily 45 分钟、每局镜牢 100 分钟、各至多两次尝试,另加 30 分钟收尾预算。
此改动只影响后续安装任务,未操作现有 Windows 计划任务。
- 纠正合成安装脚本关于注销后运行和固定体力恢复速率的过时注释,清理文档尾部空行。
验证:Linux / Python 3.12 全套 **437 项通过**(17.112 秒);相对 main 的
`git diff --check` 通过。新增回归涵盖真正退出 130 的子进程、保留恢复文件、用户停止后
不继续操作、驱动按住时急停、清理卡住仍退出以及正常/预检拒绝后的监听器清理。
Windows 热键、驱动及 PowerShell 计划任务仍需实机验收。
分支清理仅针对完整合入 main 的来源分支。`fix/team-scroll-patch` 仍有独有的
`dd4259d` 实验提交,本次不合入也不删除;其历史取舍见上面的 DSH 审查记录。
+7 -245
View File
@@ -63,61 +63,12 @@ class WindowGuard(threading.Thread):
size = int(self.cfg.set_win_size) size = int(self.cfg.set_win_size)
return int(size * 16 / 9), size return int(size * 16 / 9), size
def check_position(self):
"""窗口有一截跑到屏幕外时挪回工作区。
背景(2026-10-22 实测): 游戏会恢复自己保存的窗口位置, 出现过 (-8, 39) 这种
—— 左边 8 像素在屏幕外。前台模式(background_click=false)下 AALC 从**屏幕**
抓图, 窗口一出界抓到的画面就整体错位, 模板匹配相似度掉到 0.2~0.5, 表现是
"日志一直在动但几乎不点击"(实测 30 秒只点 1 次, 挪回来立刻恢复)。
set_win_position=free 时 AALC 不碰位置, 所以这里补上。
返回 'ok' / 'fixed' / None(没法判断)。
"""
try:
import win32con
import win32gui
except ImportError:
return None
handle = self.screen.handle
hwnd = handle._hwnd
try:
left, top, right, bottom = handle.monitor_info["Work"]
except Exception:
return None
try:
x, y, r, b = win32gui.GetWindowRect(hwnd)
except Exception:
return None
width, height = r - x, b - y
if width <= 0 or height <= 0:
return None
# 已经完整落在工作区内就不动
if x >= left and y >= top and r <= right and b <= bottom:
return 'ok'
new_x = max(left, min(x, right - width))
new_y = max(top, min(y, bottom - height))
try:
win32gui.SetWindowPos(hwnd, 0, new_x, new_y, 0, 0,
win32con.SWP_NOSIZE | win32con.SWP_NOZORDER |
win32con.SWP_NOACTIVATE)
except Exception as e:
self.log('[lc_mcp] window guard: 挪窗口失败 %s: %s' % (type(e).__name__, e))
return None
self.fixes += 1
self.log('[lc_mcp] window guard: 窗口 (%d,%d) 有部分在屏幕外, 已挪到 (%d,%d)'
% (x, y, new_x, new_y))
return 'fixed'
def check_once(self): def check_once(self):
"""返回 'ok' / 'fixed' / 'failed' / None(没有可检查的窗口)。""" """返回 'ok' / 'fixed' / 'failed' / None(没有可检查的窗口)。"""
handle = self.screen.handle handle = self.screen.handle
# set_windows 关闭表示用户自己管窗口, AALC 也不调, 这里同样不插手 # set_windows 关闭表示用户自己管窗口, AALC 也不调, 这里同样不插手
if self.cfg.simulator or not self.cfg.set_windows or not handle._hwnd or handle.isMinimized: if self.cfg.simulator or not self.cfg.set_windows or not handle._hwnd or handle.isMinimized:
return None return None
# 位置先修: 出界会让抓图错位, 那种情况下尺寸检查也没意义
if self.check_position() == 'fixed':
time.sleep(0.5)
current = (handle.width(True), handle.height(True)) current = (handle.width(True), handle.height(True))
want = self.want() want = self.want()
if current == want or 0 in current: if current == want or 0 in current:
@@ -228,8 +179,7 @@ class DriverClickProxy:
sx, sy = self._screen_pos(x, y) sx, sy = self._screen_pos(x, y)
if not self._driver.move_to(sx, sy): if not self._driver.move_to(sx, sy):
return False return False
self._driver.down(1) return self._driver.down(1) is not False
return True
def mouse_up(self, x, y): def mouse_up(self, x, y):
try: try:
@@ -255,13 +205,6 @@ def install_driver_click(auto, screen, driver=None, log=print):
if not ok: if not ok:
log('[lc_mcp] 驱动级输入未启用: %s' % why) log('[lc_mcp] 驱动级输入未启用: %s' % why)
return None return None
# 绑定目标窗口: click() 靠它做句柄级前台校验。
# 只比矩形是不够的 —— 窗口互相重叠时, 同一个屏幕坐标会同时落在两边,
# 实测把浏览器切到前台后, 几何校验照样通过(2026-10-23)。
try:
drv.bind_window(screen.handle.hwnd)
except Exception:
pass
proxy = DriverClickProxy(auto.input_handler, drv, screen, log=log) proxy = DriverClickProxy(auto.input_handler, drv, screen, log=log)
trace = os.environ.get('LCP_DRIVER_TRACE') trace = os.environ.get('LCP_DRIVER_TRACE')
@@ -282,6 +225,12 @@ def install_driver_click(auto, screen, driver=None, log=print):
return drv return drv
def stop_driver_click(auto):
handler = auto.input_handler
if isinstance(handler, DriverClickProxy):
handler._driver.emergency_stop()
@contextmanager @contextmanager
def driver_click_tasks(scheme, auto, screen, cfg, log=print): def driver_click_tasks(scheme, auto, screen, cfg, log=print):
"""每次游戏初始化完成后接管, 包括 all 任务和故障重启。""" """每次游戏初始化完成后接管, 包括 all 任务和故障重启。"""
@@ -356,190 +305,3 @@ def install_robust_set_foreground(screen, log=print):
handle.setForeground = setForeground handle.setForeground = setForeground
log('[lc_mcp] patch: SetForegroundWindow 加 AttachThreadInput 兜底') log('[lc_mcp] patch: SetForegroundWindow 加 AttachThreadInput 兜底')
return handle return handle
# ---------------------------------------------------------------- 日常本用默认队伍
def install_default_battle_team(scheme, log=print):
"""日常本不再翻队伍列表, 直接用界面上已经选中的默认队伍。
背景(2026-11-06): 这账号的队伍是自定义名字(不是 "编队#N"), 而
select_battle_team 按名字找队伍, 找不到就来回滑动 10 次(实测 61 秒), 滑完还把
队伍页留在滚动后的位置; 紧接着 battle.to_battle() 在 15 次循环里都找不到
"进入战斗" 按钮, 报 "超出最大尝试次数, 未能进入战斗", 整个日常就这样空转。
经验本/纽本本来就是用界面默认队伍打的, 跳过选队伍这一步即可。
"""
try:
from tasks.teams import team_formation as tf
except Exception as e:
log('[lc_mcp] 默认队伍补丁跳过: 无法导入 team_formation: %s' % e)
return None
original = getattr(tf, 'select_battle_team', None)
if original is None:
log('[lc_mcp] 默认队伍补丁跳过: 找不到 select_battle_team')
return None
def select_battle_team(*args, **kwargs):
log('[lc_mcp] patch: 日常本跳过选队伍, 直接用默认队伍')
return True
tf.select_battle_team = select_battle_team
scheme.select_battle_team = select_battle_team
log('[lc_mcp] patch: 日常本使用默认队伍')
return original
# ---------------------------------------------------------------- 镜牢按体系名选队
# 这账号把编队按体系命名(流血的队就叫 "流血"), AALC 却只会找 "编队#N" / "TEAMS #N"。
# 2026-11-14 实测: 列表里是 剧情关卡/斩击/突刺/打击/烧伤/流血/震颤/破裂/沉沦/呼吸法/充能
# 再接 编队#13..#38, 根本没有 "编队#1" —— AALC 翻满 10 页也找不到, 报 "无法寻得队伍"。
SYSTEM_TEAM_NAMES = {
'burn': ('烧伤',),
'bleed': ('流血',),
'tremor': ('震颤',),
'rupture': ('破裂',),
'poise': ('呼吸法', '呼吸'),
'sinking': ('沉沦',),
'charge': ('充能',),
'slash': ('斩击',),
'pierce': ('突刺',),
'blunt': ('打击',),
}
# 左侧编队列表的 OCR 命中范围(客户区像素, 1280x720 实测)
TEAM_LIST_X_MAX = 260
TEAM_LIST_Y_MIN = 300
TEAM_LIST_Y_MAX = 640
# 顶栏 "编队名" 的位置, 用来确认真的选中了
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)
result = []
for text, pos in (ocr or {}).items():
clean = str(text).replace(' ', '').strip()
if not clean:
continue
try:
x, y = float(pos[0]), float(pos[1])
except (TypeError, IndexError, ValueError):
continue
result.append((clean, x, y))
return result
def _in_list(x, y):
return x < TEAM_LIST_X_MAX and TEAM_LIST_Y_MIN < y < TEAM_LIST_Y_MAX
def _in_header(x, y):
x1, x2, y1, y2 = TEAM_HEADER
return x1 < x < x2 and y1 < y < y2
def _scroll_team_list(auto, direction, times=6, distance=250):
"""direction=+1 向下拖(回到列表顶部), -1 向上拖(往下翻)。"""
for _ in range(times):
auto.mouse_swipe_for_team_scroll(130, 430, dy=direction * distance, duration=0.3)
time.sleep(0.35)
def _header_is(auto, name):
"""顶栏当前队伍名就是 name。"""
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))
def _wait_header(auto, name, tries=3, delay=1.2):
"""点完之后顶栏要过一两帧才刷新, 多等几次。"""
for _ in range(tries):
time.sleep(delay)
if _header_is(auto, name):
return True
return False
def _select_team_by_name(auto, names, log=print, rounds=4):
"""在编队列表里按名字点选。成功返回 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)
return True
auto.mouse_click(1, 1)
time.sleep(0.3)
_scroll_team_list(auto, +1) # 先回到顶部
for round_index in range(rounds):
if auto.take_screenshot() is None:
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
if hit:
break
if hit:
name, x, y = hit
log('[lc_mcp] 编队列表里找到 %s @(%d,%d)' % (name, x, y))
auto.mouse_action_with_pos([x, y], offset=False)
if _wait_header(auto, name):
log('[lc_mcp] patch: 已按体系名选中编队 %s' % name)
return True
log('[lc_mcp] 点了 %s 但顶栏没变, 继续往下翻' % name)
_scroll_team_list(auto, -1, times=3)
log('[lc_mcp] 编队列表里没找到 %s(共 %d 轮)' % ('/'.join(names), rounds))
return False
def install_system_team_selection(log=print):
"""镜牢选队改成"按队伍体系对应的中文名"在列表里点。
AALC 原生只认 编队#N; 本账号的编队是自定义名字(流血/斩击/...), 原生逻辑永远选不上。
"""
try:
from tasks.mirror import mirror as mirror_mod
from module.automation import auto
except Exception as e:
log('[lc_mcp] 体系选队补丁跳过: 无法导入 %s' % e)
return None
original = getattr(mirror_mod, 'select_battle_team', None)
if original is None:
log('[lc_mcp] 体系选队补丁跳过: mirror 模块没有 select_battle_team')
return None
wanted = {'names': ()}
original_init = mirror_mod.Mirror.__init__
def __init__(self, team_setting, team_num):
original_init(self, team_setting, team_num)
wanted['names'] = SYSTEM_TEAM_NAMES.get(getattr(self, 'system', ''), ())
log('[lc_mcp] 镜牢体系 %s -> 目标编队 %s'
% (getattr(self, 'system', '?'), '/'.join(wanted['names']) or '(无配置)'))
def select_battle_team(num):
names = wanted['names']
if names:
try:
if _select_team_by_name(auto, names, log=log):
return True
except Exception as e:
log('[lc_mcp] 按名字选队出错: %s: %s' % (type(e).__name__, e))
return False
return original(num)
mirror_mod.Mirror.__init__ = __init__
mirror_mod.select_battle_team = select_battle_team
log('[lc_mcp] patch: 镜牢按体系名选队')
return original
+4 -16
View File
@@ -9,12 +9,10 @@ import json
import os import os
import sys import sys
from . import preflight from . import killswitch, preflight
from .aalc_engine import bootstrap from .aalc_engine import bootstrap
from . import killswitch from .aalc_patches import (WindowGuard, driver_click_tasks, install_exact_team_match,
from .aalc_patches import (WindowGuard, driver_click_tasks, install_default_battle_team, install_robust_set_foreground, stop_driver_click)
install_exact_team_match, install_robust_set_foreground,
install_system_team_selection)
# 任务 -> {参数名: AALC 配置项}; 参数只在本次运行内生效 # 任务 -> {参数名: AALC 配置项}; 参数只在本次运行内生效
TASKS = { TASKS = {
@@ -77,10 +75,7 @@ def run(task, params):
from tasks.battle import battle from tasks.battle import battle
from utils.path_manager import path_manager from utils.path_manager import path_manager
# 急停热键: 装得越早越好。驱动级点击期间鼠标被人和程序抢来抢去, with killswitch.listening(log=log, on_stop=lambda: stop_driver_click(auto)):
# 用户没法用鼠标点停止按钮, 键盘是唯一可靠的中断手段。
kill_listener = killswitch.install(log=log)
problems = preflight.check(preflight.collect(cfg), task, problems = preflight.check(preflight.collect(cfg), task,
desktop=None if cfg.simulator else preflight.desktop_size()) desktop=None if cfg.simulator else preflight.desktop_size())
if problems: if problems:
@@ -90,13 +85,6 @@ def run(task, params):
install_exact_team_match(auto, log) install_exact_team_match(auto, log)
install_robust_set_foreground(screen, log=log) install_robust_set_foreground(screen, log=log)
# 日常本(经验/纽本)不翻队伍列表: 队伍是自定义名字时按名字找必然失败,
# 白等 60 秒还会把界面滚乱, 后面 to_battle 就找不到 "进入战斗" 了。
if task in ('daily', 'all'):
install_default_battle_team(scheme, log=log)
# 镜牢: 编队是自定义名字(体系名), AALC 只会找 "编队#N"; 改成按体系名点选。
if task in ('mirror', 'all'):
install_system_team_selection(log=log)
guard = WindowGuard(screen, cfg, log=log) guard = WindowGuard(screen, cfg, log=log)
guard.start() guard.start()
restore_path = os.environ.get(RESTORE_ENV) restore_path = os.environ.get(RESTORE_ENV)
+30 -73
View File
@@ -22,6 +22,7 @@
import ctypes import ctypes
import os import os
import time import time
import threading
from ctypes import wintypes from ctypes import wintypes
from functools import lru_cache from functools import lru_cache
@@ -106,14 +107,9 @@ class DriverInput:
self.log = log self.log = log
self._dll = None self._dll = None
self._open = False self._open = False
# 目标窗口句柄。有它才能做句柄级前台校验 —— 几何校验在窗口重叠时没用: self._stopped = False
# 实测把浏览器切到前台, 点游戏里同一个坐标, 只比矩形的话校验照样通过。 self._input_lock = threading.RLock()
self.hwnd = 0 self._pressed = set()
def bind_window(self, hwnd):
"""绑定目标窗口。绑定后 click() 会做句柄级前台校验。"""
self.hwnd = int(hwnd or 0)
return self
# ---------------------------------------------------------------- 生命周期 # ---------------------------------------------------------------- 生命周期
@@ -139,7 +135,14 @@ class DriverInput:
@property @property
def ready(self): def ready(self):
return self._open and self._dll is not None return self._open and self._dll is not None and not self._stopped
def emergency_stop(self):
"""拒绝后续鼠标输入并释放本实例按住的按钮。急停线程另有退出超时。"""
self._stopped = True
with self._input_lock:
for button in tuple(self._pressed):
self.up(button)
def preflight(self): def preflight(self):
"""返回 (能否用, 原因)。用之前调一次, 把不能用的原因说清楚。""" """返回 (能否用, 原因)。用之前调一次, 把不能用的原因说清楚。"""
@@ -160,6 +163,7 @@ class DriverInput:
# ---------------------------------------------------------------- 移动 # ---------------------------------------------------------------- 移动
def move_relative(self, dx, dy): def move_relative(self, dx, dy):
with self._input_lock:
if not self.ready: if not self.ready:
return False return False
if dx == 0 and dy == 0: if dx == 0 and dy == 0:
@@ -185,27 +189,22 @@ class DriverInput:
# ---------------------------------------------------------------- 按键 # ---------------------------------------------------------------- 按键
def down(self, button=1): def down(self, button=1):
if self.ready: with self._input_lock:
self._dll.mouse_down(int(button)) if not self.ready:
return False
button = int(button)
self._pressed.add(button)
self._dll.mouse_down(button)
return True
def up(self, button=1): def up(self, button=1):
if self.ready: with self._input_lock:
if self._open and self._dll is not None:
self._dll.mouse_up(int(button)) self._dll.mouse_up(int(button))
self._pressed.discard(int(button))
def click(self, sx, sy, times=1, tol=1, require_foreground=True, def click(self, sx, sy, times=1, tol=1):
press_ms=60, settle=0.05): """先确认到位置, 再按下抬起。没到位就不点, 免得点错地方。"""
"""先确认到位置, 再按下抬起。
⛔ 三个已验证的"位置对却点不上"原因(2026-10-23 实测):
1. **前台不是游戏** —— 点击会送给当前前台窗口。实测: 窗口位置正确、坐标
换算正确, 但前台是别的窗口, 结果点了个寂寞, 而旧版这里照样返回 True。
现在用 require_foreground 检查: 点击点必须落在**前台窗口的客户区**内,
否则拒绝并报错 —— 宁可失败也不要静默点错地方。
2. **移动后立刻按下** —— 游戏按帧采样, 移动还没被处理就点击, 会算在旧位置。
所以定位成功后先 settle 再按。
3. **按下时间太短** —— 默认 30ms 在掉帧时会漏; 改成 60ms。
实测 30/60/120ms 在干净环境下都能中, 但 60ms 对负载高的情况更稳。
"""
if not self.ready: if not self.ready:
return False return False
if not self.move_to(sx, sy, tol=tol): if not self.move_to(sx, sy, tol=tol):
@@ -213,20 +212,14 @@ class DriverInput:
self.log('[driver] 定位失败: 目标(%d,%d) 实际(%d,%d), 不点击' self.log('[driver] 定位失败: 目标(%d,%d) 实际(%d,%d), 不点击'
% (sx, sy, cx, cy)) % (sx, sy, cx, cy))
return False return False
if require_foreground:
ok, why = click_point_is_on_foreground(sx, sy, self.hwnd or None)
if not ok:
self.log('[driver] 拒绝点击(%d,%d): %s' % (sx, sy, why))
return False
if settle:
time.sleep(settle)
for _ in range(int(times)): for _ in range(int(times)):
try: try:
self._dll.mouse_down(1) if not self.down(1):
time.sleep(press_ms / 1000.0) return False
time.sleep(0.03)
finally: finally:
self._dll.mouse_up(1) self.up(1)
return True return not self._stopped
def key_down(self, key): def key_down(self, key):
if self.ready: if self.ready:
@@ -241,42 +234,6 @@ class DriverInput:
self._dll.scroll(int(amount)) self._dll.scroll(int(amount))
def click_point_is_on_foreground(sx, sy, hwnd=None):
"""(屏幕坐标) 是否安全可点。
返回 (是否安全, 原因)。
⛔ 为什么必须比对句柄而不是比对矩形(2026-10-23 实测教训):
最初只判断"点击点落在前台窗口的矩形内", 结果把浏览器切到前台、点游戏里
同一个坐标, 校验**照样通过** —— 因为那个屏幕坐标同时也落在浏览器窗口的
矩形里。几何判断在窗口互相重叠时毫无意义。
所以: 给了 hwnd 就要求前台窗口**就是它**(或是它的子窗口); 没给 hwnd 时
退化成"有前台窗口且点在它矩形内", 可用性有限, 仅作兜底。
"""
user32 = ctypes.windll.user32
fg = user32.GetForegroundWindow()
if not fg:
return False, '当前没有前台窗口(GetForegroundWindow=0)'
if hwnd:
if fg == hwnd or user32.IsChild(hwnd, fg):
return True, 'ok'
buf = ctypes.create_unicode_buffer(64)
user32.GetWindowTextW(fg, buf, 64)
other = ctypes.create_unicode_buffer(64)
user32.GetWindowTextW(hwnd, other, 64)
return False, ('前台不是目标窗口(前台=%r, 目标=%r) —— 这次点击会打到别的窗口'
% (buf.value, other.value))
pt = wintypes.POINT(int(sx), int(sy))
rect = wintypes.RECT()
if not user32.GetWindowRect(fg, ctypes.byref(rect)):
return False, '取不到前台窗口的区域'
if not (rect.left <= pt.x < rect.right and rect.top <= pt.y < rect.bottom):
return False, ('点击点(%d,%d)不在前台窗口内(区域 %d,%d-%d,%d)'
% (pt.x, pt.y, rect.left, rect.top, rect.right, rect.bottom))
return True, 'ok'
def client_to_screen(hwnd, x, y): def client_to_screen(hwnd, x, y):
"""游戏客户区坐标 -> 屏幕坐标。""" """游戏客户区坐标 -> 屏幕坐标。"""
if not hwnd: if not hwnd:
+84 -103
View File
@@ -1,128 +1,109 @@
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
"""全局急停热键。 """全局急停热键。
为什么需要: 驱动级点击是闭环定位的 —— 手一动, 下一次点击前会读到新位置、算出 为什么需要: 驱动级点击是闭环定位的 —— 手一动,下一次点击前会读到新位置、
偏差、再把你推回目标点。所以任务运行期间鼠标是"拔河"状态, 用户没法用鼠标去点 算出偏差、再把你推回目标点。所以任务运行期间鼠标和人是"拔河"状态,用户没法
停止按钮。键盘不受影响, 所以急停必须走键盘。 用鼠标去点停止按钮。键盘不受影响,所以用键盘热键做急停。
⛔ 为什么不用 pynput / 全局钩子(2026-10-22 实测): ⛔ AALC 自带的 pause_hotkey 帮不上忙: 那个配置项只在 GUI(app/farming_interface.py)
pynput 的 GlobalHotKeys 在这台机器上**收不到任何键盘事件** —— 静态注册成功、 里注册, lc_mcp 走的是命令行子进程, 那条路径上没有热键监听。
线程也活着, 但 keybd_event 和 SendInput 两种注入都触发不了它。钩子依赖
WH_KEYBOARD_LL, 在当前会话下不工作。
改用 GetAsyncKeyState 轮询: 不装钩子、不需要消息循环, 实测能正确看到注入的
按键。用 0x8000 位判断"当前按下"。
另外 AALC 自带的 pause_hotkey 也帮不上忙: 那个配置项只在 GUI 默认 F12, 可用环境变量 LCP_KILL_KEY 改(取 pynput 的键名, 如 f11 / pause / esc)。
(app/farming_interface.py) 里注册, lc_mcp 走命令行子进程, 那条路径上没有监听。 按下后终止任务子进程, 游戏保留。硬退出不会执行任务的 finally;
临时配置由 TaskRunner 的恢复文件机制处理。退出前给驱动释放鼠标的短暂机会,
默认 End(小键盘区右下角, 好按且不冲突), 可用环境变量 LCP_KILL_KEY 改成 pause / scrolllock / f11 等。 清理卡住时仍强制退出。
⛔ 不要用 F12: 那是 Steam 的截图键(用户 2026-10-22 指出), 按下去会弹 Steam 截图
覆盖层, 而且可能被 Steam 抢先消费。Esc / F11 也不合适 —— 游戏里分别是关菜单
和切全屏。Pause 没有任何软件抢, 是最稳的选择。
按下后直接 os._exit —— 任务本来就是子进程, 硬退出不留锁或半截状态, 这与
aalc_task.py "停止 = 杀进程树" 的设计前提一致。监听器活在任务进程内,
所以即使 MCP 服务出问题、用户联系不上调用方, 按热键仍然能停。
""" """
import ctypes
import os import os
import threading import threading
import time from contextlib import contextmanager
DEFAULT_KEY = 'end' DEFAULT_KEY = 'f12'
EXIT_CODE = 130 # 与 SIGINT 一致, 便于上层识别"被用户中止" EXIT_CODE = 130 # 与 SIGINT 一致, 便于上层识别"被用户中止"
POLL_INTERVAL = 0.05 # 50ms 轮询, 人手按一下不会漏 STOP_TIMEOUT = 0.25
# 常用键 -> 虚拟键码。f12 保留是为了兼容旧配置, 但**不推荐** —— Steam 占用它。
VK = {
'f1': 0x70, 'f2': 0x71, 'f3': 0x72, 'f4': 0x73, 'f5': 0x74, 'f6': 0x75,
'f7': 0x76, 'f8': 0x77, 'f9': 0x78, 'f10': 0x79, 'f11': 0x7A, 'f12': 0x7B,
'esc': 0x1B, 'escape': 0x1B,
'pause': 0x13, 'break': 0x13,
'end': 0x23, 'home': 0x24, 'delete': 0x2E, 'insert': 0x2D,
'scrolllock': 0x91, 'numlock': 0x90, 'capslock': 0x14,
}
def resolve_vk(key): def _key_spec(name):
"""键名 -> 虚拟键码。认不出返回 None(调用方负责报错, 不要静默用默认值)。""" """'f12' -> '<f12>',pynput 的 GlobalHotKeys 要求尖括号形式。"""
name = (key or '').strip().lower().strip('<>') name = (name or '').strip().lower() or DEFAULT_KEY
if not name: if name.startswith('<') and name.endswith('>'):
name = DEFAULT_KEY return name
return VK.get(name) return '<%s>' % name
def _pressed(vk): def install(log=print, key=None, on_stop=None):
"""GetAsyncKeyState 的最高位 = 当前是否按下。""" """启动急停监听线程。返回监听器对象(可用于测试), 失败返回 None。
return bool(ctypes.windll.user32.GetAsyncKeyState(vk) & 0x8000)
任何异常都不向外抛 —— 急停装不上不该让任务起不来, 但必须把原因说清楚。
class KillSwitch: """
"""轮询线程。按住热键会立刻退出, 不会重复触发。"""
def __init__(self, vk, log=print, key_name=DEFAULT_KEY):
self.vk = vk
self.log = log
self.key_name = key_name
self.fired = False
self._stopped = threading.Event()
self._thread = threading.Thread(target=self._run, daemon=True,
name='lc_mcp-killswitch')
def start(self):
self._thread.start()
return self
def is_alive(self):
return self._thread.is_alive()
def stop(self):
self._stopped.set()
def _run(self):
# 先等一会儿, 避免把启动时按住的键当成急停
time.sleep(0.3)
while not self._stopped.is_set():
if _pressed(self.vk):
self._fire()
return
time.sleep(POLL_INTERVAL)
def _fire(self):
if self.fired:
return
self.fired = True
try:
self.log('[lc_mcp] ⛔ 急停热键 %s 被按下, 立即终止任务'
% self.key_name.upper())
self.log('[lc_mcp] 游戏窗口会保留, 可用 run_task 重新开始')
finally:
os._exit(EXIT_CODE)
def install(log=print, key=None):
"""启动急停轮询线程。返回 KillSwitch, 失败返回 None(不抛异常)。"""
key = key or os.environ.get('LCP_KILL_KEY') or DEFAULT_KEY key = key or os.environ.get('LCP_KILL_KEY') or DEFAULT_KEY
vk = resolve_vk(key) spec = _key_spec(key)
if vk is None:
log('[lc_mcp] 急停热键不可用: 认不出键名 %r(可用: %s), 请用 Ctrl+Alt+Del 强制停止'
% (key, ', '.join(sorted(VK))))
return None
try: try:
switch = KillSwitch(vk, log=log, key_name=key).start() from pynput import keyboard
except Exception as e: except Exception as e: # pynput 缺失/无显示环境
log('[lc_mcp] 急停热键启动失败(%s: %s), 请用 Ctrl+Alt+Del 强制停止' log('[lc_mcp] 急停热键不可用(pynput 加载失败: %s: %s), 请用 Ctrl+Alt+Del 强制停止'
% (type(e).__name__, e)) % (type(e).__name__, e))
return None return None
log('[lc_mcp] 急停热键已就绪: 按 %s 立即停止任务(键盘可用, 不需要鼠标, '
'也不依赖 MCP 服务)' % key.upper()) state = {'fired': False}
return switch
def on_activate():
if state['fired']:
return
state['fired'] = True
# Windows 在系统输入线程上调用此函数, 不在这里写日志或等待清理。
# 即使日志锁/驱动清理卡住, 也必须按时退出。
timer = threading.Timer(STOP_TIMEOUT, os._exit, args=(EXIT_CODE,))
timer.daemon = True
def shutdown():
try:
if on_stop is not None:
on_stop()
finally:
try:
os._exit(EXIT_CODE)
finally:
timer.cancel() # 仅供 _exit 被测试替换的情况
try:
timer.start()
worker = threading.Thread(target=shutdown, name='lc-mcp-emergency-stop', daemon=True)
state['worker'] = worker
worker.start()
except Exception:
timer.cancel()
os._exit(EXIT_CODE)
try:
listener = keyboard.GlobalHotKeys({spec: on_activate})
listener.daemon = True
listener.start()
except Exception as e:
log('[lc_mcp] 急停热键注册失败(%s: %s), 请用 Ctrl+Alt+Del 强制停止'
% (type(e).__name__, e))
return None
log('[lc_mcp] 急停监听已启动: 按 %s 终止任务, 游戏窗口保留; 可用 run_task 重新开始'
% key.upper())
listener._lc_state = state
return listener
def stop(switch): def stop(listener):
"""停止轮询(任务正常结束时调用)。""" """停止监听(任务正常结束时调用, 免得线程残留)。"""
if switch is None: if listener is None:
return return
try: try:
switch.stop() listener.stop()
except Exception: except Exception:
pass pass
@contextmanager
def listening(log=print, on_stop=None):
listener = install(log=log, on_stop=on_stop)
try:
yield listener
finally:
stop(listener)
+3 -1
View File
@@ -12,6 +12,7 @@ import time
from collections import deque from collections import deque
from .aalc_task import RESTORE_ENV from .aalc_task import RESTORE_ENV
from .killswitch import EXIT_CODE as USER_ABORT_EXIT
REPO = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) REPO = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
IS_WIN = sys.platform.startswith('win') IS_WIN = sys.platform.startswith('win')
@@ -186,7 +187,8 @@ class TaskRunner:
state = 'running' state = 'running'
else: else:
self.info.setdefault('ended', time.time()) self.info.setdefault('ended', time.time())
state = 'stopped' if self.info['stopped_by_user'] else 'succeeded' if code == 0 else 'failed' state = ('stopped' if self.info['stopped_by_user'] or code == USER_ABORT_EXIT
else 'succeeded' if code == 0 else 'failed')
r = {'ok': True, 'state': state, 'task': self.info['task'], 'params': self.info['params'], r = {'ok': True, 'state': state, 'task': self.info['task'], 'params': self.info['params'],
'elapsed_s': int((self.info.get('ended') or time.time()) - self.info['started']), 'elapsed_s': int((self.info.get('ended') or time.time()) - self.info['started']),
'log': self.info['log'], 'log_tail': tail(self.info['log'], max(1, min(int(lines), 200)))} 'log': self.info['log'], 'log_tail': tail(self.info['log'], max(1, min(int(lines), 200)))}
+9
View File
@@ -42,6 +42,10 @@ DEFAULT_REPORT_DIR = os.path.expanduser(os.path.join('~', 'lc_mcp', 'cycles'))
_log_file = None _log_file = None
class UserAborted(RuntimeError):
"""用户主动停止, 结束整轮, 不执行后续导航、升级或重试。"""
def log(msg): def log(msg):
line = '[%s] %s' % (time.strftime('%H:%M:%S'), msg) line = '[%s] %s' % (time.strftime('%H:%M:%S'), msg)
print(line, flush=True) print(line, flush=True)
@@ -176,6 +180,8 @@ def poll_task(task, timeout_s, sleep=time.sleep):
raise RuntimeError('无法读取任务状态: %s' % st.get('error', st)) raise RuntimeError('无法读取任务状态: %s' % st.get('error', st))
s = st.get('state') s = st.get('state')
el = int(time.time() - t0) el = int(time.time() - t0)
if s == 'stopped' or st.get('exit_code') == 130:
raise UserAborted('%s 已被用户停止' % task)
if s != 'running': if s != 'running':
log('%s 结束: state=%s elapsed=%ds exit=%s' % (task, s, el, st.get('exit_code'))) log('%s 结束: state=%s elapsed=%ds exit=%s' % (task, s, el, st.get('exit_code')))
# AALC 单次战斗失败后仍会 exit 0, succeeded 还要看 errors # AALC 单次战斗失败后仍会 exit 0, succeeded 还要看 errors
@@ -332,6 +338,9 @@ def main(argv=None):
try: try:
return run_cycle(args, step, finish) return run_cycle(args, step, finish)
except UserAborted as e:
step('用户停止', False, str(e))
return finish(130, '本轮已由用户停止')
except (OSError, RuntimeError, subprocess.SubprocessError) as e: except (OSError, RuntimeError, subprocess.SubprocessError) as e:
if isinstance(e, subprocess.CalledProcessError): if isinstance(e, subprocess.CalledProcessError):
output = (e.stdout or '') + (e.stderr or '') output = (e.stdout or '') + (e.stderr or '')
+3 -9
View File
@@ -5,14 +5,8 @@
# powershell -ExecutionPolicy Bypass -File scripts\install_convert_task.ps1 -EveryHours 6 # powershell -ExecutionPolicy Bypass -File scripts\install_convert_task.ps1 -EveryHours 6
# powershell -ExecutionPolicy Bypass -File scripts\install_convert_task.ps1 -Uninstall # powershell -ExecutionPolicy Bypass -File scripts\install_convert_task.ps1 -Uninstall
# #
# 节奏怎么定(体力恢复速度): # 默认每 4 小时检查一次; 是否合成以本轮实际体力读数为准, 不按固定恢复速率推算。
# Limbus 的体力每 6 分钟回 1 点, 上限 126。 # 合成 1 个模块需要 20 点体力。
# 合成 1 个模块要 20 点体力, 所以:
# 每 2 小时 -> 约 20 点 -> 1 个模块
# 每 4 小时 -> 约 40 点 -> 2 个模块(默认)
# 每 6 小时 -> 约 60 点 -> 3 个模块
# 只要不顶到 126 上限就不浪费恢复量, 所以更勤快些也不会亏。
# 4 小时是"每次都能换到东西"和"别老折腾游戏启动"之间的折中。
# #
# 这个任务和 LcMCPDailyCycle 是分开的: 用户明确要求这次不打任何关卡, # 这个任务和 LcMCPDailyCycle 是分开的: 用户明确要求这次不打任何关卡,
# 只挂机攒模块, 所以不能把刷取任务一起打开。 # 只挂机攒模块, 所以不能把刷取任务一起打开。
@@ -42,7 +36,7 @@ if (-not (Test-Path $script)) {
throw "找不到脚本: $script" throw "找不到脚本: $script"
} }
# 以当前用户运行。无人值守要点: 不要勾"只在用户登录时运行", 否则注销后不跑。 # 以当前用户的交互会话运行, 必须保持登录; 注销后没有可供截图/点击的游戏桌面。
$principal = New-ScheduledTaskPrincipal -UserId "$env:USERDOMAIN\$env:USERNAME" ` $principal = New-ScheduledTaskPrincipal -UserId "$env:USERDOMAIN\$env:USERNAME" `
-LogonType Interactive -RunLevel Limited -LogonType Interactive -RunLevel Limited
+4 -3
View File
@@ -6,7 +6,7 @@
# powershell -ExecutionPolicy Bypass -File scripts\install_unattended.ps1 # powershell -ExecutionPolicy Bypass -File scripts\install_unattended.ps1
# 可选: -At 05:30 每日运行时间。游戏每日重置为 06:00 (KST), 即北京时间 05:00 # 可选: -At 05:30 每日运行时间。游戏每日重置为 06:00 (KST), 即北京时间 05:00
# -EveryHours 2.5 改成"每 N 小时重复一轮"以持续刷取; 0 = 只按 -At 每天一次 # -EveryHours 2.5 改成"每 N 小时重复一轮"以持续刷取; 0 = 只按 -At 每天一次
# 单轮上限 = 60 + 75*Mirror 分钟, 间隔要大于它, 否则会被跳过 # 任务时限包含 daily 45 分钟、每局镜牢 100 分钟、各一次重试及 30 分钟收尾
# -Mirror 1 每轮镜牢局数, 0 = 不打镜牢 # -Mirror 1 每轮镜牢局数, 0 = 不打镜牢
# -Target 34 把队内人格升到的等级 # -Target 34 把队内人格升到的等级
# -Python <路径> 默认 vendor\aalc\.venv\Scripts\pythonw.exe (无窗口, 不抢游戏焦点) # -Python <路径> 默认 vendor\aalc\.venv\Scripts\pythonw.exe (无窗口, 不抢游戏焦点)
@@ -66,8 +66,9 @@ if (-not $NoWatchdog) {
$cycle = Join-Path $PSScriptRoot "auto_cycle.py" $cycle = Join-Path $PSScriptRoot "auto_cycle.py"
$action = New-ScheduledTaskAction -Execute $Python -WorkingDirectory $Repo ` $action = New-ScheduledTaskAction -Execute $Python -WorkingDirectory $Repo `
-Argument "-X utf8 `"$cycle`" --mirror $Mirror --target $Target" -Argument "-X utf8 `"$cycle`" --mirror $Mirror --target $Target"
# 一轮 daily 约 22 分钟, 每局镜牢实测 39~>70 分钟; 超过上限由计划任务强杀 # 与 auto_cycle.py 的 DAILY_TIMEOUT_S / MIRROR_TIMEOUT_S / STALL_RETRIES 对齐。
$limit = New-TimeSpan -Minutes (60 + 75 * [Math]::Max($Mirror, 0)) # 每个任务最多两次尝试, 另留 30 分钟给启动、轮询和升级; 避免外层先杀掉报告进程。
$limit = New-TimeSpan -Minutes (30 + 2 * (45 + 100 * [Math]::Max($Mirror, 0)))
if ($EveryHours -gt 0) { if ($EveryHours -gt 0) {
# 持续刷取: 每 N 小时重复一轮。开始时间取"现在", 装完即进入节奏。 # 持续刷取: 每 N 小时重复一轮。开始时间取"现在", 装完即进入节奏。
# 注意 New-TimeSpan -Hours 的参数是 [int], 传 2.5 会被截断成 2 小时, 所以用 -Minutes。 # 注意 New-TimeSpan -Hours 的参数是 [int], 传 2.5 会被截断成 2 小时, 所以用 -Minutes。
+29
View File
@@ -164,6 +164,35 @@ class RunAalcTest(unittest.TestCase):
self.assertIn('preflight', info) self.assertIn('preflight', info)
self.assertEqual(self.tools(mcp), ['run_task']) self.assertEqual(self.tools(mcp), ['run_task'])
def test_user_stop_never_retries(self):
for status in ({'state': 'stopped', 'exit_code': 130},
{'state': 'stopped'}, {'state': 'failed', 'exit_code': 130}):
mcp = FakeMcp([status], [DONE])
with self.subTest(status=status), self.assertRaises(auto_cycle.UserAborted):
self.run_aalc(mcp)
self.assertEqual(self.tools(mcp), ['run_task'])
def test_mirror_emergency_stop_ends_cycle_before_upgrade_or_navigation(self):
mcp = FakeMcp([DONE], [{'state': 'stopped', 'exit_code': 130}])
poll = auto_cycle.poll_task
with tempfile.TemporaryDirectory() as tmp:
with mock.patch.object(auto_cycle, 'probe', mcp.probe), \
mock.patch.object(auto_cycle, 'poll_task',
side_effect=lambda t, s, **kw: poll(t, s, sleep=lambda _: None)), \
mock.patch.object(auto_cycle, 'lunacy_guard', return_value=(True, 'ok')), \
mock.patch.object(auto_cycle, 'ensure_team1', return_value=True), \
mock.patch.object(auto_cycle, 'goto_identities') as navigate, \
mock.patch.object(auto_cycle, 'run') as upgrade, \
mock.patch('builtins.print'):
code = auto_cycle.main(['--mirror', '1', '--report-dir', tmp])
report = json.loads(next(Path(tmp).glob('cycle_*.json')).read_text(encoding='utf-8'))
self.assertEqual(code, 130)
self.assertFalse(report['ok'])
self.assertIn('用户停止', report['result'])
navigate.assert_not_called()
upgrade.assert_not_called()
self.assertEqual(self.tools(mcp), ['run_task', 'run_task'])
def test_exit_zero_with_errors_is_failure(self): def test_exit_zero_with_errors_is_failure(self):
mcp = FakeMcp([dict(DONE, errors=['[ERROR] 超出最大尝试次数,未能进入战斗'])]) mcp = FakeMcp([dict(DONE, errors=['[ERROR] 超出最大尝试次数,未能进入战斗'])])
ok, info = self.run_aalc(mcp) ok, info = self.run_aalc(mcp)
+29 -169
View File
@@ -132,8 +132,7 @@ class ClickTest(unittest.TestCase):
{'v': (pos['v'][0] + dx, pos['v'][1] + dy)}) {'v': (pos['v'][0] + dx, pos['v'][1] + dy)})
with mock.patch.object(di, 'get_cursor', lambda: pos['v']), \ with mock.patch.object(di, 'get_cursor', lambda: pos['v']), \
mock.patch.object(di.time, 'sleep', lambda s: None): mock.patch.object(di.time, 'sleep', lambda s: None):
# 这里只测定位逻辑, 前台校验另有 ForegroundCheckTest self.assertTrue(d.click(500, 400))
self.assertTrue(d.click(500, 400, require_foreground=False))
self.assertEqual(pos['v'], (500, 400)) self.assertEqual(pos['v'], (500, 400))
d._dll.mouse_down.assert_called_once_with(1) d._dll.mouse_down.assert_called_once_with(1)
d._dll.mouse_up.assert_called_once_with(1) d._dll.mouse_up.assert_called_once_with(1)
@@ -142,7 +141,7 @@ class ClickTest(unittest.TestCase):
d = self._drv(False) d = self._drv(False)
with mock.patch.object(di, 'get_cursor', lambda: (0, 0)), \ with mock.patch.object(di, 'get_cursor', lambda: (0, 0)), \
mock.patch.object(di.time, 'sleep', lambda s: None): mock.patch.object(di.time, 'sleep', lambda s: None):
self.assertFalse(d.click(500, 400, require_foreground=False)) self.assertFalse(d.click(500, 400))
d._dll.mouse_down.assert_not_called() d._dll.mouse_down.assert_not_called()
d._dll.mouse_up.assert_not_called() d._dll.mouse_up.assert_not_called()
@@ -301,8 +300,8 @@ class DriverWiringTest(unittest.TestCase):
def test_actual_task_entry_enables_driver_for_all_and_daily(self): def test_actual_task_entry_enables_driver_for_all_and_daily(self):
from lc_mcp import aalc_task from lc_mcp import aalc_task
for task in ('all', 'daily'): for task, problems in [('all', []), ('daily', []), ('all', ['invalid config'])]:
with self.subTest(task=task): with self.subTest(task=task, problems=problems):
auto, handler_type = vendor_auto() auto, handler_type = vendor_auto()
auto.clear_img_cache = mock.Mock() auto.clear_img_cache = mock.Mock()
auto.click_element = mock.Mock(return_value=False) auto.click_element = mock.Mock(return_value=False)
@@ -329,14 +328,21 @@ class DriverWiringTest(unittest.TestCase):
mock.patch.object(aalc_task, 'install_exact_team_match'), \ mock.patch.object(aalc_task, 'install_exact_team_match'), \
mock.patch.object(aalc_task, 'install_robust_set_foreground'), \ mock.patch.object(aalc_task, 'install_robust_set_foreground'), \
mock.patch.object(aalc_task, 'WindowGuard'), \ mock.patch.object(aalc_task, 'WindowGuard'), \
mock.patch.object(aalc_task.killswitch, 'install') as install_hotkey, \
mock.patch.object(aalc_task, 'log'), \ mock.patch.object(aalc_task, 'log'), \
mock.patch.object(aalc_task.preflight, 'collect', return_value={}), \ mock.patch.object(aalc_task.preflight, 'collect', return_value={}), \
mock.patch.object(aalc_task.preflight, 'desktop_size', return_value=(1920, 1080)), \ mock.patch.object(aalc_task.preflight, 'desktop_size', return_value=(1920, 1080)), \
mock.patch.object(aalc_task.preflight, 'check', return_value=[]), \ mock.patch.object(aalc_task.preflight, 'check', return_value=problems), \
mock.patch.object(di, 'DriverInput', return_value=drv), \ mock.patch.object(di, 'DriverInput', return_value=drv), \
mock.patch.object(ap.DriverClickProxy, '_screen_pos', return_value=(10, 20)): mock.patch.object(ap.DriverClickProxy, '_screen_pos', return_value=(10, 20)):
self.assertEqual(aalc_task.run(task, {}), 0) self.assertEqual(aalc_task.run(task, {}), 3 if problems else 0)
install_hotkey.return_value.stop.assert_called_once()
if problems:
drv.click.assert_not_called()
else:
drv.click.assert_called_once_with(10, 20, times=1) drv.click.assert_called_once_with(10, 20, times=1)
install_hotkey.call_args.kwargs['on_stop']()
drv.emergency_stop.assert_called_once()
def test_disabled_and_simulator_leave_initialization_unchanged(self): def test_disabled_and_simulator_leave_initialization_unchanged(self):
for enabled, simulator in [('0', False), ('1', True)]: for enabled, simulator in [('0', False), ('1', True)]:
@@ -350,16 +356,28 @@ class DriverWiringTest(unittest.TestCase):
class DriverFailureTest(unittest.TestCase): class DriverFailureTest(unittest.TestCase):
def test_emergency_stop_releases_press_and_blocks_subsequent_clicks(self):
drv = di.DriverInput()
drv._open, drv._dll = True, mock.Mock()
with mock.patch.object(drv, 'move_to', return_value=True), \
mock.patch.object(di.time, 'sleep', side_effect=lambda _: drv.emergency_stop()):
self.assertFalse(drv.click(10, 20, times=3))
drv._dll.mouse_down.assert_called_once_with(1)
drv._dll.mouse_up.assert_called_with(1)
self.assertFalse(drv.ready)
self.assertFalse(drv.click(30, 40))
self.assertFalse(drv.move_relative(20, 30))
self.assertFalse(drv.down())
drv._dll.moveR.assert_not_called()
self.assertEqual(drv._pressed, set())
def test_release_even_if_sleep_is_interrupted(self): def test_release_even_if_sleep_is_interrupted(self):
drv = di.DriverInput() drv = di.DriverInput()
drv._open, drv._dll = True, mock.Mock() drv._open, drv._dll = True, mock.Mock()
with mock.patch.object(drv, 'move_to', return_value=True), \ with mock.patch.object(drv, 'move_to', return_value=True), \
mock.patch.object(di, 'click_point_is_on_foreground',
lambda *a, **k: (True, '')), \
mock.patch.object(di.time, 'sleep', side_effect=InterruptedError): mock.patch.object(di.time, 'sleep', side_effect=InterruptedError):
with self.assertRaises(InterruptedError): with self.assertRaises(InterruptedError):
# settle=0 让第一个 sleep 出现在按下之后, 测的才是 try/finally drv.click(1, 2)
drv.click(1, 2, require_foreground=False, settle=0)
drv._dll.mouse_up.assert_called_once_with(1) drv._dll.mouse_up.assert_called_once_with(1)
def test_release_even_if_coordinate_lookup_fails(self): def test_release_even_if_coordinate_lookup_fails(self):
@@ -439,161 +457,3 @@ class ForegroundFallbackTest(unittest.TestCase):
if __name__ == '__main__': if __name__ == '__main__':
unittest.main() unittest.main()
class ForegroundCheckTest(unittest.TestCase):
"""位置对却点不上 —— 头号原因是前台不是游戏。
2026-10-23 实测: 窗口位置和坐标换算都正确, 但前台是浏览器, 点击全部落到
浏览器里, 而旧版 click() 照样返回 True。这组测试守住"必须拒绝"这一条。
"""
def _drv(self):
d = di.DriverInput(dll_path='X.dll', log=lambda m: None)
d._dll = mock.Mock()
d._open = True
return d
def test_rejects_when_no_foreground_window(self):
with mock.patch.object(di.ctypes.windll.user32, 'GetForegroundWindow',
return_value=0):
ok, why = di.click_point_is_on_foreground(100, 100)
self.assertFalse(ok)
self.assertIn('前台窗口', why)
def test_rejects_when_point_outside_foreground_window(self):
def fake_get_window_rect(hwnd, ptr):
r = ptr._obj
r.left, r.top, r.right, r.bottom = 0, 0, 50, 50
return 1
with mock.patch.object(di.ctypes.windll.user32, 'GetForegroundWindow',
return_value=12345), \
mock.patch.object(di.ctypes.windll.user32, 'GetWindowRect',
fake_get_window_rect), \
mock.patch.object(di.ctypes.windll.user32, 'GetWindowTextW'):
ok, why = di.click_point_is_on_foreground(999, 999)
self.assertFalse(ok)
self.assertIn('不在前台窗口内', why)
def test_accepts_when_point_inside_foreground_window(self):
def fake_get_window_rect(hwnd, ptr):
r = ptr._obj
r.left, r.top, r.right, r.bottom = 0, 0, 1920, 1080
return 1
with mock.patch.object(di.ctypes.windll.user32, 'GetForegroundWindow',
return_value=12345), \
mock.patch.object(di.ctypes.windll.user32, 'GetWindowRect',
fake_get_window_rect):
ok, why = di.click_point_is_on_foreground(500, 500)
self.assertTrue(ok)
self.assertEqual(why, 'ok')
def test_click_refuses_when_check_fails(self):
"""校验不过 -> 一个按键都不许发。"""
pos = {'v': (500, 400)}
d = self._drv()
d._dll.moveR.side_effect = lambda dx, dy, _: None
with mock.patch.object(di, 'get_cursor', lambda: pos['v']), \
mock.patch.object(di.time, 'sleep', lambda s: None), \
mock.patch.object(di, 'click_point_is_on_foreground',
lambda *a, **k: (False, '')):
self.assertFalse(d.click(500, 400))
d._dll.mouse_down.assert_not_called()
d._dll.mouse_up.assert_not_called()
def test_click_proceeds_when_check_passes(self):
pos = {'v': (500, 400)}
d = self._drv()
with mock.patch.object(di, 'get_cursor', lambda: pos['v']), \
mock.patch.object(di.time, 'sleep', lambda s: None), \
mock.patch.object(di, 'click_point_is_on_foreground',
lambda *a, **k: (True, '')):
self.assertTrue(d.click(500, 400))
d._dll.mouse_down.assert_called_once_with(1)
d._dll.mouse_up.assert_called_once_with(1)
def test_press_duration_is_passed_through(self):
"""按下时长必须真的用上 —— 30ms 在掉帧时会漏点。"""
pos = {'v': (500, 400)}
d = self._drv()
slept = []
with mock.patch.object(di, 'get_cursor', lambda: pos['v']), \
mock.patch.object(di.time, 'sleep', lambda s: slept.append(s)), \
mock.patch.object(di, 'click_point_is_on_foreground',
lambda *a, **k: (True, '')):
d.click(500, 400, press_ms=120, settle=0)
self.assertIn(0.12, slept, '按下时长没生效')
def test_settle_delay_happens_before_press(self):
"""定位成功到按下之间要有间隔, 否则游戏把这次点击算在旧位置。"""
pos = {'v': (500, 400)}
d = self._drv()
order = []
d._dll.mouse_down.side_effect = lambda b: order.append('down')
with mock.patch.object(di, 'get_cursor', lambda: pos['v']), \
mock.patch.object(di, 'click_point_is_on_foreground',
lambda *a, **k: (True, '')), \
mock.patch.object(di.time, 'sleep',
lambda s: order.append('sleep%.2f' % s)):
d.click(500, 400, settle=0.08)
self.assertIn('down', order)
self.assertTrue(any(x.startswith('sleep') for x in order[:order.index('down')]),
'按下之前必须有 sleep')
class HwndForegroundCheckTest(unittest.TestCase):
"""句柄级前台校验。
⛔ 为什么不能只比矩形(2026-10-23 实测): 把浏览器切到前台, 点游戏里同一个
坐标, 只判断"点在不在前台窗口矩形内"的话**照样通过** —— 因为那个屏幕坐标
同时也落在浏览器窗口的矩形里。窗口重叠时几何判断毫无意义。
给了 hwnd 就必须要求前台窗口就是它。
"""
def test_accepts_when_foreground_is_the_target(self):
with mock.patch.object(di.ctypes.windll.user32, 'GetForegroundWindow',
return_value=999):
ok, why = di.click_point_is_on_foreground(100, 100, 999)
self.assertTrue(ok)
self.assertEqual(why, 'ok')
def test_accepts_child_window_of_target(self):
"""游戏可能有子窗口拿到焦点, 也算在目标窗口上。"""
with mock.patch.object(di.ctypes.windll.user32, 'GetForegroundWindow',
return_value=1000), \
mock.patch.object(di.ctypes.windll.user32, 'IsChild',
return_value=True):
ok, _ = di.click_point_is_on_foreground(100, 100, 999)
self.assertTrue(ok)
def test_rejects_when_foreground_is_another_window(self):
with mock.patch.object(di.ctypes.windll.user32, 'GetForegroundWindow',
return_value=1000), \
mock.patch.object(di.ctypes.windll.user32, 'IsChild',
return_value=False), \
mock.patch.object(di.ctypes.windll.user32, 'GetWindowTextW'):
ok, why = di.click_point_is_on_foreground(100, 100, 999)
self.assertFalse(ok)
self.assertIn('前台不是目标窗口', why)
def test_bind_window_is_used_by_click(self):
"""绑定窗口后, click() 必须走句柄级校验。"""
d = di.DriverInput(dll_path='X.dll', log=lambda m: None)
d._dll = mock.Mock()
d._open = True
d.bind_window(4242)
self.assertEqual(d.hwnd, 4242)
seen = {}
def fake_check(sx, sy, hwnd=None):
seen['hwnd'] = hwnd
return False, '前台不是目标窗口'
with mock.patch.object(di, 'get_cursor', lambda: (10, 10)), \
mock.patch.object(di, 'click_point_is_on_foreground', fake_check), \
mock.patch.object(di.time, 'sleep', lambda s: None):
self.assertFalse(d.click(10, 10))
self.assertEqual(seen['hwnd'], 4242, 'click 没把绑定的句柄传下去')
d._dll.mouse_down.assert_not_called()
+142 -88
View File
@@ -7,11 +7,14 @@
目标点。所以任务跑起来时鼠标是"拔河"状态, 用户没法用鼠标去点停止按钮。键盘不受 目标点。所以任务跑起来时鼠标是"拔河"状态, 用户没法用鼠标去点停止按钮。键盘不受
影响, 所以急停必须走键盘。 影响, 所以急停必须走键盘。
实现上踩过一个坑: 先用了 pynput 的 GlobalHotKeys, 静态注册成功、线程也活着, 但 AALC 自带的 pause_hotkey 帮不上忙: 那个配置项只在 GUI(app/farming_interface.py)
keybd_event 和 SendInput 两种注入都触发不了它 —— 钩子在当前会话下收不到键。 里注册, lc_mcp 走命令行子进程, 那条路径上没有热键监听。这是本模块存在的原因。
改成 GetAsyncKeyState 轮询后实测可用。这里的测试守住轮询方案的几个关键性质。
""" """
import os
import sys import sys
import threading
import tempfile
import time
import unittest import unittest
from pathlib import Path from pathlib import Path
from unittest import mock from unittest import mock
@@ -20,121 +23,172 @@ sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
from lc_mcp import killswitch # noqa: E402 from lc_mcp import killswitch # noqa: E402
class ResolveVkTest(unittest.TestCase): class KeySpecTest(unittest.TestCase):
"""键名解析必须严格: 认不出来要返回 None, 不能悄悄用默认值 ——
否则用户以为设成了 F11, 实际还在监听 F12。"""
def test_common_keys(self): def test_wraps_plain_name(self):
self.assertEqual(killswitch.resolve_vk('f12'), 0x7B) self.assertEqual(killswitch._key_spec('f12'), '<f12>')
self.assertEqual(killswitch.resolve_vk('F11'), 0x7A)
self.assertEqual(killswitch.resolve_vk('esc'), 0x1B)
self.assertEqual(killswitch.resolve_vk('pause'), 0x13)
def test_accepts_angle_brackets(self): def test_keeps_already_wrapped(self):
self.assertEqual(killswitch.resolve_vk('<f12>'), 0x7B) self.assertEqual(killswitch._key_spec('<f11>'), '<f11>')
def test_trims_whitespace(self): def test_lowercases_and_trims(self):
self.assertEqual(killswitch.resolve_vk(' F12 '), 0x7B) self.assertEqual(killswitch._key_spec(' F12 '), '<f12>')
def test_empty_uses_default(self): def test_empty_falls_back_to_default(self):
self.assertEqual(killswitch.resolve_vk(''), killswitch.VK[killswitch.DEFAULT_KEY]) self.assertEqual(killswitch._key_spec(''), '<f12>')
self.assertEqual(killswitch.resolve_vk(None), killswitch.VK[killswitch.DEFAULT_KEY]) self.assertEqual(killswitch._key_spec(None), '<f12>')
self.assertEqual(killswitch._key_spec(' '), '<f12>')
def test_unknown_returns_none(self):
self.assertIsNone(killswitch.resolve_vk('nosuchkey'))
class InstallTest(unittest.TestCase): class InstallTest(unittest.TestCase):
"""装不上不能把任务带崩,但必须说清楚怎么应急。"""
def test_reports_unknown_key_and_suggests_fallback(self): def test_reports_when_pynput_is_missing(self):
lines = [] lines = []
got = killswitch.install(log=lines.append, key='nosuchkey') with mock.patch.dict(sys.modules, {'pynput': None}):
got = killswitch.install(log=lines.append, key='f12')
self.assertIsNone(got) self.assertIsNone(got)
joined = '\n'.join(lines) joined = '\n'.join(lines)
self.assertIn('认不出键名', joined) self.assertIn('急停热键不可用', joined)
self.assertIn('Ctrl+Alt+Del', joined, '必须给出应急手段') self.assertIn('Ctrl+Alt+Del', joined, '必须给出应急手段')
def test_installs_and_logs_the_key(self): def test_registers_the_configured_key(self):
lines = [] listener = mock.Mock()
with mock.patch.object(killswitch.KillSwitch, 'start', lambda self: self): listener.daemon = False
switch = killswitch.install(log=lines.append, key='f11') fake_keyboard = mock.Mock()
self.assertIsInstance(switch, killswitch.KillSwitch) fake_keyboard.GlobalHotKeys.return_value = listener
self.assertEqual(switch.vk, 0x7A) with mock.patch.dict(sys.modules, {'pynput': mock.Mock(keyboard=fake_keyboard),
self.assertIn('F11', '\n'.join(lines)) 'pynput.keyboard': fake_keyboard}):
got = killswitch.install(log=lambda m: None, key='f11')
self.assertIs(got, listener)
fake_keyboard.GlobalHotKeys.assert_called_once()
self.assertIn('<f11>', fake_keyboard.GlobalHotKeys.call_args[0][0])
listener.start.assert_called_once()
self.assertTrue(listener.daemon)
def test_env_var_overrides_default(self): def test_env_var_overrides_default_key(self):
with mock.patch.dict(killswitch.os.environ, {'LCP_KILL_KEY': 'esc'}), \ listener = mock.Mock()
mock.patch.object(killswitch.KillSwitch, 'start', lambda self: self): fake_keyboard = mock.Mock()
switch = killswitch.install(log=lambda m: None) fake_keyboard.GlobalHotKeys.return_value = listener
self.assertEqual(switch.vk, 0x1B) with mock.patch.dict(os.environ, {'LCP_KILL_KEY': 'pause'}), \
mock.patch.dict(sys.modules, {'pynput': mock.Mock(keyboard=fake_keyboard),
def test_start_failure_is_reported_not_raised(self): 'pynput.keyboard': fake_keyboard}):
lines = [] killswitch.install(log=lambda m: None)
with mock.patch.object(killswitch.KillSwitch, 'start', self.assertIn('<pause>', fake_keyboard.GlobalHotKeys.call_args[0][0])
side_effect=RuntimeError('boom')):
got = killswitch.install(log=lines.append)
self.assertIsNone(got)
self.assertIn('启动失败', '\n'.join(lines))
class PollingTest(unittest.TestCase): class ActivateTest(unittest.TestCase):
"""轮询判断的核心:0x8000 位。测错位会导致"一直触发"或"永不触发"。""" def _grab_handler(self, log=lambda _: None, on_stop=None):
listener = mock.Mock()
keyboard = mock.Mock()
keyboard.GlobalHotKeys.return_value = listener
with mock.patch.dict(sys.modules, {'pynput': mock.Mock(keyboard=keyboard)}):
killswitch.install(log=log, on_stop=on_stop)
return next(iter(keyboard.GlobalHotKeys.call_args.args[0].values())), listener
def test_high_bit_means_pressed(self): def fire(self, handler, listener):
with mock.patch.object(killswitch.ctypes.windll.user32, 'GetAsyncKeyState', handler()
return_value=0x8000): listener._lc_state['worker'].join(2)
self.assertTrue(killswitch._pressed(0x7B)) self.assertFalse(listener._lc_state['worker'].is_alive())
def test_low_bits_are_not_pressed(self): def test_exits_with_user_abort_code_and_only_fires_once(self):
# 0x0001 表示"上次调用后被按过", 不代表当前按住 —— 不能当成按下 handler, listener = self._grab_handler()
with mock.patch.object(killswitch.ctypes.windll.user32, 'GetAsyncKeyState',
return_value=0x0001):
self.assertFalse(killswitch._pressed(0x7B))
def test_zero_is_not_pressed(self):
with mock.patch.object(killswitch.ctypes.windll.user32, 'GetAsyncKeyState',
return_value=0):
self.assertFalse(killswitch._pressed(0x7B))
class FireTest(unittest.TestCase):
def _switch(self):
return killswitch.KillSwitch(0x7B, log=lambda m: None, key_name='f12')
def test_exits_with_user_abort_code(self):
sw = self._switch()
with mock.patch.object(killswitch.os, '_exit') as fake_exit: with mock.patch.object(killswitch.os, '_exit') as fake_exit:
sw._fire() self.fire(handler, listener)
handler()
fake_exit.assert_called_once_with(killswitch.EXIT_CODE) fake_exit.assert_called_once_with(killswitch.EXIT_CODE)
def test_only_fires_once(self): def test_broken_log_cannot_disable_the_hotkey(self):
sw = self._switch() log = mock.Mock()
handler, listener = self._grab_handler(log=log)
log.reset_mock()
log.side_effect = OSError('closed log')
with mock.patch.object(killswitch.os, '_exit') as fake_exit: with mock.patch.object(killswitch.os, '_exit') as fake_exit:
sw._fire() self.fire(handler, listener)
sw._fire() fake_exit.assert_called_once_with(130)
sw._fire() log.assert_not_called()
self.assertEqual(fake_exit.call_count, 1, '重复触发不该重复退出')
def test_logs_that_game_is_kept(self): def test_releases_input_before_exiting_even_when_cleanup_raises(self):
calls = []
def cleanup():
calls.append('release')
raise OSError('driver disconnected')
handler, listener = self._grab_handler(on_stop=cleanup)
# 不让测试线程输出预期的异常 traceback。
with mock.patch.object(killswitch.os, '_exit', side_effect=lambda code: calls.append(code)), \
mock.patch.object(threading, 'excepthook'):
self.fire(handler, listener)
self.assertEqual(calls, ['release', 130])
def test_hung_cleanup_cannot_block_exit_deadline(self):
release, exited = threading.Event(), threading.Event()
handler, listener = self._grab_handler(on_stop=release.wait)
with mock.patch.object(killswitch.os, '_exit', side_effect=lambda code: exited.set()):
handler()
try:
self.assertTrue(exited.wait(2), '清理卡住也必须触发强退')
finally:
release.set()
listener._lc_state['worker'].join(2)
def test_startup_message_explains_game_is_kept(self):
lines = [] lines = []
sw = killswitch.KillSwitch(0x7B, log=lines.append, key_name='f12') self._grab_handler(log=lines.append)
with mock.patch.object(killswitch.os, '_exit'): self.assertIn('游戏窗口保留', '\n'.join(lines))
sw._fire()
joined = '\n'.join(lines) def test_real_emergency_exit_is_reported_as_stopped(self):
self.assertIn('F12', joined) from lc_mcp.tasks import TaskRunner
self.assertIn('重新开始', joined) child = """
import json, os, sys, time
from types import SimpleNamespace
from lc_mcp import killswitch
from lc_mcp.aalc_task import RESTORE_ENV
class Listener:
def __init__(self, bindings): self.activate = next(iter(bindings.values()))
def start(self): pass
sys.modules['pynput'] = SimpleNamespace(keyboard=SimpleNamespace(GlobalHotKeys=Listener))
listener = killswitch.install(log=lambda msg: None)
with open(os.environ[RESTORE_ENV], 'w') as f: json.dump({'set_mirror_count': 1}, f)
listener.activate()
time.sleep(10)
"""
with tempfile.TemporaryDirectory() as tmp:
runner = TaskRunner(tmp, argv_factory=lambda t, p: [sys.executable, '-c', child])
self.assertTrue(runner.start('mirror', {'count': 2})['ok'])
self.addCleanup(runner.proc.kill)
runner.proc.wait(timeout=5)
status = runner.status()
self.assertEqual((status['state'], status['exit_code']), ('stopped', 130))
self.assertTrue(status['pending_restore'], '强退保留配置恢复文件, 下次启动前由服务处理')
class StopTest(unittest.TestCase): class StopTest(unittest.TestCase):
def test_stop_is_safe_on_none(self): def test_stop_is_safe_on_none(self):
killswitch.stop(None) killswitch.stop(None) # 不该抛
def test_stop_swallows_errors(self): def test_stop_calls_listener(self):
sw = mock.Mock() listener = mock.Mock()
sw.stop.side_effect = RuntimeError('boom') killswitch.stop(listener)
killswitch.stop(sw) listener.stop.assert_called_once()
def test_listening_stops_on_return_and_exception(self):
for failure in (False, True):
listener = mock.Mock()
with self.subTest(failure=failure), \
mock.patch.object(killswitch, 'install', return_value=listener):
try:
with killswitch.listening():
if failure:
raise RuntimeError('task failed')
except RuntimeError:
pass
listener.stop.assert_called_once()
def test_stop_swallows_listener_errors(self):
listener = mock.Mock()
listener.stop.side_effect = RuntimeError('boom')
killswitch.stop(listener) # 不该抛
if __name__ == '__main__': if __name__ == '__main__':
-168
View File
@@ -1,168 +0,0 @@
import os
import sys
import types
import unittest
from unittest import mock
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
from lc_mcp import aalc_patches # noqa: E402
class SystemTeamNamesTest(unittest.TestCase):
def test_all_ten_systems_are_mapped(self):
expected = {'burn', 'bleed', 'tremor', 'rupture', 'poise',
'sinking', 'charge', 'slash', 'pierce', 'blunt'}
self.assertEqual(set(aalc_patches.SYSTEM_TEAM_NAMES), expected)
def test_names_are_non_empty_strings(self):
for system, names in aalc_patches.SYSTEM_TEAM_NAMES.items():
self.assertIsInstance(names, tuple, system)
self.assertTrue(names, system)
for name in names:
self.assertIsInstance(name, str)
self.assertTrue(name.strip(), system)
def test_poise_accepts_both_spellings(self):
# 游戏里叫「呼吸法」, system_cn_zh 里叫「呼吸」, 两个都要能命中
self.assertIn('呼吸法', aalc_patches.SYSTEM_TEAM_NAMES['poise'])
self.assertIn('呼吸', aalc_patches.SYSTEM_TEAM_NAMES['poise'])
class RegionTest(unittest.TestCase):
def test_team_list_region(self):
self.assertTrue(aalc_patches._in_list(130, 493)) # 实测「流血」的位置
self.assertTrue(aalc_patches._in_list(255, 305))
self.assertFalse(aalc_patches._in_list(130, 120)) # 顶栏不算列表
self.assertFalse(aalc_patches._in_list(600, 493)) # 右侧面板
self.assertFalse(aalc_patches._in_list(130, 700))
def test_header_region(self):
self.assertTrue(aalc_patches._in_header(242, 125)) # 实测顶栏「流血」
self.assertFalse(aalc_patches._in_header(130, 493))
self.assertFalse(aalc_patches._in_header(900, 125))
def test_regions_do_not_overlap(self):
for x, y in [(130, 493), (242, 125), (600, 300), (1200, 600)]:
self.assertFalse(
aalc_patches._in_list(x, y) and aalc_patches._in_header(x, y),
(x, y),
)
class TeamOcrTest(unittest.TestCase):
def test_returns_list_and_strips_spaces(self):
auto = mock.Mock()
auto._run_ocr_for_text.return_value = {
'编队#20': [132.0, 340.5],
' 流血 ': [130.5, 493.0],
'': [0, 0],
}
items = aalc_patches._team_ocr(auto)
self.assertIn(('编队#20', 132.0, 340.5), items)
self.assertIn(('流血', 130.5, 493.0), items)
self.assertEqual(len(items), 2) # 空串被丢掉
def test_empty_ocr_gives_empty_list(self):
auto = mock.Mock()
auto._run_ocr_for_text.return_value = {}
self.assertEqual(aalc_patches._team_ocr(auto), [])
def test_bad_position_is_skipped_not_fatal(self):
auto = mock.Mock()
auto._run_ocr_for_text.return_value = {'流血': [], '斩击': [1.0, 2.0]}
self.assertEqual(aalc_patches._team_ocr(auto), [('斩击', 1.0, 2.0)])
class _FakeMirror:
def __init__(self, team_setting, team_num):
self.system = team_setting['system']
self.team_number = team_num
class InstallSystemTeamSelectionTest(unittest.TestCase):
"""用假模块验证挂载点与回退行为, 不依赖 AALC / Windows。"""
def setUp(self):
self.calls = []
def original(num):
self.calls.append(num)
return 'fallback'
self.original = original
self.mirror_mod = types.ModuleType('tasks.mirror.mirror')
self.mirror_mod.Mirror = _FakeMirror
self.mirror_mod.select_battle_team = original
self.auto = mock.Mock()
auto_mod = types.ModuleType('module.automation')
auto_mod.auto = self.auto
tasks_pkg = types.ModuleType('tasks')
tasks_pkg.__path__ = []
mirror_pkg = types.ModuleType('tasks.mirror')
mirror_pkg.__path__ = []
mirror_pkg.mirror = self.mirror_mod
module_pkg = types.ModuleType('module')
module_pkg.__path__ = []
self._patcher = mock.patch.dict(sys.modules, {
'tasks': tasks_pkg,
'tasks.mirror': mirror_pkg,
'tasks.mirror.mirror': self.mirror_mod,
'module': module_pkg,
'module.automation': auto_mod,
})
self._patcher.start()
self.addCleanup(self._patcher.stop)
def install(self):
return aalc_patches.install_system_team_selection(log=lambda *_: None)
def test_returns_original_and_replaces_module_global(self):
original = self.install()
self.assertIs(original, self.original)
self.assertIsNot(self.mirror_mod.select_battle_team, self.original)
# __init__ 也被包装, 但仍然正常构造
mirror = self.mirror_mod.Mirror({'system': 'bleed'}, 1)
self.assertEqual(mirror.system, 'bleed')
def test_known_system_uses_name_search(self):
self.install()
self.mirror_mod.Mirror({'system': 'bleed'}, 1)
with mock.patch.object(aalc_patches, '_select_team_by_name', return_value=True) as sel:
self.assertIs(self.mirror_mod.select_battle_team(1), True)
self.assertEqual(sel.call_args[0][1], ('流血',))
self.assertEqual(self.calls, []) # 成功后不再走编号回退
def test_name_search_failure_does_not_fall_back_to_number(self):
# 这号没有 编队#1, 静默回退到编号会选中错的队, 必须显式失败
self.install()
self.mirror_mod.Mirror({'system': 'bleed'}, 1)
with mock.patch.object(aalc_patches, '_select_team_by_name', return_value=False):
self.assertIs(self.mirror_mod.select_battle_team(1), False)
self.assertEqual(self.calls, [])
def test_exception_in_name_search_is_contained(self):
self.install()
self.mirror_mod.Mirror({'system': 'bleed'}, 1)
boom = mock.Mock(side_effect=RuntimeError('ocr down'))
with mock.patch.object(aalc_patches, '_select_team_by_name', boom):
self.assertIs(self.mirror_mod.select_battle_team(1), False)
def test_unknown_system_falls_back_to_original(self):
self.install()
self.mirror_mod.Mirror({'system': 'unknown_system'}, 3)
self.assertEqual(self.mirror_mod.select_battle_team(3), 'fallback')
self.assertEqual(self.calls, [3])
def test_missing_mirror_module_is_not_fatal(self):
with mock.patch.dict(sys.modules, {'tasks.mirror': None, 'tasks.mirror.mirror': None}):
self.assertIsNone(self.install())
if __name__ == '__main__':
unittest.main()