From 4c0038d6577ab0a69fe9a9ccc45f9bcc5f6a2f4a Mon Sep 17 00:00:00 2001 From: ywsabc2 Date: Sat, 14 Nov 2026 05:51:36 +0000 Subject: [PATCH] =?UTF-8?q?P0-2=20=E9=95=9C=E7=89=A2=E7=AE=80=E5=8D=95?= =?UTF-8?q?=E9=94=AE=E7=9B=98=E5=AF=BB=E8=B7=AF=E6=94=B9=E4=B8=BA=E6=8C=89?= =?UTF-8?q?=E8=8A=82=E7=82=B9=E7=B1=BB=E5=9E=8B=E9=80=89=E6=96=B9=E5=90=91?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit config 开着 mirror_keyboard_simple_pathfinding 时 AALC 每步只按 ↑ 进 最上面的节点(11-14:3 层只进过 1 次商店)。常规寻路要 mouse_drag 拖 地图,第二段拖动只受超时限制且超时会退回主界面;连线识别还依赖本机 坐标不对的 my_crop,所以不改用常规寻路(BACKLOG 方案 B)。 install_typed_keyboard_road() 替换 search_road/mirror 两处的简单键盘 寻路:仍只按键不拖地图,用 AALC 自带 ONNX 模型整屏识别巴士右侧一列 节点,按上游 all_node_weight 从低到高按 up/right/down,每次用原 _keyboard_enter_succeeded 确认,最多 3 次,都不行调用原函数按 ↑。 每步记录下一列候选和进入的方向、类型、理由。LCP_TYPED_ROAD=0 关闭。 README 同时补上 P0-1 商店清单与本补丁的说明。 验证:排序、方向映射、逐个回退、识别失败与开关均有单测,复制的权重 表和网格参数与上游源码比对一致;全套 529 项通过。方向上无连线时按键 不会进错节点这一点需实机确认,BACKLOG 已写明对照方法。 Co-Authored-By: Claude Opus 5.5 --- README.md | 5 ++ docs/BACKLOG.md | 14 ++++ lc_mcp/aalc_patches.py | 101 ++++++++++++++++++++++ lc_mcp/aalc_task.py | 4 +- tests/test_typed_road.py | 176 +++++++++++++++++++++++++++++++++++++++ 5 files changed, 299 insertions(+), 1 deletion(-) create mode 100644 tests/test_typed_road.py diff --git a/README.md b/README.md index 9ce40d6..bcd2e83 100644 --- a/README.md +++ b/README.md @@ -160,6 +160,10 @@ MCP 初始化说明与工具描述均指导 AI 优先使用 AALC:常规日常 并以退出码 4 结束,`task_status` 显示 `failed`;AALC 正常返回不再被当成打完。 - **指定次数**:`mirror` 传 `count` 时本次临时关闭 `infinite_dungeons`(开着时 AALC 会把次数改成 9999), 原值和次数一起写入恢复文件,结束或被强杀后都会写回。 +- **商店清单**:上游按已不存在的 `assets/images/share/...` 列目录,必买/必卖/公式合成清单恒为空。 + `mirror`/`all` 任务按各主题/语言图片根补齐(当前 5/19/31 项)。 +- **键盘寻路按节点类型**:开着简单键盘寻路时不再只按 ↑。先识别巴士右侧下一列的节点类型, + 按上游权重(事件 < 商店 < 战斗 < …)依次按方向键,进不去再退回 ↑;不拖地图。`LCP_TYPED_ROAD=0` 关闭。 ## 无人值守 @@ -208,6 +212,7 @@ powershell -ExecutionPolicy Bypass -File scripts\install_convert_task.ps1 -Every | `LCP_PORT` | 8765 | 服务/bridge 端口 | | `LCP_KEEP_SHOTS` | 30 | 截图保留张数 | | `LCP_ALLOW_LUNACY` | 未设置 | 设为 `1` 时允许预检放行 `set_lunacy_to_enkephalin` 不为 0 的配置 | +| `LCP_TYPED_ROAD` | 未设置 | 设为 `0` 时镜牢简单键盘寻路保持上游的"只按 ↑",不按节点类型选方向 | | `LCP_KILL_KEY` | `end` | 任务子进程的急停键,如 `pause` / `scrolllock`;认不出的键名会报错而不是换成默认键 | | `LC_PY` | 当前解释器 | `levelup.py`/`auto_cycle.py` 调用 MCP 用的 Python | diff --git a/docs/BACKLOG.md b/docs/BACKLOG.md index f1de3c5..6da4f3f 100644 --- a/docs/BACKLOG.md +++ b/docs/BACKLOG.md @@ -76,6 +76,20 @@ Dijkstra 那套(`search_road.py:735`,代价 event 1 / shop 2 / battle 4 / bo **风险**:中。`simple_pathfinding` 当初是为了规避鼠标拖拽卡死加的,去掉要有回退开关。 +**状态(2026-11-14 云端)**:选 **B**,已实现,待实机验收。 + +- 不选 A 的原因:常规寻路(`search_road_from_road_map`)先用 `mouse_drag` 把巴士拖到固定位置,第二段拖动只受 + 超时限制、超时还会 `back_init_menu()`;连线识别 `identify_road` 依赖 `my_crop`,HANDOVER 已证实它在本机坐标不对。 +- 做法:`install_typed_keyboard_road()` 替换 `search_road_simple_keyboard`(`search_road` 和 `mirror` 两个命名空间)。 + 仍只按键、不拖地图:找到巴士 → 用 AALC 自带 ONNX 模型整屏识别(不裁剪)→ 取巴士右侧一列、按相对行映射成 + U/M/D → 按上游 `all_node_weight`(event 1 < shop 2 < battle 4 < boss/focused 6 < risky 7)依次按 `up/right/down`, + 每按一次都用原来的 `_keyboard_enter_succeeded()` 确认;都进不去就调用原函数按 ↑。最多 3 次按键,不会循环。 +- 只看下一列,是一步贪心,不是整层最优路线。 +- 回滚:任务环境变量 `LCP_TYPED_ROAD=0` 不装补丁;或在 AALC 里关掉简单键盘寻路,回到上游常规寻路。 +- **待实机确认的假设**:方向上没有连线时按该方向键不会进入别的节点(应当没有"进入"按钮,补丁随即换下一个方向)。 + 回归时对照日志 `[lc_mcp] 键盘寻路: 进入 X 方向的 <类型>` 与实际进入的节点类型;若对不上,说明按键语义与假设不符。 +- 日志:每一步打印 `下一列 U=event(1) D=shop(2) M=battle(4)` 与最终进入的方向、类型和理由。 + --- ## P1-3 饰品三选一加「体系优先」 diff --git a/lc_mcp/aalc_patches.py b/lc_mcp/aalc_patches.py index e24828e..169cf12 100644 --- a/lc_mcp/aalc_patches.py +++ b/lc_mcp/aalc_patches.py @@ -659,3 +659,104 @@ def install_shop_lists(log=print, images_dir=os.path.join('assets', 'images')): 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 每一步只按 ↑ 进最上面的节点, +# 完全不看节点类型(2026-11-14: 3 层只进过 1 次商店)。关掉它会走常规寻路, 那条路先用 +# mouse_drag 把地图拖到固定位置(当初开简单模式就是为了躲拖地图卡死), 连线识别还依赖 +# my_crop(交接文档实测在这台机器上坐标对不上)。 +# 这里保持"只按键、不拖地图": 用 AALC 自带的 ONNX 模型整屏识别巴士右侧下一列节点的类型, +# 按上游 all_node_weight 从低到高依次按方向键, 每次都确认进得去; 都不行再退回原来的 ↑。 +ROAD_KEYS = {'U': 'up', 'M': 'right', 'D': 'down'} # 与上游 MirrorMap.enter_next_node 一致 +ROAD_TIE_ORDER = ('U', 'M', 'D') # 同类型时先试 ↑, 尽量贴近原简单模式 +UPSTREAM_ROAD_COLUMN_GAP = 520 # 上游 search_road 的网格参数(2560x1440 标定) +UPSTREAM_ROAD_ROW_GAP = 437 +UPSTREAM_NODE_WEIGHT = { + 'battle': 4, 'boss_battle': 6, 'event': 1, 'focused_encounter': 6, + 'risky_encounter': 7, 'shop': 2, 'abnormality_focused_encounter': 6, +} +TYPED_ROAD_ENV = 'LCP_TYPED_ROAD' # 设为 0 时不装这个补丁, 完全回到原简单键盘寻路 + + +def rank_next_nodes(bus, nodes, scale, weights=UPSTREAM_NODE_WEIGHT, + column_gap=UPSTREAM_ROAD_COLUMN_GAP, row_gap=UPSTREAM_ROAD_ROW_GAP): + """巴士右侧下一列的节点 -> [(方向, 类型, 权重), ...], 权重小的在前。 + + nodes 是 identify_nodes() 的输出 [[类型, (x, y)], ...]; 只取与巴士相隔一列的节点, + 按相对巴士的行差映射成 U/M/D。同一方向识别出多个时保留权重最小的那个。 + """ + if not bus or not nodes: + return [] + gap_x, gap_y = column_gap * scale, row_gap * scale + best = {} + for kind, (x, y) in nodes: + if abs((x - bus[0]) - gap_x) > gap_x / 4: + continue + direction = {1: 'U', 0: 'M', -1: 'D'}.get(round((bus[1] - y) / gap_y)) + if direction is None: + continue + weight = weights.get(kind) + if weight is None: + continue + if direction not in best or weight < best[direction][1]: + best[direction] = (kind, weight) + return sorted(((d, kind, w) for d, (kind, w) in best.items()), + key=lambda item: (item[2], ROAD_TIE_ORDER.index(item[0]))) + + +def install_typed_keyboard_road(log=print, env=None): + """替换简单键盘寻路: 按节点类型挑方向, 失败时退回原 ↑ 逻辑。返回原函数, 未安装返回 None。""" + env = os.environ if env is None else env + if env.get(TYPED_ROAD_ENV) == '0': + log('[lc_mcp] 键盘寻路按类型补丁已关闭(%s=0), 沿用原简单键盘寻路' % TYPED_ROAD_ENV) + return None + try: + from tasks.mirror import mirror as mirror_mod + from tasks.mirror import search_road as road + from module.automation import auto + from module.config import cfg + except Exception as e: + log('[lc_mcp] 键盘寻路按类型补丁跳过: 无法导入 %s' % e) + return None + original = getattr(road, 'search_road_simple_keyboard', None) + if original is None or not hasattr(road, 'identify_nodes'): + log('[lc_mcp] 键盘寻路按类型补丁跳过: 上游没有简单键盘寻路或节点识别') + return None + weights = getattr(road, 'all_node_weight', UPSTREAM_NODE_WEIGHT) + column_gap = getattr(road, 'ROAD_COLUMN_GAP', UPSTREAM_ROAD_COLUMN_GAP) + row_gap = getattr(road, 'ROAD_ROW_GAP', UPSTREAM_ROAD_ROW_GAP) + + def search_road_simple_keyboard(): + if not cfg.mirror_keyboard_navigation: + return original() # 上游会说明需要开启键盘寻路 + try: + auto.mouse_to_blank() + time.sleep(0.3) + bus = auto.find_element('mirror/mybus_default_distance.png', take_screenshot=True) + nodes = road.identify_nodes(bus[0]) if bus else None + ranked = rank_next_nodes(bus, nodes, cfg.set_win_size / 1440, weights, column_gap, row_gap) + except Exception as e: + log('[lc_mcp] 键盘寻路: 识别下一列节点出错(%s: %s), 退回按 ↑' % (type(e).__name__, e)) + return original() + if not ranked: + log('[lc_mcp] 键盘寻路: %s, 退回按 ↑' % ('没找到巴士' if not bus else '下一列没识别到节点')) + return original() + log('[lc_mcp] 键盘寻路: 下一列 %s, 按权重从低到高依次尝试' + % ' '.join('%s=%s(%d)' % item for item in ranked)) + for direction, kind, weight in ranked: + auto.key_press(ROAD_KEYS[direction]) + time.sleep(1) + if road._keyboard_enter_succeeded(): + reason = '下一列中最低' if direction == ranked[0][0] else '更优的方向没能进入' + log('[lc_mcp] 键盘寻路: 进入 %s 方向的 %s(权重 %d, %s)' % (direction, kind, weight, reason)) + return True + log('[lc_mcp] 键盘寻路: %s 方向的 %s 没能进入, 试下一个' % (direction, kind)) + log('[lc_mcp] 键盘寻路: 按类型都没进入, 退回按 ↑') + return original() + + road.search_road_simple_keyboard = search_road_simple_keyboard + mirror_mod.search_road_simple_keyboard = search_road_simple_keyboard + log('[lc_mcp] patch: 镜牢键盘寻路按节点类型选方向(不拖地图)') + return original diff --git a/lc_mcp/aalc_task.py b/lc_mcp/aalc_task.py index a5b24a1..d4a3fff 100644 --- a/lc_mcp/aalc_task.py +++ b/lc_mcp/aalc_task.py @@ -14,7 +14,8 @@ from .aalc_engine import bootstrap from .aalc_patches import (WindowGuard, driver_click_tasks, headless_hdr_warning, install_default_battle_team, install_exact_team_match, install_robust_set_foreground, install_shop_lists, - install_system_team_selection, mirror_progress, stop_driver_click) + install_system_team_selection, install_typed_keyboard_road, + mirror_progress, stop_driver_click) from .game_lock import GameBusyError, exclusive_game # 任务 -> {参数名: AALC 配置项}; 参数只在本次运行内生效 @@ -128,6 +129,7 @@ def _run(task, params): if task in ('mirror', 'all'): install_system_team_selection(log=log) install_shop_lists(log=log) + install_typed_keyboard_road(log=log) guard = WindowGuard(screen, cfg, log=log) guard.start() restore_path = os.environ.get(RESTORE_ENV) diff --git a/tests/test_typed_road.py b/tests/test_typed_road.py new file mode 100644 index 0000000..62b0e4b --- /dev/null +++ b/tests/test_typed_road.py @@ -0,0 +1,176 @@ +# -*- coding: utf-8 -*- +"""镜牢键盘寻路按节点类型选方向(BACKLOG P0-2)。 + +2026-11-14: config 开着简单键盘寻路, AALC 每步只按 ↑, 3 层只进过 1 次商店。 +补丁仍只按键、不拖地图, 但先识别下一列节点类型, 按上游权重表挑方向。 +""" +import ast +import sys +import types +import unittest +from pathlib import Path +from types import SimpleNamespace +from unittest import mock + +REPO = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(REPO)) +from lc_mcp import aalc_patches as ap # noqa: E402 + +SEARCH_ROAD = REPO / 'vendor' / 'aalc' / 'tasks' / 'mirror' / 'search_road.py' +SCALE = 720 / 1440 # 本机 set_win_size=720 +GAP_X = ap.UPSTREAM_ROAD_COLUMN_GAP * SCALE +GAP_Y = ap.UPSTREAM_ROAD_ROW_GAP * SCALE +BUS = (100, 400) + + +def node(kind, columns=1, rows=0): + """相对巴士偏 columns 列、rows 行(向上为正)的节点。""" + return [kind, (BUS[0] + columns * GAP_X, BUS[1] - rows * GAP_Y)] + + +class RankNextNodesTest(unittest.TestCase): + + def test_orders_next_column_by_upstream_weight(self): + nodes = [node('battle', rows=0), node('event', rows=1), node('shop', rows=-1), + node('event', columns=2), node('event', columns=0.3)] + self.assertEqual(ap.rank_next_nodes(BUS, nodes, SCALE), + [('U', 'event', 1), ('D', 'shop', 2), ('M', 'battle', 4)]) + + def test_ties_prefer_up_then_middle(self): + nodes = [node('battle', rows=-1), node('battle', rows=0), node('battle', rows=1)] + self.assertEqual([d for d, _, _ in ap.rank_next_nodes(BUS, nodes, SCALE)], ['U', 'M', 'D']) + + def test_tolerates_detection_offsets_within_a_quarter_gap(self): + kind, (x, y) = node('shop', rows=1) + shifted = [kind, (x + GAP_X / 5, y + GAP_Y / 3)] + self.assertEqual(ap.rank_next_nodes(BUS, [shifted], SCALE), [('U', 'shop', 2)]) + + def test_keeps_the_better_detection_per_direction(self): + nodes = [node('risky_encounter', rows=0), node('event', rows=0)] + self.assertEqual(ap.rank_next_nodes(BUS, nodes, SCALE), [('M', 'event', 1)]) + + def test_rows_beyond_neighbours_and_unknown_types_are_ignored(self): + nodes = [node('event', rows=2), node('mystery', rows=0)] + self.assertEqual(ap.rank_next_nodes(BUS, nodes, SCALE), []) + + def test_no_bus_or_no_nodes(self): + self.assertEqual(ap.rank_next_nodes(None, [node('event')], SCALE), []) + self.assertEqual(ap.rank_next_nodes(BUS, None, SCALE), []) + + +@unittest.skipUnless(SEARCH_ROAD.is_file(), 'vendor/aalc 子模块未检出') +class UpstreamConstantsTest(unittest.TestCase): + """本地兜底常量必须与上游一致(运行时优先读上游的值)。""" + + def setUp(self): + self.tree = ast.parse(SEARCH_ROAD.read_text(encoding='utf-8')) + + def assignment(self, name): + for item in self.tree.body: + if isinstance(item, ast.Assign) and any(getattr(t, 'id', None) == name for t in item.targets): + return ast.literal_eval(item.value) + self.fail('上游没有 %s' % name) + + def test_weights_and_grid_match_upstream(self): + self.assertEqual(self.assignment('all_node_weight'), ap.UPSTREAM_NODE_WEIGHT) + self.assertEqual(self.assignment('ROAD_COLUMN_GAP'), ap.UPSTREAM_ROAD_COLUMN_GAP) + self.assertEqual(self.assignment('ROAD_ROW_GAP'), ap.UPSTREAM_ROAD_ROW_GAP) + + def test_direction_keys_match_upstream_keyboard_navigation(self): + source = SEARCH_ROAD.read_text(encoding='utf-8') + for direction, key in ap.ROAD_KEYS.items(): + self.assertIn('if next_step == "%s":\n auto.key_press("%s")' % (direction, key) + if direction == 'U' else + 'elif next_step == "%s":\n auto.key_press("%s")' % (direction, key), + source) + + +class TypedKeyboardRoadTest(unittest.TestCase): + + def setUp(self): + self.lines = [] + self.keys = [] + self.original = mock.Mock(return_value='original') + self.entered = [] + self.road = types.ModuleType('tasks.mirror.search_road') + self.road.search_road_simple_keyboard = self.original + self.road.identify_nodes = mock.Mock(return_value=[node('battle', rows=0), node('event', rows=1), + node('shop', rows=-1)]) + self.road._keyboard_enter_succeeded = lambda: self.entered.pop(0) + self.mirror = types.ModuleType('tasks.mirror.mirror') + self.mirror.search_road_simple_keyboard = self.original + self.auto = SimpleNamespace(mouse_to_blank=mock.Mock(), key_press=self.keys.append, + find_element=mock.Mock(return_value=BUS)) + self.cfg = SimpleNamespace(mirror_keyboard_navigation=True, set_win_size=720) + package = types.ModuleType('tasks.mirror') + package.mirror, package.search_road = self.mirror, self.road + tasks = types.ModuleType('tasks') + tasks.mirror = package + modules = {'tasks': tasks, 'tasks.mirror': package, 'tasks.mirror.mirror': self.mirror, + 'tasks.mirror.search_road': self.road, + 'module': types.ModuleType('module'), + 'module.automation': SimpleNamespace(auto=self.auto), + 'module.config': SimpleNamespace(cfg=self.cfg)} + for patch in (mock.patch.dict(sys.modules, modules), mock.patch.object(ap.time, 'sleep')): + patch.start() + self.addCleanup(patch.stop) + + def install(self, env=None): + return ap.install_typed_keyboard_road(log=self.lines.append, env=env or {}) + + def test_replaces_both_namespaces_and_enters_the_best_direction(self): + self.assertIs(self.install(), self.original) + self.assertIs(self.mirror.search_road_simple_keyboard, self.road.search_road_simple_keyboard) + self.entered = [True] + self.assertTrue(self.mirror.search_road_simple_keyboard()) + self.assertEqual(self.keys, ['up']) + self.original.assert_not_called() + log = '\n'.join(self.lines) + self.assertIn('U=event(1) D=shop(2) M=battle(4)', log) + self.assertIn('进入 U 方向的 event', log) + + def test_tries_next_direction_when_one_cannot_be_entered(self): + self.install() + self.entered = [False, True] + self.assertTrue(self.road.search_road_simple_keyboard()) + self.assertEqual(self.keys, ['up', 'down']) + self.assertIn('更优的方向没能进入', '\n'.join(self.lines)) + + def test_falls_back_to_original_when_nothing_can_be_entered(self): + self.install() + self.entered = [False, False, False] + self.assertEqual(self.road.search_road_simple_keyboard(), 'original') + self.assertEqual(self.keys, ['up', 'down', 'right']) + self.original.assert_called_once_with() + + def test_falls_back_without_pressing_when_bus_or_nodes_are_missing(self): + self.install() + for bus, nodes in ((None, []), (BUS, None), (BUS, [])): + with self.subTest(bus=bus, nodes=nodes): + self.original.reset_mock() + self.auto.find_element.return_value = bus + self.road.identify_nodes.return_value = nodes + self.assertEqual(self.road.search_road_simple_keyboard(), 'original') + self.original.assert_called_once_with() + self.assertEqual(self.keys, []) + + def test_recognition_error_falls_back(self): + self.install() + self.road.identify_nodes.side_effect = RuntimeError('onnx missing') + self.assertEqual(self.road.search_road_simple_keyboard(), 'original') + self.assertIn('RuntimeError', '\n'.join(self.lines)) + + def test_keyboard_navigation_off_keeps_upstream_behaviour(self): + self.install() + self.cfg.mirror_keyboard_navigation = False + self.assertEqual(self.road.search_road_simple_keyboard(), 'original') + self.road.identify_nodes.assert_not_called() + + def test_env_switch_leaves_upstream_untouched(self): + self.assertIsNone(self.install(env={ap.TYPED_ROAD_ENV: '0'})) + self.assertIs(self.road.search_road_simple_keyboard, self.original) + self.assertIs(self.mirror.search_road_simple_keyboard, self.original) + + +if __name__ == '__main__': + unittest.main()