Files
myrzx_bot/ranch_assistant/drop_statistics.py
T

294 lines
15 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.
"""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