Settle player level and stamina; unify strategy configuration

This commit is contained in:
AttilaNet
2026-11-08 10:46:25 +08:00
parent d0fd15c785
commit 2498f1f98f
10 changed files with 550 additions and 48 deletions
+12 -8
View File
@@ -34,9 +34,11 @@
可选随机30秒、60秒、2分钟或5分钟,每轮刷新完成后从0到所选上限重新取间隔;喂养遵守当前突破上限,满级后转到下一喂养目标。
空坑装填单独计时:有可用蛋时随机等待1~2秒装填一个坑位,确认成功后继续下一坑,不受整体刷新间隔影响。
每次装填前重新读取坑位和库存;无可用蛋、坑位已满或停止自动执行时暂停。此快速计时不会执行购蛋、派遣或其他操作。
原“牧场策略”并入此页的“牧场与赠礼策略”子页,内容超出高度时滚动显示;可导出、导入培养策略,跨账号按魔物种类匹配目标。
导入后所有自动执行开关保持关闭,文件不包含账号、密码、Token、会话或本机路径。
- 自动赠礼:在背包勾选可用物品,在牧场勾选目标并设置优先级,再到“牧场与赠礼策略”启用。
子页分为“孵蛋策略”“牧场策略”“喂养策略”,内容超出高度时滚动显示,修改后自动保存并应用。
- 统一策略配置:通过菜单“策略配置”导入、导出全部孵蛋、牧场、喂养、赠礼、委托、每日事务、扫荡及监控间隔设置,包含自定义收益资料。
跨账号按魔物种类匹配喂养和赠礼目标;牧场实例编号不跨账号复制,默认使用有空位的牧场。兼容旧版培养策略文件。
导入保留功能勾选和规则,执行保持停止,核对后手动开始;文件不包含账号、密码、Token、会话或本机路径。
- 自动赠礼:独立页签,在背包勾选可用物品,在牧场勾选目标并设置优先级,再到“自动赠礼”启用。
每次消耗一件物品,默认只使用目标喜欢的物品;遵守当前羁绊好感上限、赠礼间隔、物品保留数量及委托保留。
- 收益资料:749 种魔物数据来自用户提供的 APK 1.9.68,支持名称搜索和1–5星分别筛选,
可导入 CSV/XLSX 覆盖价格、经验和时间。
@@ -54,6 +56,8 @@
- 每日事务:集中查看每日签到礼包、七日签到、累计奖励、VIP日奖和邮件附件;
可立即领取勾选项目,或开启自动执行时领取;手动刷新不领奖。
- 离线演示:不连接游戏服务器即可查看数据、策略和模拟操作。
- 等级与体力:经验达到下一等级门槛时自动请求官方升级结算;按客户端150秒恢复周期请求体力结算并显示服务器返回值。
到期检查独立于随机刷新间隔,在账号后台线程串行执行;未开启消耗类策略时也会同步,退出登录或连接出错后停止。
## 连接真实角色
@@ -73,10 +77,10 @@
下一步操作或等待原因。“仅监控”和手动刷新会自动同步到期的成长状态,但不会派遣、喂养、购蛋或领奖;“停止执行”保留监控。
已经发送的请求会返回,停止后不发送下一项。重启或恢复会话后需重新点开始执行。
6. 需要经验时,在“牧场”勾选接收经验的喂养目标并设置优先级。优先级数字小的先喂,达到当前突破上限后换下一个;
在“自动孵蛋 → 牧场与赠礼策略”可设全局停止等级、星级/资质保护和保留蛋数量。“收益资料”的星级勾选只筛选表格显示。
在“自动孵蛋 → 喂养策略”设置全局停止等级,在“牧场策略”设置星级/资质保护和保留蛋数量。“收益资料”的星级勾选只筛选表格显示。
7. 需要提升好感时,在“背包”的对应物品分类中勾选物品并设置保留数量,在“牧场”勾选目标并设置赠礼优先级;
在“自动孵蛋 → 牧场与赠礼策略”启用自动赠礼。达到当前好感上限或仍在赠礼间隔时不会继续消耗物品。
同页可导出策略供其他账号导入;导入后需逐项核对并手动开启自动执行。
在独立的“自动赠礼”页启用。达到当前好感上限或仍在赠礼间隔时不会继续消耗物品。
菜单“策略配置”可导出全部策略供其他账号导入;导入后需逐项核对并手动开启自动执行。
可用“绿色史莱姆金币预设(仅孵此蛋)”快速设置:只勾选绿色史莱姆、优先级1、孵出后派遣、低于1补至10、
莉莉托斯市场。这个预设关闭喂养,保留4星以上/A资质魔物,仍需点击开始执行。
@@ -216,14 +220,14 @@
- 自定义表:`typeId, sell_money, sell_exp, time_total`(秒),可只提供部分
覆盖列;中文列名“编号、派遣金币、强化经验、孵化秒数”也支持。
- 测试:`python -m unittest discover -s ranch_assistant/tests -v`。
- 140 项本地测试通过,覆盖登录、会话隔离、请求计数、成长同步、孵蛋与补货、批量喂养、派遣、赠礼、委托、扫荡和每日奖励。
- 155 项本地测试通过,覆盖登录、会话隔离、请求计数、等级与体力结算、成长同步、孵蛋与补货、批量喂养、派遣、赠礼、统一策略配置、委托、扫荡和每日奖励。
新增牧场树形/平铺切换、分组数量与空位、刷新保留折叠和控件、4S保留条件、随机刷新间隔及到期独立同步的回归测试。
双账号与大量库存的界面响应继续通过测试;测试使用本地模拟数据和模拟服务,不操作真实账号库存。
- 网络写请求发生异常后不会直接重试,以免重复消耗魔物或物品。
## 委托和扫荡的范围
“自动委托”需单独启用;可先关闭“牧场与赠礼策略”的自动管理,只运行委托。
“自动委托”需单独启用;可先关闭“自动孵蛋”的自动管理,只运行委托。
道具和魔物提交默认关闭,金币提交上限默认 0;锁定、队伍、高星和高资质保护继续生效。
已接委托需要的魔物种类和蛋会纳入牧场保留。
“也接取需要实战的委托”只允许接取此类任务,当前不会自动导航到每项委托的专用战斗。
File diff suppressed because one or more lines are too long
+15 -3
View File
@@ -10,6 +10,7 @@ from .quests import QuestPolicy, TaskPlanner
from .market import PurchaseBudget
from .management import expansion_quote, manual_monster_actions
from .gifts import GiftPlanner
from .master_sync import MasterSync
class Engine:
@@ -31,6 +32,7 @@ class Engine:
self.last_draw = ""
self.growth_cache = {}
self.growth_attempts = {}
self.master_sync = MasterSync(catalog)
self.last_executed = False
folder = Path(budget_path).parent if budget_path else None
self.daily_policy = DailyPolicy()
@@ -38,8 +40,11 @@ class Engine:
self.sweep_policy = SweepPolicy()
self.sweeper = SweepRunner(catalog, folder / "sweep_runs.json" if folder else None)
def read_snapshot(self):
def read_snapshot(self, *, sync_master=True):
self.snapshot = self.client.snapshot()
self.master_sync.apply(self.snapshot)
if sync_master:
self.master_sync.settle(self.client, self.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}
@@ -69,6 +74,13 @@ class Engine:
self.snapshot.raw["monsters"] = rows
return self.snapshot
def master_sync_due(self):
return not self.demo and bool(self.master_sync.pending(self.snapshot))
def sync_master(self):
self.read_snapshot()
return self.snapshot, self.plans(), "已同步等级 / 体力"
def remember_growth(self, response):
# MonsterCenter.checkGrowUpHandler treats these two arrays as the
# authoritative stage and growth values, including after a stale read.
@@ -140,7 +152,7 @@ class Engine:
if mon.get("process") == 2:
mon["mode"] = self.snapshot.expected_growth_mode(mon, self.catalog)
else:
self.read_snapshot()
self.read_snapshot(sync_master=not hatch_only)
if not hatch_only:
settled = self.settle_pending_growth()
message = "状态已刷新" + (";已请求孵化 / 成长结算" if settled else "")
@@ -177,7 +189,7 @@ class Engine:
response = self.client.call(action.path, action.payload)
if action.kind == "buy":
self.record_draw(response.get("eggs") or [])
self.read_snapshot()
self.read_snapshot(sync_master=not hatch_only)
if action.kind == "hatch":
stack_id = action.payload["eggs"][0]["stackId"]
slot = next((slot for slot in self.snapshot.raw["stacks"] if int(slot["id"]) == stack_id), None)
+66 -33
View File
@@ -27,7 +27,7 @@ from .debug_window import DebugWindow
from .sessions import SessionStore, identity
from .inventory_gui import ITEM_TYPES, InventoryTable
from .ranch_gui import RanchView
from .policy_io import portable_policy, import_policy
from .policy_io import portable_config, import_config
from .table_widgets import table_item
APP_VERSION = "1.1.0"
@@ -274,6 +274,7 @@ class Window(ActivityPages, W.QMainWindow):
self.room_page = self.monster_page
self.tabs.addTab(self.room_page, "牧场")
self.policy_page = self.policy_tab(embedded=True)
self.gifting_tab()
self.automation_tab()
self.yield_tab()
self.quests_tab()
@@ -282,10 +283,13 @@ class Window(ActivityPages, W.QMainWindow):
self.plans = table(["操作", "下一步计划(每轮只执行一项,并重新读取状态)"])
self.tabs.addTab(self.plans, "执行计划")
order = [self.tabs.widget(0), self.slot_page, self.inventory_tabs, self.room_page,
self.daily_page, self.automation_page, self.quests_table.parentWidget(), self.map_page,
self.daily_page, self.automation_page, self.gift_page, self.quests_table.parentWidget(), self.map_page,
self.plans, self.yields.parentWidget()]
for page in order:
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_room.currentIndexChanged.connect(self.monster_view_changed)
self.monster_view.setCurrentIndex(self.monster_view.findData(0))
@@ -418,7 +422,7 @@ class Window(ActivityPages, W.QMainWindow):
self.min_gold = spin(0, 1000000, 0, True)
self.min_exp = spin(0, 1000000, 0, True)
rows = [("保留此星级及以上", self.protect_star), ("资质保留条件", self.protect_quality),
("喂养目标", self.target), ("喂养达到此等级后停止", self.target_level), ("收取到牧场", self.room),
("收取到牧场", self.room),
("额外保留魔物编号(逗号分隔)", self.reserved_types),
("保留蛋数量(编号:数量,逗号分隔)", self.reserve_eggs)]
for label, widget in rows:
@@ -428,20 +432,22 @@ class Window(ActivityPages, W.QMainWindow):
form.addRow(W.QLabel("孵蛋开关、优先级和去向在“背包 → 魔物蛋”逐项配置。"))
self.target_status = W.QLabel("选择喂养目标后显示当前突破上限")
self.target_status.setWordWrap(True)
form.addRow("实际喂养上限", self.target_status)
feed_page = W.QWidget()
self.feed_form = W.QFormLayout(feed_page)
self.feed_form.addRow("默认喂养目标", self.target)
self.feed_form.addRow("喂养达到此等级后停止", self.target_level)
self.feed_form.addRow("实际喂养上限", self.target_status)
feed_note = W.QLabel("在“牧场”勾选喂养目标并设置优先级,优先采用这些目标。达到当前突破等级上限后转向下一只;用于喂养的魔物由蛋规则指定。")
feed_note.setWordWrap(True)
self.feed_form.addRow(feed_note)
self.feed_form.setSizeConstraint(W.QLayout.SizeConstraint.SetMinimumSize)
self.feed_scroll = W.QScrollArea()
self.feed_scroll.setWidgetResizable(True)
self.feed_scroll.setFrameShape(W.QFrame.Shape.NoFrame)
self.feed_scroll.setWidget(feed_page)
self.target.currentIndexChanged.connect(self.update_target_status)
self.target_level.valueChanged.connect(self.update_target_status)
form.addRow(W.QLabel("仅处理本次运行观察到的培育室魔物;已有牧场魔物不作为自动派遣/喂养素材。\n锁定、羁绊、已装备、队伍/探索中的魔物会保留。蛋的手机本地锁定无法从服务器读取,请设置保留蛋数量。"))
self.gift_enabled = W.QCheckBox("启用自动赠礼(在背包勾选物品,在牧场勾选目标)")
self.gift_liked_only = W.QCheckBox("仅赠送目标喜欢的物品")
self.gift_liked_only.setChecked(True)
form.addRow("好感培养", self.gift_enabled)
form.addRow(self.gift_liked_only)
self.gift_status = W.QLabel("未启用;达到当前羁绊对应的好感上限后停止。")
self.gift_status.setWordWrap(True)
form.addRow(self.gift_status)
for widget in (self.gift_enabled, self.gift_liked_only):
widget.toggled.connect(self.update_gift_status)
for label in tab.findChildren(W.QLabel):
label.setWordWrap(True)
form.setSizeConstraint(W.QLayout.SizeConstraint.SetMinimumSize)
@@ -454,6 +460,32 @@ class Window(ActivityPages, W.QMainWindow):
return scroll
self.tabs.addTab(scroll, "牧场策略")
def gifting_tab(self):
self.gift_page = W.QWidget()
layout = W.QVBoxLayout(self.gift_page)
self.gift_enabled = W.QCheckBox("启用自动赠礼(在背包勾选物品,在牧场勾选目标)")
self.gift_liked_only = W.QCheckBox("仅赠送目标喜欢的物品")
self.gift_liked_only.setChecked(True)
self.gift_status = W.QLabel("未启用;达到当前羁绊对应的好感上限后停止。")
self.gift_status.setWordWrap(True)
for widget in (self.gift_enabled, self.gift_liked_only, self.gift_status):
layout.addWidget(widget)
for widget in (self.gift_enabled, self.gift_liked_only):
widget.toggled.connect(self.update_gift_status)
note = W.QLabel("物品用量、保留数量和目标优先级分别在“背包”和“牧场”设置;修改后自动生效。达到当前好感上限或处于赠礼冷却时停止。")
note.setWordWrap(True)
layout.addWidget(note)
buttons = W.QHBoxLayout()
for label, callback in (("去背包选择物品", lambda: self.tabs.setCurrentWidget(self.inventory_tabs)),
("去牧场选择目标", lambda: self.tabs.setCurrentWidget(self.room_page)),
("开始执行勾选策略", self.start_workflow), ("停止执行", self.stop_workflow)):
button = W.QPushButton(label)
button.clicked.connect(callback)
buttons.addWidget(button)
layout.addLayout(buttons)
layout.addStretch()
self.tabs.addTab(self.gift_page, "自动赠礼")
def automation_tab(self):
self.automation_page = W.QWidget()
layout = W.QVBoxLayout(self.automation_page)
@@ -491,6 +523,7 @@ class Window(ActivityPages, W.QMainWindow):
self.dispatch = W.QCheckBox("成熟后按策略自动派遣")
self.collect = W.QCheckBox("保留或待喂养的魔物自动收取到牧场")
self.feed = W.QCheckBox("按策略喂养选定目标(受当前突破上限限制)")
self.feed_form.insertRow(0, self.feed)
for widget in (self.dispatch, self.collect, self.feed):
widget.setChecked(True)
self.market = combo([(f"{r['name']}市场 · {int(r['money'])} 金币/蛋", key) for key, r in self.catalog.data.get("markets", {}).items()])
@@ -506,7 +539,7 @@ class Window(ActivityPages, W.QMainWindow):
("购买方式", self.buy_ten), ("单抽时每批上限", self.buy_batch),
("至少保留金币", self.keep_money), ("每日购蛋金币额度(0=不购买)", self.daily_buy_money),
("孵蛋", self.fill), ("派遣", self.dispatch),
("收取", self.collect), ("喂养", self.feed)):
("收取", self.collect)):
form.addRow(label, widget)
settings_layout.addLayout(form)
self.market_status = W.QLabel()
@@ -527,10 +560,6 @@ class Window(ActivityPages, W.QMainWindow):
preset.setToolTip("只勾选绿色史莱姆:优先级1、派遣、低于1时补至10,莉莉托斯市场;保留4星以上/A资质。应用后仍需开始执行。")
bottom = W.QHBoxLayout()
bottom.addWidget(preset)
for label, function in (("导入策略…", self.import_policies), ("导出策略…", self.export_policies)):
button = W.QPushButton(label)
button.clicked.connect(function)
bottom.addWidget(button)
layout.addLayout(bottom)
configure = W.QPushButton("去背包配置孵蛋规则")
configure.clicked.connect(lambda: self.tabs.setCurrentWidget(self.egg_page))
@@ -538,8 +567,9 @@ class Window(ActivityPages, W.QMainWindow):
self.tabs.insertTab(1, self.automation_page, "自动孵蛋")
policy_tab = self.policy_page
self.automation_tabs = W.QTabWidget()
self.automation_tabs.addTab(settings_scroll, "孵蛋设置")
self.automation_tabs.addTab(policy_tab, "牧场与赠礼策略")
self.automation_tabs.addTab(settings_scroll, "孵蛋策略")
self.automation_tabs.addTab(policy_tab, "牧场策略")
self.automation_tabs.addTab(self.feed_scroll, "喂养策略")
layout.removeWidget(settings_scroll)
layout.insertWidget(2, self.automation_tabs, 1)
self.market.currentIndexChanged.connect(self.update_workflow_status)
@@ -562,7 +592,7 @@ class Window(ActivityPages, W.QMainWindow):
def start_workflow(self):
try:
policy = self.read_policy()
other = self.quest_enabled.isChecked() or self.daily_enabled.isChecked() or self.map_enabled.isChecked()
other = self.quest_enabled.isChecked() or self.daily_enabled.isChecked() or self.map_enabled.isChecked() or policy.gift_enabled
if not (policy.enabled and any((policy.buy, policy.fill, policy.dispatch, policy.collect, policy.feed))) and not other:
self.report("请先勾选至少一项功能,并启用对应策略")
return
@@ -1076,7 +1106,7 @@ class Window(ActivityPages, W.QMainWindow):
def background():
started = time.perf_counter()
value = function()
if kind in ("poll", "hatch", "monster_lock", "manual_monsters", "expansion", "growth_sync", "daily_claim", "connected"):
if kind in ("poll", "hatch", "monster_lock", "manual_monsters", "expansion", "growth_sync", "master_sync", "daily_claim", "connected"):
snapshot = value[1] if kind == "connected" else value[0]
managed = set() if kind == "connected" else set(engine.planner.managed)
preparing = time.perf_counter()
@@ -1123,7 +1153,7 @@ class Window(ActivityPages, W.QMainWindow):
note="worker总耗时包含网络;大列表在后续短批次更新")
def apply_result(self, kind, value):
if kind in ("poll", "hatch", "monster_lock", "manual_monsters", "expansion", "growth_sync", "daily_claim"):
if kind in ("poll", "hatch", "monster_lock", "manual_monsters", "expansion", "growth_sync", "master_sync", "daily_claim"):
snapshot, plans, message = value
self.render(snapshot, plans)
self.report(message)
@@ -1315,6 +1345,8 @@ class Window(ActivityPages, W.QMainWindow):
now = time.monotonic()
if not self.engine.demo and self.engine.heartbeat_enabled and now - self.engine.last_heartbeat >= 240:
self.submit("heartbeat", self.engine.keep_alive)
elif not self.engine.demo and self.engine.heartbeat_enabled and self.engine.master_sync_due():
self.submit("master_sync", self.engine.sync_master)
elif not self.engine.demo and self.engine.heartbeat_enabled and self.engine.growth_sync_due():
self.submit("growth_sync", self.engine.sync_growth)
elif (self.monitoring and self.execute.isChecked() and self.fill.isChecked()
@@ -1667,13 +1699,13 @@ class Window(ActivityPages, W.QMainWindow):
self.statusBar().showMessage("设置尚未保存,请检查输入格式及本地目录", 5000)
def export_policies(self):
path, _ = W.QFileDialog.getSaveFileName(self, "导出培养策略", "ranch-policies-1.1.0.json", "策略文件 (*.json)")
path, _ = W.QFileDialog.getSaveFileName(self, "导出全部策略", "ranch-policies-1.1.0.json", "策略文件 (*.json)")
if not path:
return
try:
value = portable_policy(self.read_policy(), self.engine.snapshot)
value = portable_config(self.config_value(), self.engine.snapshot)
Path(path).write_text(json.dumps(value, ensure_ascii=False, indent=2), encoding="utf-8")
self.report("已导出培养策略;文件不包含账号、密码、Token、会话或本机路径")
self.report("已导出全部策略;文件不包含账号、密码、Token、会话或本机路径")
except (OSError, ValueError, TypeError) as error:
self.report("策略导出失败:" + str(error))
@@ -1681,16 +1713,17 @@ class Window(ActivityPages, W.QMainWindow):
if self.busy:
self.report("请等待当前操作完成,再导入策略")
return
path, _ = W.QFileDialog.getOpenFileName(self, "导入培养策略", "", "策略文件 (*.json)")
path, _ = W.QFileDialog.getOpenFileName(self, "导入全部策略", "", "策略文件 (*.json)")
if not path:
return
try:
policy = import_policy(json.loads(Path(path).read_text(encoding="utf-8-sig")), self.engine.snapshot)
config = import_config(json.loads(Path(path).read_text(encoding="utf-8-sig")), self.engine.snapshot)
self.stop_workflow()
self.load_config({"policy": asdict(policy)})
self.save_config(quiet=True)
missing = (len(policy.feed_targets) + len(policy.gift_targets))
self.report(f"已导入并保存培养策略;已匹配 {missing} 个当前账号的喂养/赠礼目标;自动执行保持停止")
self.load_config(self.config_value() | config)
self.persist_settings()
policy = self.read_policy()
matched = len(policy.feed_targets) + len(policy.gift_targets)
self.report(f"已导入并保存策略;已匹配 {matched} 个当前账号的喂养/赠礼目标;自动执行保持停止")
except (OSError, ValueError, TypeError, KeyError) as error:
self.report("策略导入失败:" + str(error))
+71
View File
@@ -0,0 +1,71 @@
"""Client-equivalent player level and natural stamina settlement."""
import time
from .model import seconds
class MasterSync:
def __init__(self, catalog):
self.catalog = catalog
self.attempts = {}
self.level = 0
self.stamina = None
def apply(self, snapshot):
master = dict(snapshot.raw["master"])
snapshot.raw["master"] = master
# A confirmed level cannot regress within this role's session.
master["level"] = max(int(master.get("level") or 1), self.level)
if self.stamina:
before, after, expires = self.stamina
pair = (master.get("ti"), master.get("timeTi"))
if pair == before and time.monotonic() < expires:
master.update(ti=after[0], timeTi=after[1])
else:
self.stamina = None
def pending(self, snapshot):
if snapshot is None:
return []
master = snapshot.raw["master"]
settings = self.catalog.data.get("game_setting", {})
level = int(master.get("level") or 1)
threshold = self.catalog.data.get("farm_level", {}).get(str(level + 1))
paths = []
if (level < int(settings.get("masterMaxLevel", 70)) and threshold is not None
and float(master.get("exp") or 0) >= float(threshold)):
paths.append("masterService/masterLevelUpdate")
timestamp = seconds(master.get("timeTi"))
cooldown = float(settings.get("tiCD") or 150)
if timestamp > 0 and snapshot.now - timestamp >= cooldown:
paths.append("masterService/masterCheckTiAdd")
now = time.monotonic()
return [path for path in paths if now >= self.attempts.get(path, 0)]
def settle(self, client, snapshot):
master = snapshot.raw["master"]
updated = []
for path in self.pending(snapshot):
# Includes failures and unchanged replies; never spin on a stale value.
self.attempts[path] = time.monotonic() + 30
response = client.call(path, {})
if path.endswith("masterLevelUpdate"):
value = response.get("level")
if isinstance(value, bool) or not isinstance(value, (int, float)) or int(value) != value or value < int(master["level"]):
raise ValueError("升级响应缺少有效的角色等级")
self.level = int(value)
master["level"] = self.level
updated.append("等级")
else:
ti, timestamp = response.get("ti"), response.get("timeTi")
if (isinstance(ti, bool) or not isinstance(ti, (int, float)) or int(ti) != ti or ti < 0
or not isinstance(timestamp, (int, float)) or isinstance(timestamp, bool) or timestamp <= 0):
raise ValueError("体力恢复响应缺少有效的 ti / timeTi")
before = (master.get("ti"), master.get("timeTi"))
after = (int(ti), timestamp)
# Apply only over the exact pre-settlement pair, for a bounded
# period. A new cost/reward from the server always takes priority.
self.stamina = (before, after, time.monotonic() + 60)
master.update(ti=after[0], timeTi=after[1])
updated.append("体力")
return updated
+90 -2
View File
@@ -1,9 +1,34 @@
"""Portable rule sets; credentials, sessions and local paths never enter files."""
import copy
import math
from dataclasses import asdict
from .model import Policy
from .daily import DailyPolicy
from .quests import QuestPolicy
from .sweeping import SweepPolicy
FORMAT = "ranch-helper-policies"
VERSION = 1
CONFIG_VERSION = 2
def checked_policy(cls, data):
if not isinstance(data, dict):
raise ValueError("策略配置必须是对象")
for key, default in asdict(cls()).items():
if key not in data:
continue
value = data[key]
if cls.__annotations__.get(key) in (float, "float"):
valid = type(value) in (int, float) and math.isfinite(value)
else:
valid = type(value) is type(default)
if not valid:
raise ValueError("策略字段类型错误:" + key)
try:
return cls(**data)
except (AttributeError, TypeError, KeyError) as error:
raise ValueError("策略字段格式错误") from error
def portable_policy(policy, snapshot=None):
@@ -11,6 +36,9 @@ def portable_policy(policy, snapshot=None):
value["enabled"] = False
for field in ("buy", "collect", "dispatch", "feed", "fill", "gift_enabled"):
value[field] = False
if value["feed_target"] and not value["feed_targets"]:
value["feed_targets"] = {str(value["feed_target"]): 1}
value["feed_target"] = value["room_id"] = 0
targets = {}
for kind, field in (("feed", "feed_targets"), ("gift", "gift_targets")):
targets[kind] = []
@@ -24,12 +52,18 @@ def portable_policy(policy, snapshot=None):
def import_policy(value, snapshot=None):
if not isinstance(value, dict) or value.get("format") != FORMAT or value.get("schema") != VERSION or not isinstance(value.get("policy"), dict):
raise ValueError("不是受支持的辅助策略文件")
policy = Policy(**value["policy"])
policy = checked_policy(Policy, value["policy"])
policy.feed_target = policy.room_id = 0
if snapshot:
used = {"feed": set(), "gift": set()}
for kind, field in (("feed", "feed_targets"), ("gift", "gift_targets")):
result = {}
for rule in value.get("targetSpecies", {}).get(kind, []):
targets = value.get("targetSpecies", {})
if not isinstance(targets, dict) or not isinstance(targets.get(kind, []), list):
raise ValueError("培养目标配置格式错误")
for rule in targets.get(kind, []):
if not isinstance(rule, dict) or not 1 <= int(rule.get("priority", 0)) <= 999:
raise ValueError("培养目标优先级格式错误")
key = str(rule.get("typeId", ""))
for mon in sorted(snapshot.raw["monsters"], key=lambda m: int(m["id"])):
if str(mon.get("typeId")) == key and mon.get("process") == 3 and int(mon["id"]) not in used[kind]:
@@ -40,3 +74,57 @@ def import_policy(value, snapshot=None):
else:
policy.feed_targets, policy.gift_targets = {}, {}
return policy
def portable_config(config, snapshot=None):
"""One portable file for all strategies, independent of session/UI state."""
policy = Policy(**config.get("policy", {}))
value = portable_policy(policy, snapshot)
value["schema"] = CONFIG_VERSION
# These are configuration choices. The GUI execution switch is deliberately
# outside the portable document and stays stopped on import.
for field in ("enabled", "buy", "collect", "dispatch", "feed", "fill", "gift_enabled"):
value["policy"][field] = getattr(policy, field)
for key, cls in (("quest_policy", QuestPolicy), ("daily_policy", DailyPolicy), ("sweep_policy", SweepPolicy)):
value[key] = asdict(cls(**config.get(key, {})))
value["interval"] = config.get("interval", 30)
value["overrides"] = copy.deepcopy(config.get("overrides", {}))
value["yield_stars"] = list(config.get("yield_stars", [1, 2, 3, 4, 5]))
return value
def import_config(value, snapshot=None):
if not isinstance(value, dict) or value.get("format") != FORMAT:
raise ValueError("不是受支持的辅助策略文件")
if value.get("schema") == VERSION:
return {"policy": asdict(import_policy(value, snapshot))}
if value.get("schema") != CONFIG_VERSION:
raise ValueError("不支持此策略文件版本")
config = {"policy": asdict(import_policy(value | {"schema": VERSION}, snapshot))}
for key, cls in (("quest_policy", QuestPolicy), ("daily_policy", DailyPolicy), ("sweep_policy", SweepPolicy)):
if not isinstance(value.get(key), dict):
raise ValueError("策略文件缺少 " + key)
config[key] = asdict(checked_policy(cls, value[key]))
interval = value.get("interval", 30)
if interval not in (30, 60, 120, 300):
raise ValueError("刷新间隔须为30、60、120或300秒")
overrides, stars = value.get("overrides", {}), value.get("yield_stars", [1, 2, 3, 4, 5])
if not isinstance(overrides, dict) or not isinstance(stars, list) or any(type(s) is not int or s not in range(1, 6) for s in stars):
raise ValueError("收益资料配置格式错误")
for key, row in overrides.items():
if (not str(key).isdigit() or not isinstance(row, dict)
or any(field not in ("sell_money", "sell_exp", "time_total") or type(number) not in (int, float)
or not math.isfinite(number) or number < 0 for field, number in row.items())):
raise ValueError("收益资料配置格式错误")
for rule in config["sweep_policy"]["rules"].values():
if (not isinstance(rule, dict) or str(rule.get("level", "3")) not in ("1", "2", "3")
or type(rule.get("limit", 3)) is not int or not 0 <= rule.get("limit", 3) <= 999
or type(rule.get("enabled", False)) is not bool):
raise ValueError("扫荡规则格式错误")
if any(not isinstance(key, str) for key in config["daily_policy"]["selected"]):
raise ValueError("每日事务规则格式错误")
if any(not str(key).isdigit() or type(count) is not int or count < 0
for key, count in config["quest_policy"]["item_reserves"].items()):
raise ValueError("委托保留物品规则格式错误")
config.update(interval=interval, overrides=copy.deepcopy(overrides), yield_stars=list(stars))
return config
+5
View File
@@ -228,6 +228,11 @@ class ActivityGuiTests(unittest.TestCase):
window.engine = Engine(catalog)
window.engine.snapshot = snapshot
window.render_maps()
for _ in range(200):
if not window.map_render_timer.running:
break
QTest.qWait(5)
self.assertFalse(window.map_render_timer.running)
window.render_daily()
self.assertEqual(window.maps_tree.topLevelItem(0).text(0), "莉莉托斯")
region = window.maps_tree.topLevelItem(0)
+165
View File
@@ -0,0 +1,165 @@
import copy
import os
import time
import unittest
from unittest.mock import patch
from ranch_assistant.engine import Engine, demo_snapshot
from ranch_assistant.model import Catalog, Snapshot
NOW = 1800000000
LEVEL = "masterService/masterLevelUpdate"
STAMINA = "masterService/masterCheckTiAdd"
class MasterClient:
def __init__(self, catalog):
self.raw = copy.deepcopy(demo_snapshot(catalog).raw)
self.raw.update(monsters=[], items=[], stacks=[])
self.raw["master"].update(level=1, exp=0, ti=5, timeTi=(NOW - 360) * 1000)
self.calls = []
self.responses = {LEVEL: {"level": 3}, STAMINA: {"ti": 6, "timeTi": NOW * 1000}}
def snapshot(self):
return Snapshot(copy.deepcopy(self.raw))
def call(self, path, payload=None):
self.calls.append((path, payload))
return self.responses[path]
def persist_session(self):
pass
def close(self):
pass
class MasterSyncTests(unittest.TestCase):
def setUp(self):
self.clock = patch("ranch_assistant.model.time.time", return_value=NOW)
self.now = self.clock.start()
self.addCleanup(self.clock.stop)
self.catalog = Catalog()
self.catalog.data = self.catalog.data | {"game_setting": self.catalog.data["game_setting"] | {"tiCD": 360}}
self.client = MasterClient(self.catalog)
self.engine = Engine(self.catalog, self.client)
def test_monitor_settles_stamina_and_preserves_server_result_across_stale_read(self):
snapshot, _, _ = self.engine.poll()
self.assertEqual(snapshot.raw["master"]["ti"], 6)
self.assertEqual(self.client.calls, [(STAMINA, {})])
self.engine.poll()
self.assertEqual(self.engine.snapshot.raw["master"]["ti"], 6)
self.assertEqual(len(self.client.calls), 1)
def test_experience_threshold_requests_server_level_without_starting_automation(self):
self.client.raw["master"].update(exp=self.catalog.data["farm_level"]["4"], timeTi=NOW * 1000)
snapshot, _, _ = self.engine.poll()
self.assertEqual(snapshot.raw["master"]["level"], 3)
self.assertEqual(self.client.calls, [(LEVEL, {})])
self.assertFalse(self.engine.auto)
def test_before_recovery_boundary_and_level_threshold_no_request(self):
self.client.raw["master"].update(exp=self.catalog.data["farm_level"]["2"] - 1,
timeTi=(NOW - 359) * 1000)
self.engine.poll()
self.assertEqual(self.client.calls, [])
self.assertFalse(self.engine.master_sync_due())
self.now.return_value = NOW + 1
self.assertTrue(self.engine.master_sync_due())
self.engine.sync_master()
self.assertEqual(self.engine.snapshot.raw["master"]["ti"], 6)
def test_fresh_consumption_overrides_cached_stamina_and_levels_never_regress(self):
self.client.raw["master"]["exp"] = self.catalog.data["farm_level"]["3"]
self.engine.poll()
self.client.raw["master"].update(ti=2, timeTi=NOW * 1000)
self.engine.read_snapshot()
self.assertEqual(self.engine.snapshot.raw["master"]["ti"], 2)
self.assertEqual(self.engine.snapshot.raw["master"]["level"], 3)
self.assertIsNone(self.engine.master_sync.stamina)
def test_no_progress_and_failures_are_throttled_per_account(self):
self.client.responses[STAMINA] = {"ti": 5, "timeTi": (NOW - 360) * 1000}
with patch("ranch_assistant.master_sync.time.monotonic", return_value=100) as monotonic:
self.engine.poll()
self.engine.poll()
self.assertEqual(len(self.client.calls), 1)
other = Engine(self.catalog, MasterClient(self.catalog))
other.poll()
self.assertEqual(len(other.client.calls), 1)
monotonic.return_value = 130
self.assertTrue(self.engine.master_sync_due())
self.client.call = unittest.mock.Mock(side_effect=RuntimeError("test failure"))
with self.assertRaises(RuntimeError):
self.engine.sync_master()
self.assertFalse(self.engine.master_sync_due())
def test_fast_hatching_never_settles_player_state(self):
self.client.raw["master"]["exp"] = self.catalog.data["farm_level"]["3"]
self.engine.poll(hatch_only=True)
self.assertEqual(self.client.calls, [])
def test_full_stamina_uses_server_timestamp_without_repeated_requests(self):
self.client.raw["master"]["ti"] = 600
self.client.responses[STAMINA] = {"ti": 600, "timeTi": NOW * 1000}
self.engine.poll()
self.engine.poll()
self.assertEqual(len(self.client.calls), 1)
self.assertFalse(self.engine.master_sync_due())
def test_max_level_and_absent_timestamp_do_not_request(self):
self.client.raw["master"].update(level=70, exp=10**9, timeTi=None)
self.engine.poll()
self.assertEqual(self.client.calls, [])
def test_incomplete_stamina_reply_never_fabricates_new_value(self):
self.client.responses[STAMINA] = {"ti": 600}
with self.assertRaisesRegex(ValueError, "ti / timeTi"):
self.engine.poll()
self.assertEqual(self.engine.snapshot.raw["master"]["ti"], 5)
self.assertFalse(self.engine.master_sync_due())
class MasterSyncGuiTests(unittest.TestCase):
def test_recovery_deadline_uses_background_job_without_changing_poll_deadline(self):
os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
from PySide6 import QtWidgets as W
from PySide6.QtTest import QTest
from ranch_assistant.gui import Window
from ranch_assistant.api import Session
from ranch_assistant.tests.test_core import workspace_temp
app = W.QApplication.instance() or W.QApplication([])
with workspace_temp() as folder, patch("ranch_assistant.model.time.time", return_value=NOW):
window = Window(folder)
window.timer.stop()
def wait():
for _ in range(500):
app.processEvents()
QTest.qWait(2)
if not window.busy:
return
self.fail("Master sync worker did not finish")
try:
wait()
client = MasterClient(window.catalog)
client.session = Session("http://127.0.0.1/", "synthetic-test-token")
window.engine = Engine(window.catalog, client)
window.engine.last_heartbeat = time.monotonic()
window.engine.snapshot = client.snapshot()
window.next_poll = float("inf")
window.schedule()
self.assertTrue(window.busy)
wait()
self.assertEqual(window.engine.snapshot.raw["master"]["ti"], 6)
self.assertEqual(client.calls, [(STAMINA, {})])
self.assertEqual(window.next_poll, float("inf"))
self.assertFalse(window.execute.isChecked())
self.assertFalse(window.monitoring)
finally:
window.close()
if __name__ == "__main__":
unittest.main()
+124
View File
@@ -0,0 +1,124 @@
from dataclasses import asdict
import json
import os
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.daily import DailyPolicy
from ranch_assistant.engine import demo_snapshot
from ranch_assistant.gui import Window
from ranch_assistant.model import Catalog, Policy
from ranch_assistant.policy_io import portable_config, import_config, portable_policy
from ranch_assistant.quests import QuestPolicy
from ranch_assistant.sweeping import SweepPolicy
from ranch_assistant.tests.test_core import workspace_temp
class UnifiedPolicyTests(unittest.TestCase):
def config(self):
return {"policy": asdict(Policy(buy=True, gift_enabled=True, feed_target=900, room_id=999999,
gift_targets={"900": 2}, gift_items={"30001": {"enabled": True, "reserve": 5}})),
"quest_policy": asdict(QuestPolicy(enabled=True, max_money=100, item_reserves={"30001": 6})),
"daily_policy": asdict(DailyPolicy(enabled=True, selected=["mail"])),
"sweep_policy": asdict(SweepPolicy(enabled=True, rules={"0101": {"enabled": True, "level": 3, "limit": 5}}, keep_stamina=22)),
"interval": 120, "overrides": {"1001010": {"sell_money": 151}}, "yield_stars": [1, 2],
"token": "secret-test-only", "account": "private-test-only", "log_sizes": [600, 200]}
def test_all_strategies_round_trip_and_targets_match_other_account(self):
snapshot = demo_snapshot(Catalog())
exported = portable_config(self.config(), snapshot)
text = json.dumps(exported)
for secret in ("secret-test-only", "private-test-only", "999999", '"900"', "log_sizes"):
self.assertNotIn(secret, text)
snapshot.monsters[900]["id"] = 999
config = import_config(exported, snapshot)
self.assertEqual(config["policy"]["feed_targets"], {"999": 1})
self.assertEqual(config["policy"]["gift_targets"], {"999": 2})
self.assertEqual(config["policy"]["feed_target"], 0)
self.assertEqual(config["policy"]["room_id"], 0)
self.assertTrue(config["policy"]["gift_enabled"])
for key in ("quest_policy", "daily_policy", "sweep_policy", "interval", "overrides", "yield_stars"):
self.assertEqual(config[key], self.config()[key])
def test_old_files_import_without_replacing_other_strategy_sections(self):
config = import_config(portable_policy(Policy(protect_quality=6)))
self.assertEqual(list(config), ["policy"])
self.assertEqual(config["policy"]["protect_quality"], 6)
self.assertFalse(config["policy"]["enabled"])
def test_invalid_bundle_rejected_before_applying(self):
exported = portable_config(self.config())
for value in (exported | {"schema": 100}, exported | {"interval": 0},
exported | {"daily_policy": []}, exported | {"yield_stars": [None]},
exported | {"policy": exported["policy"] | {"target_level": "bad"}},
exported | {"sweep_policy": exported["sweep_policy"] | {"rules": {"0101": None}}}):
with self.assertRaises((ValueError, TypeError)):
import_config(value)
class StrategyGuiTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.app = W.QApplication.instance() or W.QApplication([])
def wait(self, window):
for _ in range(500):
self.app.processEvents()
QTest.qWait(2)
if not window.busy:
return
self.fail("Offline task did not finish")
def test_separate_pages_and_unified_import_apply_without_starting_execution(self):
with workspace_temp() as folder:
window = Window(folder)
window.timer.stop()
try:
self.wait(window)
self.assertEqual([window.automation_tabs.tabText(i) for i in range(3)],
["孵蛋策略", "牧场策略", "喂养策略"])
self.assertEqual(window.tabs.tabText(window.tabs.indexOf(window.gift_page)), "自动赠礼")
self.assertTrue(window.gift_page.isAncestorOf(window.gift_enabled))
self.assertTrue(window.feed_scroll.isAncestorOf(window.feed))
value = portable_config(UnifiedPolicyTests().config(), window.engine.snapshot)
path = folder / "portable.json"
path.write_text(json.dumps(value), encoding="utf-8")
with patch("ranch_assistant.gui.W.QFileDialog.getOpenFileName", return_value=(str(path), "")):
window.import_policies()
self.assertFalse(window.execute.isChecked())
self.assertFalse(window.engine.auto)
self.assertTrue(window.engine.policy.gift_enabled)
self.assertEqual(window.engine.quest_policy.max_money, 100)
self.assertEqual(window.engine.sweep_policy.keep_stamina, 22)
self.assertEqual(window.engine.daily_policy.selected, ["mail"])
self.assertEqual(window.interval.currentData(), 120)
window.quest_money.setValue(42)
window.gift_liked_only.setChecked(False)
QTest.qWait(400)
self.assertEqual(window.engine.quest_policy.max_money, 42)
self.assertFalse(window.engine.policy.gift_liked_only)
with patch("ranch_assistant.gui.W.QFileDialog.getSaveFileName", return_value=(str(path), "")):
window.export_policies()
exported = json.loads(path.read_text(encoding="utf-8"))
self.assertEqual(import_config(exported, window.engine.snapshot)["quest_policy"]["max_money"], 42)
self.assertFalse(any("保存规则" in b.text() for b in window.findChildren(W.QPushButton)))
finally:
window.close()
def test_gift_only_workflow_does_not_require_hatch_rules(self):
with workspace_temp() as folder:
window = Window(folder)
window.timer.stop()
try:
self.wait(window)
window.ranch_enabled.setChecked(False)
window.gift_enabled.setChecked(True)
with patch.object(window, "refresh"):
window.start_workflow()
self.assertTrue(window.execute.isChecked())
finally:
window.close()
+1 -1
View File
@@ -61,7 +61,7 @@ tables["activity_info"] = {k: v for k, v in tables["activity_info"].items() if k
# Only positions are needed to avoid starting a sweep through an active story task.
tables["stage_task_positions"] = {str(k): [s.get("position", "") for s in r.get("steps", [])] for k, r in tables["task_info"].items()
if any(str(s.get("position", "")).startswith("city") for s in r.get("steps", []))}
tables["game_setting"] = {k: v for k, v in tables["game_setting"].items() if k in ("monExpScale", "xyz", "xyz1", "cityInfo", "upStarAdd", "maxLike", "vipReward", "monGiftTime", "monGiftMax", "masterMaxLevel") or k.startswith("loopTask") or k.endswith("_xyz")}
tables["game_setting"] = {k: v for k, v in tables["game_setting"].items() if k in ("monExpScale", "xyz", "xyz1", "cityInfo", "upStarAdd", "maxLike", "vipReward", "monGiftTime", "monGiftMax", "masterMaxLevel", "tiCD", "tiFirst", "tiLevelAdd", "tiTotalMax") or k.startswith("loopTask") or k.endswith("_xyz")}
task_fields = {"type", "typeId", "name", "des", "city", "closed", "condition", "startStep", "reward"}
step_fields = {"statusType", "statusValue", "condition", "des", "position", "npc", "afterStory", "auto"}
tables["task_info"] = {str(k): {f: v for f, v in row.items() if f in task_fields} |