WindowGuard 补上窗口位置纠正(窗口出界会让抓图整体错位)

Browse Source
现象: 任务日志一直在动、进程正常,但几乎不点击 —— 实测 30 秒只点了 1 次。
      同时图像匹配相似度全在 0.2~0.5(AALC 阈值通常 0.8)。

排查: 游戏窗口位置是 (-8, 39) —— 左边 8 像素在屏幕外。

原因: 前台模式(background_click=false)下 AALC 从**屏幕**抓图(BitBlt 屏幕 DC),
      窗口一出界, 抓到的画面就整体偏移, 模板匹配自然全部失败; 而 AALC 的
      set_win_position=free 表示它不碰窗口位置, 所以没人管这件事。

      手动把窗口挪到 (0,0) 后, 30 秒内点击立刻恢复到 5 次 —— 确认因果。

修复: WindowGuard 原来只纠正客户区尺寸, 现在先纠正位置:
      用 monitor_info["Work"](工作区, 已扣任务栏)判断窗口是否完整落在里面,
      不在就用 SetWindowPos 夹回边界内(保留尺寸、不夺焦点)。
      位置放在尺寸检查之前 —— 出界时尺寸检查本身也没意义。

游戏每次启动都会恢复自己保存的位置, 所以这个纠正必须常驻, 不能只在启动时做一次。
This commit is contained in:
Codex Agent
2026-10-22 17:15:35 +08:00
parent 8a9495b185
commit 13c038a175
3 changed files with 230 additions and 120 deletions
+49
View File
@@ -63,12 +63,61 @@ 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:
+96 -46
View File
@@ -1,78 +1,128 @@
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
"""全局急停热键。 """全局急停热键。
为什么需要: 驱动级点击是闭环定位的 —— 手一动,下一次点击前会读到新位置、 为什么需要: 驱动级点击是闭环定位的 —— 手一动, 下一次点击前会读到新位置、算出
算出偏差、再把你推回目标点。所以任务运行期间鼠标和人是"拔河"状态,用户没法 偏差、再把你推回目标点。所以任务运行期间鼠标是"拔河"状态, 用户没法用鼠标去点
用鼠标去点停止按钮。键盘不受影响,所以用键盘热键做急停。 停止按钮。键盘不受影响, 所以急停必须走键盘。
⛔ AALC 自带的 pause_hotkey 帮不上忙: 那个配置项只在 GUI(app/farming_interface.py) ⛔ 为什么不用 pynput / 全局钩子(2026-10-22 实测):
里注册, lc_mcp 走的是命令行子进程, 那条路径上没有热键监听。 pynput 的 GlobalHotKeys 在这台机器上**收不到任何键盘事件** —— 静态注册成功、
线程也活着, 但 keybd_event 和 SendInput 两种注入都触发不了它。钩子依赖
WH_KEYBOARD_LL, 在当前会话下不工作。
改用 GetAsyncKeyState 轮询: 不装钩子、不需要消息循环, 实测能正确看到注入的
按键。用 0x8000 位判断"当前按下"。
默认 F12, 可用环境变量 LCP_KILL_KEY 改(取 pynput 的键名, 如 f11 / pause / esc)。 另外 AALC 自带的 pause_hotkey 也帮不上忙: 那个配置项只在 GUI
按下后直接 os._exit —— 任务本来就是子进程, 硬退出不会留下锁或半截状态, (app/farming_interface.py) 里注册, lc_mcp 走命令行子进程, 那条路径上没有监听。
这正是 aalc_task.py 的设计前提("停止 = 杀进程树")。
默认 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
DEFAULT_KEY = 'f12' DEFAULT_KEY = 'end'
EXIT_CODE = 130 # 与 SIGINT 一致, 便于上层识别"被用户中止" EXIT_CODE = 130 # 与 SIGINT 一致, 便于上层识别"被用户中止"
POLL_INTERVAL = 0.05 # 50ms 轮询, 人手按一下不会漏
# 常用键 -> 虚拟键码。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 _key_spec(name): def resolve_vk(key):
"""'f12' -> '<f12>',pynput 的 GlobalHotKeys 要求尖括号形式。""" """键名 -> 虚拟键码。认不出返回 None(调用方负责报错, 不要静默用默认值)。"""
name = (name or DEFAULT_KEY).strip().lower() name = (key or '').strip().lower().strip('<>')
if name.startswith('<') and name.endswith('>'): if not name:
return name name = DEFAULT_KEY
return '<%s>' % name return VK.get(name)
def install(log=print, key=None): def _pressed(vk):
"""启动急停监听线程。返回监听器对象(可用于测试), 失败返回 None。 """GetAsyncKeyState 的最高位 = 当前是否按下。"""
return bool(ctypes.windll.user32.GetAsyncKeyState(vk) & 0x8000)
任何异常都不向外抛 —— 急停装不上不该让任务起不来, 但必须把原因说清楚。
"""
key = key or os.environ.get('LCP_KILL_KEY') or DEFAULT_KEY
spec = _key_spec(key)
try: class KillSwitch:
from pynput import keyboard """轮询线程。按住热键会立刻退出, 不会重复触发。"""
except Exception as e: # pynput 缺失/无显示环境
log('[lc_mcp] 急停热键不可用(pynput 加载失败: %s: %s), 请用 Ctrl+Alt+Del 强制停止'
% (type(e).__name__, e))
return None
state = {'fired': False} 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 on_activate(): def start(self):
if state['fired']: 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 return
state['fired'] = True self.fired = True
log('[lc_mcp] ⛔ 急停热键 %s 被按下, 立即终止任务' % key.upper())
try: try:
log('[lc_mcp] 游戏窗口会保留, 可用 run_task 重新开始') self.log('[lc_mcp] ⛔ 急停热键 %s 被按下, 立即终止任务'
% self.key_name.upper())
self.log('[lc_mcp] 游戏窗口会保留, 可用 run_task 重新开始')
finally: finally:
os._exit(EXIT_CODE) os._exit(EXIT_CODE)
def install(log=print, key=None):
"""启动急停轮询线程。返回 KillSwitch, 失败返回 None(不抛异常)。"""
key = key or os.environ.get('LCP_KILL_KEY') or DEFAULT_KEY
vk = resolve_vk(key)
if vk is None:
log('[lc_mcp] 急停热键不可用: 认不出键名 %r(可用: %s), 请用 Ctrl+Alt+Del 强制停止'
% (key, ', '.join(sorted(VK))))
return None
try: try:
listener = keyboard.GlobalHotKeys({spec: on_activate}) switch = KillSwitch(vk, log=log, key_name=key).start()
listener.daemon = True
listener.start()
except Exception as e: except Exception as e:
log('[lc_mcp] 急停热键注册失败(%s: %s), 请用 Ctrl+Alt+Del 强制停止' log('[lc_mcp] 急停热键启动失败(%s: %s), 请用 Ctrl+Alt+Del 强制停止'
% (type(e).__name__, e)) % (type(e).__name__, e))
return None return None
log('[lc_mcp] 急停热键已就绪: 按 %s 立即停止任务(键盘可用, 不需要鼠标, '
log('[lc_mcp] 急停热键已就绪: 按 %s 立即停止任务(键盘可用, 不需要鼠标)' % key.upper()) '也不依赖 MCP 服务)' % key.upper())
listener._lc_state = state return switch
return listener
def stop(listener): def stop(switch):
"""停止监听(任务正常结束时调用, 免得线程残留)。""" """停止轮询(任务正常结束时调用)。"""
if listener is None: if switch is None:
return return
try: try:
listener.stop() switch.stop()
except Exception: except Exception:
pass pass
+85 -74
View File
@@ -7,10 +7,10 @@
目标点。所以任务跑起来时鼠标是"拔河"状态, 用户没法用鼠标去点停止按钮。键盘不受 目标点。所以任务跑起来时鼠标是"拔河"状态, 用户没法用鼠标去点停止按钮。键盘不受
影响, 所以急停必须走键盘。 影响, 所以急停必须走键盘。
AALC 自带的 pause_hotkey 帮不上忙: 那个配置项只在 GUI(app/farming_interface.py) 实现上踩过一个坑: 先用了 pynput 的 GlobalHotKeys, 静态注册成功、线程也活着, 但
里注册, lc_mcp 走命令行子进程, 那条路径上没有热键监听。这是本模块存在的原因。 keybd_event 和 SendInput 两种注入都触发不了它 —— 钩子在当前会话下收不到键。
改成 GetAsyncKeyState 轮询后实测可用。这里的测试守住轮询方案的几个关键性质。
""" """
import os
import sys import sys
import unittest import unittest
from pathlib import Path from pathlib import Path
@@ -20,110 +20,121 @@ 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 KeySpecTest(unittest.TestCase): class ResolveVkTest(unittest.TestCase):
"""键名解析必须严格: 认不出来要返回 None, 不能悄悄用默认值 ——
否则用户以为设成了 F11, 实际还在监听 F12。"""
def test_wraps_plain_name(self): def test_common_keys(self):
self.assertEqual(killswitch._key_spec('f12'), '<f12>') self.assertEqual(killswitch.resolve_vk('f12'), 0x7B)
self.assertEqual(killswitch.resolve_vk('F11'), 0x7A)
self.assertEqual(killswitch.resolve_vk('esc'), 0x1B)
self.assertEqual(killswitch.resolve_vk('pause'), 0x13)
def test_keeps_already_wrapped(self): def test_accepts_angle_brackets(self):
self.assertEqual(killswitch._key_spec('<f11>'), '<f11>') self.assertEqual(killswitch.resolve_vk('<f12>'), 0x7B)
def test_lowercases_and_trims(self): def test_trims_whitespace(self):
self.assertEqual(killswitch._key_spec(' F12 '), '<f12>') self.assertEqual(killswitch.resolve_vk(' F12 '), 0x7B)
def test_empty_falls_back_to_default(self): def test_empty_uses_default(self):
self.assertEqual(killswitch._key_spec(''), '<f12>') self.assertEqual(killswitch.resolve_vk(''), killswitch.VK[killswitch.DEFAULT_KEY])
self.assertEqual(killswitch._key_spec(None), '<f12>') self.assertEqual(killswitch.resolve_vk(None), killswitch.VK[killswitch.DEFAULT_KEY])
def test_unknown_returns_none(self):
self.assertIsNone(killswitch.resolve_vk('nosuchkey'))
class InstallTest(unittest.TestCase): class InstallTest(unittest.TestCase):
"""装不上不能把任务带崩,但必须说清楚怎么应急。"""
def test_reports_when_pynput_is_missing(self): def test_reports_unknown_key_and_suggests_fallback(self):
lines = [] lines = []
with mock.patch.dict(sys.modules, {'pynput': None}): got = killswitch.install(log=lines.append, key='nosuchkey')
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_registers_the_configured_key(self): def test_installs_and_logs_the_key(self):
listener = mock.Mock() lines = []
listener.daemon = False with mock.patch.object(killswitch.KillSwitch, 'start', lambda self: self):
fake_keyboard = mock.Mock() switch = killswitch.install(log=lines.append, key='f11')
fake_keyboard.GlobalHotKeys.return_value = listener self.assertIsInstance(switch, killswitch.KillSwitch)
with mock.patch.dict(sys.modules, {'pynput': mock.Mock(keyboard=fake_keyboard), self.assertEqual(switch.vk, 0x7A)
'pynput.keyboard': fake_keyboard}): self.assertIn('F11', '\n'.join(lines))
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_key(self): def test_env_var_overrides_default(self):
listener = mock.Mock() with mock.patch.dict(killswitch.os.environ, {'LCP_KILL_KEY': 'esc'}), \
fake_keyboard = mock.Mock() mock.patch.object(killswitch.KillSwitch, 'start', lambda self: self):
fake_keyboard.GlobalHotKeys.return_value = listener switch = killswitch.install(log=lambda m: None)
with mock.patch.dict(os.environ, {'LCP_KILL_KEY': 'pause'}), \ self.assertEqual(switch.vk, 0x1B)
mock.patch.dict(sys.modules, {'pynput': mock.Mock(keyboard=fake_keyboard),
'pynput.keyboard': fake_keyboard}): def test_start_failure_is_reported_not_raised(self):
killswitch.install(log=lambda m: None) lines = []
self.assertIn('<pause>', fake_keyboard.GlobalHotKeys.call_args[0][0]) with mock.patch.object(killswitch.KillSwitch, 'start',
side_effect=RuntimeError('boom')):
got = killswitch.install(log=lines.append)
self.assertIsNone(got)
self.assertIn('启动失败', '\n'.join(lines))
class ActivateTest(unittest.TestCase): class PollingTest(unittest.TestCase):
"""按下热键必须真的退出进程,而且只退一次。""" """轮询判断的核心:0x8000 位。测错位会导致"一直触发"或"永不触发"。"""
def _grab_handler(self): def test_high_bit_means_pressed(self):
listener = mock.Mock() with mock.patch.object(killswitch.ctypes.windll.user32, 'GetAsyncKeyState',
fake_keyboard = mock.Mock() return_value=0x8000):
fake_keyboard.GlobalHotKeys.return_value = listener self.assertTrue(killswitch._pressed(0x7B))
with mock.patch.dict(sys.modules, {'pynput': mock.Mock(keyboard=fake_keyboard),
'pynput.keyboard': fake_keyboard}): def test_low_bits_are_not_pressed(self):
killswitch.install(log=lambda m: None) # 0x0001 表示"上次调用后被按过", 不代表当前按住 —— 不能当成按下
bindings = fake_keyboard.GlobalHotKeys.call_args[0][0] with mock.patch.object(killswitch.ctypes.windll.user32, 'GetAsyncKeyState',
return list(bindings.values())[0], listener 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): def test_exits_with_user_abort_code(self):
handler, _ = self._grab_handler() sw = self._switch()
with mock.patch.object(killswitch.os, '_exit') as fake_exit: with mock.patch.object(killswitch.os, '_exit') as fake_exit:
handler() sw._fire()
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_only_fires_once(self):
handler, _ = self._grab_handler() sw = self._switch()
with mock.patch.object(killswitch.os, '_exit') as fake_exit: with mock.patch.object(killswitch.os, '_exit') as fake_exit:
handler() sw._fire()
handler() sw._fire()
handler() sw._fire()
self.assertEqual(fake_exit.call_count, 1, '重复按下不该重复退出') self.assertEqual(fake_exit.call_count, 1, '重复触发不该重复退出')
def test_logs_that_game_stays_alive(self): def test_logs_that_game_is_kept(self):
handler, _ = self._grab_handler()
lines = [] lines = []
sw = killswitch.KillSwitch(0x7B, log=lines.append, key_name='f12')
with mock.patch.object(killswitch.os, '_exit'): with mock.patch.object(killswitch.os, '_exit'):
handler.__closure__ # 确认是闭包 sw._fire()
killswitch.install(log=lines.append) joined = '\n'.join(lines)
# 用新的 logger 重新装一次才拿得到日志,这里只验证消息文案存在 self.assertIn('F12', joined)
self.assertTrue(callable(handler)) self.assertIn('重新开始', joined)
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_calls_listener(self): def test_stop_swallows_errors(self):
listener = mock.Mock() sw = mock.Mock()
killswitch.stop(listener) sw.stop.side_effect = RuntimeError('boom')
listener.stop.assert_called_once() killswitch.stop(sw)
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__':