Files
lc-mcp/scripts/auto_cycle.py
T
Codex Agent ad7a362f9d 挂机合成模块: 新增 convert_modules.py + 计划任务; 并修掉一个把测试跑崩的用例
用户要求: 这次不打任何关卡, 只挂机等体力恢复、把体力合成成模块, 合成完关掉游戏。

一、新增 scripts/convert_modules.py(启动游戏->合成->关掉)
    单独一个脚本, 不走 AALC 的任务系统 —— AALC 的 make_enkephalin_module 是挂在
    Luxcavation 流程里的(打完一次才顺手换一次), 没有独立入口, 而这次不能打关卡。

    界面流程(1600x900 基准, lc_ui 负责换算):
      主界面点模组图标 -> Charge Enkephalin -> [Modules]/[Use Lunacy]/[Use Boxes]
      -> 停在 Modules(免费) -> » 取最大 -> Confirm -> 20 体力换 1 模块

    三条硬规则:
      1. 绝不点 Use Lunacy 页签。USE_LUNACY_TAB 常量只用于"确认没点到它",
         并写了 AST 检查的测试: 任何 click() 传入该坐标都会让测试失败。
      2. 不打任何关卡, 全程只碰底栏模组图标和合成面板。
      3. 合成前后各读一次狂气做相对比对, 不一致就报错退出。

    实机验证: 模组 23 -> 29(+6)、体力 132 -> 13(6x20)、狂气 6636 未变。

二、修窗口尺寸: RDP 断线重连会把客户区改成 1278x719(实测), 之后 OCR 连底栏
    的 LUNACY 标签都读不出来, 狂气校验直接退化成"读不到, 跳过"。AALC 的
    WindowGuard 只在跑任务时生效, 这个脚本不跑任务, 所以自己做 MoveWindow。

三、新增 scripts/install_convert_task.ps1: 每 4 小时一轮(LcMCPConvertModules)。
    体力每 6 分钟回 1 点、上限 126, 合成 1 个模块要 20 点 -> 4 小时约能换 2 个。
    与 LcMCPDailyCycle 完全分开, 刷取任务保持禁用。

四、修 keep_display.ps1 的一个真 bug:
    (Get-Content $out -Raw) 在文件为空/被当通配时返回数组, 后面的 .Trim() 报
    "does not contain a method named Trim"。看门狗本身照常工作, 但每次都会
    吐一条红字, 掩盖真正的失败。改成先拼接再裁剪。

五、⛔ 修掉一个我自己写坏的测试, 它会让整个测试进程崩掉:
    poll_task 的循环上限是按墙钟判的(time.time()), 而测试里把 sleep 换成空函数
    却没换时钟 —— 于是 timeout_s=3600 真的空转了一小时, 每圈还往 mcp.calls 里
    塞一条, 内存吃爆后进程以 0xC0000005 退出。表现就是"跑测试跑崩了"。
    改成 FakeTime 快进时钟。全套从 156 秒(且崩)降到 14 秒, 246/246 通过。

新增 tests/test_convert_modules.py 13 个用例(屏幕判定/资源读数/狂气众数/禁用坐标)。
其中"禁用坐标"那条也验证过能失败: 故意把 click(*TAB_MODULES) 改成
click(*USE_LUNACY_TAB), 它准确报出违规行号。
2026-10-16 10:30:54 +08:00

380 lines
16 KiB
Python

