fix: continue hidden sweep battles safely in Web 2.0.12

This commit is contained in:
AttilaNet
2026-11-14 12:41:11 +08:00
parent 7ca2ee13e3
commit 69b59e18dd
21 changed files with 1691 additions and 102 deletions
+7
View File
@@ -59,6 +59,13 @@ jobs:
PY
- name: Install Web runtime and test dependencies
run: python -m pip install -r ranch_web/requirements-test.txt
- name: Offline sweep hidden handoff, battles, and engine regression
timeout-minutes: 3
run: |
python -B -m unittest \
ranch_assistant.tests.test_sweep_hidden_handoff \
ranch_assistant.tests.test_sweep_hidden_battles \
ranch_assistant.tests.test_sweep_hidden_engine -v
- name: Offline primary cultivation and resource admission regression
run: |
python -B -m unittest \
+1 -1
View File
@@ -1,6 +1,6 @@
FROM python:3.12-slim-bookworm
ARG WEB_VERSION=2.0.11
ARG WEB_VERSION=2.0.12
ARG VCS_REF=unknown
LABEL org.opencontainers.image.source="https://github.com/attilanet/myrzx_bot" \
org.opencontainers.image.title="myrzx_bot Web" \
+9 -5
View File
@@ -1,11 +1,11 @@
# 牧羊人之心Bot
Web **2.0.11**,源码发布入口为 `main`;原生 PySide6 桌面正式版本保留 **1.2.0**(`v1.2.0`)。两者的适配资料基线均为《牧羊人之心》Android **1.9.68**。
Web **2.0.12**,源码发布入口为 `main`;原生 PySide6 桌面正式版本保留 **1.2.0**(`v1.2.0`)。两者的适配资料基线均为《牧羊人之心》Android **1.9.68**。
支持多账号独立运行、牧场培养、每日事务、主线与委托推进、近似战斗模拟、探险、扫荡及本地掉落分析,能力与验证限制见下文。
## 运行指引
### Web 2.0.11(源码发布入口 main)
### Web 2.0.12(源码发布入口 main)
Windows 使用 Python 3.12+,在项目根目录执行:
@@ -19,9 +19,13 @@ py -3 -m venv .venv-web
Web 无需 Node/npm 或 PySide6,数据独立保存在 `local_state/ranch_web`。Linux Python 启动、离线演示与环境配置见 [Web 运行说明](ranch_web/README.md);单服务 Docker、`/data` 持久化、子路径反代与宿主机受控更新见 [Web 部署说明](deploy/web/README.md)。
**2.0.11** 修复 Linux 战斗子进程输入传输、中断恢复、停止检查及导航能力误报。升级后,符合证据的旧委托备料战斗可按原客户端协议记录失败并退出一次;完整战果可续交尚未发送的结果,未知已发送写请求不重放。来源策略关闭时明确等待启用,保留用户运行意愿,不自动开启策略。
**2.0.12** 修复自动扫荡触发隐藏关卡后的战斗接续。完整入场响应与原始队伍快照等原始输入均已保存且可验证时,新记录或可恢复旧记录才自动续打:按 `stageEvent.hideStageId` 构建隐藏关卡难度1的战斗,结束扫荡并自动战斗,无需手动确认,不再次请求入场;战后结算使用隐藏关卡 ID。旧记录即使能从 trace 找回隐藏 ID,缺少原始队伍也保留中文待核对状态,不用当前属性替代原始属性,不发送游戏写请求。
本版后端、模型与更新器共 **550 项唯一测试:548 通过、2 项 Windows 预期跳过**;另有 **14 项全新浏览器测试全部通过**。正式镜像与稳定 Release 就绪后,由用户通过“帮助 → 检查版本更新…”在线升级,详情见 [本版发布说明](analysis/RELEASE_2_0_11.md)。
现场旧 pending 仅保留 `0211 / 3`、提示与 `sampleId`,原始响应已被日志轮转覆盖,无法还原隐藏关卡 ID。仅对符合精确四字段 legacy 形态、严格确认已入场且未结算的这类旧阶段,本版保留证据,在本地归档为未完成并放弃,不提交胜利或失败、不重发入场,让后续策略继续;这不表示当前生产战斗已经打通。
本版共 **491 项唯一仓库测试:489 通过、2 项 Windows 预期跳过,0 失败 / 错误**;历史测试不计入本版。正式镜像与稳定 Release 就绪后,由用户通过“帮助 → 检查版本更新…”在线升级,详情见 [本版发布说明](analysis/RELEASE_2_0_12.md)。
沿用 2.0.11 的 Linux 战斗输入传输与按证据恢复修复。手动停止继续阻止提交,来源策略关闭时等待启用,未知已发送写请求不重放,见 [2.0.11 发布说明](analysis/RELEASE_2_0_11.md)。
沿用 2.0.9 的快速数值模型、伤害配置、委托备料与潜能误报修复;模型按双方属性、血量、伤害、时间及关卡目标估算胜负,逐帧实现仅供研发。2.0.9 的配置预检与历史验证见 [历史发布说明](analysis/RELEASE_2_0_9.md)。
@@ -44,7 +48,7 @@ Web 无需 Node/npm 或 PySide6,数据独立保存在 `local_state/ranch_web`
| 组件与版本 | 《牧羊人之心》Android 基线 | 入口与状态 |
| --- | --- | --- |
| Web 2.0.11 | 1.9.68 | 源码发布入口 `main`,`Start_Ranch_Web.cmd` / `sh start-web.sh` |
| Web 2.0.12 | 1.9.68 | 源码发布入口 `main`,`Start_Ranch_Web.cmd` / `sh start-web.sh` |
| 桌面 1.2.0(`v1.2.0`) | 1.9.68 | 当前桌面版本;`Start_Ranch_Helper.cmd` / `python -m ranch_assistant` |
| 桌面 1.1.1(`v1.1.1`) | 1.9.68 | 历史正式版本,1.1 系列修复与界面更新 |
| 桌面 1.1.0(`v1.1.0`) | 1.9.68 | 历史已发布版本 |
+36
View File
@@ -0,0 +1,36 @@
# Web 2.0.12 发布说明
Web **2.0.12** 基于 **2.0.11**;游戏资料 **1.9.68**,桌面正式版 **1.2.0**。
## 本版范围
- **隐藏关卡自动接续**:自动扫荡遇到隐藏事件,且完整入场响应与原始队伍快照等原始输入均已保存、可验证时,沿用原客户端流程关闭扫荡,直接用 `stageEvent.hideStageId` 构建隐藏关卡难度1(`stageLevel='1'`)的战斗。无需手动确认,不再发送第二次 `stageStart`。
- **使用真实隐藏关卡结算**:后续 `battleEnd` / `recordBattleResult` 使用隐藏关卡 ID;普通关卡 ID、原扫荡等级及 `sampleId` 不作为隐藏关卡 ID 的替代值。
- **完整入场与原始输入可验证才续打**:新记录或可恢复旧记录只有在完整入场响应、原始队伍快照等原始战斗输入均可验证时,才按保存证据继续战斗。用户停止、来源策略授权和未知已发送请求的核对约束继续生效。
- **缺原始队伍时保留待核对**:旧记录即使能从 trace 找回隐藏 ID,缺少原始队伍快照也不能拿当前属性当原始属性重新计算;保留具体中文待核对原因,不发送游戏写请求。仅有隐藏 ID 不构成自动续打依据。
- **缺失隐藏 ID 的精确旧记录本地归档**:仅对符合精确四字段 legacy 形态、已确认入场且未结算的隐藏阶段,保留原始证据,本地归档为未完成并放弃,让后续策略继续;不提交虚构胜利或失败,不重发入场。
- **中文战斗记录**:隐藏战斗显示“隐藏关卡战斗”,本地归档或取消显示“未完成,已放弃”或“未完成,已取消”;具体原因继续保留在原有详情中。
## 历史现场限制
本次现场旧 pending 只有普通关卡 `0211`、难度 `3`、隐藏提示与 `sampleId`。包含真实隐藏关卡 ID 的原始响应已被 **8 MB × 2** 的日志轮转覆盖,现有证据无法还原 `stageEvent.hideStageId`。
该旧记录只能按上述严格条件本地归档,无法据此恢复或证明服务端当前战斗已完成。**本版未在生产打通当前这场战斗**;归档不等于游戏服务端已结算或退出。新记录或可恢复旧记录只有完整入场响应、原始队伍快照等原始输入均可验证时,才具备自动续打依据;仅找回隐藏 ID 的旧记录仍保留待核对。
## 验证
本版共 **491 项唯一仓库测试:489 通过、2 项 Windows 预期跳过,0 失败 / 错误**,按实际测试 ID 去重,覆盖50项隐藏关卡专项及74项受影响引擎回归。各阶段复验不重复相加,2.0.11 及更早版本的历史测试结果不计入本版。
另有 **2 项 Web 离线探针通过**,验证隐藏入场恢复、启停、账号隔离与禁止重复请求,单独统计,不计入上述491项仓库测试。
静态离线模型另以现有两支队伍分别组合 `hd01`–`hd08`,共16种代表性配置,均在模型支持范围内;32次重复运行结果可复现。其中13种配置得到模型胜利、3种得到模型失败,单次离线模型计算约0.4–14毫秒。此项仅代表静态配置,现场实际隐藏 ID 仍未知,不代表真实通关,不计入 unittest 测试总数。
本轮验证仅使用离线 fake / 临时目录,不实际调用游戏 API,不部署生产,不修改真实用户策略或生产 journal。
CI 保留通过 `ranch_web/requirements-test.txt` 安装 HTTPX 测试依赖的修复;生产镜像继续只安装运行依赖。镜像工作流在安装测试依赖后,独立执行隐藏关卡 handoff、battles、engine 三个专用回归模块。
## 发布与升级
正式镜像及非草稿、非预发布的稳定 Release 核验就绪后,由用户在“帮助 → 检查版本更新…”发起在线升级,见 [部署说明](../deploy/web/README.md)。
随版提供与源码一致的 `updater.pyz` 及 ASCII、LF 结尾的 `SHA256SUMS`,下载后核对校验值再使用。v2.0.11 Release、资产、refs 与 Git bundle 已独立备份并校验。
+2 -2
View File
@@ -1,11 +1,11 @@
name: ranch-web
services:
web:
image: ${RANCH_WEB_IMAGE:-ghcr.io/attilanet/myrzx_bot-web:v2.0.11}
image: ${RANCH_WEB_IMAGE:-ghcr.io/attilanet/myrzx_bot-web:v2.0.12}
build:
context: .
args:
WEB_VERSION: ${RANCH_WEB_BUILD_VERSION:-2.0.11}
WEB_VERSION: ${RANCH_WEB_BUILD_VERSION:-2.0.12}
user: "10001:10001"
init: true
restart: unless-stopped
+9 -9
View File
@@ -1,8 +1,8 @@
# Web 2 Linux Docker 部署与更新
当前应用及更新示例为 `v2.0.11`。下文首次初始化章节保留 2.0.1 流程及历史版本示例。游戏资料基线为 `1.9.68`,桌面版保留 `1.2.0`。镜像流水线成功、Git tag 与 GitHub Release 是不同的发布步骤:在线更新必须等对应镜像及非草稿、非预发布的 Release 均发布后才能使用。私有仓库未获授权返回 404 属于访问失败,不代表没有版本;只有成功读取列表且没有稳定 2.x 时才显示“暂无正式版”。
当前应用及更新示例为 `v2.0.12`。下文首次初始化章节保留 2.0.1 流程及历史版本示例。游戏资料基线为 `1.9.68`,桌面版保留 `1.2.0`。镜像流水线成功、Git tag 与 GitHub Release 是不同的发布步骤:在线更新必须等对应镜像及非草稿、非预发布的 Release 均发布后才能使用。私有仓库未获授权返回 404 属于访问失败,不代表没有版本;只有成功读取列表且没有稳定 2.x 时才显示“暂无正式版”。
2.0.11 修复 Linux 战斗输入传输、中断恢复、停止检查及能力状态误报。升级后按持久化证据恢复:符合条件的旧委托备料技术失败记录退出一次;来源策略关闭时明确等待启用,保留运行意愿,不自动开启策略;未知已发送写请求不重放。已有宿主机由用户在 Web 内发起在线更新,见 [本版发布说明](../../analysis/RELEASE_2_0_11.md)。
2.0.12 修复扫荡隐藏事件的自动战斗接续:完整入场响应与原始队伍快照等原始输入均已保存且可验证时,才按 `stageEvent.hideStageId` 直接构建隐藏关卡难度1的战斗,不再请求入场,战后使用隐藏 ID 结算。旧记录即使能从 trace 找回隐藏 ID,缺少原始队伍也保留中文待核对状态,不以当前属性重算,不发送游戏写请求。现场旧 `0211 / 3` 记录的原始响应已被日志轮转覆盖,无法还原隐藏 ID;仅对符合精确四字段 legacy 形态、严格确认已入场且未结算的这类旧阶段,保留证据并在本地归档为未完成、放弃,不提交胜负或重发入场。归档不等于服务端已结算,也不表示当前生产战斗已打通,见 [本版发布说明](../../analysis/RELEASE_2_0_12.md)。
已在 2.0.1 完成私有仓库和 GHCR 认证的部署,稳定 Release 与正式镜像发布后,可直接通过“帮助 → 检查版本更新…”升级,无需先安装 2.0.2、重复初始化或替换宿主机更新器。尚未接入私有在线更新的宿主机才需参考下文“已有宿主机首次初始化”。
@@ -23,7 +23,7 @@ sudo install -m 0600 -o root -g root deploy/web/image.env.example .image.env
sudoedit .env .image.env
```
在 `.env` 填入独立的 `RANCH_WEB_PASSWORD`,这是 Web 管理密码,不是游戏密码;`.image.env` 的目标示例为 `RANCH_WEB_IMAGE=ghcr.io/attilanet/myrzx_bot-web:v2.0.11`,需确认对应镜像已发布后再 pull。Compose 默认只发布到宿主机 `127.0.0.1:8765`,容器内监听 `0.0.0.0:8765` 并强制管理密码。使用域名反代时,同时配置 `RANCH_WEB_ALLOWED_HOSTS` 与 `RANCH_WEB_ALLOWED_ORIGINS`;TLS 入口设置 `RANCH_WEB_SECURE_COOKIE=true`。代理保留正确的 Host,写请求依赖来源校验。
在 `.env` 填入独立的 `RANCH_WEB_PASSWORD`,这是 Web 管理密码,不是游戏密码;`.image.env` 的目标示例为 `RANCH_WEB_IMAGE=ghcr.io/attilanet/myrzx_bot-web:v2.0.12`,需确认对应镜像已发布后再 pull。Compose 默认只发布到宿主机 `127.0.0.1:8765`,容器内监听 `0.0.0.0:8765` 并强制管理密码。使用域名反代时,同时配置 `RANCH_WEB_ALLOWED_HOSTS` 与 `RANCH_WEB_ALLOWED_ORIGINS`;TLS 入口设置 `RANCH_WEB_SECURE_COOKIE=true`。代理保留正确的 Host,写请求依赖来源校验。
`/opt/ranch-web/data` 挂到容器 `/data`,包括账号、加密会话与密钥、配置、委托历史、SQLite 统计和更新请求;独立于桌面数据。心跳控制目录独立只读挂到 `/run/ranch-updater`。使用 bind mount 的目录必须预先创建,Compose 不会悄悄创建 root 所有、容器无法写入的目录。默认容器用户 `10001:10001`,根文件系统只读,临时文件写到 `/tmp`。不要对现有账号目录重新初始化密钥。
@@ -55,7 +55,7 @@ Web 只读检查官方 GitHub Releases;默认只接受 `v2.MINOR.PATCH`,跳
### 已完成 2.0.1 初始化的宿主机
稳定 Release 与正式镜像发布后,用户打开“帮助 → 检查版本更新…”,检查到 2.0.11 后手动提交更新请求,可从 2.0.1 直接安装。现有私有仓库认证、GHCR 登录与宿主机更新器继续使用;Web 按钮仍要求有效心跳及 `accept_web_requests=true`。请求显示 `pending` 只表示已提交,宿主机完成备份、安装及健康检查后才确认成功;升级完成后刷新网页以加载新版界面,底部日志默认收起。Windows 或未启用执行器时仍仅可检查版本。自动安装默认关闭。
稳定 Release 与正式镜像发布后,用户打开“帮助 → 检查版本更新…”,检查到 2.0.12 后手动提交更新请求,可从 2.0.1 直接安装。现有私有仓库认证、GHCR 登录与宿主机更新器继续使用;Web 按钮仍要求有效心跳及 `accept_web_requests=true`。请求显示 `pending` 只表示已提交,宿主机完成备份、安装及健康检查后才确认成功;升级完成后刷新网页以加载新版界面,底部日志默认收起。Windows 或未启用执行器时仍仅可检查版本。自动安装默认关闭。
### 全新宿主机安装
@@ -110,7 +110,7 @@ python3 -B /opt/ranch-web/updater.pyz --version
Docker 保存的宿主机登录配置供更新器拉镜像使用;不要复制开发机的 Git/registry 凭据,也不要把 Docker 凭据放进 GitHub Token 文件或 Web 容器。[GHCR 官方认证说明](https://docs.github.com/en/packages/working-with-a-github-packages-registry/working-with-the-container-registry)
4. 使用新包先检查再由用户明确发起在线更新。以下 `--apply v2.0.1` 仅保留首次初始化的历史示例,不是本轮 2.0.11 升级命令:
4. 使用新包先检查再由用户明确发起在线更新。以下 `--apply v2.0.1` 仅保留首次初始化的历史示例,不是本轮 2.0.12 升级命令:
```sh
sudo python3 -B /opt/ranch-web/updater.pyz --config /etc/ranch-web-updater.toml --check
@@ -165,14 +165,14 @@ Windows 或未安装执行器的 Docker 部署仍能检查版本,但按钮会
[web-image.yml](../../.github/workflows/web-image.yml) 仅对官方仓库的严格稳定 `v2.x.y` tag 推送 `ghcr.io/attilanet/myrzx_bot-web:v2.x.y`;校验 `ranch_web.__version__` 必须与 tag 一致,不能只改变镜像 label。PR 与手动运行只测试、构建,不推送。开发分支 push 不触发正式镜像发布,也没有 `latest` 滚动升级通道。CI 执行更新器、私有凭据和独立包回归,并在无外网容器中检查 healthcheck、非 root 数据写权限、无 Qt 和正常停止;镜像发布状态以对应 tag 的工作流结果为准。
2.0.11 后端、模型与更新器共 **550 项唯一测试:548 通过、2 项 Windows 预期跳过**;另有 **14 项全新浏览器测试全部通过**,8组独立探针复核通过。本轮验证未写入真实游戏 API、未手动部署、未修改生产 journal;升级后的恢复以保存证据与策略授权为准。
本版共 **491 项唯一仓库测试:489 通过、2 项 Windows 预期跳过,0 失败 / 错误**,见 [2.0.12 发布说明](../../analysis/RELEASE_2_0_12.md#验证)。本轮不实际调用游戏 API、不部署生产、不修改真实用户策略或生产 journal。2.0.11 的测试结果见 [历史发布说明](../../analysis/RELEASE_2_0_11.md#验证),不计入本版。CI 保留通过 `ranch_web/requirements-test.txt` 安装 HTTPX 的修复。
2.0.8 共验证739项独立测试:736通过、3项 Windows 跳过;其中非浏览器662项(659通过、3跳过),浏览器77项全部验证通过,详见 [发布说明](../../analysis/RELEASE_2_0_8.md#验证)。2.0.7 结果保留在 [历史发布说明](../../analysis/RELEASE_2_0_7.md#验证)。以下命令可复现本地更新器构建与离线检查;历史 Windows 离线验证与 Linux 部署烟测见 [Web 运行说明](../../ranch_web/README.md#离线验证),不计入本版验收。可在无 Docker 的机器上构建临时更新器资产并打印计划;`--dry-run` 不联网、不读取凭据、不调用 Docker,也不写文件:
```sh
python -B tools/build_web_updater.py --output test-artifacts/releases/v2.0.11/updater.pyz
python -B test-artifacts/releases/v2.0.11/updater.pyz --version
python -B test-artifacts/releases/v2.0.11/updater.pyz --config deploy/web/updater.example.toml --apply v2.0.11 --dry-run
python -B tools/build_web_updater.py --output test-artifacts/releases/v2.0.12/updater.pyz
python -B test-artifacts/releases/v2.0.12/updater.pyz --version
python -B test-artifacts/releases/v2.0.12/updater.pyz --config deploy/web/updater.example.toml --apply v2.0.12 --dry-run
python -B -m unittest ranch_web.tests.test_updates ranch_web.tests.test_web_updater ranch_web.tests.test_private_updates ranch_web.tests.test_web_updater_package -v
```
+2 -2
View File
@@ -1,2 +1,2 @@
# Pull only after the v2.0.11 image publishing workflow succeeds and the image is available.
RANCH_WEB_IMAGE=ghcr.io/attilanet/myrzx_bot-web:v2.0.11
# Pull only after the v2.0.12 image publishing workflow succeeds and the image is available.
RANCH_WEB_IMAGE=ghcr.io/attilanet/myrzx_bot-web:v2.0.12
+275 -57
View File
@@ -30,7 +30,7 @@ from .drop_statistics import event_reward
from .maps import stages
from .resource_stages import resource_entry_reason, item_requirements, available_item_count
from .quests import indexed, stage_has_level
from .sweeping import SweepPolicy
from .sweeping import SweepPolicy, hidden_stage_id
from .team_availability import team_availability_reason
@@ -87,6 +87,8 @@ def gameplay_response(response):
_locks_guard = threading.Lock()
_locks = {}
SWEEP_KINDS = ("map_sweep", "sweep", "progression_sweep", "progression_farm_sweep", "progression_map_sweep")
COMBAT_KINDS = ("progression_battle", "map_battle", "stage_battle", "battle", "task_battle") + SWEEP_KINDS
def account_lock(path):
@@ -155,7 +157,7 @@ class BattleJournal:
self.reload()
return deepcopy(list(reversed(self.role(snapshot)["records"])))
def begin(self, snapshot, intent, *, kind=None):
def begin(self, snapshot, intent, *, kind=None, sweep_entry=None, sweep_phase=None):
if self.pending(snapshot):
raise ValueError("有待核对的任务 / 战斗,禁止重复开始")
record = {name: public_data(value(intent, name)) for name in (
@@ -170,6 +172,12 @@ class BattleJournal:
"loop_time": snapshot.raw.get("history", {}).get("loopTaskTime"),
"passed": stage_has_level(snapshot.raw.get("history", {}), "passStage",
value(intent, "stage_id", ""), value(intent, "difficulty", "1"))})
if sweep_entry is not None:
legacy_archive = sweep_phase == "legacy_hidden_archived" and sweep_entry.get("role_id") is None
if (not legacy_archive and str(sweep_entry.get("role_id")) != role_id(snapshot)) or not sweep_entry.get("sampleId"):
raise ValueError("扫荡交接角色或原始编号缺失")
record.update(sweep_sample_id=sweep_entry["sampleId"], sweep_entry=public_data(sweep_entry),
sweep_entry_digest=digest(public_data(sweep_entry)), phase=sweep_phase or record["phase"])
if value(intent, "token") and value(intent, "account_key"):
record.update(intent_id=value(intent, "token"), account_key=value(intent, "account_key"))
if record.get("source_task_type_id") and not record.get("source_task_id"):
@@ -190,9 +198,10 @@ class BattleJournal:
record.update(phase="done", outcome=outcome, message=message, finished_at=time.time())
if state["pending"] == record["attempt_id"]:
state["pending"] = None
if outcome == "loss" and record.get("kind") != "map_battle":
shared_loss_budget = record.get("kind") != "map_battle" and not record.get("sweep_sample_id")
if outcome == "loss" and shared_loss_budget:
state["losses"] += 1
elif outcome == "win" and record.get("kind") != "map_battle":
elif outcome == "win" and shared_loss_budget:
state["losses"] = 0
self.save()
@@ -455,7 +464,11 @@ class BattleOrchestrator:
def save_combat_request(self, record, request):
if request.get("battle_mode") != "experimental":
return {}
if request.get("battle_kind") != "hidden":
return {}
combat = public_data(request)
return {"combat_request": combat, "combat_request_digest": digest(combat),
"combat_resource_digest": self.combat_resource_digest()}
from .battle_simulator import _transport_request
combat = public_data(_transport_request(request))
raw = combat.get("roster")
@@ -560,9 +573,12 @@ class BattleOrchestrator:
response = record.get("start_response")
task = bool(record.get("task_id"))
path = "battleService/battleStart" if task else "stageService/stageStart"
hidden = hidden_stage_id(response)
confirmed_hidden = (not task and hidden is not None and record.get("battle_kind") == "hidden"
and hidden == str(record.get("stage_id")) and str(record.get("difficulty")) == "1")
return (record.get("start_path") == path and isinstance(response, dict)
and response.get("resCode", 0) in (0, "0") and (task or response.get("triggerEvent") is False
or type(response.get("triggerEvent")) is int and response["triggerEvent"] == 0))
or type(response.get("triggerEvent")) is int and response["triggerEvent"] == 0 or confirmed_hidden))
@staticmethod
def source_matches(record, snapshot):
@@ -595,7 +611,7 @@ class BattleOrchestrator:
@staticmethod
def resumable_task_clock(record):
common = bool(record and record.get("kind") in ("progression_battle", "map_battle", "stage_battle", "battle", "task_battle")
common = bool(record and record.get("kind") in COMBAT_KINDS
and ((record.get("execution_mode") == "experimental" and record.get("execution_status") == "completed"
and record.get("experimental_settlement_eligible") is True and record.get("terminal") is True
and record.get("approximate") is True and record.get("faithful") is False)
@@ -628,7 +644,7 @@ class BattleOrchestrator:
return status("none")
if isinstance(snapshot, dict):
snapshot = SimpleNamespace(raw=snapshot, now=time.time())
if record.get("kind") not in ("progression_battle", "map_battle", "stage_battle", "battle", "task_battle"):
if record.get("kind") not in COMBAT_KINDS:
return status("blocked", record.get("message") or "任务请求待核对,不能按战斗恢复")
if snapshot and str(record.get("role_id")) != role_id(snapshot):
return status("blocked", "角色与原入场记录不匹配,保留待核对记录")
@@ -650,6 +666,9 @@ class BattleOrchestrator:
return status("unsent", "开战请求尚未发送,可取消本地准备记录")
if not self.confirmed_start(record):
return status("blocked", "开战请求结果未确认,禁止重新入场或自动退出")
if (record.get("sweep_sample_id") and record.get("runtime_not_started") is True
and not record.get("combat_request") and self.hidden_sweep_inputs(record)):
return status("prepare_hidden_sweep", "隐藏入场及原始队伍已保存,可继续本次战斗")
interrupted = (record.get("runtime_not_started") is True or record.get("phase") in ("started", "running", "hidden_started") or
record.get("execution_status") in ("cancelled", "timed_out", "error"))
if not interrupted or record.get("battle_data"):
@@ -665,7 +684,8 @@ class BattleOrchestrator:
return status("abandon_stage", "本地战斗未完成且来源委托已变化或恢复已用尽;开启后按原客户端退出协议记录失败")
if record.get("runtime_recovery_attempts", 0) >= 1:
return status("blocked", "本地战斗恢复已尝试一次仍未完成,保留入场记录等待核对")
if (record.get("battle_mode") != "experimental" or digest(combat) != record.get("combat_request_digest")
if (record.get("battle_mode") != "experimental" and record.get("battle_kind") != "hidden"
or digest(combat) != record.get("combat_request_digest")
or self.combat_resource_digest() != record.get("combat_resource_digest")):
return status("blocked", "保存的原始战斗输入或资源校验不匹配,禁止改用当前属性重算")
return status("retry_local_runtime", "入场已确认且结算未发送,可用保存的原始输入恢复一次本地战斗")
@@ -728,7 +748,7 @@ class BattleOrchestrator:
self.journal.update(record, "running", runtime_recovery_attempts=1, runtime_not_started=False)
try:
started = self.clock()
result = self.runtime.run(request, cancel_event=cancel)
result = self.runtime.run(request.get("runtime_request", request), cancel_event=cancel)
if not self.accept_runtime_result(record, request, result, started, cancel):
return record["message"]
except Exception as error:
@@ -763,6 +783,7 @@ class BattleOrchestrator:
if self.observer:
self.observer("loss", intent, None)
self.journal.finish(snapshot, record, "loss", "打不过(保存的模拟结果);未提交胜利结算")
self._finish_hidden_sweep(snapshot, record)
return record["message"]
response = record.get("response") if record.get("settlement_confirmed") else None
if response is None:
@@ -771,9 +792,10 @@ class BattleOrchestrator:
if task_battle:
payload.update(taskId=int(record["task_id"]), taskTypeId=str(record["task_type_id"]), removeIds=None)
self.journal.update(record, "settlement_pending", path=path, settlement_dispatched=True)
response = self._call(client, path, payload, cancel=cancel)
response = self._call(client, path, payload, cancel=cancel, require_code=record.get("battle_kind") == "hidden")
self.journal.update(record, "settlement_acknowledged", response=gameplay_response(response),
settlement_confirmed=True, reward=response["stageReward"] if response.get("stageReward") is not None else response.get("reward"))
self._remember_hidden_sweep(snapshot, record)
if not task_battle and not record.get("record_confirmed"):
self._record(client, record, record["stage_id"], True, cancel=cancel)
if self.observer:
@@ -781,6 +803,7 @@ class BattleOrchestrator:
elif task_battle:
self.journal.checkpoint(snapshot, intent, response)
self.journal.finish(snapshot, record, "win", "已恢复此入场的战果并确认结算;未重新开战")
self._finish_hidden_sweep(snapshot, record)
return record["message"]
except CancelledBeforeDispatch:
if not record.get("settlement_confirmed"):
@@ -861,54 +884,15 @@ class BattleOrchestrator:
if flag is not False and not (type(flag) is int and flag == 0):
event = started.get("stageEvent")
if isinstance(event, dict) and event.get("hideStageId") is not None:
hidden = str(event["hideStageId"])
fields = asdict(intent) if is_dataclass(intent) else dict(intent) if isinstance(intent, dict) else vars(intent).copy()
fields.update(stage_id=hidden, difficulty="1", battle_kind="hidden")
request = self.request(snapshot, fields, policy)
request = self._hidden_request(record, snapshot, intent, policy, started)
if request is None:
return self._unknown(record, "隐藏关卡编号或原入场证据无效,等待核对")
supported, reason = self.inspect(request)
if not supported:
return self._unknown(record, "隐藏关卡待处理:" + reason)
self.journal.update(record, "hidden_started", stage_id=hidden, difficulty="1",
**self.save_combat_request(record, request))
else:
return self._unknown(record, "探索事件或开战状态未知,等待核对")
if cancel.is_set():
return self._unknown(record, "开战后已取消,等待服务器状态核对")
self.journal.update(record, "running", runtime_not_started=False)
result = self.runtime.run(request.get("runtime_request", request), cancel_event=cancel)
if not self.accept_runtime_result(record, request, result, battle_started, cancel):
return record["message"]
data = record["battle_data"]
if not data["win"]:
if not value(intent, "task_id") or value(intent, "battle_kind") == "passStage":
self._record(client, record, request["stage_id"], False, cancel=cancel)
if self.observer:
self.observer("loss", intent, None)
label = "实验模型战败(近似)" if mode == "experimental" else "实际战败"
self.journal.finish(snapshot, record, "loss", label + ";未提交胜利结算或推进任务")
return label + ";已停止此轮任务推进"
if value(intent, "task_id"):
path, payload = "taskService/taskCompleteStep", {"taskId": int(value(intent, "task_id")),
"taskTypeId": str(value(intent, "task_type_id")), "removeIds": None, "battleData": data}
else:
path, payload = "battleService/battleEnd", {"battleData": data}
self.journal.update(record, "settlement_pending", path=path, settlement_dispatched=True)
response = self._call(client, path, payload, cancel=cancel)
self.journal.update(record, "settlement_acknowledged", response=gameplay_response(response), settlement_confirmed=True,
reward=response["stageReward"] if response.get("stageReward") is not None else response.get("reward"))
if value(intent, "task_id"):
if self.observer:
self.observer("settled", intent, response)
else:
self.journal.checkpoint(snapshot, intent, response)
else:
self._record(client, record, request["stage_id"], True,
cancel=None if value(intent, "kind") == "map_battle" else cancel)
if self.observer:
self.observer("settled", intent, response)
label = "实验模型胜利(近似)" if mode == "experimental" else "实际胜利"
self.journal.finish(snapshot, record, "win", label + ",结算接口已确认;后续进度以服务器快照核对")
return label + ",已确认对应结算"
return self._fight(client, snapshot, intent, request, record, battle_started, cancel)
except CancelledBeforeDispatch:
if not record.get("settlement_confirmed"):
self.journal.update(record, "waiting_for_battle_clock", path=record["start_path"],
@@ -918,6 +902,225 @@ class BattleOrchestrator:
self._unknown(record, "任务 / 战斗请求或运行未确认;禁止自动重试", error_type=type(error).__name__)
raise
def _hidden_request(self, record, snapshot, intent, policy, started):
hidden = hidden_stage_id(started)
if hidden is None:
return None
fields = asdict(intent) if is_dataclass(intent) else dict(intent) if isinstance(intent, dict) else vars(intent).copy()
fields.update(stage_id=hidden, difficulty="1", battle_kind="hidden")
# Preserve the source intent for policies/observers, and the actual
# hidden BattlePosition for every runtime/settlement/recovery path.
self.journal.update(record, "hidden_started",
parent_stage_id=record.get("parent_stage_id") or record["stage_id"],
parent_difficulty=record.get("parent_difficulty") or record["difficulty"],
stage_id=hidden, difficulty="1", battle_kind="hidden", runtime_not_started=True)
request = self.request(snapshot, fields, policy)
self.journal.update(record, "hidden_started", **self.save_combat_request(record, request),
team=policy.team, battle_mode=request.get("battle_mode", "original"))
return request
def _remember_hidden_sweep(self, snapshot, record):
if (self.sweeper is not None and record.get("sweep_sample_id")
and record.get("settlement_confirmed") is True):
self.sweeper.remember_map_reward(snapshot, record, record.get("response"))
self.sweeper.last_outcome = "hidden_win"
def _finish_hidden_sweep(self, snapshot, record):
if not self.sweeper or not record.get("sweep_sample_id") or record.get("outcome") not in ("win", "loss"):
return
if str(record.get("role_id")) != role_id(snapshot):
return
self._remember_hidden_sweep(snapshot, record)
self.sweeper.last_outcome = "hidden_" + record["outcome"]
def handoff_sweep(self, snapshot):
"""Move a confirmed hidden entry into the journal without a game write."""
if self.sweeper is None:
return None
with self.journal.lock:
self.journal.reload()
pending = self.sweeper.state.get("pending")
if not isinstance(pending, dict):
return None
hidden = hidden_stage_id(pending.get("start_response"))
if (not hidden or pending.get("hidden_stage_id") not in (None, hidden)
or str(pending.get("role_id")) != role_id(snapshot)
or pending.get("start_confirmed") is not True
or pending.get("start_path") != "stageService/stageStart"
or pending.get("phase") not in ("hidden_started", "开始请求待确认") or not pending.get("sampleId")):
return None
if pending.get("phase") != "hidden_started" or pending.get("hidden_stage_id") is None:
pending.update(phase="hidden_started", hidden_stage_id=hidden)
self.sweeper.save()
record = self.journal.pending(snapshot)
completed = next((row for row in self.journal.role(snapshot)["records"]
if row.get("sweep_sample_id") == pending["sampleId"] and row.get("phase") == "done"), None)
if completed:
if (record or completed.get("sweep_entry") != pending or completed.get("outcome") not in ("win", "loss")
or completed.get("record_confirmed") is not True
or completed.get("outcome") == "win" and completed.get("settlement_confirmed") is not True):
return None
self._finish_hidden_sweep(snapshot, completed)
self.sweeper.state["pending"] = None
self.sweeper.save()
return completed
install = not record or record.get("sweep_sample_id") != pending["sampleId"]
origin = pending.get("origin") or ({name: record.get(name) for name in ("kind", "stage_id", "difficulty",
"battle_kind", "task_id", "task_type_id", "step_number", "source_task_id", "source_task_type_id", "source_step_number",
"battle_mode")} if record else {"kind": "map_sweep", "stage_id": pending["stage"],
"difficulty": str(pending["level"]), "battle_kind": "sweep"})
if record and record.get("sweep_sample_id") == pending["sampleId"]:
if record.get("sweep_entry") != pending:
return None
install = record.get("phase") == "prepared" and not record.get("start_dispatched")
else:
if record:
if (record.get("kind") not in SWEEP_KINDS or record.get("sweep_sample_id")
or str(record.get("stage_id")) != str(pending["stage"])
or str(record.get("difficulty")) != str(pending["level"])
or record.get("phase") not in ("prepared", "sweep_pending", "unknown")
or record.get("start_dispatched") or record.get("settlement_dispatched") or record.get("record_dispatched")):
return None
else:
record = self.journal.begin(snapshot, origin, sweep_entry=pending)
if install:
self.journal.update(record, "hidden_started", sweep_sample_id=pending["sampleId"],
sweep_entry=deepcopy(pending), parent_stage_id=str(pending["stage"]), parent_difficulty=str(pending["level"]),
stage_id=hidden, difficulty="1", battle_kind="hidden", team=pending.get("team") or "teamA",
battle_mode=origin.get("battle_mode", "experimental"), start_path=pending["start_path"],
path=pending["start_path"], start_response=pending["start_response"], start_confirmed=True,
start_confirmed_at=pending.get("start_confirmed_at"), start_dispatched=True,
runtime_not_started=True, settlement_dispatched=False, record_dispatched=False,
sweep_entry_digest=digest(pending))
# The journal now owns both the response and original inputs. This
# also lets the existing Web Start gate use battle recovery.
self.sweeper.state["pending"] = None
self.sweeper.save()
return record
def archive_cancelled_sweep(self, snapshot):
"""Release only an explicitly cancelled, never-settled sweep entry."""
pending = self.sweeper.state.get("pending") if self.sweeper else None
if not isinstance(pending, dict) or pending.get("phase") != "cancelled_before_sweep_settlement":
return ""
response = pending.get("start_response") or {}
flag = response.get("triggerEvent")
if (pending.get("role_id") != role_id(snapshot) or pending.get("start_confirmed") is not True
or pending.get("start_path") != "stageService/stageStart" or pending.get("settlement_dispatched") is not False
or pending.get("record_dispatched") is not False or hidden_stage_id(response) is not None
or not (flag is False or type(flag) is int and flag == 0)
or response.get("resCode", 0) not in (0, "0") or not pending.get("sampleId")):
return ""
with self.journal.lock:
self.journal.reload()
record = self.journal.pending(snapshot)
if record and (record.get("kind") not in SWEEP_KINDS
or str(record.get("stage_id")) != str(pending["stage"])
or str(record.get("difficulty")) != str(pending["level"])
or record.get("settlement_dispatched") or record.get("record_dispatched")
or record.get("phase") not in ("sweep_pending", "unknown", "cancelled_sweep_archived")):
return ""
done = next((row for row in self.journal.role(snapshot)["records"]
if row.get("sweep_sample_id") == pending["sampleId"] and row.get("sweep_entry") == pending
and row.get("outcome") == "abandoned_cancelled_sweep"), None)
message = "扫荡入场已确认,结算尚未发送,停止后已本地放弃;未结算奖励"
if done is None:
record = record or self.journal.begin(snapshot, pending.get("origin") or {
"kind": "map_sweep", "stage_id": pending["stage"], "difficulty": pending["level"]},
sweep_entry=pending, sweep_phase="cancelled_sweep_archived")
self.journal.update(record, "cancelled_sweep_archived", sweep_sample_id=pending["sampleId"],
sweep_entry=deepcopy(pending), archival_evidence={"role_id": role_id(snapshot), "snapshot_read_at": time.time(),
"settlement_never_dispatched": True})
self.journal.finish(snapshot, record, "abandoned_cancelled_sweep", message)
self.sweeper.state["pending"] = None
self.sweeper.save()
return message
@staticmethod
def hidden_sweep_inputs(record):
entry = record.get("sweep_entry") or {}
raw = entry.get("entry_snapshot")
return (record.get("sweep_sample_id") and entry.get("sampleId") == record["sweep_sample_id"]
and digest(entry) == record.get("sweep_entry_digest") and isinstance(raw, dict)
and str((raw.get("master") or {}).get("id")) == str(record.get("role_id"))
and entry.get("team") == record.get("team") and hidden_stage_id(entry.get("start_response")) == record.get("stage_id"))
def continue_sweep(self, client, snapshot, policy, *, cancel=None):
"""Complete an already entered hidden sweep; never dispatch stageStart."""
cancel = cancel or threading.Event()
with self.journal.lock:
self.handoff_sweep(snapshot)
record = self.journal.pending(snapshot)
if not record or not record.get("sweep_sample_id") or not policy.enabled or cancel.is_set():
return ""
status = self.recovery_status(record, snapshot=snapshot)
if not status["resumable"]:
return status["message"]
intent = {key: record.get(key) for key in ("kind", "task_id", "task_type_id", "step_number", "stage_category",
"stage_id", "difficulty", "battle_kind", "team", "source_task_id", "source_task_type_id", "source_step_number")}
if status["state"] != "prepare_hidden_sweep":
return self.resume_task_clock(client, snapshot, intent, policy, cancel=cancel)
entry = record["sweep_entry"]
original = SimpleNamespace(raw=deepcopy(entry["entry_snapshot"]), now=entry.get("entry_snapshot_now", snapshot.now))
chosen = SimpleNamespace(**(vars(policy) | {"team": record["team"], "battle_mode": record["battle_mode"]}))
try:
request = self._hidden_request(record, original, intent, chosen, record["start_response"])
supported, reason = self.inspect(request)
if not supported:
return self._unknown(record, "隐藏关卡待处理:" + reason)
return self._fight(client, snapshot, intent, request, record, self.clock(), cancel)
except CancelledBeforeDispatch:
if not record.get("settlement_confirmed"):
self.journal.update(record, "waiting_for_battle_clock", path=record["start_path"],
settlement_dispatched=False, resume_clock_ready=True)
return "策略已停止,隐藏战果已保存,等待重新开启来源策略"
except Exception as error:
self._unknown(record, "隐藏关卡结果未确认,保留原入场且禁止重发写请求", error_type=type(error).__name__)
raise
def _fight(self, client, snapshot, intent, request, record, battle_started, cancel):
if cancel.is_set():
return self._unknown(record, "开战后已取消,等待服务器状态核对")
self.journal.update(record, "running", runtime_not_started=False)
result = self.runtime.run(request.get("runtime_request", request), cancel_event=cancel)
if not self.accept_runtime_result(record, request, result, battle_started, cancel):
return record["message"]
data = record["battle_data"]
mode = request.get("battle_mode", "original")
if not data["win"]:
if not value(intent, "task_id") or value(intent, "battle_kind") == "passStage":
self._record(client, record, request["stage_id"], False, cancel=cancel)
if self.observer:
self.observer("loss", intent, None)
label = "实验模型战败(近似)" if mode == "experimental" else "实际战败"
self.journal.finish(snapshot, record, "loss", label + ";未提交胜利结算或推进任务")
self._finish_hidden_sweep(snapshot, record)
return label + ";已停止此轮任务推进"
if value(intent, "task_id"):
path, payload = "taskService/taskCompleteStep", {"taskId": int(value(intent, "task_id")),
"taskTypeId": str(value(intent, "task_type_id")), "removeIds": None, "battleData": data}
else:
path, payload = "battleService/battleEnd", {"battleData": data}
self.journal.update(record, "settlement_pending", path=path, settlement_dispatched=True)
response = self._call(client, path, payload, cancel=cancel, require_code=record.get("battle_kind") == "hidden")
self.journal.update(record, "settlement_acknowledged", response=gameplay_response(response), settlement_confirmed=True,
reward=response["stageReward"] if response.get("stageReward") is not None else response.get("reward"))
self._remember_hidden_sweep(snapshot, record)
if value(intent, "task_id"):
if self.observer:
self.observer("settled", intent, response)
else:
self.journal.checkpoint(snapshot, intent, response)
else:
self._record(client, record, request["stage_id"], True,
cancel=None if value(intent, "kind") == "map_battle" else cancel)
if self.observer:
self.observer("settled", intent, response)
label = "实验模型胜利(近似)" if mode == "experimental" else "实际胜利"
self.journal.finish(snapshot, record, "win", label + ",结算接口已确认;后续进度以服务器快照核对")
self._finish_hidden_sweep(snapshot, record)
return label + ",已确认对应结算"
def _sweep(self, client, snapshot, intent, policy, cancel):
if not policy.allow_sweep or self.sweeper is None or value(intent, "task_id"):
return "任务战斗或当前策略不允许普通扫荡"
@@ -927,6 +1130,10 @@ class BattleOrchestrator:
return "仅三个难度全通且客户端允许的普通关卡可扫荡"
if cancel.is_set():
return "扫荡已取消,未开始"
origin = {name: public_data(value(intent, name)) for name in ("kind", "task_id", "task_type_id", "step_number",
"stage_id", "difficulty", "battle_kind", "source_task_id", "source_task_type_id", "source_step_number")}
origin["battle_mode"] = value(policy, "battle_mode", "experimental")
battle_policy = policy
policy = SweepPolicy(enabled=True, team=policy.team, keep_stamina=policy.reserve_ti,
rules={stage.stage_id: {"enabled": True, "level": stage.level, "limit": self.sweeper.used(snapshot, stage) + 1}})
record = self.journal.begin(snapshot, intent)
@@ -934,29 +1141,40 @@ class BattleOrchestrator:
try:
if self.observer:
self.observer("started", intent, None)
response = self.sweeper.run(client, snapshot, stage, policy)
response = self.sweeper.run(client, snapshot, stage, policy, cancel=cancel, origin=origin)
if self.sweeper.last_outcome == "hidden":
return self.continue_sweep(client, snapshot, battle_policy, cancel=cancel)
if self.observer:
self.observer("event" if self.sweeper.last_outcome == "event" else "settled", intent, response)
self.journal.finish(snapshot, record, "event" if self.sweeper.last_outcome == "event" else "sweep", "复用客户端已有扫荡路径")
return "探索奖励事件已结算" if self.sweeper.last_outcome == "event" else "扫荡已完成"
except CancelledBeforeDispatch:
if self.sweeper.state.get("pending") is None:
self.journal.finish(snapshot, record, "cancelled", "扫荡入场尚未发送,已取消")
return "扫荡已停止,已保留未确认记录"
except Exception as error:
record = self.journal.pending(snapshot) or record
self._unknown(record, "扫荡结果未确认,禁止自动重试", error_type=type(error).__name__)
raise
@staticmethod
def _call(client, path, payload, *, cancel=None):
def _call(client, path, payload, *, cancel=None, require_code=False):
if cancel is not None and cancel.is_set():
raise CancelledBeforeDispatch()
response = client.call(path, payload)
if not isinstance(response, dict) or response.get("resCode", 0) not in (0, "0"):
raise ValueError("游戏接口未返回可信的成功响应")
if require_code and not (type(response.get("resCode")) is int and response["resCode"] == 0
or type(response.get("resCode")) is str and response["resCode"] == "0"):
raise ValueError("隐藏关卡写请求缺少明确成功回包,保留待核对且禁止重发")
return response
def _record(self, client, record, stage, win, *, cancel=None):
phase = record["phase"]
self.journal.update(record, "record_pending", record_dispatched=True, record_result=win)
try:
response = self._call(client, "battleService/recordBattleResult", {"stageId": str(stage), "cityId": str(stage)[1:2], "result": int(win)}, cancel=cancel)
response = self._call(client, "battleService/recordBattleResult", {"stageId": str(stage), "cityId": str(stage)[1:2], "result": int(win)},
cancel=cancel, require_code=record.get("battle_kind") == "hidden")
except CancelledBeforeDispatch:
self.journal.update(record, phase, record_dispatched=False)
raise
+99 -2
View File
@@ -134,6 +134,8 @@ class Engine:
self._battle_roster = None
self._battle_runtimes = {"original": battle_runtime, "experimental": experimental_runtime}
self._selected_battle_mode = "original"
self._sweep_recovery_cache = {}
self._sweep_recovery_message = ""
def _map_catalog(self):
if self.resource_catalog is None:
@@ -597,7 +599,7 @@ class Engine:
from .game_data import load_progression_data
self.game_data = load_progression_data()
if not self._intent_policy(record).enabled:
origin = ("自动扫荡" if record.get("kind") == "map_battle" else
origin = ("自动扫荡" if record.get("kind") in ("map_battle", "map_sweep") else
"自动委托" if self._is_commission(record) else "自动主线")
return {"state": "blocked_policy", "resumable": False,
"message": "等待启用" + origin + "来源策略;已保留待核对战斗"}
@@ -622,6 +624,9 @@ class Engine:
intent = {key: record.get(key) for key in ("kind", "task_id", "task_type_id", "step_number", "stage_category",
"stage_id", "difficulty", "battle_kind", "team", "path", "source_task_id", "source_task_type_id", "source_step_number")}
policy = self._intent_policy(intent)
if record.get("sweep_sample_id"):
self._select_battle_runtime(record["battle_mode"])
return self.battles.continue_sweep(self.client, self.snapshot, policy, cancel=cancel)
if self.pending_battle_recovery()["state"] == "retry_local_runtime":
self._select_battle_runtime(record["battle_mode"])
return self.battles.resume_task_clock(self.client, self.snapshot, intent, policy, cancel=cancel)
@@ -868,6 +873,8 @@ class Engine:
return value(intent, "kind") in ("sweep", "progression_sweep", "progression_farm_sweep", "progression_map_sweep") or value(intent, "battle_kind") == "sweep"
def _intent_policy(self, intent):
if value(intent, "kind") == "map_sweep":
return SimpleNamespace(**(vars(self._map_policy()) | {"enabled": self.sweep_policy.enabled}))
if value(intent, "kind") == "map_battle":
return self._map_policy()
if not self._is_commission(intent):
@@ -1227,11 +1234,84 @@ class Engine:
finally:
self._sync_commission_history()
def _recover_sweep_entry(self):
"""Worker-only local migration, immediately after a successful read."""
pending = self.sweeper.state.get("pending")
if not isinstance(pending, dict):
return
message = self.battles.archive_cancelled_sweep(self.snapshot)
if message:
self._sweep_recovery_message = message
return
if self.battles.handoff_sweep(self.snapshot):
return
phases = ("遭遇隐藏关卡,请在游戏内手动战斗", "遇到事件或响应缺少事件状态,请在游戏内处理", "开始请求待确认")
if pending.get("phase") not in phases or pending.get("start_response"):
return
from .sweep_recovery import scan_trace, role_path_matches
owner = str(self.snapshot.raw["master"]["id"])
path = getattr(getattr(self.client, "trace", None), "path", None)
key = owner + ":" + digest(pending)
if key not in self._sweep_recovery_cache:
evidence = scan_trace(path, owner)
recovered = (evidence["valid"] and (pending.get("role_id") is not None
or role_path_matches(self.sweeper.path, getattr(self.client, "session", None), owner, path))
and self.sweeper.recover_hidden_start(self.snapshot, path, events=evidence["events"]))
# Keep only bounded evidence after the one scan. Presentation and
# subsequent snapshots never rescan the 16 MB rotated logs.
evidence.pop("events", None)
self._sweep_recovery_cache[key] = evidence
if recovered:
self.battles.handoff_sweep(self.snapshot)
return
else:
# An unsuccessful legacy proof is not retried on every refresh.
# A completed archive still repairs a crash before sweep.save.
if not any(row.get("sweep_sample_id") == pending.get("sampleId")
and (row.get("outcome") == "abandoned_missing_hidden_id" or row.get("phase") == "legacy_hidden_archived")
and row.get("sweep_entry") == pending
for row in self.battle_journal.role(self.snapshot)["records"]):
return
evidence = self._sweep_recovery_cache[key]
if (pending.get("phase") != phases[0] or set(pending) != {"stage", "level", "phase", "sampleId"}
or not all(isinstance(pending.get(field), str) and pending[field] for field in ("stage", "level", "sampleId"))
or not evidence["valid"] or not evidence["owner_read"] or not evidence["no_consumption"]
or self.snapshot.raw.get("masterCurrentEvent")
or not role_path_matches(self.sweeper.path, getattr(self.client, "session", None), owner, path)
or any(state.get("pending") and not any(row.get("attempt_id") == state["pending"]
and row.get("phase") == "legacy_hidden_archived" and row.get("sweep_entry") == pending
and row.get("sweep_sample_id") == pending["sampleId"]
and str(row.get("role_id")) == owner
for row in state.get("records", [])) for state in self.battle_journal.state["roles"].values())):
return
reservations = [str(key).split(":") for key, count in self.sweeper.state.get("counts", {}).items()
if type(count) is int and count > 0 and str(key).split(":")[-2:] == [pending["stage"], pending["level"]]]
if not reservations or any(len(parts) != 4 or parts[0] != owner for parts in reservations):
return
# Archive before releasing the guard. A crash between these two atomic
# saves is repaired by the sample ID on the next trusted read.
existing = next((row for row in self.battle_journal.role(self.snapshot)["records"]
if row.get("sweep_sample_id") == pending["sampleId"]
and row.get("outcome") == "abandoned_missing_hidden_id" and row.get("sweep_entry") == pending), None)
message = "旧版未保存隐藏关卡编号,本次未完成已放弃;未结算奖励"
if existing is None:
record = self.battle_journal.pending(self.snapshot) or self.battle_journal.begin(self.snapshot,
{"kind": "map_sweep", "stage_id": pending["stage"], "difficulty": pending["level"], "battle_kind": "sweep"},
sweep_entry=pending, sweep_phase="legacy_hidden_archived")
self.battle_journal.update(record, "legacy_hidden_archived", sweep_sample_id=pending["sampleId"],
sweep_entry=deepcopy(pending), archival_evidence={"role_id": owner, "snapshot_read_at": time.time(),
"role_path_bound": True, "trace_files": evidence["files"], "no_later_consumption": True})
self.battle_journal.finish(self.snapshot, record, "abandoned_missing_hidden_id", message)
self.sweeper.state["pending"] = None
self.sweeper.save()
self._sweep_recovery_message = message
@account_serial
def read_snapshot(self, *, sync_master=True):
if self._progression_pending():
self.last_pending_check = time.monotonic()
self.snapshot = self.client.snapshot()
self._recover_sweep_entry()
self._reconcile_procurement()
pending = self.battle_journal.pending(self.snapshot)
pending_id = pending.get("attempt_id") if pending else None
@@ -1384,6 +1464,9 @@ class Engine:
if not hatch_only:
settled = self.settle_pending_growth()
message = "状态已刷新" + (";已请求孵化 / 成长结算" if settled else "")
if self._sweep_recovery_message:
message += ";" + self._sweep_recovery_message
self._sweep_recovery_message = ""
if self.sweeper.recovered_event:
message += ";已解除旧版对已结算奖励事件的误阻塞"
self.sweeper.recovered_event = False
@@ -1451,7 +1534,21 @@ class Engine:
stage = self.sweeper.next(self.snapshot, self.sweep_policy)
if self.demo:
return self.snapshot, plans, "扫荡需要登录真实账号;演示不会提交战斗"
result = self.sweeper.run(self.client, self.snapshot, stage, self.sweep_policy)
origin = {"kind": "map_sweep", "stage_id": stage.stage_id, "difficulty": stage.level,
"battle_kind": "sweep", "battle_mode": "experimental"}
try:
result = self.sweeper.run(self.client, self.snapshot, stage, self.sweep_policy,
cancel=self._progression_cancel, origin=origin)
except CancelledBeforeDispatch:
return self.snapshot, [], "扫荡已停止,未确认的入场已保留"
if self.sweeper.last_outcome == "hidden":
self.battles.handoff_sweep(self.snapshot)
self._select_battle_runtime("experimental")
message = self.battles.continue_sweep(self.client, self.snapshot, self._intent_policy(origin),
cancel=self._progression_cancel)
if not self._progression_cancel.is_set():
self.read_snapshot(sync_master=False)
return self.snapshot, self.plans(), "扫荡遭遇隐藏关卡;" + (message or "隐藏入场已保存,等待来源策略开启后继续")
self.read_snapshot()
label = "探索奖励事件已结算" if self.sweeper.last_outcome == "event" else "扫荡完成"
message = f"{label}:{stage.number} {stage.name} / 难度{stage.level};" + reward_text(self.sweeper.last_reward)
+5 -4
View File
@@ -16,10 +16,10 @@ from .battle_messages import battle_message
CATEGORIES = {"mainline": "主线", "sidequest": "支线", "commission": "委托", "event": "活动(暂不自动)",
"bond": "羁绊(暂不自动)", "unknown": "其他 / 未知"}
BATTLE_KINDS = {"mainline": "主线战斗", "sidequest": "支线战斗", "commission": "委托战斗",
"battle": "普通战斗", "map_battle": "地图战斗", "sweep": "扫荡", "map_reward_event": "地图奖励事件",
"battle": "普通战斗", "map_battle": "地图战斗", "sweep": "扫荡", "hidden": "隐藏关卡战斗", "map_reward_event": "地图奖励事件",
"ordinary_stage": "普通关卡战斗", "task_battle": "任务战斗", "task_pass_stage": "任务通关战斗", "unknown": "其他 / 未知"}
BATTLE_ALIASES = {"task": "task_battle", "passStage": "task_pass_stage", "event": "map_reward_event",
"reward_event": "map_reward_event", "normal": "battle"}
"reward_event": "map_reward_event", "normal": "battle", "map_sweep": "sweep"}
BATTLE_MODES = {"original": "原版运行时(以能力检查为准)", "experimental": "实验模拟(近似,未完整验证)"}
STATES = {"available": "可接取", "unaccepted": "未接取", "active": "进行中", "in_progress": "进行中",
"ready": "待交付", "completed": "已完成", "complete": "已完成", "claimed": "已领奖",
@@ -32,7 +32,8 @@ STATE_ALIASES = {"active": "received", "in_progress": "received", "available": "
"ready": "ready_to_reward", "completed": "finished", "complete": "finished", "claimed": "finished", "blocked": "received"}
CURRENT_STATES = {"received", "unlocked", "ready_to_reward"}
OUTCOMES = {"win": "胜利", "loss": "打不过", "unsupported": "暂不支持", "event": "地图奖励事件",
"completed": "已完成", "cancelled": "已取消", "timeout": "超时", "unknown": "结果待核对"}
"completed": "已完成", "cancelled": "已取消", "timeout": "超时", "unknown": "结果待核对",
"abandoned_missing_hidden_id": "未完成,已放弃", "abandoned_unsettled_sweep": "未完成,已放弃", "cancelled_unsent_sweep": "未完成,已取消"}
def category(value):
@@ -99,7 +100,7 @@ def prepare_progression_views(engine, *, tasks=True, records=True):
kind = "map_reward_event"
elif row.get("task_id") and kind == "battle":
kind = "task_battle"
elif row.get("kind") == "sweep":
elif row.get("kind") in ("sweep", "map_sweep") and kind != "hidden":
kind = "sweep"
stamp = row.get("finished_at") or row.get("started_at") or row.get("timestamp", row.get("time", row.get("at")))
if type(stamp) in (int, float) and 0 <= stamp <= 253402271999:
+68
View File
@@ -0,0 +1,68 @@
"""Read-only evidence shared by hidden-entry migration and legacy archival."""
import hashlib
import json
from pathlib import Path
def scan_trace(path, owner):
"""Called once per pending by the account worker, never by presentation."""
evidence = {"events": [], "files": [], "valid": False, "owner_read": False, "no_consumption": True}
if not isinstance(path, (str, Path)):
return evidence
path = Path(path)
role = None
safe = {"读取角色", "masterService/masterQueryDetail", "heartBeatService/keepAlive",
"渠道账号验证", "获取官方区服", "进入选中区服", "本地区服整理"}
def unique(pairs):
result = {}
for key, item in pairs:
if key in result:
raise ValueError("调试记录字段重复")
result[key] = item
return result
try:
for file in (path.with_name("network_debug.previous.jsonl"), path):
if not file.exists():
continue
raw = file.read_bytes()
evidence["files"].append({"name": file.name, "sha256": hashlib.sha256(raw).hexdigest()})
for line in raw.decode("utf-8").splitlines():
if not line.strip():
continue
event = json.loads(line, object_pairs_hook=unique)
if not isinstance(event, dict):
return evidence
# Client.enter_server emits this local signature diagnostic
# before entering the server; it dispatches no game request.
if (event.get("kind") == "info" and event.get("operation") == "进入参数检查"
and event.get("scope") == "local"):
continue
if event.get("kind") not in ("request", "response", "error"):
return evidence
evidence["events"].append(event)
operation, kind, body = event.get("operation"), event.get("kind"), event.get("body")
if operation in ("读取角色", "masterService/masterQueryDetail") and kind == "response":
role = str((body.get("master") or {}).get("id")) if isinstance(body, dict) else None
if role != owner or event.get("http_status", 200) != 200 or body.get("resCode", 0) not in (0, "0"):
evidence["no_consumption"] = False
else:
evidence["owner_read"] = True
elif operation not in safe:
# A missing role or an unrecognised operation cannot prove
# that no later consuming request was dispatched.
evidence["no_consumption"] = False
evidence["valid"] = bool(evidence["files"]) and role == owner
except (OSError, ValueError, TypeError, AttributeError):
pass
return evidence
def role_path_matches(sweep_path, session, owner, trace_path):
from .api import Session
from .sessions import identity
if not isinstance(session, Session) or str(session.role_id) != owner or not sweep_path:
return False
root = Path(sweep_path).parent
return (root.parent.name == "roles" and root.name == identity(session)
and root.resolve() == root.absolute() and isinstance(trace_path, (str, Path))
and Path(trace_path).parent.resolve() == root.parent.parent.resolve())
+209 -2
View File
@@ -1,9 +1,13 @@
"""The built-in three-difficulty-cleared sweep path from StageStartPanel."""
from dataclasses import dataclass, field
from contextlib import nullcontext
from datetime import datetime
from types import SimpleNamespace
import json
import math
from pathlib import Path
import sqlite3
import time
import uuid
from .daily import day
@@ -17,6 +21,34 @@ def settled_reward_event(response):
return event_reward(response) is not None
def successful_response(response):
if not isinstance(response, dict):
return False
if "resCode" not in response:
# Existing in-process adapters may already have checked resCode.
return (type(response.get("triggerEvent")) is bool
or type(response.get("triggerEvent")) is int and response["triggerEvent"] in (0, 1)
or isinstance(response.get("reward"), dict))
return (type(response["resCode"]) is int and response["resCode"] == 0
or type(response["resCode"]) is str and response["resCode"] == "0")
def hidden_stage_id(response):
"""Return the original hidden ID only for an explicit hidden event."""
if not isinstance(response, dict):
return None
flag = response.get("triggerEvent")
event = response.get("stageEvent")
if not (flag is True or type(flag) is int and flag == 1) or not isinstance(event, dict):
return None
identifier = event.get("hideStageId")
if isinstance(identifier, str) and identifier.strip():
return identifier
if type(identifier) is int and identifier > 0:
return str(identifier)
return None
@dataclass
class SweepPolicy:
enabled: bool = False
@@ -133,6 +165,140 @@ class SweepRunner:
return True
return False
def recover_hidden_start(self, snapshot, trace_path, *, events=None):
"""Recover entry evidence only; never replay entry or infer settlement.
Old journals lack entry snapshots. Trace proof deliberately does not
manufacture runtime inputs from the current, post-entry snapshot.
"""
from .battles import gameplay_response
pending = self.state.get("pending")
old_phases = {"遭遇隐藏关卡,请在游戏内手动战斗", "遇到事件或响应缺少事件状态,请在游戏内处理"}
if not isinstance(pending, dict) or not trace_path:
return False
if (pending.get("phase") not in old_phases
and not (pending.get("phase") == "开始请求待确认" and "start_response" not in pending)):
return False
owner = snapshot.raw.get("master", {}).get("id")
if owner is None or (pending.get("role_id") is not None and str(pending["role_id"]) != str(owner)):
return False
owner = str(owner)
parent, level = pending.get("stage"), pending.get("level")
if parent is None or level is None:
return False
reservation = pending.get("counts_key")
if pending.get("role_id") is None:
# Multiple dates or roles cannot identify which entry this block owns.
reservations = [(key, count) for key, count in self.state.get("counts", {}).items()
if isinstance(key, str) and len(key.split(":")) == 4
and key.split(":")[2:] == [str(parent), str(level)] and count != 0]
if (len(reservations) != 1 or reservations[0][0].split(":")[0] != owner
or type(reservations[0][1]) is not int or reservations[0][1] <= 0):
return False
reservation = reservations[0][0]
if reservation is not None:
parts = reservation.split(":") if isinstance(reservation, str) else []
if len(parts) != 4 or parts[0] != owner or parts[2:] != [str(parent), str(level)]:
return False
try:
datetime.strptime(parts[1], "%Y-%m-%d")
except ValueError:
return False
role, latest, candidate = None, None, None
requests, responses = {}, set()
# Everything outside these explicit reads is an uncertain write.
reads = {"读取角色", "masterService/masterQueryDetail"}
def unambiguous_object(pairs):
result = {}
for key, value in pairs:
if key in result:
raise ValueError("Duplicate trace field")
result[key] = value
return result
path = Path(trace_path)
try:
for file in ((None,) if events is not None else (path.with_name("network_debug.previous.jsonl"), path)):
if file is not None and not file.exists():
continue
with (nullcontext(events) if file is None else file.open(encoding="utf-8")) as stream:
for line in stream:
if isinstance(line, str) and not line.strip():
continue
event = line if isinstance(line, dict) else json.loads(line, object_pairs_hook=unambiguous_object)
if not isinstance(event, dict):
return False
operation, kind = event.get("operation"), event.get("kind")
body, identifier = event.get("body"), event.get("request_id")
if not isinstance(operation, str) or kind not in ("request", "response", "error"):
return False
if operation in reads:
if kind == "response":
master = body.get("master") if isinstance(body, dict) else None
observed = master.get("id") if isinstance(master, dict) else None
if (type(observed) not in (int, str) or not str(observed).strip()
or event.get("http_status", 200) != 200
or "resCode" in body and not successful_response(body)):
observed = None
observed = str(observed) if observed is not None else None
if role != observed:
latest, candidate = None, None
role = observed
elif kind == "error":
role, latest, candidate = None, None, None
continue
if not isinstance(identifier, str) or not identifier or not isinstance(body, dict):
return False
if kind == "request":
if identifier in requests:
return False
requests[identifier] = (operation, role)
if role is None or role == owner:
latest, candidate = None, None
if (role == owner and operation == "stageService/stageStart"
and str(body.get("stageTypeId")) == str(parent)
and str(body.get("stageLevel")) == str(level)):
latest = identifier
elif kind == "response":
if identifier in responses:
return False
responses.add(identifier)
if (identifier == latest and requests.get(identifier) == (operation, owner)
and role == owner and operation == "stageService/stageStart"
and event.get("http_status") == 200 and body.get("resCode") in (0, "0") and successful_response(body)
and hidden_stage_id(body) is not None and not settled_reward_event(body)):
candidate = event
elif role is None or role == owner:
latest, candidate = None, None
elif role is None or role == owner:
latest, candidate = None, None
except (OSError, ValueError, TypeError, AttributeError):
return False
if candidate is None or role != owner:
return False
confirmed_at = None
try:
stamp = candidate.get("time")
parsed = datetime.fromisoformat(stamp) if isinstance(stamp, str) else None
if parsed is not None and parsed.tzinfo is not None:
confirmed_at = parsed.timestamp()
if confirmed_at is not None and (not math.isfinite(confirmed_at) or confirmed_at <= 0):
confirmed_at = None
except (ValueError, OverflowError, OSError):
pass
update = {"role_id": owner, "phase": "hidden_started", "start_path": "stageService/stageStart",
"start_dispatched": True, "start_confirmed": True,
"start_response": gameplay_response(candidate["body"]),
"hidden_stage_id": hidden_stage_id(candidate["body"]),
"start_request_id": candidate["request_id"], "evidence_status": "trace_confirmed_hidden_start"}
if reservation is not None:
update["counts_key"] = reservation
if confirmed_at is not None:
update["start_confirmed_at"] = confirmed_at
pending.update(update)
self.save()
return True
def save(self):
if self.path:
self.path.parent.mkdir(parents=True, exist_ok=True)
@@ -202,7 +368,9 @@ class SweepRunner:
return stage
return None
def run(self, client, snapshot, stage, policy):
def run(self, client, snapshot, stage, policy, *, cancel=None, origin=None):
from .battles import CancelledBeforeDispatch, gameplay_response, public_data
self.last_outcome = ""
self.last_reward = None
rule = policy.rules.get(stage.stage_id) or {}
@@ -212,10 +380,42 @@ class SweepRunner:
if reason:
raise ValueError(reason)
key = self.key(snapshot, stage)
previous_count = self.state["counts"].get(key)
self.state["counts"][key] = self.used(snapshot, stage) + 1
self.state["pending"] = {"stage": stage.stage_id, "level": stage.level, "phase": "开始请求待确认", "sampleId": uuid.uuid4().hex}
self.state["pending"] = {"stage": stage.stage_id, "level": stage.level,
"phase": "开始请求待确认", "sampleId": uuid.uuid4().hex,
"role_id": str(snapshot.raw["master"]["id"]), "team": policy.team, "counts_key": key,
"entry_snapshot": public_data(snapshot.raw), "entry_snapshot_now": snapshot.now,
"origin": public_data(origin) if isinstance(origin, dict) else {},
"start_path": "stageService/stageStart", "start_dispatched": False, "start_confirmed": False,
"settlement_dispatched": False, "record_dispatched": False}
self.save() # Reserve before the first non-retryable write, including timeouts.
self.state["pending"]["start_dispatched"] = True
self.save()
if cancel is not None and cancel.is_set():
if previous_count is None:
self.state["counts"].pop(key, None)
else:
self.state["counts"][key] = previous_count
self.state["pending"] = None
self.save()
raise CancelledBeforeDispatch()
started = client.call("stageService/stageStart", {"stageTypeId": stage.stage_id, "stageLevel": stage.level})
if not successful_response(started):
raise ValueError("扫荡开始未返回可信的成功响应,禁止自动重试")
self.state["pending"].update(start_response=gameplay_response(started),
start_confirmed=True, start_confirmed_at=time.time())
self.save()
hidden = hidden_stage_id(started)
if hidden is not None and not settled_reward_event(started):
self.state["pending"].update(phase="hidden_started", hidden_stage_id=hidden)
self.save()
self.last_outcome = "hidden"
if origin is None:
# Callers without the orchestrator handoff must retain the
# historical stop signal, while preserving the new evidence.
raise ValueError("隐藏关卡已入场,等待战斗接续")
return started
if settled_reward_event(started):
# StageCenter.startStageHandler applies stageEvent.result directly;
# StageStartPanel shows it and returns, without battleEnd.
@@ -239,8 +439,15 @@ class SweepRunner:
"win": True, "cheatNum": 0, "cheatRecords": "", "killMonster": {}, "battleMonIds": self.team_ids(snapshot, policy),
**{name: 0 for name in ("leftTime", "killNum", "totalDamage", "bossDamage", "deadNum", "aliveNum", "apLeft")}}
self.state["pending"]["phase"] = "扫荡结算待确认"
self.state["pending"].update(settlement_dispatched=True, sweep_battle_data=battle)
self.save()
if cancel is not None and cancel.is_set():
self.state["pending"].update(phase="cancelled_before_sweep_settlement", settlement_dispatched=False)
self.save()
raise CancelledBeforeDispatch()
result = client.call("battleService/battleEnd", {"battleData": battle})
if not successful_response(result):
raise ValueError("扫荡结算未返回可信的成功响应,禁止自动重试")
self.remember_reward(client, snapshot, stage, "sweep", result.get("reward"), result)
self.state["pending"] = None
self.save()
@@ -0,0 +1,291 @@
"""Hidden sweep handoff/recovery regressions; every game operation is mocked."""
from copy import deepcopy
import threading
import unittest
from unittest.mock import Mock
from ranch_assistant.battles import BattleJournal, BattleOrchestrator
from ranch_assistant.sweeping import SweepRunner
from ranch_assistant.tests.test_battle_orchestration import ExperimentalRuntime, fixture, intent, policy
from ranch_assistant.tests.test_core import workspace_temp
class HiddenSweepBattleTests(unittest.TestCase):
def setUp(self):
self.folder = self.enterContext(workspace_temp())
self.catalog, self.snapshot = fixture()
self.snapshot.raw["history"]["passStage"] = {"0101": [1, 2, 3]}
self.runtime = ExperimentalRuntime()
self.client = Mock()
self.start = {"resCode": 0, "triggerEvent": True,
"stageEvent": {"hideStageId": "0102", "result": {"money": 999}, "costTi": 99}}
self.client.call.side_effect = lambda path, payload: deepcopy(self.start) if path.endswith("stageStart") else {
"resCode": 0, "reward": {"money": 17}, "costTi": 6}
self.chosen = policy(battle_mode="experimental")
self.action = intent(kind="sweep", battle_kind="sweep", difficulty="3")
self.restart()
def restart(self):
self.sweeper = SweepRunner(self.catalog, self.folder / "sweep_runs.json")
self.runner = BattleOrchestrator(self.catalog, BattleJournal(self.folder / "journal.json"),
self.runtime, self.sweeper)
def run_sweep(self, cancel=None):
return self.runner.run(self.client, self.snapshot, self.action, self.chosen, cancel=cancel)
def paths(self):
return [call.args[0] for call in self.client.call.call_args_list]
def test_hidden_win_uses_hidden_inputs_metadata_and_record_with_one_entry(self):
self.run_sweep()
self.assertEqual(self.paths(), ["stageService/stageStart", "battleService/battleEnd", "battleService/recordBattleResult"])
request = self.runtime.run.call_args.args[0]
self.assertEqual((request["stage_id"], request["difficulty"], request["battle_kind"]), ("0102", "1", "hidden"))
data = self.client.call.call_args_list[1].args[1]["battleData"]
self.assertEqual(data["battlePosition"]["stageId"], "0102")
self.assertEqual(data["totalDamage"], 47)
self.assertEqual(self.client.call.call_args_list[2].args[1], {"stageId": "0102", "cityId": "1", "result": 1})
record = self.runner.journal.records(self.snapshot)[0]
self.assertEqual((record["stage_id"], record["difficulty"], record["battle_kind"]), ("0102", "1", "hidden"))
self.assertEqual((record["parent_stage_id"], record["parent_difficulty"], record["outcome"]), ("0101", "3", "win"))
self.assertEqual(sum(self.sweeper.state["counts"].values()), 1)
self.assertIsNone(self.sweeper.state["pending"])
totals = self.sweeper.statistics.snapshot(7)["totals"]
self.assertEqual(totals["0102:1:sweep"]["n"], 1)
self.assertNotIn("0101:3:event", totals)
self.assertEqual(self.sweeper.last_reward["money"], 17)
def test_hidden_loss_records_hidden_id_without_victory_settlement(self):
self.runtime.win = False
self.run_sweep()
self.assertEqual(self.paths(), ["stageService/stageStart", "battleService/recordBattleResult"])
self.assertEqual(self.client.call.call_args.args[1], {"stageId": "0102", "cityId": "1", "result": 0})
self.assertIsNone(self.sweeper.state["pending"])
self.assertEqual(self.runner.journal.records(self.snapshot)[0]["outcome"], "loss")
self.assertEqual(self.runner.journal.role(self.snapshot)["losses"], 0)
self.assertEqual(self.sweeper.statistics.snapshot(7)["totals"], {})
def test_stop_during_computation_resumes_saved_result_without_second_worker_or_entry(self):
cancel = threading.Event()
def complete(request, *, cancel_event):
result = self.runtime._run(request, cancel_event=cancel_event)
cancel_event.set()
return result
self.runtime.run.side_effect = complete
self.run_sweep(cancel)
self.assertEqual(self.paths(), ["stageService/stageStart"])
self.restart()
self.runner.continue_sweep(self.client, self.snapshot, self.chosen, cancel=threading.Event())
self.assertEqual(self.runtime.run.call_count, 1)
self.assertEqual(self.paths(), ["stageService/stageStart", "battleService/battleEnd", "battleService/recordBattleResult"])
self.assertIsNone(self.sweeper.state["pending"])
self.assertEqual(sum(self.sweeper.state["counts"].values()), 1)
def test_stop_after_start_keeps_original_inputs_for_restart(self):
cancel = threading.Event()
def start(path, payload):
cancel.set()
return deepcopy(self.start)
self.client.call.side_effect = start
self.run_sweep(cancel)
self.runtime.run.assert_not_called()
self.snapshot.raw["monsters"][0]["level"] = 999
self.restart()
self.client.call.side_effect = lambda path, payload: {"resCode": 0, "reward": {}}
self.runner.continue_sweep(self.client, self.snapshot, self.chosen, cancel=threading.Event())
request = self.runtime.run.call_args.args[0]
self.assertNotIn("level", request.get("roster", request["snapshot"])["monsters"][0])
self.assertEqual(self.paths().count("stageService/stageStart"), 1)
self.assertIsNone(self.sweeper.state["pending"])
def test_unknown_settlement_is_never_replayed_or_cleared(self):
def call(path, payload):
if path.endswith("battleEnd"):
raise TimeoutError("offline lost settlement response")
return deepcopy(self.start)
self.client.call.side_effect = call
with self.assertRaises(TimeoutError):
self.run_sweep()
self.restart()
before = deepcopy(self.sweeper.state)
self.runner.continue_sweep(self.client, self.snapshot, self.chosen, cancel=threading.Event())
self.assertEqual(self.paths(), ["stageService/stageStart", "battleService/battleEnd"])
self.assertEqual(self.sweeper.state, before)
self.assertIsNotNone(self.runner.pending(self.snapshot))
def test_unknown_record_keeps_confirmed_rewards_and_never_replays(self):
def call(path, payload):
if path.endswith("recordBattleResult"):
raise TimeoutError("offline lost record response")
return deepcopy(self.start) if path.endswith("stageStart") else {"resCode": 0, "reward": {"money": 17}}
self.client.call.side_effect = call
with self.assertRaises(TimeoutError):
self.run_sweep()
self.restart()
self.runner.continue_sweep(self.client, self.snapshot, self.chosen, cancel=threading.Event())
self.assertEqual(len(self.paths()), 3)
self.assertIsNotNone(self.runner.pending(self.snapshot)["sweep_entry"])
self.assertEqual(self.sweeper.statistics.snapshot(7)["totals"]["0102:1:sweep"]["n"], 1)
def test_role_mismatch_cannot_adopt_hidden_sweep(self):
cancel = threading.Event()
self.client.call.side_effect = lambda *args: cancel.set() or deepcopy(self.start)
self.run_sweep(cancel)
self.restart()
self.snapshot.raw["master"]["id"] = 8
before = deepcopy(self.sweeper.state)
self.runner.continue_sweep(self.client, self.snapshot, self.chosen, cancel=threading.Event())
self.assertEqual(self.sweeper.state, before)
self.assertEqual(len(self.paths()), 1)
self.runtime.run.assert_not_called()
def test_no_hidden_evidence_keeps_legacy_pending_and_journal(self):
self.sweeper.state["pending"] = {"stage": "0101", "level": "3", "sampleId": "old",
"phase": "遭遇隐藏关卡,请在游戏内手动战斗"}
self.sweeper.save()
before = deepcopy(self.sweeper.state)
self.runner.continue_sweep(self.client, self.snapshot, self.chosen, cancel=threading.Event())
self.assertEqual(self.sweeper.state, before)
self.client.call.assert_not_called()
self.runtime.run.assert_not_called()
def test_cross_day_handoff_and_completed_journal_cleanup_keep_original_reservation(self):
cancel = threading.Event()
self.client.call.side_effect = lambda *args: cancel.set() or deepcopy(self.start)
self.run_sweep(cancel)
record = self.runner.pending(self.snapshot)
entry = deepcopy(record["sweep_entry"])
counts = deepcopy(self.sweeper.state["counts"])
# Emulate a crash after journal.save but before sweep.save.
self.sweeper.state["pending"] = deepcopy(entry)
self.sweeper.save()
self.snapshot.server_offset += 86400
self.restart()
self.runner.handoff_sweep(self.snapshot)
self.assertIsNone(self.sweeper.state["pending"])
self.assertEqual(self.sweeper.state["counts"], counts)
self.client.call.side_effect = lambda *args: {"resCode": 0, "reward": {"money": 17}}
self.runner.continue_sweep(self.client, self.snapshot, self.chosen)
self.assertEqual(self.paths().count("stageService/stageStart"), 1)
self.sweeper.state["pending"] = deepcopy(entry)
self.sweeper.save()
self.restart()
self.runner.handoff_sweep(self.snapshot)
self.assertIsNone(self.sweeper.state["pending"])
self.assertEqual(self.sweeper.state["counts"], counts)
self.assertEqual(len(self.runner.journal.records(self.snapshot)), 1)
self.assertEqual(self.sweeper.statistics.snapshot(7)["totals"]["0102:1:sweep"]["n"], 1)
def test_runtime_clock_stop_and_resume_does_not_resimulate_or_enter(self):
cancel = threading.Event()
cancel.wait = Mock(side_effect=lambda timeout: cancel.set() or True)
self.runner.clock = lambda: 0
self.runtime.run.side_effect = lambda request, cancel_event: self.runtime._run(request, cancel_event=cancel_event) | {
"requires_realtime_wait": True, "model_elapsed_ms": 10000}
self.run_sweep(cancel)
self.assertEqual(self.paths(), ["stageService/stageStart"])
self.restart()
record = self.runner.pending(self.snapshot)
self.assertEqual(record["battle_clock_seconds"], 10)
self.assertEqual(self.runner.recovery_status(record)["state"], "resume_result")
self.runner.journal.update(record, record["phase"], battle_ready_at=1)
self.runner.continue_sweep(self.client, self.snapshot, self.chosen)
self.assertEqual(self.runtime.run.call_count, 1)
self.assertEqual(len(self.paths()), 3)
def test_confirmed_hidden_start_does_not_recover_with_wrong_hidden_id(self):
cancel = threading.Event()
self.client.call.side_effect = lambda *args: cancel.set() or deepcopy(self.start)
self.run_sweep(cancel)
record = self.runner.pending(self.snapshot)
self.runner.journal.update(record, record["phase"], stage_id="0101")
self.runner.continue_sweep(self.client, self.snapshot, self.chosen)
self.assertEqual(self.paths(), ["stageService/stageStart"])
self.runtime.run.assert_not_called()
def test_empty_settlement_or_record_response_never_confirms_or_retries_hidden_write(self):
for target in ("battleEnd", "recordBattleResult"):
with self.subTest(target=target):
self.setUp()
def call(path, payload):
if path.endswith(target):
return {}
return deepcopy(self.start) if path.endswith("stageStart") else {"resCode": 0, "reward": {}}
self.client.call.side_effect = call
with self.assertRaises(ValueError):
self.run_sweep()
count = len(self.paths())
self.restart()
record = self.runner.pending(self.snapshot)
self.assertFalse(self.runner.recovery_status(record)["resumable"])
self.runner.continue_sweep(self.client, self.snapshot, self.chosen)
self.assertEqual(len(self.paths()), count)
def test_crash_after_trusted_response_save_derives_hidden_only_from_response(self):
cancel = threading.Event()
self.client.call.side_effect = lambda *args: cancel.set() or deepcopy(self.start)
self.run_sweep(cancel)
entry = deepcopy(self.runner.pending(self.snapshot)["sweep_entry"])
self.runner.journal.state = {"version": 1, "roles": {}}
self.runner.journal.save()
entry.pop("hidden_stage_id")
entry["phase"] = "开始请求待确认"
self.sweeper.state["pending"] = entry
self.sweeper.save()
self.restart()
self.client.call.side_effect = lambda *args: {"resCode": 0, "reward": {}}
self.runner.continue_sweep(self.client, self.snapshot, self.chosen)
self.assertEqual(self.paths().count("stageService/stageStart"), 1)
self.assertEqual(self.runner.journal.records(self.snapshot)[0]["stage_id"], "0102")
def test_crash_after_new_journal_begin_keeps_sample_role_and_recovers_same_record(self):
cancel = threading.Event()
self.client.call.side_effect = lambda *args: cancel.set() or deepcopy(self.start)
self.run_sweep(cancel)
entry = deepcopy(self.runner.pending(self.snapshot)["sweep_entry"])
self.runner.journal.state = {"version": 1, "roles": {}}
self.runner.journal.save()
self.sweeper.state["pending"] = entry
self.sweeper.save()
begin = self.runner.journal.begin
def crash(*args, **kwargs):
record = begin(*args, **kwargs)
self.assertEqual((record["sweep_sample_id"], record["role_id"]), (entry["sampleId"], "7"))
raise OSError("offline crash after durable begin")
self.runner.journal.begin = crash
with self.assertRaises(OSError):
self.runner.handoff_sweep(self.snapshot)
self.restart()
self.client.call.side_effect = lambda *args: {"resCode": 0, "reward": {}}
self.runner.continue_sweep(self.client, self.snapshot, self.chosen)
self.assertIsNone(self.runner.pending(self.snapshot))
self.assertEqual(len(self.runner.journal.records(self.snapshot)), 1)
self.assertEqual(self.paths().count("stageService/stageStart"), 1)
def test_commission_farming_sweep_keeps_source_and_single_entry_during_resume(self):
self.action.update(kind="progression_farm_sweep", task_id=0, task_type_id="", step_number=0,
source_task_id=51, source_task_type_id="400", source_step_number=1)
self.snapshot.raw["currentTasks"] = [{"id": 51, "typeId": "400", "curStep": 1}]
cancel = threading.Event()
def complete(request, *, cancel_event):
result = self.runtime._run(request, cancel_event=cancel_event)
cancel_event.set()
return result
self.runtime.run.side_effect = complete
self.run_sweep(cancel)
self.restart()
record = self.runner.pending(self.snapshot)
self.assertEqual((record["kind"], record["source_task_id"], record["source_task_type_id"]),
("progression_farm_sweep", 51, "400"))
self.runner.continue_sweep(self.client, self.snapshot, policy(enabled=False, battle_mode="experimental"))
self.assertEqual(len(self.paths()), 1)
self.runner.continue_sweep(self.client, self.snapshot, self.chosen)
self.assertEqual(self.runtime.run.call_count, 1)
self.assertEqual(self.paths(), ["stageService/stageStart", "battleService/battleEnd", "battleService/recordBattleResult"])
self.assertEqual(sum(self.sweeper.state["counts"].values()), 1)
self.assertEqual(self.sweeper.statistics.snapshot(7)["totals"]["0102:1:sweep"]["n"], 1)
self.assertEqual(self.runner.journal.role(self.snapshot)["losses"], 0)
if __name__ == "__main__":
unittest.main()
@@ -0,0 +1,331 @@
"""Account-worker sweep recovery, with local files and mocked transport only."""
from copy import deepcopy
import json
import threading
import unittest
from unittest.mock import Mock, patch
from ranch_assistant.api import Session
from ranch_assistant.engine import Engine
from ranch_assistant.game_data import ProgressionData
from ranch_assistant.model import Policy, Snapshot
from ranch_assistant.sessions import identity
from ranch_assistant.sweeping import SweepPolicy
from ranch_assistant.maps import stages
from ranch_assistant.tests.test_activities import scenario
from ranch_assistant.tests.test_battle_orchestration import ExperimentalRuntime
from ranch_assistant.tests.test_core import workspace_temp
class HiddenSweepEngineTests(unittest.TestCase):
def setUp(self):
self.folder = self.enterContext(workspace_temp())
self.catalog, self.snapshot = scenario()
self.raw = deepcopy(self.snapshot.raw)
self.raw["master"].update(id=7, ti=100, timeTi=0)
self.raw["currentTasks"] = []
self.session = Session(account_id="offline", role_id=7, server_id=1)
self.root = self.folder / "roles" / identity(self.session)
self.trace = self.folder / "network_debug.jsonl"
self.client = Mock()
self.client.session = self.session
self.client.trace = Mock(path=self.trace, events=[])
self.client.snapshot.side_effect = lambda: Snapshot(deepcopy(self.raw))
self.runtime = ExperimentalRuntime()
data = {"stage_info": deepcopy(self.catalog.data["stage_info"]), "game_setting": self.catalog.data["game_setting"],
"task_info": {}, "stage_battles": {}}
data["stage_info"]["0102"]["level"]["1"]["battle"] = {"fixture_hidden": True}
self.engine = Engine(self.catalog, self.client, self.root / "purchase.json",
game_data=ProgressionData(data), experimental_runtime=self.runtime)
self.engine.policy = Policy(enabled=False, gift_enabled=False, fill=False)
self.engine.progression_policy.enabled = False
self.engine.sweep_policy = SweepPolicy(True, {"0101": {"enabled": True, "level": "3", "limit": 3}}, allow_challenge=False)
self.engine.master_sync.settle = Mock()
self.engine.snapshot = Snapshot(deepcopy(self.raw))
def legacy(self, phase="遭遇隐藏关卡,请在游戏内手动战斗"):
pending = {"stage": "0101", "level": "3", "phase": phase, "sampleId": "legacy-entry"}
self.engine.sweeper.state = {"counts": {"7:2026-11-13:0101:3": 1}, "pending": pending}
self.engine.sweeper.save()
events = [{"kind": "response", "operation": "读取角色", "http_status": 200,
"body": {"resCode": 0, "master": {"id": 7}}}]
self.trace.write_text("\n".join(json.dumps(row) for row in events) + "\n", encoding="utf-8")
return deepcopy(pending)
def test_exact_legacy_missing_id_is_archived_after_trusted_read_without_reward_or_write(self):
original = self.legacy()
self.engine.sweep_policy.enabled = False
self.engine.cancel_progression()
self.engine.read_snapshot(sync_master=False)
self.assertIsNone(self.engine.sweeper.state["pending"])
record = self.engine.battle_journal.records(self.engine.snapshot)[0]
self.assertEqual(record["outcome"], "abandoned_missing_hidden_id")
self.assertEqual(record["sweep_entry"], original)
self.assertIn("旧版未保存隐藏关卡编号,本次未完成已放弃;未结算奖励", record["message"])
self.assertEqual(self.engine.sweeper.state["counts"], {"7:2026-11-13:0101:3": 1})
self.client.call.assert_not_called()
self.assertEqual(self.engine.sweeper.statistics.snapshot(7)["totals"], {})
self.engine.read_snapshot(sync_master=False)
self.assertEqual(len(self.engine.battle_journal.records(self.engine.snapshot)), 1)
def test_legacy_archive_accepts_exact_local_login_info_then_role_read_and_heartbeat(self):
original = self.legacy()
events = [{"kind": "info", "operation": "进入参数检查", "scope": "local",
"sign_date": "20261114", "date_format": "yyyyMMdd", "signature_rule": "2|2|1|2|3",
"tj_channel": "unknow", "platform": "ANDROID", "channel": "DYD", "uid_length": 7, "token_length": 16},
{"kind": "response", "operation": "读取角色", "http_status": 200,
"body": {"resCode": 0, "master": {"id": 7}}},
{"kind": "request", "operation": "heartBeatService/keepAlive", "request_id": "heartbeat", "body": {}},
{"kind": "response", "operation": "heartBeatService/keepAlive", "request_id": "heartbeat",
"http_status": 200, "body": {"resCode": 0}}]
self.trace.write_text("\n".join(json.dumps(row) for row in events) + "\n", encoding="utf-8")
self.engine.read_snapshot(sync_master=False)
self.assertIsNone(self.engine.sweeper.state["pending"])
record = self.engine.battle_journal.records(self.engine.snapshot)[0]
self.assertEqual(record["outcome"], "abandoned_missing_hidden_id")
self.assertEqual(record["sweep_entry"], original)
self.assertEqual(self.engine.sweeper.state["counts"], {"7:2026-11-13:0101:3": 1})
self.assertTrue(next(iter(self.engine._sweep_recovery_cache.values()))["valid"])
self.client.call.assert_not_called()
self.runtime.run.assert_not_called()
self.assertEqual(self.engine.sweeper.statistics.snapshot(7)["totals"], {})
def test_unknown_info_or_login_info_without_local_scope_blocks_legacy_archive(self):
for info in ({"kind": "info", "operation": "未知信息", "scope": "local"},
{"kind": "info", "operation": "进入参数检查", "scope": "network"},
{"kind": "info", "operation": "进入参数检查"}):
with self.subTest(info=info):
original = self.legacy()
self.engine._sweep_recovery_cache.clear()
events = [info, {"kind": "response", "operation": "读取角色", "http_status": 200,
"body": {"resCode": 0, "master": {"id": 7}}}]
self.trace.write_text("\n".join(json.dumps(row) for row in events) + "\n", encoding="utf-8")
self.engine.read_snapshot(sync_master=False)
self.assertEqual(self.engine.sweeper.state["pending"], original)
self.assertFalse(next(iter(self.engine._sweep_recovery_cache.values()))["valid"])
self.assertEqual(self.engine.battle_journal.records(self.engine.snapshot), [])
self.client.call.assert_not_called()
self.runtime.run.assert_not_called()
def test_uncertain_phases_are_never_archived(self):
for phase in ("开始请求待确认", "扫荡结算待确认", "start_pending", "settlement_pending"):
original = self.legacy(phase)
self.engine.read_snapshot(sync_master=False)
self.assertEqual(self.engine.sweeper.state["pending"], original)
self.client.call.assert_not_called()
def test_archive_requires_role_path_binding_and_fresh_read(self):
original = self.legacy()
self.engine.sweeper.path = self.folder / "other" / "sweep_runs.json"
self.engine.read_snapshot(sync_master=False)
self.assertEqual(self.engine.sweeper.state["pending"], original)
self.client.snapshot.side_effect = TimeoutError("offline read failed")
with self.assertRaises(TimeoutError):
self.engine.read_snapshot(sync_master=False)
self.assertEqual(self.engine.sweeper.state["pending"], original)
def test_later_consumption_or_conflicting_journal_blocks_archive(self):
original = self.legacy()
with self.trace.open("a", encoding="utf-8") as stream:
stream.write(json.dumps({"kind": "request", "operation": "battleService/battleEnd",
"request_id": "later", "body": {"battleData": {}}}) + "\n")
self.engine.read_snapshot(sync_master=False)
self.assertEqual(self.engine.sweeper.state["pending"], original)
self.legacy()
self.engine.battle_journal.begin(self.engine.snapshot, {"kind": "battle", "stage_id": "0102", "difficulty": "1"})
self.engine.read_snapshot(sync_master=False)
self.assertEqual(self.engine.sweeper.state["pending"], original)
self.client.call.assert_not_called()
def test_map_sweep_origin_uses_enabled_sweep_with_challenges_disabled(self):
self.assertTrue(self.engine._intent_policy({"kind": "map_sweep"}).enabled)
self.engine.sweep_policy.enabled = False
self.assertFalse(self.engine._intent_policy({"kind": "map_sweep"}).enabled)
def test_commission_farming_origin_uses_quest_policy(self):
self.engine.game_data.tasks["400"] = {"type": 4}
self.engine.quest_policy.enabled = True
origin = {"kind": "progression_farm_sweep", "source_task_type_id": "400"}
self.assertTrue(self.engine._intent_policy(origin).enabled)
self.engine.quest_policy.enabled = False
self.engine.progression_policy.enabled = True
self.assertFalse(self.engine._intent_policy(origin).enabled)
def prepare_hidden(self):
response = {"resCode": 0, "triggerEvent": True, "stageEvent": {"hideStageId": "0102", "result": {"money": 999}}}
self.client.call.side_effect = lambda path, payload: deepcopy(response) if path.endswith("stageStart") else {
"resCode": 0, "reward": {"money": 17}}
stage = next(s for s in stages(self.catalog, self.engine.snapshot) if s.stage_id == "0101" and s.level == "3")
self.engine.sweeper.run(self.client, self.engine.snapshot, stage, self.engine.sweep_policy,
origin={"kind": "map_sweep", "stage_id": "0101", "difficulty": "3", "battle_kind": "sweep", "battle_mode": "experimental"})
self.engine.read_snapshot(sync_master=False)
def test_worker_migrates_before_web_start_and_resumes_without_challenge_or_mainline(self):
self.prepare_hidden()
self.assertIsNone(self.engine.sweeper.state["pending"])
self.assertEqual(self.engine.pending_battle_recovery()["state"], "prepare_hidden_sweep")
self.engine.poll(resume_pending=True)
self.assertFalse(self.engine.auto)
self.assertIsNone(self.engine.battle_journal.pending(self.engine.snapshot))
self.assertEqual([call.args[0] for call in self.client.call.call_args_list], [
"stageService/stageStart", "battleService/battleEnd", "battleService/recordBattleResult"])
request = self.runtime.run.call_args.args[0]
self.assertEqual((request["stage_id"], request["difficulty"]), ("0102", "1"))
self.assertEqual(request["roster"]["teams"][0]["monsters"], [900, 0])
self.assertEqual(sum(self.engine.sweeper.state["counts"].values()), 1)
totals = self.engine.sweeper.statistics.snapshot(7)["totals"]
self.assertEqual(totals["0102:1:sweep"]["n"], 1)
self.assertNotIn("0101:3:sweep", totals)
def test_stop_disabled_source_and_stale_generation_do_not_resume_consumption(self):
self.prepare_hidden()
self.engine.cancel_progression()
self.engine.poll(resume_pending=False)
self.engine.sweep_policy.enabled = False
self.assertEqual(self.engine.pending_battle_recovery()["state"], "blocked_policy")
self.engine.poll(resume_pending=True)
self.engine.sweep_policy.enabled = True
self.assertEqual(self.engine._resume_pending_task_clock(running=True,
generation=self.engine._progression_cancel_generation - 1), "")
self.runtime.run.assert_not_called()
self.assertEqual(self.client.call.call_count, 1)
self.engine.poll(resume_pending=True)
self.assertEqual(self.client.call.call_count, 3)
def test_legacy_scan_is_cached_and_never_runs_in_recovery_presentation(self):
self.legacy()
with patch("ranch_assistant.sweep_recovery.scan_trace", wraps=__import__(
"ranch_assistant.sweep_recovery", fromlist=["scan_trace"]).scan_trace) as scan:
for _ in range(3):
self.engine.pending_battle_recovery()
self.assertEqual(scan.call_count, 0)
self.engine.read_snapshot(sync_master=False)
self.engine.read_snapshot(sync_master=False)
self.assertEqual(scan.call_count, 1)
def test_archive_crash_after_journal_finish_repairs_without_second_record(self):
original = self.legacy()
self.engine.read_snapshot(sync_master=False)
self.engine.sweeper.state["pending"] = original
self.engine.sweeper.save()
self.engine.read_snapshot(sync_master=False)
self.assertIsNone(self.engine.sweeper.state["pending"])
self.assertEqual(len(self.engine.battle_journal.records(self.engine.snapshot)), 1)
self.client.call.assert_not_called()
def test_archive_crash_after_begin_recovers_same_sample_without_generic_prepared_record(self):
original = self.legacy()
begin = self.engine.battle_journal.begin
def crash(*args, **kwargs):
begin(*args, **kwargs)
raise OSError("offline interrupted archive")
self.engine.battle_journal.begin = crash
with self.assertRaises(OSError):
self.engine.read_snapshot(sync_master=False)
self.engine.battle_journal.begin = begin
self.engine.read_snapshot(sync_master=False)
self.assertIsNone(self.engine.sweeper.state["pending"])
records = self.engine.battle_journal.records(self.engine.snapshot)
self.assertEqual(len(records), 1)
self.assertEqual(records[0]["sweep_entry"], original)
self.assertEqual(records[0]["outcome"], "abandoned_missing_hidden_id")
def test_normal_sweep_stop_before_dispatch_archives_but_unknown_dispatch_stays_pending(self):
cancel = threading.Event()
stage = next(s for s in stages(self.catalog, self.engine.snapshot) if s.stage_id == "0101" and s.level == "3")
def start(path, payload):
cancel.set()
return {"resCode": 0, "triggerEvent": False}
self.client.call.side_effect = start
from ranch_assistant.battles import CancelledBeforeDispatch
with self.assertRaises(CancelledBeforeDispatch):
self.engine.sweeper.run(self.client, self.engine.snapshot, stage, self.engine.sweep_policy,
cancel=cancel, origin={"kind": "map_sweep"})
pending = deepcopy(self.engine.sweeper.state["pending"])
self.assertIs(pending["settlement_dispatched"], False)
self.engine.read_snapshot(sync_master=False)
self.assertIsNone(self.engine.sweeper.state["pending"])
self.assertEqual(self.engine.battle_journal.records(self.engine.snapshot)[0]["outcome"], "abandoned_cancelled_sweep")
self.assertEqual(self.client.call.call_count, 1)
for dispatched in (True, None):
unknown = dict(pending, phase="扫荡结算待确认")
unknown.pop("settlement_dispatched")
if dispatched is not None:
unknown["settlement_dispatched"] = dispatched
self.engine.sweeper.state["pending"] = unknown
self.engine.sweeper.save()
self.engine.read_snapshot(sync_master=False)
self.assertEqual(self.engine.sweeper.state["pending"], unknown)
def test_ordinary_automatic_entry_runs_hidden_battle_and_counts_once(self):
self.client.call.side_effect = lambda path, payload=None: {"resCode": 0, "triggerEvent": True,
"stageEvent": {"hideStageId": "0102", "result": {"money": 999}}} if path.endswith("stageStart") else {
"resCode": 0, "reward": {"money": 17}}
self.engine.auto = True
_, _, message = self.engine.poll()
self.assertIn("隐藏关卡", message)
self.assertEqual([call.args[0] for call in self.client.call.call_args_list], [
"stageService/stageStart", "battleService/battleEnd", "battleService/recordBattleResult"])
self.assertEqual(sum(self.engine.sweeper.state["counts"].values()), 1)
def test_trace_proven_legacy_hidden_id_runs_first_computation_without_new_entry(self):
self.legacy()
original_roster = deepcopy(self.raw)
self.engine.sweeper.state["pending"].update(entry_snapshot=original_roster,
entry_snapshot_now=self.engine.snapshot.now, team="teamA")
self.engine.sweeper.save()
next(mon for mon in self.raw["monsters"] if mon["id"] == 900)["level"] = 999
events = [{"kind": "response", "operation": "读取角色", "http_status": 200,
"body": {"resCode": 0, "master": {"id": 7}}},
{"kind": "request", "operation": "stageService/stageStart", "request_id": "old-start",
"body": {"stageTypeId": "0101", "stageLevel": "3"}},
{"kind": "response", "operation": "stageService/stageStart", "request_id": "old-start", "http_status": 200,
"body": {"resCode": 0, "triggerEvent": True, "stageEvent": {"hideStageId": "0102"}}}]
self.trace.write_text("\n".join(json.dumps(row) for row in events) + "\n", encoding="utf-8")
self.client.call.return_value = {"resCode": 0, "reward": {"money": 17}}
self.engine.read_snapshot(sync_master=False)
self.assertEqual(self.engine.pending_battle_recovery()["state"], "prepare_hidden_sweep")
self.engine.poll(resume_pending=True)
self.assertEqual([call.args[0] for call in self.client.call.call_args_list], [
"battleService/battleEnd", "battleService/recordBattleResult"])
self.assertEqual(self.engine.sweeper.state["counts"], {"7:2026-11-13:0101:3": 1})
saved = self.engine.battle_journal.records(self.engine.snapshot)[0]["sweep_entry"]
self.assertEqual(saved["entry_snapshot"], original_roster)
runtime_roster = self.runtime.run.call_args.args[0]["roster"]
self.assertEqual(next(mon for mon in runtime_roster["monsters"] if mon["id"] == 900)["level"], 20)
def test_legacy_hidden_id_without_original_inputs_blocks_changed_current_roster(self):
self.legacy()
next(mon for mon in self.raw["monsters"] if mon["id"] == 900)["level"] = 999
events = [{"kind": "response", "operation": "读取角色", "http_status": 200,
"body": {"resCode": 0, "master": {"id": 7}}},
{"kind": "request", "operation": "stageService/stageStart", "request_id": "old-start",
"body": {"stageTypeId": "0101", "stageLevel": "3"}},
{"kind": "response", "operation": "stageService/stageStart", "request_id": "old-start", "http_status": 200,
"body": {"resCode": 0, "triggerEvent": True, "stageEvent": {"hideStageId": "0102"}}}]
self.trace.write_text("\n".join(json.dumps(row) for row in events) + "\n", encoding="utf-8")
self.engine.read_snapshot(sync_master=False)
record = self.engine.battle_journal.pending(self.engine.snapshot)
self.assertEqual(record["stage_id"], "0102")
self.assertEqual(record["sweep_sample_id"], "legacy-entry")
self.assertNotIn("entry_snapshot", record["sweep_entry"])
self.assertNotIn("entry_snapshot_now", record["sweep_entry"])
self.assertNotIn("input_evidence", record["sweep_entry"])
self.assertNotIn("combat_request", record)
self.assertNotIn("combat_request_digest", record)
recovery = self.engine.pending_battle_recovery()
self.assertEqual(recovery["state"], "blocked")
self.assertFalse(recovery["resumable"])
self.assertIn("缺少原始战斗输入", recovery["message"])
for _ in range(2):
self.engine.poll(resume_pending=True)
self.runtime.inspect.assert_not_called()
self.runtime.run.assert_not_called()
self.client.call.assert_not_called()
self.assertEqual(self.engine.sweeper.state["counts"], {"7:2026-11-13:0101:3": 1})
self.assertEqual(self.engine.sweeper.statistics.snapshot(7)["totals"], {})
self.assertEqual(self.engine.battle_journal.pending(self.engine.snapshot), record)
if __name__ == "__main__":
unittest.main()
@@ -0,0 +1,322 @@
"""Offline coverage for the durable sweep-to-hidden-battle handoff."""
from copy import deepcopy
import json
from pathlib import Path
from tempfile import TemporaryDirectory
from threading import Event
from types import SimpleNamespace
import unittest
from unittest.mock import Mock
from ranch_assistant.battles import CancelledBeforeDispatch
from ranch_assistant.sweeping import SweepPolicy, SweepRunner, hidden_stage_id
class HiddenSweepHandoffTests(unittest.TestCase):
def setUp(self):
self.temp = TemporaryDirectory()
self.addCleanup(self.temp.cleanup)
self.folder = Path(self.temp.name)
self.catalog = SimpleNamespace(data={})
self.snapshot = SimpleNamespace(now=1794618000, monsters={9: {}}, raw={
"master": {"id": 17, "sessionKey": "never-save"},
"teams": [{"teamName": "teamA", "teamType": "battleTeam", "monsters": [9]}],
"nested": {"token": "never-save", "safe": 1}})
self.stage = SimpleNamespace(stage_id="0101", level="3")
self.policy = SweepPolicy(True, {"0101": {"enabled": True, "level": "3", "limit": 4}})
self.runner = SweepRunner(self.catalog, self.folder / "sweeps.json")
self.runner.reason = Mock(return_value="")
self.response = {"resCode": 0, "triggerEvent": True, "stageEvent": {
"hideStageId": "00109", "costTi": 16, "result": {"money": 999}}}
self.client = Mock()
self.client.call.return_value = self.response
def test_hidden_handoff_counts_once_without_settlement_or_reward(self):
result = self.runner.run(self.client, self.snapshot, self.stage, self.policy, origin={"kind": "map_sweep"})
self.assertIs(result, self.response)
self.client.call.assert_called_once_with("stageService/stageStart", {
"stageTypeId": "0101", "stageLevel": "3"})
self.assertEqual(self.runner.used(self.snapshot, self.stage), 1)
self.assertEqual(self.runner.last_outcome, "hidden")
self.assertIsNone(self.runner.last_reward)
self.assertEqual(self.runner.statistics.snapshot(17)["totals"], {})
pending = self.runner.state["pending"]
self.assertEqual((pending["phase"], pending["hidden_stage_id"]), ("hidden_started", "00109"))
def test_restart_has_sanitized_entry_and_trusted_start_evidence(self):
self.response["sessionKey"] = "never-save"
self.runner.run(self.client, self.snapshot, self.stage, self.policy,
origin={"kind": "sweep", "secret": "never-save"})
restored = SweepRunner(self.catalog, self.runner.path)
pending = restored.state["pending"]
self.assertEqual(pending["role_id"], "17")
self.assertEqual((pending["stage"], pending["level"], pending["team"]), ("0101", "3", "teamA"))
self.assertEqual(pending["counts_key"], self.runner.key(self.snapshot, self.stage))
self.assertTrue(pending["sampleId"])
self.assertEqual(pending["entry_snapshot_now"], self.snapshot.now)
self.assertEqual(pending["entry_snapshot"]["nested"], {"safe": 1})
self.assertEqual(pending["origin"], {"kind": "sweep"})
self.assertEqual(pending["start_path"], "stageService/stageStart")
self.assertTrue(pending["start_dispatched"])
self.assertTrue(pending["start_confirmed"])
self.assertGreater(pending["start_confirmed_at"], 0)
self.assertNotIn("sessionKey", pending["start_response"])
self.assertNotIn("never-save", restored.path.read_text(encoding="utf-8"))
def test_hidden_ids_and_trigger_require_exact_protocol_types(self):
for identifier, expected in (("00109", "00109"), (109, "109"), (" hidden ", " hidden "),
(None, None), ("", None), (" ", None), (0, None), (-1, None),
(True, None), (1.0, None), ({}, None), ([], None)):
with self.subTest(identifier=identifier):
response = dict(self.response, stageEvent={"hideStageId": identifier})
self.assertEqual(hidden_stage_id(response), expected)
for flag in (False, 0, "1", 1.0, None):
self.assertIsNone(hidden_stage_id(dict(self.response, triggerEvent=flag)))
self.assertEqual(hidden_stage_id(dict(self.response, triggerEvent=1)), "00109")
def test_ordinary_and_settled_event_paths_still_complete(self):
self.client.call.side_effect = [{"resCode": 0, "triggerEvent": False},
{"resCode": 0, "reward": {"money": 1}}, {"resCode": 0}]
self.runner.run(self.client, self.snapshot, self.stage, self.policy)
self.assertEqual([call.args[0] for call in self.client.call.call_args_list], [
"stageService/stageStart", "battleService/battleEnd", "battleService/recordBattleResult"])
self.assertEqual(self.runner.last_outcome, "sweep")
self.assertIsNone(self.runner.state["pending"])
self.client.reset_mock(side_effect=True)
self.client.call.return_value = {"resCode": 0, "triggerEvent": True,
"stageEvent": {"hideStageId": None, "result": {"money": 2}}}
self.runner.run(self.client, self.snapshot, self.stage, self.policy)
self.assertEqual(self.client.call.call_count, 1)
self.assertEqual(self.runner.last_outcome, "event")
self.assertIsNone(self.runner.state["pending"])
self.assertEqual(self.runner.used(self.snapshot, self.stage), 2)
def test_timeout_preserves_dispatched_pending_and_cannot_reenter(self):
self.client.call.side_effect = TimeoutError("entry not confirmed")
with self.assertRaises(TimeoutError):
self.runner.run(self.client, self.snapshot, self.stage, self.policy)
restored = SweepRunner(self.catalog, self.runner.path)
self.assertTrue(restored.state["pending"]["start_dispatched"])
self.assertFalse(restored.state["pending"]["start_confirmed"])
self.assertNotIn("start_response", restored.state["pending"])
with self.assertRaises(ValueError):
restored.run(self.client, self.snapshot, self.stage, self.policy)
self.assertEqual(self.client.call.call_count, 1)
def test_malformed_and_unsuccessful_start_keeps_pending(self):
for response in (None, [], {}, {"resCode": False, "triggerEvent": False},
{"resCode": 9, "triggerEvent": False}, {"resCode": 0, "triggerEvent": "1"},
{"resCode": 0, "triggerEvent": True, "stageEvent": {"hideStageId": []}}):
with self.subTest(response=response):
self.runner.state = {"counts": {}, "pending": None}
self.client.reset_mock()
self.client.call.return_value = response
with self.assertRaises(ValueError):
self.runner.run(self.client, self.snapshot, self.stage, self.policy)
self.assertIsNotNone(SweepRunner(self.catalog, self.runner.path).state["pending"])
self.assertEqual(self.runner.used(self.snapshot, self.stage), 1)
self.assertEqual(self.client.call.call_count, 1)
def test_cancel_after_reservation_rolls_back_only_unissued_entry(self):
cancel = Event()
original_save = self.runner.save
def save_and_stop():
original_save()
cancel.set()
self.runner.save = save_and_stop
before = deepcopy(self.runner.state)
with self.assertRaises(CancelledBeforeDispatch):
self.runner.run(self.client, self.snapshot, self.stage, self.policy, cancel=cancel)
self.client.call.assert_not_called()
self.assertEqual(self.runner.state, before)
self.assertEqual(SweepRunner(self.catalog, self.runner.path).state, before)
def test_cancel_after_start_preserves_pending_without_settlement(self):
cancel = Event()
def start(*args):
cancel.set()
return {"resCode": 0, "triggerEvent": False}
self.client.call.side_effect = start
with self.assertRaises(CancelledBeforeDispatch):
self.runner.run(self.client, self.snapshot, self.stage, self.policy, cancel=cancel)
self.assertEqual(self.client.call.call_count, 1)
self.assertTrue(self.runner.state["pending"]["start_confirmed"])
self.assertEqual(self.runner.used(self.snapshot, self.stage), 1)
def test_cancel_at_dispatch_boundary_restores_existing_quota(self):
key = self.runner.key(self.snapshot, self.stage)
self.runner.state["counts"][key] = 2
before = deepcopy(self.runner.state)
cancel = Event()
original_save = self.runner.save
def save_and_stop():
original_save()
if (self.runner.state.get("pending") or {}).get("start_dispatched"):
cancel.set()
self.runner.save = save_and_stop
with self.assertRaises(CancelledBeforeDispatch):
self.runner.run(self.client, self.snapshot, self.stage, self.policy, cancel=cancel)
self.client.call.assert_not_called()
self.assertEqual(self.runner.state, before)
def test_stop_at_settlement_boundary_keeps_entry_reserved(self):
cancel = Event()
self.client.call.return_value = {"resCode": 0, "triggerEvent": False}
original_save = self.runner.save
def save_and_stop():
original_save()
if self.runner.state["pending"]["phase"] == "扫荡结算待确认":
cancel.set()
self.runner.save = save_and_stop
with self.assertRaises(CancelledBeforeDispatch):
self.runner.run(self.client, self.snapshot, self.stage, self.policy, cancel=cancel)
self.assertEqual(self.client.call.call_count, 1)
self.assertEqual(self.runner.used(self.snapshot, self.stage), 1)
def test_invalid_or_failed_settlement_remains_pending(self):
for result in (None, [], {}, {"resCode": 7}):
with self.subTest(result=result):
self.runner.state = {"counts": {}, "pending": None}
self.client.reset_mock()
self.client.call.side_effect = [{"resCode": 0, "triggerEvent": False}, result]
with self.assertRaises(ValueError):
self.runner.run(self.client, self.snapshot, self.stage, self.policy)
self.assertIsNotNone(self.runner.state["pending"])
self.assertEqual(self.client.call.call_count, 2)
def trace_rows(self):
return [{"kind": "response", "operation": "读取角色", "body": {"master": {"id": 17}}},
{"kind": "request", "operation": "stageService/stageStart", "request_id": "start-1",
"body": {"stageTypeId": "0101", "stageLevel": "3"}},
{"kind": "response", "operation": "stageService/stageStart", "request_id": "start-1",
"http_status": 200, "time": "2026-11-14T09:00:00+08:00", "body": deepcopy(self.response)}]
def legacy_pending(self, phase="遭遇隐藏关卡,请在游戏内手动战斗"):
self.runner.state = {"counts": {self.runner.key(self.snapshot, self.stage): 1}, "pending": {
"stage": "0101", "level": "3", "phase": phase, "sampleId": "old"}}
self.runner.save()
def write_trace(self, rows):
trace = self.folder / "network_debug.jsonl"
trace.write_text("\n".join(json.dumps(row) for row in rows), encoding="utf-8")
return trace
def test_valid_rotated_trace_recovers_without_new_write_or_count(self):
self.legacy_pending()
rows = self.trace_rows()
trace = self.write_trace(rows[2:])
trace.with_name("network_debug.previous.jsonl").write_text(
"\n".join(json.dumps(row) for row in rows[:2]), encoding="utf-8")
counts = deepcopy(self.runner.state["counts"])
self.assertTrue(self.runner.recover_hidden_start(self.snapshot, trace))
pending = SweepRunner(self.catalog, self.runner.path).state["pending"]
self.assertEqual((pending["role_id"], pending["hidden_stage_id"]), ("17", "00109"))
self.assertEqual(pending["phase"], "hidden_started")
self.assertEqual(pending["start_request_id"], "start-1")
self.assertTrue(pending["start_confirmed"])
self.assertEqual(pending["start_confirmed_at"], self.snapshot.now)
self.assertEqual(self.runner.state["counts"], counts)
self.assertNotIn("entry_snapshot", pending)
self.assertNotIn("entry_snapshot_now", pending)
self.client.call.assert_not_called()
def test_unknown_entry_and_old_event_phase_can_recover(self):
for phase in ("开始请求待确认", "遇到事件或响应缺少事件状态,请在游戏内处理"):
with self.subTest(phase=phase):
self.legacy_pending(phase)
self.assertTrue(self.runner.recover_hidden_start(self.snapshot, self.write_trace(self.trace_rows())))
def test_only_latest_matching_start_can_supply_recovery_id(self):
self.legacy_pending()
rows = self.trace_rows()
newer = deepcopy(rows[1:])
for row in newer:
row["request_id"] = "latest"
newer[1]["body"]["stageEvent"]["hideStageId"] = "new-hidden"
self.assertTrue(self.runner.recover_hidden_start(self.snapshot, self.write_trace(rows + newer)))
self.assertEqual(self.runner.state["pending"]["hidden_stage_id"], "new-hidden")
self.assertEqual(self.runner.state["pending"]["start_request_id"], "latest")
def test_bound_pending_role_must_match_snapshot(self):
self.legacy_pending()
self.runner.state["pending"]["role_id"] = "18"
before = deepcopy(self.runner.state)
self.assertFalse(self.runner.recover_hidden_start(self.snapshot, self.write_trace(self.trace_rows())))
self.assertEqual(self.runner.state, before)
def test_nonlegacy_or_persisted_unknown_response_is_not_recovered(self):
for phase in ("hidden_started", "扫荡结算待确认", "开始请求待确认"):
with self.subTest(phase=phase):
self.legacy_pending(phase)
if phase == "开始请求待确认":
self.runner.state["pending"]["start_response"] = {}
before = deepcopy(self.runner.state)
self.assertFalse(self.runner.recover_hidden_start(self.snapshot, self.write_trace(self.trace_rows())))
self.assertEqual(self.runner.state, before)
def test_subsequent_combat_and_task_writes_always_prevent_recovery(self):
for operation in ("stageService/stageStart", "battleService/battleStart", "battleService/battleEnd",
"battleService/recordBattleResult", "taskService/taskCompleteStep"):
with self.subTest(operation=operation):
self.legacy_pending()
rows = self.trace_rows() + [{"kind": "request", "operation": operation,
"request_id": "later", "body": {}}]
before = deepcopy(self.runner.state)
self.assertFalse(self.runner.recover_hidden_start(self.snapshot, self.write_trace(rows)))
self.assertEqual(self.runner.state, before)
def test_insufficient_trace_proof_never_mutates_journal(self):
for problem in ("role", "request_id", "later_settlement", "uncertain_write", "ambiguous_owner",
"second_reservation", "role_switch", "missing_role", "failed_http", "failed_code",
"wrong_level", "duplicate_response", "newer_unknown_start", "corrupt", "duplicate_field",
"invalid_reservation", "corrupt_other_owner_reservation"):
with self.subTest(problem=problem):
self.legacy_pending()
rows = self.trace_rows()
if problem == "role":
rows[0]["body"]["master"]["id"] = 18
elif problem == "request_id":
rows[2]["request_id"] = "different"
elif problem in ("later_settlement", "uncertain_write"):
rows.append({"kind": "request", "request_id": "later", "body": {}, "operation":
"battleService/battleEnd" if problem == "later_settlement" else "unknownService/doSomething"})
elif problem == "ambiguous_owner":
self.runner.state["counts"][self.runner.key(self.snapshot, self.stage).replace("17:", "18:", 1)] = 1
elif problem == "second_reservation":
self.runner.state["counts"]["17:2026-11-13:0101:3"] = 1
elif problem == "invalid_reservation":
self.runner.state["counts"] = {"17:invalid:0101:3": 1}
elif problem == "corrupt_other_owner_reservation":
self.runner.state["counts"]["18:2026-11-14:0101:3"] = "1"
elif problem == "role_switch":
rows.insert(2, {"kind": "response", "operation": "读取角色", "body": {"master": {"id": 18}}})
elif problem == "missing_role":
rows.pop(0)
elif problem == "failed_http":
rows[2]["http_status"] = 500
elif problem == "failed_code":
rows[2]["body"]["resCode"] = 2
elif problem == "wrong_level":
rows[1]["body"]["stageLevel"] = "1"
elif problem == "duplicate_response":
rows.append(deepcopy(rows[2]))
rows[-1]["body"]["stageEvent"]["hideStageId"] = "another"
elif problem == "newer_unknown_start":
rows.append(dict(rows[1], request_id="newer"))
self.runner.save()
before = deepcopy(self.runner.state)
disk = self.runner.path.read_bytes()
trace = self.write_trace(rows)
if problem == "corrupt":
with trace.open("a", encoding="utf-8") as stream:
stream.write("\n{broken")
elif problem == "duplicate_field":
trace.write_text(trace.read_text(encoding="utf-8").replace(
'"request_id": "start-1"', '"request_id": "other", "request_id": "start-1"'), encoding="utf-8")
self.assertFalse(self.runner.recover_hidden_start(self.snapshot, trace))
self.assertEqual(self.runner.state, before)
self.assertEqual(self.runner.path.read_bytes(), disk)
if __name__ == "__main__":
unittest.main()
+11 -5
View File
@@ -1,10 +1,10 @@
# 牧羊人之心牧场助手 · Web 2.0.11
# 牧羊人之心牧场助手 · Web 2.0.12
## 产品约束
把现有桌面助手的功能和操作结构迁移至单管理员 Web 工作台。桌面版是页面顺序、信息密度、业务名称、保护条件与交互的依据,保留桌面兼容。Web `2.0.11`,源码发布入口 `main`,游戏数据版本 `1.9.68`;桌面正式版保留 `1.2.0`。启动与配置见 [运行说明](README.md),Docker 与更新条件见 [部署说明](../deploy/web/README.md),既有功能与历史验证见 [2.0.8 发布说明](../analysis/RELEASE_2_0_8.md)。
把现有桌面助手的功能和操作结构迁移至单管理员 Web 工作台。桌面版是页面顺序、信息密度、业务名称、保护条件与交互的依据,保留桌面兼容。Web `2.0.12`,源码发布入口 `main`,游戏数据版本 `1.9.68`;桌面正式版保留 `1.2.0`。启动与配置见 [运行说明](README.md),Docker 与更新条件见 [部署说明](../deploy/web/README.md),既有功能与历史验证见 [2.0.8 发布说明](../analysis/RELEASE_2_0_8.md)。
2.0.11 聚焦战斗输入传输、中断恢复、启停意愿与能力状态纠正;保留账号简短状态、错误、表格、表单与原单一底部分类日志,见 [本版发布说明](../analysis/RELEASE_2_0_11.md)。
2.0.12 聚焦扫荡隐藏事件的自动战斗接续与旧缺失响应记录的本地归档;保留账号简短状态、错误、表格、表单与原单一底部分类日志,见 [本版发布说明](../analysis/RELEASE_2_0_12.md)。
使用者在 Windows 本机配置、验证,随后可在 Linux Docker 常驻运行。多个浏览器访问同一个管理员工作台;账号互相隔离,各账号串行执行,账号之间可以并行。
@@ -28,7 +28,13 @@
- 帮助可检查 GitHub 正式版本并提交受控更新请求。未配置部署器时明确显示原因,更新提交不表示更新成功。
- 已在 2.0.1 完成私有仓库和 GHCR 认证的部署,稳定 Release 与正式镜像发布后,可直接通过“帮助 → 检查版本更新…”升级,无需先安装 2.0.2、重复初始化或替换宿主机更新器;升级完成后刷新网页以加载新版界面,安装结果以宿主机健康检查为准。
## 2.0.11 本轮范围
## 2.0.12 本轮范围
- 完整入场响应与原始队伍快照等原始输入均已保存且可验证时,隐藏事件才按 `stageEvent.hideStageId` 直接构建隐藏关卡难度1的战斗,关闭扫荡并自动战斗,无需手动确认,不再发送第二次 `stageStart`;`battleEnd` / `recordBattleResult` 使用隐藏 ID。
- 新记录或可恢复旧记录仅在完整入场及原始输入可验证时自动续打,保留用户停止、来源策略及未知已发送请求的核对约束。旧记录即使能从 trace 找回隐藏 ID,缺少原始队伍也保留中文待核对状态,不用当前属性替代原始属性,不发送游戏写请求。
- 现场旧 `0211 / 3` pending 的原始响应已被日志轮转覆盖,隐藏 ID 无法还原。仅对符合精确四字段 legacy 形态、严格确认已入场且未结算的这类旧阶段,保留证据,本地归档为未完成并放弃,不提交胜负、不重发入场,让后续策略继续。归档不表示服务端已结算,本版未在生产打通当前这场战斗。
## 2.0.11 沿用修复
- Linux 战斗子进程从匿名临时文件一次读取完整 stdin,保留取消、超时及输入大小检查。
- 升级后,旧委托备料记录若已确认入场、未发送结算且符合技术失败条件,按原客户端协议记录失败并退出一次;兼容来源任务与步骤均为0的记录,不重新入场或提交胜利。
@@ -91,7 +97,7 @@
## 安全与验证
2.0.11 后端、模型与更新器共 **550 项唯一测试:548 通过、2 项 Windows 预期跳过**;另有 **14 项全新浏览器测试全部通过**,8组独立探针复核通过。范围见 [本版发布说明](../analysis/RELEASE_2_0_11.md#验证);战斗模型仍为近似实现。
本版共 **491 项唯一仓库测试:489 通过、2 项 Windows 预期跳过,0 失败 / 错误**,见 [2.0.12 发布说明](../analysis/RELEASE_2_0_12.md#验证)。2.0.11 的测试结果见 [历史发布说明](../analysis/RELEASE_2_0_11.md#验证),不计入本版;战斗模型仍为近似实现。
2.0.9 的历史验证见 [历史发布说明](../analysis/RELEASE_2_0_9.md#验证),不计入本版。
+5 -5
View File
@@ -1,8 +1,8 @@
# Web 2.0.11 运行说明
# Web 2.0.12 运行说明
Web **2.0.11**,源码发布入口 `main`,游戏资料基线 **1.9.68**。桌面正式版保留 **1.2.0**,入口为 `python -m ranch_assistant`;Web 使用独立依赖与数据根。自动委托提供当前委托与每日记录,功能和历史验证状态见 [2.0.8 发布说明](../analysis/RELEASE_2_0_8.md)。
Web **2.0.12**,源码发布入口 `main`,游戏资料基线 **1.9.68**。桌面正式版保留 **1.2.0**,入口为 `python -m ranch_assistant`;Web 使用独立依赖与数据根。自动委托提供当前委托与每日记录,功能和历史验证状态见 [2.0.8 发布说明](../analysis/RELEASE_2_0_8.md)。
2.0.11 修复 Linux 战斗子进程大输入传输、停止检查及导航能力误报。升级后按保存的入场、原始输入与战果证据恢复:符合条件的旧委托备料技术失败记录退出一次,完整战果续交尚未发送的结果;未知已发送写请求不重放。中文状态明确指出等待原因,详情继续使用原单一底部分类日志,见 [本版发布说明](../analysis/RELEASE_2_0_11.md)。
2.0.12 修复扫荡触发隐藏关卡后的接续:完整入场响应与原始队伍快照等原始输入均已保存且可验证时,新记录或可恢复旧记录才按 `stageEvent.hideStageId` 构建隐藏关卡难度1的战斗,自动战斗且无需手动确认,不再发送第二次 `stageStart`,战后使用隐藏 ID 结算。旧记录即使能从 trace 找回隐藏 ID,缺少原始队伍也保留中文待核对状态,不用当前属性替代原始属性,不发送游戏写请求。现场旧 `0211 / 3` pending 的原始响应已被日志轮转覆盖,隐藏 ID 无法还原;仅对符合精确四字段 legacy 形态、严格确认已入场且未结算的这类旧阶段,保留证据、本地归档为未完成并放弃,不提交胜负或重发入场,让后续策略继续。归档不等于服务端已结算,本版未在生产打通当前这场战斗,见 [本版发布说明](../analysis/RELEASE_2_0_12.md)。
正常执行默认使用现有内置实验运行时入口的快速 HP/DPS 模型,保留现有伤害配置,无需选择新模式;逐帧实现仅供研发。模型按双方属性、血量、每秒伤害、时间与目标估算胜利、战败或超时,仍有机制简化,不保证全部关卡可通关或与客户端结果一致。
@@ -108,11 +108,11 @@ sh start-web.sh --no-browser
Web 检查固定官方 GitHub Releases 的稳定 `v2.x.y`,跳过桌面 1.x、未来 3.x、草稿和预发布。开发版本 `2.0.0.dev1` 可升级至同数字的正式 `v2.0.0`;没有正式 Web 2 发布时明确显示暂无更新。Windows 默认仅检查;Web “更新”按钮仅在宿主机显式启用并有有效只读心跳时可提交 `pending` 请求,安装、备份和回滚由宿主机执行。默认定时检查只通知,自动安装需操作者 opt-in。
已在 **2.0.1** 完成私有仓库和 GHCR 认证的部署,稳定 Release 和正式镜像就绪、宿主机心跳有效后,可直接通过“帮助 → 检查版本更新…”升级 **2.0.11**,无需先安装 2.0.2、重复初始化或替换宿主机更新器。升级完成后刷新网页以加载新版界面,底部日志默认收起。安装结果以宿主机健康检查为准;首次配置仅供尚未初始化的宿主机参考。
已在 **2.0.1** 完成私有仓库和 GHCR 认证的部署,稳定 Release 和正式镜像就绪、宿主机心跳有效后,可直接通过“帮助 → 检查版本更新…”升级 **2.0.12**,无需先安装 2.0.2、重复初始化或替换宿主机更新器。升级完成后刷新网页以加载新版界面,底部日志默认收起。安装结果以宿主机健康检查为准;首次配置仅供尚未初始化的宿主机参考。
## 离线验证
2.0.11 后端、模型与更新器共 **550 项唯一测试:548 通过、2 项 Windows 预期跳过**;另有 **14 项全新浏览器测试全部通过**,8组独立探针复核通过,见 [本版发布说明](../analysis/RELEASE_2_0_11.md#验证)。镜像工作流新增子进程传输、战斗恢复、能力展示、Web 生命周期、恢复契约及状态 API 六个定向模块:
本版共 **491 项唯一仓库测试:489 通过、2 项 Windows 预期跳过,0 失败 / 错误**,见 [2.0.12 发布说明](../analysis/RELEASE_2_0_12.md#验证)。镜像工作流在安装测试依赖后,独立执行隐藏关卡 handoff、battles、engine 三个专用回归模块;通过 `ranch_web/requirements-test.txt` 安装 HTTPX 的修复继续保留。2.0.11 的测试结果见 [历史发布说明](../analysis/RELEASE_2_0_11.md#验证),不计入本版。以下为继续保留的子进程传输、战斗恢复、能力展示、Web 生命周期、恢复契约及状态 API 回归命令:
```console
python -B -m unittest ranch_assistant.tests.test_battle_worker_transport ranch_assistant.tests.test_battle_recovery ranch_assistant.tests.test_battle_capability_presentation ranch_web.tests.test_lifecycle_recovery ranch_web.tests.test_battle_recovery_contract ranch_web.tests.test_status_recovery_api -v
+1 -1
View File
@@ -1,6 +1,6 @@
"""Headless Web workspace for the ranch assistant."""
__version__ = "2.0.11"
__version__ = "2.0.12"
GAME_VERSION = "1.9.68"
__all__ = ["__version__", "GAME_VERSION"]
+2 -2
View File
@@ -415,7 +415,7 @@ async function exportYields(account=current()) {
async function command(name,account=current()) {
try {
if(name==='add-account'||name==='add-demo')return await addAccount(name==='add-demo');
if(name==='about')return dialog('关于牧场助手',el('div',{},el('p',{text:`牧羊人之心牧场助手 Web ${state.meta?.version || '2.0.11'}`}),el('p',{text:`游戏数据版本 ${state.meta?.gameVersion || '1.9.68'}`})),{info:true});
if(name==='about')return dialog('关于牧场助手',el('div',{},el('p',{text:`牧羊人之心牧场助手 Web ${state.meta?.version || '2.0.12'}`}),el('p',{text:`游戏数据版本 ${state.meta?.gameVersion || '1.9.68'}`})),{info:true});
if(name==='updates')return await showUpdates();
if(name==='admin-logout'){hideWorkbench();try{await api.logout();}finally{requireAuth();}return;}
if(!account)throw new Error('请先新增或选择账号。');
@@ -640,7 +640,7 @@ async function bootstrap() {
$('#app').hidden=false;
const [meta,schema]=await Promise.all([api.meta(),api.schema()]);state.meta=meta;state.schema=schema;
if(state.redirecting)return;
$('#app-version').textContent=meta.version || '2.0.11';$('#game-version').textContent=meta.gameVersion || '1.9.68';$('#access-mode').textContent=auth.access_mode==='local'||auth.access_mode==='loopback'?'本机工作台':auth.required?'管理工作台':'本机工作台';
$('#app-version').textContent=meta.version || '2.0.12';$('#game-version').textContent=meta.gameVersion || '1.9.68';$('#access-mode').textContent=auth.access_mode==='local'||auth.access_mode==='loopback'?'本机工作台':auth.required?'管理工作台':'本机工作台';
await syncAccounts();if(state.redirecting)return;state.ready=true;setStatus('工作台已连接');
}catch(failure){if(failure.status===401||$('#app').hidden){requireAuth();return;}if(state.redirecting)return;setStatus(failure.message);$('#page-host').replaceChildren(el('div',{class:'initial-state'},el('p',{text:failure.message}),el('button',{text:'重新连接',onClick:bootstrap})));}
}
+1 -1
View File
@@ -26,7 +26,7 @@
</div></details>
<details class="menu"><summary accesskey="h">帮助<span class="access-key">(H)</span></summary><div class="menu-popup"><button data-command="updates">检查版本更新…</button><button data-command="debug">调试日志</button><button data-command="about">关于…</button></div></details>
</nav>
<span class="window-title">牧羊人之心牧场助手 <span id="app-version">2.0.11</span></span>
<span class="window-title">牧羊人之心牧场助手 <span id="app-version">2.0.12</span></span>
<span id="access-mode" class="muted"></span>
</header>
<div class="account-bar"><div id="account-tabs" class="account-tabs" role="tablist" aria-label="账号"></div><button id="add-account" class="compact" title="新增账号">+ 新增账号</button></div>
+5 -4
View File
@@ -455,15 +455,16 @@ def _gifts(dto, engine, config, query):
CATEGORIES = {"mainline": "主线", "sidequest": "支线", "commission": "委托", "event": "活动(暂不自动)", "bond": "羁绊(暂不自动)", "unknown": "其他 / 未知"}
BATTLE_KINDS = {"mainline": "主线战斗", "sidequest": "支线战斗", "commission": "委托战斗", "battle": "普通战斗", "map_battle": "地图战斗",
"sweep": "扫荡", "map_reward_event": "地图奖励事件", "ordinary_stage": "普通关卡战斗", "resource_stage": "资源关卡战斗", "task_battle": "任务战斗", "task_pass_stage": "任务通关战斗", "unknown": "其他 / 未知"}
BATTLE_ALIASES = {"task": "task_battle", "passStage": "task_pass_stage", "event": "map_reward_event", "reward_event": "map_reward_event", "normal": "battle"}
"sweep": "扫荡", "hidden": "隐藏关卡战斗", "map_reward_event": "地图奖励事件", "ordinary_stage": "普通关卡战斗", "resource_stage": "资源关卡战斗", "task_battle": "任务战斗", "task_pass_stage": "任务通关战斗", "unknown": "其他 / 未知"}
BATTLE_ALIASES = {"task": "task_battle", "passStage": "task_pass_stage", "event": "map_reward_event", "reward_event": "map_reward_event", "normal": "battle", "map_sweep": "sweep"}
STATES = {"available": "可接取", "unaccepted": "未接取", "active": "进行中", "in_progress": "进行中", "ready": "待交付", "completed": "已完成", "complete": "已完成",
"claimed": "已领奖", "received": "进行中", "unlocked": "已解锁 / 待接取", "offered": "待接取", "locked": "未解锁", "finished": "已完成", "ready_to_reward": "待领取任务奖励",
"blocked": "受阻", "unsupported": "暂不支持", "unknown": "未知"}
STATE_ALIASES = {"active": "received", "in_progress": "received", "available": "unlocked", "unaccepted": "unlocked", "offered": "unlocked", "ready": "ready_to_reward",
"completed": "finished", "complete": "finished", "claimed": "finished", "blocked": "received"}
STATE_FILTERS = [("current", "当前(进行中 + 待接取 + 待领奖)"), ("received", "进行中"), ("unlocked", "待接取"), ("ready_to_reward", "待领奖"), ("finished", "已完成"), ("locked", "未解锁"), ("", "全部状态")]
OUTCOMES = {"win": "胜利", "loss": "打不过", "unsupported": "暂不支持", "event": "地图奖励事件", "completed": "已完成", "cancelled": "已取消", "abandoned": "已放弃(本地计算失败)", "timeout": "超时", "unknown": "结果待核对"}
OUTCOMES = {"win": "胜利", "loss": "打不过", "unsupported": "暂不支持", "event": "地图奖励事件", "completed": "已完成", "cancelled": "已取消", "abandoned": "已放弃(本地计算失败)", "timeout": "超时", "unknown": "结果待核对",
"abandoned_missing_hidden_id": "未完成,已放弃", "abandoned_unsettled_sweep": "未完成,已放弃", "cancelled_unsent_sweep": "未完成,已取消"}
CHINA_TIME = timezone(timedelta(hours=8))
@@ -554,7 +555,7 @@ def _battles(dto, engine, config, query):
kind = "map_reward_event"
elif source.get("task_id") and kind == "battle":
kind = "task_battle"
elif source.get("kind") == "sweep":
elif source.get("kind") in ("sweep", "map_sweep") and kind != "hidden":
kind = "sweep"
if selected and selected != kind:
continue