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秒装填一个坑位,确认成功后继续下一坑,不受整体刷新间隔影响。
每次装填前重新读取坑位和库存;无可用蛋、坑位已满或停止自动执行时暂停。此快速计时不会执行购蛋、派遣或其他操作。
子页分为“孵蛋策略”“牧场策略”“喂养策略”,内容超出高度时滚动显示,修改后自动保存并应用。
“牧场策略”新增独立开关“保留资质高于牧场同种培养代表的新魔物”,与S/A/B/C、4S及星级保护分别生效。
同种培养代表优先选等级最高者,再依次比较好感、综合成长资质;新魔物的四项成长按各自范围归一化后取平均,严格更高才算提升。
同分不算提升;牧场尚无同种时保留首只,代表资质未同步完整时暂留。已有锁定、队伍及保留种类保护继续生效。
- 统一策略配置:通过主窗口菜单“策略配置”,保存、导入或导出当前账号的全部孵蛋、牧场、喂养、赠礼、委托、每日事务、扫荡及监控间隔设置,包含自定义收益资料。
跨账号按魔物种类匹配喂养和赠礼目标;牧场实例编号不跨账号复制,默认使用有空位的牧场。兼容旧版培养策略文件。
导入保留功能勾选和规则,执行保持停止,核对后手动开始;文件不包含账号、密码、Token、会话或本机路径。
- 自动赠礼:独立页签,在背包勾选可用物品,在牧场勾选目标并设置优先级,再到“自动赠礼”启用。
每次消耗一件物品,默认只使用目标喜欢的物品;遵守当前羁绊好感上限、赠礼间隔、物品保留数量及委托保留。
勾选“每种魔物只培养一只,自动选择培养代表”后,自动为牧场中的每种魔物选一只,按等级 → 好感 → 综合成长资质排序,无需逐只勾选。
综合资质相同再比较四项成长;各项均相同时随机选定并按账号/角色记住。列表显示代表的ID、等级、好感和资质,“刷新 / 预览培养对象”可更新预览。
同种代表满好感或冷却时不改喂同种其他魔物;可继续处理其他种类。自动模式下代表会受自动派遣/喂养保护,手动模式保留原有目标优先级。
两个新开关均默认关闭,修改后自动保存并纳入统一策略导入/导出;选定实例保存在角色目录的 `cultivation_choices.json`,不跨账号复制。
- 收益资料:749 种魔物数据来自用户提供的 APK 1.9.68,支持名称搜索和1–5星分别筛选,
可导入 CSV/XLSX 覆盖价格、经验和时间。
- 账号密码登录:第一弹渠道密码验证 → 官方区服列表 → 选择区服并读取角色。
@@ -235,7 +242,7 @@
- 自定义表:`typeId, sell_money, sell_exp, time_total`(秒),可只提供部分
覆盖列;中文列名“编号、派遣金币、强化经验、孵化秒数”也支持。
- 测试:`python -m unittest discover -s ranch_assistant/tests -v`。
- 189 项本地测试通过,覆盖登录、会话隔离、账号关闭与移除、菜单账号路由、数字框滚轮、地图缓存、请求计数、等级与体力结算、成长同步、孵蛋与补货、批量喂养、派遣、赠礼、统一策略配置、委托、扫荡、奖励统计与体力效率和每日奖励。
- 199 项本地测试通过,覆盖登录、会话隔离、账号关闭与移除、菜单账号路由、数字框滚轮、地图缓存、请求计数、等级与体力结算、成长同步、孵蛋与补货、同种魔物培养与资质提升保护、批量喂养、派遣、赠礼、统一策略配置、委托、扫荡、奖励统计与体力效率和每日奖励。
新增牧场树形/平铺切换、分组数量与空位、刷新保留折叠和控件、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",
"daily_claims.json", "daily_claims.tmp", "sweep_runs.json", "sweep_runs.tmp",
"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):
+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 .stage_cache import StageCache
from .drop_statistics import reward_text
from .cultivation import CultivationSelector
class Engine:
def __init__(self, catalog, client=None, budget_path=None):
self.catalog, self.client = catalog, client
self.planner = Planner(catalog)
self.hatch_planner = Planner(catalog)
folder = Path(budget_path).parent if budget_path else None
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.gift_planner = GiftPlanner(catalog)
self.gift_planner = GiftPlanner(catalog, self.cultivation)
self.policy = Policy()
self.quest_policy = QuestPolicy()
self.tasks = TaskPlanner(catalog)
@@ -36,7 +39,6 @@ class Engine:
self.growth_attempts = {}
self.master_sync = MasterSync(catalog)
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.daily_policy = DailyPolicy()
self.daily_ledger = DailyLedger(folder / "daily_claims.json" if folder else None)
@@ -233,6 +235,8 @@ class Engine:
return self.snapshot, plans, message
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)
types, eggs = self.tasks.reservations(self.snapshot)
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 []
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 []
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):
self.daily_ledger.record(self.snapshot, entry.key)
+34 -18
View File
@@ -1,5 +1,6 @@
"""Conservative item gifting, using the original client's caps and cooldown."""
from .model import Action, seconds
from .cultivation import CultivationSelector
def item_reserve(item_type, ranch, quests):
@@ -7,15 +8,20 @@ def item_reserve(item_type, ranch, quests):
class GiftPlanner:
def __init__(self, catalog):
def __init__(self, catalog, cultivation=None):
self.catalog = catalog
self.cultivation = cultivation or CultivationSelector(catalog)
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):
for key, _ in sorted(policy.gift_targets.items(), key=lambda pair: pair[1]):
mon = snapshot.monsters.get(int(key))
if not mon or mon.get("process") != 3:
continue
for mon in self.candidates(snapshot, policy):
limit = self.catalog.max_feel(mon)
if int(mon.get("feel") or 0) < limit:
return mon, limit
@@ -28,16 +34,6 @@ class GiftPlanner:
if not any(rule.get("enabled") for rule in policy.gift_items.values()):
self.notes.append("自动赠礼:请先在“背包”勾选允许使用的物品")
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()
for item in snapshot.raw["items"]:
key = str(item.get("typeId"))
@@ -54,13 +50,33 @@ class GiftPlanner:
continue
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))
if available and (not policy.gift_liked_only or int(likes.get(key, 0)) > 0):
if available:
stocks[key] = available
if not stocks:
self.notes.append("自动赠礼:背包中没有符合开关、保留数量和偏好规则的物品")
self.notes.append("自动赠礼:背包中没有符合开关和保留数量的物品")
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))
candidates = self.candidates(snapshot, policy) if policy.gift_auto_representative else [self.target(snapshot, policy)[0]]
for target in candidates:
if target is None:
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.setToolTip("4S要求攻、防、生命、敏捷分别为S;锁定、队伍、保留星级等保护仍单独生效。")
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_level = spin(1, 100, 70)
self.room = combo([("自动选择有空位的牧场", 0)])
@@ -431,6 +433,7 @@ class Window(ActivityPages, W.QMainWindow):
("保留蛋数量(编号:数量,逗号分隔)", self.reserve_eggs)]
for label, widget in rows:
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):
widget.setParent(self.session_fields)
form.addRow(W.QLabel("孵蛋开关、优先级和去向在“背包 → 魔物蛋”逐项配置。"))
@@ -467,21 +470,27 @@ class Window(ActivityPages, W.QMainWindow):
def gifting_tab(self):
self.gift_page = W.QWidget()
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.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):
for widget in (self.gift_enabled, self.gift_auto_representative, self.gift_liked_only, self.gift_status):
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)
note = W.QLabel("物品用量、保留数量和目标优先级分别在“背包”和“牧场”设置;修改后自动生效。达到当前好感上限或处于赠礼冷却时停止。")
note = W.QLabel("自动模式按等级 → 好感 → 综合成长资质选择每种魔物的一只代表,全部相同时随机选定并记住;忽略手动勾选的重复目标。\n代表满好感或冷却时不改喂同种另一只,可继续处理其他种类。礼物开关和保留数量仍在“背包”设置。")
note.setWordWrap(True)
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()
for label, callback in (("去背包选择物品", lambda: self.tabs.setCurrentWidget(self.inventory_tabs)),
("去牧场选择目标", lambda: self.tabs.setCurrentWidget(self.room_page)),
("刷新 / 预览培养对象", self.refresh),
("开始执行勾选策略", self.start_workflow), ("停止执行", self.stop_workflow)):
button = W.QPushButton(label)
button.clicked.connect(callback)
@@ -583,6 +592,7 @@ class Window(ActivityPages, W.QMainWindow):
self.fill.toggled.connect(self.arm_hatching)
self.ranch_enabled.toggled.connect(self.arm_hatching)
self.protect_star.valueChanged.connect(self.update_workflow_status)
self.keep_better_quality.toggled.connect(self.update_workflow_status)
self.update_workflow_status()
def execution_changed(self, value):
@@ -676,6 +686,8 @@ class Window(ActivityPages, W.QMainWindow):
self.market_status.setText("登录后显示市场解锁状态和购蛋剩余额度")
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()}。")
if self.keep_better_quality.isChecked():
self.workflow_rules.setText(self.workflow_rules.text() + " 额外保留优于同种培养代表的魔物。")
self.draw_status.setText("最近抽蛋:" + (self.engine.last_draw or "尚无记录"))
def render_egg_rules(self):
@@ -712,7 +724,18 @@ class Window(ActivityPages, W.QMainWindow):
def update_gift_status(self, *args):
if not hasattr(self, "gift_status"):
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):
grouped = bool(self.monster_view.currentData())
@@ -1312,6 +1335,7 @@ class Window(ActivityPages, W.QMainWindow):
feed_targets=copy.deepcopy(self.feed_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_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())
def read_quest_policy(self):
@@ -1496,6 +1520,8 @@ class Window(ActivityPages, W.QMainWindow):
self.analysis_page.set_data(self.catalog, data)
elif page is self.daily_page:
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:
self.refresh_target_choices(snapshot)
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",
"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",
"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:
widget = getattr(self, name)
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_enabled.setChecked(policy.gift_enabled)
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)
self.interval.setCurrentIndex(max(0, self.interval.findData(value.get("interval", 30))))
del blocker
+17 -1
View File
@@ -5,6 +5,7 @@ import json
import math
from pathlib import Path
import time
from .cultivation import CultivationSelector, growth_score
WIKI = "https://wiki.biligame.com/myrzx/魔物收益表"
@@ -299,6 +300,8 @@ class Policy:
gift_targets: dict[str, int] = field(default_factory=dict)
gift_items: dict[str, dict] = field(default_factory=dict)
gift_liked_only: bool = True
gift_auto_representative: bool = False
keep_better_quality: bool = False
def __post_init__(self):
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:
def __init__(self, catalog):
def __init__(self, catalog, cultivation=None):
self.catalog = catalog
self.cultivation = cultivation or CultivationSelector(catalog)
self.managed = set()
self.notes = []
self.restocking = set()
@@ -341,6 +345,18 @@ class Planner:
if condition:
return reason
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:
return "攻/防/生命/敏捷四项资质全S(4S)" if all(q == 4 for q in qualities) else ""
if quality >= policy.protect_quality:
@@ -94,11 +94,12 @@ class RemovalTests(unittest.TestCase):
(folder / "roles" / "role").mkdir(parents=True)
(folder / "roles" / "role" / "maps.json").write_text("{}", 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.write_text("keep", encoding="utf-8")
try:
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.assertTrue(sentinel.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()