294 lines
15 KiB
Python
294 lines
15 KiB
Python
"""Confirmed sweep rewards and empirical drop rates, stored only locally."""
|
||
from contextlib import contextmanager
|
||
from datetime import datetime
|
||
import json
|
||
import math
|
||
from pathlib import Path
|
||
import sqlite3
|
||
import threading
|
||
import weakref
|
||
|
||
|
||
def event_reward(response):
|
||
event = response.get("stageEvent")
|
||
if (response.get("triggerEvent") in (True, 1) and isinstance(event, dict)
|
||
and event.get("resCode", 0) in (0, "0") and event.get("hideStageId") is None
|
||
and isinstance(event.get("result"), dict)):
|
||
return event["result"]
|
||
|
||
|
||
def drop_info(catalog, type_id, kind="item"):
|
||
key = str(type_id)
|
||
if kind == "item" and key in catalog.monsters:
|
||
kind = "egg"
|
||
if kind in ("egg", "monster"):
|
||
name = catalog.monster(key).get("name", key) + ("蛋" if kind == "egg" else "")
|
||
else:
|
||
name = catalog.data.get("item_names", {}).get(key, f"物品 #{key}")
|
||
return {"key": f"{kind}:{key}", "typeId": key, "kind": kind, "name": name}
|
||
|
||
|
||
def integer(value):
|
||
if type(value) not in (int, float) or not math.isfinite(value) or int(value) != value:
|
||
raise ValueError("奖励数量不是有效整数")
|
||
return int(value)
|
||
|
||
|
||
def normalize_reward(catalog, reward):
|
||
if not isinstance(reward, dict):
|
||
raise ValueError("结算响应缺少奖励对象")
|
||
result = {key: integer(reward.get(key) or 0) for key in ("money", "exp", "ke", "ti")}
|
||
drops = {}
|
||
for field, kind in (("items", "item"), ("monsters", "monster")):
|
||
rows = reward.get(field) or []
|
||
if not isinstance(rows, list):
|
||
raise ValueError("结算奖励列表格式错误")
|
||
for row in rows:
|
||
if not isinstance(row, dict):
|
||
raise ValueError("结算奖励条目格式错误")
|
||
type_id = row.get("typeId", row.get("type"))
|
||
if type_id is None:
|
||
raise ValueError("结算奖励缺少物品编号")
|
||
number = integer(row.get("num", 1) if kind == "monster" else row.get("num"))
|
||
if number < 0:
|
||
raise ValueError("奖励物品数量不能为负数")
|
||
if not number:
|
||
continue
|
||
info = drop_info(catalog, type_id, kind)
|
||
entry = drops.setdefault(info["key"], info | {"num": 0})
|
||
entry["num"] += number
|
||
result["drops"] = list(drops.values())
|
||
return result
|
||
|
||
|
||
def reward_text(reward):
|
||
if reward is None:
|
||
return "奖励数据未确认,未计入统计"
|
||
parts = [f"{label} {reward[key]}" for key, label in (("money", "金币"), ("exp", "经验"), ("ke", "氪金"), ("ti", "体力")) if reward[key]]
|
||
parts.extend(f"{row['name']} ×{row['num']}" for row in reward["drops"])
|
||
return ";".join(parts) or "无物品或货币奖励"
|
||
|
||
|
||
def log_events(path):
|
||
with path.open(encoding="utf-8") as stream:
|
||
for line in stream:
|
||
try:
|
||
value = json.loads(line)
|
||
except ValueError:
|
||
continue
|
||
if isinstance(value, dict):
|
||
yield value
|
||
|
||
|
||
def possible_drops(catalog, stage_id, level):
|
||
reward = catalog.data.get("stage_info", {}).get(stage_id, {}).get("level", {}).get(str(level), {}).get("reward") or {}
|
||
found = {}
|
||
for piece in reward.get("rewards") or []:
|
||
if piece.get("num", 0) > 0 and piece.get("chance", 1) > 0:
|
||
for row in piece.get("monsters") or []:
|
||
info = drop_info(catalog, row["name"], "monster" if piece.get("monMode") else "egg")
|
||
found[info["key"]] = info
|
||
if piece.get("item_num", 0) > 0 and piece.get("item_chance", 1) > 0:
|
||
for row in piece.get("items") or []:
|
||
info = drop_info(catalog, str(row["name"]).split(",")[0])
|
||
found[info["key"]] = info
|
||
return found
|
||
|
||
|
||
def interval(hits, samples):
|
||
if not samples:
|
||
return None
|
||
z = 1.95996398454
|
||
rate = hits / samples
|
||
denominator = 1 + z * z / samples
|
||
center = (rate + z * z / (2 * samples)) / denominator
|
||
radius = z * math.sqrt(rate * (1 - rate) / samples + z * z / (4 * samples * samples)) / denominator
|
||
return max(0, center - radius), min(1, center + radius)
|
||
|
||
|
||
def analyze(catalog, data, stage_id, level, source="sweep"):
|
||
kinds = ("sweep", "event") if source == "all" else (source,)
|
||
totals = {"n": 0, "money": 0, "exp": 0, "ke": 0, "ti": 0, "spent": 0, "known": 0}
|
||
known = possible_drops(catalog, stage_id, level)
|
||
rows = {key: info | {"hits": 0, "units": 0, "cost_units": 0, "configured": True} for key, info in known.items()}
|
||
for kind in kinds:
|
||
key = f"{stage_id}:{level}:{kind}"
|
||
total = data.get("totals", {}).get(key, {})
|
||
for field in totals:
|
||
totals[field] += total.get(field, 0)
|
||
for row in data.get("drops", {}).get(key, []):
|
||
target = rows.setdefault(row["key"], {k: row[k] for k in ("key", "typeId", "kind", "name")} | {"hits": 0, "units": 0, "cost_units": 0, "configured": False})
|
||
target["hits"] += row["hits"]
|
||
target["units"] += row["units"]
|
||
target["cost_units"] += row.get("cost_units", 0)
|
||
for row in rows.values():
|
||
row.update(samples=totals["n"], rate=row["hits"] / totals["n"] if totals["n"] else None,
|
||
average=row["units"] / totals["n"] if totals["n"] else None, interval=interval(row["hits"], totals["n"]),
|
||
per_stamina=row["cost_units"] / totals["spent"] if totals["spent"] else None)
|
||
return totals, sorted(rows.values(), key=lambda row: (-(row["rate"] or 0), row["name"]))
|
||
|
||
|
||
SCHEMA = """
|
||
CREATE TABLE IF NOT EXISTS samples (
|
||
owner TEXT, source TEXT, stage TEXT, level TEXT, kind TEXT, timestamp REAL, reward TEXT,
|
||
PRIMARY KEY(owner, source));
|
||
CREATE TABLE IF NOT EXISTS totals (
|
||
owner TEXT, stage TEXT, level TEXT, kind TEXT, n INTEGER, money INTEGER, exp INTEGER,
|
||
ke INTEGER, ti INTEGER, spent INTEGER, known INTEGER DEFAULT 0, PRIMARY KEY(owner,stage,level,kind));
|
||
CREATE TABLE IF NOT EXISTS drops (
|
||
owner TEXT, stage TEXT, level TEXT, kind TEXT, key TEXT, typeId TEXT, category TEXT,
|
||
name TEXT, hits INTEGER, units INTEGER, cost_units INTEGER DEFAULT 0, PRIMARY KEY(owner,stage,level,kind,key));
|
||
CREATE TABLE IF NOT EXISTS metadata (key TEXT PRIMARY KEY, value TEXT);
|
||
"""
|
||
|
||
|
||
class SweepStatistics:
|
||
def __init__(self, catalog, path=None):
|
||
self.catalog = catalog
|
||
self.path = Path(path) if path else None
|
||
self.lock = threading.RLock()
|
||
self.memory = None
|
||
self.memo = None
|
||
self.backfilled = set()
|
||
self.error = ""
|
||
self.schema_ready = False
|
||
|
||
@contextmanager
|
||
def connection(self, write=False):
|
||
with self.lock:
|
||
if self.path:
|
||
if not write and not self.path.exists():
|
||
yield None
|
||
return
|
||
if write:
|
||
self.path.parent.mkdir(parents=True, exist_ok=True)
|
||
connection = sqlite3.connect(str(self.path), timeout=1)
|
||
else:
|
||
if self.memory is None:
|
||
if not write:
|
||
yield None
|
||
return
|
||
self.memory = sqlite3.connect(":memory:", check_same_thread=False)
|
||
self.memory_cleanup = weakref.finalize(self, self.memory.close)
|
||
connection = self.memory
|
||
connection.row_factory = sqlite3.Row
|
||
try:
|
||
if not self.schema_ready:
|
||
connection.executescript(SCHEMA)
|
||
if "known" not in {row["name"] for row in connection.execute("PRAGMA table_info(totals)")}:
|
||
connection.execute("ALTER TABLE totals ADD COLUMN known INTEGER DEFAULT 0")
|
||
connection.execute("UPDATE totals SET spent=0")
|
||
if "cost_units" not in {row["name"] for row in connection.execute("PRAGMA table_info(drops)")}:
|
||
connection.execute("ALTER TABLE drops ADD COLUMN cost_units INTEGER DEFAULT 0")
|
||
connection.commit()
|
||
self.schema_ready = True
|
||
with connection:
|
||
yield connection
|
||
finally:
|
||
if self.path:
|
||
connection.close()
|
||
|
||
def record(self, owner, stage, level, kind, source, timestamp, reward, spent=None):
|
||
with self.connection(write=True) as db:
|
||
added = self.insert_record(db, owner, stage, level, kind, source, timestamp, reward, spent)
|
||
if added:
|
||
self.memo = None
|
||
return added
|
||
|
||
def insert_record(self, db, owner, stage, level, kind, source, timestamp, reward, spent=None):
|
||
if kind not in ("sweep", "event"):
|
||
raise ValueError("未知的结算类型")
|
||
normalized = normalize_reward(self.catalog, reward)
|
||
cost = integer(spent) if spent is not None else None
|
||
if cost is not None and cost < 0:
|
||
cost = None
|
||
result = db.execute("INSERT OR IGNORE INTO samples VALUES(?,?,?,?,?,?,?)",
|
||
(str(owner), source, stage, str(level), kind, timestamp, json.dumps(normalized | {"spent": cost}, ensure_ascii=False)))
|
||
if result.rowcount == 0:
|
||
return False
|
||
db.execute("""INSERT INTO totals(owner,stage,level,kind,n,money,exp,ke,ti,spent,known) VALUES(?,?,?,?,1,?,?,?,?,?,?)
|
||
ON CONFLICT(owner,stage,level,kind) DO UPDATE SET n=n+1,
|
||
money=money+excluded.money, exp=exp+excluded.exp, ke=ke+excluded.ke,
|
||
ti=ti+excluded.ti, spent=spent+excluded.spent, known=known+excluded.known""",
|
||
(str(owner), stage, str(level), kind, normalized["money"], normalized["exp"], normalized["ke"], normalized["ti"], cost or 0, int(cost is not None)))
|
||
for row in normalized["drops"]:
|
||
db.execute("""INSERT INTO drops(owner,stage,level,kind,key,typeId,category,name,hits,units,cost_units) VALUES(?,?,?,?,?,?,?,?,1,?,?)
|
||
ON CONFLICT(owner,stage,level,kind,key) DO UPDATE SET hits=hits+1, units=units+excluded.units, cost_units=cost_units+excluded.cost_units""",
|
||
(str(owner), stage, str(level), kind, row["key"], row["typeId"], row["kind"], row["name"], row["num"], row["num"] if cost is not None else 0))
|
||
return True
|
||
|
||
def snapshot(self, owner):
|
||
owner = str(owner)
|
||
if self.memo and self.memo["owner"] == owner:
|
||
return self.memo
|
||
data = {"owner": owner, "totals": {}, "drops": {}, "error": self.error}
|
||
try:
|
||
with self.connection() as db:
|
||
if db:
|
||
for row in db.execute("SELECT * FROM totals WHERE owner=?", (owner,)):
|
||
key = f"{row['stage']}:{row['level']}:{row['kind']}"
|
||
data["totals"][key] = {field: row[field] for field in ("n", "money", "exp", "ke", "ti", "spent", "known")}
|
||
for row in db.execute("SELECT * FROM drops WHERE owner=?", (owner,)):
|
||
key = f"{row['stage']}:{row['level']}:{row['kind']}"
|
||
data["drops"].setdefault(key, []).append({field: row[field] for field in ("key", "typeId", "name", "hits", "units", "cost_units")} | {"kind": row["category"]})
|
||
except (sqlite3.Error, OSError) as error:
|
||
data["error"] = "本地统计读取失败:" + str(error)
|
||
self.memo = data
|
||
return data
|
||
|
||
def import_log(self, owner, trace_path):
|
||
"""Import only role-matched successful helper settlements, once per role."""
|
||
owner = str(owner)
|
||
if owner in self.backfilled or not trace_path:
|
||
return
|
||
self.backfilled.add(owner)
|
||
try:
|
||
with self.connection() as db:
|
||
if db and db.execute("SELECT 1 FROM metadata WHERE key=?", ("backfill:" + owner,)).fetchone():
|
||
return
|
||
requests, role, samples = {}, None, []
|
||
path = Path(trace_path)
|
||
for file in (path.with_name("network_debug.previous.jsonl"), path):
|
||
if not file.exists():
|
||
continue
|
||
for event in log_events(file):
|
||
body = event.get("body")
|
||
if not isinstance(body, dict):
|
||
continue
|
||
operation, direction = event.get("operation"), event.get("kind")
|
||
if operation == "读取角色" and direction == "response":
|
||
role = str((body.get("master") or {}).get("id"))
|
||
identifier = event.get("request_id")
|
||
if not identifier:
|
||
continue
|
||
if direction == "request" and role == owner:
|
||
if operation == "stageService/stageStart":
|
||
requests[identifier] = ("event", body.get("stageTypeId"), body.get("stageLevel"))
|
||
elif operation == "battleService/battleEnd":
|
||
battle = body.get("battleData") or {}
|
||
position = battle.get("battlePosition") or {}
|
||
if (battle.get("win") is True and position.get("battleType") == "stage"
|
||
and all(battle.get(key) == 0 for key in ("leftTime", "killNum", "totalDamage", "cheatNum"))):
|
||
requests[identifier] = ("sweep", position.get("stageId"), position.get("stageLevel"))
|
||
elif direction == "response" and identifier in requests and event.get("http_status") == 200 and body.get("resCode") in (0, "0"):
|
||
kind, stage, level = requests.pop(identifier)
|
||
reward = event_reward(body) if kind == "event" else body.get("reward")
|
||
if isinstance(reward, dict) and stage in self.catalog.data["stage_info"] and str(level) in self.catalog.data["stage_info"][stage]["level"]:
|
||
try:
|
||
timestamp = datetime.fromisoformat(event["time"]).timestamp()
|
||
cost = (body.get("stageEvent") or {}).get("costTi") if kind == "event" else body.get("costTi")
|
||
samples.append((owner, stage, level, kind, "request:" + identifier, timestamp, reward, cost))
|
||
except (ValueError, TypeError, KeyError):
|
||
continue
|
||
with self.connection(write=True) as db:
|
||
for sample in samples:
|
||
try:
|
||
self.insert_record(db, *sample)
|
||
except (ValueError, TypeError, KeyError):
|
||
continue
|
||
db.execute("INSERT OR REPLACE INTO metadata VALUES(?,?)", ("backfill:" + owner, "1"))
|
||
self.memo = None
|
||
except (sqlite3.Error, OSError, AttributeError, TypeError) as error:
|
||
self.error = "历史日志补录未完成:" + str(error)
|
||
self.memo = None
|