Add automatic mining and ticket resource stages

This commit is contained in:
AttilaNet
2026-11-10 12:54:48 +08:00
parent 0109cc0d1c
commit 5082c2df5c
20 changed files with 1615 additions and 67 deletions
+3 -2
View File
@@ -32,7 +32,7 @@
| 自动主线 | 展示主线、支线、委托的状态、位置、NPC、需求、对话和阻塞原因;推进已支持的接取、线性对话、交付、领奖与任务补链。材料、蛋或击杀不足时,按已知来源规划普通地图收集;开图受前置、资源和战斗能力限制。 |
| 自动委托 | 根据每日剩余次数、城市与库存接取委托,推进已支持的步骤并领奖;显示金币和氪金奖励,金币、道具及魔物提交可分别限制。实战委托已接入任务战斗调度,须开启对应选项并通过所选模式的能力检查;设置仍在“自动委托”。 |
| 战斗模式与记录 | “自动主线 → 推进策略”显式选择原版运行时(默认)或实验模拟(近似);按普通地图、任务专属战斗、任务通关战斗分别编排。记录胜负、模式、地图奖励事件和待核对原因,支持停止与中断恢复;局部能力不代表全部关卡可用。 |
| 自动扫荡与挑战 | 按地区折叠显示关卡、难度、通关星级及可能掉落;账号地图本地缓存,手动刷新或挑战结束后同步进度。逐关勾选、选择已解锁难度和本日次数上限,配置保留体力与战队;满足扫荡条件时扫荡,未满星时可自动模拟挑战,战败显示“打不过”,支持探索奖励事件。 |
| 自动扫荡与挑战 | 按地区折叠显示关卡、难度、通关星级及可能掉落;账号地图本地缓存,手动刷新或挑战结束后同步进度。逐关勾选、选择已解锁难度和本日次数上限,配置保留体力与战队;满足扫荡条件时扫荡,未满星时可自动模拟挑战,战败显示“打不过”,支持探索奖励事件。可筛选普通或矿洞/门票关;资源关需单独开启,显示体力及每种工具的单次需求、实时可用库存和保留量。 |
| 掉落数据分析 | 按账号、关卡与难度在本地保存扫荡记录,默认合计扫荡和奖励事件,也可切换查看单一来源;展示合计样本拆分、出现次数、总数量、实测掉落率、平均数量和95%区间,事件独有产物一并展示。支持掉落率/每点体力获得数量的条形图,不额外请求游戏服务器。 |
| 收益资料与执行计划 | 内置749种魔物的培育时间、派遣金币、强化经验及每小时收益,支持名称/星级筛选和CSV/XLSX覆盖;执行计划显示下一步操作与等待原因。 |
| 统一策略配置 | 规则修改后自动保存并应用;通过原生菜单保存、导入或导出当前账号的孵蛋、牧场、喂养、突破、赠礼、委托、每日事务、探险、扫荡、主线推进、战斗模式、刷新间隔及自定义收益资料。跨账号按魔物种类匹配培养/突破目标,探险按队序重新绑定并匹配队员,隐藏页不丢规则;不复制原账号实例ID,不包含凭据或服务器进度。 |
@@ -46,6 +46,7 @@
- **内置战斗模拟**:无需选择运行时,程序使用原始数值资料,在独立进程中计算 AP、出场、移动、攻击和部分技能,等待计算出的战斗时长后提交结果。模型仍有机制近似与遗漏,可能和原版胜负不同,未支持的战斗会显示原因。
- **委托优先**:按奖励氪金数量20→15→10接取可处理的委托,优先执行委托步骤和材料补缺,再处理主线及普通牧场策略。缺少材料时使用现有扫荡/挑战来源;按委托缺口自动购买并孵化魔物蛋的联动留待后续实现。
- **地图与扫荡**:在“自动扫荡”勾选“未满星时自动挑战”,已解锁普通关卡可使用内置模拟首次挑战,无需开启自动主线;满足三个难度全部通关的条件后自动使用扫荡。普通地图直接发放探索奖励时按事件处理;当前任务占用的关卡交由自动主线处理。
- **矿洞与门票关卡**:在同一“自动扫荡”页筛选“矿洞与门票”,开启默认关闭的“允许矿洞 / 门票关卡”,再逐关勾选。仅显示原入口难度1,不采用残留的2/3级占位费用。此类关卡使用实际模型挑战结果,不伪装成扫荡;已提取战斗配置不等于模型支持或可通关,其他特殊关仍不可用。
- **中断恢复**:后台最长每2分钟自动核对角色与任务。模型已完成、等待时长被中断且结算从未发出的记录,在策略开启后自动续交保存的胜利结果;不重新开战或模拟。已经发出但结果不明的写请求不重发,继续核对服务器状态。
详细设置、能力限制与恢复方法见[辅助使用说明](ranch_assistant/README.md#v12-自动主线与战斗设置);阶段证据及待验收事项见[v1.2 实施与交接](analysis/V1_2_IMPLEMENTATION.md)。当前仍为开发版,尚未发布 v1.2 正式标签。
@@ -69,7 +70,7 @@
## 功能范围与数据
当前登录适配第一弹渠道;需要短信验证的登录流程尚未提供验证码界面。
自动扫荡仅用于已满足游戏原有条件的普通关卡;v1.2 的首次挑战、任务及委托战斗受所选运行时能力检查限制,未支持内容显示原因并等待处理。当前不提供手机截图配置或ADB自动战斗。
自动扫荡仅用于已满足游戏原有条件的普通关卡;明确启用的矿洞/门票关走能力受限的挑战路径,不代表全部特殊关已支持。v1.2 的首次挑战、任务及委托战斗受运行时能力检查限制,未支持内容显示原因并等待处理。当前不提供手机截图配置或ADB自动战斗。
地图与可能掉落来自客户端静态配置,实际奖励以服务器响应为准;统计概率为本账号已确认样本的实测值。
“每点体力数量”按已知消耗样本的物品总量除以实际扣除体力计算,未知消耗不参与。
+2 -1
View File
@@ -74,6 +74,7 @@
首次读取后按账号/角色保存本地地图缓存,重启、切换页面或普通监控刷新均复用缓存,仅“刷新关卡”(或本页右键刷新)更新列表。
每关可勾选、选择已解锁难度和本日上限;满足游戏原有条件的普通关卡可接口扫荡,
“未满星时自动挑战”默认开启,勾选已解锁普通关卡后可模拟首次挑战;符合三个难度全部通关条件后使用扫荡。打不过会暂停同一队伍的重复尝试,换队或提升属性后再试;未支持的规则显示中文原因。
分类筛选支持普通、矿洞与门票、全部。矿洞/门票关需明确启用默认关闭的“允许矿洞 / 门票关卡”并逐关勾选,且只可选原入口难度1;残留的2/3级占位不会作为低价入口。每项显示体力及所有入场工具的单次需求、当前可用库存和保留量;库存按最新角色快照更新,地图解锁仍复用缓存。资源关按实际模拟结果挑战,不能当作普通扫荡,也不代表全部特殊关可运行。
- 战斗记录:按上下文筛选普通地图、主线、任务与委托战斗、扫荡和地图奖励事件;实验模型结果标明“实验近似”,未知结果保留待核对原因。
- 扫荡奖励:普通扫荡读取 `battleEnd.reward`,奖励事件读取 `stageEvent.result`,日志列出本次实际获得的物品、魔物蛋、金币和经验。
- 数据分析:紧邻“自动扫荡”的独立页签。左侧按地区选择关卡和难度,右侧显示条形图与掉落明细;关卡和可能掉落来自本地静态配置。
@@ -307,7 +308,7 @@
在“自动扫荡”展开地区,每关勾选“刷图”、选择已解锁的难度、输入“本日上限”,勾选该页功能,再开启顶部策略开关。需要挑战未通关普通关卡时保留“未满星时自动挑战”勾选;关闭后只执行符合条件的扫荡,无需开启自动主线。
挑战沿用原始属性和内置模拟,等待计算出的战斗时长后按普通关卡流程结算,战果与奖励在“战斗记录”查看。实际战败显示“打不过”,本日内相同阵容及属性不会反复尝试该难度;更换战队、升级或属性变化后允许再试。每日次数与扫荡共用,开战前占用次数,确定未发送的取消会退回次数;未知回包不重复请求。暂停或重启后可续交已完成并保存的模型结果,保持原始开战和每日计数。地图列表保存在本地,普通轮询不重建;挑战已确认结束后同步账号实际通关进度。
星级是服务器通关进度计算出来的,只读。未解锁难度不能选;特殊关卡、未全通关、剧情任务、
星级是服务器通关进度计算出来的,只读。未解锁难度不能选;其他特殊关卡、未全通关、剧情任务、
体力/金币/门票不足的关卡会显示原因并跳过。次数按角色、日期、关卡和难度保存,
是本地已开始次数,不冒充服务器每日限制。
一次扫荡内部的几个请求顺序执行,完成后重读账号状态;开启其他策略时与孵蛋/委托逐轮串行。
+78 -14
View File
@@ -3,7 +3,7 @@ from PySide6 import QtCore as C, QtWidgets as W
from .daily import DailyPolicy, entries
from .native_widgets import ComboBox, IntegerInput, RowBatch
from .stage_cache import StageCache
from .resource_stages import available_item_count, item_requirements
from .sweeping import SweepPolicy
from .table_widgets import SORT_ROLE, TreeItem, bind_controls, set_value, table_item
@@ -16,6 +16,39 @@ def number(value, maximum=9999):
class ActivityPages:
def resource_catalog(self):
return self.engine.stage_cache.catalog
def resource_cost_text(self, snapshot, stage):
base = self.resource_catalog().data.get("stage_info", {}).get(stage.stage_id, {}).get("cost") or {}
owned_ti = int(snapshot.raw.get("master", {}).get("ti") or 0)
parts = [f"体力 单次 {stage.stamina} / 可用 {owned_ti} / 保留 {self.map_keep_ti.value()}"]
reserve = self.map_keep_tickets.value()
for key, count in item_requirements(base.get("items") or []).items():
name = self.resource_catalog().data.get("item_names", {}).get(key, key)
owned = available_item_count(snapshot, key)
parts.append(f"{name} 单次 {count} / 可用 {owned} / 保留 {reserve}")
return "\n".join(parts)
def resource_status_text(self, snapshot, stage, policy, reason):
if not stage.battle_available:
return "该资源关卡缺少已提取的战斗配置,未启用"
if not policy.allow_special:
return "尚未开启“允许矿洞 / 门票关卡”资源关开关"
base = self.resource_catalog().data.get("stage_info", {}).get(stage.stage_id, {}).get("cost") or {}
owned_ti = int(snapshot.raw.get("master", {}).get("ti") or 0)
if stage.stamina + self.map_keep_ti.value() > owned_ti:
return f"体力不足:单次需 {stage.stamina},可用 {owned_ti},保留 {self.map_keep_ti.value()}"
reserve = self.map_keep_tickets.value()
for key, count in item_requirements(base.get("items") or []).items():
owned = available_item_count(snapshot, key)
if owned - count < reserve:
name = self.resource_catalog().data.get("item_names", {}).get(key, key)
return f"{name}不足:单次需 {count},可用 {owned},保留 {reserve}"
if reason:
return reason
return "将按实际模拟结果挑战;不是扫荡"
def maps_tab(self):
self.map_rules = {}
self.map_page = W.QWidget()
@@ -25,7 +58,11 @@ class ActivityPages:
self.map_search.setPlaceholderText("搜索关卡编号、名称或掉落物品")
self.only_unlocked = W.QCheckBox("只看账号已解锁")
self.only_unlocked.setChecked(True)
for widget in (self.map_search, self.only_unlocked):
self.map_category = ComboBox()
self.map_category.addItem("全部关卡", "all")
self.map_category.addItem("普通关卡", "ordinary")
self.map_category.addItem("矿洞与门票", "resource")
for widget in (self.map_search, self.map_category, self.only_unlocked):
line.addWidget(widget)
for label, function in (("刷新关卡", self.refresh_maps), ("展开地区", lambda: self.maps_tree.expandAll()),
("折叠地区", lambda: self.maps_tree.collapseAll())):
@@ -52,35 +89,50 @@ class ActivityPages:
line.addWidget(reset)
line.addStretch()
layout.addLayout(line)
line = W.QHBoxLayout()
self.map_allow_special = W.QCheckBox("允许矿洞 / 门票关卡")
self.map_allow_special.setToolTip("仅处理下方单独勾选且已检查支持的资源关卡;不会自动处理所有特殊关卡。")
self.map_keep_tickets = number(0)
self.map_keep_tickets.setToolTip("每种入场门票或工具分别保留此数量;0 表示不额外保留。")
line.addWidget(self.map_allow_special)
line.addWidget(W.QLabel("每种门票/工具保留"))
line.addWidget(self.map_keep_tickets)
line.addStretch()
layout.addLayout(line)
self.maps_summary = W.QLabel("登录后读取实际解锁状态")
self.maps_summary.setWordWrap(True)
layout.addWidget(self.maps_summary)
self.maps_tree = W.QTreeWidget()
self.maps_tree.setHeaderLabels(["刷图", "关卡", "名称", "难度", "星级", "扫荡 / 挑战状态", "体力 / 门票", "可能掉落", "本日上限", "本日已开始"])
self.maps_tree.setHeaderLabels(["刷图", "关卡", "名称", "难度", "星级", "扫荡 / 挑战状态", "体力 / 门票:单次 / 可用 / 保留", "可能掉落", "本日上限", "本日已开始"])
self.maps_tree.setAlternatingRowColors(True)
self.maps_tree.setTextElideMode(C.Qt.TextElideMode.ElideNone)
self.maps_tree.setUniformRowHeights(False)
self.maps_tree.setEditTriggers(W.QAbstractItemView.EditTrigger.NoEditTriggers)
self.maps_tree.itemChanged.connect(self.map_item_changed)
self.maps_tree.sortByColumn(1, C.Qt.SortOrder.AscendingOrder)
self.maps_tree.setSortingEnabled(True)
for col, width in enumerate((100, 82, 160, 130, 70, 210, 120, 340, 100, 92)):
for col, width in enumerate((100, 82, 160, 130, 70, 270, 300, 340, 100, 92)):
self.maps_tree.setColumnWidth(col, width)
layout.addWidget(self.maps_tree, 1)
note = W.QLabel("地图按账号保存在本地,点击“刷新关卡”可更新完整列表;挑战结束后同步实际进度。星级来自实际通关难度,不能手动修改。\n普通关卡三个难度全部通关后可扫荡;开启“未满星时自动挑战”后,其余已解锁且开放的勾选普通关卡使用内置模拟挑战,共用所选战队、保留体力和本日上限。实际战败显示“打不过”,未支持的内容显示具体原因;未解锁、特殊关卡和当前任务拦截的关卡仍不可刷图。随机掉落并非必得。")
note = W.QLabel("地图按账号保存在本地,点击“刷新关卡”可更新完整列表;挑战结束后同步实际进度。星级来自实际通关难度,不能手动修改。\n普通关卡三个难度全部通关后可扫荡;开启“未满星时自动挑战”后,其余已解锁且开放的勾选普通关卡使用内置模拟挑战,共用所选战队、保留体力和本日上限。实际战败显示“打不过”,未支持的内容显示具体原因;未解锁和当前任务拦截的关卡不可刷图。\n矿洞 / 门票关卡需同时开启资源关开关并逐关勾选,仅显示原入口难度1;体力、每种工具的需求与可用库存随账号快照更新。此类关卡按实际模拟结果挑战,不是扫荡,能力检查不通过时不会入场;其他特殊关仍不可刷图。随机掉落并非必得。")
note.setWordWrap(True)
layout.addWidget(note)
self.tabs.addTab(self.map_page, "自动扫荡")
self.map_search.textChanged.connect(self.render_maps)
self.map_category.currentIndexChanged.connect(self.render_maps)
self.only_unlocked.toggled.connect(self.render_maps)
self.map_enabled.toggled.connect(self.activity_settings_changed)
self.map_allow_challenge.toggled.connect(self.activity_settings_changed)
self.map_keep_ti.valueChanged.connect(self.activity_settings_changed)
self.map_allow_special.toggled.connect(self.activity_settings_changed)
self.map_keep_tickets.valueChanged.connect(self.activity_settings_changed)
self.map_team.currentIndexChanged.connect(self.activity_settings_changed)
def read_sweep_policy(self):
import copy
return SweepPolicy(self.map_enabled.isChecked(), copy.deepcopy(self.map_rules), self.map_keep_ti.value(),
self.map_team.currentData(), allow_challenge=self.map_allow_challenge.isChecked())
self.map_team.currentData(), allow_challenge=self.map_allow_challenge.isChecked(),
allow_special=self.map_allow_special.isChecked(), keep_tickets=self.map_keep_tickets.value())
def reset_map_view(self):
if hasattr(self, "map_render_timer"):
@@ -104,8 +156,8 @@ class ActivityPages:
if hasattr(self, "map_enabled") and not self.map_enabled.isChecked():
self.engine.sweep_policy.enabled = False
sender = self.sender()
if sender in (self.map_enabled, self.map_allow_challenge) and not sender.isChecked():
field = "enabled" if sender is self.map_enabled else "allow_challenge"
if sender in (self.map_enabled, self.map_allow_challenge, self.map_allow_special) and not sender.isChecked():
field = "enabled" if sender is self.map_enabled else "allow_challenge" if sender is self.map_allow_challenge else "allow_special"
setattr(self.engine.sweep_policy, field, False)
if self.pending_policy is not None:
setattr(self.pending_policy["sweep_policy"], field, False)
@@ -115,7 +167,7 @@ class ActivityPages:
if hasattr(self, "daily_enabled") and not self.daily_enabled.isChecked():
self.engine.daily_policy.enabled = False
self.settings_changed()
if sender is self.map_allow_challenge:
if sender in (self.map_allow_challenge, self.map_allow_special, self.map_keep_ti, self.map_keep_tickets):
self.render_maps()
def map_item_changed(self, item, column):
@@ -139,11 +191,11 @@ class ActivityPages:
if isinstance(focused, W.QLineEdit) and self.maps_tree.isAncestorOf(focused):
return
snapshot = self.engine.snapshot
if self.engine.stage_cache.catalog is not self.catalog:
self.engine.stage_cache = StageCache(self.catalog)
all_rows = self.engine.stage_cache.get(snapshot)
grouped = {}
for row in all_rows:
if row.category in ("mine", "ticket") and row.level != "1":
continue
grouped.setdefault(row.stage_id, []).append(row)
query = self.map_search.text().strip().casefold()
policy = self.read_sweep_policy()
@@ -151,6 +203,10 @@ class ActivityPages:
visible = []
for key, options in sorted(grouped.items(), key=lambda pair: (pair[1][0].city, pair[1][0].number, pair[0])):
first = options[0]
resource = first.category in ("mine", "ticket")
if ((self.map_category.currentData() == "ordinary" and first.category != "ordinary")
or (self.map_category.currentData() == "resource" and not resource)):
continue
if self.only_unlocked.isChecked() and not any(s.unlocked for s in options):
continue
if query and query not in (first.city_name + key + first.number + first.name + " ".join(s.drops for s in options)).casefold():
@@ -160,7 +216,12 @@ class ActivityPages:
chosen = chosen or next((s for s in reversed(options) if s.unlocked), first)
self.map_rules.setdefault(key, {"enabled": False, "level": chosen.level, "limit": 3})
reason = self.engine.map_stage_reason(snapshot, chosen, policy, team_ids=team_ids)
visible.append((key, options, chosen, dict(self.map_rules[key]), reason))
if resource and rule.get("enabled") and not policy.allow_special:
reason = "尚未开启“允许矿洞 / 门票关卡”资源关开关"
if resource:
reason = self.resource_status_text(snapshot, chosen, policy, reason)
cost_text = self.resource_cost_text(snapshot, chosen) if resource else str(chosen.stamina) + (" / " + chosen.tickets if chosen.tickets else "")
visible.append((key, options, chosen, dict(self.map_rules[key]), reason, cost_text))
self._map_items = getattr(self, "_map_items", {})
self._map_cities = getattr(self, "_map_cities", {})
if not hasattr(self, "map_render_timer"):
@@ -175,8 +236,11 @@ class ActivityPages:
item = self._map_items.pop(data)
item.parent().takeChild(item.parent().indexOfChild(item))
return
key, options, chosen, rule, reason = data
key, options, chosen, rule, reason, cost_text = data
first = options[0]
if first.category in ("mine", "ticket"):
reason = self.resource_status_text(snapshot, chosen, self.read_sweep_policy(), reason)
cost_text = self.resource_cost_text(snapshot, chosen)
city = self._map_cities.get(first.city)
if city is None:
city = TreeItem(self.maps_tree, [first.city_name])
@@ -198,7 +262,7 @@ class ActivityPages:
item.setSizeHint(0, C.QSize(90, max(difficulty.sizeHint().height(), limit.sizeHint().height()) + 4))
self._map_items[key] = item
values = ["", first.number, first.name, "", "★" * first.stars + "☆" * (3 - first.stars), reason or ("可扫荡" if chosen.sweep else "将模拟挑战"),
str(chosen.stamina) + (" / " + chosen.tickets if chosen.tickets else ""), chosen.drops, "", str(self.engine.sweeper.used(snapshot, chosen))]
cost_text, chosen.drops, "", str(self.engine.sweeper.used(snapshot, chosen))]
for col, text in enumerate(values):
if item.text(col) != text:
set_value(item, col, text)
+246 -28
View File
@@ -37,9 +37,9 @@ LIMITATIONS = (
"Original hit callbacks and projectile speed inform delays; visual offsets, easing and rocket paths are omitted.",
"Skills 3, 5, 7, 9, 38 have partial source ports; all other skills are omitted and individually reported.",
"Skill presentation callbacks are replaced with immediate model activation; AI checks use modeled cadence.",
"Knockback, cosmetic equipment animations and special equipment words are omitted.",
"Attack knockback, cosmetic equipment animations and special equipment words are omitted.",
"Python seeded RNG is not the original Random helper or Math.random stream.",
"Only elimination objectives are supported; authored combat controllers, triggers and active field areas are rejected.",
"Mining supports destroy-all/protect-all objectives, fixed hurt, target locks and timed joins; other controllers and triggers are rejected.",
"Original cheat-check execution is incomplete; detected model anomalies are preserved, not a clean-engine verdict.",
)
@@ -186,6 +186,12 @@ class Unit:
effects: Mapping = field(default_factory=dict)
source_id: str = ""
attack_area: str = ""
protect_target: bool = False
destroy_target: bool = False
pow_defense: float = 0
hurt_types: Mapping = field(default_factory=dict)
hurt_elements: Mapping = field(default_factory=dict)
lock_target: str = ""
@dataclass
@@ -211,6 +217,10 @@ class Actor:
poison_damage: int = 0
area_hit: bool = False
combo_hits: int = 0
force_join: bool = False
vx: float = 0
vy: float = 0
locked_target: str = ""
def _skills(species_row, mon, tables, diagnostic, *, player):
@@ -310,6 +320,12 @@ def _enemy(mon, team, tables, key, battle, diagnostic, master):
raise SimulationInputError("Configured enemy movement/range/attack interval is incomplete")
effect_keys = ("atkVim", "atkStun", "defStun", "atkStunTime", "defStunTime", "atkPoi",
"atkPoiDmg", "thorns", "selfCure", "skillCooldown", "sunFire", "moonHeal", "deadBoom")
hurt_types, hurt_elements = {}, {}
for controller in mon.get("controller", ()) or ():
if _get(controller, "type") == "fixHurt":
para = _get(controller, "para", {})
hurt_types = {str(k): _number(v) for k, v in para.get("type", {}).items()}
hurt_elements = {str(k): _number(v) for k, v in para.get("element", {}).items()}
return Unit(key, species, _int(mon.get("team", team["team"])),
Stats(hp, int(stats["atk"] * ability), int(stats["def"] * ability),
int(stats["dex"] * ability), attack, move, distance, _int(row["element"]),
@@ -325,7 +341,41 @@ def _enemy(mon, team, tables, key, battle, diagnostic, master):
ap_recovery=bool(mon.get("apRecovery")), boss_point=_int(mon.get("bossPoint", 0)),
effects=_freeze({k: _number(mon[k], k) * (ability if k in ("deadBoom", "sunFire", "moonHeal", "selfCure") else 1)
for k in effect_keys if k in mon}),
source_id=str(mon.get("mid", "")), attack_area=str(mon.get("attackArea", "")))
source_id=str(mon.get("mid", "")), attack_area=str(mon.get("attackArea", "")),
protect_target=mon.get("protectTarget") is True,
destroy_target=mon.get("destroyTarget") is True,
pow_defense=_number(mon.get("powDefPercent", 0)),
hurt_types=_freeze(hurt_types), hurt_elements=_freeze(hurt_elements),
lock_target=next((str(_get(c, "para", {}).get("mid", ""))
for c in mon.get("controller", ()) or ()
if _get(c, "type") == "lockTarget"), ""))
def _mining_trigger(entry, unit_mids):
"""Return an immutable trigger, or a precise unsupported reason."""
kind = _get(entry, "type", "unknown")
para = _get(entry, "para", {})
if not isinstance(para, Mapping) or not isinstance(_get(entry, "effects"), list):
return None, "Malformed mining battle trigger"
if kind == "monDead":
if _int(para.get("mid", -1)) not in unit_mids:
return None, "Mining monDead trigger references an unknown unit"
if any(_get(effect, "type") != "showFace" for effect in entry["effects"]):
return None, "Only visual showFace effects are supported for mining monDead"
elif kind == "time":
if _int(para.get("time", -1)) <= 0 or para.get("loop") is True:
return None, "Mining time trigger requires a positive non-looping time"
for effect in entry["effects"]:
if _get(effect, "type") == "showFace":
continue
effect_para = _get(effect, "para", {})
if (_get(effect, "type") != "monJoin" or not isinstance(effect_para, Mapping)
or _int(effect_para.get("mid", -1)) not in unit_mids):
return None, "Only showFace and configured monJoin are supported for mining time"
else:
return None, "Unsupported mining battle trigger: " + str(kind)
return _freeze({"id": str(_get(entry, "id", "")), "type": kind,
"para": para, "effects": entry["effects"]}), None
@dataclass
@@ -339,6 +389,9 @@ class Scenario:
trace_limit: int
position: object
roster_ids: tuple
win_types: tuple = (1,)
lose_types: tuple = (1, 2)
triggers: tuple = ()
def _prepare(request, tables):
@@ -361,12 +414,15 @@ def _prepare(request, tables):
battle = _get(original, "battle")
if not isinstance(battle, Mapping) or not battle:
raise SimulationInputError("original_data.battle must contain the full original configuration")
if list(map(_int, battle.get("winType", (1,)))) != [1] or any(
_int(x) not in (1, 2) for x in battle.get("loseType", (1, 2))):
win_types = tuple(map(_int, battle.get("winType", (1,))))
lose_types = tuple(map(_int, battle.get("loseType", (1, 2))))
mining = win_types == (4,)
if not mining and (win_types != (1,) or any(x not in (1, 2) for x in lose_types)):
diagnostic("objective", "Non-elimination win/loss objective is unsupported", blocking=True)
for key in ("controller", "triggers"):
for entry in battle.get(key, ()) or ():
diagnostic(key, f"Unsupported battle {key}: {_get(entry, 'type', 'unknown')}", blocking=True)
if mining and lose_types != (4, 2):
diagnostic("objective", "Mining requires exact winType=[4] and loseType=[4,2]", blocking=True)
for entry in battle.get("controller", ()) or ():
diagnostic("controller", f"Unsupported battle controller: {_get(entry, 'type', 'unknown')}", blocking=True)
raw = _get(request, "roster", _get(request, "snapshot"))
raw = _get(raw, "raw", raw)
if not isinstance(raw, Mapping) or not isinstance(raw.get("master"), Mapping):
@@ -413,6 +469,19 @@ def _prepare(request, tables):
diagnostic("equipment_words", "Equipment/skin numeric bonuses use monsterAttributes; special words and skin attack overrides are omitted", ignored=True)
if battle.get("hideTeamMon"):
units = [] # BattleCenter empties the master team before adding authored allies.
configured_mons = [(team, mon) for team in battle.get("teams", ())
for mon in team.get("mons", ()) if mon is not None]
unit_mids = {_int(mon.get("mid", -1)) for _, mon in configured_mons}
triggers = []
for entry in battle.get("triggers", ()) or ():
if mining:
parsed, reason = _mining_trigger(entry, unit_mids)
if reason:
diagnostic("triggers", reason, blocking=True)
else:
triggers.append(parsed)
else:
diagnostic("triggers", f"Unsupported battle triggers: {_get(entry, 'type', 'unknown')}", blocking=True)
for ti, team in enumerate(battle.get("teams", ())):
team_id = _int(team.get("team", 2))
initial_ap = _int(team.get("ap", 0))
@@ -432,14 +501,28 @@ def _prepare(request, tables):
if (kind == "buffMovie" and isinstance(para, Mapping)
and para.get("type") == "none" and not para.get("stopMove", False)):
diagnostic("cosmetic_controller", "Cosmetic monster buffMovie animation is omitted", ignored=True)
elif mining and kind in ("fixHurt", "lockTarget"):
if not isinstance(para, Mapping):
diagnostic("unit_controller", f"Malformed mining controller: {kind}", blocking=True)
elif kind == "lockTarget":
if _int(para.get("mid", -1)) not in unit_mids:
diagnostic("unit_controller", "Mining lockTarget references an unknown unit", blocking=True)
if para.get("interval") is not None and _number(para["interval"]) <= 0:
diagnostic("unit_controller", "Mining lockTarget interval must be positive", blocking=True)
else:
diagnostic("unit_controller", f"Unsupported monster controller: {kind}", blocking=True)
if mon.get("protectTarget") or mon.get("destroyTarget"):
if not mining:
diagnostic("unit_objective", "Protected/destroy objective units are unsupported", blocking=True)
elif mon.get("protectTarget") and mon.get("destroyTarget"):
diagnostic("unit_objective", "Mining target cannot be both protected and destroyed", blocking=True)
unit = _enemy(mon, dict(team, team=team_id), tables, f"configured-{ti + 1}-{mi + 1}", battle, diagnostic, master)
teams.setdefault(unit.team, config.copy())
units.append(unit)
if not any(u.team != 1 and not u.is_object for u in units):
if mining:
if not any(u.destroy_target for u in units) or not any(u.protect_target for u in units):
diagnostic("unit_objective", "Mining requires actual destroy and protect target units", blocking=True)
elif not any(u.team != 1 and not u.is_object for u in units):
raise SimulationInputError("Elimination battle must contain configured enemies")
for team in teams.values():
if team["capacity"] <= 0 or team["initial"] < 0:
@@ -459,7 +542,7 @@ def _prepare(request, tables):
if "area_battlefield" not in areas or not points:
raise SimulationInputError("Battlefield needs original points and area_battlefield")
for area in areas.values():
if area.get("type", "none") != "none":
if area.get("type", "none") not in (("none", "pow") if mining else ("none",)):
diagnostic("field_effect", f"Unsupported active field area: {area.get('type')}", blocking=True)
if field_config.get("mapObjects"):
diagnostic("ground_objects", "Battlefield ground object collision/decoration is omitted", ignored=True)
@@ -495,9 +578,11 @@ def _prepare(request, tables):
report["teams"] = _plain(teams)
report["duration_ms"] = duration * 1000
report["supported"] = not report["reasons"]
report["objective"] = "destroy_all_protect_until_none" if mining else "elimination"
return Scenario(units, teams, points, areas, duration * 1000, seed, trace_limit,
_position(_get(request, "battle_position")),
tuple(_int(mid) for mid in selected) if not battle.get("hideTeamMon") else ()), report
tuple(_int(mid) for mid in selected) if not battle.get("hideTeamMon") else (),
win_types, lose_types, tuple(triggers)), report
except (SimulationInputError, KeyError, TypeError, AttributeError, IndexError) as exc:
message = str(exc) if isinstance(exc, SimulationInputError) else "Malformed original combat input"
diagnostic("input", message, blocking=True)
@@ -510,7 +595,10 @@ def _unit_preview(unit):
"skills": [{"id": s.id, "level": s.level, "cost": s.cost,
"cooldown_ms": s.cooldown_ms, "para": _plain(s.para)} for s in unit.skills],
"wave": unit.wave, "join_time_seconds": unit.join_time, "position": unit.position,
"count_unit": unit.count_unit, "is_object": unit.is_object, "ap_cost": unit.ap_cost}
"count_unit": unit.count_unit, "is_object": unit.is_object, "ap_cost": unit.ap_cost,
"auto_target": unit.auto_target, "source_id": unit.source_id,
"protect_target": unit.protect_target, "destroy_target": unit.destroy_target,
"lock_target": unit.lock_target}
def _snapshot_anomalies(mon, unit, tables):
@@ -571,6 +659,7 @@ class _Battle:
self.ap = {team: dict(initial=v["initial"], current=v["initial"], max=v["max"], spent=0, recovered=0)
for team, v in scenario.teams.items()}
self.wave = {team: 1 for team in scenario.teams}
self.unlocked_waves = {team: {0, 1} for team in scenario.teams}
self.wave_due = {}
self.queue = []
self.sequence = 0
@@ -588,6 +677,10 @@ class _Battle:
self.complete_at = None
self.resource_limited = False
self.skill_used = False
self.pending_triggers = list(scenario.triggers)
self.by_source_id = {a.unit.source_id: a for a in self.actors if a.unit.source_id}
self.next_area = 0
self.area_due = {key: 0 for key in scenario.areas}
def event(self, kind, **fields):
record = {"at_ms": self.now, "type": kind, **fields}
@@ -617,6 +710,24 @@ class _Battle:
return sum(a.unit.team == team and a.state != "dead"
and (team == 1 or a.state == "active" or not a.unit.is_object) for a in self.actors)
def check_objectives(self):
"""BattleGround.checkGameOver's original winner precedence."""
if self.now >= self.s.duration_ms:
return "win" if 2 in self.s.win_types else "loss"
mining = self.s.win_types == (4,)
team_one_alive = sum(a.unit.team == 1 and a.state != "dead" for a in self.actors) if mining else self.terminal_team_size(1)
if not team_one_alive:
return "loss"
if not mining and not any(self.terminal_team_size(team) for team in self.s.teams if team != 1):
return "win"
protected = [a for a in self.actors if a.unit.protect_target]
if 4 in self.s.lose_types and protected and all(a.state == "dead" for a in protected):
return "loss"
destroyed = [a for a in self.actors if a.unit.destroy_target]
if 4 in self.s.win_types and destroyed and all(a.state == "dead" for a in destroyed):
return "win"
return None
def add_ap(self, team, amount, reason):
ap = self.ap[team]
before = ap["current"]
@@ -657,7 +768,8 @@ class _Battle:
def deploy(self):
for actor in self.actors:
u = actor.unit
if actor.state != "waiting" or u.wave > self.wave[u.team] or u.join_time * 1000 > self.now:
if (actor.state != "waiting" or not actor.force_join and u.wave not in self.unlocked_waves[u.team]
or not actor.force_join and u.join_time * 1000 > self.now):
continue
count = sum(a.state == "active" and a.unit.team == u.team and a.unit.count_unit for a in self.actors)
if u.count_unit and count >= self.s.teams[u.team]["capacity"]:
@@ -674,6 +786,8 @@ class _Battle:
self.add_ap(u.team, self.ap[u.team]["max"] * self.game["addApByJoinMon"], "join")
self.event("deploy", actor=u.key, team=u.team, wave=u.wave, x=actor.x, y=actor.y,
count_unit=u.count_unit, ap_charged=0)
if actor.unit.lock_target:
actor.locked_target = actor.unit.lock_target
@staticmethod
def ai_interval(unit):
@@ -683,6 +797,11 @@ class _Battle:
def target(self, actor):
u = actor.unit
if actor.locked_target:
locked = self.by_source_id.get(actor.locked_target)
if locked is not None and locked.state == "active" and locked.hp > 0:
return locked
actor.locked_target = ""
choices = [b for b in self.active() if b.unit.team != u.team]
if u.attack_area:
area = self.s.areas[u.attack_area]
@@ -791,9 +910,35 @@ class _Battle:
if amount:
self.event("heal", actor=actor.unit.key, amount=amount, hp=actor.hp, reason=reason)
def hurt(self, actor, amount, attacker, reason):
def hurt(self, actor, amount, attacker, reason, real_attack=False):
if actor.state != "active":
return 0
# beHurt passes the attack value (its atk argument) to onHurt at line
# 902, despite onHurt naming that parameter damage. For real attacks
# there is no GameMath.damage call before this controller.
element = str(attacker.unit.stats.element) if attacker else ""
if element in actor.unit.hurt_types and element in actor.unit.hurt_elements:
amount = int(amount * actor.unit.hurt_elements[element])
elif attacker and str(attacker.unit.species) in actor.unit.hurt_types:
amount = int(amount * actor.unit.hurt_types[str(attacker.unit.species)])
if real_attack:
amount = max(0, int(amount * (1 - actor.unit.stats.damage_reduction)))
lost = min(actor.hp, amount)
actor.hp -= lost
actor.total_hurt += amount
self.hp_lost[actor.unit.team] += lost
if actor.unit.boss_point == -1:
self.boss_points += lost
if attacker:
attacker.damage_dealt += lost
self.event("damage", actor=attacker.unit.key if attacker else None, target=actor.unit.key,
damage=amount, hp_lost=lost, hp=actor.hp, reason=reason)
if amount > 80000:
self.anomaly("+10overdamage", points=10, damage=amount, hurt_team=actor.unit.team,
actor=attacker.unit.key if attacker else None, target=actor.unit.key)
if actor.hp == 0:
self.finish_death(actor)
return amount
amount = max(0, int(int(amount) * (1 - actor.unit.stats.damage_reduction)))
lost = min(actor.hp, amount)
actor.hp -= lost
@@ -809,6 +954,10 @@ class _Battle:
self.anomaly("+10overdamage", points=10, damage=amount, hurt_team=actor.unit.team,
actor=attacker.unit.key if attacker else None, target=actor.unit.key)
if actor.hp == 0:
self.finish_death(actor)
return amount
def finish_death(self, actor):
actor.state = "dead"
actor.died_ms = self.now
if actor.unit.boss_point > 0:
@@ -822,8 +971,15 @@ class _Battle:
if actor.total_hurt == 0:
self.anomaly("+1k_cheatDead", points=1000, target=actor.unit.key)
self.event("death", actor=actor.unit.key, team=actor.unit.team, summon=bool(actor.summon_of))
remaining = []
for trigger in self.pending_triggers:
if trigger["type"] == "monDead" and _int(trigger["para"]["mid"]) == _int(actor.unit.source_id):
self.event("trigger", trigger_kind="monDead", trigger=trigger["id"],
actor=actor.unit.key, effects="visual_only")
else:
remaining.append(trigger)
self.pending_triggers = remaining
self.complete_at = self.now + 1000 # Original delayed checkGameOver.
return amount
def impact(self, fields):
attacker = self.by_key[fields["attacker"]]
@@ -886,17 +1042,65 @@ class _Battle:
for team in self.s.teams:
if team in self.wave_due:
if self.now >= self.wave_due[team]:
self.wave[team] += 1
current = self.wave[team]
waves = [a.unit.wave for a in self.actors if a.unit.team == team
and a.state != "dead" and not a.unit.is_object and a.unit.wave > current]
self.wave[team] = min(waves) if waves else current + 1
self.unlocked_waves[team].update(range(current + 1, self.wave[team] + 1))
del self.wave_due[team]
self.event("wave", team=team, wave=self.wave[team])
continue
current = self.wave[team]
relevant = [a for a in self.actors if a.unit.team == team and a.state != "dead"]
relevant = [a for a in self.actors if a.unit.team == team and a.state != "dead" and not a.unit.is_object]
if any(a.unit.wave == current for a in relevant):
continue
if any(a.unit.wave == current + 1 for a in relevant):
next_waves = [a.unit.wave for a in relevant if a.unit.wave > current]
if next_waves:
next_wave = min(next_waves)
self.wave_due[team] = self.now + 700
self.event("wave_wait", team=team, next_wave=current + 1, until_ms=self.now + 700)
self.event("wave_wait", team=team, next_wave=next_wave, until_ms=self.now + 700)
def advance_triggers(self):
"""SecondDriver checks elapsed seconds once; trigger removal prevents repeats."""
if self.now % 1000:
return
remaining = []
for trigger in self.pending_triggers:
if trigger["type"] == "time" and _int(trigger["para"]["time"]) * 1000 <= self.now:
for effect in trigger["effects"]:
if effect.get("type") == "monJoin":
target = self.by_source_id.get(str(_int(effect["para"]["mid"])))
if target is not None and target.state != "dead":
target.force_join = True
self.event("trigger", trigger_kind="time", trigger=trigger["id"],
effect="monJoin", actor=target.unit.key)
self.event("trigger", trigger_kind="time", trigger=trigger["id"])
else:
remaining.append(trigger)
self.pending_triggers = remaining
def advance_areas(self):
if self.now < self.next_area:
return
self.next_area = self.now + 125
for key, area in self.s.areas.items():
if area.get("type") != "pow" or self.now < self.area_due[key]:
continue
self.area_due[key] = self.now + _int(area["para"].get("interval", 0))
for actor in self.active():
if not (area["x"] <= actor.x <= area["x"] + area["w"]
and area["y"] <= actor.y <= area["y"] + area["h"]):
continue
if actor.unit.move_immune:
continue # BattleMon.givePow returns before changing velocity.
para = area["para"]
power = _number(para["pow"]) * .8 * (1 - actor.unit.pow_defense)
dx, dy = actor.x - _number(para.get("fromX", actor.x)), actor.y - _number(para.get("fromY", actor.y))
length = math.hypot(dx, dy)
if length:
actor.vx, actor.vy = power * dx / length, power * dy / length
self.event("area_pow", actor=actor.unit.key, area=key,
vx=actor.vx, vy=actor.vy)
def tick(self):
self.skill_used = False
@@ -909,6 +1113,8 @@ class _Battle:
if self.now >= self.next_deploy:
self.deploy()
self.next_deploy = (self.now // 1000 + 1) * 1000
self.advance_triggers()
self.advance_areas()
while self.queue and self.queue[0][0] <= self.now:
_, _, kind, fields = heapq.heappop(self.queue)
if kind == "impact":
@@ -926,6 +1132,15 @@ class _Battle:
self.impact(fields)
for actor in list(self.active()):
u = actor.unit
if not u.move_immune and (actor.vx or actor.vy):
# Engine2D's existing damping is retained as a trajectory
# approximation; movement resumes once inertia has decayed.
actor.x += actor.vx
actor.y += actor.vy
actor.vx *= .91
actor.vy *= .91
if abs(actor.vx) + abs(actor.vy) < .01:
actor.vx = actor.vy = 0
if actor.poison_until >= self.now and actor.poison_at and actor.poison_at <= self.now:
self.hurt(actor, actor.poison_damage, None, "poison")
actor.poison_at += 1000
@@ -951,7 +1166,7 @@ class _Battle:
self.event("attack", actor=u.key, target=target.unit.key, hit_delay_ms=delay)
self.schedule(delay, "launch", attacker=u.key, target=target.unit.key,
atk=u.stats.atk, projectile=profile["projectile"], speed=profile["projectile_speed"])
elif not u.move_immune:
elif not u.move_immune and not (actor.vx or actor.vy):
dx, dy = target.x - actor.x, target.y - actor.y
distance = math.hypot(dx, dy)
# Source Pointer.Point2Point uses spd_mov per frame.
@@ -1027,8 +1242,9 @@ def simulate(request, *, cancel_event=None, timeout=30.0, tables=None):
if time.monotonic() - started >= timeout:
return battle.result("timeout", "wall_clock")
if battle.now >= scenario.duration_ms:
battle.event("complete", outcome="loss", reason="battle_time_limit")
result = battle.result("loss")
outcome = battle.check_objectives()
battle.event("complete", outcome=outcome, reason="battle_time_limit")
result = battle.result(outcome)
result["terminal_reason"] = "battle_time_limit"
return result
try:
@@ -1041,12 +1257,14 @@ def simulate(request, *, cancel_event=None, timeout=30.0, tables=None):
if battle.resource_limited:
return battle.result("timeout", "resource_limit")
if battle.complete_at is not None and battle.now >= battle.complete_at:
if not battle.terminal_team_size(1):
battle.event("complete", outcome="loss")
return battle.result("loss")
if not any(battle.terminal_team_size(team) for team in scenario.teams if team != 1):
battle.event("complete", outcome="win")
return battle.result("win")
outcome = battle.check_objectives()
if outcome:
reason = "battle_time_limit" if battle.now >= scenario.duration_ms else (
"elimination" if 1 in scenario.win_types else "objective")
battle.event("complete", outcome=outcome, reason=reason)
result = battle.result(outcome)
result["terminal_reason"] = reason
return result
return battle.result("timeout", "resource_limit")
+28 -7
View File
@@ -15,7 +15,7 @@ No estimation module is imported here. SweepRunner is the sole sweep executor.
from __future__ import annotations
from copy import deepcopy
from dataclasses import asdict, is_dataclass
from dataclasses import asdict, is_dataclass, replace
import hashlib
import json
import math
@@ -24,9 +24,11 @@ from pathlib import Path
import threading
import time
import uuid
from types import SimpleNamespace
from .drop_statistics import event_reward
from .maps import stages
from .resource_stages import resource_entry_reason, item_requirements, available_item_count
from .quests import indexed, stage_has_level
from .sweeping import SweepPolicy
from .team_availability import team_availability_reason
@@ -158,7 +160,7 @@ class BattleJournal:
raise ValueError("有待核对的任务 / 战斗,禁止重复开始")
record = {name: public_data(value(intent, name)) for name in (
"kind", "description", "path", "payload", "task_id", "task_type_id", "step_number",
"position", "stage_id", "difficulty", "battle_kind", "source_task_id", "source_task_type_id", "source_step_number", "farming_target")}
"position", "stage_id", "difficulty", "battle_kind", "stage_category", "source_task_id", "source_task_type_id", "source_step_number", "farming_target")}
record.update(attempt_id=uuid.uuid4().hex, role_id=role_id(snapshot),
phase="prepared", outcome="", timestamp=time.time(), started_at=time.time(), team=value(intent, "team", ""),
message="", kind=kind or record["kind"], battle_mode=value(intent, "battle_mode", "original"),
@@ -313,7 +315,7 @@ class BattleOrchestrator:
"taskStep": max(0, int(value(intent, "step_number", 1) or 1) - 1) if task else 0}
request = {"snapshot": snapshot.raw if self.request_builder else deepcopy(snapshot.raw), "team": policy.team, "battle_position": position,
"battle_mode": value(policy, "battle_mode", "original"),
**{name: value(intent, name) for name in ("stage_id", "difficulty", "task_type_id", "step_number", "battle_kind")}}
**{name: value(intent, name) for name in ("stage_id", "difficulty", "task_type_id", "step_number", "battle_kind", "stage_category")}}
return self.request_builder(snapshot, intent, policy, request) if self.request_builder else request
def resource_reason(self, snapshot, intent, policy, ranch=None):
@@ -350,6 +352,27 @@ class BattleOrchestrator:
if not stage or difficulty not in stage.get("level", {}):
return "关卡配置缺失"
if not value(intent, "task_id"):
if value(intent, "kind") == "map_battle" and value(intent, "stage_category") in ("mine", "ticket"):
if value(intent, "battle_kind") != "resource_stage":
return "资源关卡战斗类型不匹配,禁止入场"
if self.sweeper:
rule = value(policy, "rules", {}).get(stage_id, {})
key = self.sweeper.key(snapshot, SimpleNamespace(stage_id=stage_id, level=difficulty))
if (not rule.get("enabled") or str(rule.get("level")) != difficulty
or int(self.sweeper.state.get("counts", {}).get(key, 0)) >= max(0, int(rule.get("limit") or 0))):
return "资源关卡未显式勾选或已达本日次数上限"
match = next((row for row in stages(self.catalog, snapshot)
if row.stage_id == stage_id and row.level == difficulty), None)
if match is None:
return "资源关卡配置缺失"
reason = resource_entry_reason(self.catalog, snapshot, match, policy)
if reason:
return reason
policy = replace(policy, item_reserves={key: max(int(value(policy, "item_reserves", {}).get(key, 0)),
int(value(policy, "keep_tickets", 0))) for key in item_requirements((stage.get("cost") or {}).get("items", []))}) \
if is_dataclass(policy) else SimpleNamespace(**(vars(policy) | {"item_reserves": {key: max(
int(value(policy, "item_reserves", {}).get(key, 0)), int(value(policy, "keep_tickets", 0)))
for key in item_requirements((stage.get("cost") or {}).get("items", []))}}))
position = value(intent, "position") or f"city{stage.get('city')}_wild_stage{stage_id}_level{difficulty}"
if self.task_at_position(snapshot, position):
return "该位置由当前任务优先处理,不能执行普通挑战或扫荡"
@@ -366,13 +389,11 @@ class BattleOrchestrator:
money = float(base.get("money") or 0)
if money and (money > policy.max_money or float(master.get("money") or 0) - money < max(0, value(ranch, "keep_money", 0))):
return "入场金币超过上限或保留金币不足"
for item in base.get("items") or []:
key, count = str(item["typeId"]), int(item["num"])
for key, count in item_requirements(base.get("items") or []).items():
if count and not policy.allow_items:
return "入场需要消耗道具,未启用"
reserve = max(int(policy.item_reserves.get(key, 0)), int(value(ranch, "reserved_eggs", {}).get(key, 0)))
owned = sum(int(i.get("num") or 0) for i in snapshot.raw.get("items", [])
if str(i.get("typeId")) == key and not i.get("lock") and not i.get("sysLock") and not i.get("feedLock"))
owned = available_item_count(snapshot, key)
reserve = max(reserve, int(value(ranch, "gift_items", {}).get(key, {}).get("reserve", 0)))
if owned - count < reserve:
return "入场道具不足或已达保留数量"
File diff suppressed because one or more lines are too long
+36 -9
View File
@@ -21,6 +21,8 @@ from .stage_cache import StageCache
from .drop_statistics import reward_text
from .cultivation import CultivationSelector
from .battles import BattleJournal, BattleOrchestrator, CancelledBeforeDispatch, digest, gameplay_response, public_data, value
from .resource_stages import resource_entry_reason
from .resource_stages import with_resource_data
from .progression import ProgressionIntent, ProgressionPlanner, ProgressionPolicy
from .battle_messages import battle_message
from .maps import stages
@@ -56,6 +58,7 @@ def single_flight(method):
class Engine:
def __init__(self, catalog, client=None, budget_path=None, *, game_data=None, battle_runtime=None, experimental_runtime=None):
self.catalog, self.client = catalog, client
self.resource_catalog = None
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)
@@ -126,6 +129,11 @@ class Engine:
self._battle_runtimes = {"original": battle_runtime, "experimental": experimental_runtime}
self._selected_battle_mode = "original"
def _map_catalog(self):
if self.resource_catalog is None:
self.resource_catalog = with_resource_data(self.catalog)
return self.resource_catalog
def _load_automation_state(self):
if not self.automation_state_path:
return
@@ -356,13 +364,13 @@ class Engine:
self._progression_state_loaded = True
# A separate view preserves the commission-only legacy catalog.
if not self._battle_catalog_ready:
battle_catalog = copy(self.catalog)
battle_catalog = self._map_catalog()
positions = dict(self.catalog.data.get("stage_task_positions", {}))
for key, task in self.game_data.tasks.items():
positions[str(key)] = [step.get("position", "") for step in task.get("steps", [])]
battle_catalog.data = self.catalog.data | {"stage_info": self.game_data.stages,
"stage_sp": self.game_data.stage_sp, "stage_task_positions": positions,
"game_setting": self.game_data.game_setting}
battle_catalog.data = battle_catalog.data | {"stage_info": self.game_data.stages | battle_catalog.data.get("stage_info", {}),
"stage_sp": self.game_data.stage_sp | battle_catalog.data.get("stage_sp", {}), "stage_task_positions": positions,
"game_setting": self.game_data.game_setting | battle_catalog.data.get("game_setting", {})}
self.battles.catalog = battle_catalog
self._battle_catalog_ready = True
self._select_battle_runtime(self.progression_policy.battle_mode)
@@ -429,6 +437,9 @@ class Engine:
self.sweeper.save()
elif event in ("settled", "event"):
self.sweeper.state.setdefault("challenge_failures", {}).pop(key, None)
if value(intent, "stage_category") in ("mine", "ticket"):
completed = self.battle_journal.pending(self.snapshot) or {}
self.sweeper.remember_map_reward(self.snapshot, completed, response, event=event == "event")
self.sweeper.save()
return None
farming = self._is_farm(intent)
@@ -529,7 +540,7 @@ class Engine:
if not self.auto or self._progression_cancel.is_set() or not self.battles.resumable_task_clock(record):
return ""
if record.get("kind") == "map_battle":
intent = {key: record.get(key) for key in ("kind", "task_id", "task_type_id", "step_number",
intent = {key: record.get(key) for key in ("kind", "task_id", "task_type_id", "step_number", "stage_category",
"stage_id", "difficulty", "battle_kind", "team", "path")}
return self.battles.resume_task_clock(self.client, self.snapshot, intent, self._map_policy(), cancel=self._progression_cancel)
pending = self.progression_planner.pending(self.snapshot) if self.progression_planner else None
@@ -1174,8 +1185,11 @@ class Engine:
raise
def _map_policy(self):
return SimpleNamespace(enabled=self.sweep_policy.enabled and self.sweep_policy.allow_challenge,
return SimpleNamespace(enabled=self.sweep_policy.enabled and (self.sweep_policy.allow_challenge or self.sweep_policy.allow_special),
team=self.sweep_policy.team, reserve_ti=self.sweep_policy.keep_stamina,
keep_stamina=self.sweep_policy.keep_stamina, allow_challenge=self.sweep_policy.allow_challenge,
rules=self.sweep_policy.rules,
allow_special=self.sweep_policy.allow_special, keep_tickets=self.sweep_policy.keep_tickets,
max_money=max(0, int(self.snapshot.raw["master"].get("money") or 0)) if self.snapshot else 0,
allow_items=True, item_reserves=dict(self.quest_policy.item_reserves),
stop_after_loss=0, battle_mode="experimental")
@@ -1204,6 +1218,13 @@ class Engine:
return "已达本日次数上限"
if stage.sweep:
return ""
if stage.category in ("mine", "ticket"):
failed = self.sweeper.state.get("challenge_failures", {}).get(self.sweeper.key(snapshot, stage))
if failed and failed == self._map_roster_signature(snapshot, policy.team):
return "打不过;调整战队或提升魔物属性后自动重试"
if self._map_reason_snapshot is snapshot and self._map_reason_team == policy.team:
return self._map_challenge_reasons.get((stage.stage_id, stage.level), "")
return ""
if not policy.allow_challenge:
return "未开启未满星时自动挑战"
failed = self.sweeper.state.get("challenge_failures", {}).get(self.sweeper.key(snapshot, stage))
@@ -1218,7 +1239,7 @@ class Engine:
return None
self._map_challenge_reasons = {}
self._map_reason_snapshot, self._map_reason_team = self.snapshot, self.sweep_policy.team
for stage in sorted(stages(self.catalog, self.snapshot), key=lambda row: (row.city, row.number, row.stage_id, row.level)):
for stage in sorted(stages(self._map_catalog(), self.snapshot), key=lambda row: (row.city, row.number, row.stage_id, row.level)):
rule = self.sweep_policy.rules.get(stage.stage_id) or {}
if not rule.get("enabled") or str(rule.get("level", "3")) != stage.level:
continue
@@ -1237,6 +1258,8 @@ class Engine:
"stage_id": stage.stage_id, "difficulty": int(stage.level), "battle_kind": "ordinary_stage",
"position": f"city{stage.city}_wild_stage{stage.stage_id}_level{stage.level}",
"team": self.sweep_policy.team, "battle_mode": "experimental"}
if stage.category in ("mine", "ticket"):
intent.update(description=f"资源关卡 {stage.number} {stage.name}", battle_kind="resource_stage", stage_category=stage.category)
supported, reason = self._battle_capability(intent)
self._map_challenge_reasons[(stage.stage_id, stage.level)] = battle_message(reason)
if supported:
@@ -1244,10 +1267,14 @@ class Engine:
return None
def _run_map_challenge(self, intent):
stage = next((row for row in stages(self.catalog, self.snapshot) if row.stage_id == str(value(intent, "stage_id"))
stage = next((row for row in stages(self._map_catalog(), self.snapshot) if row.stage_id == str(value(intent, "stage_id"))
and row.level == str(value(intent, "difficulty"))), None)
if stage is None or not self.sweep_policy.enabled or not self.sweep_policy.allow_challenge:
resource = stage is not None and stage.category in ("mine", "ticket")
if stage is None or not self.sweep_policy.enabled or not (self.sweep_policy.allow_special if resource else self.sweep_policy.allow_challenge):
return self.snapshot, self.plans(), "自动挑战已关闭或关卡状态已改变"
if resource:
if str(value(intent, "stage_category")) != stage.category or str(value(intent, "battle_kind")) != "resource_stage":
return self.snapshot, self.plans(), "资源关卡类型或入口已改变,禁止入场"
reason = self.map_stage_reason(self.snapshot, stage, self.sweep_policy)
if reason:
return self.snapshot, self.plans(), reason
+2
View File
@@ -2236,6 +2236,8 @@ class Window(ExplorationPages, ProgressionPages, ActivityPages, W.QMainWindow):
self.map_enabled.setChecked(sweep.enabled)
self.map_allow_challenge.setChecked(sweep.allow_challenge)
self.map_keep_ti.setValue(sweep.keep_stamina)
self.map_allow_special.setChecked(sweep.allow_special)
self.map_keep_tickets.setValue(sweep.keep_tickets)
self.map_team.setCurrentIndex(max(0, self.map_team.findData(sweep.team)))
self.load_progression_policy(progression)
self.egg_rules = copy.deepcopy(policy.egg_rules)
+69 -1
View File
@@ -54,29 +54,97 @@ class Stage:
sweep: bool = False
drops: str = ""
reason: str = ""
category: str = "ordinary"
battle_available: bool = False
def resource_mines(catalog):
"""Only original mine1 nodes, excluding their guardian and dungeon stages."""
mine = (catalog.data.get("mine_info") or {}).get("mines", {}).get("mine1") or {}
return {str(obj["stageId"]) for layer in mine.get("layers") or []
for obj in layer.get("objs") or [] if obj.get("type") == "stage" and obj.get("stageId")}
def stage_category(catalog, stage_id, row, metadata=None):
stage_id, row = str(stage_id), row or {}
if row.get("posmode"):
return "special"
items = (row.get("cost") or {}).get("items") or []
mines, sp_children = (metadata or _stage_metadata(catalog))[:2]
if stage_id in mines and items and all(
str(item.get("typeId")) in {"20009", "20010", "20011"} for item in items):
return "mine"
if row.get("special") and items and (stage_id in catalog.data.get("stage_sp", {}) or stage_id in sp_children):
names = catalog.data.get("item_names") or {}
if all("券" in names.get(str(item.get("typeId")), "") or "门票" in names.get(str(item.get("typeId")), "") for item in items):
return "ticket"
return "special" if row.get("special") else "ordinary"
def _stage_metadata(catalog):
table = catalog.data
if getattr(catalog, "_resource_metadata", None) is None:
catalog._resource_metadata = (resource_mines(catalog),
{str(obj.get("stageId")) for key, special in table.get("stage_sp", {}).items()
if not special.get("tag") and not (table.get("stage_info", {}).get(key) or {}).get("special")
for obj in special.get("stages") or [] if isinstance(obj, dict)},
{str(obj.get("stageId")): (key, special) for key, special in table.get("stage_sp", {}).items()
if not special.get("tag") and not (table.get("stage_info", {}).get(key) or {}).get("special")
for obj in special.get("stages") or [] if isinstance(obj, dict)})
return catalog._resource_metadata
def resource_stages(catalog, snapshot):
"""Classified level-one resource candidates; runtime capability is separate."""
return [stage for stage in stages(catalog, snapshot)
if stage.category in ("mine", "ticket") and stage.level == "1"]
def stages(catalog, snapshot):
history = snapshot.raw.get("history") or {}
cities = catalog.data["game_setting"].get("cityInfo", {})
result = []
metadata = _stage_metadata(catalog)
for key, row in catalog.data["stage_info"].items():
special = catalog.data.get("stage_sp", {}).get(key, {})
category = stage_category(catalog, key, row, metadata)
parent = metadata[2].get(key) if category == "ticket" else None
if parent:
parent_key, special = parent
parent_row = catalog.data.get("stage_info", {}).get(parent_key, {})
if parent_row.get("closed") or not condition_ok(special.get("condition"), snapshot):
for level, info in row.get("level", {}).items():
result.append(Stage(key, str(level), row.get("name") or key, int(row.get("city") or 0),
stage_has_level(history, "unlockStage", key, level), stage_has_level(history, "passStage", key, level),
False, int((row.get("cost") or {}).get("ti") or 0) + int(info.get("cost") or 0),
", ".join(f"{catalog.data.get('item_names', {}).get(str(i['typeId']), i['typeId'])}×{i['num']}"
for i in (row.get("cost") or {}).get("items", [])), row.get("tagname") or key,
cities.get(str(int(row.get("city") or 0)), {}).get("name", f"地区 {int(row.get('city') or 0)}"),
0, False, reward_summary(catalog, info.get("reward")), "所属活动当前未开放", category,
bool(info.get("battle_available"))))
continue
opened = not row.get("closed") and condition_ok(special.get("condition"), snapshot)
city = int(row.get("city") or 0)
city_info = cities.get(str(city), {})
passed_levels = [i for i in (1, 2, 3) if stage_has_level(history, "passStage", key, i)]
sweep = not row.get("special") and not row.get("posmode") and len(passed_levels) == 3
mine_unlocked = bool(category == "mine" and (history.get("unlockStage") or {}).get(key) is not None)
for level, info in row.get("level", {}).items():
unlocked = stage_has_level(history, "unlockStage", key, level)
unlocked = unlocked or (mine_unlocked and str(level) == "1")
passed = stage_has_level(history, "passStage", key, level)
gate = city_info.get({"2": "openHardModeStage", "3": "openExtraModeStage"}.get(str(level), ""))
unlocked = unlocked and not info.get("levelLock") and (not gate or stage_has_level(history, "passStage", gate, 1))
base = row.get("cost") or {}
tickets = ", ".join(f"{catalog.data.get('item_names', {}).get(str(i['typeId']), i['typeId'])}×{i['num']}" for i in base.get("items", []))
reason = "未解锁" if not unlocked else "当前未开放" if not opened else "特殊关卡需手机实战" if row.get("special") or row.get("posmode") else "需三个难度全部通关" if not sweep else "可扫荡"
if category in ("mine", "ticket") and str(level) != "1":
reason = "矿点仅支持原入口难度1" if category == "mine" else "门票关卡仅支持原入口难度1"
elif category in ("mine", "ticket") and not info.get("battle_available"):
reason = "该资源关卡缺少已提取的战斗配置,未启用"
result.append(Stage(key, str(level), row.get("name") or key, city, unlocked, passed, opened,
int(base.get("ti") or 0) + int(info.get("cost") or 0), tickets,
row.get("tagname") or key, city_info.get("name", f"地区 {city}"), max(passed_levels, default=0),
sweep and unlocked and opened, reward_summary(catalog, info.get("reward")), reason))
sweep and unlocked and opened, reward_summary(catalog, info.get("reward")), reason,
category, bool(info.get("battle_available"))))
return result
+90
View File
@@ -0,0 +1,90 @@
"""Explicit resource-stage inventory gates; entry and combat stay with Engine."""
from copy import copy
import hashlib
import json
from pathlib import Path
ORIGINAL_APK_SHA256 = "01678ee3a8465d818d32cbbd94baa0d8253b04b4c57b70ebc5544ed341f1015d"
def with_resource_data(catalog):
"""Return a local static-data view; credentials and account state are excluded."""
path = Path(__file__).with_name("data") / "resource_stages.json"
index = json.loads(path.read_text(encoding="utf-8"))
if index.get("schema") != 1 or index.get("apk_sha256") != ORIGINAL_APK_SHA256:
raise ValueError("资源关卡静态索引版本或原客户端校验不一致")
if hashlib.sha256((path.parent / "progression.json.gz").read_bytes()).hexdigest() != index.get("progression_sha256"):
raise ValueError("资源关卡静态索引与关卡数据校验不一致")
source = copy(catalog)
if "_resource_metadata" in vars(source):
del source._resource_metadata
supplemented = dict(catalog.data.get("stage_info", {}))
for key, row in index["stage_info"].items():
if key not in supplemented:
supplemented[key] = row
continue
# Existing/custom rows retain ownership; add only original metadata.
supplemented[key] = supplemented[key] | {"level": {level: info | {
"battle_available": index["stage_info"][key].get("level", {}).get(level, {}).get("battle_available", False)}
for level, info in supplemented[key].get("level", {}).items()}}
source.data = catalog.data | {"stage_info": supplemented, "stage_sp": catalog.data.get("stage_sp", {}) | index["stage_sp"],
"mine_info": {"mines": {"mine1": index["mine"]}}, "item_names": catalog.data.get("item_names", {}) | index["item_names"],
"game_setting": catalog.data.get("game_setting", {}) | index["game_setting"]}
return source
def _count(value):
try:
result = int(value or 0)
except (TypeError, ValueError, OverflowError):
return 0
return max(0, result)
def available_item_count(snapshot, type_id):
"""Total usable stacks; locked and currently reserved stack counts are excluded."""
total = 0
for item in snapshot.raw.get("items") or []:
if str(item.get("typeId")) != str(type_id):
continue
if any(item.get(name) for name in ("lock", "locked", "sysLock", "feedLock", "busy", "isBusy", "using", "inUse")):
continue
total += max(0, _count(item.get("num")) - _count(item.get("usingNum") or item.get("busyNum") or item.get("usedNum")))
return total
def item_requirements(stage):
result = {}
for item in stage:
key = str(item.get("typeId"))
if not key or key == "None":
continue
result[key] = result.get(key, 0) + _count(item.get("num"))
return result
def resource_entry_reason(catalog, snapshot, stage, policy):
"""A public UI/worker gate. Passing this never implies runtime support."""
if stage.category not in ("mine", "ticket"):
return "仅显式勾选的矿点或门票资源关卡可自动入场"
if not policy.enabled or not policy.allow_special:
return "资源关卡自动入场未开启"
if stage.level != "1":
return "矿点仅支持原入口难度1" if stage.category == "mine" else "门票关卡仅支持原入口难度1"
if not stage.unlocked or not stage.open:
return "关卡尚未解锁或当前未开放"
if not stage.battle_available:
return "该资源关卡缺少已提取的战斗配置,未启用"
row = (catalog.data.get("stage_info") or {}).get(stage.stage_id) or {}
base = row.get("cost") or {}
# MinePanel/StageSpPanel check level.cost separately from base costVo.
if base.get("ke") or base.get("money"):
return "该资源关卡包含未启用的氪金或金币消耗"
if float(snapshot.raw.get("master", {}).get("ti") or 0) < stage.stamina + max(0, policy.keep_stamina):
return "体力不足或已达保留体力,等待恢复"
for key, count in item_requirements(base.get("items") or []).items():
name = catalog.data.get("item_names", {}).get(key, key)
if available_item_count(snapshot, key) - count < policy.keep_tickets:
return f"{name}不足或已达保留工具数量,等待补充"
return ""
+4 -2
View File
@@ -4,11 +4,13 @@ import json
from pathlib import Path
from .maps import Stage, stages
from .resource_stages import with_resource_data
class StageCache:
def __init__(self, catalog, path=None):
self.catalog = catalog
self.catalog = with_resource_data(catalog)
self.path = Path(path) if path else None
self.owner = None
self.rows = None
@@ -22,7 +24,7 @@ class StageCache:
if not refresh and self.path and self.path.exists():
try:
value = json.loads(self.path.read_text(encoding="utf-8"))
if value.get("schema") == 1 and value.get("gameVersion") == "1.9.68" and value.get("owner") == owner:
if value.get("schema") == 2 and value.get("gameVersion") == "1.9.68" and value.get("owner") == owner:
self.rows = [Stage(**row) for row in value["stages"]]
self.owner, self.saved_at = owner, float(value["savedAt"])
self.revision += 1
@@ -34,7 +36,7 @@ class StageCache:
if self.path:
self.path.parent.mkdir(parents=True, exist_ok=True)
temporary = self.path.with_suffix(".tmp")
temporary.write_text(json.dumps({"schema": 1, "gameVersion": "1.9.68", "owner": owner,
temporary.write_text(json.dumps({"schema": 2, "gameVersion": "1.9.68", "owner": owner,
"savedAt": saved_at, "stages": [asdict(row) for row in rows]}, ensure_ascii=False), encoding="utf-8")
temporary.replace(self.path)
self.rows, self.owner, self.saved_at = rows, owner, saved_at
+30 -1
View File
@@ -1,5 +1,6 @@
"""The built-in three-difficulty-cleared sweep path from StageStartPanel."""
from dataclasses import dataclass, field
from types import SimpleNamespace
import json
from pathlib import Path
import sqlite3
@@ -7,6 +8,7 @@ import uuid
from .daily import day
from .maps import stages
from .resource_stages import resource_entry_reason
from .drop_statistics import SweepStatistics, event_reward, normalize_reward
from .team_availability import team_availability_reason
@@ -22,6 +24,14 @@ class SweepPolicy:
keep_stamina: int = 0
team: str = "teamA"
allow_challenge: bool = True
allow_special: bool = False
keep_tickets: int = 0
def __post_init__(self):
if type(self.allow_special) is not bool:
raise ValueError("资源关卡开关必须为布尔值")
if type(self.keep_tickets) is not int or self.keep_tickets < 0:
raise ValueError("保留工具数量必须为非负整数")
class SweepRunner:
@@ -51,10 +61,27 @@ class SweepRunner:
cost = (response.get("stageEvent") or {}).get("costTi") if kind == "event" else response.get("costTi")
self.statistics.record(snapshot.raw["master"]["id"], stage.stage_id, stage.level, kind, source,
snapshot.now, reward, cost)
except (OSError, sqlite3.Error, ValueError, TypeError) as error:
except (OSError, sqlite3.Error, ValueError, TypeError, KeyError) as error:
# A local statistics failure must never repeat an awarded request.
self.statistics_error = "奖励统计未写入:" + str(error)
def remember_map_reward(self, snapshot, record, response, *, event=False):
"""Attach an already journaled resource result to existing drop statistics."""
self.last_outcome = "resource_event" if event else "resource"
reward = record.get("reward")
if reward is None:
self.statistics_error = "资源关卡结算缺少奖励,未写入掉落统计"
return
self.statistics_error = ""
try:
self.last_reward = normalize_reward(self.catalog, reward)
source_response = record.get("response") or record.get("start_response") or response or {}
self.statistics.record(snapshot.raw["master"]["id"], record["stage_id"], str(record["difficulty"]), "event" if event else "sweep",
"battle:" + record["attempt_id"], snapshot.now, reward,
(source_response.get("stageEvent") or {}).get("costTi") if event else source_response.get("costTi"))
except (OSError, sqlite3.Error, ValueError, TypeError, KeyError) as error:
self.statistics_error = "奖励统计未写入:" + str(error)
def recover_reward_event(self, snapshot, trace_path):
"""Repair only old reward-event blocks with a role-matched log reply.
@@ -130,6 +157,8 @@ class SweepRunner:
return "扫荡 / 自动挑战已关闭,禁止新的入场"
if self.state.get("pending"):
return "有未完成的扫荡,请先在游戏内检查"
if stage.category in ("mine", "ticket"):
return resource_entry_reason(self.catalog, snapshot, stage, policy) or team_availability_reason(snapshot, policy.team)
if challenge:
config = self.catalog.data.get("stage_info", {}).get(stage.stage_id, {})
if not stage.unlocked or not stage.open:
+2 -1
View File
@@ -99,7 +99,7 @@ class MapCacheGuiTests(unittest.TestCase):
window.engine.snapshot = snapshot
window.map_rules = {"0102": {"enabled": False, "level": "1", "limit": 3}}
original = window.engine.stage_cache.get(snapshot)
statuses = {"bd00": "特殊关卡暂不支持自动挑战"}
statuses = {"bd00": "尚未开启“允许矿洞 / 门票关卡”资源关开关"}
def reason(current, stage, policy, *, team_ids=None):
self.assertIs(current, snapshot)
self.assertTrue(policy.allow_challenge)
@@ -134,6 +134,7 @@ class MapCacheGuiTests(unittest.TestCase):
self.assertEqual(item.text(5), status)
self.assertEqual(item.toolTip(5), status)
self.assertEqual(window._map_items["bd00"].text(5), statuses["bd00"])
self.assertFalse(window.map_allow_special.isChecked())
self.assertIs(window.engine.stage_cache.rows, original)
self.assertEqual(client.calls, [])
finally:
@@ -0,0 +1,181 @@
"""Focused mining scenarios from the original m101/m113/m125 configurations."""
import unittest
from dataclasses import replace
from ranch_assistant.battle_simulator import (
ExperimentalBattleRuntime, _Battle, _prepare, combat_tables, simulate,
)
from ranch_assistant.game_data import ProgressionData
from ranch_assistant.tests.test_battle_simulator import enemy, monster, request
from ranch_assistant.tests.test_resource_protocol import original_roster
class MiningBattleSimulationTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.data = ProgressionData()
@staticmethod
def mining(stage="m101"):
return {"context": "ordinary_stage", "stage_id": stage, "difficulty": 1,
"roster": original_roster(), "team": "teamB", "seed": 0,
"trace_limit": 10000, "original_data": {
"battle": ProgressionData().stage_battle(stage)}}
@staticmethod
def unit(result, source_id):
return next(unit for unit in result["units"] if unit.get("source_id") == str(source_id))
def test_original_mining_targets_are_supported_without_instant_settlement(self):
for stage in ("m101", "m113", "m125"):
with self.subTest(stage=stage):
report = ExperimentalBattleRuntime().inspect(self.mining(stage))
self.assertTrue(report["supported"], report["reasons"])
self.assertTrue(report["approximate"])
self.assertFalse(report["settlement_eligible"])
self.assertFalse(report["experimental_settlement_eligible"])
def test_m101_natural_win_requires_all_three_ore_deaths(self):
req = self.mining()
battle = req["original_data"]["battle"]
battle["teams"][0]["mons"] = [mon for mon in battle["teams"][0]["mons"]
if mon.get("protectTarget") or mon.get("destroyTarget")]
result = simulate(req)
ores = [unit for unit in result["units"] if unit["destroy_target"]]
miners = [unit for unit in result["units"] if unit["protect_target"]]
self.assertEqual(result["outcome"], "win")
self.assertEqual(result["terminal_reason"], "objective")
self.assertEqual(len(ores), 3)
self.assertTrue(all(unit["state"] == "dead" and unit["hp"] == 0 for unit in ores))
self.assertTrue(all(unit["state"] == "active" for unit in miners))
self.assertGreater(result["elapsed_ms"], 1000)
self.assertEqual(result["battle_data"]["leftTime"], 300000 - result["elapsed_ms"])
self.assertNotIn("9998010", result["battle_data"]["killMonster"])
for miner in miners:
self.assertTrue(any(event["type"] == "attack" and event["actor"] == miner["id"]
and event["target"] == "configured-1-" + str(int(miner["lock_target"]) - 10000)
for event in result["events"]))
def test_locked_miners_do_not_switch_to_nearby_auto_target_enemies(self):
req = self.mining()
battle = req["original_data"]["battle"]
for mon in battle["teams"][0]["mons"]:
if mon.get("destroyTarget"):
mon["hp"] = 1
result = simulate(req)
miners = [unit for unit in result["units"] if unit["protect_target"]]
self.assertEqual(len(miners), 3)
for miner in miners:
attacks = [event for event in result["events"] if event["type"] == "attack"
and event["actor"] == miner["id"]]
expected = "configured-1-" + str(int(miner["lock_target"]) - 10000)
death = self.unit(result, int(miner["lock_target"]))["died_ms"]
self.assertTrue(death)
locked_attacks = [event for event in attacks if event["at_ms"] < death]
self.assertTrue(locked_attacks)
self.assertTrue(all(event["target"] == expected for event in locked_attacks))
def test_players_prefer_defense_over_non_auto_target_ore(self):
req = self.mining()
req["roster"]["monsters"][0].update(pHp=10000)
req["original_data"]["battle"]["time"] = 20
result = simulate(req)
attacks = [event for event in result["events"] if event["type"] == "attack"
and event["actor"] == "player-1"]
self.assertTrue(attacks)
self.assertTrue(all(event["target"] not in ("configured-1-1", "configured-1-2", "configured-1-3")
for event in attacks))
def test_one_miner_death_is_not_protect_all_loss(self):
req = self.mining()
battle = req["original_data"]["battle"]
battle["teams"][0]["mons"] = [mon for mon in battle["teams"][0]["mons"]
if mon.get("protectTarget") or mon.get("destroyTarget")]
for mon in battle["teams"][0]["mons"]:
if mon.get("protectTarget"):
mon["hp"] = 100 if mon["mid"] == 20001 else 1000000
elif mon.get("destroyTarget"):
mon["atk_dis"] = 1000
mon["isObject"] = False
mon["ai"] = 1
req["roster"]["monsters"][0].update(pHp=1000000)
battle["time"] = 10
result = simulate(req)
self.assertEqual(self.unit(result, 20001)["state"], "dead")
self.assertEqual(self.unit(result, 20002)["state"], "active")
self.assertEqual(self.unit(result, 20003)["state"], "active")
self.assertEqual(result["outcome"], "loss")
self.assertEqual(result["terminal_reason"], "battle_time_limit")
self.assertEqual(result["elapsed_ms"], 10000)
def test_weak_team_loses_without_any_assigned_victory(self):
for stage in ("m101", "m113", "m125"):
with self.subTest(stage=stage):
result = simulate(self.mining(stage))
self.assertEqual(result["outcome"], "loss")
self.assertTrue(result["terminal"])
self.assertFalse(result["battle_data"]["win"])
self.assertEqual(result["execution_status"], "completed")
def test_count_unit_false_miners_join_beside_a_full_player_team(self):
req = self.mining()
req["roster"]["master"]["level"] = 43
players = [monster(mid=1000001 + i, pHp=100000) for i in range(4)]
req["roster"]["monsters"] = players
req["roster"]["teams"][0]["monsters"] = [mon["id"] for mon in players]
req["original_data"]["battle"]["time"] = 1
result = simulate(req)
self.assertEqual(sum(unit["team"] == 1 and unit["count_unit"]
and unit["state"] == "active" for unit in result["units"]), 4)
self.assertTrue(all(self.unit(result, mid)["state"] == "active"
for mid in (20001, 20002, 20003)))
def test_m113_time_trigger_forces_configured_unit_into_battle(self):
req = self.mining("m113")
req["roster"]["monsters"][0].update(pHp=1000000)
result = simulate(req)
trigger = next(event for event in result["events"] if event["type"] == "trigger"
and event.get("effect") == "monJoin")
deploy = next(event for event in result["events"] if event["type"] == "deploy"
and event["actor"] == "configured-1-23")
self.assertEqual(trigger["at_ms"], 35000)
self.assertGreater(deploy["at_ms"], trigger["at_ms"])
def test_unknown_mining_objectives_and_controllers_still_refuse(self):
for kind, value in (("winType", ["2"]), ("loseType", ["4"])):
req = self.mining()
req["original_data"]["battle"][kind] = value
self.assertEqual(simulate(req)["outcome"], "unsupported")
req = self.mining()
req["original_data"]["battle"]["teams"][0]["mons"][0]["controller"].append({"type": "unknown"})
self.assertEqual(simulate(req)["outcome"], "unsupported")
def test_fix_hurt_uses_attack_value_and_source_element_guard(self):
scenario, report = _prepare(self.mining(), combat_tables())
battle = _Battle(scenario, report, combat_tables())
battle.deploy()
ore = battle.by_source_id["10001"]
player = battle.by_key["player-1"]
miner = battle.by_source_id["20001"]
self.assertGreater(ore.unit.stats.defense, 0)
player.unit = replace(player.unit, stats=replace(player.unit.stats, element=3))
battle.apply_damage(player, ore, 100, "fixture")
player_damage = battle.events[-1]["damage"]
battle.apply_damage(miner, ore, 100, "fixture")
miner_damage = battle.events[-1]["damage"]
self.assertEqual((player_damage, miner_damage), (99, 425))
def test_ordinary_elimination_behavior_and_guards_are_unchanged(self):
req = request(enemies=[enemy(hp=1), enemy(hp=1, wave=2, joinTime=4)])
result = simulate(req)
self.assertEqual(result["outcome"], "win")
self.assertEqual(result["terminal_reason"], "elimination")
self.assertTrue(any(event["type"] == "deploy" and event["wave"] == 2
for event in result["events"]))
req["original_data"]["battle"]["triggers"] = [{"type": "monDead", "effects": []}]
self.assertEqual(simulate(req)["outcome"], "unsupported")
if __name__ == "__main__":
unittest.main()
@@ -0,0 +1,115 @@
"""Independent, offline admission checks for pickaxe resource stages."""
import unittest
from types import SimpleNamespace
from ranch_assistant.battle_runtime import BattleRuntime, NATIVE_ADMISSION_ENABLED
from ranch_assistant.battle_simulator import ExperimentalBattleRuntime
from ranch_assistant.battles import BattleOrchestrator
from ranch_assistant.game_data import ProgressionData
from ranch_assistant.maps import stages
from ranch_assistant.model import Catalog, Snapshot
from ranch_assistant.sweeping import SweepRunner
from tools.battle_runtime.inputs import MON_FIELDS
MINES = ("m101", "m113", "m125")
def original_roster():
"""A complete synthetic level-one roster, never an account snapshot."""
monster = dict.fromkeys(MON_FIELDS, 0)
monster.update(id=1000001, typeId=1001010, level=1, mode=2,
process=3, potentialLevel=1, nicName="")
history = dict.fromkeys(("numAddMoney", "numChicken", "countBattle"), 0)
history.update(dict.fromkeys(("monLib", "equipLib", "passAchi",
"guide_record", "unlockCity"), []))
history.update(dict.fromkeys((
"numFeedMonsters", "numKillMonsters", "historyGacha", "passTask",
"unlockTask", "loopTask", "unlockStage", "passStage",
"payTypeCount", "everyDayBuyProductNum"), {}))
history["guide_main"] = ""
return {
"master": {"id": 1, "level": 1, "globalAtk": 0,
"globalDef": 0, "globalHp": 0, "globalDex": 0},
"monsters": [monster], "monsterAttributes": [], "items": [],
"teams": [{"teamName": "teamB", "teamType": "battleTeam",
"monsters": [1000001, 0]}],
"history": history,
}
class ResourceRuntimeAdmissionTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.data = ProgressionData()
source = cls.data.manifest["source"]
cls.identity = {"apk_sha256": source["apk_sha256"],
"main_swf_sha256": source["main_swf_sha256"]}
def request(self, stage_id, purpose="offline_validation"):
return {
"context": "ordinary_stage", "stage_id": stage_id, "difficulty": 1,
"purpose": purpose, "roster": original_roster(), "team": "teamB",
"original_data": {"source": "original_apk",
"resource_identity": self.identity,
"battle": self.data.stage_battle(stage_id)},
"battle_position": {"battleType": "stage", "stageId": stage_id,
"stageLevel": "1", "taskTypeId": None, "taskStep": 0},
}
def test_original_inspection_supports_mining_without_grant_settlement(self):
for stage_id in MINES:
with self.subTest(stage=stage_id):
report = BattleRuntime().inspect(self.request(stage_id))
self.assertEqual(report["reasons"], [], report)
self.assertTrue(report["supported"], report)
self.assertTrue(report["faithful"], report)
self.assertFalse(report["settlement_eligible"], report)
def test_original_online_admission_still_requires_completed_qa(self):
orchestrator = BattleOrchestrator(None, None, BattleRuntime())
for stage_id in MINES:
with self.subTest(stage=stage_id):
request = self.request(stage_id, "settlement")
report = BattleRuntime().inspect(request)
self.assertEqual(report["settlement_eligible"], NATIVE_ADMISSION_ENABLED)
self.assertEqual(report["native_admission_validation_pending"],
not NATIVE_ADMISSION_ENABLED)
supported, reason = orchestrator.inspect({
"runtime_request": request, "battle_mode": "original"})
self.assertEqual(supported, NATIVE_ADMISSION_ENABLED, reason)
def test_experimental_model_admits_mining_without_claiming_fidelity(self):
for stage_id in MINES:
with self.subTest(stage=stage_id):
report = ExperimentalBattleRuntime().inspect(self.request(stage_id))
self.assertTrue(report["supported"], report)
self.assertTrue(report["approximate"], report)
self.assertFalse(report["faithful"], report)
self.assertFalse(report["settlement_eligible"], report)
self.assertFalse(report["experimental_settlement_eligible"], report)
class ResourceSweepBoundaryTests(unittest.TestCase):
def test_special_resource_stages_cannot_use_empty_data_sweep(self):
catalog = Catalog()
snapshot = Snapshot({
"master": {"id": 1, "ti": 1000, "money": 0},
"history": {"unlockStage": {key: [1] for key in MINES}},
"teams": [{"teamName": "teamB", "teamType": "battleTeam",
"monsters": [1000001]}],
"monsters": [{"id": 1000001}], "items": [], "currentTasks": [],
"stacks": [], "rooms": [],
})
policy = SimpleNamespace(enabled=True, team="teamB", keep_stamina=0)
for stage in stages(catalog, snapshot):
if stage.stage_id not in MINES:
continue
with self.subTest(stage=stage.stage_id):
self.assertFalse(stage.sweep)
self.assertTrue(SweepRunner(catalog).reason(snapshot, stage, policy))
if __name__ == "__main__":
unittest.main()
@@ -0,0 +1,309 @@
"""Resource-stage contracts; all network and runtime boundaries are offline fakes."""
import unittest
from copy import deepcopy
from types import SimpleNamespace
from unittest.mock import Mock
from ranch_assistant.maps import resource_stages, stages
from ranch_assistant.resource_stages import resource_entry_reason
from ranch_assistant.sweeping import SweepPolicy
from ranch_assistant.stage_cache import StageCache
from ranch_assistant.tests.test_activities import scenario
from ranch_assistant.tests.test_battle_orchestration import ExperimentalRuntime
from ranch_assistant.engine import Engine
from ranch_assistant.drop_statistics import analyze
from ranch_assistant.game_data import ProgressionData
from ranch_assistant.model import Policy
from ranch_assistant.tests.test_core import workspace_temp
class ResourceStageTests(unittest.TestCase):
def setUp(self):
self.catalog, self.snapshot = scenario()
from ranch_assistant.game_data import load_progression_data
data = load_progression_data()
self.catalog.data["stage_info"] = deepcopy(data.stages)
self.catalog.data["stage_sp"] = data.stage_sp
self.catalog.data["mine_info"] = {"mines": data.mines}
self.snapshot.raw["history"]["unlockStage"].update({k: ["1"] for k in ("m101", "m113", "m125", "lzex01", "dg202")})
self.snapshot.raw["history"]["passStage"].update({k: ["1"] for k in ("m101", "m113", "m125", "lzex01", "dg202")})
self.snapshot.raw["master"]["ti"] = 1000
self.snapshot.raw["items"] = [{"id": 1, "typeId": "20009", "num": 2}]
def stage(self, key="m101", level="1"):
if key in ("m101", "m113", "m125"):
self.snapshot.raw["history"]["unlockStage"][key] = {"1": True}
return next(row for row in stages(self.catalog, self.snapshot) if row.stage_id == key and row.level == level)
def test_resource_policy_defaults_and_strict_types(self):
policy = SweepPolicy()
self.assertFalse(policy.allow_special)
self.assertEqual(policy.keep_tickets, 0)
SweepPolicy(allow_special=True, keep_tickets=2)
for changes in ({"allow_special": 1}, {"keep_tickets": True}, {"keep_tickets": -1}):
with self.subTest(changes=changes), self.assertRaises(ValueError):
SweepPolicy(**changes)
def test_mine_category_is_from_original_mine_mapping_not_prefix_or_pick_cost(self):
mine = {"type": "mine1", "layers": [{"objs": [
{"type": "stage", "stageId": "m101", "typeId": "water1"},
{"type": "stage", "stageId": "m103", "typeId": "monster"},
]}]}
catalog = type("Catalog", (), {"data": {
"game_setting": {"cityInfo": {}}, "stage_sp": {}, "item_names": {},
"stage_info": {
"m101": {"name": "水矿", "city": 0, "special": True,
"cost": {"ti": 0, "items": [{"typeId": "20009", "num": 1}]},
"level": {"1": {"cost": 16, "battle_available": True}, "2": {"cost": 2}, "3": {"cost": 3}}},
"m103": {"name": "守卫", "city": 0, "special": True,
"cost": {"ti": 0}, "level": {"1": {"cost": 16}}},
"dg202": {"name": "地下城矿点", "city": 5, "special": True,
"cost": {"ti": 0, "items": [{"typeId": "20009", "num": 1}]},
"level": {"1": {"cost": 16}}},
}, "mine_info": {"mines": {"mine1": mine}},
}})()
snapshot = type("Snapshot", (), {"raw": {"history": {"unlockStage": {}, "passStage": {}}}})()
rows = {(row.stage_id, row.level): row for row in stages(catalog, snapshot)}
self.assertEqual(rows["m101", "1"].category, "mine")
self.assertEqual(rows["m101", "1"].stamina, 16)
self.assertTrue(rows["m101", "1"].battle_available)
self.assertEqual(rows["m101", "2"].reason, "矿点仅支持原入口难度1")
self.assertEqual(rows["m103", "1"].category, "special")
self.assertEqual(rows["dg202", "1"].category, "special")
self.assertEqual([row.stage_id for row in resource_stages(catalog, snapshot)], ["m101"])
def test_real_mine_costs_inventory_reservation_and_capability_gates(self):
for key, stamina, tool in (("m101", 16, "20009"), ("m113", 20, "20010"), ("m125", 22, "20011")):
with self.subTest(key=key):
stage = self.stage(key)
self.assertEqual((stage.category, stage.stamina), ("mine", stamina))
self.assertEqual(stage.tickets, self.catalog.item_name(tool) + "×1")
self.assertFalse(stage.sweep)
policy = SweepPolicy(enabled=True, allow_special=True)
self.assertEqual(resource_entry_reason(self.catalog, self.snapshot, self.stage(), policy), "")
policy.keep_tickets = 2
self.assertIn("保留", resource_entry_reason(self.catalog, self.snapshot, self.stage(), policy))
policy.keep_tickets = 0
self.snapshot.raw["items"] = [
{"id": 1, "typeId": "20009", "num": 2, "lock": 1},
{"id": 2, "typeId": "20009", "num": 2, "usingNum": 1},
{"id": 3, "typeId": "20009", "num": 1, "busy": True},
]
self.assertEqual(resource_entry_reason(self.catalog, self.snapshot, self.stage(), policy), "")
self.snapshot.raw["master"]["ti"] = 15
self.assertIn("体力", resource_entry_reason(self.catalog, self.snapshot, self.stage(), policy))
def test_default_catalog_retains_ordinary_maps_and_gains_real_mines(self):
from ranch_assistant.model import Catalog
from ranch_assistant.engine import demo_snapshot
from ranch_assistant.resource_stages import with_resource_data
catalog = Catalog()
snapshot = demo_snapshot(catalog)
snapshot.raw["history"].setdefault("unlockStage", {})
snapshot.raw["history"].setdefault("passStage", {})
snapshot.raw["history"]["unlockStage"]["0101"] = ["1"]
snapshot.raw["history"]["unlockStage"]["m101"] = {"1": True}
snapshot.raw["history"]["passStage"]["m101"] = {"1": True}
rows = {(row.stage_id, row.level): row for row in stages(with_resource_data(catalog), snapshot)}
self.assertEqual(rows["0101", "1"].category, "ordinary")
self.assertTrue(rows["0101", "1"].unlocked)
self.assertTrue(rows["m101", "1"].battle_available)
self.assertEqual(rows["m101", "1"].stamina, 16)
def test_augmenting_after_plain_catalog_render_recomputes_classification(self):
from ranch_assistant.model import Catalog
from ranch_assistant.resource_stages import with_resource_data
catalog = Catalog()
from ranch_assistant.engine import demo_snapshot
snapshot = demo_snapshot(catalog)
self.assertEqual(next(row for row in stages(catalog, snapshot)
if row.stage_id == "m101" and row.level == "1").category, "special")
rows = {(row.stage_id, row.level): row for row in stages(with_resource_data(catalog), snapshot)}
for key in ("m101", "m113", "m125"):
self.assertEqual(rows[key, "1"].category, "mine")
self.assertTrue(rows[key, "1"].battle_available)
self.assertEqual(rows["bd00", "1"].category, "ticket")
def test_duplicate_requirements_are_combined_and_only_explicit_resources_enter(self):
policy = SweepPolicy(enabled=True, allow_special=True)
row = self.catalog.data["stage_info"]["m101"]
row["cost"]["items"] = [{"typeId": "20009", "num": 1}, {"typeId": "20009", "num": 2}]
self.assertIn("矿镐", resource_entry_reason(self.catalog, self.snapshot, self.stage(), policy))
self.snapshot.raw["items"][0]["num"] = 3
self.assertEqual(resource_entry_reason(self.catalog, self.snapshot, self.stage(), policy), "")
self.assertEqual(self.stage("lzex01").category, "ticket")
self.assertEqual(self.stage("bd00").category, "ticket")
self.assertEqual(self.stage("bd01").category, "special")
self.assertEqual(self.stage("02f5").category, "special")
self.assertEqual(self.stage("dg202").category, "special")
for level in ("2", "3"):
self.assertIn("难度1", resource_entry_reason(self.catalog, self.snapshot, self.stage(level=level), policy))
self.catalog.data["stage_info"]["m101"]["level"]["1"]["battle_available"] = False
self.assertIn("战斗配置", resource_entry_reason(self.catalog, self.snapshot, self.stage(), policy))
policy.allow_special = False
self.assertIn("未开启", resource_entry_reason(self.catalog, self.snapshot, self.stage(), policy))
def test_old_map_cache_rebuilds_locally_and_new_cache_round_trip(self):
with workspace_temp() as folder:
path = folder / "maps.json"
import json
from dataclasses import asdict
original = StageCache(self.catalog, path).get(self.snapshot)
path.write_text(json.dumps({"schema": 1, "gameVersion": "1.9.68", "owner": str(self.snapshot.raw["master"]["id"]),
"savedAt": self.snapshot.now, "stages": [{key: value for key, value in asdict(row).items()
if key not in ("category", "battle_available")} for row in original]}, ensure_ascii=False), encoding="utf-8")
rows = StageCache(self.catalog, path).get(self.snapshot)
self.assertEqual(next(row for row in rows if row.stage_id == "m101" and row.level == "1").category, "mine")
restored = StageCache(self.catalog, path).get(self.snapshot)
self.assertEqual(next(row for row in restored if row.stage_id == "m101" and row.level == "1").category, "mine")
class ResourceStageExecutionTests(unittest.TestCase):
def setUp(self):
self.folder = self.enterContext(workspace_temp())
self.catalog, self.snapshot = scenario()
from ranch_assistant.game_data import load_progression_data
data = load_progression_data()
self.catalog.data["stage_info"] = deepcopy(data.stages)
self.catalog.data["stage_sp"] = data.stage_sp
self.catalog.data["mine_info"] = {"mines": data.mines}
self.raw = deepcopy(self.snapshot.raw)
self.raw["currentTasks"] = []
self.raw["history"]["unlockStage"]["m101"] = ["1"]
self.raw["history"]["passStage"]["m101"] = ["1"]
self.raw["master"].update(ti=1000, timeTi=0)
self.raw["master"]["level"] = 62
self.raw["items"] = [{"id": 1, "typeId": "20009", "num": 4}]
self.runtime = ExperimentalRuntime()
self.client = Mock()
self.client.snapshot.side_effect = lambda: __import__("ranch_assistant.model", fromlist=["Snapshot"]).Snapshot(deepcopy(self.raw))
self.client.call.side_effect = self.respond
self.data = ProgressionData({"task_info": {}, "stage_info": deepcopy(data.stages),
"stage_sp": data.stage_sp, "mine_info": {"mines": data.mines},
"game_setting": data.game_setting, "battle_members": data.data["battle_members"]})
self.engine = Engine(self.catalog, self.client, self.folder / "purchase.json", game_data=self.data,
experimental_runtime=self.runtime)
self.engine.policy = Policy(enabled=False, keep_money=0)
self.engine.sweep_policy = SweepPolicy(True,
{"m101": {"enabled": True, "level": "1", "limit": 3}}, allow_challenge=False, allow_special=True)
self.engine.master_sync.settle = Mock()
self.engine.auto = True
def respond(self, path, payload):
if path == "stageService/stageStart":
return {"resCode": 0, "triggerEvent": False}
return {"resCode": 0, "reward": {"money": 25}}
def paths(self):
return [call.args[0] for call in self.client.call.call_args_list]
def test_explicit_resource_runs_model_not_sweep_even_when_challenge_is_off(self):
snapshot, _, message = self.engine.poll()
self.assertEqual(self.paths(), ["stageService/stageStart", "battleService/battleEnd", "battleService/recordBattleResult"])
self.assertEqual(self.client.call.call_args_list[0].args[1], {"stageTypeId": "m101", "stageLevel": "1"})
self.assertEqual(self.runtime.run.call_args.args[0]["context"], "ordinary_stage")
data = self.client.call.call_args_list[1].args[1]["battleData"]
self.assertNotEqual(data["totalDamage"], 0)
self.assertEqual(self.engine.sweeper.last_outcome, "resource")
record = self.engine.battle_journal.records(snapshot)[0]
with self.engine.sweeper.statistics.connection() as db:
sample = db.execute("SELECT source, kind FROM samples WHERE stage='m101' AND level='1'").fetchone()
self.assertEqual(dict(sample), {"source": "battle:" + record["attempt_id"], "kind": "sweep"})
self.assertEqual(self.engine.sweeper.used(snapshot, self.engine.stage_cache.get(snapshot)[0].__class__(
"m101", "1", "", 0, True, True, True, 16, "")), 1)
def test_unsupported_disabled_and_bad_level_never_send_start(self):
self.runtime.supported = False
self.engine.poll()
self.client.call.assert_not_called()
def test_inventory_wait_refresh_and_direct_entry_recheck(self):
self.raw["items"][0]["num"] = 0
self.engine.poll()
self.client.call.assert_not_called()
self.raw["items"][0]["num"] = 3
self.engine.poll()
self.assertEqual(self.paths(), ["stageService/stageStart", "battleService/battleEnd", "battleService/recordBattleResult"])
self.raw["items"][0]["num"] = 0
self.engine.poll()
self.assertEqual(len(self.paths()), 3)
self.assertEqual(self.engine.sweeper.used(self.engine.snapshot, next(row for row in stages(self.engine._map_catalog(), self.engine.snapshot)
if row.stage_id == "m101" and row.level == "1")), 1)
def test_event_reward_records_existing_kind_without_model_or_second_entry(self):
self.client.call.side_effect = lambda path, payload: {"resCode": 0, "triggerEvent": True,
"stageEvent": {"resCode": 0, "result": {"money": 9}, "costTi": 16}}
snapshot, _, message = self.engine.poll()
self.assertEqual(self.paths(), ["stageService/stageStart"])
self.runtime.run.assert_not_called()
self.assertEqual(self.engine.sweeper.last_outcome, "resource_event")
totals, _ = analyze(
self.catalog, self.engine.sweeper.statistics.snapshot(snapshot.raw["master"]["id"]), "m101", "1", source="all")
self.assertEqual(totals["n"], 1)
self.assertEqual(totals["spent"], 16)
self.assertEqual(totals["known"], 1)
self.engine.sweeper.remember_map_reward(snapshot, self.engine.battle_journal.records(snapshot)[0],
self.client.call.call_args_list[0].args[1], event=True)
totals, _ = analyze(self.catalog, self.engine.sweeper.statistics.snapshot(snapshot.raw["master"]["id"]), "m101", "1", source="all")
self.assertEqual(totals["n"], 1)
self.raw["items"][0]["num"] = 0
self.engine.poll()
self.assertEqual(len(self.paths()), 1)
def test_unknown_start_is_retained_without_replay(self):
self.client.call.side_effect = TimeoutError("fixture")
with self.assertRaises(TimeoutError):
self.engine.poll()
record = self.engine.battle_journal.pending(self.engine.snapshot)
self.assertEqual(record["stage_category"], "mine")
self.client.call.reset_mock()
self.engine.poll()
self.client.call.assert_not_called()
def test_default_catalog_resource_and_ordinary_coexist_and_reserved_tool_blocks(self):
from ranch_assistant.model import Catalog, Snapshot
self.catalog = Catalog()
self.snapshot = Snapshot(deepcopy(self.raw))
self.data = ProgressionData()
self.engine = Engine(self.catalog, self.client, self.folder / "purchase.json", game_data=self.data,
experimental_runtime=self.runtime)
self.engine.policy = Policy(enabled=False, keep_money=0)
self.engine.sweep_policy = SweepPolicy(True,
{"m101": {"enabled": True, "level": "1", "limit": 3}}, allow_challenge=False, allow_special=True)
self.engine.master_sync.settle = Mock()
self.engine.auto = True
rows = {(row.stage_id, row.level): row for row in self.engine.stage_cache.get(self.snapshot)}
self.assertEqual(rows["0101", "1"].category, "ordinary")
self.assertEqual(rows["m101", "1"].category, "mine")
self.engine.poll()
self.assertEqual(self.paths(), ["stageService/stageStart", "battleService/battleEnd", "battleService/recordBattleResult"])
self.client.call.reset_mock()
reserved = Engine(self.catalog, self.client, self.folder / "reserved.json", game_data=self.data,
experimental_runtime=self.runtime)
reserved.policy = Policy(enabled=False, keep_money=0)
reserved.sweep_policy = SweepPolicy(True,
{"m101": {"enabled": True, "level": "1", "limit": 3}}, allow_challenge=False, allow_special=True)
reserved.master_sync.settle = Mock()
reserved.auto = True
reserved.quest_policy.item_reserves["20009"] = 4
reserved.poll()
self.client.call.assert_not_called()
def test_common_admission_aggregates_busy_inventory_and_all_reserves(self):
self.snapshot.raw["history"]["unlockStage"]["m101"] = ["1"]
self.snapshot.raw["items"] = [
{"id": 1, "typeId": "20009", "num": 2},
{"id": 2, "typeId": "20009", "num": 2, "usingNum": 1},
{"id": 3, "typeId": "20009", "num": 5, "lock": 1},
]
policy = self.engine._map_policy()
policy.keep_tickets = 1
self.engine.quest_policy.item_reserves["20009"] = 2
policy.item_reserves["20009"] = 2
self.engine._map_catalog().data["stage_info"]["m101"]["cost"]["items"] = [
{"typeId": "20009", "num": 1}, {"typeId": "20009", "num": 1}]
intent = {"kind": "map_battle", "stage_category": "mine", "battle_kind": "resource_stage",
"stage_id": "m101", "difficulty": "1", "task_id": 0}
self.assertIn("保留", self.engine.battles.resource_reason(self.snapshot, intent, policy, self.engine.policy))
self.snapshot.raw["items"][1]["usingNum"] = 0
self.assertEqual(self.engine.battles.resource_reason(self.snapshot, intent, policy, self.engine.policy), "")
@@ -0,0 +1,358 @@
import os
os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
import unittest
import json
import copy
import threading
from dataclasses import asdict
from dataclasses import replace
from unittest.mock import Mock, patch
from PySide6 import QtCore as C, QtWidgets as W
from PySide6.QtTest import QTest
from ranch_assistant.gui import Window
from ranch_assistant.native_widgets import IntegerInput
from ranch_assistant.model import Snapshot
from ranch_assistant.policy_io import import_config, portable_config
from ranch_assistant.sweeping import SweepPolicy
from ranch_assistant.tests.test_activities import scenario
from ranch_assistant.tests.test_core import workspace_temp
class ResourceStageGuiTests(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 Qt task did not finish")
def maps_ready(self, window):
self.wait(window)
for _ in range(500):
self.app.processEvents()
QTest.qWait(2)
if not window.map_render_timer.running:
return
self.fail("Map rendering did not finish")
def resource_fixture(self, window):
catalog, snapshot = scenario()
from ranch_assistant.maps import stages as build_stages
cached = build_stages(catalog, snapshot)
stages = []
for row in cached:
if row.stage_id == "bd00":
continue
stages.append(row)
stages.extend([
replace(cached[0], stage_id="m101", level="1", name="矿洞", category="mine", sweep=False),
replace(cached[0], stage_id="m101", level="2", name="矿洞", category="mine", sweep=False),
replace(cached[0], stage_id="t101", level="1", name="门票关", category="ticket", sweep=False),
replace(cached[0], stage_id="bd00", level="1", name="其他特殊关", category="special", sweep=False),
])
window.map_category.setCurrentIndex(window.map_category.findData("resource"))
cached_rows = object()
window.engine.snapshot = snapshot
window.engine.stage_cache.rows = cached_rows
window.engine.stage_cache.get = Mock(return_value=stages)
window.engine.map_stage_reason = Mock(return_value="资源不足:矿镐,单次需要 2,当前库存 1,保留 1")
for row in stages:
if row.category in ("mine", "ticket"):
row.battle_available = True
window.map_rules = {"m101": {"enabled": True, "level": "1", "limit": 4},
"t101": {"enabled": True, "level": "1", "limit": 2}}
return snapshot, cached_rows
def test_special_stages_require_separate_opt_in_and_ticket_reserve(self):
with workspace_temp() as folder:
window = Window(folder)
window.timer.stop()
try:
self.wait(window)
self.assertIsInstance(window.map_allow_special, W.QCheckBox)
self.assertIsInstance(window.map_keep_tickets, IntegerInput)
self.assertFalse(window.map_allow_special.isChecked())
self.assertEqual(window.map_keep_tickets.value(), 0)
self.assertEqual(window.tabs.tabText(window.tabs.indexOf(window.map_page)), "自动扫荡")
self.assertFalse(window.read_sweep_policy().allow_special)
self.assertEqual(window.read_sweep_policy().keep_tickets, 0)
finally:
window.close()
def test_special_policy_autosaves_and_survives_restart(self):
with workspace_temp() as folder:
window = Window(folder)
window.timer.stop()
try:
self.wait(window)
window.map_enabled.setChecked(True)
window.map_allow_special.setChecked(True)
window.map_keep_tickets.setValue(7)
window.pending_policy = {"sweep_policy": Mock()}
window.map_allow_special.setChecked(False)
self.assertFalse(window.engine.sweep_policy.allow_special)
self.assertFalse(window.pending_policy["sweep_policy"].allow_special)
window.map_allow_special.setChecked(True)
self.assertTrue(window.read_sweep_policy().allow_special)
self.assertEqual(window.read_sweep_policy().keep_tickets, 7)
QTest.qWait(350)
saved = json.loads((folder / "settings.json").read_text(encoding="utf-8"))["sweep_policy"]
self.assertTrue(saved["allow_special"])
self.assertEqual(saved["keep_tickets"], 7)
self.assertTrue(window.read_sweep_policy().allow_special)
self.assertEqual(window.read_sweep_policy().keep_tickets, 7)
finally:
window.close()
restored = Window(folder)
restored.timer.stop()
try:
self.wait(restored)
restored.show()
restored.tabs.setCurrentWidget(restored.map_page)
self.app.processEvents()
self.assertTrue(restored.map_enabled.isChecked())
self.assertTrue(restored.map_allow_special.isChecked())
self.assertTrue(restored.map_allow_special.isEnabled())
QTest.mouseClick(restored.map_allow_special, C.Qt.MouseButton.LeftButton, pos=restored.map_allow_special.rect().center())
self.assertFalse(restored.map_allow_special.isChecked())
self.assertFalse(restored.engine.sweep_policy.allow_special)
QTest.mouseClick(restored.map_allow_special, C.Qt.MouseButton.LeftButton, pos=restored.map_allow_special.rect().center())
self.assertTrue(restored.map_allow_special.isChecked())
self.assertEqual(restored.map_keep_tickets.value(), 7)
self.assertFalse(restored.strategy_toggle.isChecked())
finally:
restored.close()
def test_import_retains_resource_rules_while_execution_stays_stopped(self):
with workspace_temp() as folder:
window = Window(folder)
window.timer.stop()
try:
self.wait(window)
sweep = SweepPolicy(enabled=True, allow_special=True, keep_tickets=9,
rules={"m101": {"enabled": True, "level": "1", "limit": 2}})
source = window.config_value() | {"sweep_policy": sweep.__dict__}
path = folder / "policies.json"
path.write_text(json.dumps(portable_config(source)), encoding="utf-8")
window.set_strategy_checked(True)
window.engine.auto = True
with patch("ranch_assistant.gui.W.QFileDialog.getOpenFileName", return_value=(str(path), "")):
window.import_policies()
self.assertTrue(window.map_allow_special.isChecked())
self.assertEqual(window.map_keep_tickets.value(), 9)
self.assertEqual(window.map_rules["m101"], {"enabled": True, "level": "1", "limit": 2})
self.assertEqual(asdict(window.engine.sweep_policy), sweep.__dict__)
self.assertFalse(window.strategy_toggle.isChecked())
self.assertFalse(window.engine.auto)
finally:
window.close()
def test_full_catalog_keeps_ordinary_and_real_mine_rows_without_rebuilding_cache(self):
with workspace_temp() as folder:
window = Window(folder)
window.timer.stop()
try:
self.wait(window)
snapshot = window.engine.snapshot
snapshot.raw["history"].update(unlockStage={"0101": ["1"], "m101": ["1"], "m113": ["1"], "m125": ["1"]},
passStage={"0101": ["1"]})
cached_rows = window.engine.stage_cache.get(snapshot, refresh=True)
window.map_rules = {"0101": {"enabled": True, "level": "1", "limit": 3},
"m101": {"enabled": True, "level": "1", "limit": 2}}
with patch("ranch_assistant.stage_cache.stages", side_effect=AssertionError("Inventory render rebuilt map cache")), \
patch.object(window.engine, "map_stage_reason", return_value=""):
window.tabs.setCurrentWidget(window.map_page)
window.map_category.setCurrentIndex(window.map_category.findData("all"))
self.maps_ready(window)
self.assertIn("0101", window._map_items)
self.assertIn("m101", window._map_items)
for key, stamina in (("m101", 16), ("m113", 20), ("m125", 22)):
combo = window.maps_tree.itemWidget(window._map_items[key], 3)
self.assertEqual([combo.itemData(i) for i in range(combo.count())], ["1"])
self.assertIn(f"体力 单次 {stamina}", window._map_items[key].text(6))
window.map_category.setCurrentIndex(window.map_category.findData("ordinary"))
self.maps_ready(window)
self.assertIn("0101", window._map_items)
self.assertNotIn("m101", window._map_items)
window.map_category.setCurrentIndex(window.map_category.findData("resource"))
self.maps_ready(window)
self.assertIn("m101", window._map_items)
self.assertEqual(window.map_rules["m101"], {"enabled": True, "level": "1", "limit": 2})
self.assertEqual(window.map_rules["0101"], {"enabled": True, "level": "1", "limit": 3})
self.assertIs(window.engine.stage_cache.rows, cached_rows)
finally:
window.close()
def test_category_filter_preserves_rules_and_supported_mine_levels(self):
with workspace_temp() as folder:
window = Window(folder)
window.timer.stop()
try:
self.wait(window)
snapshot, cached_rows = self.resource_fixture(window)
window.tabs.setCurrentWidget(window.map_page)
window.map_category.setCurrentIndex(window.map_category.findData("ordinary"))
window.render_maps()
self.maps_ready(window)
self.assertIn("普通关卡", [window.map_category.itemText(i) for i in range(window.map_category.count())])
self.assertEqual(set(window._map_items), {"0101", "0102"})
window.engine.map_stage_reason.return_value = "资源自动入场未开启"
window.map_rules["m101"]["enabled"] = False
window.map_category.setCurrentIndex(window.map_category.findData("resource"))
window.map_keep_tickets.setValue(1)
self.maps_ready(window)
self.assertIn("m101", window._map_items)
self.assertIn("t101", window._map_items)
self.assertNotIn("bd00", window._map_items)
window.map_allow_special.setChecked(True)
self.maps_ready(window)
window._map_items["m101"].setCheckState(0, C.Qt.CheckState.Checked)
difficulty = window.maps_tree.itemWidget(window._map_items["m101"], 3)
self.assertEqual([difficulty.itemData(i) for i in range(difficulty.count())], ["1"])
self.assertEqual(window._map_items["m101"].text(5), "铜矿镐不足:单次需 1,可用 0,保留 1")
window.map_category.setCurrentIndex(window.map_category.findData("ordinary"))
self.maps_ready(window)
self.assertEqual(set(window._map_items), {"0101", "0102"})
self.assertEqual(window.map_rules["m101"], {"enabled": True, "level": "1", "limit": 4})
self.assertIs(window.engine.stage_cache.rows, cached_rows)
finally:
window.close()
def test_resource_challenge_preserves_model_result_and_never_claims_sweep(self):
with workspace_temp() as folder:
window = Window(folder)
window.timer.stop()
try:
self.wait(window)
snapshot, cached_rows = self.resource_fixture(window)
snapshot.raw["items"] = [{"id": 701, "typeId": "20009", "num": 10}]
window.map_allow_special.setChecked(True)
window.map_category.setCurrentIndex(window.map_category.findData("resource"))
window.map_rules["m101"]["enabled"] = False
for status in ("暂不支持:非上场目标;lockTarget", "实验近似:真实模型结果已保存,等待结算"):
with self.subTest(status=status):
window.engine.map_stage_reason.return_value = status
window.render_maps()
self.maps_ready(window)
self.assertEqual(window._map_items["m101"].text(5), status)
window.engine.map_stage_reason.return_value = ""
window.render_maps()
self.maps_ready(window)
self.assertEqual(window._map_items["m101"].text(5), "将按实际模拟结果挑战;不是扫荡")
self.assertIs(window.engine.stage_cache.rows, cached_rows)
finally:
window.close()
def test_legacy_gui_policy_defaults_to_resources_disabled(self):
with workspace_temp() as folder:
window = Window(folder)
window.timer.stop()
try:
self.wait(window)
sweep = window.config_value()["sweep_policy"]
sweep.pop("allow_special")
sweep.pop("keep_tickets")
window.load_config(window.config_value() | {"sweep_policy": sweep})
self.assertFalse(window.read_sweep_policy().allow_special)
self.assertEqual(window.read_sweep_policy().keep_tickets, 0)
finally:
window.close()
def test_disabling_special_access_is_immediate_while_worker_is_busy(self):
with workspace_temp() as folder:
window = Window(folder)
window.timer.stop()
release, entered = threading.Event(), threading.Event()
try:
self.wait(window)
window.map_enabled.setChecked(True)
window.map_allow_special.setChecked(True)
window.persist_settings()
def held_worker():
entered.set()
if not release.wait(4):
raise TimeoutError("test worker was not released")
window.run_job("held_worker", held_worker)
self.assertTrue(entered.wait(1))
window.map_keep_tickets.setValue(5)
window.persist_settings()
pending = window.pending_policy["sweep_policy"]
self.assertTrue(window.engine.sweep_policy.allow_special)
self.assertTrue(pending.allow_special)
with patch.object(window, "cancel_progression") as cancel:
window.map_allow_special.setChecked(False)
self.assertTrue(window.busy)
self.assertFalse(window.engine.sweep_policy.allow_special)
self.assertFalse(pending.allow_special)
cancel.assert_not_called()
release.set()
self.wait(window)
self.assertFalse(window.engine.sweep_policy.allow_special)
self.assertEqual(window.engine.sweep_policy.keep_tickets, 5)
finally:
release.set()
self.wait(window)
window.close()
def test_resource_cost_uses_aggregated_requirements_and_current_inventory(self):
with workspace_temp() as folder:
window = Window(folder)
window.timer.stop()
try:
self.wait(window)
snapshot, cached_rows = self.resource_fixture(window)
window.resource_catalog().data["stage_info"]["m101"] = {
"cost": {"ti": 10, "items": [{"typeId": "20009", "num": 1}, {"typeId": "20009", "num": 2}]},
"level": {"1": {"cost": 6, "battle_available": True}}}
window.resource_catalog().data["item_names"]["20009"] = "铜矿镐"
snapshot.raw["items"] = [{"id": 701, "typeId": "20009", "num": 4},
{"id": 702, "typeId": "20009", "num": 2, "usingNum": 1}]
window.map_enabled.setChecked(True)
window.map_allow_special.setChecked(True)
window.map_keep_tickets.setValue(1)
window.map_category.setCurrentIndex(window.map_category.findData("resource"))
self.maps_ready(window)
item = window._map_items["m101"]
self.assertIn("体力 单次 6 / 可用 100 / 保留 0", item.text(6))
self.assertIn("铜矿镐 单次 3 / 可用 5 / 保留 1", item.text(6))
snapshot.raw["items"][0]["num"] = 1
window.engine.snapshot = Snapshot(copy.deepcopy(snapshot.raw))
window.render_maps()
self.maps_ready(window)
self.assertIn("铜矿镐 单次 3 / 可用 2 / 保留 1", item.text(6))
self.assertIn("铜矿镐", item.text(5))
self.assertIn("单次需 3", item.text(5))
self.assertIn("可用 2", item.text(5))
self.assertIn("保留 1", item.text(5))
self.assertIs(window.engine.stage_cache.rows, cached_rows)
finally:
window.close()
class ResourceStagePolicyTests(unittest.TestCase):
def test_legacy_defaults_round_trip_and_invalid_resource_fields(self):
legacy = portable_config({})
del legacy["sweep_policy"]["allow_special"]
del legacy["sweep_policy"]["keep_tickets"]
imported = import_config(legacy)
self.assertFalse(imported["sweep_policy"]["allow_special"])
self.assertEqual(imported["sweep_policy"]["keep_tickets"], 0)
policy = SweepPolicy(allow_special=True, keep_tickets=7,
rules={"m101": {"enabled": True, "level": "1", "limit": 4}})
exported = portable_config({"sweep_policy": policy.__dict__})
self.assertEqual(import_config(exported)["sweep_policy"], policy.__dict__)
for field, invalid in (("allow_special", 1), ("keep_tickets", -1), ("keep_tickets", True)):
with self.subTest(field=field, invalid=invalid):
with self.assertRaises(ValueError):
import_config(exported | {"sweep_policy": exported["sweep_policy"] | {field: invalid}})
if __name__ == "__main__":
unittest.main()
@@ -14,6 +14,7 @@ from ranch_assistant.gui import Window
from ranch_assistant import presentation
from ranch_assistant.engine import demo_snapshot
from ranch_assistant.engine import Engine
from ranch_assistant.stage_cache import StageCache
from ranch_assistant.api import Client, Session, encode
from ranch_assistant.tests.test_activities import scenario
from ranch_assistant.tests.test_core import workspace_temp
@@ -200,8 +201,16 @@ class ResponsivenessTests(unittest.TestCase):
catalog, snapshot = scenario()
window.catalog = catalog
window.engine.catalog = catalog
window.engine.stage_cache = StageCache(catalog)
window.engine.snapshot = snapshot
window.render_maps()
self.wait(window)
for _ in range(400):
self.app.processEvents()
QTest.qWait(5)
if not window.map_render_timer.running:
break
self.assertFalse(window.map_render_timer.running)
original = window.maps_tree.topLevelItem(0).child(0)
edit = window.maps_tree.itemWidget(original, 8)
edit.setText("12")
@@ -125,6 +125,8 @@ class RuleEditingTests(unittest.TestCase):
catalog, snapshot = scenario()
window.catalog = catalog
window.engine.catalog = catalog
from ranch_assistant.stage_cache import StageCache
window.engine.stage_cache = StageCache(catalog)
window.engine.snapshot = snapshot
window.render_maps()
self.wait(lambda: not window.map_render_timer.running)
+49
View File
@@ -0,0 +1,49 @@
"""Build the small resource-stage index from already verified local static data."""
import argparse
import hashlib
import json
from pathlib import Path
import sys
ROOT = Path(__file__).resolve().parent.parent
sys.path.insert(0, str(ROOT))
from ranch_assistant.game_data import load_progression_data
from ranch_assistant.model import Catalog
from ranch_assistant.resource_stages import ORIGINAL_APK_SHA256
def build(output):
data = load_progression_data()
names = Catalog().data["item_names"]
mine = data.mines["mine1"]
mines = {str(obj["stageId"]) for layer in mine["layers"] for obj in layer.get("objs") or []
if obj.get("type") == "stage" and obj.get("stageId")}
sp_children = {str(obj["stageId"]) for key, sp in data.stage_sp.items()
if not sp.get("tag") and not data.stages.get(key, {}).get("special")
for obj in sp.get("stages") or [] if obj.get("stageId")}
ids = mines | {key for key in sp_children | set(data.stage_sp) if data.stages.get(key, {}).get("special")
and not data.stages[key].get("posmode") and (data.stages[key].get("cost") or {}).get("items")
and all("券" in names.get(str(item.get("typeId")), "") or "门票" in names.get(str(item.get("typeId")), "")
for item in data.stages[key]["cost"]["items"])}
ids |= {key for key, sp in data.stage_sp.items() if any(obj.get("stageId") in ids for obj in sp.get("stages") or [])}
needed = sorted({str(item["typeId"]) for key in ids for item in (data.stages.get(key, {}).get("cost") or {}).get("items", [])})
result = {"schema": 1, "apk_sha256": ORIGINAL_APK_SHA256,
"progression_sha256": hashlib.sha256((data.directory / "progression.json.gz").read_bytes()).hexdigest(),
"mine": mine,
"stage_info": {key: data.stages[key] for key in sorted(ids) if key in data.stages},
"stage_sp": data.stage_sp,
"item_names": {key: names.get(key, key) for key in needed},
"game_setting": {"cityInfo": data.game_setting.get("cityInfo", {})}}
output.parent.mkdir(parents=True, exist_ok=True)
output.write_text(json.dumps(result, ensure_ascii=False, separators=(",", ":")), encoding="utf-8")
return len(mines), len(ids)
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("--output", type=Path, default=ROOT / "ranch_assistant/data/resource_stages.json")
args = parser.parse_args()
print("Resource mines/stages:", *build(args.output))