457 lines
24 KiB
Python
457 lines
24 KiB
Python
"""The built-in three-difficulty-cleared sweep path from StageStartPanel."""
|
|
from dataclasses import dataclass, field
|
|
from contextlib import nullcontext
|
|
from datetime import datetime
|
|
from types import SimpleNamespace
|
|
import json
|
|
import math
|
|
from pathlib import Path
|
|
import sqlite3
|
|
import time
|
|
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
|
|
|
|
|
|
def settled_reward_event(response):
|
|
return event_reward(response) is not None
|
|
|
|
|
|
def successful_response(response):
|
|
if not isinstance(response, dict):
|
|
return False
|
|
if "resCode" not in response:
|
|
# Existing in-process adapters may already have checked resCode.
|
|
return (type(response.get("triggerEvent")) is bool
|
|
or type(response.get("triggerEvent")) is int and response["triggerEvent"] in (0, 1)
|
|
or isinstance(response.get("reward"), dict))
|
|
return (type(response["resCode"]) is int and response["resCode"] == 0
|
|
or type(response["resCode"]) is str and response["resCode"] == "0")
|
|
|
|
|
|
def hidden_stage_id(response):
|
|
"""Return the original hidden ID only for an explicit hidden event."""
|
|
if not isinstance(response, dict):
|
|
return None
|
|
flag = response.get("triggerEvent")
|
|
event = response.get("stageEvent")
|
|
if not (flag is True or type(flag) is int and flag == 1) or not isinstance(event, dict):
|
|
return None
|
|
identifier = event.get("hideStageId")
|
|
if isinstance(identifier, str) and identifier.strip():
|
|
return identifier
|
|
if type(identifier) is int and identifier > 0:
|
|
return str(identifier)
|
|
return None
|
|
|
|
|
|
@dataclass
|
|
class SweepPolicy:
|
|
enabled: bool = False
|
|
rules: dict = field(default_factory=dict)
|
|
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:
|
|
def __init__(self, catalog, path=None):
|
|
self.catalog = catalog
|
|
self.path = Path(path) if path else None
|
|
self.state = json.loads(self.path.read_text(encoding="utf-8")) if self.path and self.path.exists() else {"counts": {}, "pending": None}
|
|
self.last_outcome = ""
|
|
self.recovery_checked = False
|
|
self.recovered_event = False
|
|
self.statistics = SweepStatistics(catalog, self.path.with_name("sweep_rewards.sqlite3") if self.path else None)
|
|
self.last_reward = None
|
|
self.statistics_error = ""
|
|
|
|
def remember_reward(self, client, snapshot, stage, kind, reward, response):
|
|
self.last_outcome = kind
|
|
self.last_reward = None
|
|
self.statistics_error = ""
|
|
try:
|
|
self.last_reward = normalize_reward(self.catalog, reward)
|
|
source = "run:" + self.state["pending"]["sampleId"]
|
|
operation = "stageService/stageStart" if kind == "event" else "battleService/battleEnd"
|
|
for event in reversed(getattr(getattr(client, "trace", None), "events", [])):
|
|
if event.get("operation") == operation and event.get("kind") == "response" and event.get("request_id"):
|
|
source = "request:" + event["request_id"]
|
|
break
|
|
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, 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.
|
|
|
|
This never replays a start or settlement request. Missing/ambiguous
|
|
evidence leaves the pending record intact.
|
|
"""
|
|
pending = self.state.get("pending")
|
|
if (self.recovery_checked or not trace_path or not pending
|
|
or pending.get("phase") != "遇到事件或响应缺少事件状态,请在游戏内处理"):
|
|
return False
|
|
self.recovery_checked = True
|
|
role, requests, last_reply = None, {}, None
|
|
owner = snapshot.raw["master"]["id"]
|
|
path = Path(trace_path)
|
|
try:
|
|
for file in (path.with_name("network_debug.previous.jsonl"), path):
|
|
if not file.exists():
|
|
continue
|
|
with file.open(encoding="utf-8") as stream:
|
|
for line in stream:
|
|
try:
|
|
event = json.loads(line)
|
|
except ValueError:
|
|
continue
|
|
body = event.get("body")
|
|
if not isinstance(body, dict):
|
|
continue
|
|
if event.get("operation") == "读取角色" and event.get("kind") == "response":
|
|
role = (body.get("master") or {}).get("id")
|
|
if event.get("operation") != "stageService/stageStart":
|
|
continue
|
|
identifier = event.get("request_id")
|
|
if not isinstance(identifier, str) or not identifier:
|
|
continue
|
|
if event.get("kind") == "request":
|
|
matched = (str(role) == str(owner) and str(body.get("stageTypeId")) == pending["stage"]
|
|
and str(body.get("stageLevel")) == str(pending["level"]))
|
|
requests[identifier] = matched
|
|
if matched:
|
|
last_reply = None
|
|
elif event.get("kind") == "response" and requests.get(identifier):
|
|
last_reply = body if event.get("http_status") == 200 and body.get("resCode") in (0, "0") else None
|
|
except (OSError, ValueError, TypeError, AttributeError):
|
|
return False
|
|
if last_reply and settled_reward_event(last_reply):
|
|
self.state["pending"] = None
|
|
self.save()
|
|
self.recovered_event = True
|
|
return True
|
|
return False
|
|
|
|
def recover_hidden_start(self, snapshot, trace_path, *, events=None):
|
|
"""Recover entry evidence only; never replay entry or infer settlement.
|
|
|
|
Old journals lack entry snapshots. Trace proof deliberately does not
|
|
manufacture runtime inputs from the current, post-entry snapshot.
|
|
"""
|
|
from .battles import gameplay_response
|
|
|
|
pending = self.state.get("pending")
|
|
old_phases = {"遭遇隐藏关卡,请在游戏内手动战斗", "遇到事件或响应缺少事件状态,请在游戏内处理"}
|
|
if not isinstance(pending, dict) or not trace_path:
|
|
return False
|
|
if (pending.get("phase") not in old_phases
|
|
and not (pending.get("phase") == "开始请求待确认" and "start_response" not in pending)):
|
|
return False
|
|
owner = snapshot.raw.get("master", {}).get("id")
|
|
if owner is None or (pending.get("role_id") is not None and str(pending["role_id"]) != str(owner)):
|
|
return False
|
|
owner = str(owner)
|
|
parent, level = pending.get("stage"), pending.get("level")
|
|
if parent is None or level is None:
|
|
return False
|
|
reservation = pending.get("counts_key")
|
|
if pending.get("role_id") is None:
|
|
# Multiple dates or roles cannot identify which entry this block owns.
|
|
reservations = [(key, count) for key, count in self.state.get("counts", {}).items()
|
|
if isinstance(key, str) and len(key.split(":")) == 4
|
|
and key.split(":")[2:] == [str(parent), str(level)] and count != 0]
|
|
if (len(reservations) != 1 or reservations[0][0].split(":")[0] != owner
|
|
or type(reservations[0][1]) is not int or reservations[0][1] <= 0):
|
|
return False
|
|
reservation = reservations[0][0]
|
|
if reservation is not None:
|
|
parts = reservation.split(":") if isinstance(reservation, str) else []
|
|
if len(parts) != 4 or parts[0] != owner or parts[2:] != [str(parent), str(level)]:
|
|
return False
|
|
try:
|
|
datetime.strptime(parts[1], "%Y-%m-%d")
|
|
except ValueError:
|
|
return False
|
|
role, latest, candidate = None, None, None
|
|
requests, responses = {}, set()
|
|
# Everything outside these explicit reads is an uncertain write.
|
|
reads = {"读取角色", "masterService/masterQueryDetail"}
|
|
def unambiguous_object(pairs):
|
|
result = {}
|
|
for key, value in pairs:
|
|
if key in result:
|
|
raise ValueError("Duplicate trace field")
|
|
result[key] = value
|
|
return result
|
|
path = Path(trace_path)
|
|
try:
|
|
for file in ((None,) if events is not None else (path.with_name("network_debug.previous.jsonl"), path)):
|
|
if file is not None and not file.exists():
|
|
continue
|
|
with (nullcontext(events) if file is None else file.open(encoding="utf-8")) as stream:
|
|
for line in stream:
|
|
if isinstance(line, str) and not line.strip():
|
|
continue
|
|
event = line if isinstance(line, dict) else json.loads(line, object_pairs_hook=unambiguous_object)
|
|
if not isinstance(event, dict):
|
|
return False
|
|
operation, kind = event.get("operation"), event.get("kind")
|
|
body, identifier = event.get("body"), event.get("request_id")
|
|
if not isinstance(operation, str) or kind not in ("request", "response", "error"):
|
|
return False
|
|
if operation in reads:
|
|
if kind == "response":
|
|
master = body.get("master") if isinstance(body, dict) else None
|
|
observed = master.get("id") if isinstance(master, dict) else None
|
|
if (type(observed) not in (int, str) or not str(observed).strip()
|
|
or event.get("http_status", 200) != 200
|
|
or "resCode" in body and not successful_response(body)):
|
|
observed = None
|
|
observed = str(observed) if observed is not None else None
|
|
if role != observed:
|
|
latest, candidate = None, None
|
|
role = observed
|
|
elif kind == "error":
|
|
role, latest, candidate = None, None, None
|
|
continue
|
|
if not isinstance(identifier, str) or not identifier or not isinstance(body, dict):
|
|
return False
|
|
if kind == "request":
|
|
if identifier in requests:
|
|
return False
|
|
requests[identifier] = (operation, role)
|
|
if role is None or role == owner:
|
|
latest, candidate = None, None
|
|
if (role == owner and operation == "stageService/stageStart"
|
|
and str(body.get("stageTypeId")) == str(parent)
|
|
and str(body.get("stageLevel")) == str(level)):
|
|
latest = identifier
|
|
elif kind == "response":
|
|
if identifier in responses:
|
|
return False
|
|
responses.add(identifier)
|
|
if (identifier == latest and requests.get(identifier) == (operation, owner)
|
|
and role == owner and operation == "stageService/stageStart"
|
|
and event.get("http_status") == 200 and body.get("resCode") in (0, "0") and successful_response(body)
|
|
and hidden_stage_id(body) is not None and not settled_reward_event(body)):
|
|
candidate = event
|
|
elif role is None or role == owner:
|
|
latest, candidate = None, None
|
|
elif role is None or role == owner:
|
|
latest, candidate = None, None
|
|
except (OSError, ValueError, TypeError, AttributeError):
|
|
return False
|
|
if candidate is None or role != owner:
|
|
return False
|
|
confirmed_at = None
|
|
try:
|
|
stamp = candidate.get("time")
|
|
parsed = datetime.fromisoformat(stamp) if isinstance(stamp, str) else None
|
|
if parsed is not None and parsed.tzinfo is not None:
|
|
confirmed_at = parsed.timestamp()
|
|
if confirmed_at is not None and (not math.isfinite(confirmed_at) or confirmed_at <= 0):
|
|
confirmed_at = None
|
|
except (ValueError, OverflowError, OSError):
|
|
pass
|
|
update = {"role_id": owner, "phase": "hidden_started", "start_path": "stageService/stageStart",
|
|
"start_dispatched": True, "start_confirmed": True,
|
|
"start_response": gameplay_response(candidate["body"]),
|
|
"hidden_stage_id": hidden_stage_id(candidate["body"]),
|
|
"start_request_id": candidate["request_id"], "evidence_status": "trace_confirmed_hidden_start"}
|
|
if reservation is not None:
|
|
update["counts_key"] = reservation
|
|
if confirmed_at is not None:
|
|
update["start_confirmed_at"] = confirmed_at
|
|
pending.update(update)
|
|
self.save()
|
|
return True
|
|
|
|
def save(self):
|
|
if self.path:
|
|
self.path.parent.mkdir(parents=True, exist_ok=True)
|
|
temp = self.path.with_suffix(".tmp")
|
|
temp.write_text(json.dumps(self.state, ensure_ascii=False), encoding="utf-8")
|
|
temp.replace(self.path)
|
|
|
|
def key(self, snapshot, stage):
|
|
return f"{snapshot.raw['master']['id']}:{day(snapshot.now)}:{stage.stage_id}:{stage.level}"
|
|
|
|
def used(self, snapshot, stage):
|
|
return int(self.state["counts"].get(self.key(snapshot, stage), 0))
|
|
|
|
def team_ids(self, snapshot, policy):
|
|
team = next((t for t in snapshot.raw.get("teams", []) if t.get("teamName") == policy.team and t.get("teamType") == "battleTeam"), {})
|
|
ids = [int(mid) for mid in team.get("monsters", []) if mid and int(mid) > 0]
|
|
monsters = snapshot.monsters
|
|
return [mid for mid in ids if mid in monsters]
|
|
|
|
def reason(self, snapshot, stage, policy, *, team_ids=None, challenge=False):
|
|
if not policy.enabled:
|
|
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:
|
|
return "关卡尚未解锁或当前未开放"
|
|
if config.get("special") or config.get("posmode"):
|
|
return "特殊关卡当前不支持自动挑战"
|
|
elif not stage.sweep:
|
|
return stage.reason
|
|
reason = team_availability_reason(snapshot, policy.team)
|
|
if reason:
|
|
return reason
|
|
positions = self.catalog.data.get("stage_task_positions", {})
|
|
for task in snapshot.raw.get("currentTasks", []):
|
|
steps = positions.get(str(task.get("typeId")), [])
|
|
index = int(task.get("curStep") or 1) - 1
|
|
position = steps[index] if 0 <= index < len(steps) else ""
|
|
if position == f"city{stage.city}_wild_stage{stage.stage_id}_level{stage.level}":
|
|
return "该难度有当前剧情任务,请先在游戏内完成"
|
|
base = self.catalog.data["stage_info"][stage.stage_id].get("cost") or {}
|
|
master = snapshot.raw["master"]
|
|
if float(master.get("ti") or 0) < stage.stamina + policy.keep_stamina:
|
|
return "体力不足或已达保留体力"
|
|
if base.get("ke"):
|
|
return "需要氪金,未启用"
|
|
if float(master.get("money") or 0) < float(base.get("money") or 0):
|
|
return "金币不足"
|
|
for item in base.get("items") or []:
|
|
owned = sum(int(i.get("num") or 0) for i in snapshot.raw.get("items", []) if str(i.get("typeId")) == str(item["typeId"]))
|
|
if owned < int(item["num"]):
|
|
return "入场券不足"
|
|
return ""
|
|
|
|
def next(self, snapshot, policy):
|
|
if not policy.enabled:
|
|
return None
|
|
for stage in sorted(stages(self.catalog, snapshot), key=lambda s: (s.city, s.number, s.stage_id, s.level)):
|
|
rule = policy.rules.get(stage.stage_id) or {}
|
|
if not rule.get("enabled") or str(rule.get("level", "3")) != stage.level:
|
|
continue
|
|
if self.used(snapshot, stage) < max(0, int(rule.get("limit") or 0)) and not self.reason(snapshot, stage, policy):
|
|
return stage
|
|
return None
|
|
|
|
def run(self, client, snapshot, stage, policy, *, cancel=None, origin=None):
|
|
from .battles import CancelledBeforeDispatch, gameplay_response, public_data
|
|
|
|
self.last_outcome = ""
|
|
self.last_reward = None
|
|
rule = policy.rules.get(stage.stage_id) or {}
|
|
if not rule.get("enabled") or str(rule.get("level")) != stage.level or self.used(snapshot, stage) >= int(rule.get("limit") or 0):
|
|
raise ValueError("此关卡未勾选或已达本日次数上限")
|
|
reason = self.reason(snapshot, stage, policy)
|
|
if reason:
|
|
raise ValueError(reason)
|
|
key = self.key(snapshot, stage)
|
|
previous_count = self.state["counts"].get(key)
|
|
self.state["counts"][key] = self.used(snapshot, stage) + 1
|
|
self.state["pending"] = {"stage": stage.stage_id, "level": stage.level,
|
|
"phase": "开始请求待确认", "sampleId": uuid.uuid4().hex,
|
|
"role_id": str(snapshot.raw["master"]["id"]), "team": policy.team, "counts_key": key,
|
|
"entry_snapshot": public_data(snapshot.raw), "entry_snapshot_now": snapshot.now,
|
|
"origin": public_data(origin) if isinstance(origin, dict) else {},
|
|
"start_path": "stageService/stageStart", "start_dispatched": False, "start_confirmed": False,
|
|
"settlement_dispatched": False, "record_dispatched": False}
|
|
self.save() # Reserve before the first non-retryable write, including timeouts.
|
|
self.state["pending"]["start_dispatched"] = True
|
|
self.save()
|
|
if cancel is not None and cancel.is_set():
|
|
if previous_count is None:
|
|
self.state["counts"].pop(key, None)
|
|
else:
|
|
self.state["counts"][key] = previous_count
|
|
self.state["pending"] = None
|
|
self.save()
|
|
raise CancelledBeforeDispatch()
|
|
started = client.call("stageService/stageStart", {"stageTypeId": stage.stage_id, "stageLevel": stage.level})
|
|
if not successful_response(started):
|
|
raise ValueError("扫荡开始未返回可信的成功响应,禁止自动重试")
|
|
self.state["pending"].update(start_response=gameplay_response(started),
|
|
start_confirmed=True, start_confirmed_at=time.time())
|
|
self.save()
|
|
hidden = hidden_stage_id(started)
|
|
if hidden is not None and not settled_reward_event(started):
|
|
self.state["pending"].update(phase="hidden_started", hidden_stage_id=hidden)
|
|
self.save()
|
|
self.last_outcome = "hidden"
|
|
if origin is None:
|
|
# Callers without the orchestrator handoff must retain the
|
|
# historical stop signal, while preserving the new evidence.
|
|
raise ValueError("隐藏关卡已入场,等待战斗接续")
|
|
return started
|
|
if settled_reward_event(started):
|
|
# StageCenter.startStageHandler applies stageEvent.result directly;
|
|
# StageStartPanel shows it and returns, without battleEnd.
|
|
self.remember_reward(client, snapshot, stage, "event", started["stageEvent"]["result"], started)
|
|
self.state["pending"] = None
|
|
self.save()
|
|
self.last_outcome = "event"
|
|
return started
|
|
flag = started.get("triggerEvent")
|
|
if flag is not False and not (type(flag) is int and flag == 0):
|
|
event = started.get("stageEvent")
|
|
if isinstance(event, dict) and event.get("hideStageId") is not None:
|
|
phase = "遭遇隐藏关卡,请在游戏内手动战斗"
|
|
else:
|
|
phase = "事件结果或开始状态尚未确认,请在游戏内检查"
|
|
self.state["pending"]["phase"] = phase
|
|
self.save()
|
|
raise ValueError(self.state["pending"]["phase"])
|
|
# Exactly the official doSaodangBattle data; only for its eligible stages.
|
|
battle = {"battlePosition": {"battleType": "stage", "stageId": stage.stage_id, "stageLevel": stage.level, "taskTypeId": None, "taskStep": 0},
|
|
"win": True, "cheatNum": 0, "cheatRecords": "", "killMonster": {}, "battleMonIds": self.team_ids(snapshot, policy),
|
|
**{name: 0 for name in ("leftTime", "killNum", "totalDamage", "bossDamage", "deadNum", "aliveNum", "apLeft")}}
|
|
self.state["pending"]["phase"] = "扫荡结算待确认"
|
|
self.state["pending"].update(settlement_dispatched=True, sweep_battle_data=battle)
|
|
self.save()
|
|
if cancel is not None and cancel.is_set():
|
|
self.state["pending"].update(phase="cancelled_before_sweep_settlement", settlement_dispatched=False)
|
|
self.save()
|
|
raise CancelledBeforeDispatch()
|
|
result = client.call("battleService/battleEnd", {"battleData": battle})
|
|
if not successful_response(result):
|
|
raise ValueError("扫荡结算未返回可信的成功响应,禁止自动重试")
|
|
self.remember_reward(client, snapshot, stage, "sweep", result.get("reward"), result)
|
|
self.state["pending"] = None
|
|
self.save()
|
|
client.call("battleService/recordBattleResult", {"stageId": stage.stage_id, "cityId": stage.stage_id[1:2], "result": 1})
|
|
self.last_outcome = "sweep"
|
|
return result
|