P0-2 镜牢简单键盘寻路改为按节点类型选方向

Browse Source
config 开着 mirror_keyboard_simple_pathfinding 时 AALC 每步只按 ↑ 进
最上面的节点(11-14:3 层只进过 1 次商店)。常规寻路要 mouse_drag 拖
地图,第二段拖动只受超时限制且超时会退回主界面;连线识别还依赖本机
坐标不对的 my_crop,所以不改用常规寻路(BACKLOG 方案 B)。

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

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

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

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
yws
2026-11-14 05:51:36 +00:00
co-authored by Claude Opus 5.5
parent baa362808c
commit 4c0038d657
5 changed files with 299 additions and 1 deletions
+5
View File
@@ -160,6 +160,10 @@ MCP 初始化说明与工具描述均指导 AI 优先使用 AALC:常规日常
并以退出码 4 结束,`task_status` 显示 `failed`;AALC 正常返回不再被当成打完。 并以退出码 4 结束,`task_status` 显示 `failed`;AALC 正常返回不再被当成打完。
- **指定次数**:`mirror` 传 `count` 时本次临时关闭 `infinite_dungeons`(开着时 AALC 会把次数改成 9999), - **指定次数**:`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_PORT` | 8765 | 服务/bridge 端口 |
| `LCP_KEEP_SHOTS` | 30 | 截图保留张数 | | `LCP_KEEP_SHOTS` | 30 | 截图保留张数 |
| `LCP_ALLOW_LUNACY` | 未设置 | 设为 `1` 时允许预检放行 `set_lunacy_to_enkephalin` 不为 0 的配置 | | `LCP_ALLOW_LUNACY` | 未设置 | 设为 `1` 时允许预检放行 `set_lunacy_to_enkephalin` 不为 0 的配置 |
| `LCP_TYPED_ROAD` | 未设置 | 设为 `0` 时镜牢简单键盘寻路保持上游的"只按 ↑",不按节点类型选方向 |
| `LCP_KILL_KEY` | `end` | 任务子进程的急停键,如 `pause` / `scrolllock`;认不出的键名会报错而不是换成默认键 | | `LCP_KILL_KEY` | `end` | 任务子进程的急停键,如 `pause` / `scrolllock`;认不出的键名会报错而不是换成默认键 |
| `LC_PY` | 当前解释器 | `levelup.py`/`auto_cycle.py` 调用 MCP 用的 Python | | `LC_PY` | 当前解释器 | `levelup.py`/`auto_cycle.py` 调用 MCP 用的 Python |
+14
View File
@@ -76,6 +76,20 @@ Dijkstra 那套(`search_road.py:735`,代价 event 1 / shop 2 / battle 4 / bo
**风险**:中。`simple_pathfinding` 当初是为了规避鼠标拖拽卡死加的,去掉要有回退开关。 **风险**:中。`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 饰品三选一加「体系优先」 ## P1-3 饰品三选一加「体系优先」
+101
View File
@@ -659,3 +659,104 @@ def install_shop_lists(log=print, images_dir=os.path.join('assets', 'images')):
log('[lc_mcp] patch: 镜牢商店清单按 assets/images/<主题>/<语言> 补齐: %s' log('[lc_mcp] patch: 镜牢商店清单按 assets/images/<主题>/<语言> 补齐: %s'
% ', '.join('%s=%d' % item for item in filled.items())) % ', '.join('%s=%d' % item for item in filled.items()))
return filled 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
+3 -1
View File
@@ -14,7 +14,8 @@ from .aalc_engine import bootstrap
from .aalc_patches import (WindowGuard, driver_click_tasks, headless_hdr_warning, from .aalc_patches import (WindowGuard, driver_click_tasks, headless_hdr_warning,
install_default_battle_team, install_exact_team_match, install_default_battle_team, install_exact_team_match,
install_robust_set_foreground, install_shop_lists, 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 from .game_lock import GameBusyError, exclusive_game
# 任务 -> {参数名: AALC 配置项}; 参数只在本次运行内生效 # 任务 -> {参数名: AALC 配置项}; 参数只在本次运行内生效
@@ -128,6 +129,7 @@ def _run(task, params):
if task in ('mirror', 'all'): if task in ('mirror', 'all'):
install_system_team_selection(log=log) install_system_team_selection(log=log)
install_shop_lists(log=log) install_shop_lists(log=log)
install_typed_keyboard_road(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)
+176
View File
@@ -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()