Add v1.2 development quest progression and experimental battle runtime

This commit is contained in:
AttilaNet
2026-11-08 19:29:28 +08:00
parent 79b7672471
commit 0d3e231cde
71 changed files with 14349 additions and 172 deletions
+45 -16
View File
@@ -1,7 +1,7 @@
# 牧羊人之心牧场辅助
原生 PySide6 窗口,使用 Qt 默认控件。双击项目根目录的
`Start_Ranch_Helper.cmd` 启动。当前辅助版本为 **1.1.1**,适配游戏 **1.9.68**。
`Start_Ranch_Helper.cmd` 启动。当前开发版本为 **1.2.0.dev1**,资料基线为游戏 **1.9.68**;最近正式版本为 **1.1.1**。497项常规回归已检查并完成失败项复测,原版运行时最终集成与真实账号验证仍待完成,自动原版开战准入保持关闭。
首次运行请先执行 `python -m pip install -r ranch_assistant/requirements.txt`。
完整功能与版本摘要见[项目README](../README.md)。
@@ -42,7 +42,7 @@
“牧场策略”新增独立开关“保留资质高于牧场同种培养代表的新魔物”,与S/A/B/C、4S及星级保护分别生效。
同种培养代表优先选等级最高者,再依次比较好感、综合成长资质;新魔物的四项成长按各自范围归一化后取平均,严格更高才算提升。
同分不算提升;牧场尚无同种时保留首只,代表资质未同步完整时暂留。已有锁定、队伍及保留种类保护继续生效。
- 统一策略配置:通过主窗口菜单“策略配置”,保存、导入或导出当前账号的全部孵蛋、牧场、喂养、赠礼、委托、每日事务、扫荡及监控间隔设置,包含自定义收益资料。
- 统一策略配置:通过主窗口菜单“策略配置”,保存、导入或导出当前账号的全部孵蛋、牧场、喂养、赠礼、委托、每日事务、扫荡、主线推进、战斗模式及监控间隔设置,包含自定义收益资料。
跨账号按魔物种类匹配喂养和赠礼目标;牧场实例编号不跨账号复制,默认使用有空位的牧场。兼容旧版培养策略文件。
导入保留功能勾选和规则,策略开关保持关闭,核对后手动开启;文件不包含账号、密码、Token、会话或本机路径。
- 自动赠礼:独立页签,在背包勾选可用物品,在牧场勾选目标并设置优先级,再到“自动赠礼”启用。
@@ -64,12 +64,14 @@
密码使用当前 Windows 账户的 DPAPI 加密;可取消勾选移除保存内容。
- 调试窗口:逐条查看请求地址、参数、HTTP 状态、耗时、解密响应和错误阶段,
支持复制/导出,自动保存本地脱敏日志。
- 自动委托:按每日剩余接取次数、解锁城市和库存,接取、推进已满足条件的步骤、
领取奖励;列表显示奖励金币和氪金数量。提交金币、道具、魔物分别受策略限制。战斗步骤等待游戏实际完成。
- 自动主线:查看任务、NPC、位置、需求、对话和下一步,推进已支持的任务链;材料、蛋和击杀缺口可按已知普通地图来源自动收集,能力或条件不足时显示原因。详见下方设置。
- 自动委托:按每日剩余接取次数、解锁城市和库存,接取、推进已支持的步骤、
领取奖励;列表显示奖励金币和氪金数量。提交金币、道具、魔物分别受策略限制。实战步骤已接入任务战斗编排,仍须通过能力检查。
- 自动扫荡:按地区分组,默认折叠显示关卡、难度、掉落及账号解锁/通关记录。
首次读取后按账号/角色保存本地地图缓存,重启、切换页面或普通监控刷新均复用缓存,仅“刷新关卡”(或本页右键刷新)更新列表。
每关可勾选、选择已解锁难度和本日上限;满足游戏原有条件的普通关卡可接口扫荡,
其余请在游戏内手动战斗。
首次挑战由任务与战斗调度按能力检查处理;未支持内容等待用户在游戏内处理。
- 战斗记录:按上下文筛选普通地图、主线、任务与委托战斗、扫荡和地图奖励事件;实验模型结果标明“实验近似”,未知结果保留待核对原因。
- 扫荡奖励:普通扫荡读取 `battleEnd.reward`,奖励事件读取 `stageEvent.result`,日志列出本次实际获得的物品、魔物蛋、金币和经验。
- 数据分析:紧邻“自动扫荡”的独立页签。左侧按地区选择关卡和难度,右侧显示条形图与掉落明细;关卡和可能掉落来自本地静态配置。
可分别查看普通扫荡、奖励事件或合计,显示样本数、出现次数、获得总数量、实测掉落率、每次平均数量及95%区间。
@@ -83,6 +85,36 @@
- 等级与体力:经验达到下一等级门槛时自动请求官方升级结算;按客户端150秒恢复周期请求体力结算并显示服务器返回值。
到期检查独立于随机刷新间隔,在账号后台线程串行执行;未开启消耗类策略时也会同步,退出登录或连接出错后停止。
## v1.2 自动主线与战斗设置
本节对应 **1.2.0.dev1 开发版**。任务调度和界面已实现,原版与实验模式均有局部能力限制;完整集成 QA、实际阵容的原 AIR 输入桥接和真实账号验收尚未完成。
1. 登录或恢复当前角色后,进入“自动主线”,点击“刷新任务 / 预览”。“任务状态”显示类别、步骤、目标位置、需求、下一步和支持状态;选择一行可查看 NPC、对话与阻塞原因。刷新用于同步与预览,不执行任务交付或开战。
2. 打开“推进策略”,选择主线或支线、自动接取、已支持对话和补链选项。需要补齐材料、蛋或击杀时,勾选“自动收集任务材料 / 击杀目标”;来源必须符合当前位置、地图解锁、资源保护及运行时能力。
3. 在“战斗模式(任务 / 委托)”明确选择模式,默认是“原版运行时(以能力检查为准)”。“实验模拟(近似,未完整验证)”需要手动选择;任务和委托共用此模式。选择推进战斗队伍,设置保留体力、单次交付金币上限、物品保留量和连续失败停止次数。物品、魔物交付默认关闭,金币上限默认 0。
4. 委托仍在“自动委托”单独配置启用、接取、城市、交付限制及“也接取需要实战的委托”。“自动主线”中的“委托(仅诊断)”用于查看状态;委托执行遵循“自动委托”的规则。接取前会检查已知后续条件与战斗能力,避免接下当前无法处理的委托。
5. 勾选“启用自动主线策略”,再点击顶部绿色“开启”。修改规则会自动保存并应用;菜单“策略配置”可立即保存、导入或导出当前账号规则,包含任务策略与战斗模式。重启、恢复会话和导入后,顶部策略开关保持关闭,核对后再开启。
6. 在“战斗记录”查看上下文、队伍、胜负和原因;“刷新本地记录”只读取本机记录。点击顶部红色“停止”可取消后续推进和可取消的运行/时钟等待;已经发出的请求仍须等待确认,开战后的未知状态会保留待核对记录。
| 能力 | 当前开发版行为与边界 |
| --- | --- |
| 任务与对话 | 已实现接取、已支持线性对话、满足条件后的交付、领奖、后继接取与任务补链。服务器确认步骤后,才完成后续剧情和本地步骤收尾;本地检查点按账号/角色保存。 |
| 开图与收集 | 随任务目标和地图前置推进,缺少材料、蛋或已识别的成年目标击杀时规划普通地图;可能掉落只用于选择来源,实际库存与击杀仍需结算后刷新。扫荡不计作击杀来源。 |
| 扫荡 | 普通、非特殊、无当前任务截获的关卡,三个难度全部通关后才可扫荡。“允许用扫荡完成已通关目标”受此条件限制;任务专属战斗和任务通关战斗仍走各自任务路线。逐关次数与难度在“自动扫荡”配置。 |
| 地图奖励事件 | 普通地图开始时若已经发放探索奖励,单独记录奖励并刷新;该分支不运行战斗,也不重复提交战斗奖励。隐藏战斗重新检查能力,未知事件保留待处理。 |
| 原版运行时(默认) | 原 AIR 的合成 1-1 已通过原始战斗面板自然完成,读取实际统计与检查,样例 `cheatNum=0`。任意实际阵容桥接仍在完善;当前只允许能力检查确认的范围,尚未验证的开战会被阻止。 |
| 实验模拟(显式选择) | 独立进程使用原始数值资料计算 AP、出场、移动、攻击及技能 3、5、7、9、38 的部分机制,保留轨迹、胜负和异常。物理、随机、时序、装备及其他技能存在近似或遗漏,结果可能与原版不同。 |
任务资料包含 1165 个任务、1178 个关卡、337 个 NPC 和 4269 份脚本;4239 份属于已支持的线性脚本,主线引用中为 718/720。这些是资料与脚本分类数量,不是整条主线通关率。30 份特殊选择等脚本(含 2 份主线)、4 类特殊接取入口、任务1001006第4步的特殊抽蛋钩子尚不支持;活动、羁绊和未知任务类别也不承诺自动推进。
实验模型当前拒绝未支持的控制器、触发器、保护/破坏目标及活动场地区域;未实现的技能与属性效果会在诊断中列出。941/2512 份地图战斗配置和 106/199 份任务内嵌战斗配置通过结构准入,12 场合成阵容地图实验自然胜利;这些数量不证明全部关卡可过、完整原版机制或真实账号验证。原 APK 资料与线上热更新资源的一致性、全部实际角色加成仍需核对。详细机制与遗漏见[实验模型说明](../analysis/V1_2_SIMULATION_IMPLEMENTATION.md),原引擎实验见[运行时说明](../analysis/V1_2_RUNTIME_IMPLEMENTATION.md)。
离线演示和独立实验可以加速计算模型时钟,不预测服务器奖励或任务进度。已接入的实验战斗编排在开战确认后,以真实经过时间补足模型战斗耗时,等待可取消;自然战斗时间耗尽与工作进程超时分别记录。离线计算快不代表可以提前完成在线结算,服务器是否接受结果尚未验证。
看到“待核对”“不支持”或资源不足时,先查看任务详情和战斗记录中的具体原因。请求结果不明时,本账号的牧场、赠礼及任务等冲突写操作会暂停;重启不会清除待核对状态。恢复角色后点击“刷新任务 / 预览”,程序只在新的角色/任务状态足以证明结果时解除阻塞,随后可继续已保存的普通剧情检查点;证据不足时仍等待用户在游戏内核实。不要通过删除记录或反复开启来重发未知请求,策略导入也不能覆盖服务器通关进度或解除未知结算。
任务与战斗记录保存在本账号、区服和角色的本地工作区;规则导出不含凭据、任务执行记录、待核对日志或服务器进度。实现边界、验证记录和接口分流另见[v1.2 实施与阶段交接](../analysis/V1_2_IMPLEMENTATION.md)。
## 连接真实角色
默认未登录,使用本地示例数据。顶部账号页签用于切换账号,菜单“账号 → 新增账号页签”用于登录另一账号。
@@ -247,8 +279,8 @@
未知魔物和不完整资质不会自动派遣或喂养。
- 自定义表:`typeId, sell_money, sell_exp, time_total`(秒),可只提供部分
覆盖列;中文列名“编号、派遣金币、强化经验、孵化秒数”也支持。
- 测试:`python -m unittest discover -s ranch_assistant/tests -v`。
- 209 项本地测试通过,覆盖登录、会话隔离、账号关闭与移除、菜单账号路由、数字框滚轮、地图缓存、请求计数、等级与体力结算、成长同步、孵蛋与补货、同种魔物培养与资质提升保护、批量喂养、派遣、赠礼、统一策略配置、委托、扫荡、奖励统计与体力效率和每日奖励。
- 测试:`python -B -m unittest discover -s ranch_assistant/tests -v`。
- 1.1.1 阶段记录为 209 项本地测试;v1.2 的数据/规划、编排、模型和界面定向验证见[实施验证记录](../analysis/V1_2_IMPLEMENTATION.md#验证记录),完整集成 QA 仍在进行,各组数量不能直接相加作为全量结果。原有回归覆盖登录、会话隔离、账号关闭与移除、菜单账号路由、数字框滚轮、地图缓存、请求计数、等级与体力结算、成长同步、孵蛋与补货、同种魔物培养与资质提升保护、批量喂养、派遣、赠礼、统一策略配置、委托、扫荡、奖励统计与体力效率和每日奖励。
赠礼覆盖手动目标冷却跳过、连续赠礼、独立到期调度、成功响应回写、滞后查询及本地培养筛选不发请求的回归测试;本地策略与页面异常写入调试日志并标记为本地错误。
登录后自动刷新、顶部统一策略开关、关闭策略后继续刷新及多账号批量开关均有回归覆盖。
新增牧场树形/平铺切换、分组数量与空位、刷新保留折叠和控件、4S保留条件、随机刷新间隔及到期独立同步的回归测试。
@@ -260,21 +292,18 @@
“自动委托”需单独启用;可先关闭“自动孵蛋”的自动管理,只运行委托。
道具和魔物提交默认关闭,金币提交上限默认 0;锁定、队伍、高星和高资质保护继续生效。
已接委托需要的魔物种类和蛋会纳入牧场保留。
“也接取需要实战的委托”只允许接取此类任务,当前不会自动导航到每项委托的专用战斗。
“也接取需要实战的委托”允许经检查后接取实战委托;已支持的剧情、交付和专用战斗通过任务调度继续推进。战斗模式与队伍在“自动主线 → 推进策略”选择,委托资源限制仍由本页配置。当前默认原版模式的实际阵容桥接尚待完成,不应把这个开关视为所有委托均已可用。
普通关卡首次通关仍需在游戏内实际战斗。客户端有 `startSaodang` /
`doSaodangBattle` 扫荡分支:普通、非剧情定位关卡的三个难度全部通关后才开放。
它复用 `stageStart` → `battleEnd` → `recordBattleResult`,无需本地战斗演算或手机截图。
此前只搜索英文 sweep 和中文“扫荡”漏掉了这个拼音方法;现已按该分支实现。
普通、非剧情定位关卡的三个难度全部通关后才开放扫荡,无需本地战斗演算或手机截图。首次挑战、任务专属战斗与扫荡分别处理,当前可执行范围见上方能力表。客户端调用链与字段证据见[地图及每日事务研究](../analysis/STAGES_DAILY.md)和[战斗路线说明](../analysis/V1_2_IMPLEMENTATION.md#调度与恢复约定)。
在“自动扫荡”展开地区,每关勾选“刷图”、选择难度、输入“本日上限”,勾选该页功能,再开启顶部策略开关。
星级是服务器通关进度计算出来的,只读。未解锁难度不能选;特殊关卡、未全通关、剧情任务、
体力/金币/门票不足的关卡会显示原因并跳过。次数按角色、日期、关卡和难度保存,
是本地已开始次数,不冒充服务器每日限制。
一次扫荡内部的几个请求顺序执行,完成后重读账号状态;开启其他策略时与孵蛋/委托逐轮串行。
探索奖励事件由 `stageStart` 返回的 `stageEvent.result` 直接结算,无需提交 `battleEnd`,刷新角色后可继续下一轮。
探索奖励事件已由地图开始响应直接发放,刷新角色后可继续下一轮,不再提交普通战斗结算。
旧版将此类奖励事件误记为未完成时,只在本地日志能匹配当前角色、关卡和成功响应的情况下自动解除阻塞,不重发请求。
隐藏关卡需要游戏内实战;缺失事件状态或请求结果不明确时保持待处理,避免重复扣体力,在游戏内确认处理后可清除本地记录。
隐藏关卡单独检查运行时能力;不支持、缺失事件状态或请求结果不明确时保持待处理,避免重复扣体力。恢复前先刷新并在游戏内核实,未知写请求不会自动重发。
“每日事务”选择要处理的奖励类别,点“领取勾选项目”可立即领取;
勾选“启用每日奖励领取”并开启顶部策略开关后,只自动处理符合状态的项目。
@@ -284,8 +313,8 @@ VIP奖励只对已有资格领取;不会购买VIP或升级礼包。邮件仅
资料包含此APK的1178个关卡、各难度奖励和2079种道具名称。
这些是安装包配置中的可能掉落,并非实时掉落概率保证;后续热更新新增数据需要重新提取。
本次签到、领邮件和扫荡均由本地模拟验证,尚未在真实账号上执行验证。
静态证据与字段规则见 `analysis/STAGES_DAILY.md`。
这些流程有本地模拟验证;本轮开发验证未执行真实游戏请求,v1.2 的任务与战斗服务器验收仍待用户手动验证。软件在用户开启策略后,可按配置和能力检查自动执行已支持操作。
静态证据与字段规则见[地图及每日事务研究](../analysis/STAGES_DAILY.md)。
## 刷新响应与批量喂养
+15 -8
View File
@@ -58,15 +58,22 @@ class Reader:
self.objects.append(value)
return value
if kind == 9:
associative, dense = {}, []
result = associative if not h >> 1 else dense
self.objects.append(result)
while (name := self.string()):
associative[name] = self.read()
for _ in range(h >> 1):
dense.append(self.read())
if dense and associative:
dense_length = h >> 1
# The first key decides the shape, including dense length 0.
# Reading a key uses only the string table; reserve the final
# object container before any child value can reference it.
name = self.string()
if name and dense_length:
raise ValueError("Mixed AMF array unsupported")
result = {} if name else []
self.objects.append(result)
if name:
while name:
result[name] = self.read()
name = self.string()
else:
for _ in range(dense_length):
result.append(self.read())
return result
if not h & 2:
external, dynamic, names = self.traits[h >> 2]
+373
View File
@@ -0,0 +1,373 @@
"""Execute pinned original AIR combat offline, with original result/check callbacks.
Canonical stage/task inputs and complete snapshots use the original compiled
BattleCenter/BattleGround/skills. This development adapter never authorizes game
API actions or claims server compatibility. See the implementation evidence.
"""
from __future__ import annotations
from collections.abc import Mapping
from dataclasses import asdict, dataclass, fields
import hashlib
import json
import math
import os
from pathlib import Path
import sys
import time
from typing import Any
import uuid
ROOT = Path(__file__).resolve().parent.parent
LOCAL = ROOT / "local_state/battle_runtime"
ORIGINAL_APK_SHA256 = "01678ee3a8465d818d32cbbd94baa0d8253b04b4c57b70ebc5544ed341f1015d"
ORIGINAL_MAIN_SHA256 = "c6838331a198a22ffa486cbf61cc74c97619e011bc3364c8bb8dc99e269036cf"
CONTEXTS = frozenset(("ordinary_stage", "task_battle", "task_pass_stage"))
# Release checkpoint: final callback-binding/Engine integration QA is pending.
# Offline execution remains available. Do not enable before that bounded QA.
NATIVE_ADMISSION_ENABLED = False
ORIGINAL_FIXTURE_ROSTER = {"kind": "original_fixture", "species": 1001010, "players": 3,
"level": 1, "mode": 2, "growth_area": .5, "master_level": 1}
@dataclass(frozen=True)
class BattleRequest:
context: str
original_data: Mapping[str, Any]
roster: Mapping[str, Any]
stage_id: str | None = None
difficulty: int = 1
task_id: str | None = None
step_index: int | None = None
purpose: str = "settlement"
team: str | None = None
battle_position: Mapping[str, Any] | None = None
def original_fixture_request() -> BattleRequest:
"""Explicit synthetic fixture, never an account roster or settlement request."""
return BattleRequest("ordinary_stage", {"source": "original_apk", "resource_identity": {
"apk_sha256": ORIGINAL_APK_SHA256, "main_swf_sha256": ORIGINAL_MAIN_SHA256}},
dict(ORIGINAL_FIXTURE_ROSTER), stage_id="0101", purpose="offline_validation")
def _canonical(value: Any) -> bytes:
return json.dumps(value, ensure_ascii=True, allow_nan=False, sort_keys=True,
separators=(",", ":")).encode("ascii")
def _validate_callback_binding(scene, native, evidence, validation):
"""Validate original callback provenance/data; never synthesize statistics."""
data=scene["battle_data"]
events=native.get("events",[])
completed=[event for event in events if event.get("kind")=="original_battle_completed"]
built=[event for event in events if event.get("kind")=="snapshot_bridge_built"]
if len(completed)!=1 or completed[0].get("data")!=scene or not built or built[-1].get("data",{}).get("installed") is not True:
raise ValueError("Missing or mismatched original snapshot/completion callback evidence")
if not any(event.get("kind")=="BattleCenter_started" for event in events):
raise ValueError("Missing original BattleCenter execution evidence")
ids=data.get("battleMonIds")
expected=validation["expected_battle_mon_ids"]
if not isinstance(ids,list) or any(type(mid) is not int for mid in ids) or sorted(ids)!=sorted(expected):
raise ValueError("Original callback roster does not match the selected input team")
records=scene["anomaly_records"]
if set(records)!={"mons","damages","master","text"} or not isinstance(records["mons"],list) or not isinstance(records["damages"],list) or not isinstance(records["text"],str):
raise ValueError("Original anomaly records are incomplete")
checked=[record.get("mid") for record in records["mons"] if isinstance(record,dict)]
# Original makeRecord may serialize mid as a decimal String, while
# BattleData.battleMonIds is numeric. Compare identity without rewriting
# either original output representation.
if any(type(mid) not in (str,int) or not str(mid).isdecimal() for mid in checked):
raise ValueError("Invalid original player integrity record identity")
if len(checked)!=len(records["mons"]) or sorted(map(int,checked))!=sorted(expected):
raise ValueError("Original player integrity checks do not match the selected roster")
if data["cheatNum"]==0:
if data.get("cheatRecords")!="": raise ValueError("Original zero-count callback serialization mismatch")
elif not isinstance(data.get("cheatRecords"),str) or json.loads(data["cheatRecords"])!=records:
raise ValueError("Original serialized anomaly records were altered")
for field in ("leftTime","killNum","totalDamage","bossDamage","deadNum","aliveNum","apLeft"):
if type(data.get(field)) is not int: raise ValueError("Missing original callback statistic: "+field)
if not 0 <= data["leftTime"] <= validation["battle_seconds"]*1000 or not isinstance(data.get("killMonster"),dict):
raise ValueError("Invalid original battle clock or kill dictionary")
if scene.get("game_api_requests")!=0 or scene.get("requested_fps")!=50 or not isinstance(scene.get("wall_ms"),(int,float)) or scene["wall_ms"]<=0 or scene.get("observed_frames",0)<=0:
raise ValueError("Missing original offline clock/frame evidence")
if not native.get("nonce") or not native.get("application_id") or not native.get("storage_directory"):
raise ValueError("Missing isolated native application identity")
return True
def _coerce(request) -> tuple[BattleRequest | None, list[dict]]:
if isinstance(request, BattleRequest):
try:
request = asdict(request)
except (TypeError, ValueError, RecursionError) as error:
return None, [{"code": "invalid_request", "detail": str(error)}]
if not isinstance(request, Mapping):
return None, [{"code": "invalid_request", "detail": "Expected BattleRequest or a mapping"}]
allowed = {field.name for field in fields(BattleRequest)}
unknown = set(request) - allowed
if unknown:
return None, [{"code": "unknown_request_fields", "detail": ", ".join(sorted(map(str, unknown)))}]
try:
encoded = _canonical(dict(request))
if len(encoded) > 4 * 1024 * 1024:
raise ValueError("Request exceeds 4 MiB")
snapshot = json.loads(encoded) # detached from mutable caller state
result = BattleRequest(**snapshot)
except (TypeError, ValueError, OverflowError, RecursionError) as error:
return None, [{"code": "invalid_request", "detail": str(error)}]
return result, []
class BattleRuntime:
"""Fixed original runtime, with a separate offline-validation capability.
inspect() is read-only and returns a dictionary. supported means this exact
OFFLINE job can execute. Online callers must additionally require faithful
AND settlement_eligible. Complete original snapshot requests can be admitted;
only a verified completed callback can yield an eligible result. Server
acceptance remains explicitly unverified. Diagnostic fixtures never qualify.
Imported commands, paths, manifests, engine results and verified claims
never select an executable or enable support.
"""
def __init__(self, runtime_config: Mapping | None = None):
self._config_reasons = []
if runtime_config is not None:
if not isinstance(runtime_config, Mapping) or set(runtime_config) - {"backend"}:
self._config_reasons.append({"code": "untrusted_runtime_config",
"detail": "Only backend=original_air is accepted; commands and verification claims are forbidden"})
elif runtime_config.get("backend", "original_air") != "original_air":
self._config_reasons.append({"code": "unknown_backend", "detail": "Expected original_air"})
def inspect(self, request: BattleRequest | Mapping) -> dict:
req, reasons = _coerce(request)
reasons.extend(self._config_reasons)
result = {"supported": False, "offline_supported": False, "settlement_eligible": False,
"faithful": False, "approximate":False,"original_core": True, "backend": "original_air",
"execution_mode":"original","server_acceptance_verified":False,
"reasons": reasons, "resource_identity": {"apk_sha256": ORIGINAL_APK_SHA256,
"main_swf_sha256": ORIGINAL_MAIN_SHA256, "baseline": "original APK 1.9.68",
"live_resource_match_verified": False},
"coverage": {"validated_offline_fixtures": ["ordinary_stage:0101:1:three_level1_slimes"],
"validated_skills": [3], "validated_online_contexts": [],
"validated_callback_route":"BattlePanel.battleCompleteHandler to local observer",
"original_checks_preserved": True},
"limitations": ["Original APK lacks 1001010_q_2s.png; original local error callbacks execute",
"Math.random is native and unseeded; no synchronized trace comparison",
"Current live-resource matching and server acceptance remain unvalidated"]}
if req is None:
return result
result["request_sha256"] = hashlib.sha256(_canonical(asdict(req))).hexdigest()
if isinstance(req.roster,Mapping) and ("snapshot" in req.roster or "master" in req.roster):
return self._inspect_snapshot(req,result)
if not isinstance(req.context, str) or req.context not in CONTEXTS:
reasons.append({"code": "unknown_context", "detail": str(req.context)})
elif req.context != "ordinary_stage":
reasons.append({"code": "task_route_not_validated", "detail": req.context})
if req.purpose not in ("settlement", "offline_validation"):
reasons.append({"code": "unknown_purpose", "detail": str(req.purpose)})
if req.purpose != "offline_validation":
reasons.append({"code": "settlement_not_validated", "detail":
"This development build cannot authorize an online battle start or settlement"})
if req.stage_id != "0101" or type(req.difficulty) is not int or req.difficulty != 1:
reasons.append({"code": "scene_not_validated", "detail": "Only original stage 0101, difficulty 1 has a native fixture proof"})
if req.task_id is not None or req.step_index is not None:
reasons.append({"code": "task_input_not_validated", "detail": "No task context may reuse the ordinary-stage fixture"})
if not isinstance(req.original_data, Mapping):
reasons.append({"code": "original_data_required", "detail": "Expected original APK source and resource identity"})
else:
data = req.original_data
if set(data) - {"source", "resource_identity"}:
reasons.append({"code": "external_battle_data_unvalidated", "detail":
"Only pinned original APK tables are executed; imported tables/commands/verification claims are refused"})
identity = data.get("resource_identity")
if data.get("source") != "original_apk" or not isinstance(identity, Mapping):
reasons.append({"code": "original_data_identity_missing", "detail": "Expected source=original_apk and resource_identity"})
elif dict(identity) != {"apk_sha256": ORIGINAL_APK_SHA256, "main_swf_sha256": ORIGINAL_MAIN_SHA256}:
reasons.append({"code": "resource_identity_mismatch", "detail": "Expected the pinned original APK and main SWF"})
if not isinstance(req.roster, Mapping) or dict(req.roster) != ORIGINAL_FIXTURE_ROSTER:
reasons.append({"code": "roster_not_validated", "detail":
"Only the explicit original_fixture roster is supported offline; real snapshots and reference stats are unvalidated"})
if os.name != "nt":
reasons.append({"code": "runtime_platform_unavailable", "detail": "The pinned native runner uses Windows x64 AIR"})
from tools.battle_runtime.trusted import LIBRARY_FILES, SDK_FILES, verify_files
sdk_reasons = verify_files(LOCAL / "air_sdk", SDK_FILES)
library_reasons = verify_files(LOCAL / "original", LIBRARY_FILES)
reasons.extend(sdk_reasons)
reasons.extend(library_reasons)
result["resource_identity"]["sdk_pins_match"] = not sdk_reasons
result["resource_identity"]["prepared_library_pins_match"] = not library_reasons
candidates = list(ROOT.glob("*_1.9.68.apk"))
if not candidates:
reasons.append({"code": "original_apk_missing", "detail": "The worker re-verifies the original local APK before executing"})
elif len(candidates) != 1:
reasons.append({"code":"original_apk_ambiguous","detail":"Expected exactly one original *_1.9.68.apk"})
result["supported"] = result["offline_supported"] = not reasons
return result
def _inspect_snapshot(self,req,result):
from tools.battle_runtime.inputs import validate
from tools.battle_runtime.trusted import LIBRARY_FILES,SDK_FILES,verify_files
reasons = result["reasons"]
if req.purpose not in ("settlement","offline_validation"):
reasons.append({"code":"unknown_purpose","detail":str(req.purpose)})
if os.name != "nt": reasons.append({"code":"runtime_platform_unavailable","detail":"Windows x64 AIR is required"})
if not (ROOT / "tools/battle_runtime/SnapshotBridge.as").is_file():
reasons.append({"code":"snapshot_bridge_unavailable","detail":"Bundled original snapshot bridge source is missing"})
try:
validation = validate(asdict(req))
except (OSError,ValueError,KeyError,TypeError,AttributeError) as error:
validation = {"reasons":[{"code":"invalid_original_request","detail":str(error)}]}
reasons.extend(validation["reasons"])
sdk_reasons = verify_files(LOCAL/"air_sdk",SDK_FILES)
library_reasons = verify_files(LOCAL/"original",LIBRARY_FILES)
reasons.extend(sdk_reasons);reasons.extend(library_reasons)
result["resource_identity"].update(sdk_pins_match=not sdk_reasons,prepared_library_pins_match=not library_reasons)
result["coverage"] = {**result["coverage"],**validation.get("coverage",{}),"input_mode":"original_snapshot"}
result["coverage"]["validated_offline_contexts"] = sorted(CONTEXTS)
result["coverage"]["fidelity_basis"] = "unchanged original compiled core, original event loop and result/check callbacks"
result["limitations"] = ["Server acceptance and current live-resource compatibility have not been tested",
"Native Math.random is unseeded; results use the actual original event loop",
"Original empty optional image declarations retain their recorded local IO-error callbacks"]
result["native_position"] = validation.get("position")
seconds = validation.get("battle_seconds",300)
result["battle_seconds"] = seconds
result["watchdog_seconds"] = seconds*2+90
result["supported"] = result["offline_supported"] = not reasons
result["faithful"] = not reasons
result["settlement_eligible"] = NATIVE_ADMISSION_ENABLED and not reasons and req.purpose=="settlement"
result["native_admission_validation_pending"] = not NATIVE_ADMISSION_ENABLED
result["admission_requires_completed_original_checks"] = True
return result
def run(self, request: BattleRequest | Mapping, *, cancel_event=None, timeout: float | None = None) -> dict:
if timeout is not None and (isinstance(timeout, bool) or not isinstance(timeout, (float, int)) or not math.isfinite(timeout) or timeout <= 0):
raise ValueError("timeout must be a finite positive number")
started = time.monotonic()
if cancel_event is not None and cancel_event.is_set():
return {"status": "cancelled", "battle_executed": False, "settlement_eligible": False, "faithful": False}
# Freeze caller input once, before inspection and process serialization.
# Mutating a shared policy/snapshot cannot redirect an inspected job.
frozen, _ = _coerce(request)
from tools.battle_runtime.inputs import InspectionInterrupted, inspection_budget
try:
with inspection_budget(cancel_event,started+timeout if timeout is not None else None):
capability = self.inspect(frozen if frozen is not None else request)
except InspectionInterrupted as error:
return {"status":error.status,"battle_executed":False,"battle_completed":False,
"settlement_eligible":False,"faithful":False}
if not capability["supported"]:
return {"status": "unsupported", "battle_executed": False, "settlement_eligible": False,
"faithful": False, "capability": capability, "reasons": capability["reasons"]}
deadline = timeout if timeout is not None else capability.get("watchdog_seconds",690.0)
remaining = deadline-(time.monotonic()-started)
if (cancel_event is not None and cancel_event.is_set()) or remaining <= 0:
return {"status":"cancelled" if cancel_event is not None and cancel_event.is_set() else "timeout",
"battle_executed":False,"battle_completed":False,"faithful":False,"settlement_eligible":False}
source_request = asdict(frozen) if capability["coverage"].get("input_mode")=="original_snapshot" else None
return self._execute(scene=True, timeout=remaining, cancel_event=cancel_event,
request_sha256=capability["request_sha256"],source_request=source_request,
expected_position=capability.get("native_position"),admitted=capability["settlement_eligible"])
def probe_original_components(self, *, cancel_event=None, timeout: float = 60.0) -> dict:
"""Explicit diagnostic operation; cannot produce settlement data."""
if self._config_reasons:
return {"status": "unsupported", "reasons": list(self._config_reasons), "settlement_eligible": False}
from tools.battle_runtime.trusted import SDK_FILES, verify_files
reasons = verify_files(LOCAL / "air_sdk", SDK_FILES)
if reasons:
return {"status": "unsupported", "reasons": reasons, "settlement_eligible": False}
return self._execute(scene=False, timeout=timeout, cancel_event=cancel_event, request_sha256=None)
def _execute(self, *, scene, timeout, cancel_event, request_sha256,source_request=None,expected_position=None,admitted=False):
from tools.battle_runtime.isolation import run_isolated
validation=None
if source_request is not None:
from tools.battle_runtime.inputs import validate
validation=validate(source_request)
if validation["reasons"]:
return {"status":"unsupported","supported":False,"faithful":False,"settlement_eligible":False,
"battle_executed":False,"battle_completed":False,"server_acceptance_verified":False,
"reasons":validation["reasons"]}
attempt = LOCAL / "jobs" / uuid.uuid4().hex
attempt.mkdir(parents=True)
nonce = uuid.uuid4().hex
output = attempt / "worker-result.json"
argv = [sys.executable, "-I", "-B", str(ROOT / "tools/battle_runtime/worker.py"),
"--output", str(output), "--nonce", nonce, "--action", "scene" if scene else "components","--timeout",str(timeout)]
if source_request is not None:
input_path = attempt / "worker-input.local.json"
input_path.write_bytes(_canonical(source_request))
argv.extend(("--input",str(input_path)))
process = run_isolated(argv, cwd=attempt, timeout=timeout, cancel_event=cancel_event)
result = {"status": process.status, "settlement_eligible": False, "faithful": False,
"approximate":False,"original_core":True,"execution_mode":"original",
"server_acceptance_verified":False,"supported":False,"terminal":False,
"battle_executed": None, "battle_completed": False, "request_sha256": request_sha256,
"diagnostics_directory": str(attempt), "process_exit_code": process.returncode}
if process.status != "completed":
result["error"] = process.stderr[-4000:] or process.stdout[-4000:]
return result
try:
if output.stat().st_size > 2 * 1024 * 1024:
raise ValueError("Oversized original runner evidence")
payload = json.loads(output.read_text(encoding="utf-8"))
if payload["nonce"] != nonce or payload["schema"] != 1:
raise ValueError("Original runner evidence binding mismatch")
evidence = payload["evidence"]
native = evidence["result"]
if source_request is not None and evidence.get("input_sha256") != request_sha256:
raise ValueError("Native execution belongs to a different input snapshot")
if evidence["resource_identity"].get("apk_sha256") != ORIGINAL_APK_SHA256 or evidence["resource_identity"]["main_swf_sha256"] != ORIGINAL_MAIN_SHA256:
raise ValueError("Original runner resource identity mismatch")
if native.get("settlement_eligible") is not False or native.get("faithful", False) is not False:
raise ValueError("Runner claimed unvalidated settlement eligibility or fidelity")
if evidence.get("resource_audit", {}).get("all_present_assets_match_apk") is not True:
raise ValueError("Original assets do not match the pinned APK")
completed = native.get("status") == ("scene_completed" if scene else "probe_completed")
if completed and evidence["process_exit_code"] == 0:
result["status"] = "completed"
else:
result["status"] = "error"
result["error"] = native.get("error") or {"code":"native_process_failed",
"detail":"Original runtime did not complete the requested operation"}
result["battle_executed"] = native.get("battle_executed") is True
result["evidence"] = evidence
if completed and scene:
if not result["battle_executed"] or not isinstance(native.get("scene_result"), dict):
raise ValueError("Scene completion lacks an executed original battle result")
scene_result = native["scene_result"]
outcome = scene_result.get("outcome")
data = scene_result.get("battle_data")
if outcome not in ("win", "loss") or not isinstance(data, dict) or type(data.get("win")) is not bool:
raise ValueError("Invalid native outcome/data")
cheat_num = data.get("cheatNum")
if type(cheat_num) not in (int,float) or not math.isfinite(cheat_num) or cheat_num < 0 or int(cheat_num) != cheat_num:
raise ValueError("Missing or invalid original anomaly count")
if data["win"] != (outcome == "win") or not isinstance(scene_result.get("anomaly_records"), dict):
raise ValueError("Native result is inconsistent or lacks original anomaly records")
wanted_position = expected_position if expected_position is not None else {"battleType":"stage", "stageLevel":"1", "stageId":"0101", "taskTypeId":None, "taskStep":0}
if data.get("battlePosition") != wanted_position:
raise ValueError("Native result belongs to a different battle route")
if validation is not None:
_validate_callback_binding(scene_result,native,evidence,validation)
result["outcome"] = outcome
result["offline_result"] = scene_result
result["battle_data"] = data
result["battle_completed"] = True
result["checks_passed"] = data.get("cheatNum")==0
result["server_validated"] = False
result["faithful"] = validation is not None
result["supported"] = True
result["terminal"] = True
result["execution_status"] = "completed"
result["terminal_reason"] = scene_result.get("terminal_reason")
result["wall_time_ms"] = scene_result.get("wall_ms")
result["requires_realtime_wait"] = False
result["resource_identity"] = evidence["resource_identity"]
result["settlement_eligible"] = admitted and validation is not None and result["checks_passed"]
if data.get("cheatNum",0)>0: result["status"]="anomaly"
except (OSError, KeyError, TypeError, ValueError) as error:
result.update(status="error", battle_executed=None, battle_completed=False,settlement_eligible=False,faithful=False,error=str(error))
result.pop("outcome", None); result.pop("offline_result", None);result.pop("battle_data",None)
return result
File diff suppressed because it is too large Load Diff
+631
View File
@@ -0,0 +1,631 @@
"""Durable orchestration; combat statistics belong exclusively to the runtime.
Partner contract: BattleOrchestrator accepts ProgressionIntent objects (or dicts).
The runtime adapter implements inspect(request) and run(request, cancel_event=Event).
Inspection must explicitly report supported=True. Original settlement requires
settlement_eligible=True; experimental execution requires its separate
experimental_settlement_eligible=True after completed model execution.
Original execution must be faithful; explicitly selected experimental execution
must identify itself as approximate and retain its limitations and trace.
Both supply unmodified, computed battle_data. The request
contains snapshot, team, battle_position, stage_id, difficulty, task_type_id,
step_number and battle_kind. Engine adapts the concrete runtime's input builder.
No estimation module is imported here. SweepRunner is the sole sweep executor.
"""
from __future__ import annotations
from copy import deepcopy
from dataclasses import asdict, is_dataclass
import hashlib
import json
import math
import os
from pathlib import Path
import threading
import time
import uuid
from .drop_statistics import event_reward
from .maps import stages
from .quests import indexed, stage_has_level
from .sweeping import SweepPolicy
def value(obj, name, default=None):
return obj.get(name, default) if isinstance(obj, dict) else getattr(obj, name, default)
class CancelledBeforeDispatch(Exception):
"""Raised only before Client.call is invoked; the request was not sent."""
def role_id(snapshot):
owner = snapshot.raw.get("master", {}).get("id")
if owner is None:
raise ValueError("角色身份缺失,不能推进任务")
return str(owner)
def digest(obj):
return hashlib.sha256(json.dumps(obj, sort_keys=True, ensure_ascii=False,
separators=(",", ":"), default=str).encode("utf-8")).hexdigest()
def public_data(obj):
"""Never persist transport credentials, even in an unexpected response."""
if is_dataclass(obj):
obj = asdict(obj)
if isinstance(obj, dict):
return {str(k): public_data(v) for k, v in obj.items()
if str(k).lower().replace("_", "") not in ("key", "sessionkey", "session", "sessionid", "aeskey", "encryptionkey", "sdkkey", "appkey",
"reqid", "reqsid", "uid", "sdkuid", "deviceid")
and not any(secret in str(k).lower() for secret in ("token", "password", "secret", "authorization", "cookie"))}
if isinstance(obj, (list, tuple)):
return [public_data(v) for v in obj]
if obj is None or isinstance(obj, (str, int, float, bool)):
return obj
return str(obj)
def gameplay_response(response):
result = {k: v for k, v in response.items() if k in (
"resCode", "triggerEvent", "stageEvent", "reward", "stageReward", "costTi", "unlockStage", "lockStage",
"monsterExpInfos", "taskStepValue", "task", "nextTasks", "unlockTasks", "unlockStages", "receiveTasks", "loopTask",
"loopTaskNum", "loopTaskTime")}
def task_fields(task):
return {key: task[key] for key in ("id", "typeId", "curStep", "stepValue") if key in task}
if isinstance(result.get("task"), dict):
result["task"] = task_fields(result["task"])
for field in ("nextTasks", "receiveTasks"):
if isinstance(result.get(field), list):
result[field] = [task_fields(task) for task in result[field] if isinstance(task, dict)]
return public_data(result)
_locks_guard = threading.Lock()
_locks = {}
def account_lock(path):
if path is None:
return threading.RLock()
key = os.path.normcase(str(Path(path).resolve()))
with _locks_guard:
return _locks.setdefault(key, threading.RLock())
class BattleJournal:
"""Atomic per-role write-ahead records, including local story checkpoints."""
def __init__(self, path=None):
self.path = Path(path) if path else None
self.lock = account_lock(path)
self.state = {"version": 1, "roles": {}}
self.reload()
def reload(self):
if self.path and self.path.exists():
try:
state = json.loads(self.path.read_text(encoding="utf-8"))
if state.get("version") != 1 or not isinstance(state.get("roles"), dict):
raise ValueError("unsupported journal")
self.state = state
except (OSError, ValueError, AttributeError) as error:
raise ValueError("任务 / 战斗日志无法读取;请保留日志并核对,不能自动重试") from error
def save(self):
for state in self.state["roles"].values():
completed = [r for r in state["records"] if r["attempt_id"] != state["pending"]]
keep = {r["attempt_id"] for r in completed[-500:]}
state["records"] = [r for r in state["records"] if r["attempt_id"] == state["pending"] or r["attempt_id"] in keep]
if self.path:
self.path.parent.mkdir(parents=True, exist_ok=True)
temporary = self.path.with_name(self.path.name + "." + uuid.uuid4().hex + ".tmp")
try:
with temporary.open("w", encoding="utf-8") as stream:
json.dump(self.state, stream, ensure_ascii=False, allow_nan=False)
stream.flush()
os.fsync(stream.fileno())
for attempt in range(5):
try:
temporary.replace(self.path)
break
except PermissionError:
if attempt == 4:
raise
# Windows indexers can briefly hold a just-closed file.
# Only local atomic replacement is retried, never an API.
time.sleep(0.01 * (attempt + 1))
finally:
temporary.unlink(missing_ok=True)
def role(self, snapshot):
return self.state["roles"].setdefault(role_id(snapshot),
{"pending": None, "records": [], "cursors": {}, "losses": 0})
def pending(self, snapshot):
state = self.role(snapshot)
return next((r for r in state["records"] if r["attempt_id"] == state["pending"]), None)
def records(self, snapshot):
with self.lock:
self.reload()
return deepcopy(list(reversed(self.role(snapshot)["records"])))
def begin(self, snapshot, intent, *, kind=None):
if self.pending(snapshot):
raise ValueError("有待核对的任务 / 战斗,禁止重复开始")
record = {name: public_data(value(intent, name)) for name in (
"kind", "description", "path", "payload", "task_id", "task_type_id", "step_number",
"position", "stage_id", "difficulty", "battle_kind", "source_task_id", "source_task_type_id", "source_step_number", "farming_target")}
record.update(attempt_id=uuid.uuid4().hex, role_id=role_id(snapshot),
phase="prepared", outcome="", timestamp=time.time(), started_at=time.time(), team=value(intent, "team", ""),
message="", kind=kind or record["kind"], battle_mode=value(intent, "battle_mode", "original"),
baseline={"tasks": [{k: t[k] for k in ("id", "typeId", "curStep", "stepValue") if k in t}
for t in snapshot.raw.get("currentTasks", []) if str(t.get("id")) == str(value(intent, "task_id"))
or str(t.get("typeId")) == str(value(intent, "task_type_id"))],
"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 value(intent, "token") and value(intent, "account_key"):
record.update(intent_id=value(intent, "token"), account_key=value(intent, "account_key"))
state = self.role(snapshot)
state["records"].append(record)
state["pending"] = record["attempt_id"]
self.save() # Must succeed BEFORE any non-retryable request.
return record
def update(self, record, phase, **fields):
record.update(public_data(fields), phase=phase, updated_at=time.time())
self.save()
def finish(self, snapshot, record, outcome, message=""):
state = self.role(snapshot)
record.update(phase="done", outcome=outcome, message=message, finished_at=time.time())
if state["pending"] == record["attempt_id"]:
state["pending"] = None
if outcome == "loss":
state["losses"] += 1
elif outcome == "win":
state["losses"] = 0
self.save()
def cursors(self, snapshot):
return deepcopy(self.role(snapshot)["cursors"])
def checkpoint(self, snapshot, intent, response=None):
"""Local acknowledgements never rewrite the authoritative snapshot."""
key = f"{value(intent, 'task_id', 0)}:{value(intent, 'task_type_id', '')}"
step = int(value(intent, "step_number", 0) or 0)
current = next((t for t in snapshot.raw.get("currentTasks", [])
if str(t.get("id")) == str(value(intent, "task_id"))), {})
entry = self.role(snapshot)["cursors"].setdefault(key,
{"task_id": value(intent, "task_id"), "task_type_id": value(intent, "task_type_id"),
"server_step": int(current.get("curStep", step) or step), "steps": {}})
checkpoint = entry["steps"].setdefault(str(step), {"operations": {}, "submitted": False, "local_complete": False})
kind, phase = value(intent, "kind"), value(intent, "phase", "")
checkpoint["operations"][f"{kind}:{phase}"] = {"kind": kind, "phase": phase,
"response": gameplay_response(response) if isinstance(response, dict) else None}
if isinstance(response, dict) and ((value(intent, "path", "") or "").endswith("taskCompleteStep")
or kind in ("battle", "task_battle", "progression_battle")):
checkpoint["submitted"] = True
if kind in ("progression_local_step", "local_step"):
checkpoint["local_complete"] = True
self.save()
def reconcile(self, snapshot, *, trusted=False):
"""Only a new role-checked server snapshot can resolve uncertain writes.
An unchanged step, stamina change or old three-star clear is insufficient.
No endpoint is replayed by reconciliation.
"""
if not trusted:
return False
with self.lock:
self.reload()
record = self.pending(snapshot)
tasks = snapshot.raw.get("currentTasks", [])
history = snapshot.raw.get("history", {})
state = self.role(snapshot)
changed = False
# Keep checkpoints for steps that the server has not incorporated.
for key, cursor in list(state["cursors"].items()):
task = next((t for t in tasks if str(t.get("id")) == str(cursor.get("task_id"))
and str(t.get("typeId")) == str(cursor.get("task_type_id"))), None)
if task is None:
del state["cursors"][key]
changed = True
elif int(task.get("curStep", 1)) > int(cursor.get("server_step", 0)):
cursor["server_step"] = int(task["curStep"])
cursor["steps"] = {k: v for k, v in cursor["steps"].items() if int(k) >= int(task["curStep"])}
changed = True
resolved = False
if record:
task = next((t for t in tasks if str(t.get("id")) == str(record.get("task_id"))
and str(t.get("typeId")) == str(record.get("task_type_id"))), None)
path = record.get("path") or ""
if record.get("task_id") and record.get("step_number"):
resolved = bool(task and int(task.get("curStep", 1)) > int(record["step_number"]))
response = record.get("response") or {}
baseline = next((t for t in record["baseline"]["tasks"]
if str(t.get("id")) == str(record["task_id"])), {})
if (not resolved and "planner_state" not in state and task and response.get("taskStepValue") is not None
and task.get("stepValue") == response["taskStepValue"]
and baseline.get("stepValue") != response["taskStepValue"]):
self.checkpoint(snapshot, record, response)
resolved = True
if record.get("task_type_id") and path.endswith(("taskReceive", "taskLoopReceive")):
old = {str(t.get("id")) for t in record["baseline"]["tasks"]}
resolved = any(str(t.get("typeId")) == str(record["task_type_id"])
and str(t.get("id")) not in old for t in tasks)
if path.endswith("taskComplete"):
resolved = task is None and bool(indexed(history.get("passTask"), record["task_type_id"], False))
if path.endswith("taskLoopFlush"):
resolved = history.get("loopTaskTime") != record["baseline"].get("loop_time")
if path.endswith("taskUpdate"):
payload = record.get("payload") or {}
resolved = (all(any(str(t.get("typeId")) == str(row.get("taskTypeId")) for t in tasks)
for row in payload.get("receiveTasks", []))
and all(indexed(history.get("unlockTask"), row.get("taskTypeId"), False)
for row in payload.get("unlockTasks", []))
and all(not any(str(t.get("id")) == str(mid) for t in tasks) for mid in payload.get("removeTasks", [])))
if record.get("stage_id") and not record.get("task_id"):
# A first clear proves settlement, but NOT the optional record request.
resolved = (not record["baseline"]["passed"] and
stage_has_level(history, "passStage", record["stage_id"], record.get("difficulty", "1"))
and record["phase"] not in ("record_pending", "record_unknown"))
if resolved:
self.finish(snapshot, record, "reconciled", "已由服务器任务 / 首次通关快照核对;未重发请求")
if changed and not resolved:
self.save()
return resolved
class BattleOrchestrator:
def __init__(self, catalog, journal=None, runtime=None, sweeper=None, request_builder=None, observer=None, clock=None):
self.catalog = catalog
self.journal = journal or BattleJournal()
self.runtime = runtime
self.sweeper = sweeper
self.request_builder = request_builder
self.observer = observer
self.clock = clock or time.monotonic
def pending(self, snapshot):
return self.journal.pending(snapshot)
def task_at_position(self, snapshot, position):
positions = self.catalog.data.get("stage_task_positions", {})
for task in snapshot.raw.get("currentTasks", []):
steps = positions.get(str(task.get("typeId")), [])
number = int(task.get("curStep", 1)) - 1
if 0 <= number < len(steps) and steps[number] == position:
return task
def request(self, snapshot, intent, policy):
task = bool(value(intent, "task_id")) or bool(value(intent, "task_type_id")) and value(intent, "battle_kind") in (
"task", "battle", "passStage", "task_battle", "task_pass_stage")
position = {"battleType": "task" if task else "stage",
"stageId": None if task else str(value(intent, "stage_id", "")),
"stageLevel": None if task else str(value(intent, "difficulty", "1")),
"taskTypeId": str(value(intent, "task_type_id")) if task else None,
"taskStep": max(0, int(value(intent, "step_number", 1) or 1) - 1) if task else 0}
request = {"snapshot": snapshot.raw if self.request_builder else deepcopy(snapshot.raw), "team": policy.team, "battle_position": position,
"battle_mode": value(policy, "battle_mode", "original"),
**{name: value(intent, name) for name in ("stage_id", "difficulty", "task_type_id", "step_number", "battle_kind")}}
return self.request_builder(snapshot, intent, policy, request) if self.request_builder else request
def resource_reason(self, snapshot, intent, policy, ranch=None):
if self.sweeper and self.sweeper.state.get("pending"):
return "有未核对的扫荡,不能开始任务 / 战斗"
if self.journal.pending(snapshot):
return "有待核对的任务 / 战斗,禁止重复开始"
if value(intent, "task_id"):
planner_validated = self.observer("validate", intent, None) if self.observer else None
task = next((t for t in snapshot.raw.get("currentTasks", [])
if str(t.get("id")) == str(value(intent, "task_id"))
and str(t.get("typeId")) == str(value(intent, "task_type_id"))), None)
number = int(value(intent, "step_number", 1))
key = f"{value(intent, 'task_id')}:{value(intent, 'task_type_id')}"
checkpoints = self.journal.cursors(snapshot).get(key, {}).get("steps", {})
server = int(task.get("curStep", 1)) if task else 0
locally_completed = task and server < number and all(checkpoints.get(str(i), {}).get("local_complete")
for i in range(server, number))
if planner_validated is False or planner_validated is None and (task is None or server != number and not locally_completed):
return "任务实例或服务器步骤已变化,请重新规划"
if planner_validated is None and checkpoints.get(str(number), {}).get("submitted"):
return "该任务步骤已有确认记录,等待剧情 / 服务器步骤核对"
limit = max(0, int(policy.stop_after_loss))
if limit and self.journal.role(snapshot)["losses"] >= limit:
return "已达战败停止次数,请核对阵容后重置战败计数"
teams = snapshot.raw.get("teams", [])
team = next((t for t in teams if t.get("teamName") == policy.team and t.get("teamType") == "battleTeam"), {})
ids = [int(mid) for mid in team.get("monsters", []) if mid and int(mid) > 0]
if not ids or any(mid not in snapshot.monsters for mid in ids):
return "所选战队无有效魔物或实例缺失"
stage_id = str(value(intent, "stage_id", "") or "")
difficulty = str(value(intent, "difficulty", "1") or "1")
if not stage_id:
return "" if value(intent, "task_id") else "缺少关卡定位"
stage = self.catalog.data.get("stage_info", {}).get(stage_id)
if not stage or difficulty not in stage.get("level", {}):
return "关卡配置缺失"
if not value(intent, "task_id"):
position = value(intent, "position") or f"city{stage.get('city')}_wild_stage{stage_id}_level{difficulty}"
if self.task_at_position(snapshot, position):
return "该位置由当前任务优先处理,不能执行普通挑战或扫荡"
match = next((s for s in stages(self.catalog, snapshot) if s.stage_id == stage_id and s.level == difficulty), None)
if match is None or not match.unlocked or not match.open:
return "关卡尚未解锁或当前未开放"
base = stage.get("cost") or {}
master = snapshot.raw["master"]
stamina = float(base.get("ti") or 0) + float(stage["level"][difficulty].get("cost") or 0)
if float(master.get("ti") or 0) < stamina + max(0, policy.reserve_ti):
return "体力不足或已达保留体力"
if base.get("ke"):
return "入场需要氪金,未启用"
money = float(base.get("money") or 0)
if money > policy.max_money or float(master.get("money") or 0) - money < max(0, value(ranch, "keep_money", 0)):
return "入场金币超过上限或保留金币不足"
for item in base.get("items") or []:
key, count = str(item["typeId"]), int(item["num"])
if count and not policy.allow_items:
return "入场需要消耗道具,未启用"
reserve = max(int(policy.item_reserves.get(key, 0)), int(value(ranch, "reserved_eggs", {}).get(key, 0)))
owned = sum(int(i.get("num") or 0) for i in snapshot.raw.get("items", [])
if str(i.get("typeId")) == key and not i.get("lock") and not i.get("sysLock") and not i.get("feedLock"))
reserve = max(reserve, int(value(ranch, "gift_items", {}).get(key, {}).get("reserve", 0)))
if owned - count < reserve:
return "入场道具不足或已达保留数量"
return ""
def inspect(self, request):
self._inspection_evidence = {}
if self.runtime is None:
return False, "所选战斗运行时尚未提供,未开始战斗"
report = self.runtime.inspect(request.get("runtime_request", request))
self._inspection_evidence = self.runtime_evidence(report, request.get("battle_mode", "original"))
supported = value(report, "supported") is True
if request.get("battle_mode", "original") == "experimental":
supported = (supported and value(report, "execution_mode") == "experimental"
and value(report, "approximate") is True and value(report, "faithful") is False)
else:
supported = supported and value(report, "settlement_eligible") is True and value(report, "approximate") is not True
blockers = list(value(report, "anomalies", []) or [])
blockers += [row for row in value(report, "diagnostics", []) or [] if isinstance(row, dict) and row.get("blocking") is True]
supported = supported and not blockers
reasons = list(value(report, "reasons", []) or []) + blockers
reason = value(report, "block_reason") or value(report, "reason") or "; ".join(
str(row.get("detail") or row.get("code")) if isinstance(row, dict) else str(row) for row in reasons) or \
"运行时尚未验证支持此阵容 / 关卡,未开始战斗"
return supported, "" if supported else str(reason)
@staticmethod
def runtime_evidence(result, mode):
evidence = {"battle_mode": mode, **{field: public_data(value(result, field)) for field in (
"faithful", "approximate", "limitations", "reasons", "status", "elapsed_ms", "model_elapsed_ms",
"requires_realtime_wait", "wall_time_ms", "trace_path", "resource_identity", "terminal_reason", "settlement_eligible",
"experimental_settlement_eligible", "execution_mode", "execution_status", "terminal", "diagnostics",
"ignored_mechanics", "anomalies", "assumptions", "experimental_eligibility_reasons", "omitted_events")}}
trace = value(result, "trace")
if trace is None:
trace = value(result, "events")
evidence["trace_source"] = "events"
if isinstance(trace, (list, tuple)):
evidence.update(trace=public_data(list(trace[:128]) + list(trace[-128:]) if len(trace) > 256 else trace),
trace_count=len(trace), trace_truncated=len(trace) > 256 or bool(value(result, "trace_truncated")),
journal_trace_truncated=len(trace) > 256, trace_digest=digest(trace))
elif trace is not None:
evidence["trace"] = public_data(trace)
return evidence
def wait_for_battle_clock(self, record, request, result, data, started, cancel):
if value(result, "requires_realtime_wait") is not True:
return True
duration = None
for field, scale in (("model_elapsed_ms", .001), ("battle_elapsed_ms", .001), ("elapsed_ms", .001),
("model_elapsed_seconds", 1), ("elapsed_seconds", 1), ("elapsed", 1)):
elapsed = value(result, field)
if type(elapsed) in (int, float) and math.isfinite(elapsed) and elapsed >= 0:
duration = elapsed * scale
break
battle = (request.get("original_data") or {}).get("battle") or {}
limit, left = battle.get("time"), data.get("leftTime")
if type(limit) in (int, float) and math.isfinite(limit) and limit > 0 and type(left) in (int, float) and 0 <= left <= limit * 1000:
duration = max(duration or 0, limit - left / 1000)
if duration is None:
self._unknown(record, "模型未提供有效战斗时钟,未提交结算")
return False
self.journal.update(record, "waiting_for_battle_clock", battle_clock_seconds=duration,
message="等待已计算的战斗时钟;可以停止,停止后保留待核对记录")
deadline = started + duration
while not cancel.is_set():
remaining = deadline - self.clock()
if remaining <= 0:
return True
if cancel.wait(min(remaining, .25)):
break
self._unknown(record, "等待战斗时钟期间已取消,开战记录保留待核对")
return False
def run(self, client, snapshot, intent, policy, *, cancel=None, ranch=None):
if not self.journal.lock.acquire(blocking=False):
return "同账号已有任务 / 战斗正在执行"
try:
return self._run(client, snapshot, intent, policy, cancel=cancel, ranch=ranch)
finally:
self.journal.lock.release()
def _run(self, client, snapshot, intent, policy, *, cancel=None, ranch=None):
cancel = cancel or threading.Event()
with self.journal.lock:
self.journal.reload()
if not policy.enabled:
return "自动主线策略未启用"
reason = value(intent, "block_reason") or self.resource_reason(snapshot, intent, policy, ranch)
if reason:
return str(reason)
if cancel.is_set():
return "任务 / 战斗已取消,未开始"
if value(intent, "kind") in ("sweep", "progression_sweep", "progression_farm_sweep", "progression_map_sweep") or value(intent, "battle_kind") == "sweep":
return self._sweep(client, snapshot, intent, policy, cancel)
request = self.request(snapshot, intent, policy)
mode = request.get("battle_mode", "original")
supported, reason = self.inspect(request)
if not supported:
record = self.journal.begin(snapshot, intent)
record.update(self._inspection_evidence, team=policy.team, battle_mode=mode)
self.journal.finish(snapshot, record, "unsupported", reason)
return reason
if cancel.is_set():
return "任务 / 战斗已取消,未开始"
record = self.journal.begin(snapshot, intent)
try:
if self.observer:
self.observer("started", intent, None)
if value(intent, "task_id"):
path, payload = "battleService/battleStart", {"battleType": "task", "taskTypeId": str(value(intent, "task_type_id"))}
else:
path, payload = "stageService/stageStart", {"stageTypeId": str(value(intent, "stage_id")), "stageLevel": str(value(intent, "difficulty", "1"))}
self.journal.update(record, "start_pending", start_path=path, input_digest=digest(public_data(request)),
team=policy.team, battle_mode=mode,
resource_identity=(request.get("original_data") or {}).get("manifest", {}).get("source"))
try:
started = self._call(client, path, payload, cancel=cancel)
except CancelledBeforeDispatch:
if self.observer:
self.observer("cancelled_before_start", intent, None)
self.journal.finish(snapshot, record, "cancelled", "开战请求尚未发送,已取消;未消耗入场资源")
return record["message"]
battle_started = self.clock()
self.journal.update(record, "started", start_response=gameplay_response(started))
if not value(intent, "task_id"):
reward = event_reward(started)
if reward is not None:
self.journal.update(record, "event_reward", reward=reward)
if self.observer:
self.observer("event", intent, started)
self.journal.finish(snapshot, record, "event", "探索事件奖励已由开始响应发放")
return "探索事件奖励已结算;未执行战斗"
flag = started.get("triggerEvent")
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)
supported, reason = self.inspect(request)
if not supported:
return self._unknown(record, "隐藏关卡待处理:" + reason)
self.journal.update(record, "hidden_started", stage_id=hidden, difficulty="1")
else:
return self._unknown(record, "探索事件或开战状态未知,等待核对")
if cancel.is_set():
return self._unknown(record, "开战后已取消,等待服务器状态核对")
self.journal.update(record, "running")
result = self.runtime.run(request.get("runtime_request", request), cancel_event=cancel)
evidence = self.runtime_evidence(result, mode)
self.journal.update(record, "runtime_returned", **evidence)
if cancel.is_set() or value(result, "outcome") in ("cancelled", "cancel", "timeout", "unknown", "unsupported"):
return self._unknown(record, "战斗已取消、超时或结果不确定,等待核对")
data = value(result, "battle_data")
eligible = value(result, "outcome") in ("win", "loss")
if mode == "experimental":
eligible = (eligible and value(result, "experimental_settlement_eligible") is True
and value(result, "execution_mode") == "experimental" and value(result, "execution_status") == "completed"
and value(result, "supported") is True and value(result, "terminal") is True
and value(result, "approximate") is True and value(result, "faithful") is False and not value(result, "anomalies"))
else:
eligible = eligible and value(result, "settlement_eligible") is True and value(result, "faithful") is True and value(result, "approximate") is not True
if not eligible or not isinstance(data, dict) or type(data.get("win")) is not bool:
return self._unknown(record, "所选运行时未提供可结算的实际执行结果,未提交结算")
if data["win"] != (value(result, "outcome") == "win"):
return self._unknown(record, "运行结果与战果胜负不一致,未提交结算")
position = data.get("battlePosition")
if (not isinstance(position, dict) or {k: v for k, v in position.items() if v is not None}
!= {k: v for k, v in request["battle_position"].items() if v is not None}):
return self._unknown(record, "运行时战果定位不匹配,未提交结算")
# Keep all statistics and integrity records exactly as supplied.
self.journal.update(record, "runtime_complete", battle_data=data)
if not self.wait_for_battle_clock(record, request, result, data, battle_started, cancel):
return record["message"]
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)
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=cancel)
if self.observer:
self.observer("settled", intent, response)
label = "实验模型胜利(近似)" if mode == "experimental" else "实际胜利"
self.journal.finish(snapshot, record, "win", label + ",结算接口已确认;后续进度以服务器快照核对")
return label + ",已确认对应结算"
except Exception as error:
self._unknown(record, "任务 / 战斗请求或运行未确认;禁止自动重试", error_type=type(error).__name__)
raise
def _sweep(self, client, snapshot, intent, policy, cancel):
if not policy.allow_sweep or self.sweeper is None or value(intent, "task_id"):
return "任务战斗或当前策略不允许普通扫荡"
stage = next((s for s in stages(self.catalog, snapshot) if s.stage_id == str(value(intent, "stage_id"))
and s.level == str(value(intent, "difficulty", "1"))), None)
if stage is None or not stage.sweep:
return "仅三个难度全通且客户端允许的普通关卡可扫荡"
if cancel.is_set():
return "扫荡已取消,未开始"
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)
self.journal.update(record, "sweep_pending")
try:
if self.observer:
self.observer("started", intent, None)
response = self.sweeper.run(client, snapshot, stage, policy)
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 Exception as error:
self._unknown(record, "扫荡结果未确认,禁止自动重试", error_type=type(error).__name__)
raise
@staticmethod
def _call(client, path, payload, *, cancel=None):
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("游戏接口未返回可信的成功响应")
return response
def _record(self, client, record, stage, win, *, cancel=None):
self.journal.update(record, "record_pending")
try:
self._call(client, "battleService/recordBattleResult", {"stageId": str(stage), "cityId": str(stage)[1:2], "result": int(win)}, cancel=cancel)
except Exception:
self.journal.update(record, "record_unknown", message="战果记录未确认,不能重放战斗")
raise
def _unknown(self, record, message, **fields):
phase = "record_unknown" if record["phase"] == "record_unknown" else "unknown"
self.journal.update(record, phase, message=message, **fields)
return message
Binary file not shown.
+336
View File
@@ -0,0 +1,336 @@
{
"artifact": {
"bytes": 242430,
"decoded_sha256": "dd3ba996346dd682d052dfc63e9d8112b1096739df77cd7b2f500703c36d1742",
"name": "combat_tables.json.gz",
"sha256": "1348e2e80c8803dbe4e44999f151d939d847002ddb5aa992acb3aa0086877c12"
},
"artifacts": {
"combat_battles.json.gz": {
"bytes": 1465404,
"decoded_sha256": "b3ecc8bed6190db9b960088022bb845fa422f705908a7b9d8140200d588f924a",
"name": "combat_battles.json.gz",
"sha256": "8d8798040c5d79eb60b971efac8e250cc37f01986cc96d917d3f87af74916515"
},
"combat_tables.json.gz": {
"bytes": 242430,
"decoded_sha256": "dd3ba996346dd682d052dfc63e9d8112b1096739df77cd7b2f500703c36d1742",
"name": "combat_tables.json.gz",
"sha256": "1348e2e80c8803dbe4e44999f151d939d847002ddb5aa992acb3aa0086877c12"
}
},
"attack_sources": {
"net/pixvi/myr/view/attack/AttackType1.as": "0dffc06552cf2a0e382bd30eed877d2e2bc46c87136ef95f415a57b2ecea62d0",
"net/pixvi/myr/view/attack/AttackType10.as": "6c6d1d4b96724a14abb6b8fa0eb099f5bb21b20ea235b1f5e78bf53fb25c0b7d",
"net/pixvi/myr/view/attack/AttackType100.as": "935eb7beee181b9ec91f85ff917bded6b1ebd9436d460009f0b6f980400ddb76",
"net/pixvi/myr/view/attack/AttackType101.as": "8d4305a74797a2f88c4e0a6454e080097edcb42db6bc9e2991fb21d68fc15f8e",
"net/pixvi/myr/view/attack/AttackType103.as": "5b0947393b8ada6dd72d30faef7ce0861f6f410a9de16b4950c37dd202a5a551",
"net/pixvi/myr/view/attack/AttackType104.as": "ab374cd66e63bcd8c9cf3072e34c01b648c086a4309c212bf03feece96327207",
"net/pixvi/myr/view/attack/AttackType105.as": "a34653f6e278dbbfee55e7e9d00279c2bbf810c8ea58217236dbf520ea874444",
"net/pixvi/myr/view/attack/AttackType106.as": "0abe774699386a2244ab8a39787363f3201c3caebfffd7355a9cc51e16552b49",
"net/pixvi/myr/view/attack/AttackType107.as": "745d993e4782741f11e5d5f3bb31c5732e36ba10cc4ac6ceab0e7cc5b871608a",
"net/pixvi/myr/view/attack/AttackType108.as": "875e9d2db43079b59d20d52071e3632825180ca7d1625abc8c2fc7a2b5b102b0",
"net/pixvi/myr/view/attack/AttackType109.as": "f5ad710478d0669ec8cc4a4ab1d2ae7dea0bc9ac32ad48e1aab2211374943a44",
"net/pixvi/myr/view/attack/AttackType11.as": "98b98a51104a23892a5fecf30ec585d459c9c4ab05ea94622d4aba2b8e9f5f0d",
"net/pixvi/myr/view/attack/AttackType110.as": "df2c574bda929d78a11c899a94c0213a0c498d1c809c5c237947481b0944b300",
"net/pixvi/myr/view/attack/AttackType111.as": "fd111aea97ce86a9978514613f957f872001e261676f48346db9ffb6c62058dc",
"net/pixvi/myr/view/attack/AttackType112.as": "63ce66d7ebab8b044bef81eaa5dc723594f158b58d2e64fe88047c88f410ca0e",
"net/pixvi/myr/view/attack/AttackType113.as": "55df84bad4470c10c36cfc0a9381bc7b7835f2b31cff790f6a04ed3551bce5e1",
"net/pixvi/myr/view/attack/AttackType114.as": "882c6272945cc29f38e4a6008042837d7036f9d08af9ec56a3750a60de7c4616",
"net/pixvi/myr/view/attack/AttackType115.as": "66fdefe5e613187633371807db48bead69769adb48d26b93c324afd4437f898b",
"net/pixvi/myr/view/attack/AttackType116.as": "15e9957dcb57d9e9aaaa554cb83faef4d03c0eab5fb542fff19675f8368ed675",
"net/pixvi/myr/view/attack/AttackType117.as": "977dbbe2e2c04a724eeba8573f0337bd2dde4ca199eda14966020b08f4313603",
"net/pixvi/myr/view/attack/AttackType118.as": "ab25bf71f5d18e403e6452c4c567330f301108cfa93b49941b15cc0f6864096f",
"net/pixvi/myr/view/attack/AttackType119.as": "6773e33051522b260b98141fc57ec8c6c72c65c38c215ece0a98cc9c244e3858",
"net/pixvi/myr/view/attack/AttackType12.as": "644a3d29aa83ea9c2ac90c40ebae4229e84e63247d1f0613ead5cd213bc8cbc9",
"net/pixvi/myr/view/attack/AttackType120.as": "2818a113ae7f3f3054c31a4d15d182c3891ff5333f678c04d8e7e0f84e5b47a3",
"net/pixvi/myr/view/attack/AttackType121.as": "9bba26701a1fc3001a0ce6e462120c0e023c4c64ba24500539afeaa8942ec5ed",
"net/pixvi/myr/view/attack/AttackType122.as": "20ddc709700060db16dc77ee35d3eb10197a02c6ca8c79b39e431d247e33135c",
"net/pixvi/myr/view/attack/AttackType123.as": "6cbacf698081d3bd51ede16a73c181cbc0815c01625196ca9db06827495cca16",
"net/pixvi/myr/view/attack/AttackType124.as": "733d2eda0bfa0b9037e2c547ba4d7fe4edf33c4e2ba01510271f439d914d9037",
"net/pixvi/myr/view/attack/AttackType125.as": "0d352666335baf476b75c9cce6b3af9a3a2f9d6fbac0d87fb22a455a0fa26f7e",
"net/pixvi/myr/view/attack/AttackType126.as": "7f775e355c8c6cefa4799fa359bb48ead8bb3825235b0cebb4f837d21bb402df",
"net/pixvi/myr/view/attack/AttackType127.as": "efba984f19354331d1592678293d52308d7753f75af965758ea4541c4d7a83ec",
"net/pixvi/myr/view/attack/AttackType129.as": "dbb285b1a2d3fc8ac9e386164dd6820f667981df472c305981072aba53669d57",
"net/pixvi/myr/view/attack/AttackType13.as": "0c4655520e90c147f0e99a5dd683bb6262283495c0207d401d36912666733990",
"net/pixvi/myr/view/attack/AttackType130.as": "3a96142623ea5ed38ec5963de8732b27993444361e5f8e748de2d33581be3672",
"net/pixvi/myr/view/attack/AttackType131.as": "2cbf0b8dfa3c0c630977b60b738ae777b10b0ea4565d36aa1dea06efb4538450",
"net/pixvi/myr/view/attack/AttackType132.as": "54f572d79db1d5acb0e9c1f697a6d99bc70864b9b625df7b5c07ef0001817b07",
"net/pixvi/myr/view/attack/AttackType133.as": "7a01ecf35c2c1f2f31797775d91a1280fa21786b188f70cbbf95fc298c01595a",
"net/pixvi/myr/view/attack/AttackType134.as": "87fcc3c6e4c24a1a13be051cf2f68556f1e8c33fedda904b64b01d849eba05c6",
"net/pixvi/myr/view/attack/AttackType135.as": "5602be86e8f0ba6c9b01d197f8dc1f924ad8602a77f3641f05d129269a721f3d",
"net/pixvi/myr/view/attack/AttackType136.as": "5a6ff9b57519ac124a5bf7c2aafb4aac92e8b05915955e82e3fc8b99df70e602",
"net/pixvi/myr/view/attack/AttackType137.as": "851f1df4a70fdb2b6cde5515023692a85edf4b26eba0d6cf7d69880e216abf5c",
"net/pixvi/myr/view/attack/AttackType138.as": "a369f54614099cc0bbff87eed83dde2a0ddf496ed29a4499ac02fb7832de0be4",
"net/pixvi/myr/view/attack/AttackType139.as": "d882cbab23627c96c4342d0981936e15454e835305f2b2ed98ebfb61eb4825e1",
"net/pixvi/myr/view/attack/AttackType14.as": "6986f6705444066bb62a324e0f927bf0e4ba80cacf77facb42c94cdabba2b925",
"net/pixvi/myr/view/attack/AttackType140.as": "dc39d24b77e88ca0f86092cd8d68f0167be4d845cad703c8e3aa97552c740eb0",
"net/pixvi/myr/view/attack/AttackType141.as": "2feaea684006b0fa72b39cd61415c8f58bdc33bfac5a86b5d1fbb4acf18bae24",
"net/pixvi/myr/view/attack/AttackType142.as": "62d07f6d11548d975c2873d88b1a848c7c90308e5446e7fd4a0103a120ce330b",
"net/pixvi/myr/view/attack/AttackType143.as": "4371a86e568a59a82aaad269481abe4daba14739fe484666097649827e2b3a31",
"net/pixvi/myr/view/attack/AttackType144.as": "fdc94785f9781b54a22f005274c7c5fbcd04110f7c1164c3e5caa446bad62208",
"net/pixvi/myr/view/attack/AttackType145.as": "9cc056bfcc138518a1bfdea213859c1b479ffc4635fc77314dbd1f85ed70dafe",
"net/pixvi/myr/view/attack/AttackType146.as": "c2dd3bcb089a1fa7b6adeaa4efda51b5c0e6cf34ebd7a7f48e2da26214052e13",
"net/pixvi/myr/view/attack/AttackType147.as": "cf050b3597ee610b17bebd7696d5b0ef302e9d3a11e3383db2c4c7daf1e8b02c",
"net/pixvi/myr/view/attack/AttackType148.as": "df27b64bbec556bf9042faf94607f51775b903ae5c8671a196df8eb90dd640aa",
"net/pixvi/myr/view/attack/AttackType149.as": "3e82c4d78f2118bf61bc3b471d475ae49bf2d5eefeb508628820453d90e66e9b",
"net/pixvi/myr/view/attack/AttackType15.as": "087b4797c732b50acade0305640f5fc69e38907b4574c007d8ee145d53fe4c2c",
"net/pixvi/myr/view/attack/AttackType150.as": "ee959a667c2bc18bb3954ca52b8fefa7728d9f1ce78dd8c167f5aa769815fb9c",
"net/pixvi/myr/view/attack/AttackType151.as": "fc92767832c39c1484851da08efec1c4ad8460159a07d2d802e9b62c447d52f3",
"net/pixvi/myr/view/attack/AttackType152.as": "7fa3c669492ffd8701c0d481e32e8f524aa9d66ae8a3e993e36ec4867009402f",
"net/pixvi/myr/view/attack/AttackType153.as": "d57169f5e30d9a8cfc0537224db0ec2f4911ef192bcf1729b22da491a559e9fb",
"net/pixvi/myr/view/attack/AttackType154.as": "f737893f9cd07637e3643b63247bc0da7860a31531247e897329a6a8479d7106",
"net/pixvi/myr/view/attack/AttackType155.as": "204d9066aa2a407a89a2fdd27c12d670c66cec4ca32b2e2c509d7b2e2862d3c4",
"net/pixvi/myr/view/attack/AttackType156.as": "27f91fddf1bbd34051271e71db28bc243466e863ddb2f4ac0d090981d6f76655",
"net/pixvi/myr/view/attack/AttackType157.as": "90e47846087eb12260253155d4f4742ff9c756817c0965d1fa800ca73da4784e",
"net/pixvi/myr/view/attack/AttackType159.as": "ad2d2ffe5968fde2e5fba35d229da96a12df1c520663c3d8436cb4d49e02f6be",
"net/pixvi/myr/view/attack/AttackType16.as": "3cbb8838e547d15e20ef4d26c7ef2efe151ed00dd8e85b95809562bcf56aa4e3",
"net/pixvi/myr/view/attack/AttackType161.as": "50d6819563e7b5a77f653278c609c357f19a8eba35ba1f149fc47dbeef3f31bf",
"net/pixvi/myr/view/attack/AttackType162.as": "20c710190af9dc57aa81aeed6b9f4875234e88a84356c49c25501eb1fe5aaec8",
"net/pixvi/myr/view/attack/AttackType163.as": "8e85047f44f6019dd8d7387532f7d67c41c1504bfbbb3b9e1dbd7f80f22bed8c",
"net/pixvi/myr/view/attack/AttackType164.as": "7adc1d4ad8c996314a07007456ecb89c72654098d060139c7a7486091309ba3c",
"net/pixvi/myr/view/attack/AttackType165.as": "323e06ca412dd3bc14055851610d6a4bcf190614c04f16fec818301ca64455d2",
"net/pixvi/myr/view/attack/AttackType166.as": "a074dfdd3f8102a3ddad9eaabd88bf8c4e863537d745da15ecbc68eaaa9f9632",
"net/pixvi/myr/view/attack/AttackType167.as": "3cad12e54bb746d257adc436aba2caa5c7d3ba0e91daa4dbbc28e4ec288d8801",
"net/pixvi/myr/view/attack/AttackType168.as": "1a459d0454da026b5d317859efe410a160be15444c9ca68a1238015f00a37acd",
"net/pixvi/myr/view/attack/AttackType169.as": "8de58d6d7a63162ab134ca6931e4f38e9778e33a4251a8a61c9d21942bf984a1",
"net/pixvi/myr/view/attack/AttackType17.as": "8e6d41c9a474919bc0cca92677eec296c5fb372573b3fffd46fe4c4bfbeef9f1",
"net/pixvi/myr/view/attack/AttackType170.as": "c9077b83e5a9bce3e5c2201c07b2c6d926e3e7ea9e400e7ddab401ca0b112b77",
"net/pixvi/myr/view/attack/AttackType171.as": "9b266e40b6cbb05058449b342aaecae0ee0e26dece9d0d4e8587479b7028c6e4",
"net/pixvi/myr/view/attack/AttackType172.as": "1627326b34268b3d1f3ed4bb9b43ce883b6f5357bd8e0238ef3bc811e19bd2a9",
"net/pixvi/myr/view/attack/AttackType173.as": "2fbfaa83e3b533d00f3016a1fac5b87fefb28a06eefb02ec82869897c3ffeb93",
"net/pixvi/myr/view/attack/AttackType174.as": "436a986d644fac77e43f8377bc276600ca9d010f28b7bc4389060ced6e97c92a",
"net/pixvi/myr/view/attack/AttackType175.as": "bf6512783506026d0e9ebb6c72f698fb97c912ab9e66d2b4db8851428e9ac336",
"net/pixvi/myr/view/attack/AttackType176.as": "8a8bbea7f6fcfd2596be161c1d2c72784632329e902ffaf69b81672fa6b0c339",
"net/pixvi/myr/view/attack/AttackType177.as": "f92ee0d405cf0be5558bc4818c35057dc975a4f16254a5e2510fe1967656fcfc",
"net/pixvi/myr/view/attack/AttackType178.as": "5a3d2a51a7fc797a86a6c6cc539f84db7663a6487d446f2fbe612c37f5af7560",
"net/pixvi/myr/view/attack/AttackType179.as": "d90de0d02651d9c2f6f9a50e970693d967e3a4f23089ac521f32c9a8f3a2c0bc",
"net/pixvi/myr/view/attack/AttackType18.as": "fcbf833515bfc5f3e3ba25385d767c92aff3623c1d81ba1979d2f1651ed60642",
"net/pixvi/myr/view/attack/AttackType180.as": "f8f7fdff5cd8616473a87b370c1cc29d65fd94d4daf5aed079c5698dc3c0f2a6",
"net/pixvi/myr/view/attack/AttackType181.as": "b41c85e623a00d1fb2e12502f59fb33d30e16753f3255c0263cc6436014fe288",
"net/pixvi/myr/view/attack/AttackType182.as": "fe3b6b96fa41d7ee5d498bac024d88d69eb2f876bd737394e63b5fdd7f8438af",
"net/pixvi/myr/view/attack/AttackType183.as": "e111732254e4d768dce458e637ca7960397e50406ba5110244eb09313037b8ba",
"net/pixvi/myr/view/attack/AttackType184.as": "6e10dfbf19f041f941cd44f8b4c15a0df6b636a00319c1b14642579742dd63e3",
"net/pixvi/myr/view/attack/AttackType185.as": "2789ec6290683d0b97cad976dd9be6dc678e8525947fd565551772f8c4ea0008",
"net/pixvi/myr/view/attack/AttackType186.as": "205e9d06a7012ae9ea1bc5b59d143906d55b2a53ecc2a2e7e178a2906e393b4b",
"net/pixvi/myr/view/attack/AttackType187.as": "af1c3b003a51e7a1fc4df3abea6c18ee60afec748b2e2295d6551fdad9eef657",
"net/pixvi/myr/view/attack/AttackType188.as": "a06a06e75901f94bdcb6b4182457e900d688b3a91e96073f3e6271c373af3709",
"net/pixvi/myr/view/attack/AttackType189.as": "00cc15523cf73fd167978bb24dd113a01c1c11fff37628e48c3d2446a6b6486b",
"net/pixvi/myr/view/attack/AttackType19.as": "70b66c36d589b1558e5ec18a2e9dcad5208af2d235c29938b58004fdfee1fc81",
"net/pixvi/myr/view/attack/AttackType190.as": "72a8750997a341b1db297a4243962c5baa019c05a69f88ed7e3abb73bba11e78",
"net/pixvi/myr/view/attack/AttackType191.as": "f5a64c46e0b4db246f36ee3f625c4d87e07d063e56b7654eb09e5c23194d1d4c",
"net/pixvi/myr/view/attack/AttackType192.as": "48dbc616501f01f15b38b8b566e0eb629e57d6cd6f24b301b236a2bc5c1367e9",
"net/pixvi/myr/view/attack/AttackType193.as": "a1ac302369634d93ab00151bdc4696f683d49fc2b79554cad7e981b10ab6a52d",
"net/pixvi/myr/view/attack/AttackType194.as": "197128dcc29002a4753cff7abb72b3001faabbff15356bf2792827a94f4dad54",
"net/pixvi/myr/view/attack/AttackType195.as": "01e0d38843a19deb8fe3889d517117396355e2729db14116744b9b5cccea6b57",
"net/pixvi/myr/view/attack/AttackType196.as": "d9b4f60d278d42796dc348426d92f76503cabff904497c269812d43a2041d0c5",
"net/pixvi/myr/view/attack/AttackType197.as": "1fd3c13ab5b7b76644ec7039423782837b6440312ac862fd8ea52744f9d520c9",
"net/pixvi/myr/view/attack/AttackType198.as": "3b7f4522e9a309a7b510467b3160f852b2fb8b06d5dea3c5b0a56cdfe5c39d99",
"net/pixvi/myr/view/attack/AttackType199.as": "8f69cd93990909829b9500dfedb46c9df1b8f8bd4251f087cc49d70506176e6a",
"net/pixvi/myr/view/attack/AttackType2.as": "11d7ac16ec956905ce455886bcaf12d52b889e5b835100e2a7deae76830a2cc0",
"net/pixvi/myr/view/attack/AttackType20.as": "44a8f8bfc0388c95f7daf564fac429b021fa45de6d4d001f0489ed76fda5b935",
"net/pixvi/myr/view/attack/AttackType21.as": "f07fc1544ce46c6c03dd8c80c63cb4239e6f5ea9e05a905f6c0a629062ba3510",
"net/pixvi/myr/view/attack/AttackType22.as": "a2f5e8ecc2ebfa2e7d46a97c6175fe9fd17942bd5ca0643febb058a2b75e8809",
"net/pixvi/myr/view/attack/AttackType23.as": "0a4f4ff4b4e8942361c2fb4e92cab873ef458cca500507703094aaf78b7e9f57",
"net/pixvi/myr/view/attack/AttackType24.as": "c2ad78ae100cdc83452f814b5ef49990fe0b73a1863af7bb8b3e06e70a087155",
"net/pixvi/myr/view/attack/AttackType25.as": "fb86a08860c54541db2aee35fc47c73233a94652caeb9cb96ff8168d6ae23016",
"net/pixvi/myr/view/attack/AttackType26.as": "cb0238e0251a34a246f7273a63161021814fbc532a6e3b8ebf1e623617743e78",
"net/pixvi/myr/view/attack/AttackType27.as": "fb07c83055653a911cbfba1ff047056a5086998b550c453e5b8a74eae9e68c74",
"net/pixvi/myr/view/attack/AttackType28.as": "dfa44ffb29ce7473c60192809575802968d999036ae668a77e88101686204216",
"net/pixvi/myr/view/attack/AttackType29.as": "03b231e5dc9edbd634fa5e26c959cd8242a79a2a5f52884f3a07ccb1b2dfd3c7",
"net/pixvi/myr/view/attack/AttackType3.as": "1fd991981bcc58a0f1cbaeb0ac37f78f73e22146f7745ff5c9b0919ffd6e824f",
"net/pixvi/myr/view/attack/AttackType30.as": "46252e49598b802a2b6a456f3acee115f3bad7417b2494ff49ce2e2ad7099050",
"net/pixvi/myr/view/attack/AttackType31.as": "d6fcc6f03cb77265bdba9d37f0d82f1e450ec3ccfb17f6ca131e610e7c3db8a8",
"net/pixvi/myr/view/attack/AttackType32.as": "e4c542f5cbd719f30b2b076575d3cf8dadc4b02cabe1ca37269e3593fb3e26a1",
"net/pixvi/myr/view/attack/AttackType33.as": "e34da954bd5538928b7019155df2ba3e99f25f6880775a9bc60eef08216d1d2a",
"net/pixvi/myr/view/attack/AttackType34.as": "f8f27ac279a5e1ee404eacdbb7d5dc7fe21401a43d2d1e622c64e6af92072ddb",
"net/pixvi/myr/view/attack/AttackType35.as": "ff57aa89b4b06949ee69fa4219c364c1cc47c1f69fb9a33cbae3ffc4d5fcbea6",
"net/pixvi/myr/view/attack/AttackType36.as": "853b3f2f330e134e7696756d728f1e6f67d625aecccd458f87af368a9c90d033",
"net/pixvi/myr/view/attack/AttackType37.as": "f14ffa6e9b75f1a1a45891a7d4e5155e912088584ea5242368e2f1b780d12e7a",
"net/pixvi/myr/view/attack/AttackType38.as": "33cc7324a5b0a5b11634f2cf6393a37e28d30a3ae5da84f2fae898118f9b959e",
"net/pixvi/myr/view/attack/AttackType39.as": "9dc5430dc4fd2f7894ea67556270d393372a220b5bb86e7234ddedcfbe748016",
"net/pixvi/myr/view/attack/AttackType4.as": "1422775f7e9751002167280c3e73921783911f1a239f20550f294ba728a99ce6",
"net/pixvi/myr/view/attack/AttackType40.as": "afc3bf6d31b06eaf5e6d756c0ae103c7f8786df1bc3f811c6f993ca0deb405d3",
"net/pixvi/myr/view/attack/AttackType41.as": "6a92bc1459bc97df9dd0e605268760dc13498c35709fde7aa61ee51ac22a0eae",
"net/pixvi/myr/view/attack/AttackType42.as": "3c190ce02663246985f9d007549aa94fcf5bd701584289446d90d39941c54dab",
"net/pixvi/myr/view/attack/AttackType45.as": "28d54d026806fb95c5312277609ffbe5d7133148fdf6c3b1411e5681c6418b58",
"net/pixvi/myr/view/attack/AttackType46.as": "42ce24054433264fa277236dc50c2892dd16c381f151ed6dbed3815debe8483d",
"net/pixvi/myr/view/attack/AttackType47.as": "7708f991956ce989f56dda081cb38e27aa5b686e9b6f4010a71f284171d5360d",
"net/pixvi/myr/view/attack/AttackType48.as": "752a7136c5b56a5f0a4da6cd9b3e74643548947573d8f1c70672d07f98101119",
"net/pixvi/myr/view/attack/AttackType49.as": "2a4edf8a2932f0aadc198d52184512e57d62fe72dbb23f8d8ebbd55a400f2243",
"net/pixvi/myr/view/attack/AttackType5.as": "32f0c68d7dc78c5ff3d2a49bca86771c2ab9e9dbb49c44011ccf228f59b78566",
"net/pixvi/myr/view/attack/AttackType50.as": "3b41931ae51634ade5deb2c50314f1989047b78eabbdff4e40ac9d2b9d8c8139",
"net/pixvi/myr/view/attack/AttackType51.as": "d4c5fed8aa2defc4f68f63c7f834aae14397f92b3f14635544de6390f47f044a",
"net/pixvi/myr/view/attack/AttackType52.as": "e5d9e6ccab505d046adcafd5b8a1a8b171111f1d5c35bfeecfe2d539b566fcd5",
"net/pixvi/myr/view/attack/AttackType53.as": "5958aa3bd0b6430eb01eac7e6bc786752faa608786584dab732abc7eaa7eb463",
"net/pixvi/myr/view/attack/AttackType54.as": "cab1ae59f0336c5c11d5101bb6225f65b0d4b761907de49488de46e042511d19",
"net/pixvi/myr/view/attack/AttackType55.as": "cc3276af937449fc14e4175b72a4d66626a326234fb90a06d1c4052b822042a9",
"net/pixvi/myr/view/attack/AttackType56.as": "9ebf3bd60bb88ca87106c417dae10e73c034da28667c34a46857c07583feeef9",
"net/pixvi/myr/view/attack/AttackType57.as": "821ca9c2a194319577d75bea0c5960c8fe3d86b59bbe4ecc9716bd694aa8a760",
"net/pixvi/myr/view/attack/AttackType58.as": "bbcce3d45da79d28298550df76c88516c69291a1e13a7acaa29347a414d5c529",
"net/pixvi/myr/view/attack/AttackType59.as": "a63f9b041892325656ca692715929f8564665e5368eed3494c615fe88669957e",
"net/pixvi/myr/view/attack/AttackType6.as": "e89b64a54d754d4eeea548b867652fdbe6d7cd3c9f55674a85f797fbd6a043ae",
"net/pixvi/myr/view/attack/AttackType60.as": "92b4b5356b505f47b703bb4540a0c8c79a7a5ad9015b2f7ca65d35a8c277d2b2",
"net/pixvi/myr/view/attack/AttackType61.as": "7da4e03069543f9bb6d9452c0b072a2468f310462da554e32dbf51e0981ddf6b",
"net/pixvi/myr/view/attack/AttackType62.as": "76468a4f435e039851eba8818791c04bdb380e3dedda2bb1ed9c06eeb6fff140",
"net/pixvi/myr/view/attack/AttackType63.as": "601bfe31181613a89e679c6d10b63c397c21a3b0155a756767a7f3936d34d4e0",
"net/pixvi/myr/view/attack/AttackType64.as": "e2e71fed79135e9c7673a0b5623257e088c265e70d23102d7fa62490faf7379e",
"net/pixvi/myr/view/attack/AttackType65.as": "03d9d8117f38f1c4a55bee9d16e1fe0279a12bdd7ccdb5b3ba56a2bc22b1ef80",
"net/pixvi/myr/view/attack/AttackType66.as": "c3c66e956d036c4d65cb829a8a063914f91c7b58b0f5926e47800771ec90698c",
"net/pixvi/myr/view/attack/AttackType67.as": "a654f614cf92c0ce90489a3e86233ade0fe82a1f489e020bc5cbcdff505c7174",
"net/pixvi/myr/view/attack/AttackType68.as": "997def7202226e486415283e1c08794992e609088580a099904ec5e134e37145",
"net/pixvi/myr/view/attack/AttackType69.as": "6788f24562510db10ae80a43fd7ebaafb130ca4e18550cce6e9f27ac877843cc",
"net/pixvi/myr/view/attack/AttackType7.as": "3beb8725a71189fd12f72616c9c748d81a53d08bf4d11d2d98834c89e0e47906",
"net/pixvi/myr/view/attack/AttackType70.as": "e695bd657fb6aa5ab088234226d691c1649b2050066fd272fa83e72d0c7ca2ca",
"net/pixvi/myr/view/attack/AttackType71.as": "56d36824b5f45491dc6177396ac479ca1e48a0e69d0ecd55309d24bf1a5cd367",
"net/pixvi/myr/view/attack/AttackType72.as": "27d729b9f466d8771c37b494e5a7665f852eefc8ed07819d5a935218c8abb15a",
"net/pixvi/myr/view/attack/AttackType73.as": "97a7df2ef72f3164d8b37bb55f25fd4ab13dbb3c81070deb159f6311c66bb754",
"net/pixvi/myr/view/attack/AttackType74.as": "66d3d2fd44d4919407f4c39e92d2c782b322b584c20f27f418ed926ffe5cfc4a",
"net/pixvi/myr/view/attack/AttackType75.as": "ab3642aba6d6edc56dbbd13d6145efae83676c2fd0c6f999e468ab1dcd10ef84",
"net/pixvi/myr/view/attack/AttackType76.as": "74482eb72c07dbb7d029b26d1cae7f870373f6a4b283081349db76f3ca0d5d7c",
"net/pixvi/myr/view/attack/AttackType77.as": "a3acef9185308cd283afea3deff491b70fbf5d3de64a9834aad5a5ef8f167841",
"net/pixvi/myr/view/attack/AttackType78.as": "4cd107cf64c2570a64e667359871619c39f4d6c9c867cc3156e68a162072101d",
"net/pixvi/myr/view/attack/AttackType79.as": "5701373df6d08bcc5d89c7a92843b468f97ffef0211fcfeef03c05d2918626f0",
"net/pixvi/myr/view/attack/AttackType8.as": "3f12d1e9eeb3fd01644b814d1abfc425fed2fa041404a5fe70d96c50ed778f1c",
"net/pixvi/myr/view/attack/AttackType80.as": "4f92579c57f6ab40c1d3e85e32cba0e67aee496cba49e032e8932cf513e19ba9",
"net/pixvi/myr/view/attack/AttackType81.as": "b6301fb386483fe769d3ad5d8d54dbc7c5ef31a6bbdfdfc59b432b4dd1fc5bd8",
"net/pixvi/myr/view/attack/AttackType82.as": "8e306dba1c95661095716fb97e865c610c98babe635d96fc7b93c264aadffdb3",
"net/pixvi/myr/view/attack/AttackType83.as": "55ccd1b7480b5120b47f4c83820fc567bab11bb116b0364c8e9d75a2fc2e1c7e",
"net/pixvi/myr/view/attack/AttackType84.as": "b18ea22798aec560fac108dca48b23c19d64b5d0040b4881f91be77b5b7c61a4",
"net/pixvi/myr/view/attack/AttackType85.as": "4182a5a89472bc807206b431a9f7ca765b1b2be87b5e22996a9a42f47774869f",
"net/pixvi/myr/view/attack/AttackType86.as": "944db4431ed87edf20827984336280d3b5d3fc428f1a2191eb988050b5d2c21b",
"net/pixvi/myr/view/attack/AttackType87.as": "25c92f209834c79e6ba3498d98c93339e0245a7b9b51129ca17a860729f227f0",
"net/pixvi/myr/view/attack/AttackType88.as": "559c7cb9f95184f76d99fb006849f78adf5d1e159aa77d90bd3b64153901dcbb",
"net/pixvi/myr/view/attack/AttackType89.as": "d65b9f1e7e21d7dbc82032ff826e927bdfc0eed0519809058db25fcae854c8bf",
"net/pixvi/myr/view/attack/AttackType9.as": "7e38d439e41c7e22a8fc33ecd5cc4c91b6dca89965db4c129c0b2fb7a3e26b0f",
"net/pixvi/myr/view/attack/AttackType90.as": "3952c1ebb4f8d73e03c6e246fc7a1ab481de642b61be1ce993eb3515ce87908c",
"net/pixvi/myr/view/attack/AttackType91.as": "e6f3a19bbabbbd58a4bfe421801821b47e9f418ea9a9c12d1ddf5f531c7ad3a8",
"net/pixvi/myr/view/attack/AttackType92.as": "adc98f8657b64e1af3b4bfbabe6e6021552b7b9ce7ba722fa04d100577607a34",
"net/pixvi/myr/view/attack/AttackType93.as": "56bf88bb8b76f76c27fdcedb599aa37a5e0a138299766747dc78e3baa75eb024",
"net/pixvi/myr/view/attack/AttackType94.as": "ebf37c24a1ff73a741040e71bb92c464000f9acc2b13b6aadec8074fa63a3798",
"net/pixvi/myr/view/attack/AttackType95.as": "1c231e8854d3396d5dd2e47be7182ba059f1da5f71e18434f5de0032f0d72033",
"net/pixvi/myr/view/attack/AttackType96.as": "8490bd84bb19a054580c609440b38a6a9ddbb1e2dffe4c262c0c604e506260fc",
"net/pixvi/myr/view/attack/AttackType97.as": "736600dbce8b0999cc3f55ac946d9d7454b2bec0d9f0097c8b20a810079cb3ce",
"net/pixvi/myr/view/attack/AttackType98.as": "1c5e8ca69ae457cc3e4760181e0218ae1133c1e19d53f6931adcb24ea058db0b",
"net/pixvi/myr/view/attack/AttackType99.as": "51c76ccaf2c59e36c699e2c911c39c22f397989f1d2130dae27e7d0b20230f20",
"net/pixvi/myr/view/attack/BaseAttack.as": "6eb67299c8a228f82fe72e98ee363c7832b6d79d359fe896da2170e0c0b2598c",
"net/pixvi/myr/view/attack/action/BaseHitAction.as": "a206304b74660bda2a2b44c1cf4f8a3d4476383152869add2270bfdbbbfd2d11",
"net/pixvi/myr/view/attack/action/HitAction10XScalehit.as": "c46050034738af4008a9262a94f3e032aba66c18f437a5ef9791f9dd1c8b65b1",
"net/pixvi/myr/view/attack/action/HitAction1Jumphit.as": "708c37ac00c953fc0e4247a33000226f1d2cc3223dca5d7ff1a71ddca02bebc4",
"net/pixvi/myr/view/attack/action/HitAction2YScalehit.as": "013208ab246f7c6dc52aba094a84b20f8bfdb96862ae45f274e438ec5cefc0b2",
"net/pixvi/myr/view/attack/action/HitAction3Horizonhit.as": "2dba19351fec44c3d647345b4966d3a10d74496e33a559e264e2cb05956c92a9",
"net/pixvi/myr/view/attack/action/HitAction4Ymovehit.as": "7edfe705a05df20ca1a564f997044855e410a0e44e6917c0cb29599bc0ce016a",
"net/pixvi/myr/view/attack/action/HitAction5Nonehit.as": "d16cc43eb246365d1dd5a08a62a744652b2103f6c671232cbc18d6bd46556196",
"net/pixvi/myr/view/attack/action/HitAction6HorizonhitDelay.as": "35d62d8defefb6aafcdb0dd29fa20473a943046ebab35b596967628af558c0ac",
"net/pixvi/myr/view/attack/action/HitAction7HorizionhitQuick.as": "670b5da16c54c22b578757eec146f29f154ad53eff2ecd6ce3fb868dd814a617",
"net/pixvi/myr/view/attack/action/HitAction8FrontHit.as": "46d765d27c47674dec866107d8cf66acfe8710acc982c83b53a5e1217fcd2e35",
"net/pixvi/myr/view/attack/action/HitAction9Jumphit2.as": "ee8ca7eb8a556ef3f19f4655a616b711dce82aa441d9882bee29975c82a707bf",
"net/pixvi/myr/view/attack/action/type/HitActionType.as": "a4b25f7c2f790ff6d8c3eb0c25cbd2ad4102ef97419673cd390d3cd4f94847e6",
"net/pixvi/myr/view/attack/type/AttackType.as": "66c3825acebff052befe99b8b0057b1330591e95ee5bab8d1969c0935614e5e4"
},
"original_frame_rate": 50.0,
"schema_version": 1,
"scope": "Public original combat tables; experimental simulator, not engine fidelity.",
"source": {
"apk_sha256": "01678ee3a8465d818d32cbbd94baa0d8253b04b4c57b70ebc5544ed341f1015d",
"main_swf_sha256": "c6838331a198a22ffa486cbf61cc74c97619e011bc3364c8bb8dc99e269036cf"
},
"tables": {
"entangle_info": {
"compressed_bytes": 1040,
"decoded_bytes": 1820,
"logical_path": "data/table/entangle_info.json",
"member": "assets/codes/e814d801e619000ae8af8f08fcbdc5b8",
"record_count": 8,
"sha256": "9be02321151385379b0992053a41f2df6e911d6e3a9474701c118faad386e8b0"
},
"game_setting": {
"compressed_bytes": 3559,
"decoded_bytes": 5820,
"logical_path": "data/table/game_setting.json",
"member": "assets/codes/f1c2e2603d6c82bbb8b5f94585273208",
"record_count": 141,
"sha256": "8810981688414e3cef520976911d16e2847df0a435dccd792e2dd527695283e3"
},
"item_info": {
"compressed_bytes": 132384,
"decoded_bytes": 494454,
"logical_path": "data/table/item_info.json",
"member": "assets/codes/1cabfff17cd6d6a38368b9068204329d",
"record_count": 2079,
"sha256": "9beeab37d107b09d02c4491a052594390c874c92328f524752080f5a7fab21e2"
},
"monster_info": {
"compressed_bytes": 219398,
"decoded_bytes": 933486,
"logical_path": "data/table/monster_info.json",
"member": "assets/codes/08b83182d2a7882bfe2bb0ed710d343f",
"record_count": 749,
"sha256": "081747ddc5b7afba03f69e65f5eba6af815b9fbd3ea7e0821c7f8807d9486921"
},
"monster_setting": {
"compressed_bytes": 6687,
"decoded_bytes": 22488,
"logical_path": "data/table/monster_setting.json",
"member": "assets/codes/1d188dbf8ca7a253fb2e5bc2475b2669",
"record_count": 11,
"sha256": "49388d221e3d4461fede3b176526d593ec0f1647a8b93a8d2b33a712761febab"
},
"monster_skill": {
"compressed_bytes": 50349,
"decoded_bytes": 236294,
"logical_path": "data/table/monster_skill.json",
"member": "assets/codes/8da7ff8cb5aeb85080ac37ca677f52ef",
"record_count": 266,
"sha256": "0fea0eb8553a4868ff704210e9adfd09c6e2b2c3b2730e9ebe25642fa478bf9b"
},
"potential_info": {
"compressed_bytes": 992,
"decoded_bytes": 1913,
"logical_path": "data/table/potential_info.json",
"member": "assets/codes/f4b5363a0460df23903e7f605c50f82e",
"record_count": 13,
"sha256": "cf43bde8204ed1e13c555cfc48df5a54ea7f2df7813e017a04ba02f0453d7895"
},
"setting": {
"compressed_bytes": 14422,
"decoded_bytes": 47740,
"logical_path": "data/table/setting.json",
"member": "assets/codes/82885f1c0190a591b6aaee2521bf3daa",
"record_count": 64,
"sha256": "68bb8d2ee882a1c14b98315eb61dfb3545dc633173b53409b1dec3af68fb7af3"
},
"stage_info": {
"compressed_bytes": 1061791,
"decoded_bytes": 19703775,
"logical_path": "data/table/stage_info.json",
"member": "assets/codes/9484cfff9fb912e4791832375e771475",
"record_count": 1178,
"sha256": "47ccef41d460f4ef23732624cf302e863a22ca33148dc02629841d764c38b487"
},
"task_info": {
"compressed_bytes": 271024,
"decoded_bytes": 1622428,
"logical_path": "data/table/task_info.json",
"member": "assets/codes/70d0e869536fc2b968582dd1f1ea86d6",
"record_count": 1165,
"sha256": "b833985c54e11f3079a3ccc53709f87d25b1f8301699b3eb99613a826a469744"
},
"team_info": {
"compressed_bytes": 1961,
"decoded_bytes": 4416,
"logical_path": "data/table/team_info.json",
"member": "assets/codes/26e7c61bf20be81add4b8335bf8623ed",
"record_count": 10,
"sha256": "21254655b6966ab67d5b3f1105568ab6ed13e2eecc4f05d27ef016de0e34ced2"
},
"upstar_info": {
"compressed_bytes": 177,
"decoded_bytes": 326,
"logical_path": "data/table/upstar_info.json",
"member": "assets/codes/3498a00946020cb39986776e1dc87f79",
"record_count": 7,
"sha256": "b53db40bd0c94e0c0fff7e6c1bc5519b05c0aa353f4ba384cd3062ad5865c350"
}
}
}
Binary file not shown.
Binary file not shown.
Binary file not shown.
@@ -0,0 +1,165 @@
{
"artifacts": {
"progression.json.gz": {
"bytes": 779024,
"decoded_bytes": 8710604,
"decoded_sha256": "213a8ab328522c7b033cc17ffe6da79cd4eb3584edb734a411cec354b836685c",
"sha256": "f3255cc27be99520af0fafc43769492138c5794bb1a65ae83c5d8c732505b8a4"
},
"progression_battles.zip": {
"bytes": 2457497,
"sha256": "30ba36932d57051f9873b57c64d1f79d0cf2e564b53d2c1d74beb8450e9a8328"
},
"progression_support.json": {
"bytes": 18760,
"sha256": "d6d98cbc6fe115e636b169f315f5c8f72dc1f9c360c54b4f055809148c8ec948"
}
},
"as3_sources": {
"analysis/as3/scripts/net/pixvi/myr/battle/BattleGround.as": "d2e8679fb3557163d9ac57aca3405e27bb5140364f528b6a073adffd27dd5c54",
"analysis/as3/scripts/net/pixvi/myr/center/BagCenter.as": "846213b6f72da7ee6fb653d22717ecf5e42fe96b4723b3c7fc205d7991da2638",
"analysis/as3/scripts/net/pixvi/myr/center/GuideCenter.as": "e4728dde31c6d1ec89cfa600e86685e384f5ac2b64a76c7aa663dff66ef79cb8",
"analysis/as3/scripts/net/pixvi/myr/center/LibCenter.as": "3630efbb0c20a5ab778bcc63177377f454b0d6318dc56d68ecdb1545c3e3b7a4",
"analysis/as3/scripts/net/pixvi/myr/center/MonsterCenter.as": "5c3c5f80de4e6ce22b6a2d4ae218b3c760a4bcf34243265f62c516d5e3c7f06d",
"analysis/as3/scripts/net/pixvi/myr/center/PosCenter.as": "cf3843df8abc588b6857ab3155684c5434a88f369b80cfcdd7d8af63ed8d15f5",
"analysis/as3/scripts/net/pixvi/myr/center/StageCenter.as": "5e477ecafeecfc1ce2e0d1fea160ed05b2483825abe6e7dd4ff2971a28fcbc59",
"analysis/as3/scripts/net/pixvi/myr/center/TaskCenter.as": "0cc9770aa214d98bdfede7f6130ca948e428cd8280e3c4f2f3107176b9d73dcc",
"analysis/as3/scripts/net/pixvi/myr/element/city/CityVo.as": "9631e65acc6a50c2308780bbe60e20e7840b7a26114d74cde71a196916f3fe35",
"analysis/as3/scripts/net/pixvi/myr/element/npc/ConditionVo.as": "c76a2ec36571737897c509e0fe8ee39b9134fe2315727b77d0c858f5fd26d410",
"analysis/as3/scripts/net/pixvi/myr/element/reward/RewardPieceVo.as": "45f397a734efcab23d2a4827042568e54a2847667a15e15579d20e96ad2a4e3d",
"analysis/as3/scripts/net/pixvi/myr/element/stage/StageVo.as": "3a5c25d60fd60e699c75c04bf2102e100c325f9e07fe12c86ae15c3f77dd8f84",
"analysis/as3/scripts/net/pixvi/myr/element/task/TaskStatusType.as": "ce8b50bfca362428f624fdccea95d6697cad6b23670ac2e83a1ba4bd0afb1335",
"analysis/as3/scripts/net/pixvi/myr/element/task/TaskStepVo.as": "bc7c7f418260257a9df66642b158b5765491ea7e0a7bc88b1fe938cbcbd2c41a",
"analysis/as3/scripts/net/pixvi/myr/element/task/TaskType.as": "c5bc4eae6027ae7b00712893bb4563d84d90c924f64192cdac19e0fa7174722b",
"analysis/as3/scripts/net/pixvi/myr/element/task/TaskVo.as": "e996300986dac7db2adfe713058dd26e1459c2900cab94a07c5c51f1a03f59a9",
"analysis/as3/scripts/net/pixvi/myr/net/NetBattle.as": "5fc5558b72bdd016a664b423f145d31bdc035f2af4619357e1a1387cf4163cdf",
"analysis/as3/scripts/net/pixvi/myr/net/NetTask.as": "b54f07bca6912aa93472cf607e8710ff3941586d77422bdda2cbeb4f481c42dc",
"analysis/as3/scripts/net/pixvi/myr/panel/battle/BattlePanel.as": "5540956d4a4e4b35617ffda13b10f4b69ced5efaa247fb553d398c2f0ddf50bf",
"analysis/as3/scripts/net/pixvi/myr/panel/loopStagePanel/LoopStagePanel.as": "4a210a6178f5c0c670ed54ea10b58fdca1f6d30a02b2ee0e131336f517ed282f",
"analysis/as3/scripts/net/pixvi/myr/panel/stage/StagePanel.as": "39d9291d447833a546f0400d303c177ca4f9a1177dedfc73c3116b0ddfa3b104",
"analysis/as3/scripts/net/pixvi/myr/panel/stage/StageStartPanel.as": "faf901b266f1786cdeefe8aee394c114e6c96c7c4d87b1dfacb1ec009926a797",
"analysis/as3/scripts/net/pixvi/myr/panel/story/GAoNanoEventVo.as": "a67602f2de90bdc08d2bac91c7f86a376414e1a71d5c387d0116479b123bbb7d",
"analysis/as3/scripts/net/pixvi/myr/panel/story/StoryPanel.as": "626c661a104847963dc60cf139227b27565a50bbf2569edaa95dc3fceeb693df",
"analysis/as3/scripts/net/pixvi/myr/panel/task/TaskViewPanel.as": "d59c6a34affb7f8d5409facc010ff226108243f5f0a2b3cbd21a2ace9f5507bc",
"analysis/as3/scripts/net/pixvi/myr/panel/taskstartpanel/TaskStartPanel.as": "a3123e266f0f8b87a2f3218af3cf23fc5646224b2b1f59e73f2965ba68bcfb18",
"analysis/as3/scripts/net/pixvi/myr/panel/wild/AreaIconUI.as": "34d961f71b0d8f8030affb8209a6d5b833c6a26e1f096585cae32408180437ea",
"analysis/as3/scripts/net/pixvi/myr/panel/wild/AreaPositionIconUI.as": "f2628f23a751b1ce02186e60be3b9d1a5a2fc03f7e4257f7630532bde846389f",
"analysis/as3/scripts/net/pixvi/myr/panel/wild/AreaVo.as": "c085696d9c928be393f30fef03eaa0f4f749313e66d18992ddb19c1d493f0913",
"analysis/as3/scripts/net/pixvi/myr/panel/wild/StageMap.as": "15f99de22e9bbee8d029dcc9272dee91761bf33c4f091597e63b18a3d1ca713d",
"analysis/as3/scripts/net/pixvi/myr/panel/wild/WildPanel.as": "f66ce96cb780c3316f2973a5e7b6e90904c772be79b01768acce6d479fbff5b0"
},
"builder": {
"python": "3.13.15",
"sha256": "c77c02e814c44a14768bbc2e9557bb2fc27c33da8e19a0b49a8f814586636a77",
"zlib": "1.3.1"
},
"counts": {
"areas": 41,
"linear_scripts": 4239,
"mainline_linear_scripts": 718,
"mainline_referenced_scripts": 720,
"mines": 7,
"referenced_scripts": 4269,
"scripts": 4269,
"stages": 1178,
"steps": 3462,
"supported_scripts": 4239,
"task_types": {
"1": 176,
"2": 138,
"3": 431,
"4": 83,
"5": 336,
"6": 1
},
"tasks": 1165
},
"limitations": [
"Static original APK baseline; live resource version not verified.",
"Script support means linear dialogue/presentation and boolean GAoEvent only.",
"ConditionVo passStage loading and lang assignment anomalies require conservative checks.",
"No account data, network operations, combat execution, or battle results."
],
"schema_version": 1,
"source": {
"amf_reader_sha256": "482019cb9b4210693d2bec86695b8320c06977a69fe93063255c1a8bd7584109",
"apk_sha256": "01678ee3a8465d818d32cbbd94baa0d8253b04b4c57b70ebc5544ed341f1015d",
"apk_version": "1.9.68",
"main_swf_sha256": "c6838331a198a22ffa486cbf61cc74c97619e011bc3364c8bb8dc99e269036cf"
},
"tables": {
"area_info": {
"compressed_bytes": 9780,
"decoded_bytes": 25811,
"logical_path": "data/table/area_info.json",
"member": "assets/codes/b03e7e576d730454d1be826aeda1ae5f",
"record_count": 3,
"recovered_sha256": "889dac99b4e707262f8a53fae24f8d7a250e45cf122199507721e29e6bc4686d",
"sha256": "f1c8b72715b30eb42ff8b60906247ee8ac12292b0e55e0642917502eac23fe35"
},
"game_setting": {
"compressed_bytes": 3559,
"decoded_bytes": 5820,
"logical_path": "data/table/game_setting.json",
"member": "assets/codes/f1c2e2603d6c82bbb8b5f94585273208",
"record_count": 141,
"recovered_sha256": "fdc64a2d196463a8afda740b8017a512aafec784eb689ef98b3ba0d8ac7e8696",
"sha256": "8810981688414e3cef520976911d16e2847df0a435dccd792e2dd527695283e3"
},
"mine_info": {
"compressed_bytes": 7043,
"decoded_bytes": 28341,
"logical_path": "data/table/mine_info.json",
"member": "assets/codes/99e6627e76cd0e6c44fca31711fdd82f",
"record_count": 4,
"recovered_sha256": "eb61748195e42091d7db0bc183fc206e372681b7f5224e7ad713452905d8f733",
"sha256": "8a547ab20f86d7ed9a53c57bf547afec6d03bdaf16abd1046712f130ffaab73d"
},
"npc_info": {
"compressed_bytes": 9744,
"decoded_bytes": 21631,
"logical_path": "data/table/npc_info.json",
"member": "assets/codes/b6f76ee8807eb37648844bd01120814b",
"record_count": 337,
"recovered_sha256": "426c588c5dc12cd1e85bedb1137b070505b1d5dd7e27b7fa19c92beace543573",
"sha256": "42e82cfa5a8245a2cd15bbba9a0ae4351a5a5d5a724dcf15e828d2de4649b338"
},
"setting": {
"compressed_bytes": 14422,
"decoded_bytes": 47740,
"logical_path": "data/table/setting.json",
"member": "assets/codes/82885f1c0190a591b6aaee2521bf3daa",
"record_count": 64,
"recovered_sha256": "8db94bc4ff30ddf3b99d856c75be807ae6298c97fc90e9341cff4a1eeaa9d6cb",
"sha256": "68bb8d2ee882a1c14b98315eb61dfb3545dc633173b53409b1dec3af68fb7af3"
},
"stage_info": {
"compressed_bytes": 1061791,
"decoded_bytes": 19703775,
"logical_path": "data/table/stage_info.json",
"member": "assets/codes/9484cfff9fb912e4791832375e771475",
"record_count": 1178,
"recovered_sha256": "093e2ad3d2e51eeebc149b02ad85cefc518fddbf5ca744d60900cdac609843ee",
"sha256": "47ccef41d460f4ef23732624cf302e863a22ca33148dc02629841d764c38b487"
},
"stage_sp": {
"compressed_bytes": 3020,
"decoded_bytes": 17857,
"logical_path": "data/table/stage_sp.json",
"member": "assets/codes/eb91238441fb5bd21f029f8eb2967efb",
"record_count": 78,
"recovered_sha256": "267de867ec7da43d572c0b27e715513b41a7ae9690f6b919b5718cbf16a5089a",
"sha256": "8938ac51752b5f2eaf086943ee45210e1ba04f27d42af6684f47f4c8b9283c30"
},
"task_info": {
"compressed_bytes": 271024,
"decoded_bytes": 1622428,
"logical_path": "data/table/task_info.json",
"member": "assets/codes/70d0e869536fc2b968582dd1f1ea86d6",
"record_count": 1165,
"recovered_sha256": "3e70889ee05a5f639be64752696b158978cc5e7f2560e4a464a308b60b2e3920",
"sha256": "b833985c54e11f3079a3ccc53709f87d25b1f8301699b3eb99613a826a469744"
}
},
"task_update_mode": "new"
}
@@ -0,0 +1,879 @@
{
"battle_routing": {
"battle": "battleStart(task) -> real battle -> taskCompleteStep",
"passStage": "same task route; stage configuration; never a sweep"
},
"condition_loader_anomalies": [
{
"condition": {
"channel": "all",
"close": false,
"endTime": 2400,
"finishTask": [],
"maxLevel": 99999,
"minLevel": 0,
"passStage": [
"10dg5"
],
"platform": "all",
"startTime": 0,
"unfinishTask": [],
"week": [
0,
1,
2,
3,
4,
5,
6
]
},
"reason": "Retained ConditionVo loader anomaly; declared conditions checked conservatively",
"step_number": 2,
"task_type_id": "1014011"
},
{
"condition": {
"channel": "all",
"close": false,
"endTime": 2400,
"finishTask": [],
"maxLevel": 99999,
"minLevel": 0,
"passStage": [
"dg201"
],
"platform": "all",
"startTime": 0,
"unfinishTask": [],
"week": [
0,
1,
2,
3,
4,
5,
6
]
},
"reason": "Retained ConditionVo loader anomaly; declared conditions checked conservatively",
"step_number": 4,
"task_type_id": "2006001"
},
{
"condition": {
"channel": "all",
"close": false,
"endTime": 2400,
"finishTask": [],
"maxLevel": 99999,
"minLevel": 0,
"passStage": [
"dg218"
],
"platform": "all",
"startTime": 0,
"unfinishTask": [],
"week": [
0,
1,
2,
3,
4,
5,
6
]
},
"reason": "Retained ConditionVo loader anomaly; declared conditions checked conservatively",
"step_number": 5,
"task_type_id": "2006001"
},
{
"condition": {
"channel": "all",
"close": false,
"endTime": 2400,
"finishTask": [],
"maxLevel": 99999,
"minLevel": 0,
"passStage": [
"dg219"
],
"platform": "all",
"startTime": 0,
"unfinishTask": [],
"week": [
0,
1,
2,
3,
4,
5,
6
]
},
"reason": "Retained ConditionVo loader anomaly; declared conditions checked conservatively",
"step_number": 6,
"task_type_id": "2006001"
},
{
"condition": {
"channel": "all",
"close": false,
"endTime": 2400,
"finishTask": [],
"maxLevel": 99999,
"minLevel": 0,
"passStage": [
"dg501"
],
"platform": "all",
"startTime": 0,
"unfinishTask": [],
"week": [
0,
1,
2,
3,
4,
5,
6
]
},
"reason": "Retained ConditionVo loader anomaly; declared conditions checked conservatively",
"step_number": 2,
"task_type_id": "2009005"
},
{
"condition": {
"channel": "all",
"close": false,
"endTime": 2400,
"finishTask": [],
"maxLevel": 99999,
"minLevel": 0,
"passStage": [
"dg502"
],
"platform": "all",
"startTime": 0,
"unfinishTask": [],
"week": [
0,
1,
2,
3,
4,
5,
6
]
},
"reason": "Retained ConditionVo loader anomaly; declared conditions checked conservatively",
"step_number": 3,
"task_type_id": "2009005"
},
{
"condition": {
"channel": "all",
"close": false,
"endTime": 2400,
"finishTask": [],
"maxLevel": 99999,
"minLevel": 0,
"passStage": [
"dg503"
],
"platform": "all",
"startTime": 0,
"unfinishTask": [],
"week": [
0,
1,
2,
3,
4,
5,
6
]
},
"reason": "Retained ConditionVo loader anomaly; declared conditions checked conservatively",
"step_number": 4,
"task_type_id": "2009005"
},
{
"condition": {
"channel": "all",
"close": false,
"endTime": 2400,
"finishTask": [],
"maxLevel": 99999,
"minLevel": 0,
"passStage": [
"dg504"
],
"platform": "all",
"startTime": 0,
"unfinishTask": [],
"week": [
0,
1,
2,
3,
4,
5,
6
]
},
"reason": "Retained ConditionVo loader anomaly; declared conditions checked conservatively",
"step_number": 5,
"task_type_id": "2009005"
},
{
"condition": {
"channel": "all",
"close": false,
"endTime": 2400,
"finishTask": [],
"maxLevel": 99999,
"minLevel": 0,
"passStage": [
"dg505"
],
"platform": "all",
"startTime": 0,
"unfinishTask": [],
"week": [
0,
1,
2,
3,
4,
5,
6
]
},
"reason": "Retained ConditionVo loader anomaly; declared conditions checked conservatively",
"step_number": 6,
"task_type_id": "2009005"
},
{
"condition": {
"channel": "all",
"close": false,
"endTime": 2400,
"finishTask": [],
"maxLevel": 99999,
"minLevel": 0,
"passStage": [
"dg506"
],
"platform": "all",
"startTime": 0,
"unfinishTask": [],
"week": [
0,
1,
2,
3,
4,
5,
6
]
},
"reason": "Retained ConditionVo loader anomaly; declared conditions checked conservatively",
"step_number": 7,
"task_type_id": "2009005"
},
{
"condition": {
"channel": "all",
"close": false,
"endTime": 2400,
"finishTask": [],
"maxLevel": 99999,
"minLevel": 0,
"passStage": [
"dg508"
],
"platform": "all",
"startTime": 0,
"unfinishTask": [],
"week": [
0,
1,
2,
3,
4,
5,
6
]
},
"reason": "Retained ConditionVo loader anomaly; declared conditions checked conservatively",
"step_number": 1,
"task_type_id": "2009006"
},
{
"condition": {
"channel": "all",
"close": false,
"endTime": 2400,
"finishTask": [],
"maxLevel": 99999,
"minLevel": 0,
"passStage": [
"dg509"
],
"platform": "all",
"startTime": 0,
"unfinishTask": [],
"week": [
0,
1,
2,
3,
4,
5,
6
]
},
"reason": "Retained ConditionVo loader anomaly; declared conditions checked conservatively",
"step_number": 2,
"task_type_id": "2009006"
},
{
"condition": {
"channel": "all",
"close": false,
"endTime": 2400,
"finishTask": [],
"maxLevel": 99999,
"minLevel": 0,
"passStage": [
"dg511"
],
"platform": "all",
"startTime": 0,
"unfinishTask": [],
"week": [
0,
1,
2,
3,
4,
5,
6
]
},
"reason": "Retained ConditionVo loader anomaly; declared conditions checked conservatively",
"step_number": 5,
"task_type_id": "2009006"
},
{
"condition": {
"channel": "all",
"close": false,
"endTime": 2400,
"finishTask": [],
"maxLevel": 99999,
"minLevel": 0,
"passStage": [
"dg512"
],
"platform": "all",
"startTime": 0,
"unfinishTask": [],
"week": [
0,
1,
2,
3,
4,
5,
6
]
},
"reason": "Retained ConditionVo loader anomaly; declared conditions checked conservatively",
"step_number": 6,
"task_type_id": "2009006"
},
{
"condition": {
"channel": "all",
"close": false,
"endTime": 2400,
"endTimestamp": 2147483647.0,
"finishTask": [],
"lang": "all",
"maxLevel": 99999,
"minLevel": 0,
"passStage": [
"dg315"
],
"platform": "all",
"startTime": 0,
"startTimestamp": 0,
"unfinishTask": [],
"unlockStage": [],
"week": [
0,
1,
2,
3,
4,
5,
6
]
},
"reason": "Retained ConditionVo loader anomaly; declared conditions checked conservatively",
"step_number": 2,
"task_type_id": "3001027"
}
],
"counts": {
"linear_scripts": 4239,
"mainline_linear_scripts": 718,
"mainline_referenced_scripts": 720,
"referenced_scripts": 4269
},
"delegated_categories": {
"3": "event",
"4": "commission_plan driven by existing QuestPolicy",
"5": "bond"
},
"farming": {
"item_or_egg_types": 259,
"kill_rule": "team != 1 and !isObject and mode == 2; declared battle teams only",
"kill_species": 440,
"loot": "Configured potential rewards; actual inventory and kills must be refreshed after settlement",
"sweep_kill_credit": false,
"unindexed": "Dynamic controller/skill spawns and external reward sources"
},
"guide_gates": [
{
"record": "minefail",
"step_number": 0,
"task_type_id": "2001008"
}
],
"scope": "Static planning support only; no game server calls or combat execution.",
"script_classification_basis": "Original GAo expression keys and literal text formatting; StoryPanel/GAoNanoEventVo event handlers. Bundled GAo renderer implementation is not retained.",
"source_apk_sha256": "01678ee3a8465d818d32cbbd94baa0d8253b04b4c57b70ebc5544ed341f1015d",
"special_acceptance_task_types": [
"1001001",
"1001002",
"2001009",
"2001012"
],
"special_local_hooks": [
{
"action": "GachaPanel.popInGacha('task1')",
"step_number": 4,
"supported": false,
"task_type_id": "1001006"
}
],
"supported_nonbattle_statuses": [
"none",
"getItem",
"getMonster",
"getMoney",
"killMonster",
"passLevel",
"unlockMonster",
"sysLock"
],
"unknown_task_types": {
"542160100": 6
},
"unsupported_scripts": {
"event_cmas2_3": {
"reasons": [
"unsupported command: jump",
"unsupported command: option"
],
"uses": [
{
"phase": "story",
"step_number": 3,
"task_type_id": "3000039"
},
{
"phase": "story",
"step_number": 3,
"task_type_id": "30000391"
},
{
"phase": "story",
"step_number": 3,
"task_type_id": "30000392"
}
]
},
"event_midatum_3_4": {
"reasons": [
"unsupported command: jump",
"unsupported command: option"
],
"uses": [
{
"phase": "story",
"step_number": 4,
"task_type_id": "3010008"
}
]
},
"event_qianxi_3t": {
"reasons": [
"unsupported inline command: 主人公"
],
"uses": [
{
"phase": "afterStory",
"step_number": 3,
"task_type_id": "3001005"
}
]
},
"event_sbh_5_2": {
"reasons": [
"unsupported command: jump",
"unsupported command: option"
],
"uses": [
{
"phase": "story",
"step_number": 2,
"task_type_id": "3013005"
},
{
"phase": "story",
"step_number": 2,
"task_type_id": "3013105"
}
]
},
"event_uma_12_4t": {
"reasons": [
"unsupported inline command: [l"
],
"uses": [
{
"phase": "afterStory",
"step_number": 4,
"task_type_id": "3005012"
},
{
"phase": "afterStory",
"step_number": 4,
"task_type_id": "30050121"
}
]
},
"event_warm_newseason_4": {
"reasons": [
"unsupported inline command: 主人公"
],
"uses": [
{
"phase": "story",
"step_number": 1,
"task_type_id": "2001015"
}
]
},
"main_1020": {
"reasons": [
"unsupported command: option"
],
"uses": [
{
"phase": "story",
"step_number": 0,
"task_type_id": "2001003"
}
]
},
"mp3010010_1_1t": {
"reasons": [
"unsupported inline command: [l"
],
"uses": [
{
"phase": "afterStory",
"step_number": 1,
"task_type_id": "530100101"
}
]
},
"mp3129010_0_2": {
"reasons": [
"unsupported inline command: show[l"
],
"uses": [
{
"phase": "story",
"step_number": 2,
"task_type_id": "531290100"
}
]
},
"mp3183010_1_1f": {
"reasons": [
"unsupported inline command: coor"
],
"uses": [
{
"phase": "story",
"step_number": 1,
"task_type_id": "531830101"
}
]
},
"mp4019010_0_0": {
"reasons": [
"unsupported inline command: "
],
"uses": [
{
"phase": "story",
"step_number": 0,
"task_type_id": "540190100"
}
]
},
"mp4019010_0_1a": {
"reasons": [
"unsupported inline command: "
],
"uses": [
{
"phase": "afterStory",
"step_number": 1,
"task_type_id": "540190100"
}
]
},
"mp5109010_0_2": {
"reasons": [
"unsupported command: option"
],
"uses": [
{
"phase": "story",
"step_number": 2,
"task_type_id": "551090100"
}
]
},
"task_1004010_1": {
"reasons": [
"unsupported command: option"
],
"uses": [
{
"phase": "story",
"step_number": 2,
"task_type_id": "1004010"
}
]
},
"task_1004013_0": {
"reasons": [
"unsupported command: option"
],
"uses": [
{
"phase": "story",
"step_number": 1,
"task_type_id": "1004013"
}
]
},
"task_2001002g": {
"reasons": [
"unsupported command: option"
],
"uses": [
{
"phase": "story",
"step_number": 0,
"task_type_id": "2001002"
}
]
},
"task_2001004_1": {
"reasons": [
"unsupported command: option"
],
"uses": [
{
"phase": "story",
"step_number": 0,
"task_type_id": "2001004"
}
]
},
"task_2001005_0": {
"reasons": [
"unsupported command: option"
],
"uses": [
{
"phase": "story",
"step_number": 0,
"task_type_id": "2001005"
}
]
},
"task_2001006_0": {
"reasons": [
"unsupported command: option"
],
"uses": [
{
"phase": "story",
"step_number": 0,
"task_type_id": "2001006"
}
]
},
"task_2001006_1": {
"reasons": [
"unsupported command: option"
],
"uses": [
{
"phase": "story",
"step_number": 1,
"task_type_id": "2001006"
}
]
},
"task_2001008_0": {
"reasons": [
"unsupported command: option"
],
"uses": [
{
"phase": "story",
"step_number": 0,
"task_type_id": "2001008"
}
]
},
"task_2002001_0": {
"reasons": [
"unsupported command: option"
],
"uses": [
{
"phase": "story",
"step_number": 0,
"task_type_id": "2002001"
}
]
},
"task_2002002_0": {
"reasons": [
"unsupported command: option"
],
"uses": [
{
"phase": "story",
"step_number": 0,
"task_type_id": "2002002"
}
]
},
"task_2002003_0": {
"reasons": [
"unsupported command: option"
],
"uses": [
{
"phase": "story",
"step_number": 0,
"task_type_id": "2002003"
}
]
},
"task_2002004_0": {
"reasons": [
"unsupported command: option"
],
"uses": [
{
"phase": "story",
"step_number": 0,
"task_type_id": "2002004"
}
]
},
"task_2003002_0": {
"reasons": [
"unsupported command: option"
],
"uses": [
{
"phase": "story",
"step_number": 0,
"task_type_id": "2003002"
}
]
},
"task_2003003_0": {
"reasons": [
"unsupported command: option"
],
"uses": [
{
"phase": "story",
"step_number": 0,
"task_type_id": "2003003"
}
]
},
"task_2003005_0": {
"reasons": [
"unsupported command: option",
"unsupported command: para"
],
"uses": [
{
"phase": "story",
"step_number": 0,
"task_type_id": "2003005"
}
]
},
"task_2009001_3": {
"reasons": [
"unsupported inline command: wit"
],
"uses": [
{
"phase": "story",
"step_number": 3,
"task_type_id": "2009001"
}
]
},
"task_lnp_k_0": {
"reasons": [
"unsupported command: option"
],
"uses": [
{
"phase": "story",
"step_number": 0,
"task_type_id": "3001006"
},
{
"phase": "story",
"step_number": 0,
"task_type_id": "30010061"
}
]
}
}
}
+579 -7
View File
@@ -1,7 +1,10 @@
from __future__ import annotations
from copy import copy, deepcopy
from dataclasses import replace
from functools import wraps
import json
from pathlib import Path
import threading
import time
from .model import Action, Catalog, Planner, Policy, Snapshot, seconds
from .daily import DailyLedger, DailyPolicy, selected_entries
@@ -14,10 +17,37 @@ from .master_sync import MasterSync
from .stage_cache import StageCache
from .drop_statistics import reward_text
from .cultivation import CultivationSelector
from .battles import BattleJournal, BattleOrchestrator, CancelledBeforeDispatch, digest, gameplay_response, public_data, value
from .progression import ProgressionIntent, ProgressionPlanner, ProgressionPolicy
def account_serial(method):
"""Serialize whole operations, not just individual Client.call requests."""
@wraps(method)
def invoke(self, *args, **kwargs):
with self.battle_journal.lock:
return method(self, *args, **kwargs)
return invoke
def single_flight(method):
@wraps(method)
def invoke(self, *args, **kwargs):
generation = self._progression_cancel_generation
if not self.battle_journal.lock.acquire(blocking=False):
return self.snapshot, [], "同账号已有任务 / 战斗正在执行"
try:
with self._progression_cancel_lock:
if self.auto and generation == self._progression_cancel_generation and self._progression_cancel.is_set():
self._progression_cancel = threading.Event()
return method(self, *args, **kwargs)
finally:
self.battle_journal.lock.release()
return invoke
class Engine:
def __init__(self, catalog, client=None, budget_path=None):
def __init__(self, catalog, client=None, budget_path=None, *, game_data=None, battle_runtime=None, experimental_runtime=None):
self.catalog, self.client = catalog, client
folder = Path(budget_path).parent if budget_path else None
self.cultivation = CultivationSelector(catalog, folder / "cultivation_choices.json" if folder else None)
@@ -44,11 +74,500 @@ class Engine:
self.daily_ledger = DailyLedger(folder / "daily_claims.json" if folder else None)
self.sweep_policy = SweepPolicy()
self.sweeper = SweepRunner(catalog, folder / "sweep_runs.json" if folder else None)
self.progression_policy = ProgressionPolicy()
self.progression_view_active = False
self.progression_planner = None
self.game_data = game_data
self._progression_namespace = str(folder.resolve()) if folder else ""
self._progression_state_loaded = False
self._battle_catalog_ready = False
self.battle_journal = BattleJournal(folder / "progression" / "journal.json" if folder else None)
self.battles = BattleOrchestrator(catalog, self.battle_journal, battle_runtime, self.sweeper,
request_builder=self._battle_request, observer=self._battle_observer)
self._progression_cancel = threading.Event()
self._progression_cancel_lock = threading.Lock()
self._progression_cancel_generation = 0
self._progression_cache_key = None
self._progression_rows = []
self._progression_intents = []
self._commission_planner_available = False
self._commission_offer_reason = ""
self._progression_records = []
self._progression_error = ""
self._planner_pending = False
self._capability_cache = {}
self._battle_snapshot_source = None
self._battle_snapshot_digest = ""
self._battle_roster_digest = None
self._battle_roster = None
self._battle_runtimes = {"original": battle_runtime, "experimental": experimental_runtime}
self._selected_battle_mode = "original"
def cancel_progression(self):
"""Safe on Qt's thread while a worker is running; never waits or calls APIs."""
with self._progression_cancel_lock:
self.auto = False
self._progression_cancel_generation += 1
self._progression_cancel.set()
def progression_rows(self):
"""A cached view only. Full-table planning always runs in an account worker."""
return deepcopy(self._progression_rows)
def progression_records(self):
return deepcopy(self._progression_records)
def _progression_pending(self):
return self.snapshot is not None and (self.battle_journal.pending(self.snapshot)
or self.sweeper.state.get("pending") or self._planner_pending)
def _require_no_battle(self):
if self._progression_pending():
raise ValueError("有待核对的任务 / 战斗,已暂停牧场、赠礼和任务写操作;请先刷新核对")
def _ensure_progression(self):
if self.game_data is None:
from .game_data import load_progression_data
self.game_data = load_progression_data()
if self.progression_planner is None:
self.progression_planner = ProgressionPlanner(self.catalog, self.game_data, account_key=self._progression_namespace)
if not self._progression_state_loaded and self.snapshot is not None:
stored = deepcopy(self.battle_journal.role(self.snapshot).get("planner_state"))
if stored:
for account in stored.get("accounts", {}).values():
pending = account.get("pending")
if pending:
pending["token"] = pending.pop("intent_id", "")
pending["intent"]["token"] = pending["intent"].pop("intent_id", "")
self.progression_planner.restore_state(stored)
self._progression_state_loaded = True
# A separate view preserves the commission-only legacy catalog.
if not self._battle_catalog_ready:
battle_catalog = copy(self.catalog)
positions = dict(self.catalog.data.get("stage_task_positions", {}))
for key, task in self.game_data.tasks.items():
positions[str(key)] = [step.get("position", "") for step in task.get("steps", [])]
battle_catalog.data = self.catalog.data | {"stage_info": self.game_data.stages,
"stage_sp": self.game_data.stage_sp, "stage_task_positions": positions,
"game_setting": self.game_data.game_setting}
self.battles.catalog = battle_catalog
self._battle_catalog_ready = True
self._select_battle_runtime(self.progression_policy.battle_mode)
def _select_battle_runtime(self, mode):
if mode not in ("original", "experimental"):
raise ValueError("未知战斗模式,未开始战斗")
if self.battles.runtime is not None:
self._battle_runtimes[self._selected_battle_mode] = self.battles.runtime
self._selected_battle_mode = mode
runtime = self._battle_runtimes.get(mode)
if runtime is None:
try:
if mode == "experimental":
from .battle_simulator import ExperimentalBattleRuntime as Runtime
else:
from .battle_runtime import BattleRuntime as Runtime
except ImportError:
pass
else:
runtime = self._battle_runtimes[mode] = Runtime()
self.battles.runtime = runtime
def _persist_progression(self, *, save=True):
state = self.progression_planner.export_state()
self._planner_pending = any(account.get("pending") for account in state.get("accounts", {}).values())
for account in state.get("accounts", {}).values():
account["applied"] = account["applied"][-1000:]
account["received"] = {key: {field: task[field] for field in ("id", "typeId", "curStep", "stepValue") if field in task}
for key, task in account["received"].items()}
pending = account.get("pending")
if pending:
# These are planner-issued hashes, not authentication tokens.
# Store them under an unambiguous local name on disk.
pending["intent_id"] = pending.pop("token")
pending["intent"]["intent_id"] = pending["intent"].pop("token")
for task in account["tasks"].values():
cutoff = min(task.get("cursor", 0), task.get("server_step", 0))
for field in ("before", "after", "acknowledged"):
task[field] = [number for number in task.get(field, []) if number >= cutoff]
state = public_data(state)
target = self.battle_journal.role(self.snapshot)
if target.get("planner_state") != state:
target["planner_state"] = state
if save:
self.battle_journal.save()
def _battle_observer(self, event, intent, response):
farming = self._is_farm(intent)
if value(intent, "kind") != "progression_battle" and not farming:
return None
planner = self.progression_planner
if event == "cancelled_before_start":
self._cancel_unsent_progression(intent)
return None
if farming:
if event == "started":
planner.mark_started(self.snapshot, intent) # validates the issued ordinary intent only
# Farming is a normal map action. Its journal and fresh server
# snapshot govern the result; it never acknowledges a task step.
return None
if event == "validate":
account = planner.export_state().get("accounts", {}).get(intent.account_key, {})
task = account.get("tasks", {}).get(f"{intent.task_id}:{intent.task_type_id}", {})
return task.get("cursor") == intent.step_number
if event == "started":
planner.mark_started(self.snapshot, intent)
elif event in ("settled", "event"):
if not planner.acknowledge(self.snapshot, intent, gameplay_response(response)):
raise ValueError("任务战斗结算已返回,但任务步骤确认未完成")
elif event == "loss":
planner.battle_lost(self.snapshot, intent)
self._persist_progression()
def _cancel_unsent_progression(self, intent):
"""Rollback only the matching planner send marker, before dispatch."""
state = self.progression_planner.export_state()
account = state.get("accounts", {}).get(value(intent, "account_key"), {})
pending = account.get("pending")
if pending:
if pending.get("token") != value(intent, "token") or pending.get("intent") != intent.to_dict():
raise ValueError("取消的未发送请求与任务检查点不匹配")
account["pending"] = None
self.progression_planner.restore_state(state)
self._persist_progression(save=False)
def _recover_confirmed_progression(self):
"""Replay only local acknowledgement of a durably received success."""
record = self.battle_journal.pending(self.snapshot)
if (not record or str(record.get("role_id")) != str(self.snapshot.raw["master"].get("id"))
or not str(record.get("kind", "")).startswith("progression_")):
return
battle = record["kind"] == "progression_battle"
confirmed = record.get("phase") == ("settlement_acknowledged" if battle else "acknowledged")
confirmed = confirmed or record.get("settlement_confirmed" if battle else "response_confirmed") is True
response = record.get("response")
if not confirmed or not isinstance(response, dict) or response.get("resCode", 0) not in (0, "0"):
return
path = record.get("path") or ""
if battle and path != "taskService/taskCompleteStep":
return
if not battle and path not in {"taskService/taskReceive", "taskService/taskLoopReceive", "taskService/taskLoopFlush",
"taskService/taskCompleteStep", "taskService/taskComplete", "taskService/taskUpdate"}:
return
state = self.progression_planner.export_state()
account = state.get("accounts", {}).get(record.get("account_key"), {})
intent_id = record.get("intent_id")
applied = bool(intent_id and intent_id in account.get("applied", []))
if not applied:
pending = self.progression_planner.pending(self.snapshot)
if not pending or not isinstance(pending.get("intent"), dict):
return
intent = ProgressionIntent(**pending["intent"])
if (pending.get("token") != intent.token or intent.blocked
or intent_id and intent.token != intent_id
or record.get("account_key") and intent.account_key != record["account_key"]):
return
if any(str(value(intent, field)) != str(record.get(field))
for field in ("kind", "task_id", "task_type_id", "step_number")):
return
# The current restore_state API restores durable accounts but not
# its transient issued-token registry. Rehydrate only this exact
# saved pending intent after validating the successful receipt.
# Cursor/story effects still belong exclusively to acknowledge.
issued = self.progression_planner._issued
if intent.token in issued and issued[intent.token] != intent.to_dict():
raise ValueError("持久化确认与已签发任务意图不匹配")
issued[intent.token] = intent.to_dict()
if not self.progression_planner.acknowledge(self.snapshot, intent, response):
return
self._persist_progression(save=False)
self.battle_journal.finish(self.snapshot, record, "win" if battle else "task",
"已从持久化成功回包恢复本地任务检查点;未重发请求")
def _battle_capability(self, intent):
try:
if self._is_commission(intent) and not self.quest_policy.battle_tasks:
return False, "战斗委托未启用;未开始战斗"
if self.battles.runtime is None:
return False, ("实验模型" if self.progression_policy.battle_mode == "experimental" else "原始战斗运行时") + "尚未提供,未开始战斗"
policy = self._intent_policy(intent)
preview = bool(value(intent, "task_type_id")) and not value(intent, "task_id") and not self._is_farm(intent)
if not preview:
reason = self.battles.resource_reason(self.snapshot, intent, policy, self.policy)
if reason:
return False, reason
key = digest({"snapshot": self._battle_snapshot_digest, "runtime": id(self.battles.runtime), "team": policy.team, "mode": policy.battle_mode,
**{name: value(intent, name) for name in ("task_type_id", "step_number", "stage_id", "difficulty", "battle_kind")}})
if key not in self._capability_cache:
request = self.battles.request(self.snapshot, intent, policy)
self._capability_cache[key] = self.battles.inspect(request)
while len(self._capability_cache) > 64:
self._capability_cache.pop(next(iter(self._capability_cache)))
return self._capability_cache[key]
except (ImportError, OSError, ValueError, TypeError, KeyError, AttributeError) as error:
return False, "战斗输入或运行时未就绪:" + str(error)
def _overlay_battle_capabilities(self, rows, intents):
battle_kinds = {"task", "battle", "passStage", "task_battle", "task_pass_stage", "ordinary_stage", "stage", "map_battle", "hidden"}
reasons = {}
adjusted = []
for intent in intents:
if value(intent, "kind") == "progression_loop_accept" and not self._commission_offer_supported(value(intent, "task_type_id")):
intent = replace(intent, block_reason=self._commission_offer_reason)
if (value(intent, "kind") in ("progression_battle", "battle", "task_battle", "stage_battle", "map_battle")
or self._is_farm(intent) and not self._is_sweep_intent(intent)) and not value(intent, "block_reason"):
supported, reason = self._battle_capability(intent)
reasons[str(value(intent, "source_task_type_id") or value(intent, "task_type_id"))] = (supported, reason)
if not supported:
intent = replace(intent, block_reason=reason) if not isinstance(intent, dict) else intent | {"block_reason": reason}
adjusted.append(intent)
commissions = {str(value(intent, "task_type_id")): intent for intent in adjusted if self._is_commission(intent)}
farms = {str(value(intent, "source_task_type_id")): intent for intent in adjusted if self._is_farm(intent)}
for row in rows:
source_supported = row.get("supported") is not False
commission = commissions.get(str(row.get("task_type_id")))
if commission is not None:
row.update(next_action=value(commission, "description"), block_reason=value(commission, "block_reason", ""))
farm = farms.get(str(row.get("task_type_id")))
if farm is not None:
row.update(next_action=value(farm, "description"), block_reason=value(farm, "block_reason", ""),
battle_kind="sweep" if self._is_sweep_intent(farm) else "ordinary_stage",
stage_id=value(farm, "stage_id"), difficulty=value(farm, "difficulty"))
reason = row.get("block_reason") or row.get("blocked_reason") or ""
if row.get("battle_kind") in battle_kinds:
supported, runtime_reason = reasons.get(str(row.get("task_type_id")),
(False, "战斗运行时能力尚未核对;配置存在不代表已支持实战"))
row["supported"] = bool(source_supported and supported and not reason)
reason = reason or runtime_reason
else:
row["supported"] = bool(source_supported and not reason)
row["block_reason"] = row["blocked_reason"] = reason
return rows, adjusted
def _battle_request(self, snapshot, intent, policy, request):
self._ensure_progression()
if self._battle_snapshot_source is not snapshot:
self._battle_snapshot_source = snapshot
self._battle_snapshot_digest = digest(snapshot.raw)
if self._battle_roster_digest != self._battle_snapshot_digest:
self._battle_roster = deepcopy(snapshot.raw)
self._battle_roster_digest = self._battle_snapshot_digest
task = bool(value(intent, "task_type_id")) and value(intent, "battle_kind") in ("task", "battle", "passStage", "task_battle", "task_pass_stage")
kind = value(intent, "battle_kind")
battle = self.game_data.task_battle(value(intent, "task_type_id"), value(intent, "step_number")) if task else \
self.game_data.stage_battle(value(intent, "stage_id"), value(intent, "difficulty", "1"))
prepared = request | {"snapshot": self._battle_roster,
"battle_mode": policy.battle_mode,
"context": "task_pass_stage" if task and kind == "passStage" else "task_battle" if task else "ordinary_stage",
"original_data": {"battle": battle, "manifest": self.game_data.manifest},
"roster": self._battle_roster, "task_id": value(intent, "task_id"),
"step_index": int(value(intent, "step_number", 1) or 1) - 1 if task else None}
if policy.battle_mode == "original":
from .battle_runtime import BattleRuntime
if isinstance(self.battles.runtime, BattleRuntime):
source = self.game_data.manifest.get("source", {})
prepared["runtime_request"] = {name: prepared[name] for name in (
"context", "roster", "stage_id", "task_id", "step_index")}
prepared["runtime_request"].update(difficulty=int(value(intent, "difficulty", 1) or 1), purpose="settlement",
original_data={"source": "original_apk", "resource_identity": {
"apk_sha256": source.get("apk_sha256"), "main_swf_sha256": source.get("main_swf_sha256")}})
return prepared
def _is_commission(self, intent):
if value(intent, "kind") in ("progression_loop_accept", "progression_loop_reset"):
return True
info = self.game_data.task(value(intent, "source_task_type_id") or value(intent, "task_type_id")) if self.game_data else None
return bool(info and info.get("type") == 4)
@staticmethod
def _is_farm(intent):
return bool(value(intent, "source_task_type_id")) and not value(intent, "task_id") and bool(value(intent, "stage_id"))
@staticmethod
def _is_sweep_intent(intent):
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 not self._is_commission(intent):
return self.progression_policy
quest = self.quest_policy
return replace(self.progression_policy, enabled=quest.enabled, mainline=False, sidequests=False,
commissions=True, accept=quest.accept, allow_items=quest.allow_items, allow_monsters=quest.allow_monsters,
max_money=quest.max_money, item_reserves=dict(quest.item_reserves))
def _commission_offer_supported(self, type_id):
self._commission_offer_reason = "委托后续条件、剧情或战斗未验证支持,未消耗接取次数"
info = self.game_data.task(type_id)
if not info or info.get("type") != 4:
return False
for number, step in enumerate(info.get("steps", []), 1):
for name in (step.get("story"), step.get("afterStory")):
if name and (self.game_data.script(name) or {}).get("supported") is not True:
return False
kind = step.get("statusType")
if kind in ("battle", "passStage"):
if not self.quest_policy.battle_tasks:
return False
intent = {"kind": "progression_battle", "task_type_id": str(type_id), "task_id": 0,
"step_number": number, "battle_kind": "passStage" if kind == "passStage" else "task",
"stage_id": (step.get("statusValue") or {}).get("stage"),
"difficulty": (step.get("statusValue") or {}).get("level", 1)}
supported, reason = self._battle_capability(intent)
if not supported:
self._commission_offer_reason = reason
return False
else:
ready, _, _ = self.progression_planner.requirement(self.snapshot, step, {},
self._intent_policy({"task_type_id": str(type_id)}), self.policy)
if not ready:
return False
return bool(info.get("steps"))
def _refresh_progression_cache(self, *, force=False):
if self.snapshot is None:
return
if not (force or self.progression_view_active or self.progression_policy.enabled or self.quest_policy.enabled):
return
try:
self._ensure_progression()
self._recover_confirmed_progression()
self._battle_snapshot_source = self.snapshot
self._battle_snapshot_digest = digest(self.snapshot.raw)
key = digest({"snapshot": self._battle_snapshot_digest, "policy": vars(self.progression_policy),
"quests": vars(self.quest_policy), "ranch": vars(self.policy), "local_state": self.progression_planner.state_signature(self.snapshot),
"pending": self._progression_pending(), "runtime": id(self.battles.runtime), "day": int(self.snapshot.now // 86400)})
if force or key != self._progression_cache_key:
rows = self.progression_planner.rows(self.snapshot, self.progression_policy, self.policy, quest_policy=self.quest_policy)
intents = self.progression_planner.plan(self.snapshot, self.progression_policy, self.policy)
commission_plan = getattr(self.progression_planner, "commission_plan", None)
self._commission_planner_available = callable(commission_plan)
if self._commission_planner_available:
intents += commission_plan(self.snapshot, self.quest_policy, self.policy, battle_policy=self.progression_policy)
self._progression_rows, self._progression_intents = self._overlay_battle_capabilities(rows, intents)
self._persist_progression()
self._progression_cache_key = digest({"snapshot": self._battle_snapshot_digest, "policy": vars(self.progression_policy),
"quests": vars(self.quest_policy), "ranch": vars(self.policy), "local_state": self.progression_planner.state_signature(self.snapshot),
"pending": self._progression_pending(), "runtime": id(self.battles.runtime), "day": int(self.snapshot.now // 86400)})
self._progression_error = ""
except (ImportError, OSError, ValueError, TypeError, KeyError, AttributeError) as error:
self._progression_error = "任务规划暂不可用:" + str(error)
self._progression_rows = [{"state": "unsupported", "supported": False, "blocked_reason": self._progression_error}]
self._progression_intents = []
self._progression_records = self.battle_journal.records(self.snapshot)
@account_serial
def refresh_progression(self):
if not self.demo:
self.read_snapshot(sync_master=False)
elif self.snapshot is None:
self.snapshot = demo_snapshot(self.catalog)
self._refresh_progression_cache(force=True)
pending = self.battle_journal.pending(self.snapshot)
message = self._progression_error or (pending.get("message") or "存在待核对的任务 / 战斗") if pending else self._progression_error or "已刷新任务与战斗记录"
return self.snapshot, self.plans(), message
@single_flight
@account_serial
def run_progression_once(self):
self.last_executed = False
if not self.demo:
self.read_snapshot(sync_master=False)
elif self.snapshot is None:
self.snapshot = demo_snapshot(self.catalog)
self._refresh_progression_cache()
return self._run_progression_intent()
def _run_progression_intent(self, intent=None):
if not self.progression_policy.enabled and not self.quest_policy.enabled:
return self.snapshot, self.plans(), "自动主线策略未启用"
if self._progression_pending():
return self.snapshot, [], "有待核对的任务 / 战斗;未重复提交"
if self._progression_cancel.is_set():
return self.snapshot, self.plans(), "任务推进已取消"
intents = self._progression_intents
if intent is None:
intent = next((i for i in intents if not value(i, "block_reason")), None)
if intent is None:
reasons = [str(value(i, "block_reason")) for i in intents if value(i, "block_reason")]
return self.snapshot, self.plans(), self._progression_error or (";".join(dict.fromkeys(reasons)) if reasons else "当前没有可执行的任务步骤")
if self.demo:
return self.snapshot, self.plans(), "演示只展示任务;不会伪造战斗、任务进度或奖励"
if value(intent, "block_reason"):
return self.snapshot, self.plans(), str(value(intent, "block_reason"))
effective_policy = self._intent_policy(intent)
if not effective_policy.enabled:
return self.snapshot, self.plans(), "对应任务策略未启用"
try:
self.last_executed = True
kind = value(intent, "kind")
if kind in ("progression_battle", "battle", "task_battle", "stage_battle", "map_battle", "sweep") or self._is_farm(intent):
message = self.battles.run(self.client, self.snapshot, intent, effective_policy,
cancel=self._progression_cancel, ranch=self.policy)
else:
message = self._execute_task_intent(intent)
if self.battle_journal.pending(self.snapshot) and kind == "progression_battle":
self.progression_planner.mark_uncertain(self.snapshot, intent, "战斗待核对,禁止重放")
self._persist_progression()
if not self._progression_cancel.is_set():
self.read_snapshot(sync_master=False)
return self.snapshot, self.plans(), message
except Exception:
if self.battle_journal.pending(self.snapshot) and not self._is_farm(intent) and value(intent, "kind", "").startswith("progression_"):
self.progression_planner.mark_uncertain(self.snapshot, intent, "任务 / 战斗结果待核对,禁止重放")
self._persist_progression()
raise
finally:
self._refresh_progression_cache(force=True)
def _execute_task_intent(self, intent):
path, kind = value(intent, "path", "") or "", value(intent, "kind")
payload = deepcopy(value(intent, "payload", {}) or {})
allowed = {"taskService/taskReceive": {"taskTypeId"}, "taskService/taskLoopReceive": {"taskTypeId", "city"},
"taskService/taskCompleteStep": {"taskId", "taskTypeId", "removeIds"},
"taskService/taskComplete": {"taskId", "taskTypeId"}, "taskService/taskLoopFlush": set(),
"taskService/taskUpdate": {"unlockTasks", "receiveTasks", "removeTasks"}}
local = kind in ("progression_navigate", "progression_dialogue", "progression_local_step") and not path
if not local and (path not in allowed or set(payload) != allowed[path]):
return "任务请求字段或本地剧情类型未受支持,未执行"
if path.endswith("taskUpdate") and (not all(isinstance(payload[k], list) for k in allowed[path])
or not any(payload.values())):
return "任务补链必须提供计算后的三个数组;未发送查询或空补链"
if self._progression_cancel.is_set():
return "任务推进已取消"
record = self.battle_journal.begin(self.snapshot, intent)
if local:
self.progression_planner.acknowledge(self.snapshot, intent)
self._persist_progression(save=False)
self.battle_journal.finish(self.snapshot, record, "local", "已保存普通剧情的本地检查点")
return "已推进普通剧情并保存本地检查点"
try:
self.progression_planner.mark_started(self.snapshot, intent)
self._persist_progression(save=False)
self.battle_journal.update(record, "request_pending")
try:
response = self.battles._call(self.client, path, payload, cancel=self._progression_cancel)
except CancelledBeforeDispatch:
self._cancel_unsent_progression(intent)
self.battle_journal.finish(self.snapshot, record, "cancelled", "任务请求尚未发送,已取消")
return record["message"]
self.battle_journal.update(record, "acknowledged", response=gameplay_response(response), response_confirmed=True)
acknowledged = self.progression_planner.acknowledge(self.snapshot, intent, gameplay_response(response))
self._persist_progression(save=False)
if acknowledged:
self.battle_journal.finish(self.snapshot, record, "task", "服务器已确认任务请求,已保存本地检查点")
else:
self.battle_journal.update(record, "unknown", message="任务成功回包缺少有效状态,等待核对")
return value(intent, "description", "任务请求已确认")
except Exception as error:
self.battle_journal.update(record, "unknown", message="任务请求结果未确认,禁止自动重试", error_type=type(error).__name__)
raise
@account_serial
def read_snapshot(self, *, sync_master=True):
self.snapshot = self.client.snapshot()
self.battle_journal.reconcile(self.snapshot, trusted=True)
self.master_sync.apply(self.snapshot)
if sync_master:
if sync_master and not self._progression_pending():
self.master_sync.settle(self.client, self.snapshot)
present = self.snapshot.monsters
self.growth_cache = {mid: entry for mid, entry in self.growth_cache.items() if mid in present}
@@ -79,15 +598,18 @@ class Engine:
self.snapshot.raw["monsters"] = rows
self.gift_planner.apply_confirmed(self.snapshot)
self.sweeper.recover_reward_event(self.snapshot, getattr(getattr(self.client, "trace", None), "path", None))
self._refresh_progression_cache()
return self.snapshot
def master_sync_due(self):
return not self.demo and bool(self.master_sync.pending(self.snapshot))
return not self.demo and not self._progression_pending() and bool(self.master_sync.pending(self.snapshot))
@account_serial
def sync_master(self):
self.read_snapshot()
return self.snapshot, self.plans(), "已同步等级 / 体力"
@account_serial
def refresh_stages(self):
self.auto = False
if not self.demo:
@@ -118,6 +640,8 @@ class Engine:
entry.update({field: row[field] for field in ("gAtk", "gDef", "gHp", "gDex") if row.get(field) is not None})
def settle_pending_growth(self, force=False):
if self._progression_pending():
return False
pending = self.snapshot.growth_pending(self.catalog)
now = time.monotonic()
if not pending or not force and all(now - self.growth_attempts.get(key, -1e12) < 60 for key in pending):
@@ -130,11 +654,12 @@ class Engine:
return True
def growth_sync_due(self):
if self.snapshot is None:
if self.snapshot is None or self._progression_pending():
return False
now = time.monotonic()
return any(now - self.growth_attempts.get(key, -1e12) >= 60 for key in self.snapshot.growth_pending(self.catalog))
@account_serial
def sync_growth(self):
if self.demo:
if self.snapshot is None:
@@ -151,6 +676,7 @@ class Engine:
message += f";仍有 {len(pending)} 只等待服务器确认阶段或资质"
return self.snapshot, self.plans(), message
@account_serial
def keep_alive(self):
if self.demo:
return "离线演示无需心跳"
@@ -158,6 +684,8 @@ class Engine:
self.client.call("heartBeatService/keepAlive")
return "会话心跳已更新"
@single_flight
@account_serial
def poll(self, *, hatch_only=False, defer_hatch=False):
self.last_executed = False
settled = False
@@ -177,6 +705,12 @@ class Engine:
self.sweeper.recovered_event = False
if self.snapshot.growth_pending(self.catalog):
message += ";成长状态等待服务器确认,将自动检查"
if self.demo:
self._refresh_progression_cache()
if self._progression_pending():
self.pending_hatches = []
pending = self.battle_journal.pending(self.snapshot) or {}
return self.snapshot, [], message + ";" + (pending.get("message") or "有待核对的任务 / 战斗,已暂停冲突操作")
try:
plans = self.plans()
except (ValueError, TypeError, KeyError, AttributeError) as error:
@@ -188,6 +722,8 @@ class Engine:
action = None
if self.auto and action is not None:
self.last_executed = True
if action.kind == "progression":
return self._run_progression_intent(action.payload["intent"])
if action.kind == "daily":
entry = next(row for row in selected_entries(self.catalog, self.snapshot, self.daily_policy, self.daily_ledger) if row.action == action)
self.claim_daily_entry(entry)
@@ -209,7 +745,7 @@ class Engine:
if self.demo:
self.apply_demo(action)
else:
response = self.client.call(action.path, action.payload)
response = self._execute_legacy_task(action) if action.kind.startswith("quest_") else self.client.call(action.path, action.payload)
if action.kind == "buy":
self.record_draw(response.get("eggs") or [])
if action.kind == "gift":
@@ -241,10 +777,32 @@ class Engine:
message += ";" + ";".join(dict.fromkeys(self.planner.notes))
return self.snapshot, plans, message
def _execute_legacy_task(self, action):
"""Keep the commission scheduler, with the same durable replay barrier."""
payload = action.payload
task = next((task for task in self.snapshot.raw.get("currentTasks", [])
if str(task.get("id")) == str(payload.get("taskId"))), {})
intent = {"kind": action.kind, "description": action.description, "path": action.path, "payload": payload,
"task_id": payload.get("taskId"), "task_type_id": payload.get("taskTypeId"), "step_number": task.get("curStep")}
record = self.battle_journal.begin(self.snapshot, intent)
try:
self.battle_journal.update(record, "request_pending")
response = self.battles._call(self.client, action.path, payload)
self.battle_journal.update(record, "acknowledged", response=gameplay_response(response))
return response
except Exception as error:
self.battle_journal.update(record, "unknown", message="委托请求结果未确认,禁止自动重试", error_type=type(error).__name__)
raise
def plans(self):
if self.snapshot is None or self._progression_pending():
self.pending_hatches = []
return []
if self.policy.keep_better_quality or self.policy.gift_auto_representative:
self.cultivation.select(self.snapshot)
quests = self.tasks.plan(self.snapshot, self.quest_policy, self.policy)
# One owner for commission writes; never accept the same offer through
# both the legacy planner and the full progression planner.
quests = [] if self._commission_planner_available else self.tasks.plan(self.snapshot, self.quest_policy, self.policy)
types, eggs = self.tasks.reservations(self.snapshot)
reserved = dict(self.policy.reserved_eggs)
for key, count in eggs.items():
@@ -259,18 +817,26 @@ class Engine:
gifts = self.gift_planner.plan(self.snapshot, policy, self.quest_policy)
ranch = self.planner.plan(self.snapshot, policy, left)
self.planner.notes.extend(self.gift_planner.notes)
return daily + quests + gifts + ranch + sweep_actions
progression = [Action("progression", value(intent, "description", "推进任务"), "", {"intent": intent})
for intent in self._progression_intents if not value(intent, "block_reason") and self._intent_policy(intent).enabled]
if quests and quests[0].kind == "quest_reset":
return daily + quests + progression[:1] + gifts + ranch + sweep_actions
return daily + progression[:1] + quests + gifts + ranch + sweep_actions
@account_serial
def claim_daily_entry(self, entry):
self._require_no_battle()
self.daily_ledger.record(self.snapshot, entry.key)
if not self.demo:
self.client.call(entry.action.path, entry.action.payload)
self.read_snapshot()
@account_serial
def claim_daily(self):
self.auto = False
if not self.demo:
self.read_snapshot()
self._require_no_battle()
# Fresh status after every claim, bounded by the initially available IDs.
keys = [row.key for row in selected_entries(self.catalog, self.snapshot, self.daily_policy, self.daily_ledger)]
done = 0
@@ -290,6 +856,7 @@ class Engine:
parts = [f"{self.catalog.monster(key).get('name', key)} ×{count}" for key, count in totals.items()]
self.last_draw = f"抽蛋完成,共 {sum(totals.values())} 枚:" + "、".join(parts[:8]) + ("…" if len(parts) > 8 else "")
@account_serial
def set_monster_lock(self, monster_ids, locked):
self.auto = False
ids = list(dict.fromkeys(int(mid) for mid in monster_ids))
@@ -297,6 +864,7 @@ class Engine:
raise ValueError("请先选择需要锁定 / 解锁的魔物")
if not self.demo:
self.read_snapshot()
self._require_no_battle()
monsters = self.snapshot.monsters
if any(mid not in monsters for mid in ids):
raise ValueError("选中的魔物已不存在,请刷新后重新选择")
@@ -317,10 +885,12 @@ class Engine:
message = ("[演示] " if self.demo else "") + f"已{'锁定' if locked else '解锁'} {changed} 只魔物;自动执行已暂停"
return self.snapshot, self.plans(), message
@account_serial
def manage_monsters(self, kind, monster_ids, target_id=0):
self.auto = False
if not self.demo:
self.read_snapshot()
self._require_no_battle()
actions = manual_monster_actions(self.catalog, self.snapshot, kind, monster_ids, target_id)
for action in actions:
if self.demo:
@@ -335,10 +905,12 @@ class Engine:
raise ValueError("操作已返回,但魔物记录尚未更新;请刷新核对,不会重复提交")
return self.snapshot, self.plans(), ("[演示] " if self.demo else "") + ";".join(a.description for a in actions) + ";自动执行已暂停"
@account_serial
def expand(self, quote):
self.auto = False
if not self.demo:
self.read_snapshot()
self._require_no_battle()
fresh = expansion_quote(self.catalog, self.snapshot, quote.kind, quote.currency, quote.position)
if fresh != quote:
raise ValueError("扩建费用或次数已变化,请刷新后重新确认")
+142
View File
@@ -0,0 +1,142 @@
"""Verified, offline progression configuration from the original 1.9.68 APK.
The application reads derived static files only. Stage battle dictionaries live
in a separate archive and are read one stage at a time by a battle worker.
Nothing in this module opens an APK, imports the research tools, or uses a
network client. The existing commission-only Catalog is deliberately untouched.
"""
from __future__ import annotations
from functools import lru_cache
import gzip
import hashlib
import json
from pathlib import Path
import zipfile
DATA_DIR = Path(__file__).with_name("data")
MANIFEST_NAME = "progression_manifest.json"
DATA_NAME = "progression.json.gz"
BATTLES_NAME = "progression_battles.zip"
SCHEMA_VERSION = 1
ORIGINAL_APK_SHA256 = "01678ee3a8465d818d32cbbd94baa0d8253b04b4c57b70ebc5544ed341f1015d"
class ProgressionDataError(ValueError):
"""Missing, inconsistent, or damaged derived configuration."""
class ProgressionData:
"""Small task/index data; optional stage battles are loaded lazily.
Public tables: tasks/task_info, stages/stage_info, scripts, setting,
game_setting, npc_info, stage_sp, areas, mines, farming, manifest. ``data`` exposes the index
mapping for integrations. This is shared read-only configuration; callers
must keep character state and credentials elsewhere.
"""
def __init__(self, data=None, *, directory=None):
self.directory = Path(directory or DATA_DIR)
self.manifest = {}
if data is None:
try:
self.manifest = json.loads((self.directory / MANIFEST_NAME).read_text(encoding="utf-8"))
if self.manifest.get("schema_version") != SCHEMA_VERSION:
raise ProgressionDataError("Unsupported progression manifest version")
if self.manifest.get("source", {}).get("apk_sha256") != ORIGINAL_APK_SHA256:
raise ProgressionDataError("Progression data is not bound to the original APK")
artifact = (self.directory / DATA_NAME).read_bytes()
expected = self.manifest["artifacts"][DATA_NAME]["sha256"]
if hashlib.sha256(artifact).hexdigest() != expected:
raise ProgressionDataError("Progression artifact hash mismatch")
decoded = gzip.decompress(artifact)
if hashlib.sha256(decoded).hexdigest() != self.manifest["artifacts"][DATA_NAME]["decoded_sha256"]:
raise ProgressionDataError("Progression decoded data hash mismatch")
data = json.loads(decoded)
except (OSError, KeyError, ValueError, EOFError) as exc:
if isinstance(exc, ProgressionDataError):
raise
raise ProgressionDataError(f"Cannot load static progression data: {exc}") from exc
if not isinstance(data, dict) or not isinstance(data.get("task_info"), dict):
raise ProgressionDataError("Progression data must contain a full task_info mapping")
if data.get("schema_version", SCHEMA_VERSION) != SCHEMA_VERSION:
raise ProgressionDataError("Unsupported progression data version")
self.data = data
self.tasks = self.task_info = data["task_info"]
self.stages = self.stage_info = data.get("stage_info", {})
self.scripts = data.get("scripts", {})
self.setting = data.get("setting", {})
self.game_setting = data.get("game_setting", {})
self.npc_info = data.get("npc_info", {})
self.stage_sp = data.get("stage_sp", {})
self.areas = (data.get("area_info") or {}).get("areaInfo", {})
self.area_maps = (data.get("area_info") or {}).get("areaMap", {})
self.mines = (data.get("mine_info") or {}).get("mines", {})
self.positions = {}
self.farming = data.get("farming") or {"kills": {}, "items": {}}
for parent, area in self.area_maps.items():
for entry in area.get("positions") or []:
if entry.get("posId"):
self.positions.setdefault(entry["posId"], []).append(entry | {"parent_area": parent})
def task(self, type_id):
return self.tasks.get(str(type_id))
def stage(self, stage_id):
return self.stages.get(str(stage_id))
def script(self, name):
return self.scripts.get(str(name))
def npc_name(self, key):
return self.npc_info.get(str(key), {}).get("name") or str(key or "")
def stage_battle(self, stage_id, difficulty=1):
"""Read one original stage's battle config, never the entire archive.
Call this from the battle worker, not the GUI thread. The per-member
digest is itself covered by the checked index artifact digest.
"""
stage_id = str(stage_id)
stage = self.stage(stage_id) or {}
# Injected data can carry full stage dictionaries for offline tests.
level = (stage.get("level") or {}).get(str(difficulty), {})
if "battle" in level:
return level["battle"]
record = self.data.get("battle_members", {}).get(stage_id)
if not record:
raise ProgressionDataError(f"Missing original battle configuration for stage {stage_id}")
try:
with zipfile.ZipFile(self.directory / BATTLES_NAME) as archive:
raw = archive.read(record["member"])
if hashlib.sha256(raw).hexdigest() != record["sha256"]:
raise ProgressionDataError(f"Stage {stage_id} battle hash mismatch")
return json.loads(raw).get(str(difficulty))
except (OSError, KeyError, ValueError, zipfile.BadZipFile) as exc:
if isinstance(exc, ProgressionDataError):
raise
raise ProgressionDataError(f"Cannot load stage {stage_id}: {exc}") from exc
def task_battle(self, type_id, step_number):
"""Resolve source battle data; step_number is the one-based wire step."""
task = self.task(type_id) or {}
steps = task.get("steps") or []
if not 1 <= int(step_number) <= len(steps):
raise ProgressionDataError("Task battle step is outside the configured task")
step = steps[int(step_number) - 1]
if step.get("statusType") == "passStage":
value = step.get("statusValue") or {}
return self.stage_battle(value["stage"], value.get("level", 1))
if step.get("statusType") == "battle":
return step.get("battle")
raise ProgressionDataError("Task step is not a battle")
GameData = ProgressionData
@lru_cache(maxsize=1)
def load_progression_data():
"""Load the packaged static index once; does not parse an APK."""
return ProgressionData()
+271 -50
View File
@@ -19,7 +19,9 @@ from .login import PasswordLogin, device_id, server_labels
from .quests import QuestPolicy
from .daily import DailyPolicy
from .sweeping import SweepPolicy
from .progression import ProgressionPolicy
from .activity_gui import ActivityPages
from .progression_gui import ProgressionPages, prepare_progression_views
from .presentation import Presented, prepare_views, monster_rows
from .credentials import CredentialStore
from .debug import TraceLog
@@ -27,13 +29,13 @@ from .debug_window import DebugWindow
from .sessions import SessionStore, identity
from .inventory_gui import ITEM_TYPES, InventoryTable
from .ranch_gui import RanchView
from .policy_io import portable_config, import_config
from .policy_io import portable_config, import_config, checked_progression_policy
from .table_widgets import table_item
from .stage_cache import StageCache
from .drop_statistics import SweepStatistics
from .statistics_gui import StatisticsPage
APP_VERSION = "1.1.1"
APP_VERSION = "1.2.0.dev1"
GAME_VERSION = "1.9.68"
ROOT = Path(sys.executable).parent if getattr(sys, "frozen", False) else Path(__file__).resolve().parent.parent
@@ -109,7 +111,7 @@ def fill_table(widget, rows, sorting=True):
widget.setSortingEnabled(sorting)
class Window(ActivityPages, W.QMainWindow):
class Window(ProgressionPages, ActivityPages, W.QMainWindow):
network_event = C.Signal(object)
profile_changed = C.Signal(str)
@@ -148,7 +150,15 @@ class Window(ActivityPages, W.QMainWindow):
self.busy, self.monitoring = False, False
self.active_job = None
self.pending_preview = False
self.pending_policy = None
self.logout_phase = None
self.pending_monster_view = False
self.monster_data_pending = False
self.pending_schedule = False
self.monster_view_visible = False
self.presentation_active = True
self.engine.presentation_active = True
self.engine.progression_view_active = False
self.latest_render = None
self.prepared_views = None
self.next_poll = 0
@@ -293,6 +303,8 @@ class Window(ActivityPages, W.QMainWindow):
self.policy_page = self.policy_tab(embedded=True)
self.gifting_tab()
self.automation_tab()
self.progression_tab()
self.battle_records_tab()
self.yield_tab()
self.quests_tab()
self.maps_tab()
@@ -303,7 +315,8 @@ class Window(ActivityPages, W.QMainWindow):
self.plans = table(["操作", "下一步计划(每轮只执行一项,并重新读取状态)"])
self.tabs.addTab(self.plans, "执行计划")
order = [self.tabs.widget(0), self.slot_page, self.inventory_tabs, self.room_page,
self.daily_page, self.automation_page, self.gift_page, self.quests_table.parentWidget(), self.map_page, self.analysis_page,
self.daily_page, self.automation_page, self.progression_page, self.battle_records_page, self.gift_page,
self.quests_table.parentWidget(), self.map_page, self.analysis_page,
self.plans, self.yields.parentWidget()]
for page in order:
self.tabs.addTab(page, self.tabs.tabText(self.tabs.indexOf(page)))
@@ -614,9 +627,13 @@ class Window(ActivityPages, W.QMainWindow):
del blocker
def start_workflow(self):
if self.closed or self.logout_phase is not None:
return
try:
policy = self.read_policy()
other = self.quest_enabled.isChecked() or self.daily_enabled.isChecked() or self.map_enabled.isChecked() or policy.gift_enabled
progression = self.read_progression_policy()
other = (self.quest_enabled.isChecked() or self.daily_enabled.isChecked() or self.map_enabled.isChecked()
or policy.gift_enabled or progression.enabled)
if not (policy.enabled and any((policy.buy, policy.fill, policy.dispatch, policy.collect, policy.feed))) and not other:
self.report("请先勾选至少一项功能,并启用对应策略")
self.stop_workflow()
@@ -627,8 +644,8 @@ class Window(ActivityPages, W.QMainWindow):
self.tabs.setCurrentWidget(self.egg_page)
self.stop_workflow()
return
except ValueError:
self.report("请先修正牧场策略中的保留编号和数量")
except ValueError as error:
self.report("请先修正策略输入:" + str(error))
self.stop_workflow()
return
self.save_config(quiet=True)
@@ -646,6 +663,7 @@ class Window(ActivityPages, W.QMainWindow):
def stop_workflow(self):
self.set_strategy_checked(False)
self.engine.auto = False
self.cancel_progression()
self.pending_execute = False
self.next_gift = float("inf")
self.update_gift_clock()
@@ -687,6 +705,13 @@ class Window(ActivityPages, W.QMainWindow):
state = "策略已开启" if active else "策略已关闭"
state += " · 状态自动刷新" if self.monitoring else ""
self.workflow_status.setText(("演示 · " if self.engine.demo else "已登录 · ") + state)
if hasattr(self, "progression_enabled"):
enabled = [label for checked, label in ((self.ranch_enabled.isChecked(), "牧场 / 孵蛋"),
(self.gift_enabled.isChecked(), "赠礼"), (self.quest_enabled.isChecked(), "委托"),
(self.map_enabled.isChecked(), "扫荡"), (self.daily_enabled.isChecked(), "每日事务"),
(self.progression_enabled.isChecked(), "主线推进")) if checked]
self.workflow_status.setText(self.workflow_status.text() + ";已选功能:" + ("、".join(enabled) or "无"))
self.update_progression_status()
market = self.catalog.data.get("markets", {}).get(self.market.currentData(), {})
snapshot = self.engine.snapshot
if snapshot:
@@ -1047,6 +1072,10 @@ class Window(ActivityPages, W.QMainWindow):
self.refresh_maps()
elif tab is self.analysis_page:
self.refresh_analysis()
elif tab is self.progression_page:
self.refresh_progression()
elif tab is self.battle_records_page:
self.refresh_progression_records()
else:
self.refresh()
@@ -1128,16 +1157,55 @@ class Window(ActivityPages, W.QMainWindow):
self.render_catalog()
def logout_and_clear(self):
if self.busy:
self.report("请等待当前操作完成,再清除登录记录")
if self.closed or self.logout_phase is not None:
return
keys = [entry["session_id"] for entry in self.session_store.entries()]
engine = self.engine
resume_monitoring, resume_heartbeat = self.monitoring, engine.heartbeat_enabled
resume_timer = self.timer.isActive()
self.logout_phase = "confirming"
self.timer.stop()
self.monitoring = False
engine.heartbeat_enabled = False
self.stop_workflow()
self.pending_refresh = self.pending_policy = None
self.pending_preview = self.pending_monster_view = self.pending_progression_view = False
self.pending_schedule = False
text = "将退出登录,并删除当前账号页签保存的会话和账号密码。\n培养策略、日志及其他账号的记录不受影响。"
if W.QMessageBox.question(self, "清除登录记录", text, W.QMessageBox.StandardButton.Yes | W.QMessageBox.StandardButton.No,
W.QMessageBox.StandardButton.No) != W.QMessageBox.StandardButton.Yes:
return
self.demo()
try:
confirmed = W.QMessageBox.question(self, "清除登录记录", text,
W.QMessageBox.StandardButton.Yes | W.QMessageBox.StandardButton.No,
W.QMessageBox.StandardButton.No) == W.QMessageBox.StandardButton.Yes
except Exception:
self.logout_phase = None
if resume_timer and not self.closed:
self.timer.start(500)
raise
if self.closed:
return
if not confirmed:
self.logout_phase = None
if self.engine is engine:
self.monitoring, engine.heartbeat_enabled = resume_monitoring, resume_heartbeat
if resume_timer:
self.timer.start(500)
return
self.logout_phase = "waiting"
self.statusBar().showMessage("正在退出登录;当前请求完成后清除登录记录" if self.busy else "正在退出登录")
if not self.busy:
self.finish_logout()
def finish_logout(self):
if self.busy or self.logout_phase != "waiting":
return
self.logout_phase = "finishing"
try:
self.pending_refresh = self.pending_policy = None
self.pending_execute = self.pending_preview = self.pending_schedule = False
self.pending_monster_view = self.pending_progression_view = False
self.demo()
if not self.engine.demo or self.engine.client is not None:
raise ValueError("原登录连接尚未释放")
keys = [entry["session_id"] for entry in self.session_store.entries()]
for key in keys:
self.session_store.remove(key)
self.credentials.save("", "", False)
@@ -1148,19 +1216,50 @@ class Window(ActivityPages, W.QMainWindow):
self.reload_saved_sessions()
self.login_status.setText("已退出登录并清除当前账号页签的登录记录")
self.report("已清除当前账号页签的登录记录")
except (OSError, ValueError, KeyError):
self.report("部分登录记录未能删除,请检查本地状态目录")
except (OSError, ValueError, KeyError, RuntimeError) as error:
self.report("退出登录或清除记录未完成:" + str(error) + ";策略保持停止")
finally:
self.logout_phase = None
self.monitoring = False
self.engine.auto = self.engine.heartbeat_enabled = False
if not self.closed:
self.timer.start(500)
if self.engine.demo:
self.refresh()
elif self.close_after_job:
C.QTimer.singleShot(0, self.close)
def run_job(self, kind, function):
"""All task requests share the account's existing serial worker."""
return self.submit(kind, function)
def update_policy(self, value=None):
"""Apply a whole policy set between requests, never during a worker call."""
if value is None:
value = self.config_value()
policies = {key: cls(**value[key]) for key, cls in (("policy", Policy), ("quest_policy", QuestPolicy),
("daily_policy", DailyPolicy), ("sweep_policy", SweepPolicy))}
policies["progression_policy"] = checked_progression_policy(value.get("progression_policy", {}))
if self.busy:
self.pending_policy = policies
return False
for key, policy in policies.items():
setattr(self.engine, key, policy)
return True
def submit(self, kind, function):
if self.busy or self.closed:
if self.busy or self.closed or self.logout_phase is not None:
return
self.busy = True
self.update_monster_actions()
catalog, engine = self.catalog, self.engine
self.sync_presentation_visibility()
progression_visible = self.presentation_active and self.tabs.currentWidget() is self.progression_page
records_visible = self.presentation_active and self.tabs.currentWidget() is self.battle_records_page
def background():
started = time.perf_counter()
value = function()
if kind in ("poll", "hatch", "monster_lock", "manual_monsters", "expansion", "growth_sync", "master_sync", "map_refresh", "daily_claim", "connected"):
if kind in ("poll", "hatch", "monster_lock", "manual_monsters", "expansion", "growth_sync", "master_sync", "map_refresh", "daily_claim", "connected", "policy_preview", "progression_refresh", "progression_run"):
snapshot = value[1] if kind == "connected" else value[0]
managed = set() if kind == "connected" else set(engine.planner.managed)
preparing = time.perf_counter()
@@ -1174,7 +1273,12 @@ class Window(ActivityPages, W.QMainWindow):
statistics = SweepStatistics(catalog, folder / "sweep_rewards.sqlite3")
client = value[0]
statistics.import_log(snapshot.raw["master"]["id"], getattr(getattr(client, "trace", None), "path", None))
views = prepare_views(catalog, snapshot, managed, cache, statistics)
views = prepare_views(catalog, snapshot, managed, cache, statistics,
include_monsters=self.presentation_active and not self.closed and (self.monster_view_visible or kind == "connected"))
explicit_progression = kind in ("progression_refresh", "progression_run")
if kind != "connected" and (progression_visible or records_visible or explicit_progression):
views.progression = prepare_progression_views(engine,
tasks=progression_visible or explicit_progression, records=records_visible or explicit_progression)
return Presented(value, views, (time.perf_counter() - preparing) * 1000, (time.perf_counter() - started) * 1000)
return value
job = Job(kind, background)
@@ -1189,6 +1293,30 @@ class Window(ActivityPages, W.QMainWindow):
self.busy = False
self.update_monster_actions()
self.active_job = None
if self.logout_phase is not None:
if self.logout_phase == "waiting":
C.QTimer.singleShot(0, self.finish_logout)
elif self.close_after_job:
C.QTimer.singleShot(0, self.close)
return
if not self.presentation_active or self.tabs.currentWidget() not in (self.progression_page, self.battle_records_page):
self.pending_progression_view = False
if not self.monster_view_visible:
self.pending_monster_view = False
if self.pending_policy is not None and not self.closed:
policies, self.pending_policy = self.pending_policy, None
progression_changed = asdict(getattr(self.engine, "progression_policy", ProgressionPolicy())) != asdict(policies["progression_policy"])
for key, policy in policies.items():
setattr(self.engine, key, policy)
if progression_changed:
self.progression_views = None
if self.presentation_active and self.tabs.currentWidget() in (self.progression_page, self.battle_records_page):
self.pending_progression_view = True
if self.pending_schedule and not self.closed and not self.close_after_job:
self.pending_schedule = False
self.schedule()
if self.busy:
return
if self.close_after_job:
C.QTimer.singleShot(0, self.close)
elif self.pending_refresh is not None:
@@ -1196,6 +1324,10 @@ class Window(ActivityPages, W.QMainWindow):
C.QTimer.singleShot(0, lambda: self.refresh_page(tab))
elif self.pending_preview and not self.closed:
C.QTimer.singleShot(0, self.preview_cultivation)
elif self.pending_monster_view and not self.closed:
self.request_monster_views()
elif self.pending_progression_view and not self.closed:
C.QTimer.singleShot(0, lambda: self.request_progression_views(force=True))
elif self.pending_execute and self.monitoring and self.strategy_toggle.isChecked() and not self.closed:
self.pending_execute = False
C.QTimer.singleShot(0, lambda: self.refresh(automated=True))
@@ -1205,6 +1337,8 @@ class Window(ActivityPages, W.QMainWindow):
metrics = None
if isinstance(value, Presented):
self.prepared_views = value.views
if value.views.progression is not None:
self.accept_progression_views(value.views.progression)
metrics = value
value = value.value
started = time.perf_counter()
@@ -1219,9 +1353,9 @@ class Window(ActivityPages, W.QMainWindow):
note="worker总耗时包含网络;大列表在后续短批次更新")
def apply_result(self, kind, value):
if kind in ("poll", "hatch", "monster_lock", "manual_monsters", "expansion", "growth_sync", "master_sync", "map_refresh", "daily_claim", "policy_preview"):
if kind in ("poll", "hatch", "monster_lock", "manual_monsters", "expansion", "growth_sync", "master_sync", "map_refresh", "daily_claim", "policy_preview", "progression_refresh", "progression_run"):
snapshot, plans, message = value
if kind != "policy_preview" and not self.engine.demo and not self.closed:
if kind != "policy_preview" and not self.engine.demo and not self.closed and self.logout_phase is None:
self.monitoring = True
self.engine.heartbeat_enabled = True
self.render(snapshot, plans)
@@ -1240,6 +1374,13 @@ class Window(ActivityPages, W.QMainWindow):
self.prepared_views.drop_statistics = value
self.analysis_page.set_data(self.catalog, value)
self.report("已从本地刷新掉落统计")
elif kind == "progression_view":
self.accept_progression_views(value)
self.render_progression()
elif kind == "monster_view":
if value.snapshot is self.engine.snapshot:
self.prepared_views = value
self.render_current_page()
elif kind == "connected":
client, snapshot = value
if self.connection_guard and not self.connection_guard(client.session):
@@ -1251,6 +1392,8 @@ class Window(ActivityPages, W.QMainWindow):
if self.engine.client and self.engine.client is not client:
self.engine.client.close()
self.engine = Engine(self.catalog, client, self.state / "purchase_budget.json")
self.sync_presentation_visibility()
self.clear_progression_views()
self.engine.snapshot = snapshot
if self.prepared_views and self.prepared_views.snapshot is snapshot and self.prepared_views.stage_cache:
self.engine.stage_cache = self.prepared_views.stage_cache
@@ -1274,16 +1417,15 @@ class Window(ActivityPages, W.QMainWindow):
self.mode.setText("已登录")
self.login_status.setText("已进入所选区服并读取角色")
self.stop_workflow()
self.monitoring = not self.closed
self.monitoring = not self.closed and self.logout_phase is None
if self.logout_phase is not None:
self.engine.heartbeat_enabled = False
self.next_poll = 0
self.account.setReadOnly(True)
self.render(snapshot, [])
try:
self.engine.policy = self.read_policy()
self.engine.quest_policy = self.read_quest_policy()
self.engine.daily_policy = self.read_daily_policy()
self.engine.sweep_policy = self.read_sweep_policy()
fill_table(self.plans, [[action.kind, action.description] for action in self.engine.plans()])
self.update_policy()
self.pending_preview = True
except (ValueError, TypeError, KeyError, AttributeError) as error:
self.report("状态已显示;策略暂不可用:" + str(error))
self.profile_changed.emit(self.session_label or snapshot.raw["master"].get("roleName", "已连接"))
@@ -1326,6 +1468,9 @@ class Window(ActivityPages, W.QMainWindow):
@C.Slot(str)
def error(self, message):
self.pending_monster_view = False
self.monster_data_pending = False
self.monster_render_timer.stop()
last = self.trace.events[-1] if self.trace.events else {}
if last.get("kind") != "error" or last.get("message") != self.trace.redact(message):
self.trace.emit("error", "界面 / 任务处理", scope="local", message=message)
@@ -1369,23 +1514,21 @@ class Window(ActivityPages, W.QMainWindow):
battle_tasks=self.quest_battles.isChecked(), item_reserves=reserves)
def refresh(self, checked=False, *, automated=False, hatch_only=False):
if self.busy or self.closed:
if self.busy or self.closed or self.logout_phase is not None:
return
try:
self.engine.policy = self.read_policy()
self.engine.quest_policy = self.read_quest_policy()
self.engine.daily_policy = self.read_daily_policy()
self.engine.sweep_policy = self.read_sweep_policy()
self.update_policy()
self.engine.auto = self.strategy_toggle.isChecked() and automated and self.monitoring
if hatch_only:
self.hatch_timer.stop()
self.next_hatch = float("inf")
self.submit("hatch" if hatch_only else "poll", lambda: self.engine.poll(hatch_only=hatch_only, defer_hatch=not hatch_only))
except ValueError:
self.run_job("hatch" if hatch_only else "poll", lambda: self.engine.poll(hatch_only=hatch_only, defer_hatch=not hatch_only))
except ValueError as error:
self.stop_workflow()
self.engine.policy = Policy(enabled=False)
self.engine.quest_policy = QuestPolicy()
self.report("策略输入尚未完整,已关闭策略;本次继续刷新角色数据")
self.engine.progression_policy = ProgressionPolicy()
self.report("策略输入尚未完整,已关闭策略;本次继续刷新角色数据:" + str(error))
self.submit("poll", self.engine.poll)
def poll_delay(self):
@@ -1435,7 +1578,11 @@ class Window(ActivityPages, W.QMainWindow):
def schedule(self):
self.update_gift_clock()
if self.busy or self.closed:
if self.closed or self.logout_phase is not None:
return
if self.busy:
if self.active_job and self.active_job.kind == "monster_view":
self.pending_schedule = True
return
now = time.monotonic()
if not self.engine.demo and self.engine.heartbeat_enabled and now - self.engine.last_heartbeat >= 240:
@@ -1455,6 +1602,7 @@ class Window(ActivityPages, W.QMainWindow):
def render(self, snapshot, plans):
self.latest_render = (snapshot, plans)
self.engine.snapshot = snapshot
self.refresh_progression_teams(snapshot)
master = snapshot.raw["master"]
self.summary.setText(f"{master.get('roleName', '')} | Lv.{master.get('level', '?')} | 经验 {self.catalog.master_experience(master)} | 金币 {master.get('money', '?')} | 氪金 {master.get('ke', '?')} | 体力 {master.get('ti', '?')}")
decisions = {int((a.payload.get('monsterId') or a.payload.get('monsterIds') or a.payload.get('foods') or [0])[0]): a.description for a in plans if a.kind in ('sell', 'feed')}
@@ -1496,10 +1644,23 @@ class Window(ActivityPages, W.QMainWindow):
if self.presentation_active:
self.render_current_page()
def sync_presentation_visibility(self):
page = self.tabs.currentWidget()
self.engine.presentation_active = bool(self.presentation_active)
self.engine.progression_view_active = bool(self.presentation_active and page is self.progression_page)
self.monster_view_visible = bool(self.presentation_active and page is self.monster_page)
def set_presentation_active(self, active):
self.presentation_active = active
self.presentation_active = bool(active)
self.sync_presentation_visibility()
if not active:
self.pending_monster_view = False
if self.prepared_views:
self.prepared_views.monsters = self.prepared_views.monster_source = None
self.pending_progression_view = False
self.analysis_page.row_batch.stop()
self.progression_table.row_batch.stop()
self.battle_records_table.row_batch.stop()
for name in ("map_render_timer", "monster_render_timer"):
timer = getattr(self, name, None)
if timer:
@@ -1512,10 +1673,19 @@ class Window(ActivityPages, W.QMainWindow):
self.render_current_page()
def render_current_page(self, *args):
self.sync_presentation_visibility()
if self.closed or not self.presentation_active or not self.latest_render:
return
snapshot, plans = self.latest_render
page = self.tabs.currentWidget()
if page not in (self.progression_page, self.battle_records_page):
self.pending_progression_view = False
if page is not self.monster_page:
self.pending_monster_view = False
for target, widget in ((self.progression_page, self.progression_table),
(self.battle_records_page, self.battle_records_table)):
if page is not target:
widget.row_batch.stop()
if page is not self.analysis_page:
self.analysis_page.row_batch.stop()
for name, target in (("map_render_timer", self.map_page), ("monster_render_timer", self.monster_page)):
@@ -1557,6 +1727,8 @@ class Window(ActivityPages, W.QMainWindow):
self.render_daily()
elif page is self.gift_page:
self.render_gift_representatives(snapshot)
elif page in (self.progression_page, self.battle_records_page):
self.render_progression()
elif page is self.target.parentWidget() or page is self.automation_page:
self.refresh_target_choices(snapshot)
except (ValueError, TypeError, KeyError, AttributeError) as error:
@@ -1565,11 +1737,35 @@ class Window(ActivityPages, W.QMainWindow):
def render_monsters(self, snapshot):
views = self.prepared_views
managed = self.engine.planner.managed
if views and views.snapshot is snapshot and views.monster_source == repr(snapshot.raw["monsters"]) and views.managed == managed:
rows = views.monsters
if views and views.snapshot is snapshot and views.monsters is not None and views.managed == managed:
self.pending_monster_view = False
if self.monster_data_pending:
self.monster_render_timer.stop()
self.monster_data_pending = False
self.monsters.set_data(snapshot, views.monsters, self.feed_targets, self.gift_targets)
else:
rows = monster_rows(self.catalog, snapshot, managed)
self.monsters.set_data(snapshot, rows, self.feed_targets, self.gift_targets)
self.request_monster_views(snapshot)
def request_monster_views(self, snapshot=None):
if self.closed or self.logout_phase is not None or not self.monster_view_visible:
return
# Rendering is still pending while the serial worker prepares its data.
self.monster_render_timer.stop()
self.monster_render_timer.running = True
self.monster_data_pending = True
if self.busy:
self.pending_monster_view = True
return
snapshot = snapshot or self.engine.snapshot
if snapshot is None:
self.monster_render_timer.stop()
self.monster_data_pending = False
return
self.pending_monster_view = False
engine, catalog = self.engine, self.catalog
self.run_job("monster_view", lambda: prepare_views(catalog, snapshot, engine.planner.managed,
engine.stage_cache, engine.sweeper.statistics,
include_monsters=self.monster_view_visible and self.presentation_active and not self.closed))
def refresh_target_choices(self, snapshot):
self.update_combo(self.target, [("未设置:不自动喂养", 0)] + [(f"{self.catalog.monster(m['typeId']).get('name')} Lv.{m.get('level', 1)}/{self.catalog.max_level(m) or '?'} #{m['id']}", int(m["id"])) for m in snapshot.raw["monsters"] if m.get("process") == 3])
@@ -1659,7 +1855,7 @@ class Window(ActivityPages, W.QMainWindow):
self.submit("connected", lambda: (client, client.snapshot()))
def demo(self):
if self.busy:
if self.busy or self.logout_phase not in (None, "finishing"):
return
self.monitoring = False
self.stop_workflow()
@@ -1669,6 +1865,8 @@ class Window(ActivityPages, W.QMainWindow):
self.engine.client.persist_session()
self.engine.client.close()
self.engine = Engine(self.catalog)
self.sync_presentation_visibility()
self.clear_progression_views()
self.reset_map_view()
self.analysis_page.set_data(self.catalog, {"owner": "", "totals": {}, "drops": {}})
self.active_identity = None
@@ -1755,6 +1953,7 @@ class Window(ActivityPages, W.QMainWindow):
def config_value(self):
return {"policy": asdict(self.read_policy()), "quest_policy": asdict(self.read_quest_policy()),
"daily_policy": asdict(self.read_daily_policy()), "sweep_policy": asdict(self.read_sweep_policy()),
"progression_policy": asdict(self.read_progression_policy()),
"overrides": copy.deepcopy(self.catalog.overrides),
"log_visible": self.show_log.isChecked(), "log_sizes": self.log_splitter.sizes() if self.show_log.isChecked() else self.log_sizes,
"yield_stars": [star for star, check in self.yield_stars.items() if check.isChecked()],
@@ -1777,6 +1976,14 @@ class Window(ActivityPages, W.QMainWindow):
signal.connect(self.settings_changed)
for widget in self.yield_stars.values():
widget.toggled.connect(self.settings_changed)
for key in asdict(ProgressionPolicy()):
if key == "enabled":
continue
widget = getattr(self, "progression_" + key)
signal = (widget.toggled if isinstance(widget, W.QAbstractButton) else
widget.currentIndexChanged if isinstance(widget, W.QComboBox) else
widget.valueChanged if hasattr(widget, "valueChanged") else widget.textChanged)
signal.connect(self.progression_settings_changed)
def settings_changed(self, *args):
if not self.closed and not self.loading_config and hasattr(self, "auto_save_timer"):
@@ -1790,12 +1997,15 @@ class Window(ActivityPages, W.QMainWindow):
return
changed = any(asdict(getattr(self.engine, key)) != value[key]
for key in ("policy", "quest_policy", "daily_policy", "sweep_policy"))
progression_changed = asdict(getattr(self.engine, "progression_policy", ProgressionPolicy())) != value["progression_policy"]
changed = changed or progression_changed
local_selection_changed = any(getattr(self.engine.policy, key) != value["policy"][key]
for key in ("gift_auto_representative", "keep_better_quality"))
self.engine.policy = Policy(**value["policy"])
self.engine.quest_policy = QuestPolicy(**value["quest_policy"])
self.engine.daily_policy = DailyPolicy(**value["daily_policy"])
self.engine.sweep_policy = SweepPolicy(**value["sweep_policy"])
self.update_policy(value)
if progression_changed:
self.progression_views = None
if self.presentation_active and self.tabs.currentWidget() in (self.progression_page, self.battle_records_page):
self.request_progression_views(force=True)
if local_selection_changed:
self.pending_preview = True
self.preview_cultivation()
@@ -1806,7 +2016,7 @@ class Window(ActivityPages, W.QMainWindow):
self.next_poll = 0
self.arm_hatching()
self.arm_gifting()
self.statusBar().showMessage("规则已自动保存并应用", 3000)
self.statusBar().showMessage("规则已保存,当前请求完成后应用" if self.pending_policy else "规则已自动保存并应用", 3000)
return value
def preview_cultivation(self):
@@ -1837,7 +2047,7 @@ class Window(ActivityPages, W.QMainWindow):
self.statusBar().showMessage("设置尚未保存,请检查输入格式及本地目录", 5000)
def export_policies(self):
path, _ = W.QFileDialog.getSaveFileName(self, "导出全部策略", "ranch-policies-1.1.1.json", "策略文件 (*.json)")
path, _ = W.QFileDialog.getSaveFileName(self, "导出全部策略", f"ranch-policies-{APP_VERSION}.json", "策略文件 (*.json)")
if not path:
return
try:
@@ -1875,6 +2085,7 @@ class Window(ActivityPages, W.QMainWindow):
try:
if value is None:
value = json.loads(path.read_text(encoding="utf-8"))
progression = checked_progression_policy(value.get("progression_policy", {}))
sizes = value.get("log_sizes", [420, 140])
if isinstance(sizes, list) and len(sizes) == 2 and all(isinstance(v, int) and v >= 0 for v in sizes) and sum(sizes) > 0:
self.log_sizes = sizes
@@ -1894,6 +2105,7 @@ class Window(ActivityPages, W.QMainWindow):
self.map_enabled.setChecked(sweep.enabled)
self.map_keep_ti.setValue(sweep.keep_stamina)
self.map_team.setCurrentIndex(max(0, self.map_team.findData(sweep.team)))
self.load_progression_policy(progression)
self.egg_rules = copy.deepcopy(policy.egg_rules)
self.feed_targets = copy.deepcopy(policy.feed_targets)
self.gift_targets = copy.deepcopy(policy.gift_targets)
@@ -1938,16 +2150,23 @@ class Window(ActivityPages, W.QMainWindow):
self.monsters.render_signature = None
if self.latest_render:
self.render_current_page()
except Exception:
self.report("旧设置无法读取,已使用默认设置")
except (OSError, ValueError, TypeError, KeyError, AttributeError) as error:
self.report("设置无法完整读取,请检查输入:" + str(error))
finally:
self.loading_config = False
def closeEvent(self, event):
self.closed = True
self.cancel_progression()
self.timer.stop()
self.hatch_timer.stop()
self.analysis_page.row_batch.stop()
self.progression_table.row_batch.stop()
self.battle_records_table.row_batch.stop()
self.pending_progression_view = False
self.pending_monster_view = False
self.pending_schedule = False
self.pending_policy = None
if hasattr(self, "auto_save_timer"):
self.auto_save_timer.stop()
if hasattr(self.eggs, "row_batch"):
@@ -1964,6 +2183,8 @@ class Window(ActivityPages, W.QMainWindow):
self.setEnabled(False)
event.ignore()
return
if self.logout_phase == "waiting":
self.finish_logout()
self.save_login_info(quiet=True)
self.save_config(quiet=True)
if self.engine.client:
+23 -1
View File
@@ -6,6 +6,7 @@ from .model import Policy
from .daily import DailyPolicy
from .quests import QuestPolicy
from .sweeping import SweepPolicy
from .progression import ProgressionPolicy
FORMAT = "ranch-helper-policies"
VERSION = 1
@@ -31,6 +32,23 @@ def checked_policy(cls, data):
raise ValueError("策略字段格式错误") from error
def checked_progression_policy(data):
"""Reject ambiguous or unsafe task choices before applying any settings."""
if not isinstance(data, dict):
raise ValueError("主线策略必须是对象")
raw = asdict(ProgressionPolicy()) | data
for key in ("reserve_ti", "max_money"):
if type(raw[key]) is not int or not 0 <= raw[key] <= 1_000_000_000:
raise ValueError("主线策略数量超出范围:" + key)
if type(raw["stop_after_loss"]) is not int or not 1 <= raw["stop_after_loss"] <= 999:
raise ValueError("连续失败停止次数须为1至999")
if not isinstance(raw["item_reserves"], dict) or any(not isinstance(key, str) or not key.isdigit() or int(key) <= 0
or type(count) is not int or not 0 <= count <= 1_000_000_000
for key, count in raw["item_reserves"].items()):
raise ValueError("主线保留物品须为正整数编号和非负整数数量")
return checked_policy(ProgressionPolicy, data)
def portable_policy(policy, snapshot=None):
value = asdict(policy)
value["enabled"] = False
@@ -45,7 +63,7 @@ def portable_policy(policy, snapshot=None):
for key, priority in sorted(value.pop(field).items(), key=lambda pair: pair[1]):
mon = snapshot.monsters.get(int(key)) if snapshot else None
targets[kind].append({"typeId": str(mon.get("typeId")) if mon else "", "priority": priority})
return {"format": FORMAT, "schema": VERSION, "assistantVersion": "1.1.1", "gameVersion": "1.9.68",
return {"format": FORMAT, "schema": VERSION, "assistantVersion": "1.2.0.dev1", "gameVersion": "1.9.68",
"policy": value, "targetSpecies": targets}
@@ -87,6 +105,7 @@ def portable_config(config, snapshot=None):
value["policy"][field] = getattr(policy, field)
for key, cls in (("quest_policy", QuestPolicy), ("daily_policy", DailyPolicy), ("sweep_policy", SweepPolicy)):
value[key] = asdict(cls(**config.get(key, {})))
value["progression_policy"] = asdict(checked_progression_policy(config.get("progression_policy", {})))
value["interval"] = config.get("interval", 30)
value["overrides"] = copy.deepcopy(config.get("overrides", {}))
value["yield_stars"] = list(config.get("yield_stars", [1, 2, 3, 4, 5]))
@@ -105,6 +124,9 @@ def import_config(value, snapshot=None):
if not isinstance(value.get(key), dict):
raise ValueError("策略文件缺少 " + key)
config[key] = asdict(checked_policy(cls, value[key]))
# An additive section preserves schema-2 compatibility with older bundles.
if "progression_policy" in value:
config["progression_policy"] = asdict(checked_progression_policy(value["progression_policy"]))
interval = value.get("interval", 30)
if interval not in (30, 60, 120, 300):
raise ValueError("刷新间隔须为30、60、120或300秒")
+8 -4
View File
@@ -20,14 +20,15 @@ def map_source(snapshot):
@dataclass
class Views:
snapshot: object
monster_source: str
monster_source: str | None
managed: set
monsters: list
monsters: list | None
map_source: str
maps: list
stage_cache: object = None
statistics_store: object = None
drop_statistics: dict = None
progression: object = None
@dataclass
@@ -38,7 +39,10 @@ class Presented:
worker_ms: float = 0
def prepare_views(catalog, snapshot, managed, stage_cache=None, statistics=None):
return Views(snapshot, repr(snapshot.raw["monsters"]), set(managed), monster_rows(catalog, snapshot, managed),
def prepare_views(catalog, snapshot, managed, stage_cache=None, statistics=None, *, include_monsters=True):
"""Omitted monster rows stay dirty; the default preserves the full view API."""
source = repr(snapshot.raw["monsters"]) if include_monsters else None
monsters = monster_rows(catalog, snapshot, managed) if include_monsters else None
return Views(snapshot, source, set(managed), monsters,
str(snapshot.raw["master"]["id"]), stage_cache.get(snapshot) if stage_cache else stages(catalog, snapshot), stage_cache,
statistics, statistics.snapshot(snapshot.raw["master"]["id"]) if statistics else None)
File diff suppressed because it is too large Load Diff
+498
View File
@@ -0,0 +1,498 @@
"""Compact task pages; account workers prepare data, Qt only renders cached rows."""
import copy
from dataclasses import asdict, dataclass
from datetime import datetime, timedelta, timezone
import json
from PySide6 import QtCore as C, QtWidgets as W
from .native_widgets import ComboBox, IntegerInput, RowBatch
from .policy_io import checked_progression_policy
from .progression import ProgressionPolicy
from .table_widgets import set_value, table_item
CATEGORIES = {"mainline": "主线", "sidequest": "支线", "commission": "委托", "event": "活动(暂不自动)",
"bond": "羁绊(暂不自动)", "unknown": "其他 / 未知"}
BATTLE_KINDS = {"mainline": "主线战斗", "sidequest": "支线战斗", "commission": "委托战斗",
"battle": "普通战斗", "map_battle": "地图战斗", "sweep": "扫荡", "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"}
BATTLE_MODES = {"original": "原版运行时(以能力检查为准)", "experimental": "实验模拟(近似,未完整验证)"}
STATES = {"available": "可接取", "unaccepted": "未接取", "active": "进行中", "in_progress": "进行中",
"ready": "待交付", "completed": "已完成", "complete": "已完成", "claimed": "已领奖",
"received": "进行中", "unlocked": "已解锁 / 待接取", "locked": "未解锁", "finished": "已完成",
"ready_to_reward": "待领取任务奖励", "blocked": "受阻", "unsupported": "暂不支持", "unknown": "未知"}
CHINA_TIME = timezone(timedelta(hours=8))
OUTCOMES = {"win": "胜利", "loss": "战败", "unsupported": "暂不支持", "event": "地图奖励事件",
"completed": "已完成", "cancelled": "已取消", "timeout": "超时", "unknown": "结果待核对"}
def category(value):
return {"main": "mainline", "side": "sidequest", "sidequests": "sidequest", "commissions": "commission",
"主线": "mainline", "支线": "sidequest", "委托": "commission"}.get(value, value) if isinstance(value, str) else "unknown"
def display(value, empty="—"):
if value is None or value == "":
return empty
if isinstance(value, (dict, list, tuple)):
return json.dumps(value, ensure_ascii=False, sort_keys=True)
return str(value)
@dataclass
class ProgressionViews:
snapshot: object
tasks: list | None
records: list | None
message: str = ""
def prepare_progression_views(engine, *, tasks=True, records=True):
"""Worker boundary: getters may parse task data or read local battle records."""
task_reader = getattr(engine, "progression_rows", None)
record_reader = getattr(engine, "progression_records", None)
task_data = task_reader() if tasks and callable(task_reader) else []
record_data = record_reader() if records and callable(record_reader) else []
for name, rows in (("progression_rows", task_data), ("progression_records", record_data)):
if not isinstance(rows, list) or any(not isinstance(row, dict) for row in rows):
raise TypeError(name + "() 必须返回 list[dict]")
task_rows, record_rows = [], []
for index, source in enumerate(task_data):
row = copy.deepcopy(source)
kind = category(row.get("category", "unknown"))
kind = kind if kind in CATEGORIES else "unknown"
state = display(row.get("state"), "未知")
reason = display(row.get("blocked_reason") or row.get("block_reason") or row.get("reason"), "")
supported = row.get("supported")
support = "受阻:" + reason if reason else "已支持" if supported is True else "暂不支持" if supported is False else "支持状态未确认"
step = display(row.get("step_number")) + " / " + display(row.get("total_steps"))
battle = display(row.get("battle_kind"), "未确认")
battle = BATTLE_ALIASES.get(battle, battle)
location = row.get("location_text") or row.get("location") or row.get("position")
values = [display(row.get("task_type_id")), CATEGORIES[kind], display(row.get("name")), STATES.get(state, state), step,
display(location), display(row.get("requirement")), display(row.get("next_action")),
BATTLE_KINDS.get(battle, battle), support]
dialogue = display(row.get("dialogue") or row.get("dialogue_text") or row.get("dialogue_status"), "当前未提供对话内容")
detail = "\n".join(("任务:" + values[2] + " #" + values[0] + ";类别:" + values[1] + ";状态:" + values[3] + ";步骤:" + step,
"目标 / 位置:" + values[5] + ";NPC:" + display(row.get("npc_name")), "需求:" + values[6], "对话:" + dialogue,
"下一步:" + values[7] + ";战斗:" + values[8] + ";运行状态:" + display(row.get("status"), values[3]),
"支持状态 / 阻塞原因:" + support))
task_rows.append({"key": str(index), "category": kind, "values": values, "detail": detail,
"search": (" ".join(values) + " " + dialogue).casefold()})
for index, source in enumerate(record_data):
row = copy.deepcopy(source)
raw_kind = row.get("battle_kind") or row.get("kind") or row.get("context") or "unknown"
kind = BATTLE_ALIASES.get(raw_kind, raw_kind) if isinstance(raw_kind, str) else "unknown"
if row.get("outcome") == "event":
kind = "map_reward_event"
elif row.get("task_id") and kind == "battle":
kind = "task_battle"
elif row.get("kind") == "sweep":
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:
stamp = datetime.fromtimestamp(stamp, CHINA_TIME).strftime("%Y-%m-%d %H:%M:%S")
outcome = row.get("outcome") or row.get("status") or row.get("phase") or row.get("result")
if isinstance(outcome, dict):
outcome = outcome.get("outcome") or outcome.get("status")
outcome = display(outcome, "未确认")
values = [display(stamp), BATTLE_KINDS.get(kind, display(raw_kind)),
display(row.get("name") or row.get("task_type_id") or row.get("stage_id") or row.get("stage") or row.get("description")),
display(row.get("team")), OUTCOMES.get(outcome, outcome),
display(row.get("blocked_reason") or row.get("block_reason") or row.get("message") or row.get("reason"))]
mode = row.get("battle_mode") or row.get("execution_mode")
mode = mode if isinstance(mode, str) else None
if mode == "experimental":
values[4] += "(实验近似)"
detail = "\n".join(("时间(北京时间):" + values[0], "上下文:" + values[1] + ";任务 / 地图:" + values[2],
"战斗模式:" + BATTLE_MODES.get(mode, "记录未标明"),
"队伍:" + values[3] + ";结果:" + values[4], "详情 / 阻塞原因:" + values[5], "奖励:" + display(row.get("reward"))))
record_rows.append({"key": str(index), "category": kind if kind in BATTLE_KINDS else "unknown", "values": values,
"detail": detail, "search": " ".join(values).casefold()})
message = "" if callable(task_reader) else "当前引擎尚未提供任务读取;任务只展示,不自动推进"
return ProgressionViews(getattr(engine, "snapshot", None), task_rows if tasks else None, record_rows if records else None, message)
class CachedTable(W.QTableWidget):
"""Refresh owned items in short batches; never reinsert an existing Qt item."""
def __init__(self, headers, left_columns=()):
super().__init__(0, len(headers))
self.setHorizontalHeaderLabels(headers)
self.setEditTriggers(W.QAbstractItemView.EditTrigger.NoEditTriggers)
self.setSelectionBehavior(W.QAbstractItemView.SelectionBehavior.SelectRows)
self.setSelectionMode(W.QAbstractItemView.SelectionMode.SingleSelection)
self.horizontalHeader().setStretchLastSection(True)
self.verticalHeader().setMinimumSectionSize(18)
self.verticalHeader().setDefaultSectionSize(22)
self.row_batch = RowBatch(self)
self.signature = None
self.details = {}
self.left_columns = {0, 1, *left_columns}
def set_rows(self, rows):
if self.signature == rows:
return
self.row_batch.stop()
self.signature = None
self.details = {row["key"]: row["detail"] for row in rows}
self.setSortingEnabled(False)
self.setRowCount(len(rows))
def apply(entry):
index, row = entry
for column, value in enumerate(row["values"]):
cell = self.item(index, column)
if cell is None:
cell = table_item(value, column)
self.setItem(index, column, cell)
else:
set_value(cell, column, value)
cell.setToolTip(value)
if column in self.left_columns:
cell.setTextAlignment(C.Qt.AlignmentFlag.AlignVCenter | C.Qt.AlignmentFlag.AlignLeft)
if column == 0:
cell.setData(C.Qt.ItemDataRole.UserRole, row["key"])
def finish():
self.signature = rows
self.setSortingEnabled(True)
self.itemSelectionChanged.emit()
self.row_batch.start(enumerate(rows), apply, finish)
class ProgressionPages:
def progression_tab(self):
self.progression_views = None
self.pending_progression_view = False
self.progression_generation = 0
self.progression_page = W.QWidget()
layout = W.QVBoxLayout(self.progression_page)
tools = W.QHBoxLayout()
self.progression_enabled = W.QCheckBox("启用自动主线策略")
self.progression_refresh_button = W.QPushButton("刷新任务 / 预览")
self.progression_refresh_button.clicked.connect(self.refresh_progression)
tools.addWidget(self.progression_enabled)
tools.addWidget(self.progression_refresh_button)
tools.addStretch()
layout.addLayout(tools)
self.progression_status = W.QLabel()
self.progression_status.setWordWrap(True)
layout.addWidget(self.progression_status)
self.progression_tabs = W.QTabWidget()
task_page = W.QWidget()
task_layout = W.QVBoxLayout(task_page)
filters = W.QHBoxLayout()
self.progression_filter = ComboBox()
for key, name in (("", "全部类别"), *CATEGORIES.items()):
self.progression_filter.addItem(name, key)
self.progression_search = W.QLineEdit()
self.progression_search.setPlaceholderText("按任务编号、名称、目标或阻塞原因筛选")
filters.addWidget(self.progression_filter)
filters.addWidget(self.progression_search, 1)
task_layout.addLayout(filters)
self.progression_table = CachedTable(["编号", "类别", "任务", "状态", "步骤", "目标 / 位置", "需求", "下一步", "战斗类型", "支持状态 / 阻塞原因"],
left_columns=(2, 5, 6, 7, 9))
self.progression_table.setColumnWidth(2, 180)
task_layout.addWidget(self.progression_table, 1)
self.progression_detail = W.QPlainTextEdit()
self.progression_detail.setReadOnly(True)
self.progression_detail.setMaximumHeight(108)
self.progression_detail.setPlaceholderText("选择任务,查看步骤、目标、对话、运行状态和阻塞原因")
task_layout.addWidget(self.progression_detail)
self.progression_tabs.addTab(task_page, "任务状态")
settings = W.QWidget()
form = W.QFormLayout(settings)
defaults = ProgressionPolicy()
groups = (("任务类别", (("mainline", "主线"), ("sidequests", "支线"), ("commissions", "委托(仅诊断)"))),
("任务流程", (("accept", "接取已确认的任务"), ("auto_dialogue", "自动推进已支持的对话"),
("repair_chain", "补全已确认的任务链"))),
("交付 / 通关", (("allow_items", "允许提交物品"), ("allow_monsters", "允许提交魔物"),
("allow_sweep", "允许用扫荡完成已通关目标"))))
for label, choices in groups:
line = W.QHBoxLayout()
for key, text in choices:
check = W.QCheckBox(text)
check.setChecked(getattr(defaults, key))
setattr(self, "progression_" + key, check)
line.addWidget(check)
line.addStretch()
form.addRow(label, line)
if hasattr(defaults, "auto_farm"):
self.progression_auto_farm = W.QCheckBox("自动收集任务材料 / 击杀目标")
self.progression_auto_farm.setChecked(defaults.auto_farm)
self.progression_auto_farm.setToolTip("允许规划器为已识别的材料或击杀缺口选择普通地图。\n"
"仍受任务规则、战斗能力、保留体力和顶部“开启 / 停止”限制;无法匹配的目标会显示原因。")
form.addRow("任务目标", self.progression_auto_farm)
self.progression_commissions.setToolTip("委托交付由“自动委托”页独立配置;此项只纳入任务诊断,不开启委托执行")
self.progression_battle_mode = ComboBox()
for mode, label in BATTLE_MODES.items():
self.progression_battle_mode.addItem(label, mode)
self.progression_battle_mode.setToolTip("原版运行时:只执行当前能力检查确认支持的战斗。\n"
"实验模拟:近似推演,不保证与原版结果一致,也不代表全部规则已经验证;实际可用范围以能力检查为准。\n"
"任务和委托战斗共用此模式,仍由顶部“开启 / 停止”控制。")
form.addRow("战斗模式(任务 / 委托)", self.progression_battle_mode)
self.progression_team = ComboBox()
for team in ("teamA", "teamB", "teamC"):
self.progression_team.addItem(team, team)
form.addRow("推进战斗队伍", self.progression_team)
for key, label, maximum in (("reserve_ti", "保留体力", 1_000_000_000), ("max_money", "单次交付金币上限(0=不交金币)", 1_000_000_000),
("stop_after_loss", "连续失败后停止次数", 999)):
widget = IntegerInput()
widget.setRange(1 if key == "stop_after_loss" else 0, maximum)
widget.setValue(getattr(defaults, key))
setattr(self, "progression_" + key, widget)
form.addRow(label, widget)
self.progression_item_reserves = W.QLineEdit()
self.progression_item_reserves.setPlaceholderText("物品编号:保留数量,多个用英文逗号分隔")
form.addRow("交付后至少保留", self.progression_item_reserves)
note = W.QLabel("勾选功能后,使用顶部绿色“开启”运行。支持状态以任务列表为准;未知状态不会自动执行。\n任务列表区分主线 / 支线 / 委托;战斗记录区分普通战斗、扫荡和地图奖励事件。未支持的步骤显示原因。")
note.setWordWrap(True)
form.addRow(note)
scroll = W.QScrollArea()
scroll.setWidgetResizable(True)
scroll.setFrameShape(W.QFrame.Shape.NoFrame)
scroll.setWidget(settings)
self.progression_tabs.addTab(scroll, "推进策略")
layout.addWidget(self.progression_tabs, 1)
self.tabs.addTab(self.progression_page, "自动主线")
self.progression_filter.currentIndexChanged.connect(self.render_progression)
self.progression_search.textChanged.connect(self.render_progression)
self.progression_table.itemSelectionChanged.connect(self.progression_selection_changed)
self.progression_enabled.toggled.connect(self.progression_settings_changed)
self.update_progression_status()
def battle_records_tab(self):
self.battle_records_page = W.QWidget()
layout = W.QVBoxLayout(self.battle_records_page)
tools = W.QHBoxLayout()
self.battle_records_filter = ComboBox()
for key, name in (("", "全部上下文"), *BATTLE_KINDS.items()):
self.battle_records_filter.addItem(name, key)
self.battle_records_search = W.QLineEdit()
self.battle_records_search.setPlaceholderText("按任务、地图、结果或阻塞原因筛选")
refresh = W.QPushButton("刷新本地记录")
refresh.clicked.connect(self.refresh_progression_records)
for widget in (self.battle_records_filter, self.battle_records_search, refresh):
tools.addWidget(widget)
layout.addLayout(tools)
self.battle_records_status = W.QLabel("尚无已读取的战斗记录;地图奖励事件会单独标明,结果以实际记录为准")
self.battle_records_status.setWordWrap(True)
layout.addWidget(self.battle_records_status)
self.battle_records_table = CachedTable(["时间(北京时间)", "上下文", "任务 / 地图", "队伍", "结果", "详情 / 阻塞原因"], left_columns=(2, 5))
for column, width in enumerate((158, 124, 140, 70, 95)):
self.battle_records_table.setColumnWidth(column, width)
layout.addWidget(self.battle_records_table, 1)
self.battle_record_detail = W.QPlainTextEdit()
self.battle_record_detail.setReadOnly(True)
self.battle_record_detail.setMaximumHeight(108)
self.battle_record_detail.setPlaceholderText("选择记录查看引擎提供的详情")
layout.addWidget(self.battle_record_detail)
self.tabs.addTab(self.battle_records_page, "战斗记录")
self.battle_records_filter.currentIndexChanged.connect(self.render_progression)
self.battle_records_search.textChanged.connect(self.render_progression)
self.battle_records_table.itemSelectionChanged.connect(self.progression_selection_changed)
def progression_settings_changed(self, *args):
if self.loading_config or self.closed:
return
if self.sender() is self.progression_enabled and not self.progression_enabled.isChecked():
self.cancel_progression()
self.update_progression_status()
self.settings_changed()
def cancel_progression(self):
self.progression_generation += 1
cancel = getattr(self.engine, "cancel_progression", None)
if callable(cancel):
cancel()
def read_progression_policy(self):
value = {}
for key, default in asdict(ProgressionPolicy()).items():
widget = getattr(self, "progression_" + key)
if key == "item_reserves":
reserves = {}
for entry in widget.text().split(","):
if entry.strip():
item_id, count = entry.split(":")
reserves[item_id.strip()] = int(count.strip())
value[key] = reserves
elif isinstance(widget, W.QComboBox):
value[key] = widget.currentData()
else:
value[key] = widget.isChecked() if type(default) is bool else widget.value()
return checked_progression_policy(value)
def load_progression_policy(self, policy):
for key, value in asdict(policy).items():
widget = getattr(self, "progression_" + key)
blocker = C.QSignalBlocker(widget)
if key == "item_reserves":
widget.setText(",".join(f"{item_id}:{count}" for item_id, count in value.items()))
elif isinstance(widget, W.QComboBox):
index = widget.findData(value)
if index < 0:
if key != "team":
raise ValueError("不支持的策略选项:" + key)
widget.addItem(value + "(当前账号未找到)", value)
index = widget.findData(value)
widget.setCurrentIndex(index)
elif type(value) is bool:
widget.setChecked(value)
else:
widget.setValue(value)
del blocker
self.update_progression_status()
def refresh_progression_teams(self, snapshot):
"""Keep imported selections visible until this account confirms a team."""
selected = self.progression_team.currentData() or "teamA"
names = ["teamA", "teamB", "teamC"]
confirmed = set()
for team in snapshot.raw.get("teams", []):
name = team.get("teamName")
if team.get("teamType") == "battleTeam" and isinstance(name, str) and name:
confirmed.add(name)
if name not in names:
names.append(name)
if selected not in names:
names.append(selected)
options = [(name + "(当前账号未找到)" if name == selected and name not in confirmed and name not in ("teamA", "teamB", "teamC") else name, name)
for name in names]
widget = self.progression_team
if [(widget.itemText(i), widget.itemData(i)) for i in range(widget.count())] != options:
blocker = C.QSignalBlocker(widget)
widget.clear()
for label, name in options:
widget.addItem(label, name)
widget.setCurrentIndex(widget.findData(selected))
del blocker
def update_progression_status(self):
if not hasattr(self, "progression_status"):
return
active = self.strategy_toggle.isChecked() and self.progression_enabled.isChecked()
text = "自动主线已开启" if active else "策略已停止;顶部“开启”后执行勾选功能" if self.progression_enabled.isChecked() else "自动主线未启用"
mode = self.progression_battle_mode.currentData()
text += ";战斗模式:" + BATTLE_MODES.get(mode, "未选择,请检查策略")
if not callable(getattr(self.engine, "refresh_progression", None)):
text += ";当前引擎尚未接入任务刷新"
if not callable(getattr(self.engine, "run_progression_once", None)):
text += ";当前引擎尚未接入自动推进"
if self.progression_views and self.progression_views.message:
text += ";" + self.progression_views.message
self.progression_status.setText(text)
def refresh_progression(self, checked=False):
if self.closed:
return
if self.busy:
self.pending_refresh = self.progression_page
self.statusBar().showMessage("当前请求完成后刷新任务")
return
refresh = getattr(self.engine, "refresh_progression", None)
if not callable(refresh):
self.report("当前引擎尚未提供任务刷新;请等待功能接入")
self.request_progression_views(force=True)
return
try:
self.update_policy()
except ValueError as error:
self.stop_workflow()
self.report("主线策略输入有误:" + str(error))
return
self.run_job("progression_refresh", refresh)
def run_progression_once(self):
"""Explicit one-step entry; it never changes the global execution switch."""
if self.closed or self.busy:
return
if not self.strategy_toggle.isChecked() or not self.progression_enabled.isChecked():
self.report("自动主线已停止;请先勾选策略并开启顶部开关")
return
run = getattr(self.engine, "run_progression_once", None)
if not callable(run):
self.report("当前引擎尚未提供自动推进")
return
try:
self.update_policy()
except ValueError as error:
self.stop_workflow()
self.report("主线策略输入有误:" + str(error))
return
self.engine.auto = self.monitoring and self.strategy_toggle.isChecked()
engine, generation = self.engine, self.progression_generation
def execute():
if generation != self.progression_generation or not engine.auto:
return engine.snapshot, [], "任务推进已取消;未开始执行"
return run()
self.run_job("progression_run", execute)
def refresh_progression_records(self, checked=False):
self.request_progression_views(force=True)
def clear_progression_views(self):
self.progression_views = None
self.pending_progression_view = False
for widget in (self.progression_table, self.battle_records_table):
widget.row_batch.stop()
widget.set_rows([])
self.progression_detail.clear()
self.battle_record_detail.clear()
self.update_progression_status()
def accept_progression_views(self, views):
previous = self.progression_views
if previous and previous.snapshot is views.snapshot:
if views.tasks is None:
views.tasks = previous.tasks
if views.records is None:
views.records = previous.records
self.progression_views = views
def request_progression_views(self, *, force=False):
if self.closed or self.engine.snapshot is None:
return
tasks = self.tabs.currentWidget() is not self.battle_records_page
cached = self.progression_views
if not force and cached and cached.snapshot is self.engine.snapshot and (cached.tasks if tasks else cached.records) is not None:
return
if self.busy:
self.pending_progression_view = True
return
self.pending_progression_view = False
engine = self.engine
self.run_job("progression_view", lambda: prepare_progression_views(engine, tasks=tasks, records=not tasks))
def render_progression(self, *args):
if self.closed or not self.presentation_active:
return
page = self.tabs.currentWidget()
if page not in (self.progression_page, self.battle_records_page):
return
views = self.progression_views
tasks = page is self.progression_page
if views is None or views.snapshot is not self.engine.snapshot or (views.tasks if tasks else views.records) is None:
self.request_progression_views()
table = self.progression_table if tasks else self.battle_records_table
rows = ((views.tasks if tasks else views.records) or []) if views else []
selected = self.progression_filter.currentData() if tasks else self.battle_records_filter.currentData()
query = (self.progression_search.text() if tasks else self.battle_records_search.text()).strip().casefold()
visible = [row for row in rows if (not selected or row["category"] == selected) and (not query or query in row["search"])]
table.set_rows(visible)
if not tasks:
self.battle_records_status.setText(f"已读取 {len(rows)} 条记录,显示 {len(visible)} 条;战斗、扫荡和地图奖励事件分别标记" if rows else
"尚无已读取的战斗记录;未记录结果不代表战斗成功")
self.update_progression_status()
self.progression_selection_changed()
def progression_selection_changed(self):
for table, detail in ((self.progression_table, self.progression_detail), (self.battle_records_table, self.battle_record_detail)):
item = table.item(table.currentRow(), 0)
text = table.details.get(item.data(C.Qt.ItemDataRole.UserRole), "") if item else ""
if detail.toPlainText() != text:
detail.setPlainText(text)
+8 -5
View File
@@ -78,7 +78,9 @@ class TaskPlanner:
self.guard = Planner(catalog)
def current(self, snapshot):
return [t for t in snapshot.raw.get("currentTasks", []) if str(t.get("typeId")) in self.catalog.data.get("task_info", {})]
infos = self.catalog.data.get("task_info", {})
return [t for t in snapshot.raw.get("currentTasks", []) if str(t.get("typeId")) in infos
and infos[str(t["typeId"])].get("type", 4) == 4]
def requirement(self, snapshot, step, task, policy, ranch):
if not condition_ok(step.get("condition"), snapshot):
@@ -146,11 +148,11 @@ class TaskPlanner:
continue
for type_id in offers:
info = self.catalog.data.get("task_info", {}).get(str(type_id), {})
if info:
if info and info.get("type", 4) == 4:
rows.append((str(type_id), info.get("name", ""), f"城市 {city} 可接", info.get("des", ""), {"city": int(city)}))
return rows
def plan(self, snapshot, policy, ranch):
def plan(self, snapshot, policy, ranch, *, include_active=True, accept_supported=None):
if not policy.enabled:
return []
history = snapshot.raw.get("history", {})
@@ -159,7 +161,7 @@ class TaskPlanner:
current_day = int((snapshot.now - 10 + 8 * 3600) // 86400)
if old_day < current_day:
return [Action("quest_reset", "刷新跨日委托", "taskService/taskLoopFlush", {})]
for task in self.current(snapshot):
for task in self.current(snapshot) if include_active else []:
info = self.catalog.data["task_info"][str(task["typeId"])]
index, steps = int(task.get("curStep", 1)) - 1, info.get("steps", [])
payload = {"taskId": int(task["id"]), "taskTypeId": str(task["typeId"])}
@@ -182,7 +184,8 @@ class TaskPlanner:
if info.get("closed") or not condition_ok((info.get("startStep") or {}).get("condition"), snapshot):
continue
steps = info.get("steps", [])
supported = all((s.get("statusType") in ("passStage", "battle") and policy.battle_tasks)
supported = accept_supported(type_id) if accept_supported else all(
(s.get("statusType") in ("passStage", "battle") and policy.battle_tasks)
or self.requirement(snapshot, s, {}, policy, ranch)[0] for s in steps)
if supported:
return [Action("quest_accept", f"接取委托:{name}", "taskService/taskLoopReceive", {"taskTypeId": type_id, "city": city})]
+1
View File
@@ -274,6 +274,7 @@ class AccountGuiTests(unittest.TestCase):
hub.tabs.setCurrentWidget(first)
for page in (first.egg_page, first.monster_page, first.room_page):
first.tabs.setCurrentWidget(page)
self.wait(windows)
self.assertEqual([first.slots.rowCount(), first.eggs.rowCount(), len(first.monsters.monster_items)], [11, 4, 4])
self.assertFalse(first.monsters.group_items)
self.assertTrue(all(item.parent() is None for item in first.monsters.monster_items.values()))
+60
View File
@@ -0,0 +1,60 @@
"""AMF3 array shapes and object-reference regressions, entirely offline."""
import unittest
from ranch_assistant.amf import Reader
class ArrayReaderTests(unittest.TestCase):
def test_empty_dense_array_is_list_and_occupies_object_reference_slot(self):
reader = Reader(b"\x09\x01\x01\x09\x00")
value = reader.read()
self.assertIs(type(value), list)
self.assertEqual(value, [])
self.assertIs(reader.read(), value)
self.assertIs(reader.objects[0], value)
self.assertEqual(reader.pos, len(reader.data))
def test_pure_associative_array_preserves_self_reference(self):
# Array, zero dense entries, property 'x', array reference 0, end keys.
reader = Reader(b"\x09\x01\x03x\x09\x00\x01")
value = reader.read()
self.assertIs(type(value), dict)
self.assertIs(value["x"], value)
self.assertIs(reader.objects[0], value)
def test_dense_array_preserves_self_reference(self):
reader = Reader(b"\x09\x03\x01\x09\x00")
value = reader.read()
self.assertIs(type(value), list)
self.assertIs(value[0], value)
def test_nested_empty_array_keeps_parent_and_child_reference_order(self):
# [empty array, reference to that array, reference to parent]
reader = Reader(b"\x09\x07\x01\x09\x01\x01\x09\x02\x09\x00")
value = reader.read()
self.assertIs(type(value[0]), list)
self.assertIs(value[1], value[0])
self.assertIs(value[2], value)
self.assertIs(reader.objects[0], value)
self.assertIs(reader.objects[1], value[0])
def test_associative_first_key_can_use_string_reference(self):
reader = Reader(b"\x06\x03k\x09\x01\x00\x04\x07\x01")
self.assertEqual(reader.read(), "k")
self.assertEqual(reader.read(), {"k": 7})
self.assertEqual(len(reader.objects), 1)
def test_dynamic_empty_object_remains_mapping(self):
reader = Reader(b"\x0a\x0b\x01\x01\x0a\x00")
value = reader.read()
self.assertIs(type(value), dict)
self.assertEqual(value, {})
self.assertIs(reader.read(), value)
def test_mixed_arrays_still_rejected(self):
with self.assertRaisesRegex(ValueError, "Mixed AMF array unsupported"):
Reader(b"\x09\x03\x03k\x04\x01\x01\x04\x02").read()
if __name__ == "__main__":
unittest.main()
+1
View File
@@ -425,6 +425,7 @@ class AutomationGuiTests(unittest.TestCase):
before = len(window.engine.snapshot.raw["monsters"])
def select(mid):
window.tabs.setCurrentWidget(window.monster_page)
self.wait(window)
window.monsters.clearSelection()
window.monsters.setCurrentItem(window.monsters.monster_items[mid])
select(101)
File diff suppressed because it is too large Load Diff
@@ -0,0 +1,488 @@
from contextlib import ExitStack
from copy import deepcopy
from dataclasses import asdict, replace
import hashlib
import json
import os
from pathlib import Path
import struct
import sys
import threading
import time
from types import SimpleNamespace
import unittest
from unittest.mock import patch
import zipfile
import zlib
from ranch_assistant.battle_runtime import (
BattleRequest, BattleRuntime, ORIGINAL_APK_SHA256, ORIGINAL_MAIN_SHA256, original_fixture_request,
)
from ranch_assistant.tests.test_core import workspace_temp
from tools.battle_runtime.isolation import ProcessResult, run_isolated
from tools.battle_runtime.swf_library import encode_tag, library_only, symbols, tags
from tools.battle_runtime.trusted import verify_files
from tools.battle_runtime.inputs import ADD_FIELDS, MON_FIELDS, validate
from tools.battle_runtime.prepare import asset_index, write_atomic
class RuntimeContractTests(unittest.TestCase):
def setUp(self):
self.stack = ExitStack()
self.addCleanup(self.stack.close)
self.root = Path(self.stack.enter_context(workspace_temp()))
(self.root / "fixture_1.9.68.apk").write_bytes(b"Not an engine; contract tests never execute this")
self.stack.enter_context(patch("ranch_assistant.battle_runtime.ROOT", self.root))
self.stack.enter_context(patch("ranch_assistant.battle_runtime.LOCAL", self.root / "runtime"))
self.stack.enter_context(patch("ranch_assistant.battle_runtime.os", SimpleNamespace(name="nt")))
self.stack.enter_context(patch("tools.battle_runtime.trusted.verify_files", return_value=[]))
self.request = original_fixture_request()
def inspect(self, **changes):
return BattleRuntime().inspect(replace(self.request, **changes))
def codes(self, capability):
return {row["code"] for row in capability["reasons"]}
def test_native_fixture_support_never_grants_settlement_or_fidelity(self):
capability = self.inspect()
self.assertTrue(capability["supported"])
self.assertFalse(capability["faithful"])
self.assertFalse(capability["settlement_eligible"])
self.assertEqual(capability["coverage"]["validated_skills"], [3])
def test_default_purpose_refuses_before_starting_any_process(self):
request = BattleRequest("ordinary_stage", self.request.original_data, self.request.roster, stage_id="0101")
with patch("tools.battle_runtime.isolation.run_isolated") as execute:
result = BattleRuntime().run(request)
execute.assert_not_called()
self.assertEqual(result["status"], "unsupported")
self.assertIn("settlement_not_validated", self.codes(result["capability"]))
self.assertNotIn("outcome", result)
self.assertNotIn("offline_result", result)
def test_dict_contract_matches_dataclass_and_input_is_unchanged(self):
request = asdict(self.request)
before = json.loads(json.dumps(request))
self.assertEqual(BattleRuntime().inspect(request), BattleRuntime().inspect(self.request))
self.assertEqual(request, before)
def test_unknown_context_and_unhashable_context_refuse(self):
for context in ("boss", "pve", ["ordinary_stage"], None):
with self.subTest(context=context):
self.assertIn("unknown_context", self.codes(self.inspect(context=context)))
def test_task_routes_cannot_reuse_the_ordinary_stage_proof(self):
for context in ("task_battle", "task_pass_stage"):
capability = self.inspect(context=context, task_id="1001004", step_index=0)
self.assertFalse(capability["supported"])
self.assertIn("task_route_not_validated", self.codes(capability))
def test_other_stages_and_difficulties_refuse(self):
for changes in ({"stage_id":"0102"}, {"difficulty":2}, {"difficulty":True}, {"difficulty":"1"}):
self.assertIn("scene_not_validated", self.codes(self.inspect(**changes)))
def test_task_fields_are_rejected_even_with_ordinary_context(self):
self.assertIn("task_input_not_validated", self.codes(self.inspect(step_index=0)))
def test_unknown_roster_skills_equipment_and_estimates_refuse(self):
for roster in ({"hp":100,"atk":100}, {**self.request.roster,"skills":[9999]},
{**self.request.roster,"equipment":[123]}):
self.assertIn("roster_not_validated", self.codes(self.inspect(roster=roster)))
def test_unverified_original_tables_cannot_enable_unknown_mechanics(self):
data = {**self.request.original_data, "battle":{"controller":[{"type":"unimplemented"}]}}
self.assertIn("external_battle_data_unvalidated", self.codes(self.inspect(original_data=data)))
def test_claimed_original_identity_must_match_both_pins(self):
identity = {**self.request.original_data["resource_identity"], "main_swf_sha256":"0" * 64}
self.assertIn("resource_identity_mismatch", self.codes(self.inspect(original_data={
"source":"original_apk", "resource_identity":identity})))
def test_imported_commands_paths_and_unsigned_verified_manifests_never_execute(self):
for config in ({"command":["cmd","/c","anything"]}, {"executable":"evil.exe"},
{"backend":"original_air","verified":True,"supports":["*"]},
{"backend":"original_air","resource_root":"somewhere"}):
with self.subTest(config=config), patch("tools.battle_runtime.isolation.run_isolated") as execute:
result = BattleRuntime(config).run(self.request)
self.assertEqual(result["status"], "unsupported")
self.assertIn("untrusted_runtime_config", self.codes(result["capability"]))
execute.assert_not_called()
def test_foreign_backend_refuses(self):
result = BattleRuntime({"backend":"basic_estimate"}).inspect(self.request)
self.assertIn("unknown_backend", self.codes(result))
def test_unsigned_result_in_request_is_not_an_engine_result(self):
request = {**asdict(self.request), "result":{"win":True}, "verified":True}
result = BattleRuntime().run(request)
self.assertEqual(result["status"], "unsupported")
self.assertIn("unknown_request_fields", self.codes(result["capability"]))
def test_malformed_nonfinite_and_oversize_inputs_refuse(self):
for request in (None, [], {}, {**asdict(self.request),"roster":{"hp":float("nan")}},
{**asdict(self.request),"roster":{"payload":"x" * (4 * 1024 * 1024)}}):
self.assertFalse(BattleRuntime().inspect(request)["supported"])
def test_cancellation_before_run_does_not_inspect_or_launch(self):
event = threading.Event(); event.set()
runtime = BattleRuntime()
with patch.object(runtime,"inspect") as inspect:
result = runtime.run(self.request,cancel_event=event)
inspect.assert_not_called()
self.assertEqual(result["status"], "cancelled")
def test_timeout_must_be_finite_and_positive(self):
for value in (0, -1, True, float("nan"), float("inf"), "5"):
with self.subTest(value=value), self.assertRaises(ValueError):
BattleRuntime().run(self.request, timeout=value)
def fake_worker(self, mutate):
def execute(argv, **kwargs):
output = Path(argv[argv.index("--output")+1])
nonce = argv[argv.index("--nonce")+1]
payload = {"schema":1,"nonce":nonce,"evidence":{
"resource_identity":{"apk_sha256":ORIGINAL_APK_SHA256,"main_swf_sha256":ORIGINAL_MAIN_SHA256},
"resource_audit":{"all_present_assets_match_apk":True},"process_exit_code":0,
"result":{"status":"scene_completed","battle_executed":True,"settlement_eligible":False,
"scene_result":{"outcome":"win","battle_data":{"win":True,"cheatNum":0,"battlePosition":{
"battleType":"stage","stageLevel":"1","stageId":"0101","taskTypeId":None,"taskStep":0}},
"anomaly_records":{"text":"real anomaly","damages":[{"damage":999}]}}}}}
mutate(payload)
output.write_text(json.dumps(payload),encoding="utf-8")
return ProcessResult("completed",0,.1,"","")
return execute
def test_result_protocol_rejects_wrong_nonce_identity_claim_or_missing_execution(self):
mutations = [lambda p:p.update(nonce="wrong"),
lambda p:p["evidence"]["resource_identity"].update(apk_sha256="0" * 64),
lambda p:p["evidence"]["resource_identity"].update(main_swf_sha256="0" * 64),
lambda p:p["evidence"]["result"].update(settlement_eligible=True),
lambda p:p["evidence"]["result"].update(faithful=True),
lambda p:p["evidence"]["result"].update(battle_executed=False),
lambda p:p["evidence"]["resource_audit"].update(all_present_assets_match_apk=False),
lambda p:p["evidence"]["result"]["scene_result"].update(outcome="invented")]
for mutation in mutations:
with self.subTest(mutation=mutation), patch("tools.battle_runtime.isolation.run_isolated",side_effect=self.fake_worker(mutation)):
result = BattleRuntime().run(self.request)
self.assertEqual(result["status"], "error")
self.assertNotIn("outcome",result)
self.assertFalse(result["settlement_eligible"])
def test_original_anomaly_records_survive_protocol_without_filtering(self):
with patch("tools.battle_runtime.isolation.run_isolated",side_effect=self.fake_worker(lambda p:None)):
result = BattleRuntime().run(self.request)
self.assertEqual(result["status"],"completed")
self.assertEqual(result["offline_result"]["anomaly_records"]["text"],"real anomaly")
self.assertEqual(result["offline_result"]["anomaly_records"]["damages"],[{"damage":999}])
self.assertFalse(result["faithful"])
def test_positive_original_anomaly_count_preserves_completed_result(self):
def anomaly(payload):
payload["evidence"]["result"]["scene_result"]["battle_data"]["cheatNum"] = 4
with patch("tools.battle_runtime.isolation.run_isolated",side_effect=self.fake_worker(anomaly)):
result = BattleRuntime().run(self.request)
self.assertEqual(result["status"],"anomaly")
self.assertTrue(result["battle_completed"])
self.assertFalse(result["checks_passed"])
self.assertEqual(result["offline_result"]["anomaly_records"]["text"],"real anomaly")
def test_natural_native_time_limit_is_completed_loss_not_watchdog_timeout(self):
def expiry(payload):
scene = payload["evidence"]["result"]["scene_result"]
scene.update(outcome="loss",terminal_reason="time_limit")
scene["battle_data"].update(win=False,leftTime=0)
with patch("tools.battle_runtime.isolation.run_isolated",side_effect=self.fake_worker(expiry)):
result = BattleRuntime().run(self.request)
self.assertEqual(result["status"],"completed")
self.assertEqual(result["outcome"],"loss")
self.assertEqual(result["offline_result"]["terminal_reason"],"time_limit")
def test_default_deadline_allows_original_300_second_battle_and_explicit_is_preserved(self):
runtime=BattleRuntime()
with patch.object(runtime,"_execute",return_value={}) as execute:
runtime.run(self.request)
self.assertGreater(execute.call_args.kwargs["timeout"],600)
with patch.object(runtime,"_execute",return_value={}) as execute:
runtime.run(self.request,timeout=10)
self.assertGreater(execute.call_args.kwargs["timeout"],8)
self.assertLessEqual(execute.call_args.kwargs["timeout"],10)
def test_timed_out_worker_does_not_yield_a_battle_result(self):
with patch("tools.battle_runtime.isolation.run_isolated",return_value=ProcessResult("timeout",1,.1,"","")):
result = BattleRuntime().run(self.request)
self.assertEqual(result["status"],"timeout")
self.assertNotIn("outcome",result)
self.assertNotIn("offline_result",result)
class OriginalInputTests(unittest.TestCase):
"""Data-only preflight tests; no APK, AIR, account, or network is required."""
def setUp(self):
self.battle={"time":300,"groundType":1,"teams":[],"controller":[],"triggers":[],
"battleField":{"mapAreas":[],"mapObjects":[]}}
self.tables={"stage_info":{"0101":{"level":{"1":{"battle":self.battle}}}},
"task_info":{"original-task":{"steps":[
{"statusType":"battle","battle":self.battle},
{"statusType":"passStage","statusValue":{"stage":"0101","level":1}}]}},
"monster_info":{"1001010":{"skill_1":3,"skill_2":0,"imgFix":{"2":{"x":0,"y":0}}}},
"monster_skill":{"3":{}},"skin_info":{},"upstar_info":{},"item_info":{},
"team_info":{"battleTeam":{"0":{},"1":{}}},
"setting":{"groundType":{"1":{"battleImg":"background.png"}},"groundObject":{}},
"game_setting":{"normalBattleTime":300,"maxFeel":200},
"potential_info":{"potentialLevelMaxAdd":10}}
self.members={self.member(path) for path in ("data/img/bg/background.png","data/img/monster/q/1001010_q_2.png")}
mon=dict.fromkeys(MON_FIELDS,0)
mon.update(id=1000001,typeId=1001010,level=1,mode=2,process=3,potentialLevel=1,nicName="")
self.snapshot={"master":{"id":1,"level":1,"globalAtk":0,"globalDef":0,"globalHp":0,"globalDex":0},
"monsters":[mon],"monsterAttributes":[],"items":[],
"teams":[{"teamName":"teamB","teamType":"battleTeam","monsters":[1000001,0]}],
"history":{**dict.fromkeys(("numAddMoney","numChicken","countBattle"),0),
**{k:[] for k in ("monLib","equipLib","passAchi","guide_record","unlockCity")},
**{k:{} for k in ("numFeedMonsters","numKillMonsters","historyGacha","passTask","unlockTask","loopTask","unlockStage","passStage","payTypeCount","everyDayBuyProductNum")},
"guide_main":""}}
self.request={"context":"ordinary_stage","stage_id":"0101","difficulty":1,
"original_data":{"battle":self.battle},"roster":self.snapshot,"team":"teamB",
"battle_position":{"battleType":"stage","stageId":"0101","stageLevel":"1","taskTypeId":None,"taskStep":0}}
@staticmethod
def member(path):
return "assets/codes/"+hashlib.md5(path.encode()).hexdigest()
def validate(self,request=None):
return validate(self.request if request is None else request,source=(self.tables,self.members))
def codes(self,result):
return {r["code"] for r in result["reasons"]}
def test_raw_roster_contract_preserves_selected_team_b_and_empty_additions(self):
before=deepcopy(self.request);result=self.validate()
self.assertEqual(result["reasons"],[])
self.assertEqual(result["native_request"]["roster"]["team_name"],"teamB")
self.assertEqual(result["native_request"]["roster"]["snapshot"]["monsterAttributes"],[])
self.assertEqual(self.request,before)
def test_wrapper_and_raw_contract_produce_identical_native_input(self):
raw=self.validate()
wrapped=deepcopy(self.request);wrapped.pop("team")
wrapped["roster"]={"snapshot":self.snapshot,"team_name":"teamB"}
self.assertEqual(self.validate(wrapped)["native_request"],raw["native_request"])
def test_missing_or_conflicting_team_is_never_defaulted(self):
request=deepcopy(self.request);request.pop("team")
self.assertIn("invalid_roster",self.codes(self.validate(request)))
request["team"]="teamA"
self.assertIn("invalid_selected_team",self.codes(self.validate(request)))
request["roster"]={"snapshot":self.snapshot,"team_name":"teamB"}
self.assertIn("invalid_roster",self.codes(self.validate(request)))
def test_all_three_contexts_keep_original_position(self):
for context,index in (("task_battle",0),("task_pass_stage",1)):
request=deepcopy(self.request);request.update(context=context,stage_id=None,
task_id="account-instance",step_index=index,battle_position={"battleType":"task",
"stageId":None,"stageLevel":None,"taskTypeId":"original-task","taskStep":index})
result=self.validate(request)
self.assertEqual(result["reasons"],[])
self.assertEqual(result["position"],request["battle_position"])
request["battle_position"]["battleType"]="stage"
self.assertIn("battle_position_mismatch",self.codes(self.validate(request)))
def test_mismatched_task_status_step_and_authored_config_refuse(self):
request=deepcopy(self.request);request.update(context="task_battle",stage_id=None,
task_id="original-task",step_index=1,battle_position=None)
self.assertIn("invalid_battle_context",self.codes(self.validate(request)))
request=deepcopy(self.request);request["original_data"]["battle"]["time"]=1
self.assertIn("battle_config_mismatch",self.codes(self.validate(request)))
def test_unknown_original_mechanics_refuse_even_with_canonical_config(self):
for field,value,code in (("controller",[{"type":"unknown"}],"unknown_battle_controller"),
("triggers",[{"type":"time","effects":[{"type":"story"}]}],"unsupported_trigger_effect")):
with self.subTest(field=field):
self.battle[field]=value
self.assertIn(code,self.codes(self.validate()))
self.battle[field]=[]
self.battle["battleField"]["mapAreas"]=[{"type":"block"}]
self.assertIn("unknown_battle_area",self.codes(self.validate()))
def test_missing_assets_and_malformed_arrays_refuse(self):
self.members.remove(self.member("data/img/monster/q/1001010_q_2.png"))
self.assertIn("original_asset_missing",self.codes(self.validate()))
self.battle["teams"]={}
self.assertIn("invalid_battle_array",self.codes(self.validate()))
def test_missing_history_duplicate_slots_and_partial_attributes_refuse(self):
request=deepcopy(self.request);del request["roster"]["history"]["passTask"]
self.assertIn("incomplete_battle_history",self.codes(self.validate(request)))
request=deepcopy(self.request);request["roster"]["teams"][0]["monsters"]=[1000001,1000001]
self.assertIn("duplicate_selected_monster",self.codes(self.validate(request)))
request=deepcopy(self.request);request["roster"]["monsterAttributes"]=[{"monsterId":1000001,"atk":0}]
self.assertIn("incomplete_monster_additions",self.codes(self.validate(request)))
def test_skin_uses_visual_table_and_original_species_skills(self):
self.tables["skin_info"]["1001011"]={"monType":"1001010"}
self.tables["monster_info"]["1001011"]={"imgFix":{"2":{}},"skill_1":9999}
self.members.add(self.member("data/img/monster/q/1001011_q_2.png"))
self.snapshot["monsters"][0]["skin"]=1001011
result=self.validate()
self.assertEqual(result["reasons"],[])
self.assertEqual(result["coverage"]["skill_ids"],[3])
def test_equipment_requires_original_params_and_its_visible_asset(self):
self.snapshot["monsters"][0]["equip1"]=2000001
self.snapshot["items"]=[{"id":2000001,"typeId":50001,"num":1,"isUsed":1,
"itemClass":3,"equipParams":json.dumps(dict.fromkeys(ADD_FIELDS,0))}]
self.tables["item_info"]["50001"]={"position":{"position":1,"img":True}}
self.assertIn("original_asset_missing",self.codes(self.validate()))
self.members.add(self.member("data/img/item/item_50001_o.png"))
self.assertEqual(self.validate()["reasons"],[])
self.snapshot["items"][0]["equipParams"]='{}'
self.assertIn("incomplete_equipment",self.codes(self.validate()))
def test_public_dataclass_retains_canonical_raw_roster_fields(self):
request=BattleRequest(**self.request)
self.assertEqual(asdict(request)["team"],"teamB")
self.assertEqual(asdict(request)["battle_position"],self.request["battle_position"])
def test_public_inspector_routes_engine_raw_roster_to_snapshot_validation(self):
with patch("tools.battle_runtime.inputs.original_source",return_value=(self.tables,self.members)), \
patch("tools.battle_runtime.trusted.verify_files",return_value=[]), \
patch("ranch_assistant.battle_runtime.os",SimpleNamespace(name="nt")):
result=BattleRuntime().inspect(self.request)
self.assertTrue(result["supported"],result["reasons"])
self.assertEqual(result["native_position"],self.request["battle_position"])
self.assertEqual(result["watchdog_seconds"],690)
self.assertFalse(result["settlement_eligible"])
self.assertTrue(result["native_admission_validation_pending"])
self.assertTrue(result["faithful"])
self.assertFalse(result["server_acceptance_verified"])
class ArtifactIdentityTests(unittest.TestCase):
def swf(self, payloads):
raw = bytearray(b"FWS\x32\0\0\0\0\0\0\x1e\x01\0")
for code,payload in payloads:
raw.extend(encode_tag(code,payload))
raw.extend(encode_tag(0,b""));struct.pack_into("<I",raw,4,len(raw))
return bytes(raw)
def test_library_copy_cannot_invoke_original_document_and_preserves_abc(self):
abc = b"opaque original ABC byte identity fixture"
bindings = struct.pack("<H",2)+struct.pack("<H",0)+b"GameStartup\0"+struct.pack("<H",42)+b"BattleAnimation\0"
raw = self.swf([(76,bindings),(82,struct.pack("<I",0)+b"main\0"+abc)])
converted,identity = library_only(raw)
output = dict(tags(converted))
self.assertEqual(symbols(output[76]),[(42,b"BattleAnimation")])
self.assertEqual(output[82][output[82].index(0,4)+1:],abc)
self.assertEqual(struct.unpack_from("<I",output[82])[0],1)
self.assertEqual(identity["removed_document_classes"],["GameStartup"])
self.assertEqual(identity["abc_sha256"],[hashlib.sha256(abc).hexdigest()])
def test_compressed_swf_has_same_library_code(self):
raw = self.swf([(82,struct.pack("<I",1)+b"main\0abc")])
compressed = b"CWS"+raw[3:8]+zlib.compress(raw[8:])
self.assertEqual(library_only(raw)[0],library_only(compressed)[0])
def test_executable_or_import_tags_and_truncation_refuse(self):
for tag in (12,59,72,57,71):
with self.subTest(tag=tag),self.assertRaises(ValueError):
library_only(self.swf([(tag,b"not allowed")]))
with self.assertRaises(ValueError):library_only(self.swf([])[:-1])
def test_digest_validation_ignores_a_local_manifest_claiming_verification(self):
with workspace_temp() as directory:
root=Path(directory); (root/"runner.exe").write_bytes(b"replaced code")
(root/"identity.json").write_text(json.dumps({"verified":True,"files":{"runner.exe":hashlib.sha256(b"replaced code").hexdigest()}}))
reasons=verify_files(root,{"runner.exe":hashlib.sha256(b"reviewed code").hexdigest()})
self.assertEqual(reasons,[{"code":"dependency_digest_mismatch","detail":"runner.exe"}])
def test_identical_preparation_does_not_replace_a_resource_open_by_another_job(self):
with workspace_temp() as directory:
path=Path(directory)/"resource";path.write_bytes(b"verified immutable bytes")
with patch.object(Path,"replace",side_effect=PermissionError("shared reader")) as replace_file:
write_atomic(path,b"verified immutable bytes")
replace_file.assert_not_called()
self.assertEqual(path.read_bytes(),b"verified immutable bytes")
def test_zip_index_ranges_decode_exact_original_stored_and_deflated_bytes(self):
with workspace_temp() as directory:
path=Path(directory)/"source.zip"
originals={"a"*32:b"packed original bytes"*50,"b"*32:bytes(range(256))}
with zipfile.ZipFile(path,"w") as archive:
for index,(key,data) in enumerate(originals.items()):
archive.writestr("assets/codes/"+key,data,compress_type=zipfile.ZIP_DEFLATED if index else zipfile.ZIP_STORED)
with zipfile.ZipFile(path) as archive:
entries=asset_index(path,archive)
with path.open("rb") as stream:
for key,entry in entries.items():
stream.seek(entry["offset"]);packed=stream.read(entry["compressed_size"])
data=zlib.decompress(packed,-15) if entry["method"]==8 else packed
self.assertEqual(data,originals[key])
self.assertEqual(len(data),entry["size"])
self.assertEqual(zlib.crc32(data),entry["crc32"])
def test_zip_index_refuses_mismatched_local_header_and_unsafe_keys(self):
with workspace_temp() as directory:
path=Path(directory)/"source.zip"
with zipfile.ZipFile(path,"w") as archive:archive.writestr("assets/codes/"+"a"*32,b"data")
with path.open("r+b") as stream:stream.seek(8);stream.write(struct.pack("<H",8))
with zipfile.ZipFile(path) as archive,self.assertRaisesRegex(ValueError,"metadata"):
asset_index(path,archive)
with zipfile.ZipFile(path,"w") as archive:archive.writestr("assets/codes/../../escape",b"data")
with zipfile.ZipFile(path) as archive,self.assertRaisesRegex(ValueError,"Unsupported"):
asset_index(path,archive)
class ProcessIsolationTests(unittest.TestCase):
def test_child_executes_in_its_own_directory_and_nonzero_exit_is_error(self):
with workspace_temp() as directory:
root=Path(directory)
result=run_isolated([sys.executable,"-I","-c","from pathlib import Path; print(Path.cwd().name)"],cwd=root,timeout=5)
self.assertEqual(result.status,"completed",result.stderr)
self.assertEqual(result.stdout.strip(),root.name)
result=run_isolated([sys.executable,"-I","-c","raise SystemExit(7)"],cwd=root,timeout=5)
self.assertEqual(result.status,"error")
self.assertEqual(result.returncode,7)
def test_wall_timeout_terminates_child_promptly(self):
with workspace_temp() as directory:
result=run_isolated([sys.executable,"-I","-c","import time; time.sleep(30)"],cwd=Path(directory),timeout=.2)
self.assertEqual(result.status,"timeout")
self.assertLess(result.duration_seconds,3)
def test_mid_run_cancellation_terminates_child(self):
event=threading.Event();timer=threading.Timer(.2,event.set);timer.start()
try:
with workspace_temp() as directory:
result=run_isolated([sys.executable,"-I","-c","import time; time.sleep(30)"],cwd=Path(directory),timeout=5,cancel_event=event)
finally:timer.cancel()
self.assertEqual(result.status,"cancelled")
self.assertLess(result.duration_seconds,3)
def test_pre_cancelled_run_does_not_spawn(self):
event=threading.Event();event.set()
with workspace_temp() as directory,patch("tools.battle_runtime.isolation.subprocess.Popen") as popen:
result=run_isolated([sys.executable,"-I","-c","pass"],cwd=Path(directory),timeout=5,cancel_event=event)
popen.assert_not_called();self.assertEqual(result.status,"cancelled")
@unittest.skipUnless(os.name=="nt","Windows Job Object process-tree check")
def test_timeout_kills_worker_descendant_not_only_parent(self):
import ctypes
from ctypes import wintypes
with workspace_temp() as directory:
root=Path(directory)
script="import subprocess,sys,time; from pathlib import Path; p=subprocess.Popen([sys.executable,'-I','-c','import time; time.sleep(30)']); Path('child.pid').write_text(str(p.pid)); time.sleep(30)"
result=run_isolated([sys.executable,"-I","-c",script],cwd=root,timeout=.6)
self.assertEqual(result.status,"timeout")
self.assertTrue((root/"child.pid").exists())
pid=int((root/"child.pid").read_text())
kernel=ctypes.WinDLL("kernel32",use_last_error=True)
kernel.OpenProcess.argtypes=[wintypes.DWORD,wintypes.BOOL,wintypes.DWORD];kernel.OpenProcess.restype=wintypes.HANDLE
kernel.GetExitCodeProcess.argtypes=[wintypes.HANDLE,ctypes.POINTER(wintypes.DWORD)];kernel.CloseHandle.argtypes=[wintypes.HANDLE]
handle=kernel.OpenProcess(0x1000,False,pid)
if handle:
try:
code=wintypes.DWORD();kernel.GetExitCodeProcess(handle,ctypes.byref(code));self.assertNotEqual(code.value,259)
finally:kernel.CloseHandle(handle)
if __name__=="__main__":unittest.main()
@@ -0,0 +1,503 @@
"""Offline tests use synthetic ids/snapshots and public original static tables."""
from copy import deepcopy
import hashlib
import json
from pathlib import Path
import socket
import subprocess
import sys
import threading
from types import SimpleNamespace
import unittest
from unittest.mock import patch
from ranch_assistant.battle_simulator import (
ExperimentalBattleRuntime, ORIGINAL_APK_SHA256, Stats, _offline_audit,
combat_battles, combat_tables, damage_roll, simulate,
)
def monster(mid=101, species=1001010, level=20, **changes):
row = combat_tables()["monster_info"][str(species)]
result = {"id": mid, "typeId": species, "level": level, "mode": 2,
"tpLevel": 0, "feel": 0, "upStar": 0, "pAtk": 0,
"pDef": 0, "pHp": 0, "pDex": 0}
for name in ("Atk", "Def", "Hp", "Dex"):
stat = name.lower()
result["g" + name] = (row[stat + "_grow_min"] + row[stat + "_grow_max"]) / 2
result.update(changes)
return result
def enemy(**changes):
result = {"type": "1001010", "team": 2, "mode": 2, "level": 1,
"atk": 16, "def": 20, "hp": 101, "dex": 4, "spd_mov": .92,
"spd_atk": 1595, "atk_dis": 100, "skill_1": 0, "skill_2": 0,
"joinTime": -1, "wave": 1, "teamPos": 1, "ai": 0,
"joinPoint": "point_team2_fore2", "controller": []}
result.update(changes)
return result
def request(*, players=None, enemies=None, seconds=30, seed=0, master_level=43, **changes):
players = players if players is not None else [monster()]
result = {"context": "ordinary_stage", "seed": seed, "team": "teamA",
"battle_position": {"battleType": "stage", "stageId": "fixture", "stageLevel": "1"},
"roster": {"master": {"level": master_level}, "monsters": players,
"teams": [{"teamName": "teamA", "monsters": [m["id"] for m in players]}],
"monsterAttributes": []},
"original_data": {"battle": {"time": seconds, "winType": ["1"], "loseType": ["1", "2"],
"controller": [], "triggers": [], "teams": [{"team": 2, "numMax": 2, "ap": 80,
"mons": enemies if enemies is not None else [enemy()]}],
"battleField": {"fieldMode": True, "fieldName": "default", "mapAreas": [], "mapObjects": []}}}}
result.update(changes)
return result
def battle_of(value):
return value["original_data"]["battle"]
class Midpoint:
def uniform(self, low, high):
return (low + high) / 2
class CombatDataTests(unittest.TestCase):
def test_complete_original_data_is_cached_and_recursively_immutable(self):
data = combat_tables()
self.assertIs(data, combat_tables())
self.assertEqual(len(data["monster_info"]), 749)
self.assertEqual(len(data["monster_skill"]), 266)
self.assertEqual(len(combat_battles()["stage_info"]), 1178)
self.assertEqual(len(combat_battles()["task_info"]), 1165)
self.assertNotIn("stage_info", data) # Never decode the corpus in a battle worker.
with self.assertRaises(TypeError):
data["monster_info"]["1001010"]["atk"] = 999
self.assertEqual(data["game_setting"]["countDamagePerAtk"], .95)
self.assertEqual(data["game_setting"]["critAdd"], 1.5)
self.assertEqual(data["monster_skill"]["3"]["lv1"]["para"]["ability"], .4)
self.assertEqual(data["attack_profiles"]["43"]["source_class"], "AttackType2")
def test_manifest_identity_and_artifact_match(self):
root = Path(__file__).resolve().parents[1] / "data"
manifest = json.loads((root / "combat_manifest.json").read_text(encoding="utf-8"))
self.assertEqual(manifest["source"]["apk_sha256"], ORIGINAL_APK_SHA256)
for name, artifact in manifest["artifacts"].items():
self.assertEqual(hashlib.sha256((root / name).read_bytes()).hexdigest(), artifact["sha256"])
def test_damage_formula_uses_original_numbers_and_no_extra_multiplier(self):
defender = Stats(100, 100, 20, 10, 1600, .9, 100, 5)
# round(100*.95 - 20*(.25*.75 + .25*.125)) = 91.
self.assertEqual(damage_roll(100, 10, defender, combat_tables()["game_setting"], Midpoint()), 91)
self.assertEqual(damage_roll(1, 10, defender, combat_tables()["game_setting"], Midpoint()), 1)
class SimulatorTests(unittest.TestCase):
def test_snapshot_sanity_records_are_preserved_and_never_repaired(self):
mon = monster(mid=100001, pAtk=200000, feel=201, potentialLevel=1)
req = request(players=[mon])
inspected = ExperimentalBattleRuntime().inspect(req)
codes = {a["code"] for a in inspected["anomalies"]}
self.assertTrue({"+15overfeel", "+15overgrow", "+15overpoten", "+50overlv"}.issubset(codes))
result = simulate(req)
for record in inspected["anomalies"]:
self.assertIn(record, result["anomalies"])
self.assertGreater(result["units"][0]["stats"]["atk"], 200000)
self.assertEqual(mon["feel"], 201)
self.assertFalse(result["experimental_settlement_eligible"])
def test_authored_hidden_team_uses_only_original_configured_combatants(self):
req = request(enemies=[enemy(hp=10), enemy(team=1, atk=10000)])
battle_of(req)["hideTeamMon"] = True
result = simulate(req)
self.assertEqual(result["outcome"], "win")
self.assertTrue(all(not a["id"].startswith("player-") for a in result["units"]))
self.assertTrue(any(a["team"] == 1 for a in result["units"]))
self.assertEqual(result["battle_data"]["battleMonIds"], [])
def test_three_routes_preserve_position_and_ordered_roster_ids_including_waiting(self):
routes = {
"ordinary_stage": {"battleType": "stage", "stageId": "fixture-stage", "stageLevel": "2", "taskTypeId": None, "taskStep": 0},
"task_battle": {"battleType": "task", "stageId": None, "stageLevel": None, "taskTypeId": "fixture-task", "taskStep": 1},
"task_pass_stage": {"battleType": "task", "stageId": None, "stageLevel": None, "taskTypeId": "fixture-pass", "taskStep": 2},
}
expected_ids = [202, 105, 301, 101, 111]
for context, position in routes.items():
req = request(context=context, battle_position=position, seconds=1,
players=[monster(mid) for mid in expected_ids])
req["roster"]["monsters"].reverse() # Team order wins over inventory order.
result = simulate(req)
self.assertEqual(result["battle_data"]["battleMonIds"], expected_ids)
self.assertEqual(result["battle_data"]["battlePosition"],
{k: v for k, v in position.items() if v is not None})
self.assertEqual(sum(a["state"] == "waiting" and a["team"] == 1 for a in result["units"]), 1)
self.assertNotIn(1001010, result["battle_data"]["battleMonIds"])
def test_source_boss_points_are_updated_by_actual_damage_and_deaths(self):
for marker, expected in ((-1, 10), (7, 7)):
result = simulate(request(enemies=[enemy(hp=10, bossPoint=marker)]))
self.assertEqual(result["battle_data"]["bossDamage"], expected)
self.assertEqual(result["battle_data"]["totalDamage"], 0)
def test_cancellation_during_simulation_retains_partial_trace(self):
class CancelAfterTicks:
calls = 0
def is_set(self):
self.calls += 1
return self.calls > 10
result = simulate(request(), cancel_event=CancelAfterTicks())
self.assertEqual(result["outcome"], "cancelled")
self.assertGreater(result["elapsed_ms"], 0)
self.assertTrue(result["events"])
self.assertIsNone(result["battle_data"])
def test_model_failure_keeps_detected_records(self):
req = request(players=[monster(mid=100001, feel=201)])
with patch("ranch_assistant.battle_simulator._Battle.tick", side_effect=RuntimeError("fixture")):
result = simulate(req)
self.assertEqual(result["execution_status"], "error")
self.assertTrue(result["anomalies"])
self.assertIsNone(result["battle_data"])
def test_known_copy_skills_use_original_factors_and_summons_count_alive(self):
for species, skill_id, count, factor in ((1001010, 3, 1, .4), (1030010, 7, 3, .1)):
req = request(players=[monster(species=species, pHp=100000)],
enemies=[enemy(hp=1000000), enemy(hp=1000000)], seconds=20)
result = simulate(req)
summons = [u for u in result["units"] if u["summon_of"]]
self.assertEqual(len(summons), count)
parent = result["units"][0]
self.assertEqual(result["battle_data"]["aliveNum"], count + 1)
self.assertEqual(result["battle_data"]["battleMonIds"], [101])
for child in summons:
self.assertFalse(child["count_unit"])
self.assertFalse(child["skills"])
self.assertEqual(child["stats"]["atk"], int(parent["stats"]["atk"] * factor))
self.assertEqual(child["stats"]["defense"], int(parent["stats"]["defense"] * factor))
self.assertTrue(any(e["type"] == "skill" and e["skill"] == skill_id for e in result["events"]))
ap = result["ap"]["1"]
self.assertEqual(ap["current"], ap["initial"] - ap["spent"] + ap["recovered"])
self.assertEqual(ap["spent"], 18 if skill_id == 3 else 20)
def test_area_hit_cleave_uses_original_skill9_and_spatial_neighbors(self):
req = request(players=[monster(species=2004010, pHp=100000)],
enemies=[enemy(hp=1000000), enemy(hp=1000000)], seconds=20)
result = simulate(req)
area = [e for e in result["events"] if e.get("reason") == "skill9_area"]
self.assertTrue(area)
self.assertTrue(all(e["hp_lost"] > 0 for e in area))
stats = result["units"][0]["skills"][0]
self.assertEqual(stats["id"], 9)
self.assertEqual(stats["para"], {"areahurt": 1, "pow": 5})
def test_flash_move_and_four_hit_combo_are_executed(self):
req = request(players=[monster(species=3010010, pHp=100000)],
enemies=[enemy(hp=1000000), enemy(hp=1000000)], seconds=30)
battle_of(req)["battleField"]["fieldName"] = "longMapDefault"
result = simulate(req)
used = {e["skill"] for e in result["events"] if e["type"] == "skill"}
self.assertTrue({5, 38}.issubset(used))
self.assertTrue(any(e["type"] == "dash" for e in result["events"]))
casts = [e["at_ms"] for e in result["events"] if e["type"] == "skill" and e["skill"] == 38]
attacks = [e for e in result["events"] if e["type"] == "attack" and e["actor"] == "player-1"]
for start in casts:
burst = [e for e in attacks if start <= e["at_ms"] < start + 1600]
self.assertGreaterEqual(len(burst), 4)
self.assertEqual(burst[0]["hit_delay_ms"], 100)
def test_projectile_speed_and_launch_delay_produce_nonzero_travel(self):
result = simulate(request(players=[monster(species=1001020)], enemies=[enemy(hp=1000000)], seconds=8))
projectiles = [e for e in result["events"] if e["type"] == "projectile" and e["actor"] == "player-1"]
self.assertTrue(projectiles)
self.assertGreater(projectiles[0]["travel_ms"], 0)
attack = next(e for e in result["events"] if e["type"] == "attack" and e["actor"] == "player-1")
self.assertEqual(attack["hit_delay_ms"], 100)
self.assertGreaterEqual(projectiles[0]["at_ms"], attack["at_ms"] + 100)
def test_status_effects_healing_and_thorns_are_real_trajectory_events(self):
for attributes, event_type, reason in (({"atkStun": 100}, "stun", None),
({"atkPoi": 100, "atkPoiDmg": 15}, "damage", "poison"),
({"thorns": 100}, "damage", "thorns"),
({"atkVim": 50, "selfCure": 10}, "heal", None)):
req = request(players=[monster(level=1, pHp=10000)], enemies=[enemy(hp=1000000)], seconds=20)
req["roster"]["monsterAttributes"] = [dict(monsterId=101, **attributes)]
result = simulate(req)
self.assertTrue(any(e["type"] == event_type and (reason is None or e.get("reason") == reason)
for e in result["events"]), attributes)
if "atkVim" in attributes:
self.assertGreater(result["units"][0]["healed"], 0)
self.assertTrue(any(e.get("reason") == "selfCure" for e in result["events"]))
def test_overcure_preserves_exact_source_score_even_when_effective_heal_is_small(self):
req = request(seconds=6, trace_limit=0, enemies=[enemy(hp=1000000)])
req["roster"]["monsterAttributes"] = [{"monsterId": 101, "selfCure": 20001}]
result = simulate(req)
self.assertTrue(any(a["code"] == "+15overcure" and a["source_cheat_points"] == 19
for a in result["anomalies"]))
self.assertEqual(result["battle_data"]["cheatNum"], 19)
self.assertFalse(result["experimental_settlement_eligible"])
def test_experimental_eligibility_is_separate_and_requires_completed_clean_model(self):
report = ExperimentalBattleRuntime().inspect(request())
self.assertFalse(report["experimental_settlement_eligible"])
result = simulate(request())
self.assertTrue(result["experimental_settlement_eligible"])
self.assertFalse(result["settlement_eligible"])
self.assertFalse(result["faithful"])
anomaly = simulate(request(players=[monster(pAtk=200000)]))
self.assertFalse(anomaly["experimental_settlement_eligible"])
self.assertTrue(anomaly["experimental_eligibility_reasons"])
def test_original_stage_battle_executes_without_apk_or_network_reads(self):
req = request()
req["original_data"]["battle"] = combat_battles()["stage_info"]["0101"]["level"]["1"]["battle"]
with patch("socket.socket", side_effect=AssertionError("No network")), \
patch("zipfile.ZipFile", side_effect=AssertionError("No APK access")):
result = simulate(req)
self.assertEqual(result["outcome"], "win")
self.assertGreater(result["kills"], 1)
self.assertEqual(result["kill_monster"], {}) # Original stage enemies are mode 1.
self.assertTrue(any(e["type"] == "wave" for e in result["events"]))
def test_full_snapshot_stats_follow_monster_vo_including_server_attributes(self):
mon = monster(level=10, gAtk=3.125, gDef=2.5, gHp=30.25, gDex=1.25,
tpLevel=2, pAtk=12, pDef=8, pHp=80, pDex=3, feel=120, upStar=1)
req = request(players=[mon])
req["roster"]["master"].update(globalAtk=7, globalDef=4, globalHp=55, globalDex=2)
req["roster"]["monsterAttributes"] = [{"monsterId": 101, "atk": 13, "def": 9,
"hp": 45, "dex": 2, "atkSpd": 5, "crit": 4, "apCostSave": 1}]
inspected = ExperimentalBattleRuntime().inspect(req)
self.assertTrue(inspected["supported"], inspected["reasons"])
stats = inspected["units"][0]["stats"]
original = combat_tables()["monster_info"]["1001010"]
for stat, suffix in (("hp", "Hp"), ("atk", "Atk"), ("def", "Def"), ("dex", "Dex")):
expected = int(1.21 * (original[stat] + mon["g" + suffix] * 11 + mon["p" + suffix]
+ req["roster"]["master"]["global" + suffix]
+ req["roster"]["monsterAttributes"][0][stat]))
self.assertEqual(stats["defense" if stat == "def" else stat], expected)
self.assertEqual(stats["attack_ms"], 1600 + int(-stats["dex"] * 3 / 4) - 80)
self.assertEqual(stats["crit"], 4)
self.assertEqual(inspected["units"][0]["ap_cost"], 0)
def test_inspect_is_honest_and_does_not_mutate_inputs(self):
req = request()
before = deepcopy(req)
result = ExperimentalBattleRuntime().inspect(req)
self.assertTrue(result["supported"])
self.assertEqual(result["execution_mode"], "experimental")
self.assertTrue(result["approximate"])
self.assertFalse(result["faithful"])
self.assertFalse(result["settlement_eligible"])
self.assertTrue(result["requires_realtime_wait"])
self.assertTrue(result["ignored_mechanics"])
self.assertEqual(req, before)
def test_all_three_contexts_execute_deterministic_natural_win(self):
first = None
for context in ("ordinary_stage", "task_battle", "task_pass_stage"):
result = simulate(request(context=context))
self.assertEqual(result["outcome"], "win")
self.assertTrue(result["terminal"])
self.assertEqual(result["execution_status"], "completed")
self.assertEqual(result["kills"], 1)
self.assertEqual(result["battle_data"]["win"], True)
if first:
self.assertEqual(result["events"], first["events"])
first = result
def test_natural_defeat_retains_actual_state_and_evidence(self):
result = simulate(request(players=[monster(level=1)], enemies=[enemy(atk=10000, hp=10000)]))
self.assertEqual(result["outcome"], "loss")
self.assertEqual(result["terminal_reason"], "elimination")
self.assertFalse(result["battle_data"]["win"])
self.assertEqual(result["alive_num"], 0)
self.assertEqual(result["units"][0]["hp"], 0)
self.assertTrue(any(e["type"] == "death" for e in result["events"]))
def test_battle_clock_expiry_is_completed_loss_not_technical_timeout(self):
req = request(seconds=1, enemies=[enemy(hp=100000, moveImmune=True, atk_dis=1)])
result = simulate(req)
self.assertEqual(result["outcome"], "loss")
self.assertEqual(result["execution_status"], "completed")
self.assertEqual(result["terminal_reason"], "battle_time_limit")
self.assertEqual(result["elapsed_ms"], 1000)
self.assertEqual(result["battle_data"]["leftTime"], 0)
self.assertFalse(result["battle_data"]["win"])
self.assertGreater(result["units"][0]["hp"], 0)
def test_technical_timeout_and_cancellation_have_no_battle_data(self):
event = threading.Event()
event.set()
for result in (simulate(request(), timeout=0), simulate(request(), cancel_event=event)):
self.assertIn(result["execution_status"], ("timed_out", "cancelled"))
self.assertFalse(result["terminal"])
self.assertIsNone(result["battle_data"])
def test_source_selective_kill_map_differs_from_all_kills(self):
req = request(enemies=[enemy(hp=1, mode=1), enemy(hp=1, mode=2)])
result = simulate(req)
self.assertEqual(result["outcome"], "win")
self.assertEqual(result["kills"], 2)
self.assertEqual(result["all_kills"], {"1001010": 2})
self.assertEqual(result["battle_data"]["killMonster"], {"1001010": 1})
self.assertEqual(result["battle_data"]["totalDamage"], 0)
self.assertEqual(result["battle_data"]["killNum"], 0)
self.assertEqual(result["battle_data"]["deadNum"], 0)
self.assertGreater(result["damage_hp_lost"]["2"], 0)
def test_waiting_roster_counts_alive_and_respects_source_capacity(self):
players = [monster(i, level=1) for i in (101, 102, 103, 104, 105)]
result = simulate(request(players=players, seconds=1, master_level=18))
player_units = [a for a in result["units"] if a["team"] == 1]
self.assertEqual(sum(a["state"] == "active" for a in player_units), 4)
self.assertEqual(sum(a["state"] == "waiting" for a in player_units), 1)
self.assertEqual(result["battle_data"]["aliveNum"], 5)
self.assertTrue(all(e["ap_charged"] == 0 for e in result["events"] if e["type"] == "deploy"))
def test_order_reinforcements_and_wave_delay(self):
req = request(enemies=[enemy(hp=1), enemy(hp=1, wave=2, joinTime=4)])
result = simulate(req)
self.assertEqual(result["outcome"], "win")
wave_wait = next(e for e in result["events"] if e["type"] == "wave_wait")
wave = next(e for e in result["events"] if e["type"] == "wave")
self.assertEqual(wave["at_ms"] - wave_wait["at_ms"], 700)
second = next(e for e in result["events"] if e["type"] == "deploy" and e.get("wave") == 2)
self.assertGreaterEqual(second["at_ms"], 4000)
def test_unimplemented_skills_are_specific_and_explicit(self):
req = request(players=[monster(species=1001020)]) # actual skill 10
report = ExperimentalBattleRuntime().inspect(req)
self.assertTrue(report["supported"])
self.assertTrue(any(d["code"] == "unsupported_skill" and "10" in d["message"] for d in report["diagnostics"]))
self.assertTrue(any("Skill 10" in x for x in report["ignored_mechanics"]))
def test_controllers_triggers_and_non_elimination_are_rejected(self):
for key, value in (("controller", [{"type": "monMaker"}]),
("triggers", [{"type": "dead"}]), ("winType", ["2"])):
req = request()
battle_of(req)[key] = value
result = simulate(req)
self.assertEqual(result["outcome"], "unsupported")
self.assertFalse(result["supported"])
self.assertIsNone(result["battle_data"])
self.assertTrue(result["reasons"])
def test_missing_actual_growth_and_nonpositive_original_speed_are_rejected(self):
req = request()
req["roster"]["monsters"][0].pop("gAtk")
self.assertFalse(ExperimentalBattleRuntime().inspect(req)["supported"])
req = request()
req["roster"]["monsterAttributes"] = [{"monsterId": 101, "atkSpd": 200}]
report = ExperimentalBattleRuntime().inspect(req)
self.assertFalse(report["supported"])
self.assertTrue(any("nonpositive" in x for x in report["reasons"]))
def test_enemy_authored_stats_and_authored_scales_are_preserved(self):
req = request(enemies=[enemy(atk=31, hp=101, dex=7, spd_atk=1595)])
battle_of(req).update(scaleAbility=1.2, scaleHp=1.5)
stats = ExperimentalBattleRuntime().inspect(req)["units"][1]["stats"]
self.assertEqual(stats["atk"], 37)
self.assertEqual(stats["hp"], 151)
self.assertEqual(stats["dex"], 8)
self.assertEqual(stats["attack_ms"], 1595)
def test_trace_limit_never_erases_overdamage_anomalies(self):
req = request(players=[monster(pAtk=200000)], enemies=[enemy(hp=10)], trace_limit=1)
result = simulate(req)
self.assertEqual(result["outcome"], "win")
self.assertEqual(len(result["events"]), 1)
self.assertTrue(result["trace_truncated"])
records = [a for a in result["anomalies"] if a["code"] == "+10overdamage"]
self.assertTrue(records)
self.assertGreater(records[0]["damage"], 80000)
self.assertEqual(result["battle_data"]["cheatNum"], 10)
self.assertEqual(result["battle_data"]["cheatRecords"], result["anomalies"])
def test_stats_and_snapshot_never_mutate_across_runs(self):
req = request()
before = deepcopy(req)
a, b = simulate(req), simulate(req)
self.assertEqual(a, b)
self.assertEqual(req, before)
class WorkerTests(unittest.TestCase):
def test_object_request_and_snapshot_raw_have_the_same_contract(self):
req = request()
req["snapshot"] = SimpleNamespace(raw=req.pop("roster"))
result = ExperimentalBattleRuntime().run(SimpleNamespace(**req))
self.assertEqual(result["outcome"], "win")
self.assertEqual(result["battle_data"]["battlePosition"], req["battle_position"])
def test_fixed_module_subprocess_equals_direct_model(self):
req = request()
with patch("socket.socket", side_effect=AssertionError("No network")):
result = ExperimentalBattleRuntime().run(req)
self.assertEqual(result, simulate(req))
def test_worker_entrypoint_does_not_import_gui_or_production_engine(self):
completed = subprocess.run([sys.executable, "-c",
"import sys; import ranch_assistant.battle_simulator; "
"assert not any(n in sys.modules for n in "
"('ranch_assistant.gui','ranch_assistant.engine','ranch_assistant.__main__',"
"'ranch_assistant.battles','ranch_assistant.battle_runtime'))"], capture_output=True)
self.assertEqual(completed.returncode, 0, completed.stderr)
def test_worker_network_guard_rejects_socket_audit_events(self):
for event in ("socket.__new__", "socket.connect", "socket.getaddrinfo", "urllib.Request"):
with self.assertRaises(PermissionError):
_offline_audit(event, ())
program = """import socket,sys
from ranch_assistant.battle_simulator import _offline_audit
sys.addaudithook(_offline_audit)
try:
socket.socket()
except PermissionError:
pass
else:
raise AssertionError('worker socket creation must fail')
"""
completed = subprocess.run([sys.executable, "-c", program], capture_output=True)
self.assertEqual(completed.returncode, 0, completed.stderr)
def test_cancel_and_wall_timeout_kill_and_reap_worker(self):
for cancelled in (True, False):
event = threading.Event()
processes = []
real_popen = subprocess.Popen
def observe(*args, **kwargs):
self.assertEqual(args[0], [sys.executable, "-m", "ranch_assistant.battle_simulator", "--worker"])
self.assertNotIn("shell", kwargs)
self.assertEqual(kwargs["creationflags"], getattr(subprocess, "CREATE_NO_WINDOW", 0))
process = real_popen(*args, **kwargs)
processes.append(process)
if cancelled:
event.set()
return process
with patch("ranch_assistant.battle_simulator.subprocess.Popen", side_effect=observe):
result = ExperimentalBattleRuntime().run(request(), cancel_event=event,
timeout=10 if cancelled else .001)
self.assertEqual(result["outcome"], "cancelled" if cancelled else "timeout")
self.assertFalse(result["terminal"])
self.assertIsNone(result["battle_data"])
self.assertTrue(processes)
self.assertIsNotNone(processes[0].poll())
def test_keyboard_interrupt_terminates_child(self):
process = unittest.mock.MagicMock()
process.communicate.side_effect = [KeyboardInterrupt, (b"", b"")]
process.poll.return_value = None
with patch("ranch_assistant.battle_simulator.subprocess.Popen", return_value=process):
result = ExperimentalBattleRuntime().run(request())
self.assertEqual(result["outcome"], "cancelled")
process.kill.assert_called_once()
self.assertIsNone(result["battle_data"])
if __name__ == "__main__":
unittest.main()
+5
View File
@@ -199,6 +199,11 @@ class GrowthGuiTests(unittest.TestCase):
window.engine.snapshot = client.snapshot()
window.render(window.engine.snapshot, window.engine.plans())
window.tabs.setCurrentWidget(window.monster_page)
for _ in range(200):
self.app.processEvents()
QTest.qWait(5)
if not window.busy and 501 in window.monsters.monster_items:
break
row = next(i for i in range(window.slots.rowCount()) if window.slots.item(i, 1).text() == "1")
self.assertIn("待同步", window.slots.item(row, 5).text())
self.assertIn("待成熟", window.slots.item(row, 7).text())
@@ -0,0 +1,260 @@
"""Native AIR integration tests; fixtures contain no account data or networking.
The tests compile the actual bridge once, then run all cases in a child
ApplicationDomain with the pinned original SWFs. Missing local AIR assets skip
the suite; compilation/runtime failures with installed assets fail the suite.
"""
import copy
import unittest
from tools.battle_runtime.snapshot_bridge_check import (
dependencies_available, run_checks, synthetic_snapshot,
)
@unittest.skipUnless(dependencies_available(), "Prepared local Windows AIR SDK/original libraries required")
class NativeSnapshotBridgeTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
plain, rich = synthetic_snapshot(), synthetic_snapshot(rich=True)
cases = []
def case(name, source=plain, *, team="teamA", integrity=False):
snapshot = copy.deepcopy(source)
cases.append(dict(name=name, snapshot=snapshot, teamName=team, integrity=integrity))
return snapshot
case("plain", integrity=True)
case("rich", rich, integrity=True)
case("empty_attributes", integrity=True)["monsterAttributes"] = []
flat_skin = case("flat_skin_entry", rich, integrity=True)
flat_skin["items"] = []
flat_skin["monsters"][0].update(equip2=0, pAtk=0, pDef=0, pHp=0, pDex=0)
# Keep explicit server attributes independent of skin table abilities.
# The bridge must use the supplied values once, not recalculate them.
flat_skin["monsterAttributes"][0] = copy.deepcopy(plain["monsterAttributes"][0])
flat_skin["monsterAttributes"][1]["def"] = 7
case("shuffled_attributes", rich)["monsterAttributes"].reverse()
case("low_master_level")["master"]["level"] = 1
case("high_master_level")["master"]["level"] = 80
case("original_tp_clamp")["monsters"][0]["tpLevel"] = 9
case("original_skills")["monsters"][0].update(skill_1=999999, atk=999999, hp=999999)
alternate = case("alternate_team", team="teamB")
alternate["teams"].append(dict(teamName="teamB", teamType="pveBattleTeam",
monsters=[0, 100000002, 100000003, 100000001, 0, 0, 0]))
case("empty_padding")["teams"][0]["monsters"].append(0)
with_egg = case("unselected_incubator")
egg = copy.deepcopy(plain["monsters"][0])
egg.update(id=100000004, process=2, mode=0, level=0, potentialLevel=0)
with_egg["monsters"].append(egg)
case("bad_feel", integrity=True)["monsters"][0]["feel"] = 201
missing_global = case("missing_global")
del missing_global["master"]["globalAtk"]
missing_growth = case("missing_growth")
del missing_growth["monsters"][0]["gAtk"]
case("absent_attribute_row", integrity=True)["monsterAttributes"].pop(0)
missing_attribute_field = case("missing_attribute_field")
del missing_attribute_field["monsterAttributes"][0]["atk"]
missing_attributes = case("missing_attributes")
del missing_attributes["monsterAttributes"]
case("duplicate_attributes")["monsterAttributes"].append(copy.deepcopy(plain["monsterAttributes"][0]))
case("species_as_instance")["teams"][0]["monsters"][0] = 1001010
case("duplicate_member")["teams"][0]["monsters"][1] = 100000003
case("incubating_member")["monsters"][0]["process"] = 2
case("egg_member")["monsters"][0]["mode"] = 0
case("exploring_member")["monsters"][0]["inExploreTeam"] = 1
case("negative_member")["teams"][0]["monsters"][0] = -1
case("empty_team")["teams"][0]["monsters"] = [0] * 7
case("missing_team", team="absent")
case("occupied_padding")["teams"][0]["monsters"].append(100000002)
case("missing_equipment", rich)["items"] = []
missing_params = case("missing_equip_params", rich)
del missing_params["items"][0]["equipParams"]
case("bad_equip_params", rich)["items"][0]["equipParams"] = "{broken"
case("wrong_equipment_class", rich)["items"][0]["itemClass"] = 0
overflowing_equip = case("equipment_id_overflow", rich)
overflowing_equip["items"][0]["id"] = 2147483648
overflowing_equip["monsters"][0]["equip2"] = 2147483648
case("bad_entangle_json", rich)["monsters"][1]["entangleSkills"] = "null"
missing_history = case("missing_history")
del missing_history["history"]["monLib"]
case("string_stat")["monsters"][0]["gAtk"] = "4.9"
case("boolean_stat")["master"]["globalAtk"] = False
cls.evidence = run_checks(cases)
if not cls.evidence["result"].get("ok"):
raise AssertionError(cls.evidence["result"])
cls.results = {row["name"]: row for row in cls.evidence["result"]["cases"]}
def accepted(self, name):
result = self.results[name]
self.assertTrue(result["ok"], result.get("error"))
self.assertTrue(result["inputUnchanged"])
self.assertTrue(result["installed"])
self.assertTrue(result["contextUnchanged"])
return result
def rejected(self, name, code, path=None):
result = self.results[name]
self.assertFalse(result["ok"], name)
self.assertIn(f"SnapshotBridge[{code}]", result["error"], name)
if path:
self.assertIn(path, result["error"])
self.assertTrue(result["inputUnchanged"], name)
self.assertTrue(result["previousMasterRestored"], name)
def test_as3_compiles_and_runs_against_pinned_original_libraries(self):
self.assertEqual(self.evidence["compiler_exit_code"], 0)
self.assertEqual(self.evidence["process_exit_code"], 0)
self.assertEqual(len(self.evidence["source_sha256"]), 64)
def test_original_values_and_ordered_instance_ids_reach_native_team(self):
result = self.accepted("plain")
self.assertEqual(result["validation"]["selectedIds"], [100000003, 100000001, 100000002])
self.assertEqual(result["selectedSlots"], [100000003, 0, 100000001, 100000002, 0, 0, 0])
self.assertEqual(result["nativeMembers"], [dict(mid=100000003, teamPos=1),
dict(mid=100000001, teamPos=2),
dict(mid=100000002, teamPos=5)])
# Pinned original Lv1 slime values, independently of bridge mapping.
first = result["units"][0]
self.assertEqual(first["battle"], {"atk": 28, "def": 24, "hp": 335, "dex": 6})
self.assertEqual(first["skill_1"], 3)
def test_rich_snapshot_preserves_equipment_potential_skin_and_entangle(self):
result = self.accepted("rich")
first, second = result["units"][:2]
self.assertEqual(first["battle"], {"atk": 31, "def": 27, "hp": 393, "dex": 11})
self.assertEqual(first["potential"], 1)
self.assertEqual(first["equip2"], 100000101)
self.assertEqual(first["special"]["atkPoi"], 2)
self.assertEqual(first["special"]["atkPoiType"], 1)
self.assertEqual(second["skinVo"], 1003011)
self.assertEqual(second["entangleSkill"], {"1": 1001})
self.assertTrue(second["entangle"])
self.assertEqual(second["skill_1"], 6)
self.assertEqual(second["battle"], {"atk": 48, "def": 39, "hp": 209, "dex": 11})
self.assertEqual(result["inventory"], [dict(id=100000101, type=50001, num=1,
isUsed=True, atk=0, hp=50, atkPoiType=1)])
def test_attributes_join_by_instance_id_and_are_not_double_counted(self):
rich = self.accepted("rich")
reordered = self.accepted("shuffled_attributes")
self.assertEqual(rich["units"], reordered["units"])
# The two slime instances share a species, but only one has equipment.
self.assertEqual(rich["units"][0]["additions"]["hp"], 50)
self.assertEqual(rich["units"][2]["additions"]["hp"], 0)
def test_explicit_empty_and_absent_attribute_rows_preserve_original_defaults(self):
plain = self.accepted("plain")
for name, count in (("empty_attributes", 0), ("absent_attribute_row", 2)):
with self.subTest(name=name):
result = self.accepted(name)
self.assertEqual(result["validation"]["attributeCount"], count)
self.assertEqual(result["units"], plain["units"])
self.assertEqual(result["integrity"], plain["integrity"])
self.assertEqual(result["inventory"], [])
self.assertTrue(all(unit["skin"] == 0 for unit in result["units"]))
def test_flat_skin_table_resolves_original_entry_and_keeps_server_attributes(self):
result = self.accepted("flat_skin_entry")
skinned = result["units"][1]
self.assertEqual(skinned["skinVo"], 1003011)
self.assertEqual(skinned["skinEntry"], {"monType": "1003010",
"ability": {"def": 15, "atkVim": 2},
"sameOriginalEntry": True})
self.assertEqual(skinned["additions"]["def"], 7)
self.assertEqual(skinned["battle"]["def"], 31)
self.assertEqual(self.accepted("rich")["units"][1]["battle"]["def"], 39)
self.assertEqual(result["integrity"]["cheatNum"], 0)
self.assertEqual(len(result["integrity"]["records"]), 3)
def test_ap_and_tp_levels_use_original_source_semantics(self):
for name, level in (("low_master_level", 1), ("plain", 30), ("high_master_level", 80)):
with self.subTest(name=name):
result = self.accepted(name)
self.assertEqual(result["validation"]["masterLevel"], level)
self.assertEqual(result["nativeAP"], result["apFromRawLevel"])
self.assertEqual(result["validation"]["ap"], result["nativeAP"])
self.assertGreater(self.results["high_master_level"]["nativeAP"], self.results["plain"]["nativeAP"])
self.assertEqual(self.accepted("original_tp_clamp")["units"][0]["tplevel"], 4)
self.assertEqual(self.accepted("original_skills")["units"], self.accepted("plain")["units"])
def test_history_uses_original_flag_conversion_api(self):
history = self.accepted("rich")["history"]
self.assertEqual(history["guide_record"], {"firstOut": True})
self.assertEqual(history["unlockCity"], {"1": True})
self.assertEqual(history["passStage"], {"0101": {"1": True}})
self.assertEqual(history["unlockStage"], {"0101": {"1": True}})
self.assertEqual(history["monLib"], [1001010, 1003010])
self.assertEqual(self.results["rich"]["validation"]["historyLoader"], "HistoryVo.loadHistoryData")
def test_selected_team_and_original_loader_padding(self):
result = self.accepted("alternate_team")
self.assertEqual(result["validation"]["teamName"], "teamB")
self.assertEqual(result["validation"]["selectedIds"], [100000002, 100000003, 100000001])
padding = self.accepted("empty_padding")
self.assertEqual(padding["nativeMembers"], self.results["plain"]["nativeMembers"])
self.assertEqual(len(padding["validation"]["rawSlots"]), 8)
self.rejected("occupied_padding", "team_slot")
def test_unselected_incubation_does_not_change_selected_roster(self):
result = self.accepted("unselected_incubator")
self.assertEqual(result["loadedMonsterIds"], [100000001, 100000002, 100000003, 100000004])
self.assertEqual(result["validation"]["monsterCount"], 4)
self.assertEqual(result["validation"]["attributeCount"], 3)
self.assertEqual(result["units"], self.accepted("plain")["units"])
def test_real_integrity_checker_records_high_ids_and_detects_invalid_input(self):
for name in ("plain", "rich", "empty_attributes", "flat_skin_entry", "absent_attribute_row"):
integrity = self.accepted(name)["integrity"]
self.assertEqual(integrity["cheatNum"], 0)
ids = [int(record["mid"]) for record in integrity["records"]]
self.assertEqual(ids, [100000003, 100000001, 100000002])
self.assertTrue(all(mid > 100000000 for mid in ids))
self.assertIn("+0uneqmon100000001", integrity["text"])
self.assertIsNotNone(integrity["records"][0]["skillLevel1"])
invalid = self.accepted("bad_feel")
self.assertEqual(invalid["units"][0]["feel"], 201)
self.assertGreater(invalid["integrity"]["cheatNum"], 0)
self.assertIn("overfeel", invalid["integrity"]["text"])
self.assertEqual(len(invalid["integrity"]["records"]), 3)
self.assertIsNotNone(invalid["integrity"]["master"])
def test_missing_stats_fail_with_paths_without_zero_defaults(self):
for name, code, path in (
("missing_global", "missing_number", "master.globalAtk"),
("missing_growth", "missing_number", "monsters[0].gAtk"),
("missing_attribute_field", "missing_number", "monsterAttributes[0].atk"),
("missing_attributes", "missing_array", "monsterAttributes"),
("string_stat", "missing_number", "monsters[0].gAtk"),
("boolean_stat", "missing_number", "master.globalAtk"),
("missing_history", "missing_array", "history.monLib"),
):
with self.subTest(name=name):
self.rejected(name, code, path)
def test_selected_members_must_exist_and_be_available(self):
for name, code in (
("species_as_instance", "missing_team_member"), ("duplicate_member", "duplicate_member"),
("incubating_member", "incubating_member"), ("egg_member", "incubating_member"),
("exploring_member", "exploring_member"), ("negative_member", "team_member_id"),
("empty_team", "empty_team"), ("missing_team", "team_missing"),
("duplicate_attributes", "duplicate_attributes"),
):
with self.subTest(name=name):
self.rejected(name, code)
def test_incomplete_equipment_and_entangle_cannot_enter_original_error_fallbacks(self):
for name, code in (
("missing_equipment", "missing_equipment"), ("missing_equip_params", "json_string"),
("bad_equip_params", "json_string"), ("wrong_equipment_class", "equipment_class"),
("equipment_id_overflow", "equipment_id"),
("bad_entangle_json", "missing_object"),
):
with self.subTest(name=name):
self.rejected(name, code)
if __name__ == "__main__":
unittest.main()
+733
View File
@@ -0,0 +1,733 @@
"""Offline source-derived progression tests; no clients or game servers."""
from copy import deepcopy
from dataclasses import asdict, replace
import hashlib
import json
from pathlib import Path
import unittest
from unittest.mock import patch
import zipfile
from ranch_assistant.game_data import (
BATTLES_NAME, DATA_DIR, DATA_NAME, MANIFEST_NAME,
ORIGINAL_APK_SHA256, ProgressionData, ProgressionDataError, load_progression_data,
)
from ranch_assistant.model import Catalog, Policy, Snapshot
from ranch_assistant.progression import ProgressionPlanner, ProgressionPolicy
from ranch_assistant.quests import QuestPolicy
from tools.build_progression_data import farming_index, summarize_script
ROOT = Path(__file__).resolve().parents[2]
def step(kind="none", **changes):
return {"statusType": kind, "statusValue": {}, "story": "", "afterStory": "",
"position": "", "npc": "", "unlockStages": [], "condition": {}, **changes}
def task(type_id="100", *, steps=None, **changes):
return {"id": type_id, "name": "离线测试任务", "type": 1, "startStep": step(),
"steps": [step()] if steps is None else steps, "closed": False,
"nextTasks": [], "unlockTasks": [], "unlockStages": [], **changes}
def snapshot(**changes):
return Snapshot({"master": {"id": 1, "level": 20, "money": 2000, "ti": 50},
"items": [], "monsters": [], "stacks": [], "rooms": [], "teams": [],
"history": {"unlockCity": {"1": True}, "unlockStage": {"0101": [1, 2, 3]},
"passStage": {}, "passTask": {}, "unlockTask": {}, "openHardMode": True},
"currentTasks": [{"id": 11, "typeId": "100", "curStep": 1, "stepValue": None}],
**changes})
def config(tasks=None, **changes):
return {"task_info": tasks or {"100": task()}, "scripts": {
"linear": {"supported": True, "answer": None, "dialogue_lines": 5},
"accept": {"supported": True, "answer": True, "dialogue_lines": 3},
"choice": {"supported": False, "answer": None, "block_reasons": ["unsupported command: option"]}},
"game_setting": {"cityInfo": {"1": {"name": "莉莉托斯", "cid": "1"}}}, "setting": {},
"stage_info": {"0101": {"id": "0101", "name": "王城郊外 1-1", "city": 1, "cost": {"ti": 2},
"level": {str(i): {"cost": i, "battle_available": True} for i in (1, 2, 3)}}},
"npc_info": {"nina": {"name": "妮娜"}}, "stage_sp": {}, **changes}
class ProgressionTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.catalog = Catalog()
def setUp(self):
self.policy = ProgressionPolicy(enabled=True)
self.ranch = Policy(keep_money=1000)
self.snapshot = snapshot()
self.planner = ProgressionPlanner(self.catalog, config())
def plan(self):
return self.planner.plan(self.snapshot, self.policy, self.ranch)
def next(self, kind):
planned = self.plan()
self.assertTrue(planned)
self.assertEqual(planned[0].kind, kind, planned[0].description)
return planned[0]
def test_policy_defaults_roundtrip_and_validation(self):
policy = ProgressionPolicy()
self.assertFalse(policy.enabled)
self.assertEqual(ProgressionPolicy.from_dict(json.loads(json.dumps(asdict(policy)))), policy)
for changes in ({"enabled": "false"}, {"reserve_ti": -1}, {"stop_after_loss": 0},
{"max_money": float("nan")}, {"allow_items": 1}, {"team": ""},
{"team": "has\nnewline"}, {"team": " too much space "}, {"team": "x" * 65},
{"battle_mode": "faithful_estimate"},
{"item_reserves": {"20001": -2}}, {"item_reserves": {"token": 1}}):
with self.subTest(changes=changes), self.assertRaises(ValueError):
ProgressionPolicy(**changes)
with self.assertRaises(ValueError):
ProgressionPolicy.from_dict({"session": "must-not-import"})
self.assertEqual(ProgressionPolicy(team="自定义编队").team, "自定义编队")
self.assertEqual(ProgressionPolicy(team="bonusTeam4").battle_mode, "original")
self.assertEqual(ProgressionPolicy(battle_mode="experimental").to_dict()["battle_mode"], "experimental")
self.assertEqual(self.planner.plan(self.snapshot, ProgressionPolicy(), self.ranch), [])
def test_nonbattle_server_ack_then_local_complete_then_reward(self):
original = deepcopy(self.snapshot.raw)
action = self.next("progression_step")
self.assertEqual(action.path, "taskService/taskCompleteStep")
self.assertEqual(action.payload, {"taskId": 11, "taskTypeId": "100", "removeIds": None})
self.assertNotIn("battleData", action.payload)
self.planner.mark_started(self.snapshot, action)
self.assertTrue(self.plan()[0].block_reason)
self.planner.acknowledge(self.snapshot, action, {"taskStepValue": None})
self.assertFalse(self.planner.acknowledge(self.snapshot, action, {}))
local = self.next("progression_local_step")
self.assertEqual(local.path, "")
self.planner.acknowledge(self.snapshot, local)
reward = self.next("progression_complete")
self.assertEqual(reward.payload, {"taskId": 11, "taskTypeId": "100"})
self.planner.acknowledge(self.snapshot, reward, {"reward": {}})
self.assertEqual(self.plan(), [])
self.assertEqual(self.snapshot.raw, original)
def test_ordinary_dialogue_and_navigation_are_logical_and_do_not_submit_twice(self):
self.planner = ProgressionPlanner(self.catalog, config({"100": task(steps=[
step(story="linear", afterStory="linear", position="city1_market", npc="nina"), step()])}))
nav = self.next("progression_navigate")
self.assertEqual(nav.position, "city1_market")
self.assertEqual(nav.payload, {})
self.assertEqual(nav.npc_name, "妮娜")
self.assertIn("市场", nav.location)
self.planner.acknowledge(self.snapshot, nav)
before = self.next("progression_dialogue")
self.assertEqual(before.phase, "before")
self.planner.acknowledge(self.snapshot, before)
server = self.next("progression_step")
self.assertEqual(self.snapshot.raw["currentTasks"][0]["curStep"], 1)
self.planner.acknowledge(self.snapshot, server, {})
after = self.next("progression_dialogue")
self.assertEqual(after.phase, "after")
self.planner.acknowledge(self.snapshot, after)
self.planner.acknowledge(self.snapshot, self.next("progression_local_step"))
following = self.next("progression_step")
self.assertEqual(following.step_number, 2)
self.assertEqual(self.snapshot.raw["currentTasks"][0]["curStep"], 1)
def test_empty_before_story_does_not_skip_after_story(self):
self.planner = ProgressionPlanner(self.catalog, config({"100": task(steps=[step(afterStory="linear")])}))
self.planner.acknowledge(self.snapshot, self.next("progression_step"), {})
self.assertEqual(self.next("progression_dialogue").phase, "after")
def test_server_step_advance_does_not_skip_unfinished_acknowledged_after_story(self):
self.planner = ProgressionPlanner(self.catalog, config({"100": task(steps=[step(afterStory="linear"), step()])}))
self.planner.acknowledge(self.snapshot, self.next("progression_step"), {})
self.snapshot.raw["currentTasks"][0]["curStep"] = 2
self.assertEqual(self.next("progression_dialogue").step_number, 1)
def test_finished_received_unlocked_states_deduplicate(self):
self.snapshot.raw["history"]["unlockTask"] = {"100": True}
rows = self.planner.rows(self.snapshot, self.policy, self.ranch)
self.assertEqual(len(rows), 1)
self.assertEqual(rows[0]["state"], "received")
self.assertEqual(self.next("progression_step").task_id, 11)
self.snapshot.raw["history"]["passTask"] = {"100": True}
self.assertEqual(self.plan(), [])
self.assertEqual(self.planner.rows(self.snapshot, self.policy, self.ranch)[0]["state"], "finished")
def test_task_history_id_lists_are_supported_alongside_flag_mappings(self):
self.snapshot.raw["currentTasks"] = []
self.snapshot.raw["history"]["unlockTask"] = [100]
self.next("progression_accept")
self.snapshot.raw["history"]["passTask"] = [100]
self.assertEqual(self.plan(), [])
def test_accept_uses_verified_payload_and_success_instance(self):
self.snapshot.raw["currentTasks"] = []
self.snapshot.raw["history"]["unlockTask"] = {"100": True}
accept = self.next("progression_accept")
self.assertEqual(accept.path, "taskService/taskReceive")
self.assertEqual(accept.payload, {"taskTypeId": "100"})
self.planner.acknowledge(self.snapshot, accept, {"task": {"id": 15, "typeId": "100", "stepValue": None}})
self.assertEqual(self.next("progression_step").task_id, 15)
def test_start_answer_is_required_and_choice_scripts_are_blocked(self):
self.snapshot.raw["currentTasks"] = []
self.snapshot.raw["history"]["unlockTask"] = {"100": True}
for name in ("linear", "choice", "missing"):
with self.subTest(name=name):
self.planner = ProgressionPlanner(self.catalog, config({"100": task(startStep=step(story=name))}))
self.assertTrue(self.plan()[0].block_reason)
self.planner = ProgressionPlanner(self.catalog, config({"100": task(startStep=step(story="accept"))}))
self.planner.acknowledge(self.snapshot, self.next("progression_dialogue"))
self.next("progression_accept")
def test_missing_accept_response_never_invents_an_instance(self):
self.snapshot.raw["currentTasks"] = []
self.snapshot.raw["history"]["unlockTask"] = {"100": True}
action = self.next("progression_accept")
self.assertFalse(self.planner.acknowledge(self.snapshot, action, {}))
self.assertIn("禁止自动重发", self.plan()[0].block_reason)
def test_reward_reply_received_successor_and_unlocked_sidequest(self):
self.planner = ProgressionPlanner(self.catalog, config({
"100": task(), "101": task("101"), "200": task("200", type=2)}))
self.snapshot.raw["currentTasks"][0]["curStep"] = 2
action = self.next("progression_complete")
self.planner.acknowledge(self.snapshot, action, {
"nextTasks": [{"id": 12, "typeId": "101", "curStep": 1}], "unlockTasks": ["200"]})
following = self.next("progression_step")
self.assertEqual(following.task_type_id, "101")
states = {row["task_type_id"]: row["state"] for row in self.planner.rows(self.snapshot, self.policy, self.ranch)}
self.assertEqual(states, {"100": "finished", "101": "received", "200": "unlocked"})
def test_graph_repair_uses_explicit_edges_and_three_exact_arrays(self):
self.planner = ProgressionPlanner(self.catalog, config({
"100": task(nextTasks=["500", "501"], unlockTasks=["700"]),
"500": task("500"), "501": task("501", closed=True), "700": task("700", type=2)}))
self.snapshot.raw["currentTasks"] = []
self.snapshot.raw["history"]["passTask"] = {"100": True, "unrelated": False}
self.policy.sidequests = True
action = self.next("progression_update")
self.assertEqual(action.path, "taskService/taskUpdate")
self.assertEqual(action.payload, {"receiveTasks": [{"prev": "100", "taskTypeId": "500"}],
"unlockTasks": [{"prev": "100", "taskTypeId": "700"}], "removeTasks": []})
self.snapshot.raw["history"]["unlockTask"] = {"500": True, "700": True}
self.policy.accept = False
self.assertNotIn("progression_update", [action.kind for action in self.plan()])
def test_graph_no_guessed_first_task_and_legacy_root_is_respected(self):
self.snapshot.raw["currentTasks"] = []
self.assertEqual(self.plan(), [])
data = config({"999": task("999", nextTasks=["100"]), "100": task()}, setting={"useOldNewTaskFunction": True})
self.planner = ProgressionPlanner(self.catalog, data)
self.snapshot.raw["history"]["passTask"] = {"999": True}
self.assertEqual(self.plan(), [])
def test_closed_task_removal_ack_is_not_replayed_on_a_stale_snapshot(self):
self.planner = ProgressionPlanner(self.catalog, config({"100": task(closed=True)}))
action = self.next("progression_update")
self.assertEqual(action.payload, {"unlockTasks": [], "receiveTasks": [], "removeTasks": [11]})
self.planner.acknowledge(self.snapshot, action, {})
self.assertEqual(self.plan(), [])
def test_declared_conditions_time_and_loader_anomaly_are_conservative(self):
self.assertFalse(self.planner.condition({"minLevel": 21}, self.snapshot)[0])
self.assertFalse(self.planner.condition({"maxLevel": 19}, self.snapshot)[0])
self.assertFalse(self.planner.condition({"close": True}, self.snapshot)[0])
self.assertFalse(self.planner.condition({"unfinishTask": ["100"]}, self.snapshot)[0])
self.assertFalse(self.planner.condition({"passStage": ["0101"]}, self.snapshot)[0])
self.assertTrue(self.planner.condition({"unlockStage": ["0101"]}, self.snapshot)[0])
self.assertFalse(self.planner.condition({"lang": "CN"}, self.snapshot)[0])
self.snapshot.raw["client_context"] = {"lang": "CN", "platform": "ANDROID", "channel": "DYD"}
self.assertTrue(self.planner.condition({"lang": "CN", "platform": "ANDROID"}, self.snapshot)[0])
self.assertFalse(self.planner.condition({"futureFlag": True}, self.snapshot)[0])
with patch("ranch_assistant.model.time.time", return_value=1794112200):
# 2026-11-08 12:30 UTC+8, Sunday == AS3 day 0.
self.assertTrue(self.planner.condition({"week": [0], "startTime": 1230, "endTime": 1230}, self.snapshot)[0])
self.assertFalse(self.planner.condition({"week": [1]}, self.snapshot)[0])
self.assertFalse(self.planner.condition({"endTimestamp": 1}, self.snapshot)[0])
def test_guide_gates_and_special_gacha_stay_blocked(self):
self.planner = ProgressionPlanner(self.catalog, config({"100": task(steps=[step(passGuide="minefail")])}))
self.assertTrue(self.plan()[0].block_reason)
self.snapshot.raw["history"]["guide_record"] = {"minefail": True}
self.next("progression_step")
self.planner = ProgressionPlanner(self.catalog, config({"1001006": task("1001006", steps=[step()] * 4)}))
self.snapshot.raw["currentTasks"] = [{"id": 12, "typeId": "1001006", "curStep": 4}]
self.assertIn("特殊抽蛋", self.plan()[0].block_reason)
def test_item_reserve_locks_and_exact_remove_ids(self):
self.planner = ProgressionPlanner(self.catalog, config({"100": task(steps=[step("getItem", statusValue={"type": 30001, "num": 3, "remove": True})])}))
self.snapshot.raw["items"] = [{"id": 1, "typeId": 30001, "num": 2}, {"id": 2, "typeId": 30001, "num": 4},
{"id": 3, "typeId": 30001, "num": 100, "lock": True}]
self.assertIn("未启用", self.plan()[0].block_reason)
self.policy.allow_items = True
self.policy.item_reserves = {"30001": 4}
self.assertIn("保留", self.plan()[0].block_reason)
self.policy.item_reserves = {"30001": 3}
action = self.next("progression_step")
self.assertEqual(action.payload["removeIds"], [1, 2])
self.assertEqual(self.snapshot.raw["items"][1]["num"], 4)
def test_observation_only_items_still_send_source_ids_without_allowing_consumption(self):
self.planner = ProgressionPlanner(self.catalog, config({"100": task(steps=[step("getItem", statusValue={"type": 30001, "num": 2, "remove": False})])}))
self.snapshot.raw["items"] = [{"id": 1, "typeId": 30001, "num": 2}]
self.policy.item_reserves = {"30001": 100}
self.assertEqual(self.next("progression_step").payload["removeIds"], [1])
def test_money_removal_respects_maximum_and_ranch_reserve(self):
self.planner = ProgressionPlanner(self.catalog, config({"100": task(steps=[step("getMoney", statusValue={"money": 1200, "remove": True})])}))
self.assertIn("上限", self.plan()[0].block_reason)
self.policy.max_money = 1200
self.assertIn("保留", self.plan()[0].block_reason)
self.snapshot.raw["master"]["money"] = 2200
self.next("progression_step")
def test_monster_submission_never_consumes_team_locked_or_reserved_monsters(self):
self.planner = ProgressionPlanner(self.catalog, config({"100": task(steps=[step("getMonster", statusValue={"type": 1001010, "num": 1, "mode": 2, "remove": True})])}))
base = self.catalog.monster(1001010)
monster = {"id": 1, "typeId": 1001010, "mode": 2, "process": 3, "level": 1,
**{"g" + stat.capitalize(): base[stat + "_grow_min"] for stat in ("atk", "def", "hp", "dex")}}
self.snapshot.raw["monsters"] = [monster]
self.policy.allow_monsters = True
self.ranch.protect_quality = 5
self.assertEqual(self.next("progression_step").payload["removeIds"], [1])
for changes in ({"lock": True}, {"entangle": True}, {"equip1": 3}, {"inExploreTeam": True}):
with self.subTest(changes=changes):
self.snapshot.raw["monsters"] = [monster | changes]
self.assertTrue(self.plan()[0].block_reason)
self.snapshot.raw["monsters"] = [monster]
self.snapshot.raw["teams"] = [{"monsters": [1]}]
self.assertTrue(self.plan()[0].block_reason)
self.snapshot.raw["teams"] = []
self.ranch.reserved_types = [1001010]
self.assertTrue(self.plan()[0].block_reason)
def test_kill_target_uses_step_value_and_never_configured_relative_count(self):
self.planner = ProgressionPlanner(self.catalog, config({"100": task(steps=[step("killMonster", statusValue={"type": 1001010, "num": 2})])}))
self.snapshot.raw["currentTasks"][0]["stepValue"] = 150
self.snapshot.raw["history"]["numKillMonsters"] = {"1001010": 149}
self.assertTrue(self.plan()[0].block_reason)
self.snapshot.raw["history"]["numKillMonsters"]["1001010"] = 150
self.next("progression_step")
self.snapshot.raw["currentTasks"][0]["stepValue"] = None
self.assertIn("未同步", self.plan()[0].block_reason)
def test_pass_stage_and_task_battle_route_are_distinct_and_never_sweeps(self):
for kind in ("battle", "passStage"):
with self.subTest(kind=kind):
value = {"stage": "0101", "level": "1"} if kind == "passStage" else {}
self.planner = ProgressionPlanner(self.catalog, config({"100": task(steps=[step(kind, statusValue=value, battle={"teams": [{"mons": []}]})])}))
self.snapshot.raw["history"]["passStage"] = {"0101": [1, 2, 3]}
action = self.next("progression_battle")
self.assertEqual(action.path, "battleService/battleStart")
self.assertEqual(action.payload, {"battleType": "task", "taskTypeId": "100"})
self.assertEqual(action.battle_kind, "task" if kind == "battle" else "passStage")
self.assertEqual(action.stage_id, "" if kind == "battle" else "0101")
self.assertNotIn("battleData", action.payload)
self.planner.battle_lost(self.snapshot, action)
self.assertIn("战败", self.plan()[0].block_reason)
def test_task_pass_stage_stamina_and_hard_mode_gates(self):
self.planner = ProgressionPlanner(self.catalog, config({"100": task(steps=[step("passStage", statusValue={"stage": "0101", "level": 2})])}))
self.snapshot.raw["history"]["openHardMode"] = False
self.assertIn("高难度", self.plan()[0].block_reason)
self.snapshot.raw["history"]["openHardMode"] = True
self.policy.reserve_ti = 47
self.assertIn("体力", self.plan()[0].block_reason)
self.policy.reserve_ti = 46
self.next("progression_battle")
def test_battle_start_or_local_win_is_not_a_step_settlement(self):
self.planner = ProgressionPlanner(self.catalog, config({"100": task(steps=[step("battle", battle={"teams": []})])}))
action = self.next("progression_battle")
for response in ({"resCode": 0}, {"win": True}, {"resCode": 1, "reward": {}}):
with self.subTest(response=response), self.assertRaises(ValueError):
self.planner.acknowledge(self.snapshot, action, response)
def test_pass_stage_local_flags_require_confirmed_settlement(self):
self.planner = ProgressionPlanner(self.catalog, config({"100": task(steps=[
step("passStage", statusValue={"stage": "0101", "level": 1}),
step(condition={"passStage": ["0101"]})])}))
action = self.next("progression_battle")
self.assertFalse(self.planner.condition({"passStage": ["0101"]}, self.snapshot)[0])
self.planner.acknowledge(self.snapshot, action, {"costTi": 3, "unlockStage": [], "lockStage": []})
self.assertTrue(self.planner.condition({"passStage": ["0101"]}, self.snapshot)[0])
self.planner.acknowledge(self.snapshot, self.next("progression_local_step"))
self.assertEqual(self.next("progression_step").step_number, 2)
def test_wrong_account_stale_and_invalid_wire_steps_are_not_accepted(self):
action = self.next("progression_step")
other = snapshot(master={"id": 2})
with self.assertRaises(ValueError):
self.planner.acknowledge(other, action, {})
with self.assertRaises(ValueError):
self.planner.acknowledge(self.snapshot, replace(action, payload={}), {})
self.snapshot.raw["currentTasks"][0]["curStep"] = 0
self.planner = ProgressionPlanner(self.catalog, config())
self.assertIn("一基步骤", self.plan()[0].block_reason)
def test_pending_request_survives_restore_and_is_not_replayed(self):
action = self.next("progression_step")
self.planner.mark_started(self.snapshot, action)
restored = ProgressionPlanner(self.catalog, config())
restored.restore_state(json.loads(json.dumps(self.planner.export_state())))
self.assertTrue(restored.plan(self.snapshot, self.policy, self.ranch)[0].block_reason)
self.snapshot.raw["currentTasks"][0]["curStep"] = 2
planned = restored.plan(self.snapshot, self.policy, self.ranch)[0]
self.assertEqual(planned.kind, "progression_local_step")
def test_local_progress_import_requires_an_actual_step_ack(self):
cursor = {"11:100": {"task_id": 11, "task_type_id": "100", "steps": {
"1": {"kind": "progression_dialogue", "phase": "before", "acknowledged": True}}}}
planned = self.planner.plan(self.snapshot, self.policy, self.ranch, local_progress=cursor)
self.assertEqual(planned[0].kind, "progression_step")
cursor["11:100"]["steps"]["1"] = {"kind": "progression_step", "acknowledged": True, "response": {"taskStepValue": None}}
planned = self.planner.plan(self.snapshot, self.policy, self.ranch, local_progress=cursor)
self.assertEqual(planned[0].kind, "progression_local_step")
def test_unknown_types_are_visible_and_commissions_are_not_duplicated(self):
self.planner = ProgressionPlanner(self.catalog, config({"100": task(type=6), "400": task("400", type=4)}))
self.snapshot.raw["currentTasks"].append({"id": 12, "typeId": "400", "curStep": 1})
rows = self.planner.rows(self.snapshot, self.policy, self.ranch)
self.assertEqual({row["category"] for row in rows}, {"unknown", "commission"})
self.policy.commissions = True
self.assertTrue(all(not action.path for action in self.plan()))
self.assertIn("QuestPolicy", next(row for row in rows if row["category"] == "commission")["block_reason"])
class CommissionProgressionTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.catalog = Catalog()
def setUp(self):
self.snapshot = snapshot(currentTasks=[{"id": 40, "typeId": "400", "curStep": 1}])
self.snapshot.raw["history"].update(loopTaskTime=int(self.snapshot.now), loopTaskNum=6, loopTask={"1": []})
self.quest = QuestPolicy(enabled=True)
self.ranch = Policy(keep_money=1000)
self.battle_policy = ProgressionPolicy(team="teamB", reserve_ti=5)
self.planner = ProgressionPlanner(self.catalog, config({"400": task("400", type=4)}))
def plans(self):
return self.planner.commission_plan(self.snapshot, self.quest, self.ranch, battle_policy=self.battle_policy)
def next(self, kind):
actions = self.plans()
self.assertTrue(actions)
self.assertEqual(actions[0].kind, kind, actions[0].description)
return actions[0]
def offers(self, values=None):
self.snapshot.raw["currentTasks"] = []
self.snapshot.raw["history"]["loopTask"] = {"1": ["400"] if values is None else values}
def test_current_commission_uses_full_nonbattle_acknowledgement_flow(self):
self.snapshot.raw["history"]["passTask"] = {"400": True} # Prior day's same type.
action = self.next("progression_step")
self.planner.acknowledge(self.snapshot, action, {})
self.planner.acknowledge(self.snapshot, self.next("progression_local_step"))
reward = self.next("progression_complete")
self.planner.acknowledge(self.snapshot, reward, {})
self.assertEqual(self.plans(), [])
self.assertEqual(self.planner.commission_rows(self.snapshot, self.quest, self.ranch)[0]["state"], "finished")
def test_battle_and_pass_stage_use_quest_battle_switch_and_task_route(self):
for kind in ("battle", "passStage"):
with self.subTest(kind=kind):
value = {"stage": "0101", "level": 1} if kind == "passStage" else {}
self.planner = ProgressionPlanner(self.catalog, config({"400": task("400", type=4, steps=[
step(kind, battle={"teams": []}, statusValue=value, afterStory="linear")])}))
self.quest.battle_tasks = False
self.assertIn("战斗开关", self.plans()[0].block_reason)
self.quest.battle_tasks = True
action = self.next("progression_battle")
self.assertEqual(action.payload, {"battleType": "task", "taskTypeId": "400"})
self.assertEqual(action.battle_kind, "task" if kind == "battle" else "passStage")
self.assertEqual(action.team, "teamB")
self.assertEqual(action.battle_mode, "original")
self.planner.acknowledge(self.snapshot, action, {"reward": {}})
self.assertEqual(self.next("progression_dialogue").phase, "after")
def test_offer_acceptance_has_exact_loop_payload_and_spends_one_slot_once(self):
self.offers()
self.snapshot.raw["history"]["loopTaskNum"] = 1
action = self.next("progression_loop_accept")
self.assertEqual(action.path, "taskService/taskLoopReceive")
self.assertEqual(action.payload, {"taskTypeId": "400", "city": 1})
response = {"task": {"id": 41, "typeId": "400", "curStep": 1}}
self.assertTrue(self.planner.acknowledge(self.snapshot, action, response))
self.assertFalse(self.planner.acknowledge(self.snapshot, action, response))
account = next(iter(self.planner.export_state()["accounts"].values()))
self.assertEqual(account["commissions"]["remaining"], 0)
self.assertEqual(self.next("progression_step").task_id, 41)
self.planner.acknowledge(self.snapshot, self.next("progression_step"), {})
self.planner.acknowledge(self.snapshot, self.next("progression_local_step"))
self.planner.acknowledge(self.snapshot, self.next("progression_complete"), {})
self.assertEqual(self.plans(), [])
def test_quest_enabled_accept_city_and_quota_are_authoritative(self):
self.offers()
self.quest.enabled = False
self.assertEqual(self.plans(), [])
self.quest.enabled = True
self.quest.accept = False
self.assertEqual(self.plans(), [])
self.quest.accept = True
self.quest.city = 2
self.assertEqual(self.plans(), [])
self.quest.city = 1
self.snapshot.raw["history"]["loopTaskNum"] = 0
self.assertEqual(self.plans(), [])
self.snapshot.raw["history"]["loopTaskNum"] = 1
self.next("progression_loop_accept")
def test_quest_resources_control_offer_acceptance(self):
self.planner = ProgressionPlanner(self.catalog, config({"400": task("400", type=4, steps=[
step("getItem", statusValue={"type": 30001, "num": 3, "remove": True}, afterStory="linear")])}))
self.offers()
self.snapshot.raw["items"] = [{"id": 1, "typeId": 30001, "num": 5}]
self.assertEqual(self.plans(), [])
self.quest.allow_items = True
self.quest.item_reserves = {"30001": 3}
self.assertEqual(self.plans(), [])
row = self.planner.commission_rows(self.snapshot, self.quest, self.ranch)[0]
self.assertIn("保留", row["block_reason"])
self.assertFalse(row["supported"])
self.quest.item_reserves = {"30001": 2}
self.next("progression_loop_accept")
def test_offer_with_linear_stories_is_accepted_and_choice_is_not(self):
self.offers()
for name, expected in (("linear", True), ("choice", False)):
with self.subTest(name=name):
self.planner = ProgressionPlanner(self.catalog, config({"400": task("400", type=4, steps=[step(story=name)])}))
self.assertEqual(bool(self.plans()), expected)
def test_battle_offers_need_existing_battle_tasks_opt_in(self):
self.offers()
self.planner = ProgressionPlanner(self.catalog, config({"400": task("400", type=4, steps=[step("battle", battle={"teams": []})])}))
self.assertEqual(self.plans(), [])
self.quest.battle_tasks = True
self.next("progression_loop_accept")
def test_reset_expires_old_instance_and_uses_confirmed_new_offers(self):
self.snapshot.raw["history"]["loopTaskTime"] -= 86400
self.snapshot.raw["history"]["loopTaskNum"] = 0
action = self.next("progression_loop_reset")
self.assertEqual(action.path, "taskService/taskLoopFlush")
self.assertEqual(action.payload, {})
self.planner.acknowledge(self.snapshot, action, {"loopTask": {"1": [400]}})
following = self.next("progression_loop_accept")
self.assertEqual(following.payload, {"taskTypeId": "400", "city": 1})
account = next(iter(self.planner.export_state()["accounts"].values()))
self.assertIn("40", account["commissions"]["expired_ids"])
self.assertEqual(account["commissions"]["remaining"], 6)
def test_uncertain_loop_accept_reconciles_without_spending_quota_twice(self):
self.offers()
self.snapshot.raw["history"]["loopTaskNum"] = 1
action = self.next("progression_loop_accept")
self.planner.mark_uncertain(self.snapshot, action)
self.assertTrue(self.plans()[0].block_reason)
self.snapshot.raw["currentTasks"] = [{"id": 41, "typeId": "400", "curStep": 1}]
self.snapshot.raw["history"]["loopTaskNum"] = 0
self.next("progression_step")
account = next(iter(self.planner.export_state()["accounts"].values()))
self.assertEqual(account["commissions"]["remaining"], 0)
def test_cn_reset_uses_ten_second_grace(self):
midnight = 1794067200 # 2026-11-08 00:00 UTC+8.
with patch("ranch_assistant.model.time.time", return_value=midnight + 5):
self.snapshot.raw["history"]["loopTaskTime"] = midnight - 100
self.assertNotEqual(self.plans()[0].kind, "progression_loop_reset")
with patch("ranch_assistant.model.time.time", return_value=midnight + 11):
self.assertEqual(self.plans()[0].kind, "progression_loop_reset")
class RecoveredProgressionDataTests(unittest.TestCase):
def test_full_original_tasks_static_manifest_and_battle_archive(self):
data = load_progression_data()
self.assertEqual(len(data.tasks), 1165)
self.assertEqual(sum(len(task["steps"]) for task in data.tasks.values()), 3462)
self.assertEqual(len(data.stages), 1178)
self.assertEqual(len(data.scripts), 4269)
self.assertEqual(data.manifest["source"]["apk_sha256"], ORIGINAL_APK_SHA256)
self.assertEqual(len(Catalog().data["task_info"]), 83)
self.assertEqual(data.task("1001002")["steps"][0]["story"], "task_1001002")
self.assertIs(type(data.task("1001001")["unlockTasks"]), list)
self.assertEqual(data.manifest["source"]["amf_reader_sha256"], hashlib.sha256((ROOT / "ranch_assistant/amf.py").read_bytes()).hexdigest())
self.assertTrue(data.script("task_1001002")["supported"])
for name, record in data.manifest["artifacts"].items():
self.assertEqual(hashlib.sha256((DATA_DIR / name).read_bytes()).hexdigest(), record["sha256"])
self.assertLess((DATA_DIR / BATTLES_NAME).stat().st_size, 3_000_000)
with zipfile.ZipFile(DATA_DIR / BATTLES_NAME) as archive:
self.assertEqual(len(archive.namelist()), 1178)
self.assertTrue(all(name.startswith("stages/") and name.endswith(".json") for name in archive.namelist()))
self.assertTrue(all(info.date_time == (1980, 1, 1, 0, 0, 0) for info in archive.infolist()))
self.assertTrue(data.stage_battle("0101", 1))
self.assertTrue(data.task_battle("1001001", 1))
def test_loader_never_opens_apk_or_eagerly_reads_battles(self):
with patch("ranch_assistant.game_data.zipfile.ZipFile", side_effect=AssertionError("eager archive read")):
data = ProgressionData()
self.assertEqual(len(data.tasks), 1165)
def test_artifact_tampering_is_rejected(self):
with patch("ranch_assistant.game_data.Path.read_bytes", return_value=b"tampered"):
with self.assertRaisesRegex(ProgressionDataError, "hash mismatch"):
ProgressionData()
def test_shared_static_data_is_not_mutated_by_account_planning(self):
data = load_progression_data()
before = json.dumps(data.data, sort_keys=True, ensure_ascii=True)
planner = ProgressionPlanner(Catalog(), data)
planner.rows(snapshot(), ProgressionPolicy(), Policy())
planner.plan(snapshot(master={"id": 2}), ProgressionPolicy(enabled=True), Policy())
self.assertEqual(json.dumps(data.data, sort_keys=True, ensure_ascii=True), before)
def test_linear_hide_newlines_and_placeholders_are_presentation(self):
expressions = [
{"key": "text", "para": {"text": "[show]你好 [{gn.myName}][r]下一行\n[hide][cm]"}},
{"key": "event", "para": {"event": "GAoEvent", "eventData": "true"}},
]
summary = summarize_script(json.dumps({"exps": expressions}).encode(), "fixture")
self.assertTrue(summary["supported"], summary)
self.assertTrue(summary["answer"])
self.assertEqual(summary["dialogue_lines"], 1)
for expression in ({"key": "option", "para": {"options": []}}, {"key": "jump", "para": {"tag": "x"}},
{"key": "event", "para": {"event": "GAoEvent", "eventData": '{"action":"gacha"}'}}):
with self.subTest(expression=expression):
summary = summarize_script(json.dumps({"exps": [expression]}).encode(), "fixture")
self.assertFalse(summary["supported"])
class FarmingAndAreaTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.catalog = Catalog()
def setUp(self):
self.snapshot = snapshot()
self.policy = ProgressionPolicy(enabled=True)
self.ranch = Policy(keep_money=1000)
self.data = config(farming={"kills": {"1001010": [{"stage_id": "0101", "difficulty": 1, "configured_enemies": 2}]},
"items": {key: [{"stage_id": "0101", "difficulty": 1}] for key in ("30001", "1001010")}})
def planner(self, current_step):
data = deepcopy(self.data)
data["task_info"]["100"]["steps"] = [current_step]
return ProgressionPlanner(self.catalog, data)
def test_kill_farming_has_no_task_wire_context_and_never_uses_sweep(self):
planner = self.planner(step("killMonster", statusValue={"type": 1001010, "num": 5}))
self.snapshot.raw["currentTasks"][0]["stepValue"] = 5
self.snapshot.raw["history"]["numKillMonsters"] = {"1001010": 0}
self.snapshot.raw["history"]["passStage"] = {"0101": [1, 2, 3]}
action = planner.plan(self.snapshot, self.policy, self.ranch)[0]
self.assertEqual(action.kind, "stage_battle")
self.assertEqual(action.battle_kind, "ordinary_stage")
self.assertEqual((action.task_id, action.task_type_id), (0, ""))
self.assertEqual((action.source_task_id, action.source_task_type_id, action.source_step_number), (11, "100", 1))
self.assertEqual(action.payload, {"stageTypeId": "0101", "stageLevel": "1"})
self.assertEqual(action.path, "stageService/stageStart")
with self.assertRaises(ValueError):
planner.acknowledge(self.snapshot, action, {"reward": {}})
self.assertEqual(self.snapshot.raw["currentTasks"][0]["curStep"], 1)
self.snapshot.raw["history"]["numKillMonsters"]["1001010"] = 5
self.assertEqual(planner.plan(self.snapshot, self.policy, self.ranch)[0].kind, "progression_step")
def test_loot_uses_sweep_only_after_three_difficulties_are_cleared(self):
planner = self.planner(step("getItem", statusValue={"type": 30001, "num": 3, "remove": False}))
self.snapshot.raw["history"]["passStage"] = {"0101": [3]}
self.assertEqual(planner.plan(self.snapshot, self.policy, self.ranch)[0].kind, "stage_battle")
self.snapshot.raw["history"]["passStage"] = {"0101": [1, 2, 3]}
action = planner.plan(self.snapshot, self.policy, self.ranch)[0]
self.assertEqual(action.kind, "sweep")
self.assertEqual(action.task_id, 0)
self.assertEqual(action.source_task_type_id, "100")
self.policy.allow_sweep = False
self.assertEqual(planner.plan(self.snapshot, self.policy, self.ranch)[0].kind, "stage_battle")
def test_egg_farming_and_reserves_wait_for_actual_inventory(self):
planner = self.planner(step("getMonster", statusValue={"type": 1001010, "num": 2, "mode": 0, "remove": True}))
self.policy.allow_items = True
self.policy.item_reserves = {"1001010": 2}
self.snapshot.raw["items"] = [{"id": 1, "typeId": 1001010, "num": 3}]
self.assertEqual(planner.plan(self.snapshot, self.policy, self.ranch)[0].kind, "stage_battle")
self.snapshot.raw["items"][0]["num"] = 4
self.assertEqual(planner.plan(self.snapshot, self.policy, self.ranch)[0].kind, "progression_step")
def test_farming_respects_disabled_consumption_stamina_locks_and_premium(self):
planner = self.planner(step("getItem", statusValue={"type": 30001, "num": 3, "remove": True}))
self.assertTrue(planner.plan(self.snapshot, self.policy, self.ranch)[0].block_reason)
self.policy.allow_items = True
self.policy.reserve_ti = 48
self.assertTrue(planner.plan(self.snapshot, self.policy, self.ranch)[0].block_reason)
self.policy.reserve_ti = 0
self.snapshot.raw["history"]["unlockStage"] = {}
self.assertTrue(planner.plan(self.snapshot, self.policy, self.ranch)[0].block_reason)
self.snapshot.raw["history"]["unlockStage"] = {"0101": [1]}
self.data["stage_info"]["0101"]["cost"]["ke"] = 1
self.assertTrue(self.planner(step("getItem", statusValue={"type": 30001, "num": 1})).plan(self.snapshot, self.policy, self.ranch)[0].block_reason)
def test_task_interception_and_auto_farm_switch_are_honored(self):
current = step("getItem", statusValue={"type": 30001, "num": 3})
planner = self.planner(current)
self.policy.auto_farm = False
self.assertTrue(planner.plan(self.snapshot, self.policy, self.ranch)[0].block_reason)
self.policy.auto_farm = True
data = deepcopy(self.data)
data["task_info"]["100"]["steps"] = [current]
data["task_info"]["200"] = task("200", type=2, steps=[step(position="city1_wild_stage0101_level1")])
planner = ProgressionPlanner(self.catalog, data)
self.snapshot.raw["currentTasks"].append({"id": 12, "typeId": "200", "curStep": 1})
self.assertTrue(planner.plan(self.snapshot, self.policy, self.ranch)[0].block_reason)
def test_farming_ticket_locks_and_gift_reserves_are_protected(self):
self.data["stage_info"]["0101"]["cost"]["items"] = [{"typeId": 30002, "num": 1}]
self.policy.allow_items = True
self.snapshot.raw["items"] = [{"id": 2, "typeId": 30002, "num": 1, "sysLock": True}]
planner = self.planner(step("getItem", statusValue={"type": 30001, "num": 2}))
self.assertTrue(planner.plan(self.snapshot, self.policy, self.ranch)[0].block_reason)
self.snapshot.raw["items"][0]["sysLock"] = False
self.ranch.gift_items = {"30002": {"enabled": True, "reserve": 1}}
self.assertTrue(planner.plan(self.snapshot, self.policy, self.ranch)[0].block_reason)
def test_static_index_excludes_juveniles_allies_objects_and_zero_chance(self):
monsters = [
{"type": "1001010", "team": 2, "mode": 2},
{"type": "1001020", "team": 2, "mode": 1},
{"type": "1001030", "team": 1, "mode": 2},
{"type": "1001040", "team": 2, "mode": 2, "isObject": True},
]
reward = {"rewards": [
{"item_num": 1, "item_chance": 1, "items": [{"name": "30001,1,2", "value": 1}]},
{"item_num": 1, "item_chance": 0, "items": [{"name": "30002,1,1", "value": 1}]},
{"num": 1, "chance": 1, "monMode": 0, "monsters": [{"name": "1001010", "value": 1}]},
{"num": 1, "chance": 1, "monMode": 2, "monsters": [{"name": "1001020", "value": 1}]},
]}
index = farming_index({"0101": {"level": {"1": {"battle": {"teams": [{"mons": monsters}]}, "reward": reward}}}})
self.assertEqual(set(index["kills"]), {"1001010"})
self.assertEqual(set(index["items"]), {"30001", "1001010"})
def test_area_and_dungeon_navigation_use_recovered_conditions_and_labels(self):
self.data["area_info"] = {"areaInfo": {"1f": {"name": "森林", "city": "1", "openStage": "0101"}},
"areaMap": {"1": {"positions": [
{"posId": "city1_wild_1f", "action": "area", "actionPara": {"area": "1f"}, "condition": {"finishTask": ["200"]}},
{"posId": "city1_dungeon1", "action": "dungeon", "actionPara": {"dungeon": "dungeon1"}, "condition": {}},
]}}}
self.data["mine_info"] = {"mines": {"dungeon1": {"pos": "city1_dungeon1", "name": "试炼矿洞"}}}
planner = self.planner(step(position="city1_wild_1f", story="linear"))
self.assertTrue(planner.plan(self.snapshot, self.policy, self.ranch)[0].block_reason)
self.snapshot.raw["history"]["passTask"] = {"200": True}
action = planner.plan(self.snapshot, self.policy, self.ranch)[0]
self.assertEqual(action.kind, "progression_navigate")
self.assertIn("森林", action.location)
planner = self.planner(step(position="city1_dungeon1", story="linear"))
action = planner.plan(self.snapshot, self.policy, self.ranch)[0]
self.assertEqual(action.kind, "progression_navigate")
self.assertIn("试炼矿洞", action.location)
if __name__ == "__main__":
unittest.main()
@@ -0,0 +1,749 @@
import os
os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
from dataclasses import asdict
from types import SimpleNamespace
import copy
import json
import threading
import time
import unittest
from unittest.mock import Mock, patch
from PySide6 import QtCore as C, QtWidgets as W
from PySide6.QtTest import QTest
from ranch_assistant import gui
from ranch_assistant.policy_io import import_config, portable_config
from ranch_assistant.progression import ProgressionPolicy
from ranch_assistant.progression_gui import CachedTable, prepare_progression_views
from ranch_assistant.tests.test_core import workspace_temp
def configured_policy():
policy = ProgressionPolicy(enabled=True, mainline=True, sidequests=True, commissions=True, accept=False,
auto_dialogue=False, team="teamC", reserve_ti=24, allow_sweep=False, max_money=42,
allow_items=True, allow_monsters=True, item_reserves={"30001": 17}, stop_after_loss=3, repair_chain=False,
battle_mode="experimental")
if hasattr(policy, "auto_farm"):
policy.auto_farm = False
return policy
TASKS = [
{"task_type_id": "1001", "name": "主线测试", "category": "mainline", "state": "active", "step_number": 2,
"total_steps": 4, "position": "地图0101", "requirement": "与NPC对话", "next_action": "dialogue", "battle_kind": "task_battle",
"dialogue": "测试对话内容", "supported": True, "status": "等待对话"},
{"task_type_id": "1002", "name": "支线测试", "category": "sidequest", "state": "blocked", "step_number": 1,
"total_steps": 2, "position": "地图0102", "requirement": "战斗", "next_action": "", "battle_kind": "task_battle",
"supported": False, "blocked_reason": "战斗运行时尚未支持"},
{"task_type_id": "1003", "name": "委托测试", "category": "commission", "state": "available", "step_number": 0,
"total_steps": 1, "position": "村庄", "requirement": "物品", "next_action": "accept", "battle_kind": ""},
{"task_type_id": "1004", "name": "未知测试", "category": "new_category", "state": 999, "step_number": None,
"total_steps": None, "position": None, "requirement": None, "next_action": None, "battle_kind": None},
]
RECORDS = [
{"timestamp": 1700000000, "battle_kind": "task_battle", "task_type_id": "1001", "team": "teamC", "outcome": "unsupported", "reason": "未支持"},
{"timestamp": 1700000001, "battle_kind": "sweep", "stage_id": "0101", "outcome": "completed", "message": "扫荡记录"},
{"timestamp": 1700000002, "battle_kind": "map_reward_event", "stage_id": "0102", "outcome": "event", "message": "奖励事件"},
]
class ProgressionPolicyIOTests(unittest.TestCase):
def test_round_trip_preserves_choices_without_session_or_runtime_state(self):
policy = configured_policy()
source = {"progression_policy": asdict(policy), "token": "test-secret", "account": "private-account",
"progression_records": RECORDS, "progression_rows": TASKS, "runtime_path": "private-runtime"}
exported = portable_config(source)
self.assertEqual(exported["assistantVersion"], "1.2.0.dev1")
self.assertEqual(import_config(exported)["progression_policy"], asdict(policy))
text = json.dumps(exported)
for secret in ("test-secret", "private-account", "private-runtime", "progression_records", "progression_rows"):
self.assertNotIn(secret, text)
self.assertEqual(policy, configured_policy())
def test_defaults_and_older_bundles_do_not_enable_or_replace_progression(self):
exported = portable_config({})
self.assertFalse(exported["progression_policy"]["enabled"])
self.assertEqual(exported["progression_policy"]["battle_mode"], "original")
if hasattr(ProgressionPolicy(), "auto_farm"):
self.assertEqual(exported["progression_policy"]["auto_farm"], ProgressionPolicy().auto_farm)
del exported["progression_policy"]["auto_farm"]
self.assertEqual(import_config(exported)["progression_policy"]["auto_farm"], ProgressionPolicy().auto_farm)
del exported["progression_policy"]["battle_mode"]
self.assertEqual(import_config(exported)["progression_policy"]["battle_mode"], "original")
del exported["progression_policy"]
self.assertNotIn("progression_policy", import_config(exported))
def test_invalid_progression_rejected_atomically(self):
exported = portable_config({"progression_policy": asdict(configured_policy())})
for field, invalid in (("enabled", 1), ("mainline", "true"), ("reserve_ti", -1), ("reserve_ti", True),
("max_money", -1), ("max_money", 1_000_000_001), ("stop_after_loss", 0), ("stop_after_loss", 1000),
("team", ""), ("team", None), ("team", True), ("battle_mode", "automatic"), ("battle_mode", True),
("battle_mode", ["experimental"]), ("item_reserves", {"30001": -1}), ("item_reserves", {"30001": True}),
("item_reserves", {"invalid": 1}), ("item_reserves", {"0": 1}), ("allow_items", "yes"),
("auto_farm", "true"), ("auto_farm", 1), ("auto_farm", None)):
with self.subTest(field=field, invalid=invalid):
value = copy.deepcopy(exported)
value["progression_policy"][field] = invalid
with self.assertRaises((ValueError, TypeError)):
import_config(value)
for invalid in (None, [], {"unknown_field": True}):
with self.assertRaises((ValueError, TypeError)):
import_config(exported | {"progression_policy": invalid})
class ProgressionGuiTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.app = W.QApplication.instance() or W.QApplication([])
def wait(self, window, predicate=lambda: True):
deadline = time.monotonic() + 6
while time.monotonic() < deadline:
self.app.processEvents()
QTest.qWait(5)
if (not window.busy and not window.progression_table.row_batch.running
and not window.battle_records_table.row_batch.running and predicate()):
return
self.fail("Offline Qt job did not complete: " + window.log.toPlainText())
def mock_readers(self, window):
threads = []
def tasks():
threads.append(C.QThread.currentThread())
return copy.deepcopy(TASKS)
def records():
threads.append(C.QThread.currentThread())
return copy.deepcopy(RECORDS)
task_mock = Mock(side_effect=tasks)
record_mock = Mock(side_effect=records)
window.engine.progression_rows = task_mock
window.engine.progression_records = record_mock
return threads, task_mock, record_mock
def login_fixture(self, window, events):
from ranch_assistant.api import Session
session = Session("http://127.0.0.1/fixture/", "fixture-token", account_id="fixture-account", server_id=1, role_id=101)
client = SimpleNamespace(session=session, trace=None, persist_session=Mock(),
close=Mock(side_effect=lambda: events.append("client_closed")))
window.engine.client = client
window.engine.demo = False
window.engine.last_heartbeat = time.monotonic()
window.engine.master_sync_due = Mock(return_value=False)
window.engine.growth_sync_due = Mock(return_value=False)
window.engine.heartbeat_enabled = True
window.monitoring = True
window.set_strategy_checked(True)
window.next_poll = 0
window.account.setText("fixture-account")
window.password.setText("fixture-password")
window.credentials.save("fixture-account", "fixture-password", True)
window.session_store.save(session, "fixture account")
window.reload_saved_sessions()
return client
def test_logout_nested_confirmation_cannot_report_clear_before_client_release(self):
with workspace_temp() as folder:
window = gui.Window(folder)
window.timer.stop()
release = threading.Event()
events = []
try:
self.wait(window)
client = self.login_fixture(window, events)
def held_poll(**kwargs):
if not release.wait(4):
raise TimeoutError("logout fixture was not released")
return window.engine.snapshot, [], "fixture poll finished"
window.engine.poll = Mock(side_effect=held_poll)
save = window.credentials.save
def record_save(account, password, remember):
if not remember and not account and not password:
events.append("credentials_cleared")
return save(account, password, remember)
def confirm(*args):
window.schedule() # The real modal runs this nested event loop.
self.app.processEvents()
return W.QMessageBox.StandardButton.Yes
with patch.object(gui.W.QMessageBox, "question", side_effect=confirm), patch.object(window.credentials, "save", side_effect=record_save):
window.logout_and_clear()
if "credentials_cleared" in events:
self.assertIn("client_closed", events, "credentials were cleared while the original client was active")
self.assertLess(events.index("client_closed"), events.index("credentials_cleared"))
release.set()
self.wait(window, lambda: window.engine.demo)
client.close.assert_called_once_with()
self.assertEqual(window.credentials.load(), (False, "", ""))
self.assertEqual(window.session_store.entries(), [])
self.assertFalse(window.monitoring)
self.assertFalse(window.engine.auto)
self.assertFalse(window.strategy_toggle.isChecked())
finally:
release.set()
self.wait(window)
window.close()
def test_logout_cancel_freezes_scheduler_but_preserves_credentials_and_stopped_intent(self):
with workspace_temp() as folder:
window = gui.Window(folder)
window.timer.stop()
events, observed = [], []
try:
self.wait(window)
client = self.login_fixture(window, events)
engine = window.engine
window.ranch_enabled.setChecked(False)
window.progression_enabled.setChecked(True)
engine.auto = True
engine.poll = Mock(return_value=(engine.snapshot, [], "fixture refresh"))
def cancel(*args):
observed.append((engine.auto, window.monitoring, window.strategy_toggle.isChecked(), engine.heartbeat_enabled))
window.schedule()
window.start_workflow() # A previously queued start must also stay frozen.
self.app.processEvents()
observed.append((engine.auto, window.monitoring, window.strategy_toggle.isChecked(), engine.heartbeat_enabled))
return W.QMessageBox.StandardButton.No
with patch.object(gui.W.QMessageBox, "question", side_effect=cancel):
window.logout_and_clear()
self.wait(window)
self.assertEqual(observed, [(False, False, False, False)] * 2)
engine.poll.assert_not_called()
self.assertIs(window.engine, engine)
client.close.assert_not_called()
self.assertEqual(window.credentials.load(), (True, "fixture-account", "fixture-password"))
self.assertEqual(len(window.session_store.entries()), 1)
self.assertFalse(window.strategy_toggle.isChecked())
self.assertFalse(engine.auto)
finally:
window.close()
def test_confirmed_busy_logout_waits_for_worker_before_clear(self):
with workspace_temp() as folder:
window = gui.Window(folder)
window.timer.stop()
release = threading.Event()
events = []
try:
self.wait(window)
client = self.login_fixture(window, events)
engine = window.engine
def held_poll():
if not release.wait(4):
raise TimeoutError("logout fixture was not released")
return engine.snapshot, [], "fixture poll finished"
window.submit("poll", held_poll)
with patch.object(gui.W.QMessageBox, "question", return_value=W.QMessageBox.StandardButton.Yes) as question:
window.logout_and_clear()
question.assert_called_once()
self.assertTrue(window.busy)
client.close.assert_not_called()
self.assertEqual(window.credentials.load(), (True, "fixture-account", "fixture-password"))
self.assertNotIn("已清除当前账号页签的登录记录", window.log.toPlainText())
release.set()
self.wait(window, lambda: window.engine.demo)
client.close.assert_called_once_with()
self.assertEqual(window.credentials.load(), (False, "", ""))
self.assertFalse(window.engine.auto)
self.assertFalse(engine.auto)
self.assertFalse(engine.heartbeat_enabled)
finally:
release.set()
self.wait(window)
window.close()
def test_failed_client_release_does_not_clear_credentials_or_report_success(self):
with workspace_temp() as folder:
window = gui.Window(folder)
window.timer.stop()
try:
self.wait(window)
client = self.login_fixture(window, [])
client.close.side_effect = RuntimeError("fixture close failed")
with patch.object(gui.W.QMessageBox, "question", return_value=W.QMessageBox.StandardButton.Yes):
window.logout_and_clear()
self.assertEqual(window.credentials.load(), (True, "fixture-account", "fixture-password"))
self.assertEqual(len(window.session_store.entries()), 1)
self.assertNotIn("已清除当前账号页签的登录记录", window.log.toPlainText())
self.assertIn("fixture close failed", window.log.toPlainText())
self.assertFalse(window.engine.auto)
self.assertFalse(window.engine.heartbeat_enabled)
self.assertFalse(window.monitoring)
client.close.side_effect = None
finally:
window.close()
def test_confirmed_logout_still_clears_sessions_if_window_closes_while_waiting(self):
with workspace_temp() as folder:
window = gui.Window(folder)
window.timer.stop()
release = threading.Event()
try:
self.wait(window)
client = self.login_fixture(window, [])
window.submit("logout_fixture", lambda: release.wait(4))
with patch.object(gui.W.QMessageBox, "question", return_value=W.QMessageBox.StandardButton.Yes):
window.logout_and_clear()
window.close()
release.set()
for _ in range(600):
self.app.processEvents()
QTest.qWait(5)
if not window.busy and client.close.called:
break
self.assertEqual(window.session_store.entries(), [])
self.assertEqual(window.credentials.load(), (False, "", ""))
client.close.assert_called_once_with()
finally:
release.set()
self.wait(window)
window.close()
def test_tabs_stopped_defaults_and_progression_only_global_start(self):
with workspace_temp() as folder:
window = gui.Window(folder)
window.timer.stop()
try:
self.wait(window)
labels = [window.tabs.tabText(i) for i in range(window.tabs.count())]
self.assertEqual(labels[labels.index("自动孵蛋") + 1], "自动主线")
self.assertIn("战斗记录", labels)
self.assertEqual(labels[-1], "收益资料")
self.assertEqual(window.styleSheet(), "")
self.assertFalse(window.progression_enabled.isChecked())
self.assertTrue(window.progression_mainline.isChecked())
self.assertFalse(window.progression_sidequests.isChecked())
self.assertFalse(window.progression_commissions.isChecked())
if hasattr(ProgressionPolicy(), "auto_farm"):
self.assertEqual(window.progression_auto_farm.isChecked(), ProgressionPolicy().auto_farm)
else:
self.assertFalse(hasattr(window, "progression_auto_farm"))
self.assertEqual(window.progression_battle_mode.currentData(), "original")
self.assertIn("近似", window.progression_battle_mode.toolTip())
self.assertIn("委托", window.progression_battle_mode.toolTip())
self.assertFalse(window.strategy_toggle.isChecked())
for widget in (window.ranch_enabled, window.quest_enabled, window.daily_enabled, window.map_enabled, window.gift_enabled):
widget.setChecked(False)
window.progression_enabled.setChecked(True)
window.engine.cancel_progression = Mock()
with patch.object(window, "refresh"):
window.start_workflow()
self.assertTrue(window.strategy_toggle.isChecked())
self.assertIn("主线推进", window.workflow_status.text())
window.stop_workflow()
window.engine.cancel_progression.assert_called_once_with()
self.assertFalse(window.strategy_toggle.isChecked())
buttons = [b.text() for b in window.findChildren(W.QPushButton)]
self.assertEqual(buttons.count("开启"), 1)
self.assertNotIn("开始监控", buttons)
finally:
window.close()
def test_per_account_autosave_and_restart_round_trip(self):
with workspace_temp() as folder:
expected = asdict(configured_policy())
window = gui.Window(folder / "one")
window.timer.stop()
try:
self.wait(window)
window.load_progression_policy(configured_policy())
window.progression_max_money.setValue(43)
expected["max_money"] = 43
QTest.qWait(350)
self.wait(window)
self.assertEqual(json.loads((folder / "one" / "settings.json").read_text(encoding="utf-8"))["progression_policy"], expected)
self.assertEqual(asdict(window.engine.progression_policy), expected)
self.assertFalse(window.engine.auto)
finally:
window.close()
first = gui.Window(folder / "one")
second = gui.Window(folder / "two")
first.timer.stop()
second.timer.stop()
try:
self.wait(first)
self.wait(second)
self.assertEqual(asdict(first.read_progression_policy()), expected)
self.assertEqual(asdict(second.read_progression_policy()), asdict(ProgressionPolicy()))
self.assertFalse(first.strategy_toggle.isChecked())
self.assertFalse(second.strategy_toggle.isChecked())
finally:
first.close()
second.close()
def test_unified_import_keeps_choices_and_execution_stopped(self):
with workspace_temp() as folder:
window = gui.Window(folder)
window.timer.stop()
try:
self.wait(window)
source = window.config_value() | {"progression_policy": asdict(configured_policy())}
path = folder / "policies.json"
path.write_text(json.dumps(portable_config(source)), encoding="utf-8")
window.set_strategy_checked(True)
window.engine.auto = True
window.engine.run_progression_once = Mock()
with patch.object(gui.W.QFileDialog, "getOpenFileName", return_value=(str(path), "")):
window.import_policies()
self.assertEqual(asdict(window.read_progression_policy()), asdict(configured_policy()))
self.assertEqual(asdict(window.engine.progression_policy), asdict(configured_policy()))
self.assertFalse(window.strategy_toggle.isChecked())
self.assertFalse(window.engine.auto)
window.engine.run_progression_once.assert_not_called()
with patch.object(gui.W.QFileDialog, "getSaveFileName", return_value=(str(path), "")):
window.export_policies()
self.assertEqual(import_config(json.loads(path.read_text(encoding="utf-8")))["progression_policy"], asdict(configured_policy()))
finally:
window.close()
def test_battle_mode_autosaves_without_starting_and_reaches_worker_policy(self):
with workspace_temp() as folder:
window = gui.Window(folder)
window.timer.stop()
try:
self.wait(window)
window.engine.run_progression_once = Mock()
self.assertEqual(window.progression_battle_mode.currentData(), "original")
window.progression_battle_mode.setCurrentIndex(window.progression_battle_mode.findData("experimental"))
QTest.qWait(350)
self.wait(window)
saved = json.loads((folder / "settings.json").read_text(encoding="utf-8"))
self.assertEqual(saved["progression_policy"]["battle_mode"], "experimental")
self.assertEqual(window.engine.progression_policy.battle_mode, "experimental")
self.assertIn("实验模拟", window.progression_status.text())
self.assertIn("近似", window.progression_status.text())
self.assertFalse(window.strategy_toggle.isChecked())
self.assertFalse(window.engine.auto)
window.engine.run_progression_once.assert_not_called()
observations = []
def preview():
observations.append((window.engine.progression_policy.battle_mode, C.QThread.currentThread()))
return window.engine.snapshot, [], "已预览所选战斗模式"
window.engine.refresh_progression = Mock(side_effect=preview)
window.refresh_progression()
self.wait(window)
self.assertEqual(observations[0][0], "experimental")
self.assertNotEqual(observations[0][1], self.app.thread())
self.assertFalse(window.engine.auto)
finally:
window.close()
def test_additional_and_unavailable_teams_round_trip_visibly_without_starting(self):
with workspace_temp() as folder:
window = gui.Window(folder)
window.timer.stop()
try:
self.wait(window)
policy = configured_policy()
policy.team = "Raid42"
exported = portable_config(window.config_value() | {"progression_policy": asdict(policy)})
value = import_config(exported)
self.assertEqual(value["progression_policy"]["team"], "Raid42")
window.load_config(window.config_value() | value)
self.assertEqual(window.progression_team.currentData(), "Raid42")
self.assertIn("当前账号未找到", window.progression_team.currentText())
window.engine.snapshot.raw["teams"] = [{"teamType": "battleTeam", "teamName": "Raid42", "monsters": [900]},
{"teamType": "battleTeam", "teamName": "teamD", "monsters": [900]}]
window.refresh_progression_teams(window.engine.snapshot)
self.assertEqual(window.progression_team.currentText(), "Raid42")
self.assertGreaterEqual(window.progression_team.findData("teamD"), 0)
self.assertEqual(window.read_progression_policy().team, "Raid42")
self.assertFalse(window.strategy_toggle.isChecked())
self.assertFalse(window.engine.auto)
finally:
window.close()
@unittest.skipUnless(hasattr(ProgressionPolicy(), "auto_farm"), "Planner has not exposed ProgressionPolicy.auto_farm yet")
def test_auto_farm_autosaves_without_starting_or_duplicate_controls(self):
with workspace_temp() as folder:
window = gui.Window(folder)
window.timer.stop()
try:
self.wait(window)
checks = [check for check in window.findChildren(W.QCheckBox)
if check.text() == "自动收集任务材料 / 击杀目标"]
self.assertEqual(checks, [window.progression_auto_farm])
window.engine.run_progression_once = Mock()
selected = not ProgressionPolicy().auto_farm
window.progression_auto_farm.setChecked(selected)
QTest.qWait(350)
self.wait(window)
saved = json.loads((folder / "settings.json").read_text(encoding="utf-8"))
self.assertEqual(saved["progression_policy"]["auto_farm"], selected)
self.assertEqual(window.engine.progression_policy.auto_farm, selected)
exported = portable_config(window.config_value())
self.assertEqual(import_config(exported)["progression_policy"]["auto_farm"], selected)
self.assertFalse(window.strategy_toggle.isChecked())
self.assertFalse(window.engine.auto)
window.engine.run_progression_once.assert_not_called()
finally:
window.close()
def test_hidden_page_and_account_skip_task_getters_and_cached_view_is_lazy(self):
with workspace_temp() as folder:
window = gui.Window(folder)
window.timer.stop()
try:
self.wait(window)
threads, tasks, records = self.mock_readers(window)
window.refresh()
self.wait(window)
tasks.assert_not_called()
records.assert_not_called()
window.set_presentation_active(False)
window.tabs.setCurrentWidget(window.progression_page)
window.refresh()
self.wait(window)
tasks.assert_not_called()
records.assert_not_called()
window.set_presentation_active(True)
self.wait(window, lambda: window.progression_table.rowCount() == 4)
self.assertTrue(all(thread != self.app.thread() for thread in threads))
self.assertEqual(tasks.call_count, 1)
window.render_progression()
window.render_current_page()
self.assertEqual(tasks.call_count, 1)
records.assert_not_called()
window.tabs.setCurrentWidget(window.battle_records_page)
self.wait(window, lambda: window.battle_records_table.rowCount() == 3)
self.assertEqual(records.call_count, 1)
tasks.reset_mock()
window.refresh()
self.wait(window)
tasks.assert_not_called()
self.assertEqual(TASKS[0]["state"], "active")
finally:
window.close()
def test_account_views_share_static_data_without_mutating_it_or_loading_battles(self):
with workspace_temp() as folder:
first, second = gui.Window(folder / "one"), gui.Window(folder / "two")
first.timer.stop()
second.timer.stop()
try:
self.wait(first)
self.wait(second)
with patch("ranch_assistant.game_data.zipfile.ZipFile", side_effect=AssertionError("task UI must not load battle archives")):
first.refresh_progression()
self.wait(first)
second.refresh_progression()
self.wait(second)
data = first.engine.game_data
self.assertIsNotNone(data)
self.assertIs(data, second.engine.game_data)
original = repr(data.tasks)
self.assertIsNot(first.progression_views, second.progression_views)
self.assertIsNot(first.progression_views.tasks, second.progression_views.tasks)
if first.progression_views.tasks:
first.progression_views.tasks[0]["values"][2] = "account-one-only"
self.assertEqual(repr(data.tasks), original)
self.assertFalse(second.progression_views.tasks and second.progression_views.tasks[0]["values"][2] == "account-one-only")
finally:
first.close()
second.close()
def test_leaving_task_page_drops_its_queued_local_view(self):
with workspace_temp() as folder:
window = gui.Window(folder)
window.timer.stop()
release = threading.Event()
try:
self.wait(window)
_, tasks, records = self.mock_readers(window)
window.run_job("held_request", lambda: release.wait(4))
window.tabs.setCurrentWidget(window.progression_page)
self.assertTrue(window.pending_progression_view)
window.tabs.setCurrentWidget(window.automation_page)
self.assertFalse(window.pending_progression_view)
release.set()
self.wait(window)
tasks.assert_not_called()
records.assert_not_called()
finally:
release.set()
self.wait(window)
window.close()
def test_filters_details_unknown_support_and_records_contexts(self):
with workspace_temp() as folder:
window = gui.Window(folder)
window.timer.stop()
try:
self.wait(window)
self.mock_readers(window)
window.tabs.setCurrentWidget(window.progression_page)
self.wait(window, lambda: window.progression_table.rowCount() == 4)
for kind, expected in (("mainline", "主线测试"), ("sidequest", "支线测试"), ("commission", "委托测试"), ("unknown", "未知测试")):
window.progression_filter.setCurrentIndex(window.progression_filter.findData(kind))
self.wait(window, lambda: window.progression_table.rowCount() == 1)
self.assertEqual(window.progression_table.item(0, 2).text(), expected)
window.progression_table.selectRow(0)
if kind == "mainline":
detail = window.progression_detail.toPlainText()
for text in ("测试对话内容", "2 / 4", "地图0101", "等待对话"):
self.assertIn(text, detail)
elif kind == "sidequest":
self.assertIn("战斗运行时尚未支持", window.progression_detail.toPlainText())
elif kind == "unknown":
self.assertIn("支持状态未确认", window.progression_table.item(0, 9).text())
window.tabs.setCurrentWidget(window.battle_records_page)
self.wait(window, lambda: window.battle_records_table.rowCount() == 3)
for kind, label in (("sweep", "扫荡"), ("map_reward_event", "地图奖励事件"), ("task_battle", "任务战斗")):
window.battle_records_filter.setCurrentIndex(window.battle_records_filter.findData(kind))
self.wait(window, lambda: window.battle_records_table.rowCount() == 1)
self.assertEqual(window.battle_records_table.item(0, 1).text(), label)
finally:
window.close()
def test_refresh_and_step_use_worker_prepare_and_result_paths(self):
with workspace_temp() as folder:
window = gui.Window(folder)
window.timer.stop()
try:
self.wait(window)
threads, tasks, _ = self.mock_readers(window)
def refresh():
threads.append(C.QThread.currentThread())
return window.engine.snapshot, [], "离线任务刷新完成"
window.engine.refresh_progression = Mock(side_effect=refresh)
window.engine.run_progression_once = Mock(side_effect=refresh)
with patch.object(window, "run_job", wraps=window.run_job) as run_job:
window.refresh_progression()
self.wait(window)
self.assertEqual(run_job.call_args[0][0], "progression_refresh")
self.assertIsNotNone(window.progression_views)
self.assertEqual(tasks.call_count, 1)
self.assertIn("离线任务刷新完成", window.log.toPlainText())
window.run_progression_once()
window.engine.run_progression_once.assert_not_called()
window.progression_enabled.setChecked(True)
window.monitoring = True
window.set_strategy_checked(True)
window.run_progression_once()
self.wait(window)
self.assertEqual(run_job.call_args[0][0], "progression_run")
self.assertEqual(window.engine.run_progression_once.call_count, 1)
self.assertTrue(all(thread != self.app.thread() for thread in threads))
finally:
window.close()
def test_policy_changes_wait_for_serial_request_but_stop_cancels_immediately(self):
with workspace_temp() as folder:
window = gui.Window(folder)
window.timer.stop()
release = threading.Event()
entered = threading.Event()
try:
self.wait(window)
policy = window.engine.progression_policy
def held_request():
entered.set()
if not release.wait(4):
raise TimeoutError("test worker was not released")
window.engine.cancel_progression = Mock()
window.run_job("held_request", held_request)
self.assertTrue(entered.wait(1))
window.progression_enabled.setChecked(True)
window.progression_reserve_ti.setValue(77)
window.progression_battle_mode.setCurrentIndex(window.progression_battle_mode.findData("experimental"))
window.persist_settings()
self.assertIs(window.engine.progression_policy, policy)
self.assertIsNotNone(window.pending_policy)
window.stop_workflow()
window.engine.cancel_progression.assert_called_once_with()
self.assertTrue(window.busy)
release.set()
self.wait(window)
self.assertEqual(window.engine.progression_policy.reserve_ti, 77)
self.assertEqual(window.engine.progression_policy.battle_mode, "experimental")
self.assertFalse(window.engine.auto)
finally:
release.set()
self.wait(window)
window.close()
def test_stop_before_queued_step_starts_prevents_engine_entry(self):
with workspace_temp() as folder:
window = gui.Window(folder)
window.timer.stop()
try:
self.wait(window)
window.progression_enabled.setChecked(True)
window.monitoring = True
window.set_strategy_checked(True)
window.engine.run_progression_once = Mock()
queued = []
with patch.object(window.pool, "start", side_effect=queued.append):
window.run_progression_once()
self.assertEqual(len(queued), 1)
self.assertTrue(window.busy)
window.stop_workflow()
window.pool.start(queued[0])
self.wait(window)
window.engine.run_progression_once.assert_not_called()
self.assertIn("未开始执行", window.log.toPlainText())
self.assertFalse(window.engine.auto)
finally:
window.close()
def test_bad_task_contract_errors_are_reported(self):
engine = Mock()
engine.progression_rows.return_value = [{"task_type_id": "ok"}, None]
engine.progression_records.return_value = []
with self.assertRaisesRegex(TypeError, r"progression_rows\(\)"):
prepare_progression_views(engine)
def test_journal_timestamps_use_beijing_and_preserve_original_records(self):
source = [
{"kind": "battle", "task_id": 12, "battle_kind": "passStage", "started_at": 1700000000, "finished_at": 1700000010},
{"kind": "battle", "battle_kind": "ordinary_stage", "started_at": 1700000000, "outcome": "event"},
{"kind": "sweep", "battle_kind": "normal", "started_at": 1700000000},
]
original = copy.deepcopy(source)
engine = SimpleNamespace(snapshot=object(), progression_rows=lambda: TASKS, progression_records=lambda: source)
views = prepare_progression_views(engine)
self.assertEqual(views.records[0]["values"][0], "2023-11-15 06:13:30")
self.assertEqual(views.records[1]["values"][0], "2023-11-15 06:13:20")
self.assertEqual([row["category"] for row in views.records], ["task_pass_stage", "map_reward_event", "sweep"])
self.assertEqual(source, original)
def test_experimental_record_outcomes_keep_their_approximate_label(self):
records = [
{"battle_mode": "experimental", "faithful": False, "approximate": True, "outcome": "win"},
{"battle_mode": "original", "outcome": "win"},
{"outcome": "win"},
]
engine = SimpleNamespace(snapshot=object(), progression_rows=lambda: [], progression_records=lambda: records)
rows = prepare_progression_views(engine).records
self.assertIn("实验近似", rows[0]["values"][4])
self.assertIn("近似,未完整验证", rows[0]["detail"])
self.assertEqual(rows[1]["values"][4], "胜利")
self.assertIn("原版运行时", rows[1]["detail"])
self.assertIn("记录未标明", rows[2]["detail"])
self.assertEqual(records[0]["outcome"], "win")
def test_repeated_sorted_table_updates_do_not_reinsert_owned_items(self):
table = CachedTable(["编号", "名称"])
messages = []
previous = C.qInstallMessageHandler(lambda level, context, message: messages.append(message))
try:
for count in (80, 4, 35, 80):
rows = [{"key": str(i), "values": [str(i), "name " + str(i)], "detail": str(i)} for i in range(count)]
table.set_rows(rows)
deadline = time.monotonic() + 2
while table.row_batch.running and time.monotonic() < deadline:
self.app.processEvents()
QTest.qWait(2)
self.assertFalse(table.row_batch.running)
table.sortItems(0, C.Qt.SortOrder.DescendingOrder)
self.assertEqual(table.rowCount(), count)
self.assertEqual(table.item(0, 0).text(), str(count - 1))
self.assertFalse(any("already owned" in message.lower() or "cannot insert" in message.lower() for message in messages), messages)
finally:
C.qInstallMessageHandler(previous)
table.row_batch.stop()
table.deleteLater()
if __name__ == "__main__":
unittest.main()
@@ -11,6 +11,7 @@ from PySide6 import QtCore as C, QtWidgets as W
from PySide6.QtTest import QTest
from ranch_assistant.gui import Window
from ranch_assistant import presentation
from ranch_assistant.engine import demo_snapshot
from ranch_assistant.engine import Engine
from ranch_assistant.api import Client, Session, encode
@@ -62,6 +63,134 @@ class ResponsivenessTests(unittest.TestCase):
finally:
window.close()
def test_hidden_account_skips_worker_monster_preparation_and_prepares_on_show(self):
with workspace_temp() as folder:
window = Window(folder)
window.timer.stop()
try:
self.wait(window)
snapshot = demo_snapshot(window.catalog)
template = snapshot.raw["monsters"][-1]
snapshot.raw["monsters"] = [copy.deepcopy(template) | {"id": 1000 + i} for i in range(500)]
window.set_presentation_active(False)
window.tabs.setCurrentWidget(window.monster_page)
window.engine.poll = lambda **kwargs: (snapshot, [], "fixture poll")
threads = []
build = presentation.monster_rows
def record_build(*args, **kwargs):
threads.append(threading.get_ident())
return build(*args, **kwargs)
with patch.object(presentation, "monster_rows", side_effect=record_build) as preparing, patch("ranch_assistant.gui.monster_rows", side_effect=AssertionError("GUI thread monster fallback")):
window.refresh()
self.wait(window)
self.assertEqual(preparing.call_count, 0, "hidden account formatted monster rows")
window.set_presentation_active(True)
for _ in range(600):
self.app.processEvents()
QTest.qWait(5)
if not window.busy and len(window.monsters.monster_items) == 500:
break
self.assertEqual(len(window.monsters.monster_items), 500)
self.assertTrue(threads)
self.assertTrue(all(tid != threading.get_ident() for tid in threads))
self.assertTrue(window.engine.presentation_active)
finally:
self.wait(window)
window.close()
def test_visible_other_page_skips_monster_preparation_on_poll(self):
with workspace_temp() as folder:
window = Window(folder)
window.timer.stop()
try:
self.wait(window)
window.tabs.setCurrentIndex(0)
with patch.object(presentation, "monster_rows", wraps=presentation.monster_rows) as preparing:
window.refresh()
self.wait(window)
self.assertEqual(preparing.call_count, 0, "another page formatted monster rows")
finally:
window.close()
def test_warm_monster_view_finishes_preparation_when_unchanged_after_show(self):
with workspace_temp() as folder:
window = Window(folder)
window.timer.stop()
try:
self.wait(window)
window.tabs.setCurrentWidget(window.monster_page)
for _ in range(500):
self.app.processEvents()
QTest.qWait(2)
if not window.busy and not window.monster_render_timer.running:
break
original = dict(window.monsters.monster_items)
self.assertTrue(original)
window.set_presentation_active(False)
self.assertIsNone(window.prepared_views.monsters)
window.set_presentation_active(True)
for _ in range(500):
self.app.processEvents()
QTest.qWait(2)
if not window.busy and not window.monster_render_timer.running:
break
self.assertFalse(window.busy)
self.assertFalse(window.monster_render_timer.running)
self.assertEqual(window.monsters.monster_items, original)
finally:
self.wait(window)
window.close()
def test_prepare_views_default_stays_complete_and_opt_out_marks_monsters_dirty(self):
with workspace_temp() as folder:
window = Window(folder)
window.timer.stop()
try:
self.wait(window)
snapshot = window.engine.snapshot
with patch.object(presentation, "monster_rows", wraps=presentation.monster_rows) as preparing:
full = presentation.prepare_views(window.catalog, snapshot, set())
self.assertEqual(preparing.call_count, 1)
thin = presentation.prepare_views(window.catalog, snapshot, set(), include_monsters=False)
self.assertEqual(preparing.call_count, 1)
self.assertEqual(len(full.monsters), len(snapshot.raw["monsters"]))
self.assertEqual(full.monster_source, repr(snapshot.raw["monsters"]))
self.assertIsNone(thin.monsters)
self.assertIsNone(thin.monster_source)
self.assertIsInstance(full.maps, list)
self.assertIsInstance(thin.maps, list)
finally:
window.close()
def test_hidden_connection_sets_engine_visibility_before_first_plan(self):
from ranch_assistant.model import Snapshot
from ranch_assistant.tests.test_accounts import fake_client, role_snapshot
with workspace_temp() as folder:
window = Window(folder)
window.timer.stop()
try:
self.wait(window)
window.set_presentation_active(False)
previous = window.engine
session = Session("http://127.0.0.1/fixture/", "fixture-token", account_id="fixture", server_id=1, role_id=101)
client = fake_client(session, window.catalog, [])
window.result("connected", (client, Snapshot(role_snapshot(window.catalog, 101))))
engine = window.engine
self.assertIsNot(engine, previous)
self.assertFalse(engine.presentation_active)
self.assertFalse(engine.progression_view_active)
observed = []
def plan():
observed.append((engine.presentation_active, threading.get_ident()))
return []
with patch.object(engine, "plans", side_effect=plan):
window.preview_cultivation()
self.wait(window)
self.assertEqual([active for active, _ in observed], [False])
self.assertTrue(all(tid != threading.get_ident() for _, tid in observed))
finally:
window.close()
def test_unchanged_maps_reuse_controls_and_keep_edits(self):
with workspace_temp() as folder:
window = Window(folder)
@@ -194,6 +194,7 @@ class ManualGuiTests(unittest.TestCase):
self.assertEqual(window.eggs.item(row, 2).text(), "0")
self.assertTrue(window.eggs.cellWidget(row, 3).isChecked())
window.tabs.setCurrentWidget(window.monster_page)
self.wait(window)
item = window.monsters.monster_items[900]
window.monsters.itemWidget(item, 8).setChecked(True)
window.monsters.itemWidget(item, 9).setValue(1)
@@ -276,6 +277,7 @@ class ManualGuiTests(unittest.TestCase):
self.wait(window)
def select(mid):
window.tabs.setCurrentWidget(window.monster_page)
self.wait(window)
window.monsters.clearSelection()
window.monsters.setCurrentItem(window.monsters.monster_items[mid])
select(101)