Select one cultivation target per species and retain growth improvements

This commit is contained in:
AttilaNet
2026-11-08 12:08:29 +08:00
parent b172d1ffb9
commit 1eef0f80d1
9 changed files with 366 additions and 37 deletions
+8 -1
View File
@@ -38,11 +38,18 @@
空坑装填单独计时:有可用蛋时随机等待1~2秒装填一个坑位,确认成功后继续下一坑,不受整体刷新间隔影响。 空坑装填单独计时:有可用蛋时随机等待1~2秒装填一个坑位,确认成功后继续下一坑,不受整体刷新间隔影响。
每次装填前重新读取坑位和库存;无可用蛋、坑位已满或停止自动执行时暂停。此快速计时不会执行购蛋、派遣或其他操作。 每次装填前重新读取坑位和库存;无可用蛋、坑位已满或停止自动执行时暂停。此快速计时不会执行购蛋、派遣或其他操作。
子页分为“孵蛋策略”“牧场策略”“喂养策略”,内容超出高度时滚动显示,修改后自动保存并应用。 子页分为“孵蛋策略”“牧场策略”“喂养策略”,内容超出高度时滚动显示,修改后自动保存并应用。
“牧场策略”新增独立开关“保留资质高于牧场同种培养代表的新魔物”,与S/A/B/C、4S及星级保护分别生效。
同种培养代表优先选等级最高者,再依次比较好感、综合成长资质;新魔物的四项成长按各自范围归一化后取平均,严格更高才算提升。
同分不算提升;牧场尚无同种时保留首只,代表资质未同步完整时暂留。已有锁定、队伍及保留种类保护继续生效。
- 统一策略配置:通过主窗口菜单“策略配置”,保存、导入或导出当前账号的全部孵蛋、牧场、喂养、赠礼、委托、每日事务、扫荡及监控间隔设置,包含自定义收益资料。 - 统一策略配置:通过主窗口菜单“策略配置”,保存、导入或导出当前账号的全部孵蛋、牧场、喂养、赠礼、委托、每日事务、扫荡及监控间隔设置,包含自定义收益资料。
跨账号按魔物种类匹配喂养和赠礼目标;牧场实例编号不跨账号复制,默认使用有空位的牧场。兼容旧版培养策略文件。 跨账号按魔物种类匹配喂养和赠礼目标;牧场实例编号不跨账号复制,默认使用有空位的牧场。兼容旧版培养策略文件。
导入保留功能勾选和规则,执行保持停止,核对后手动开始;文件不包含账号、密码、Token、会话或本机路径。 导入保留功能勾选和规则,执行保持停止,核对后手动开始;文件不包含账号、密码、Token、会话或本机路径。
- 自动赠礼:独立页签,在背包勾选可用物品,在牧场勾选目标并设置优先级,再到“自动赠礼”启用。 - 自动赠礼:独立页签,在背包勾选可用物品,在牧场勾选目标并设置优先级,再到“自动赠礼”启用。
每次消耗一件物品,默认只使用目标喜欢的物品;遵守当前羁绊好感上限、赠礼间隔、物品保留数量及委托保留。 每次消耗一件物品,默认只使用目标喜欢的物品;遵守当前羁绊好感上限、赠礼间隔、物品保留数量及委托保留。
勾选“每种魔物只培养一只,自动选择培养代表”后,自动为牧场中的每种魔物选一只,按等级 → 好感 → 综合成长资质排序,无需逐只勾选。
综合资质相同再比较四项成长;各项均相同时随机选定并按账号/角色记住。列表显示代表的ID、等级、好感和资质,“刷新 / 预览培养对象”可更新预览。
同种代表满好感或冷却时不改喂同种其他魔物;可继续处理其他种类。自动模式下代表会受自动派遣/喂养保护,手动模式保留原有目标优先级。
两个新开关均默认关闭,修改后自动保存并纳入统一策略导入/导出;选定实例保存在角色目录的 `cultivation_choices.json`,不跨账号复制。
- 收益资料:749 种魔物数据来自用户提供的 APK 1.9.68,支持名称搜索和1–5星分别筛选, - 收益资料:749 种魔物数据来自用户提供的 APK 1.9.68,支持名称搜索和1–5星分别筛选,
可导入 CSV/XLSX 覆盖价格、经验和时间。 可导入 CSV/XLSX 覆盖价格、经验和时间。
- 账号密码登录:第一弹渠道密码验证 → 官方区服列表 → 选择区服并读取角色。 - 账号密码登录:第一弹渠道密码验证 → 官方区服列表 → 选择区服并读取角色。
@@ -235,7 +242,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`。
- 189 项本地测试通过,覆盖登录、会话隔离、账号关闭与移除、菜单账号路由、数字框滚轮、地图缓存、请求计数、等级与体力结算、成长同步、孵蛋与补货、批量喂养、派遣、赠礼、统一策略配置、委托、扫荡、奖励统计与体力效率和每日奖励。 - 199 项本地测试通过,覆盖登录、会话隔离、账号关闭与移除、菜单账号路由、数字框滚轮、地图缓存、请求计数、等级与体力结算、成长同步、孵蛋与补货、同种魔物培养与资质提升保护、批量喂养、派遣、赠礼、统一策略配置、委托、扫荡、奖励统计与体力效率和每日奖励。
新增牧场树形/平铺切换、分组数量与空位、刷新保留折叠和控件、4S保留条件、随机刷新间隔及到期独立同步的回归测试。 新增牧场树形/平铺切换、分组数量与空位、刷新保留折叠和控件、4S保留条件、随机刷新间隔及到期独立同步的回归测试。
双账号与大量库存的界面响应继续通过测试;测试使用本地模拟数据和模拟服务,不操作真实账号库存。 双账号与大量库存的界面响应继续通过测试;测试使用本地模拟数据和模拟服务,不操作真实账号库存。
- 网络写请求发生异常后不会直接重试,以免重复消耗魔物或物品。 - 网络写请求发生异常后不会直接重试,以免重复消耗魔物或物品。
+2 -1
View File
@@ -8,7 +8,8 @@ DEFAULT_ACCOUNT_ENTRIES = ("credentials.json", "credentials.tmp", "sessions", "r
"settings.json", "settings.tmp", "purchase_budget.json", "purchase_budget.tmp", "settings.json", "settings.tmp", "purchase_budget.json", "purchase_budget.tmp",
"daily_claims.json", "daily_claims.tmp", "sweep_runs.json", "sweep_runs.tmp", "daily_claims.json", "daily_claims.tmp", "sweep_runs.json", "sweep_runs.tmp",
"maps.json", "maps.tmp", "network_debug.jsonl", "network_debug.previous.jsonl", "maps.json", "maps.tmp", "network_debug.jsonl", "network_debug.previous.jsonl",
"sweep_rewards.sqlite3", "sweep_rewards.sqlite3-journal", "sweep_rewards.sqlite3-wal", "sweep_rewards.sqlite3-shm") "sweep_rewards.sqlite3", "sweep_rewards.sqlite3-journal", "sweep_rewards.sqlite3-wal", "sweep_rewards.sqlite3-shm",
"cultivation_choices.json", "cultivation_choices.tmp")
def profile_directory(root, identifier): def profile_directory(root, identifier):
+77
View File
@@ -0,0 +1,77 @@
"""Choose a single ranch representative per species, independently of gifts."""
import json
from pathlib import Path
import random
import threading
def growth_values(catalog, mon):
if any(value is None for value in catalog.quality(mon)):
return None
row = catalog.monster(mon.get("typeId"))
return tuple(round(min(1, max(0, (float(f"{float(mon['g' + stat.capitalize()]):.3f}")
- row[stat + "_grow_min"]) / (row[stat + "_grow_max"] - row[stat + "_grow_min"]))), 9)
for stat in ("atk", "def", "hp", "dex"))
def growth_score(catalog, mon):
values = growth_values(catalog, mon)
return round(sum(values) / 4, 9) if values is not None else None
class CultivationSelector:
def __init__(self, catalog, path=None):
self.catalog = catalog
self.path = Path(path) if path else None
self.owner = None
self.choices = {}
self.selected = {}
self.signature = None
self.lock = threading.RLock()
def rank(self, mon):
values = growth_values(self.catalog, mon)
return (int(mon.get("level") or 1), int(mon.get("feel") or 0),
round(sum(values) / 4, 9) if values is not None else -1,
values if values is not None else (-1,) * 4)
def select(self, snapshot):
with self.lock:
owner = str(snapshot.raw["master"]["id"])
ranch = [mon for mon in snapshot.raw["monsters"] if mon.get("process") == 3 and mon.get("typeId") is not None]
signature = (owner, tuple((int(mon["id"]), str(mon["typeId"]), mon.get("level"), mon.get("feel"),
*(mon.get(key) for key in ("gAtk", "gDef", "gHp", "gDex"))) for mon in ranch))
if self.signature == signature:
current = {int(mon["id"]): mon for mon in ranch}
self.selected = {key: current[int(mon["id"])] for key, mon in self.selected.items()}
return self.selected
if self.owner != owner:
self.choices = {}
if self.path and self.path.exists():
try:
value = json.loads(self.path.read_text(encoding="utf-8"))
if value.get("owner") == owner and isinstance(value.get("choices"), dict):
self.choices = {str(key): int(mid) for key, mid in value["choices"].items()}
except (OSError, ValueError, TypeError, AttributeError):
pass
self.owner = owner
groups = {}
for mon in ranch:
groups.setdefault(str(mon["typeId"]), []).append(mon)
selected = {}
for key, members in groups.items():
ranked = [(self.rank(mon), mon) for mon in members]
highest = max(rank for rank, _ in ranked)
tied = [mon for rank, mon in ranked if rank == highest]
previous = next((mon for mon in tied if int(mon["id"]) == self.choices.get(key)), None)
selected[key] = previous if previous is not None else tied[0] if len(tied) == 1 else random.choice(tied)
choices = {key: int(mon["id"]) for key, mon in selected.items()}
if choices != self.choices:
if self.path:
self.path.parent.mkdir(parents=True, exist_ok=True)
temporary = self.path.with_suffix(".tmp")
temporary.write_text(json.dumps({"owner": owner, "choices": choices}, ensure_ascii=False), encoding="utf-8")
temporary.replace(self.path)
self.choices = choices
self.signature, self.selected = signature, selected
return selected
+12 -5
View File
@@ -13,15 +13,18 @@ from .gifts import GiftPlanner
from .master_sync import MasterSync from .master_sync import MasterSync
from .stage_cache import StageCache from .stage_cache import StageCache
from .drop_statistics import reward_text from .drop_statistics import reward_text
from .cultivation import CultivationSelector
class Engine: class Engine:
def __init__(self, catalog, client=None, budget_path=None): def __init__(self, catalog, client=None, budget_path=None):
self.catalog, self.client = catalog, client self.catalog, self.client = catalog, client
self.planner = Planner(catalog) folder = Path(budget_path).parent if budget_path else None
self.hatch_planner = Planner(catalog) self.cultivation = CultivationSelector(catalog, folder / "cultivation_choices.json" if folder else None)
self.planner = Planner(catalog, self.cultivation)
self.hatch_planner = Planner(catalog, self.cultivation)
self.pending_hatches = [] self.pending_hatches = []
self.gift_planner = GiftPlanner(catalog) self.gift_planner = GiftPlanner(catalog, self.cultivation)
self.policy = Policy() self.policy = Policy()
self.quest_policy = QuestPolicy() self.quest_policy = QuestPolicy()
self.tasks = TaskPlanner(catalog) self.tasks = TaskPlanner(catalog)
@@ -36,7 +39,6 @@ class Engine:
self.growth_attempts = {} self.growth_attempts = {}
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
self.stage_cache = StageCache(catalog, folder / "maps.json" if folder 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)
@@ -233,6 +235,8 @@ class Engine:
return self.snapshot, plans, message return self.snapshot, plans, message
def plans(self): def plans(self):
if self.policy.keep_better_quality or self.policy.gift_auto_representative:
self.cultivation.select(self.snapshot)
quests = self.tasks.plan(self.snapshot, self.quest_policy, self.policy) quests = self.tasks.plan(self.snapshot, self.quest_policy, self.policy)
types, eggs = self.tasks.reservations(self.snapshot) types, eggs = self.tasks.reservations(self.snapshot)
reserved = dict(self.policy.reserved_eggs) reserved = dict(self.policy.reserved_eggs)
@@ -245,7 +249,10 @@ class Engine:
daily = [row.action for row in selected_entries(self.catalog, self.snapshot, self.daily_policy, self.daily_ledger)] if self.daily_policy.enabled else [] daily = [row.action for row in selected_entries(self.catalog, self.snapshot, self.daily_policy, self.daily_ledger)] if self.daily_policy.enabled else []
sweep = self.sweeper.next(self.snapshot, self.sweep_policy) if self.sweep_policy.enabled and not self.demo else None sweep = self.sweeper.next(self.snapshot, self.sweep_policy) if self.sweep_policy.enabled and not self.demo else None
sweep_actions = [Action(kind="sweep", path="", payload={}, description=f"扫荡 {sweep.number} {sweep.name} / 难度{sweep.level}")] if sweep else [] sweep_actions = [Action(kind="sweep", path="", payload={}, description=f"扫荡 {sweep.number} {sweep.name} / 难度{sweep.level}")] if sweep else []
return daily + quests + self.gift_planner.plan(self.snapshot, policy, self.quest_policy) + self.planner.plan(self.snapshot, policy, left) + sweep_actions gifts = self.gift_planner.plan(self.snapshot, policy, self.quest_policy)
ranch = self.planner.plan(self.snapshot, policy, left)
self.planner.notes.extend(self.gift_planner.notes)
return daily + quests + gifts + ranch + sweep_actions
def claim_daily_entry(self, entry): def claim_daily_entry(self, entry):
self.daily_ledger.record(self.snapshot, entry.key) self.daily_ledger.record(self.snapshot, entry.key)
+38 -22
View File
@@ -1,5 +1,6 @@
"""Conservative item gifting, using the original client's caps and cooldown.""" """Conservative item gifting, using the original client's caps and cooldown."""
from .model import Action, seconds from .model import Action, seconds
from .cultivation import CultivationSelector
def item_reserve(item_type, ranch, quests): def item_reserve(item_type, ranch, quests):
@@ -7,15 +8,20 @@ def item_reserve(item_type, ranch, quests):
class GiftPlanner: class GiftPlanner:
def __init__(self, catalog): def __init__(self, catalog, cultivation=None):
self.catalog = catalog self.catalog = catalog
self.cultivation = cultivation or CultivationSelector(catalog)
self.notes = [] self.notes = []
def candidates(self, snapshot, policy):
if policy.gift_auto_representative:
return sorted(self.cultivation.select(snapshot).values(), key=lambda mon: self.cultivation.rank(mon), reverse=True)
monsters = snapshot.monsters
return [monsters[int(key)] for key, _ in sorted(policy.gift_targets.items(), key=lambda pair: pair[1])
if int(key) in monsters and monsters[int(key)].get("process") == 3]
def target(self, snapshot, policy): def target(self, snapshot, policy):
for key, _ in sorted(policy.gift_targets.items(), key=lambda pair: pair[1]): for mon in self.candidates(snapshot, policy):
mon = snapshot.monsters.get(int(key))
if not mon or mon.get("process") != 3:
continue
limit = self.catalog.max_feel(mon) limit = self.catalog.max_feel(mon)
if int(mon.get("feel") or 0) < limit: if int(mon.get("feel") or 0) < limit:
return mon, limit return mon, limit
@@ -28,16 +34,6 @@ class GiftPlanner:
if not any(rule.get("enabled") for rule in policy.gift_items.values()): if not any(rule.get("enabled") for rule in policy.gift_items.values()):
self.notes.append("自动赠礼:请先在“背包”勾选允许使用的物品") self.notes.append("自动赠礼:请先在“背包”勾选允许使用的物品")
return [] return []
target, limit = self.target(snapshot, policy)
if not target:
self.notes.append("自动赠礼:未选择目标,或目标已达到当前好感上限")
return []
cooldown = int(self.catalog.data["game_setting"].get("monGiftTime", 7200))
elapsed = snapshot.now - seconds(target.get("giftTime"))
if elapsed < cooldown:
self.notes.append(f"自动赠礼:{self.catalog.monster_label(target)} 还需等待 {int(cooldown - elapsed)} 秒")
return []
likes = self.catalog.monster(target.get("typeId")).get("like") or {}
totals, blocked = {}, set() totals, blocked = {}, set()
for item in snapshot.raw["items"]: for item in snapshot.raw["items"]:
key = str(item.get("typeId")) key = str(item.get("typeId"))
@@ -54,13 +50,33 @@ class GiftPlanner:
continue continue
reserve = item_reserve(key, policy, quest_policy) if quest_policy else int(rule.get("reserve", 0)) reserve = item_reserve(key, policy, quest_policy) if quest_policy else int(rule.get("reserve", 0))
available = max(0, totals[key] - max(int(rule.get("reserve", 0)), reserve)) available = max(0, totals[key] - max(int(rule.get("reserve", 0)), reserve))
if available and (not policy.gift_liked_only or int(likes.get(key, 0)) > 0): if available:
stocks[key] = available stocks[key] = available
if not stocks: if not stocks:
self.notes.append("自动赠礼:背包中没有符合开关、保留数量和偏好规则的物品") self.notes.append("自动赠礼:背包中没有符合开关和保留数量的物品")
return [] return []
key = max(stocks, key=lambda k: (int(likes.get(k, 0)), stocks[k], -int(k))) cooldown = int(self.catalog.data["game_setting"].get("monGiftTime", 7200))
gain = int(likes.get(key, 0)) candidates = self.candidates(snapshot, policy) if policy.gift_auto_representative else [self.target(snapshot, policy)[0]]
name = self.catalog.item_name(key) for target in candidates:
return [Action("gift", f"赠礼 {self.catalog.monster_label(target)} ← {name}(好感 {target.get('feel', 0)}/{limit},预计 {gain:+d})", if target is None:
"monsterService/monsterSendGift", {"monsterId": int(target["id"]), "itemId": int(key)})] continue
limit = self.catalog.max_feel(target)
if int(target.get("feel") or 0) >= limit:
continue
elapsed = snapshot.now - seconds(target.get("giftTime"))
if elapsed < cooldown:
if len(self.notes) < 6:
self.notes.append(f"自动赠礼:{self.catalog.monster_label(target)} 还需等待 {int(cooldown - elapsed)} 秒")
continue
likes = self.catalog.monster(target.get("typeId")).get("like") or {}
usable = [key for key in stocks if not policy.gift_liked_only or int(likes.get(key, 0)) > 0]
if not usable:
continue
key = max(usable, key=lambda k: (int(likes.get(k, 0)), stocks[k], -int(k)))
gain = int(likes.get(key, 0))
name = self.catalog.item_name(key)
return [Action("gift", f"赠礼 {self.catalog.monster_label(target)} ← {name}(好感 {target.get('feel', 0)}/{limit},预计 {gain:+d})",
"monsterService/monsterSendGift", {"monsterId": int(target["id"]), "itemId": int(key)})]
self.notes.append("自动赠礼:培养代表已达好感上限、处于冷却或缺少允许的礼物" if policy.gift_auto_representative
else "自动赠礼:未选择目标、目标已达当前好感上限或没有符合偏好的礼物")
return []
+34 -6
View File
@@ -414,6 +414,8 @@ class Window(ActivityPages, W.QMainWindow):
self.protect_quality = combo([("S及以上", 4), ("A及以上", 3), ("B及以上", 2), ("全部资质", 1), ("不按资质保留", 5), ("四项全S(4S)才保留", 6)]) self.protect_quality = combo([("S及以上", 4), ("A及以上", 3), ("B及以上", 2), ("全部资质", 1), ("不按资质保留", 5), ("四项全S(4S)才保留", 6)])
self.protect_quality.setToolTip("4S要求攻、防、生命、敏捷分别为S;锁定、队伍、保留星级等保护仍单独生效。") self.protect_quality.setToolTip("4S要求攻、防、生命、敏捷分别为S;锁定、队伍、保留星级等保护仍单独生效。")
self.protect_quality.setCurrentIndex(1) self.protect_quality.setCurrentIndex(1)
self.keep_better_quality = W.QCheckBox("保留资质高于牧场同种培养代表的新魔物")
self.keep_better_quality.setToolTip("独立于S/A/B/C及4S条件:按四项成长范围归一化后的平均值比较,严格更高才算提升;牧场没有同种魔物时保留首只。")
self.target = combo([("未设置:不自动喂养", 0)]) self.target = combo([("未设置:不自动喂养", 0)])
self.target_level = spin(1, 100, 70) self.target_level = spin(1, 100, 70)
self.room = combo([("自动选择有空位的牧场", 0)]) self.room = combo([("自动选择有空位的牧场", 0)])
@@ -431,6 +433,7 @@ class Window(ActivityPages, W.QMainWindow):
("保留蛋数量(编号:数量,逗号分隔)", self.reserve_eggs)] ("保留蛋数量(编号:数量,逗号分隔)", self.reserve_eggs)]
for label, widget in rows: for label, widget in rows:
form.addRow(label, widget) form.addRow(label, widget)
form.addRow("同种资质提升保护", self.keep_better_quality)
for widget in (self.strategy, self.coin_exp, self.egg_order, self.min_gold, self.min_exp): for widget in (self.strategy, self.coin_exp, self.egg_order, self.min_gold, self.min_exp):
widget.setParent(self.session_fields) widget.setParent(self.session_fields)
form.addRow(W.QLabel("孵蛋开关、优先级和去向在“背包 → 魔物蛋”逐项配置。")) form.addRow(W.QLabel("孵蛋开关、优先级和去向在“背包 → 魔物蛋”逐项配置。"))
@@ -467,21 +470,27 @@ class Window(ActivityPages, W.QMainWindow):
def gifting_tab(self): def gifting_tab(self):
self.gift_page = W.QWidget() self.gift_page = W.QWidget()
layout = W.QVBoxLayout(self.gift_page) layout = W.QVBoxLayout(self.gift_page)
self.gift_enabled = W.QCheckBox("启用自动赠礼(在背包勾选物品,在牧场勾选目标)") self.gift_enabled = W.QCheckBox("启用自动赠礼(在背包勾选物品,目标可手动或自动选择)")
self.gift_auto_representative = W.QCheckBox("每种魔物只培养一只,自动选择培养代表")
self.gift_liked_only = W.QCheckBox("仅赠送目标喜欢的物品") self.gift_liked_only = W.QCheckBox("仅赠送目标喜欢的物品")
self.gift_liked_only.setChecked(True) self.gift_liked_only.setChecked(True)
self.gift_status = W.QLabel("未启用;达到当前羁绊对应的好感上限后停止。") self.gift_status = W.QLabel("未启用;达到当前羁绊对应的好感上限后停止。")
self.gift_status.setWordWrap(True) self.gift_status.setWordWrap(True)
for widget in (self.gift_enabled, self.gift_liked_only, self.gift_status): for widget in (self.gift_enabled, self.gift_auto_representative, self.gift_liked_only, self.gift_status):
layout.addWidget(widget) layout.addWidget(widget)
for widget in (self.gift_enabled, self.gift_liked_only): for widget in (self.gift_enabled, self.gift_auto_representative, self.gift_liked_only):
widget.toggled.connect(self.update_gift_status) widget.toggled.connect(self.update_gift_status)
note = W.QLabel("物品用量、保留数量和目标优先级分别在“背包”和“牧场”设置;修改后自动生效。达到当前好感上限或处于赠礼冷却时停止。") note = W.QLabel("自动模式按等级 → 好感 → 综合成长资质选择每种魔物的一只代表,全部相同时随机选定并记住;忽略手动勾选的重复目标。\n代表满好感或冷却时不改喂同种另一只,可继续处理其他种类。礼物开关和保留数量仍在“背包”设置。")
note.setWordWrap(True) note.setWordWrap(True)
layout.addWidget(note) layout.addWidget(note)
self.gift_representatives = table(["魔物种类", "培养对象 ID", "等级", "好感 / 上限", "资质 攻/防/血/敏"])
self.gift_representatives.setMinimumHeight(120)
self.gift_representatives.setVisible(False)
layout.addWidget(self.gift_representatives, 1)
buttons = W.QHBoxLayout() buttons = W.QHBoxLayout()
for label, callback in (("去背包选择物品", lambda: self.tabs.setCurrentWidget(self.inventory_tabs)), for label, callback in (("去背包选择物品", lambda: self.tabs.setCurrentWidget(self.inventory_tabs)),
("去牧场选择目标", lambda: self.tabs.setCurrentWidget(self.room_page)), ("去牧场选择目标", lambda: self.tabs.setCurrentWidget(self.room_page)),
("刷新 / 预览培养对象", self.refresh),
("开始执行勾选策略", self.start_workflow), ("停止执行", self.stop_workflow)): ("开始执行勾选策略", self.start_workflow), ("停止执行", self.stop_workflow)):
button = W.QPushButton(label) button = W.QPushButton(label)
button.clicked.connect(callback) button.clicked.connect(callback)
@@ -583,6 +592,7 @@ class Window(ActivityPages, W.QMainWindow):
self.fill.toggled.connect(self.arm_hatching) self.fill.toggled.connect(self.arm_hatching)
self.ranch_enabled.toggled.connect(self.arm_hatching) self.ranch_enabled.toggled.connect(self.arm_hatching)
self.protect_star.valueChanged.connect(self.update_workflow_status) self.protect_star.valueChanged.connect(self.update_workflow_status)
self.keep_better_quality.toggled.connect(self.update_workflow_status)
self.update_workflow_status() self.update_workflow_status()
def execution_changed(self, value): def execution_changed(self, value):
@@ -676,6 +686,8 @@ class Window(ActivityPages, W.QMainWindow):
self.market_status.setText("登录后显示市场解锁状态和购蛋剩余额度") self.market_status.setText("登录后显示市场解锁状态和购蛋剩余额度")
enabled = sum(bool(rule.get("enabled")) for rule in self.egg_rules.values()) enabled = sum(bool(rule.get("enabled")) for rule in self.egg_rules.values())
self.workflow_rules.setText(f"手动孵蛋规则:已勾选 {enabled} 种;保留 {self.protect_star.value()} 星及以上;资质保护:{self.protect_quality.currentText()}。") self.workflow_rules.setText(f"手动孵蛋规则:已勾选 {enabled} 种;保留 {self.protect_star.value()} 星及以上;资质保护:{self.protect_quality.currentText()}。")
if self.keep_better_quality.isChecked():
self.workflow_rules.setText(self.workflow_rules.text() + " 额外保留优于同种培养代表的魔物。")
self.draw_status.setText("最近抽蛋:" + (self.engine.last_draw or "尚无记录")) self.draw_status.setText("最近抽蛋:" + (self.engine.last_draw or "尚无记录"))
def render_egg_rules(self): def render_egg_rules(self):
@@ -712,7 +724,18 @@ class Window(ActivityPages, W.QMainWindow):
def update_gift_status(self, *args): def update_gift_status(self, *args):
if not hasattr(self, "gift_status"): if not hasattr(self, "gift_status"):
return return
self.gift_status.setText(f"已允许 {sum(bool(r.get('enabled')) for r in self.gift_items.values())} 种物品;已选择 {len(self.gift_targets)} 个目标;每次赠礼一件,达到当前好感上限或处于赠礼间隔时停止。") targets = "自动选择每种魔物的唯一培养代表" if self.gift_auto_representative.isChecked() else f"已选择 {len(self.gift_targets)} 个手动目标"
self.gift_status.setText(f"已允许 {sum(bool(r.get('enabled')) for r in self.gift_items.values())} 种物品;{targets};每次赠礼一件,遵守当前好感上限和赠礼间隔。")
if hasattr(self, "gift_representatives"):
self.gift_representatives.setVisible(self.gift_auto_representative.isChecked())
def render_gift_representatives(self, snapshot):
if not self.gift_auto_representative.isChecked():
return
representatives = self.engine.cultivation.selected if self.engine.cultivation.owner == str(snapshot.raw["master"]["id"]) else {}
rows = [[self.catalog.monster(mon["typeId"]).get("name", mon["typeId"]), mon["id"], mon.get("level", 1),
f"{mon.get('feel') or 0} / {self.catalog.max_feel(mon)}", self.catalog.quality_text(mon)] for mon in representatives.values()]
fill_table(self.gift_representatives, rows)
def monster_view_changed(self, *args): def monster_view_changed(self, *args):
grouped = bool(self.monster_view.currentData()) grouped = bool(self.monster_view.currentData())
@@ -1312,6 +1335,7 @@ class Window(ActivityPages, W.QMainWindow):
feed_targets=copy.deepcopy(self.feed_targets), feed_targets=copy.deepcopy(self.feed_targets),
gift_enabled=self.gift_enabled.isChecked(), gift_targets=copy.deepcopy(self.gift_targets), gift_enabled=self.gift_enabled.isChecked(), gift_targets=copy.deepcopy(self.gift_targets),
gift_items=copy.deepcopy(self.gift_items), gift_liked_only=self.gift_liked_only.isChecked(), gift_items=copy.deepcopy(self.gift_items), gift_liked_only=self.gift_liked_only.isChecked(),
gift_auto_representative=self.gift_auto_representative.isChecked(), keep_better_quality=self.keep_better_quality.isChecked(),
keep_money=self.keep_money.value(), daily_buy_money=self.daily_buy_money.value()) keep_money=self.keep_money.value(), daily_buy_money=self.daily_buy_money.value())
def read_quest_policy(self): def read_quest_policy(self):
@@ -1496,6 +1520,8 @@ class Window(ActivityPages, W.QMainWindow):
self.analysis_page.set_data(self.catalog, data) self.analysis_page.set_data(self.catalog, data)
elif page is self.daily_page: elif page is self.daily_page:
self.render_daily() self.render_daily()
elif page is self.gift_page:
self.render_gift_representatives(snapshot)
elif page is self.target.parentWidget() or page is self.automation_page: elif page is self.target.parentWidget() or page is self.automation_page:
self.refresh_target_choices(snapshot) self.refresh_target_choices(snapshot)
except (ValueError, TypeError, KeyError, AttributeError) as error: except (ValueError, TypeError, KeyError, AttributeError) as error:
@@ -1704,7 +1730,7 @@ class Window(ActivityPages, W.QMainWindow):
"coin_exp", "reserved_types", "reserve_eggs", "fill", "egg_order", "min_gold", "min_exp", "buy_eggs", "coin_exp", "reserved_types", "reserve_eggs", "fill", "egg_order", "min_gold", "min_exp", "buy_eggs",
"buy_ten", "dispatch", "collect", "feed", "market", "egg_stock", "buy_batch", "keep_money", "daily_buy_money", "buy_ten", "dispatch", "collect", "feed", "market", "egg_stock", "buy_batch", "keep_money", "daily_buy_money",
"hatch_max_star", "gift_enabled", "gift_liked_only", "quest_enabled", "quest_accept", "quest_city", "quest_items", "hatch_max_star", "gift_enabled", "gift_liked_only", "quest_enabled", "quest_accept", "quest_city", "quest_items",
"quest_monsters", "quest_money", "quest_battles", "quest_reserves") "quest_monsters", "quest_money", "quest_battles", "quest_reserves", "keep_better_quality", "gift_auto_representative")
for name in names: for name in names:
widget = getattr(self, name) widget = getattr(self, name)
signal = (widget.toggled if isinstance(widget, W.QAbstractButton) else signal = (widget.toggled if isinstance(widget, W.QAbstractButton) else
@@ -1816,6 +1842,8 @@ class Window(ActivityPages, W.QMainWindow):
self.gift_items = copy.deepcopy(policy.gift_items) self.gift_items = copy.deepcopy(policy.gift_items)
self.gift_enabled.setChecked(policy.gift_enabled) self.gift_enabled.setChecked(policy.gift_enabled)
self.gift_liked_only.setChecked(policy.gift_liked_only) self.gift_liked_only.setChecked(policy.gift_liked_only)
self.gift_auto_representative.setChecked(policy.gift_auto_representative)
self.keep_better_quality.setChecked(policy.keep_better_quality)
blocker = C.QSignalBlocker(self.interval) blocker = C.QSignalBlocker(self.interval)
self.interval.setCurrentIndex(max(0, self.interval.findData(value.get("interval", 30)))) self.interval.setCurrentIndex(max(0, self.interval.findData(value.get("interval", 30))))
del blocker del blocker
+17 -1
View File
@@ -5,6 +5,7 @@ import json
import math import math
from pathlib import Path from pathlib import Path
import time import time
from .cultivation import CultivationSelector, growth_score
WIKI = "https://wiki.biligame.com/myrzx/魔物收益表" WIKI = "https://wiki.biligame.com/myrzx/魔物收益表"
@@ -299,6 +300,8 @@ class Policy:
gift_targets: dict[str, int] = field(default_factory=dict) gift_targets: dict[str, int] = field(default_factory=dict)
gift_items: dict[str, dict] = field(default_factory=dict) gift_items: dict[str, dict] = field(default_factory=dict)
gift_liked_only: bool = True gift_liked_only: bool = True
gift_auto_representative: bool = False
keep_better_quality: bool = False
def __post_init__(self): def __post_init__(self):
self.egg_rules = {str(int(key)): asdict(EggRule(**rule)) for key, rule in self.egg_rules.items()} self.egg_rules = {str(int(key)): asdict(EggRule(**rule)) for key, rule in self.egg_rules.items()}
@@ -317,8 +320,9 @@ class Action:
class Planner: class Planner:
def __init__(self, catalog): def __init__(self, catalog, cultivation=None):
self.catalog = catalog self.catalog = catalog
self.cultivation = cultivation or CultivationSelector(catalog)
self.managed = set() self.managed = set()
self.notes = [] self.notes = []
self.restocking = set() self.restocking = set()
@@ -341,6 +345,18 @@ class Planner:
if condition: if condition:
return reason return reason
quality = math.ceil(sum(qualities) / 4) quality = math.ceil(sum(qualities) / 4)
if policy.keep_better_quality or policy.gift_auto_representative:
representative = self.cultivation.select(snapshot).get(str(mon.get("typeId")))
if representative and int(representative["id"]) == int(mon["id"]):
return "同种魔物的唯一培养代表(等级、好感、资质优先)"
if policy.keep_better_quality:
if representative is None:
return "牧场尚无同种魔物,保留首次获得的魔物"
baseline, candidate = growth_score(self.catalog, representative), growth_score(self.catalog, mon)
if baseline is None:
return "同种培养代表的资质尚未同步,暂时保留"
if candidate is not None and candidate > baseline + 1e-8:
return f"综合成长资质高于同种培养代表 #{representative['id']}({candidate:.1%} > {baseline:.1%})"
if policy.protect_quality == 6: if policy.protect_quality == 6:
return "攻/防/生命/敏捷四项资质全S(4S)" if all(q == 4 for q in qualities) else "" return "攻/防/生命/敏捷四项资质全S(4S)" if all(q == 4 for q in qualities) else ""
if quality >= policy.protect_quality: if quality >= policy.protect_quality:
@@ -94,11 +94,12 @@ class RemovalTests(unittest.TestCase):
(folder / "roles" / "role").mkdir(parents=True) (folder / "roles" / "role").mkdir(parents=True)
(folder / "roles" / "role" / "maps.json").write_text("{}", encoding="utf-8") (folder / "roles" / "role" / "maps.json").write_text("{}", encoding="utf-8")
(folder / "sweep_rewards.sqlite3").write_text("synthetic statistics", encoding="utf-8") (folder / "sweep_rewards.sqlite3").write_text("synthetic statistics", encoding="utf-8")
(folder / "cultivation_choices.json").write_text("{}", encoding="utf-8")
shared = folder / "shared-note.txt" shared = folder / "shared-note.txt"
shared.write_text("keep", encoding="utf-8") shared.write_text("keep", encoding="utf-8")
try: try:
self.remove(hub, "default") self.remove(hub, "default")
for name in ("credentials.json", "sessions", "roles", "settings.json", "sweep_rewards.sqlite3"): for name in ("credentials.json", "sessions", "roles", "settings.json", "sweep_rewards.sqlite3", "cultivation_choices.json"):
self.assertFalse((folder / name).exists()) self.assertFalse((folder / name).exists())
self.assertTrue(sentinel.exists()) self.assertTrue(sentinel.exists())
self.assertTrue(shared.exists()) self.assertTrue(shared.exists())
+176
View File
@@ -0,0 +1,176 @@
import copy
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.cultivation import CultivationSelector, growth_score
from ranch_assistant.engine import Engine, demo_snapshot
from ranch_assistant.gifts import GiftPlanner
from ranch_assistant.gui import Window
from ranch_assistant.model import Catalog, Planner, Policy, Snapshot
from ranch_assistant.policy_io import import_config, portable_config
from ranch_assistant.tests.test_core import workspace_temp
def monster(catalog, mid, *, level=10, feel=0, scale=.3, species=1001010, process=3):
row = catalog.monster(species)
return {"id": mid, "typeId": species, "process": process, "mode": 2, "level": level,
"feel": feel, "entangleLevel": 0, "giftTime": 0, "roomId": 1, "lock": 0,
**{"g" + stat.capitalize(): row[stat + "_grow_min"] + scale * (row[stat + "_grow_max"] - row[stat + "_grow_min"])
for stat in ("atk", "def", "hp", "dex")}}
class CultivationTests(unittest.TestCase):
def setUp(self):
self.catalog = Catalog()
self.snapshot = demo_snapshot(self.catalog)
self.snapshot.raw.update(monsters=[], teams=[], stacks=[])
def test_representative_prefers_level_then_feel_then_growth(self):
rows = [monster(self.catalog, 1, level=11, feel=0, scale=.1),
monster(self.catalog, 2, level=10, feel=99, scale=1),
monster(self.catalog, 3, level=11, feel=1, scale=.1),
monster(self.catalog, 4, level=11, feel=1, scale=.8),
monster(self.catalog, 5, level=99, feel=200, scale=1, process=2)]
self.snapshot.raw["monsters"] = rows
selector = CultivationSelector(self.catalog)
self.assertEqual(selector.select(self.snapshot)["1001010"]["id"], 4)
rows[1]["level"] = 12
self.assertEqual(selector.select(self.snapshot)["1001010"]["id"], 2)
def test_ties_are_chosen_once_persisted_and_do_not_leak_to_other_role(self):
self.snapshot.raw["monsters"] = [monster(self.catalog, 1), monster(self.catalog, 2)]
with workspace_temp() as folder:
path = folder / "choices.json"
with patch("ranch_assistant.cultivation.random.choice", side_effect=lambda choices: choices[-1]) as draw:
selector = CultivationSelector(self.catalog, path)
self.assertEqual(selector.select(self.snapshot)["1001010"]["id"], 2)
selector.select(self.snapshot)
self.assertEqual(draw.call_count, 1)
with patch("ranch_assistant.cultivation.random.choice", side_effect=AssertionError("Re-selected an exact tie")):
self.assertEqual(CultivationSelector(self.catalog, path).select(self.snapshot)["1001010"]["id"], 2)
self.snapshot.raw["master"]["id"] += 1
with patch("ranch_assistant.cultivation.random.choice", side_effect=lambda choices: choices[0]):
self.assertEqual(CultivationSelector(self.catalog, path).select(self.snapshot)["1001010"]["id"], 1)
def test_cached_selection_uses_current_cooldown_and_bond_cap(self):
self.snapshot.raw["monsters"] = [monster(self.catalog, 1)]
selector = CultivationSelector(self.catalog)
selector.select(self.snapshot)
updated = Snapshot(copy.deepcopy(self.snapshot.raw))
updated.raw["monsters"][0].update(giftTime=123456789, entangleLevel=2)
chosen = selector.select(updated)["1001010"]
self.assertIs(chosen, updated.raw["monsters"][0])
self.assertEqual((chosen["giftTime"], chosen["entangleLevel"]), (123456789, 2))
def test_better_growth_is_kept_independently_of_four_s_and_equal_or_worse_is_not(self):
representative = monster(self.catalog, 1, level=50, feel=90, scale=.3)
hatched = monster(self.catalog, 2, level=1, scale=.4, process=2)
self.snapshot.raw["monsters"] = [representative, hatched]
planner = Planner(self.catalog)
policy = Policy(strategy="gold", protect_star=6, protect_quality=6, keep_better_quality=True)
self.assertEqual(planner.disposition(hatched, self.snapshot, policy), "keep")
self.assertIn("同种培养代表 #1", planner.protection_reason(hatched, self.snapshot, policy))
policy.keep_better_quality = False
self.assertEqual(planner.disposition(hatched, self.snapshot, policy), "sell")
policy.keep_better_quality = True
for scale in (.3, .2):
self.snapshot.raw["monsters"][1] = monster(self.catalog, 2, scale=scale, process=2)
self.assertEqual(planner.disposition(self.snapshot.monsters[2], self.snapshot, policy), "sell")
def test_missing_species_or_unknown_reference_is_conservatively_retained(self):
hatched = monster(self.catalog, 2, process=2)
self.snapshot.raw["monsters"] = [hatched]
policy = Policy(protect_star=6, protect_quality=5, keep_better_quality=True)
planner = Planner(self.catalog)
self.assertIn("首次", planner.protection_reason(hatched, self.snapshot, policy))
reference = monster(self.catalog, 1, level=50)
reference["gAtk"] = None
self.snapshot.raw["monsters"].append(reference)
self.assertIn("尚未同步", planner.protection_reason(hatched, self.snapshot, policy))
def test_gifts_target_only_the_representative_and_do_not_move_to_duplicates_at_cap(self):
best = monster(self.catalog, 1, level=30)
duplicate = monster(self.catalog, 2, level=29, feel=50, scale=1)
self.snapshot.raw["monsters"] = [best, duplicate]
self.snapshot.raw["items"] = [{"id": 1, "typeId": 30005, "num": 20}]
policy = Policy(gift_enabled=True, gift_auto_representative=True, gift_liked_only=False,
gift_targets={"2": 1}, gift_items={"30005": {"enabled": True, "reserve": 2}})
planner = GiftPlanner(self.catalog)
self.assertEqual(planner.plan(self.snapshot, policy)[0].payload["monsterId"], 1)
best["feel"] = self.catalog.max_feel(best)
self.assertEqual(planner.plan(self.snapshot, policy), [])
best["feel"] = 0
best["giftTime"] = self.snapshot.now * 1000
self.assertEqual(planner.plan(self.snapshot, policy), [])
def test_cooldown_or_unavailable_food_skips_to_other_species_without_wasting_on_duplicates(self):
self.snapshot.raw["monsters"] = [monster(self.catalog, 1, level=50), monster(self.catalog, 2, level=40),
monster(self.catalog, 3, level=20, species=1002010)]
self.snapshot.raw["monsters"][0]["giftTime"] = self.snapshot.now * 1000
self.snapshot.raw["items"] = [{"id": 1, "typeId": 30005, "num": 3}]
policy = Policy(gift_enabled=True, gift_auto_representative=True, gift_liked_only=False,
gift_items={"30005": {"enabled": True, "reserve": 2}})
planner = GiftPlanner(self.catalog)
self.assertEqual(planner.plan(self.snapshot, policy)[0].payload["monsterId"], 3)
self.snapshot.raw["items"][0]["num"] = 2
self.assertEqual(planner.plan(self.snapshot, policy), [])
def test_auto_gift_representative_is_also_protected_from_hatch_disposal(self):
representative = monster(self.catalog, 1, level=20)
self.snapshot.raw["monsters"] = [representative, monster(self.catalog, 2, level=1)]
policy = Policy(strategy="gold", protect_star=6, protect_quality=5, gift_auto_representative=True)
planner = Planner(self.catalog)
self.assertTrue(planner.protected(representative, self.snapshot, policy))
self.assertFalse(planner.protected(self.snapshot.monsters[2], self.snapshot, policy))
def test_growth_score_normalizes_health_and_attack_to_their_own_ranges(self):
mon = monster(self.catalog, 1, scale=.5)
self.assertAlmostEqual(growth_score(self.catalog, mon), .5, places=3)
mon["gHp"] = self.catalog.monster(1001010)["hp_grow_max"]
self.assertAlmostEqual(growth_score(self.catalog, mon), .625, places=3)
class CultivationGuiTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.app = W.QApplication.instance() or W.QApplication([])
def wait(self, predicate):
for _ in range(800):
self.app.processEvents()
QTest.qWait(2)
if predicate():
return
self.fail("Cultivation preview did not finish")
def test_rule_flags_autosave_and_portable_settings_and_representative_preview(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)
window.keep_better_quality.setChecked(True)
window.gift_auto_representative.setChecked(True)
self.wait(lambda: not window.auto_save_timer.isActive())
saved = json.loads((folder / "settings.json").read_text(encoding="utf-8"))
self.assertTrue(saved["policy"]["keep_better_quality"])
self.assertTrue(window.engine.policy.gift_auto_representative)
imported = import_config(portable_config(window.config_value(), window.engine.snapshot), window.engine.snapshot)
self.assertTrue(imported["policy"]["keep_better_quality"])
self.assertTrue(imported["policy"]["gift_auto_representative"])
window.engine.plans()
window.tabs.setCurrentWidget(window.gift_page)
self.assertGreater(window.gift_representatives.rowCount(), 0)
self.assertFalse(window.execute.isChecked())
window.load_config()
self.assertTrue(window.keep_better_quality.isChecked())
self.assertTrue(window.gift_auto_representative.isChecked())
finally:
window.close()