Use main-window menus, cache maps, and handle settled sweep events

This commit is contained in:
AttilaNet
2026-11-08 11:10:07 +08:00
parent 2498f1f98f
commit dba667f21d
13 changed files with 578 additions and 33 deletions
+11 -5
View File
@@ -12,6 +12,9 @@
超过屏幕宽度的文字可横向滚动。 超过屏幕宽度的文字可横向滚动。
下拉框收起时悬停可查看完整选项,动态加载的区服、市场和魔物名称会重新计算宽度。 下拉框收起时悬停可查看完整选项,动态加载的区服、市场和魔物名称会重新计算宽度。
规则修改后自动保存并应用,无需点击保存按钮;连续输入会合并保存,尚未完整的输入不会覆盖已保存配置。 规则修改后自动保存并应用,无需点击保存按钮;连续输入会合并保存,尚未完整的输入不会覆盖已保存配置。
数字输入框仅在点击或键盘切换获得焦点后响应滚轮;未聚焦时滚动页面,不修改数字。
主窗口使用原生菜单栏:“账号”管理页签和保存会话,“监控”提供全部开始/停止,“策略配置”操作当前选中账号,“帮助 → 关于”显示版本号。
“保存当前账号策略”(Ctrl+S)可立即保存并应用当前配置,自动保存仍然有效。
勾选状态、优先级、孵出后的处理方式及保留数量都支持点击表头排序;刷新后保留排序,排序不改变策略优先级。 勾选状态、优先级、孵出后的处理方式及保留数量都支持点击表头排序;刷新后保留排序,排序不改变策略优先级。
表格中的编号和名称靠左,星级、数量、优先级等内容及勾选框居中显示。 表格中的编号和名称靠左,星级、数量、优先级等内容及勾选框居中显示。
@@ -35,7 +38,7 @@
空坑装填单独计时:有可用蛋时随机等待1~2秒装填一个坑位,确认成功后继续下一坑,不受整体刷新间隔影响。 空坑装填单独计时:有可用蛋时随机等待1~2秒装填一个坑位,确认成功后继续下一坑,不受整体刷新间隔影响。
每次装填前重新读取坑位和库存;无可用蛋、坑位已满或停止自动执行时暂停。此快速计时不会执行购蛋、派遣或其他操作。 每次装填前重新读取坑位和库存;无可用蛋、坑位已满或停止自动执行时暂停。此快速计时不会执行购蛋、派遣或其他操作。
子页分为“孵蛋策略”“牧场策略”“喂养策略”,内容超出高度时滚动显示,修改后自动保存并应用。 子页分为“孵蛋策略”“牧场策略”“喂养策略”,内容超出高度时滚动显示,修改后自动保存并应用。
- 统一策略配置:通过菜单“策略配置”导入、导出全部孵蛋、牧场、喂养、赠礼、委托、每日事务、扫荡及监控间隔设置,包含自定义收益资料。 - 统一策略配置:通过主窗口菜单“策略配置”,保存、导入或导出当前账号的全部孵蛋、牧场、喂养、赠礼、委托、每日事务、扫荡及监控间隔设置,包含自定义收益资料。
跨账号按魔物种类匹配喂养和赠礼目标;牧场实例编号不跨账号复制,默认使用有空位的牧场。兼容旧版培养策略文件。 跨账号按魔物种类匹配喂养和赠礼目标;牧场实例编号不跨账号复制,默认使用有空位的牧场。兼容旧版培养策略文件。
导入保留功能勾选和规则,执行保持停止,核对后手动开始;文件不包含账号、密码、Token、会话或本机路径。 导入保留功能勾选和规则,执行保持停止,核对后手动开始;文件不包含账号、密码、Token、会话或本机路径。
- 自动赠礼:独立页签,在背包勾选可用物品,在牧场勾选目标并设置优先级,再到“自动赠礼”启用。 - 自动赠礼:独立页签,在背包勾选可用物品,在牧场勾选目标并设置优先级,再到“自动赠礼”启用。
@@ -50,7 +53,8 @@
支持复制/导出,自动保存本地脱敏日志。 支持复制/导出,自动保存本地脱敏日志。
- 自动委托:按每日剩余接取次数、解锁城市和库存,接取、推进已满足条件的步骤、 - 自动委托:按每日剩余接取次数、解锁城市和库存,接取、推进已满足条件的步骤、
领取奖励;列表显示奖励金币和氪金数量。提交金币、道具、魔物分别受策略限制。战斗步骤等待游戏实际完成。 领取奖励;列表显示奖励金币和氪金数量。提交金币、道具、魔物分别受策略限制。战斗步骤等待游戏实际完成。
- 自动扫荡:按地区折叠显示安装包内的关卡、难度、掉落及账号解锁/通关记录, - 自动扫荡:按地区分组,默认折叠显示关卡、难度、掉落及账号解锁/通关记录。
首次读取后按账号/角色保存本地地图缓存,重启、切换页面或普通监控刷新均复用缓存,仅“刷新关卡”(或本页右键刷新)更新列表。
每关可勾选、选择已解锁难度和本日上限;满足游戏原有条件的普通关卡可接口扫荡, 每关可勾选、选择已解锁难度和本日上限;满足游戏原有条件的普通关卡可接口扫荡,
其余请在游戏内手动战斗。 其余请在游戏内手动战斗。
- 每日事务:集中查看每日签到礼包、七日签到、累计奖励、VIP日奖和邮件附件; - 每日事务:集中查看每日签到礼包、七日签到、累计奖励、VIP日奖和邮件附件;
@@ -61,7 +65,7 @@
## 连接真实角色 ## 连接真实角色
默认未登录,使用本地示例数据。顶部账号页签用于切换账号,“新增账号页签”用于登录另一账号。 默认未登录,使用本地示例数据。顶部账号页签用于切换账号,菜单“账号 → 新增账号页签”用于登录另一账号。
1. 在“登录”页填写第一弹渠道账号和密码,点击“账号密码登录并获取区服”。 1. 在“登录”页填写第一弹渠道账号和密码,点击“账号密码登录并获取区服”。
默认勾选“记住账号和密码”;编辑完、点击登录或关闭窗口时自动保存。 默认勾选“记住账号和密码”;编辑完、点击登录或关闭窗口时自动保存。
@@ -220,7 +224,7 @@
- 自定义表:`typeId, sell_money, sell_exp, time_total`(秒),可只提供部分 - 自定义表:`typeId, sell_money, sell_exp, time_total`(秒),可只提供部分
覆盖列;中文列名“编号、派遣金币、强化经验、孵化秒数”也支持。 覆盖列;中文列名“编号、派遣金币、强化经验、孵化秒数”也支持。
- 测试:`python -m unittest discover -s ranch_assistant/tests -v`。 - 测试:`python -m unittest discover -s ranch_assistant/tests -v`。
- 155 项本地测试通过,覆盖登录、会话隔离、请求计数、等级与体力结算、成长同步、孵蛋与补货、批量喂养、派遣、赠礼、统一策略配置、委托、扫荡和每日奖励。 - 166 项本地测试通过,覆盖登录、会话隔离、菜单账号路由、数字框滚轮、地图缓存、请求计数、等级与体力结算、成长同步、孵蛋与补货、批量喂养、派遣、赠礼、统一策略配置、委托、扫荡和每日奖励。
新增牧场树形/平铺切换、分组数量与空位、刷新保留折叠和控件、4S保留条件、随机刷新间隔及到期独立同步的回归测试。 新增牧场树形/平铺切换、分组数量与空位、刷新保留折叠和控件、4S保留条件、随机刷新间隔及到期独立同步的回归测试。
双账号与大量库存的界面响应继续通过测试;测试使用本地模拟数据和模拟服务,不操作真实账号库存。 双账号与大量库存的界面响应继续通过测试;测试使用本地模拟数据和模拟服务,不操作真实账号库存。
- 网络写请求发生异常后不会直接重试,以免重复消耗魔物或物品。 - 网络写请求发生异常后不会直接重试,以免重复消耗魔物或物品。
@@ -242,7 +246,9 @@
体力/金币/门票不足的关卡会显示原因并跳过。次数按角色、日期、关卡和难度保存, 体力/金币/门票不足的关卡会显示原因并跳过。次数按角色、日期、关卡和难度保存,
是本地已开始次数,不冒充服务器每日限制。 是本地已开始次数,不冒充服务器每日限制。
一次扫荡内部的几个请求顺序执行,完成后重读账号状态;开启其他策略时与孵蛋/委托逐轮串行。 一次扫荡内部的几个请求顺序执行,完成后重读账号状态;开启其他策略时与孵蛋/委托逐轮串行。
触发随机事件或请求结果不明确时停止,不提交后续结算;在游戏内处理后可清除本地待处理记录。 探索奖励事件由 `stageStart` 返回的 `stageEvent.result` 直接结算,无需提交 `battleEnd`,刷新角色后可继续下一轮。
旧版将此类奖励事件误记为未完成时,只在本地日志能匹配当前角色、关卡和成功响应的情况下自动解除阻塞,不重发请求。
隐藏关卡需要游戏内实战;缺失事件状态或请求结果不明确时保持待处理,避免重复扣体力,在游戏内确认处理后可清除本地记录。
“每日事务”选择要处理的奖励类别,点“领取勾选项目”可立即领取; “每日事务”选择要处理的奖励类别,点“领取勾选项目”可立即领取;
点“开始每日事务”会打开统一监控和自动执行,只处理符合状态的项目。 点“开始每日事务”会打开统一监控和自动执行,只处理符合状态的项目。
+46 -8
View File
@@ -27,14 +27,7 @@ class AccountsWindow(W.QMainWindow):
central = W.QWidget() central = W.QWidget()
layout = W.QVBoxLayout(central) layout = W.QVBoxLayout(central)
self.setCentralWidget(central) self.setCentralWidget(central)
toolbar = W.QHBoxLayout() self.setup_menus()
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 = W.QLabel("每个页签独立登录、保存 Token 和运行。切换页签不会停止其他账号;自动执行需在各账号里分别开启。")
note.setWordWrap(True) note.setWordWrap(True)
layout.addWidget(note) layout.addWidget(note)
@@ -54,6 +47,50 @@ class AccountsWindow(W.QMainWindow):
self.add_profile() self.add_profile()
gui.compact_layouts(central) gui.compact_layouts(central)
def setup_menus(self):
accounts = self.menuBar().addMenu("账号(&A)")
for text, handler in (("新增账号页签", self.add_profile), ("打开已保存账号…", self.choose_profile),
("恢复各页签的保存会话", self.resume_all)):
accounts.addAction(text, handler)
accounts.addSeparator()
accounts.addAction("退出", self.close)
monitoring = self.menuBar().addMenu("监控(&M)")
monitoring.addAction("全部开始监控", self.monitor_all)
monitoring.addAction("全部停止", self.stop_all)
strategies = self.menuBar().addMenu("策略配置(&S)")
self.save_policy_action = strategies.addAction("保存当前账号策略", self.save_current_policies)
self.save_policy_action.setShortcut("Ctrl+S")
self.import_policy_action = strategies.addAction("导入当前账号策略…",
lambda: self.run_account_action("import_policies"))
self.export_policy_action = strategies.addAction("导出当前账号策略…",
lambda: self.run_account_action("export_policies"))
self.policy_actions = (self.save_policy_action, self.import_policy_action, self.export_policy_action)
strategies.aboutToShow.connect(self.update_account_actions)
help_menu = self.menuBar().addMenu("帮助(&H)")
self.about_action = help_menu.addAction("关于…", self.show_about)
def update_account_actions(self):
window = self.tabs.currentWidget()
for action in self.policy_actions:
action.setEnabled(window is not None and not window.closed)
def run_account_action(self, method):
window = self.tabs.currentWidget()
if window is not None and not window.closed:
return getattr(window, method)()
def save_current_policies(self):
value = self.run_account_action("persist_settings")
if value is not None:
label = self.tabs.tabText(self.tabs.currentIndex())
self.statusBar().showMessage(f"已保存账号“{label}”的策略", 5000)
else:
self.statusBar().showMessage("策略尚未保存,请检查当前账号的输入和提示", 5000)
def show_about(self):
W.QMessageBox.about(self, "关于牧羊人之心牧场辅助",
f"牧羊人之心牧场辅助\n\n辅助版本:{gui.APP_VERSION}(开发中)\n适配游戏版本:{gui.GAME_VERSION}")
def open_profile(self, profile): def open_profile(self, profile):
identifier = profile["id"] identifier = profile["id"]
if identifier in self.windows: if identifier in self.windows:
@@ -83,6 +120,7 @@ class AccountsWindow(W.QMainWindow):
active = self.tabs.currentWidget() active = self.tabs.currentWidget()
for window in self.windows.values(): for window in self.windows.values():
window.set_presentation_active(window is active) window.set_presentation_active(window is active)
self.update_account_actions()
def choose_profile(self): def choose_profile(self):
if not self.profiles: if not self.profiles:
+24 -8
View File
@@ -2,9 +2,8 @@
from PySide6 import QtCore as C, QtWidgets as W from PySide6 import QtCore as C, QtWidgets as W
from .daily import DailyPolicy, entries from .daily import DailyPolicy, entries
from .maps import stages
from .native_widgets import ComboBox, IntegerInput, RowBatch from .native_widgets import ComboBox, IntegerInput, RowBatch
from .presentation import map_source from .stage_cache import StageCache
from .sweeping import SweepPolicy from .sweeping import SweepPolicy
from .table_widgets import SORT_ROLE, TreeItem, bind_controls, set_value, table_item from .table_widgets import SORT_ROLE, TreeItem, bind_controls, set_value, table_item
@@ -28,7 +27,7 @@ class ActivityPages:
self.only_unlocked.setChecked(True) self.only_unlocked.setChecked(True)
for widget in (self.map_search, self.only_unlocked): for widget in (self.map_search, self.only_unlocked):
line.addWidget(widget) line.addWidget(widget)
for label, function in (("刷新关卡", self.refresh), ("展开地区", lambda: self.maps_tree.expandAll()), for label, function in (("刷新关卡", self.refresh_maps), ("展开地区", lambda: self.maps_tree.expandAll()),
("折叠地区", lambda: self.maps_tree.collapseAll())): ("折叠地区", lambda: self.maps_tree.collapseAll())):
button = W.QPushButton(label) button = W.QPushButton(label)
button.clicked.connect(function) button.clicked.connect(function)
@@ -69,7 +68,7 @@ class ActivityPages:
for col, width in enumerate((100, 82, 160, 130, 70, 210, 120, 340, 100, 92)): for col, width in enumerate((100, 82, 160, 130, 70, 210, 120, 340, 100, 92)):
self.maps_tree.setColumnWidth(col, width) self.maps_tree.setColumnWidth(col, width)
layout.addWidget(self.maps_tree, 1) layout.addWidget(self.maps_tree, 1)
note = W.QLabel("星级来自实际通关难度,不能手动修改。普通关卡三个难度全部通关后可扫荡;每行勾选、选择难度并输入本日次数上限。\n未满足扫荡条件的关卡请在游戏内手动战斗;扫荡按表格顺序逐关执行,使用所选战队。掉落来自安装包配置,随机物品并非必掉。") note = W.QLabel("地图按账号保存在本地,点击“刷新关卡”才更新列表。星级来自实际通关难度,不能手动修改。\n普通关卡三个难度全部通关后可扫荡;未满足条件的关卡请在游戏内手动战斗。每行勾选、选择难度并输入本日次数上限,使用所选战队。随机掉落并非必得。")
note.setWordWrap(True) note.setWordWrap(True)
layout.addWidget(note) layout.addWidget(note)
self.tabs.addTab(self.map_page, "自动扫荡") self.tabs.addTab(self.map_page, "自动扫荡")
@@ -83,6 +82,21 @@ class ActivityPages:
import copy import copy
return SweepPolicy(self.map_enabled.isChecked(), copy.deepcopy(self.map_rules), self.map_keep_ti.value(), self.map_team.currentData()) return SweepPolicy(self.map_enabled.isChecked(), copy.deepcopy(self.map_rules), self.map_keep_ti.value(), self.map_team.currentData())
def reset_map_view(self):
if hasattr(self, "map_render_timer"):
self.map_render_timer.stop()
self.maps_tree.clear()
self._map_items, self._map_cities = {}, {}
def refresh_maps(self):
if self.closed:
return
if self.busy:
self.pending_refresh = self.map_page
self.statusBar().showMessage("当前请求完成后刷新关卡")
return
self.submit("map_refresh", self.engine.refresh_stages)
def activity_settings_changed(self, *args): def activity_settings_changed(self, *args):
if self.closed or self.loading_config: if self.closed or self.loading_config:
return return
@@ -114,8 +128,9 @@ class ActivityPages:
if isinstance(focused, W.QLineEdit) and self.maps_tree.isAncestorOf(focused): if isinstance(focused, W.QLineEdit) and self.maps_tree.isAncestorOf(focused):
return return
snapshot = self.engine.snapshot snapshot = self.engine.snapshot
views = self.prepared_views if self.engine.stage_cache.catalog is not self.catalog:
all_rows = views.maps if views and views.snapshot is snapshot and views.map_source == map_source(snapshot) else stages(self.catalog, snapshot) self.engine.stage_cache = StageCache(self.catalog)
all_rows = self.engine.stage_cache.get(snapshot)
grouped = {} grouped = {}
for row in all_rows: for row in all_rows:
grouped.setdefault(row.stage_id, []).append(row) grouped.setdefault(row.stage_id, []).append(row)
@@ -141,7 +156,6 @@ class ActivityPages:
self.map_render_timer = RowBatch(self) self.map_render_timer = RowBatch(self)
wanted = {row[0] for row in visible} wanted = {row[0] for row in visible}
operations = [("remove", key) for key in self._map_items if key not in wanted] + [("row", row) for row in visible] operations = [("remove", key) for key in self._map_items if key not in wanted] + [("row", row) for row in visible]
first_render = not self.maps_tree.topLevelItemCount()
self.maps_tree.setSortingEnabled(False) self.maps_tree.setSortingEnabled(False)
def apply(operation): def apply(operation):
kind, data = operation kind, data = operation
@@ -156,8 +170,10 @@ class ActivityPages:
if city is None: if city is None:
city = TreeItem(self.maps_tree, [first.city_name]) city = TreeItem(self.maps_tree, [first.city_name])
city.setFirstColumnSpanned(True) city.setFirstColumnSpanned(True)
city.setExpanded(first_render or bool(query)) city.setExpanded(bool(query))
self._map_cities[first.city] = city self._map_cities[first.city] = city
elif query:
city.setExpanded(True)
item = self._map_items.get(key) item = self._map_items.get(key)
if item is None: if item is None:
item = TreeItem(city) item = TreeItem(city)
+19 -1
View File
@@ -11,6 +11,7 @@ from .market import PurchaseBudget
from .management import expansion_quote, manual_monster_actions from .management import expansion_quote, manual_monster_actions
from .gifts import GiftPlanner from .gifts import GiftPlanner
from .master_sync import MasterSync from .master_sync import MasterSync
from .stage_cache import StageCache
class Engine: class Engine:
@@ -35,6 +36,7 @@ class Engine:
self.master_sync = MasterSync(catalog) self.master_sync = MasterSync(catalog)
self.last_executed = False self.last_executed = False
folder = Path(budget_path).parent if budget_path else None folder = Path(budget_path).parent if budget_path else None
self.stage_cache = StageCache(catalog, folder / "maps.json" if folder else None)
self.daily_policy = DailyPolicy() self.daily_policy = DailyPolicy()
self.daily_ledger = DailyLedger(folder / "daily_claims.json" if folder else None) self.daily_ledger = DailyLedger(folder / "daily_claims.json" if folder else None)
self.sweep_policy = SweepPolicy() self.sweep_policy = SweepPolicy()
@@ -72,6 +74,7 @@ class Engine:
mon.update({field: entry[field] for field in fields if field in entry}) mon.update({field: entry[field] for field in fields if field in entry})
rows.append(mon) rows.append(mon)
self.snapshot.raw["monsters"] = rows self.snapshot.raw["monsters"] = rows
self.sweeper.recover_reward_event(self.snapshot, getattr(getattr(self.client, "trace", None), "path", None))
return self.snapshot return self.snapshot
def master_sync_due(self): def master_sync_due(self):
@@ -81,6 +84,15 @@ class Engine:
self.read_snapshot() self.read_snapshot()
return self.snapshot, self.plans(), "已同步等级 / 体力" return self.snapshot, self.plans(), "已同步等级 / 体力"
def refresh_stages(self):
self.auto = False
if not self.demo:
self.read_snapshot()
elif self.snapshot is None:
self.snapshot = demo_snapshot(self.catalog)
self.stage_cache.get(self.snapshot, refresh=True)
return self.snapshot, self.plans(), "已刷新关卡并保存当前账号的地图缓存"
def remember_growth(self, response): def remember_growth(self, response):
# MonsterCenter.checkGrowUpHandler treats these two arrays as the # MonsterCenter.checkGrowUpHandler treats these two arrays as the
# authoritative stage and growth values, including after a stale read. # authoritative stage and growth values, including after a stale read.
@@ -156,6 +168,9 @@ class Engine:
if not hatch_only: if not hatch_only:
settled = self.settle_pending_growth() settled = self.settle_pending_growth()
message = "状态已刷新" + (";已请求孵化 / 成长结算" if settled else "") message = "状态已刷新" + (";已请求孵化 / 成长结算" if settled else "")
if self.sweeper.recovered_event:
message += ";已解除旧版对已结算奖励事件的误阻塞"
self.sweeper.recovered_event = False
if self.snapshot.growth_pending(self.catalog): if self.snapshot.growth_pending(self.catalog):
message += ";成长状态等待服务器确认,将自动检查" message += ";成长状态等待服务器确认,将自动检查"
try: try:
@@ -177,8 +192,11 @@ class Engine:
stage = self.sweeper.next(self.snapshot, self.sweep_policy) stage = self.sweeper.next(self.snapshot, self.sweep_policy)
if self.demo: if self.demo:
return self.snapshot, plans, "扫荡需要登录真实账号;演示不会提交战斗" return self.snapshot, plans, "扫荡需要登录真实账号;演示不会提交战斗"
self.sweeper.run(self.client, self.snapshot, stage, self.sweep_policy) result = self.sweeper.run(self.client, self.snapshot, stage, self.sweep_policy)
self.read_snapshot() self.read_snapshot()
if self.sweeper.last_outcome == "event":
from .maps import reward_summary
return self.snapshot, self.plans(), f"探索奖励事件已结算:{stage.number} {stage.name} / 难度{stage.level};" + reward_summary(self.catalog, result["stageEvent"]["result"])
return self.snapshot, self.plans(), f"扫荡完成:{stage.number} {stage.name} / 难度{stage.level}" return self.snapshot, self.plans(), f"扫荡完成:{stage.number} {stage.name} / 难度{stage.level}"
if action.kind == "buy": if action.kind == "buy":
price = int(self.catalog.data["markets"][action.payload["id"]]["money"]) price = int(self.catalog.data["markets"][action.payload["id"]]["money"])
+19 -8
View File
@@ -14,7 +14,7 @@ from .engine import Engine
from .model import Catalog, Policy, WIKI, duration from .model import Catalog, Policy, WIKI, duration
from .egg_rules_gui import EggTable from .egg_rules_gui import EggTable
from .management import expansion_quote, manual_monster_actions from .management import expansion_quote, manual_monster_actions
from .native_widgets import ComboBox, use_native_scrollbars from .native_widgets import ComboBox, SpinBox, DoubleSpinBox, use_native_scrollbars
from .login import PasswordLogin, device_id, server_labels from .login import PasswordLogin, device_id, server_labels
from .quests import QuestPolicy from .quests import QuestPolicy
from .daily import DailyPolicy from .daily import DailyPolicy
@@ -29,8 +29,10 @@ from .inventory_gui import ITEM_TYPES, InventoryTable
from .ranch_gui import RanchView from .ranch_gui import RanchView
from .policy_io import portable_config, import_config from .policy_io import portable_config, import_config
from .table_widgets import table_item from .table_widgets import table_item
from .stage_cache import StageCache
APP_VERSION = "1.1.0" APP_VERSION = "1.1.0"
GAME_VERSION = "1.9.68"
ROOT = Path(sys.executable).parent if getattr(sys, "frozen", False) else Path(__file__).resolve().parent.parent ROOT = Path(sys.executable).parent if getattr(sys, "frozen", False) else Path(__file__).resolve().parent.parent
STATE = ROOT / "local_state" / "ranch_helper" STATE = ROOT / "local_state" / "ranch_helper"
@@ -58,7 +60,7 @@ class Job(C.QRunnable):
def spin(low, high, value, decimals=False): def spin(low, high, value, decimals=False):
widget = W.QDoubleSpinBox() if decimals else W.QSpinBox() widget = DoubleSpinBox() if decimals else SpinBox()
widget.setRange(low, high) widget.setRange(low, high)
widget.setValue(value) widget.setValue(value)
return widget return widget
@@ -287,9 +289,6 @@ class Window(ActivityPages, W.QMainWindow):
self.plans, self.yields.parentWidget()] self.plans, self.yields.parentWidget()]
for page in order: for page in order:
self.tabs.addTab(page, self.tabs.tabText(self.tabs.indexOf(page))) self.tabs.addTab(page, self.tabs.tabText(self.tabs.indexOf(page)))
strategies = self.menuBar().addMenu("策略配置")
strategies.addAction("导入全部策略…", self.import_policies)
strategies.addAction("导出全部策略…", self.export_policies)
self.monster_view.currentIndexChanged.connect(self.monster_view_changed) self.monster_view.currentIndexChanged.connect(self.monster_view_changed)
self.monster_room.currentIndexChanged.connect(self.monster_view_changed) self.monster_room.currentIndexChanged.connect(self.monster_view_changed)
self.monster_view.setCurrentIndex(self.monster_view.findData(0)) self.monster_view.setCurrentIndex(self.monster_view.findData(0))
@@ -1003,6 +1002,8 @@ class Window(ActivityPages, W.QMainWindow):
if tab is self.yields.parentWidget(): if tab is self.yields.parentWidget():
self.render_catalog() self.render_catalog()
self.report("收益资料已从本地表刷新") self.report("收益资料已从本地表刷新")
elif tab is self.map_page:
self.refresh_maps()
else: else:
self.refresh() self.refresh()
@@ -1106,11 +1107,16 @@ class Window(ActivityPages, W.QMainWindow):
def background(): def background():
started = time.perf_counter() started = time.perf_counter()
value = function() value = function()
if kind in ("poll", "hatch", "monster_lock", "manual_monsters", "expansion", "growth_sync", "master_sync", "daily_claim", "connected"): if kind in ("poll", "hatch", "monster_lock", "manual_monsters", "expansion", "growth_sync", "master_sync", "map_refresh", "daily_claim", "connected"):
snapshot = value[1] if kind == "connected" else value[0] snapshot = value[1] if kind == "connected" else value[0]
managed = set() if kind == "connected" else set(engine.planner.managed) managed = set() if kind == "connected" else set(engine.planner.managed)
preparing = time.perf_counter() preparing = time.perf_counter()
views = prepare_views(catalog, snapshot, managed) cache = engine.stage_cache
if kind == "connected":
session = value[0].session
folder = self.profile_root / "roles" / identity(session) if isinstance(session, Session) and session.role_id else self.state
cache = StageCache(catalog, folder / "maps.json")
views = prepare_views(catalog, snapshot, managed, cache)
return Presented(value, views, (time.perf_counter() - preparing) * 1000, (time.perf_counter() - started) * 1000) return Presented(value, views, (time.perf_counter() - preparing) * 1000, (time.perf_counter() - started) * 1000)
return value return value
job = Job(kind, background) job = Job(kind, background)
@@ -1153,7 +1159,7 @@ class Window(ActivityPages, W.QMainWindow):
note="worker总耗时包含网络;大列表在后续短批次更新") note="worker总耗时包含网络;大列表在后续短批次更新")
def apply_result(self, kind, value): def apply_result(self, kind, value):
if kind in ("poll", "hatch", "monster_lock", "manual_monsters", "expansion", "growth_sync", "master_sync", "daily_claim"): if kind in ("poll", "hatch", "monster_lock", "manual_monsters", "expansion", "growth_sync", "master_sync", "map_refresh", "daily_claim"):
snapshot, plans, message = value snapshot, plans, message = value
self.render(snapshot, plans) self.render(snapshot, plans)
self.report(message) self.report(message)
@@ -1177,6 +1183,9 @@ class Window(ActivityPages, W.QMainWindow):
self.engine.client.close() self.engine.client.close()
self.engine = Engine(self.catalog, client, self.state / "purchase_budget.json") self.engine = Engine(self.catalog, client, self.state / "purchase_budget.json")
self.engine.snapshot = snapshot self.engine.snapshot = snapshot
if self.prepared_views and self.prepared_views.snapshot is snapshot and self.prepared_views.stage_cache:
self.engine.stage_cache = self.prepared_views.stage_cache
self.reset_map_view()
if isinstance(client.session, Session): if isinstance(client.session, Session):
if client.session.account_name and client.session.account_name != self.account.text().strip(): if client.session.account_name and client.session.account_name != self.account.text().strip():
_, saved_account, saved_password = self.credentials.load() _, saved_account, saved_password = self.credentials.load()
@@ -1556,6 +1565,7 @@ class Window(ActivityPages, W.QMainWindow):
self.engine.client.persist_session() self.engine.client.persist_session()
self.engine.client.close() self.engine.client.close()
self.engine = Engine(self.catalog) self.engine = Engine(self.catalog)
self.reset_map_view()
self.active_identity = None self.active_identity = None
self.state = self.profile_root self.state = self.profile_root
self.load_config(copy.deepcopy(self.default_config)) self.load_config(copy.deepcopy(self.default_config))
@@ -1684,6 +1694,7 @@ class Window(ActivityPages, W.QMainWindow):
self.next_poll = 0 self.next_poll = 0
self.arm_hatching() self.arm_hatching()
self.statusBar().showMessage("规则已自动保存并应用", 3000) self.statusBar().showMessage("规则已自动保存并应用", 3000)
return value
def save_config(self, *args, quiet=False): def save_config(self, *args, quiet=False):
try: try:
+40
View File
@@ -3,6 +3,27 @@ from PySide6 import QtCore as C, QtGui as G, QtWidgets as W
import time import time
class FocusWheelMixin:
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
# StrongFocus permits click/keyboard focus, but never wheel focus.
self.setFocusPolicy(C.Qt.FocusPolicy.StrongFocus)
def wheelEvent(self, event):
if not self.hasFocus():
event.ignore()
return
super().wheelEvent(event)
class SpinBox(FocusWheelMixin, W.QSpinBox):
pass
class DoubleSpinBox(FocusWheelMixin, W.QDoubleSpinBox):
pass
class ComboBox(W.QComboBox): class ComboBox(W.QComboBox):
"""Size popups for their text, independently of narrow table columns.""" """Size popups for their text, independently of narrow table columns."""
def __init__(self, parent=None): def __init__(self, parent=None):
@@ -129,6 +150,8 @@ class IntegerInput(W.QLineEdit):
def __init__(self): def __init__(self):
super().__init__() super().__init__()
self._value, self._minimum, self._maximum = 0, 0, 2147483647 self._value, self._minimum, self._maximum = 0, 0, 2147483647
self._wheel_delta = 0
self.setFocusPolicy(C.Qt.FocusPolicy.StrongFocus)
self.setValidator(G.QIntValidator(self._minimum, self._maximum, self)) self.setValidator(G.QIntValidator(self._minimum, self._maximum, self))
self.setText("0") self.setText("0")
self.setMinimumWidth(76) self.setMinimumWidth(76)
@@ -165,6 +188,23 @@ class IntegerInput(W.QLineEdit):
def finish_number(self): def finish_number(self):
self.setValue(self._value) self.setValue(self._value)
def wheelEvent(self, event):
if not self.hasFocus() or not event.angleDelta().y():
event.ignore()
return
self._wheel_delta += event.angleDelta().y()
steps = int(self._wheel_delta / 120)
self._wheel_delta -= steps * 120
if steps:
if event.modifiers() & C.Qt.KeyboardModifier.ControlModifier:
steps *= 10
self.setValue(self.value() + steps)
event.accept()
def focusOutEvent(self, event):
self._wheel_delta = 0
super().focusOutEvent(event)
class NativeScrollStyle(W.QProxyStyle): class NativeScrollStyle(W.QProxyStyle):
def pixelMetric(self, metric, option=None, widget=None): def pixelMetric(self, metric, option=None, widget=None):
+3 -2
View File
@@ -25,6 +25,7 @@ class Views:
monsters: list monsters: list
map_source: str map_source: str
maps: list maps: list
stage_cache: object = None
@dataclass @dataclass
@@ -35,6 +36,6 @@ class Presented:
worker_ms: float = 0 worker_ms: float = 0
def prepare_views(catalog, snapshot, managed): def prepare_views(catalog, snapshot, managed, stage_cache=None):
return Views(snapshot, repr(snapshot.raw["monsters"]), set(managed), monster_rows(catalog, snapshot, managed), return Views(snapshot, repr(snapshot.raw["monsters"]), set(managed), monster_rows(catalog, snapshot, managed),
map_source(snapshot), stages(catalog, snapshot)) str(snapshot.raw["master"]["id"]), stage_cache.get(snapshot) if stage_cache else stages(catalog, snapshot), stage_cache)
+42
View File
@@ -0,0 +1,42 @@
"""Per-role map list, captured once and replaced only on explicit refresh."""
from dataclasses import asdict
import json
from pathlib import Path
from .maps import Stage, stages
class StageCache:
def __init__(self, catalog, path=None):
self.catalog = catalog
self.path = Path(path) if path else None
self.owner = None
self.rows = None
self.saved_at = 0
self.revision = 0
def get(self, snapshot, *, refresh=False):
owner = str(snapshot.raw["master"]["id"])
if not refresh and self.rows is not None and self.owner == owner:
return self.rows
if not refresh and self.path and self.path.exists():
try:
value = json.loads(self.path.read_text(encoding="utf-8"))
if value.get("schema") == 1 and value.get("gameVersion") == "1.9.68" and value.get("owner") == owner:
self.rows = [Stage(**row) for row in value["stages"]]
self.owner, self.saved_at = owner, float(value["savedAt"])
self.revision += 1
return self.rows
except (OSError, ValueError, TypeError, KeyError, AttributeError):
pass
rows = stages(self.catalog, snapshot)
saved_at = snapshot.now
if self.path:
self.path.parent.mkdir(parents=True, exist_ok=True)
temporary = self.path.with_suffix(".tmp")
temporary.write_text(json.dumps({"schema": 1, "gameVersion": "1.9.68", "owner": owner,
"savedAt": saved_at, "stages": [asdict(row) for row in rows]}, ensure_ascii=False), encoding="utf-8")
temporary.replace(self.path)
self.rows, self.owner, self.saved_at = rows, owner, saved_at
self.revision += 1
return self.rows
+76 -1
View File
@@ -7,6 +7,13 @@ from .daily import day
from .maps import stages from .maps import stages
def settled_reward_event(response):
event = response.get("stageEvent")
return (response.get("triggerEvent") in (True, 1) and isinstance(event, dict)
and event.get("resCode", 0) in (0, "0") and event.get("hideStageId") is None
and isinstance(event.get("result"), dict))
@dataclass @dataclass
class SweepPolicy: class SweepPolicy:
enabled: bool = False enabled: bool = False
@@ -20,6 +27,60 @@ class SweepRunner:
self.catalog = catalog self.catalog = catalog
self.path = Path(path) if path else None self.path = Path(path) if path else None
self.state = json.loads(self.path.read_text(encoding="utf-8")) if self.path and self.path.exists() else {"counts": {}, "pending": None} self.state = json.loads(self.path.read_text(encoding="utf-8")) if self.path and self.path.exists() else {"counts": {}, "pending": None}
self.last_outcome = ""
self.recovery_checked = False
self.recovered_event = False
def recover_reward_event(self, snapshot, trace_path):
"""Repair only old reward-event blocks with a role-matched log reply.
This never replays a start or settlement request. Missing/ambiguous
evidence leaves the pending record intact.
"""
pending = self.state.get("pending")
if (self.recovery_checked or not trace_path or not pending
or pending.get("phase") != "遇到事件或响应缺少事件状态,请在游戏内处理"):
return False
self.recovery_checked = True
role, requests, last_reply = None, {}, None
owner = snapshot.raw["master"]["id"]
path = Path(trace_path)
try:
for file in (path.with_name("network_debug.previous.jsonl"), path):
if not file.exists():
continue
with file.open(encoding="utf-8") as stream:
for line in stream:
try:
event = json.loads(line)
except ValueError:
continue
body = event.get("body")
if not isinstance(body, dict):
continue
if event.get("operation") == "读取角色" and event.get("kind") == "response":
role = (body.get("master") or {}).get("id")
if event.get("operation") != "stageService/stageStart":
continue
identifier = event.get("request_id")
if not isinstance(identifier, str) or not identifier:
continue
if event.get("kind") == "request":
matched = (str(role) == str(owner) and str(body.get("stageTypeId")) == pending["stage"]
and str(body.get("stageLevel")) == str(pending["level"]))
requests[identifier] = matched
if matched:
last_reply = None
elif event.get("kind") == "response" and requests.get(identifier):
last_reply = body if event.get("http_status") == 200 and body.get("resCode") in (0, "0") else None
except (OSError, ValueError, TypeError, AttributeError):
return False
if last_reply and settled_reward_event(last_reply):
self.state["pending"] = None
self.save()
self.recovered_event = True
return True
return False
def save(self): def save(self):
if self.path: if self.path:
@@ -78,6 +139,7 @@ class SweepRunner:
return None return None
def run(self, client, snapshot, stage, policy): def run(self, client, snapshot, stage, policy):
self.last_outcome = ""
rule = policy.rules.get(stage.stage_id) or {} rule = policy.rules.get(stage.stage_id) or {}
if not rule.get("enabled") or str(rule.get("level")) != stage.level or self.used(snapshot, stage) >= int(rule.get("limit") or 0): if not rule.get("enabled") or str(rule.get("level")) != stage.level or self.used(snapshot, stage) >= int(rule.get("limit") or 0):
raise ValueError("此关卡未勾选或已达本日次数上限") raise ValueError("此关卡未勾选或已达本日次数上限")
@@ -89,9 +151,21 @@ class SweepRunner:
self.state["pending"] = {"stage": stage.stage_id, "level": stage.level, "phase": "开始请求待确认"} self.state["pending"] = {"stage": stage.stage_id, "level": stage.level, "phase": "开始请求待确认"}
self.save() # Reserve before the first non-retryable write, including timeouts. self.save() # Reserve before the first non-retryable write, including timeouts.
started = client.call("stageService/stageStart", {"stageTypeId": stage.stage_id, "stageLevel": stage.level}) started = client.call("stageService/stageStart", {"stageTypeId": stage.stage_id, "stageLevel": stage.level})
if settled_reward_event(started):
# StageCenter.startStageHandler applies stageEvent.result directly;
# StageStartPanel shows it and returns, without battleEnd.
self.state["pending"] = None
self.save()
self.last_outcome = "event"
return started
flag = started.get("triggerEvent") flag = started.get("triggerEvent")
if flag is not False and not (type(flag) is int and flag == 0): if flag is not False and not (type(flag) is int and flag == 0):
self.state["pending"]["phase"] = "遇到事件或响应缺少事件状态,请在游戏内处理" event = started.get("stageEvent")
if isinstance(event, dict) and event.get("hideStageId") is not None:
phase = "遭遇隐藏关卡,请在游戏内手动战斗"
else:
phase = "事件结果或开始状态尚未确认,请在游戏内检查"
self.state["pending"]["phase"] = phase
self.save() self.save()
raise ValueError(self.state["pending"]["phase"]) raise ValueError(self.state["pending"]["phase"])
# Exactly the official doSaodangBattle data; only for its eligible stages. # Exactly the official doSaodangBattle data; only for its eligible stages.
@@ -104,4 +178,5 @@ class SweepRunner:
self.state["pending"] = None self.state["pending"] = None
self.save() self.save()
client.call("battleService/recordBattleResult", {"stageId": stage.stage_id, "cityId": stage.stage_id[1:2], "result": 1}) client.call("battleService/recordBattleResult", {"stageId": stage.stage_id, "cityId": stage.stage_id[1:2], "result": 1})
self.last_outcome = "sweep"
return result return result
+76
View File
@@ -117,6 +117,82 @@ class AccountGuiTests(unittest.TestCase):
window.result("connected", (client, Snapshot(role_snapshot(window.catalog, role_id)))) window.result("connected", (client, Snapshot(role_snapshot(window.catalog, role_id))))
return client return client
def test_main_menu_routes_strategy_actions_to_selected_account_and_saves_immediately(self):
with workspace_temp() as folder:
hub = AccountsWindow(folder)
hub.add_profile()
windows = list(hub.windows.values())
for window in windows:
window.timer.stop()
try:
self.wait(windows)
first, second = windows
first.keep_money.setValue(1234)
second.keep_money.setValue(5678)
for window in windows:
window.auto_save_timer.stop()
for selected, other, expected in ((first, second, 1234), (second, first, 5678)):
hub.tabs.setCurrentWidget(selected)
with patch.object(selected, "import_policies") as imported, patch.object(other, "import_policies") as other_imported:
hub.import_policy_action.trigger()
imported.assert_called_once_with()
other_imported.assert_not_called()
with patch.object(selected, "export_policies") as exported, patch.object(other, "export_policies") as other_exported:
hub.export_policy_action.trigger()
exported.assert_called_once_with()
other_exported.assert_not_called()
with patch.object(other, "persist_settings") as other_saved:
hub.save_policy_action.trigger()
other_saved.assert_not_called()
saved = json.loads((selected.state / "settings.json").read_text(encoding="utf-8"))
self.assertEqual(saved["policy"]["keep_money"], expected)
self.assertEqual(selected.engine.policy.keep_money, expected)
self.assertFalse(selected.execute.isChecked())
finally:
hub.close()
def test_only_main_window_has_menus_and_about_shows_versions(self):
with workspace_temp() as folder:
hub = AccountsWindow(folder)
windows = list(hub.windows.values())
for window in windows:
window.timer.stop()
try:
self.wait(windows)
self.assertEqual([action.text().split("(")[0] for action in hub.menuBar().actions()],
["账号", "监控", "策略配置", "帮助"])
for window in windows:
self.assertIsNone(window.findChild(W.QMenuBar))
labels = {button.text() for button in hub.findChildren(W.QPushButton)}
for label in ("新增账号页签", "打开已保存账号", "恢复各页签的保存会话", "全部开始监控", "全部停止"):
self.assertNotIn(label, labels)
with patch.object(W.QMessageBox, "about") as about:
hub.about_action.trigger()
self.assertIn(gui.APP_VERSION, about.call_args.args[2])
self.assertIn(gui.GAME_VERSION, about.call_args.args[2])
finally:
hub.close()
def test_strategy_menu_disables_when_no_account_is_open(self):
with workspace_temp() as folder:
hub = AccountsWindow(folder)
windows = list(hub.windows.values())
for window in windows:
window.timer.stop()
try:
self.wait(windows)
hub.close_profile(0)
self.assertEqual(hub.tabs.count(), 0)
self.assertTrue(all(not action.isEnabled() for action in hub.policy_actions))
hub.add_profile()
windows = list(hub.windows.values())
for window in windows:
window.timer.stop()
self.wait(windows)
self.assertTrue(all(action.isEnabled() for action in hub.policy_actions))
finally:
hub.close()
def test_closed_fresh_tab_does_not_start_queued_refresh_and_can_reopen(self): def test_closed_fresh_tab_does_not_start_queued_refresh_and_can_reopen(self):
with workspace_temp() as folder: with workspace_temp() as folder:
hub = AccountsWindow(folder) hub = AccountsWindow(folder)
+48
View File
@@ -112,6 +112,54 @@ class ActivityTests(unittest.TestCase):
runner.run(client, self.snapshot, self.stage(), policy) runner.run(client, self.snapshot, self.stage(), policy)
self.assertTrue(SweepRunner(self.catalog, folder / "runs.json").state["pending"]) self.assertTrue(SweepRunner(self.catalog, folder / "runs.json").state["pending"])
def test_reward_event_is_already_settled_and_does_not_block_next_sweep(self):
runner = SweepRunner(self.catalog)
policy = SweepPolicy(True, {"0101": {"enabled": True, "level": "3", "limit": 3}})
client = FakeClient(self.snapshot)
response = {"resCode": 0, "triggerEvent": True, "stageEvent": {"resCode": 0,
"typeId": "300007", "hideStageId": None, "costTi": 16,
"result": {"money": 32, "exp": 64, "items": [], "monsters": [], "ti": 0, "ke": 0}}}
def call(path, payload=None):
client.calls.append((path, payload))
if path == "stageService/stageStart":
return response
raise AssertionError("Reward events do not submit a battle result")
client.call = call
result = runner.run(client, self.snapshot, self.stage(), policy)
self.assertIs(result, response)
self.assertIsNone(runner.state["pending"])
self.assertIsNotNone(runner.next(self.snapshot, policy))
self.assertEqual(len(client.calls), 1)
def test_legacy_event_block_recovers_only_from_role_matched_successful_reward_reply(self):
with workspace_temp() as folder:
trace = folder / "network_debug.jsonl"
for role, hidden, http_status, recovered in ((123456, None, 200, False),
(self.snapshot.raw["master"]["id"], "hidden", 200, False),
(self.snapshot.raw["master"]["id"], None, 500, False),
(self.snapshot.raw["master"]["id"], None, 200, True)):
runner = SweepRunner(self.catalog)
runner.state["pending"] = {"stage": "0101", "level": "3", "phase": "遇到事件或响应缺少事件状态,请在游戏内处理"}
records = [{"kind": "response", "operation": "读取角色", "body": {"master": {"id": role}}},
{"kind": "request", "operation": "stageService/stageStart", "request_id": "test-1",
"body": {"stageTypeId": "0101", "stageLevel": "3"}},
{"kind": "response", "operation": "stageService/stageStart", "request_id": "test-1", "http_status": http_status,
"body": {"resCode": 0, "triggerEvent": True, "stageEvent": {"hideStageId": hidden, "result": {"money": 32}}}}]
trace.write_text("\n".join(json.dumps(row) for row in records), encoding="utf-8")
self.assertEqual(runner.recover_reward_event(self.snapshot, trace), recovered)
self.assertEqual(runner.state["pending"] is None, recovered)
def test_hidden_stage_event_waits_for_real_battle_without_submitting_a_result(self):
runner = SweepRunner(self.catalog)
policy = SweepPolicy(True, {"0101": {"enabled": True, "level": "3", "limit": 3}})
client = FakeClient(self.snapshot)
client.call = unittest.mock.Mock(return_value={"resCode": 0, "triggerEvent": True,
"stageEvent": {"hideStageId": "hidden", "result": {"money": 1}}})
with self.assertRaisesRegex(ValueError, "隐藏关卡"):
runner.run(client, self.snapshot, self.stage(), policy)
client.call.assert_called_once_with("stageService/stageStart", {"stageTypeId": "0101", "stageLevel": "3"})
self.assertIsNone(runner.next(self.snapshot, policy))
def test_sweep_checks_team_stamina_and_active_story_before_writes(self): def test_sweep_checks_team_stamina_and_active_story_before_writes(self):
runner = SweepRunner(self.catalog) runner = SweepRunner(self.catalog)
policy = SweepPolicy(True, {"0101": {"enabled": True, "level": "3", "limit": 3}}, keep_stamina=999) policy = SweepPolicy(True, {"0101": {"enabled": True, "level": "3", "limit": 3}}, keep_stamina=999)
+97
View File
@@ -0,0 +1,97 @@
import json
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.engine import Engine
from ranch_assistant.api import Session
from ranch_assistant.gui import Window
from ranch_assistant.stage_cache import StageCache
from ranch_assistant.tests.test_activities import scenario, FakeClient
from ranch_assistant.tests.test_core import workspace_temp
class MapCacheTests(unittest.TestCase):
def test_snapshot_changes_and_restart_reuse_cache_until_explicit_refresh(self):
catalog, snapshot = scenario()
with workspace_temp() as folder:
cache = StageCache(catalog, folder / "maps.json")
original = cache.get(snapshot)
original_json = (folder / "maps.json").read_text(encoding="utf-8")
snapshot.raw["history"]["unlockStage"]["0102"] = ["1", "2", "3"]
with patch("ranch_assistant.stage_cache.stages", side_effect=AssertionError("Unrequested refresh")):
self.assertIs(cache.get(snapshot), original)
restored = StageCache(catalog, folder / "maps.json")
self.assertEqual([asdict(row) for row in restored.get(snapshot)], [asdict(row) for row in original])
self.assertEqual((folder / "maps.json").read_text(encoding="utf-8"), original_json)
refreshed = cache.get(snapshot, refresh=True)
self.assertTrue(next(row for row in refreshed if row.stage_id == "0102" and row.level == "2").unlocked)
def test_cache_rejects_other_role_and_recovers_corrupt_local_file(self):
catalog, snapshot = scenario()
with workspace_temp() as folder:
path = folder / "maps.json"
cache = StageCache(catalog, path)
cache.get(snapshot)
snapshot.raw["master"]["id"] += 1
with patch("ranch_assistant.stage_cache.stages", wraps=__import__("ranch_assistant.maps", fromlist=["stages"]).stages) as build:
cache.get(snapshot)
self.assertEqual(build.call_count, 1)
self.assertEqual(json.loads(path.read_text(encoding="utf-8"))["owner"], str(snapshot.raw["master"]["id"]))
path.write_text("[]", encoding="utf-8")
self.assertTrue(StageCache(catalog, path).get(snapshot))
class MapCacheGuiTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.app = W.QApplication.instance() or W.QApplication([])
def wait(self, predicate):
for _ in range(700):
self.app.processEvents()
QTest.qWait(2)
if predicate():
return
self.fail("Qt worker did not finish")
def test_collapsed_maps_remain_cached_on_page_switch_and_poll_manual_refresh_updates(self):
with workspace_temp() as folder:
window = Window(folder)
window.timer.stop()
try:
self.wait(lambda: not window.busy and window.engine.snapshot is not None)
catalog, snapshot = scenario()
client = FakeClient(snapshot)
client.session = Session("http://127.0.0.1/", "synthetic-test-token")
client.persist_session = lambda: None
client.close = lambda: None
window.catalog = catalog
window.engine = Engine(catalog, client, folder / "purchase.json")
window.engine.snapshot = snapshot
window.tabs.setCurrentWidget(window.map_page)
self.wait(lambda: not window.map_render_timer.running)
self.assertTrue(all(not window.maps_tree.topLevelItem(i).isExpanded() for i in range(window.maps_tree.topLevelItemCount())))
original = window.engine.stage_cache.rows
client.value["history"]["unlockStage"]["0102"] = ["1", "2", "3"]
window.tabs.setCurrentWidget(window.slot_page)
with patch("ranch_assistant.stage_cache.stages", side_effect=AssertionError("Page/poll refreshed cached maps")):
window.refresh()
self.wait(lambda: not window.busy)
window.tabs.setCurrentWidget(window.map_page)
self.wait(lambda: not window.map_render_timer.running)
self.assertIs(window.engine.stage_cache.rows, original)
self.assertTrue(window.engine.heartbeat_enabled)
refresh = next(b for b in window.map_page.findChildren(W.QPushButton) if b.text() == "刷新关卡")
refresh.click()
self.wait(lambda: not window.busy and not window.map_render_timer.running)
changed = next(row for row in window.engine.stage_cache.rows if row.stage_id == "0102" and row.level == "2")
self.assertTrue(changed.unlocked)
self.assertTrue((folder / "maps.json").exists())
finally:
window.close()
@@ -0,0 +1,77 @@
import os
import unittest
os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
from PySide6 import QtCore as C, QtGui as G, QtWidgets as W
from PySide6.QtTest import QTest
from ranch_assistant.gui import spin
from ranch_assistant.native_widgets import IntegerInput
class NumericWheelTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.app = W.QApplication.instance() or W.QApplication([])
def wheel(self, widget, delta=120):
point = widget.rect().center()
event = G.QWheelEvent(C.QPointF(point), C.QPointF(widget.mapToGlobal(point)),
C.QPoint(), C.QPoint(0, delta), C.Qt.MouseButton.NoButton,
C.Qt.KeyboardModifier.NoModifier, C.Qt.ScrollPhase.NoScrollPhase, False)
self.app.sendEvent(widget, event)
return event
def test_all_number_controls_require_focus_and_release_wheel_for_page_scrolling(self):
host = W.QWidget()
layout = W.QVBoxLayout(host)
other = W.QLineEdit()
layout.addWidget(other)
widgets = [spin(0, 100, 10), spin(0, 100, 10, True), IntegerInput()]
for widget in widgets:
if isinstance(widget, IntegerInput):
widget.setRange(0, 100)
widget.setValue(10)
layout.addWidget(widget)
host.show()
host.activateWindow()
QTest.qWait(10)
try:
for widget in widgets:
with self.subTest(type=type(widget).__name__):
other.setFocus()
self.app.processEvents()
self.assertFalse(self.wheel(widget).isAccepted())
self.assertEqual(widget.value(), 10)
self.assertFalse(widget.hasFocus())
QTest.mouseClick(widget, C.Qt.MouseButton.LeftButton)
self.app.processEvents()
self.assertTrue(widget.hasFocus())
self.wheel(widget)
self.assertEqual(widget.value(), 11)
self.wheel(widget, -120)
self.assertEqual(widget.value(), 10)
other.setFocus()
self.app.processEvents()
self.wheel(widget)
self.assertEqual(widget.value(), 10)
finally:
host.close()
def test_integer_wheel_clamps_and_accumulates_small_steps(self):
widget = IntegerInput()
widget.setRange(0, 2)
widget.show()
widget.activateWindow()
widget.setFocus()
QTest.qWait(10)
try:
self.wheel(widget, 60)
self.assertEqual(widget.value(), 0)
self.wheel(widget, 60)
self.assertEqual(widget.value(), 1)
self.wheel(widget, 1200)
self.assertEqual(widget.value(), 2)
self.wheel(widget, -1200)
self.assertEqual(widget.value(), 0)
finally:
widget.close()