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
+6 -6
View File
@@ -26,12 +26,12 @@
| 牧场与魔物管理 | 默认平铺全部魔物,可切换为按牧场折叠分组;显示容量、空位、普通等级上限、同种突破、突破经验、潜能阶段、资质、参考属性、好感上限及喜欢的物品。支持详情查看、多选锁定/解锁、派遣、指定喂养,以及确认费用后新建牧场。 |
| 自动孵蛋与补货 | 按手动规则完成金币市场买蛋/抽蛋、孵化、成长同步、成熟收取、派遣或喂养;默认只十连,可单独开启“允许单抽”,遵守金币保留和每日购蛋额度。空坑按优先级独立随机1~2秒装填,不受整体刷新间隔影响。 |
| 资质保留与经验喂养 | “背包 → 魔物蛋”的“牧场保留”默认1,是最低保留数量,0表示关闭数量保护;同种数量跨牧场及孵化批次统一保底。锁定、星级/资质保护仍可让实际保留数超过该值;资质提升依次按S项数、A项数、B项数、四项成长各自归一化后的平均值,与牧场已保留的同种最高资质比较,严格更高才额外保留,同分不额外保留,不自动解锁或强删旧魔物。经验喂养遵守普通等级上限;同种突破最高4级,每只同种素材增加1点突破经验,与潜能阶段分开计算。 |
| 自动突破与探险 | 牧场勾选突破目标并设置优先级,即授权先补满四项潜能、再提升潜能阶段,消耗对应元素材料并遵守物品/委托保留量,不购买材料、不消耗金币或氪金。自动探险默认关闭,每队配置地区、保留体力和队员,完成后先领奖再出发,不花钱开队或召回;未知请求持久化,新快照确认前不重发,停止策略后继续只读刷新。 |
| 自动突破与探险 | 牧场的“潜能突破设置”可定位目标及优先级列;勾选后先补满四项潜能、再提升潜能阶段,消耗对应元素材料并遵守物品/委托保留量,不购买材料、不消耗金币或氪金。顶部策略开启后自动领取已完成的探险奖励;再次出发默认关闭,按队配置地区、保留体力和队员。不花钱开队或召回;未知请求持久化,新快照确认前不重发,停止策略后继续只读刷新。 |
| 自动赠礼与好感培养 | 在背包选择物品、牧场选择目标后自动赠礼;跳过冷却目标,连续处理其他可送目标,在本地倒计时并到期核对状态。支持喜欢物品筛选、库存保留及当前好感上限。可在本地自动为每种魔物选择唯一培养代表,依次按等级、好感、成长资质比较,完全相同时随机选定并记住。 |
| 每日事务 | 查看并领取每日签到礼包、七日签到、累计奖励、已有VIP日奖和邮件附件;支持手动领取及按勾选项目自动领取。 |
| 自动主线 | 展示主线、支线、委托的状态、位置、NPC、需求、对话和阻塞原因;推进已支持的接取、线性对话、交付、领奖与任务补链。材料、蛋或击杀不足时,按已知来源规划普通地图收集;开图受前置、资源和战斗能力限制。 |
| 自动主线 | 默认显示当前进行中、待接取及待领奖的主线任务,可按类别、状态和关键词组合筛选,另行查看未解锁或已完成任务;展示位置、NPC、需求、对话和阻塞原因。推进已支持的接取、线性对话、交付、领奖与任务补链。材料、蛋或击杀不足时,按已知来源规划普通地图收集;开图受前置、资源和战斗能力限制。 |
| 自动委托 | 根据每日剩余次数、城市与库存接取委托,推进已支持的步骤并领奖;显示金币和氪金奖励,金币、道具及魔物提交可分别限制。实战委托已接入任务战斗调度,须开启对应选项并通过所选模式的能力检查;设置仍在“自动委托”。 |
| 战斗模式与记录 | “自动主线 → 推进策略”显式选择原版运行时(默认)或实验模拟(近似);按普通地图、任务专属战斗、任务通关战斗分别编排。记录胜负、模式、地图奖励事件和待核对原因,支持停止与中断恢复;局部能力不代表全部关卡可用。 |
| 战斗模式与记录 | 当前 GUI 隐藏运行时选择,统一强制使用内置实验模拟(近似);按普通地图、任务专属战斗、任务通关战斗分别编排。记录胜负、模式、地图奖励事件和待核对原因,支持停止与中断恢复;局部能力不代表全部关卡可用。 |
| 自动扫荡与挑战 | 按地区折叠显示关卡、难度、通关星级及可能掉落;账号地图本地缓存,手动刷新或挑战结束后同步进度。逐关勾选、选择已解锁难度和本日次数上限,配置保留体力与战队;满足扫荡条件时扫荡,未满星时可自动模拟挑战,战败显示“打不过”,支持探索奖励事件。可筛选普通或矿洞/门票关;资源关需单独开启,显示体力及每种工具的单次需求、实时可用库存和保留量。 |
| 掉落数据分析 | 按账号、关卡与难度在本地保存扫荡记录,默认合计扫荡和奖励事件,也可切换查看单一来源;展示合计样本拆分、出现次数、总数量、实测掉落率、平均数量和95%区间,事件独有产物一并展示。支持掉落率/每点体力获得数量的条形图,不额外请求游戏服务器。 |
| 收益资料与执行计划 | 内置749种魔物的培育时间、派遣金币、强化经验及每小时收益,支持名称/星级筛选和CSV/XLSX覆盖;执行计划显示下一步操作与等待原因。 |
@@ -43,13 +43,13 @@
在“自动主线 → 任务状态”点击“刷新任务 / 预览”,查看下一步和阻塞原因;到“推进策略”选择任务范围、推进战斗队伍、保留体力和交付限制,再勾选“启用自动主线策略”,用顶部绿色“开启”运行、红色“停止”暂停。规则自动保存,重启、恢复会话或导入配置后仍需手动开启。委托接取、交付和“也接取需要实战的委托”继续在“自动委托”配置。
- **内置战斗模拟**:无需选择运行时,程序使用原始数值资料,在独立进程中计算 AP、出场、移动、攻击和部分技能,等待计算出的战斗时长后提交结果。模型仍有机制近似与遗漏,可能和原版胜负不同,未支持的战斗会显示原因。
- **内置战斗模拟**:无需选择运行时,程序使用原始属性资料,在独立进程中计算 AP、出场、移动、攻击和部分技能;桌面模拟按已用修改客户端的规则,将我方打敌方的最终伤害乘10,单次最高50000,等待计算出的战斗时长后提交结果。模型仍有机制近似与遗漏,可能和客户端胜负不同,未支持的战斗会显示原因。
- **委托优先**:按奖励氪金数量20→15→10接取可处理的委托,优先执行委托步骤和材料补缺,再处理主线及普通牧场策略。缺少材料时使用现有扫荡/挑战来源;按委托缺口自动购买并孵化魔物蛋的联动留待后续实现。
- **地图与扫荡**:在“自动扫荡”勾选“未满星时自动挑战”,已解锁普通关卡可使用内置模拟首次挑战,无需开启自动主线;满足三个难度全部通关的条件后自动使用扫荡。普通地图直接发放探索奖励时按事件处理;当前任务占用的关卡交由自动主线处理。
- **矿洞与门票关卡**:在同一“自动扫荡”页筛选“矿洞与门票”,开启默认关闭的“允许矿洞 / 门票关卡”,再逐关勾选。仅显示原入口难度1,不采用残留的2/3级占位费用。此类关卡使用实际模型挑战结果,不伪装成扫荡;已提取战斗配置不等于模型支持或可通关,其他特殊关仍不可用。
- **中断恢复**:后台最长每2分钟自动核对角色与任务。模型已完成、等待时长被中断且结算从未发出的记录,在策略开启后自动续交保存的胜利结果;不重新开战或模拟。已经发出但结果不明的写请求不重发,继续核对服务器状态。
详细设置、能力限制与恢复方法见[辅助使用说明](ranch_assistant/README.md#v12-自动主线与战斗设置);阶段证据及待验收事项见[v1.2 实施与交接](analysis/V1_2_IMPLEMENTATION.md)。当前仍为开发版,尚未发布 v1.2 正式标签。
详细设置、能力限制与恢复方法见[辅助使用说明](ranch_assistant/README.md#v12-自动主线与战斗设置);逐项实测入口及结果模板见[v1.2 当前开发版验收清单](analysis/V1_2_ACCEPTANCE_CHECKLIST.md),阶段证据见[v1.2 实施与交接](analysis/V1_2_IMPLEMENTATION.md)。当前仍为开发版,尚未发布 v1.2 正式标签。
## 1.1.1 更新内容
@@ -77,7 +77,7 @@
资料包含1178个关卡和2079种道具名称;v1.2 的独立任务资料另含1165个任务、337个NPC和4269份剧情脚本,其中4239份属于已支持的线性类别,主线引用的720份中有718份属于该类别。脚本分类数量不代表任务或战斗全部通过;30份特殊选择等脚本、4类特殊接取入口及任务1001006的抽蛋钩子仍不支持。客户端热更新与当前账号资源是否一致尚未验证。
账号凭据、策略、地图缓存、购蛋/扫荡记录及统计数据库均保存在本机 `local_state/ranch_helper/`,按账号和角色隔离。
v1.2 常规回归检查497项,493项首轮通过,4项旧界面测试补齐异步等待后复测通过;14项原AIR长时间试跑不纳入常规回归。原版适配器最终集成仍待完成,自动原版开战准入保持关闭。各组准确数量及验证条件见[实施验证记录](analysis/V1_2_IMPLEMENTATION.md#验证记录)。本地模拟结果不代表真实账号通关、服务器接受结算或全部关卡支持。本轮开发验证未执行真实游戏请求,真实账号联网验收由用户手动进行;软件在用户开启策略后,可按配置和能力检查自动执行已支持操作。
v1.2 本轮完整模块隔离回归为56个模块共724项通过、0项跳过;单进程运行整套Qt测试曾出现崩溃,本轮采用逐模块独立进程验证。当前桌面自动战斗使用内置模拟的10倍伤害规则,原版适配器最终集成仍待完成。历史阶段记录见[实施验证记录](analysis/V1_2_IMPLEMENTATION.md#验证记录),当前验收范围见[验收清单](analysis/V1_2_ACCEPTANCE_CHECKLIST.md)。本地模拟结果不代表真实账号通关、服务器接受结算或全部关卡支持。本轮开发验证未执行真实游戏请求,真实账号联网验收由用户手动进行;软件在用户开启策略后,可按配置和能力检查自动执行已支持操作。
详细配置与实现范围见[辅助使用说明](ranch_assistant/README.md)。
## 项目目录与测试
+100
View File
@@ -0,0 +1,100 @@
# v1.2 当前开发版功能总结与实测验收清单
## 范围与使用方式
- 验收对象:`develop/v1.2.0` 当前开发代码,包含 `5082c2d` 矿洞更新及后续任务筛选、界面与战斗规则调整,版本 **1.2.0.dev1**;游戏资料基线为 Android **1.9.68**。比较基线为 `v1.1.1`,本清单只列这一区间的变化,不把既有登录、背包等历史功能算作新增。
- 当前是**开发版**,不是正式版 1.2;本次不合并 `main`,不新增功能。以下“已实现”仅表示 HEAD 已有对应代码或界面,所有真实游戏闭环仍以用户实测为准。
- 桌面 GUI 已隐藏运行时选择,读取及加载策略时均强制使用 `experimental` 内置实验模拟。原 AIR 研究工具不属于当前桌面自动战斗的可选模式。
- 每条 `[ ]` 仅表示“待逐项核对”,不是预先判定通过。测试后在文末记录“通过 / 失败 / 未测”;受阻或不支持应按实际表现记录,不能为了让条目通过而绕过限制。
- 建议先用离线演示熟悉入口,再用可接受资源消耗的测试角色少量验证。记录只使用“账号 A / B”等别名;不要粘贴账号、密码、会话、设备标识、本机路径或私有日志。
## 1. 自动主线
- [ ] **1. 刷新、筛选与预览**:进入“自动主线 → 任务状态”,默认只显示进行中、待接取及待领奖的主线,当前受阻任务不能被隐藏。组合切换类别、状态和关键词,可查看未解锁或已完成任务;筛选不发送游戏请求,刷新后保持所选筛选。点击“刷新任务 / 预览”应显示位置、需求、下一步及阻塞原因;预览本身不交付物品、不开战。
- [ ] **2. 已支持任务推进**:在“推进策略”选择主线或支线,按需启用接取、对话和补链,再启用“自动主线策略”并点击顶部“开启”。已支持的接取、线性对话、满足条件后的交付、领奖及后继任务应逐步推进;特殊剧情应明确受阻。
- [ ] **3. 缺口收集**:启用“自动收集任务材料 / 击杀目标”,构造材料、蛋或击杀缺口。应仅从符合当前位置、解锁、保留资源和战斗能力的已知来源规划普通地图;扫荡不能冒充击杀来源。
- [ ] **4. 本地导航不往返刷屏**:让已支持的剧情在牧场、孵化场等本地位置间连续推进。到达当前步骤位置后应继续该步骤,不应因另一本地目标在两个导航动作之间反复切换;服务器状态未确认时不得伪造推进。
## 2. 自动委托
- [ ] **5. 独立运行**:只启用“自动委托”和顶部“开启”,不启用自动主线。已配置的委托仍应检查、接取、推进和领奖,不要求同时开启主线策略。
- [ ] **6. 奖励优先与降级**:准备多份可接委托,观察“需求 / 进度”。应按氪金奖励 20 → 15 → 10 优先;高奖励委托因条件或战斗能力无法处理时,应继续检查其他同奖励或较低奖励委托。
- [ ] **7. 交付限制**:分别核对道具、魔物、金币和实战开关,设置库存保留及单次金币上限。只有获授权且满足条件的交付才可执行;保护目标及保留库存不得被消耗,完成后奖励与任务状态应刷新。
- [ ] **8. 战斗委托准入**:开启“也接取需要实战的委托”,在“自动主线 → 推进策略”配置队伍、保留体力等。接取前应逐份检查实验模型和队伍能力;不支持或正在探险的队伍应说明原因,不能因开启开关就视为全部委托可完成。
## 3. 自动扫荡与未通关挑战
- [ ] **9. 普通扫荡配置**:进入“自动扫荡”,逐关勾选,选择已解锁难度及本日上限,配置保留体力和战队,再启用“启用勾选关卡自动刷图”。仅满足游戏扫荡条件的关卡应执行扫荡,并遵守逐关次数和体力限制。
- [ ] **10. 关闭挑战**:保持“未满星时自动挑战”未勾选。可扫荡关应照常扫荡;未满足扫荡条件的关卡不得借此进入挑战,也不能要求开启自动主线。
- [ ] **11. 未满星挑战**:勾选“未满星时自动挑战”,选择已解锁但尚未满足扫荡条件的普通关。能力检查通过后才进入实验模拟;核对我方对敌最终伤害10倍、单次最高50000,敌方伤害不变,等待对应时长再处理结果;自然失败应显示“打不过”,不得记为胜利。
- [ ] **12. 战败与地图状态**:完成一次挑战或制造一次明确战败,再刷新地图。记录应保留模式、结果及原因;只有服务器确认的新进度才能更新通关状态,战败不能发放或伪造扫荡奖励。
## 4. 矿洞与门票关卡
- [ ] **13. 双重启用**:在“自动扫荡”筛选“矿洞与门票”,先确认“允许矿洞 / 门票关卡”默认关闭。仅开启总开关不应刷资源关;还须逐关勾选,反过来只逐关勾选也不应绕过总开关。
- [ ] **14. 入场资源核对**:查看资源关的原入口难度、体力、每种工具单次需求、可用库存和保留量。体力不足、工具不足或触及保留量时应阻止入场,不应套用普通关的占位费用。
- [ ] **15. 挑战路径**:为受支持的矿洞或门票关配置战队并开启策略。应走实际实验模型挑战,不得伪装成扫荡;模型不支持、资源变化或队伍不可用时,应显示原因且不发送入场请求。
- [ ] **16. 范围边界**:尝试一个未列入当前支持范围的特殊关。应明确显示不支持或等待处理,不得把“已提取配置”当作可通关;资源关结算及库存变化须以游戏实际结果复核。
## 5. 孵蛋、保留与同种喂养
- [ ] **17. 补蛋方式**:在“自动孵蛋 → 孵蛋策略”配置市场、保留金币和每日购蛋额度。默认仅十连抽;单独开启“允许单抽”后才可单抽,实际花费、购蛋数量及额度应符合设置。
- [ ] **18. 空坑装填**:准备可用蛋和空坑,开启自动填充。应随机等待约 1~2 秒后逐坑装填,每次重新读取坑位和库存;快速装填不能顺带购蛋、派遣或执行其他策略。
- [ ] **19. 牧场保留**:在“背包 → 魔物蛋”设置“牧场保留”,分别核对默认值、0 和更高数值。同种最低保留应跨牧场及孵化批次合计;例如已有 AASA 同种代表时,新魔物 SSAS 应优先额外保留,已有 SSAS 同种代表时新魔物 AASA 则不应额外保留;旧锁定魔物仍受保护,因此实际保留总数可以超过最低值 1,不得自动解锁或强行派遣旧魔物。
- [ ] **20. 同种突破喂养**:在牧场喂养列表设置目标及优先级,数字小的先喂,不另设喂养目标;当前目标达到等级上限后应换下一只。使用同种素材并观察详情,普通经验等级仍受等级上限约束;同种喂养提升的是 `tpLevel / tpExp`,每只同种素材增加 1 点突破经验、突破等级最高 4 级,实际升级以服务器状态为准。它不是潜能材料突破。
## 6. 潜能强化与潜能突破
- [ ] **21. 自动目标及职责**:在牧场选中魔物,点击“潜能突破设置”应定位到自动突破目标及优先级列,勾选并设置优先级。该选项只授权 `BreakthroughPlanner` 的材料补潜能及 `potentialLevel` 阶段突破,**不是独立的同种喂养按钮**;定位按钮不改变勾选、优先级或原选择,同种喂养仍由喂养策略控制。
- [ ] **22. 先补满四项潜能**:准备四项潜能未满且材料充足的目标。应按攻击、防御、生命、敏捷缺口逐项使用对应元素材料,每次操作后重读状态;不购买材料,不消耗金币或氪金。
- [ ] **23. 再提升潜能阶段**:准备四项均达当前阶段上限的目标。应消耗对应阶段材料提升 `potentialLevel`,再进入下一阶段;不得把此结果记为同种喂养的 `tpLevel / tpExp` 增长。
- [ ] **24. 保留与不足**:设置物品、赠礼及委托保留量,再测试材料不足、材料被锁定或目标达到当前上限的情况。不得动用受保护库存或强行突破,应显示等待原因;未勾选的目标不规划突破。
## 7. 自动探险
- [ ] **25. 队伍配置**:进入“自动探险”,逐队设置开关、地区、保留体力,选择“自动选三只”或三只手动队员。未解锁、缺人或体力不满足时应显示原因,且不能阻断牧场等其他独立策略。
- [ ] **26. 自动领奖与再次出发**:准备已完成的探险队,开启顶部策略;即使“自动安排再次探险”和该队开关关闭,也应先自动领奖并释放队员。只有开启再次探险及对应队伍后才重新出发;不得花钱开队或提前召回,奖励与下一次出发状态需刷新确认。
- [ ] **27. 探险中禁止战斗**:让至少一只所选战队成员处于探险中,再分别尝试主线、委托或地图挑战。应提示有成员正在探险,整队空闲前不得开战,也不得剔除忙碌成员后残缺上阵。
- [ ] **28. 请求确认**:在出发或领奖后观察状态,必要时中断并重开应用。新快照未确认前不得重复发送同一探险写请求;默认关闭的探险总开关不得因普通刷新自行开启。
## 8. 奖励事件与掉落统计
- [ ] **29. 默认合计口径**:进入“数据分析”,选择已有扫荡和奖励事件样本的关卡与难度。默认“扫荡+奖励事件”应合计样本、金币、经验、物品、掉落率和体力效率,并显示两类样本数拆分。
- [ ] **30. 来源切换**:切换“普通扫荡”“奖励事件”及合计来源。表格、图表和摘要应只统计当前来源,不同难度仍分开;切换本地统计不应触发新的游戏请求。
- [ ] **31. 事件独有奖励**:准备包含事件独有物品的已确认事件。普通地图开始即发奖励时应单独记录事件,不运行战斗、不重复提交战斗奖励;事件独有物品应出现在统计中。
- [ ] **32. 指标边界**:核对同次多件、无样本和未知体力消耗的记录。同次多件只增加一次出现次数,无样本显示“—”,未知消耗不参与体力效率;实测率和 95% 区间不得被表述为官方掉率。
## 9. 调度、停止与中断恢复
- [ ] **33. 子功能独立开关**:分别取消孵蛋或突破的目标勾选,或关闭赠礼、委托、扫荡、主线中对应功能的“启用”项。关闭后不得再发该功能的新写请求;其他仍启用且满足条件的策略应独立继续,不能互相误停。探险的再次出发开关只停止新出发,已完成队伍仍自动领奖;顶部停止才禁止全部新写操作。
- [ ] **34. 顶部停止**:运行中点击顶部红色“停止”。后续推进和可取消的模型/时钟等待应取消,之后的刷新只读不写;已经发出的请求仍须等待确认,不能假定停按钮能撤销服务器操作。
- [ ] **35. 中断续交与未知结果**:在模型已完成、仅等待战斗时长且结算尚未发出时中断,再开启对应策略。应续交保存的同一胜利结果,不重新入场或模拟;已发出但结果未知的请求只核对服务器状态,不得自动重发。
- [ ] **36. 随机监控节奏**:选择随机 30 秒、60 秒、2 分钟或 5 分钟上限,同时运行快速孵蛋或探险。整体监控仍应每轮完成后重新随机取间隔,快速计时器只处理自身动作,不应加速普通轮询;待核对状态最长每 2 分钟后台核对。
## 10. 多账号、配置与分组
- [ ] **37. 账号隔离**:以账号 A、B 分别登录或恢复会话,配置不同规则并切换账号窗口。各账号请求应串行且后台独立,角色状态、策略和本地记录不得串用;批量开启/停止及单账号控制应符合所执行操作。
- [ ] **38. 导入导出安全**:通过菜单“策略配置”导出再导入当前账号配置。规则应保留,但顶部执行开关及探险总开关应保持关闭,须人工核对后开启;文件不得含凭据、会话、本机路径、执行日志或服务器进度。
- [ ] **39. 跨账号目标匹配**:向账号 B 导入账号 A 的喂养、突破和探险配置。培养目标按魔物种类重新匹配,探险队按队序绑定、手动队员按种类匹配;不得复用账号 A 的魔物实例编号,缺失目标应留待核对。
- [ ] **40. 牧场分组与完整规则**:在“牧场”切换“全部魔物 / 按牧场分组”及具体牧场筛选,并切换其他页面。显示分组和筛选应正确,隐藏页规则仍被保存、导入和导出,切换视图不应清空培养或战斗设置。
## 已知未完成与验收限制
- **委托到买蛋孵化的联动未完成**:已接委托所需种类和蛋可纳入保留,但按委托缺口自动买蛋、再孵化并交付的完整链路尚未实现。
- **特殊剧情及战斗机制覆盖不全**:特殊选择等脚本、部分接取入口、特殊抽蛋钩子以及未实现技能、触发器和场地机制仍可能受阻;资料数量或结构准入不等于通关率。
- **实验模型存在近似**:桌面模拟按我方对敌最终伤害10倍、单次最高50000计算,角色属性本身不乘倍;离线研究默认仍为原始1倍。移动、攻击、技能、装备、随机与时序等不能视为原版完整复现。模型胜负、计时和服务器是否接受结算均须真实游戏验收。
- **战斗记录的人话转换未完全覆盖**:缺少名称时仍可能回退显示任务或关卡编号,内部结果 `local` 也可能直接出现;不能声称记录已全部中文化。
- **线上验证尚未完成**:最新验证没有调用真实游戏 API,没有真实账号任务、开战、结算、领奖及资源消耗结果。本清单中的联网条目默认均为未测。
- **本地验证的范围**:本轮 **56 个模块隔离测试,共 724 项通过、0 项跳过**。单进程运行整套 Qt 测试曾出现崩溃,因此本轮采用逐模块独立进程验证,不将隔离回归结果解释为线上验收通过。
## 实测结果记录模板
测试对象:版本 `1.2.0.dev1` / 提交号:____;账号别名:____;测试日期:____。
| 功能(编号与名称) | 结果(通过 / 失败 / 未测) | 前置条件与预期 | 复现步骤 | 实际结果(脱敏) |
| --- | --- | --- | --- | --- |
| 例:1. 刷新与预览 | 未测 | 已进入任务状态页;只刷新,不执行交付或开战 | 1. 打开页面;2. 点击刷新;3. 核对任务详情与资源变化 | |
| | | | | |
| | | | | |
失败记录应附上可重复的最短步骤、实际提示及测试前配置;证据仅保留必要的脱敏摘要,不提交账号、设备、路径、会话或私有日志。
+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()