Refine ranch tree, growth sync and monitoring policies

This commit is contained in:
AttilaNet
2026-11-08 09:53:02 +08:00
parent a37627b490
commit 9611a3413f
24 changed files with 640 additions and 1227 deletions
+28 -76
View File
@@ -18,14 +18,15 @@
数量归零后保留规则;可添加当前无库存的蛋。未勾选的蛋不会自动孵化或触发补货。 数量归零后保留规则;可添加当前无库存的蛋。未勾选的蛋不会自动孵化或触发补货。
各物品分类支持名称筛选,显示数量、品质和售价;可为物品设置赠礼开关及至少保留数量。只刷新当前打开的分类表格。 各物品分类支持名称筛选,显示数量、品质和售价;可为物品设置赠礼开关及至少保留数量。只刷新当前打开的分类表格。
- 牧场:合并魔物与牧场列表,可按牧场筛选或查看全部魔物;按钮或右键可新建金币/氪金牧场,提交前确认费用。 - 牧场:合并魔物与牧场列表,可按牧场筛选或查看全部魔物;按钮或右键可新建金币/氪金牧场,提交前确认费用。
“按牧场分组”使用可折叠树形:牧场标题显示数量、容量和空位,下方直接列出所属魔物;空牧场也保留显示,培育室魔物单独分组。
勾选喂养/赠礼目标并分别设置优先级;显示突破、当前等级上限、成长资质、参考属性、当前好感上限和喜欢的物品。 勾选喂养/赠礼目标并分别设置优先级;显示突破、当前等级上限、成长资质、参考属性、当前好感上限和喜欢的物品。
双击查看详情;右键可锁定、解锁、派遣、喂给指定魔物。 双击查看详情;右键可锁定、解锁、派遣、喂给指定魔物。
- 每个页面的表格和空白处可右键“刷新本页”;刷新只读取状态,不执行派遣、喂养等策略。 - 每个页面的表格和空白处可右键“刷新本页”;刷新会同步到期的成长状态,不执行派遣、喂养等消耗类策略。
- 多账号:同一程序内多个独立账号页签,各自监控、自动执行、记录日志;切换页签不停止其他账号。 - 多账号:同一程序内多个独立账号页签,各自监控、自动执行、记录日志;切换页签不停止其他账号。
- 会话保存:成功读取角色后自动加密保存 Token、账号/区服/角色和请求编号,重启后可恢复。 - 会话保存:成功读取角色后自动加密保存 Token、账号/区服/角色和请求编号,重启后可恢复。
- 自动孵蛋:按手动规则执行,提供开始执行、仅监控、停止按钮;支持十连优先、金币保留和每日购蛋额度。 - 自动孵蛋:按手动规则执行,提供开始执行、仅监控、停止按钮;支持十连优先、金币保留和每日购蛋额度。
5/10/30/60 秒刷新;喂养遵守当前突破上限,满级后转到下一喂养目标。 可选随机30秒、60秒、2分钟或5分钟,每轮刷新完成后从0到所选上限重新取间隔;喂养遵守当前突破上限,满级后转到下一喂养目标。
原“牧场策略”并入此页的“牧场与赠礼策略”子页;可导出、导入培养策略,跨账号按魔物种类匹配目标。 原“牧场策略”并入此页的“牧场与赠礼策略”子页,内容超出高度时滚动显示;可导出、导入培养策略,跨账号按魔物种类匹配目标。
导入后所有自动执行开关保持关闭,文件不包含账号、密码、Token、会话或本机路径。 导入后所有自动执行开关保持关闭,文件不包含账号、密码、Token、会话或本机路径。
- 自动赠礼:在背包勾选可用物品,在牧场勾选目标并设置优先级,再到“牧场与赠礼策略”启用。 - 自动赠礼:在背包勾选可用物品,在牧场勾选目标并设置优先级,再到“牧场与赠礼策略”启用。
每次消耗一件物品,默认只使用目标喜欢的物品;遵守当前羁绊好感上限、赠礼间隔、物品保留数量及委托保留。 每次消耗一件物品,默认只使用目标喜欢的物品;遵守当前羁绊好感上限、赠礼间隔、物品保留数量及委托保留。
@@ -39,16 +40,11 @@
支持复制/导出,自动保存本地脱敏日志。 支持复制/导出,自动保存本地脱敏日志。
- 自动委托:按每日剩余接取次数、解锁城市和库存,接取、推进已满足条件的步骤、 - 自动委托:按每日剩余接取次数、解锁城市和库存,接取、推进已满足条件的步骤、
领取奖励;列表显示奖励金币和氪金数量。提交金币、道具、魔物分别受策略限制。战斗步骤等待游戏实际完成。 领取奖励;列表显示奖励金币和氪金数量。提交金币、道具、魔物分别受策略限制。战斗步骤等待游戏实际完成。
- 地图关卡:按地区折叠显示安装包内的关卡、难度、掉落及账号解锁/通关记录, - 自动扫荡:按地区折叠显示安装包内的关卡、难度、掉落及账号解锁/通关记录,
每关可勾选、选择已解锁难度和本日上限;满足游戏原有条件的普通关卡可接口扫荡, 每关可勾选、选择已解锁难度和本日上限;满足游戏原有条件的普通关卡可接口扫荡,
其余可设为 ADB 自动战斗目标。 其余请在游戏内手动战斗。
- 每日事务:集中查看每日签到礼包、七日签到、累计奖励、VIP日奖和邮件附件; - 每日事务:集中查看每日签到礼包、七日签到、累计奖励、VIP日奖和邮件附件;
可立即领取勾选项目,或开启监控时自动领取。刷新本身只读。 可立即领取勾选项目,或开启自动执行时领取;手动刷新不领奖。
- 页面截图配置:每个页面一个截图按钮,自动保存原图与设备、分辨率、关卡、难度。
截图无需登录或 Token,不会点击或切换手机页面;由助手查看样本后生成按钮配置。
- 布丁史莱姆牧场:通过 ADB 操作手机里的实际战斗;根据当前体力、
入场券和自定每日轮数决定是否继续,支持自动开战、倒计时、自动战斗、
结算按钮识别、失败停止和超时停止。完成一次界面标定后可循环运行。
- 离线演示:不连接游戏服务器即可查看数据、策略和模拟操作。 - 离线演示:不连接游戏服务器即可查看数据、策略和模拟操作。
## 连接真实角色 ## 连接真实角色
@@ -66,7 +62,7 @@
每行可选包含该蛋的金币市场;蛋用完后这一行仍会保留。规则自动保存。 每行可选包含该蛋的金币市场;蛋用完后这一行仍会保留。规则自动保存。
5. 到“自动孵蛋”启用需要的买蛋、孵蛋、派遣、收取或喂养开关。 5. 到“自动孵蛋”启用需要的买蛋、孵蛋、派遣、收取或喂养开关。
点“刷新 / 预览”查看下一步,再点“开始执行勾选功能”。页面会显示“执行中”、 点“刷新 / 预览”查看下一步,再点“开始执行勾选功能”。页面会显示“执行中”、
下一步操作或等待原因。“仅监控”和手动刷新不会执行策略;“停止执行”保留只读监控。 下一步操作或等待原因。“仅监控”和手动刷新会自动同步到期的成长状态,但不会派遣、喂养、购蛋或领奖;“停止执行”保留监控。
已经发送的请求会返回,停止后不发送下一项。重启或恢复会话后需重新点开始执行。 已经发送的请求会返回,停止后不发送下一项。重启或恢复会话后需重新点开始执行。
6. 需要经验时,在“牧场”勾选接收经验的喂养目标并设置优先级。优先级数字小的先喂,达到当前突破上限后换下一个; 6. 需要经验时,在“牧场”勾选接收经验的喂养目标并设置优先级。优先级数字小的先喂,达到当前突破上限后换下一个;
在“自动孵蛋 → 牧场与赠礼策略”可设全局停止等级、星级/资质保护和保留蛋数量。“收益资料”的星级勾选只筛选表格显示。 在“自动孵蛋 → 牧场与赠礼策略”可设全局停止等级、星级/资质保护和保留蛋数量。“收益资料”的星级勾选只筛选表格显示。
@@ -106,25 +102,25 @@
1. 每个账号使用独立页签。用顶部“新增账号页签”添加账号,用页签或“打开已保存账号”切换。 1. 每个账号使用独立页签。用顶部“新增账号页签”添加账号,用页签或“打开已保存账号”切换。
2. 每个账号首次在本版本正常登录一次;此前版本只保存在内存的 Token 不能从脱敏日志补回。 2. 每个账号首次在本版本正常登录一次;此前版本只保存在内存的 Token 不能从脱敏日志补回。
3. 重启后在“登录”页点击“恢复选中会话”,或在顶部点击“恢复各页签的保存会话”。 3. 重启后在“登录”页点击“恢复选中会话”,或在顶部点击“恢复各页签的保存会话”。
恢复会先读取角色并核对角色编号,成功后才显示为真实数据;不会自动开启策略或刷图。 恢复会先读取角色并核对角色编号,成功后才显示为真实数据;不会自动开启消耗类策略。
4. 各页签可分别开启监控和自动执行。顶部“全部开始监控”只开启已连接账号的监控, 4. 各页签可分别开启监控和自动执行。顶部“全部开始监控”只开启已连接账号的监控,
自动执行仍由各账号的勾选决定;“全部停止”停止所有页签的监控和刷图。 自动执行仍由各账号的勾选决定;“全部停止”停止所有页签的监控和自动执行。
5. 关闭一个页签会停止该账号,其他账号继续运行;保存的账号和会话仍可再次打开。 5. 关闭一个页签会停止该账号,其他账号继续运行;保存的账号和会话仍可再次打开。
账号工作区各自保存凭据、会话和日志;区服/角色各自保存策略、喂养目标、截图和刷图次数。 账号工作区各自保存凭据、会话和日志;区服/角色各自保存策略、喂养目标和扫荡次数。
切换区服时不沿用其他角色的策略。相同账号区服不会在两个页签重复运行。 切换区服时不沿用其他角色的策略。相同账号区服不会在两个页签重复运行。
会话的请求编号在发送前保存,包括超时未确认的请求;写请求不会自动重发。 会话的请求编号在发送前保存,包括超时未确认的请求;写请求不会自动重发。
删除保存会话需先退出登录,再点击“删除选中保存会话”;也可使用“退出登录并清除登录记录”一次清理当前账号页签。 删除保存会话需先退出登录,再点击“删除选中保存会话”;也可使用“退出登录并清除登录记录”一次清理当前账号页签。
“记住账号和密码”只控制密码,独立于会话保存。 “记住账号和密码”只控制密码,独立于会话保存。
正常会话心跳按客户端的 240 秒周期运行。ADB 刷图中,同一台手机同时只允许一个账号页签控制; 正常会话心跳按客户端的 240 秒周期运行;成长状态按阶段到期触发同步。需要实际战斗的关卡在游戏内手动进行。
不同手机可分别配置。未实现脚本检测规避,也不保证服务端无法识别自动化。
## 页面数据与刷新 ## 页面数据与刷新
“培育室”“背包”“牧场”可直接查看状态,顶部显示坑位、蛋数量、物品、魔物、牧场数量和更新时间。 “培育室”“背包”“牧场”可直接查看状态,顶部显示坑位、蛋数量、物品、魔物、牧场数量和更新时间。
表格或页面空白处右键选择“刷新本页”,保持当前页面;请求进行中再次刷新会排队。 表格或页面空白处右键选择“刷新本页”,保持当前页面;请求进行中再次刷新会排队。
收益资料和截图配置页刷新本地资料。自动刷新的 5/10/30/60 秒间隔继续保留。 收益资料页刷新本地资料;已移至最后。状态轮询支持随机30秒、60秒、2分钟和5分钟,每轮完成后从0到所选上限取间隔。
当前客户端代码可确认240秒会话心跳和成长阶段到期结算,未找到统一的全量状态轮询周期;阶段同步独立于随机轮询,不必等下一轮。
已修复实际响应里 `activityHistory.vipInfo=null` 导致策略报错、阻止数据显示的问题。 已修复实际响应里 `activityHistory.vipInfo=null` 导致策略报错、阻止数据显示的问题。
已用实际角色响应回放验证 4 个坑位、4 类蛋、4 只魔物和 1 个牧场能显示。 已用实际角色响应回放验证 4 个坑位、4 类蛋、4 只魔物和 1 个牧场能显示。
@@ -179,11 +175,13 @@
## 手动管理与扩建 ## 手动管理与扩建
孵化与幼体成长阶段显示“待成熟后生成”,不把服务端的零值算成 C 资质。 孵化与幼体成长阶段显示“待成熟后生成”,不把服务端的零值算成 C 资质。
自动执行会在两个阶段转换时请求成长结算,并使用结算响应中的阶段和四项成长值更新界面; 登录后在两个阶段到期时自动请求成长结算,并使用结算响应中的阶段和四项成长值更新界面;
成熟、资质确定后才决定派遣、喂养或保留,旧查询结果不会覆盖尚未确认回写的结算数据。 成熟、资质确定后才决定派遣、喂养或保留,旧查询结果不会覆盖尚未确认回写的结算数据。
培育室的“同步孵化 / 成长”可单独更新这些状态,本次不执行派遣或喂养。 培育室无需手动同步;阶段到期会在后台同步,即使未开启整体监控也会检查。服务器暂未确认时会限频等待,避免连续发送。
“仅监控”不会结算或派遣;需点“开始执行勾选功能”才能自动处理。 “仅监控”可以同步成长;派遣、喂养等操作仍需点“开始执行勾选功能”。
保留原因会显示在培育室建议和日志中,例如达到保留星级、综合资质A/S、锁定或未启用派遣。 资质保留条件新增“四项全S(4S)才保留”,要求攻、防、生命、敏捷分别为S;综合评级为S不等于4S。
锁定、队伍、保留星级、资料不完整等保护独立生效;若希望低星魔物仅按4S保留,请同时检查保留星级设置。
保留原因会显示在培育室建议和日志中。
培育室与牧场派遣都使用 `monsterService/monsterSell` 的 `monsterIds` 数组参数, 培育室与牧场派遣都使用 `monsterService/monsterSell` 的 `monsterIds` 数组参数,
不需要先收取到牧场。旧版培育室误用了遗留包装的 `monsterId` 字段,会触发服务端997 不需要先收取到牧场。旧版培育室误用了遗留包装的 `monsterId` 字段,会触发服务端997
“网络错误”;现已统一修正自动派遣和右键手动派遣。 “网络错误”;现已统一修正自动派遣和右键手动派遣。
@@ -201,69 +199,23 @@
费用变化会要求重新确认。取消确认不会发送请求,超时不会自动重复购买。 费用变化会要求重新确认。取消确认不会发送请求,超时不会自动重复购买。
- 实测日志里的空坑是 `monsterId=-1`,已按客户端 `<=0` 规则修复;此前买到蛋却不孵化的原因就是误判空坑。 - 实测日志里的空坑是 `monsterId=-1`,已按客户端 `<=0` 规则修复;此前买到蛋却不孵化的原因就是误判空坑。
## 页面截图配置(推荐)
1. 手机启用 USB 调试并允许 ADB。在“体力刷图”填写 ADB 路径(本机已自动找到),
选择关卡和难度。只有一台手机时设备编号可留空。
2. 打开“页面截图配置”。自己玩到对应页面时,点击该行“截取此页面”。
每次截图会暂停当前辅助监控和刷图;不自动登录、开战或跳转页面。
3. 最少拍齐“关卡准备页”(标题、难度、进入按钮)和“胜利结算页”(胜利标识、确认按钮)。
按需补拍“战斗倒计时”“自动关闭”“自动开启”“后续确认”“失败结算”五页。
不必特意输一局来收集失败页。点击页面行可预览已有图片。
4. 截图自动保存在项目目录:
当前角色目录下的 `capture_profiles/<设备>/<宽x高>/<关卡>_<难度>/`。
登录角色的目录为 `<账号工作区>/roles/<角色标识>/`,软件会显示实际路径。
原图为页面英文标识命名的 PNG,`profile.json` 保存设备、分辨率、时间和图片摘要。
“打开截图文件夹”可查看;重启后通过下拉框找回配置。
5. 拍好后告知助手“截图好了”。助手直接读取此工作区的文件,查看按钮位置,
生成同目录 `buttons.json` 和裁剪模板,不需要你手工框选或提供 Token。
这一步由助手完成,Qt 程序本身不包含自动理解任意截图的模型。
6. 点击“加载已生成的按钮配置”,然后用真实会话核对体力、入场券,
让手机停在相同账号的所选关卡准备页,设置每日轮数,开始刷图。
按钮配置绑定设备、分辨率、关卡、难度及生成时的截图摘要。重新拍摄改变了内容,
或更换设备/分辨率时需要重新生成。胜利标识的识别位置和确认按钮的点击位置可分开。
保留“体力刷图”里的手工框选作为可选工具;推荐流程不需要使用它。
必须同时匹配关卡名称与进入按钮才会开始一轮。请保持同一画面布局,
不要手动切换其他关卡或应用。分辨率/界面布局变化后需要重新标定。
模板匹配无法理解任意游戏弹窗;未知画面会等待,并在单轮超时后停止。
当前 APK 的 `bd00` 一般难度数据为 6 体力 + 道具 20047 一枚入场券,
`bd01` 使用另外一种入场券;程序按对应关卡配置检查,不把“免费”当成
“不限次数”。本地每日轮数按北京时间和角色/关卡分别持久化,统计已开始
的尝试,包括中断或失败;它不是服务器的每日次数查询接口。服务器的
入场券余量也会独立检查。暂未找到该活动独立的每日次数字段,不声称已
读取到该字段,遇到服务器限制或未知弹窗会停止/超时退出自动流程。
## 文件与验证 ## 文件与验证
- 工作区:首账号使用 `local_state/ranch_helper/`,新增账号使用其 `profiles/<编号>/`。 - 工作区:首账号使用 `local_state/ranch_helper/`,新增账号使用其 `profiles/<编号>/`。
`sessions/` 是加密会话;`roles/<角色标识>/` 是各角色的策略、截图和本日次数。 `sessions/` 是加密会话;`roles/<角色标识>/` 是各角色的策略和本日次数。
- `catalog.json` 是本地数据;游戏热更新后的新魔物/新售价需要更新资料。 - `catalog.json` 是本地数据;游戏热更新后的新魔物/新售价需要更新资料。
未知魔物和不完整资质不会自动派遣或喂养。 未知魔物和不完整资质不会自动派遣或喂养。
- 自定义表:`typeId, sell_money, sell_exp, time_total`(秒),可只提供部分 - 自定义表:`typeId, sell_money, sell_exp, time_total`(秒),可只提供部分
覆盖列;中文列名“编号、派遣金币、强化经验、孵化秒数”也支持。 覆盖列;中文列名“编号、派遣金币、强化经验、孵化秒数”也支持。
- 测试:`python -m unittest discover -s ranch_assistant/tests -v`。 - 测试:`python -m unittest discover -s ranch_assistant/tests -v`。
- 122 项测试通过,包含双账号慢网络与大量库存的界面响应、后台账号不重建表格、控件复用、 - 127 项本地测试通过,覆盖登录、会话隔离、请求计数、成长同步、孵蛋与补货、批量喂养、派遣、赠礼、委托、扫荡和每日奖励。
批量喂养和培育室派遣997的加密HTTP回归;覆盖难度列表解析、扫荡条件/请求顺序/异常暂停/跨角色每日额度、 新增牧场树形/平铺切换、分组数量与空位、刷新保留折叠和控件、4S保留条件、随机刷新间隔及到期独立同步的回归测试。
签到与邮件JSON/空VIP/时间单位/失败不重试、树形规则恢复和截图页不重叠;以及 双账号与大量库存的界面响应继续通过测试;测试使用本地模拟数据和模拟服务,不操作真实账号库存。
加密HTTP十连→实际赠蛋→负数空坑孵化→成长结算→派遣→余额刷新、逐种优先级和补货、
多目标喂养优先级、锁定/手动派遣/喂养、开坑与建牧场的费用复核和取消确认、金币/库存/每日额度限制、
购蛋超时记账、突破等级上限、星级筛选、启动/停止/忙时排队和委托奖励显示;也覆盖多账号并行/重启恢复、账号和角色隔离、请求计数持久化、超时恢复、错角色阻止、
右键只读刷新、空值响应显示、心跳、关闭页签,以及四位年份的进入签名、APK 追踪渠道、区服引用还原/去重、两个角色显示、选二区登录、本地错误去重,
Windows 密码加密保存/恢复、登录失败保留密码、调试窗与脱敏日志,
以及 Qt 截图按钮只读、不点击手机、配置恢复、图片变更失效、
设备/分辨率检查、两种区服编号下密码登录及选二区的 loopback HTTP 链路、
缺失/冲突编号停止、Qt 登录回调错误处理、委托、地图和牧场策略;
另覆盖物品分类、赠礼上限/间隔/保留、策略脱敏导入导出及两种退出登录行为。
开发测试未向官方服务提交真实账号凭据,未对真实库存执行购蛋、派遣、喂养、委托或刷图。
用户已验证登录和角色读取;本次买蛋循环及多账号并行由本地模拟服务验证,真实账号效果仍需用户启动后验证。按钮配置需当前页面样本。
- 网络写请求发生异常后不会直接重试,以免重复消耗魔物或物品。 - 网络写请求发生异常后不会直接重试,以免重复消耗魔物或物品。
## 委托和扫荡的范围 ## 委托和扫荡的范围
“自动委托”需单独启用;可先关闭“牧场策略”的自动管理,只运行委托。 “自动委托”需单独启用;可先关闭“牧场与赠礼策略”的自动管理,只运行委托。
道具和魔物提交默认关闭,金币提交上限默认 0;锁定、队伍、高星和高资质保护继续生效。 道具和魔物提交默认关闭,金币提交上限默认 0;锁定、队伍、高星和高资质保护继续生效。
已接委托需要的魔物种类和蛋会纳入牧场保留。 已接委托需要的魔物种类和蛋会纳入牧场保留。
“也接取需要实战的委托”只允许接取此类任务,当前不会自动导航到每项委托的专用战斗。 “也接取需要实战的委托”只允许接取此类任务,当前不会自动导航到每项委托的专用战斗。
@@ -273,17 +225,17 @@
它复用 `stageStart` → `battleEnd` → `recordBattleResult`,无需本地战斗演算或手机截图。 它复用 `stageStart` → `battleEnd` → `recordBattleResult`,无需本地战斗演算或手机截图。
此前只搜索英文 sweep 和中文“扫荡”漏掉了这个拼音方法;现已按该分支实现。 此前只搜索英文 sweep 和中文“扫荡”漏掉了这个拼音方法;现已按该分支实现。
在“地图关卡”展开地区,每关勾选“刷图”、选择难度、输入“本日上限”,再点击“开始扫荡”。 在“自动扫荡”展开地区,每关勾选“刷图”、选择难度、输入“本日上限”,再点击“开始扫荡”。
星级是服务器通关进度计算出来的,只读。未解锁难度不能选;特殊关卡、未全通关、剧情任务、 星级是服务器通关进度计算出来的,只读。未解锁难度不能选;特殊关卡、未全通关、剧情任务、
体力/金币/门票不足的关卡会显示原因并跳过。次数按角色、日期、关卡和难度保存, 体力/金币/门票不足的关卡会显示原因并跳过。次数按角色、日期、关卡和难度保存,
是本地已开始次数,不冒充服务器每日限制。扫荡和ADB实战不能同时运行。 是本地已开始次数,不冒充服务器每日限制。
一次扫荡内部的几个请求顺序执行,完成后重读账号状态;开启其他策略时与孵蛋/委托逐轮串行。 一次扫荡内部的几个请求顺序执行,完成后重读账号状态;开启其他策略时与孵蛋/委托逐轮串行。
触发随机事件或请求结果不明确时停止,不提交后续结算;在游戏内处理后可清除本地待处理记录。 触发随机事件或请求结果不明确时停止,不提交后续结算;在游戏内处理后可清除本地待处理记录。
“每日事务”选择要处理的奖励类别,点“领取勾选项目”可立即领取; “每日事务”选择要处理的奖励类别,点“领取勾选项目”可立即领取;
点“开始每日事务”会打开统一监控和自动执行,只处理符合状态的项目。 点“开始每日事务”会打开统一监控和自动执行,只处理符合状态的项目。
VIP奖励只对已有资格领取;不会购买VIP或升级礼包。邮件仅领取附件,不删除邮件。 VIP奖励只对已有资格领取;不会购买VIP或升级礼包。邮件仅领取附件,不删除邮件。
启动/重启默认仍只读,自动化需要手动开始。勾选项、战队、保留体力及刷图规则按角色保存。 启动/重启默认不执行消耗类策略,成长到期自动同步;其他自动化需要手动开始。勾选项、战队、保留体力及刷图规则按角色保存。
网络写请求发送前保存本地记录,异常不直接重试;本日已提交但服务器仍返回旧状态的奖励会明确提示。 网络写请求发送前保存本地记录,异常不直接重试;本日已提交但服务器仍返回旧状态的奖励会明确提示。
资料包含此APK的1178个关卡、各难度奖励和2079种道具名称。 资料包含此APK的1178个关卡、各难度奖励和2079种道具名称。
-7
View File
@@ -68,7 +68,6 @@ class AccountsWindow(W.QMainWindow):
window = gui.Window(folder) window = gui.Window(folder)
window.connection_guard = lambda session: self.allow_connection(window, session) window.connection_guard = lambda session: self.allow_connection(window, session)
window.login_guard = lambda account: self.allow_login(window, account) window.login_guard = lambda account: self.allow_login(window, account)
window.device_guard = lambda serial: self.allow_device(window, serial)
window.profile_changed.connect(lambda label: self.rename_profile(identifier, label)) window.profile_changed.connect(lambda label: self.rename_profile(identifier, label))
self.windows[identifier], self.locks[identifier] = window, lock self.windows[identifier], self.locks[identifier] = window, lock
self.tabs.addTab(window, profile.get("label", "账号")) self.tabs.addTab(window, profile.get("label", "账号"))
@@ -124,10 +123,6 @@ class AccountsWindow(W.QMainWindow):
return False return False
return True return True
def allow_device(self, requester, serial):
return not any(window is not requester and window.farm.running and
(not serial or not window.farm.adb.serial or serial == window.farm.adb.serial) for window in self.windows.values())
def resume_all(self): def resume_all(self):
for window in self.windows.values(): for window in self.windows.values():
if window.engine.demo and not window.busy and window.saved_sessions.count(): if window.engine.demo and not window.busy and window.saved_sessions.count():
@@ -141,7 +136,6 @@ class AccountsWindow(W.QMainWindow):
def stop_all(self): def stop_all(self):
for window in self.windows.values(): for window in self.windows.values():
window.start_monitor.setChecked(False) window.start_monitor.setChecked(False)
window.start_farm.setChecked(False)
window.execute.setChecked(False) window.execute.setChecked(False)
def close_profile(self, index): def close_profile(self, index):
@@ -149,7 +143,6 @@ class AccountsWindow(W.QMainWindow):
if window is None: if window is None:
return return
window.start_monitor.setChecked(False) window.start_monitor.setChecked(False)
window.start_farm.setChecked(False)
window.timer.stop() window.timer.stop()
window.closed = True window.closed = True
window.pending_refresh = None window.pending_refresh = None
+3 -23
View File
@@ -28,7 +28,7 @@ class ActivityPages:
for widget in (self.map_search, self.only_unlocked): for widget in (self.map_search, self.only_unlocked):
line.addWidget(widget) line.addWidget(widget)
for label, function in (("刷新关卡", self.refresh), ("展开地区", lambda: self.maps_tree.expandAll()), for label, function in (("刷新关卡", self.refresh), ("展开地区", lambda: self.maps_tree.expandAll()),
("折叠地区", lambda: self.maps_tree.collapseAll()), ("转到手机实战", self.choose_map)): ("折叠地区", lambda: self.maps_tree.collapseAll())):
button = W.QPushButton(label) button = W.QPushButton(label)
button.clicked.connect(function) button.clicked.connect(function)
line.addWidget(button) line.addWidget(button)
@@ -66,10 +66,10 @@ class ActivityPages:
for col, width in enumerate((100, 82, 160, 130, 70, 210, 120, 340, 100, 92)): for col, width in enumerate((100, 82, 160, 130, 70, 210, 120, 340, 100, 92)):
self.maps_tree.setColumnWidth(col, width) self.maps_tree.setColumnWidth(col, width)
layout.addWidget(self.maps_tree, 1) layout.addWidget(self.maps_tree, 1)
note = W.QLabel("星级来自实际通关难度,不能手动修改。普通关卡三个难度全部通关后可扫荡;每行勾选、选择难度并输入本日次数上限。\n未满足扫荡条件的关卡可“转到手机实战”;扫荡按表格顺序逐关执行,使用所选战队。掉落来自安装包配置,随机物品并非必掉。") note = W.QLabel("星级来自实际通关难度,不能手动修改。普通关卡三个难度全部通关后可扫荡;每行勾选、选择难度并输入本日次数上限。\n未满足扫荡条件的关卡请在游戏内手动战斗;扫荡按表格顺序逐关执行,使用所选战队。掉落来自安装包配置,随机物品并非必掉。")
note.setWordWrap(True) note.setWordWrap(True)
layout.addWidget(note) layout.addWidget(note)
self.tabs.addTab(self.map_page, "地图关卡") self.tabs.addTab(self.map_page, "自动扫荡")
self.map_search.textChanged.connect(self.render_maps) self.map_search.textChanged.connect(self.render_maps)
self.only_unlocked.toggled.connect(self.render_maps) self.only_unlocked.toggled.connect(self.render_maps)
self.map_enabled.toggled.connect(self.activity_settings_changed) self.map_enabled.toggled.connect(self.activity_settings_changed)
@@ -205,23 +205,6 @@ class ActivityPages:
(f" 待处理:{pending['stage']} / {pending['phase']}" if pending else "") + (f" 待处理:{pending['stage']} / {pending['phase']}" if pending else "") +
(" 正在执行扫荡计划。" if self.map_enabled.isChecked() and self.execute.isChecked() and self.monitoring else " 扫荡已停止。")) (" 正在执行扫荡计划。" if self.map_enabled.isChecked() and self.execute.isChecked() and self.monitoring else " 扫荡已停止。"))
def choose_map(self):
item = self.maps_tree.currentItem()
key = item.data(0, C.Qt.ItemDataRole.UserRole) if item else None
if not key:
return
level = self.maps_tree.itemWidget(item, 3).currentData()
stage = next(s for s in stages(self.catalog, self.engine.snapshot) if s.stage_id == key and s.level == level)
if not stage.unlocked or not stage.open:
self.report("所选关卡未解锁或当前未开放")
return
if self.stage.findData(key) < 0:
self.stage.addItem(f"{stage.number} {stage.name}", key)
self.stage.setCurrentIndex(self.stage.findData(key))
self.stage_level.setCurrentIndex(self.stage_level.findData(level))
self.tabs.setCurrentWidget(self.screen.parentWidget())
self.report("已设置手机实战目标;手机需打开该关卡准备页并配置截图")
def clear_sweep_pending(self): def clear_sweep_pending(self):
if self.busy: if self.busy:
self.report("请等待当前请求完成") self.report("请等待当前请求完成")
@@ -297,9 +280,6 @@ class ActivityPages:
if self.engine.demo: if self.engine.demo:
self.report("请先登录账号,再开始扫荡") self.report("请先登录账号,再开始扫荡")
return return
if self.farm.running:
self.report("请先停止手机实战,再开始接口扫荡")
return
if not any(r.get("enabled") for r in self.map_rules.values()): if not any(r.get("enabled") for r in self.map_rules.values()):
self.report("请先勾选关卡,并设置难度和本日次数上限") self.report("请先勾选关卡,并设置难度和本日次数上限")
return return
-155
View File
@@ -1,155 +0,0 @@
"""User-triggered page samples, grouped by device, resolution and stage."""
from __future__ import annotations
from datetime import datetime, timedelta, timezone
import hashlib
import json
from pathlib import Path
import re
from PIL import Image
PAGES = (
("stage_ready", "关卡准备页", "需看到关卡名称、选中难度和进入按钮", True),
("battle_start", "战斗倒计时页", "需看到触摸开始 / 开始倒计时", False),
("auto_off", "自动战斗关闭状态", "需看到自动按钮处于关闭状态", False),
("auto_on", "自动战斗开启状态", "需看到自动按钮处于开启状态", False),
("victory", "胜利结算页", "需看到胜利标识和领取 / 继续按钮", True),
("continue", "后续确认页", "胜利后如还有奖励确认 / 返回页面,截取此页", False),
("defeat", "失败结算页", "如方便,保留失败页面以识别停止条件", False),
)
BUTTON_PAGES = {"stage": "stage_ready", "entry": "stage_ready", "countdown": "battle_start",
"auto_off": "auto_off", "victory": "victory", "continue": "continue", "defeat": "defeat"}
def component(value):
return re.sub(r"[^a-zA-Z0-9_.-]", "_", str(value))[:100].strip(".") or "device"
def read_profile(path, root):
path, root = Path(path).resolve(), Path(root).resolve()
if not path.is_relative_to(root):
raise ValueError("截图配置路径不在本地状态目录内")
profile = json.loads(path.read_text(encoding="utf-8"))
if profile.get("schema_version") != 1 or not isinstance(profile.get("captures"), dict):
raise ValueError("无法识别此截图配置")
return profile
def saved_profiles(root, stage_id, level, serial=""):
result = []
for path in (Path(root) / "capture_profiles").glob("*/*/*/profile.json"):
try:
profile = read_profile(path, root)
if (str(profile["stage_id"]) == str(stage_id) and str(profile["stage_level"]) == str(level)
and (not serial or profile["device_serial"] == serial)):
result.append((path.resolve(), profile))
except (OSError, ValueError, KeyError, TypeError):
continue
return sorted(result, key=lambda item: item[0].stat().st_mtime, reverse=True)
def save_page(root, image, serial, stage_id, level, page):
if page not in {p[0] for p in PAGES}:
raise ValueError("未知截图页面")
root = Path(root).resolve()
folder = root / "capture_profiles" / component(serial) / f"{image.width}x{image.height}" / f"{component(stage_id)}_{component(level)}"
folder.mkdir(parents=True, exist_ok=True)
path = folder / "profile.json"
profile = json.loads(path.read_text(encoding="utf-8")) if path.exists() else {
"schema_version": 1, "device_serial": serial, "stage_id": stage_id, "stage_level": str(level),
"resolution": list(image.size), "app_package": "air.net.pixvi.myrzx", "captures": {}}
if (profile["device_serial"] != serial or str(profile["stage_id"]) != str(stage_id)
or profile["stage_level"] != str(level) or profile["resolution"] != list(image.size)):
raise ValueError("截图目录中的设备或关卡记录不一致")
target = folder / (page + ".png")
image.save(target)
profile["captures"][page] = {"file": target.name, "sha256": hashlib.sha256(target.read_bytes()).hexdigest(),
"captured_at": datetime.now(timezone(timedelta(hours=8))).isoformat(timespec="seconds")}
temporary = path.with_suffix(".tmp")
temporary.write_text(json.dumps(profile, ensure_ascii=False, indent=2), encoding="utf-8")
temporary.replace(path)
return path, profile
def write_buttons(profile_path, root, regions):
"""Create templates from regions reviewed by the assistant in saved samples."""
profile_path = Path(profile_path).resolve()
profile = read_profile(profile_path, root)
if not {"stage", "entry", "victory"}.issubset(regions):
raise ValueError("需提供关卡标题、进入和胜利区域")
width, height = profile["resolution"]
templates, sources = {}, {}
for name, region in regions.items():
page = BUTTON_PAGES[name]
record = profile["captures"][page]
source = (profile_path.parent / record["file"]).resolve()
if not source.is_relative_to(Path(root).resolve()) or hashlib.sha256(source.read_bytes()).hexdigest() != record["sha256"]:
raise ValueError("截图文件与记录不一致")
box = list(region["box"])
tap = list(region.get("tap", [(box[0] + box[2]) / 2, (box[1] + box[3]) / 2]))
if (len(box) != 4 or not 0 <= box[0] < box[2] <= width or not 0 <= box[1] < box[3] <= height
or len(tap) != 2 or not 0 <= tap[0] < width or not 0 <= tap[1] < height):
raise ValueError("按钮区域或点击位置超出截图范围")
filename = f"button_{name}.png"
with Image.open(source) as image:
image.crop(box).save(profile_path.parent / filename)
templates[name] = {"file": filename, "box": box, "tap": tap}
sources[page] = record["sha256"]
buttons = {k: profile[k] for k in ("schema_version", "device_serial", "stage_id", "stage_level", "resolution")}
buttons.update(source_captures=sources, templates=templates)
path = profile_path.with_name("buttons.json")
temporary = path.with_suffix(".tmp")
temporary.write_text(json.dumps(buttons, ensure_ascii=False, indent=2), encoding="utf-8")
temporary.replace(path)
load_buttons(profile_path, root, profile["stage_id"], profile["stage_level"])
return path
def load_buttons(profile_path, root, stage_id, level, serial=""):
profile_path, root = Path(profile_path).resolve(), Path(root).resolve()
profile = read_profile(profile_path, root)
path = profile_path.with_name("buttons.json")
buttons = json.loads(path.read_text(encoding="utf-8"))
if str(buttons["stage_id"]) != str(stage_id) or str(buttons["stage_level"]) != str(level):
raise ValueError("按钮配置与所选关卡/难度不一致")
if str(profile["stage_id"]) != str(stage_id) or str(profile["stage_level"]) != str(level):
raise ValueError("页面截图属于其他关卡或难度")
if buttons["resolution"] != profile["resolution"] or buttons.get("device_serial") != profile["device_serial"]:
raise ValueError("按钮配置与当前设备或分辨率不一致")
if serial and profile["device_serial"] != serial:
raise ValueError("按钮配置属于其他设备")
sources = buttons.get("source_captures", {})
if not sources or any(profile["captures"].get(k, {}).get("sha256") != v for k, v in sources.items()):
raise ValueError("页面截图已更新,需要重新生成按钮配置")
if not {"stage_ready", "victory"}.issubset(sources):
raise ValueError("按钮配置缺少必需页面来源")
for key, digest in sources.items():
source = (path.parent / profile["captures"][key]["file"]).resolve()
if not source.is_relative_to(root) or hashlib.sha256(source.read_bytes()).hexdigest() != digest:
raise ValueError("截图文件与记录不一致,请重新截图并生成配置")
templates = {}
for name, original in buttons.get("templates", {}).items():
item = dict(original)
image_path = (path.parent / item["file"]).resolve()
if not image_path.is_relative_to(root) or not image_path.is_file():
raise ValueError("按钮模板图片缺失或路径无效")
item["file"] = str(image_path.relative_to(root))
item["stage_id"], item["stage_level"] = str(stage_id), str(level)
item["screen"] = buttons["resolution"]
item["device_serial"] = profile["device_serial"]
item["strict_resolution"] = True
width, height = buttons["resolution"]
box = item.get("box", [])
if (len(box) != 4 or not 0 <= box[0] < box[2] <= width or not 0 <= box[1] < box[3] <= height):
raise ValueError("按钮识别区域超出截图范围")
tap = item.get("tap", [(box[0] + box[2]) / 2, (box[1] + box[3]) / 2])
if len(tap) != 2 or not 0 <= tap[0] < width or not 0 <= tap[1] < height:
raise ValueError("按钮点击位置超出截图范围")
with Image.open(image_path) as reference:
if reference.size != (box[2] - box[0], box[3] - box[1]):
raise ValueError("按钮模板尺寸与识别区域不一致")
templates[name] = item
if not {"stage", "entry", "victory"}.issubset(templates):
raise ValueError("按钮配置缺少关卡名称、进入或胜利模板")
return templates
+14 -11
View File
@@ -99,8 +99,13 @@ class Engine:
self.read_snapshot() self.read_snapshot()
return True return True
def growth_sync_due(self):
if self.snapshot is None:
return False
now = time.monotonic()
return any(now - self.growth_attempts.get(key, -1e12) >= 60 for key in self.snapshot.growth_pending(self.catalog))
def sync_growth(self): def sync_growth(self):
self.auto = False
if self.demo: if self.demo:
if self.snapshot is None: if self.snapshot is None:
self.snapshot = demo_snapshot(self.catalog) self.snapshot = demo_snapshot(self.catalog)
@@ -109,9 +114,9 @@ class Engine:
mon["mode"] = self.snapshot.expected_growth_mode(mon, self.catalog) mon["mode"] = self.snapshot.expected_growth_mode(mon, self.catalog)
else: else:
self.read_snapshot() self.read_snapshot()
self.settle_pending_growth(force=True) self.settle_pending_growth()
pending = self.snapshot.growth_pending(self.catalog) pending = self.snapshot.growth_pending(self.catalog)
message = "已同步孵化 / 成长状态;本次不执行派遣或喂养" message = "已自动同步孵化 / 成长状态"
if pending: if pending:
message += f";仍有 {len(pending)} 只等待服务器确认阶段或资质" message += f";仍有 {len(pending)} 只等待服务器确认阶段或资质"
return self.snapshot, self.plans(), message return self.snapshot, self.plans(), message
@@ -129,17 +134,15 @@ class Engine:
if self.demo: if self.demo:
if self.snapshot is None: if self.snapshot is None:
self.snapshot = demo_snapshot(self.catalog) self.snapshot = demo_snapshot(self.catalog)
if self.auto and self.policy.enabled: for mon in self.snapshot.raw["monsters"]:
for mon in self.snapshot.raw["monsters"]: if mon.get("process") == 2:
if mon.get("process") == 2: mon["mode"] = self.snapshot.expected_growth_mode(mon, self.catalog)
mon["mode"] = self.snapshot.expected_growth_mode(mon, self.catalog)
else: else:
self.read_snapshot() self.read_snapshot()
if self.auto and self.policy.enabled: settled = self.settle_pending_growth()
settled = self.settle_pending_growth()
message = "状态已刷新" + (";已请求孵化 / 成长结算" if settled else "") message = "状态已刷新" + (";已请求孵化 / 成长结算" if settled else "")
if not self.auto and self.snapshot.growth_pending(self.catalog): if self.snapshot.growth_pending(self.catalog):
message += ";仅监控:有待结算的孵化 / 成长;请开始执行,或点击“同步孵化 / 成长”" message += ";成长状态等待服务器确认,将自动检查"
try: try:
plans = self.plans() plans = self.plans()
except (ValueError, TypeError, KeyError, AttributeError) as error: except (ValueError, TypeError, KeyError, AttributeError) as error:
-199
View File
@@ -1,199 +0,0 @@
from __future__ import annotations
from dataclasses import dataclass, field
from datetime import datetime, timedelta, timezone
import io
import json
from pathlib import Path
import shutil
import subprocess
import time
from PIL import Image, ImageChops, ImageStat
from .capture import load_buttons
class Adb:
def __init__(self, executable="", serial=""):
self.executable = executable or shutil.which("adb") or r"C:\Program Files\adb_tools\adb.exe"
self.serial = serial
def run(self, *args, binary=False):
command = [self.executable] + (["-s", self.serial] if self.serial else []) + list(args)
flags = getattr(subprocess, "CREATE_NO_WINDOW", 0)
result = subprocess.run(command, capture_output=True, timeout=12, creationflags=flags)
if result.returncode:
raise RuntimeError("ADB 操作失败,请检查连接、授权和设备编号")
return result.stdout if binary else result.stdout.decode("utf-8", errors="replace")
def screenshot(self):
raw = self.run("exec-out", "screencap", "-p", binary=True)
image = Image.open(io.BytesIO(raw)).convert("RGB")
return image
def foreground(self):
value = self.run("shell", "dumpsys", "activity", "activities")
lines = [s for s in value.splitlines() if "topResumedActivity=" in s or "mResumedActivity:" in s or "mResumedActivity=" in s]
return bool(lines) and all("air.net.pixvi.myrzx" in s for s in lines)
def tap(self, x, y):
if not self.foreground():
raise RuntimeError("游戏不在前台,刷图已停止")
self.run("shell", "input", "tap", str(int(x)), str(int(y)))
@dataclass
class FarmConfig:
stage_id: str = "bd00"
stage_level: str = "1"
daily_limit: int = 3
keep_stamina: int = 0
timeout: int = 240
threshold: float = 0.96
templates: dict = field(default_factory=dict)
capture_profile: str = ""
class FarmBudget:
def __init__(self, path):
self.path = Path(path)
self.records = json.loads(self.path.read_text(encoding="utf-8")) if self.path.exists() else {}
def key(self, snapshot, config):
day = datetime.fromtimestamp(snapshot.now, timezone(timedelta(hours=8))).strftime("%Y-%m-%d")
return f"{snapshot.raw['master']['id']}:{config.stage_id}:{day}"
def used(self, snapshot, config):
return self.records.get(self.key(snapshot, config), 0)
def reserve(self, snapshot, config):
key = self.key(snapshot, config)
self.records[key] = self.records.get(key, 0) + 1
self.path.parent.mkdir(parents=True, exist_ok=True)
temporary = self.path.with_suffix(".tmp")
temporary.write_text(json.dumps(self.records), encoding="utf-8")
temporary.replace(self.path)
def check(self, snapshot, config, catalog):
if time.time() - snapshot.received_at > 30:
return False, "角色状态超过30秒未刷新"
if self.used(snapshot, config) >= config.daily_limit:
return False, "已达到本日设置的刷图上限"
stage = catalog.data["stage_info"].get(config.stage_id)
if not stage:
return False, "未找到此关卡的数据"
base = stage.get("cost", {})
cost = float(base.get("ti", 0)) + float(stage.get("level", {}).get(config.stage_level, {}).get("cost", 0))
if float(snapshot.raw["master"].get("ti", 0)) < cost + config.keep_stamina:
return False, "剩余体力不足或已达到保留体力"
counts = {str(i["typeId"]): int(i.get("num", 0)) for i in snapshot.raw["items"]}
for item in base.get("items", []):
if counts.get(str(item["typeId"]), 0) < int(item["num"]):
return False, "关卡入场券/每日可用次数已不足"
if float(snapshot.raw["master"].get("money", 0)) < float(base.get("money", 0)):
return False, "关卡金币消耗不足"
if float(base.get("ke", 0)):
return False, "此关卡需要氪金,未启用"
return True, f"可继续,今日已开始 {self.used(snapshot, config)} 轮"
def matches(image, template, folder, threshold):
width, height = template["screen"]
if template.get("strict_resolution") and image.size != (width, height):
return False
if abs(image.width / image.height - width / height) > 0.02:
return False
image = image.resize((width, height))
box = tuple(template["box"])
crop = image.crop(box).convert("RGB")
with Image.open(Path(folder) / template["file"]) as reference:
diff = ImageChops.difference(crop, reference.convert("RGB"))
similarity = 1 - sum(ImageStat.Stat(diff).mean) / (3 * 255)
return similarity >= threshold
class FarmRunner:
def __init__(self, adb, catalog, folder):
self.adb, self.catalog = adb, catalog
self.folder = Path(folder)
self.budget = FarmBudget(self.folder / "daily_runs.json")
self.config = FarmConfig()
self.state = "idle"
self.started = 0
self.last_tap = 0
self.running = False
self.completed = 0
def start(self):
if self.config.capture_profile:
self.config.templates = load_buttons(self.folder / self.config.capture_profile, self.folder,
self.config.stage_id, self.config.stage_level, self.adb.serial)
if not {"entry", "victory", "stage"}.issubset(self.config.templates):
raise ValueError("先截取关卡名称、进入按钮和胜利结算按钮")
if any(t.get("stage_id") != self.config.stage_id for t in self.config.templates.values()):
raise ValueError("标定不属于当前关卡,请为所选关卡重新标定按钮")
if any(str(t.get("stage_level", "1")) != self.config.stage_level for t in self.config.templates.values()):
raise ValueError("按钮配置属于其他难度,请加载对应页面配置")
self.state, self.running = "idle", True
def stop(self):
self.running = False
def tick(self, snapshot):
if not self.running:
return "已停止"
if not self.adb.foreground():
self.stop()
raise RuntimeError("游戏不在前台,刷图已停止")
templates = self.config.templates
devices = {t["device_serial"] for t in templates.values() if t.get("device_serial")}
if devices:
serial = self.adb.serial or self.adb.run("get-serialno").strip()
if devices != {serial}:
self.stop()
raise RuntimeError("当前手机与截图配置的设备不一致,已停止")
image = self.adb.screenshot()
if any(t.get("strict_resolution") and list(image.size) != t["screen"] for t in templates.values()):
self.stop()
raise RuntimeError("手机分辨率已变化,请补拍对应页面并重新生成配置")
visible = {name: matches(image, value, self.folder, self.config.threshold) for name, value in templates.items()}
now = time.monotonic()
if self.state != "idle" and now - self.started > self.config.timeout:
self.stop()
raise RuntimeError("战斗/结算等待超时,已停止;请检查手机画面")
if visible.get("defeat"):
self.stop()
raise RuntimeError("检测到战斗失败,已停止刷图")
if now - self.last_tap < 2:
return "等待画面更新"
button = None
if visible.get("entry"):
if self.state == "settling":
self.completed += 1
self.state = "idle"
return "结算完成,等待刷新体力和次数"
if self.state == "idle":
if not visible.get("stage"):
return "准备页关卡名称不匹配,未点击进入"
allowed, reason = self.budget.check(snapshot, self.config, self.catalog)
if not allowed:
self.stop()
return reason
# Count attempts before tapping, including interrupted/failed attempts.
self.budget.reserve(snapshot, self.config)
self.state, self.started, button = "battle", now, "entry"
elif self.state in ("battle", "settling"):
if visible.get("victory"):
self.state, button = "settling", "victory"
elif self.state == "settling" and visible.get("continue"):
button = "continue"
elif self.state == "battle":
button = next((name for name in ("countdown", "auto_off") if visible.get(name)), None)
if button and self.running:
template = templates[button]
x1, y1, x2, y2 = template["box"]
width, height = template["screen"]
tap_x, tap_y = template.get("tap", [(x1 + x2) / 2, (y1 + y2) / 2])
self.adb.tap(tap_x * image.width / width, tap_y * image.height / height)
self.last_tap = now
return f"点击 {button};完成 {self.completed} 轮"
return "等待匹配按钮;请勿切换到其他关卡"
+89 -529
View File
@@ -1,8 +1,8 @@
from __future__ import annotations from __future__ import annotations
from dataclasses import asdict from dataclasses import asdict
import copy import copy
import io
import json import json
import random
from pathlib import Path from pathlib import Path
import sys import sys
import time import time
@@ -11,23 +11,22 @@ from PySide6 import QtCore as C, QtGui as G, QtWidgets as W
from .api import ApiError, Client, Session, DEFAULT_KEY, server_entries from .api import ApiError, Client, Session, DEFAULT_KEY, server_entries
from .engine import Engine from .engine import Engine
from .farming import Adb, FarmConfig, FarmRunner
from .model import Catalog, Policy, WIKI, duration from .model import Catalog, Policy, WIKI, duration
from .egg_rules_gui import EggTable from .egg_rules_gui import EggTable
from .management import expansion_quote, manual_monster_actions from .management import expansion_quote, manual_monster_actions
from .native_widgets import IntegerInput, RowBatch, use_native_scrollbars from .native_widgets import use_native_scrollbars
from .login import PasswordLogin, device_id, server_labels from .login import PasswordLogin, device_id, server_labels
from .quests import QuestPolicy from .quests import QuestPolicy
from .daily import DailyPolicy from .daily import DailyPolicy
from .sweeping import SweepPolicy from .sweeping import SweepPolicy
from .activity_gui import ActivityPages from .activity_gui import ActivityPages
from .presentation import Presented, prepare_views, monster_rows from .presentation import Presented, prepare_views, monster_rows
from .capture import PAGES, load_buttons, read_profile, saved_profiles, save_page
from .credentials import CredentialStore from .credentials import CredentialStore
from .debug import TraceLog from .debug import TraceLog
from .debug_window import DebugWindow from .debug_window import DebugWindow
from .sessions import SessionStore, identity from .sessions import SessionStore, identity
from .inventory_gui import ITEM_TYPES, InventoryTable, RanchView from .inventory_gui import ITEM_TYPES, InventoryTable
from .ranch_gui import RanchView
from .policy_io import portable_policy, import_policy from .policy_io import portable_policy, import_policy
APP_VERSION = "1.1.0" APP_VERSION = "1.1.0"
@@ -57,61 +56,6 @@ class Job(C.QRunnable):
self.signals.done.emit() self.signals.done.emit()
class Screen(W.QWidget):
selected = C.Signal(object)
def __init__(self, selectable=True):
super().__init__()
self.selectable = selectable
self.setMinimumSize(220, 300)
self.image, self.pixmap, self.anchor, self.current = None, None, None, None
def set_image(self, image):
self.image = image
stream = io.BytesIO()
image.save(stream, format="PNG")
self.pixmap = G.QPixmap()
self.pixmap.loadFromData(stream.getvalue())
self.update()
def rect_image(self):
size = self.pixmap.size().scaled(self.size(), C.Qt.AspectRatioMode.KeepAspectRatio)
return C.QRect((self.width() - size.width()) // 2, (self.height() - size.height()) // 2, size.width(), size.height())
def paintEvent(self, event):
painter = G.QPainter(self)
if self.pixmap is None:
painter.drawText(self.rect(), C.Qt.AlignmentFlag.AlignCenter,
"截图后拖动框选按钮" if self.selectable else "点击上方对应页面的截图按钮,这里显示预览")
return
painter.drawPixmap(self.rect_image(), self.pixmap)
if self.anchor is not None and self.current is not None:
painter.setPen(G.QPen(C.Qt.GlobalColor.red, 2))
painter.drawRect(C.QRect(self.anchor, self.current).normalized())
def mousePressEvent(self, event):
if self.selectable and self.pixmap is not None and self.rect_image().contains(event.position().toPoint()):
self.anchor = self.current = event.position().toPoint()
def mouseMoveEvent(self, event):
if self.anchor is not None:
self.current = event.position().toPoint()
self.update()
def mouseReleaseEvent(self, event):
if self.anchor is None:
return
rectangle = C.QRect(self.anchor, event.position().toPoint()).normalized().intersected(self.rect_image())
target = self.rect_image()
scale = self.image.width / target.width()
box = (int((rectangle.left() - target.left()) * scale), int((rectangle.top() - target.top()) * scale),
int((rectangle.right() - target.left()) * scale), int((rectangle.bottom() - target.top()) * scale))
self.anchor = self.current = None
self.update()
if box[2] - box[0] >= 12 and box[3] - box[1] >= 12:
self.selected.emit(box)
def spin(low, high, value, decimals=False): def spin(low, high, value, decimals=False):
widget = W.QDoubleSpinBox() if decimals else W.QSpinBox() widget = W.QDoubleSpinBox() if decimals else W.QSpinBox()
widget.setRange(low, high) widget.setRange(low, high)
@@ -179,7 +123,6 @@ class Window(ActivityPages, W.QMainWindow):
self.closed = False self.closed = False
self.connection_guard = None self.connection_guard = None
self.login_guard = None self.login_guard = None
self.device_guard = None
if not G.QFontDatabase.families(): if not G.QFontDatabase.families():
font_id = G.QFontDatabase.addApplicationFont("C:/Windows/Fonts/msyh.ttc") font_id = G.QFontDatabase.addApplicationFont("C:/Windows/Fonts/msyh.ttc")
families = G.QFontDatabase.applicationFontFamilies(font_id) families = G.QFontDatabase.applicationFontFamilies(font_id)
@@ -197,16 +140,14 @@ class Window(ActivityPages, W.QMainWindow):
self.catalog, self.pool = Catalog(), C.QThreadPool(self) self.catalog, self.pool = Catalog(), C.QThreadPool(self)
self.pool.setMaxThreadCount(1) self.pool.setMaxThreadCount(1)
self.engine = Engine(self.catalog) self.engine = Engine(self.catalog)
self.farm = FarmRunner(Adb(), self.catalog, self.state)
self.busy, self.monitoring = False, False self.busy, self.monitoring = False, False
self.active_job = None self.active_job = None
self.presentation_active = True self.presentation_active = True
self.latest_render = None self.latest_render = None
self.prepared_views = None self.prepared_views = None
self.next_poll = self.next_farm = 0 self.next_poll = 0
self.client_pending = None self.client_pending = None
self.password_login_result = None self.password_login_result = None
self.capture_profile = None
self.egg_rules = {} self.egg_rules = {}
self.feed_targets = {} self.feed_targets = {}
self.gift_targets = {} self.gift_targets = {}
@@ -218,8 +159,8 @@ class Window(ActivityPages, W.QMainWindow):
self.mode = W.QLabel("未登录") self.mode = W.QLabel("未登录")
self.summary = W.QLabel() self.summary = W.QLabel()
self.data_summary = W.QLabel("等待读取培育室、背包和牧场状态") self.data_summary = W.QLabel("等待读取培育室、背包和牧场状态")
self.interval = combo([("5秒", 5), ("10秒", 10), ("30秒", 30), ("60秒", 60)]) self.interval = combo([("随机30秒", 30), ("随机60秒", 60), ("随机2分钟", 120), ("随机5分钟", 300)])
self.interval.setCurrentIndex(1) self.interval.setToolTip("每轮完成后,从0到所选上限随机等待;请求串行执行。孵化/成长到期会单独同步。")
self.start_monitor = W.QPushButton("开始监控") self.start_monitor = W.QPushButton("开始监控")
self.start_monitor.setCheckable(True) self.start_monitor.setCheckable(True)
self.start_monitor.toggled.connect(self.toggle_monitor) self.start_monitor.toggled.connect(self.toggle_monitor)
@@ -247,21 +188,13 @@ class Window(ActivityPages, W.QMainWindow):
self.slots.sortItems(0, C.Qt.SortOrder.AscendingOrder) self.slots.sortItems(0, C.Qt.SortOrder.AscendingOrder)
self.eggs = EggTable(self.catalog) self.eggs = EggTable(self.catalog)
self.eggs.rules_changed.connect(self.egg_rules_changed) self.eggs.rules_changed.connect(self.egg_rules_changed)
self.monsters = table(["魔物ID", "名称", "星", "等级 / 当前上限", "资质 攻/防/血/敏", "位置", "锁定", "管理范围", self.monsters = RanchView(self.catalog)
"喂养目标", "喂养优先级", "突破等级", "参考攻击", "参考防御", "参考生命", "参考敏捷", "好感 / 当前上限", "喜欢的物品", "赠礼", "赠礼优先级"]) self.monster_render_timer = self.monsters.row_batch
self.monsters.horizontalHeader().setSectionResizeMode(W.QHeaderView.ResizeMode.Interactive)
for column, width in enumerate((115, 140, 45, 120, 150, 140, 80, 130, 90, 110, 85, 90, 90, 90, 90, 90, 220, 65, 110)):
self.monsters.setColumnWidth(column, width)
self.rooms_table = table(["牧场ID", "名称", "类型", "当前魔物", "容量", "空位"])
self.slot_page = W.QWidget() self.slot_page = W.QWidget()
slot_layout = W.QVBoxLayout(self.slot_page) slot_layout = W.QVBoxLayout(self.slot_page)
self.slot_status = W.QLabel() self.slot_status = W.QLabel()
slot_layout.addWidget(self.slot_status) slot_layout.addWidget(self.slot_status)
slot_tools = W.QHBoxLayout() slot_tools = W.QHBoxLayout()
self.sync_growth_button = W.QPushButton("同步孵化 / 成长")
self.sync_growth_button.setToolTip("读取服务器成长结算和成熟资质;本次只同步,不派遣或喂养")
self.sync_growth_button.clicked.connect(self.request_growth_sync)
slot_tools.addWidget(self.sync_growth_button)
for label, currency in (("开启选中普通坑位(金币)", "money"), ("开启选中普通坑位(氪金)", "ke")): for label, currency in (("开启选中普通坑位(金币)", "money"), ("开启选中普通坑位(氪金)", "ke")):
button = W.QPushButton(label) button = W.QPushButton(label)
button.clicked.connect(lambda checked=False, currency=currency: self.request_expansion("stack", currency)) button.clicked.connect(lambda checked=False, currency=currency: self.request_expansion("stack", currency))
@@ -326,38 +259,25 @@ class Window(ActivityPages, W.QMainWindow):
detail_note = W.QLabel("勾选“喂养目标”并设置优先级(数字小的先喂);当前突破上限满级后转下一个目标。参考属性含等级、潜能、好感和升星,不含装备、羁绊或全局加成。") detail_note = W.QLabel("勾选“喂养目标”并设置优先级(数字小的先喂);当前突破上限满级后转下一个目标。参考属性含等级、潜能、好感和升星,不含装备、羁绊或全局加成。")
detail_note.setWordWrap(True) detail_note.setWordWrap(True)
monster_layout.addWidget(detail_note) monster_layout.addWidget(detail_note)
self.ranch_view = RanchView(self.rooms_table, self.monsters) self.ranch_view = self.monsters
monster_layout.addWidget(self.ranch_view) monster_layout.addWidget(self.ranch_view)
self.monsters.itemSelectionChanged.connect(self.update_monster_actions) self.monsters.itemSelectionChanged.connect(self.update_monster_actions)
self.monsters.cellDoubleClicked.connect(lambda row, column: self.show_monster_detail(row)) self.monsters.monster_activated.connect(self.show_monster_detail)
self.room_page = W.QWidget() self.monsters.feed_changed.connect(self.monster_feed_changed)
room_layout = W.QVBoxLayout(self.room_page) self.monsters.gift_changed.connect(self.monster_gift_changed)
room_tools = W.QHBoxLayout()
for label, currency in (("新建牧场(金币)", "money"), ("新建牧场(氪金)", "ke")):
button = W.QPushButton(label)
button.clicked.connect(lambda checked=False, currency=currency: self.request_expansion("room", currency))
room_tools.addWidget(button)
room_tools.addStretch()
room_layout.addLayout(room_tools)
self.room_status = W.QLabel("已开启的牧场列在下方;新建前会显示费用并确认。")
self.room_status.setWordWrap(True)
room_layout.addWidget(self.room_status)
self.room_page.hide()
self.room_page = self.monster_page self.room_page = self.monster_page
self.tabs.addTab(self.room_page, "牧场") self.tabs.addTab(self.room_page, "牧场")
self.policy_tab(embedded=True) self.policy_page = self.policy_tab(embedded=True)
self.automation_tab() self.automation_tab()
self.yield_tab() self.yield_tab()
self.quests_tab() self.quests_tab()
self.maps_tab() self.maps_tab()
self.daily_tab() self.daily_tab()
self.farm_tab()
self.capture_tab()
self.plans = table(["操作", "下一步计划(每轮只执行一项,并重新读取状态)"]) self.plans = table(["操作", "下一步计划(每轮只执行一项,并重新读取状态)"])
self.tabs.addTab(self.plans, "执行计划") self.tabs.addTab(self.plans, "执行计划")
order = [self.tabs.widget(0), self.slot_page, self.inventory_tabs, self.room_page, order = [self.tabs.widget(0), self.slot_page, self.inventory_tabs, self.room_page,
self.quests_table.parentWidget(), self.yields.parentWidget(), self.daily_page, self.map_page, self.daily_page, self.automation_page, self.quests_table.parentWidget(), self.map_page,
self.automation_page, self.start_farm.parentWidget(), self.capture_scroll, self.plans] self.plans, self.yields.parentWidget()]
for page in order: for page in order:
self.tabs.addTab(page, self.tabs.tabText(self.tabs.indexOf(page))) self.tabs.addTab(page, self.tabs.tabText(self.tabs.indexOf(page)))
self.monster_view.currentIndexChanged.connect(self.monster_view_changed) self.monster_view.currentIndexChanged.connect(self.monster_view_changed)
@@ -389,10 +309,10 @@ class Window(ActivityPages, W.QMainWindow):
self.remember_password.toggled.connect(self.save_login_info) self.remember_password.toggled.connect(self.save_login_info)
self.account.editingFinished.connect(lambda: self.save_login_info(quiet=True)) self.account.editingFinished.connect(lambda: self.save_login_info(quiet=True))
self.password.editingFinished.connect(lambda: self.save_login_info(quiet=True)) self.password.editingFinished.connect(lambda: self.save_login_info(quiet=True))
self.refresh_capture_profiles()
self.render_catalog() self.render_catalog()
self.install_refresh_menus() self.install_refresh_menus()
self.tabs.currentChanged.connect(self.render_current_page) self.tabs.currentChanged.connect(self.render_current_page)
self.interval.currentIndexChanged.connect(self.poll_interval_changed)
self.reload_saved_sessions() self.reload_saved_sessions()
self.timer = C.QTimer(self) self.timer = C.QTimer(self)
self.timer.timeout.connect(self.schedule) self.timer.timeout.connect(self.schedule)
@@ -477,7 +397,8 @@ class Window(ActivityPages, W.QMainWindow):
self.ranch_enabled.setChecked(True) self.ranch_enabled.setChecked(True)
self.strategy = combo([("Wiki机会成本", "wiki"), ("金币优先:成熟后派遣", "gold"), ("经验优先:收取后喂养", "experience"), ("全部收取并保留", "keep")]) self.strategy = combo([("Wiki机会成本", "wiki"), ("金币优先:成熟后派遣", "gold"), ("经验优先:收取后喂养", "experience"), ("全部收取并保留", "keep")])
self.protect_star = spin(1, 6, 3) self.protect_star = spin(1, 6, 3)
self.protect_quality = combo([("S及以上", 4), ("A及以上", 3), ("B及以上", 2), ("全部资质", 1), ("不按资质保留", 5)]) self.protect_quality = combo([("S及以上", 4), ("A及以上", 3), ("B及以上", 2), ("全部资质", 1), ("不按资质保留", 5), ("四项全S(4S)才保留", 6)])
self.protect_quality.setToolTip("4S要求攻、防、生命、敏捷分别为S;锁定、队伍、保留星级等保护仍单独生效。")
self.protect_quality.setCurrentIndex(1) self.protect_quality.setCurrentIndex(1)
self.target = combo([("未设置:不自动喂养", 0)]) self.target = combo([("未设置:不自动喂养", 0)])
self.target_level = spin(1, 100, 70) self.target_level = spin(1, 100, 70)
@@ -490,7 +411,7 @@ class Window(ActivityPages, W.QMainWindow):
self.egg_order = combo([("短时间优先", "shortest"), ("金币/小时优先", "gold"), ("经验/小时优先", "experience"), ("长时间优先", "longest")]) self.egg_order = combo([("短时间优先", "shortest"), ("金币/小时优先", "gold"), ("经验/小时优先", "experience"), ("长时间优先", "longest")])
self.min_gold = spin(0, 1000000, 0, True) self.min_gold = spin(0, 1000000, 0, True)
self.min_exp = spin(0, 1000000, 0, True) self.min_exp = spin(0, 1000000, 0, True)
rows = [("保留此星级及以上", self.protect_star), ("保留综合资质", self.protect_quality), rows = [("保留此星级及以上", self.protect_star), ("资质保留条件", self.protect_quality),
("喂养目标", self.target), ("喂养达到此等级后停止", self.target_level), ("收取到牧场", self.room), ("喂养目标", self.target), ("喂养达到此等级后停止", self.target_level), ("收取到牧场", self.room),
("额外保留魔物编号(逗号分隔)", self.reserved_types), ("额外保留魔物编号(逗号分隔)", self.reserved_types),
("保留蛋数量(编号:数量,逗号分隔)", self.reserve_eggs)] ("保留蛋数量(编号:数量,逗号分隔)", self.reserve_eggs)]
@@ -518,9 +439,17 @@ class Window(ActivityPages, W.QMainWindow):
save = W.QPushButton("保存设置") save = W.QPushButton("保存设置")
save.clicked.connect(self.save_config) save.clicked.connect(self.save_config)
form.addRow(save) form.addRow(save)
for label in tab.findChildren(W.QLabel):
label.setWordWrap(True)
form.setSizeConstraint(W.QLayout.SizeConstraint.SetMinimumSize)
scroll = W.QScrollArea()
scroll.setWidgetResizable(True)
scroll.setFrameShape(W.QFrame.Shape.NoFrame)
scroll.setWidget(tab)
self.policy_scroll = scroll
if embedded: if embedded:
return tab return scroll
self.tabs.addTab(tab, "牧场策略") self.tabs.addTab(scroll, "牧场策略")
def automation_tab(self): def automation_tab(self):
self.automation_page = W.QWidget() self.automation_page = W.QWidget()
@@ -607,7 +536,7 @@ class Window(ActivityPages, W.QMainWindow):
configure.clicked.connect(lambda: self.tabs.setCurrentWidget(self.egg_page)) configure.clicked.connect(lambda: self.tabs.setCurrentWidget(self.egg_page))
layout.addWidget(configure) layout.addWidget(configure)
self.tabs.insertTab(1, self.automation_page, "自动孵蛋") self.tabs.insertTab(1, self.automation_page, "自动孵蛋")
policy_tab = self.policy_tab(embedded=True) policy_tab = self.policy_page
self.automation_tabs = W.QTabWidget() self.automation_tabs = W.QTabWidget()
self.automation_tabs.addTab(settings_scroll, "孵蛋设置") self.automation_tabs.addTab(settings_scroll, "孵蛋设置")
self.automation_tabs.addTab(policy_tab, "牧场与赠礼策略") self.automation_tabs.addTab(policy_tab, "牧场与赠礼策略")
@@ -664,21 +593,6 @@ class Window(ActivityPages, W.QMainWindow):
self.pending_execute = False self.pending_execute = False
self.update_workflow_status() self.update_workflow_status()
def request_growth_sync(self):
if self.busy or self.closed:
self.report("请等待当前请求完成后再同步成长")
return
try:
self.engine.policy = self.read_policy()
self.engine.quest_policy = self.read_quest_policy()
self.engine.daily_policy = self.read_daily_policy()
self.engine.sweep_policy = self.read_sweep_policy()
except ValueError:
self.report("请先修正孵蛋规则中的编号和保留数量")
return
self.stop_workflow()
self.submit("growth_sync", self.engine.sync_growth)
def gold_preset(self): def gold_preset(self):
self.stop_workflow() self.stop_workflow()
self.ranch_enabled.setChecked(True) self.ranch_enabled.setChecked(True)
@@ -711,7 +625,7 @@ class Window(ActivityPages, W.QMainWindow):
if not hasattr(self, "workflow_status"): if not hasattr(self, "workflow_status"):
return return
active = self.execute.isChecked() and self.monitoring active = self.execute.isChecked() and self.monitoring
state = "执行中" if active else "仅监控(不结算成长、不派遣;请点“开始执行”)" if self.monitoring else "已停止(不会自动派遣)" state = "执行中" if active else "仅监控(自动同步成长,不派遣或喂养)" if self.monitoring else "已停止(不会自动派遣)"
self.workflow_status.setText(("演示 · " if self.engine.demo else "已登录 · ") + state) self.workflow_status.setText(("演示 · " if self.engine.demo else "已登录 · ") + state)
self.workflow_start.setEnabled(not active) self.workflow_start.setEnabled(not active)
self.workflow_stop.setEnabled(self.execute.isChecked()) self.workflow_stop.setEnabled(self.execute.isChecked())
@@ -767,9 +681,28 @@ class Window(ActivityPages, W.QMainWindow):
grouped = bool(self.monster_view.currentData()) grouped = bool(self.monster_view.currentData())
self.monster_room.setEnabled(grouped) self.monster_room.setEnabled(grouped)
self.ranch_view.set_view(grouped, self.monster_room.currentData() or 0) self.ranch_view.set_view(grouped, self.monster_room.currentData() or 0)
self.monster_render_signature = None if self.latest_render and self.presentation_active and self.tabs.currentWidget() is self.monster_page:
if self.latest_render:
self.render_monsters(self.latest_render[0]) self.render_monsters(self.latest_render[0])
self.update_monster_actions()
def monster_feed_changed(self, mid, enabled, priority):
if enabled:
self.feed_targets[mid] = priority
self.feed.setChecked(True)
self.collect.setChecked(True)
else:
self.feed_targets.pop(mid, None)
self.save_config(quiet=True)
self.update_target_status()
def monster_gift_changed(self, mid, enabled, priority):
if enabled:
self.gift_targets[mid] = priority
self.gift_enabled.setChecked(True)
else:
self.gift_targets.pop(mid, None)
self.save_config(quiet=True)
self.update_gift_status()
def add_egg_rule(self): def add_egg_rule(self):
choices = {f"{row.get('name', key)} [{key}]": key for key, row in self.catalog.monsters.items() choices = {f"{row.get('name', key)} [{key}]": key for key, row in self.catalog.monsters.items()
@@ -831,200 +764,6 @@ class Window(ActivityPages, W.QMainWindow):
layout.addWidget(self.quests_table) layout.addWidget(self.quests_table)
self.tabs.addTab(tab, "自动委托") self.tabs.addTab(tab, "自动委托")
def farm_tab(self):
tab, horizontal = W.QWidget(), W.QHBoxLayout()
tab.setLayout(horizontal)
form = W.QFormLayout()
horizontal.addLayout(form)
self.adb_path = W.QLineEdit(self.farm.adb.executable)
self.serial = W.QLineEdit()
self.stage = combo([("布丁史莱姆牧场 bd00", "bd00"), ("布丁史莱姆牧场 bd01", "bd01")])
self.stage_level = combo([("普通 / 1", "1"), ("进阶 / 2", "2"), ("精英 / 3", "3")])
self.daily = spin(1, 999, 3)
self.keep_ti = spin(0, 9999, 0)
self.timeout = spin(30, 1200, 240)
self.threshold = spin(0.8, 1.0, 0.96, True)
self.threshold.setSingleStep(0.01)
for label, widget in (("ADB路径", self.adb_path), ("设备编号(单设备可留空)", self.serial), ("目标关卡", self.stage), ("难度", self.stage_level),
("本日轮数上限(自定)", self.daily), ("保留体力", self.keep_ti), ("单轮超时秒数", self.timeout), ("按钮匹配阈值", self.threshold)):
form.addRow(label, widget)
self.template = combo([("进入关卡按钮(必需)", "entry"), ("胜利结算按钮(必需)", "victory"),
("关卡名称区域(必需,仅识别)", "stage"), ("触摸开始倒计时", "countdown"), ("自动战斗未开启图标", "auto_off"), ("结算下一步按钮", "continue"), ("失败标识(只检测不点击)", "defeat")])
form.addRow("框选的按钮类型", self.template)
guide = W.QPushButton("打开ADB实战截图配置(扫荡无需截图)")
guide.clicked.connect(lambda: self.tabs.setCurrentWidget(self.capture_scroll))
form.addRow(guide)
capture = W.QPushButton("手工标定(可选):截图并在右侧框选")
capture.clicked.connect(self.capture)
form.addRow(capture)
self.template_status = W.QLabel("尚未标定")
form.addRow(self.template_status)
self.start_farm = W.QPushButton("开始布丁牧场刷图")
self.start_farm.setCheckable(True)
self.start_farm.toggled.connect(self.toggle_farm)
form.addRow(self.start_farm)
self.farm_status = W.QLabel("已停止")
self.farm_status.setWordWrap(True)
form.addRow(self.farm_status)
note = W.QLabel("先到“页面截图配置”保存关卡准备和胜利结算页,生成配置后加载。\n开始后手机保持游戏前台;开启游戏内自动战斗,或提供关闭状态截图。\n开战前核对体力、入场券和本日轮数。")
note.setWordWrap(True)
form.addRow(note)
self.screen = Screen()
self.screen.selected.connect(self.save_template)
horizontal.addWidget(self.screen, 1)
self.tabs.addTab(tab, "体力刷图")
def capture_tab(self):
tab, layout = W.QWidget(), W.QVBoxLayout()
tab.setLayout(layout)
self.capture_page_widget = tab
scroll = W.QScrollArea()
scroll.setWidgetResizable(True)
scroll.setWidget(tab)
self.capture_scroll = scroll
layout.setSizeConstraint(W.QLayout.SizeConstraint.SetMinimumSize)
note = W.QLabel("此页仅用于ADB手机实战;地图接口扫荡和每日事务不需要截图。\n先在“体力刷图”选择设备、关卡和难度。你玩到对应页面时点击该行截图,无需手工框选;截图不会自动点击或切换手机页面。")
note.setWordWrap(True)
layout.addWidget(note)
self.capture_target = W.QLabel()
layout.addWidget(self.capture_target)
self.capture_profiles = W.QComboBox()
self.capture_profiles.setPlaceholderText("尚未保存截图;截图后会按设备和分辨率列出配置")
self.capture_profiles.currentIndexChanged.connect(self.select_capture_profile)
layout.addWidget(self.capture_profiles)
self.capture_rows = W.QTableWidget(len(PAGES), 4)
self.capture_rows.verticalHeader().setDefaultSectionSize(max(28, self.fontMetrics().height() + 12))
self.capture_rows.setHorizontalHeaderLabels(["页面", "截图需要包含", "操作", "状态"])
self.capture_rows.setEditTriggers(W.QAbstractItemView.EditTrigger.NoEditTriggers)
self.capture_rows.cellClicked.connect(self.preview_capture)
self.capture_rows.horizontalHeader().setSectionResizeMode(W.QHeaderView.ResizeMode.ResizeToContents)
self.capture_rows.horizontalHeader().setStretchLastSection(True)
for index, (key, name, description, required) in enumerate(PAGES):
self.capture_rows.setItem(index, 0, W.QTableWidgetItem(name + ("(必需)" if required else "(可选)")))
self.capture_rows.setItem(index, 1, W.QTableWidgetItem(description))
button = W.QPushButton("截取此页面")
button.clicked.connect(lambda checked=False, page=key: self.capture_page(page))
self.capture_rows.setCellWidget(index, 2, button)
self.capture_rows.setItem(index, 3, W.QTableWidgetItem("未截图"))
self.capture_rows.setRowHeight(index, max(28, button.sizeHint().height() + 4))
height = self.capture_rows.horizontalHeader().sizeHint().height() + sum(self.capture_rows.rowHeight(i) for i in range(len(PAGES))) + 30
self.capture_rows.setFixedHeight(height)
layout.addWidget(self.capture_rows)
line = W.QHBoxLayout()
refresh = W.QPushButton("检查已保存截图")
refresh.clicked.connect(self.refresh_capture_profiles)
load = W.QPushButton("加载已生成的按钮配置")
load.clicked.connect(self.load_capture_buttons)
folder = W.QPushButton("打开截图文件夹")
folder.clicked.connect(self.open_capture_folder)
line.addWidget(refresh)
line.addWidget(load)
line.addWidget(folder)
layout.addLayout(line)
self.capture_path = W.QLineEdit()
self.capture_path.setReadOnly(True)
layout.addWidget(self.capture_path)
self.capture_preview = Screen(selectable=False)
self.capture_preview.setMinimumHeight(140)
layout.addWidget(self.capture_preview, 1)
self.tabs.addTab(scroll, "页面截图配置")
self.tabs.setTabToolTip(self.tabs.indexOf(scroll), "仅用于ADB手机实战;接口扫荡和每日事务无需截图")
self.stage.currentIndexChanged.connect(self.refresh_capture_profiles)
self.stage_level.currentIndexChanged.connect(self.refresh_capture_profiles)
self.serial.editingFinished.connect(self.refresh_capture_profiles)
def capture_page(self, page):
if self.busy:
self.report("正在处理上一项操作,请稍候再截图")
return
self.update_farm_config()
self.start_farm.setChecked(False)
self.start_monitor.setChecked(False)
adb = Adb(self.adb_path.text(), self.serial.text().strip())
stage_id, level = self.stage.currentData(), self.stage_level.currentData()
def sample():
if not adb.foreground():
raise RuntimeError("请先把游戏切到对应页面,再点击截图")
serial = adb.serial or adb.run("get-serialno").strip()
image = adb.screenshot()
path, profile = save_page(self.state, image, serial, stage_id, level, page)
return path, profile, image
self.submit("page_sample", sample)
def refresh_capture_profiles(self, *args):
profiles = saved_profiles(self.state, self.stage.currentData(), self.stage_level.currentData(), self.serial.text().strip())
old = str(self.capture_profile) if self.capture_profile else None
self.capture_profiles.blockSignals(True)
self.capture_profiles.clear()
for path, profile in profiles:
width, height = profile["resolution"]
self.capture_profiles.addItem(f"{profile['device_serial']} / {width}×{height} / 已拍 {len(profile['captures'])} 页", str(path))
index = self.capture_profiles.findData(old)
self.capture_profiles.setCurrentIndex(max(0, index) if profiles else -1)
self.capture_profiles.blockSignals(False)
self.select_capture_profile()
def select_capture_profile(self, *args):
value = self.capture_profiles.currentData()
self.capture_profile = Path(value) if value else None
self.capture_preview.image = self.capture_preview.pixmap = None
self.capture_preview.update()
self.refresh_capture_status()
def preview_capture(self, row, column):
if self.capture_profile is None:
return
try:
from PIL import Image
profile = read_profile(self.capture_profile, self.state)
record = profile["captures"].get(PAGES[row][0])
if record:
path = (self.capture_profile.parent / record["file"]).resolve()
if path.is_relative_to(self.state.resolve()):
with Image.open(path) as image:
self.capture_preview.set_image(image.convert("RGB"))
except (OSError, ValueError, KeyError) as error:
self.report(f"截图预览无法读取:{error}")
def open_capture_folder(self):
path = self.capture_profile.parent if self.capture_profile else self.state / "capture_profiles"
path.mkdir(parents=True, exist_ok=True)
G.QDesktopServices.openUrl(C.QUrl.fromLocalFile(str(path.resolve())))
def refresh_capture_status(self, *args):
stage_id, level = self.stage.currentData(), self.stage_level.currentData()
self.capture_target.setText(f"当前目标:{self.stage.currentText()} / 难度 {level}")
profile = None
if self.capture_profile and self.capture_profile.exists():
try:
candidate = read_profile(self.capture_profile, self.state)
if str(candidate["stage_id"]) == stage_id and str(candidate["stage_level"]) == level:
profile = candidate
except (OSError, ValueError, KeyError):
self.report("截图配置无法读取,请重新截图")
for index, (key, _, _, _) in enumerate(PAGES):
record = (profile or {}).get("captures", {}).get(key)
self.capture_rows.item(index, 3).setText(record["captured_at"] if record else "未截图")
self.capture_path.setText(str(self.capture_profile) if profile else "截图后会显示配置文件位置")
def load_capture_buttons(self):
if self.busy or self.farm.running:
self.report("请先停止自动战斗,再加载配置")
return
if self.capture_profile is None:
self.report("尚未保存页面截图")
return
try:
self.update_farm_config()
self.farm.config.templates = load_buttons(self.capture_profile, self.state, self.stage.currentData(), self.stage_level.currentData(), self.serial.text().strip())
self.farm.config.capture_profile = str(self.capture_profile.relative_to(self.state.resolve()))
self.template_status.setText("已加载页面按钮配置:" + ", ".join(self.farm.config.templates))
self.save_config()
except FileNotFoundError:
self.report("页面截图已保存;按钮配置尚未生成,截图齐后可直接读取这些文件进行配置")
except (ValueError, KeyError, TypeError, OSError) as error:
self.report(str(error))
def show_debug(self): def show_debug(self):
self.debug_window.show() self.debug_window.show()
self.debug_window.raise_() self.debug_window.raise_()
@@ -1092,13 +831,15 @@ class Window(ActivityPages, W.QMainWindow):
action.triggered.connect(lambda: self.refresh_page(tab)) action.triggered.connect(lambda: self.refresh_page(tab))
if tab is self.monster_page: if tab is self.monster_page:
if target is self.monsters.viewport(): if target is self.monsters.viewport():
row = self.monsters.indexAt(position).row() item = self.monsters.itemAt(position)
if row >= 0 and not self.monsters.selectionModel().isRowSelected(row, C.QModelIndex()): if item is not None and not item.isSelected():
self.monsters.selectRow(row) self.monsters.clearSelection()
self.monsters.setCurrentItem(item)
item.setSelected(item.data(0, C.Qt.ItemDataRole.UserRole) is not None)
menu.addSeparator() menu.addSeparator()
detail = menu.addAction("查看魔物详情") detail = menu.addAction("查看魔物详情")
detail.setEnabled(bool(self.selected_monster_ids())) detail.setEnabled(bool(self.selected_monster_ids()))
detail.triggered.connect(lambda: self.show_monster_detail(self.monsters.currentRow())) detail.triggered.connect(lambda: self.show_monster_detail(self.selected_monster_ids()[0]) if self.selected_monster_ids() else None)
for label, locked in (("锁定选中魔物", True), ("解锁选中魔物", False)): for label, locked in (("锁定选中魔物", True), ("解锁选中魔物", False)):
action = menu.addAction(label) action = menu.addAction(label)
action.setEnabled(bool(self.selected_monster_ids()) and not self.busy) action.setEnabled(bool(self.selected_monster_ids()) and not self.busy)
@@ -1107,6 +848,11 @@ class Window(ActivityPages, W.QMainWindow):
action = menu.addAction(label) action = menu.addAction(label)
action.setEnabled(bool(self.selected_monster_ids()) and not self.busy) action.setEnabled(bool(self.selected_monster_ids()) and not self.busy)
action.triggered.connect(lambda checked=False, kind=kind: self.request_monster_action(kind)) action.triggered.connect(lambda checked=False, kind=kind: self.request_monster_action(kind))
menu.addSeparator()
for label, currency in (("新建牧场:使用金币…", "money"), ("新建牧场:使用氪金…", "ke")):
action = menu.addAction(label)
action.setEnabled(not self.busy)
action.triggered.connect(lambda checked=False, currency=currency: self.request_expansion("room", currency))
elif tab in (self.slot_page, self.room_page): elif tab in (self.slot_page, self.room_page):
if tab is self.slot_page and target is self.slots.viewport(): if tab is self.slot_page and target is self.slots.viewport():
row = self.slots.indexAt(position).row() row = self.slots.indexAt(position).row()
@@ -1121,13 +867,11 @@ class Window(ActivityPages, W.QMainWindow):
menu.popup(target.mapToGlobal(position)) menu.popup(target.mapToGlobal(position))
def selected_monster_ids(self): def selected_monster_ids(self):
return [int(self.monsters.item(index.row(), 0).text()) for index in self.monsters.selectionModel().selectedRows() return self.monsters.selected_monster_ids()
if self.monsters.item(index.row(), 0)]
def show_monster_detail(self, row): def show_monster_detail(self, mid):
if row < 0 or not self.monsters.item(row, 0) or self.engine.snapshot is None: if self.engine.snapshot is None:
return return
mid = int(self.monsters.item(row, 0).text())
mon = self.engine.snapshot.monsters.get(mid) mon = self.engine.snapshot.monsters.get(mid)
if not mon: if not mon:
return return
@@ -1226,8 +970,6 @@ class Window(ActivityPages, W.QMainWindow):
if tab is self.yields.parentWidget(): if tab is self.yields.parentWidget():
self.render_catalog() self.render_catalog()
self.report("收益资料已从本地表刷新") self.report("收益资料已从本地表刷新")
elif tab is self.capture_scroll:
self.refresh_capture_profiles()
else: else:
self.refresh() self.refresh()
@@ -1256,7 +998,6 @@ class Window(ActivityPages, W.QMainWindow):
self.error("保存的会话无法读取,请重新登录") self.error("保存的会话无法读取,请重新登录")
return return
self.start_monitor.setChecked(False) self.start_monitor.setChecked(False)
self.start_farm.setChecked(False)
self.execute.setChecked(False) self.execute.setChecked(False)
self.session_label = self.saved_sessions.currentText().rsplit(" / ", 1)[0] self.session_label = self.saved_sessions.currentText().rsplit(" / ", 1)[0]
label = self.session_label label = self.session_label
@@ -1292,15 +1033,11 @@ class Window(ActivityPages, W.QMainWindow):
if self.active_identity: if self.active_identity:
self.save_config(quiet=True) self.save_config(quiet=True)
self.start_monitor.setChecked(False) self.start_monitor.setChecked(False)
self.start_farm.setChecked(False)
self.execute.setChecked(False) self.execute.setChecked(False)
self.active_identity = key self.active_identity = key
self.state = self.profile_root / "roles" / key self.state = self.profile_root / "roles" / key
self.capture_profile = None
self.farm = FarmRunner(Adb(), self.catalog, self.state)
self.load_config(copy.deepcopy(self.default_config)) self.load_config(copy.deepcopy(self.default_config))
self.load_config() self.load_config()
self.refresh_capture_profiles()
self.render_catalog() self.render_catalog()
def logout_and_clear(self): def logout_and_clear(self):
@@ -1388,32 +1125,12 @@ class Window(ActivityPages, W.QMainWindow):
self.render(snapshot, plans) self.render(snapshot, plans)
self.report(message) self.report(message)
self.reload_saved_sessions() self.reload_saved_sessions()
if kind == "poll" and self.engine.last_executed and self.execute.isChecked() and self.monitoring: if kind == "poll":
self.next_poll = time.monotonic() + .15 self.next_poll = time.monotonic() + self.poll_delay()
if "策略暂不可用" in message: if "策略暂不可用" in message:
self.execute.setChecked(False) self.execute.setChecked(False)
elif kind == "heartbeat": elif kind == "heartbeat":
self.report(value) self.report(value)
elif kind == "capture":
self.screen.set_image(value)
elif kind == "page_sample":
captured_path, profile, image = value
self.capture_profile = captured_path
self.refresh_capture_profiles()
if self.capture_profile == captured_path:
self.capture_preview.set_image(image)
self.save_config()
count = len(profile["captures"])
self.report(f"已保存 {count}/{len(PAGES)} 个页面样本:{captured_path.parent}")
if {"stage_ready", "victory"}.issubset(profile["captures"]):
self.report("必需页面已齐,可告知助手直接读取本地截图并生成配置;其余页面按需补拍")
elif kind == "farm":
self.farm_status.setText(value)
if not self.farm.running:
self.start_farm.setChecked(False)
if "结算完成" in value:
self.next_poll = 0
self.report(value)
elif kind == "connected": elif kind == "connected":
client, snapshot = value client, snapshot = value
if self.connection_guard and not self.connection_guard(client.session): if self.connection_guard and not self.connection_guard(client.session):
@@ -1502,8 +1219,6 @@ class Window(ActivityPages, W.QMainWindow):
self.execute.setChecked(False) self.execute.setChecked(False)
self.monitoring = False self.monitoring = False
self.start_monitor.setChecked(False) self.start_monitor.setChecked(False)
self.farm.stop()
self.start_farm.setChecked(False)
self.report("已停止:" + message) self.report("已停止:" + message)
self.statusBar().showMessage(message) self.statusBar().showMessage(message)
@@ -1546,7 +1261,6 @@ class Window(ActivityPages, W.QMainWindow):
self.engine.daily_policy = self.read_daily_policy() self.engine.daily_policy = self.read_daily_policy()
self.engine.sweep_policy = self.read_sweep_policy() self.engine.sweep_policy = self.read_sweep_policy()
self.engine.auto = self.execute.isChecked() and automated and self.monitoring self.engine.auto = self.execute.isChecked() and automated and self.monitoring
self.next_poll = time.monotonic() + self.interval.currentData()
self.submit("poll", self.engine.poll) self.submit("poll", self.engine.poll)
except ValueError: except ValueError:
if automated: if automated:
@@ -1567,17 +1281,23 @@ class Window(ActivityPages, W.QMainWindow):
self.execute.setChecked(False) self.execute.setChecked(False)
self.update_workflow_status() self.update_workflow_status()
def poll_delay(self):
return random.uniform(0, self.interval.currentData())
def poll_interval_changed(self, *args):
self.next_poll = time.monotonic() + self.poll_delay()
self.save_config(quiet=True)
def schedule(self): def schedule(self):
if self.busy or self.closed: if self.busy or self.closed:
return return
now = time.monotonic() now = time.monotonic()
if not self.engine.demo and self.engine.heartbeat_enabled and now - self.engine.last_heartbeat >= 240: if not self.engine.demo and self.engine.heartbeat_enabled and now - self.engine.last_heartbeat >= 240:
self.submit("heartbeat", self.engine.keep_alive) self.submit("heartbeat", self.engine.keep_alive)
elif (self.monitoring or self.farm.running) and now >= self.next_poll: elif not self.engine.demo and self.engine.heartbeat_enabled and self.engine.growth_sync_due():
self.submit("growth_sync", self.engine.sync_growth)
elif self.monitoring and now >= self.next_poll:
self.refresh(automated=True) self.refresh(automated=True)
elif self.farm.running and now >= self.next_farm and self.engine.snapshot:
self.next_farm = now + 2
self.submit("farm", lambda: self.farm.tick(self.engine.snapshot))
def render(self, snapshot, plans): def render(self, snapshot, plans):
self.latest_render = (snapshot, plans) self.latest_render = (snapshot, plans)
@@ -1655,7 +1375,6 @@ class Window(ActivityPages, W.QMainWindow):
inventory.row_batch.stop() inventory.row_batch.stop()
try: try:
if page is self.monster_page: if page is self.monster_page:
self.render_rooms(snapshot)
self.render_monsters(snapshot) self.render_monsters(snapshot)
elif page is self.inventory_tabs: elif page is self.inventory_tabs:
if self.inventory_tabs.currentWidget() is self.egg_rules_page: if self.inventory_tabs.currentWidget() is self.egg_rules_page:
@@ -1664,8 +1383,6 @@ class Window(ActivityPages, W.QMainWindow):
active_inventory.set_data(snapshot, self.gift_items) active_inventory.set_data(snapshot, self.gift_items)
elif page is self.egg_page: elif page is self.egg_page:
self.render_egg_rules() self.render_egg_rules()
elif page is self.room_page:
self.render_rooms(snapshot)
elif page is self.quests_table.parentWidget(): elif page is self.quests_table.parentWidget():
self.render_quests(snapshot) self.render_quests(snapshot)
elif page is self.map_page: elif page is self.map_page:
@@ -1683,83 +1400,8 @@ class Window(ActivityPages, W.QMainWindow):
if views and views.snapshot is snapshot and views.monster_source == repr(snapshot.raw["monsters"]) and views.managed == managed: if views and views.snapshot is snapshot and views.monster_source == repr(snapshot.raw["monsters"]) and views.managed == managed:
rows = views.monsters rows = views.monsters
else: else:
rows = monster_rows(self.catalog, snapshot, managed, self.monster_room.currentData() or 0) rows = monster_rows(self.catalog, snapshot, managed)
room_id = self.monster_room.currentData() or 0 self.monsters.set_data(snapshot, rows, self.feed_targets, self.gift_targets)
if room_id:
rows = monster_rows(self.catalog, snapshot, managed, room_id)
visible_monsters = [mon for mon in snapshot.raw["monsters"] if not room_id or mon.get("process") == 3 and int(mon.get("roomId") or 0) == room_id]
signature = (rows, dict(self.feed_targets), dict(self.gift_targets), room_id)
if getattr(self, "monster_render_signature", None) == signature:
return
if not hasattr(self, "monster_render_timer"):
self.monster_render_timer = RowBatch(self)
self.monsters.setSortingEnabled(False)
self.monsters.setRowCount(len(rows))
def apply(entry):
row_index, mon, values = entry
for column, value in enumerate(values):
item = self.monsters.item(row_index, column)
if item is None:
item = W.QTableWidgetItem()
self.monsters.setItem(row_index, column, item)
if item.data(C.Qt.ItemDataRole.DisplayRole) != value:
item.setData(C.Qt.ItemDataRole.DisplayRole, value)
mid = str(mon["id"])
existing = self.monsters.cellWidget(row_index, 8)
if existing and existing.property("monster_id") == mid:
priority = self.monsters.cellWidget(row_index, 9)
gift_check, gift_priority = self.monsters.cellWidget(row_index, 17), self.monsters.cellWidget(row_index, 18)
blockers = [C.QSignalBlocker(existing), C.QSignalBlocker(priority), C.QSignalBlocker(gift_check), C.QSignalBlocker(gift_priority)]
existing.setChecked(mid in self.feed_targets)
existing.setEnabled(mon.get("process") == 3)
if not priority.hasFocus():
priority.setValue(self.feed_targets.get(mid, 100))
gift_check.setChecked(mid in self.gift_targets)
gift_priority.setValue(self.gift_targets.get(mid, 100))
return
check, priority = W.QCheckBox(), IntegerInput()
check.setProperty("monster_id", mid)
priority.setRange(1, 999)
priority.setValue(self.feed_targets.get(mid, 100))
check.setChecked(mid in self.feed_targets)
check.setEnabled(mon.get("process") == 3)
priority.setFixedWidth(76)
def changed(*args, mid=mid, check=check, priority=priority):
if check.isChecked():
self.feed_targets[mid] = priority.value()
self.feed.setChecked(True)
self.collect.setChecked(True)
else:
self.feed_targets.pop(mid, None)
self.save_config(quiet=True)
self.update_target_status()
check.toggled.connect(changed)
priority.valueChanged.connect(changed)
self.monsters.setCellWidget(row_index, 8, check)
self.monsters.setCellWidget(row_index, 9, priority)
self.monsters.item(row_index, 16).setToolTip(str(values[16]))
gift_check, gift_priority = W.QCheckBox(), IntegerInput()
gift_check.setChecked(mid in self.gift_targets)
gift_check.setEnabled(mon.get("process") == 3)
gift_priority.setRange(1, 999)
gift_priority.setValue(self.gift_targets.get(mid, 100))
gift_priority.setEnabled(mon.get("process") == 3)
def gift_changed(*args, mid=mid, check=gift_check, priority=gift_priority):
if check.isChecked():
self.gift_targets[mid] = priority.value()
self.gift_enabled.setChecked(True)
else:
self.gift_targets.pop(mid, None)
self.save_config(quiet=True)
self.update_gift_status()
gift_check.toggled.connect(gift_changed)
gift_priority.valueChanged.connect(gift_changed)
self.monsters.setCellWidget(row_index, 17, gift_check)
self.monsters.setCellWidget(row_index, 18, gift_priority)
def finish():
self.monster_render_signature = copy.deepcopy(signature)
self.monsters.setSortingEnabled(True)
self.monster_render_timer.start(((i, mon, values) for i, (mon, values) in enumerate(zip(visible_monsters, rows))), apply, finish)
def refresh_target_choices(self, snapshot): def refresh_target_choices(self, snapshot):
self.update_combo(self.target, [("未设置:不自动喂养", 0)] + [(f"{self.catalog.monster(m['typeId']).get('name')} Lv.{m.get('level', 1)}/{self.catalog.max_level(m) or '?'} #{m['id']}", int(m["id"])) for m in snapshot.raw["monsters"] if m.get("process") == 3]) self.update_combo(self.target, [("未设置:不自动喂养", 0)] + [(f"{self.catalog.monster(m['typeId']).get('name')} Lv.{m.get('level', 1)}/{self.catalog.max_level(m) or '?'} #{m['id']}", int(m["id"])) for m in snapshot.raw["monsters"] if m.get("process") == 3])
@@ -1773,16 +1415,6 @@ class Window(ActivityPages, W.QMainWindow):
self.update_combo(self.monster_room, [("全部牧场", 0)] + [(f"{r.get('name') or '牧场'} #{r['id']}", int(r["id"])) for r in snapshot.raw["rooms"]]) self.update_combo(self.monster_room, [("全部牧场", 0)] + [(f"{r.get('name') or '牧场'} #{r['id']}", int(r["id"])) for r in snapshot.raw["rooms"]])
self.update_gift_status() self.update_gift_status()
def render_rooms(self, snapshot):
rooms = []
for room in snapshot.raw["rooms"]:
info = self.catalog.data["room_info"].get(str(room.get("typeId")), {})
used = sum(int(mon.get("roomId") or 0) == int(room["id"]) and mon.get("process") == 3 for mon in snapshot.raw["monsters"])
capacity = info.get("maxNum")
rooms.append([room["id"], room.get("name") or info.get("name") or "牧场", room.get("typeId", ""), used,
capacity if capacity is not None else "未知", max(0, int(capacity) - used) if capacity is not None else "未知"])
fill_table(self.rooms_table, rooms)
def render_quests(self, snapshot): def render_quests(self, snapshot):
quest_policy = self.read_quest_policy() quest_policy = self.read_quest_policy()
quest_rows = self.engine.tasks.rows(snapshot, quest_policy, self.read_policy()) quest_rows = self.engine.tasks.rows(snapshot, quest_policy, self.read_policy())
@@ -1850,7 +1482,6 @@ class Window(ActivityPages, W.QMainWindow):
if self.busy: if self.busy:
return return
self.start_monitor.setChecked(False) self.start_monitor.setChecked(False)
self.start_farm.setChecked(False)
self.session_label = "" self.session_label = ""
if not self.token.text().strip(): if not self.token.text().strip():
self.error("请先导入手机会话或填写 Token") self.error("请先导入手机会话或填写 Token")
@@ -1862,7 +1493,6 @@ class Window(ActivityPages, W.QMainWindow):
if self.busy: if self.busy:
return return
self.start_monitor.setChecked(False) self.start_monitor.setChecked(False)
self.start_farm.setChecked(False)
self.execute.setChecked(False) self.execute.setChecked(False)
if self.active_identity: if self.active_identity:
self.save_config(quiet=True) self.save_config(quiet=True)
@@ -1872,8 +1502,6 @@ class Window(ActivityPages, W.QMainWindow):
self.engine = Engine(self.catalog) self.engine = Engine(self.catalog)
self.active_identity = None self.active_identity = None
self.state = self.profile_root self.state = self.profile_root
self.capture_profile = None
self.farm = FarmRunner(Adb(), self.catalog, self.state)
self.load_config(copy.deepcopy(self.default_config)) self.load_config(copy.deepcopy(self.default_config))
self.load_config() self.load_config()
self.session_label = "" self.session_label = ""
@@ -1902,7 +1530,6 @@ class Window(ActivityPages, W.QMainWindow):
self.error("需要登录中心、SDK用户ID和SDK Token") self.error("需要登录中心、SDK用户ID和SDK Token")
return return
self.start_monitor.setChecked(False) self.start_monitor.setChecked(False)
self.start_farm.setChecked(False)
client = Client(Session(key=self.key.text()), trace=self.trace) client = Client(Session(key=self.key.text()), trace=self.trace)
self.submit("sdk", lambda: (client, client.sdk_login(values[0], values[1], values[2], values[3], values[4], values[5], self.submit("sdk", lambda: (client, client.sdk_login(values[0], values[1], values[2], values[3], values[4], values[5],
tj_channel=self.catalog.data.get("tjchannel", {}).get("tjchannel", "unknow")), values)) tj_channel=self.catalog.data.get("tjchannel", {}).get("tjchannel", "unknow")), values))
@@ -1919,7 +1546,6 @@ class Window(ActivityPages, W.QMainWindow):
return return
self.save_login_info(quiet=True) self.save_login_info(quiet=True)
self.start_monitor.setChecked(False) self.start_monitor.setChecked(False)
self.start_farm.setChecked(False)
self.enter_button.setEnabled(False) self.enter_button.setEnabled(False)
self.server_list.clear() self.server_list.clear()
if self.password_login_result and self.password_login_result[0] is not self.engine.client: if self.password_login_result and self.password_login_result[0] is not self.engine.client:
@@ -1953,65 +1579,13 @@ class Window(ActivityPages, W.QMainWindow):
return client, client.snapshot() return client, client.snapshot()
self.submit("connected", enter) self.submit("connected", enter)
def capture(self):
if not self.busy:
self.farm.adb = Adb(self.adb_path.text(), self.serial.text().strip())
self.submit("capture", self.farm.adb.screenshot)
def save_template(self, box):
if self.farm.running:
self.error("请先停止刷图再修改按钮标定")
return
self.state.mkdir(parents=True, exist_ok=True)
name = self.template.currentData()
filename = name + ".png"
self.screen.image.crop(box).save(self.state / filename)
self.farm.config.templates[name] = {"file": filename, "box": list(box), "screen": [self.screen.image.width, self.screen.image.height], "stage_id": self.stage.currentData(), "stage_level": self.stage_level.currentData()}
self.farm.config.capture_profile = ""
self.template_status.setText("已标定:" + ", ".join(self.farm.config.templates))
self.save_config()
def toggle_farm(self, value):
if not value:
self.farm.stop()
self.start_farm.setText("开始布丁牧场刷图")
return
if self.map_enabled.isChecked() and self.execute.isChecked():
self.start_farm.setChecked(False)
self.report("请先停止地图页的接口扫荡,再开始手机实战")
return
if self.busy or self.engine.demo or self.engine.snapshot is None:
self.start_farm.setChecked(False)
self.report("请先连接真实手机会话,等待刷新完成后再开始刷图")
return
try:
self.update_farm_config()
if self.device_guard and not self.device_guard(self.farm.adb.serial):
self.start_farm.setChecked(False)
self.report("此手机已由另一个账号页签刷图,请先停止该页签或选择其他设备")
return
self.farm.start()
self.start_farm.setText("停止刷图")
self.next_poll = self.next_farm = 0
self.save_config()
except Exception as error:
self.start_farm.setChecked(False)
self.report(str(error))
def update_farm_config(self):
self.farm.adb = Adb(self.adb_path.text(), self.serial.text().strip())
self.farm.config = FarmConfig(stage_id=self.stage.currentData(), stage_level=self.stage_level.currentData(), daily_limit=self.daily.value(), keep_stamina=self.keep_ti.value(),
timeout=self.timeout.value(), threshold=self.threshold.value(), templates=self.farm.config.templates, capture_profile=self.farm.config.capture_profile)
def config_value(self): def config_value(self):
self.update_farm_config()
return {"policy": asdict(self.read_policy()), "quest_policy": asdict(self.read_quest_policy()), return {"policy": asdict(self.read_policy()), "quest_policy": asdict(self.read_quest_policy()),
"daily_policy": asdict(self.read_daily_policy()), "sweep_policy": asdict(self.read_sweep_policy()), "daily_policy": asdict(self.read_daily_policy()), "sweep_policy": asdict(self.read_sweep_policy()),
"farm": asdict(self.farm.config), "overrides": copy.deepcopy(self.catalog.overrides), "overrides": copy.deepcopy(self.catalog.overrides),
"log_visible": self.show_log.isChecked(), "log_sizes": self.log_splitter.sizes() if self.show_log.isChecked() else self.log_sizes, "log_visible": self.show_log.isChecked(), "log_sizes": self.log_splitter.sizes() if self.show_log.isChecked() else self.log_sizes,
"yield_stars": [star for star, check in self.yield_stars.items() if check.isChecked()], "yield_stars": [star for star, check in self.yield_stars.items() if check.isChecked()],
"adb_path": self.adb_path.text(), "serial": self.serial.text().strip(), "interval": self.interval.currentData(), "interval": self.interval.currentData()}
"capture_profile": str(self.capture_profile.relative_to(self.state.resolve())) if self.capture_profile else None}
def save_config(self, *args, quiet=False): def save_config(self, *args, quiet=False):
try: try:
@@ -2021,7 +1595,7 @@ class Window(ActivityPages, W.QMainWindow):
temporary.write_text(json.dumps(value, ensure_ascii=False, indent=2), encoding="utf-8") temporary.write_text(json.dumps(value, ensure_ascii=False, indent=2), encoding="utf-8")
temporary.replace(self.state / "settings.json") temporary.replace(self.state / "settings.json")
if not quiet: if not quiet:
self.report("已保存当前角色的策略和标定;会话单独加密保存") self.report("已保存当前角色的策略;会话单独加密保存")
except ValueError: except ValueError:
self.error("设置格式不正确,未保存") self.error("设置格式不正确,未保存")
@@ -2085,7 +1659,10 @@ class Window(ActivityPages, W.QMainWindow):
self.gift_items = copy.deepcopy(policy.gift_items) self.gift_items = copy.deepcopy(policy.gift_items)
self.gift_enabled.setChecked(policy.gift_enabled) self.gift_enabled.setChecked(policy.gift_enabled)
self.gift_liked_only.setChecked(policy.gift_liked_only) self.gift_liked_only.setChecked(policy.gift_liked_only)
for widget, data in ((self.strategy, policy.strategy), (self.protect_quality, policy.protect_quality), (self.egg_order, policy.egg_order), (self.interval, value.get("interval", 10)), blocker = C.QSignalBlocker(self.interval)
self.interval.setCurrentIndex(max(0, self.interval.findData(value.get("interval", 30))))
del blocker
for widget, data in ((self.strategy, policy.strategy), (self.protect_quality, policy.protect_quality), (self.egg_order, policy.egg_order),
(self.market, policy.market_id), (self.hatch_max_star, policy.hatch_max_star)): (self.market, policy.market_id), (self.hatch_max_star, policy.hatch_max_star)):
widget.setCurrentIndex(max(0, widget.findData(data))) widget.setCurrentIndex(max(0, widget.findData(data)))
for widget, number in ((self.protect_star, policy.protect_star), (self.target_level, policy.target_level), (self.coin_exp, policy.coins_per_exp), (self.min_gold, policy.min_gold_per_hour), (self.min_exp, policy.min_exp_per_hour)): for widget, number in ((self.protect_star, policy.protect_star), (self.target_level, policy.target_level), (self.coin_exp, policy.coins_per_exp), (self.min_gold, policy.min_gold_per_hour), (self.min_exp, policy.min_exp_per_hour)):
@@ -2111,27 +1688,11 @@ class Window(ActivityPages, W.QMainWindow):
self.reserved_types.setText(",".join(map(str, policy.reserved_types))) self.reserved_types.setText(",".join(map(str, policy.reserved_types)))
self.reserve_eggs.setText(",".join(f"{k}:{v}" for k, v in policy.reserved_eggs.items())) self.reserve_eggs.setText(",".join(f"{k}:{v}" for k, v in policy.reserved_eggs.items()))
self.restore_target, self.restore_room = policy.feed_target, policy.room_id self.restore_target, self.restore_room = policy.feed_target, policy.room_id
self.farm.config = FarmConfig(**value.get("farm", {}))
if self.stage.findData(self.farm.config.stage_id) < 0:
info = self.catalog.data["stage_info"].get(self.farm.config.stage_id, {})
self.stage.addItem(info.get("name", self.farm.config.stage_id), self.farm.config.stage_id)
self.stage.setCurrentIndex(max(0, self.stage.findData(self.farm.config.stage_id)))
self.stage_level.setCurrentIndex(max(0, self.stage_level.findData(self.farm.config.stage_level)))
for widget, number in ((self.daily, self.farm.config.daily_limit), (self.keep_ti, self.farm.config.keep_stamina), (self.timeout, self.farm.config.timeout), (self.threshold, self.farm.config.threshold)):
widget.setValue(number)
self.adb_path.setText(value.get("adb_path", self.adb_path.text()))
self.serial.setText(value.get("serial", ""))
self.catalog.overrides = value.get("overrides", {}) self.catalog.overrides = value.get("overrides", {})
self.template_status.setText("已标定:" + ", ".join(self.farm.config.templates))
if value.get("capture_profile"):
candidate = (self.state / value["capture_profile"]).resolve()
if candidate.is_relative_to(self.state.resolve()):
self.capture_profile = candidate
self.refresh_capture_status()
self.render_egg_rules() self.render_egg_rules()
self.render_catalog() self.render_catalog()
self.update_workflow_status() self.update_workflow_status()
self.monster_render_signature = None self.monsters.render_signature = None
if self.latest_render: if self.latest_render:
self.render_current_page() self.render_current_page()
except Exception: except Exception:
@@ -2151,7 +1712,6 @@ class Window(ActivityPages, W.QMainWindow):
self.pending_refresh = None self.pending_refresh = None
self.engine.auto = False self.engine.auto = False
self.monitoring = False self.monitoring = False
self.farm.stop()
if self.busy: if self.busy:
self.close_after_job = True self.close_after_job = True
self.setEnabled(False) self.setEnabled(False)
-20
View File
@@ -1,6 +1,5 @@
"""Native, incremental inventory and combined ranch/monster views.""" """Native, incremental inventory and combined ranch/monster views."""
import copy import copy
from dataclasses import asdict
from PySide6 import QtCore as C, QtWidgets as W from PySide6 import QtCore as C, QtWidgets as W
from .native_widgets import IntegerInput, RowBatch from .native_widgets import IntegerInput, RowBatch
@@ -92,22 +91,3 @@ class InventoryTable(W.QTableWidget):
self.setSortingEnabled(True) self.setSortingEnabled(True)
self.render_signature = copy.deepcopy(signature) self.render_signature = copy.deepcopy(signature)
self.row_batch.start(enumerate(rows), apply, finish) self.row_batch.start(enumerate(rows), apply, finish)
class RanchView(W.QSplitter):
def __init__(self, rooms, monsters):
super().__init__(C.Qt.Orientation.Vertical)
self.rooms, self.monsters = rooms, monsters
self.grouped = True
self.room_id = 0
self.setChildrenCollapsible(False)
self.addWidget(rooms)
self.addWidget(monsters)
self.setStretchFactor(0, 0)
self.setStretchFactor(1, 1)
self.setSizes([100, 440])
def set_view(self, grouped, room_id=0):
self.grouped, self.room_id = grouped, room_id
self.rooms.setVisible(grouped)
self.setSizes([100, 440] if grouped else [0, 540])
+2
View File
@@ -341,6 +341,8 @@ class Planner:
if condition: if condition:
return reason return reason
quality = math.ceil(sum(qualities) / 4) quality = math.ceil(sum(qualities) / 4)
if policy.protect_quality == 6:
return "攻/防/生命/敏捷四项资质全S(4S)" if all(q == 4 for q in qualities) else ""
if quality >= policy.protect_quality: if quality >= policy.protect_quality:
return f"综合资质{'CBAS'[quality - 1]}达到保留资质{'CBAS'[policy.protect_quality - 1]}" return f"综合资质{'CBAS'[quality - 1]}达到保留资质{'CBAS'[policy.protect_quality - 1]}"
return "" return ""
+7 -1
View File
@@ -55,7 +55,13 @@ class IntegerInput(W.QLineEdit):
return self._value return self._value
def setValue(self, value): def setValue(self, value):
self.setText(str(min(self._maximum, max(self._minimum, int(value))))) value = min(self._maximum, max(self._minimum, int(value)))
changed = value != self._value
# Signal blockers must not prevent updates to the stored numeric value.
self._value = value
self.setText(str(value))
if changed:
self.valueChanged.emit(value)
def setRange(self, minimum, maximum): def setRange(self, minimum, maximum):
self._minimum, self._maximum = int(minimum), int(maximum) self._minimum, self._maximum = int(minimum), int(maximum)
+150
View File
@@ -0,0 +1,150 @@
"""Incremental monster tree with ranch headers or a flat list."""
import copy
from collections import Counter
from PySide6 import QtCore as C, QtWidgets as W
from .native_widgets import IntegerInput, RowBatch
class RanchView(W.QTreeWidget):
feed_changed = C.Signal(str, bool, int)
gift_changed = C.Signal(str, bool, int)
monster_activated = C.Signal(int)
def __init__(self, catalog):
super().__init__()
self.catalog = catalog
self.setHeaderLabels(["牧场 / 魔物ID", "名称", "星", "等级 / 当前上限", "资质 攻/防/血/敏", "位置", "锁定", "管理范围",
"喂养目标", "喂养优先级", "突破等级", "参考攻击", "参考防御", "参考生命", "参考敏捷", "好感 / 当前上限", "喜欢的物品", "赠礼", "赠礼优先级"])
self.header().setSectionResizeMode(W.QHeaderView.ResizeMode.Interactive)
for column, width in enumerate((260, 140, 45, 120, 150, 140, 80, 130, 90, 110, 85, 90, 90, 90, 90, 90, 220, 65, 110)):
self.setColumnWidth(column, width)
self.setSelectionMode(W.QAbstractItemView.SelectionMode.ExtendedSelection)
self.setSelectionBehavior(W.QAbstractItemView.SelectionBehavior.SelectRows)
self.setEditTriggers(W.QAbstractItemView.EditTrigger.NoEditTriggers)
self.setUniformRowHeights(True)
self.setAllColumnsShowFocus(True)
self.grouped, self.room_id = True, 0
self.monster_items, self.group_items, self.expansion = {}, {}, {}
self.render_signature = None
self.row_batch = RowBatch(self)
self.itemDoubleClicked.connect(self.activate_monster)
def activate_monster(self, item, column):
mid = item.data(0, C.Qt.ItemDataRole.UserRole)
if mid is not None:
self.monster_activated.emit(int(mid))
def selected_monster_ids(self):
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 set_view(self, grouped, room_id=0):
self.grouped, self.room_id = grouped, room_id if grouped else 0
@staticmethod
def group_key(mon):
if mon.get("process") == 2:
return "incubator"
return f"room:{int(mon.get('roomId') or 0)}"
def set_data(self, snapshot, rows, feed_targets, gift_targets):
monsters = snapshot.raw["monsters"]
entries = [(mon, values) for mon, values in zip(monsters, rows)
if not self.room_id or mon.get("process") == 3 and int(mon.get("roomId") or 0) == self.room_id]
signature = (entries, snapshot.raw["rooms"], feed_targets, gift_targets, self.grouped, self.room_id)
if self.render_signature == signature:
return
self.row_batch.stop()
self.render_signature = None
self.setSortingEnabled(False)
selected = set(self.selected_monster_ids())
self.expansion.update({key: item.isExpanded() for key, item in self.group_items.items()})
counts = Counter(self.group_key(mon) for mon, _ in entries)
groups = {}
if self.grouped:
for room in snapshot.raw["rooms"]:
rid = int(room["id"])
if self.room_id and rid != self.room_id:
continue
key = f"room:{rid}"
info = self.catalog.data["room_info"].get(str(room.get("typeId")), {})
capacity = info.get("maxNum")
label = f"{room.get('name') or info.get('name') or '牧场'} #{rid} | 魔物 {counts[key]}"
if capacity is not None:
label += f" / {capacity} | 空位 {max(0, int(capacity) - counts[key])}"
groups[key] = label
for key, count in counts.items():
if key not in groups:
label = "培育室" if key == "incubator" else "未归属牧场" if key == "room:0" else "牧场 #" + key.split(":")[1]
groups[key] = f"{label} | 魔物 {count}"
wanted = {int(mon["id"]): self.group_key(mon) if self.grouped else None for mon, _ in entries}
for mid, item in list(self.monster_items.items()):
current_group = item.parent().data(0, C.Qt.ItemDataRole.UserRole + 1) if item.parent() is not None else None
if mid not in wanted or current_group != wanted[mid]:
self.remove_item(item)
del self.monster_items[mid]
for key, item in list(self.group_items.items()):
if key not in groups:
self.remove_item(item)
del self.group_items[key]
for key, label in groups.items():
item = self.group_items.get(key)
if item is None:
item = W.QTreeWidgetItem(self, [label])
item.setData(0, C.Qt.ItemDataRole.UserRole + 1, key)
item.setFirstColumnSpanned(True)
item.setSizeHint(0, C.QSize(100, 26))
item.setFlags(item.flags() & ~C.Qt.ItemFlag.ItemIsSelectable)
item.setExpanded(self.expansion.get(key, True))
self.group_items[key] = item
item.setText(0, label)
self.setRootIsDecorated(self.grouped)
def apply(entry):
mon, values = entry
mid = int(mon["id"])
item = self.monster_items.get(mid)
if item is None:
parent = self.group_items.get(wanted[mid])
item = W.QTreeWidgetItem(parent if parent is not None else self)
item.setData(0, C.Qt.ItemDataRole.UserRole, mid)
self.monster_items[mid] = item
for check_column, priority_column, signal in ((8, 9, self.feed_changed), (17, 18, self.gift_changed)):
check, priority = W.QCheckBox(), IntegerInput()
priority.setRange(1, 999)
priority.setFixedWidth(76)
def changed(*args, check=check, priority=priority, signal=signal, mid=mid):
signal.emit(str(mid), check.isChecked(), priority.value())
check.toggled.connect(changed)
priority.valueChanged.connect(changed)
self.setItemWidget(item, check_column, check)
self.setItemWidget(item, priority_column, priority)
item.setSizeHint(0, C.QSize(100, 26))
item.setSelected(mid in selected)
for column, value in enumerate(values):
if item.data(column, C.Qt.ItemDataRole.DisplayRole) != value:
item.setData(column, C.Qt.ItemDataRole.DisplayRole, value)
item.setToolTip(16, str(values[16]))
for check_column, priority_column, targets in ((8, 9, feed_targets), (17, 18, gift_targets)):
check, priority = self.itemWidget(item, check_column), self.itemWidget(item, priority_column)
blockers = [C.QSignalBlocker(check), C.QSignalBlocker(priority)]
check.setChecked(str(mid) in targets)
check.setEnabled(mon.get("process") == 3)
priority.setEnabled(mon.get("process") == 3)
if not priority.hasFocus():
priority.setValue(targets.get(str(mid), 100))
def finish():
self.render_signature = copy.deepcopy(signature)
self.setSortingEnabled(True)
self.row_batch.start(entries, apply, finish)
def remove_item(self, item):
parent = item.parent()
if parent is None:
self.takeTopLevelItem(self.indexOfTopLevelItem(item))
else:
parent.takeChild(parent.indexOfChild(item))
-1
View File
@@ -1,5 +1,4 @@
PySide6>=6.8,<7 PySide6>=6.8,<7
requests>=2.32,<3 requests>=2.32,<3
cryptography>=43 cryptography>=43
Pillow>=11
openpyxl>=3.1,<4 openpyxl>=3.1,<4
+2 -5
View File
@@ -172,7 +172,8 @@ class AccountGuiTests(unittest.TestCase):
hub.tabs.setCurrentWidget(first) hub.tabs.setCurrentWidget(first)
for page in (first.egg_page, first.monster_page, first.room_page): for page in (first.egg_page, first.monster_page, first.room_page):
first.tabs.setCurrentWidget(page) first.tabs.setCurrentWidget(page)
self.assertEqual([first.slots.rowCount(), first.eggs.rowCount(), first.monsters.rowCount(), first.rooms_table.rowCount()], [11, 4, 4, 1]) self.assertEqual([first.slots.rowCount(), first.eggs.rowCount(), len(first.monsters.monster_items)], [11, 4, 4])
self.assertIn("room:1", first.monsters.group_items)
self.assertEqual(first.saved_sessions.count(), 1) self.assertEqual(first.saved_sessions.count(), 1)
first.start_monitor.setChecked(True) first.start_monitor.setChecked(True)
hub.tabs.setCurrentWidget(second) hub.tabs.setCurrentWidget(second)
@@ -204,10 +205,6 @@ class AccountGuiTests(unittest.TestCase):
self.assertTrue(all(url.endswith("masterService/masterQueryDetail") for _, url, _ in calls[before:])) self.assertTrue(all(url.endswith("masterService/masterQueryDetail") for _, url, _ in calls[before:]))
self.assertFalse(first.engine.auto) self.assertFalse(first.engine.auto)
self.assertIs(first.tabs.currentWidget(), first.egg_page) self.assertIs(first.tabs.currentWidget(), first.egg_page)
first.farm.running = True
first.farm.adb.serial = "phone-a"
self.assertFalse(hub.allow_device(second, "phone-a"))
self.assertTrue(hub.allow_device(second, "phone-b"))
self.assertFalse(hub.allow_login(second, "account-a")) self.assertFalse(hub.allow_login(second, "account-a"))
self.assertFalse(hub.allow_connection(second, first.engine.client.session)) self.assertFalse(hub.allow_connection(second, first.engine.client.session))
finally: finally:
+6 -5
View File
@@ -19,6 +19,9 @@ def scenario():
# One ordinary stage, one not fully passed, one special activity. # One ordinary stage, one not fully passed, one special activity.
catalog.data["stage_info"] = {k: catalog.data["stage_info"][k] for k in ("0101", "0102", "bd00")} catalog.data["stage_info"] = {k: catalog.data["stage_info"][k] for k in ("0101", "0102", "bd00")}
snapshot = demo_snapshot(catalog) snapshot = demo_snapshot(catalog)
for mon in snapshot.raw["monsters"]:
if mon.get("process") == 2:
mon["mode"] = snapshot.expected_growth_mode(mon, catalog)
snapshot.raw["history"].update(unlockStage={"0101": ["1", "2", "3"], "0102": ["1"], "bd00": ["1", "2", "3"]}, snapshot.raw["history"].update(unlockStage={"0101": ["1", "2", "3"], "0102": ["1"], "bd00": ["1", "2", "3"]},
passStage={"0101": ["1", "2", "3"], "0102": ["1"], "bd00": ["1", "2", "3"]}) passStage={"0101": ["1", "2", "3"], "0102": ["1"], "bd00": ["1", "2", "3"]})
snapshot.raw["teams"] = [{"teamName": "teamA", "teamType": "battleTeam", "monsters": [900, 0]}] snapshot.raw["teams"] = [{"teamName": "teamA", "teamType": "battleTeam", "monsters": [900, 0]}]
@@ -241,13 +244,11 @@ class ActivityGuiTests(unittest.TestCase):
self.assertEqual(settings["sweep_policy"]["rules"]["0101"]["limit"], 12) self.assertEqual(settings["sweep_policy"]["rules"]["0101"]["limit"], 12)
window.resize(1100, 650) window.resize(1100, 650)
window.show() window.show()
window.tabs.setCurrentWidget(window.capture_scroll) window.tabs.setCurrentWidget(window.automation_page)
window.automation_tabs.setCurrentWidget(window.policy_scroll)
window.log_splitter.setSizes([180, 450]) window.log_splitter.setSizes([180, 450])
self.app.processEvents() self.app.processEvents()
table_rect = window.capture_rows.geometry() self.assertGreater(window.policy_scroll.verticalScrollBar().maximum(), 0)
next_button = next(b for b in window.capture_page_widget.findChildren(W.QPushButton) if b.text() == "检查已保存截图")
self.assertGreater(next_button.geometry().top(), table_rect.bottom())
self.assertGreater(window.capture_scroll.verticalScrollBar().maximum(), 0)
self.assertEqual(window.styleSheet(), "") self.assertEqual(window.styleSheet(), "")
finally: finally:
window.close() window.close()
+2 -2
View File
@@ -418,8 +418,8 @@ class AutomationGuiTests(unittest.TestCase):
before = len(window.engine.snapshot.raw["monsters"]) before = len(window.engine.snapshot.raw["monsters"])
def select(mid): def select(mid):
window.tabs.setCurrentWidget(window.monster_page) window.tabs.setCurrentWidget(window.monster_page)
row = next(i for i in range(window.monsters.rowCount()) if int(window.monsters.item(i, 0).text()) == mid) window.monsters.clearSelection()
window.monsters.selectRow(row) window.monsters.setCurrentItem(window.monsters.monster_items[mid])
select(101) select(101)
self.assertTrue(window.lock_monsters.isEnabled()) self.assertTrue(window.lock_monsters.isEnabled())
window.lock_monsters.click() window.lock_monsters.click()
+2 -59
View File
@@ -11,11 +11,9 @@ import uuid
from unittest.mock import patch from unittest.mock import patch
import requests import requests
from PIL import Image, ImageDraw
from ranch_assistant.api import ApiError, Client, DEFAULT_KEY, Session, decode, encode from ranch_assistant.api import ApiError, Client, DEFAULT_KEY, Session, decode, encode
from ranch_assistant.engine import Engine, demo_snapshot from ranch_assistant.engine import Engine, demo_snapshot
from ranch_assistant.farming import FarmBudget, FarmConfig, FarmRunner, matches
from ranch_assistant.model import Catalog, Planner, Policy, Snapshot from ranch_assistant.model import Catalog, Planner, Policy, Snapshot
@@ -144,63 +142,7 @@ class CoreTests(unittest.TestCase):
self.assertEqual(post.call_count, 1) self.assertEqual(post.call_count, 1)
self.assertNotIn("private-token", str(raised.exception)) self.assertNotIn("private-token", str(raised.exception))
def test_budget_stamina_tickets_stale_and_persistent_daily_limit(self):
snapshot = self.snapshot()
config = FarmConfig(daily_limit=1)
with workspace_temp() as folder:
budget = FarmBudget(Path(folder) / "runs.json")
self.assertTrue(budget.check(snapshot, config, self.catalog)[0])
snapshot.raw["master"]["ti"] = 5
self.assertFalse(budget.check(snapshot, config, self.catalog)[0])
snapshot.raw["master"]["ti"] = 100
snapshot.raw["items"] = []
self.assertFalse(budget.check(snapshot, config, self.catalog)[0])
snapshot = self.snapshot()
snapshot.received_at -= 60
self.assertFalse(budget.check(snapshot, config, self.catalog)[0])
snapshot.received_at = time.time()
budget.reserve(snapshot, config)
restarted = FarmBudget(Path(folder) / "runs.json")
self.assertFalse(restarted.check(snapshot, config, self.catalog)[0])
def test_farm_screen_gate_and_real_tap_sequence(self):
with workspace_temp() as folder:
folder = Path(folder)
blank = Image.new("RGB", (200, 400), "black")
ready, victory = blank.copy(), blank.copy()
draw = ImageDraw.Draw(ready)
draw.rectangle((10, 10, 99, 39), fill="green")
draw.rectangle((20, 300, 99, 349), fill="red")
ImageDraw.Draw(victory).rectangle((100, 200, 179, 249), fill="blue")
boxes = {"stage": (10, 10, 100, 40), "entry": (20, 300, 100, 350), "victory": (100, 200, 180, 250)}
templates = {}
for name, box in boxes.items():
(victory if name == "victory" else ready).crop(box).save(folder / f"{name}.png")
templates[name] = {"screen": [200, 400], "box": box, "file": name + ".png", "stage_id": "bd00"}
class FakeAdb:
image = ready
taps = []
def foreground(self): return True
def screenshot(self): return self.image
def tap(self, x, y): self.taps.append((x, y))
adb = FakeAdb()
runner = FarmRunner(adb, self.catalog, folder)
runner.config = FarmConfig(templates=templates)
runner.start()
bad = ready.copy()
ImageDraw.Draw(bad).rectangle(boxes["stage"], fill="black")
adb.image = bad
runner.tick(self.snapshot())
self.assertEqual(adb.taps, [])
adb.image = ready
with patch("ranch_assistant.farming.time.monotonic", return_value=10): runner.tick(self.snapshot())
self.assertEqual(len(adb.taps), 1)
adb.image = victory
with patch("ranch_assistant.farming.time.monotonic", return_value=13): runner.tick(self.snapshot())
adb.image = ready
with patch("ranch_assistant.farming.time.monotonic", return_value=16): runner.tick(self.snapshot())
self.assertEqual(runner.completed, 1)
self.assertEqual(len(adb.taps), 2)
class WireIntegrationTests(unittest.TestCase): class WireIntegrationTests(unittest.TestCase):
@@ -242,7 +184,8 @@ class WireIntegrationTests(unittest.TestCase):
engine = Engine(catalog, client) engine = Engine(catalog, client)
engine.policy = Policy(strategy="gold", protect_star=6, protect_quality=5, fill=False) engine.policy = Policy(strategy="gold", protect_star=6, protect_quality=5, fill=False)
engine.poll() engine.poll()
self.assertFalse(any(p.endswith("stackCheckProcess") or p.endswith("monsterSell") for p, _ in calls)) self.assertTrue(any(p.endswith("stackCheckProcess") for p, _ in calls))
self.assertFalse(any(p.endswith("monsterSell") for p, _ in calls))
engine.auto = True engine.auto = True
snapshot, _, _ = engine.poll() snapshot, _, _ = engine.poll()
self.assertEqual(sum(p.endswith("monsterSell") for p, _ in calls), 1) self.assertEqual(sum(p.endswith("monsterSell") for p, _ in calls), 1)
-64
View File
@@ -8,13 +8,10 @@ import unittest
from urllib.parse import parse_qs, urlsplit from urllib.parse import parse_qs, urlsplit
from unittest.mock import patch from unittest.mock import patch
from PIL import Image, ImageDraw
from ranch_assistant.api import ApiError, Client, DEFAULT_KEY, Session, decode, encode, server_entries, server_id from ranch_assistant.api import ApiError, Client, DEFAULT_KEY, Session, decode, encode, server_entries, server_id
from ranch_assistant.capture import load_buttons, save_page, saved_profiles, write_buttons
from ranch_assistant.engine import Engine, demo_snapshot from ranch_assistant.engine import Engine, demo_snapshot
from ranch_assistant.debug import TraceLog from ranch_assistant.debug import TraceLog
from ranch_assistant.farming import FarmConfig, FarmRunner
from ranch_assistant.login import PasswordLogin, SDK_APP_ID, SDK_APP_SECRET, server_labels from ranch_assistant.login import PasswordLogin, SDK_APP_ID, SDK_APP_SECRET, server_labels
from ranch_assistant.maps import stages from ranch_assistant.maps import stages
from ranch_assistant.model import Catalog, Policy from ranch_assistant.model import Catalog, Policy
@@ -230,67 +227,6 @@ class PlanningTests(unittest.TestCase):
self.assertEqual((first.stamina, second.stamina), (7, 8)) self.assertEqual((first.stamina, second.stamina), (7, 8))
class CaptureTests(unittest.TestCase):
def test_profile_scope_button_binding_and_changed_capture(self):
with workspace_temp() as folder:
ready = Image.new("RGB", (100, 200), "blue")
victory = Image.new("RGB", (100, 200), "green")
path, _ = save_page(folder, ready, "phone-a", "bd00", "1", "stage_ready")
save_page(folder, victory, "phone-a", "bd00", "1", "victory")
alternate, _ = save_page(folder, ready.resize((200, 400)), "phone-a", "bd00", "1", "stage_ready")
other, _ = save_page(folder, ready, "phone-b", "bd00", "1", "stage_ready")
self.assertEqual(len({path, alternate, other}), 3)
self.assertEqual(len(saved_profiles(folder, "bd00", "1", "phone-a")), 2)
regions = {"stage": {"box": [0, 0, 20, 20]}, "entry": {"box": [20, 20, 40, 40]},
"victory": {"box": [40, 40, 60, 60], "tap": [70, 180]}}
write_buttons(path, folder, regions)
templates = load_buttons(path, folder, "bd00", "1", "phone-a")
self.assertEqual(templates["victory"]["tap"], [70, 180])
with self.assertRaises(ValueError):
load_buttons(path, folder, "bd00", "2")
with self.assertRaises(ValueError):
load_buttons(path, folder, "bd00", "1", "phone-b")
save_page(folder, Image.new("RGB", ready.size, "red"), "phone-a", "bd00", "1", "stage_ready")
with self.assertRaises(ValueError):
load_buttons(path, folder, "bd00", "1")
def test_runtime_device_resolution_and_separate_victory_tap(self):
with workspace_temp() as folder:
ready = Image.new("RGB", (100, 200), "black")
victory = ready.copy()
ImageDraw.Draw(ready).rectangle((0, 0, 40, 40), fill="blue")
ImageDraw.Draw(victory).rectangle((40, 40, 60, 60), fill="green")
path, _ = save_page(folder, ready, "phone-a", "bd00", "1", "stage_ready")
save_page(folder, victory, "phone-a", "bd00", "1", "victory")
write_buttons(path, folder, {"stage": {"box": [0, 0, 20, 20]}, "entry": {"box": [20, 20, 40, 40]},
"victory": {"box": [40, 40, 60, 60], "tap": [70, 180]}})
class FakeAdb:
serial = "phone-a"
image = ready
taps = []
def foreground(self): return True
def screenshot(self): return self.image
def tap(self, x, y): self.taps.append((x, y))
adb = FakeAdb()
catalog = Catalog()
runner = FarmRunner(adb, catalog, folder)
runner.config = FarmConfig(capture_profile=str(path.relative_to(folder)))
runner.start()
with patch("ranch_assistant.farming.time.monotonic", return_value=10):
runner.tick(demo_snapshot(catalog))
adb.image = victory
with patch("ranch_assistant.farming.time.monotonic", return_value=13):
runner.tick(demo_snapshot(catalog))
self.assertEqual(adb.taps[-1], (70, 180))
adb.serial = "phone-b"
with self.assertRaises(RuntimeError):
runner.tick(demo_snapshot(catalog))
adb.serial = "phone-a"
runner.start()
adb.image = ready.resize((200, 400))
with self.assertRaises(RuntimeError):
runner.tick(demo_snapshot(catalog))
self.assertEqual(len(adb.taps), 2)
if __name__ == "__main__": if __name__ == "__main__":
+8 -8
View File
@@ -150,17 +150,16 @@ class GrowthTests(unittest.TestCase):
self.assertEqual(sum(name == "growth" for name, _ in client.calls), 1) self.assertEqual(sum(name == "growth" for name, _ in client.calls), 1)
self.assertFalse(any(name == "monsterService/monsterSell" for name, _ in client.calls)) self.assertFalse(any(name == "monsterService/monsterSell" for name, _ in client.calls))
def test_monitor_is_read_only_and_explicit_sync_does_not_dispatch(self): def test_monitor_automatically_syncs_growth_without_dispatch(self):
client = GrowthClient(self.catalog, age=610) client = GrowthClient(self.catalog, age=610)
engine = self.engine(client) engine = self.engine(client)
engine.auto = False engine.auto = False
snapshot, _, message = engine.poll() snapshot, _, message = engine.poll()
self.assertFalse(any(name == "growth" for name, _ in client.calls)) self.assertTrue(any(name == "growth" for name, _ in client.calls))
self.assertIn("仅监控", message) self.assertIn("成长结算", message)
snapshot, plans, _ = engine.sync_growth()
self.assertEqual(snapshot.monsters[501]["mode"], 2) self.assertEqual(snapshot.monsters[501]["mode"], 2)
self.assertEqual(self.catalog.quality_text(snapshot.monsters[501]), "C/C/C/C") self.assertEqual(self.catalog.quality_text(snapshot.monsters[501]), "C/C/C/C")
self.assertTrue(any(action.kind == "sell" for action in plans)) self.assertTrue(any(action.kind == "sell" for action in engine.plans()))
self.assertFalse(any(name == "monsterService/monsterSell" for name, _ in client.calls)) self.assertFalse(any(name == "monsterService/monsterSell" for name, _ in client.calls))
def test_mature_protected_monster_with_null_room_id_can_be_collected(self): def test_mature_protected_monster_with_null_room_id_can_be_collected(self):
@@ -203,8 +202,9 @@ class GrowthGuiTests(unittest.TestCase):
row = next(i for i in range(window.slots.rowCount()) if window.slots.item(i, 1).text() == "1") row = next(i for i in range(window.slots.rowCount()) if window.slots.item(i, 1).text() == "1")
self.assertIn("待同步", window.slots.item(row, 5).text()) self.assertIn("待同步", window.slots.item(row, 5).text())
self.assertIn("待成熟", window.slots.item(row, 7).text()) self.assertIn("待成熟", window.slots.item(row, 7).text())
self.assertNotEqual(window.monsters.item(0, 4).text(), "C/C/C/C") self.assertNotEqual(window.monsters.monster_items[501].text(4), "C/C/C/C")
window.sync_growth_button.click() window.engine.last_heartbeat = __import__("time").monotonic()
window.schedule()
for _ in range(200): for _ in range(200):
self.app.processEvents() self.app.processEvents()
QTest.qWait(5) QTest.qWait(5)
@@ -213,7 +213,7 @@ class GrowthGuiTests(unittest.TestCase):
row = next(i for i in range(window.slots.rowCount()) if window.slots.item(i, 1).text() == "1") row = next(i for i in range(window.slots.rowCount()) if window.slots.item(i, 1).text() == "1")
self.assertEqual(window.slots.item(row, 7).text(), "S/S/S/S") self.assertEqual(window.slots.item(row, 7).text(), "S/S/S/S")
self.assertIn("资质", window.slots.item(row, 8).text()) self.assertIn("资质", window.slots.item(row, 8).text())
self.assertIn("S/S/S/S", window.monsters.item(0, 4).text()) self.assertIn("S/S/S/S", window.monsters.monster_items[501].text(4))
self.assertFalse(window.execute.isChecked()) self.assertFalse(window.execute.isChecked())
self.assertFalse(any(name == "monsterService/monsterSell" for name, _ in client.calls)) self.assertFalse(any(name == "monsterService/monsterSell" for name, _ in client.calls))
finally: finally:
+7 -52
View File
@@ -29,7 +29,13 @@ class GuiTests(unittest.TestCase):
window.timer.stop() window.timer.stop()
try: try:
self.wait(window) self.wait(window)
self.assertIn("页面截图配置", [window.tabs.tabText(i) for i in range(window.tabs.count())]) labels = [window.tabs.tabText(i) for i in range(window.tabs.count())]
self.assertNotIn("页面截图配置", labels)
self.assertNotIn("体力刷图", labels)
self.assertIn("自动扫荡", labels)
self.assertNotIn("地图关卡", labels)
self.assertEqual(labels[-1], "收益资料")
self.assertLess(labels.index("自动孵蛋"), labels.index("自动扫荡"))
self.assertEqual(window.yields.rowCount(), 749) self.assertEqual(window.yields.rowCount(), 749)
self.assertEqual(window.styleSheet(), "") self.assertEqual(window.styleSheet(), "")
window.strategy.setCurrentIndex(window.strategy.findData("gold")) window.strategy.setCurrentIndex(window.strategy.findData("gold"))
@@ -58,57 +64,6 @@ class GuiTests(unittest.TestCase):
finally: finally:
window.close() window.close()
def test_page_buttons_only_capture_and_restore_profile(self):
from PIL import Image
from ranch_assistant.capture import PAGES
operations = []
class FakeAdb:
def __init__(self, executable="", serial=""):
self.serial = serial
def foreground(self):
operations.append("foreground")
return True
def run(self, *args):
operations.append(args)
if args != ("get-serialno",):
raise AssertionError("Screenshot flow attempted another ADB command")
return "test-phone"
def screenshot(self):
operations.append("screenshot")
return Image.new("RGB", (320, 640), "green")
def tap(self, *args):
raise AssertionError("Screenshot flow must never tap")
with workspace_temp() as folder, patch.object(gui, "STATE", folder):
window = gui.Window()
window.timer.stop()
try:
self.wait(window)
window.start_monitor.setChecked(True)
with patch.object(gui, "Adb", FakeAdb):
for index in range(len(PAGES)):
window.capture_rows.cellWidget(index, 2).click()
self.wait(window)
self.assertFalse(window.monitoring)
profile = json.loads(window.capture_profile.read_text(encoding="utf-8"))
self.assertEqual(set(profile["captures"]), {p[0] for p in PAGES})
self.assertEqual(operations.count("screenshot"), len(PAGES))
self.assertFalse(window.capture_preview.selectable)
original = window.capture_profile
window.stage.setCurrentIndex(1)
self.assertIsNone(window.capture_profile)
window.stage.setCurrentIndex(0)
self.assertEqual(window.capture_profile, original)
finally:
window.close()
restored = gui.Window()
restored.timer.stop()
try:
self.wait(restored)
self.assertEqual(restored.capture_profile, original)
restored.preview_capture(0, 0)
self.assertEqual(restored.capture_preview.image.size, (320, 640))
finally:
restored.close()
def test_password_result_accepts_serverId_and_handles_missing_identifier(self): def test_password_result_accepts_serverId_and_handles_missing_identifier(self):
from unittest.mock import Mock from unittest.mock import Mock
@@ -0,0 +1,135 @@
import os
import time
import unittest
from unittest.mock import patch
os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
from PySide6 import QtWidgets as W
from PySide6.QtTest import QTest
from ranch_assistant.api import Session
from ranch_assistant.engine import Engine, demo_snapshot
from ranch_assistant.gui import Window
from ranch_assistant.model import Catalog, Planner, Policy
from ranch_assistant.policy_io import import_policy, portable_policy
from ranch_assistant.tests.test_core import workspace_temp
from ranch_assistant.tests.test_growth import GrowthClient, NOW
class FourSProtectionTests(unittest.TestCase):
def test_four_s_requires_every_stat_instead_of_average_grade(self):
catalog = Catalog()
snapshot = demo_snapshot(catalog)
mon = snapshot.monsters[101]
mon.update(mode=2, lock=0)
info = catalog.monster(mon["typeId"])
for stat in ("atk", "def", "hp", "dex"):
mon["g" + stat.capitalize()] = info[stat + "_grow_max"]
policy = Policy(strategy="gold", protect_star=6, protect_quality=6)
planner = Planner(catalog)
self.assertEqual(catalog.quality(mon), [4, 4, 4, 4])
self.assertIn("4S", planner.protection_reason(mon, snapshot, policy))
self.assertEqual(planner.disposition(mon, snapshot, policy), "keep")
for stat in ("atk", "def", "hp", "dex"):
with self.subTest(stat=stat):
mon["g" + stat.capitalize()] = info[stat + "_grow_min"]
self.assertEqual(planner.disposition(mon, snapshot, policy), "sell")
self.assertTrue(planner.protected(mon, snapshot, Policy(protect_star=6, protect_quality=4)))
mon["g" + stat.capitalize()] = info[stat + "_grow_max"]
def test_four_s_keeps_locks_unknown_grades_star_guards_and_round_trips(self):
catalog = Catalog()
snapshot = demo_snapshot(catalog)
mon = snapshot.monsters[101]
policy = Policy(protect_star=6, protect_quality=6)
planner = Planner(catalog)
mon["lock"] = 1
self.assertTrue(planner.protected(mon, snapshot, policy))
mon["lock"] = 0
policy.protect_star = 1
self.assertTrue(planner.protected(mon, snapshot, policy))
policy.protect_star = 6
mon["gAtk"] = None
self.assertTrue(planner.protected(mon, snapshot, policy))
self.assertEqual(import_policy(portable_policy(policy, snapshot), snapshot).protect_quality, 6)
class MonitoringGuiTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.app = W.QApplication.instance() or W.QApplication([])
def wait(self, window):
for _ in range(500):
self.app.processEvents()
QTest.qWait(2)
if not window.busy:
return
self.fail("Background job did not finish")
def test_random_intervals_are_redrawn_and_saved_and_old_settings_migrate(self):
with workspace_temp() as folder:
window = Window(folder)
window.timer.stop()
try:
self.wait(window)
self.assertEqual([window.interval.itemData(i) for i in range(window.interval.count())], [30, 60, 120, 300])
with patch("ranch_assistant.gui.random.uniform", side_effect=[0, 29.9]) as draw:
self.assertEqual(window.poll_delay(), 0)
self.assertEqual(window.poll_delay(), 29.9)
self.assertEqual(draw.call_args_list[0].args, (0, 30))
self.assertEqual(draw.call_count, 2)
window.interval.setCurrentIndex(3)
window.save_config(quiet=True)
window.load_config({"interval": 5, "farm": {"stage_id": "bd00"}, "capture_profile": "old.json"})
self.assertEqual(window.interval.currentData(), 30)
self.assertFalse(hasattr(window, "farm"))
self.assertFalse(hasattr(window, "capture_scroll"))
window.load_config()
self.assertEqual(window.interval.currentData(), 300)
window.protect_quality.setCurrentIndex(window.protect_quality.findData(6))
window.save_config(quiet=True)
finally:
window.close()
restored = Window(folder)
restored.timer.stop()
try:
self.wait(restored)
self.assertEqual(restored.interval.currentData(), 300)
self.assertEqual(restored.read_policy().protect_quality, 6)
self.assertFalse(restored.execute.isChecked())
finally:
restored.close()
def test_growth_deadline_sync_runs_without_waiting_for_monitor_poll(self):
with workspace_temp() as folder, patch("ranch_assistant.model.time.time", return_value=NOW):
window = Window(folder)
window.timer.stop()
try:
self.wait(window)
client = GrowthClient(window.catalog, age=599, grade="S")
client.raw["monsters"][0]["mode"] = 1
client.session = Session("http://127.0.0.1/", "synthetic-test-token")
window.engine = Engine(window.catalog, client)
window.engine.last_heartbeat = time.monotonic()
window.engine.snapshot = client.snapshot()
self.assertFalse(window.engine.growth_sync_due())
window.engine.snapshot.server_offset = 2
client.raw["monsters"][0]["timeStart"] -= 2000
client.stage = 2
window.next_poll = float("inf")
self.assertFalse(window.monitoring)
window.schedule()
self.wait(window)
self.assertEqual(sum(name == "growth" for name, _ in client.calls), 1)
self.assertEqual(window.engine.snapshot.monsters[501]["mode"], 2)
self.assertEqual(window.catalog.quality_text(window.engine.snapshot.monsters[501]), "S/S/S/S")
self.assertFalse(any(name == "monsterService/monsterSell" for name, _ in client.calls))
self.assertFalse(window.execute.isChecked())
self.assertFalse(any("同步孵化" in button.text() for button in window.slot_page.findChildren(W.QPushButton)))
finally:
window.close()
if __name__ == "__main__":
unittest.main()
+174
View File
@@ -0,0 +1,174 @@
import copy
import os
import time
import unittest
from unittest.mock import patch
os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
from PySide6 import QtCore as C, QtWidgets as W
from PySide6.QtTest import QTest
from ranch_assistant.engine import demo_snapshot
from ranch_assistant.gui import Window
from ranch_assistant.model import Catalog
from ranch_assistant.presentation import monster_rows
from ranch_assistant.ranch_gui import RanchView
from ranch_assistant.tests.test_core import workspace_temp
class RanchTreeTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.app = W.QApplication.instance() or W.QApplication([])
def drain(self, tree):
for _ in range(500):
self.app.processEvents()
if not tree.row_batch.running:
return
QTest.qWait(2)
self.fail("Ranch rows did not finish")
def scenario(self):
catalog = Catalog()
snapshot = demo_snapshot(catalog)
room = snapshot.raw["rooms"][0]
snapshot.raw["rooms"] += [room | {"id": 2, "name": "第二牧场"}, room | {"id": 3, "name": "空牧场"}]
snapshot.raw["monsters"].append(snapshot.monsters[900] | {"id": 901, "roomId": 2})
return catalog, snapshot
def render(self, tree, snapshot, feeds=None, gifts=None):
tree.set_data(snapshot, monster_rows(tree.catalog, snapshot, set()), feeds or {}, gifts or {})
self.drain(tree)
def test_ranch_headers_children_and_refresh_preserve_controls_and_collapse(self):
catalog, snapshot = self.scenario()
tree = RanchView(catalog)
try:
self.render(tree, snapshot)
self.assertEqual(tree.group_items["room:1"].childCount(), 1)
self.assertEqual(tree.group_items["room:2"].childCount(), 1)
self.assertEqual(tree.group_items["room:3"].childCount(), 0)
self.assertEqual(tree.group_items["incubator"].childCount(), 4)
self.assertIn("魔物 1 /", tree.group_items["room:1"].text(0))
self.assertIn("魔物 0 /", tree.group_items["room:3"].text(0))
item = tree.monster_items[900]
check, priority = tree.itemWidget(item, 8), tree.itemWidget(item, 9)
tree.setCurrentItem(item)
tree.group_items["room:1"].setExpanded(False)
updated = copy.deepcopy(snapshot)
updated.monsters[900]["feel"] = 30
self.render(tree, updated, {"900": 2}, {"900": 3})
self.assertIs(tree.monster_items[900], item)
self.assertIs(tree.itemWidget(item, 8), check)
self.assertIs(tree.itemWidget(item, 9), priority)
self.assertTrue(check.isChecked())
self.assertEqual(priority.value(), 2)
self.assertTrue(tree.itemWidget(item, 17).isChecked())
self.assertEqual(tree.itemWidget(item, 18).value(), 3)
self.assertFalse(tree.group_items["room:1"].isExpanded())
self.assertEqual(tree.selected_monster_ids(), [900])
self.assertTrue(item.text(15).startswith("30 /"))
finally:
tree.row_batch.stop()
tree.close()
def test_flat_toggle_room_transfer_and_removed_monsters_keep_correct_ids(self):
catalog, snapshot = self.scenario()
tree = RanchView(catalog)
messages = []
previous = C.qInstallMessageHandler(lambda kind, context, message: messages.append(message))
try:
self.render(tree, snapshot)
tree.set_view(False)
self.render(tree, snapshot)
self.assertEqual(tree.topLevelItemCount(), 6)
self.assertFalse(tree.rootIsDecorated())
self.assertTrue(all(item.parent() is None for item in tree.monster_items.values()))
tree.set_view(True)
self.render(tree, snapshot)
self.assertIs(tree.monster_items[900].parent(), tree.group_items["room:1"])
updated = copy.deepcopy(snapshot)
updated.monsters[900]["roomId"] = 2
updated.raw["monsters"] = [mon for mon in updated.raw["monsters"] if mon["id"] != 901]
self.render(tree, updated)
self.assertNotIn(901, tree.monster_items)
self.assertEqual(tree.group_items["room:1"].childCount(), 0)
self.assertIs(tree.monster_items[900].parent(), tree.group_items["room:2"])
tree.set_view(True, 2)
self.render(tree, updated)
self.assertEqual(set(tree.monster_items), {900})
tree.set_view(False, 2)
self.render(tree, updated)
self.assertEqual(len(tree.monster_items), 5)
self.assertFalse(any("already owned" in message for message in messages))
finally:
C.qInstallMessageHandler(previous)
tree.row_batch.stop()
tree.close()
def test_tree_rules_context_menu_and_double_click_use_monster_ids(self):
with workspace_temp() as folder:
window = Window(folder)
window.timer.stop()
try:
for _ in range(400):
self.app.processEvents()
QTest.qWait(2)
if not window.busy:
break
window.tabs.setCurrentWidget(window.monster_page)
tree = window.monsters
self.drain(tree)
item = tree.monster_items[900]
tree.itemWidget(item, 8).setChecked(True)
tree.itemWidget(item, 9).setValue(4)
tree.itemWidget(item, 17).setChecked(True)
tree.itemWidget(item, 18).setValue(5)
self.assertEqual(window.read_policy().feed_targets, {"900": 4})
self.assertEqual(window.read_policy().gift_targets, {"900": 5})
tree.setCurrentItem(item)
with patch("PySide6.QtWidgets.QMenu.popup"):
window.page_menu(tree.viewport(), C.QPoint(-1, -1), window.monster_page)
lock = next(action for action in window.refresh_menu.actions() if action.text() == "解锁选中魔物")
self.assertTrue(lock.isEnabled())
lock.trigger()
for _ in range(400):
self.app.processEvents()
QTest.qWait(2)
if not window.busy:
break
self.assertFalse(window.engine.snapshot.monsters[900].get("lock"))
with patch("PySide6.QtWidgets.QMessageBox.information") as detail:
tree.itemDoubleClicked.emit(tree.monster_items[900], 1)
self.assertIn("#900", detail.call_args.args[2])
tree.clearSelection()
with patch("PySide6.QtWidgets.QMenu.popup"):
window.page_menu(tree.viewport(), C.QPoint(-1, -1), window.monster_page)
dispatch = next(action for action in window.refresh_menu.actions() if action.text() == "派遣选中魔物…")
self.assertFalse(dispatch.isEnabled())
finally:
window.close()
def test_large_monster_tree_renders_in_batches(self):
catalog, snapshot = self.scenario()
template = snapshot.monsters[900]
snapshot.raw["monsters"] = [template | {"id": 10000 + index} for index in range(500)]
tree = RanchView(catalog)
timer, beats = C.QTimer(), []
timer.setInterval(5)
timer.timeout.connect(lambda: beats.append(time.perf_counter()))
try:
timer.start()
self.render(tree, snapshot)
self.assertEqual(len(tree.monster_items), 500)
self.assertGreater(len(beats), 2)
self.assertLess(max(b - a for a, b in zip(beats, beats[1:])), .25)
finally:
timer.stop()
tree.row_batch.stop()
tree.close()
if __name__ == "__main__":
unittest.main()
+2 -2
View File
@@ -54,7 +54,7 @@ class ResponsivenessTests(unittest.TestCase):
snapshot = demo_snapshot(window.catalog) snapshot = demo_snapshot(window.catalog)
template = snapshot.raw["monsters"][-1] template = snapshot.raw["monsters"][-1]
snapshot.raw["monsters"] = [copy.deepcopy(template) | {"id": 1000 + i} for i in range(500)] snapshot.raw["monsters"] = [copy.deepcopy(template) | {"id": 1000 + i} for i in range(500)]
with patch.object(window.monsters, "setCellWidget") as cells: with patch.object(window.monsters, "setItemWidget") as cells:
window.engine.snapshot = snapshot window.engine.snapshot = snapshot
window.render(snapshot, []) window.render(snapshot, [])
self.assertEqual(cells.call_count, 0) self.assertEqual(cells.call_count, 0)
@@ -171,7 +171,7 @@ class ResponsivenessTests(unittest.TestCase):
break break
self.assertFalse(any(w.busy for w in windows)) self.assertFalse(any(w.busy for w in windows))
self.assertEqual(windows[0].eggs.rowCount(), 200) self.assertEqual(windows[0].eggs.rowCount(), 200)
self.assertEqual(windows[1].monsters.rowCount(), 0) self.assertEqual(len(windows[1].monsters.monster_items), 0)
self.assertGreater(len(beats), 10) self.assertGreater(len(beats), 10)
self.assertLess(max(b - a for a, b in zip(beats, beats[1:])), .25) self.assertLess(max(b - a for a, b in zip(beats, beats[1:])), .25)
self.assertTrue(any(e["operation"] == "刷新耗时" for e in windows[0].trace.events)) self.assertTrue(any(e["operation"] == "刷新耗时" for e in windows[0].trace.events))
@@ -194,9 +194,9 @@ class ManualGuiTests(unittest.TestCase):
self.assertEqual(window.eggs.item(row, 2).text(), "0") self.assertEqual(window.eggs.item(row, 2).text(), "0")
self.assertTrue(window.eggs.cellWidget(row, 3).isChecked()) self.assertTrue(window.eggs.cellWidget(row, 3).isChecked())
window.tabs.setCurrentWidget(window.monster_page) window.tabs.setCurrentWidget(window.monster_page)
row = next(i for i in range(window.monsters.rowCount()) if window.monsters.item(i, 0).text() == "900") item = window.monsters.monster_items[900]
window.monsters.cellWidget(row, 8).setChecked(True) window.monsters.itemWidget(item, 8).setChecked(True)
window.monsters.cellWidget(row, 9).setValue(1) window.monsters.itemWidget(item, 9).setValue(1)
self.assertEqual(window.read_policy().feed_targets, {"900": 1}) self.assertEqual(window.read_policy().feed_targets, {"900": 1})
self.assertFalse(window.server.isVisible()) self.assertFalse(window.server.isVisible())
window.save_config() window.save_config()
@@ -276,8 +276,8 @@ class ManualGuiTests(unittest.TestCase):
self.wait(window) self.wait(window)
def select(mid): def select(mid):
window.tabs.setCurrentWidget(window.monster_page) window.tabs.setCurrentWidget(window.monster_page)
row = next(i for i in range(window.monsters.rowCount()) if window.monsters.item(i, 0).text() == str(mid)) window.monsters.clearSelection()
window.monsters.selectRow(row) window.monsters.setCurrentItem(window.monsters.monster_items[mid])
select(101) select(101)
with patch.object(gui.W.QMessageBox, "question", return_value=W.QMessageBox.StandardButton.No): with patch.object(gui.W.QMessageBox, "question", return_value=W.QMessageBox.StandardButton.No):
window.request_monster_action("sell") window.request_monster_action("sell")
+4 -3
View File
@@ -161,11 +161,12 @@ class V11GuiTests(unittest.TestCase):
for _ in range(100): for _ in range(100):
self.app.processEvents() self.app.processEvents()
QTest.qWait(2) QTest.qWait(2)
target_row = next(i for i in range(window.monsters.rowCount()) if window.monsters.item(i, 0).text() == "900") target_item = window.monsters.monster_items[900]
window.monsters.cellWidget(target_row, 17).setChecked(True) window.monsters.itemWidget(target_item, 17).setChecked(True)
self.assertIn("900", window.read_policy().gift_targets) self.assertIn("900", window.read_policy().gift_targets)
window.monster_view.setCurrentIndex(1) window.monster_view.setCurrentIndex(1)
self.assertTrue(window.rooms_table.isHidden()) self.assertFalse(window.monsters.rootIsDecorated())
self.assertTrue(all(item.parent() is None for item in window.monsters.monster_items.values()))
finally: finally:
window.close() window.close()