# -*- coding: utf-8 -*-
"""一轮自动推进: 刷材料 -> (镜牢) -> 升级最弱人格 -> 同步 -> 报告。
用法: python auto_cycle.py [--mirror N] [--target LV] [--retries N] [--report-dir DIR]
退出码: 0 正常完成一轮 / 1 失败
每轮在 report-dir(默认 ~/lc_mcp/cycles)写一份 cycle_<时间>.log 与同名 .json 报告,
计划任务无人值守跑完后据此核对。
设计: 只做"一轮",不做无限循环——由外层(goal 轮次)负责重复与判断,
避免无人监督地长时间空转。每轮输出结构化报告供上层核对。
"""
import argparse
import json
import os
import time
from lc_ui import HERE, PY, click, drag, items, keypress, probe, run
LEVELUP = os.path.join(HERE, 'levelup.py')
# 手动抽卡花掉狂气后, 删掉这个文件重新记基线, 否则每轮都会中止
LUNACY_BASELINE = os.path.expanduser(os.path.join('~', 'lc_mcp', 'lunacy_baseline.txt'))
# 导航
BACK = (85, 75) # 只在 Sinners 内部退层用, 主界面上按它会进剧情
BTN_SINNERS = (1130, 805) # 主界面底部 Sinners
TAB_ALL_IDENTITIES = (1472, 245) # TEAMS 页 -> All Identities
# AALC 任务轮询上限
DAILY_TIMEOUT_S = 45 * 60
# 每局镜牢。10-04 首次 39 分钟、10-13 两局分别 59 与 >70 分钟(19 场战斗仍未结束),
# 所以 70 分钟不够用 —— 实测撞过超时, 强杀后游戏停在副本里, 连升级都进不去。
MIRROR_TIMEOUT_S = 100 * 60
POLL_S = 60
# task_status 连续几次报 stall 就判定卡死并停任务
STALL_POLLS = 2
# 卡死后重跑次数。AALC 任务开头会自己回主界面, 重跑通常就能脱困
STALL_RETRIES = 1
DEFAULT_REPORT_DIR = os.path.expanduser(os.path.join('~', 'lc_mcp', 'cycles'))
_log_file = None
def log(msg):
line = '[%s] %s' % (time.strftime('%H:%M:%S'), msg)
print(line, flush=True)
if _log_file:
with open(_log_file, 'a', encoding='utf-8') as f:
f.write(line + '\n')
def goto_identities():
"""从任意位置尽力走到 罪人 -> Identities 网格。
只点 Sinners 按钮, 绝不点左上返回键——主界面上的返回键会进入剧情(Drive),
实测会掉进过场动画, 需要额外恢复。
"""
for attempt in range(5):
its = items()
txt = ' | '.join(i.get('text', '') for i in its)
if 'IDENTITIES' in txt and 'Facades' in txt:
return True
if 'TEAMS #1' in txt or 'SIN COST' in txt or 'All Idensities' in txt:
click(*TAB_ALL_IDENTITIES)
time.sleep(3)
continue
if 'LUXCAVATION' in txt.upper() or 'MIRROR' in txt.upper():
# 在副本/关卡菜单里, 先回主界面
keypress('esc')
time.sleep(2)
continue
click(*BTN_SINNERS)
time.sleep(3.5)
its = items()
txt = ' | '.join(i.get('text', '') for i in its)
return 'IDENTITIES' in txt and 'Facades' in txt
def on_teams_screen(txt):
"""TEAMS 界面的判定。
实测 OCR 会把 "SIN COST" 输出成 "SINICOST"(无空格), 直接匹配 'SIN COST'
会漏判 —— 于是 ensure_team1() 以为不在 TEAMS 页, 去点 Sinners 按钮空转,
最后报 "未能确认选中 TEAMS #1"。所以先去空格再比。
"""
t = txt.replace(' ', '').upper()
return ('SINCOST' in t or 'SINICOST' in t
or 'ALLIDENTITIES' in t or 'ALLE.G.0' in t or 'ALLE.G.O' in t)
def on_grid(txt):
return 'IDENTITIES' in txt and 'Facades' in txt
def ensure_team1():
"""进 TEAMS 界面, 把预设列表滚到顶并选中 TEAMS #1。
实测坑: 这个账号有 40 个队伍预设, 而 AALC 的选队搜索只朝列表下方扫
(dy 为负), 列表一旦停在底部就永远找不到 TEAMS #1, 日志表现为
"找不到队伍 # 1" 然后整轮空转。所以每轮开跑前先把列表拉回顶部。
"""
for _ in range(5):
its = items()
txt = ' | '.join(i.get('text', '') for i in its)
if on_teams_screen(txt):
break
if on_grid(txt):
click(*BACK) # 网格 -> TEAMS, 仍在 Sinners 内, 安全
time.sleep(3)
continue
click(*BTN_SINNERS)
time.sleep(3.5)
for _ in range(10):
its = items()
cand = [i for i in its
if i.get('text', '').strip().replace(' ', '') in
('TEAMS#1', 'TFAMS#1') and i.get('x', 999) < 320]
if cand:
top = min(cand, key=lambda i: i.get('y', 0))
click(top['x'], top['y'])
time.sleep(2.5)
return True
# 向下拖拽 = 列表内容下移 = 露出更靠前的预设
drag(190, 400, 190, 700)
time.sleep(2)
return False
def clear_blocking_modal():
"""清掉挡在 AALC 前面的模态框, 返回清掉的说明或 None。
2026-10-13 实测: Enkephalin Modules 不足时游戏弹出
"You don't have enough Enkephalin Modules. / Would you like to go assemble some?"
而 AALC 的 Luxcavation 流程不认这个框 —— 它一直在后面点被挡住的 Enter 按钮,
每次都要等满 10 分钟被 no_progress 判据救回来。点 Cancel 拒绝去组装,
AALC 就会自己往下走(该关卡过不去, 它会降级试下一关)。
只在轮询里做这件事, 不碰 AALC 自己的识别; 模态框本来就挡住了一切输入,
点它的 Cancel 不会造成误操作。
"""
its = items()
txt = ' '.join(i.get('text', '') for i in its).replace(' ', '')
if 'enoughEnkephalinModules' not in txt:
return None
for it in its:
if 'cancel' in it.get('text', '').lower():
w = it.get('w') or 0
h = it.get('h') or 0
click(it['x'] + w / 2.0, it['y'] + h / 2.0)
return 'Enkephalin Modules 不足 -> 点 Cancel'
return None
# 同一轮里连着这么多次看到"模组不足", 就不是偶发了, 是资源真的见底
RESOURCE_OUT_LIMIT = 3
def poll_task(task, timeout_s, sleep=time.sleep):
"""轮询到任务结束。返回 (ok, 说明, 是否因卡死被停)。"""
t0 = time.time()
stalled = 0
cleared = 0
while time.time() - t0 < timeout_s:
sleep(POLL_S)
st = probe('task_status', {'lines': 1})
s = st.get('state')
el = int(time.time() - t0)
if s != 'running':
log('%s 结束: state=%s elapsed=%ds exit=%s' % (task, s, el, st.get('exit_code')))
# AALC 单次战斗失败后仍会 exit 0, succeeded 还要看 errors
if st.get('errors'):
return False, '%s: %s' % (s, st['errors'][-1]), False
return s == 'succeeded', 'state=%s elapsed=%ds' % (s, el), False
try:
msg = clear_blocking_modal()
except Exception as e: # 清道夫不该拖垮轮询
msg = None
log(' [warn] 清模态框时出错: %s' % e)
if msg:
cleared += 1
log(' [fix] %s (%d/%d)' % (msg, cleared, RESOURCE_OUT_LIMIT))
if cleared >= RESOURCE_OUT_LIMIT:
# 反复缺模组 = 体力/模组真的见底了。继续点下去只是空转到超时,
# 浪费掉这一轮的时间(实测每次都烧满 10 分钟)。直接收工, 等下一轮。
probe('stop_task')
return False, 'RESOURCE_OUT', False
stalled = stalled + 1 if st.get('stall') else 0
if stalled >= STALL_POLLS:
probe('stop_task')
return False, '卡死(%s), 已停止任务 elapsed=%ds' % (st['stall'], el), True
if el % 600 < POLL_S:
log(' ...%s running %ds' % (task, el))
probe('stop_task')
return False, '超时 %ds' % timeout_s, False
def run_aalc(task, params, timeout_s, retries=STALL_RETRIES, sleep=time.sleep):
"""跑一个 AALC 任务; 卡死时停掉重跑, 最多 retries 次。返回 (ok, 说明)。"""
info = ''
for attempt in range(retries + 1):
if attempt:
log('%s 卡死后重跑 (%d/%d)' % (task, attempt, retries))
sleep(10)
r = probe('run_task', dict(params, task=task))
if not r.get('ok'):
return False, 'run_task 失败: %s' % r.get('error', r)
log('%s 已启动 %s, 开始轮询' % (task, params or ''))
ok, info, stalled = poll_task(task, timeout_s, sleep=sleep)
if ok or not stalled:
return ok, info
return False, info
def report_grid():
out = run([PY, '-X', 'utf8', LEVELUP, 'list'])
return out.strip()
MAIN_MENU_MARKERS = ('SINNERS', 'WINDOW', 'DISPENSE', 'THEATER', 'EXTRACT')
def read_lunacy(reads=5, pause=1.0):
"""读狂气余额。取多次读数的**众数**, 读不到返回 None。
两个实测坑(2026-10-13):
1. OCR 偶尔漏掉 LUNACY 标签, 所以多读几次。
2. **同一个画面上数字本身就会抖**: 放大 6 倍肉眼确认余额是 6388, 而 OCR 在
同一画面连读 5 次得到 6388 四次、8859 一次。8859 被当成基线后, 之后正确
的 6388 反而被判成"已消耗"并中止整轮 —— 一次误读就能造成一次误报。
所以取众数(至少出现 2 次才采信), 而不是"最后读到什么就是什么"。
曾经试过"只在主界面取数", 但那样几乎总是读不到(轮次开始/结束时常停在副本、
网格、结算页), 守卫直接跳过 —— 防线等于没有。众数投票已经能压住误读,
覆盖率更重要。
"""
votes = {}
for attempt in range(reads):
its = items()
lab = None
for it in its:
if 'LUNACY' in it.get('text', '').upper():
lab = it
break
if lab:
best = None
for it in its:
t = it.get('text', '').strip()
if t.isdigit() and len(t) >= 3:
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 votes[best] >= 2:
return best
if attempt < reads - 1:
time.sleep(pause)
return None
def lunacy_guard():
"""狂气只许不降。用户明确要求狂气只能用于抽卡。
返回 (ok, 说明)。首次运行写入基线。
"""
cur = read_lunacy()
if cur is None:
return True, '读不到狂气余额, 跳过校验'
base = None
if os.path.exists(LUNACY_BASELINE):
try:
base = int(open(LUNACY_BASELINE, encoding='utf-8').read().strip())
except ValueError:
base = None
if base is None:
with open(LUNACY_BASELINE, 'w', encoding='utf-8') as f:
f.write(str(cur))
return True, '记录狂气基线 %d' % cur
if cur < base:
return False, '狂气从 %d 降到 %d —— 已消耗, 立即停止' % (base, cur)
if cur > base:
with open(LUNACY_BASELINE, 'w', encoding='utf-8') as f:
f.write(str(cur))
return True, '狂气 %d -> %d (增加, 更新基线)' % (base, cur)
return True, '狂气 %d 未变' % cur
def main(argv=None):
global _log_file
ap = argparse.ArgumentParser(description='一轮: 刷材料 -> 镜牢 -> 升级/同步')
ap.add_argument('--mirror', type=int, default=0, help='本轮镜牢局数, 默认 0')
ap.add_argument('--target', type=int, default=34, help='把队内人格升到的等级')
ap.add_argument('--retries', type=int, default=STALL_RETRIES, help='AALC 卡死后重跑次数')
ap.add_argument('--report-dir', default=DEFAULT_REPORT_DIR)
args = ap.parse_args(argv)
os.makedirs(args.report_dir, exist_ok=True)
base = os.path.join(args.report_dir, 'cycle_' + time.strftime('%Y%m%d_%H%M%S'))
_log_file = base + '.log'
t_start = time.time()
steps = []
def step(name, ok, info):
steps.append({'step': name, 'ok': ok, 'info': info, 'at': time.strftime('%H:%M:%S')})
log('%s: %s (%s)' % (name, 'OK' if ok else 'FAIL', info))
return ok
def finish(code, why):
log('=== %s, 耗时 %ds ===' % (why, int(time.time() - t_start)))
report = {'ok': code == 0, 'result': why, 'started': time.strftime(
'%Y-%m-%d %H:%M:%S', time.localtime(t_start)), 'elapsed_s': int(time.time() - t_start),
'args': vars(args), 'steps': steps, 'log': _log_file}
with open(base + '.json', 'w', encoding='utf-8') as f:
json.dump(report, f, ensure_ascii=False, indent=2)
return code
log('=== 一轮开始 ===')
if not step('狂气校验', *lunacy_guard()):
return finish(1, '中止: 狂气被消耗, 按用户要求不得使用')
# 先把预设列表拉回顶部并选中 TEAMS #1——AALC 只朝列表下方找, 停在底部会找不到
if not ensure_team1():
log('[warn] 未能确认选中 TEAMS #1, 继续尝试')
ok, info = run_aalc('daily', {}, DAILY_TIMEOUT_S, args.retries)
if info == 'RESOURCE_OUT':
# 体力/模组见底, Luxcavation 打不了。这不是故障, 是资源周期 —— 体力和燃料
# 都会自然恢复, 下一轮(计划任务 2.5 小时后再来)通常就能继续。空转没有意义。
step('刷材料', False, '体力/模组不足, 本轮跳过')
log('[warn] 体力或模组见底, 本轮不再刷材料; 等自然恢复后下一轮继续')
return finish(0, '一轮结束(资源不足, 跳过刷取)')
if not step('刷材料', ok, info):
return finish(1, '本轮失败: 刷材料未成功')
if args.mirror > 0:
# 镜牢掉落自我碎片, 同步到 IV 阶要用
ok, info = run_aalc('mirror', {'count': args.mirror},
MIRROR_TIMEOUT_S * args.mirror, args.retries)
if not step('镜牢 x%d' % args.mirror, ok, info):
log('[warn] 镜牢未完成, 继续升级')
# AALC 任务结束后在主界面, 这里才是能读到 LUNACY 的时机
time.sleep(8)
if not step('狂气校验(刷后)', *lunacy_guard()):
return finish(1, '中止: 狂气被消耗, 按用户要求不得使用')
if not goto_identities():
# 镜牢超时被强杀时游戏还停在副本里, 这时进不去网格是正常的, 不是缺陷。
# 刷取本身已经发生, 不该因为附加的升级环节把整轮判死 —— 下一轮 AALC
# 的 back_init_menu 会自行把游戏带回主界面。
step('进入 Identities 网格', False, '找不到网格(可能仍停在镜牢内), 跳过升级')
log('[warn] 进不去网格, 跳过升级; 下一轮的 AALC 会自行回到主界面')
return finish(0, '一轮结束(跳过升级)')
log('升级前:\n' + report_grid())
log('对队内低于 Lv.%d 的人格升级 + 同步' % args.target)
# 用 progress 而非 weakest: 网格 OCR 会把 LV14 读成 Lv.1,
# progress 会逐个打开详情页以真实等级判断目标。
out = run([PY, '-X', 'utf8', LEVELUP, 'progress', str(args.target), '--uptie'])
lines = out.strip().splitlines()
for line in lines:
log(' ' + line)
step('升级/同步', not any('FAIL' in l for l in lines),
'; '.join(l.strip() for l in lines if '升级:' in l or '同步:' in l) or '无需升级')
time.sleep(5)
if not goto_identities():
# 同上: 升级结果已经拿到, 回不到网格只影响下一轮的起点
step('回到网格', False, '升级后无法回到网格, 不影响本轮产出')
log('[warn] 升级后回不到网格')
else:
log('升级后:\n' + report_grid())
return finish(0, '一轮结束')
if __name__ == '__main__':
raise SystemExit(main())