Files
myrzx_bot/ranch_web/views.py
T

771 lines
60 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""Plain-data desktop parity views. Called only on an account worker thread."""
from __future__ import annotations
from collections import Counter
from copy import deepcopy
from dataclasses import asdict
from datetime import datetime, timedelta, timezone
from ranch_assistant.model import EggRule, duration, seconds
from ranch_assistant.maps import reward_summary
from ranch_assistant.daily import entries
from ranch_assistant.drop_statistics import analyze
from ranch_assistant.presentation import monster_rows
from ranch_assistant.battle_messages import battle_message
from ranch_assistant.resource_stages import available_item_count, item_requirements, with_resource_data
from .policies import default_config, validate_config
PAGES = [
("login", "登录"), ("incubator", "培育室"), ("bag", "背包"), ("ranch", "牧场"),
("daily", "每日事务"), ("hatching", "自动孵蛋"), ("mainline", "自动主线"),
("battles", "战斗记录"), ("gifts", "自动赠礼"), ("commissions", "自动委托"),
("exploration", "自动探险"), ("maps", "自动扫荡"), ("statistics", "数据分析"),
("plans", "执行计划"), ("yields", "收益资料"),
]
ITEM_TYPES = {0: "全部物品", 6: "魔物蛋", 1: "可使用", 2: "消耗品", 3: "材料", 4: "其他", 5: "装备"}
BAG_CATEGORIES = [("eggs", "魔物蛋"), ("usable", "可使用"), ("consumables", "消耗品"),
("materials", "材料"), ("other", "其他"), ("equipment", "装备")]
def _options(pairs):
return [{"value": value, "label": label} for value, label in pairs]
def _field(path, label, kind="boolean", **extra):
return {"path": list(path), "label": label, "type": kind, **extra}
def _policy_field(key, label, kind="boolean", **extra):
return _field(["policy", key], label, kind, **extra)
def _strategy_fields(catalog):
"""Only controls retained by the current GUI; legacy Policy fields stay hidden."""
markets = _options([(key, row.get("name", key) + "市场") for key, row in catalog.data.get("markets", {}).items()])
team_options = _options([(key, key) for key in ("teamA", "teamB", "teamC")])
hatch = [_policy_field(key, label, group="孵蛋策略") for key, label in (
("enabled", "启用培育室自动管理"), ("buy", "自动从金币市场购蛋 / 抽蛋"),
("allow_single_draw", "允许单抽"), ("buy_ten", "优先十连"), ("fill", "自动填充空坑位"),
("dispatch", "成熟后按策略自动派遣"), ("collect", "自动收取到牧场"))]
hatch += [_policy_field("market_id", "新增规则默认市场", "select", options=markets, group="孵蛋策略")]
hatch += [_policy_field(key, label, "integer", min=low, max=high, group="孵蛋策略") for key, label, low, high in (
("buy_batch", "单抽时每批上限", 1, 100), ("keep_money", "至少保留金币", 0, 1_000_000_000),
("daily_buy_money", "每日购蛋金币额度(0=不购买)", 0, 1_000_000_000))]
hatch += [_policy_field("protect_star", "保留此星级及以上", "integer", min=1, max=6, group="牧场策略"),
_policy_field("protect_quality", "资质保留条件", "select", group="牧场策略", options=_options([
(4, "S及以上"), (3, "A及以上"), (2, "B及以上"), (1, "全部资质"), (5, "不按资质保留"), (6, "四项全S(4S)才保留")])),
_policy_field("keep_better_quality", "保留资质高于牧场同种培养代表的新魔物", group="牧场策略"),
_policy_field("room_id", "收取到牧场", "select", options=_options([(0, "自动选择有空位的牧场")]), group="牧场策略"),
_policy_field("reserved_types", "额外保留魔物编号", "id_list", group="牧场策略"),
_policy_field("reserved_eggs", "保留蛋数量", "id_counts", group="牧场策略"),
_policy_field("feed", "按策略喂养选定目标(受当前突破上限限制)", group="喂养策略")]
gift = [_policy_field(key, label) for key, label in (
("gift_enabled", "启用自动赠礼"), ("gift_auto_representative", "每种魔物只培养一只,自动选择培养代表"),
("gift_liked_only", "仅赠送目标喜欢的物品"))]
quest = [_field(["quest_policy", key], label) for key, label in (
("enabled", "启用委托自动接取 / 推进 / 领奖"), ("accept", "按氪金奖励优先接取(20 → 15 → 10)"), ("allow_items", "允许提交道具(遵守保留数量)"),
("allow_monsters", "允许提交1级魔物(遵守锁定、星级和资质保留)"), ("battle_tasks", "也接取需要实战的委托"))]
quest += [_field(["quest_policy", "city"], "城市编号(0=所有已解锁城市)", "integer", min=0, max=99),
_field(["quest_policy", "max_money"], "单次最多提交金币", "integer", min=0, max=10_000_000),
_field(["quest_policy", "item_reserves"], "保留道具", "id_counts")]
progression_labels = [("enabled", "启用自动主线策略"), ("mainline", "主线"), ("sidequests", "支线"),
("commissions", "委托(仅诊断)"), ("accept", "接取已确认的任务"), ("auto_dialogue", "自动推进已支持的对话"),
("repair_chain", "补全已确认的任务链"), ("allow_items", "允许提交物品"), ("allow_monsters", "允许提交魔物"),
("allow_sweep", "允许用扫荡完成已通关目标"), ("auto_farm", "自动收集任务材料 / 击杀目标")]
progression = [_field(["progression_policy", key], label) for key, label in progression_labels]
progression += [_field(["progression_policy", "team"], "推进战斗队伍", "select", options=team_options)]
progression += [_field(["progression_policy", key], label, "integer", min=low, max=high) for key, label, low, high in (
("reserve_ti", "保留体力", 0, 1_000_000_000), ("max_money", "单次交付金币上限(0=不交金币)", 0, 1_000_000_000),
("stop_after_loss", "连续失败后停止次数", 1, 999))]
progression += [_field(["progression_policy", "item_reserves"], "交付后至少保留物品", "id_counts")]
maps = [_field(["sweep_policy", key], label) for key, label in (
("enabled", "启用勾选关卡自动刷图"), ("allow_challenge", "未满星时自动挑战"), ("allow_special", "允许矿洞 / 门票关卡"))]
maps += [_field(["sweep_policy", "team"], "使用战队", "select", options=team_options)]
maps += [_field(["sweep_policy", key], label, "integer", min=0, max=1_000_000_000) for key, label in (
("keep_stamina", "保留体力"), ("keep_tickets", "每种门票 / 工具保留"))]
return {"hatching": hatch, "gifts": gift, "commissions": quest, "mainline": progression, "maps": maps,
"daily": [_field(["daily_policy", "enabled"], "启用每日奖励领取"),
_field(["daily_policy", "selected"], "领取项目", "multiselect", options=_options([
("gift", "每日签到礼包"), ("check", "七日签到"), ("loop", "累计奖励"), ("vip", "VIP日奖"), ("mail", "邮件附件")]))],
"exploration": [_field(["explore_policy", "enabled"], "自动安排再次探险(完成后自动领奖)"),
_field(["explore_policy", "reserve_ti"], "保留体力", "integer", min=0, max=1_000_000_000)],
"yields": [_field(["yield_stars"], "星级", "multiselect", options=_options([(i, f"{i}星") for i in range(1, 6)]))],
"login": [], "incubator": [], "bag": [], "ranch": [], "battles": [], "statistics": [], "plans": []}
def schema(catalog):
fields = _strategy_fields(catalog)
return {"version": 1, "pages": [{"key": key, "title": title, "form": fields[key]} for key, title in PAGES],
"settings": [_field(["interval"], "随机刷新间隔", "select", options=_options([
(30, "0~30秒"), (60, "0~60秒"), (120, "0~120秒"), (300, "0~300秒")])),
_field(["log_visible"], "显示日志"), _field(["log_sizes"], "页面 / 日志高度", "sizes")],
"defaults": default_config()}
def _value(config, path):
value = config
for key in path:
value = value[key]
return deepcopy(value)
def _column(key, label, kind=None, edit=None):
return {"key": key, "label": label, **({"type": kind} if kind else {}), **({"edit": edit} if edit else {})}
def build_view(engine, page, config, query=None):
if page not in dict(PAGES):
raise ValueError("未知页面")
config = validate_config(config)
fields = _strategy_fields(engine.catalog)[page]
dto = {"page": page, "title": dict(PAGES)[page], "columns": [], "rows": [], "summary": "",
"form": [field | {"value": _value(config, field["path"])} for field in fields],
"filters": [], "details": {}, "actions": [{"operation": "refresh", "label": "刷新本页", "payload": {"page": page}}]}
builder = _BUILDERS.get(page)
if engine.snapshot is None and page not in ("login", "yields", "statistics"):
dto["summary"] = "请先登录或打开离线演示"
return dto
if builder is not None:
builder(dto, engine, config, query or {})
elif engine.snapshot is None:
dto["summary"] = "请先登录或打开离线演示"
return dto
_BUILDERS = {}
def _filter(key, label, value, pairs=None, kind="select"):
return {"key": key, "label": label, "type": kind, "value": value,
**({"options": _options(pairs)} if pairs is not None else {})}
def _search(dto, query):
search = str(query.get("search", "")).strip().casefold()
dto["filters"].append(_filter("search", "搜索", query.get("search", ""), kind="text"))
return search
def _boolean(value, default=False):
return value if type(value) is bool else str(value).lower() in ("true", "1", "yes") if value is not None else default
def _edit(path, kind, **extra):
return {"path": list(path), "type": kind, **extra}
def _row_column(key, label, section, *, kind="integer", **extra):
return _column(key, label, kind, _edit([*section, "{id}", key], kind, **extra))
def _login(dto, engine, config, query):
dto["columns"] = [_column("name", "服务器"), _column("role_name", "角色")]
dto["summary"] = "离线演示,无游戏网络连接" if engine.demo else "请在此账号登录或恢复已保存的角色"
# Runtime adds only public saved-session/server metadata via login_view().
dto["servers"], dto["saved_sessions"], dto["has_saved_password"] = [], [], False
dto["actions"] = [{"operation": "login", "label": "账号密码登录"},
{"operation": "restore_session", "label": "恢复保存角色"},
{"operation": "logout", "label": "退出当前角色"},
{"operation": "forget_login", "label": "忘记登录信息"}]
def _plans(engine):
# Only kind and description are public. Action paths/payloads may contain
# instance IDs, protocol evidence or non-JSON progression intents.
return [{"id": str(i), "kind": action.kind, "description": action.description}
for i, action in enumerate(engine.plans())]
def _incubator(dto, engine, config, query):
snapshot, catalog = engine.snapshot, engine.catalog
dto["columns"] = [_column(k, label) for k, label in (
("position_label", "坑位"), ("stack_id", "坑位ID"), ("status", "开启状态"), ("name", "魔物"),
("star", "星"), ("phase", "阶段"), ("remaining_text", "剩余时间"), ("quality", "资质 攻/防/血/敏"), ("decision", "策略预览"))]
opened = {int(row.get("position", -1)): row for row in snapshot.raw["stacks"]}
total = max(int(catalog.data.get("stack_meta", {}).get("total", 0)), max(opened, default=-1) + 1)
vip = seconds((snapshot.raw.get("activityHistory", {}).get("vipInfo") or {}).get("vipTime")) > snapshot.now
engine.plans() # Refresh core disposition/status calculations without executing.
for position in range(total):
slot = opened.get(position)
mon = snapshot.monsters.get(int(slot.get("monsterId") or 0)) if slot else None
info = catalog.monster(mon.get("typeId")) if mon else {}
remaining = snapshot.remaining(mon, catalog) if mon else None
dto["rows"].append({"id": str(position), "position": position, "position_label": position + 1,
"stack_id": slot.get("id", "") if slot else "", "opened": bool(slot), "vip": position == 3,
"status": ("VIP已激活" if vip else "VIP未激活") if slot and position == 3 else "已开启" if slot else "VIP专用" if position == 3 else "未开启",
"name": info.get("name", "未知") if mon else "空位" if slot else "", "star": info.get("star", ""),
"monster_id": int(mon["id"]) if mon else None, "phase": snapshot.phase_text(mon, catalog) if mon else "",
"remaining": remaining, "remaining_text": duration(remaining) if mon else "", "quality": catalog.quality_text(mon) if mon else "",
"decision": engine.planner.statuses.get(int(mon["id"]), "等待成长 / 预览规则") if mon else "",
"can_expand": slot is None and position != 3})
dto["summary"] = f"已开启 {len(opened)} / {total} 个坑位;第4坑为VIP专用({'已激活' if vip else '未激活'})"
dto["actions"] += [{"operation": "quote_expansion", "label": "开启选中普通坑位", "selection": "position",
"payload": {"kind": "stack"}, "currencies": _options([("money", "金币"), ("ke", "氪金")])}]
def _default_egg_rule(catalog, type_id, preferred_market):
markets = catalog.markets_for(type_id)
market = preferred_market if preferred_market in markets else markets[0] if markets else ""
return asdict(EggRule(market_id=market))
def _egg_rows(dto, engine, config, query):
catalog, snapshot = engine.catalog, engine.snapshot
groups = {}
for egg in snapshot.eggs(catalog):
key = str(egg["typeId"])
group = groups.setdefault(key, {"count": 0, "inventory_ids": []})
group["count"] += int(egg.get("num") or 0)
group["inventory_ids"].append(int(egg["id"]))
rules = config["policy"]["egg_rules"]
search = str(query.get("search", "")).strip().casefold()
dto["columns"] = [_column(k, label) for k, label in (("name", "魔物蛋"), ("star", "星"), ("count", "数量"))]
for key, label, kind, extra in (
("enabled", "孵化", "boolean", {}), ("priority", "优先级", "integer", {"min": 1, "max": 999}),
("action", "孵出后", "select", {"options": _options([("sell", "派遣"), ("feed", "喂养"), ("keep", "保留")])}),
("refill_below", "低于补货", "integer", {"min": 0, "max": 1000}),
("refill_target", "补至", "integer", {"min": 1, "max": 1000}), ("market_id", "补货市场", "select", {})):
dto["columns"].append(_row_column(key, label, ["policy", "egg_rules"], kind=kind, **extra))
dto["columns"] += [_column(k, label) for k, label in (
("time_text", "培育时间"), ("sell_money", "派遣金币"), ("sell_exp", "基础经验"),
("gold_per_hour", "金币/小时"), ("exp_per_hour", "经验/小时"), ("inventory_text", "物品ID"))]
dto["columns"].append(_row_column("keep_count", "牧场保留", ["policy", "egg_rules"], min=0, max=1000,
help="已启用规则跨牧场至少保留此数量;0不保留名额,硬保护仍有效"))
for key in dict.fromkeys([*groups, *rules]):
info = catalog.monster(key)
if not info or search and search not in (key + str(info.get("name", ""))).casefold():
continue
markets = catalog.markets_for(key)
defaults = _default_egg_rule(catalog, key, config["policy"]["market_id"])
rule = defaults | rules.get(key, {})
total = max(1, catalog.total_time(key))
money, exp = info.get("sell_money", 0), info.get("sell_exp", 0)
options = _options([(market, catalog.data["markets"][market]["name"] + "市场") for market in markets])
dto["rows"].append({"id": key, "type_id": key, "name": info.get("name", key), "star": info.get("star", "?"),
**groups.get(key, {"count": 0, "inventory_ids": []}), **rule, "time_total": total, "time_text": duration(total),
"sell_money": money, "sell_exp": exp, "gold_per_hour": round(money * 3600 / total, 2), "exp_per_hour": round(exp * 3600 / total, 2),
"inventory_text": ", ".join(map(str, groups.get(key, {}).get("inventory_ids", []))),
"rule_defaults": defaults, "rule_path": ["policy", "egg_rules", key],
"edits": {"market_id": _edit(["policy", "egg_rules", key, "market_id"], "select", options=options or _options([("", "金币市场无此蛋")]))}})
dto["summary"] = f"{len(dto['rows'])} 种魔物蛋规则;已启用 {sum(row['enabled'] for row in dto['rows'])} 种"
dto["form"].append(_field(["policy", "egg_rules"], "添加魔物蛋规则", "add_rule", value=None,
options=_options([(key, row.get("name", key)) for key, row in catalog.monsters.items()]), defaults=asdict(EggRule()),
defaults_by_id={key: _default_egg_rule(catalog, key, config["policy"]["market_id"]) for key in catalog.monsters},
help="可配置背包当前没有的蛋;按孵化优先级、去向、补货和牧场保留规则自动执行"))
def _bag(dto, engine, config, query):
category = str(query.get("category", "eggs"))
if category not in dict(BAG_CATEGORIES) and category != "all":
raise ValueError("背包分类无效")
dto["filters"].append(_filter("category", "背包分类", category, BAG_CATEGORIES))
search = _search(dto, query)
if category == "eggs":
_egg_rows(dto, engine, config, query)
return
category_code = {"all": 0, "usable": 1, "consumables": 2, "materials": 3, "other": 4, "equipment": 5}[category]
catalog = engine.catalog
groups = {}
for item in engine.snapshot.raw["items"]:
key = str(item.get("typeId"))
if int(item.get("num") or 0) <= 0 or category_code and catalog.item_type(key) != category_code:
continue
if search and search not in (key + catalog.item_name(key)).casefold():
continue
group = groups.setdefault(key, {"count": 0, "inventory_ids": []})
group["count"] += int(item["num"])
group["inventory_ids"].append(int(item["id"]))
dto["columns"] = [_column(k, label) for k, label in (("inventory_text", "物品ID"), ("name", "名称"), ("category", "分类"),
("quality", "品质"), ("count", "数量"), ("sell_money", "售价"))]
dto["columns"] += [_row_column("enabled", "允许赠礼", ["policy", "gift_items"], kind="boolean"),
_row_column("reserve", "至少保留", ["policy", "gift_items"], min=0, max=1_000_000_000)]
for key, group in groups.items():
info = catalog.item(key)
code = catalog.item_type(key)
eligible = code not in (5, 6) and bool(info.get("sellable"))
rule = {"enabled": False, "reserve": 0} | config["policy"]["gift_items"].get(key, {})
dto["rows"].append({"id": key, "type_id": key, "name": catalog.item_name(key), "category": ITEM_TYPES.get(code, "其他"),
"quality": info.get("quality", ""), **group, "inventory_text": ", ".join(map(str, group["inventory_ids"])),
"sell_money": info.get("sellMoney", ""), **rule, "gift_eligible": eligible,
"rule_defaults": {"enabled": False, "reserve": 0}, "rule_path": ["policy", "gift_items", key],
"edits": {field: _edit(["policy", "gift_items", key, field], kind, disabled=not eligible,
reason="此类物品不进入自动赠礼" if not eligible else "") for field, kind in (("enabled", "boolean"), ("reserve", "integer"))}})
dto["summary"] = f"{len(groups)} 类物品 / {sum(row['count'] for row in groups.values())} 件;同种库存合并显示"
def _ranch(dto, engine, config, query):
snapshot, catalog = engine.snapshot, engine.catalog
grouped = _boolean(query.get("grouped"), False)
try:
room_id = int(query.get("room_id") or 0)
except (ValueError, TypeError) as exc:
raise ValueError("牧场编号无效") from exc
dto["filters"] = [_filter("grouped", "按牧场分组", grouped, kind="boolean"),
_filter("room_id", "牧场", room_id, [(0, "全部牧场")] + [(int(room["id"]), f"{room.get('name') or '牧场'} #{room['id']}") for room in snapshot.raw["rooms"]])]
search = _search(dto, query)
keys = ["monster_id", "name", "star", "level_text", "quality", "location", "locked", "scope",
"feed_selected", "feed_priority", "potential_level", "attack", "defense", "health", "dexterity", "feel_text", "likes",
"gift_selected", "gift_priority", "breakthrough_selected", "breakthrough_priority", "tp_level_text", "tp_exp_text"]
labels = ["牧场 / 魔物ID", "名称", "星", "等级 / 当前上限", "资质 攻/防/血/敏", "位置", "锁定", "管理范围",
"喂养目标", "喂养优先级", "潜能阶段", "参考攻击", "参考防御", "参考生命", "参考敏捷", "好感 / 当前上限", "喜欢的物品",
"赠礼", "赠礼优先级", "自动突破目标", "突破优先级", "同种突破", "突破经验"]
dto["columns"] = [_column(key, label) for key, label in zip(keys, labels)]
for prefix, mapping in (("feed", "feed_targets"), ("gift", "gift_targets"), ("breakthrough", "breakthrough_targets")):
for column in dto["columns"]:
if column["key"] == prefix + "_selected":
column.update(type="boolean", edit=_edit(["policy", mapping, "{id}"], "target", default=100, unchecked="delete"))
elif column["key"] == prefix + "_priority":
column.update(type="integer", edit=_edit(["policy", mapping, "{id}"], "integer", min=1, max=999, optional=True))
managed = engine.planner.managed
rows = monster_rows(catalog, snapshot, managed)
counts = Counter("incubator" if mon.get("process") == 2 else f"room:{int(mon.get('roomId') or 0)}" for mon in snapshot.raw["monsters"])
dto["groups"] = []
if grouped:
for room in snapshot.raw["rooms"]:
rid = int(room["id"])
if room_id and rid != room_id:
continue
info = catalog.data.get("room_info", {}).get(str(room.get("typeId")), {})
group_key = f"room:{rid}"
capacity = info.get("maxNum")
dto["groups"].append({"id": group_key, "label": f"{room.get('name') or info.get('name') or '牧场'} #{rid}",
"count": counts[group_key], "capacity": capacity, "free": max(0, int(capacity) - counts[group_key]) if capacity is not None else None, "collapsed": False})
for mon, values in zip(snapshot.raw["monsters"], rows):
if room_id and (mon.get("process") != 3 or int(mon.get("roomId") or 0) != room_id):
continue
if search and search not in " ".join(map(str, values)).casefold():
continue
key = str(int(mon["id"]))
row = dict(zip(keys, values)) | {"id": key, "type_id": str(mon["typeId"]), "level": int(mon.get("level") or 1), "max_level": catalog.max_level(mon),
"process": mon.get("process"), "room_id": int(mon.get("roomId") or 0), "group": "incubator" if mon.get("process") == 2 else f"room:{int(mon.get('roomId') or 0)}", "edits": {}}
for prefix, mapping in (("feed", "feed_targets"), ("gift", "gift_targets"), ("breakthrough", "breakthrough_targets")):
targets = config["policy"][mapping]
selected = key in targets
row[prefix + "_selected"], row[prefix + "_priority"] = selected, targets.get(key, 100)
row["edits"][prefix + "_selected"] = _edit(["policy", mapping, key], "target", default=100, unchecked="delete", disabled=mon.get("process") != 3)
row["edits"][prefix + "_priority"] = _edit(["policy", mapping, key], "integer", min=1, max=999, optional=True, disabled=not selected or mon.get("process") != 3)
dto["rows"].append(row)
dto["details"][key] = {"name": row["name"], "species": catalog.monster(mon["typeId"]).get("name", "未知"), "id": int(mon["id"]),
"level": row["level_text"], "quality": row["quality"], "reference_stats": catalog.reference_stats(mon),
"growth": {name: mon.get("g" + name.capitalize()) for name in ("atk", "def", "hp", "dex")},
"likes": row["likes"], "feel": row["feel_text"], "feed_exp": catalog.feed_exp(mon), "scope": row["scope"]}
if grouped:
known = {group["id"] for group in dto["groups"]}
for row in dto["rows"]:
if row["group"] not in known:
known.add(row["group"])
dto["groups"].append({"id": row["group"], "label": "培育室" if row["group"] == "incubator" else "未归属牧场", "count": counts[row["group"]], "collapsed": False})
dto["summary"] = f"{len(snapshot.raw['rooms'])} 座牧场;显示 {len(dto['rows'])} 只魔物;勾选目标按较小优先级先执行"
targets = [{"value": int(mon["id"]), "label": f"{catalog.monster_label(mon)} Lv.{mon.get('level', 1)}/{catalog.max_level(mon)}"}
for mon in snapshot.raw["monsters"] if mon.get("process") == 3 and catalog.max_level(mon) is not None and int(mon.get("level", 1)) < catalog.max_level(mon)]
dto["feed_targets"] = targets
dto["actions"] += [{"operation": operation, "label": label, "selection": "monster_ids", **extra} for operation, label, extra in (
("lock", "锁定选中魔物", {}), ("unlock", "解锁选中魔物", {}),
("sell", "派遣选中魔物", {"confirm": "将消耗选中魔物,无法撤销"}),
("feed", "喂给指定魔物", {"confirm": "将消耗选中魔物作为经验素材,无法撤销", "target_options": targets}))]
dto["actions"].append({"operation": "quote_expansion", "label": "新建牧场", "payload": {"kind": "room"},
"currencies": _options([("money", "金币"), ("ke", "氪金")])})
def _daily(dto, engine, config, query):
dto["columns"] = [_column(k, label) for k, label in (("name", "项目 / 邮件"), ("status", "状态"), ("reward", "奖励 / 附件"))]
for row in entries(engine.catalog, engine.snapshot, engine.daily_ledger):
dto["rows"].append({"id": row.key, "name": row.name, "status": row.status, "reward": row.reward, "claimable": row.action is not None})
dto["summary"] = "刷新只更新状态;领取勾选项目立即处理可领奖励;自动领取需要开启顶部策略"
dto["actions"].append({"operation": "claim_daily", "label": "领取勾选项目", "payload": {}})
def _hatching(dto, engine, config, query):
for field in dto["form"]:
if field["path"] == ["policy", "room_id"]:
field["options"] += _options([(int(room["id"]), f"{room.get('name') or '牧场'} #{room['id']}") for room in engine.snapshot.raw["rooms"]])
dto["tabs"] = [{"key": label, "title": label} for label in ("孵蛋策略", "牧场策略", "喂养策略")]
dto["columns"] = [_column("kind", "类型"), _column("description", "下一步 / 等待条件")]
dto["rows"] = _plans(engine)
policy = engine.policy
dto["summary"] = "先在背包魔物蛋配置规则,再开启顶部策略;空坑按优先级随机1~2秒装填"
dto["details"] = {"feed_status": engine.planner.feed_status(engine.snapshot, policy),
"last_draw": engine.last_draw or "尚无记录", "notes": list(dict.fromkeys(engine.planner.notes)),
"preset": {"label": "绿色史莱姆金币预设(仅孵此蛋)", "patch": {
"policy": {"enabled": True, "buy": True, "fill": True, "dispatch": True, "collect": True, "buy_ten": True,
"allow_single_draw": False, "feed": False, "strategy": "gold", "market_id": "sc_city1", "egg_order": "shortest",
"protect_quality": 3, "protect_star": 4, "hatch_max_star": 3, "min_gold_per_hour": 0, "min_exp_per_hour": 0}},
"egg_rules": {key: rule | {"enabled": False} for key, rule in config["policy"]["egg_rules"].items()} | {
"1001010": asdict(EggRule(enabled=True, priority=1, action="sell", refill_below=1, refill_target=10, market_id="sc_city1"))},
"help": "只更改策略并保存;开启顶部策略后运行"}}
def _gifts(dto, engine, config, query):
catalog, snapshot = engine.catalog, engine.snapshot
dto["columns"] = [_column(k, label) for k, label in (("species", "魔物种类"), ("monster_id", "培养对象 ID"),
("level", "等级"), ("feel_text", "好感 / 上限"), ("quality", "资质 攻/防/血/敏"), ("likes", "喜欢的物品"), ("cooldown", "赠礼冷却"))]
representatives = engine.cultivation.select(snapshot) if engine.policy.gift_auto_representative else {}
candidates = list(representatives.values()) if representatives else engine.gift_planner.candidates(snapshot, engine.policy)
cooldown = int(catalog.data["game_setting"].get("monGiftTime", 7200))
for mon in candidates:
remaining = max(0, seconds(mon.get("giftTime")) + cooldown - snapshot.now)
dto["rows"].append({"id": str(mon["id"]), "species": catalog.monster(mon["typeId"]).get("name", "未知"),
"monster_id": int(mon["id"]), "level": mon.get("level", 1), "feel_text": f"{mon.get('feel', 0)} / {catalog.max_feel(mon)}",
"quality": catalog.quality_text(mon), "likes": catalog.likes_text(mon["typeId"]), "remaining": remaining,
"cooldown": duration(remaining) if remaining else "可赠礼"})
engine.gift_planner.plan(snapshot, engine.policy, engine.quest_policy)
dto["summary"] = "自动代表按等级 → 好感 → 综合成长资质选择并记住;满好感或冷却时不换喂同种另一只"
dto["details"] = {"notes": list(engine.gift_planner.notes), "next_ready_at": engine.gift_planner.next_ready_at,
"inventory_page": "bag", "targets_page": "ranch"}
CATEGORIES = {"mainline": "主线", "sidequest": "支线", "commission": "委托", "event": "活动(暂不自动)", "bond": "羁绊(暂不自动)", "unknown": "其他 / 未知"}
BATTLE_KINDS = {"mainline": "主线战斗", "sidequest": "支线战斗", "commission": "委托战斗", "battle": "普通战斗", "map_battle": "地图战斗",
"sweep": "扫荡", "map_reward_event": "地图奖励事件", "ordinary_stage": "普通关卡战斗", "resource_stage": "资源关卡战斗", "task_battle": "任务战斗", "task_pass_stage": "任务通关战斗", "unknown": "其他 / 未知"}
BATTLE_ALIASES = {"task": "task_battle", "passStage": "task_pass_stage", "event": "map_reward_event", "reward_event": "map_reward_event", "normal": "battle"}
STATES = {"available": "可接取", "unaccepted": "未接取", "active": "进行中", "in_progress": "进行中", "ready": "待交付", "completed": "已完成", "complete": "已完成",
"claimed": "已领奖", "received": "进行中", "unlocked": "已解锁 / 待接取", "offered": "待接取", "locked": "未解锁", "finished": "已完成", "ready_to_reward": "待领取任务奖励",
"blocked": "受阻", "unsupported": "暂不支持", "unknown": "未知"}
STATE_ALIASES = {"active": "received", "in_progress": "received", "available": "unlocked", "unaccepted": "unlocked", "offered": "unlocked", "ready": "ready_to_reward",
"completed": "finished", "complete": "finished", "claimed": "finished", "blocked": "received"}
STATE_FILTERS = [("current", "当前(进行中 + 待接取 + 待领奖)"), ("received", "进行中"), ("unlocked", "待接取"), ("ready_to_reward", "待领奖"), ("finished", "已完成"), ("locked", "未解锁"), ("", "全部状态")]
OUTCOMES = {"win": "胜利", "loss": "打不过", "unsupported": "暂不支持", "event": "地图奖励事件", "completed": "已完成", "cancelled": "已取消", "timeout": "超时", "unknown": "结果待核对"}
CHINA_TIME = timezone(timedelta(hours=8))
def _text(value, empty="—"):
# Display only scalars. Arbitrary raw structures must never reach a detail
# drawer through json.dumps (battle records may contain responses/secrets).
return str(value) if isinstance(value, (str, int, float, bool)) and value != "" else empty
def _category(value):
value = {"main": "mainline", "side": "sidequest", "sidequests": "sidequest", "commissions": "commission", "主线": "mainline", "支线": "sidequest", "委托": "commission"}.get(value, value) if isinstance(value, str) else "unknown"
return value if value in CATEGORIES else "unknown"
def _mainline(dto, engine, config, query):
selected, state = str(query.get("category", "mainline")), str(query.get("state", "current"))
dto["filters"] = [_filter("category", "任务类别", selected, [("", "全部类别"), *CATEGORIES.items()]),
_filter("state", "任务状态", state, STATE_FILTERS)]
search = _search(dto, query)
dto["columns"] = [_column(key, label) for key, label in (("task_type_id", "编号"), ("category_label", "类别"), ("name", "任务"), ("state_label", "状态"),
("step", "步骤"), ("location", "目标 / 位置"), ("requirement", "需求"), ("next_action", "下一步"), ("battle", "战斗类型"), ("support", "支持状态 / 阻塞原因"))]
sources = engine.progression_rows()
for index, source in enumerate(sources):
category = _category(source.get("category"))
raw_state = _text(source.get("state"), "unknown")
lifecycle = STATE_ALIASES.get(raw_state, raw_state)
if selected and category != selected or state == "current" and lifecycle not in ("received", "unlocked", "ready_to_reward") or state not in ("", "current") and lifecycle != state:
continue
reason = battle_message(source.get("blocked_reason") or source.get("block_reason") or source.get("reason") or "")
support = "受阻:" + reason if reason else "已支持" if source.get("supported") is True else "暂不支持" if source.get("supported") is False else "支持状态未确认"
battle = _text(source.get("battle_kind"), "未确认")
battle = BATTLE_ALIASES.get(battle, battle)
row = {"id": str(source.get("task_id") or source.get("task_type_id") or index), "task_type_id": _text(source.get("task_type_id")), "category": category,
"category_label": CATEGORIES[category], "name": _text(source.get("name")), "state": raw_state, "lifecycle_state": lifecycle,
"state_label": STATES.get(raw_state, raw_state), "step": _text(source.get("step_number")) + " / " + _text(source.get("total_steps")),
"location": _text(source.get("location_text") or source.get("location") or source.get("position")), "requirement": _text(source.get("requirement")),
"next_action": _text(source.get("next_action")), "battle": BATTLE_KINDS.get(battle, battle), "support": support}
detail = {"任务": row["name"], "类别": row["category_label"], "状态": row["state_label"], "步骤": row["step"],
"目标 / 位置": row["location"], "NPC": _text(source.get("npc_name")), "需求": row["requirement"],
"对话": _text(source.get("dialogue") or source.get("dialogue_text") or source.get("dialogue_status"), "当前未提供对话内容"),
"下一步": row["next_action"], "战斗": row["battle"], "运行状态": _text(source.get("status"), row["state_label"]), "支持状态 / 阻塞原因": support}
if search and search not in " ".join(map(str, [*row.values(), *detail.values()])).casefold():
continue
dto["rows"].append(row)
dto["details"][row["id"]] = detail
dto["summary"] = f"显示 {len(dto['rows'])} / {len(sources)} 条任务;未支持的步骤显示原因" if sources else "尚未读取任务,请刷新任务 / 预览"
dto["tabs"] = [{"key": "status", "title": "任务状态"}, {"key": "policy", "title": "推进策略"}]
dto["actions"] = [{"operation": "refresh_tasks", "label": "刷新任务 / 预览", "payload": {}}]
dto["battle_mode"] = {"mode": "experimental", "label": "实验模拟(近似,未完整验证)", "damage_rule": "保持原始属性;我方对敌最终伤害10倍,单次最高50000"}
def _battles(dto, engine, config, query):
selected = str(query.get("category", ""))
dto["filters"] = [_filter("category", "战斗类型", selected, [("", "全部类型"), *BATTLE_KINDS.items()])]
search = _search(dto, query)
dto["columns"] = [_column(key, label) for key, label in (("time", "时间(北京时间)"), ("kind_label", "上下文 / 类型"),
("name", "任务 / 地图"), ("team", "队伍"), ("outcome_label", "结果"), ("message", "详情 / 阻塞原因"))]
records = engine.progression_records()
for index, source in enumerate(records):
raw_kind = source.get("battle_kind") or source.get("kind") or source.get("context") or "unknown"
kind = BATTLE_ALIASES.get(raw_kind, raw_kind) if isinstance(raw_kind, str) else "unknown"
if source.get("outcome") == "event":
kind = "map_reward_event"
elif source.get("task_id") and kind == "battle":
kind = "task_battle"
elif source.get("kind") == "sweep":
kind = "sweep"
if selected and selected != kind:
continue
stamp = source.get("finished_at") or source.get("started_at") or source.get("timestamp", source.get("time", source.get("at")))
if type(stamp) in (int, float) and 0 <= stamp <= 253402271999:
stamp = datetime.fromtimestamp(stamp, CHINA_TIME).strftime("%Y-%m-%d %H:%M:%S")
outcome = source.get("outcome") or source.get("status") or source.get("phase") or source.get("result")
if isinstance(outcome, dict):
outcome = outcome.get("outcome") or outcome.get("status")
outcome = _text(outcome, "unknown")
mode = source.get("battle_mode") or source.get("execution_mode")
row = {"id": str(index), "time": _text(stamp), "category": kind, "kind_label": BATTLE_KINDS.get(kind, "其他 / 未知"),
"name": _text(source.get("name") or source.get("task_type_id") or source.get("stage_id") or source.get("stage") or source.get("description")),
"team": _text(source.get("team")), "outcome": outcome, "outcome_label": OUTCOMES.get(outcome, outcome) + ("(实验近似)" if mode == "experimental" else ""),
"message": battle_message(_text(source.get("blocked_reason") or source.get("block_reason") or source.get("message") or source.get("reason")))}
if search and search not in " ".join(map(str, row.values())).casefold():
continue
dto["rows"].append(row)
damage = {"client_v4_x10": "我方对敌最终伤害10倍,单次最高50000;角色属性保持原值", "original_1x": "原始1倍;角色属性保持原值"}.get(source.get("damage_profile"), "旧记录未标明伤害倍率")
reward = source.get("reward")
if isinstance(reward, dict):
# Both wire-shaped and already normalized journal rewards occur.
shown_reward = reward_summary(engine.catalog, reward)
normalized_drops = reward.get("drops")
if isinstance(normalized_drops, list):
drop_text = [f"{_text(drop.get('name'))} ×{_text(drop.get('num'), '0')}" for drop in normalized_drops if isinstance(drop, dict)]
shown_reward += (";" if shown_reward and drop_text else "") + ";".join(drop_text)
else:
shown_reward = "当前未提供奖励数据"
dto["details"][row["id"]] = {"时间(北京时间)": row["time"], "上下文": row["kind_label"], "任务 / 地图": row["name"],
"战斗模式": "实验模拟(近似,未完整验证)" if mode == "experimental" else "原版运行时" if mode == "original" else "记录未标明",
"队伍": row["team"], "结果": row["outcome_label"], "详情 / 阻塞原因": row["message"], "奖励": shown_reward, "伤害规则": damage}
dto["summary"] = f"已读取 {len(records)} 条记录,显示 {len(dto['rows'])} 条" if records else "尚无已读取的战斗记录;未记录结果不代表战斗成功"
dto["actions"] = [{"operation": "refresh_tasks", "label": "刷新战斗记录", "payload": {}}]
def _commissions(dto, engine, config, query):
snapshot, catalog = engine.snapshot, engine.catalog
search = _search(dto, query)
dto["columns"] = [_column(key, label) for key, label in (("task_type_id", "编号"), ("name", "委托"), ("status", "状态"),
("reward_money", "金币奖励"), ("reward_ke", "氪金奖励"), ("reason", "需求 / 下一步 / 阻塞原因"))]
diagnostics = {str(row.get("task_type_id")): row for row in engine.progression_rows() if _category(row.get("category")) == "commission"}
source = engine.tasks.rows(snapshot, engine.quest_policy, engine.policy)
for index, (key, name, status, text, meta) in enumerate(source):
diagnostic = diagnostics.get(str(key), {})
reason = diagnostic.get("block_reason") or diagnostic.get("blocked_reason")
if reason:
status = "暂不接取" if "city" in meta else "等待条件"
text = reason
elif diagnostic.get("next_action"):
text = diagnostic["next_action"]
info = catalog.data.get("task_info", {}).get(str(key), {})
reward = info.get("reward") or {}
row = {"id": f"{key}:{index}", "task_type_id": str(key), "name": name, "status": status,
"reward_money": reward.get("money", 0), "reward_ke": reward.get("ke", 0), "reason": battle_message(text),
"city": meta.get("city"), "active": "city" not in meta}
if search and search not in " ".join(map(str, row.values())).casefold():
continue
dto["rows"].append(row)
dto["details"][row["id"]] = {"描述": info.get("des", ""), "需求 / 下一步": row["reason"],
"交付限制": {"允许物品": engine.quest_policy.allow_items, "允许魔物": engine.quest_policy.allow_monsters,
"单次金币上限": engine.quest_policy.max_money, "允许已支持战斗": engine.quest_policy.battle_tasks},
"接取优先级": "氪金奖励较高的委托优先;仅接取原规划器确认可支持的委托"}
dto["summary"] = f"今日剩余可接次数:{snapshot.raw.get('history', {}).get('loopTaskNum', '未知')};当前委托:{len(engine.tasks.current(snapshot))};按氪金奖励优先"
def _exploration(dto, engine, config, query):
planner, snapshot = engine.explore_planner, engine.snapshot
policy = engine.explore_policy
rows = planner.rows(snapshot, policy, engine.policy)
area_options = [{"value": key, "label": f"{area.get('name') or key}({key})", "disabled": not planner.area_unlocked(snapshot, area),
"reason": "" if planner.area_unlocked(snapshot, area) else f"需通关 {area.get('passStage') or '指定关卡'} 难度1"} for key, area in planner.areas.items()]
dto["columns"] = [_row_column("enabled", "启用", ["explore_policy", "teams"], kind="boolean"), _column("team_id", "队伍"),
_row_column("area", "地区", ["explore_policy", "teams"], kind="select", options=_options([("", "请选择地区")]) + area_options),
_column("state_text", "状态 / 剩余"), _column("monsters", "队长 / 队员 / 队员", "members",
_edit(["explore_policy", "teams", "{id}", "monsters"], "members", slots=["队长", "队员(等级不可高于队长)", "队员(等级不可高于队长)"])),
_column("cost_text", "体力 / 时间"), _column("reason", "原因 / 选择规则")]
for source in rows:
key = str(source["team_id"])
rule = {"enabled": False, "area": "", "monsters": []} | config["explore_policy"]["teams"].get(key, {})
disabled = source["state"] in ("探索中", "可领取", "待核对")
candidates = planner.member_options(snapshot, int(key), policy, engine.policy)
options = []
for candidate in candidates:
mon = snapshot.monsters.get(candidate["id"])
manual_reason = planner.monster_exclusion(snapshot, mon, engine.policy, automatic=False) if mon else "快照中不存在"
if candidate["reason"] == "正在其他探险队":
manual_reason = candidate["reason"]
options.append({"value": candidate["id"], "label": f"{candidate['label']} Lv.{candidate['level']}" + (f";{candidate['reason']}" if candidate["reason"] else ""),
"level": candidate["level"], "automatic": candidate["automatic"], "automatic_reason": candidate["reason"],
"disabled": bool(manual_reason), "reason": manual_reason})
for mid in rule["monsters"]:
if not any(option["value"] == mid for option in options):
options.append({"value": mid, "label": f"#{mid}(当前快照不存在)", "disabled": True,
"reason": "当前快照不存在", "automatic": False, "automatic_reason": "当前快照不存在"})
members_edit = _edit(["explore_policy", "teams", key, "monsters"], "members", options=options, disabled=disabled,
slots=["队长", "队员(等级不可高于队长)", "队员(等级不可高于队长)"])
dto["rows"].append({"id": key, "team_id": source["team_id"], **rule, "state": source["state"],
"remaining": source["remaining"], "state_text": source["state"] + " / " + (duration(source["remaining"]) if source["remaining"] is not None else "—"),
"monster_ids": source["monster_ids"], "monster_labels": [engine.catalog.monster_label(snapshot.monsters[mid]) if mid in snapshot.monsters else f"#{mid}" for mid in source["monster_ids"]],
"member_options": options, "cost_ti": source["cost_ti"], "cost_time": source["cost_time"], "cost_text": f"{source['cost_ti']} / {duration(source['cost_time'])}",
"manual": source["manual"], "can_auto": source["can_auto"], "reason": source["reason"] or ("手动指定;允许锁定 / 装备" if source["manual"] else "自动选空闲魔物"),
"rule_defaults": {"enabled": False, "area": "", "monsters": []}, "rule_path": ["explore_policy", "teams", key],
"edits": {"enabled": _edit(["explore_policy", "teams", key, "enabled"], "boolean", disabled=disabled),
"area": _edit(["explore_policy", "teams", key, "area"], "select", options=_options([("", "请选择地区")]) + area_options, disabled=disabled),
"monsters": members_edit}})
dto["summary"] = f"已有 {len(rows)} 支探险队;配置 {len(policy.teams)} 支;启用 {sum(rule.enabled for rule in policy.teams.values())} 支。完成时自动领奖,再次出发由开关控制。"
dto["details"] = {"help": "留空任一槽位恢复自动选人;手动队员必须三只不同魔物,队员等级不可高于队长;不自动花钱开队或召回"}
def _maps(dto, engine, config, query):
snapshot = engine.snapshot
all_rows = engine.stage_cache.get(snapshot)
resource_catalog = engine.stage_cache.catalog
category = str(query.get("category", "all"))
only_unlocked = _boolean(query.get("only_unlocked"), True)
if category not in ("all", "ordinary", "resource"):
raise ValueError("地图分类无效")
dto["filters"] = [_filter("category", "关卡分类", category, [("all", "全部关卡"), ("ordinary", "普通关卡"), ("resource", "矿洞与门票")]),
_filter("only_unlocked", "只看账号已解锁", only_unlocked, kind="boolean")]
search = _search(dto, query)
policy = engine.sweep_policy
team_ids = engine.sweeper.team_ids(snapshot, policy)
dto["columns"] = [_row_column("enabled", "刷图", ["sweep_policy", "rules"], kind="boolean"), _column("number", "关卡"), _column("name", "名称"),
_row_column("level", "难度", ["sweep_policy", "rules"], kind="select", options=_options([(str(i), f"难度{i}") for i in (1, 2, 3)])),
_column("stars_text", "星级"), _column("status", "扫荡 / 挑战状态"), _column("cost_text", "体力 / 门票:单次 / 可用 / 保留"),
_column("drops", "可能掉落"), _row_column("limit", "本日上限", ["sweep_policy", "rules"], min=0, max=999), _column("used", "本日已开始")]
grouped = {}
for stage in all_rows:
if stage.category in ("mine", "ticket") and stage.level != "1":
continue
grouped.setdefault(stage.stage_id, []).append(stage)
dto["groups"] = []
cities = set()
for key, stages in sorted(grouped.items(), key=lambda pair: (pair[1][0].city, pair[1][0].number, pair[0])):
first = stages[0]
resource = first.category in ("mine", "ticket")
if category == "ordinary" and first.category != "ordinary" or category == "resource" and not resource:
continue
if only_unlocked and not any(stage.unlocked for stage in stages):
continue
if search and search not in (first.city_name + key + first.number + first.name + " ".join(stage.drops for stage in stages)).casefold():
continue
saved = config["sweep_policy"]["rules"].get(key, {})
chosen = next((stage for stage in stages if stage.level == saved.get("level")), None)
chosen = chosen or next((stage for stage in reversed(stages) if stage.unlocked), first)
defaults = {"enabled": False, "level": chosen.level, "limit": 3}
rule = defaults | saved
reason = engine.map_stage_reason(snapshot, chosen, policy, team_ids=team_ids)
costs = [{"kind": "stamina", "label": "体力", "required": chosen.stamina,
"available": int(snapshot.raw["master"].get("ti") or 0), "reserve": policy.keep_stamina}]
base = resource_catalog.data.get("stage_info", {}).get(key, {}).get("cost") or {}
if resource:
for item_id, count in item_requirements(base.get("items") or []).items():
costs.append({"kind": "item", "type_id": item_id, "label": resource_catalog.data.get("item_names", {}).get(item_id, item_id),
"required": count, "available": available_item_count(snapshot, item_id), "reserve": policy.keep_tickets})
if not chosen.battle_available:
reason = "该资源关卡缺少已提取的战斗配置,未启用"
elif not policy.allow_special:
reason = "尚未开启“允许矿洞 / 门票关卡”资源关开关"
else:
insufficient = next((cost for cost in costs if cost["available"] - cost["required"] < cost["reserve"]), None)
if insufficient:
reason = f"{insufficient['label']}不足:单次需 {insufficient['required']},可用 {insufficient['available']},保留 {insufficient['reserve']}"
reason = reason or "将按实际模拟结果挑战;不是扫荡"
cost_text = "\n".join(f"{cost['label']} 单次 {cost['required']} / 可用 {cost['available']} / 保留 {cost['reserve']}" for cost in costs)
levels = [{"value": stage.level, "label": f"难度 {stage.level}" + ("(已通关)" if stage.passed else ""), "disabled": not (stage.unlocked and stage.open)} for stage in stages]
dto["rows"].append({"id": key, "number": first.number, "name": first.name, "group": str(first.city), "city_name": first.city_name, "category": first.category,
**rule, "stars": first.stars, "stars_text": "★" * first.stars + "☆" * max(0, 3 - first.stars), "status": reason or ("可扫荡" if chosen.sweep else "将模拟挑战"),
"unlocked": chosen.unlocked, "open": chosen.open, "sweep": chosen.sweep, "costs": costs, "cost_text": cost_text, "drops": chosen.drops,
"used": engine.sweeper.used(snapshot, chosen), "rule_defaults": defaults, "rule_path": ["sweep_policy", "rules", key],
"edits": {"enabled": _edit(["sweep_policy", "rules", key, "enabled"], "boolean", disabled=not any(stage.unlocked and stage.open for stage in stages)),
"level": _edit(["sweep_policy", "rules", key, "level"], "select", options=levels)}})
if first.city not in cities:
cities.add(first.city)
dto["groups"].append({"id": str(first.city), "label": first.city_name, "collapsed": not bool(search)})
pending = engine.sweeper.state.get("pending")
dto["summary"] = f"已解锁 {sum(stage.unlocked for stage in all_rows)} 个难度;显示 {len(dto['rows'])} 关;勾选 {sum(bool(rule.get('enabled')) for rule in policy.rules.values())} 关"
dto["details"] = {"pending": {"stage": _text(pending.get("stage")), "phase": _text(pending.get("phase"))} if pending else None,
"help": "普通关卡三个难度全部通关可扫荡;资源关卡需单独开启并逐关勾选,仅原入口难度1;未支持内容保留具体原因,随机掉落并非必得"}
dto["actions"] = [{"operation": "refresh_maps", "label": "刷新关卡", "payload": {}},
{"operation": "reset_map_pending", "label": "核对未完成记录", "payload": {"confirm": True}, "confirm": "按服务器证据核对;证据不完整时会保留记录"}]
def _statistics(dto, engine, config, query):
catalog = engine.stage_cache.catalog
source = str(query.get("source", "all"))
metric = str(query.get("metric", "rate"))
if metric == "probability":
metric = "rate"
if source not in ("all", "sweep", "event") or metric not in ("rate", "per_stamina"):
raise ValueError("数据分析来源或指标无效")
stage_id, level = str(query.get("stage_id") or query.get("stage") or ""), str(query.get("level", "3"))
data = engine.sweeper.statistics.snapshot(engine.snapshot.raw["master"]["id"]) if engine.snapshot else {"totals": {}, "drops": {}}
dto["filters"] = [_filter("source", "统计范围", source, [("all", "扫荡+奖励事件"), ("sweep", "普通扫荡"), ("event", "奖励事件")]),
_filter("metric", "图表指标", metric, [("rate", "实测掉落率"), ("per_stamina", "每点体力数量")])]
search = _search(dto, query)
stages, choices = [], []
for key, stage in sorted(catalog.data.get("stage_info", {}).items(), key=lambda pair: (int(pair[1].get("city") or 0), pair[1].get("tagname") or pair[0])):
label = f"{stage.get('tagname') or key} {stage.get('name') or key}"
if search and search not in (key + label).casefold():
continue
levels = [{"id": str(number), "level": str(number), "value": str(number), "label": f"{label} / 难度 {number}",
"sweep": data["totals"].get(f"{key}:{number}:sweep", {}).get("n", 0),
"event": data["totals"].get(f"{key}:{number}:event", {}).get("n", 0)} for number in sorted(stage.get("level", {}), key=int)]
city_id = str(int(stage.get("city") or 0))
city = catalog.data["game_setting"].get("cityInfo", {}).get(city_id, {}).get("name", f"地区 {city_id}")
stages.append({"id": key, "label": label, "city_id": city_id, "city_name": city, "levels": levels,
"sweep": sum(row["sweep"] for row in levels), "event": sum(row["event"] for row in levels)})
choices.append((key, label))
dto["stages"] = stages
dto["filters"] += [_filter("stage_id", "关卡", stage_id, [("", "请选择关卡"), *choices])]
stage = catalog.data.get("stage_info", {}).get(stage_id)
levels = [(str(number), f"难度 {number}") for number in sorted(stage.get("level", {}), key=int)] if stage else [(str(i), f"难度{i}") for i in (1, 2, 3)]
dto["filters"].append(_filter("level", "难度", level, levels))
dto["columns"] = [_column(key, label) for key, label in (("name", "掉落物"), ("kind_label", "类别"), ("hits", "出现次数"), ("units", "总数量"),
("samples", "样本数"), ("rate_text", "实测掉落率"), ("average", "平均数量/次"), ("per_stamina", "每点体力数量"), ("interval_text", "95%区间"), ("configured_text", "静态配置"))]
dto["chart"] = {"type": "horizontal_bar", "metric": metric, "label": "实测掉落率" if metric == "rate" else "每点体力数量", "series": [], "max": 1 if metric == "rate" else None,
"unit": "ratio" if metric == "rate" else "个 / 体力", "empty_reason": "请选择关卡和难度"}
dto["charts"] = [dto["chart"]]
if not stage_id:
dto["summary"] = "请选择关卡和难度;关卡来自本地配置,统计按当前账号读取"
return
if stage is None or level not in stage.get("level", {}):
raise ValueError("数据分析的关卡或难度无效")
totals, rows = analyze(catalog, data, stage_id, level, source)
counts = {kind: data["totals"].get(f"{stage_id}:{level}:{kind}", {}).get("n", 0) for kind in ("sweep", "event")}
dto["totals"] = totals | counts | {"source": source, "stage_id": stage_id, "level": level}
for row in rows:
interval = row["interval"]
dto["rows"].append({"id": row["key"], **row, "kind_label": {"item": "物品", "egg": "魔物蛋", "monster": "魔物"}.get(row["kind"], "未知"),
"rate_text": f"{row['rate'] * 100:.2f}%" if row["rate"] is not None else "—", "interval_text": f"{interval[0] * 100:.1f}%~{interval[1] * 100:.1f}%" if interval else "—",
"configured_text": "可能掉落" if row["configured"] else "实际观测"})
dto["chart"]["series"] = [{"id": row["key"], "label": row["name"], "value": row[metric], "hits": row["hits"], "samples": row["samples"]}
for row in rows if row[metric] is not None]
dto["chart"]["empty_reason"] = "尚无此范围的已确认样本" if not totals["n"] else "没有已知的非零体力消耗,暂不计算体力效率" if metric == "per_stamina" and not totals["spent"] else ""
if metric == "per_stamina":
dto["chart"]["max"] = max([point["value"] for point in dto["chart"]["series"]] + [0]) * 1.15 or 1
dto["summary"] = f"{stage.get('tagname') or stage_id} {stage.get('name') or stage_id} / 难度 {level};扫荡 {counts['sweep']} / 奖励事件 {counts['event']};当前范围 {totals['n']} 个已确认样本;累计金币 {totals['money']}、经验 {totals['exp']};已知体力消耗样本 {totals['known']}/{totals['n']},消耗体力 {totals['spent']},返还体力 {totals['ti']}"
dto["details"] = {"help": "掉落率=出现次数/已确认样本数;每点体力数量只计已知消耗样本,不扣减奖励返还体力;实测值不是官方掉率;95%区间反映样本不确定性",
"statistics_error": "本地统计读取失败,请查看服务器日志" if data.get("error") else ""}
def _execution_plans(dto, engine, config, query):
dto["columns"] = [_column("kind", "类型"), _column("description", "计划动作")]
dto["rows"] = _plans(engine)
dto["summary"] = f"{len(dto['rows'])} 项计划;仅预览,开启顶部策略后由原引擎执行"
dto["details"] = {"notes": list(dict.fromkeys(engine.planner.notes))}
def _yields(dto, engine, config, query):
search = _search(dto, query)
dto["columns"] = [_column(key, label) for key, label in (("type_id", "魔物编号"), ("name", "名称"), ("star", "星"), ("time_text", "培育时间"),
("sell_money", "派遣金币"), ("sell_exp", "基础经验"), ("gold_per_hour", "金币/小时"), ("exp_per_hour", "经验/小时"), ("ratio", "金币/经验"), ("recommendation", "建议(未计保留条件)"))]
threshold = config["policy"]["coins_per_exp"]
for type_id in engine.catalog.monsters:
info = engine.catalog.monster(type_id)
if int(info.get("star", 0)) not in config["yield_stars"] or search and search not in (type_id + str(info.get("name", ""))).casefold():
continue
total = engine.catalog.total_time(type_id)
if not total:
continue
money, exp = info.get("sell_money", 0), info.get("sell_exp", 0)
ratio = money / exp if exp else None
dto["rows"].append({"id": type_id, "type_id": int(type_id), "name": info.get("name", "未知"), "star": info.get("star", "?"), "time_total": total, "time_text": duration(total),
"sell_money": money, "sell_exp": exp, "gold_per_hour": round(money * 3600 / total, 2), "exp_per_hour": round(exp * 3600 / total, 2),
"ratio": round(ratio, 3) if ratio is not None else "无经验", "recommendation": "适合喂养" if ratio is not None and ratio < threshold else "适合派遣"})
dto["summary"] = f"本地资料共 {len(engine.catalog.monsters)} 种魔物,当前显示 {len(dto['rows'])} 种;CSV/XLSX覆盖值仅影响收益计算"
dto["actions"].append({"operation": "import_yields", "label": "导入CSV / XLSX收益资料", "accept": ".csv,.xlsx"})
dto["details"] = {"import_columns": ["typeId / 编号 / 魔物ID", "sell_money / 派遣金币", "sell_exp / 强化经验", "time_total / 孵化秒数"]}
_BUILDERS.update({"login": _login, "incubator": _incubator, "bag": _bag, "ranch": _ranch,
"daily": _daily, "hatching": _hatching, "mainline": _mainline, "battles": _battles,
"gifts": _gifts, "commissions": _commissions, "exploration": _exploration, "maps": _maps,
"statistics": _statistics, "plans": _execution_plans, "yields": _yields})