Initialize local project and fix ranch growth synchronization
This commit is contained in:
@@ -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 在游戏中正常战斗。
|
||||
没有实现脱离手机的完整战斗模拟,也没有伪造胜利记录。
|
||||
@@ -0,0 +1 @@
|
||||
"""Native Qt companion for the supplied game client."""
|
||||
@@ -0,0 +1,3 @@
|
||||
from .gui import main
|
||||
|
||||
raise SystemExit(main())
|
||||
@@ -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()
|
||||
@@ -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}")
|
||||
@@ -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()
|
||||
@@ -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
|
||||
@@ -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
@@ -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")
|
||||
@@ -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()
|
||||
@@ -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)
|
||||
@@ -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}})
|
||||
@@ -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
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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)
|
||||
@@ -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)
|
||||
@@ -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
|
||||
@@ -0,0 +1,5 @@
|
||||
PySide6>=6.8,<7
|
||||
requests>=2.32,<3
|
||||
cryptography>=43
|
||||
Pillow>=11
|
||||
openpyxl>=3.1,<4
|
||||
@@ -0,0 +1,6 @@
|
||||
{
|
||||
"server_url": "",
|
||||
"token": "",
|
||||
"reqid": 0,
|
||||
"reqsid": 0
|
||||
}
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
Reference in New Issue
Block a user