Improve task filters, exploration rewards and V4 battle simulation

This commit is contained in:
AttilaNet
2026-11-10 14:09:53 +08:00
parent 5082c2df5c
commit 6d74730735
20 changed files with 1129 additions and 42 deletions
+11 -11
View File
@@ -1,7 +1,7 @@
# 牧羊人之心牧场辅助
原生 PySide6 窗口,使用 Qt 默认控件。双击项目根目录的
`Start_Ranch_Helper.cmd` 启动。当前开发版本为 **1.2.0.dev1**,资料基线为游戏 **1.9.68**;最近正式版本为 **1.1.1**。497项常规回归已检查并完成失败项复测,原版运行时最终集成与真实账号验证仍待完成,自动原版开战准入保持关闭。
`Start_Ranch_Helper.cmd` 启动。当前开发版本为 **1.2.0.dev1**,资料基线为游戏 **1.9.68**;最近正式版本为 **1.1.1**。56个模块隔离测试共724项通过、0项跳过;单进程整套Qt测试曾出现崩溃,本轮采用逐模块独立进程验证。原版运行时最终集成与真实账号验证仍待完成,当前桌面自动战斗使用我方对敌最终伤害10倍、单次最高50000的内置模拟。
首次运行请先执行 `python -m pip install -r ranch_assistant/requirements.txt`。
完整功能与版本摘要见[项目README](../README.md)。
@@ -46,11 +46,11 @@
跨账号按魔物种类匹配喂养、赠礼和突破目标;探险队伍按队序重新绑定,手动队员按种类匹配且不复用原账号实例ID。探险总开关导入后关闭,顶部策略执行开关保持关闭,其余功能按原导入保留勾选。隐藏页不会裁剪规则,兼容旧版培养策略文件。
- 牧场保留与自动突破:“背包 → 魔物蛋”中每种蛋的“牧场保留”默认1,是最低保留数量,0关闭数量保护;同种数量跨牧场及孵化批次统一保底。锁定、星级/资质保护仍可超过数量,“更好资质额外保留”会额外保留,不自动解锁旧只或强行派遣。普通等级上限、同种突破(最高4级、每只同种素材+1突破经验)与潜能阶段是三种独立进度。
勾选“自动突破目标”即授权先补满四项潜能、再提升潜能阶段,消耗对应元素材料并沿用物品/委托保留量,不购买材料、不花金币或氪金。未勾选目标时不规划或输出突破提示。
- 自动探险:独立页签,默认关闭,每队配置开关、地区、三只手动队员或自动选人及保留体力;先领奖再出发,不花钱开队或召回。未解锁只显示原因,不阻断牧场等其他自动化;未确认的请求保留在角色本地状态中,新快照确认前禁止重发,停止后的刷新只读不写。
- 自动探险:顶部策略开启后自动领取已完成队伍的奖励,不要求勾选再次出发。“自动安排再次探险”默认关闭,每队配置开关、地区、三只手动队员或自动选人及保留体力;先领奖确认队伍空闲,再按配置出发,不花钱开队或召回。未解锁不阻断牧场等其他自动化;未确认的请求保留在角色本地状态中,新快照确认前禁止重发,顶部停止后的刷新只读不写。
导入保留功能勾选和规则,策略开关保持关闭,核对后手动开启;文件不包含账号、密码、Token、会话或本机路径。
- 自动赠礼:独立页签,在背包勾选可用物品,在牧场勾选目标并设置优先级,再到“自动赠礼”启用。
每次消耗一件物品,默认只使用目标喜欢的物品;遵守当前羁绊好感上限、赠礼间隔、物品保留数量及委托保留。
勾选“每种魔物只培养一只,自动选择培养代表”后,自动为牧场中的每种魔物选一只,按等级 → 好感 → 综合成长资质排序,无需逐只勾选。
勾选“每种魔物只培养一只,自动选择培养代表”后,自动为牧场中的每种魔物选一只,按等级 → 好感 → 综合成长资质排序,无需逐只勾选。牧场中的“喂养目标”只控制经验喂养,和赠礼无关;若只想给手动勾选的魔物赠礼,关闭自动选择代表,再在牧场右侧“赠礼”列选择目标。
综合资质相同再比较四项成长;各项均相同时随机选定并按账号/角色记住。列表显示代表的ID、等级、好感和资质,“刷新 / 预览培养对象”可更新预览。
同种代表满好感或冷却时不改喂同种其他魔物;可继续处理其他种类。自动模式下代表会受自动派遣/喂养保护,手动模式保留原有目标优先级。
手动目标也会逐只判断,前一只冷却不会挡住后面的可赠礼目标;可送目标按账号顺序连续处理,无需等待整体随机刷新。
@@ -92,15 +92,15 @@
## v1.2 自动主线与战斗设置
本节对应 **1.2.0.dev1 开发版**。任务调度和界面已实现,原版与实验模式均有局部能力限制;完整集成 QA、实际阵容的原 AIR 输入桥接和真实账号验收尚未完成。
本节对应 **1.2.0.dev1 开发版**。任务调度和界面已实现,桌面 GUI 隐藏运行时选择并强制使用实验模拟,存在局部能力限制;完整集成 QA、实际阵容的原 AIR 输入桥接和真实账号验收尚未完成。
1. 登录或恢复当前角色后,进入“自动主线”,点击“刷新任务 / 预览”。“任务状态”显示类别、步骤、目标位置、需求、下一步和支持状态;选择一行可查看 NPC、对话与阻塞原因。刷新用于同步与预览,不执行任务交付或开战。
1. 登录或恢复当前角色后,进入“自动主线”,点击“刷新任务 / 预览”。“任务状态”默认只显示当前进行中、待接取及待领奖的主线任务;类别、状态和关键词可组合筛选,需要查看未解锁或已完成任务时再切换状态。当前受阻的任务仍会显示原因;选择一行可查看步骤、目标位置、NPC、需求和对话。筛选在本地完成,刷新用于同步与预览,不执行任务交付或开战。
2. 打开“推进策略”,选择主线或支线、自动接取、已支持对话和补链选项。需要补齐材料、蛋或击杀时,勾选“自动收集任务材料 / 击杀目标”;来源必须符合当前位置、地图解锁、资源保护及运行时能力。
3. 任务和委托统一使用内置模拟,无需选择运行时;保留原始属性,计算战斗过程并等待相应时长后再提交。选择推进战斗队伍,设置保留体力、单次交付金币上限、物品保留量和连续失败停止次数。物品、魔物交付默认关闭,金币上限默认 0。
3. 任务和委托统一使用内置模拟,无需选择运行时;角色属性保持原值,按已用修改客户端的规则将我方打敌方的最终伤害乘10、单次最高50000,计算战斗过程并等待相应时长后再提交。选择推进战斗队伍,设置保留体力、单次交付金币上限、物品保留量和连续失败停止次数。物品、魔物交付默认关闭,金币上限默认 0。
4. 委托仍在“自动委托”单独配置启用、接取、城市、交付限制及“也接取需要实战的委托”。按奖励氪金20→15→10优先接取可处理的委托,已有委托优先完成,委托步骤及材料补缺优先于普通孵蛋、赠礼、主线和刷图。缺少材料时自动选择已支持的扫荡/挑战来源,并遵守保留设置;已有足够库存则直接交付。按委托缺口买蛋、孵化、交付的完整联动尚待实现。
委托自动执行只需启用“自动委托”及顶部绿色“开启”,下一轮状态刷新会检查接取和完成条件,无需启用自动主线。接取前会逐份检查实际战斗能力;高奖励委托无法完成时继续检查其他同奖励或较低奖励的委托。表格“需求 / 进度”以中文显示暂不接取或等待条件的原因。勾选允许提交道具、魔物及实战表示允许这些操作,不能使尚未实现的战斗机制或买蛋孵化联动自动变为可用。
5. 勾选“启用自动主线策略”,再点击顶部绿色“开启”。修改规则会自动保存并应用;菜单“策略配置”可立即保存、导入或导出当前账号规则,包含任务策略与战斗模式。重启、恢复会话和导入后,顶部策略开关保持关闭,核对后再开启。
5. 勾选“启用自动主线策略”,再点击顶部绿色“开启”。修改规则会自动保存并应用;菜单“策略配置”可立即保存、导入或导出当前账号规则,包含任务策略,战斗固定为实验模拟。重启、恢复会话和导入后,顶部策略开关保持关闭,核对后再开启。
6. 在“战斗记录”查看上下文、队伍、胜负和原因;“刷新本地记录”只读取本机记录。点击顶部红色“停止”可取消后续推进和可取消的运行/时钟等待;已经发出的请求仍须等待确认,开战后的未知状态会保留待核对记录。
有待核对记录时,后台最长每2分钟刷新服务器状态,无需手动核对。若是模型已完成、仅等待战斗时长时被中断,开启对应策略后会自动续交原先保存的胜利结果,保持同一任务实例与步骤,不重新发起入场请求或模拟;旧版记录也可恢复。关闭策略时只查询状态,不续交。结算请求已发出但结果未知时只自动查询,不重复发送;没有足够服务器证据时仍会显示等待原因。
@@ -112,7 +112,7 @@
| 扫荡 | 普通、非特殊、无当前任务截获的关卡,三个难度全部通关后才可扫荡。“允许用扫荡完成已通关目标”受此条件限制;任务专属战斗和任务通关战斗仍走各自任务路线。逐关次数与难度在“自动扫荡”配置。 |
| 地图奖励事件 | 普通地图开始时若已经发放探索奖励,单独记录奖励并刷新;该分支不运行战斗,也不重复提交战斗奖励。隐藏战斗重新检查能力,未知事件保留待处理。 |
| 原版内核研究工具 | 保留原 AIR 离线验证工具,不再要求桌面用户选择;最终原版集成尚待完成。 |
| 内置模拟 | 独立进程使用原始数值资料计算 AP、出场、移动、攻击及技能 3、5、7、9、38 的部分机制,保留轨迹、胜负和异常,并等待计算出的战斗时长。物理、随机、时序、装备及其他技能存在近似或遗漏,结果可能与原版不同。任务1002002所需的纯显示 `buffMovie` 控制器已支持。 |
| 内置模拟 | 独立进程使用原始属性资料计算 AP、出场、移动、攻击及技能 3、5、7、9、38 的部分机制;桌面模拟将我方打敌方的最终伤害乘10、单次最高50000。保留轨迹、胜负和异常,并等待计算出的战斗时长。物理、随机、时序、装备及其他技能存在近似或遗漏,结果可能与客户端不同。任务1002002所需的纯显示 `buffMovie` 控制器已支持。 |
任务资料包含 1165 个任务、1178 个关卡、337 个 NPC 和 4269 份脚本;4239 份属于已支持的线性脚本,主线引用中为 718/720。这些是资料与脚本分类数量,不是整条主线通关率。30 份特殊选择等脚本(含 2 份主线)、4 类特殊接取入口、任务1001006第4步的特殊抽蛋钩子尚不支持;活动、羁绊和未知任务类别也不承诺自动推进。
@@ -122,7 +122,7 @@
看到“待核对”“不支持”或资源不足时,先查看任务详情和战斗记录中的具体原因。请求结果不明时,本账号的牧场、赠礼及任务等冲突写操作会暂停;重启不会清除待核对状态。恢复角色后点击“刷新任务 / 预览”,程序只在新的角色/任务状态足以证明结果时解除阻塞,随后可继续已保存的普通剧情检查点;证据不足时仍等待用户在游戏内核实。不要通过删除记录或反复开启来重发未知请求,策略导入也不能覆盖服务器通关进度或解除未知结算。
任务与战斗记录保存在本账号、区服和角色的本地工作区;规则导出不含凭据、任务执行记录、待核对日志或服务器进度。实现边界、验证记录和接口分流另见[v1.2 实施与阶段交接](../analysis/V1_2_IMPLEMENTATION.md)。
任务与战斗记录保存在本账号、区服和角色的本地工作区;规则导出不含凭据、任务执行记录、待核对日志或服务器进度。逐项实测入口和结果模板见[v1.2 当前开发版验收清单](../analysis/V1_2_ACCEPTANCE_CHECKLIST.md),实现边界、验证记录和接口分流另见[v1.2 实施与阶段交接](../analysis/V1_2_IMPLEMENTATION.md)。
## 连接真实角色
@@ -301,13 +301,13 @@
“自动委托”需单独启用;可先关闭“自动孵蛋”的自动管理,只运行委托。
道具和魔物提交默认关闭,金币提交上限默认 0;锁定、队伍、高星和高资质保护继续生效。
已接委托需要的魔物种类和蛋会纳入牧场保留。
“也接取需要实战的委托”允许经检查后接取实战委托;已支持的剧情、交付和专用战斗通过任务调度继续推进。战斗模式与队伍在“自动主线 → 推进策略”选择,委托资源限制仍由本页配置。当前默认原版模式的实际阵容桥接尚待完成,不应把这个开关视为所有委托均已可用。
“也接取需要实战的委托”允许经检查后接取实战委托;已支持的剧情、交付和专用战斗通过任务调度继续推进。队伍在“自动主线 → 推进策略”选择,战斗固定为实验模拟,委托资源限制仍由本页配置。实际阵容桥接和真实账号验收尚待完成,不应把这个开关视为所有委托均已可用。
普通、非剧情定位关卡的三个难度全部通关后才开放扫荡,无需本地战斗演算或手机截图。首次挑战、任务专属战斗与扫荡分别处理,当前可执行范围见上方能力表。客户端调用链与字段证据见[地图及每日事务研究](../analysis/STAGES_DAILY.md)和[战斗路线说明](../analysis/V1_2_IMPLEMENTATION.md#调度与恢复约定)。
在“自动扫荡”展开地区,每关勾选“刷图”、选择已解锁的难度、输入“本日上限”,勾选该页功能,再开启顶部策略开关。需要挑战未通关普通关卡时保留“未满星时自动挑战”勾选;关闭后只执行符合条件的扫荡,无需开启自动主线。
挑战沿用原始属性和内置模拟,等待计算出的战斗时长后按普通关卡流程结算,战果与奖励在“战斗记录”查看。实际战败显示“打不过”,本日内相同阵容及属性不会反复尝试该难度;更换战队、升级或属性变化后允许再试。每日次数与扫荡共用,开战前占用次数,确定未发送的取消会退回次数;未知回包不重复请求。暂停或重启后可续交已完成并保存的模型结果,保持原始开战和每日计数。地图列表保存在本地,普通轮询不重建;挑战已确认结束后同步账号实际通关进度。
挑战沿用原始属性,按我方对敌最终伤害10倍、单次最高50000的内置模拟计算,等待战斗时长后按普通关卡流程结算,战果与奖励在“战斗记录”查看。实际战败显示“打不过”,本日内相同阵容、属性及伤害规则不会反复尝试该难度;更换战队、升级、属性或伤害规则变化后允许再试。每日次数与扫荡共用,开战前占用次数,确定未发送的取消会退回次数;未知回包不重复请求。暂停或重启后可续交已完成并保存的模型结果,保持原始开战和每日计数。地图列表保存在本地,普通轮询不重建;挑战已确认结束后同步账号实际通关进度。
星级是服务器通关进度计算出来的,只读。未解锁难度不能选;其他特殊关卡、未全通关、剧情任务、
体力/金币/门票不足的关卡会显示原因并跳过。次数按角色、日期、关卡和难度保存,
是本地已开始次数,不冒充服务器每日限制。
+7
View File
@@ -8,6 +8,12 @@ from .sweeping import SweepPolicy
from .table_widgets import SORT_ROLE, TreeItem, bind_controls, set_value, table_item
class ElideRightDelegate(W.QStyledItemDelegate):
def initStyleOption(self, option, index):
super().initStyleOption(option, index)
option.textElideMode = C.Qt.TextElideMode.ElideRight
def number(value, maximum=9999):
widget = IntegerInput()
widget.setRange(0, maximum)
@@ -106,6 +112,7 @@ class ActivityPages:
self.maps_tree.setHeaderLabels(["刷图", "关卡", "名称", "难度", "星级", "扫荡 / 挑战状态", "体力 / 门票:单次 / 可用 / 保留", "可能掉落", "本日上限", "本日已开始"])
self.maps_tree.setAlternatingRowColors(True)
self.maps_tree.setTextElideMode(C.Qt.TextElideMode.ElideNone)
self.maps_tree.setItemDelegateForColumn(7, ElideRightDelegate(self.maps_tree))
self.maps_tree.setUniformRowHeights(False)
self.maps_tree.setEditTriggers(W.QAbstractItemView.EditTrigger.NoEditTriggers)
self.maps_tree.itemChanged.connect(self.map_item_changed)
+43 -1
View File
@@ -30,6 +30,8 @@ FPS = 50 # Original MYRMain.app SWF header: 50 fps.
MAX_TRACE = 10000
MAX_UNITS = 1024
MAX_WIRE_BYTES = 16 * 1024 * 1024
DEFAULT_DAMAGE_PROFILE = "original_1x"
DESKTOP_DAMAGE_PROFILE = "client_v4_x10"
LIMITATIONS = (
"Experimental fixed clock: not validated against original AIR battle trajectories.",
"Straight-line ground movement; collision, inertia, flight height and animation joins are approximated.",
@@ -75,6 +77,15 @@ def _freeze(value):
return value
DAMAGE_PROFILES = _freeze({
DEFAULT_DAMAGE_PROFILE: {"multiplier": 1, "cap": None},
DESKTOP_DAMAGE_PROFILE: {"multiplier": 10, "cap": 50000},
})
DAMAGE_PROFILE_DIGESTS = _freeze({name: hashlib.sha256(json.dumps(
{"name": name, **config}, sort_keys=True, separators=(",", ":")).encode("ascii")).hexdigest()
for name, config in DAMAGE_PROFILES.items()})
def _plain(value):
if isinstance(value, Mapping):
return {str(k): _plain(v) for k, v in value.items()}
@@ -83,6 +94,20 @@ def _plain(value):
return value
def _damage_profile(request):
name = _get(request, "damage_profile", DEFAULT_DAMAGE_PROFILE)
if not isinstance(name, str) or name not in DAMAGE_PROFILES:
raise SimulationInputError("Unknown damage profile")
return name, DAMAGE_PROFILES[name]
def _damage_profile_report(name, config):
return {"damage_profile": name, "damage_multiplier": config["multiplier"],
"damage_cap": config["cap"], "damage_profile_digest": DAMAGE_PROFILE_DIGESTS[name],
"damage_profile_scope": "team1 attacker to team2 target, after hurt controllers and before HP deduction"
if name == DESKTOP_DAMAGE_PROFILE else "unchanged original final damage"}
def _position(value):
if value is None:
return None
@@ -408,6 +433,8 @@ def _prepare(request, tables):
report["reasons"].append(message)
try:
profile_name, profile_config = _damage_profile(request)
report.update(_damage_profile_report(profile_name, profile_config))
if _get(request, "context") not in CONTEXTS:
raise SimulationInputError("Context must be ordinary_stage, task_battle or task_pass_stage")
original = _get(request, "original_data", {})
@@ -651,6 +678,8 @@ class _Battle:
def __init__(self, scenario, report, tables):
self.s = scenario
self.report = report
self.damage_profile = report["damage_profile"]
self.damage_config = DAMAGE_PROFILES[self.damage_profile]
self.tables = tables
self.game = tables["game_setting"]
self.rng = random.Random(scenario.seed)
@@ -684,6 +713,9 @@ class _Battle:
def event(self, kind, **fields):
record = {"at_ms": self.now, "type": kind, **fields}
if kind == "damage":
record.update(damage_profile=self.damage_profile,
damage_cap=self.damage_config["cap"])
if len(self.events) < self.s.trace_limit:
self.events.append(record)
else:
@@ -923,6 +955,7 @@ class _Battle:
amount = int(amount * actor.unit.hurt_types[str(attacker.unit.species)])
if real_attack:
amount = max(0, int(amount * (1 - actor.unit.stats.damage_reduction)))
amount = self.final_damage(amount, attacker, actor)
lost = min(actor.hp, amount)
actor.hp -= lost
actor.total_hurt += amount
@@ -940,6 +973,7 @@ class _Battle:
self.finish_death(actor)
return amount
amount = max(0, int(int(amount) * (1 - actor.unit.stats.damage_reduction)))
amount = self.final_damage(amount, attacker, actor)
lost = min(actor.hp, amount)
actor.hp -= lost
actor.total_hurt += amount
@@ -957,6 +991,13 @@ class _Battle:
self.finish_death(actor)
return amount
def final_damage(self, amount, attacker, actor):
"""V4's insertion: after every existing modifier, immediately before HP loss."""
if (self.damage_profile == DESKTOP_DAMAGE_PROFILE and attacker is not None
and attacker.unit.team == 1 and actor.unit.team == 2):
return int(min(amount * self.damage_config["multiplier"], self.damage_config["cap"]))
return amount
def finish_death(self, actor):
actor.state = "dead"
actor.died_ms = self.now
@@ -1278,7 +1319,8 @@ def _transport_request(request):
raw["master"] = {k: v for k, v in raw["master"].items()
if k in ("level", "globalAtk", "globalDef", "globalHp", "globalDex")}
original = _get(request, "original_data", {})
return {"context": _get(request, "context"), "original_data": {"battle": _plain(_get(original, "battle"))},
return {"context": _get(request, "context"), "damage_profile": _damage_profile(request)[0],
"original_data": {"battle": _plain(_get(original, "battle"))},
"roster": raw, "team": _get(request, "team", "teamA"),
"seed": _get(request, "seed", 0), "trace_limit": _get(request, "trace_limit", 2000),
"battle_position": _position(_get(request, "battle_position"))}
+2 -1
View File
@@ -426,7 +426,8 @@ class BattleOrchestrator:
"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")}}
"ignored_mechanics", "anomalies", "assumptions", "experimental_eligibility_reasons", "omitted_events",
"damage_profile", "damage_multiplier", "damage_cap", "damage_profile_digest", "damage_profile_scope")}}
trace = value(result, "trace")
if trace is None:
trace = value(result, "events")
+8 -2
View File
@@ -559,6 +559,7 @@ class Engine:
def _battle_capability(self, intent):
try:
from .battle_simulator import DEFAULT_DAMAGE_PROFILE, DESKTOP_DAMAGE_PROFILE
if self._is_commission(intent) and not self.quest_policy.battle_tasks:
return False, "战斗委托未启用;未开始战斗"
if self.battles.runtime is None:
@@ -569,7 +570,9 @@ class Engine:
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,
damage_profile = DESKTOP_DAMAGE_PROFILE if policy.battle_mode == "experimental" else DEFAULT_DAMAGE_PROFILE
key = digest({"snapshot": self._battle_snapshot_digest, "runtime": id(self.battles.runtime), "team": policy.team,
"mode": policy.battle_mode, "damage_profile": damage_profile,
**{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)
@@ -626,6 +629,7 @@ class Engine:
return rows, adjusted
def _battle_request(self, snapshot, intent, policy, request):
from .battle_simulator import DEFAULT_DAMAGE_PROFILE, DESKTOP_DAMAGE_PROFILE
self._ensure_progression()
self._select_battle_runtime(policy.battle_mode)
if self._battle_snapshot_source is not snapshot:
@@ -640,6 +644,7 @@ class Engine:
self.game_data.stage_battle(value(intent, "stage_id"), value(intent, "difficulty", "1"))
prepared = request | {"snapshot": self._battle_roster,
"battle_mode": policy.battle_mode,
"damage_profile": DESKTOP_DAMAGE_PROFILE if policy.battle_mode == "experimental" else DEFAULT_DAMAGE_PROFILE,
"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"),
@@ -1195,11 +1200,12 @@ class Engine:
stop_after_loss=0, battle_mode="experimental")
def _map_roster_signature(self, snapshot, team):
from .battle_simulator import DESKTOP_DAMAGE_PROFILE
selected = next((row for row in snapshot.raw.get("teams", []) if row.get("teamName") == team
and row.get("teamType") == "battleTeam"), {})
ids = {int(mid) for mid in selected.get("monsters", []) if mid and int(mid) > 0}
transient = {"exp", "timeStart", "nicName", "roomId"}
return digest({"team": selected,
return digest({"team": selected, "damage_profile": DESKTOP_DAMAGE_PROFILE,
"master": {key: val for key, val in snapshot.raw["master"].items() if key == "level" or key.startswith("global")},
"monsters": sorted([{key: val for key, val in mon.items() if key not in transient}
for mon in snapshot.raw.get("monsters", []) if int(mon["id"]) in ids], key=lambda mon: int(mon["id"])),
+6 -4
View File
@@ -614,17 +614,19 @@ class ExplorePlanner:
if account["pending"]:
return [self._blocked(account["pending"])]
self._issued.pop(scope, None)
if not policy.enabled:
return []
if not self.open(snapshot):
return [Action("explore_blocked", "探险功能尚未解锁", "", {})]
teams = [team for team in snapshot.raw.get("exploreTeams") or [] if isinstance(team, dict)]
# The host's global automation switch authorizes reward claims.
# This policy's global/per-team switches only authorize a restart.
for team in teams:
team_id = _integer(team.get("id"), -1)
if (team_id > 0 and _integer(team.get("status")) == 1
and self.remaining(snapshot, team) == 0):
return [self._issue(scope, Action("explore_finish", f"领取探险队 {team_id} 的奖励",
"exploreService/finish", {"exploreTeamId": team_id}))]
if not policy.enabled:
return []
if not self.open(snapshot):
return [Action("explore_blocked", "探险功能尚未解锁", "", {})]
stamina = _integer((snapshot.raw.get("master") or {}).get("ti"))
occupied = self._occupied(snapshot)
for team in teams:
+2 -1
View File
@@ -191,7 +191,8 @@ class ExplorationPages:
self.exploration_page = W.QWidget()
layout = W.QVBoxLayout(self.exploration_page)
tools = W.QHBoxLayout()
self.explore_enabled = W.QCheckBox("启用自动探险")
self.explore_enabled = W.QCheckBox("自动安排再次探险(完成后自动领奖)")
self.explore_enabled.setToolTip("仅控制完成领奖后是否重新出发;顶部策略停止时不会自动领奖或再次探险。")
self.explore_reserve_ti = IntegerInput()
self.explore_reserve_ti.setRange(0, 1_000_000_000)
self.explore_refresh_button = W.QPushButton("刷新探险状态")
+16 -5
View File
@@ -289,7 +289,11 @@ class Window(ExplorationPages, ProgressionPages, ActivityPages, W.QMainWindow):
self.monster_selection = W.QLabel("选择魔物后可锁定 / 解锁,也可右键操作")
self.monster_view = combo([("按牧场分组", 1), ("全部魔物", 0)])
self.monster_room = combo([("全部牧场", 0)])
for widget in (self.monster_view, self.monster_room, self.lock_monsters, self.unlock_monsters, self.monster_selection):
self.breakthrough_settings = W.QPushButton("潜能突破设置")
self.breakthrough_settings.setToolTip("定位当前魔物的自动突破目标和优先级;使用材料补满四项潜能再提升阶段,不是同种喂养突破。")
self.breakthrough_settings.clicked.connect(self.monsters.reveal_breakthrough)
for widget in (self.monster_view, self.monster_room, self.lock_monsters, self.unlock_monsters,
self.breakthrough_settings, self.monster_selection):
monster_tools.addWidget(widget)
for label, currency in (("新建牧场(金币)", "money"), ("新建牧场(氪金)", "ke")):
button = W.QPushButton(label)
@@ -1592,7 +1596,7 @@ class Window(ExplorationPages, ProgressionPages, ActivityPages, W.QMainWindow):
if self.busy or not self.monitoring or not self.strategy_toggle.isChecked() or not self.engine.snapshot:
return
now = time.monotonic()
if now >= self.next_explore and self.explore_enabled.isChecked():
if now >= self.next_explore:
self.run_fast_automation("explore")
elif now >= self.next_breakthrough and self.breakthrough_targets:
self.run_fast_automation("breakthrough")
@@ -1615,13 +1619,20 @@ class Window(ExplorationPages, ProgressionPages, ActivityPages, W.QMainWindow):
def arm_extended_automation(self):
active = self.monitoring and self.strategy_toggle.isChecked() and not self.closed and self.engine.snapshot is not None
plans = self.latest_render[1] if self.latest_render else []
explore_ready = active and self.explore_enabled.isChecked() and any(
action.kind in ("explore_start", "explore_finish") and action.path for action in plans)
# Pending writes use the existing reconciliation cadence. In particular,
# a completed team must not keep a one-second claim loop alive while a
# finish or task/battle request is unresolved.
pending = active and (self.engine.explore_planner.pending(self.engine.snapshot)
or self.engine._progression_pending() or self.engine._breakthrough_pending)
if pending:
self.next_explore = float("inf")
explore_ready = active and not pending and any(action.path and (action.kind == "explore_finish"
or action.kind == "explore_start" and self.explore_enabled.isChecked()) for action in plans)
breakthrough = active and bool(self.breakthrough_targets) and any(
action.kind in ("potential", "breakthrough") for action in plans)
now = time.monotonic()
explore_delay = 1.0 if explore_ready else None
if active and self.explore_enabled.isChecked() and self.engine.snapshot is not None:
if active and not pending and self.engine.snapshot is not None:
for team in self.engine.snapshot.raw.get("exploreTeams") or []:
if not isinstance(team, dict) or team.get("status") not in (1, "1"):
continue
+53 -11
View File
@@ -23,9 +23,14 @@ BATTLE_ALIASES = {"task": "task_battle", "passStage": "task_pass_stage", "event"
BATTLE_MODES = {"original": "原版运行时(以能力检查为准)", "experimental": "实验模拟(近似,未完整验证)"}
STATES = {"available": "可接取", "unaccepted": "未接取", "active": "进行中", "in_progress": "进行中",
"ready": "待交付", "completed": "已完成", "complete": "已完成", "claimed": "已领奖",
"received": "进行中", "unlocked": "已解锁 / 待接取", "locked": "未解锁", "finished": "已完成",
"received": "进行中", "unlocked": "已解锁 / 待接取", "offered": "待接取", "locked": "未解锁", "finished": "已完成",
"ready_to_reward": "待领取任务奖励", "blocked": "受阻", "unsupported": "暂不支持", "unknown": "未知"}
CHINA_TIME = timezone(timedelta(hours=8))
STATE_FILTERS = (("current", "当前(进行中 + 待接取 + 待领奖)"), ("received", "进行中"), ("unlocked", "待接取"),
("ready_to_reward", "待领奖"), ("finished", "已完成"), ("locked", "未解锁"), ("", "全部状态"))
STATE_ALIASES = {"active": "received", "in_progress": "received", "available": "unlocked", "unaccepted": "unlocked", "offered": "unlocked",
"ready": "ready_to_reward", "completed": "finished", "complete": "finished", "claimed": "finished", "blocked": "received"}
CURRENT_STATES = {"received", "unlocked", "ready_to_reward"}
OUTCOMES = {"win": "胜利", "loss": "打不过", "unsupported": "暂不支持", "event": "地图奖励事件",
"completed": "已完成", "cancelled": "已取消", "timeout": "超时", "unknown": "结果待核对"}
@@ -65,7 +70,9 @@ def prepare_progression_views(engine, *, tasks=True, records=True):
row = copy.deepcopy(source)
kind = category(row.get("category", "unknown"))
kind = kind if kind in CATEGORIES else "unknown"
state = display(row.get("state"), "未知")
raw_state = row.get("state")
state = display(raw_state, "未知")
lifecycle_state = STATE_ALIASES.get(state, state)
reason = battle_message(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 "支持状态未确认"
@@ -81,7 +88,8 @@ def prepare_progression_views(engine, *, tasks=True, records=True):
"目标 / 位置:" + 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,
task_rows.append({"key": str(index), "category": kind, "state": raw_state, "lifecycle_state": lifecycle_state,
"values": values, "detail": detail,
"search": (" ".join(values) + " " + dialogue).casefold()})
for index, source in enumerate(record_data):
row = copy.deepcopy(source)
@@ -111,6 +119,14 @@ def prepare_progression_views(engine, *, tasks=True, records=True):
detail = "\n".join(("时间(北京时间):" + values[0], "上下文:" + values[1] + ";任务 / 地图:" + values[2],
"战斗模式:" + BATTLE_MODES.get(mode, "记录未标明"),
"队伍:" + values[3] + ";结果:" + values[4], "详情 / 阻塞原因:" + values[5], "奖励:" + display(row.get("reward"))))
if row.get("damage_profile") == "client_v4_x10":
detail += "\n伤害规则:我方对敌最终伤害 10 倍,单次最高 50000;角色属性保持原值"
elif row.get("damage_profile") == "original_1x":
detail += "\n伤害规则:原始 1 倍;角色属性保持原值"
elif row.get("damage_profile") is not None:
detail += "\n伤害规则未识别"
else:
detail += "\n旧记录未标明伤害倍率"
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 "当前引擎尚未提供任务读取;任务只展示,不自动推进"
@@ -190,11 +206,19 @@ class ProgressionPages:
self.progression_filter = ComboBox()
for key, name in (("", "全部类别"), *CATEGORIES.items()):
self.progression_filter.addItem(name, key)
self.progression_filter.setCurrentIndex(self.progression_filter.findData("mainline"))
self.progression_state_filter = ComboBox()
for key, name in STATE_FILTERS:
self.progression_state_filter.addItem(name, key)
self.progression_search = W.QLineEdit()
self.progression_search.setPlaceholderText("按任务编号、名称、目标或阻塞原因筛选")
filters.addWidget(self.progression_filter)
filters.addWidget(self.progression_state_filter)
filters.addWidget(self.progression_search, 1)
task_layout.addLayout(filters)
self.progression_task_status = W.QLabel("默认只显示当前账号进行中、待接取和待领奖的主线任务")
self.progression_task_status.setWordWrap(True)
task_layout.addWidget(self.progression_task_status)
self.progression_table = CachedTable(["编号", "类别", "任务", "状态", "步骤", "目标 / 位置", "需求", "下一步", "战斗类型", "支持状态 / 阻塞原因"],
left_columns=(2, 5, 6, 7, 9))
self.progression_table.setColumnWidth(2, 180)
@@ -249,7 +273,7 @@ class ProgressionPages:
self.progression_item_reserves = W.QLineEdit()
self.progression_item_reserves.setPlaceholderText("物品编号:保留数量,多个用英文逗号分隔")
form.addRow("交付后至少保留", self.progression_item_reserves)
note = W.QLabel("勾选功能后,使用顶部绿色“开启”运行。支持状态以任务列表为准;未知状态不会自动执行。\n任务列表区分主线 / 支线 / 委托;战斗记录区分普通战斗、扫荡和地图奖励事件。未支持的步骤显示原因。")
note = W.QLabel("勾选功能后,使用顶部绿色“开启”运行。支持状态以任务列表为准;未知状态不会自动执行。\n任务列表区分主线 / 支线 / 委托;战斗记录区分普通战斗、扫荡和地图奖励事件。未支持的步骤显示原因。\n桌面模拟保持原始属性,仅将我方对敌最终伤害调整为 10 倍、上限 50000。")
note.setWordWrap(True)
form.addRow(note)
scroll = W.QScrollArea()
@@ -259,8 +283,9 @@ class ProgressionPages:
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_filter.currentIndexChanged.connect(self.render_progression_filters)
self.progression_state_filter.currentIndexChanged.connect(self.render_progression_filters)
self.progression_search.textChanged.connect(self.render_progression_filters)
self.progression_table.itemSelectionChanged.connect(self.progression_selection_changed)
self.progression_enabled.toggled.connect(self.progression_settings_changed)
self.update_progression_status()
@@ -382,7 +407,7 @@ class ProgressionPages:
return
active = self.strategy_toggle.isChecked() and self.progression_enabled.isChecked()
text = "自动主线已开启" if active else "策略已停止;顶部“开启”后执行勾选功能" if self.progression_enabled.isChecked() else "自动主线未启用"
text += ";战斗按原始属性进行实验模拟,等待计算出的战斗时长后提交(近似推演,结果以实际记录为准)"
text += ";战斗保持原始属性,实验模拟中我方对敌最终伤害为 10 倍、上限 50000,等待计算出的战斗时长后提交(近似推演,结果以实际记录为准)"
if not callable(getattr(self.engine, "refresh_progression", None)):
text += ";当前引擎尚未接入任务刷新"
if not callable(getattr(self.engine, "run_progression_once", None)):
@@ -447,6 +472,7 @@ class ProgressionPages:
widget.set_rows([])
self.progression_detail.clear()
self.battle_record_detail.clear()
self.progression_task_status.setText("默认只显示当前账号进行中、待接取和待领奖的主线任务")
self.update_progression_status()
def accept_progression_views(self, views):
@@ -472,7 +498,10 @@ class ProgressionPages:
engine = self.engine
self.run_job("progression_view", lambda: prepare_progression_views(engine, tasks=tasks, records=not tasks))
def render_progression(self, *args):
def render_progression_filters(self, *args):
self.render_progression(request_missing=False)
def render_progression(self, *args, request_missing=True):
if self.closed or not self.presentation_active:
return
page = self.tabs.currentWidget()
@@ -480,15 +509,28 @@ class ProgressionPages:
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:
if request_missing and (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"])]
state = self.progression_state_filter.currentData()
def matches(row):
if selected and row["category"] != selected:
return False
if query and query not in row["search"]:
return False
if not tasks or not state:
return True
lifecycle_state = row["lifecycle_state"]
return lifecycle_state in CURRENT_STATES if state == "current" else lifecycle_state == state
visible = [row for row in rows if matches(row)]
table.set_rows(visible)
if not tasks:
if tasks:
self.progression_task_status.setText(f"显示 {len(visible)} / {len(rows)} 条任务" if visible else
f"没有符合当前类别、状态和搜索条件的任务(共 {len(rows)} 条)")
else:
self.battle_records_status.setText(f"已读取 {len(rows)} 条记录,显示 {len(visible)} 条;战斗、扫荡和地图奖励事件分别标记" if rows else
"尚无已读取的战斗记录;未记录结果不代表战斗成功")
self.update_progression_status()
+11
View File
@@ -46,6 +46,17 @@ class RanchView(W.QTreeWidget):
return [int(item.data(0, C.Qt.ItemDataRole.UserRole)) for item in self.selectedItems()
if item.data(0, C.Qt.ItemDataRole.UserRole) is not None]
def reveal_breakthrough(self):
item = next((item for item in self.selectedItems()
if item.data(0, C.Qt.ItemDataRole.UserRole) is not None), None)
if item is None:
item = next(iter(self.monster_items.values()), None)
if item is None:
return
if item.parent() is not None:
item.parent().setExpanded(True)
self.scrollTo(self.indexFromItem(item, 20), W.QAbstractItemView.ScrollHint.EnsureVisible)
def set_view(self, grouped, room_id=0):
self.grouped, self.room_id = grouped, room_id if grouped else 0
@@ -0,0 +1,194 @@
import os
import unittest
from dataclasses import replace
from unittest.mock import Mock, patch
os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
from PySide6 import QtCore as C, QtGui as G, QtWidgets as W
from PySide6.QtTest import QTest
from ranch_assistant.engine import Engine, demo_snapshot
from ranch_assistant.gui import Window
from ranch_assistant.maps import stages
from ranch_assistant.native_widgets import IntegerInput
from ranch_assistant.presentation import monster_rows
from ranch_assistant.tests.test_activities import scenario
from ranch_assistant.tests.test_core import workspace_temp
LONG_DROP = "金币、绿色史莱姆蛋、" + "、".join(f"离线材料{i:02d}" for i in range(30)) + "、末尾稀有掉落"
class ActivityDropElisionTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.app = W.QApplication.instance() or W.QApplication([])
def finish_maps(self, window):
for _ in range(200):
self.app.processEvents()
QTest.qWait(2)
if not window.map_render_timer.running:
return
self.fail("Offline map rendering did not finish")
def fixture(self, window):
catalog, snapshot = scenario()
rows = [replace(row, drops=LONG_DROP)
if row.stage_id == "0101" and row.level == "3" else row
for row in stages(catalog, snapshot)]
catalog.data["stage_info"]["m101"] = {
"cost": {"ti": 8, "items": [{"typeId": "90001", "num": 2}, {"typeId": "90002", "num": 1}]}
}
catalog.data["item_names"].update({"90001": "矿镐", "90002": "门票"})
rows.append(replace(rows[0], stage_id="m101", level="1", name="矿洞", category="mine",
sweep=False, battle_available=True))
window.engine = Engine(catalog)
window.engine.snapshot = snapshot
window.engine.stage_cache.get = Mock(return_value=rows)
window.tabs.setCurrentWidget(window.map_page)
window.resize(1600, 800)
window.show()
window.maps_tree.setColumnWidth(7, 90)
window.render_maps()
self.finish_maps(window)
window.maps_tree.expandAll()
self.app.processEvents()
return window._map_items["0101"], window._map_items["m101"]
def test_long_drop_elides_without_losing_text_search_or_adjacent_controls(self):
with workspace_temp() as folder:
window = Window(folder)
window.timer.stop()
try:
item, resource_item = self.fixture(window)
tree = window.maps_tree
self.assertEqual(tree.columnWidth(7), 90)
self.assertEqual(item.text(7), LONG_DROP)
self.assertEqual(item.toolTip(7), LONG_DROP)
self.assertEqual(item.data(7, C.Qt.ItemDataRole.DisplayRole), LONG_DROP)
index = tree.indexFromItem(item, 7)
option = W.QStyleOptionViewItem()
tree.initViewItemOption(option)
option.rect = tree.visualRect(index)
delegate = tree.itemDelegateForColumn(7) or tree.itemDelegate()
delegate.initStyleOption(option, index)
self.assertEqual(option.text, LONG_DROP)
self.assertEqual(option.rect.width(), tree.columnWidth(7))
self.assertEqual(option.textElideMode, C.Qt.TextElideMode.ElideRight)
elided = option.fontMetrics.elidedText(LONG_DROP, option.textElideMode, option.rect.width())
self.assertNotEqual(elided, LONG_DROP)
self.assertTrue(elided.endswith("…"))
cost_index = tree.indexFromItem(resource_item, 6)
cost_option = W.QStyleOptionViewItem()
tree.initViewItemOption(cost_option)
cost_option.rect = tree.visualRect(cost_index)
(tree.itemDelegateForColumn(6) or tree.itemDelegate()).initStyleOption(cost_option, cost_index)
self.assertIn("\n", resource_item.text(6))
self.assertEqual(cost_option.text.replace("\u2028", "\n"), resource_item.text(6))
self.assertEqual(cost_option.textElideMode, C.Qt.TextElideMode.ElideNone)
tree.scrollTo(index, W.QAbstractItemView.ScrollHint.EnsureVisible)
self.app.processEvents()
viewport_point = tree.visualRect(index).center()
event = G.QHelpEvent(C.QEvent.Type.ToolTip, viewport_point,
tree.viewport().mapToGlobal(viewport_point))
self.app.sendEvent(tree.viewport(), event)
self.assertTrue(W.QToolTip.isVisible())
self.assertEqual(W.QToolTip.text(), LONG_DROP)
W.QToolTip.hideText()
limit = tree.itemWidget(item, 8)
self.assertIsInstance(limit, IntegerInput)
self.assertTrue(limit.isVisible())
self.assertIs(limit.style(), window.style())
self.assertEqual(limit.styleSheet(), "")
QTest.mouseClick(limit, C.Qt.MouseButton.LeftButton)
limit.selectAll()
QTest.keyClicks(limit, "12")
self.assertEqual(limit.value(), 12)
self.assertEqual(window.map_rules["0101"]["limit"], 12)
window.map_search.setFocus()
window.map_search.setText("末尾稀有掉落")
self.finish_maps(window)
self.assertIn("0101", window._map_items)
self.assertEqual(window._map_items["0101"].text(7), LONG_DROP)
window.map_search.setText("不在任何掉落中的词")
self.finish_maps(window)
self.assertNotIn("0101", window._map_items)
finally:
window.close()
def test_breakthrough_button_reveals_columns_without_changing_selection_or_rules(self):
with workspace_temp() as folder:
window = Window(folder)
window.timer.stop()
try:
window.tabs.setCurrentWidget(window.monster_page)
tree = window.monsters
snapshot = demo_snapshot(tree.catalog)
window.feed_targets = {"900": 2}
window.gift_targets = {"900": 3}
window.breakthrough_targets = {"900": 7}
tree.set_view(True)
tree.set_data(snapshot, monster_rows(tree.catalog, snapshot, set()),
window.feed_targets, window.gift_targets, window.breakthrough_targets)
self.finish_ranch(tree)
tree.setFixedWidth(320)
window.show()
self.app.processEvents()
selected = tree.monster_items[900]
tree.setCurrentItem(selected)
self.assertEqual(tree.selected_monster_ids(), [900])
self.assertIn("补满四项潜能", window.breakthrough_settings.toolTip())
self.assertIn("不是同种喂养突破", window.breakthrough_settings.toolTip())
original_rules = (dict(window.feed_targets), dict(window.gift_targets), dict(window.breakthrough_targets))
original_controls = {mid: (tree.itemWidget(item, 19).isChecked(), tree.itemWidget(item, 20).value())
for mid, item in tree.monster_items.items()}
changes = []
tree.breakthrough_changed.connect(lambda *args: changes.append(args))
with patch.object(window, "submit") as submit, patch.object(window, "refresh") as refresh:
tree.collapseAll()
tree.horizontalScrollBar().setValue(0)
QTest.mouseClick(window.breakthrough_settings, C.Qt.MouseButton.LeftButton)
self.app.processEvents()
self.assertTrue(selected.parent().isExpanded())
target_rect = tree.visualRect(tree.indexFromItem(selected, 20))
self.assertTrue(tree.viewport().rect().contains(target_rect))
self.assertGreater(tree.horizontalScrollBar().value(), 0)
self.assertEqual(tree.selected_monster_ids(), [900])
tree.clearSelection()
first = next(iter(tree.monster_items.values()))
tree.collapseAll()
tree.horizontalScrollBar().setValue(0)
QTest.mouseClick(window.breakthrough_settings, C.Qt.MouseButton.LeftButton)
self.app.processEvents()
self.assertTrue(first.parent().isExpanded())
self.assertTrue(tree.viewport().rect().contains(tree.visualRect(tree.indexFromItem(first, 20))))
self.assertEqual(tree.selectedItems(), [])
submit.assert_not_called()
refresh.assert_not_called()
self.assertEqual((window.feed_targets, window.gift_targets, window.breakthrough_targets), original_rules)
self.assertEqual({mid: (tree.itemWidget(item, 19).isChecked(), tree.itemWidget(item, 20).value())
for mid, item in tree.monster_items.items()}, original_controls)
self.assertEqual(changes, [])
finally:
window.close()
def finish_ranch(self, tree):
for _ in range(200):
self.app.processEvents()
QTest.qWait(2)
if not tree.row_batch.running:
return
self.fail("Offline ranch rendering did not finish")
if __name__ == "__main__":
unittest.main()
@@ -133,6 +133,62 @@ class AutomationSchedulingTests(unittest.TestCase):
self.assertEqual([call[1] for call in engine.calls], ["explore", "breakthrough"])
def test_finished_team_dispatches_claim_without_restart_opt_in(self):
engine = self.install_engine("explore_finish")
self.window.explore_enabled.setChecked(False)
self.window.arm_extended_automation()
self.assertLess(self.window.next_explore, float("inf"))
self.window.next_explore = time.monotonic() - 1
self.window.run_extended_automation()
self.wait(lambda: bool(engine.calls))
self.assertEqual(engine.calls, [("poll_automation", "explore")])
def test_idle_team_does_not_arm_when_restart_is_disabled(self):
self.install_engine()
self.window.explore_enabled.setChecked(False)
self.window.next_explore = float("inf")
self.window.arm_extended_automation()
self.assertEqual(self.window.next_explore, float("inf"))
def test_global_stop_blocks_claim_dispatch_and_disarms_timer(self):
engine = self.install_engine("explore_finish")
self.window.explore_enabled.setChecked(False)
self.window.arm_extended_automation()
self.assertLess(self.window.next_explore, float("inf"))
self.window.stop_workflow()
self.assertEqual(self.window.next_explore, float("inf"))
self.window.run_extended_automation()
self.wait()
self.assertEqual(engine.calls, [])
def test_pending_reconciliation_defers_claim_timer_and_active_countdown(self):
for pending in ("exploration", "battle"):
with self.subTest(pending=pending):
self.setUp()
engine = self.install_engine("explore_finish")
self.window.explore_enabled.setChecked(False)
if pending == "exploration":
engine.explore_planner.pending = Mock(return_value={"uncertain": True})
else:
engine._progression_pending = Mock(return_value=True)
self.assertEqual(self.window.latest_render[1][-1].kind, "explore_finish")
self.window.next_explore = float("inf")
self.window.arm_extended_automation()
self.assertEqual(self.window.next_explore, float("inf"))
self.window.arm_extended_automation()
self.assertEqual(self.window.next_explore, float("inf"))
engine.pending_recovery_due = Mock(return_value=True)
engine.demo = False
self.window.monitoring = True
self.window.set_strategy_checked(True)
self.window.next_breakthrough = float("inf")
self.window.schedule()
self.wait(lambda: bool(engine.calls))
self.assertEqual(engine.calls, [("poll", {"hatch_only": False, "defer_hatch": True})])
def test_fast_hatch_and_gift_dispatch_only_their_own_kind(self):
for kind in ("hatch", "gift"):
with self.subTest(kind=kind):
@@ -0,0 +1,184 @@
"""V4 final-damage profile boundaries; all fixtures are offline."""
from copy import deepcopy
from dataclasses import replace
from types import SimpleNamespace
import unittest
from unittest.mock import patch
from ranch_assistant.battle_simulator import (
DEFAULT_DAMAGE_PROFILE, DESKTOP_DAMAGE_PROFILE, ExperimentalBattleRuntime,
_Battle, _prepare, combat_tables,
)
from ranch_assistant.battles import BattleOrchestrator
from ranch_assistant.engine import Engine
from ranch_assistant.game_data import ProgressionData
from ranch_assistant.tests.test_battle_simulator import enemy, monster, request
def prepared(req):
scenario, report = _prepare(req, combat_tables())
battle = _Battle(scenario, report, combat_tables())
battle.deploy()
return battle
class DamageProfileTests(unittest.TestCase):
def test_default_offline_profile_and_explicit_v4_metadata(self):
original = request()
self.assertEqual(ExperimentalBattleRuntime().inspect(original)["damage_profile"], DEFAULT_DAMAGE_PROFILE)
original["damage_profile"] = DESKTOP_DAMAGE_PROFILE
report = ExperimentalBattleRuntime().inspect(original)
self.assertEqual(report["damage_profile"], "client_v4_x10")
self.assertEqual((report["damage_multiplier"], report["damage_cap"]), (10, 50000))
self.assertTrue(report["damage_profile_digest"])
self.assertTrue(report["approximate"] and report["faithful"] is False)
self.assertIn("Unknown damage profile", ExperimentalBattleRuntime().inspect(
request(damage_profile="unknown"))["reasons"])
self.assertFalse(ExperimentalBattleRuntime().inspect(request(damage_profile="unknown"))["supported"])
def test_v4_applies_once_with_cap_and_does_not_mutate_stats_or_request(self):
req = request(enemies=[enemy(hp=200000)], damage_profile=DESKTOP_DAMAGE_PROFILE)
before = deepcopy(req)
battle = prepared(req)
player, target = battle.by_key["player-1"], battle.by_key["configured-1-1"]
stats = replace(target.unit.stats)
hp = target.hp
self.assertEqual(battle.hurt(target, 100, player, "fixture"), 1000)
self.assertEqual(target.hp, hp - 1000)
self.assertEqual(battle.events[-1]["damage"], 1000)
self.assertEqual(battle.events[-1]["damage_profile"], DESKTOP_DAMAGE_PROFILE)
self.assertEqual(battle.events[-1]["damage_cap"], 50000)
self.assertEqual(battle.hurt(target, 5001, player, "fixture"), 50000)
self.assertEqual(target.unit.stats, stats)
self.assertEqual(req, before)
def test_enemy_environment_friendly_non_team2_and_zero_are_unchanged(self):
req = request(enemies=[enemy(hp=200000), enemy(team=3, hp=200000)],
damage_profile=DESKTOP_DAMAGE_PROFILE)
battle = prepared(req)
player = battle.by_key["player-1"]
target = battle.by_key["configured-1-1"]
other_team = battle.by_key["configured-1-2"]
self.assertEqual(battle.hurt(player, 100, target, "enemy"), 100)
self.assertEqual(battle.hurt(target, 100, None, "environment"), 100)
self.assertEqual(battle.hurt(other_team, 100, player, "other_team"), 100)
self.assertEqual(battle.hurt(target, 0, player, "zero"), 0)
def test_real_attack_uses_the_same_final_hp_order(self):
battle = prepared(request(enemies=[enemy(hp=200000)], damage_profile=DESKTOP_DAMAGE_PROFILE))
target, player = battle.by_key["configured-1-1"], battle.by_key["player-1"]
self.assertEqual(battle.hurt(target, 10, player, "real", real_attack=True), 100)
self.assertEqual(battle.hurt(target, 6000, player, "real", real_attack=True), 50000)
self.assertEqual(battle.hurt(player, 100, target, "real", real_attack=True), 100)
def test_reduction_precedes_v4_cap_in_both_hp_branches(self):
for real_attack in (False, True):
with self.subTest(real_attack=real_attack):
battle = prepared(request(enemies=[enemy(hp=200000)], damage_profile=DESKTOP_DAMAGE_PROFILE))
target, player = battle.by_key["configured-1-1"], battle.by_key["player-1"]
target.unit = replace(target.unit, stats=replace(target.unit.stats, damage_reduction=.5))
self.assertEqual(battle.hurt(target, 100, player, "reduced", real_attack=real_attack), 500)
self.assertEqual(battle.hurt(target, 11000, player, "reduced_cap", real_attack=real_attack), 50000)
def test_mining_fixed_hurt_precedes_multiplier_for_player_and_npc(self):
def fixture():
return prepared({"context": "ordinary_stage", "roster": {"master": {"level": 43},
"monsters": [monster()], "teams": [{"teamName": "teamA", "monsters": [101]}],
"monsterAttributes": []}, "team": "teamA", "damage_profile": DESKTOP_DAMAGE_PROFILE,
"original_data": {"battle": ProgressionData().stage_battle("m101")}})
battle = fixture()
player, ore = battle.by_key["player-1"], battle.by_source_id["10001"]
player.unit = replace(player.unit, stats=replace(player.unit.stats, element=3))
ore.unit = replace(ore.unit, hurt_types={**ore.unit.hurt_types, "3": 1})
self.assertEqual(battle.hurt(ore, 100, player, "fixed_hurt"), 2000)
battle = fixture()
self.assertEqual(battle.hurt(battle.by_source_id["10001"], 100,
battle.by_source_id["20001"], "fixed_hurt"), 5000)
def test_worker_transports_profile_and_battle_evidence_discloses_it(self):
req = request(enemies=[enemy(hp=200000)], damage_profile=DESKTOP_DAMAGE_PROFILE)
result = ExperimentalBattleRuntime().run(req)
self.assertEqual(result["damage_profile"], DESKTOP_DAMAGE_PROFILE)
self.assertEqual(result["damage_cap"], 50000)
self.assertEqual(next(e for e in result["events"] if e["type"] == "damage")["damage_profile"],
DESKTOP_DAMAGE_PROFILE)
evidence = BattleOrchestrator.runtime_evidence(result, "experimental")
self.assertEqual(evidence["damage_profile"], DESKTOP_DAMAGE_PROFILE)
self.assertEqual((evidence["damage_multiplier"], evidence["damage_cap"]), (10, 50000))
self.assertEqual(evidence["damage_profile_digest"], result["damage_profile_digest"])
class DesktopProfileTests(unittest.TestCase):
@staticmethod
def engine():
engine = object.__new__(Engine)
engine._ensure_progression = lambda: None
engine._select_battle_runtime = lambda mode: None
engine._battle_snapshot_source = None
engine._battle_snapshot_digest = ""
engine._battle_roster_digest = None
engine._battle_roster = None
engine.game_data = SimpleNamespace(
stage_battle=lambda stage, difficulty: {"stage": stage, "difficulty": difficulty},
task_battle=lambda task, step: {"task": task, "step": step}, manifest={})
from ranch_assistant.battle_runtime import BattleRuntime
engine.battles = SimpleNamespace(runtime=BattleRuntime())
return engine
def test_all_desktop_contexts_and_original_subrequest_carry_v4(self):
snapshot = SimpleNamespace(raw={"master": {"level": 43}, "monsters": [], "teams": []})
cases = (
({"battle_kind": "ordinary_stage", "stage_id": "0101", "difficulty": 1}, "ordinary_stage"),
({"battle_kind": "task", "task_type_id": 100, "step_number": 1}, "task_battle"),
({"battle_kind": "task", "task_type_id": 200, "step_number": 1}, "task_battle"),
({"battle_kind": "resource_stage", "stage_id": "m101", "difficulty": 1,
"stage_category": "mine"}, "ordinary_stage"),
)
for intent, context in cases:
for mode in ("experimental", "original"):
engine = self.engine()
with self.subTest(intent=intent, mode=mode):
req = Engine._battle_request(engine, snapshot, intent,
SimpleNamespace(battle_mode=mode), {"damage_profile": DEFAULT_DAMAGE_PROFILE,
**{key: intent.get(key) for key in ("stage_id", "difficulty", "task_type_id", "step_number")}})
self.assertEqual(req["context"], context)
self.assertEqual(req["damage_profile"],
DESKTOP_DAMAGE_PROFILE if mode == "experimental" else DEFAULT_DAMAGE_PROFILE)
if mode == "original":
self.assertNotIn("damage_profile", req["runtime_request"])
def test_map_failure_signature_is_scoped_to_v4(self):
engine = self.engine()
snapshot = SimpleNamespace(raw={"master": {"level": 43},
"teams": [{"teamName": "teamA", "teamType": "battleTeam", "monsters": [101]}],
"monsters": [monster()], "monsterAttributes": []})
first = engine._map_roster_signature(snapshot, "teamA")
self.assertNotEqual(first, engine._map_roster_signature(snapshot, "teamB"))
with patch("ranch_assistant.battle_simulator.DESKTOP_DAMAGE_PROFILE", DEFAULT_DAMAGE_PROFILE):
self.assertNotEqual(first, engine._map_roster_signature(snapshot, "teamA"))
def test_capability_cache_is_scoped_to_actual_mode_profile(self):
engine = self.engine()
engine.quest_policy = SimpleNamespace(battle_tasks=True)
engine._is_commission = lambda intent: False
engine._is_farm = lambda intent: False
engine._intent_policy = lambda intent: policy
engine.progression_policy = SimpleNamespace(battle_mode="experimental")
engine.snapshot = SimpleNamespace()
engine.policy = SimpleNamespace()
engine._battle_snapshot_digest = "fixture"
engine._capability_cache = {}
policy = SimpleNamespace(battle_mode="experimental", team="teamA")
engine.battles = SimpleNamespace(runtime=object(), request=lambda *args: {},
resource_reason=lambda *args: "", inspect=lambda req: (True, ""))
with patch("ranch_assistant.engine.digest", side_effect=lambda value: value["damage_profile"]):
self.assertEqual(engine._battle_capability({}), (True, ""))
self.assertEqual(engine._battle_capability({}), (True, ""))
self.assertEqual(len(engine._capability_cache), 1)
policy.battle_mode = "original"
self.assertEqual(engine._battle_capability({}), (True, ""))
self.assertEqual(set(engine._capability_cache), {DEFAULT_DAMAGE_PROFILE, DESKTOP_DAMAGE_PROFILE})
if __name__ == "__main__":
unittest.main()
+105
View File
@@ -8,8 +8,10 @@ import unittest
from unittest.mock import Mock, patch
from ranch_assistant.exploration import ExplorePlanner, ExplorePolicy, ExploreTeamRule, load_exploration_areas
from ranch_assistant.engine import Engine
from ranch_assistant.model import Catalog, Policy, Snapshot
from ranch_assistant.tests.test_core import workspace_temp
from ranch_assistant.tests.test_ranch_automation_integration import FakeClient, raw
NOW = 1_700_000_000
@@ -147,6 +149,109 @@ class ExplorationTests(unittest.TestCase):
self.assertEqual(row["state"], "可领取")
self.assertIn("仍会自动领取奖励", row["reason"])
def test_finished_team_rewards_while_automatic_restart_is_disabled(self):
team = self.snapshot.raw["exploreTeams"][0]
self.start_confirmed(team, end=NOW - 1)
disabled = ExplorePolicy(False)
actions = self.planner.plan(self.snapshot, disabled, self.ranch)
self.assertEqual([(action.kind, action.path, action.payload) for action in actions],
[("explore_finish", "exploreService/finish", {"exploreTeamId": 1})])
team.update(status=0, area=None, monsters=None, endTime=None)
self.assertIsNone(self.planner.pending(self.snapshot))
self.assertEqual(self.planner.plan(self.snapshot, disabled, self.ranch), [])
def test_locked_idle_team_is_quiet_while_automatic_restart_is_disabled(self):
self.snapshot.raw["history"]["passTask"] = {}
self.assertEqual(self.planner.plan(self.snapshot, ExplorePolicy(False), self.ranch), [])
enabled = self.planner.plan(self.snapshot, ExplorePolicy(True), self.ranch)
self.assertEqual([(action.kind, action.path) for action in enabled], [("explore_blocked", "")])
def test_disabled_restart_claim_reconciles_before_next_poll_and_global_stop_blocks(self):
with workspace_temp() as folder:
value = raw(self.catalog)
team = value["exploreTeams"][0]
team.update(status=1, area="15", monsters="900,901,902", endTime=(NOW - 1) * 1000)
client = FakeClient(value)
engine = Engine(self.catalog, client, folder / "budget.json")
engine.master_sync.settle = lambda *args: None
engine.explore_policy = ExplorePolicy(False)
def finish(path, payload):
client.calls.append((path, payload))
team.update(status=0, area=None, monsters=None, endTime=None)
return {"resCode": 0, "rewardResult": {}, "monExp": []}
client.call = finish
engine.auto = False
engine.poll_automation("explore")
self.assertEqual(client.calls, [])
engine.auto = True
engine.poll_automation("explore")
self.assertEqual(client.calls, [("exploreService/finish", {"exploreTeamId": 77})])
self.assertIsNone(engine.explore_planner.pending(engine.snapshot))
self.assertEqual(engine.plans(), [])
engine.poll_automation("explore")
self.assertEqual(len(client.calls), 1)
def test_unknown_finish_is_never_repeated_even_with_restart_disabled(self):
team = self.snapshot.raw["exploreTeams"][0]
self.start_confirmed(team, end=NOW - 1)
disabled = ExplorePolicy(False)
with workspace_temp() as folder:
path = folder / "state.json"
planner = ExplorePlanner(self.catalog, areas=AREAS, path=path)
action = planner.plan(self.snapshot, disabled, self.ranch)[0]
planner.mark_started(self.snapshot, action)
planner.mark_uncertain(self.snapshot, action, "synthetic lost finish reply")
for _ in range(2):
actions = planner.plan(self.snapshot, disabled, self.ranch)
self.assertEqual([(item.kind, item.path) for item in actions], [("explore_blocked", "")])
restored = ExplorePlanner(self.catalog, areas=AREAS, path=path)
self.assertTrue(restored.pending(self.snapshot)["uncertain"])
self.assertEqual([(item.kind, item.path) for item in restored.plan(self.snapshot, disabled, self.ranch)],
[("explore_blocked", "")])
team.update(status=0, monsters="", endTime=0)
self.assertTrue(restored.reconcile(self.snapshot))
self.assertEqual(restored.plan(self.snapshot, disabled, self.ranch), [])
def test_confirmed_claim_allows_only_opted_in_team_to_restart(self):
with workspace_temp() as folder:
value = raw(self.catalog)
team = value["exploreTeams"][0]
team.update(status=1, area="15", monsters="900,901,902", endTime=(NOW - 1) * 1000)
value["monsters"][0]["level"] = 60
client = FakeClient(value)
engine = Engine(self.catalog, client, folder / "budget.json")
engine.master_sync.settle = lambda *args: None
engine.explore_policy = ExplorePolicy(True,
{"77": {"enabled": True, "area": "1", "monsters": []}})
area = engine.explore_planner.areas["1"]
value["history"]["passStage"] = {area["passStage"]: {"1": True}}
def call(path, payload):
client.calls.append((path, payload))
if path == "exploreService/finish":
team.update(status=0, area=None, monsters=None, endTime=None)
else:
team.update(status=1, area=payload["area"], monsters=payload["monsters"],
endTime=(NOW + 3600) * 1000)
return {"resCode": 0, "rewardResult": {}, "monExp": []}
client.call = call
engine.auto = True
engine.poll_automation("explore")
self.assertEqual(client.calls, [("exploreService/finish", {"exploreTeamId": 77})])
self.assertIsNone(engine.explore_planner.pending(engine.snapshot))
engine.poll_automation("explore")
self.assertEqual([path for path, _ in client.calls],
["exploreService/finish", "exploreService/start"])
self.assertEqual(client.calls[1][1]["exploreTeamId"], 77)
self.assertIsNone(engine.explore_planner.pending(engine.snapshot))
self.assertEqual(engine.snapshot.raw["exploreTeams"][0]["status"], 1)
engine.poll_automation("explore")
self.assertEqual(len(client.calls), 2)
def test_active_zero_or_missing_deadline_is_unknown_and_never_finished(self):
for value in (None, 0, "", "not-a-time"):
with self.subTest(value=value):
@@ -111,6 +111,27 @@ class ExplorationGuiTests(unittest.TestCase):
window.arm_extended_automation()
self.assertAlmostEqual(window.next_explore, now + 61, places=2)
def test_active_snapshot_arms_claim_timer_when_restart_is_disabled(self):
window = self.window
snapshot = window.engine.snapshot
snapshot.raw["exploreTeams"][0].update(
status=1, area="1", monsters="1,2,3", endTime=(NOW + 60) * 1000)
window.latest_render = (snapshot, [])
window.monitoring = True
window.set_strategy_checked(True)
window.explore_enabled.setChecked(False)
window.next_explore = float("inf")
now = time.monotonic()
with patch.object(gui.time, "monotonic", return_value=now):
window.arm_extended_automation()
self.assertAlmostEqual(window.next_explore, now + 61, places=2)
def test_explore_opt_in_labels_restart_and_top_stop_owns_claims(self):
self.assertEqual(self.window.explore_enabled.text(), "自动安排再次探险(完成后自动领奖)")
self.assertIn("顶部", self.window.explore_enabled.toolTip())
self.assertIn("停止", self.window.explore_enabled.toolTip())
self.assertIn("领奖", self.window.explore_enabled.toolTip())
def test_real_window_three_selections_and_busy_policy_queue(self):
window = self.window
window.refresh_exploration()
@@ -0,0 +1,40 @@
import unittest
from ranch_assistant.gifts import GiftPlanner
from ranch_assistant.model import Catalog, Policy
from ranch_assistant.tests.test_gift_timing import gift_snapshot
class GiftTargetSelectionTests(unittest.TestCase):
def setUp(self):
self.catalog = Catalog()
self.snapshot = gift_snapshot(self.catalog)
self.planner = GiftPlanner(self.catalog)
self.representative = next(iter(self.planner.cultivation.select(self.snapshot).values()))
self.manual_target = next(mon for mon in self.snapshot.raw["monsters"]
if int(mon["id"]) != int(self.representative["id"]))
def policy(self, auto=False):
return Policy(gift_enabled=True, gift_auto_representative=auto,
gift_targets={} if auto else {str(self.manual_target["id"]): 1},
gift_liked_only=False, gift_items={"30005": {"enabled": True, "reserve": 0}})
def test_auto_representative_is_the_effective_target_without_manual_targets(self):
policy = self.policy(auto=True)
self.assertEqual([mon["id"] for mon in self.planner.candidates(self.snapshot, policy)],
[self.representative["id"]])
self.assertEqual([action.payload["monsterId"] for action in self.planner.plan(self.snapshot, policy)],
[self.representative["id"]])
def test_manual_mode_uses_gift_targets_instead_of_representative(self):
policy = self.policy()
self.assertEqual([mon["id"] for mon in self.planner.candidates(self.snapshot, policy)],
[self.manual_target["id"]])
self.assertEqual([action.payload["monsterId"] for action in self.planner.plan(self.snapshot, policy)],
[self.manual_target["id"]])
if __name__ == "__main__":
unittest.main()
@@ -535,6 +535,8 @@ class ProgressionGuiTests(unittest.TestCase):
tasks.assert_not_called()
records.assert_not_called()
window.set_presentation_active(True)
window.progression_filter.setCurrentIndex(window.progression_filter.findData(""))
window.progression_state_filter.setCurrentIndex(window.progression_state_filter.findData(""))
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)
@@ -610,6 +612,8 @@ class ProgressionGuiTests(unittest.TestCase):
self.wait(window)
self.mock_readers(window)
window.tabs.setCurrentWidget(window.progression_page)
window.progression_filter.setCurrentIndex(window.progression_filter.findData(""))
window.progression_state_filter.setCurrentIndex(window.progression_state_filter.findData(""))
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))
@@ -0,0 +1,260 @@
import os
os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
import copy
import threading
import time
import unittest
from unittest.mock import Mock
from PySide6 import QtWidgets as W
from PySide6.QtTest import QTest
from ranch_assistant import gui
from ranch_assistant.tests.test_core import workspace_temp
TASKS = [
{"task_type_id": "1101", "name": "主线进行中", "category": "mainline", "state": "received"},
{"task_type_id": "1102", "name": "主线待接取", "category": "mainline", "state": "unlocked"},
{"task_type_id": "1103", "name": "主线待领奖", "category": "mainline", "state": "ready_to_reward"},
{"task_type_id": "1104", "name": "主线已完成", "category": "mainline", "state": "finished"},
{"task_type_id": "1105", "name": "主线未解锁", "category": "mainline", "state": "locked"},
{"task_type_id": "1106", "name": "支线进行中", "category": "sidequest", "state": "received"},
{"task_type_id": "1107", "name": "主线受阻", "category": "mainline", "state": "received", "block_reason": "等级不足"},
]
class TaskStatusFilterTests(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 load_tasks(self, window, rows=TASKS):
reader = Mock(return_value=copy.deepcopy(rows))
records = Mock(return_value=[])
window.engine.progression_rows = reader
window.engine.progression_records = records
window.tabs.setCurrentWidget(window.progression_page)
self.wait(window, lambda: window.progression_views is not None
and not window.progression_table.row_batch.running)
return reader, records
def names(self, window):
return sorted(window.progression_table.item(row, 2).text() for row in range(window.progression_table.rowCount()))
def select(self, window, widget, value, *, wait=True):
index = widget.findData(value)
self.assertGreaterEqual(index, 0, value)
widget.setCurrentIndex(index)
if wait:
self.wait(window)
else:
self.app.processEvents()
def test_default_shows_only_current_mainline_and_reports_count(self):
with workspace_temp() as folder:
window = gui.Window(folder)
window.timer.stop()
try:
self.wait(window)
self.load_tasks(window)
self.assertEqual(window.progression_filter.currentData(), "mainline")
self.assertEqual(window.progression_state_filter.currentData(), "current")
self.assertEqual(self.names(window), sorted(["主线进行中", "主线待接取", "主线待领奖", "主线受阻"]))
self.assertIn("显示 4 / 7", window.progression_task_status.text())
self.select(window, window.progression_state_filter, "locked")
self.assertEqual(self.names(window), ["主线未解锁"])
self.select(window, window.progression_state_filter, "finished")
self.assertEqual(self.names(window), ["主线已完成"])
self.select(window, window.progression_state_filter, "ready_to_reward")
self.assertEqual(self.names(window), ["主线待领奖"])
finally:
window.close()
def test_aliases_and_blocked_received_are_filtered_by_lifecycle(self):
rows = TASKS + [
{"task_type_id": "1201", "name": "旧进行中", "category": "mainline", "state": "active"},
{"task_type_id": "1202", "name": "旧进行中别名", "category": "mainline", "state": "in_progress"},
{"task_type_id": "1203", "name": "旧待接取", "category": "mainline", "state": "available"},
{"task_type_id": "1204", "name": "旧未接取", "category": "mainline", "state": "unaccepted"},
{"task_type_id": "1205", "name": "旧待领奖", "category": "mainline", "state": "ready"},
{"task_type_id": "1206", "name": "旧已完成", "category": "mainline", "state": "completed"},
{"task_type_id": "1207", "name": "旧完成别名", "category": "mainline", "state": "complete"},
{"task_type_id": "1208", "name": "旧已领奖", "category": "mainline", "state": "claimed"},
{"task_type_id": "1209", "name": "委托已提供", "category": "commission", "state": "offered"},
]
with workspace_temp() as folder:
window = gui.Window(folder)
window.timer.stop()
try:
self.wait(window)
self.load_tasks(window, rows)
self.assertIn("主线受阻", self.names(window))
self.select(window, window.progression_state_filter, "received")
self.assertEqual(self.names(window), sorted(["主线进行中", "主线受阻", "旧进行中", "旧进行中别名"]))
self.select(window, window.progression_state_filter, "unlocked")
self.assertEqual(self.names(window), sorted(["主线待接取", "旧待接取", "旧未接取"]))
self.select(window, window.progression_state_filter, "ready_to_reward")
self.assertEqual(self.names(window), sorted(["主线待领奖", "旧待领奖"]))
self.select(window, window.progression_state_filter, "finished")
self.assertEqual(self.names(window), sorted(["主线已完成", "旧已完成", "旧完成别名", "旧已领奖"]))
self.select(window, window.progression_filter, "commission")
self.select(window, window.progression_state_filter, "unlocked")
self.assertEqual(self.names(window), ["委托已提供"])
self.assertEqual(window.progression_table.item(0, 3).text(), "待接取")
prepared = window.progression_views.tasks
offered = next(row for row in prepared if row["values"][0] == "1209")
self.assertEqual(offered["state"], "offered")
self.assertEqual(offered["lifecycle_state"], "unlocked")
finally:
window.close()
def test_status_category_search_combine_and_empty_state_is_clear(self):
with workspace_temp() as folder:
window = gui.Window(folder)
window.timer.stop()
try:
self.wait(window)
reader, _ = self.load_tasks(window)
self.select(window, window.progression_state_filter, "received")
self.select(window, window.progression_filter, "sidequest")
self.assertEqual(self.names(window), ["支线进行中"])
window.progression_search.setText("没有匹配")
self.wait(window)
self.assertEqual(self.names(window), [])
self.assertIn("没有符合", window.progression_task_status.text())
self.assertIn("共 7 条", window.progression_task_status.text())
self.assertEqual(reader.call_count, 1)
window.progression_search.clear()
self.wait(window)
self.select(window, window.progression_filter, "", wait=False)
self.select(window, window.progression_state_filter, "", wait=False)
self.assertEqual(len(self.names(window)), 7)
self.assertEqual(reader.call_count, 1)
finally:
window.close()
def test_refresh_retains_filters_and_filter_changes_never_request(self):
with workspace_temp() as folder:
window = gui.Window(folder)
window.timer.stop()
try:
self.wait(window)
reader, _ = self.load_tasks(window)
self.select(window, window.progression_filter, "sidequest")
self.select(window, window.progression_state_filter, "received")
window.progression_search.setText("支线")
self.wait(window)
reader.reset_mock()
window.engine.refresh_progression = Mock(
return_value=(window.engine.snapshot, [], "离线刷新"))
window.refresh_progression()
self.wait(window)
self.assertEqual(window.progression_filter.currentData(), "sidequest")
self.assertEqual(window.progression_state_filter.currentData(), "received")
self.assertEqual(window.progression_search.text(), "支线")
self.assertEqual(self.names(window), ["支线进行中"])
self.assertEqual(reader.call_count, 1)
reader.reset_mock()
self.select(window, window.progression_filter, "mainline")
self.select(window, window.progression_state_filter, "ready_to_reward")
self.select(window, window.progression_state_filter, "current")
self.assertEqual(reader.call_count, 0)
self.assertEqual(window.engine.refresh_progression.call_count, 1)
finally:
window.close()
def test_task_state_filter_does_not_affect_battle_records(self):
records = [
{"timestamp": 1700000000, "battle_kind": "task_battle", "name": "记录甲", "outcome": "win"},
{"timestamp": 1700000001, "battle_kind": "sweep", "name": "记录乙", "outcome": "completed"},
]
with workspace_temp() as folder:
window = gui.Window(folder)
window.timer.stop()
try:
self.wait(window)
reader, record_reader = self.load_tasks(window)
record_reader.return_value = copy.deepcopy(records)
self.select(window, window.progression_state_filter, "locked")
window.tabs.setCurrentWidget(window.battle_records_page)
self.wait(window, lambda: window.battle_records_table.rowCount() == 2)
self.assertEqual(window.battle_records_filter.currentData(), "")
self.assertEqual(window.progression_state_filter.currentData(), "locked")
self.select(window, window.battle_records_filter, "sweep")
self.assertEqual(window.battle_records_table.rowCount(), 1)
self.assertEqual(window.battle_records_table.item(0, 2).text(), "记录乙")
self.assertEqual(record_reader.call_count, 1)
self.assertEqual(reader.call_count, 1)
finally:
window.close()
def test_two_windows_have_independent_filters(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)
self.load_tasks(first)
self.load_tasks(second)
self.assertEqual(first.progression_filter.currentData(), "mainline")
self.assertEqual(second.progression_filter.currentData(), "mainline")
self.assertEqual(first.progression_state_filter.currentData(), "current")
self.assertEqual(second.progression_state_filter.currentData(), "current")
self.select(first, first.progression_filter, "sidequest")
self.select(first, first.progression_state_filter, "received")
self.assertEqual(self.names(first), ["支线进行中"])
self.assertEqual(second.progression_filter.currentData(), "mainline")
self.assertEqual(second.progression_state_filter.currentData(), "current")
self.assertEqual(self.names(second), sorted(["主线进行中", "主线待接取", "主线待领奖", "主线受阻"]))
finally:
first.close()
second.close()
def test_filter_changes_during_held_read_reuse_the_inflight_tasks(self):
with workspace_temp() as folder:
window = gui.Window(folder)
window.timer.stop()
entered = threading.Event()
release = threading.Event()
try:
self.wait(window)
def held_tasks():
entered.set()
if not release.wait(4):
raise TimeoutError("task fixture was not released")
return copy.deepcopy(TASKS)
reader = Mock(side_effect=held_tasks)
window.engine.progression_rows = reader
window.tabs.setCurrentWidget(window.progression_page)
self.assertTrue(entered.wait(2))
self.assertTrue(window.busy)
self.select(window, window.progression_filter, "", wait=False)
self.select(window, window.progression_state_filter, "", wait=False)
self.assertEqual(reader.call_count, 1)
self.assertFalse(window.pending_progression_view)
release.set()
self.wait(window, lambda: window.progression_table.rowCount() == 7)
self.assertEqual(reader.call_count, 1)
self.assertEqual(self.names(window), sorted(task["name"] for task in TASKS))
finally:
release.set()
self.wait(window)
window.close()
if __name__ == "__main__":
unittest.main()