Files
myrzx_bot/ranch_assistant/breakthrough.py
T

297 lines
14 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""Plan one original-client potential operation from a fresh snapshot.
This module never calls a Client or updates snapshot state. The runner must read
the snapshot again after executing either returned Action. ``potentialLevel``
is the material-based PotentialPanel stage; feeding's ``tpLevel/tpExp`` is a
separate progression and deliberately does not affect readiness here.
"""
from __future__ import annotations
from dataclasses import dataclass
from .cultivation import CultivationSelector
from .model import Action
from .team_availability import _exploring_ids
PATH = "monsterService/monsterPotentialLevelUpgrade"
POTENTIAL_PATH = "monsterService/monsterPotentialUpgrade"
STATS = ("atk", "def", "hp", "dex")
LABELS = {"atk": "攻击", "def": "防御", "hp": "生命", "dex": "敏捷"}
def integer(value):
"""Accept integer-valued server numbers, not lossy bool/NaN conversions."""
if isinstance(value, bool) or value is None:
return None
if isinstance(value, str):
try:
return int(value.strip())
except (ValueError, OverflowError):
return None
try:
result = int(value)
except (TypeError, ValueError, OverflowError):
return None
try:
return result if result == value else None
except (TypeError, ValueError):
return None
def field(row, name, default=None):
if isinstance(row, dict):
return row.get(name, default)
return getattr(row, name, default)
def primary_target_reason(catalog, cultivation, snapshot, monster_id, *, primaries=None):
"""Admission for automatic resources only; saved target maps are not authority."""
mid = integer(monster_id)
mon = snapshot.monsters.get(mid) if snapshot is not None else None
if mon is None:
return f"自动培养目标 #{monster_id} 已不在角色数据中"
label = catalog.monster_label(mon)
if mon.get("process") != 3:
return f"{label} 不在牧场,暂停自动培养"
primaries = cultivation.select(snapshot) if primaries is None else primaries
primary = primaries.get(str(mon.get("typeId")))
if primary is None:
return f"{label} 尚未确认同种主培养,暂停自动培养"
if int(primary["id"]) != mid:
return (f"{label} 是同种非主培养(备选 / 重复魔物);"
f"仅主培养 #{primary['id']} 可自动喂养、赠礼和突破")
if mon.get("inExploreTeam") or mid in _exploring_ids(snapshot):
return f"{label} 主培养正在探险,暂停自动培养,不改用备选"
if mon.get("inBuild"):
return f"{label} 主培养正在建筑,暂停自动培养,不改用备选"
if mon.get("sysLock"):
return f"{label} 主培养系统锁定,暂停自动培养,不改用备选"
return ""
@dataclass(frozen=True)
class Material:
type_id: int
required: int
available: int
item_ids: tuple[int, ...]
@dataclass(frozen=True)
class Candidate:
monster: dict
next_level: int
materials: tuple[Material, ...]
reason: str
@property
def ready(self):
return bool(self.materials) and not self.reason
class BreakthroughPlanner:
"""Plan PotentialPanel writes; each call returns at most one operation."""
def __init__(self, catalog, cultivation=None):
self.catalog = catalog
self.cultivation = cultivation or CultivationSelector(catalog)
self.notes = []
@staticmethod
def target_ids(policy, targets=None):
"""Explicit targets replace feeding, including an explicitly empty map."""
if targets is None:
targets = field(policy, "feed_targets")
if targets:
pass
else:
legacy = integer(field(policy, "feed_target", 0))
return [legacy] if legacy is not None and legacy > 0 else []
if not isinstance(targets, dict):
return []
pairs = []
for mid, priority in targets.items():
mid, priority = integer(mid), integer(priority)
if mid is not None and mid > 0 and priority is not None:
pairs.append((priority, mid))
return [mid for _, mid in sorted(pairs)]
@staticmethod
def reserves(policy, type_id):
"""Combine the target-item switch with ranch and quest reservations."""
key = str(type_id)
quest = field(policy, "quest_policy", {})
gift_rule = field(policy, "gift_items", {}).get(key, {})
values = [field(policy, "reserved_eggs", {}).get(key, 0),
field(policy, "item_reserves", {}).get(key, 0),
field(quest, "item_reserves", {}).get(key, 0),
field(gift_rule, "reserve", 0)]
parsed = [integer(value) for value in values]
if any(value is None or value < 0 for value in parsed):
return None
return max(parsed, default=0)
def stacks(self, snapshot, policy):
groups, seen = {}, set()
for item in snapshot.raw["items"]:
item_id, type_id, count = (integer(item.get(key)) for key in ("id", "typeId", "num"))
if item_id is None or type_id is None or count is None or item_id <= 0 or count <= 0:
continue
if item_id in seen:
raise ValueError("背包材料实例重复,暂不操作")
seen.add(item_id)
groups.setdefault(type_id, []).append((item_id, count, item))
usable = {}
for type_id, entries in groups.items():
reserve = self.reserves(policy, type_id)
if reserve is None:
raise ValueError("突破道具保留数量配置无效")
entries = [entry for entry in entries if not entry[2].get("lock") and not entry[2].get("feedLock")]
total = sum(count for _, count, _ in entries)
usable[type_id] = {"entries": entries, "available": max(0, total - reserve), "total": total}
return usable
def select_stack(self, usable, type_id, amount, reserved=None):
"""Select one sufficient stack; do not aggregate stock for itemIds."""
stock = usable.get(type_id, {"entries": [], "available": 0})
if stock["available"] < amount:
return None
entries = stock["entries"] if reserved is None else [
entry for entry in stock["entries"] if entry[0] not in reserved]
eligible = [entry for entry in entries if entry[1] >= amount]
if not eligible:
return None
item_id, count, _ = min(eligible, key=lambda entry: (entry[1], entry[0]))
return item_id, count
def caps(self, mon):
info = self.catalog.data.get("potential_info", {})
row = self.catalog.monster(mon.get("typeId"))
level = integer(mon.get("potentialLevel"))
if level is None or level < 1 or not row:
return None, None, "突破等级或魔物资料尚未同步"
maximum = integer(info.get("maxPotentialLevel"))
if maximum is not None and level >= maximum:
return None, None, "已达到最高突破等级"
caps = (info.get("potential") or {}).get(str(row.get("job")), {}).get(str(row.get("star")))
if not caps:
return None, None, "当前突破配置缺失"
result = {}
for stat in STATS:
base, increment = integer(caps.get(stat)), integer(caps.get(stat + "TpAdd"))
current = integer(mon.get("p" + stat.capitalize()))
if base is None or increment is None or current is None:
return None, None, "潜能数据尚未同步"
cap = base + (level - 1) * increment
if cap < 0 or current < 0:
return None, None, "潜能数据异常"
result[stat] = (current, cap)
return level, result, ""
def potential_action(self, mon, caps, usable):
"""One original addPotential call consumes exactly one type-ID item."""
row = self.catalog.monster(mon.get("typeId"))
type_id = integer((self.catalog.data.get("potential_info", {}).get("potentialElementItem") or {}).get(str(row.get("element"))))
if type_id is None:
return None, "当前补潜能材料配置缺失"
selected = self.select_stack(usable, type_id, 1)
incomplete = [stat for stat in STATS if caps[stat][0] < caps[stat][1]]
if selected is None:
total = usable.get(type_id, {}).get("available", 0)
return None, f"补潜能材料不足或受保留数量限制:{self.catalog.item_name(type_id)} {total}/1"
stat = min(incomplete, key=lambda key: (caps[key][1] - caps[key][0], STATS.index(key)))
item_id, count = selected
current, cap = caps[stat]
description = (f"补潜能 {self.catalog.monster_label(mon)} {LABELS[stat]} {current}/{cap}"
f"(消耗 {self.catalog.item_name(type_id)}×1;成功后重新读取,四项满再突破)")
return Action("potential", description, POTENTIAL_PATH,
{"traceInfo": {"itemTypeId": item_id, "itemNum": count},
"monId": integer(mon["id"]), "itemId": item_id, "monsterAttr": stat}), ""
def evaluate(self, mon, items, policy=None, snapshot=None):
"""Compatibility helper for stage evaluation with the same stock rules."""
if snapshot is None:
snapshot = type("ItemsSnapshot", (), {"raw": {"items": items}})()
policy = policy if policy is not None else type("ItemPolicy", (), {
"gift_items": {}})()
level, caps, reason = self.caps(mon)
if level is None:
return Candidate(mon, 0, (), reason)
incomplete = [f"{LABELS[stat]} {current}/{cap}" for stat, (current, cap) in caps.items() if current < cap]
if incomplete:
return Candidate(mon, level + 1, (), "潜能未满:" + ",".join(incomplete))
info = self.catalog.data.get("potential_info", {})
row = self.catalog.monster(mon.get("typeId"))
need = (info.get("potentialLevelItem") or {}).get(str(row.get("star")), {}).get(str(level))
elements = (info.get("elementItem") or {}).get(str(row.get("element")))
if not need or not elements:
return Candidate(mon, level + 1, (), "当前突破配置缺失")
try:
usable = self.stacks(snapshot, policy)
except ValueError as error:
return Candidate(mon, level + 1, (), str(error))
requirements = {}
for level_key in sorted(need, key=lambda key: integer(key[2:]) or 999):
type_id, amount = integer(elements.get(level_key)), integer(need[level_key])
if type_id is None or amount is None or amount <= 0:
return Candidate(mon, level + 1, (), "当前突破材料配置异常")
requirements[type_id] = requirements.get(type_id, 0) + amount
materials, missing, selected_ids = [], [], set()
for type_id, amount in requirements.items():
selected = self.select_stack(usable, type_id, amount)
available = usable.get(type_id, {}).get("available", 0)
materials.append(Material(type_id, amount, available, (selected[0],) if selected else ()))
if selected is None:
missing.append(f"{self.catalog.item_name(type_id)} 可用单堆不足 {available}/{amount}")
else:
selected_ids.add(selected[0])
return Candidate(mon, level + 1, tuple(materials), "材料不足:" + ",".join(missing) if missing else "")
def plan(self, snapshot, policy, *, targets=None, enabled=True):
self.notes = []
if not enabled or field(policy, "enabled", True) is not True:
return None
ids = self.target_ids(policy, targets)
if not ids:
self.notes.append("未选择自动突破目标")
return None
primaries = self.cultivation.select(snapshot)
for mid in ids:
reason = primary_target_reason(self.catalog, self.cultivation, snapshot, mid, primaries=primaries)
if reason:
self.notes.append(reason)
continue
mon = snapshot.monsters[mid]
label = self.catalog.monster_label(mon)
level, caps, reason = self.caps(mon)
if level is None:
self.notes.append(f"{label}:{reason}")
continue
try:
usable = self.stacks(snapshot, policy)
except ValueError as error:
self.notes.append(f"{label}:{error}")
continue
if any(current < cap for current, cap in caps.values()):
action, reason = self.potential_action(mon, caps, usable)
if action:
self.notes.append(f"{label} 先补满四项潜能,再提升至 {level + 1} 阶段;每轮仅操作一次")
return action
self.notes.append(f"{label}:{reason}")
continue
candidate = self.evaluate(mon, snapshot.raw["items"], policy, snapshot)
if not candidate.ready:
self.notes.append(f"{label}:{candidate.reason}")
continue
item_ids = [item_id for material in candidate.materials for item_id in material.item_ids]
cost = "、".join(f"{self.catalog.item_name(m.type_id)}×{m.required}" for m in candidate.materials)
self.notes.append(f"{label} 可提升至 {candidate.next_level} 阶段")
return Action("breakthrough", f"突破 {label} → {candidate.next_level} 阶段({cost};不消耗tp经验)",
PATH, {"monId": mid, "itemIds": item_ids})
return None
def plan_breakthrough(catalog, snapshot, policy, *, targets=None, enabled=True):
return BreakthroughPlanner(catalog).plan(snapshot, policy, targets=targets, enabled=enabled)