"""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