864 lines
34 KiB
Python
864 lines
34 KiB
Python
# -*- coding: utf-8 -*-
|
|
"""到点启动游戏 -> 把体力合成成模块 -> 关掉游戏。不跑任何战斗任务。
|
|
|
|
用法: python convert_modules.py [--keep-game] [--start-timeout S]
|
|
退出码: 0 完成(含"体力不够, 无需合成") / 1 失败
|
|
|
|
为什么要单独一个脚本:
|
|
用户要的是"挂机等体力恢复, 攒模块", 但**不要打任何关卡**。AALC 的
|
|
make_enkephalin_module 是挂在 Luxcavation 流程里的(打完一次才顺手换一次),
|
|
没有独立的入口, 所以这里直接用界面操作, 不经过 AALC 的任务系统。
|
|
|
|
界面流程(1600x900 基准坐标, lc_ui 负责换算到实际客户区):
|
|
主界面 -> 点模组图标 -> 弹出 Charge Enkephalin
|
|
-> 页签 [Modules] / [Use Lunacy] / [Use Boxes]
|
|
-> 停在 Modules(免费合成) -> 点 » 取最大 -> Confirm
|
|
-> 体力 -20 换 1 模块
|
|
|
|
硬规则(用户明确要求):
|
|
1. **绝不消费狂气**。Use Lunacy 页签的坐标 USE_LUNACY_TAB 在代码里只用于
|
|
"确认自己没点到它", 任何点击路径都不会碰它。
|
|
2. **不打任何关卡**。全程只碰底栏模组图标和合成面板。
|
|
3. 记录合成前后狂气读数; 已知 OCR 抖动以外的变化需要人工核查。
|
|
"""
|
|
import argparse
|
|
import json
|
|
import os
|
|
import subprocess
|
|
import sys
|
|
import time
|
|
|
|
from lc_ui import HERE, click, items, keypress, probe, screen_text
|
|
|
|
GAME_EXE = r'D:\SteamLibrary\steamapps\common\Limbus Company\LimbusCompany.exe'
|
|
GAME_PROC = 'LimbusCompany'
|
|
REPO = os.path.dirname(HERE) if os.path.basename(HERE) == 'scripts' else HERE
|
|
PYW = os.path.join(REPO, 'vendor', 'aalc', '.venv', 'Scripts', 'pythonw.exe')
|
|
SERVER_PORT = 8765
|
|
|
|
# --- 坐标(1600x900 基准; lc_ui 会换算到真实客户区) ---
|
|
# 合成面板有三个页签, 从左到右: Modules / Use Lunacy / Use Boxes
|
|
# Modules (619,283) 免费合成, 本项目只走这条
|
|
# Use Lunacy(797,283) ⛔ 花狂气, 绝对不许点
|
|
# Use Boxes (957,283) 用体力箱, 本项目不用 —— 不定义常量: 定义了却没人用
|
|
# 会让人以为某条路径处理了它, 死代码比没有更糟
|
|
MODULE_ICON = (390, 805) # 主界面底栏, 绿胶囊图标(点开合成面板)
|
|
TAB_MODULES = (619, 283) # 免费合成页签
|
|
USE_LUNACY_TAB = (797, 283) # ⛔ 绝对不许点
|
|
BTN_MAX = (1019, 413) # »: 取当前能合成的最大数量
|
|
BTN_CONFIRM = (943, 671) # 确认合成
|
|
BTN_CANCEL = (656, 670) # 取消 / 关闭面板
|
|
|
|
MAIN_MENU_MARKERS = ('Window', 'Sinners', 'Drive', 'Theater', 'Extract', 'Dispense')
|
|
PANEL_MARKER = 'Charge Enkephalin'
|
|
|
|
LOG_DIR = os.path.expanduser(os.path.join('~', 'lc_mcp', 'modules'))
|
|
LOG_FILE = os.path.join(LOG_DIR, 'convert.log')
|
|
_result = {}
|
|
|
|
|
|
def log(msg):
|
|
line = '[%s] %s' % (time.strftime('%Y-%m-%d %H:%M:%S'), msg)
|
|
print(line, flush=True)
|
|
try:
|
|
os.makedirs(LOG_DIR, exist_ok=True)
|
|
with open(LOG_FILE, 'a', encoding='utf-8') as f:
|
|
f.write(line + '\n')
|
|
except OSError:
|
|
pass
|
|
|
|
|
|
# ---------------------------------------------------------------- MCP 服务
|
|
|
|
def server_listening(host='127.0.0.1', port=SERVER_PORT, timeout=1.0):
|
|
import socket
|
|
s = socket.socket()
|
|
s.settimeout(timeout)
|
|
try:
|
|
s.connect((host, port))
|
|
return True
|
|
except OSError:
|
|
return False
|
|
finally:
|
|
s.close()
|
|
|
|
|
|
def ensure_server(timeout_s=90):
|
|
"""确保 lc-mcp 的 TCP 服务在监听, 不在就拉起来。
|
|
|
|
值守场景下没人手动救它。虽然计划任务 LcMCPServer 配了 RestartCount=3,
|
|
但那只在进程"崩溃"时生效; 服务没起来(或重启后没登录)时, 这边的合成会
|
|
直接因为连不上而失败。自己拉一把最省事。
|
|
"""
|
|
if server_listening():
|
|
return True
|
|
log('MCP 服务(%d)未监听, 尝试拉起' % SERVER_PORT)
|
|
try:
|
|
subprocess.Popen([PYW, '-m', 'lc_mcp.server'], cwd=REPO, close_fds=True)
|
|
except OSError as e:
|
|
log('拉起服务失败: %s' % e)
|
|
return False
|
|
t0 = time.time()
|
|
while time.time() - t0 < timeout_s:
|
|
time.sleep(2)
|
|
if server_listening():
|
|
log('服务已就绪 (%.0fs)' % (time.time() - t0))
|
|
return True
|
|
log('等服务就绪超时(%ds)' % timeout_s)
|
|
return False
|
|
|
|
|
|
# ---------------------------------------------------------------- 桌面渲染
|
|
|
|
def _blit_ok(hdc, hwnd=None):
|
|
"""探测采集 API, 窗口走 AALC 的 PrintWindow(flags=3)。不验证画面内容。"""
|
|
if not hdc:
|
|
return False
|
|
import ctypes
|
|
from ctypes import wintypes
|
|
import win32gui
|
|
import win32ui
|
|
|
|
source = target = bitmap = old = bitmap_handle = None
|
|
try:
|
|
width, height = 64, 64
|
|
if hwnd:
|
|
left, top, right, bottom = win32gui.GetClientRect(hwnd)
|
|
width, height = right - left, bottom - top
|
|
if width <= 0 or height <= 0:
|
|
return False
|
|
source = win32ui.CreateDCFromHandle(hdc)
|
|
target = source.CreateCompatibleDC()
|
|
bitmap = win32ui.CreateBitmap()
|
|
bitmap.CreateCompatibleBitmap(source, width, height)
|
|
bitmap_handle = bitmap.GetHandle()
|
|
old = target.SelectObject(bitmap)
|
|
if hwnd:
|
|
capture = ctypes.windll.user32.PrintWindow
|
|
capture.argtypes = [wintypes.HWND, wintypes.HDC, wintypes.UINT]
|
|
capture.restype = wintypes.BOOL
|
|
return bool(capture(hwnd, target.GetSafeHdc(), 3))
|
|
target.BitBlt((0, 0), (width, height), source, (0, 0), 0x00CC0020)
|
|
return True
|
|
except Exception:
|
|
return False
|
|
finally:
|
|
try:
|
|
if old is not None:
|
|
target.SelectObject(old)
|
|
finally:
|
|
try:
|
|
if target is not None:
|
|
target.DeleteDC()
|
|
finally:
|
|
if bitmap_handle is not None:
|
|
win32gui.DeleteObject(bitmap_handle)
|
|
# source 只包装调用者的 DC, 由调用者 ReleaseDC, 不能 DeleteDC。
|
|
|
|
|
|
def screen_blit_ok():
|
|
import win32gui
|
|
hdc = None
|
|
try:
|
|
hdc = win32gui.GetDC(0)
|
|
return _blit_ok(hdc)
|
|
except Exception:
|
|
return False
|
|
finally:
|
|
if hdc:
|
|
win32gui.ReleaseDC(0, hdc)
|
|
|
|
|
|
def window_blit_ok(hwnd):
|
|
import win32gui
|
|
hdc = None
|
|
try:
|
|
if win32gui.IsIconic(hwnd):
|
|
return False
|
|
hdc = win32gui.GetWindowDC(hwnd)
|
|
return _blit_ok(hdc, hwnd=hwnd)
|
|
except Exception:
|
|
return False
|
|
finally:
|
|
if hdc:
|
|
win32gui.ReleaseDC(hwnd, hdc)
|
|
|
|
|
|
def render_ok():
|
|
"""游戏画面是否可采集。
|
|
|
|
⛔ 原来只测屏幕 BitBlt(GetDC(0))。2026-10-22 实测它在 RDP 会话下会瞬时失败,
|
|
而 AALC 走的是 background_screenshot(窗口 DC + PrintWindow), 那条路照样能截到图
|
|
—— 结果是我的自检把本来能干活的轮次判成"截不到图"给跳过了(10-17 02:23 就这样
|
|
白丢过一轮)。
|
|
|
|
现在优先按 AALC 的方式测**窗口**能否采集, 窗口不在或不可采时才回退到屏幕。
|
|
"""
|
|
hwnd = _find_hwnd()
|
|
if hwnd and window_blit_ok(hwnd):
|
|
return True
|
|
return screen_blit_ok()
|
|
|
|
|
|
def parse_session_table(text):
|
|
"""解析 `query session` 的输出。
|
|
|
|
实测格式(注意: 成功时返回码也是 1, 不能拿返回码判断成败):
|
|
SESSIONNAME USERNAME ID STATE TYPE DEVICE
|
|
services 0 Disc
|
|
>console YWS-HHH 1 Active
|
|
31c5ce94259d4... 65536 Listen
|
|
rdp-tcp 65537 Listen
|
|
|
|
行首的 '>' 标出**当前**会话。用户从 RDP 连进来时会变成:
|
|
>rdp-tcp#70 YWS-HHH 1 Active
|
|
console 3 Conn
|
|
这时物理 console 的画面是空的, BitBlt 采集不到东西。
|
|
"""
|
|
current = rdp_active = console = None
|
|
for line in text.splitlines():
|
|
raw = line.rstrip()
|
|
stripped = raw.strip()
|
|
if not stripped or stripped.lower().startswith('sessionname'):
|
|
continue
|
|
is_current = raw.lstrip().startswith('>')
|
|
parts = stripped.lstrip('>').split()
|
|
if len(parts) < 3:
|
|
continue
|
|
name = parts[0]
|
|
# ID 列: 从后往前找第一个纯数字, 比按固定列切更耐得住用户名带空格
|
|
sid = None
|
|
for tok in parts[1:]:
|
|
if tok.isdigit():
|
|
sid = tok
|
|
break
|
|
state = 'Active' if 'active' in stripped.lower() else (
|
|
'Disc' if 'disc' in stripped.lower() else '')
|
|
if is_current:
|
|
current = name
|
|
if name.startswith('rdp-tcp#') and state == 'Active':
|
|
rdp_active = name
|
|
if name == 'console':
|
|
console = sid
|
|
return {'current': current, 'rdp_active': rdp_active, 'console': console}
|
|
|
|
|
|
def session_state():
|
|
"""查当前会话归属, 用于把"截不到图"的原因说清楚。
|
|
|
|
实测两种都会让 BitBlt 失败, 但性质完全不同:
|
|
* 会话掉到 Disc -> 看门狗能把它挂回 console, 自愈
|
|
* RDP 会话 Active 占着显示 -> console 画面是空的, 看门狗**不会动**(它只看 Disc)
|
|
不区分的话日志里只会留一句"会话被断开", 排查时会被带偏。
|
|
"""
|
|
try:
|
|
out = subprocess.run(['query', 'session'], capture_output=True, text=True,
|
|
errors='ignore', timeout=20).stdout
|
|
except (OSError, subprocess.SubprocessError):
|
|
return None
|
|
if not isinstance(out, str):
|
|
# 拿到的不是文本就别硬解析 —— 这只是诊断信息, 不值得为它炸掉整轮
|
|
return None
|
|
st = parse_session_table(out)
|
|
return st if any(st.values()) else None
|
|
|
|
|
|
def ensure_display(timeout_s=90):
|
|
"""确认桌面在出图, 不在就先跑看门狗把它挂回来。
|
|
|
|
为什么这轮必须自己做: RDP 断开时 Windows 会把显示表面拆掉, 截图全黑,
|
|
之后所有模板匹配和 OCR 都是瞎的。看门狗 LcKeepDisplay 每分钟修一次, 但
|
|
整轮合成只跑 3 分钟左右 —— 断线正好落在这 3 分钟里的话, 这一轮必然失败,
|
|
而下一轮要等 4 小时。实测 2026-10-16 一天内会话掉了两次, 不是小概率。
|
|
"""
|
|
if render_ok():
|
|
return True
|
|
st = session_state()
|
|
if st and st.get('rdp_active'):
|
|
# RDP 会话 Active 时 console 画面是空的, 看门狗按设计不会动它(它只处理 Disc)。
|
|
# 硬把它踢到 console 会把正在用的人踢下线, 所以这里只报告, 不擅自动手。
|
|
log('桌面未在出图, 而 RDP 会话 %s 处于 Active(占着显示) —— '
|
|
'看门狗只处理 Disc, 这种情况要人工把 RDP 断开; 本轮跳过' % st['rdp_active'])
|
|
return False
|
|
log('桌面未在出图(BitBlt 失败), 跑看门狗把显示挂回 console'
|
|
+ ('(会话状态: %s)' % st if st else ''))
|
|
watchdog = os.path.join(HERE, 'keep_display.ps1')
|
|
try:
|
|
subprocess.run(['powershell.exe', '-NoProfile', '-ExecutionPolicy', 'Bypass',
|
|
'-File', watchdog], capture_output=True, text=True,
|
|
errors='ignore', timeout=120)
|
|
except (OSError, subprocess.SubprocessError) as e:
|
|
log('看门狗执行失败: %s' % e)
|
|
t0 = time.time()
|
|
while time.time() - t0 < timeout_s:
|
|
time.sleep(3)
|
|
if render_ok():
|
|
log('显示已恢复 (%.0fs)' % (time.time() - t0))
|
|
return True
|
|
log('显示仍未恢复, 这轮大概会失败')
|
|
return False
|
|
|
|
|
|
# ---------------------------------------------------------------- 屏幕判定
|
|
|
|
def screen():
|
|
return screen_text(items())
|
|
|
|
|
|
def on_main_menu(txt):
|
|
return sum(1 for m in MAIN_MENU_MARKERS if m in txt) >= 4
|
|
|
|
|
|
def panel_open(txt):
|
|
return PANEL_MARKER in txt
|
|
|
|
|
|
# ---------------------------------------------------------------- 狂气
|
|
|
|
LABEL_KEY = 'NACY' # 见下: LUNACY 的首字母常被 OCR 吃掉, 只认后半段
|
|
|
|
|
|
def find_lunacy_label(its=None):
|
|
"""找狂气标签所在的那个 OCR 元素。
|
|
|
|
⛔ 实测坑(2026-10-16 11:11): OCR 把 "LUNACY" 读成了 **"UNACY"** —— 首字母 L
|
|
被吃掉了。而代码原本写的是 `'LUNACY' in text`, "UNACY" 不含 "LUNACY",
|
|
于是每次都被判成"读不到", 狂气校验直接退化成 None -> 跳过比对, 防线形同虚设。
|
|
(同一块底栏的体力却一直读得到, 所以只看日志很难发现。)
|
|
|
|
改成认后半段 "NACY": LUNACY / UNACY / 甚至 NACY 都能命中, 而这个词根
|
|
在游戏界面里不会出现在别处。
|
|
"""
|
|
if its is None:
|
|
its = items()
|
|
for it in its:
|
|
if LABEL_KEY in it.get('text', '').upper():
|
|
return it
|
|
# 再退一步: 底栏那一带最靠左的短文本元素(标签位置很固定)
|
|
near = [it for it in its
|
|
if 775 < it.get('y', 0) < 815 and it.get('x', 0) < 700
|
|
and (it.get('w') or 0) < 100]
|
|
if near:
|
|
return sorted(near, key=lambda it: it.get('x', 0))[-1]
|
|
return None
|
|
|
|
|
|
def read_lunacy(reads=5, pause=1.0):
|
|
"""读狂气余额, 取多次读数的众数。
|
|
|
|
两个实测坑:
|
|
1. 标签首字母会被 OCR 吃掉(LUNACY -> UNACY), 所以不能整词匹配, 见 find_lunacy_label。
|
|
2. 读完所有帧再取唯一众数(至少出现两次), 平票返回 None。标签和数字必须来自
|
|
同一帧。OCR 的系统性误读仍可能存在, 前后不同不能直接证明消费。
|
|
"""
|
|
votes = {}
|
|
for i in range(reads):
|
|
its = items()
|
|
lab = find_lunacy_label(its)
|
|
if lab:
|
|
best = None
|
|
for it in its:
|
|
t = it.get('text', '').strip()
|
|
if t.isdigit():
|
|
dy = it.get('y', 0) - lab.get('y', 0)
|
|
dx = abs(it.get('x', 0) - lab.get('x', 0))
|
|
if 0 < dy < 70 and dx < 130:
|
|
best = int(t)
|
|
if best is not None:
|
|
votes[best] = votes.get(best, 0) + 1
|
|
if i < reads - 1:
|
|
time.sleep(pause)
|
|
ranked = sorted(votes, key=votes.get, reverse=True)
|
|
if ranked and votes[ranked[0]] >= 2:
|
|
if len(ranked) == 1 or votes[ranked[0]] > votes[ranked[1]]:
|
|
return ranked[0]
|
|
return None
|
|
|
|
|
|
# 狂气那个数字的 OCR 读法**不稳定**: 同一个真值(6636)实测被读成过
|
|
# 6636 / 9699 / 6388 / 8859 —— 艺术字加抗锯齿, 同一画面连读几次都可能不一样。
|
|
#
|
|
# ⛔ 所以最初那套"前后读数不同 = 真的变了"是错的(2026-10-16 22:03 误报过一次:
|
|
# 前 6636 后 9699, 复读仍是 9699, 于是报了"狂气读数发生变化" —— 但那一轮脚本
|
|
# 只点了模组图标和面板内的 » / 确认, 根本没碰 Use Lunacy 页签, 没有任何消费)。
|
|
#
|
|
# 能站得住的判断只有两种:
|
|
# * 前后读数都落在"已知读法"集合里 -> 可能只是换了个误读法
|
|
# * 变化涉及集合以外的读数 -> 需要人工核查
|
|
# 真正的防线是结构性的(只点 Modules 页签, 且 Use Lunacy 坐标被测试盯着),
|
|
# 这里只是补一层"数字有没有变成陌生值"的旁证。
|
|
LUNACY_KNOWN_READINGS = (6636, 9699, 6388, 8859)
|
|
|
|
|
|
def lunacy_verdict(before, after):
|
|
"""返回 (是否可疑, 说明)。宁可说"不确定", 也不要把误读当消费。"""
|
|
if before is None or after is None:
|
|
return False, '读数不完整(%s -> %s), 本次未做比对' % (before, after)
|
|
if before == after:
|
|
return False, '前后读数一致 %s' % after
|
|
if before in LUNACY_KNOWN_READINGS and after in LUNACY_KNOWN_READINGS:
|
|
return False, ('前后均为已知读法(%s -> %s), 可能为 OCR 抖动, 不单凭此判定消费'
|
|
% (before, after))
|
|
return True, ('读数 %s -> %s, 前后至少一项不在已知读法 %s 里, 需人工核查'
|
|
% (before, after, list(LUNACY_KNOWN_READINGS)))
|
|
|
|
|
|
def read_owned(retries=3, pause=2.0):
|
|
"""从合成面板上读 'Owned NN'(当前模组数量)。读不到返回 None。
|
|
|
|
这个读数是判断"到底换到没有"的依据, 所以第一次没读到要再试几次 ——
|
|
面板刚打开时数字还在刷新, 单次读容易拿到 None。
|
|
"""
|
|
for i in range(retries):
|
|
v = _read_owned_once()
|
|
if v is not None:
|
|
return v
|
|
if i < retries - 1:
|
|
time.sleep(pause)
|
|
return None
|
|
|
|
|
|
def _read_owned_once():
|
|
import re
|
|
its = items()
|
|
for it in its:
|
|
m = re.search(r'Owned\s*(\d+)', it.get('text', ''), re.I)
|
|
if m:
|
|
return int(m.group(1))
|
|
# OCR 有可能会把 'Owned 23' 拆开, 退一步找面板里的裸数字
|
|
for it in its:
|
|
t = it.get('text', '').strip()
|
|
if t.isdigit() and 300 < it.get('y', 0) < 360:
|
|
return int(t)
|
|
return None
|
|
|
|
|
|
ENKEPHALIN_PER_MODULE = 20
|
|
|
|
|
|
def read_enkephalin():
|
|
"""读主界面底栏的体力 'x/126'。读不到返回 None。
|
|
|
|
只认 y>700 的读数 —— 合成面板里也有一个 x/126(那是"合成后"的预览值),
|
|
用高度把它排除掉, 免得把预览当余额。
|
|
"""
|
|
import re
|
|
for it in items():
|
|
t = it.get('text', '').replace(' ', '')
|
|
m = re.search(r'(\d{1,4})/126', t)
|
|
if m and it.get('y', 0) > 700:
|
|
return int(m.group(1))
|
|
return None
|
|
|
|
|
|
# ---------------------------------------------------------------- 游戏进程
|
|
|
|
def game_running():
|
|
out = subprocess.run(['tasklist', '/FI', 'IMAGENAME eq %s.exe' % GAME_PROC],
|
|
capture_output=True, text=True, errors='ignore')
|
|
return GAME_PROC.lower() in (out.stdout or '').lower()
|
|
|
|
|
|
# ---------------------------------------------------------------- 窗口尺寸
|
|
|
|
def _find_hwnd():
|
|
from ctypes import windll
|
|
return windll.user32.FindWindowW(None, 'LimbusCompany')
|
|
|
|
|
|
def _client_size(hwnd):
|
|
from ctypes import windll, wintypes
|
|
r = wintypes.RECT()
|
|
windll.user32.GetClientRect(hwnd, __import__('ctypes').byref(r))
|
|
return r.right - r.left, r.bottom - r.top
|
|
|
|
|
|
def _move_window(hwnd, width, height, cur):
|
|
"""把窗口调到客户区正好 width x height。"""
|
|
from ctypes import windll, wintypes, byref
|
|
wr = wintypes.RECT()
|
|
windll.user32.GetWindowRect(hwnd, byref(wr))
|
|
# 边框/标题栏占掉的差值 = 窗口尺寸 - 客户区尺寸
|
|
frame_w = (wr.right - wr.left) - cur[0]
|
|
frame_h = (wr.bottom - wr.top) - cur[1]
|
|
windll.user32.MoveWindow(hwnd, wr.left, wr.top,
|
|
width + frame_w, height + frame_h, True)
|
|
|
|
|
|
def ensure_window_size(width, height, find=None, client=None, resize=None):
|
|
"""把游戏客户区调成 width x height, 返回调完后的 (w, h)。
|
|
|
|
为什么要管这个: RDP 断线重连会把窗口改小(实测 1600x900 -> 1278x719), 之后
|
|
OCR 质量明显下降 —— 连底栏的 LUNACY 标签都读不出来, 狂气校验直接变成
|
|
"读不到, 跳过"。AALC 自己的 WindowGuard 只在跑任务时才生效, 而这个脚本
|
|
不跑任务, 所以得自己调。
|
|
|
|
find/client/resize 可注入, 便于测试 —— 默认走 ctypes 真实实现。
|
|
"""
|
|
find = find or _find_hwnd
|
|
client = client or _client_size
|
|
resize = resize or _move_window
|
|
hwnd = find()
|
|
if not hwnd:
|
|
return None
|
|
cur = client(hwnd)
|
|
if cur == (width, height):
|
|
return cur # 已经对了就别动它
|
|
resize(hwnd, width, height, cur)
|
|
time.sleep(2)
|
|
after = client(hwnd)
|
|
log('窗口客户区 %sx%s -> %sx%s (目标 %sx%s)' % (cur + after + (width, height)))
|
|
return after
|
|
|
|
|
|
def launch_game(timeout_s=240, tries=3):
|
|
"""启动游戏, 分几次尝试。
|
|
|
|
⛔ 2026-10-17 02:03 实测: 那一轮 exe 起来就退了 —— Steam 的 content_log 里
|
|
02:0x 毫无记录(上一轮 22:03:43 有 "App Running"), 应用事件日志也没有报错,
|
|
游戏进程始终没出现。而 13 分钟后我手动启动, 5 秒就起来了。
|
|
时间线上, 01:49 刚发生过一次会话断开重连, Steam 的 webhelper 直到 02:16 才恢复活动。
|
|
|
|
原来的写法是"点一次火, 干等 240 秒", 碰上一次静默失败就白丢一整轮(这轮体力白攒)。
|
|
改成多次尝试 —— 中间隔一会儿再来一次, 大多数瞬时故障都能靠这个救回来。
|
|
"""
|
|
if game_running():
|
|
log('游戏已在运行')
|
|
return True
|
|
log('Steam 进程数: %d' % len([p for p in _popen_psutil('steam')]))
|
|
each = max(40, timeout_s // max(1, tries))
|
|
for i in range(tries):
|
|
log('启动游戏(第 %d/%d 次, 每次等 %ds): %s' % (i + 1, tries, each, GAME_EXE))
|
|
subprocess.Popen([GAME_EXE], close_fds=True)
|
|
t0 = time.time()
|
|
while time.time() - t0 < each:
|
|
time.sleep(5)
|
|
if game_running():
|
|
log('游戏进程已出现 (%.0fs)' % (time.time() - t0))
|
|
return True
|
|
log(' 这一次没等到游戏进程')
|
|
log('游戏启动超时(试了 %d 次)' % tries)
|
|
return False
|
|
|
|
|
|
def _popen_psutil(name):
|
|
"""按进程名查进程(只用于日志, 失败返回空)。"""
|
|
try:
|
|
out = subprocess.run(['tasklist', '/FI', 'IMAGENAME eq %s.exe' % name],
|
|
capture_output=True, text=True, errors='ignore').stdout
|
|
return [l for l in out.splitlines() if l.lower().startswith(name.lower())]
|
|
except OSError:
|
|
return []
|
|
|
|
|
|
def close_game(graceful_s=20):
|
|
"""关游戏。先好好关, 关不掉再强杀。
|
|
|
|
⛔ 原来是一上来就 taskkill /F。2026-10-17 发现一次可疑的"换到的模块没保留":
|
|
18:10 合成后 31 -> 33
|
|
22:05 合成前 33, 合成后 33 -> 35 (消耗了 40 点体力)
|
|
06:04 合成前 **33** <- 22:05 那两个模块不见了
|
|
原因没查明(也可能是人手动用掉了), 但强制结束本来就有丢未保存状态的风险,
|
|
换成优雅关闭成本很低, 顺手把这条路堵上。
|
|
|
|
步骤: 先只发关闭请求(taskkill 不带 /F), 等它自己退; 超时再强杀。
|
|
"""
|
|
if not game_running():
|
|
log('游戏未在运行')
|
|
return
|
|
subprocess.run(['taskkill', '/IM', '%s.exe' % GAME_PROC],
|
|
capture_output=True, text=True, errors='ignore')
|
|
t0 = time.time()
|
|
while time.time() - t0 < graceful_s:
|
|
time.sleep(2)
|
|
if not game_running():
|
|
log('游戏已正常关闭 (%.0fs)' % (time.time() - t0))
|
|
return
|
|
log(' 优雅关闭没成功, 改用强制结束')
|
|
subprocess.run(['taskkill', '/IM', '%s.exe' % GAME_PROC, '/F'],
|
|
capture_output=True, text=True, errors='ignore')
|
|
time.sleep(3)
|
|
log('游戏已关闭' if not game_running() else '游戏仍在运行(关闭失败)')
|
|
|
|
|
|
def wait_main_menu(timeout_s=300):
|
|
"""等游戏进到主界面。中途用 Enter/点击推进标题、剧情、公告。"""
|
|
t0 = time.time()
|
|
last = ''
|
|
while time.time() - t0 < timeout_s:
|
|
try:
|
|
txt = screen()
|
|
except Exception as e:
|
|
log(' 读取画面失败(%s), 稍后再试' % type(e).__name__)
|
|
time.sleep(8)
|
|
continue
|
|
if on_main_menu(txt):
|
|
log('已进入主界面')
|
|
return True
|
|
if txt != last:
|
|
log(' 等待中: %s' % txt[:90])
|
|
last = txt
|
|
if 'DOWNLOADING' in txt.upper():
|
|
time.sleep(10)
|
|
continue
|
|
# 标题/剧情/公告: 先点一下再按 Enter, 覆盖两种推进方式。
|
|
# ⛔ 位置选屏幕中央而不是下方: 底栏 (800,830) 正好落在 Inventory 按钮里
|
|
# (实测 OCR: Inventory @(759,834) w=91, 跨度 759~850)。上面虽然每轮都先
|
|
# 查过"是不是主界面", 但画面恰在这一瞬切过去的话, 这一下就点在 Inventory
|
|
# 上了 —— 后果不重(只是开个背包), 却会让循环卡在一个预期之外的界面上。
|
|
click(800, 450)
|
|
time.sleep(1.2)
|
|
keypress('enter')
|
|
time.sleep(2.0)
|
|
log('等待主界面超时')
|
|
return False
|
|
|
|
|
|
# ---------------------------------------------------------------- 合成
|
|
|
|
def open_panel(tries=4):
|
|
"""点开合成面板。成功返回 True。
|
|
|
|
点击后要等 UI 真的出来再截图判定 —— 实测立刻截图会拿到点击前的旧帧,
|
|
于是误判成"点了没反应", 白折腾很多轮。
|
|
"""
|
|
for i in range(tries):
|
|
txt = screen()
|
|
if panel_open(txt):
|
|
return True
|
|
log(' 点模组图标 %s (第 %d 次)' % (MODULE_ICON, i + 1))
|
|
click(*MODULE_ICON)
|
|
time.sleep(3.5)
|
|
return panel_open(screen())
|
|
|
|
|
|
# 免费合成页签独有的问句 —— 这句话在别的页签上不会出现
|
|
MODULES_QUESTION = 'assemble Enkephalin Modules'
|
|
|
|
|
|
def on_modules_tab():
|
|
"""确认停在 Modules(免费合成)页签。
|
|
|
|
⛔ 实测坑(2026-10-16 18:03): 原来只看"兑换区显示体力条 x/126", 但 OCR 会把相邻
|
|
几行合并成一个元素(那次 "Enkephalin Module Owned 31" 的框高 38、宽 351, 把下面
|
|
的 x/126 一起吞了), 于是判定失败 —— 整轮拒绝合成, 一个模块没换到。
|
|
|
|
现在认面板自己的问句 "Would you like to assemble Enkephalin Modules?":
|
|
它只在免费页签出现, 而且实测单独成行、不会被合并吃掉。
|
|
体力条那条留着当备用信号(两条任一成立即可)。
|
|
|
|
判不出来时返回 False, 调用方拒绝合成 —— 宁可漏一轮, 也不在不知道哪个页签上点确认。
|
|
"""
|
|
its = items()
|
|
flat = ' '.join(it.get('text', '') for it in its).replace(' ', '')
|
|
if MODULES_QUESTION.replace(' ', '') in flat:
|
|
return True
|
|
for it in its:
|
|
if 470 < it.get('y', 0) < 560 and '/126' in it.get('text', '').replace(' ', ''):
|
|
return True
|
|
return False
|
|
|
|
|
|
def convert_once(tries=2):
|
|
"""打开面板 -> 取最大 -> 合成。返回 (ok, 说明, 合成数量)。
|
|
|
|
为什么默认重试一次: "点了确认但模组没变"有两种完全不同的原因 ——
|
|
1. 游戏限制了本轮/本日能换的数量(正常)
|
|
2. 界面这一次没响应(偶发, 重开面板通常就好了)
|
|
只做一次的话分不清这两者, 而它们该有不同的处置。重试第二次仍然不变,
|
|
就按"换不了"如实报告。
|
|
"""
|
|
last = '未尝试'
|
|
for attempt in range(tries):
|
|
if attempt:
|
|
log(' 第一次没换到, 关掉面板重开再试一次')
|
|
close_panel()
|
|
time.sleep(3)
|
|
ok, info, got = _convert_attempt()
|
|
if ok:
|
|
return ok, info, got
|
|
last = info
|
|
return False, last, 0
|
|
|
|
|
|
def _convert_attempt():
|
|
"""一次合成尝试。返回 (ok, 说明, 合成数量)。"""
|
|
if not open_panel():
|
|
return False, '打不开合成面板', 0
|
|
|
|
# 显式回到 Modules 页签。即使上一轮停在别处, 这一步也把它拨回来。
|
|
click(*TAB_MODULES)
|
|
time.sleep(2.0)
|
|
if not on_modules_tab():
|
|
return False, '确认不在 Modules(免费合成)页签, 为安全起见不合成', 0
|
|
|
|
before = read_owned()
|
|
log(' 合成前模组: %s' % before)
|
|
if before is None:
|
|
# 读不到起点就无从判断有没有换到。这里**不能报成功** —— 那是假装验证过,
|
|
# 和"狂气读不到就静默跳过"是同一类毛病。宁可不合成, 下一轮再来。
|
|
return False, '读不到合成前的模组数, 无法确认结果, 本轮不合成', 0
|
|
|
|
click(*BTN_MAX)
|
|
time.sleep(2.5)
|
|
click(*BTN_CONFIRM)
|
|
|
|
# 面板会自己刷新 Owned。等它变大, 最多等 20 秒。
|
|
t0 = time.time()
|
|
while time.time() - t0 < 20:
|
|
time.sleep(2.5)
|
|
now = read_owned()
|
|
if now is not None and now > before:
|
|
return True, '模组 %d -> %d (+%d)' % (before, now, now - before), now - before
|
|
|
|
after = read_owned()
|
|
if after is None:
|
|
return False, '合成后读不到模组数, 无法确认结果(合成前为 %d)' % before, 0
|
|
if after < before:
|
|
return False, '模组读数下降(%d -> %d), 无法确认合成结果' % (before, after), 0
|
|
if after == before:
|
|
# 走到这里时调用方已经确认体力 >= 20, 所以"体力不足"不是可能的原因,
|
|
# 写进去只会把排查方向带偏。真实原因只有这两种。
|
|
return False, ('点了确认但模组没变(%s): 可能已达兑换上限, 或界面没响应'
|
|
% after), 0
|
|
return True, '模组 %d -> %d (+%d)' % (before, after, after - before), after - before
|
|
|
|
|
|
def close_panel():
|
|
for _ in range(4):
|
|
if not panel_open(screen()):
|
|
return True
|
|
click(*BTN_CANCEL)
|
|
time.sleep(2.0)
|
|
return not panel_open(screen())
|
|
|
|
|
|
# ---------------------------------------------------------------- 主流程
|
|
|
|
def main(argv=None):
|
|
ap = argparse.ArgumentParser(description='启动游戏 -> 体力合成模块 -> 关掉游戏')
|
|
ap.add_argument('--keep-game', action='store_true', help='合成完不关游戏(调试用)')
|
|
ap.add_argument('--start-timeout', type=int, default=300, help='等主界面的秒数')
|
|
ap.add_argument('--report-dir', default=LOG_DIR)
|
|
args = ap.parse_args(argv)
|
|
|
|
t_start = time.time()
|
|
_result.clear()
|
|
_result.update({'started': time.strftime('%Y-%m-%d %H:%M:%S'), 'steps': []})
|
|
|
|
def done(code, why):
|
|
_result['ok'] = code == 0
|
|
_result['result'] = why
|
|
_result['elapsed_s'] = int(time.time() - t_start)
|
|
os.makedirs(args.report_dir, exist_ok=True)
|
|
p = os.path.join(args.report_dir, 'convert_%s.json' % time.strftime('%Y%m%d_%H%M%S'))
|
|
with open(p, 'w', encoding='utf-8') as f:
|
|
json.dump(_result, f, ensure_ascii=False, indent=2)
|
|
log('=== %s (%s), 耗时 %ds ===' % (why, 'OK' if code == 0 else 'FAIL',
|
|
int(time.time() - t_start)))
|
|
return code
|
|
|
|
log('=== 开始: 体力换模块 ===')
|
|
|
|
if not ensure_server():
|
|
return done(1, 'MCP 服务连不上, 也没能拉起来')
|
|
# 断线会让截图全黑, 那之后什么都做不了 —— 先确认桌面在出图再动游戏
|
|
if not ensure_display():
|
|
return done(1, '桌面不在出图(会话被断开), 本轮跳过')
|
|
if not launch_game():
|
|
return done(1, '游戏启动失败')
|
|
if not wait_main_menu(args.start_timeout):
|
|
if not args.keep_game:
|
|
close_game()
|
|
return done(1, '等不到主界面')
|
|
|
|
# 窗口被 RDP 改小过的话先调回去, 否则底栏 OCR 会读不出来
|
|
got_size = ensure_window_size(1600, 900)
|
|
if got_size != (1600, 900):
|
|
log('[warn] 客户区没能调到 1600x900(现为 %s), OCR 可能不稳定' % (got_size,))
|
|
|
|
time.sleep(3)
|
|
# 刚进主界面时底栏还在淡入, 单次读常常是 None(实测 11:01 那次), 那样
|
|
# 合成前后的相对比对就白做了。这里也重试几次。
|
|
lunacy_before = None
|
|
for _ in range(4):
|
|
lunacy_before = read_lunacy()
|
|
if lunacy_before is not None:
|
|
break
|
|
time.sleep(3)
|
|
log('合成前狂气(OCR, 作相对比对用): %s' % lunacy_before)
|
|
# 读到就记进报告 —— 后面可能因为体力不足提前收工, 那时这条读数不该丢。
|
|
_result['lunacy_before'] = lunacy_before
|
|
_result['converted'] = False
|
|
|
|
# 体力读数也要重试。单次读成 None 的话, 下面"体力不足就收工"这层判断会被
|
|
# 整个跳过, 于是明明只是体力不够, 却要去点合成、最后报成 FAIL(退出码 1) ——
|
|
# 给值守留下一条误导性的失败记录。
|
|
enk = None
|
|
for _ in range(4):
|
|
enk = read_enkephalin()
|
|
if enk is not None:
|
|
break
|
|
time.sleep(3)
|
|
log('当前体力: %s/126 (合成 1 个模块需要 %d)' % (enk, ENKEPHALIN_PER_MODULE))
|
|
if enk is None:
|
|
log('[warn] 体力读数没拿到, 这轮按"不确定"处理, 不主动点合成')
|
|
close_panel()
|
|
if not args.keep_game:
|
|
close_game()
|
|
return done(0, '读不到体力读数, 本轮跳过(下一轮再试)')
|
|
if enk < ENKEPHALIN_PER_MODULE:
|
|
# 体力不够换一个模块 —— 这是正常情况(挂机等恢复), 不是失败。
|
|
# 直接收工, 免得每轮都在计划任务里报错。
|
|
close_panel()
|
|
if not args.keep_game:
|
|
close_game()
|
|
return done(0, '体力不足(%s<%d), 本轮无需合成' % (enk, ENKEPHALIN_PER_MODULE))
|
|
|
|
ok, info, got = convert_once()
|
|
_result['steps'].append({'step': '合成', 'ok': ok, 'info': info})
|
|
_result['converted'] = bool(got)
|
|
log('合成: %s (%s)' % ('OK' if ok else 'FAIL', info))
|
|
|
|
time.sleep(2)
|
|
close_panel()
|
|
# 关面板后画面要缓一下才稳定, 立刻读会得到 None(实测), 那样相对比对就白做了
|
|
lunacy_after = None
|
|
for _ in range(4):
|
|
time.sleep(3)
|
|
lunacy_after = read_lunacy()
|
|
if lunacy_after is not None:
|
|
break
|
|
log('合成后狂气(OCR): %s' % lunacy_after)
|
|
|
|
# ⛔ 先记进报告再判 —— 22:03 那次是在判断之后才记, 结果告警分支提前 return,
|
|
# 报告里 lunacy_after 留了个 None, 事后想复核这次读数都无从下手。
|
|
# (和第 10 轮修过的"提前收工导致读数丢失"是同一个毛病, 这次犯在告警分支上。)
|
|
_result['lunacy_before'] = lunacy_before
|
|
_result['lunacy_after'] = lunacy_after
|
|
_result['lunacy_checked'] = (lunacy_before is not None and lunacy_after is not None)
|
|
|
|
# ⛔ 这里原来是"前后读数不同就报违规", 已证明是错的(2026-10-16 22:03 误报):
|
|
# 同一个真值 6636 的 OCR 读法本身就不固定(6636/9699/6388/8859 都出现过),
|
|
# 所以"不同"完全可能只是换了个误读法。判据换成 lunacy_verdict():
|
|
# 只有读到**从没见过的值**才算可疑, 已知读法之间的抖动不算。
|
|
suspicious, why = lunacy_verdict(lunacy_before, lunacy_after)
|
|
if suspicious:
|
|
log(' [warn] %s' % why)
|
|
if not args.keep_game:
|
|
close_game()
|
|
return done(1, '⚠️ %s' % why)
|
|
log('狂气校验: %s' % why)
|
|
if not args.keep_game:
|
|
close_game()
|
|
|
|
if not ok:
|
|
return done(1, '合成未成功: %s' % info)
|
|
if got == 0:
|
|
return done(0, '本轮无需合成(体力不足或已达上限): %s' % info)
|
|
return done(0, '合成完成: %s' % info)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
raise SystemExit(main())
|