Initialize local project and fix ranch growth synchronization

This commit is contained in:
AttilaNet
2026-11-07 22:14:49 +08:00
commit 657f5f33b5
1417 changed files with 202171 additions and 0 deletions
+254
View File
@@ -0,0 +1,254 @@
# 牧羊人之心牧场辅助
原生 PySide6 窗口,使用 Qt 默认控件。双击项目根目录的
`Start_Ranch_Helper.cmd` 启动。这台机器所需依赖已经存在。
其他环境可先运行 `python -m pip install -r ranch_assistant/requirements.txt`。
底部日志区可拖动与页面之间的分隔条来调大或调小;顶部“隐藏日志 / 显示日志”切换显隐。
隐藏期间仍继续记录日志,重新显示恢复上次高度;高度和显隐状态随账号/角色配置保存。
孵蛋优先级、补货下限/目标和魔物喂养优先级均可直接输入数字,没有上下箭头。
横向、纵向滚动条均加宽为22个逻辑像素;仅调整滚动条,窗口与按钮保持原样。
## 当前功能
- 培育室:已开启、未开启和VIP坑位分别显示;支持金币/氪金开普通坑位,先显示费用再确认。
- 背包魔物蛋:逐种勾选孵化、设置优先级、选择孵出后派遣/喂养/保留,设置补货下限、目标和市场。
数量归零后保留规则;可添加当前无库存的蛋。未勾选的蛋不会自动孵化或触发补货。
- 魔物:勾选喂养目标、设置喂养优先级;显示突破、当前等级上限、成长资质、参考属性、好感和喜欢的物品。
双击查看详情;右键可锁定、解锁、派遣、喂给指定魔物。
- 牧场概况:名称、魔物数量、容量和空位;按钮或右键可新建金币/氪金牧场,提交前确认费用。
- 每个页面的表格和空白处可右键“刷新本页”;刷新只读取状态,不执行派遣、喂养等策略。
- 多账号:同一程序内多个独立账号页签,各自监控、自动执行、记录日志;切换页签不停止其他账号。
- 会话保存:成功读取角色后自动加密保存 Token、账号/区服/角色和请求编号,重启后可恢复。
- 自动孵蛋:按手动规则执行,提供开始执行、仅监控、停止按钮;支持十连优先、金币保留和每日购蛋额度。
5/10/30/60 秒刷新;喂养遵守当前突破上限,满级后转到下一喂养目标。
- 收益资料:749 种魔物数据来自用户提供的 APK 1.9.68,支持名称搜索和1–5星分别筛选,
可导入 CSV/XLSX 覆盖价格、经验和时间。
- 账号密码登录:第一弹渠道密码验证 → 官方区服列表 → 选择区服并读取角色。
区服数量和游戏服地址采用官方响应,不写死两个区。
- 记住密码:默认启用,保存账号和密码,重启自动填回,登录失败不清空输入框。
密码使用当前 Windows 账户的 DPAPI 加密;可取消勾选移除保存内容。
- 调试窗口:逐条查看请求地址、参数、HTTP 状态、耗时、解密响应和错误阶段,
支持复制/导出,自动保存本地脱敏日志。
- 自动委托:按每日剩余接取次数、解锁城市和库存,接取、推进已满足条件的步骤、
领取奖励;列表显示奖励金币和氪金数量。提交金币、道具、魔物分别受策略限制。战斗步骤等待游戏实际完成。
- 地图关卡:显示资料表中的关卡及各难度,按账号返回的解锁/通关记录筛选,
可以设为 ADB 自动战斗目标。
- 页面截图配置:每个页面一个截图按钮,自动保存原图与设备、分辨率、关卡、难度。
截图无需登录或 Token,不会点击或切换手机页面;由助手查看样本后生成按钮配置。
- 布丁史莱姆牧场:通过 ADB 操作手机里的实际战斗;根据当前体力、
入场券和自定每日轮数决定是否继续,支持自动开战、倒计时、自动战斗、
结算按钮识别、失败停止和超时停止。完成一次界面标定后可循环运行。
- 离线演示:不连接游戏服务器即可查看数据、策略和模拟操作。
## 连接真实角色
默认进入离线演示,示例角色不是手机上的真实数据。
顶部账号页签用于切换账号,“新增账号页签”用于登录另一账号。每个页签顶部明确标注演示或真实数据。
1. 在“登录”页填写第一弹渠道账号和密码,点击“账号密码登录并获取区服”。
默认勾选“记住账号和密码”;编辑完、点击登录或关闭窗口时自动保存,也可点击“保存登录信息”。
密码保存在本机加密文件 `local_state/ranch_helper/credentials.json`,重启自动填回,不再自动清空。
2. 从“官方返回的区服 / 已有角色”选择区服,点击“进入选中区服”。
登录中心取自 APK,游戏服务器地址取自选中区服的 `gameServerAddress`。
3. 确认真实角色名称、培育室和背包数量。成功后 Token 自动保存到该账号工作区的 `sessions/`,无需复制。
4. 在“背包魔物蛋”逐种配置:勾选“孵化”,设置优先级(1最高),选择“孵出后”派遣、喂养或保留。
“低于补货”是可用蛋少于多少开始购买,0表示关闭;“补至”是希望补充到的可用蛋数量。
每行可选包含该蛋的金币市场;蛋用完后这一行仍会保留。规则自动保存。
5. 到“自动孵蛋”启用需要的买蛋、孵蛋、派遣、收取或喂养开关。
点“刷新 / 预览”查看下一步,再点“开始执行勾选功能”。页面会显示“执行中”、
下一步操作或等待原因。“仅监控”和手动刷新不会执行策略;“停止执行”保留只读监控。
已经发送的请求会返回,停止后不发送下一项。重启或恢复会话后需重新点开始执行。
6. 需要经验时,在“魔物”勾选接收经验的喂养目标并设置优先级。优先级数字小的先喂,达到当前突破上限后换下一个;
在“牧场策略”可设全局停止等级、星级/资质保护和保留蛋数量。“收益资料”的星级勾选只筛选表格显示。
可用“绿色史莱姆金币预设(仅孵此蛋)”快速设置:只勾选绿色史莱姆、优先级1、孵出后派遣、低于1补至10、
莉莉托斯市场。这个预设关闭喂养,保留4星以上/A资质魔物,仍需点击开始执行。
“登录”页不再展示服务器地址、Token、密钥和请求编号,也不自动弹出调试窗;这些信息由程序内部处理。
莉莉托斯市场单次价格为100金币(本地客户端表),买到的蛋随机,不能指定全部为绿色史莱姆。
绿色史莱姆总培育时间10分钟,成熟派遣150金币;这不代表整个随机蛋池都固定净赚50金币。
购蛋默认关闭,需要勾选或应用预设。默认优先十连,保留1000金币、每日额度5000金币。
补货缺口和可用金币均达到10枚时发送 `num=10`;有库存时等待缺口,无蛋且不足十连时可按单抽上限补充。
十连的赠蛋数量以服务端实际返回为准,“最近抽蛋”显示收到的蛋种类和数量。
只购买已解锁城市的金币市场蛋,不使用氪金、抽蛋券或酒馆抽蛋。
额度按北京时间自然日、账号区服角色分别累计,保存在角色目录的 `purchase_budget.json`;
发送前记账,超时不重试也不自动退回额度,以免重复购买。切换账号、重启不会重置当天额度。
离线演示的购买和成熟仅用于流程演示,不预测真实抽蛋结果,额度不写入真实角色记录。
该密码流程来自此 APK 内第一弹 SDK 的普通账号接口,不是游戏开发者登录。
官方要求短信验证(407)或限制登录(408)时会停止,目前未实现验证码界面。
其他渠道或接口格式变化时需调整登录实现。旧会话导入函数仍保留为内部工具,不在登录页展示。
区服编号兼容 `id` 和 `serverId`,包含数字字符串;
角色条目中的 `id` 单独作为角色编号,不与区服编号混用。用户已确认真实登录和角色数据读取成功。
区服列表里的 `{"$ref":"$.servers[0]"}` 是对同一数组条目的引用,程序会还原引用并按编号去重,
将对应的角色名显示在区服下拉框中。已用用户本地的实际响应验证两区、两个角色均能正确关联。
无法识别的区服条目会停止并在界面日志列出字段名;调试窗口保留解析前收到的响应,令牌已遮盖。
真实会话过期后会停止,需要重新登录或导入会话。游戏 Token 和协议密钥在 `sessions/` 中使用 Windows DPAPI 加密,
策略设置和调试日志不保存令牌原文;SDK Token 和 HAR 原文不持久化。密码由独立的本机加密文件保存。实际服务器如
更新了协议密钥,需要更新客户端配置;登录页不展示协议参数。
## 多账号与恢复会话
1. 每个账号使用独立页签。用顶部“新增账号页签”添加账号,用页签或“打开已保存账号”切换。
2. 每个账号首次在本版本正常登录一次;此前版本只保存在内存的 Token 不能从脱敏日志补回。
3. 重启后在“登录”页点击“恢复选中会话”,或在顶部点击“恢复各页签的保存会话”。
恢复会先读取角色并核对角色编号,成功后才显示为真实数据;不会自动开启策略或刷图。
4. 各页签可分别开启监控和自动执行。顶部“全部开始监控”只开启已连接账号的监控,
自动执行仍由各账号的勾选决定;“全部停止”停止所有页签的监控和刷图。
5. 关闭一个页签会停止该账号,其他账号继续运行;保存的账号和会话仍可再次打开。
账号工作区各自保存凭据、会话和日志;区服/角色各自保存策略、喂养目标、截图和刷图次数。
切换区服时不沿用其他角色的策略。相同账号区服不会在两个页签重复运行。
会话的请求编号在发送前保存,包括超时未确认的请求;写请求不会自动重发。
删除保存会话需先切回离线演示,再点击“删除选中保存会话”。“记住账号和密码”只控制密码,独立于会话保存。
正常会话心跳按客户端的 240 秒周期运行。ADB 刷图中,同一台手机同时只允许一个账号页签控制;
不同手机可分别配置。未实现脚本检测规避,也不保证服务端无法识别自动化。
## 页面数据与刷新
“培育室”“背包魔物蛋”“魔物”“牧场概况”可直接查看状态,顶部显示坑位、蛋数量、魔物数量和更新时间。
表格或页面空白处右键选择“刷新本页”,保持当前页面;请求进行中再次刷新会排队。
收益资料和截图配置页刷新本地资料。自动刷新的 5/10/30/60 秒间隔继续保留。
已修复实际响应里 `activityHistory.vipInfo=null` 导致策略报错、阻止数据显示的问题。
已用实际角色响应回放验证 4 个坑位、4 类蛋、4 只魔物和 1 个牧场能显示。
策略计算或配置出错时,基础数据仍可读取,自动操作会停止。
## 调试登录
点击顶部“调试窗口”手动打开。账号登录及选择区服时不自动弹窗,后台仍保存脱敏记录。
按顺序可看到:渠道账号验证、获取官方区服、选择区服、进入选中区服、读取角色。
账号验证和获取区服完成后停下来等你选服,选中后才会发送进入区服请求。
区服整理是本地将 JSON 字段转换成界面选项;“本地错误”不表示发送了额外请求。
同一个错误在网络/数据层和界面层传递时只记录一次。
进入区服前会增加“进入参数检查”本地记录,显示签名日期、规则和渠道,不包含 Token 或签名原文。
原客户端虽然写 `yyMMdd`,其格式函数实际使用四位年份,签名日期必须为八位 `yyyyMMdd`。
`channel=DYD` 与 APK 里的 `tjChannel=taptap` 分别读取和传递,不混用。
选中一条记录可看完整 JSON;游戏加密接口显示解密后的字段。HTTP 错误、连接超时、
响应解码失败和区服解析失败都记录,密码、Token、Cookie、Authorization 会遮盖。
界面显示本次运行最近 300 条记录,日志自动追加到:
首账号为 `local_state/ranch_helper/network_debug.jsonl`;新增账号位于其 `profiles/<账号页签编号>/` 目录。
窗口顶部会显示该账号的实际日志路径;超过约 8 MiB 会保留一份上一段日志。
重新尝试登录后,告诉助手“日志好了”,助手即可读取这个工作区内的调试文件;
不用发送账号密码。也可以用窗口里的复制、导出按钮取得脱敏记录。
接口静态清单见 [API_INVENTORY.md](../analysis/API_INVENTORY.md),包含用途、参数、回调字段和证据位置。
## 手动规则与保护
算法参考 [BWIKI 魔物收益表](https://wiki.biligame.com/myrzx/魔物收益表),
原页面作者 Monster-SCAG,页面标示更新于 2020-12-05。没有把旧攻略表的
所有数值直接套入当前游戏;本版使用 APK 中的事实数据计算。
- 金币/小时 = 派遣金币 / 总培育小时数。
- 经验/小时 = 强化经验 / 总培育小时数。
- 自动操作按各行手选的去向执行,不按收益表自动决定派遣还是喂养。优先级相同时先孵时间较短的蛋。
- 单体喂养经验按客户端公式计算:基础经验 + 截断(已获得经验 × 配置倍率)。
默认内置倍率从客户端数据提取为 0.2。
- 收益页的每小时金币是毛收益,不是购蛋净利润;实际购蛋金币会单独从余额和每日额度扣除。
- 默认保留三星及以上、综合 A 资质及以上,以及锁定、系统锁定、羁绊、
在队、探索中、携带装备和资质数据不完整的魔物。
- 自动派遣/喂养只处理本次运行在培育室观察到的魔物,不扫描并消耗已有
牧场魔物。未指定可用喂养目标时不消耗素材;手动右键操作可选择已有牧场魔物。
- 非 VIP 不使用客户端标识的第 4 个 VIP 坑。牧场满了停止收取;喂养停止等级为
用户目标和当前突破上限的较小值。客户端上限公式为 `potentialLevel × 10`,
例如突破等级2的上限是20,即使设置70级也会在20级停止;上限未知时停止喂养。
“魔物”和喂养目标下拉框显示等级/当前上限。每轮执行一项计划操作,随后重新读取状态;
成熟计时结束时会先结算成长并重新读取,再决定收取或派遣。
- 游戏对蛋的 `feedLock` 存在手机本地存档中,服务器会话看不到这项本地
偏好。需要保留某类蛋时,在策略页填写“编号:保留数量”。
## 手动管理与扩建
孵化与幼体成长阶段显示“待成熟后生成”,不把服务端的零值算成 C 资质。
自动执行会在两个阶段转换时请求成长结算,并使用结算响应中的阶段和四项成长值更新界面;
成熟、资质确定后才决定派遣、喂养或保留,旧查询结果不会覆盖尚未确认回写的结算数据。
培育室的“同步孵化 / 成长”可单独更新这些状态,本次不执行派遣或喂养。
“仅监控”不会结算或派遣;需点“开始执行勾选功能”才能自动处理。
保留原因会显示在培育室建议和日志中,例如达到保留星级、综合资质A/S、锁定或未启用派遣。
培育室魔物的 `roomId=null` 已兼容,统计牧场容量时不会再因空字段中断整轮策略。
- 魔物表可多选,使用按钮或右键锁定/解锁。派遣、指定喂养会列出将消耗的魔物并要求确认;
这些手动操作会暂停自动执行。锁定、系统锁、羁绊、在队、探索、建筑中及已装备的魔物不能作为素材。
- 喂养素材需已收取到牧场,目标不能是素材本身,且不能已满当前突破等级上限。
- 参考属性按基础值、成长、等级、潜能、好感及升星计算,不含装备、羁绊和全局加成;完整实战面板以游戏为准。
- 培育室按本地表列出11个坑位,并兼容服务器返回的更多位置。第4个为VIP专用,不走普通扩建接口。
选择未开启的普通坑位后可用金币或氪金开通。VIP资格需在游戏内处理。
- 牧场页的“新建牧场”支持金币或氪金。金币建牧场还要求账号已解锁相应建设功能。
- 金币建设解锁按已完成任务 `1001011` 判断,与客户端一致。
- 费用按客户端价格表与设施 `openType` 统计的扩建次数计算,提交前重读角色、检查等级和余额;
费用变化会要求重新确认。取消确认不会发送请求,超时不会自动重复购买。
- 实测日志里的空坑是 `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/<编号>/`。
`sessions/` 是加密会话;`roles/<角色标识>/` 是各角色的策略、截图和本日次数。
- `catalog.json` 是本地数据;游戏热更新后的新魔物/新售价需要更新资料。
未知魔物和不完整资质不会自动派遣或喂养。
- 自定义表:`typeId, sell_money, sell_exp, time_total`(秒),可只提供部分
覆盖列;中文列名“编号、派遣金币、强化经验、孵化秒数”也支持。
- 测试:`python -m unittest discover -s ranch_assistant/tests -v`。
- 88 项测试通过,新增加密HTTP十连→实际赠蛋→负数空坑孵化→成长结算→派遣→余额刷新、逐种优先级和补货、
多目标喂养优先级、锁定/手动派遣/喂养、开坑与建牧场的费用复核和取消确认、金币/库存/每日额度限制、
购蛋超时记账、突破等级上限、星级筛选、启动/停止/忙时排队和委托奖励显示;也覆盖多账号并行/重启恢复、账号和角色隔离、请求计数持久化、超时恢复、错角色阻止、
右键只读刷新、空值响应显示、心跳、关闭页签,以及四位年份的进入签名、APK 追踪渠道、区服引用还原/去重、两个角色显示、选二区登录、本地错误去重,
Windows 密码加密保存/恢复、登录失败保留密码、调试窗与脱敏日志,
以及 Qt 截图按钮只读、不点击手机、配置恢复、图片变更失效、
设备/分辨率检查、两种区服编号下密码登录及选二区的 loopback HTTP 链路、
缺失/冲突编号停止、Qt 登录回调错误处理、委托、地图和牧场策略。
开发测试未向官方服务提交真实账号凭据,未对真实库存执行购蛋、派遣、喂养、委托或刷图。
用户已验证登录和角色读取;本次买蛋循环及多账号并行由本地模拟服务验证,真实账号效果仍需用户启动后验证。按钮配置需当前页面样本。
- 网络写请求发生异常后不会直接重试,以免重复消耗魔物或物品。
## 委托和扫荡的范围
“自动委托”需单独启用;可先关闭“牧场策略”的自动管理,只运行委托。
道具和魔物提交默认关闭,金币提交上限默认 0;锁定、队伍、高星和高资质保护继续生效。
已接委托需要的魔物种类和蛋会纳入牧场保留。
“也接取需要实战的委托”只允许接取此类任务,当前不会自动导航到每项委托的专用战斗。
现有客户端普通关卡流程是 `stageStart` → 本地实际战斗 → `battleEnd`,
结算包含击杀、伤害、剩余时间、阵容等战斗数据,并非只传一个成功标志。
当前静态检查未找到独立扫荡接口;本程序的刷图是通过 ADB 在游戏中正常战斗。
没有实现脱离手机的完整战斗模拟,也没有伪造胜利记录。
+1
View File
@@ -0,0 +1 @@
"""Native Qt companion for the supplied game client."""
+3
View File
@@ -0,0 +1,3 @@
from .gui import main
raise SystemExit(main())
+178
View File
@@ -0,0 +1,178 @@
"""One process with independent account workspaces and workers."""
import json
from pathlib import Path
import re
import uuid
from PySide6 import QtCore as C, QtWidgets as W
from . import gui
from .api import Session
from .sessions import identity
class AccountsWindow(W.QMainWindow):
def __init__(self, root=None):
super().__init__()
gui.use_native_scrollbars()
self.root = Path(root or gui.STATE).resolve()
self.root.mkdir(parents=True, exist_ok=True)
self.index_path = self.root / "accounts.json"
self.windows, self.locks, self.profiles = {}, {}, []
self.setWindowTitle("牧羊人之心牧场辅助 — 多账号")
font = self.font()
font.setPointSizeF(8.5)
self.setFont(font)
self.resize(1100, 740)
central = W.QWidget()
layout = W.QVBoxLayout(central)
self.setCentralWidget(central)
toolbar = W.QHBoxLayout()
for text, handler in (("新增账号页签", self.add_profile), ("打开已保存账号", self.choose_profile), ("恢复各页签的保存会话", self.resume_all),
("全部开始监控", self.monitor_all), ("全部停止", self.stop_all)):
button = W.QPushButton(text)
button.clicked.connect(handler)
toolbar.addWidget(button)
toolbar.addStretch()
layout.addLayout(toolbar)
note = W.QLabel("每个页签独立登录、保存 Token 和运行。切换页签不会停止其他账号;自动执行需在各账号里分别开启。")
note.setWordWrap(True)
layout.addWidget(note)
self.tabs = W.QTabWidget()
self.tabs.setTabsClosable(True)
self.tabs.tabCloseRequested.connect(self.close_profile)
layout.addWidget(self.tabs, 1)
try:
self.profiles = json.loads(self.index_path.read_text(encoding="utf-8"))["profiles"]
except (OSError, ValueError, KeyError, TypeError):
self.profiles = [{"id": "default", "label": "账号 1"}]
self.profiles = [p for p in self.profiles if isinstance(p, dict) and re.fullmatch(r"default|[a-f0-9]{32}", str(p.get("id", "")))]
for profile in list(self.profiles):
self.open_profile(profile)
if not self.profiles:
self.add_profile()
gui.compact_layouts(central)
def open_profile(self, profile):
identifier = profile["id"]
if identifier in self.windows:
self.tabs.setCurrentWidget(self.windows[identifier])
return
folder = self.root if identifier == "default" else self.root / "profiles" / identifier
folder.mkdir(parents=True, exist_ok=True)
lock = C.QLockFile(str(folder / "workspace.lock"))
if not lock.tryLock(0):
self.statusBar().showMessage("有账号工作区已在其他程序窗口打开,未重复运行")
return
window = gui.Window(folder)
window.connection_guard = lambda session: self.allow_connection(window, session)
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))
self.windows[identifier], self.locks[identifier] = window, lock
self.tabs.addTab(window, profile.get("label", "账号"))
self.tabs.setCurrentWidget(window)
def add_profile(self):
profile = {"id": uuid.uuid4().hex, "label": f"账号 {len(self.profiles) + 1}"}
self.profiles.append(profile)
self.open_profile(profile)
self.save_index()
def choose_profile(self):
if not self.profiles:
return
labels = [p.get("label", "账号") + " [" + p["id"][:6] + "]" for p in self.profiles]
label, accepted = W.QInputDialog.getItem(self, "打开账号页签", "保存的账号工作区", labels, 0, False)
if accepted:
self.open_profile(self.profiles[labels.index(label)])
def rename_profile(self, identifier, label):
for profile in self.profiles:
if profile["id"] == identifier:
profile["label"] = label
window = self.windows.get(identifier)
if window:
self.tabs.setTabText(self.tabs.indexOf(window), label)
self.save_index()
def save_index(self):
temporary = self.index_path.with_suffix(".tmp")
temporary.write_text(json.dumps({"profiles": self.profiles}, ensure_ascii=False, indent=2), encoding="utf-8")
temporary.replace(self.index_path)
def allow_login(self, requester, account):
for window in self.windows.values():
if window is not requester and not window.engine.demo and window.account.text().strip() == account:
self.tabs.setCurrentWidget(window)
return False
return True
def allow_connection(self, requester, session):
if not isinstance(session, Session):
return True
for window in self.windows.values():
other = window.engine.client
if window is not requester and other and isinstance(other.session, Session) and identity(other.session) == identity(session):
self.tabs.setCurrentWidget(window)
return False
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):
for window in self.windows.values():
if window.engine.demo and not window.busy and window.saved_sessions.count():
window.resume_session()
def monitor_all(self):
for window in self.windows.values():
if not window.engine.demo:
window.start_monitor.setChecked(True)
def stop_all(self):
for window in self.windows.values():
window.start_monitor.setChecked(False)
window.start_farm.setChecked(False)
window.execute.setChecked(False)
def close_profile(self, index):
window = self.tabs.widget(index)
if window is None:
return
window.start_monitor.setChecked(False)
window.start_farm.setChecked(False)
window.timer.stop()
window.closed = True
window.pending_refresh = None
if window.busy:
C.QTimer.singleShot(250, lambda: self.close_profile(self.tabs.indexOf(window)))
return
identifier = next(k for k, value in self.windows.items() if value is window)
window.close()
self.tabs.removeTab(index)
del self.windows[identifier]
self.locks.pop(identifier).unlock()
# Workspaces and saved sessions remain on disk for the next launch.
window.deleteLater()
def closeEvent(self, event):
self.stop_all()
for window in self.windows.values():
window.timer.stop()
window.closed = True
window.pending_refresh = None
if any(window.busy for window in self.windows.values()):
self.setEnabled(False)
self.statusBar().showMessage("正在完成当前请求,完成后自动关闭并保存会话")
C.QTimer.singleShot(250, self.close)
event.ignore()
return
for window in self.windows.values():
window.close()
for lock in self.locks.values():
lock.unlock()
self.save_index()
event.accept()
+88
View File
@@ -0,0 +1,88 @@
"""Small AMF3 reader for the client's zlib-compressed resource tables."""
import struct
class Reader:
def __init__(self, data):
self.data, self.pos = data, 0
self.strings, self.objects, self.traits = [], [], []
def take(self, n):
value = self.data[self.pos:self.pos + n]
if len(value) != n:
raise ValueError("Truncated AMF data")
self.pos += n
return value
def u29(self):
value = 0
for _ in range(3):
b = self.take(1)[0]
if b < 128:
return value << 7 | b
value = value << 7 | b & 127
return value << 8 | self.take(1)[0]
def string(self):
h = self.u29()
if not h & 1:
return self.strings[h >> 1]
value = self.take(h >> 1).decode("utf-8")
if value:
self.strings.append(value)
return value
def read(self):
kind = self.take(1)[0]
if kind in (0, 1):
return None
if kind in (2, 3):
return kind == 3
if kind == 4:
n = self.u29()
return n - (1 << 29) if n & (1 << 28) else n
if kind == 5:
return struct.unpack(">d", self.take(8))[0]
if kind == 6:
return self.string()
if kind in (7, 8, 9, 10, 11, 12):
h = self.u29()
if not h & 1:
return self.objects[h >> 1]
if kind == 8:
value = struct.unpack(">d", self.take(8))[0]
self.objects.append(value)
return value
if kind in (7, 11, 12):
value = self.take(h >> 1)
self.objects.append(value)
return value
if kind == 9:
associative, dense = {}, []
result = associative if not h >> 1 else dense
self.objects.append(result)
while (name := self.string()):
associative[name] = self.read()
for _ in range(h >> 1):
dense.append(self.read())
if dense and associative:
raise ValueError("Mixed AMF array unsupported")
return result
if not h & 2:
external, dynamic, names = self.traits[h >> 2]
else:
self.string()
external, dynamic = bool(h & 4), bool(h & 8)
names = [self.string() for _ in range(h >> 4)]
self.traits.append((external, dynamic, names))
if external:
raise ValueError("Externalizable AMF object unsupported")
result = {}
self.objects.append(result)
for name in names:
result[name] = self.read()
if dynamic:
while (name := self.string()):
result[name] = self.read()
return result
raise ValueError(f"Unsupported AMF3 marker {kind}")
+271
View File
@@ -0,0 +1,271 @@
from __future__ import annotations
import base64
from dataclasses import dataclass
from datetime import datetime, timedelta, timezone
from email.utils import parsedate_to_datetime
import hashlib
import json
import re
import threading
import time
from urllib.parse import urlsplit
from cryptography.hazmat.primitives import padding
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
import requests
DEFAULT_KEY = "O/UT+WpvDymb26pF485QOA=="
def encode(data, key):
raw = json.dumps(data, ensure_ascii=False, separators=(",", ":")).encode()
padder = padding.PKCS7(128).padder()
raw = padder.update(raw) + padder.finalize()
cipher = Cipher(algorithms.AES(base64.b64decode(key, validate=True)), modes.ECB()).encryptor()
return base64.b64encode(cipher.update(raw) + cipher.finalize())
def decode(raw, key):
if isinstance(raw, str):
raw = raw.encode()
if raw.lstrip().startswith(b"{"):
return json.loads(raw)
data = base64.b64decode(raw, validate=True)
cipher = Cipher(algorithms.AES(base64.b64decode(key, validate=True)), modes.ECB()).decryptor()
padded = cipher.update(data) + cipher.finalize()
unpadder = padding.PKCS7(128).unpadder()
return json.loads(unpadder.update(padded) + unpadder.finalize())
class ApiError(RuntimeError):
pass
def server_id(server):
"""Resolve wire/ServerVo identifiers without guessing a server number."""
if not isinstance(server, dict):
raise ApiError("区服列表含有无法识别的条目")
identifiers = set()
for key in ("id", "serverId"):
value = server.get(key)
if type(value) is int and value >= 0:
identifiers.add(value)
elif isinstance(value, str) and value.strip().isascii() and value.strip().isdigit():
identifiers.add(int(value.strip()))
if len(identifiers) > 1:
raise ApiError("区服编号字段不一致(id/serverId),未进入区服")
if not identifiers:
fields = ", ".join(sorted(str(k) for k in server)[:20]) or "无字段"
raise ApiError(f"缺少有效区服编号(id/serverId);返回字段:{fields}")
return identifiers.pop()
def server_entries(response, platform="ANDROID"):
if not isinstance(response, dict) or not isinstance(response.get("servers"), list):
raise ApiError("登录响应中的 servers 不是区服列表")
source = response["servers"]
servers, by_id = [], {}
for row in source:
# Some responses serialize duplicate server objects as Fastjson $ref aliases.
# Resolve only references into this server array; this never fetches a URL.
visited = set()
while isinstance(row, dict) and "$ref" in row:
reference = row["$ref"]
match = re.fullmatch(r"\$\.servers\[([0-9]+)\]", reference) if isinstance(reference, str) else None
if set(row) != {"$ref"} or not match:
raise ApiError("区服引用格式无法识别,未进入区服")
index = int(match[1])
if index >= len(source) or index in visited:
raise ApiError("区服引用越界或存在循环,未进入区服")
visited.add(index)
row = source[index]
if not isinstance(row, dict):
raise ApiError("区服列表含有无法识别的条目")
if str(row.get("platform") or platform).upper() != platform.upper():
continue
identifier = server_id(row)
if identifier in by_id:
previous_address = by_id[identifier].get("gameServerAddress")
address = row.get("gameServerAddress")
if previous_address and address and previous_address != address:
raise ApiError("同一区服编号对应不同游戏服地址,未进入区服")
continue
normalized = row | {"id": identifier, "serverName": row.get("serverName") or f"区服 {identifier}"}
by_id[identifier] = normalized
servers.append(normalized)
return servers
@dataclass
class Session:
server_url: str = ""
token: str = ""
key: str = DEFAULT_KEY
reqid: int = 0
reqsid: int = 0
account_id: str = ""
server_id: int = 0
role_id: int = 0
channel: str = "DYD"
platform: str = "ANDROID"
account_name: str = ""
@classmethod
def imported(cls, value, key=DEFAULT_KEY):
if "log" not in value:
fields = {k: value[k] for k in cls.__dataclass_fields__ if k in value}
return cls(**fields)
for entry in reversed(value["log"].get("entries", [])):
request = entry.get("request", {})
if "masterService/masterQueryDetail" not in request.get("url", ""):
continue
post = request.get("postData", {})
raw = post.get("text", "")
if post.get("encoding") == "base64":
raw = base64.b64decode(raw).decode()
payload = decode(raw, key)
server = request["url"].split("masterService/masterQueryDetail", 1)[0]
return cls(server, str(payload["token"]), key, int(payload.get("reqid", 0)) + 1, int(payload.get("reqsid", 0)) + 1)
raise ValueError("HAR 中未找到角色详情请求。请在手机刷新牧场后导出抓包。")
class Client:
def __init__(self, session, trace=None, on_session_change=None):
self.session = session
self.trace = trace
self.on_session_change = on_session_change
self.http = requests.Session()
self.http.trust_env = False
self.lock = threading.Lock()
self.server_offset = 0
self.last_receive = 0
def persist_session(self):
if self.on_session_change:
try:
self.on_session_change(self.session)
except (OSError, ValueError, TypeError):
if self.trace:
self.trace.emit("error", "保存会话", scope="local", message="会话未能保存到本机,请检查本地状态目录")
def call(self, path, payload=None, base_url=None):
with self.lock:
base = (base_url or self.session.server_url).strip()
parsed = urlsplit(base)
if parsed.scheme not in ("http", "https") or not parsed.netloc or parsed.username:
raise ApiError("请填写有效的游戏服务器地址")
data = dict(payload or {}) | {"token": self.session.token, "reqid": int(self.session.reqid), "reqsid": int(self.session.reqsid)}
self.session.reqid += 1
self.session.reqsid += 1
# Persist advanced counters before sending, including an unconfirmed request.
self.persist_session()
operation = {"userServerService/loginUser": "获取官方区服", "userServerService/enterGame": "进入选中区服",
"masterService/masterQueryDetail": "读取角色"}.get(path, path)
url = base.rstrip("/") + "/" + path
headers = {"Content-Type": "application/x-www-form-urlencoded"}
identifier = self.trace.begin(operation, method="POST", url=url, headers=headers, body=data,
encoding="AES-ECB / PKCS7 / Base64(body 展示解密 JSON)") if self.trace else None
started = time.monotonic()
try:
result = self.http.post(url, data=encode(data, self.session.key),
headers=headers, timeout=(5, 15), allow_redirects=False)
try:
response = decode(result.content.strip(), self.session.key)
except (ValueError, TypeError):
if self.trace:
self.trace.emit("response", operation, request_id=identifier, url=url, http_status=result.status_code,
headers=dict(result.headers), elapsed_ms=round((time.monotonic() - started) * 1000),
body_preview=result.content[:4000].decode("utf-8", errors="replace"), bytes_received=len(result.content), decoded=False)
if result.status_code != 200:
raise ApiError(f"HTTP {result.status_code},响应无法解码,请查看调试窗口")
raise
if self.trace:
self.trace.emit("response", operation, request_id=identifier, url=url, http_status=result.status_code,
headers=dict(result.headers), elapsed_ms=round((time.monotonic() - started) * 1000), body=response, decoded=True)
if result.status_code != 200:
raise ApiError(f"HTTP {result.status_code},请求已停止")
if not isinstance(response, dict):
raise ApiError("游戏接口响应不是 JSON 对象,请查看调试窗口")
code = response.get("resCode")
if code not in (0, "0"):
if str(code) == "408":
raise ApiError("会话已失效,请重新登录或导入有效会话")
raise ApiError(f"游戏接口返回 {code},已停止本轮操作")
except ApiError as error:
if self.trace:
self.trace.emit("error", operation, request_id=identifier, url=url, message=str(error))
raise
except requests.RequestException as error:
if self.trace:
self.trace.emit("error", operation, request_id=identifier, url=url, exception_type=type(error).__name__, message=str(error))
raise ApiError("网络请求未确认完成;已停止执行,请刷新状态后再启动") from error
except (ValueError, TypeError) as error:
if self.trace:
self.trace.emit("error", operation, request_id=identifier, url=url, exception_type=type(error).__name__, message=str(error))
raise ApiError("响应无法解码,请核对会话密钥和服务器地址") from error
self.last_receive = time.time()
if result.headers.get("Date"):
try:
self.server_offset = parsedate_to_datetime(result.headers["Date"]).timestamp() - self.last_receive
except (ValueError, TypeError):
pass
return response
def snapshot(self):
from .model import Snapshot
snapshot = Snapshot(self.call("masterService/masterQueryDetail"), server_offset=self.server_offset)
role_id = int(snapshot.raw["master"]["id"])
if self.session.role_id and self.session.role_id != role_id:
raise ApiError("会话返回了其他角色,已停止;请重新登录并选择区服")
self.session.role_id = role_id
self.persist_session()
return snapshot
def settle_growth(self):
return self.call("stackService/stackCheckProcess")
def sdk_login(self, center_url, uid, sdk_token, channel="DYD", platform="ANDROID", device_id="pc", *, tj_channel="unknow"):
result = self.call("userServerService/loginUser", {"sdkUid": uid, "sdkToken": sdk_token,
"deviceId": device_id, "channel": channel, "platform": platform, "loginType": "player",
"imei": "", "osType": platform, "network": "unknow", "isp": "unknow", "tjChannel": tj_channel}, center_url)
try:
result["servers"] = server_entries(result, platform)
except ApiError as error:
if self.trace:
self.trace.emit("error", "本地区服整理", scope="local", message=str(error))
raise
player = result.get("playerInfo")
if not isinstance(player, dict) or not player.get("token"):
raise ApiError("游戏登录响应缺少玩家会话,未进入区服")
self.session.token = str(player["token"])
self.session.account_id, self.session.channel, self.session.platform = str(uid), channel, platform
self.session.server_id = self.session.role_id = 0
return result
def enter_server(self, center_url, server, uid, catalog, channel="DYD", platform="ANDROID", device_id="pc"):
identifier = server_id(server)
address = server.get("gameServerAddress")
parsed = urlsplit(address) if isinstance(address, str) else None
if not parsed or parsed.scheme not in ("http", "https") or not parsed.netloc or parsed.username:
raise ApiError("所选区服缺少有效的 gameServerAddress,未发送进入请求")
settings = catalog.data["game_setting"]
parts = settings.get(f"{platform}_{channel}_xyz", settings["xyz"]).split("|")
tail_uid = uid[int(len(uid) / int(parts[0])):]
token = self.session.token
tail_token = token[int(len(token) / int(parts[1])):]
# Paster.timestampFormat("yyMMdd") uses Date.fullYear, not a two-digit year.
date = datetime.now(timezone(timedelta(hours=8))).strftime("%Y%m%d")
tracking_channel = catalog.data.get("tjchannel", {}).get("tjchannel", "unknow")
values = {"1": tail_uid, "2": tail_token, "3": date}
random = hashlib.md5("".join(values[p] for p in parts[2:5]).encode()).hexdigest()
if self.trace:
self.trace.emit("info", "进入参数检查", scope="local", sign_date=date, date_format="yyyyMMdd",
signature_rule="|".join(parts), tj_channel=tracking_channel, platform=platform, channel=channel,
uid_length=len(uid), token_length=len(token))
self.call("userServerService/enterGame", {"serverId": identifier, "deviceId": device_id,
"network": "unknow", "isp": "unknow", "imei": "", "tjChannel": tracking_channel, "osType": platform, "random": random}, center_url)
self.session.server_url = address
self.session.server_id, self.session.role_id = identifier, 0
def close(self):
self.http.close()
+155
View File
@@ -0,0 +1,155 @@
"""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
+58
View File
@@ -0,0 +1,58 @@
"""Remember desktop credentials using the current Windows user's DPAPI key."""
import base64
import ctypes
from ctypes import wintypes
import json
import os
from pathlib import Path
class Blob(ctypes.Structure):
_fields_ = [("size", wintypes.DWORD), ("data", ctypes.POINTER(ctypes.c_ubyte))]
def crypt(data, decrypt=False):
if os.name != "nt":
raise OSError("此密码保存方式需要 Windows")
crypt32 = ctypes.WinDLL("crypt32", use_last_error=True)
kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
function = crypt32.CryptUnprotectData if decrypt else crypt32.CryptProtectData
function.argtypes = [ctypes.POINTER(Blob), ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p,
ctypes.c_void_p, wintypes.DWORD, ctypes.POINTER(Blob)]
function.restype = wintypes.BOOL
kernel32.LocalFree.argtypes = [ctypes.c_void_p]
kernel32.LocalFree.restype = ctypes.c_void_p
buffer = ctypes.create_string_buffer(data)
source = Blob(len(data), ctypes.cast(buffer, ctypes.POINTER(ctypes.c_ubyte)))
output = Blob()
if not function(ctypes.byref(source), None, None, None, None, 1, ctypes.byref(output)):
raise OSError("Windows 无法读取或保存此登录密码")
try:
return ctypes.string_at(output.data, output.size)
finally:
kernel32.LocalFree(ctypes.cast(output.data, ctypes.c_void_p))
class CredentialStore:
def __init__(self, folder):
self.path = Path(folder) / "credentials.json"
def save(self, account, password, remember=True):
value = {"remember": bool(remember), "scheme": "windows-dpapi"}
if remember:
value.update(account=account, password=base64.b64encode(crypt(password.encode("utf-8"))).decode("ascii"))
self.path.parent.mkdir(parents=True, exist_ok=True)
temporary = self.path.with_suffix(".tmp")
temporary.write_text(json.dumps(value, ensure_ascii=False, indent=2), encoding="utf-8")
temporary.replace(self.path)
def load(self):
if not self.path.exists():
return True, "", ""
value = json.loads(self.path.read_text(encoding="utf-8"))
if not value.get("remember"):
return False, "", ""
if value.get("scheme") != "windows-dpapi":
raise ValueError("无法识别保存的密码格式")
password = crypt(base64.b64decode(value["password"], validate=True), decrypt=True).decode("utf-8")
return True, value["account"], password
File diff suppressed because one or more lines are too long
+84
View File
@@ -0,0 +1,84 @@
"""Thread-safe structured network diagnostics; disk/UI records contain no secrets."""
from collections import deque
from datetime import datetime, timedelta, timezone
import json
from pathlib import Path
import re
import threading
import uuid
HIDDEN = "<隐藏>"
def sensitive(key):
key = str(key).lower().replace("_", "").replace("-", "")
return key in {"password", "passwd", "pwd", "newpass", "authorization", "cookie", "setcookie", "key", "secret",
"userpassword", "userpwd", "passwordhash", "accesstoken", "refreshtoken"} or "token" in key
class TraceLog:
def __init__(self, folder, on_event=None):
self.path = Path(folder) / "network_debug.jsonl"
self.on_event = on_event
self.events = deque(maxlen=300)
self.secrets = set()
self.lock = threading.RLock()
self.run_id, self.counter = uuid.uuid4().hex[:8], 0
self.write_error = ""
def remember(self, value):
if isinstance(value, dict):
for key, item in value.items():
if sensitive(key) and isinstance(item, (str, int)) and str(item):
self.secrets.add(str(item))
self.remember(item)
elif isinstance(value, (list, tuple)):
for item in value:
self.remember(item)
def redact(self, value):
if isinstance(value, dict):
return {key: HIDDEN if sensitive(key) else self.redact(item) for key, item in value.items()}
if isinstance(value, (list, tuple)):
return [self.redact(item) for item in value]
if isinstance(value, str):
value = re.sub(r'(?i)("(?:password|passwd|pwd|newPass|[\w]*token|authorization|cookie)"\s*:\s*")[^"]*("|$)',
lambda match: match[1] + HIDDEN + match[2], value)
for secret in sorted(self.secrets, key=len, reverse=True):
value = value.replace(secret, HIDDEN)
return value
def emit(self, kind, operation, **details):
with self.lock:
self.remember(details)
event = self.redact({"time": datetime.now(timezone(timedelta(hours=8))).isoformat(timespec="milliseconds"),
"kind": kind, "operation": operation, **details})
self.events.append(event)
try:
self.path.parent.mkdir(parents=True, exist_ok=True)
if self.path.exists() and self.path.stat().st_size > 8 * 1024 * 1024:
self.path.replace(self.path.with_name("network_debug.previous.jsonl"))
with self.path.open("a", encoding="utf-8") as stream:
stream.write(json.dumps(event, ensure_ascii=False) + "\n")
except OSError:
self.write_error = "调试日志无法写入文件,当前记录仍可在窗口查看和导出"
if self.on_event:
self.on_event(event)
return event
def begin(self, operation, **details):
with self.lock:
self.counter += 1
identifier = f"{self.run_id}-{self.counter}"
self.emit("request", operation, request_id=identifier, **details)
return identifier
def text(self):
with self.lock:
return "\n".join(json.dumps(e, ensure_ascii=False) for e in self.events)
def clear(self):
with self.lock:
self.events.clear()
if self.path.exists():
self.path.write_text("", encoding="utf-8")
+92
View File
@@ -0,0 +1,92 @@
"""Default Qt dialog for inspecting decoded requests and responses."""
import json
from pathlib import Path
from PySide6 import QtCore as C, QtGui as G, QtWidgets as W
class DebugWindow(W.QDialog):
def __init__(self, trace, parent=None):
super().__init__(parent)
self.trace, self.records = trace, []
self.setWindowTitle("请求 / 响应调试")
self.resize(1050, 720)
layout = W.QVBoxLayout(self)
note = W.QLabel("选择一行查看请求或响应 JSON;密码、Token 和 Cookie 已遮盖。\n“请求 / 响应”行表示网络通信,“本地错误”行表示辅助程序处理数据时出错。\n日志自动保存:" + str(trace.path))
note.setWordWrap(True)
layout.addWidget(note)
buttons = W.QHBoxLayout()
for label, function in (("复制选中记录", self.copy_selected), ("复制全部记录", self.copy_all),
("导出调试日志", self.export), ("打开日志目录", self.open_folder), ("清空", self.clear)):
button = W.QPushButton(label)
button.clicked.connect(function)
buttons.addWidget(button)
layout.addLayout(buttons)
splitter = W.QSplitter(C.Qt.Orientation.Vertical)
self.rows = W.QTableWidget(0, 6)
self.rows.setHorizontalHeaderLabels(["时间", "阶段 / 接口", "方向", "HTTP", "耗时 ms", "地址"])
self.rows.setEditTriggers(W.QAbstractItemView.EditTrigger.NoEditTriggers)
self.rows.setSelectionBehavior(W.QAbstractItemView.SelectionBehavior.SelectRows)
self.rows.setSelectionMode(W.QAbstractItemView.SelectionMode.SingleSelection)
self.rows.horizontalHeader().setSectionResizeMode(W.QHeaderView.ResizeMode.ResizeToContents)
self.rows.horizontalHeader().setStretchLastSection(True)
self.rows.itemSelectionChanged.connect(self.show_selected)
splitter.addWidget(self.rows)
self.details = W.QPlainTextEdit()
self.details.setReadOnly(True)
splitter.addWidget(self.details)
splitter.setSizes([260, 400])
layout.addWidget(splitter, 1)
@C.Slot(object)
def add_event(self, event):
if len(self.records) >= 300:
self.records.pop(0)
self.rows.removeRow(0)
self.records.append(event)
row = self.rows.rowCount()
self.rows.insertRow(row)
values = [event["time"][11:23], event["operation"], {"request": "请求 →", "response": "← 响应", "error": "错误", "info": "状态"}.get(event["kind"], event["kind"]),
event.get("http_status", ""), event.get("elapsed_ms", ""), event.get("url", "")]
if event["kind"] == "error" and event.get("scope") == "local":
values[2] = "本地错误"
for index, value in enumerate(values):
self.rows.setItem(row, index, W.QTableWidgetItem(str(value)))
# Follow the newest record unless the user is inspecting an older row.
if row == 0 or self.rows.currentRow() in (-1, row - 1) or event["kind"] == "error":
self.rows.selectRow(row)
self.rows.scrollToBottom()
def selected_text(self):
row = self.rows.currentRow()
return json.dumps(self.records[row], ensure_ascii=False, indent=2) if 0 <= row < len(self.records) else ""
def show_selected(self):
self.details.setPlainText(self.selected_text())
def copy_selected(self):
W.QApplication.clipboard().setText(self.selected_text())
def copy_all(self):
W.QApplication.clipboard().setText(self.trace.text())
def export(self):
path, _ = W.QFileDialog.getSaveFileName(self, "导出调试日志", str(self.trace.path.with_name("network_debug_export.jsonl")), "JSON Lines (*.jsonl);;所有文件 (*)")
if path:
try:
Path(path).write_text(self.trace.text() + "\n", encoding="utf-8")
except OSError:
self.details.setPlainText("日志导出失败,请选择可写的文件路径")
def open_folder(self):
self.trace.path.parent.mkdir(parents=True, exist_ok=True)
G.QDesktopServices.openUrl(C.QUrl.fromLocalFile(str(self.trace.path.parent.resolve())))
def clear(self):
try:
self.trace.clear()
except OSError:
self.details.setPlainText("无法清空日志文件")
return
self.records.clear()
self.rows.setRowCount(0)
self.details.clear()
+106
View File
@@ -0,0 +1,106 @@
"""Native per-species incubation and restocking controls."""
import copy
from dataclasses import asdict
from PySide6 import QtCore as C, QtWidgets as W
from .model import EggRule, duration
from .native_widgets import IntegerInput
class EggTable(W.QTableWidget):
rules_changed = C.Signal(object, str)
def __init__(self, catalog):
headers = ["魔物蛋", "星", "数量", "孵化", "优先级", "孵出后", "低于补货", "补至", "补货市场",
"培育时间", "派遣金币", "基础经验", "金币/小时", "经验/小时", "物品ID"]
super().__init__(0, len(headers))
self.catalog, self.rules, self.snapshot = catalog, {}, None
self.default_market = "sc_city1"
self.updating = False
self.setHorizontalHeaderLabels(headers)
self.setEditTriggers(W.QAbstractItemView.EditTrigger.NoEditTriggers)
self.setSelectionBehavior(W.QAbstractItemView.SelectionBehavior.SelectRows)
self.horizontalHeader().setSectionResizeMode(W.QHeaderView.ResizeMode.ResizeToContents)
self.horizontalHeader().setStretchLastSection(True)
self.verticalHeader().setDefaultSectionSize(24)
def default_rule(self, key):
markets = self.catalog.markets_for(key)
market = self.default_market if self.default_market in markets else markets[0] if markets else ""
return asdict(EggRule(market_id=market))
def set_data(self, snapshot, rules, default_market="sc_city1"):
self.snapshot, self.rules, self.default_market = snapshot, {str(key): asdict(EggRule(**rule)) for key, rule in rules.items()}, default_market
self.updating = True
self.setSortingEnabled(False)
groups = {}
for egg in snapshot.eggs(self.catalog):
key = str(egg["typeId"])
group = groups.setdefault(key, {"count": 0, "ids": []})
group["count"] += int(egg["num"])
group["ids"].append(str(egg["id"]))
keys = list(dict.fromkeys(list(groups) + list(self.rules)))
keys = [key for key in keys if self.catalog.monster(key)]
self.setRowCount(len(keys))
for i, key in enumerate(keys):
data, rule = self.catalog.monster(key), self.rules.get(key, self.default_rule(key))
group = groups.get(key, {"count": 0, "ids": []})
total = max(1, self.catalog.total_time(key))
money, exp = data.get("sell_money", 0), data.get("sell_exp", 0)
values = [data.get("name", key), data.get("star", "?"), group["count"], "", "", "", "", "", "",
duration(total), money, exp, round(money * 3600 / total, 2), round(exp * 3600 / total, 2), ", ".join(group["ids"])]
for j, value in enumerate(values):
item = W.QTableWidgetItem()
item.setData(C.Qt.ItemDataRole.DisplayRole, value)
if j == 0:
item.setData(C.Qt.ItemDataRole.UserRole, key)
item.setToolTip(f"魔物编号 {key}")
self.setItem(i, j, item)
enabled = W.QCheckBox()
enabled.setChecked(rule["enabled"])
priority, below, target = IntegerInput(), IntegerInput(), IntegerInput()
for control, low, high, value in ((priority, 1, 999, rule["priority"]), (below, 0, 1000, rule["refill_below"]),
(target, max(1, rule["refill_below"]), 1000, rule["refill_target"])):
control.setRange(low, high)
control.setValue(value)
control.setFixedWidth(76)
priority.setToolTip("数字越小,孵化优先级越高")
below.setToolTip("可用蛋少于此数量时补货;0表示不自动补货")
target.setToolTip("补货希望达到的可用蛋数量;市场随机出蛋,实际结果由服务器决定")
action, market = W.QComboBox(), W.QComboBox()
for name, value in (("派遣", "sell"), ("喂养", "feed"), ("保留", "keep")):
action.addItem(name, value)
action.setCurrentIndex(max(0, action.findData(rule["action"])))
for market_id in self.catalog.markets_for(key):
info = self.catalog.data["markets"][market_id]
market.addItem(info["name"] + "市场", market_id)
if not market.count():
market.addItem("金币市场无此蛋", "")
market.setCurrentIndex(max(0, market.findData(rule["market_id"])))
market.setMaximumWidth(135)
controls = {"enabled": enabled, "priority": priority, "action": action, "refill_below": below,
"refill_target": target, "market_id": market}
for column, control in zip(range(3, 9), controls.values()):
self.setCellWidget(i, column, control)
def commit(*args, key=key, controls=controls):
if self.updating:
return
controls["refill_target"].setMinimum(max(1, controls["refill_below"].value()))
value = {"enabled": controls["enabled"].isChecked(), "priority": controls["priority"].value(),
"action": controls["action"].currentData(), "refill_below": controls["refill_below"].value(),
"refill_target": controls["refill_target"].value(), "market_id": controls["market_id"].currentData()}
self.rules[key] = asdict(EggRule(**value))
self.rules_changed.emit(copy.deepcopy(self.rules), key)
enabled.toggled.connect(commit)
for control in (priority, below, target):
control.valueChanged.connect(commit)
action.currentIndexChanged.connect(commit)
market.currentIndexChanged.connect(commit)
self.setSortingEnabled(True)
self.updating = False
def add_rule(self, type_id):
key = str(type_id)
self.rules.setdefault(key, self.default_rule(key))
if self.snapshot:
self.set_data(self.snapshot, self.rules, self.default_market)
self.rules_changed.emit(copy.deepcopy(self.rules), key)
+359
View File
@@ -0,0 +1,359 @@
from __future__ import annotations
from dataclasses import replace
import json
from pathlib import Path
import time
from .model import Catalog, Planner, Policy, Snapshot, seconds
from .quests import QuestPolicy, TaskPlanner
from .market import PurchaseBudget
from .management import expansion_quote, manual_monster_actions
class Engine:
def __init__(self, catalog, client=None, budget_path=None):
self.catalog, self.client = catalog, client
self.planner = Planner(catalog)
self.policy = Policy()
self.quest_policy = QuestPolicy()
self.tasks = TaskPlanner(catalog)
self.snapshot = None
self.demo = client is None
self.auto = False
self.last_heartbeat = 0
self.heartbeat_enabled = True
self.purchase_budget = PurchaseBudget(budget_path)
self.last_draw = ""
self.growth_cache = {}
self.growth_attempts = {}
def read_snapshot(self):
self.snapshot = self.client.snapshot()
present = self.snapshot.monsters
self.growth_cache = {mid: entry for mid, entry in self.growth_cache.items() if mid in present}
self.growth_attempts = {key: stamp for key, stamp in self.growth_attempts.items() if key[0] in present}
rows = []
fields = ("gAtk", "gDef", "gHp", "gDex")
for mon in self.snapshot.raw["monsters"]:
mid = int(mon["id"])
entry = self.growth_cache.get(mid)
if entry:
start = seconds(mon.get("timeStart"))
if str(mon.get("typeId")) != entry["type"] or start > 0 and entry["start"] > 0 and start != entry["start"]:
self.growth_cache.pop(mid, None)
else:
confirmed = int(mon.get("mode") or 0) >= entry.get("mode", 0)
if entry.get("mode") == 2:
confirmed = confirmed and all(q is not None for q in self.catalog.quality(mon))
for field in fields:
if field in entry and mon.get(field) != entry[field]:
confirmed = False
if confirmed:
self.growth_cache.pop(mid, None)
else:
mon = dict(mon)
mon["mode"] = max(int(mon.get("mode") or 0), entry.get("mode", 0))
mon.update({field: entry[field] for field in fields if field in entry})
rows.append(mon)
self.snapshot.raw["monsters"] = rows
return self.snapshot
def remember_growth(self, response):
# MonsterCenter.checkGrowUpHandler treats these two arrays as the
# authoritative stage and growth values, including after a stale read.
if not isinstance(response, dict):
return
current = self.snapshot.monsters
for key in ("datas", "stackMonsterInfos"):
for row in response.get(key) or []:
if not isinstance(row, dict) or row.get("monsterId") is None:
continue
mid = int(row["monsterId"])
mon = current.get(mid)
if mon is None:
continue
entry = self.growth_cache.setdefault(mid, {"type": str(mon.get("typeId")), "start": seconds(mon.get("timeStart"))})
if key == "datas" and row.get("mode") in (0, 1, 2):
entry["mode"] = max(entry.get("mode", 0), int(row["mode"]))
else:
entry.update({field: row[field] for field in ("gAtk", "gDef", "gHp", "gDex") if row.get(field) is not None})
def settle_pending_growth(self, force=False):
pending = self.snapshot.growth_pending(self.catalog)
now = time.monotonic()
if not pending or not force and all(now - self.growth_attempts.get(key, -1e12) < 60 for key in pending):
return False
for key in pending:
self.growth_attempts[key] = now
response = self.client.settle_growth()
self.remember_growth(response)
self.read_snapshot()
return True
def sync_growth(self):
self.auto = False
if self.demo:
if self.snapshot is None:
self.snapshot = demo_snapshot(self.catalog)
for mon in self.snapshot.raw["monsters"]:
if mon.get("process") == 2:
mon["mode"] = self.snapshot.expected_growth_mode(mon, self.catalog)
else:
self.read_snapshot()
self.settle_pending_growth(force=True)
pending = self.snapshot.growth_pending(self.catalog)
message = "已同步孵化 / 成长状态;本次不执行派遣或喂养"
if pending:
message += f";仍有 {len(pending)} 只等待服务器确认阶段或资质"
return self.snapshot, self.plans(), message
def keep_alive(self):
if self.demo:
return "离线演示无需心跳"
self.last_heartbeat = time.monotonic()
self.client.call("heartBeatService/keepAlive")
return "会话心跳已更新"
def poll(self):
settled = False
if self.demo:
if self.snapshot is None:
self.snapshot = demo_snapshot(self.catalog)
if self.auto and self.policy.enabled:
for mon in self.snapshot.raw["monsters"]:
if mon.get("process") == 2:
mon["mode"] = self.snapshot.expected_growth_mode(mon, self.catalog)
else:
self.read_snapshot()
if self.auto and self.policy.enabled:
settled = self.settle_pending_growth()
message = "状态已刷新" + (";已请求孵化 / 成长结算" if settled else "")
if not self.auto and self.snapshot.growth_pending(self.catalog):
message += ";仅监控:有待结算的孵化 / 成长;请开始执行,或点击“同步孵化 / 成长”"
try:
plans = self.plans()
except (ValueError, TypeError, KeyError, AttributeError) as error:
self.auto = False
return self.snapshot, [], "状态已读取;策略暂不可用:" + str(error)
if self.auto and plans:
action = plans[0]
if action.kind == "buy":
price = int(self.catalog.data["markets"][action.payload["id"]]["money"])
self.purchase_budget.record(self.snapshot.now, price * action.payload["num"], self.policy.daily_buy_money)
if self.demo:
self.apply_demo(action)
else:
response = self.client.call(action.path, action.payload)
if action.kind == "buy":
self.record_draw(response.get("eggs") or [])
self.read_snapshot()
message = ("[演示] " if self.demo else "") + action.description
if action.kind == "buy" and self.last_draw:
message += ";" + self.last_draw
try:
plans = self.plans()
except (ValueError, TypeError, KeyError, AttributeError) as error:
self.auto = False
plans = []
message += ";状态已读取,策略暂不可用:" + str(error)
if not plans and self.planner.notes:
message += ";" + ";".join(dict.fromkeys(self.planner.notes))
return self.snapshot, plans, message
def plans(self):
quests = self.tasks.plan(self.snapshot, self.quest_policy, self.policy)
types, eggs = self.tasks.reservations(self.snapshot)
reserved = dict(self.policy.reserved_eggs)
for key, count in eggs.items():
reserved[key] = max(reserved.get(key, 0), count)
policy = replace(self.policy, reserved_types=list(set(self.policy.reserved_types) | types), reserved_eggs=reserved)
left = self.purchase_budget.remaining(self.snapshot.now, policy.daily_buy_money)
return quests + self.planner.plan(self.snapshot, policy, left)
def record_draw(self, eggs):
totals = {}
for egg in eggs:
if isinstance(egg, dict) and egg.get("typeId") is not None:
key = str(egg["typeId"])
totals[key] = totals.get(key, 0) + int(egg.get("num") or 0)
parts = [f"{self.catalog.monster(key).get('name', key)} ×{count}" for key, count in totals.items()]
self.last_draw = f"抽蛋完成,共 {sum(totals.values())} 枚:" + "、".join(parts[:8]) + ("…" if len(parts) > 8 else "")
def set_monster_lock(self, monster_ids, locked):
self.auto = False
ids = list(dict.fromkeys(int(mid) for mid in monster_ids))
if not ids or any(mid <= 0 for mid in ids):
raise ValueError("请先选择需要锁定 / 解锁的魔物")
if not self.demo:
self.read_snapshot()
monsters = self.snapshot.monsters
if any(mid not in monsters for mid in ids):
raise ValueError("选中的魔物已不存在,请刷新后重新选择")
if not locked and any(monsters[mid].get("sysLock") for mid in ids):
raise ValueError("选中包含系统锁定魔物,普通解锁不能解除系统锁,请重新选择")
changed = 0
for mid in ids:
if bool(monsters[mid].get("lock")) == bool(locked):
continue
if self.demo:
monsters[mid]["lock"] = int(locked)
else:
self.client.call("monsterService/monsterLock", {"monsterId": mid, "lock": int(locked)})
self.read_snapshot()
if bool(self.snapshot.monsters.get(mid, {}).get("lock")) != bool(locked):
raise ValueError("服务器返回的锁定状态未更新,已停止后续操作")
changed += 1
message = ("[演示] " if self.demo else "") + f"已{'锁定' if locked else '解锁'} {changed} 只魔物;自动执行已暂停"
return self.snapshot, self.plans(), message
def manage_monsters(self, kind, monster_ids, target_id=0):
self.auto = False
if not self.demo:
self.read_snapshot()
actions = manual_monster_actions(self.catalog, self.snapshot, kind, monster_ids, target_id)
for action in actions:
if self.demo:
field = "foods" if kind == "feed" else "monsterId" if "monsterId" in action.payload else "monsterIds"
for mid in action.payload[field]:
self.apply_demo(replace(action, payload=action.payload | {field: [mid]}))
else:
self.client.call(action.path, action.payload)
self.read_snapshot()
consumed = action.payload.get("foods") or action.payload.get("monsterId") or action.payload.get("monsterIds") or []
if any(int(mid) in self.snapshot.monsters for mid in consumed):
raise ValueError("操作已返回,但魔物记录尚未更新;请刷新核对,不会重复提交")
return self.snapshot, self.plans(), ("[演示] " if self.demo else "") + ";".join(a.description for a in actions) + ";自动执行已暂停"
def expand(self, quote):
self.auto = False
if not self.demo:
self.read_snapshot()
fresh = expansion_quote(self.catalog, self.snapshot, quote.kind, quote.currency, quote.position)
if fresh != quote:
raise ValueError("扩建费用或次数已变化,请刷新后重新确认")
old_rooms = {int(r["id"]) for r in self.snapshot.raw["rooms"]}
if self.demo:
raw = self.snapshot.raw
raw["master"][quote.currency] -= quote.cost
counter = ("numAdd" if quote.currency == "money" else "numKeAdd") + ("Stack" if quote.kind == "stack" else "Room")
raw["history"][counter] += 1
if quote.kind == "stack":
raw["stacks"].append({"id": max([int(s["id"]) for s in raw["stacks"]] + [0]) + 1,
"position": quote.position, "monsterId": -1, "openType": quote.payload["openType"]})
else:
type_id = 1000 if "1000" in self.catalog.data["room_info"] else int(raw["rooms"][0]["typeId"])
raw["rooms"].append({"id": max(old_rooms or {0}) + 1, "typeId": type_id, "openType": 1 if quote.currency == "money" else 2})
else:
self.client.call(quote.path, quote.payload)
self.read_snapshot()
verified = (any(int(s.get("position", -1)) == quote.position for s in self.snapshot.raw["stacks"]) if quote.kind == "stack"
else bool({int(r["id"]) for r in self.snapshot.raw["rooms"]} - old_rooms))
if not verified:
raise ValueError("扩建请求已返回,但尚未读取到新增记录;请刷新核对,不会自动重复提交")
return self.snapshot, self.plans(), ("[演示] " if self.demo else "") + quote.description + ",已完成"
def apply_demo(self, action):
raw = self.snapshot.raw
if action.kind.startswith("quest_"):
self.apply_demo_quest(action)
return
if action.kind == "buy":
market = self.catalog.data["markets"][action.payload["id"]]
count = action.payload["num"]
gift_every = int(market.get("freegift") or 0)
received = count + (count // gift_every if gift_every > 0 else 0)
# Deterministic offline example, not a prediction of the server draw.
type_id = int(next(iter(market["eggs"].values()))[0])
item = next((i for i in raw["items"] if int(i["typeId"]) == type_id), None)
if item:
item["num"] += received
else:
raw["items"].append({"id": max([int(i["id"]) for i in raw["items"]] + [500]) + 1, "typeId": type_id, "num": received})
raw["master"]["money"] -= int(market["money"]) * count
self.record_draw([{"typeId": type_id, "num": received}])
return
if action.kind == "collect":
data = action.payload["datas"][0]
mid = data["monsterId"][0]
self.snapshot.monsters[mid].update(process=3, roomId=data["roomId"])
elif action.kind in ("sell", "feed"):
mid = (action.payload.get("monsterId") or action.payload.get("monsterIds") or action.payload.get("foods"))[0]
mon = self.snapshot.monsters[mid]
if action.kind == "sell":
raw["master"]["money"] += self.catalog.monster(mon["typeId"])["sell_money"]
else:
target = self.snapshot.monsters[action.payload["targetId"]]
target["exp"] = target.get("exp", 0) + self.catalog.feed_exp(mon)
raw["monsters"] = [m for m in raw["monsters"] if m["id"] != mid]
else:
egg = action.payload["eggs"][0]
item = next(i for i in raw["items"] if i["id"] == egg["itemId"])
item["num"] -= 1
mid = max([m["id"] for m in raw["monsters"]] + [100]) + 1
row = self.catalog.monster(item["typeId"])
mon = {"id": mid, "typeId": item["typeId"], "process": 2, "mode": 0, "level": 1, "exp": 0, "timeStart": int(time.time() * 1000), "roomId": 0}
mon.update({"g" + s.capitalize(): row[s + "_grow_min"] for s in ("atk", "def", "hp", "dex")})
raw["monsters"].append(mon)
next(s for s in raw["stacks"] if s["id"] == egg["stackId"])["monsterId"] = mid
return
for slot in raw["stacks"]:
if slot.get("monsterId") == mid:
slot["monsterId"] = 0
def apply_demo_quest(self, action):
raw = self.snapshot.raw
history = raw.setdefault("history", {})
tasks = raw.setdefault("currentTasks", [])
if action.kind == "quest_reset":
history["loopTaskTime"] = int(time.time())
history["loopTaskNum"] = self.catalog.data["game_setting"].get("loopTaskMaxNum", 6)
elif action.kind == "quest_accept":
type_id = action.payload["taskTypeId"]
tasks.append({"id": max([t["id"] for t in tasks] + [1000]) + 1, "typeId": type_id, "curStep": 1, "stepValue": 0})
history["loopTaskNum"] -= 1
offers = history["loopTask"][str(action.payload["city"])]
offers[:] = [t for t in offers if str(t) != type_id]
else:
task = next(t for t in tasks if int(t["id"]) == action.payload["taskId"])
info = self.catalog.data["task_info"][str(task["typeId"])]
if action.kind == "quest_complete":
raw["master"]["money"] += int(info.get("reward", {}).get("money", 0))
raw["master"]["ke"] = raw["master"].get("ke", 0) + int(info.get("reward", {}).get("ke", 0))
tasks.remove(task)
else:
step = info["steps"][task["curStep"] - 1]
value = step.get("statusValue") or {}
if value.get("remove"):
ids = action.payload.get("removeIds") or []
if step["statusType"] == "getMoney":
raw["master"]["money"] -= int(value["money"])
elif step["statusType"] == "getItem" or int(value.get("mode", 2)) == 0:
left = int(value["num"])
for item in raw["items"]:
if int(item["id"]) in ids:
used = min(left, int(item["num"]))
item["num"] -= used
left -= used
else:
raw["monsters"] = [m for m in raw["monsters"] if int(m["id"]) not in ids]
for slot in raw["stacks"]:
if slot.get("monsterId") in ids:
slot["monsterId"] = 0
task["curStep"] += 1
def demo_snapshot(catalog):
types = [int(k) for k, row in catalog.monsters.items() if row.get("star") == 1 and not row.get("npc")][:4]
monsters = []
for i, type_id in enumerate(types):
row = catalog.monster(type_id)
mon = {"id": 101 + i, "typeId": type_id, "level": 1, "exp": 0, "process": 2, "mode": 2 if i < 2 else 0,
"timeStart": int((time.time() - catalog.total_time(type_id) + (0 if i < 2 else 200)) * 1000), "roomId": 0, "lock": 0}
mon.update({"g" + s.capitalize(): row[s + "_grow_min"] for s in ("atk", "def", "hp", "dex")})
monsters.append(mon)
target = dict(monsters[0]) | {"id": 900, "process": 3, "mode": 2, "level": 20, "potentialLevel": 7, "roomId": 1, "lock": 1}
room_type = next(k for k, row in catalog.data["room_info"].items() if row.get("maxNum", 0) >= 10)
return Snapshot({"master": {"id": 1, "roleName": "离线演示", "level": 62, "money": 12345, "ke": 2000, "ti": 100},
"stacks": [{"id": i + 1, "position": i, "monsterId": 101 + i if i < 4 else 0, "openType": 3} for i in range(6)],
"monsters": monsters + [target], "items": [{"id": 501 + i, "typeId": t, "num": 8} for i, t in enumerate(types)] + [{"id": 600, "typeId": 20047, "num": 3}],
"rooms": [{"id": 1, "typeId": int(room_type), "openType": 3}], "teams": [{"monsters": [900]}], "activityHistory": {},
"history": {"unlockCity": {"1": True}, "openFarmBuild": True, "numAddStack": 0, "numKeAddStack": 0, "numAddRoom": 0, "numKeAddRoom": 0}})
+199
View File
@@ -0,0 +1,199 @@
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 "等待匹配按钮;请勿切换到其他关卡"
File diff suppressed because it is too large Load Diff
+127
View File
@@ -0,0 +1,127 @@
"""Normal DYD password authentication recovered from the shipped Android SDK."""
from __future__ import annotations
import hashlib
import hmac
import time
import uuid
from pathlib import Path
import requests
from .api import ApiError, Client, Session, server_entries, server_id
SDK_LOGIN_URL = "https://gameapi.diyidan.net/g0.3/users/reallogin"
SDK_APP_ID = "76813411"
# Published client application identity, not an account credential.
SDK_APP_SECRET = "WicgaI9bN0FoQbK5"
DEFAULT_CENTER = "https://myrzx-user.diyidan.net:9099/"
def device_id(folder):
path = Path(folder) / "desktop_device_id.txt"
if path.exists():
return path.read_text(encoding="ascii").strip()
path.parent.mkdir(parents=True, exist_ok=True)
value = str(uuid.uuid4())
path.write_text(value, encoding="ascii")
return value
def sdk_headers(device):
signature = hmac.new(SDK_APP_SECRET.encode(), SDK_APP_ID.encode(), hashlib.sha256).hexdigest()
return {"deviceId": device, "AppID": SDK_APP_ID, "Authorization": signature}
class PasswordLogin:
def __init__(self, catalog, device, *, sdk_url=SDK_LOGIN_URL, center_url=None, channel="DYD", trace=None):
self.catalog, self.device = catalog, device
self.trace = trace
self.sdk_url = sdk_url
self.center_url = center_url or catalog.data["server_info"]["ANDROID"].get(channel, DEFAULT_CENTER)
self.channel = channel
def authenticate(self, account, password):
if not account.strip() or not password:
raise ApiError("请填写账号和密码")
# Cookies remain in this process and are discarded on closing the SDK session.
with requests.Session() as http:
http.trust_env = False
payload = {"account": account.strip(), "password": password}
params = {"versionCode": "1.0.1", "buildNumber": "2016122900", "appChannel": "taptap"}
headers = sdk_headers(self.device)
identifier = self.trace.begin("渠道账号验证", method="POST", url=self.sdk_url, query=params,
headers=headers, body=payload, encoding="application/x-www-form-urlencoded") if self.trace else None
started = time.monotonic()
try:
response = http.post(self.sdk_url, data=payload, params=params,
headers=headers, timeout=(5, 15), allow_redirects=False)
try:
data = response.json()
except ValueError as error:
if self.trace:
self.trace.emit("response", "渠道账号验证", request_id=identifier, url=self.sdk_url, http_status=response.status_code,
elapsed_ms=round((time.monotonic() - started) * 1000), headers=dict(response.headers),
body_preview=response.content[:4000].decode("utf-8", errors="replace"), decoded=False)
if response.status_code != 200:
raise ApiError(f"渠道登录返回 HTTP {response.status_code},尚未登录") from error
raise ApiError("渠道登录响应格式无法识别,请查看调试窗口") from error
if self.trace:
self.trace.emit("response", "渠道账号验证", request_id=identifier, url=self.sdk_url, http_status=response.status_code,
elapsed_ms=round((time.monotonic() - started) * 1000), headers=dict(response.headers), body=data, decoded=True)
if response.status_code != 200:
raise ApiError(f"渠道登录返回 HTTP {response.status_code},尚未登录")
except ApiError as error:
if self.trace:
self.trace.emit("error", "渠道账号验证", request_id=identifier, message=str(error))
raise
except requests.RequestException as error:
if self.trace:
self.trace.emit("error", "渠道账号验证", request_id=identifier, exception_type=type(error).__name__, message=str(error))
raise ApiError("渠道登录连接失败,请检查网络或查看调试窗口后重试") from error
except ValueError as error:
if self.trace:
self.trace.emit("error", "渠道账号验证", request_id=identifier, exception_type=type(error).__name__, message=str(error))
raise ApiError("渠道登录响应格式无法识别") from error
if not isinstance(data, dict):
raise ApiError("渠道登录响应不是 JSON 对象,请查看调试窗口")
code = str(data.get("code", ""))
if code != "200" and self.trace:
self.trace.emit("error", "渠道账号验证", request_id=identifier, message=f"官方登录状态码:{code or '缺失'}")
if code == "407":
raise ApiError("官方要求短信验证(407),本次登录未完成")
if code == "408":
raise ApiError("官方限制此账号登录(408),本次登录未完成")
if code != "200":
raise ApiError(f"渠道账号登录未成功({code or '未知状态'}),请核对账号或验证要求")
content = data.get("data")
users = content.get("userList", []) if isinstance(content, dict) else []
if not isinstance(users, list) or not users or not isinstance(users[0], dict) or not users[0].get("userId") or not users[0].get("token"):
raise ApiError("渠道响应缺少用户会话,尚未登录")
uid, sdk_token = str(users[0]["userId"]), str(users[0]["token"])
client = Client(Session(key=self.catalog.data["game_setting"].get("xyz1", Session().key)), trace=self.trace)
try:
game = client.sdk_login(self.center_url, uid, sdk_token, self.channel, "ANDROID", self.device,
tj_channel=self.catalog.data.get("tjchannel", {}).get("tjchannel", "unknow"))
except Exception:
client.close()
raise
client.session.account_name = account.strip()
return client, game, {"uid": uid, "center_url": self.center_url, "device_id": self.device, "channel": self.channel}
def server_labels(response):
roles = {}
for role in response.get("masterInfos") or []:
if isinstance(role, dict):
try:
# masterInfos.id is the character ID, not the server ID.
roles[server_id({"serverId": role.get("serverId")})] = role
except ApiError:
continue
labels = []
for server in server_entries(response):
role = roles.get(server["id"])
details = role or server
name = details.get("masterName") or details.get("roleName") or ("已有角色" if role or server.get("masterId") else "无已有角色")
labels.append(f"{server['serverName']}({server['id']}) - {name}")
return labels
+90
View File
@@ -0,0 +1,90 @@
"""Normal inventory actions and reviewed expansion quotes."""
from dataclasses import dataclass
from .model import Action
@dataclass(frozen=True)
class Expansion:
kind: str
currency: str
cost: int
level: int
index: int
position: int = -1
@property
def path(self):
return "stackService/stackOpen" if self.kind == "stack" else "roomService/roomCreateBy" + ("Money" if self.currency == "money" else "Ke")
@property
def payload(self):
return {"openType": 1 if self.currency == "money" else 2, "position": self.position} if self.kind == "stack" else {}
@property
def description(self):
return f"{'开启坑位 ' + str(self.position + 1) if self.kind == 'stack' else '新建牧场'}:{self.cost} {'金币' if self.currency == 'money' else '氪金'},需要角色等级 {self.level}"
def expansion_quote(catalog, snapshot, kind, currency, position=-1):
if kind not in ("stack", "room") or currency not in ("money", "ke"):
raise ValueError("未知扩建类型")
history = snapshot.raw.get("history", {})
records = snapshot.raw["stacks" if kind == "stack" else "rooms"]
if any(row.get("openType") is None for row in records):
raise ValueError("尚未读到完整的设施开启类型,请刷新后重试")
open_type = 1 if currency == "money" else 2
# HistoryVo derives these counters from actual openType records; legacy
# history.numAdd* fields can remain zero and are not a price authority.
index = sum(int(row["openType"]) == open_type for row in records)
price = catalog.data.get(kind + "_price", {}).get(str(index))
if not price or int(price.get(currency, -1)) < 0:
raise ValueError("该方式已达到扩建上限")
cost, level = int(price[currency]), int(price["level" if currency == "money" else "kelevel"])
master = snapshot.raw["master"]
if int(master.get("level", 0)) < level:
raise ValueError(f"角色需要达到 {level} 级")
if int(master.get(currency, 0)) < cost:
raise ValueError(f"{'金币' if currency == 'money' else '氪金'}不足,需要 {cost}")
if kind == "stack":
total = int(catalog.data.get("stack_meta", {}).get("total", 0))
if not 0 <= position < total or position == 3:
raise ValueError("请选择未开启的普通坑位;VIP坑位由VIP资格决定")
if any(int(s.get("position", -1)) == position for s in snapshot.raw["stacks"]):
raise ValueError("该坑位已经开启")
elif currency == "money":
passed = history.get("passTask") or {}
learned = passed.get("1001011") is not None if isinstance(passed, dict) else "1001011" in {str(key) for key in passed}
if not learned and not history.get("openFarmBuild"):
raise ValueError("尚未解锁金币建设牧场功能(需完成任务1001011)")
return Expansion(kind, currency, cost, level, index, position)
def manual_monster_actions(catalog, snapshot, kind, monster_ids, target_id=0):
ids = list(dict.fromkeys(int(mid) for mid in monster_ids))
if not ids or any(mid <= 0 or mid not in snapshot.monsters for mid in ids):
raise ValueError("请选择仍存在的魔物")
monsters = [snapshot.monsters[mid] for mid in ids]
for mon in monsters:
if (mon.get("lock") or mon.get("sysLock") or mon.get("entangle") or mon.get("inExploreTeam")
or mon.get("inBuild") or int(mon["id"]) in snapshot.team_ids or any(mon.get(f"equip{i}") for i in range(1, 6))):
raise ValueError("选中包含锁定、羁绊、在队、探索、建筑中或已装备的魔物,请先在游戏中调整")
if mon.get("process") not in (2, 3) or int(mon.get("mode", 0)) != 2:
raise ValueError("只能处理已成熟的魔物")
if kind == "feed":
target = snapshot.monsters.get(int(target_id))
if not target or target.get("process") != 3 or int(target_id) in ids:
raise ValueError("喂养目标必须在牧场中,且不能作为素材")
cap = catalog.max_level(target)
if cap is None or int(target.get("level", 1)) >= cap:
raise ValueError("目标已达到当前突破上限,或上限未知,不能喂养")
if any(mon.get("process") != 3 for mon in monsters):
raise ValueError("喂养素材需先从培育室收取到牧场")
return [Action("feed", f"将 {len(ids)} 只素材喂给 #{target_id}", "monsterService/monsterIntensify", {"targetId": int(target_id), "foods": ids})]
if kind != "sell":
raise ValueError("未知魔物操作")
actions = []
for process, field in ((2, "monsterId"), (3, "monsterIds")):
group = [int(m["id"]) for m in monsters if m.get("process") == process]
if group:
actions.append(Action("sell", f"派遣 {len(group)} 只魔物", "monsterService/monsterSell", {field: group}))
return actions
+31
View File
@@ -0,0 +1,31 @@
from dataclasses import dataclass
from .quests import condition_ok, indexed
@dataclass
class Stage:
stage_id: str
level: str
name: str
city: int
unlocked: bool
passed: bool
open: bool
stamina: int
tickets: str
def stages(catalog, snapshot):
history = snapshot.raw.get("history", {})
result = []
for key, row in catalog.data["stage_info"].items():
special = catalog.data.get("stage_sp", {}).get(key, {})
opened = not row.get("closed") and condition_ok(special.get("condition"), snapshot)
for level, info in row.get("level", {}).items():
unlocked = indexed(indexed(history.get("unlockStage"), key), level, False) == True
passed = indexed(indexed(history.get("passStage"), key), level, False) == True
base = row.get("cost") or {}
tickets = ", ".join(f"{i['typeId']}×{i['num']}" for i in base.get("items", []))
result.append(Stage(key, str(level), row.get("name", key), int(row.get("city", 0)), unlocked, passed, opened,
int(base.get("ti", 0)) + int(info.get("cost", 0)), tickets))
return result
+32
View File
@@ -0,0 +1,32 @@
"""Per-role purchase accounting, recorded before sending a non-retryable buy."""
from datetime import datetime, timedelta, timezone
import json
from pathlib import Path
class PurchaseBudget:
def __init__(self, path=None):
self.path = Path(path) if path else None
self.state = {"day": "", "spent": 0}
if self.path and self.path.exists():
self.state = json.loads(self.path.read_text(encoding="utf-8"))
if not isinstance(self.state.get("day"), str) or int(self.state["spent"]) < 0:
raise ValueError("购蛋额度记录无效")
def spent(self, now):
day = datetime.fromtimestamp(now, timezone(timedelta(hours=8))).strftime("%Y-%m-%d")
return int(self.state["spent"]) if self.state["day"] == day else 0
def remaining(self, now, limit):
return max(0, int(limit) - self.spent(now))
def record(self, now, cost, limit):
if cost <= 0 or cost > self.remaining(now, limit):
raise ValueError("购蛋花费超过今日剩余额度")
state = {"day": datetime.fromtimestamp(now, timezone(timedelta(hours=8))).strftime("%Y-%m-%d"), "spent": self.spent(now) + cost}
if self.path:
self.path.parent.mkdir(parents=True, exist_ok=True)
temporary = self.path.with_suffix(".tmp")
temporary.write_text(json.dumps(state), encoding="utf-8")
temporary.replace(self.path)
self.state = state
+503
View File
@@ -0,0 +1,503 @@
from __future__ import annotations
from dataclasses import asdict, dataclass, field, replace
import csv
import json
import math
from pathlib import Path
import time
WIKI = "https://wiki.biligame.com/myrzx/魔物收益表"
def seconds(value):
value = float(value or 0)
return value / 1000 if value > 100_000_000_000 else value
def duration(value):
if value is None:
return "未知"
value = max(0, int(value))
return f"{value // 3600:02}:{value // 60 % 60:02}:{value % 60:02}"
class Catalog:
def __init__(self, path=None):
self.data = json.loads(Path(path or Path(__file__).with_name("data") / "catalog.json").read_text(encoding="utf-8"))
self.monsters = self.data["monster_info"]
self.overrides = {}
def monster(self, type_id):
return self.monsters.get(str(type_id), {}) | self.overrides.get(str(type_id), {})
def import_prices(self, path):
path = Path(path)
if path.suffix.lower() == ".xlsx":
import openpyxl
workbook = openpyxl.load_workbook(path, read_only=True, data_only=True)
rows = iter(workbook.active.values)
headers = next(rows)
records = [dict(zip(headers, row)) for row in rows]
workbook.close()
else:
with path.open(encoding="utf-8-sig", newline="") as stream:
records = list(csv.DictReader(stream))
aliases = {"编号": "typeId", "魔物ID": "typeId", "派遣金币": "sell_money", "强化经验": "sell_exp", "孵化秒数": "time_total"}
changes = {}
for row in records:
row = {aliases.get(k, k): v for k, v in row.items()}
key = str(int(row["typeId"]))
if key not in self.monsters:
raise ValueError(f"未知魔物编号 {key}")
changes[key] = {k: float(row[k]) for k in ("sell_money", "sell_exp", "time_total") if row.get(k) not in (None, "")}
self.overrides.update(changes)
return len(changes)
def total_time(self, type_id):
row = self.monster(type_id)
return row.get("time_total", row.get("time_1", 0) + row.get("time_2", 0))
def quality(self, row):
if row.get("process") == 2 and int(row.get("mode") or 0) < 2:
return [None] * 4
table = self.monster(row.get("typeId"))
result = []
for stat in ("atk", "def", "hp", "dex"):
value = row.get("g" + stat.capitalize())
low, high = table.get(stat + "_grow_min"), table.get(stat + "_grow_max")
if value is None or low is None or high is None or high <= low:
result.append(None)
continue
value = float(f"{float(value):.3f}")
if not math.isfinite(value) or value < low - 0.001:
result.append(None)
continue
scale = (value - low) / (high - low)
result.append(min(4, max(1, math.floor(round(scale * 4, 10)) + 1)))
return result
def quality_text(self, row):
if row.get("process") == 2 and int(row.get("mode") or 0) < 2:
return "待成熟后生成"
values = self.quality(row)
if all(q is None for q in values):
return "资质待同步"
return "/".join("?" if q is None else "CBAS"[q - 1] for q in values)
def feed_exp(self, mon):
row = self.monster(mon.get("typeId"))
return int(row.get("sell_exp", 0)) + int(float(mon.get("exp", 0)) * self.data["game_setting"].get("monExpScale", 0.2))
def max_level(self, mon):
info = self.data.get("potential_info", {})
potential = mon.get("potentialLevel")
if potential is None or not 1 <= int(potential) <= int(info.get("maxPotentialLevel", 0)):
return None
increment = int(info.get("potentialLevelMaxAdd", 0))
return int(potential) * increment if increment > 0 else None
def markets_for(self, type_id):
return [key for key, market in self.data.get("markets", {}).items()
if str(type_id) in {str(t) for pool in (market.get("eggs") or {}).values() for t in pool}]
def reference_stats(self, mon):
if mon.get("process") == 2 and any(q is None for q in self.quality(mon)):
return ["?"] * 4
row = self.monster(mon.get("typeId"))
level = int(mon.get("level") or 1) + min(4, int(mon.get("tpLevel") or 0)) - 1
bonus = min(200, max(0, int(mon.get("feel") or 0))) / 2000
bonus += float(self.data["game_setting"].get("upStarAdd", 0)) * int(mon.get("upStar") or 0)
result = []
for stat in ("atk", "def", "hp", "dex"):
grow = mon.get("g" + stat.capitalize())
if row.get(stat) is None or grow is None:
result.append("?")
else:
base = float(row[stat]) + float(grow) * level + float(mon.get("p" + stat.capitalize()) or 0)
result.append(int(base * (1 + bonus)))
return result
def likes_text(self, type_id):
likes = self.monster(type_id).get("like") or {}
names = self.data.get("item_names", {})
return "、".join(f"{names.get(str(key), str(key))}(+{value})" for key, value in sorted(likes.items(), key=lambda pair: pair[1], reverse=True) if value > 0) or "无已知偏好"
@dataclass
class Snapshot:
raw: dict
received_at: float = field(default_factory=time.time)
server_offset: float = 0
def __post_init__(self):
if not isinstance(self.raw.get("master"), dict):
raise ValueError("角色快照缺少 master")
for name in ("stacks", "monsters", "items", "rooms", "teams"):
if not isinstance(self.raw.get(name), list):
raise ValueError(f"角色快照缺少 {name} 数组")
self.raw = dict(self.raw)
for name in ("history", "activityHistory"):
if self.raw.get(name) is None:
self.raw[name] = {}
for name in ("currentTasks", "exploreTeams"):
if self.raw.get(name) is None:
self.raw[name] = []
@property
def now(self):
return time.time() + self.server_offset
@property
def monsters(self):
return {int(m["id"]): m for m in self.raw["monsters"]}
@property
def team_ids(self):
return {int(mid) for t in self.raw["teams"] for mid in (t.get("monsters") or []) if mid}
def city_unlocked(self, city):
value = self.raw.get("history", {}).get("unlockCity")
if isinstance(value, dict):
return bool(value.get(str(city), value.get(city, False)))
if isinstance(value, list):
if value and all(v is None or isinstance(v, bool) for v in value):
return str(city).isdigit() and int(city) < len(value) and value[int(city)] is True
return str(city) in {str(v) for v in value if isinstance(v, (str, int)) and not isinstance(v, bool)}
return False
def eggs(self, catalog):
return [e for e in self.raw["items"] if str(e.get("typeId")) in catalog.monsters and int(e.get("num", 0)) > 0]
def remaining(self, mon, catalog):
total = catalog.total_time(mon.get("typeId"))
start = seconds(mon.get("timeStart"))
return max(0, start + total - self.now) if total and start > 0 else None
def expected_growth_mode(self, mon, catalog):
mode = int(mon.get("mode") or 0)
start = seconds(mon.get("timeStart"))
row = catalog.monster(mon.get("typeId"))
total = catalog.total_time(mon.get("typeId"))
if mon.get("process") != 2 or start <= 0 or not total:
return mode
elapsed = self.now - start
stage = 0 if elapsed < float(row.get("time_1") or 0) else 1 if elapsed < total else 2
return max(mode, stage)
def growth_pending(self, catalog):
pending = []
for mon in self.raw["monsters"]:
if mon.get("process") != 2:
continue
mode = int(mon.get("mode") or 0)
expected = self.expected_growth_mode(mon, catalog)
if expected > mode or mode == 2 and any(q is None for q in catalog.quality(mon)):
pending.append((int(mon["id"]), mode, expected))
return pending
def phase_text(self, mon, catalog):
mode = int(mon.get("mode") or 0)
expected = self.expected_growth_mode(mon, catalog)
if expected > mode:
return "成熟待同步" if expected == 2 else "孵化结束,待同步成长"
if mode == 2 and any(q is None for q in catalog.quality(mon)):
return "资质待同步"
return {0: "孵化中", 1: "幼体成长", 2: "已成熟"}.get(mode, "未知阶段")
def room_available(self, catalog, preferred=0):
for room in self.raw["rooms"]:
if preferred and int(room["id"]) != preferred:
continue
table = catalog.data["room_info"].get(str(room.get("typeId")), {})
used = sum(m.get("process") == 3 and int(m.get("roomId") or 0) == int(room["id"]) for m in self.raw["monsters"])
if used < int(table.get("maxNum") or 0):
return int(room["id"])
return None
@dataclass
class EggRule:
enabled: bool = False
priority: int = 100
action: str = "sell"
refill_below: int = 1
refill_target: int = 10
market_id: str = ""
def __post_init__(self):
if self.action not in ("sell", "feed", "keep") or not 1 <= self.priority <= 999:
raise ValueError("魔物蛋规则的优先级或孵化后去向无效")
if not 0 <= self.refill_below <= 1000 or not max(1, self.refill_below) <= self.refill_target <= 1000:
raise ValueError("补货目标不能低于补货下限,0下限表示不自动补货")
@dataclass
class Policy:
enabled: bool = True
strategy: str = "wiki"
protect_star: int = 3
protect_quality: int = 3
reserved_types: list[int] = field(default_factory=list)
reserved_eggs: dict[str, int] = field(default_factory=dict)
feed_target: int = 0
target_level: int = 70
room_id: int = 0
coins_per_exp: float = 5.0
fill: bool = True
egg_order: str = "shortest"
min_gold_per_hour: float = 0
min_exp_per_hour: float = 0
collect: bool = True
dispatch: bool = True
feed: bool = True
hatch_max_star: int = 5
buy: bool = False
market_id: str = "sc_city1"
egg_stock: int = 12
buy_batch: int = 5
buy_ten: bool = True
keep_money: int = 1000
daily_buy_money: int = 5000
manual_eggs: bool = False
egg_rules: dict[str, dict] = field(default_factory=dict)
feed_targets: dict[str, int] = field(default_factory=dict)
def __post_init__(self):
self.egg_rules = {str(int(key)): asdict(EggRule(**rule)) for key, rule in self.egg_rules.items()}
self.feed_targets = {str(int(key)): int(priority) for key, priority in self.feed_targets.items() if int(key) > 0 and 1 <= int(priority) <= 999}
@dataclass
class Action:
kind: str
description: str
path: str
payload: dict
class Planner:
def __init__(self, catalog):
self.catalog = catalog
self.managed = set()
self.notes = []
self.restocking = set()
self.statuses = {}
def protected(self, mon, snapshot, policy):
return bool(self.protection_reason(mon, snapshot, policy))
def protection_reason(self, mon, snapshot, policy):
row = self.catalog.monster(mon.get("typeId"))
qualities = self.catalog.quality(mon)
for condition, reason in ((not row, "魔物资料未知"), (int(mon["id"]) in snapshot.team_ids, "在队魔物"),
(mon.get("lock"), "已锁定"), (mon.get("sysLock"), "系统锁定"), (mon.get("entangle"), "羁绊魔物"),
(mon.get("inExploreTeam"), "正在探索"), (mon.get("inBuild"), "正在建筑中"),
(any(mon.get(f"equip{i}", 0) for i in range(1, 6)), "携带装备"),
(int(mon["id"]) == policy.feed_target or str(mon["id"]) in policy.feed_targets, "已选为喂养目标"),
(str(mon.get("typeId")) in {str(t) for t in policy.reserved_types}, "保留种类或委托保留"),
(row.get("star", 0) >= policy.protect_star, f"{row.get('star', '?')}星达到保留星级{policy.protect_star}"),
(any(q is None for q in qualities), "资质尚未确定 / 未同步")):
if condition:
return reason
quality = math.ceil(sum(qualities) / 4)
if quality >= policy.protect_quality:
return f"综合资质{'CBAS'[quality - 1]}达到保留资质{'CBAS'[policy.protect_quality - 1]}"
return ""
def disposition(self, mon, snapshot, policy):
if self.protected(mon, snapshot, policy):
return "keep"
if policy.manual_eggs:
rule = policy.egg_rules.get(str(mon["typeId"]), {})
return rule.get("action", "keep") if rule.get("enabled") else "keep"
if policy.strategy == "keep":
return "keep"
if policy.strategy in ("gold", "experience"):
return "sell" if policy.strategy == "gold" else "feed"
money = self.catalog.monster(mon["typeId"]).get("sell_money", 0)
exp = self.catalog.feed_exp(mon)
return "feed" if exp > 0 and money / exp < policy.coins_per_exp else "sell"
def feeding_target(self, snapshot, policy):
ids = [int(key) for key, _ in sorted(policy.feed_targets.items(), key=lambda pair: pair[1])] if policy.feed_targets else [policy.feed_target]
reason = "未选择牧场中的喂养目标"
for mid in ids:
target = snapshot.monsters.get(mid)
if not target or target.get("process") != 3:
continue
cap = self.catalog.max_level(target)
if cap is None:
reason = "目标突破上限未知,暂停喂养"
continue
limit = min(policy.target_level, cap)
level = int(target.get("level", 1))
reason = f"目标 #{mid} Lv.{level};当前突破上限 {cap};喂养停止等级 {limit}"
if level < limit:
return target, reason
return None, reason
def feed_status(self, snapshot, policy):
target, reason = self.feeding_target(snapshot, policy)
return target is not None, reason
def available_eggs(self, snapshot, policy):
reserves = dict(policy.reserved_eggs)
result = []
for egg in snapshot.eggs(self.catalog):
key = str(egg["typeId"])
if policy.manual_eggs and not policy.egg_rules.get(key, {}).get("enabled"):
continue
row = self.catalog.monster(egg["typeId"])
hours = self.catalog.total_time(egg["typeId"]) / 3600
if not hours or egg.get("lock") or egg.get("feedLock"):
continue
if not policy.manual_eggs and (int(row.get("star", 99)) > policy.hatch_max_star or
row.get("sell_money", 0) / hours < policy.min_gold_per_hour and row.get("sell_exp", 0) / hours < policy.min_exp_per_hour):
continue
held = min(int(egg["num"]), max(0, int(reserves.get(key, 0))))
reserves[key] = max(0, int(reserves.get(key, 0)) - held)
count = int(egg["num"]) - held
if count:
result.append((egg, count))
return result
def manual_purchase(self, snapshot, policy, daily_left):
stocks = {}
for egg, count in self.available_eggs(snapshot, policy):
key = str(egg["typeId"])
stocks[key] = stocks.get(key, 0) + count
rules = [(key, rule) for key, rule in policy.egg_rules.items() if rule["enabled"] and rule["refill_below"] > 0]
self.restocking.intersection_update(key for key, _ in rules)
for key, rule in sorted(rules, key=lambda pair: pair[1]["priority"]):
stock = stocks.get(key, 0)
if stock >= rule["refill_target"]:
self.restocking.discard(key)
if stock < rule["refill_below"]:
self.restocking.add(key)
if key not in self.restocking:
continue
market_id = rule["market_id"] or policy.market_id
name = self.catalog.monster(key).get("name", key)
if market_id not in self.catalog.markets_for(key):
self.notes.append(f"{name} 补货暂停:所选市场蛋池不包含它")
continue
buying = replace(policy, manual_eggs=False, market_id=market_id, egg_stock=rule["refill_target"])
actions = self.purchase(snapshot, buying, daily_left, stock=stock)
if actions:
actions[0].description = f"为 {name} 补货(剩{stock},目标{rule['refill_target']}):" + actions[0].description
return actions
return []
def purchase(self, snapshot, policy, daily_left, *, stock=None):
if not policy.buy:
return []
if policy.manual_eggs:
return self.manual_purchase(snapshot, policy, daily_left)
market = self.catalog.data.get("markets", {}).get(policy.market_id)
if not market or not policy.market_id.startswith("sc_city") or int(market.get("ke", -1)) != 0 or int(market.get("money", 0)) <= 0:
self.notes.append("所选市场不是已确认的金币市场,暂停购蛋")
return []
if not snapshot.city_unlocked(market["city"]):
self.notes.append("所选市场城市尚未解锁,暂停购蛋")
return []
if stock is None:
stock = sum(count for _, count in self.available_eggs(snapshot, policy))
missing = max(0, policy.egg_stock - stock)
if not missing:
self.notes.append(f"可孵蛋库存 {stock},已达到补货目标 {policy.egg_stock}")
return []
price = int(market["money"])
money = int(snapshot.raw["master"].get("money", 0))
left = min(max(0, policy.daily_buy_money), daily_left) if daily_left is not None else max(0, policy.daily_buy_money)
affordable = min(int(market.get("max") or 1), max(0, money - policy.keep_money) // price, left // price)
if policy.buy_ten and policy.egg_stock >= 10 and missing >= 10 and affordable >= 10:
count = min(missing, max(10, policy.buy_batch), affordable) // 10 * 10
elif policy.buy_ten and policy.egg_stock >= 10 and stock > 0:
self.notes.append(f"十连等待:可孵蛋库存 {stock},补货缺口 {missing};十连需 {price * 10} 可用金币,保留 {policy.keep_money},额度剩余 {left}")
return []
else:
count = min(missing, max(0, policy.buy_batch), affordable)
if count <= 0:
self.notes.append(f"购蛋暂停:余额需保留 {policy.keep_money} 金币,今日额度剩余 {left}")
return []
return [Action("buy", f"{market['name']}市场{'十连抽蛋' if count == 10 else '购蛋 / 抽蛋'} ×{count},花费 {price * count} 金币(赠蛋以实际返回为准)", "gachaService/gachaGetEggs",
{"id": policy.market_id, "num": count, "voucherNum": 0, "traceInfo": {"money": money, "ke": int(snapshot.raw["master"].get("ke", 0))}})]
def plan(self, snapshot, policy, daily_left=None):
self.notes = []
self.statuses = {}
self.managed.update(int(s["monsterId"]) for s in snapshot.raw["stacks"] if int(s.get("monsterId") or 0) > 0)
if not policy.enabled:
self.notes.append("牧场策略未启用")
return []
if policy.manual_eggs and not any(rule["enabled"] for rule in policy.egg_rules.values()):
self.notes.append("请到“背包魔物蛋”勾选要孵化的蛋,并设置优先级和孵出后的去向")
return []
actions = []
for mon in snapshot.raw["monsters"]:
mid = int(mon["id"])
if mid not in self.managed or mon.get("process") not in (2, 3):
continue
if policy.manual_eggs and not policy.egg_rules.get(str(mon["typeId"]), {}).get("enabled"):
self.statuses[mid] = "该魔物未启用孵蛋规则"
continue
if mon.get("process") == 2 and int(mon.get("mode") or 0) != 2:
self.statuses[mid] = snapshot.phase_text(mon, self.catalog)
if snapshot.expected_growth_mode(mon, self.catalog) > int(mon.get("mode") or 0):
self.notes.append(self.statuses[mid] + ",资质尚未生成")
continue
name = self.catalog.monster(mon["typeId"]).get("name", str(mid))
if mon.get("process") == 2 and any(q is None for q in self.catalog.quality(mon)):
self.statuses[mid] = "资质未同步,等待成长结算;暂不派遣、喂养或收取"
self.notes.append(f"{name}:" + self.statuses[mid])
continue
disposition = self.disposition(mon, snapshot, policy)
reason = self.protection_reason(mon, snapshot, policy) or "手动规则选择保留"
if disposition == "sell" and not policy.dispatch or disposition == "feed" and not policy.feed:
reason = "自动派遣开关已关闭" if disposition == "sell" else "自动喂养开关已关闭"
disposition = "keep"
self.statuses[mid] = "保留:" + reason if disposition == "keep" else "待派遣" if disposition == "sell" else "待喂养"
if disposition == "sell":
key = "monsterId" if mon.get("process") == 2 else "monsterIds"
actions.append(Action("sell", f"派遣 {name} #{mid}", "monsterService/monsterSell", {key: [mid]}))
elif mon.get("process") == 2 and policy.collect:
room = snapshot.room_available(self.catalog, policy.room_id)
if room is not None:
actions.append(Action("collect", f"收取 {name} #{mid} → 牧场 {room}", "stackService/stackTransferMonster", {"datas": [{"monsterId": [mid], "roomId": room}]}))
else:
self.notes.append(f"{name} 等待收取:牧场没有空位")
elif disposition == "feed" and mon.get("process") == 3:
target, reason = self.feeding_target(snapshot, policy)
if target:
actions.append(Action("feed", f"{name} #{mid} → 喂养 #{target['id']}", "monsterService/monsterIntensify", {"targetId": int(target["id"]), "foods": [mid]}))
else:
self.notes.append("暂停喂养:" + reason)
elif disposition == "keep":
self.notes.append(f"{name} 已保留:{reason}")
if actions:
return actions
vip_info = snapshot.raw.get("activityHistory", {}).get("vipInfo") or {}
vip = seconds(vip_info.get("vipTime")) > snapshot.now
empty = [s for s in snapshot.raw["stacks"] if policy.fill and int(s.get("monsterId") or 0) <= 0 and (int(s.get("position", -1)) != 3 or vip)]
eggs = self.available_eggs(snapshot, policy)
def score(entry):
egg, _ = entry
row = self.catalog.monster(egg["typeId"])
total = max(1, self.catalog.total_time(egg["typeId"]))
if policy.manual_eggs:
return (-policy.egg_rules[str(egg["typeId"])]["priority"], -total)
return {"shortest": -total, "gold": row.get("sell_money", 0) / total,
"experience": row.get("sell_exp", 0) / total, "longest": total}[policy.egg_order]
eggs.sort(key=score, reverse=True)
for egg, available in eggs:
row = self.catalog.monster(egg["typeId"])
for slot in empty[:available]:
actions.append(Action("hatch", f"装填 {row.get('name')} → 坑位 {int(slot['position']) + 1}", "stackService/stackAddMonster", {"eggs": [{"itemId": int(egg["id"]), "stackId": int(slot["id"])}]}))
empty = empty[min(available, len(empty)):]
if not empty:
break
if not actions and empty:
self.notes.append("有空坑,当前没有符合已勾选规则和保留数量的蛋" if policy.manual_eggs else "有空坑,当前没有符合星级、收益和保留数量设置的蛋")
if not actions and not self.notes:
self.notes.append("等待孵化 / 成长,成熟后按保护条件处理")
return actions or self.purchase(snapshot, policy, daily_left)
+80
View File
@@ -0,0 +1,80 @@
"""Native number inputs and scrollbars with usable click targets."""
from PySide6 import QtCore as C, QtGui as G, QtWidgets as W
class IntegerInput(W.QLineEdit):
valueChanged = C.Signal(int)
def __init__(self):
super().__init__()
self._value, self._minimum, self._maximum = 0, 0, 2147483647
self.setValidator(G.QIntValidator(self._minimum, self._maximum, self))
self.setText("0")
self.setMinimumWidth(76)
self.textChanged.connect(self.accept_number)
self.editingFinished.connect(self.finish_number)
def value(self):
return self._value
def setValue(self, value):
self.setText(str(min(self._maximum, max(self._minimum, int(value)))))
def setRange(self, minimum, maximum):
self._minimum, self._maximum = int(minimum), int(maximum)
self.validator().setRange(self._minimum, self._maximum)
self.setValue(self._value)
def setMinimum(self, minimum):
self.setRange(minimum, self._maximum)
def accept_number(self, text):
if self.hasAcceptableInput():
value = int(text)
if value != self._value:
self._value = value
self.valueChanged.emit(value)
def finish_number(self):
self.setValue(self._value)
class NativeScrollStyle(W.QProxyStyle):
def pixelMetric(self, metric, option=None, widget=None):
value = super().pixelMetric(metric, option, widget)
if metric == W.QStyle.PixelMetric.PM_ScrollBarExtent:
return max(22, value)
if metric == W.QStyle.PixelMetric.PM_ScrollBarSliderMin:
return max(30, value)
return value
def styleHint(self, hint, option=None, widget=None, returnData=None):
if hint == W.QStyle.StyleHint.SH_ScrollBar_Transient:
return 0
return super().styleHint(hint, option, widget, returnData)
class ScrollbarStyler(C.QObject):
def __init__(self, app):
super().__init__(app)
self.scroll_style = NativeScrollStyle(W.QStyleFactory.create("Fusion"))
self.scroll_style.setParent(self)
def eventFilter(self, widget, event):
if event.type() == C.QEvent.Type.Polish and isinstance(widget, W.QScrollBar) and not getattr(widget, "_ranch_scrollbar", False):
widget._ranch_scrollbar = True
widget.setStyle(self.scroll_style)
if widget.orientation() == C.Qt.Orientation.Horizontal:
widget.setFixedHeight(22)
else:
widget.setFixedWidth(22)
return False
def use_native_scrollbars():
app = W.QApplication.instance()
if app is None or getattr(app, "_ranch_scrollbar_styler", None) is not None:
return
styler = ScrollbarStyler(app)
app._ranch_scrollbar_styler = styler
app.installEventFilter(styler)
+190
View File
@@ -0,0 +1,190 @@
from __future__ import annotations
from dataclasses import dataclass, field
from datetime import datetime, timedelta, timezone
from .model import Action, Planner, seconds
CN = timezone(timedelta(hours=8))
def indexed(value, key, default=None):
if isinstance(value, dict):
return value.get(str(key), value.get(key, default))
if isinstance(value, list) and str(key).isdigit() and int(key) < len(value):
return value[int(key)]
return default
def condition_ok(condition, snapshot):
if not condition:
return True
history = snapshot.raw.get("history", {})
level = int(snapshot.raw["master"].get("level", 0))
def limit(key, default):
value = condition.get(key)
return default if value is None else value
if condition.get("close") or not limit("minLevel", 0) <= level <= limit("maxLevel", 2147483647):
return False
if condition.get("platform", "all") not in (None, "all", "ANDROID") or condition.get("channel", "all") not in (None, "all", "DYD"):
return False
if condition.get("lang", "all") not in (None, "all", "CN", "cn", "chs"):
return False
for key in condition.get("finishTask") or []:
if not indexed(history.get("passTask"), key, False):
return False
active = {str(t["typeId"]) for t in snapshot.raw.get("currentTasks", [])}
for key in condition.get("unfinishTask") or []:
if indexed(history.get("passTask"), key, False) or str(key) in active:
return False
for field, source in (("passStage", "passStage"), ("unlockStage", "unlockStage")):
for key in condition.get(field) or []:
if not indexed(indexed(history.get(source), key), 1, False):
return False
now = datetime.fromtimestamp(snapshot.now, CN)
if condition.get("week") is not None and (now.weekday() + 1) % 7 not in condition["week"]:
return False
hhmm = now.hour * 100 + now.minute
return (limit("startTime", 0) <= hhmm <= limit("endTime", 2400)
and limit("startTimestamp", 0) <= snapshot.now <= limit("endTimestamp", 2147483647))
@dataclass
class QuestPolicy:
enabled: bool = False
accept: bool = True
city: int = 0
allow_items: bool = False
allow_monsters: bool = False
max_money: int = 0
battle_tasks: bool = False
item_reserves: dict[str, int] = field(default_factory=dict)
class TaskPlanner:
def __init__(self, catalog):
self.catalog = catalog
self.guard = Planner(catalog)
def current(self, snapshot):
return [t for t in snapshot.raw.get("currentTasks", []) if str(t.get("typeId")) in self.catalog.data.get("task_info", {})]
def requirement(self, snapshot, step, task, policy, ranch):
if not condition_ok(step.get("condition"), snapshot):
return False, [], "前置条件未满足"
kind, value = step.get("statusType", "none"), step.get("statusValue") or {}
if kind in ("battle", "passStage"):
return False, [], f"需实际战斗:{value.get('stage', '委托战斗')} / 难度 {value.get('level', 1)}"
if step.get("afterStory"):
return False, [], "需在游戏中完成后续剧情"
history = snapshot.raw.get("history", {})
remove = bool(value.get("remove"))
if kind == "none":
return True, [], "可推进对话步骤"
if kind == "getMoney":
amount = max(0, int(value.get("money", 0)))
if remove and amount > policy.max_money:
return False, [], "金币提交超过设置上限"
return int(snapshot.raw["master"].get("money", 0)) >= amount, [], f"需要金币 {amount}"
if kind == "getItem" or kind == "getMonster" and int(value.get("mode", 2)) == 0:
type_id, count = str(value.get("type")), max(0, int(value.get("num", 0)))
reserve = max(int(policy.item_reserves.get(type_id, 0)), int(ranch.reserved_eggs.get(type_id, 0)))
items = [i for i in snapshot.raw["items"] if str(i.get("typeId")) == type_id and not i.get("lock") and not i.get("feedLock")]
if sum(int(i.get("num", 0)) for i in items) - (reserve if remove else 0) < count:
return False, [], f"道具 {type_id} 数量不足(需{count},保留{reserve})"
if remove and not policy.allow_items:
return False, [], "需启用委托提交道具"
ids, total = [], 0
for item in items:
ids.append(int(item["id"]))
total += int(item.get("num", 0))
if total >= count:
break
return True, ids, f"道具 {type_id} × {count}"
if kind == "getMonster":
type_id, count = str(value.get("type")), max(0, int(value.get("num", 0)))
if remove and not policy.allow_monsters:
return False, [], "需启用委托提交魔物"
monsters = [m for m in snapshot.raw["monsters"] if str(m.get("typeId")) == type_id and int(m.get("mode", 0)) == 2
and int(m.get("level", 1)) == 1 and not self.guard.protected(m, snapshot, ranch)]
monsters.sort(key=lambda m: sum(self.catalog.quality(m)))
return len(monsters) >= count, [int(m["id"]) for m in monsters[:count]], f"需要未保护的1级成熟魔物 {type_id} × {count}"
if kind == "killMonster":
target = task.get("stepValue")
kills = int(indexed(history.get("numKillMonsters"), str(value.get("type")), 0))
return target is not None and kills >= int(target), [], f"累计击杀 {kills} / {target if target is not None else '未知'}"
if kind == "passLevel":
return int(snapshot.raw["master"].get("level", 0)) >= int(value.get("level", 0)), [], f"需要等级 {value.get('level')}"
if kind == "unlockMonster":
return int(value.get("type", 0)) in history.get("monLib", []), [], "需要解锁图鉴"
if kind == "sysLock":
return bool(indexed(history.get("guide_record"), value.get("key"), False)), [], "等待游戏条件"
return False, [], "尚未支持的委托条件"
def rows(self, snapshot, policy, ranch):
rows = []
for task in self.current(snapshot):
info = self.catalog.data["task_info"][str(task["typeId"])]
index = int(task.get("curStep", 1)) - 1
steps = info.get("steps", [])
text = "可领取奖励" if index >= len(steps) else self.requirement(snapshot, steps[max(0, index)], task, policy, ranch)[2]
rows.append((str(task["typeId"]), info.get("name", ""), "已接取", text, task))
history = snapshot.raw.get("history", {})
for city, offers in (history.get("loopTask") or {}).items():
if not isinstance(offers, list):
continue
for type_id in offers:
info = self.catalog.data.get("task_info", {}).get(str(type_id), {})
if info:
rows.append((str(type_id), info.get("name", ""), f"城市 {city} 可接", info.get("des", ""), {"city": int(city)}))
return rows
def plan(self, snapshot, policy, ranch):
if not policy.enabled:
return []
history = snapshot.raw.get("history", {})
if "loopTaskTime" in history:
old_day = int((seconds(history["loopTaskTime"]) + 8 * 3600) // 86400)
current_day = int((snapshot.now - 10 + 8 * 3600) // 86400)
if old_day < current_day:
return [Action("quest_reset", "刷新跨日委托", "taskService/taskLoopFlush", {})]
for task in self.current(snapshot):
info = self.catalog.data["task_info"][str(task["typeId"])]
index, steps = int(task.get("curStep", 1)) - 1, info.get("steps", [])
payload = {"taskId": int(task["id"]), "taskTypeId": str(task["typeId"])}
if steps and index >= len(steps):
return [Action("quest_complete", f"领取委托奖励:{info['name']}", "taskService/taskComplete", payload)]
if 0 <= index < len(steps):
ready, ids, _ = self.requirement(snapshot, steps[index], task, policy, ranch)
if ready:
return [Action("quest_step", f"推进委托:{info['name']}", "taskService/taskCompleteStep", payload | {"removeIds": ids or None})]
if not policy.accept or int(history.get("loopTaskNum", 0)) <= 0:
return []
current = {str(t["typeId"]) for t in self.current(snapshot)}
for type_id, name, state, _, meta in self.rows(snapshot, policy, ranch):
if "city" not in meta or type_id in current:
continue
city = meta["city"]
if policy.city and city != policy.city or not snapshot.city_unlocked(city):
continue
info = self.catalog.data["task_info"][type_id]
if info.get("closed") or not condition_ok((info.get("startStep") or {}).get("condition"), snapshot):
continue
steps = info.get("steps", [])
supported = all((s.get("statusType") in ("passStage", "battle") and policy.battle_tasks)
or self.requirement(snapshot, s, {}, policy, ranch)[0] for s in steps)
if supported:
return [Action("quest_accept", f"接取委托:{name}", "taskService/taskLoopReceive", {"taskTypeId": type_id, "city": city})]
return []
def reservations(self, snapshot):
types, eggs = set(), {}
for task in self.current(snapshot):
info = self.catalog.data["task_info"][str(task["typeId"])]
for step in info.get("steps", [])[max(0, int(task.get("curStep", 1)) - 1):]:
value = step.get("statusValue") or {}
key = str(value.get("type", ""))
if step.get("statusType") == "getMonster" and int(value.get("mode", 2)) != 0 and key.isdigit():
types.add(int(key))
elif step.get("statusType") in ("getItem", "getMonster") and key in self.catalog.monsters:
eggs[key] = eggs.get(key, 0) + max(0, int(value.get("num", 0)))
return types, eggs
+5
View File
@@ -0,0 +1,5 @@
PySide6>=6.8,<7
requests>=2.32,<3
cryptography>=43
Pillow>=11
openpyxl>=3.1,<4
+6
View File
@@ -0,0 +1,6 @@
{
"server_url": "",
"token": "",
"reqid": 0,
"reqsid": 0
}
+68
View File
@@ -0,0 +1,68 @@
"""Per-account and per-role encrypted sessions, including request high-water marks."""
import base64
from dataclasses import asdict
from datetime import datetime, timedelta, timezone
import hashlib
import json
from pathlib import Path
import threading
from .api import Session
from .credentials import crypt
def identity(session):
owner = session.account_id or session.server_url.rstrip("/")
raw = json.dumps([owner, session.channel, session.platform, session.server_id, session.role_id], separators=(",", ":"))
return hashlib.sha256(raw.encode()).hexdigest()
class SessionStore:
def __init__(self, root):
self.folder = Path(root) / "sessions"
self.lock = threading.RLock()
def save(self, session, label):
if not session.token or not session.server_url or not session.role_id:
return None
key = identity(session)
payload = json.dumps(asdict(session), ensure_ascii=False).encode("utf-8")
record = {"schema": 1, "session_id": key, "label": label,
"saved_at": datetime.now(timezone(timedelta(hours=8))).isoformat(timespec="seconds"),
"protected": base64.b64encode(crypt(payload)).decode("ascii")}
with self.lock:
self.folder.mkdir(parents=True, exist_ok=True)
path = self.folder / (key + ".json")
temporary = path.with_suffix(".tmp")
temporary.write_text(json.dumps(record, ensure_ascii=False, indent=2), encoding="utf-8")
temporary.replace(path)
return key
def entries(self):
result = []
with self.lock:
for path in self.folder.glob("*.json"):
try:
record = json.loads(path.read_text(encoding="utf-8"))
if record.get("schema") == 1 and record.get("session_id") == path.stem:
result.append({k: record[k] for k in ("session_id", "label", "saved_at")})
except (OSError, ValueError, KeyError):
continue
return sorted(result, key=lambda record: record["saved_at"], reverse=True)
def load(self, key):
if not isinstance(key, str) or len(key) != 64 or any(c not in "0123456789abcdef" for c in key):
raise ValueError("无效的会话编号")
with self.lock:
record = json.loads((self.folder / (key + ".json")).read_text(encoding="utf-8"))
payload = crypt(base64.b64decode(record["protected"], validate=True), decrypt=True)
session = Session(**json.loads(payload))
if identity(session) != key or not session.role_id or not session.token:
raise ValueError("保存的账号/区服/角色信息不一致")
return session
def remove(self, key):
# load() validates the identifier before constructing any removable path.
self.load(key)
with self.lock:
(self.folder / (key + ".json")).unlink()
+259
View File
@@ -0,0 +1,259 @@
import copy
import json
import os
import time
os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
from types import SimpleNamespace
import unittest
from unittest.mock import patch
import requests
from PySide6 import QtCore as C, QtGui as G, QtWidgets as W
from PySide6.QtTest import QTest
from ranch_assistant import gui
from ranch_assistant.accounts_gui import AccountsWindow
from ranch_assistant.api import ApiError, Client, Session, decode, encode
from ranch_assistant.engine import Engine, demo_snapshot
from ranch_assistant.model import Catalog, Snapshot
from ranch_assistant.sessions import SessionStore, identity
from ranch_assistant.tests.test_core import workspace_temp
def role_snapshot(catalog, role_id):
raw = demo_snapshot(catalog).raw
raw["master"].update(id=role_id, roleName=f"测试角色 {role_id}")
raw["activityHistory"]["vipInfo"] = None
raw["stacks"] = raw["stacks"][:4]
for slot in raw["stacks"]:
slot["monsterId"] = 0
raw["monsters"] = raw["monsters"][:4]
for mon in raw["monsters"]:
mon.update(process=3, mode=2, roomId=1)
raw["items"] = raw["items"][:4]
return raw
def fake_client(session, catalog, calls):
client = Client(session)
def post(url, data, **kwargs):
body = decode(data, session.key)
calls.append((session.account_id, url, body))
raw = role_snapshot(catalog, session.role_id)
return SimpleNamespace(status_code=200, content=encode(raw | {"resCode": 0}, session.key), headers={})
client.http.post = post
return client
class SessionTests(unittest.TestCase):
def test_encrypted_sessions_are_isolated_by_owner_region_and_role(self):
with workspace_temp() as folder:
store = SessionStore(folder)
first = Session("http://127.0.0.1/a/", "private-token-a", account_id="account-a", server_id=1, role_id=101, reqid=5, reqsid=7)
second = Session("http://127.0.0.1/b/", "private-token-b", account_id="account-b", server_id=1, role_id=202)
other_region = copy.deepcopy(first)
other_region.server_id, other_region.role_id = 2, 303
keys = [store.save(s, "测试会话") for s in (first, second, other_region)]
self.assertEqual(len(set(keys)), 3)
self.assertEqual(store.load(keys[0]), first)
first.reqid = 9
store.save(first, "测试会话")
self.assertEqual(len(store.entries()), 3)
self.assertEqual(store.load(keys[0]).reqid, 9)
for path in store.folder.glob("*.json"):
text = path.read_text(encoding="utf-8")
self.assertNotIn("private-token", text)
self.assertNotIn(first.key, text)
with self.assertRaises(ValueError):
store.load("../credentials")
def test_failed_request_persists_advanced_counters_without_retry(self):
with workspace_temp() as folder:
store = SessionStore(folder)
session = Session("http://127.0.0.1/", "private-token", account_id="account-a", server_id=1, role_id=101)
client = Client(session, on_session_change=lambda current: store.save(current, "测试会话"))
try:
with patch.object(client.http, "post", side_effect=requests.Timeout()) as post:
with self.assertRaises(ApiError):
client.call("masterService/masterQueryDetail")
self.assertEqual(post.call_count, 1)
restored = store.load(identity(session))
self.assertEqual((restored.reqid, restored.reqsid), (1, 1))
finally:
client.close()
def test_resume_rejects_another_role_before_any_strategy_runs(self):
catalog = Catalog()
session = Session("http://127.0.0.1/", "private-token", role_id=101)
client = Client(session)
response = SimpleNamespace(status_code=200, content=encode(role_snapshot(catalog, 202) | {"resCode": 0}, session.key), headers={})
try:
with patch.object(client.http, "post", return_value=response):
with self.assertRaisesRegex(ApiError, "其他角色"):
client.snapshot()
self.assertEqual(session.role_id, 101)
finally:
client.close()
class AccountGuiTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.app = W.QApplication.instance() or W.QApplication([])
def wait(self, windows):
for _ in range(300):
self.app.processEvents()
QTest.qWait(5)
if all(not window.busy and window.slots.rowCount() for window in windows):
return
self.fail("Account workers did not complete")
def connect(self, window, owner, region, role_id, calls):
window.account.setText(owner)
session = Session("http://127.0.0.1/game/", f"test-token-{owner}", account_id=owner,
account_name=owner, server_id=region, role_id=role_id)
client = fake_client(session, window.catalog, calls)
window.result("connected", (client, Snapshot(role_snapshot(window.catalog, role_id))))
return client
def test_closed_fresh_tab_does_not_start_queued_refresh_and_can_reopen(self):
with workspace_temp() as folder:
hub = AccountsWindow(folder)
hub.add_profile()
profile = hub.profiles[-1]
try:
hub.close_profile(hub.tabs.count() - 1)
self.wait(list(hub.windows.values()))
self.assertEqual(hub.tabs.count(), 1)
hub.open_profile(profile)
self.wait(list(hub.windows.values()))
self.assertEqual(hub.tabs.count(), 2)
finally:
hub.close()
def test_failed_resume_saves_counters_before_response_and_keeps_execution_off(self):
with workspace_temp() as folder:
window = gui.Window(folder)
window.timer.stop()
try:
self.wait([window])
session = Session("http://127.0.0.1/", "private-resume-token", account_id="account-a", server_id=1, role_id=101)
key = window.session_store.save(session, "测试账号 / 区服 1 / 测试角色")
window.reload_saved_sessions()
def failing_client(current, **kwargs):
client = Client(current, **kwargs)
client.http.post = lambda *args, **kwargs: (_ for _ in ()).throw(requests.Timeout())
return client
with patch.object(gui, "Client", side_effect=failing_client):
window.resume_session()
self.wait([window])
self.assertEqual(window.session_store.load(key).reqid, 1)
self.assertFalse(window.execute.isChecked())
self.assertTrue(window.engine.demo)
finally:
window.close()
def test_two_accounts_run_independently_restore_and_right_click_read_only(self):
with workspace_temp() as folder:
hub = AccountsWindow(folder)
hub.add_profile()
windows = list(hub.windows.values())
for window in windows:
window.timer.stop()
calls = []
try:
self.wait(windows)
first, second = windows
self.connect(first, "account-a", 1, 101, calls)
self.connect(second, "account-b", 2, 202, calls)
self.assertNotEqual(first.state, second.state)
self.assertIsNot(first.pool, second.pool)
self.assertEqual([first.slots.rowCount(), first.eggs.rowCount(), first.monsters.rowCount(), first.rooms_table.rowCount()], [11, 4, 4, 1])
self.assertEqual(first.saved_sessions.count(), 1)
first.start_monitor.setChecked(True)
hub.tabs.setCurrentWidget(second)
self.assertTrue(first.monitoring)
hub.monitor_all()
for window in windows:
window.engine.last_heartbeat = time.monotonic()
window.next_poll = 0
window.schedule()
self.wait(windows)
self.assertEqual({owner for owner, _, _ in calls}, {"account-a", "account-b"})
self.assertEqual(first.engine.client.session.token, "test-token-account-a")
self.assertEqual(second.engine.client.session.token, "test-token-account-b")
self.assertEqual(first.engine.snapshot.raw["master"]["id"], 101)
self.assertEqual(second.engine.snapshot.raw["master"]["id"], 202)
first.execute.setChecked(True)
before = len(calls)
hub.tabs.setCurrentWidget(first)
first.tabs.setCurrentWidget(first.egg_page)
point = C.QPoint(3, 3)
event = G.QContextMenuEvent(G.QContextMenuEvent.Reason.Mouse, point, first.eggs.viewport().mapToGlobal(point))
self.app.sendEvent(first.eggs.viewport(), event)
self.app.processEvents()
self.assertEqual(first.refresh_menu.actions()[0].text(), "刷新本页")
first.refresh_menu.actions()[0].trigger()
first.refresh_menu.close()
self.wait(windows)
self.assertGreater(len(calls), before)
self.assertTrue(all(url.endswith("masterService/masterQueryDetail") for _, url, _ in calls[before:]))
self.assertFalse(first.engine.auto)
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_connection(second, first.engine.client.session))
finally:
hub.close()
restored = AccountsWindow(folder)
restarted = list(restored.windows.values())
for window in restarted:
window.timer.stop()
try:
self.wait(restarted)
self.assertEqual(len(restarted), 2)
self.assertTrue(all(window.saved_sessions.count() == 1 for window in restarted))
with patch.object(gui, "Client", side_effect=lambda session, **kwargs: fake_client(session, restarted[0].catalog, calls)):
restored.resume_all()
self.wait(restarted)
self.assertEqual({window.engine.snapshot.raw["master"]["id"] for window in restarted}, {101, 202},
"\n".join(window.log.toPlainText() for window in restarted))
self.assertTrue(all(not window.engine.demo and not window.execute.isChecked() and not window.monitoring for window in restarted))
finally:
restored.close()
def test_role_switch_restores_own_strategy_and_heartbeat_uses_normal_api(self):
with workspace_temp() as folder:
window = gui.Window(folder)
window.timer.stop()
calls = []
try:
self.wait([window])
self.connect(window, "account-a", 1, 101, calls)
first_state = window.state
window.strategy.setCurrentIndex(window.strategy.findData("gold"))
self.connect(window, "account-a", 2, 202, calls)
self.assertNotEqual(window.state, first_state)
self.assertEqual(window.strategy.currentData(), "wiki")
self.connect(window, "account-a", 1, 101, calls)
self.assertEqual(window.state, first_state)
self.assertEqual(window.strategy.currentData(), "gold")
self.assertEqual(window.saved_sessions.count(), 2)
window.engine.last_heartbeat = 0
window.schedule()
self.wait([window])
self.assertTrue(calls[-1][1].endswith("heartBeatService/keepAlive"))
count = len(calls)
window.schedule()
self.app.processEvents()
self.assertEqual(len(calls), count)
finally:
window.close()
if __name__ == "__main__":
unittest.main()
+441
View File
@@ -0,0 +1,441 @@
import copy
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
import json
import os
from pathlib import Path
import threading
import time
import unittest
from unittest.mock import Mock, patch
from dataclasses import asdict, replace
os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
from PySide6.QtTest import QTest
from PySide6.QtWidgets import QApplication
from ranch_assistant.api import ApiError, Client, DEFAULT_KEY, Session, decode, encode
from ranch_assistant.engine import Engine, demo_snapshot
from ranch_assistant.market import PurchaseBudget
from ranch_assistant.model import Catalog, EggRule, Planner, Policy, Snapshot
from ranch_assistant import gui
from ranch_assistant.tests.test_core import workspace_temp
class AutomationTests(unittest.TestCase):
def setUp(self):
self.catalog = Catalog()
self.snapshot = demo_snapshot(self.catalog)
self.snapshot.raw["monsters"] = []
self.snapshot.raw["stacks"] = [{"id": 1, "position": 0, "monsterId": 0}]
self.snapshot.raw["items"] = []
self.planner = Planner(self.catalog)
self.policy = Policy(strategy="gold", buy=True, protect_star=4, protect_quality=5,
hatch_max_star=3, egg_stock=3, buy_batch=2, keep_money=1000, daily_buy_money=1000)
def test_market_city_price_and_nonpremium_payload(self):
action = self.planner.plan(self.snapshot, self.policy)[0]
self.assertEqual(action.kind, "buy")
self.assertEqual(action.payload, {"id": "sc_city1", "num": 2, "voucherNum": 0,
"traceInfo": {"money": 12345, "ke": 2000}})
self.assertEqual(self.catalog.data["markets"]["sc_city1"]["money"], 100)
self.assertEqual(self.catalog.total_time(1001010), 600)
self.policy.market_id = "sc_city7"
self.assertEqual(self.planner.plan(self.snapshot, self.policy), [])
# The shipped table has legacy city=4; the actual market UI uses city 7.
self.snapshot.raw["history"]["unlockCity"] = {"7": True}
self.assertEqual(self.planner.plan(self.snapshot, self.policy)[0].payload["id"], "sc_city7")
self.policy.market_id = "ke"
self.assertEqual(self.planner.plan(self.snapshot, self.policy), [])
def test_buy_limits_reserve_balance_daily_and_stock(self):
self.snapshot.raw["master"]["money"] = 1150
self.assertEqual(self.planner.plan(self.snapshot, self.policy, 500)[0].payload["num"], 1)
self.assertEqual(self.planner.plan(self.snapshot, self.policy, 99), [])
self.snapshot.raw["master"]["money"] = 1000
self.assertEqual(self.planner.plan(self.snapshot, self.policy), [])
self.snapshot.raw["master"]["money"] = 10000
self.snapshot.raw["items"] = [{"id": 501, "typeId": 1001010, "num": 3}]
self.policy.fill = False
self.assertEqual(self.planner.plan(self.snapshot, self.policy), [])
self.policy.reserved_eggs = {"1001010": 1}
self.assertEqual(self.planner.plan(self.snapshot, self.policy)[0].payload["num"], 1)
self.policy.enabled = False
self.assertEqual(self.planner.plan(self.snapshot, self.policy), [])
def test_city_unlock_accepts_recorded_id_lists_and_legacy_maps(self):
for value in (["1"], [1], {"1": True}, [False, True]):
self.snapshot.raw["history"]["unlockCity"] = value
self.assertTrue(self.snapshot.city_unlocked(1))
self.assertEqual(self.planner.plan(self.snapshot, self.policy)[0].kind, "buy")
self.assertFalse(self.snapshot.city_unlocked(2))
self.snapshot.raw["history"]["unlockCity"] = []
self.assertEqual(self.planner.plan(self.snapshot, self.policy), [])
def test_shortest_hatching_precedes_buying_and_excludes_high_stars(self):
high = next(int(k) for k, r in self.catalog.monsters.items() if r.get("star") == 5 and self.catalog.total_time(k) > 0)
slow = next(int(k) for k, r in self.catalog.monsters.items() if r.get("star") == 1 and self.catalog.total_time(k) > 600)
self.snapshot.raw["items"] = [{"id": 501, "typeId": slow, "num": 1},
{"id": 502, "typeId": 1001010, "num": 1}, {"id": 503, "typeId": high, "num": 10}]
self.assertEqual(self.planner.plan(self.snapshot, self.policy)[0].payload["eggs"][0]["itemId"], 502)
self.snapshot.raw["items"] = [self.snapshot.raw["items"][-1]]
self.assertTrue(all(a.kind != "hatch" for a in self.planner.plan(self.snapshot, self.policy)))
def test_official_negative_empty_slots_hatch_existing_eggs_before_buy(self):
self.snapshot.raw["stacks"] = [{"id": i + 1, "position": i, "monsterId": -1} for i in range(4)]
self.snapshot.raw["items"] = [{"id": 501, "typeId": 1001010, "num": 6}]
plans = self.planner.plan(self.snapshot, self.policy)
self.assertEqual([a.kind for a in plans], ["hatch"] * 3)
self.assertEqual([a.payload["eggs"][0]["stackId"] for a in plans], [1, 2, 3])
self.assertNotIn(-1, self.planner.managed)
def test_reserve_count_spans_multiple_inventory_rows(self):
self.snapshot.raw["items"] = [{"id": i, "typeId": 1001010, "num": 1} for i in (501, 502, 503)]
self.policy.reserved_eggs = {"1001010": 2}
self.snapshot.raw["stacks"] += [{"id": 2, "position": 1, "monsterId": 0}]
plans = self.planner.plan(self.snapshot, self.policy)
self.assertEqual([a.kind for a in plans], ["hatch"])
self.assertEqual(plans[0].payload["eggs"][0]["itemId"], 503)
def test_ten_draw_waits_for_stock_gap_and_honors_money_limits(self):
self.policy.egg_stock, self.policy.buy_batch = 12, 5
self.policy.fill = False
self.assertEqual(self.planner.plan(self.snapshot, self.policy)[0].payload["num"], 10)
self.snapshot.raw["items"] = [{"id": 501, "typeId": 1001010, "num": 11}]
self.assertEqual(self.planner.plan(self.snapshot, self.policy), [])
self.snapshot.raw["items"][0]["num"] = 2
self.assertEqual(self.planner.plan(self.snapshot, self.policy)[0].payload["num"], 10)
self.snapshot.raw["master"]["money"] = 1900
self.assertEqual(self.planner.plan(self.snapshot, self.policy), [])
self.snapshot.raw["items"] = []
self.assertLess(self.planner.plan(self.snapshot, self.policy)[0].payload["num"], 10)
self.snapshot.raw["master"]["money"] = 12345
self.policy.buy_ten = False
self.assertEqual(self.planner.plan(self.snapshot, self.policy)[0].payload["num"], 5)
def test_independent_dispatch_collection_and_feeding_switches(self):
snapshot = demo_snapshot(self.catalog)
policy = Policy(strategy="gold", fill=False, dispatch=False, collect=False)
self.assertEqual(self.planner.plan(snapshot, policy), [])
policy.collect = True
self.assertTrue(all(a.kind == "collect" for a in self.planner.plan(snapshot, policy)))
policy.dispatch = True
self.assertTrue(all(a.kind == "sell" for a in self.planner.plan(snapshot, policy)))
policy.strategy, policy.feed, policy.feed_target = "experience", False, 900
mon = snapshot.raw["monsters"][0]
mon["process"] = 3
snapshot.raw["stacks"][0]["monsterId"] = 0
self.assertFalse(any(a.kind == "feed" for a in self.planner.plan(snapshot, policy)))
def test_feed_uses_actual_breakthrough_cap_and_unknown_stops(self):
snapshot = demo_snapshot(self.catalog)
policy = Policy(strategy="experience", fill=False, feed_target=900, target_level=70)
mon = snapshot.raw["monsters"][0]
self.planner.managed.add(mon["id"])
mon.update(process=3, roomId=1)
target = snapshot.monsters[900]
target.update(level=20, potentialLevel=2)
self.assertFalse(any(a.kind == "feed" for a in self.planner.plan(snapshot, policy)))
self.assertIn("上限 20", self.planner.feed_status(snapshot, policy)[1])
target["level"] = 19
self.assertTrue(any(a.kind == "feed" for a in self.planner.plan(snapshot, policy)))
policy.target_level = 19
self.assertFalse(any(a.kind == "feed" for a in self.planner.plan(snapshot, policy)))
policy.target_level = 70
del target["potentialLevel"]
self.assertFalse(any(a.kind == "feed" for a in self.planner.plan(snapshot, policy)))
self.assertIn("未知", self.planner.feed_status(snapshot, policy)[1])
def test_daily_budget_survives_restart_and_is_role_local(self):
with workspace_temp() as folder:
path = folder / "role-a" / "purchase_budget.json"
budget = PurchaseBudget(path)
now = 1794048000
budget.record(now, 200, 500)
self.assertEqual(PurchaseBudget(path).remaining(now, 500), 300)
self.assertEqual(PurchaseBudget(folder / "role-b.json").remaining(now, 500), 500)
self.assertEqual(PurchaseBudget(path).remaining(now + 86400, 500), 500)
with self.assertRaises(ValueError):
budget.record(now, 301, 500)
path.write_text('{"day":"x","spent":-1}', encoding="utf-8")
with self.assertRaises(ValueError):
PurchaseBudget(path)
def test_failed_purchase_is_accounted_before_send_and_not_retried(self):
with workspace_temp() as folder:
client = Mock()
client.snapshot.return_value = self.snapshot
client.call.side_effect = ApiError("测试超时")
engine = Engine(self.catalog, client, folder / "purchase_budget.json")
engine.policy = self.policy
engine.policy.daily_buy_money = 200
engine.auto = True
with self.assertRaises(ApiError):
engine.poll()
client.call.assert_called_once()
restored = Engine(self.catalog, client, folder / "purchase_budget.json")
restored.policy = self.policy
restored.snapshot = self.snapshot
self.assertEqual(restored.plans(), [])
def test_stop_during_snapshot_prevents_next_write(self):
client = Mock()
engine = Engine(self.catalog, client)
engine.policy, engine.auto = self.policy, True
def read():
engine.auto = False
return self.snapshot
client.snapshot.side_effect = read
engine.poll()
client.call.assert_not_called()
def test_monster_lock_uses_normal_api_rechecks_state_and_respects_system_lock(self):
state = demo_snapshot(self.catalog).raw
calls = []
class LockClient:
def snapshot(self):
return Snapshot(copy.deepcopy(state))
def call(self, path, payload):
calls.append((path, payload))
next(m for m in state["monsters"] if m["id"] == payload["monsterId"])["lock"] = payload["lock"]
return {"resCode": 0}
engine = Engine(self.catalog, LockClient())
engine.auto = True
snapshot, _, _ = engine.set_monster_lock([101, 101], True)
self.assertFalse(engine.auto)
self.assertEqual(snapshot.monsters[101]["lock"], 1)
self.assertEqual(calls, [("monsterService/monsterLock", {"monsterId": 101, "lock": 1})])
engine.set_monster_lock([101], True)
self.assertEqual(len(calls), 1)
snapshot, _, _ = engine.set_monster_lock([101], False)
self.assertEqual(snapshot.monsters[101]["lock"], 0)
state["monsters"][0]["sysLock"] = 1
with self.assertRaisesRegex(ValueError, "系统锁定"):
engine.set_monster_lock([101, 102], False)
self.assertEqual(len(calls), 2)
with self.assertRaises(ValueError):
engine.set_monster_lock([999999], True)
def test_monster_lock_stops_on_unconfirmed_server_state(self):
client = Mock()
client.snapshot.side_effect = lambda: demo_snapshot(self.catalog)
engine = Engine(self.catalog, client)
with self.assertRaisesRegex(ValueError, "未更新"):
engine.set_monster_lock([101, 102], True)
self.assertEqual(client.call.call_count, 1)
def test_encrypted_http_buy_hatch_mature_dispatch_and_balance(self):
state = copy.deepcopy(self.snapshot.raw)
state["stacks"][0]["monsterId"] = -1
initial_money = state["master"]["money"]
calls, catalog = [], self.catalog
with workspace_temp() as folder:
budget_path = folder / "purchase_budget.json"
class Handler(BaseHTTPRequestHandler):
def log_message(self, *args):
pass
def do_POST(self):
body = decode(self.rfile.read(int(self.headers["Content-Length"])), DEFAULT_KEY)
name = self.path.rsplit("/", 1)[-1]
calls.append((name, body))
if name == "gachaGetEggs":
assert PurchaseBudget(budget_path).spent(time.time()) == 1000
assert body["voucherNum"] == 0 and body["id"] == "sc_city1" and body["num"] == 10
state["master"]["money"] -= 1000
state["items"] = [{"id": 501, "typeId": 1001010, "num": 11}]
elif name == "stackAddMonster":
assert body["eggs"] == [{"itemId": 501, "stackId": 1}]
state["items"][0]["num"] -= 1
mon = {"id": 101, "typeId": 1001010, "mode": 0, "process": 2,
"timeStart": time.time() * 1000, "level": 1}
mon.update({"g" + s.capitalize(): catalog.monster(1001010)[s + "_grow_min"] for s in ("atk", "def", "hp", "dex")})
state["monsters"] = [mon]
state["stacks"][0]["monsterId"] = 101
elif name == "stackCheckProcess":
state["monsters"][0]["mode"] = 2
elif name == "monsterSell":
assert body["monsterId"] == [101]
state["monsters"] = []
state["stacks"][0]["monsterId"] = -1
state["master"]["money"] += 150
elif name != "masterQueryDetail":
raise AssertionError(name)
response = state | {"resCode": 0} if name == "masterQueryDetail" else {"resCode": 0}
if name == "gachaGetEggs":
response["eggs"] = state["items"]
data = encode(response, DEFAULT_KEY)
self.send_response(200)
self.send_header("Content-Length", str(len(data)))
self.end_headers()
self.wfile.write(data)
server = ThreadingHTTPServer(("127.0.0.1", 0), Handler)
thread = threading.Thread(target=server.serve_forever, daemon=True)
thread.start()
client = Client(Session(f"http://127.0.0.1:{server.server_port}/", "synthetic-test-token"))
try:
engine = Engine(catalog, client, budget_path)
engine.policy = replace(self.policy, manual_eggs=True, egg_rules={"1001010": asdict(EggRule(enabled=True, priority=1, refill_target=12, market_id="sc_city1"))})
engine.policy.egg_stock = 12
engine.policy.buy_batch = 5
engine.policy.daily_buy_money = 1000
engine.poll()
self.assertEqual([n for n, _ in calls], ["masterQueryDetail"])
engine.auto = True
engine.poll() # Buy, re-read, plan hatch.
self.assertEqual(state["master"]["money"], initial_money - 1000)
self.assertIn("共 11 枚", engine.last_draw)
engine.poll() # Hatch, re-read, wait.
state["monsters"][0]["timeStart"] = (time.time() - 601) * 1000
snapshot, _, _ = engine.poll() # Settle growth, dispatch, re-read.
self.assertEqual(snapshot.raw["master"]["money"], initial_money - 850)
self.assertEqual(snapshot.raw["stacks"][0]["monsterId"], -1)
self.assertEqual([n for n, _ in calls if n != "masterQueryDetail"],
["gachaGetEggs", "stackAddMonster", "stackCheckProcess", "monsterSell"])
engine.poll()
self.assertEqual(sum(n == "gachaGetEggs" for n, _ in calls), 1)
self.assertEqual([b["reqid"] for _, b in calls], list(range(len(calls))))
finally:
client.close()
server.shutdown()
server.server_close()
thread.join(2)
class AutomationGuiTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.app = QApplication.instance() or QApplication([])
def wait(self, window):
for _ in range(250):
self.app.processEvents()
QTest.qWait(5)
if not window.busy and not window.pending_execute and window.slots.rowCount():
return
self.fail("Qt task did not finish")
def test_workflow_start_monitor_stop_and_settings_restore(self):
with workspace_temp() as folder:
window = gui.Window(folder)
window.timer.stop()
try:
self.wait(window)
self.assertIn("自动孵蛋", [window.tabs.tabText(i) for i in range(window.tabs.count())])
window.gold_preset()
self.wait(window)
window.egg_rules = {str(m["typeId"]): {"enabled": True, "action": "sell"} for m in window.engine.snapshot.raw["monsters"][:2]}
window.fill.setChecked(False)
window.buy_eggs.setChecked(False)
before = len(window.engine.snapshot.raw["monsters"])
window.monitor_only()
self.wait(window)
self.assertEqual(len(window.engine.snapshot.raw["monsters"]), before)
self.assertIn("仅监控", window.workflow_status.text())
window.workflow_start.click()
self.wait(window)
self.assertEqual(len(window.engine.snapshot.raw["monsters"]), before - 1)
self.assertIn("执行中", window.workflow_status.text())
window.workflow_stop.click()
self.assertTrue(window.monitoring)
self.assertFalse(window.engine.auto)
window.buy_eggs.setChecked(True)
window.market.setCurrentIndex(window.market.findData("sc_city2"))
window.daily_buy_money.setValue(700)
window.yield_stars[4].setChecked(False)
window.yield_stars[5].setChecked(False)
self.assertTrue(all(int(window.yields.item(i, 2).text()) <= 3 for i in range(window.yields.rowCount())))
self.assertLess(window.yields.rowCount(), 749)
window.save_config()
finally:
window.close()
restored = gui.Window(folder)
restored.timer.stop()
try:
self.wait(restored)
self.assertTrue(restored.buy_eggs.isChecked())
self.assertEqual(restored.market.currentData(), "sc_city2")
self.assertEqual(restored.daily_buy_money.value(), 700)
self.assertFalse(restored.execute.isChecked())
self.assertFalse(restored.yield_stars[5].isChecked())
self.assertEqual(restored.hatch_max_star.currentData(), 3)
finally:
restored.close()
def test_start_during_busy_queues_execution_and_stop_cancels_it(self):
with workspace_temp() as folder:
window = gui.Window(folder)
window.timer.stop()
try:
self.wait(window)
window.strategy.setCurrentIndex(window.strategy.findData("gold"))
window.egg_rules = {str(m["typeId"]): {"enabled": True, "action": "sell"} for m in window.engine.snapshot.raw["monsters"][:2]}
window.fill.setChecked(False)
before = len(window.engine.snapshot.raw["monsters"])
window.refresh()
window.start_workflow()
self.assertTrue(window.pending_execute)
self.wait(window)
self.assertEqual(len(window.engine.snapshot.raw["monsters"]), before - 1)
window.refresh()
window.start_workflow()
window.stop_workflow()
self.wait(window)
self.assertEqual(len(window.engine.snapshot.raw["monsters"]), before - 1)
self.assertFalse(window.pending_execute)
finally:
window.close()
def test_quest_rewards_and_target_cap_are_visible(self):
with workspace_temp() as folder:
window = gui.Window(folder)
window.timer.stop()
try:
self.wait(window)
key = next(iter(window.catalog.data["task_info"]))
snapshot = window.engine.snapshot
snapshot.raw["currentTasks"] = [{"id": 88, "typeId": key, "curStep": 1}]
snapshot.monsters[900].update(level=20, potentialLevel=2)
window.render(snapshot, [])
window.target.setCurrentIndex(window.target.findData(900))
self.assertIn("上限 20", window.target_status.text())
reward = window.catalog.data["task_info"][key]["reward"]
self.assertEqual(int(window.quests_table.item(0, 4).text()), reward["ke"])
self.assertIn("氪金", window.summary.text())
finally:
window.close()
def test_monster_buttons_and_context_menu_update_real_selection_without_auto_sale(self):
from PySide6.QtCore import QPoint
with workspace_temp() as folder:
window = gui.Window(folder)
window.timer.stop()
try:
self.wait(window)
window.execute.setChecked(True)
window.start_monitor.setChecked(True)
before = len(window.engine.snapshot.raw["monsters"])
def select(mid):
row = next(i for i in range(window.monsters.rowCount()) if int(window.monsters.item(i, 0).text()) == mid)
window.monsters.selectRow(row)
select(101)
self.assertTrue(window.lock_monsters.isEnabled())
window.lock_monsters.click()
self.wait(window)
self.assertEqual(window.engine.snapshot.monsters[101]["lock"], 1)
self.assertFalse(window.execute.isChecked())
self.assertEqual(len(window.engine.snapshot.raw["monsters"]), before)
select(101)
with patch("PySide6.QtWidgets.QMenu.popup"):
window.page_menu(window.monsters.viewport(), QPoint(-1, -1), window.monster_page)
action = next(a for a in window.refresh_menu.actions() if a.text() == "解锁选中魔物")
action.trigger()
self.wait(window)
self.assertEqual(window.engine.snapshot.monsters[101]["lock"], 0)
self.assertFalse(window.engine.auto)
self.assertEqual(len(window.engine.snapshot.raw["monsters"]), before)
finally:
window.close()
if __name__ == "__main__":
unittest.main()
+259
View File
@@ -0,0 +1,259 @@
import copy
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
import json
from pathlib import Path
from contextlib import contextmanager
import shutil
import threading
import time
import unittest
import uuid
from unittest.mock import patch
import requests
from PIL import Image, ImageDraw
from ranch_assistant.api import ApiError, Client, DEFAULT_KEY, Session, decode, encode
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
@contextmanager
def workspace_temp():
root = Path(__file__).resolve().parents[2] / "test-artifacts"
folder = root / uuid.uuid4().hex
folder.mkdir(parents=True)
try:
yield folder
finally:
target = folder.resolve()
if target.parent != root.resolve():
raise RuntimeError("Unexpected test cleanup path")
shutil.rmtree(target)
class CoreTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.catalog = Catalog()
def snapshot(self):
return demo_snapshot(self.catalog)
def test_catalog_and_quality_boundaries(self):
self.assertEqual(len(self.catalog.monsters), 749)
mon = self.snapshot().raw["monsters"][0]
row = self.catalog.monster(mon["typeId"])
for fraction, expected in ((0, 1), (.25, 2), (.5, 3), (.75, 4), (1, 4)):
for stat in ("atk", "def", "hp", "dex"):
mon["g" + stat.capitalize()] = row[stat + "_grow_min"] + fraction * (row[stat + "_grow_max"] - row[stat + "_grow_min"])
# The client rounds growth values to three decimals first.
self.assertEqual(self.catalog.quality(mon), [expected] * 4)
mon.pop("gAtk")
self.assertIsNone(self.catalog.quality(mon)[0])
def test_locked_team_and_existing_monsters_are_preserved(self):
snapshot = self.snapshot()
planner = Planner(self.catalog)
policy = Policy(strategy="gold", protect_star=6, protect_quality=5, fill=False)
snapshot.raw["monsters"][0]["lock"] = 1
snapshot.raw["teams"][0]["monsters"].append(snapshot.raw["monsters"][1]["id"])
plans = planner.plan(snapshot, policy)
self.assertFalse(any(a.kind in ("feed", "sell") for a in plans))
self.assertNotIn(900, planner.managed)
def test_collection_then_feed_with_target_cap(self):
snapshot = self.snapshot()
planner = Planner(self.catalog)
policy = Policy(strategy="experience", protect_star=6, protect_quality=5, feed_target=900, fill=False)
first = planner.plan(snapshot, policy)[0]
self.assertEqual(first.kind, "collect")
mon = snapshot.raw["monsters"][0]
mon.update(process=3, roomId=1)
snapshot.raw["stacks"][0]["monsterId"] = 0
plans = planner.plan(snapshot, policy)
self.assertEqual(plans[0].kind, "feed")
self.assertEqual(plans[0].payload, {"targetId": 900, "foods": [mon["id"]]})
snapshot.monsters[900]["level"] = policy.target_level
self.assertFalse(any(a.kind == "feed" for a in planner.plan(snapshot, policy)))
def test_unknown_quality_never_sold(self):
snapshot = self.snapshot()
for mon in snapshot.raw["monsters"]:
mon.pop("gHp", None)
plans = Planner(self.catalog).plan(snapshot, Policy(strategy="gold", protect_star=6, protect_quality=5, fill=False))
self.assertTrue(all(a.kind != "sell" for a in plans))
def test_reserved_eggs_and_vip_slot(self):
snapshot = self.snapshot()
for slot in snapshot.raw["stacks"]:
slot["monsterId"] = 0
snapshot.raw["monsters"] = []
egg = snapshot.raw["items"][0]
snapshot.raw["items"] = [egg]
egg["num"] = 2
policy = Policy(reserved_eggs={str(egg["typeId"]): 1})
plans = Planner(self.catalog).plan(snapshot, policy)
self.assertEqual(len(plans), 1)
self.assertNotEqual(plans[0].payload["eggs"][0]["stackId"], 4)
egg["num"] = 10
plans = Planner(self.catalog).plan(snapshot, Policy())
self.assertEqual(len(plans), 5)
self.assertNotIn(4, [p.payload["eggs"][0]["stackId"] for p in plans])
def test_room_full_blocks_collecting(self):
snapshot = self.snapshot()
snapshot.raw["rooms"] = []
plans = Planner(self.catalog).plan(snapshot, Policy(strategy="keep", fill=False))
self.assertEqual(plans, [])
def test_null_vip_info_does_not_block_snapshot_preview(self):
snapshot = self.snapshot()
snapshot.raw["activityHistory"]["vipInfo"] = None
for slot in snapshot.raw["stacks"]:
slot["monsterId"] = 0
snapshot.raw["monsters"] = []
self.assertTrue(Planner(self.catalog).plan(snapshot, Policy()))
def test_policy_error_returns_fetched_data_and_stops_actions(self):
engine = Engine(self.catalog)
engine.snapshot = self.snapshot()
engine.auto = True
with patch.object(engine, "plans", side_effect=ValueError("invalid policy")):
snapshot, plans, message = engine.poll()
self.assertIs(snapshot, engine.snapshot)
self.assertEqual(plans, [])
self.assertFalse(engine.auto)
self.assertIn("策略暂不可用", message)
def test_codec_and_har_resume(self):
payload = {"token": "local-test", "reqid": 42, "reqsid": 43, "text": "魔物"}
self.assertEqual(decode(encode(payload, DEFAULT_KEY), DEFAULT_KEY), payload)
har = {"log": {"entries": [{"request": {"url": "http://127.0.0.1/game/masterService/masterQueryDetail", "postData": {"text": encode(payload, DEFAULT_KEY).decode()}}}]}}
session = Session.imported(har)
self.assertEqual(session.reqid, 43)
self.assertEqual(session.reqsid, 44)
self.assertEqual(session.server_url, "http://127.0.0.1/game/")
def test_writes_not_retried_or_secrets_logged(self):
client = Client(Session("http://127.0.0.1/", "private-token"))
with patch.object(client.http, "post", side_effect=requests.Timeout("private-token")) as post:
with self.assertRaises(ApiError) as raised:
client.call("monsterService/monsterSell", {"monsterIds": [1]})
self.assertEqual(post.call_count, 1)
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):
def test_encrypted_http_read_mature_settle_sell_refresh(self):
catalog = Catalog()
state = demo_snapshot(catalog).raw
for mon in state["monsters"]:
if mon.get("process") == 2:
mon["mode"] = 0
mon["timeStart"] = 1
calls = []
class Handler(BaseHTTPRequestHandler):
def log_message(self, *args): pass
def do_POST(self):
body = decode(self.rfile.read(int(self.headers["Content-Length"])), DEFAULT_KEY)
calls.append((self.path, body))
if self.path.endswith("stackCheckProcess"):
for mon in state["monsters"]:
if mon.get("process") == 2: mon["mode"] = 2
response = {"resCode": 0}
elif self.path.endswith("monsterSell"):
mid = body["monsterId"][0]
state["monsters"] = [m for m in state["monsters"] if m["id"] != mid]
for slot in state["stacks"]:
if slot["monsterId"] == mid: slot["monsterId"] = 0
response = {"resCode": 0, "money": 150}
else:
response = state | {"resCode": 0}
raw = encode(response, DEFAULT_KEY)
self.send_response(200)
self.send_header("Content-Length", str(len(raw)))
self.end_headers()
self.wfile.write(raw)
server = ThreadingHTTPServer(("127.0.0.1", 0), Handler)
thread = threading.Thread(target=server.serve_forever, daemon=True)
thread.start()
client = Client(Session(f"http://127.0.0.1:{server.server_port}/", "synthetic-test-token"))
try:
engine = Engine(catalog, client)
engine.policy = Policy(strategy="gold", protect_star=6, protect_quality=5, fill=False)
engine.poll()
self.assertFalse(any(p.endswith("stackCheckProcess") or p.endswith("monsterSell") for p, _ in calls))
engine.auto = True
snapshot, _, _ = engine.poll()
self.assertEqual(sum(p.endswith("monsterSell") for p, _ in calls), 1)
self.assertEqual(sum(m.get("process") == 2 for m in snapshot.raw["monsters"]), 3)
self.assertEqual([v["reqid"] for _, v in calls], list(range(len(calls))))
finally:
client.close()
server.shutdown()
server.server_close()
thread.join(2)
if __name__ == "__main__":
unittest.main()
+93
View File
@@ -0,0 +1,93 @@
import json
import os
from types import SimpleNamespace
import unittest
from unittest.mock import patch
import requests
from ranch_assistant.api import ApiError, Client, DEFAULT_KEY, Session, encode
from ranch_assistant.credentials import CredentialStore
from ranch_assistant.debug import HIDDEN, TraceLog
from ranch_assistant.login import PasswordLogin
from ranch_assistant.model import Catalog
from ranch_assistant.tests.test_core import workspace_temp
class DiagnosticsTests(unittest.TestCase):
@unittest.skipUnless(os.name == "nt", "Windows DPAPI")
def test_remember_password_round_trip_and_disable(self):
with workspace_temp() as folder:
store = CredentialStore(folder)
store.save("local-test-account", "test+密码&123")
self.assertEqual(store.load(), (True, "local-test-account", "test+密码&123"))
self.assertNotIn("test+密码&123", store.path.read_text(encoding="utf-8"))
store.save("local-test-account", "test+密码&123", False)
self.assertEqual(store.load(), (False, "", ""))
self.assertNotIn("password", json.loads(store.path.read_text(encoding="utf-8")))
def test_nested_secrets_previews_and_error_messages_are_redacted(self):
with workspace_temp() as folder:
events = []
trace = TraceLog(folder, events.append)
request = trace.begin("test", body={"password": "test-password"}, headers={"Authorization": "test-auth"})
trace.emit("response", "test", request_id=request, body={"data": {"userList": [{"token": "test-token"}]},
"servers": [{"regionId": 2}]})
trace.emit("error", "test", message="echo: test-password test-token test-auth")
trace.emit("response", "test", body_preview='{"token":"partial-secret", "field": 2, "password":"unknown')
text = trace.path.read_text(encoding="utf-8")
for secret in ("test-password", "test-token", "test-auth", "partial-secret", "unknown"):
self.assertNotIn(secret, text)
self.assertEqual(events[1]["body"]["data"]["userList"][0]["token"], HIDDEN)
self.assertEqual(events[1]["body"]["servers"], [{"regionId": 2}])
def test_failed_server_parsing_preserves_received_schema_in_trace(self):
with workspace_temp() as folder:
trace = TraceLog(folder)
client = Client(Session(), trace)
body = {"resCode": 0, "playerInfo": {"token": "private-test-token"}, "servers": [{"regionId": 2, "serverName": "测试区"}]}
response = SimpleNamespace(status_code=200, content=encode(body, DEFAULT_KEY), headers={})
try:
with patch.object(client.http, "post", return_value=response):
with self.assertRaises(ApiError):
client.sdk_login("http://127.0.0.1/", "test-user", "test-sdk")
records = list(trace.events)
self.assertEqual(records[1]["body"]["servers"][0]["regionId"], 2)
self.assertEqual(records[2]["operation"], "本地区服整理")
self.assertNotIn("private-test-token", trace.text())
finally:
client.close()
def test_timeout_is_logged_at_the_request_stage_and_is_not_retried(self):
with workspace_temp() as folder:
trace = TraceLog(folder)
client = Client(Session("http://127.0.0.1/", "private-test-token"), trace)
try:
with patch.object(client.http, "post", side_effect=requests.Timeout("echo private-test-token")) as post:
with self.assertRaises(ApiError):
client.call("masterService/masterQueryDetail")
self.assertEqual(post.call_count, 1)
self.assertEqual(list(trace.events)[-1]["operation"], "读取角色")
self.assertEqual(list(trace.events)[-1]["exception_type"], "Timeout")
self.assertNotIn("private-test-token", trace.text())
finally:
client.close()
def test_sdk_non_json_http_failure_retains_status_and_sanitized_preview(self):
with workspace_temp() as folder:
trace = TraceLog(folder)
flow = PasswordLogin(Catalog(), "test-device", trace=trace)
with patch("ranch_assistant.login.requests.Session") as session:
response = session.return_value.__enter__.return_value.post.return_value
response.status_code, response.headers = 502, {}
response.content = b"gateway error test-password"
response.json.side_effect = ValueError("not json")
with self.assertRaisesRegex(ApiError, "HTTP 502"):
flow.authenticate("test-account", "test-password")
received = next(e for e in trace.events if e["kind"] == "response")
self.assertEqual(received["http_status"], 502)
self.assertIn("gateway error", received["body_preview"])
self.assertNotIn("test-password", trace.text())
if __name__ == "__main__":
unittest.main()
+297
View File
@@ -0,0 +1,297 @@
import hashlib
import hmac
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
import json
from datetime import datetime, timedelta, timezone
import threading
import unittest
from urllib.parse import parse_qs, urlsplit
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.capture import load_buttons, save_page, saved_profiles, write_buttons
from ranch_assistant.engine import Engine, demo_snapshot
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.maps import stages
from ranch_assistant.model import Catalog, Policy
from ranch_assistant.quests import QuestPolicy, TaskPlanner, condition_ok
from ranch_assistant.tests.test_core import workspace_temp
class LoginTests(unittest.TestCase):
def entry_request(self):
catalog = Catalog()
catalog.data["tjchannel"] = {"tjchannel": "taptap"}
client = Client(Session(token="abcdefghijklmno"))
instant = datetime(2026, 11, 7, 19, 0, tzinfo=timezone(timedelta(hours=8)))
try:
with patch("ranch_assistant.api.datetime") as clock, patch.object(client, "call") as call:
clock.now.return_value = instant
client.enter_server("http://127.0.0.1/", {"id": 1, "gameServerAddress": "http://127.0.0.1/game/"}, "12345678", catalog)
return call.call_args.args[1]
finally:
client.close()
def test_entry_signature_matches_paster_full_year_format(self):
# Paster.timestampFormat replaces "yy" with Date.fullYear, yielding eight digits.
expected = hashlib.md5(b"202611075678defghijklmno").hexdigest()
self.assertEqual(self.entry_request()["random"], expected)
def test_entry_uses_apk_tracking_channel(self):
self.assertEqual(self.entry_request()["tjChannel"], "taptap")
def test_unknown_or_conflicting_server_ids_do_not_enter_any_server(self):
client = Client(Session(token="synthetic-test-token"))
try:
with patch.object(client, "call") as call:
for server in ({"serverName": "private-value"}, {"id": 1, "serverId": 2}, {"serverId": True}, {"serverId": 1.5}):
with self.assertRaises(ApiError) as raised:
client.enter_server("http://127.0.0.1/", server, "test-uid", Catalog())
self.assertNotIn("private-value", str(raised.exception))
with self.assertRaises(ApiError):
client.enter_server("http://127.0.0.1/", {"serverId": 2}, "test-uid", Catalog())
call.assert_not_called()
self.assertEqual(server_id({"serverId": "2"}), 2)
finally:
client.close()
def test_password_two_regions_and_enter_selected_game_server(self):
self.password_flow("id")
def test_password_serverId_regions_and_enter_selected_game_server(self):
self.password_flow("serverId")
def test_password_server_references_are_deduplicated_before_entering_second_region(self):
self.password_flow("id", references=True)
def test_reference_entries_resolve_to_two_real_servers_without_mutating_response(self):
response = {"servers": [{"id": 1, "serverName": "测试一区"}, {"id": 2, "serverName": "测试二区"},
{"$ref": "$.servers[0]"}, {"$ref": "$.servers[1]"}]}
self.assertEqual([row["id"] for row in server_entries(response)], [1, 2])
self.assertEqual(response["servers"][2], {"$ref": "$.servers[0]"})
def test_reference_chains_duplicates_and_invalid_targets(self):
response = {"servers": [{"$ref": "$.servers[1]"}, {"$ref": "$.servers[2]"}, {"id": 2}, {"id": "2"}]}
self.assertEqual([row["id"] for row in server_entries(response)], [2])
for rows in ([{"$ref": "$.servers[0]"}], [{"$ref": "$.servers[9]"}],
[{"$ref": "https://example.invalid/"}], [{"$ref": "$.servers[1]"}, {"$ref": "$.servers[0]"}],
[{"id": 2, "gameServerAddress": "http://127.0.0.1/a/"}, {"id": 2, "gameServerAddress": "http://127.0.0.1/b/"}]):
with self.subTest(rows=rows), self.assertRaises(ApiError):
server_entries({"servers": rows})
def test_debug_covers_all_four_login_requests_and_omits_secrets(self):
with workspace_temp() as folder:
trace = TraceLog(folder)
self.password_flow("serverId", trace)
text = trace.path.read_text(encoding="utf-8")
for secret in ("raw+p&ssword", "sdk-test-token", "game-test-token"):
self.assertNotIn(secret, text)
self.assertEqual([e["operation"] for e in trace.events if e["kind"] == "request"][:4],
["渠道账号验证", "获取官方区服", "进入选中区服", "读取角色"])
self.assertTrue(any(e.get("body", {}).get("servers") for e in trace.events if isinstance(e.get("body"), dict)))
def password_flow(self, id_field, trace=None, references=False):
catalog = Catalog()
calls = []
sdk_status = [200]
class Handler(BaseHTTPRequestHandler):
def log_message(self, *args):
pass
def do_POST(self):
raw = self.rfile.read(int(self.headers["Content-Length"]))
if self.path.startswith("/sdk"):
calls.append((self.path, parse_qs(raw.decode()), dict(self.headers)))
body = {"code": sdk_status[0], "data": {"userList": [{"userId": "12345678", "token": "sdk-test-token"}]}}
reply = json.dumps(body).encode()
else:
body = decode(raw, DEFAULT_KEY)
calls.append((self.path, body, {}))
address = f"http://127.0.0.1:{self.server.server_port}"
if self.path.endswith("loginUser"):
response = {"playerInfo": {"token": "game-test-token"},
"servers": [{id_field: 1, "serverName": "一区", "platform": "ANDROID", "gameServerAddress": address + "/one/"},
{id_field: "2", "serverName": "二区", "platform": "ANDROID", "gameServerAddress": address + "/two/"},
{id_field: 3, "serverName": "其他平台", "platform": "IOS"}],
"masterInfos": [{"id": 9001, "serverId": 2, "masterName": "本地测试角色"}]}
if references:
response["servers"] = response["servers"][:2] + [{"$ref": "$.servers[0]"}, {"$ref": "$.servers[1]"}]
elif self.path.endswith("enterGame"):
# Independent contract from NetUser + Paster, using fixed test UID/token tails.
today = datetime.now(timezone(timedelta(hours=8))).strftime("%Y%m%d")
expected = hashlib.md5((today + "5678e-test-token").encode()).hexdigest()
response = {} if body.get("random") == expected and body.get("tjChannel") == "taptap" else {"resCode": 990, "resMsg": "Illegal"}
else:
response = demo_snapshot(catalog).raw
reply = encode({"resCode": 0} | response, DEFAULT_KEY)
self.send_response(200)
self.send_header("Content-Length", str(len(reply)))
self.end_headers()
self.wfile.write(reply)
server = ThreadingHTTPServer(("127.0.0.1", 0), Handler)
thread = threading.Thread(target=server.serve_forever, daemon=True)
thread.start()
address = f"http://127.0.0.1:{server.server_port}"
flow = PasswordLogin(catalog, "desktop-test", sdk_url=address + "/sdk", center_url=address + "/center/", trace=trace)
client = None
try:
client, game, context = flow.authenticate(" local-account ", "raw+p&ssword")
self.assertIn("本地测试角色", server_labels(game)[1])
self.assertEqual([s["id"] for s in game["servers"]], [1, 2])
client.enter_server(context["center_url"], game["servers"][1], context["uid"], catalog)
self.assertEqual(client.snapshot().raw["master"]["id"], 1)
self.assertEqual(calls[0][1], {"account": ["local-account"], "password": ["raw+p&ssword"]})
self.assertEqual(parse_qs(urlsplit(calls[0][0]).query)["appChannel"], ["taptap"])
self.assertEqual(calls[0][2]["Authorization"], hmac.new(SDK_APP_SECRET.encode(), SDK_APP_ID.encode(), hashlib.sha256).hexdigest())
self.assertEqual(calls[1][1]["sdkToken"], "sdk-test-token")
self.assertEqual(calls[1][1]["channel"], "DYD")
self.assertEqual(calls[1][1]["tjChannel"], "taptap")
self.assertEqual(calls[2][1]["serverId"], 2)
self.assertEqual(calls[3][0], "/two/masterService/masterQueryDetail")
for status in (407, 408):
sdk_status[0] = status
before = len(calls)
with self.assertRaises(ApiError):
flow.authenticate("local-account", "raw+p&ssword")
self.assertEqual(len(calls), before + 1)
finally:
if client:
client.close()
server.shutdown()
server.server_close()
thread.join(2)
class PlanningTests(unittest.TestCase):
def setUp(self):
self.catalog = Catalog()
self.snapshot = demo_snapshot(self.catalog)
self.ranch = Policy(protect_star=6, protect_quality=5, fill=False)
self.policy = QuestPolicy(enabled=True)
self.catalog.data["task_info"] = {"test": {"name": "测试委托", "steps": [{"statusType": "none"}]}}
self.planner = TaskPlanner(self.catalog)
def test_quest_accept_step_reward_and_daily_limit(self):
history = self.snapshot.raw["history"]
history.update(loopTaskNum=1, unlockCity={"1": True}, loopTask={"1": ["test"]})
action = self.planner.plan(self.snapshot, self.policy, self.ranch)[0]
self.assertEqual(action.kind, "quest_accept")
engine = Engine(self.catalog)
engine.snapshot = self.snapshot
engine.apply_demo(action)
self.assertEqual(history["loopTaskNum"], 0)
action = self.planner.plan(self.snapshot, self.policy, self.ranch)[0]
self.assertEqual(action.kind, "quest_step")
engine.apply_demo(action)
action = self.planner.plan(self.snapshot, self.policy, self.ranch)[0]
self.assertEqual(action.kind, "quest_complete")
engine.apply_demo(action)
self.assertEqual(self.planner.plan(self.snapshot, self.policy, self.ranch), [])
def test_consumable_reserves_and_protected_monsters(self):
egg = self.snapshot.raw["items"][0]
step = {"statusType": "getItem", "statusValue": {"type": egg["typeId"], "num": 2, "remove": True}}
self.assertFalse(self.planner.requirement(self.snapshot, step, {}, self.policy, self.ranch)[0])
self.policy.allow_items = True
self.policy.item_reserves[str(egg["typeId"])] = egg["num"] - 1
self.assertFalse(self.planner.requirement(self.snapshot, step, {}, self.policy, self.ranch)[0])
self.policy.item_reserves.clear()
self.assertTrue(self.planner.requirement(self.snapshot, step, {}, self.policy, self.ranch)[0])
mon = self.snapshot.raw["monsters"][0]
mon["typeId"] = str(mon["typeId"])
self.policy.allow_monsters = True
self.ranch.reserved_types = [int(mon["typeId"])]
step = {"statusType": "getMonster", "statusValue": {"type": mon["typeId"], "num": 1, "mode": 2, "remove": True}}
self.assertFalse(self.planner.requirement(self.snapshot, step, {}, self.policy, self.ranch)[0])
self.ranch.reserved_types.clear()
mon["lock"] = 1
self.assertFalse(self.planner.requirement(self.snapshot, step, {}, self.policy, self.ranch)[0])
def test_battle_steps_wait_for_actual_combat(self):
self.snapshot.raw["currentTasks"] = [{"id": 12, "typeId": "test", "curStep": 1}]
for kind in ("battle", "passStage"):
self.catalog.data["task_info"]["test"]["steps"] = [{"statusType": kind}]
self.assertEqual(self.planner.plan(self.snapshot, self.policy, self.ranch), [])
step = {"statusType": "killMonster", "statusValue": {"type": 100, "num": 1}}
self.snapshot.raw["history"]["numKillMonsters"] = {"100": 12}
self.assertFalse(self.planner.requirement(self.snapshot, step, {"stepValue": 15}, self.policy, self.ranch)[0])
self.assertTrue(self.planner.requirement(self.snapshot, step, {"stepValue": 12}, self.policy, self.ranch)[0])
def test_map_unlocks_are_per_difficulty_and_conditions_accept_null(self):
self.assertTrue(condition_ok({"minLevel": None, "maxLevel": None, "week": None, "endTime": None}, self.snapshot))
self.catalog.data["stage_info"] = {"test": {"name": "地图测试", "level": {"1": {"cost": 1}, "2": {"cost": 2}}, "cost": {"ti": 6}}}
self.snapshot.raw["history"].update(unlockStage={"test": {"1": True, "2": False}}, passStage={"test": {"1": True}})
first, second = stages(self.catalog, self.snapshot)
self.assertTrue(first.unlocked and first.passed and first.open)
self.assertFalse(second.unlocked or second.passed)
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__":
unittest.main()
+223
View File
@@ -0,0 +1,223 @@
import copy
import os
from dataclasses import asdict
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 import gui
from ranch_assistant.tests.test_core import workspace_temp
from ranch_assistant.engine import Engine, demo_snapshot
from ranch_assistant.model import Catalog, EggRule, Planner, Policy, Snapshot
NOW = 1800000000
class GrowthClient:
def __init__(self, catalog, age=310, grade="C"):
self.catalog, self.calls = catalog, []
self.raw = copy.deepcopy(demo_snapshot(catalog).raw)
self.raw["stacks"] = [{"id": 1, "position": 0, "monsterId": 501}]
self.raw["monsters"] = [{"id": 501, "typeId": 1001010, "process": 2, "mode": 0,
"timeStart": (NOW - age) * 1000, "level": 1, "gAtk": 0, "gDef": 0, "gHp": 0, "gDex": 0}]
self.raw["items"] = []
self.stage = 1 if age < 600 else 2
self.grade = grade
self.empty_growth_response = False
def snapshot(self):
self.calls.append(("read", {}))
# This deliberately remains stale after growth settlement. The client
# code applies datas + stackMonsterInfos from the growth response.
return Snapshot(copy.deepcopy(self.raw))
def persist_session(self):
pass
def close(self):
pass
def settle_growth(self):
self.calls.append(("growth", {}))
if self.empty_growth_response:
return {"resCode": 0, "datas": [], "stackMonsterInfos": None}
infos = None
if self.stage == 2:
row = self.catalog.monster(1001010)
infos = [{"monsterId": 501} | {"g" + stat.capitalize(): row[stat + ("_grow_max" if self.grade == "S" else "_grow_min")]
for stat in ("atk", "def", "hp", "dex")}]
return {"resCode": 0, "datas": [{"monsterId": 501, "mode": self.stage}], "stackMonsterInfos": infos, "allExp": 0}
def call(self, path, payload):
self.calls.append((path, payload))
if path == "monsterService/monsterSell":
self.raw["monsters"] = []
self.raw["stacks"][0]["monsterId"] = -1
return {"resCode": 0}
class GrowthTests(unittest.TestCase):
def setUp(self):
self.catalog = Catalog()
self.clock = patch("ranch_assistant.model.time.time", return_value=NOW)
self.now = self.clock.start()
self.addCleanup(self.clock.stop)
def engine(self, client):
engine = Engine(self.catalog, client)
engine.policy = Policy(manual_eggs=True, fill=False, buy=False, collect=False, protect_star=4, protect_quality=3,
egg_rules={"1001010": asdict(EggRule(enabled=True, action="sell"))})
engine.auto = True
return engine
def test_unhatched_zero_growth_is_unknown_not_four_c(self):
mon = GrowthClient(self.catalog).raw["monsters"][0]
self.assertEqual(self.catalog.quality(mon), [None] * 4)
self.assertNotEqual(self.catalog.quality_text(mon), "C/C/C/C")
mon["mode"] = 2
self.assertEqual(self.catalog.quality(mon), [None] * 4)
plans = Planner(self.catalog).plan(Snapshot(GrowthClient(self.catalog).raw | {"monsters": [mon]}),
Policy(strategy="gold", fill=False, protect_quality=5))
self.assertFalse(any(a.kind in ("sell", "feed", "collect") for a in plans))
def test_hatching_phase_settles_before_full_maturity(self):
client = GrowthClient(self.catalog, age=310)
engine = self.engine(client)
snapshot, _, _ = engine.poll()
self.assertEqual(sum(name == "growth" for name, _ in client.calls), 1)
self.assertEqual(snapshot.monsters[501]["mode"], 1)
self.assertEqual(self.catalog.quality(snapshot.monsters[501]), [None] * 4)
self.assertFalse(any(name == "monsterService/monsterSell" for name, _ in client.calls))
def test_mature_response_growth_is_applied_before_dispatch_and_reads_cannot_revert_it(self):
client = GrowthClient(self.catalog, age=610)
engine = self.engine(client)
snapshot, _, _ = engine.poll()
self.assertEqual([body for name, body in client.calls if name == "monsterService/monsterSell"], [{"monsterId": [501]}])
self.assertNotIn(501, snapshot.monsters)
self.assertLess([name for name, _ in client.calls].index("growth"), [name for name, _ in client.calls].index("monsterService/monsterSell"))
def test_s_grade_is_retained_with_specific_reason_and_survives_stale_snapshots(self):
client = GrowthClient(self.catalog, age=610, grade="S")
engine = self.engine(client)
snapshot, _, _ = engine.poll()
self.assertEqual(self.catalog.quality_text(snapshot.monsters[501]), "S/S/S/S")
self.assertFalse(any(name == "monsterService/monsterSell" for name, _ in client.calls))
self.assertTrue(any("资质" in note for note in engine.planner.notes))
snapshot, _, _ = engine.poll()
self.assertEqual(self.catalog.quality_text(snapshot.monsters[501]), "S/S/S/S")
self.assertEqual(sum(name == "growth" for name, _ in client.calls), 1)
def test_two_phase_transition_updates_same_monster_without_retry_delay(self):
client = GrowthClient(self.catalog, age=310)
engine = self.engine(client)
engine.poll()
self.now.return_value = NOW + 310
client.stage = 2
snapshot, _, _ = engine.poll()
self.assertNotIn(501, snapshot.monsters)
self.assertEqual(sum(name == "growth" for name, _ in client.calls), 2)
self.assertEqual(sum(name == "monsterService/monsterSell" for name, _ in client.calls), 1)
def test_stale_positive_c_grade_cannot_overwrite_s_from_settlement(self):
client = GrowthClient(self.catalog, age=610, grade="S")
original = client.settle_growth
def settle():
response = original()
client.raw["monsters"][0]["mode"] = 2
for stat in ("atk", "def", "hp", "dex"):
client.raw["monsters"][0]["g" + stat.capitalize()] = self.catalog.monster(1001010)[stat + "_grow_min"]
return response
client.settle_growth = settle
engine = self.engine(client)
snapshot, _, _ = engine.poll()
self.assertEqual(self.catalog.quality_text(snapshot.monsters[501]), "S/S/S/S")
snapshot, _, _ = engine.poll()
self.assertEqual(self.catalog.quality_text(snapshot.monsters[501]), "S/S/S/S")
self.assertFalse(any(name == "monsterService/monsterSell" for name, _ in client.calls))
def test_no_progress_is_throttled_and_never_consumes_pending_monsters(self):
client = GrowthClient(self.catalog, age=610)
client.empty_growth_response = True
engine = self.engine(client)
engine.poll()
engine.poll()
self.assertEqual(sum(name == "growth" for name, _ in client.calls), 1)
self.assertFalse(any(name == "monsterService/monsterSell" for name, _ in client.calls))
def test_monitor_is_read_only_and_explicit_sync_does_not_dispatch(self):
client = GrowthClient(self.catalog, age=610)
engine = self.engine(client)
engine.auto = False
snapshot, _, message = engine.poll()
self.assertFalse(any(name == "growth" for name, _ in client.calls))
self.assertIn("仅监控", message)
snapshot, plans, _ = engine.sync_growth()
self.assertEqual(snapshot.monsters[501]["mode"], 2)
self.assertEqual(self.catalog.quality_text(snapshot.monsters[501]), "C/C/C/C")
self.assertTrue(any(action.kind == "sell" for action in plans))
self.assertFalse(any(name == "monsterService/monsterSell" for name, _ in client.calls))
def test_mature_protected_monster_with_null_room_id_can_be_collected(self):
client = GrowthClient(self.catalog, age=610, grade="S")
mon = client.raw["monsters"][0]
mon.update(mode=2, roomId=None)
for stat in ("atk", "def", "hp", "dex"):
mon["g" + stat.capitalize()] = self.catalog.monster(1001010)[stat + "_grow_max"]
engine = self.engine(client)
engine.policy.collect = True
engine.snapshot = Snapshot(copy.deepcopy(client.raw))
plans = engine.plans()
self.assertEqual(plans[0].kind, "collect")
self.assertEqual(plans[0].payload["datas"][0]["monsterId"], [501])
class GrowthGuiTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.app = W.QApplication.instance() or W.QApplication([])
def test_pending_display_and_explicit_sync_update_grade_and_keep_reason(self):
with workspace_temp() as folder, patch("ranch_assistant.model.time.time", return_value=NOW):
window = gui.Window(folder)
window.timer.stop()
try:
for _ in range(200):
self.app.processEvents()
QTest.qWait(5)
if not window.busy and window.slots.rowCount():
break
client = GrowthClient(window.catalog, age=610, grade="S")
client.session = Session("http://127.0.0.1/", "synthetic-test-token")
window.engine = Engine(window.catalog, client)
window.egg_rules = {"1001010": asdict(EggRule(enabled=True, action="sell"))}
window.engine.policy = window.read_policy()
window.engine.snapshot = client.snapshot()
window.render(window.engine.snapshot, window.engine.plans())
row = next(i for i in range(window.slots.rowCount()) if window.slots.item(i, 1).text() == "1")
self.assertIn("待同步", window.slots.item(row, 5).text())
self.assertIn("待成熟", window.slots.item(row, 7).text())
self.assertNotEqual(window.monsters.item(0, 4).text(), "C/C/C/C")
window.sync_growth_button.click()
for _ in range(200):
self.app.processEvents()
QTest.qWait(5)
if not window.busy:
break
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.assertIn("资质", window.slots.item(row, 8).text())
self.assertIn("S/S/S/S", window.monsters.item(0, 4).text())
self.assertFalse(window.execute.isChecked())
self.assertFalse(any(name == "monsterService/monsterSell" for name, _ in client.calls))
finally:
window.close()
if __name__ == "__main__":
unittest.main()
+215
View File
@@ -0,0 +1,215 @@
import os
os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
import json
import unittest
from unittest.mock import patch
from PySide6.QtTest import QTest
from PySide6.QtWidgets import QApplication
from ranch_assistant import gui
from ranch_assistant.tests.test_core import workspace_temp
class GuiTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.app = QApplication.instance() or QApplication([])
def wait(self, window):
for _ in range(200):
self.app.processEvents()
QTest.qWait(5)
if not window.busy and window.slots.rowCount():
return
self.fail("Qt background refresh did not complete")
def test_preview_auto_execution_and_secret_free_settings(self):
with workspace_temp() as folder, patch.object(gui, "STATE", folder):
window = gui.Window()
window.timer.stop()
try:
self.wait(window)
self.assertIn("页面截图配置", [window.tabs.tabText(i) for i in range(window.tabs.count())])
self.assertEqual(window.yields.rowCount(), 749)
self.assertEqual(window.styleSheet(), "")
window.strategy.setCurrentIndex(window.strategy.findData("gold"))
window.egg_rules = {str(m["typeId"]): {"enabled": True, "action": "sell"} for m in window.engine.snapshot.raw["monsters"][:2]}
window.protect_star.setValue(6)
window.protect_quality.setCurrentIndex(window.protect_quality.findData(5))
window.fill.setChecked(False)
window.execute.setChecked(True)
before = len(window.engine.snapshot.raw["monsters"])
window.refresh()
self.wait(window)
self.assertEqual(len(window.engine.snapshot.raw["monsters"]), before)
window.start_monitor.setChecked(True)
window.refresh(automated=True)
self.wait(window)
self.assertEqual(len(window.engine.snapshot.raw["monsters"]), before - 1)
window.token.setText("never-save-this-token")
window.key.setText("never-save-this-key")
window.password.setText("never-save-this-password")
window.save_config()
settings = (folder / "settings.json").read_text(encoding="utf-8")
self.assertNotIn("never-save-this-token", settings)
self.assertNotIn("never-save-this-key", settings)
self.assertNotIn("never-save-this-password", settings)
self.assertEqual(json.loads(settings)["policy"]["strategy"], "gold")
finally:
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):
from unittest.mock import Mock
with workspace_temp() as folder, patch.object(gui, "STATE", folder):
window = gui.Window()
window.timer.stop()
client = Mock()
try:
self.wait(window)
response = {"servers": [{"serverId": "1", "serverName": "一区"},
{"serverId": 2, "serverName": "二区"}], "masterInfos": [{"id": 9001, "serverId": 2, "roleName": "测试角色"}]}
window.result("password", (client, response, {}))
self.assertEqual(window.server_list.count(), 2)
window.server_list.setCurrentIndex(1)
self.assertIn("测试角色", window.server_list.currentText())
self.assertTrue(window.enter_button.isEnabled())
window.result("password", (client, {"servers": [{"serverName": "坏条目"}]}, {}))
self.assertFalse(window.enter_button.isEnabled())
self.assertEqual(window.server_list.count(), 0)
self.assertIsNone(window.password_login_result)
self.assertIn("serverName", window.log.toPlainText())
finally:
window.close()
def test_official_response_with_server_references_displays_both_characters(self):
from unittest.mock import Mock
with workspace_temp() as folder, patch.object(gui, "STATE", folder):
window = gui.Window()
window.timer.stop()
client = Mock()
try:
self.wait(window)
response = {"servers": [{"id": 1, "serverName": "测试一区"}, {"id": 2, "serverName": "测试二区"},
{"$ref": "$.servers[0]"}, {"$ref": "$.servers[1]"}],
"masterInfos": [{"id": 1001, "serverId": 1, "masterName": "测试角色甲"},
{"id": 2002, "serverId": 2, "masterName": "测试角色乙"}]}
window.result("password", (client, response, {}))
self.assertEqual(window.server_list.count(), 2)
self.assertIn("测试角色甲", window.server_list.itemText(0))
self.assertIn("测试角色乙", window.server_list.itemText(1))
window.server_list.setCurrentIndex(1)
self.assertEqual(window.server_list.currentData()["id"], 2)
self.assertTrue(window.enter_button.isEnabled())
self.assertNotIn("操作失败", window.login_status.text())
finally:
window.close()
def test_local_server_error_is_labeled_and_not_logged_twice(self):
with workspace_temp() as folder, patch.object(gui, "STATE", folder):
window = gui.Window()
window.timer.stop()
try:
self.wait(window)
window.trace.emit("error", "本地区服整理", scope="local", message="测试区服整理错误")
window.error("测试区服整理错误")
self.app.processEvents()
self.assertEqual(len(window.trace.events), 1)
self.assertEqual(window.debug_window.rows.rowCount(), 1)
self.assertEqual(window.debug_window.rows.item(0, 2).text(), "本地错误")
finally:
window.close()
def test_password_is_retained_after_failure_and_restored_on_restart_with_debug_records(self):
from ranch_assistant.api import ApiError
class FailedLogin:
def __init__(self, *args, trace, **kwargs):
self.trace = trace
def authenticate(self, account, password):
request = self.trace.begin("渠道账号验证", body={"account": account, "password": password})
self.trace.emit("response", "渠道账号验证", request_id=request, http_status=200, body={"code": 407})
raise ApiError("测试登录失败")
with workspace_temp() as folder, patch.object(gui, "STATE", folder):
window = gui.Window()
window.timer.stop()
try:
self.wait(window)
window.account.setText("local-gui-account")
window.password.setText("local-gui-password")
with patch.object(gui, "PasswordLogin", FailedLogin), patch.object(window, "show_debug") as show:
window.password_login()
self.wait(window)
show.assert_not_called()
self.assertEqual(window.password.text(), "local-gui-password")
self.assertGreaterEqual(window.debug_window.rows.rowCount(), 3)
text = window.trace.path.read_text(encoding="utf-8")
self.assertIn('"code": 407', text)
self.assertNotIn("local-gui-password", text)
self.assertFalse(window.enter_button.isEnabled())
finally:
window.close()
restored = gui.Window()
restored.timer.stop()
try:
self.wait(restored)
self.assertEqual(restored.account.text(), "local-gui-account")
self.assertEqual(restored.password.text(), "local-gui-password")
restored.remember_password.setChecked(False)
finally:
restored.close()
self.assertEqual(gui.CredentialStore(folder).load(), (False, "", ""))
if __name__ == "__main__":
unittest.main()
@@ -0,0 +1,301 @@
import copy
from dataclasses import asdict, replace
import os
import unittest
from unittest.mock import Mock, 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 Engine, demo_snapshot
from ranch_assistant.management import expansion_quote, manual_monster_actions
from ranch_assistant.model import Catalog, EggRule, Planner, Policy, Snapshot
from ranch_assistant import gui
from ranch_assistant.tests.test_core import workspace_temp
class ManualRuleTests(unittest.TestCase):
def setUp(self):
self.catalog = Catalog()
self.snapshot = demo_snapshot(self.catalog)
self.planner = Planner(self.catalog)
def rule(self, **values):
return asdict(EggRule(enabled=True, **values))
def test_only_checked_eggs_hatch_in_manual_priority_order(self):
slow = next(k for k, row in self.catalog.monsters.items() if row.get("star") == 1 and self.catalog.total_time(k) > 600)
self.snapshot.raw["stacks"] = [{"id": 1, "position": 0, "monsterId": -1}]
self.snapshot.raw["monsters"] = []
self.snapshot.raw["items"] = [{"id": 501, "typeId": 1001010, "num": 2}, {"id": 502, "typeId": int(slow), "num": 2}]
policy = Policy(manual_eggs=True, egg_rules={"1001010": self.rule(priority=20), slow: self.rule(priority=1)})
self.assertEqual(self.planner.plan(self.snapshot, policy)[0].payload["eggs"][0]["itemId"], 502)
policy.egg_rules[slow]["enabled"] = False
self.assertEqual(self.planner.plan(self.snapshot, policy)[0].payload["eggs"][0]["itemId"], 501)
policy.egg_rules["1001010"]["enabled"] = False
self.assertEqual(self.planner.plan(self.snapshot, policy), [])
def test_manual_disposition_overrides_legacy_strategy_and_feed_priority_skips_caps(self):
food = self.snapshot.raw["monsters"][0]
food.update(process=3, roomId=1)
self.planner.managed.add(food["id"])
primary = self.snapshot.monsters[900]
primary.update(potentialLevel=2, level=20)
secondary = dict(primary, id=901, level=9, potentialLevel=1)
self.snapshot.raw["monsters"].append(secondary)
policy = Policy(manual_eggs=True, strategy="gold", fill=False, protect_star=6, protect_quality=5,
egg_rules={str(food["typeId"]): self.rule(action="feed")}, feed_targets={"900": 1, "901": 2})
action = self.planner.plan(self.snapshot, policy)[0]
self.assertEqual(action.kind, "feed")
self.assertEqual(action.payload["targetId"], 901)
self.assertTrue(self.planner.protected(secondary, self.snapshot, policy))
secondary["level"] = 10
self.assertFalse(any(a.kind == "feed" for a in self.planner.plan(self.snapshot, policy)))
policy.egg_rules[str(food["typeId"])]["action"] = "sell"
self.assertEqual(self.planner.plan(self.snapshot, policy)[0].kind, "sell")
def test_restock_tracks_selected_type_and_market_pool_and_continues_to_target(self):
self.snapshot.raw["stacks"] = []
self.snapshot.raw["monsters"] = []
self.snapshot.raw["items"] = [{"id": 502, "typeId": 1002010, "num": 100}]
policy = Policy(manual_eggs=True, buy=True, fill=False, buy_ten=False, buy_batch=2,
egg_rules={"1001010": self.rule(refill_below=1, refill_target=5, market_id="sc_city1")})
self.assertEqual(self.planner.plan(self.snapshot, policy)[0].payload["num"], 2)
self.snapshot.raw["items"].append({"id": 501, "typeId": 1001010, "num": 2})
self.assertEqual(self.planner.plan(self.snapshot, policy)[0].payload["num"], 2)
self.snapshot.raw["items"][-1]["num"] = 5
self.assertEqual(self.planner.plan(self.snapshot, policy), [])
self.snapshot.raw["items"][-1]["num"] = 0
policy.egg_rules["1001010"]["market_id"] = "sc_city2"
self.assertEqual(self.planner.plan(self.snapshot, policy), [])
self.assertTrue(any("蛋池不包含" in note for note in self.planner.notes))
policy.egg_rules["1001010"]["market_id"] = "sc_city1"
policy.egg_rules["1001010"]["refill_below"] = 0
self.assertEqual(self.planner.plan(self.snapshot, policy), [])
def test_reference_stats_and_gift_preferences_have_shipped_data(self):
mon = {"typeId": 1001010, "level": 1, "feel": 0, "gAtk": 4.9, "gDef": 4.9, "gHp": 67, "gDex": 1.9}
self.assertEqual(self.catalog.reference_stats(mon), [28, 24, 335, 6])
mon["feel"] = 100
self.assertEqual(self.catalog.reference_stats(mon)[2], 351)
self.assertIn("(+5)", self.catalog.likes_text(1001010))
self.assertNotEqual(self.catalog.likes_text(1001010), "无已知偏好")
with self.assertRaises(ValueError):
Policy(egg_rules={"1001010": {"refill_below": 5, "refill_target": 2}})
class ManagementTests(unittest.TestCase):
def setUp(self):
self.catalog = Catalog()
self.snapshot = demo_snapshot(self.catalog)
def test_prices_use_open_types_not_stale_history_and_reject_vip_level_and_funds(self):
self.snapshot.raw["stacks"][0]["openType"] = 1
quote = expansion_quote(self.catalog, self.snapshot, "stack", "money", 6)
self.assertEqual((quote.cost, quote.index, quote.level), (2500, 1, 10))
self.assertEqual(quote.payload, {"openType": 1, "position": 6})
self.assertEqual(expansion_quote(self.catalog, self.snapshot, "room", "ke").cost, 150)
with self.assertRaisesRegex(ValueError, "VIP"):
expansion_quote(self.catalog, self.snapshot, "stack", "ke", 3)
self.snapshot.raw["master"]["ke"] = 0
with self.assertRaisesRegex(ValueError, "不足"):
expansion_quote(self.catalog, self.snapshot, "stack", "ke", 6)
self.snapshot.raw["master"]["level"] = 1
with self.assertRaisesRegex(ValueError, "级"):
expansion_quote(self.catalog, self.snapshot, "stack", "money", 6)
def test_changed_quote_cannot_charge_without_new_confirmation(self):
quote = expansion_quote(self.catalog, self.snapshot, "stack", "money", 6)
raw = copy.deepcopy(self.snapshot.raw)
raw["stacks"].append({"id": 99, "position": 7, "monsterId": -1, "openType": 1})
client = Mock()
client.snapshot.return_value = Snapshot(raw)
engine = Engine(self.catalog, client)
with self.assertRaisesRegex(ValueError, "已变化"):
engine.expand(quote)
client.call.assert_not_called()
def test_room_unlock_is_derived_from_completed_task(self):
self.snapshot.raw["history"].pop("openFarmBuild")
self.snapshot.raw["history"]["passTask"] = {"1001011": True}
self.assertEqual(expansion_quote(self.catalog, self.snapshot, "room", "money").cost, 1500)
self.snapshot.raw["history"]["passTask"] = {}
with self.assertRaisesRegex(ValueError, "解锁"):
expansion_quote(self.catalog, self.snapshot, "room", "money")
def test_real_api_payloads_add_stack_and_room_then_read_back(self):
state, calls = copy.deepcopy(self.snapshot.raw), []
class LocalClient:
def snapshot(self):
return Snapshot(copy.deepcopy(state))
def call(self, path, payload):
calls.append((path, payload))
if path == "stackService/stackOpen":
state["master"]["ke"] -= 110
state["stacks"].append({"id": 99, "position": payload["position"], "monsterId": -1, "openType": payload["openType"]})
elif path == "roomService/roomCreateByMoney":
state["master"]["money"] -= 1500
state["rooms"].append({"id": 99, "typeId": 1000, "openType": 1})
return {"resCode": 0}
engine = Engine(self.catalog, LocalClient())
engine.snapshot = self.snapshot
snapshot, _, _ = engine.expand(expansion_quote(self.catalog, self.snapshot, "stack", "ke", 6))
self.assertEqual(len(snapshot.raw["stacks"]), 7)
self.assertEqual(snapshot.raw["master"]["ke"], 1890)
snapshot, _, _ = engine.expand(expansion_quote(self.catalog, snapshot, "room", "money"))
self.assertEqual(len(snapshot.raw["rooms"]), 2)
self.assertEqual(calls, [("stackService/stackOpen", {"openType": 2, "position": 6}), ("roomService/roomCreateByMoney", {})])
def test_manual_dispatch_payloads_and_feed_guards(self):
self.snapshot.monsters[102]["process"] = 3
actions = manual_monster_actions(self.catalog, self.snapshot, "sell", [101, 102])
self.assertEqual([a.payload for a in actions], [{"monsterId": [101]}, {"monsterIds": [102]}])
action = manual_monster_actions(self.catalog, self.snapshot, "feed", [102], 900)[0]
self.assertEqual(action.payload, {"targetId": 900, "foods": [102]})
self.snapshot.monsters[900].update(level=20, potentialLevel=2)
with self.assertRaisesRegex(ValueError, "上限"):
manual_monster_actions(self.catalog, self.snapshot, "feed", [102], 900)
self.snapshot.monsters[101]["lock"] = 1
with self.assertRaisesRegex(ValueError, "锁定"):
manual_monster_actions(self.catalog, self.snapshot, "sell", [101])
class ManualGuiTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.app = W.QApplication.instance() or W.QApplication([])
def wait(self, window):
for _ in range(250):
self.app.processEvents()
QTest.qWait(5)
if not window.busy and window.slots.rowCount():
return
self.fail("Qt request did not complete")
def test_edit_rule_sort_zero_stock_and_restore_feed_targets(self):
with workspace_temp() as folder:
window = gui.Window(folder)
window.timer.stop()
try:
self.wait(window)
self.assertEqual(window.tabs.tabText(0), "登录")
key = window.eggs.item(0, 0).data(C.Qt.ItemDataRole.UserRole)
window.eggs.cellWidget(0, 3).setChecked(True)
window.eggs.cellWidget(0, 4).setValue(1)
action = window.eggs.cellWidget(0, 5)
action.setCurrentIndex(action.findData("feed"))
self.assertEqual(window.read_policy().egg_rules[key]["action"], "feed")
self.assertEqual(window.read_policy().egg_rules[key]["priority"], 1)
window.engine.snapshot.raw["items"] = [i for i in window.engine.snapshot.raw["items"] if str(i["typeId"]) != key]
window.render(window.engine.snapshot, [])
row = next(i for i in range(window.eggs.rowCount()) if window.eggs.item(i, 0).data(C.Qt.ItemDataRole.UserRole) == key)
self.assertEqual(window.eggs.item(row, 2).text(), "0")
self.assertTrue(window.eggs.cellWidget(row, 3).isChecked())
row = next(i for i in range(window.monsters.rowCount()) if window.monsters.item(i, 0).text() == "900")
window.monsters.cellWidget(row, 8).setChecked(True)
window.monsters.cellWidget(row, 9).setValue(1)
self.assertEqual(window.read_policy().feed_targets, {"900": 1})
self.assertFalse(window.server.isVisible())
window.save_config()
finally:
window.close()
restored = gui.Window(folder)
restored.timer.stop()
try:
self.wait(restored)
self.assertTrue(restored.egg_rules[key]["enabled"])
self.assertEqual(restored.egg_rules[key]["action"], "feed")
self.assertEqual(restored.feed_targets, {"900": 1})
self.assertFalse(restored.execute.isChecked())
finally:
restored.close()
def test_log_can_grow_hide_keep_records_and_restore_visibility(self):
with workspace_temp() as folder:
window = gui.Window(folder)
window.timer.stop()
window.show()
try:
self.wait(window)
window.log_splitter.setSizes([200, 300])
self.app.processEvents()
self.assertGreater(window.log.height(), 140)
window.show_log.click()
self.assertTrue(window.log.isHidden())
window.report("hidden-log-record")
self.assertIn("hidden-log-record", window.log.toPlainText())
saved_sizes = list(window.log_sizes)
window.show_log.click()
self.app.processEvents()
self.assertFalse(window.log.isHidden())
self.assertGreater(window.log.height(), 140)
self.assertEqual(window.log_sizes, saved_sizes)
window.show_log.click()
window.save_config()
finally:
window.close()
restored = gui.Window(folder)
restored.timer.stop()
try:
self.wait(restored)
self.assertFalse(restored.show_log.isChecked())
self.assertTrue(restored.log.isHidden())
self.assertEqual(restored.log_sizes, saved_sizes)
finally:
restored.close()
def test_paid_expansion_requires_confirmation_and_cancel_sends_nothing(self):
with workspace_temp() as folder:
window = gui.Window(folder)
window.timer.stop()
try:
self.wait(window)
with patch.object(gui.W.QMessageBox, "question", return_value=W.QMessageBox.StandardButton.No) as confirm, patch.object(window.engine, "expand") as expand:
window.request_expansion("stack", "ke")
expand.assert_not_called()
self.assertIn("110 氪金", confirm.call_args.args[2])
with patch.object(gui.W.QMessageBox, "question", return_value=W.QMessageBox.StandardButton.Yes):
window.request_expansion("stack", "ke")
self.wait(window)
self.assertEqual(len(window.engine.snapshot.raw["stacks"]), 7)
window.request_expansion("room", "money")
self.wait(window)
self.assertEqual(len(window.engine.snapshot.raw["rooms"]), 2)
self.assertEqual(window.slots.rowCount(), 11)
finally:
window.close()
def test_manual_dispatch_and_feed_preview_are_user_confirmed(self):
with workspace_temp() as folder:
window = gui.Window(folder)
window.timer.stop()
try:
self.wait(window)
def select(mid):
row = next(i for i in range(window.monsters.rowCount()) if window.monsters.item(i, 0).text() == str(mid))
window.monsters.selectRow(row)
select(101)
with patch.object(gui.W.QMessageBox, "question", return_value=W.QMessageBox.StandardButton.No):
window.request_monster_action("sell")
self.assertIn(101, window.engine.snapshot.monsters)
with patch.object(gui.W.QMessageBox, "question", return_value=W.QMessageBox.StandardButton.Yes):
window.request_monster_action("sell")
self.wait(window)
self.assertNotIn(101, window.engine.snapshot.monsters)
window.engine.snapshot.monsters[102].update(process=3, roomId=1)
window.render(window.engine.snapshot, [])
select(102)
target = window.engine.snapshot.monsters[900]
label = f"{window.catalog.monster(target['typeId']).get('name')} Lv.20/70 #900"
with patch.object(gui.W.QInputDialog, "getItem", return_value=(label, True)), patch.object(gui.W.QMessageBox, "question", return_value=W.QMessageBox.StandardButton.Yes):
window.request_monster_action("feed")
self.wait(window)
self.assertNotIn(102, window.engine.snapshot.monsters)
self.assertGreater(window.engine.snapshot.monsters[900]["exp"], 0)
finally:
window.close()
if __name__ == "__main__":
unittest.main()