Add automatic mining and ticket resource stages
This commit is contained in:
@@ -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自动战斗。
|
||||
|
||||
地图与可能掉落来自客户端静态配置,实际奖励以服务器响应为准;统计概率为本账号已确认样本的实测值。
|
||||
“每点体力数量”按已知消耗样本的物品总量除以实际扣除体力计算,未知消耗不参与。
|
||||
|
||||
@@ -74,6 +74,7 @@
|
||||
首次读取后按账号/角色保存本地地图缓存,重启、切换页面或普通监控刷新均复用缓存,仅“刷新关卡”(或本页右键刷新)更新列表。
|
||||
每关可勾选、选择已解锁难度和本日上限;满足游戏原有条件的普通关卡可接口扫荡,
|
||||
“未满星时自动挑战”默认开启,勾选已解锁普通关卡后可模拟首次挑战;符合三个难度全部通关条件后使用扫荡。打不过会暂停同一队伍的重复尝试,换队或提升属性后再试;未支持的规则显示中文原因。
|
||||
分类筛选支持普通、矿洞与门票、全部。矿洞/门票关需明确启用默认关闭的“允许矿洞 / 门票关卡”并逐关勾选,且只可选原入口难度1;残留的2/3级占位不会作为低价入口。每项显示体力及所有入场工具的单次需求、当前可用库存和保留量;库存按最新角色快照更新,地图解锁仍复用缓存。资源关按实际模拟结果挑战,不能当作普通扫荡,也不代表全部特殊关可运行。
|
||||
- 战斗记录:按上下文筛选普通地图、主线、任务与委托战斗、扫荡和地图奖励事件;实验模型结果标明“实验近似”,未知结果保留待核对原因。
|
||||
- 扫荡奖励:普通扫荡读取 `battleEnd.reward`,奖励事件读取 `stageEvent.result`,日志列出本次实际获得的物品、魔物蛋、金币和经验。
|
||||
- 数据分析:紧邻“自动扫荡”的独立页签。左侧按地区选择关卡和难度,右侧显示条形图与掉落明细;关卡和可能掉落来自本地静态配置。
|
||||
@@ -307,7 +308,7 @@
|
||||
在“自动扫荡”展开地区,每关勾选“刷图”、选择已解锁的难度、输入“本日上限”,勾选该页功能,再开启顶部策略开关。需要挑战未通关普通关卡时保留“未满星时自动挑战”勾选;关闭后只执行符合条件的扫荡,无需开启自动主线。
|
||||
|
||||
挑战沿用原始属性和内置模拟,等待计算出的战斗时长后按普通关卡流程结算,战果与奖励在“战斗记录”查看。实际战败显示“打不过”,本日内相同阵容及属性不会反复尝试该难度;更换战队、升级或属性变化后允许再试。每日次数与扫荡共用,开战前占用次数,确定未发送的取消会退回次数;未知回包不重复请求。暂停或重启后可续交已完成并保存的模型结果,保持原始开战和每日计数。地图列表保存在本地,普通轮询不重建;挑战已确认结束后同步账号实际通关进度。
|
||||
星级是服务器通关进度计算出来的,只读。未解锁难度不能选;特殊关卡、未全通关、剧情任务、
|
||||
星级是服务器通关进度计算出来的,只读。未解锁难度不能选;其他特殊关卡、未全通关、剧情任务、
|
||||
体力/金币/门票不足的关卡会显示原因并跳过。次数按角色、日期、关卡和难度保存,
|
||||
是本地已开始次数,不冒充服务器每日限制。
|
||||
一次扫荡内部的几个请求顺序执行,完成后重读账号状态;开启其他策略时与孵蛋/委托逐轮串行。
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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"):
|
||||
diagnostic("unit_objective", "Protected/destroy objective units are unsupported", blocking=True)
|
||||
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")
|
||||
|
||||
|
||||
|
||||
@@ -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
@@ -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
|
||||
|
||||
@@ -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
@@ -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
|
||||
|
||||
@@ -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,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
|
||||
|
||||
@@ -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:
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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))
|
||||
Reference in New Issue
Block a user