Files
myrzx_bot/ranch_assistant/sweeping.py
T

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