From b172d1ffb9e13479ec03a4a66a5fd0138bb67a1f Mon Sep 17 00:00:00 2001 From: AttilaNet Date: Sun, 8 Nov 2026 11:56:29 +0800 Subject: [PATCH] Record sweep rewards and add local drop and stamina analysis --- ranch_assistant/README.md | 9 +- ranch_assistant/account_storage.py | 3 +- ranch_assistant/drop_statistics.py | 293 ++++++++++++++++++ ranch_assistant/engine.py | 10 +- ranch_assistant/gui.py | 48 ++- ranch_assistant/presentation.py | 7 +- ranch_assistant/statistics_gui.py | 242 +++++++++++++++ ranch_assistant/sweeping.py | 35 ++- ranch_assistant/tests/test_account_removal.py | 3 +- ranch_assistant/tests/test_drop_statistics.py | 256 +++++++++++++++ 10 files changed, 890 insertions(+), 16 deletions(-) create mode 100644 ranch_assistant/drop_statistics.py create mode 100644 ranch_assistant/statistics_gui.py create mode 100644 ranch_assistant/tests/test_drop_statistics.py diff --git a/ranch_assistant/README.md b/ranch_assistant/README.md index 0e87a7d..9474baa 100644 --- a/ranch_assistant/README.md +++ b/ranch_assistant/README.md @@ -57,6 +57,13 @@ 首次读取后按账号/角色保存本地地图缓存,重启、切换页面或普通监控刷新均复用缓存,仅“刷新关卡”(或本页右键刷新)更新列表。 每关可勾选、选择已解锁难度和本日上限;满足游戏原有条件的普通关卡可接口扫荡, 其余请在游戏内手动战斗。 +- 扫荡奖励:普通扫荡读取 `battleEnd.reward`,奖励事件读取 `stageEvent.result`,日志列出本次实际获得的物品、魔物蛋、金币和经验。 +- 数据分析:紧邻“自动扫荡”的独立页签。左侧按地区选择关卡和难度,右侧显示条形图与掉落明细;关卡和可能掉落来自本地静态配置。 + 可分别查看普通扫荡、奖励事件或合计,显示样本数、出现次数、获得总数量、实测掉落率、每次平均数量及95%区间。 + “每点体力数量”按已知消耗样本的获得数量除以实际扣除体力计算,图表可切换到该指标;未知消耗样本不参与,体力奖励返还单独列出。 + 无样本显示“—”;同次获得多件物品只计一次出现,实测掉落率为出现次数除以已确认样本数。 + 数据按账号/角色保存在本地 `sweep_rewards.sqlite3`,重启保留;首次后台补录现有调试日志中能匹配角色、关卡和成功结算的记录,重复响应不重复计数。 + “刷新本地统计”仅读取本机数据;统计与图表不额外请求服务器,不上传数据。实测概率随样本变化,不代表官方掉率。 - 每日事务:集中查看每日签到礼包、七日签到、累计奖励、VIP日奖和邮件附件; 可立即领取勾选项目,或开启自动执行时领取;手动刷新不领奖。 - 离线演示:不连接游戏服务器即可查看数据、策略和模拟操作。 @@ -228,7 +235,7 @@ - 自定义表:`typeId, sell_money, sell_exp, time_total`(秒),可只提供部分 覆盖列;中文列名“编号、派遣金币、强化经验、孵化秒数”也支持。 - 测试:`python -m unittest discover -s ranch_assistant/tests -v`。 -- 175 项本地测试通过,覆盖登录、会话隔离、账号关闭与移除、菜单账号路由、数字框滚轮、地图缓存、请求计数、等级与体力结算、成长同步、孵蛋与补货、批量喂养、派遣、赠礼、统一策略配置、委托、扫荡和每日奖励。 +- 189 项本地测试通过,覆盖登录、会话隔离、账号关闭与移除、菜单账号路由、数字框滚轮、地图缓存、请求计数、等级与体力结算、成长同步、孵蛋与补货、批量喂养、派遣、赠礼、统一策略配置、委托、扫荡、奖励统计与体力效率和每日奖励。 新增牧场树形/平铺切换、分组数量与空位、刷新保留折叠和控件、4S保留条件、随机刷新间隔及到期独立同步的回归测试。 双账号与大量库存的界面响应继续通过测试;测试使用本地模拟数据和模拟服务,不操作真实账号库存。 - 网络写请求发生异常后不会直接重试,以免重复消耗魔物或物品。 diff --git a/ranch_assistant/account_storage.py b/ranch_assistant/account_storage.py index 4749d8b..07d33ea 100644 --- a/ranch_assistant/account_storage.py +++ b/ranch_assistant/account_storage.py @@ -7,7 +7,8 @@ import shutil DEFAULT_ACCOUNT_ENTRIES = ("credentials.json", "credentials.tmp", "sessions", "roles", "settings.json", "settings.tmp", "purchase_budget.json", "purchase_budget.tmp", "daily_claims.json", "daily_claims.tmp", "sweep_runs.json", "sweep_runs.tmp", - "maps.json", "maps.tmp", "network_debug.jsonl", "network_debug.previous.jsonl") + "maps.json", "maps.tmp", "network_debug.jsonl", "network_debug.previous.jsonl", + "sweep_rewards.sqlite3", "sweep_rewards.sqlite3-journal", "sweep_rewards.sqlite3-wal", "sweep_rewards.sqlite3-shm") def profile_directory(root, identifier): diff --git a/ranch_assistant/drop_statistics.py b/ranch_assistant/drop_statistics.py new file mode 100644 index 0000000..5737d43 --- /dev/null +++ b/ranch_assistant/drop_statistics.py @@ -0,0 +1,293 @@ +"""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 diff --git a/ranch_assistant/engine.py b/ranch_assistant/engine.py index 3715fc1..5af406d 100644 --- a/ranch_assistant/engine.py +++ b/ranch_assistant/engine.py @@ -12,6 +12,7 @@ from .management import expansion_quote, manual_monster_actions from .gifts import GiftPlanner from .master_sync import MasterSync from .stage_cache import StageCache +from .drop_statistics import reward_text class Engine: @@ -194,10 +195,11 @@ class Engine: return self.snapshot, plans, "扫荡需要登录真实账号;演示不会提交战斗" result = self.sweeper.run(self.client, self.snapshot, stage, self.sweep_policy) self.read_snapshot() - if self.sweeper.last_outcome == "event": - from .maps import reward_summary - return self.snapshot, self.plans(), f"探索奖励事件已结算:{stage.number} {stage.name} / 难度{stage.level};" + reward_summary(self.catalog, result["stageEvent"]["result"]) - return self.snapshot, self.plans(), f"扫荡完成:{stage.number} {stage.name} / 难度{stage.level}" + label = "探索奖励事件已结算" if self.sweeper.last_outcome == "event" else "扫荡完成" + message = f"{label}:{stage.number} {stage.name} / 难度{stage.level};" + reward_text(self.sweeper.last_reward) + if self.sweeper.statistics_error: + message += ";" + self.sweeper.statistics_error + return self.snapshot, self.plans(), message if action.kind == "buy": price = int(self.catalog.data["markets"][action.payload["id"]]["money"]) self.purchase_budget.record(self.snapshot.now, price * action.payload["num"], self.policy.daily_buy_money) diff --git a/ranch_assistant/gui.py b/ranch_assistant/gui.py index 313d08a..6d5c2e8 100644 --- a/ranch_assistant/gui.py +++ b/ranch_assistant/gui.py @@ -30,6 +30,8 @@ from .ranch_gui import RanchView from .policy_io import portable_config, import_config from .table_widgets import table_item from .stage_cache import StageCache +from .drop_statistics import SweepStatistics +from .statistics_gui import StatisticsPage APP_VERSION = "1.1.0" GAME_VERSION = "1.9.68" @@ -281,11 +283,14 @@ class Window(ActivityPages, W.QMainWindow): self.yield_tab() self.quests_tab() self.maps_tab() + self.analysis_page = StatisticsPage(self.catalog) + self.analysis_page.refresh_requested.connect(self.refresh_analysis) + self.tabs.addTab(self.analysis_page, "数据分析") self.daily_tab() self.plans = table(["操作", "下一步计划(每轮只执行一项,并重新读取状态)"]) self.tabs.addTab(self.plans, "执行计划") order = [self.tabs.widget(0), self.slot_page, self.inventory_tabs, self.room_page, - self.daily_page, self.automation_page, self.gift_page, self.quests_table.parentWidget(), self.map_page, + self.daily_page, self.automation_page, self.gift_page, self.quests_table.parentWidget(), self.map_page, self.analysis_page, self.plans, self.yields.parentWidget()] for page in order: self.tabs.addTab(page, self.tabs.tabText(self.tabs.indexOf(page))) @@ -1004,9 +1009,21 @@ class Window(ActivityPages, W.QMainWindow): self.report("收益资料已从本地表刷新") elif tab is self.map_page: self.refresh_maps() + elif tab is self.analysis_page: + self.refresh_analysis() else: self.refresh() + def refresh_analysis(self): + if self.closed or self.engine.snapshot is None: + return + if self.busy: + self.pending_refresh = self.analysis_page + return + engine = self.engine + owner = engine.snapshot.raw["master"]["id"] + self.submit("analysis", lambda: engine.sweeper.statistics.snapshot(owner)) + def reload_saved_sessions(self): previous = self.saved_sessions.currentData() self.saved_sessions.clear() @@ -1112,11 +1129,16 @@ class Window(ActivityPages, W.QMainWindow): managed = set() if kind == "connected" else set(engine.planner.managed) preparing = time.perf_counter() cache = engine.stage_cache + statistics = engine.sweeper.statistics + client = engine.client if kind == "connected": session = value[0].session folder = self.profile_root / "roles" / identity(session) if isinstance(session, Session) and session.role_id else self.state cache = StageCache(catalog, folder / "maps.json") - views = prepare_views(catalog, snapshot, managed, cache) + statistics = SweepStatistics(catalog, folder / "sweep_rewards.sqlite3") + client = value[0] + statistics.import_log(snapshot.raw["master"]["id"], getattr(getattr(client, "trace", None), "path", None)) + views = prepare_views(catalog, snapshot, managed, cache, statistics) return Presented(value, views, (time.perf_counter() - preparing) * 1000, (time.perf_counter() - started) * 1000) return value job = Job(kind, background) @@ -1171,6 +1193,11 @@ class Window(ActivityPages, W.QMainWindow): self.arm_hatching() elif kind == "heartbeat": self.report(value) + elif kind == "analysis": + if self.prepared_views: + self.prepared_views.drop_statistics = value + self.analysis_page.set_data(self.catalog, value) + self.report("已从本地刷新掉落统计") elif kind == "connected": client, snapshot = value if self.connection_guard and not self.connection_guard(client.session): @@ -1185,6 +1212,8 @@ class Window(ActivityPages, W.QMainWindow): self.engine.snapshot = snapshot if self.prepared_views and self.prepared_views.snapshot is snapshot and self.prepared_views.stage_cache: self.engine.stage_cache = self.prepared_views.stage_cache + if self.prepared_views.statistics_store: + self.engine.sweeper.statistics = self.prepared_views.statistics_store self.reset_map_view() if isinstance(client.session, Session): if client.session.account_name and client.session.account_name != self.account.text().strip(): @@ -1411,6 +1440,7 @@ class Window(ActivityPages, W.QMainWindow): def set_presentation_active(self, active): self.presentation_active = active if not active: + self.analysis_page.row_batch.stop() for name in ("map_render_timer", "monster_render_timer"): timer = getattr(self, name, None) if timer: @@ -1427,6 +1457,8 @@ class Window(ActivityPages, W.QMainWindow): return snapshot, plans = self.latest_render page = self.tabs.currentWidget() + if page is not self.analysis_page: + self.analysis_page.row_batch.stop() for name, target in (("map_render_timer", self.map_page), ("monster_render_timer", self.monster_page)): timer = getattr(self, name, None) if timer and page is not target: @@ -1452,6 +1484,16 @@ class Window(ActivityPages, W.QMainWindow): self.render_quests(snapshot) elif page is self.map_page: self.render_maps() + elif page is self.analysis_page: + views = self.prepared_views + owner = str(snapshot.raw["master"]["id"]) + if views and views.snapshot is snapshot and views.drop_statistics is not None and views.drop_statistics.get("owner") == owner: + data = views.drop_statistics + elif self.analysis_page.data.get("owner") == owner: + data = self.analysis_page.data + else: + data = {"owner": owner, "totals": {}, "drops": {}} + self.analysis_page.set_data(self.catalog, data) elif page is self.daily_page: self.render_daily() elif page is self.target.parentWidget() or page is self.automation_page: @@ -1566,6 +1608,7 @@ class Window(ActivityPages, W.QMainWindow): self.engine.client.close() self.engine = Engine(self.catalog) self.reset_map_view() + self.analysis_page.set_data(self.catalog, {"owner": "", "totals": {}, "drops": {}}) self.active_identity = None self.state = self.profile_root self.load_config(copy.deepcopy(self.default_config)) @@ -1818,6 +1861,7 @@ class Window(ActivityPages, W.QMainWindow): self.closed = True self.timer.stop() self.hatch_timer.stop() + self.analysis_page.row_batch.stop() if hasattr(self, "auto_save_timer"): self.auto_save_timer.stop() if hasattr(self.eggs, "row_batch"): diff --git a/ranch_assistant/presentation.py b/ranch_assistant/presentation.py index 423f043..dd2f464 100644 --- a/ranch_assistant/presentation.py +++ b/ranch_assistant/presentation.py @@ -26,6 +26,8 @@ class Views: map_source: str maps: list stage_cache: object = None + statistics_store: object = None + drop_statistics: dict = None @dataclass @@ -36,6 +38,7 @@ class Presented: worker_ms: float = 0 -def prepare_views(catalog, snapshot, managed, stage_cache=None): +def prepare_views(catalog, snapshot, managed, stage_cache=None, statistics=None): return Views(snapshot, repr(snapshot.raw["monsters"]), set(managed), monster_rows(catalog, snapshot, managed), - str(snapshot.raw["master"]["id"]), stage_cache.get(snapshot) if stage_cache else stages(catalog, snapshot), stage_cache) + str(snapshot.raw["master"]["id"]), stage_cache.get(snapshot) if stage_cache else stages(catalog, snapshot), stage_cache, + statistics, statistics.snapshot(snapshot.raw["master"]["id"]) if statistics else None) diff --git a/ranch_assistant/statistics_gui.py b/ranch_assistant/statistics_gui.py new file mode 100644 index 0000000..e2a058b --- /dev/null +++ b/ranch_assistant/statistics_gui.py @@ -0,0 +1,242 @@ +"""Local single-stage drop analysis using native Qt tables and charts.""" +from PySide6 import QtCore as C, QtGui as G, QtWidgets as W +from PySide6.QtCharts import QChart, QChartView, QHorizontalBarSeries, QBarSet, QBarCategoryAxis, QValueAxis + +from .drop_statistics import analyze +from .native_widgets import ComboBox, RowBatch +from .table_widgets import TreeItem, table_item, SORT_ROLE + + +class StatisticsPage(W.QWidget): + refresh_requested = C.Signal() + + def __init__(self, catalog): + super().__init__() + self.catalog = catalog + self.data = {"owner": "", "totals": {}, "drops": {}} + self.current_key = None + self.static_source = None + self.building = False + self.stage_items, self.level_items = {}, {} + self.row_batch = RowBatch(self) + layout = W.QVBoxLayout(self) + tools = W.QHBoxLayout() + self.search = W.QLineEdit() + self.search.setPlaceholderText("搜索关卡编号或名称") + self.source = ComboBox() + for label, value in (("普通扫荡", "sweep"), ("奖励事件", "event"), ("合计", "all")): + self.source.addItem(label, value) + self.chart_metric = ComboBox() + self.chart_metric.addItem("实测掉落率", "rate") + self.chart_metric.addItem("每点体力数量", "per_stamina") + refresh = W.QPushButton("刷新本地统计") + refresh.clicked.connect(self.refresh_requested) + tools.addWidget(self.search, 1) + tools.addWidget(W.QLabel("统计范围")) + tools.addWidget(self.source) + tools.addWidget(self.chart_metric) + tools.addWidget(refresh) + layout.addLayout(tools) + self.summary = W.QLabel("选择关卡和难度,查看当前账号的本地掉落统计。") + self.summary.setWordWrap(True) + layout.addWidget(self.summary) + self.splitter = W.QSplitter(C.Qt.Orientation.Horizontal) + self.tree = W.QTreeWidget() + self.tree.setHeaderLabels(["关卡 / 难度", "扫荡", "事件"]) + self.tree.setUniformRowHeights(True) + self.tree.setSelectionMode(W.QAbstractItemView.SelectionMode.SingleSelection) + self.tree.setMinimumWidth(250) + self.tree.setColumnWidth(0, 180) + self.tree.setColumnWidth(1, 55) + self.tree.setColumnWidth(2, 55) + self.splitter.addWidget(self.tree) + right = W.QWidget() + right_layout = W.QVBoxLayout(right) + self.chart_scroll = W.QScrollArea() + self.chart_scroll.setWidgetResizable(True) + self.chart_scroll.setFrameShape(W.QFrame.Shape.NoFrame) + self.chart_view = QChartView() + self.chart_view.setRenderHint(G.QPainter.RenderHint.Antialiasing) + self.chart_scroll.setWidget(self.chart_view) + self.chart_scroll.setMinimumHeight(150) + right_layout.addWidget(self.chart_scroll, 1) + self.table = W.QTableWidget(0, 10) + self.table.setHorizontalHeaderLabels(["掉落物", "类别", "出现次数", "总数量", "样本数", "实测掉落率", "平均数量/次", "每点体力数量", "95%区间", "静态配置"]) + self.table.setEditTriggers(W.QAbstractItemView.EditTrigger.NoEditTriggers) + self.table.setSelectionBehavior(W.QAbstractItemView.SelectionBehavior.SelectRows) + self.table.horizontalHeader().setSectionResizeMode(W.QHeaderView.ResizeMode.ResizeToContents) + self.table.horizontalHeader().setStretchLastSection(True) + self.table.verticalHeader().setDefaultSectionSize(22) + right_layout.addWidget(self.table, 1) + self.splitter.addWidget(right) + self.splitter.setSizes([320, 740]) + self.splitter.setStretchFactor(1, 1) + layout.addWidget(self.splitter, 1) + note = W.QLabel("实测掉落率 = 出现次数 ÷ 已确认样本数;同次多件只记一次出现。每点体力数量 = 已知消耗样本的物品数量 ÷ 实际扣除体力,不扣减奖励返还的体力。\n不同难度、扫荡和事件分别统计;未知消耗样本不参与体力效率计算,消耗为0时不计算比值。无样本显示“—”;95%区间反映样本不确定性,实测结果不是官方掉率。") + note.setWordWrap(True) + layout.addWidget(note) + self.tree.currentItemChanged.connect(self.selection_changed) + self.source.currentIndexChanged.connect(self.render_detail) + self.chart_metric.currentIndexChanged.connect(self.render_detail) + self.search.textChanged.connect(self.filter_tree) + self.render_detail() + + def set_data(self, catalog, data): + if self.data is data and self.catalog is catalog and self.static_source is catalog.data.get("stage_info"): + if self.building and not self.row_batch.running: + self.build_tree() + return + changed_owner = self.data.get("owner") != data.get("owner") + self.catalog, self.data = catalog, data + if changed_owner: + self.current_key = None + self.tree.setCurrentItem(None) + if self.current_key and self.current_key[0] not in catalog.data.get("stage_info", {}): + self.current_key = None + if self.static_source is not catalog.data.get("stage_info") or self.building and not self.row_batch.running: + self.build_tree() + else: + self.update_counts() + self.render_detail() + + def count(self, stage, level, kind): + return self.data.get("totals", {}).get(f"{stage}:{level}:{kind}", {}).get("n", 0) + + def build_tree(self): + self.static_source = self.catalog.data.get("stage_info") + self.row_batch.stop() + self.building = True + blocker = C.QSignalBlocker(self.tree) + self.tree.clear() + del blocker + self.stage_items, self.level_items = {}, {} + cities = {} + rows = sorted(self.catalog.data.get("stage_info", {}).items(), key=lambda pair: (int(pair[1].get("city") or 0), pair[1].get("tagname") or pair[0])) + def apply(pair): + key, stage = pair + city_id = str(int(stage.get("city") or 0)) + if city_id not in cities: + name = self.catalog.data["game_setting"].get("cityInfo", {}).get(city_id, {}).get("name", f"地区 {city_id}") + cities[city_id] = TreeItem(self.tree, [name]) + city = cities[city_id] + item = TreeItem(city, [f"{stage.get('tagname') or key} {stage.get('name') or key}"]) + levels = sorted(stage.get("level", {}), key=lambda value: int(value)) + item.setData(0, C.Qt.ItemDataRole.UserRole, (key, levels[-1]) if levels else None) + item.setToolTip(0, item.text(0) + f"\n关卡编号:{key}") + self.stage_items[key] = item + for level in levels: + child = TreeItem(item, [f"难度 {level}"]) + child.setData(0, C.Qt.ItemDataRole.UserRole, (key, str(level))) + self.level_items[key, str(level)] = child + self.row_batch.start(rows, apply, self.finish_tree) + + def finish_tree(self): + self.building = False + self.update_counts() + + def update_counts(self): + for (stage, level), item in self.level_items.items(): + for column, kind in ((1, "sweep"), (2, "event")): + count = self.count(stage, level, kind) + item.setText(column, str(count)) + item.setTextAlignment(column, C.Qt.AlignmentFlag.AlignCenter) + for stage, item in self.stage_items.items(): + for column in (1, 2): + item.setText(column, str(sum(int(item.child(i).text(column) or 0) for i in range(item.childCount())))) + item.setTextAlignment(column, C.Qt.AlignmentFlag.AlignCenter) + self.filter_tree() + if self.current_key in self.level_items: + self.tree.setCurrentItem(self.level_items[self.current_key]) + if self.current_key is None: + first = next((key for key in self.level_items if any(self.count(*key, kind) for kind in ("sweep", "event"))), None) + if first: + item = self.level_items[first] + item.parent().setExpanded(True) + item.parent().parent().setExpanded(True) + self.tree.setCurrentItem(item) + + def filter_tree(self): + query = self.search.text().strip().casefold() + for key, item in self.stage_items.items(): + item.setHidden(bool(query and query not in (key + " " + item.text(0)).casefold())) + if query and not item.isHidden(): + item.setExpanded(True) + item.parent().setExpanded(True) + for i in range(self.tree.topLevelItemCount()): + city = self.tree.topLevelItem(i) + city.setHidden(all(city.child(j).isHidden() for j in range(city.childCount()))) + + def selection_changed(self, item, previous=None): + if item is not None: + self.current_key = item.data(0, C.Qt.ItemDataRole.UserRole) + self.render_detail() + + def render_detail(self, *args): + self.table.setSortingEnabled(False) + self.table.setRowCount(0) + chart = QChart() + chart.setAnimationOptions(QChart.AnimationOption.NoAnimation) + chart.setBackgroundRoundness(0) + chart.legend().hide() + chart.setFont(self.font()) + chart.setMargins(C.QMargins(4, 4, 4, 4)) + if self.palette().color(G.QPalette.ColorRole.Window).lightness() < 128: + chart.setTheme(QChart.ChartTheme.ChartThemeDark) + rows = [] + metric = self.chart_metric.currentData() + if self.current_key: + stage_id, level = self.current_key + stage = self.catalog.data["stage_info"][stage_id] + totals, rows = analyze(self.catalog, self.data, stage_id, level, self.source.currentData()) + counts = f"扫荡 {self.count(stage_id, level, 'sweep')} 次 / 事件 {self.count(stage_id, level, 'event')} 次" + average = f";平均金币 {totals['money']/totals['n']:.2f}、经验 {totals['exp']/totals['n']:.2f}" if totals["n"] else ";尚无此范围的样本,完成结算后自动记录" + self.summary.setText(f"{stage.get('tagname') or stage_id} {stage.get('name') or stage_id} / 难度 {level} | {counts}\n{self.source.currentText()}:{totals['n']} 个已确认样本;累计金币 {totals['money']}、经验 {totals['exp']}{average}\n已知体力消耗样本 {totals['known']}/{totals['n']};消耗体力 {totals['spent']};奖励返还体力 {totals['ti']}" + ("\n" + self.data["error"] if self.data.get("error") else "")) + chart.setTitle(self.chart_metric.currentText() if totals["n"] else "尚无样本") + self.table.setRowCount(len(rows)) + kinds = {"item": "物品", "egg": "魔物蛋", "monster": "魔物"} + for i, row in enumerate(rows): + confidence = row["interval"] + values = [row["name"], kinds[row["kind"]], row["hits"], row["units"], row["samples"], + f"{row['rate']*100:.2f}%" if row["rate"] is not None else "—", + f"{row['average']:.3f}" if row["average"] is not None else "—", + f"{row['per_stamina']:.6g}" if row["per_stamina"] is not None else "—", + f"{confidence[0]*100:.1f}%~{confidence[1]*100:.1f}%" if confidence else "—", + "可能掉落" if row["configured"] else "实际观测"] + for column, value in enumerate(values): + item = table_item(value, column) + if column == 5: + item.setData(SORT_ROLE, row["rate"] if row["rate"] is not None else -1) + elif column == 7: + item.setData(SORT_ROLE, row["per_stamina"] if row["per_stamina"] is not None else -1) + self.table.setItem(i, column, item) + if totals["n"] and rows and any(row[metric] is not None for row in rows): + graph_rows = sorted(rows, key=lambda row: row[metric] or 0) + series = QHorizontalBarSeries() + bars = QBarSet(self.chart_metric.currentText()) + values = [(row[metric] or 0) * (100 if metric == "rate" else 1) for row in graph_rows] + bars.append(values) + series.append(bars) + chart.addSeries(series) + x_axis, y_axis = QValueAxis(), QBarCategoryAxis() + x_axis.setRange(0, 100 if metric == "rate" else max(max(values) * 1.15, .001)) + x_axis.setLabelFormat("%.0f%%" if metric == "rate" else "%.3g") + x_axis.setTitleText("出现次数 / 已确认样本数" if metric == "rate" else "获得数量 / 实际扣除体力") + names = [row["name"] for row in graph_rows] + y_axis.append([row["name"] if names.count(row["name"]) == 1 else f"{row['name']} #{row['typeId']}" for row in graph_rows]) + chart.addAxis(x_axis, C.Qt.AlignmentFlag.AlignBottom) + chart.addAxis(y_axis, C.Qt.AlignmentFlag.AlignLeft) + series.attachAxis(x_axis) + series.attachAxis(y_axis) + series.hovered.connect(lambda active, index, barset: W.QToolTip.showText(G.QCursor.pos(), + f"{graph_rows[index]['name']}:" + (f"{graph_rows[index]['hits']}/{totals['n']} = {graph_rows[index]['rate']*100:.2f}%" if metric == "rate" else f"每点体力 {graph_rows[index]['per_stamina']:.6g} 个")) if active else W.QToolTip.hideText()) + elif totals["n"] and metric == "per_stamina": + chart.setTitle("没有已知的非零体力消耗,暂不计算体力效率") + else: + self.summary.setText(self.data.get("error") or "请选择左侧的关卡和难度;关卡列表来自本地配置,不请求服务器。") + chart.setTitle("选择关卡后显示实测掉落率") + self.table.setSortingEnabled(True) + self.chart_view.setMinimumHeight(max(200, min(1400, len(rows) * 32 + 100))) + old = self.chart_view.chart() + self.chart_view.setChart(chart) + if old: + old.deleteLater() diff --git a/ranch_assistant/sweeping.py b/ranch_assistant/sweeping.py index 4feb838..4608c9b 100644 --- a/ranch_assistant/sweeping.py +++ b/ranch_assistant/sweeping.py @@ -2,16 +2,16 @@ from dataclasses import dataclass, field import json from pathlib import Path +import sqlite3 +import uuid from .daily import day from .maps import stages +from .drop_statistics import SweepStatistics, event_reward, normalize_reward def settled_reward_event(response): - event = response.get("stageEvent") - return (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_reward(response) is not None @dataclass @@ -30,6 +30,28 @@ class SweepRunner: 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) as error: + # A local statistics failure must never repeat an awarded request. + 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. @@ -140,6 +162,7 @@ class SweepRunner: def run(self, client, snapshot, stage, policy): 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("此关卡未勾选或已达本日次数上限") @@ -148,12 +171,13 @@ class SweepRunner: raise ValueError(reason) key = self.key(snapshot, stage) self.state["counts"][key] = self.used(snapshot, stage) + 1 - self.state["pending"] = {"stage": stage.stage_id, "level": stage.level, "phase": "开始请求待确认"} + self.state["pending"] = {"stage": stage.stage_id, "level": stage.level, "phase": "开始请求待确认", "sampleId": uuid.uuid4().hex} self.save() # Reserve before the first non-retryable write, including timeouts. started = client.call("stageService/stageStart", {"stageTypeId": stage.stage_id, "stageLevel": stage.level}) 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" @@ -175,6 +199,7 @@ class SweepRunner: self.state["pending"]["phase"] = "扫荡结算待确认" self.save() result = client.call("battleService/battleEnd", {"battleData": battle}) + 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}) diff --git a/ranch_assistant/tests/test_account_removal.py b/ranch_assistant/tests/test_account_removal.py index 0b93830..ec8c8db 100644 --- a/ranch_assistant/tests/test_account_removal.py +++ b/ranch_assistant/tests/test_account_removal.py @@ -93,11 +93,12 @@ class RemovalTests(unittest.TestCase): (folder / "sessions" / "old.json").write_text("synthetic", encoding="utf-8") (folder / "roles" / "role").mkdir(parents=True) (folder / "roles" / "role" / "maps.json").write_text("{}", encoding="utf-8") + (folder / "sweep_rewards.sqlite3").write_text("synthetic statistics", encoding="utf-8") shared = folder / "shared-note.txt" shared.write_text("keep", encoding="utf-8") try: self.remove(hub, "default") - for name in ("credentials.json", "sessions", "roles", "settings.json"): + for name in ("credentials.json", "sessions", "roles", "settings.json", "sweep_rewards.sqlite3"): self.assertFalse((folder / name).exists()) self.assertTrue(sentinel.exists()) self.assertTrue(shared.exists()) diff --git a/ranch_assistant/tests/test_drop_statistics.py b/ranch_assistant/tests/test_drop_statistics.py new file mode 100644 index 0000000..95bb37d --- /dev/null +++ b/ranch_assistant/tests/test_drop_statistics.py @@ -0,0 +1,256 @@ +import copy +import json +import os +import sqlite3 +from types import SimpleNamespace +import unittest +from unittest.mock import patch + +os.environ.setdefault("QT_QPA_PLATFORM", "offscreen") +from PySide6 import QtWidgets as W +from PySide6.QtTest import QTest + +from ranch_assistant.drop_statistics import SweepStatistics, analyze, normalize_reward, reward_text +from ranch_assistant.engine import Engine +from ranch_assistant.gui import Window +from ranch_assistant.statistics_gui import StatisticsPage +from ranch_assistant.model import Catalog +from ranch_assistant.sweeping import SweepPolicy, SweepRunner +from ranch_assistant.tests.test_activities import scenario, FakeClient +from ranch_assistant.tests.test_core import workspace_temp + + +REWARD = {"money": 32, "exp": 64, "ke": 0, "ti": 0, "items": [ + {"id": 100, "typeId": 30005, "num": 2}, {"id": 100, "typeId": 30005, "num": 3}, + {"id": 101, "typeId": 1001010, "num": 1}], "monsters": []} + + +class DropStatisticsTests(unittest.TestCase): + def setUp(self): + self.catalog = Catalog() + + def test_quantity_is_aggregated_but_presence_is_counted_once_per_sample(self): + store = SweepStatistics(self.catalog) + store.record(1, "0101", "3", "sweep", "one", 1000, REWARD) + store.record(1, "0101", "3", "sweep", "two", 1001, {"money": 32, "items": []}) + totals, rows = analyze(self.catalog, store.snapshot(1), "0101", "3") + item = next(row for row in rows if row["key"] == "item:30005") + self.assertEqual((item["hits"], item["units"], item["samples"], item["rate"], item["average"]), (1, 5, 2, .5, 2.5)) + self.assertEqual(totals["money"], 64) + self.assertLessEqual(item["interval"][0], .5) + self.assertGreaterEqual(item["interval"][1], .5) + self.assertIn("×5", reward_text(normalize_reward(self.catalog, REWARD))) + + def test_items_per_stamina_uses_known_cost_totals_and_ignores_unknown_samples(self): + store = SweepStatistics(self.catalog) + store.record(1, "0101", "3", "sweep", "one", 1, {"items": [{"typeId": 30005, "num": 5}]}, spent=10) + store.record(1, "0101", "3", "sweep", "two", 2, {"items": [{"typeId": 30005, "num": 2}]}, spent=20) + store.record(1, "0101", "3", "sweep", "unknown", 3, {"items": [{"typeId": 30005, "num": 7}]}) + total, rows = analyze(self.catalog, store.snapshot(1), "0101", "3") + row = next(row for row in rows if row["key"] == "item:30005") + self.assertEqual((total["known"], total["spent"], total["n"]), (2, 30, 3)) + self.assertEqual((row["units"], row["cost_units"]), (14, 7)) + self.assertAlmostEqual(row["per_stamina"], 7 / 30) + self.assertIsNone(next(row for row in analyze(self.catalog, store.snapshot(1), "0102", "1")[1])["per_stamina"]) + + def test_zero_stamina_and_refunds_do_not_create_infinite_or_net_cost_efficiency(self): + store = SweepStatistics(self.catalog) + store.record(1, "0101", "3", "event", "free", 1, {"items": [{"typeId": 30005, "num": 2}]}, spent=0) + total, rows = analyze(self.catalog, store.snapshot(1), "0101", "3", "event") + self.assertEqual(total["known"], 1) + self.assertTrue(all(row["per_stamina"] is None for row in rows)) + store.record(1, "0101", "1", "event", "refund", 2, {"ti": 5, "items": [{"typeId": 30005, "num": 2}]}, spent=5) + total, rows = analyze(self.catalog, store.snapshot(1), "0101", "1", "event") + self.assertEqual((total["spent"], total["ti"]), (5, 5)) + self.assertEqual(next(r for r in rows if r["key"] == "item:30005")["per_stamina"], .4) + + def test_earlier_database_without_known_cost_columns_keeps_rewards_and_migrates(self): + with workspace_temp() as folder: + path = folder / "old.sqlite3" + db = sqlite3.connect(path) + try: + db.executescript("""CREATE TABLE totals(owner TEXT,stage TEXT,level TEXT,kind TEXT,n INTEGER,money INTEGER,exp INTEGER,ke INTEGER,ti INTEGER,spent INTEGER,PRIMARY KEY(owner,stage,level,kind)); + CREATE TABLE drops(owner TEXT,stage TEXT,level TEXT,kind TEXT,key TEXT,typeId TEXT,category TEXT,name TEXT,hits INTEGER,units INTEGER,PRIMARY KEY(owner,stage,level,kind,key)); + INSERT INTO totals VALUES('1','0101','3','sweep',1,32,64,0,0,16); + INSERT INTO drops VALUES('1','0101','3','sweep','item:30005','30005','item','sample',1,2);""") + db.commit() + finally: + db.close() + store = SweepStatistics(self.catalog, path) + total, rows = analyze(self.catalog, store.snapshot(1), "0101", "3") + self.assertEqual((total["n"], total["known"], total["spent"]), (1, 0, 0)) + self.assertEqual(next(r for r in rows if r["key"] == "item:30005")["units"], 2) + store.record(1, "0101", "3", "sweep", "new", 2, {"items": [{"typeId": 30005, "num": 3}]}, spent=10) + self.assertEqual(next(r for r in analyze(self.catalog, store.snapshot(1), "0101", "3")[1] if r["key"] == "item:30005")["per_stamina"], .3) + + def test_role_difficulty_source_and_repeated_response_are_isolated_after_restart(self): + with workspace_temp() as folder: + path = folder / "rewards.sqlite3" + store = SweepStatistics(self.catalog, path) + self.assertTrue(store.record(1, "0101", "3", "sweep", "same", 1, REWARD)) + self.assertFalse(store.record(1, "0101", "3", "sweep", "same", 1, REWARD)) + store.record(1, "0101", "1", "sweep", "difficulty", 2, REWARD) + store.record(1, "0101", "3", "event", "event", 3, {"items": []}) + store.record(2, "0101", "3", "sweep", "same", 4, REWARD) + restored = SweepStatistics(self.catalog, path) + totals, rows = analyze(self.catalog, restored.snapshot(1), "0101", "3", "all") + self.assertEqual(totals["n"], 2) + self.assertEqual(next(r for r in rows if r["key"] == "item:30005")["rate"], .5) + self.assertEqual(analyze(self.catalog, restored.snapshot(2), "0101", "3")[0]["n"], 1) + + def test_no_samples_and_unobserved_static_drop_are_distinguished(self): + store = SweepStatistics(self.catalog) + _, rows = analyze(self.catalog, store.snapshot(1), "0101", "3") + self.assertTrue(rows) + self.assertTrue(all(row["rate"] is None for row in rows)) + store.record(1, "0101", "3", "sweep", "one", 1, {"items": [{"typeId": 99999999, "num": 1}]}) + _, rows = analyze(self.catalog, store.snapshot(1), "0101", "3") + self.assertTrue(all(row["rate"] == 0 for row in rows if row["configured"])) + unknown = next(row for row in rows if row["key"] == "item:99999999") + self.assertFalse(unknown["configured"]) + self.assertEqual(unknown["rate"], 1) + + def test_malformed_or_missing_reward_does_not_add_a_sample(self): + store = SweepStatistics(self.catalog) + for reward in (None, {"items": [{"typeId": 30005, "num": None}]}, {"items": [{"typeId": 30005, "num": -1}]}): + with self.assertRaises((ValueError, TypeError)): + store.record(1, "0101", "3", "sweep", "bad", 1, reward) + self.assertEqual(store.snapshot(1)["totals"], {}) + + def test_log_backfill_matches_role_and_deduplicates_live_and_rotated_records(self): + with workspace_temp() as folder: + path = folder / "network_debug.jsonl" + battle = {"win": True, "leftTime": 0, "killNum": 0, "totalDamage": 0, "cheatNum": 0, + "battlePosition": {"battleType": "stage", "stageId": "0101", "stageLevel": "3"}} + entries = [{"operation": "读取角色", "kind": "response", "body": {"master": {"id": 1}}}, + {"operation": "battleService/battleEnd", "kind": "request", "request_id": "normal", "body": {"battleData": battle}}, + {"operation": "battleService/battleEnd", "kind": "response", "request_id": "normal", "http_status": 200, + "time": "2026-11-08T12:00:00+08:00", "body": {"resCode": 0, "reward": REWARD}}, + {"operation": "stageService/stageStart", "kind": "request", "request_id": "event", "body": {"stageTypeId": "0101", "stageLevel": "3"}}, + {"operation": "stageService/stageStart", "kind": "response", "request_id": "event", "http_status": 200, + "time": "2026-11-08T12:00:01+08:00", "body": {"resCode": 0, "triggerEvent": True, + "stageEvent": {"hideStageId": None, "result": {"items": []}}}}] + text = "\n".join(json.dumps(row) for row in entries) + path.write_text(text, encoding="utf-8") + path.with_name("network_debug.previous.jsonl").write_text(text, encoding="utf-8") + store = SweepStatistics(self.catalog, folder / "stats.sqlite3") + store.record(1, "0101", "3", "sweep", "request:normal", 1, REWARD) + store.import_log(1, path) + self.assertEqual(analyze(self.catalog, store.snapshot(1), "0101", "3", "all")[0]["n"], 2) + store.import_log(2, path) + self.assertEqual(store.snapshot(2)["totals"], {}) + restored = SweepStatistics(self.catalog, folder / "stats.sqlite3") + restored.import_log(1, path) + self.assertEqual(analyze(self.catalog, restored.snapshot(1), "0101", "3", "all")[0]["n"], 2) + + def test_confirmed_reward_is_saved_before_later_record_request_failure(self): + catalog, snapshot = scenario() + runner = SweepRunner(catalog) + client = FakeClient(snapshot) + client.fail = "battleService/recordBattleResult" + stage = runner.next(snapshot, SweepPolicy(True, {"0101": {"enabled": True, "level": "3", "limit": 3}})) + with self.assertRaises(TimeoutError): + runner.run(client, snapshot, stage, SweepPolicy(True, {"0101": {"enabled": True, "level": "3", "limit": 3}})) + self.assertEqual(runner.statistics.snapshot(snapshot.raw["master"]["id"])["totals"]["0101:3:sweep"]["n"], 1) + self.assertIsNone(runner.state["pending"]) + + def test_local_statistics_failure_does_not_repeat_or_interrupt_sweep_settlement(self): + catalog, snapshot = scenario() + runner = SweepRunner(catalog) + client = FakeClient(snapshot) + policy = SweepPolicy(True, {"0101": {"enabled": True, "level": "3", "limit": 3}}) + with patch.object(runner.statistics, "record", side_effect=OSError("synthetic failure")): + runner.run(client, snapshot, runner.next(snapshot, policy), policy) + self.assertIsNone(runner.state["pending"]) + self.assertEqual(len(client.calls), 3) + self.assertIn("未写入", runner.statistics_error) + + def test_engine_reports_normal_sweep_rewards(self): + catalog, snapshot = scenario() + client = FakeClient(snapshot) + engine = Engine(catalog, client) + engine.policy.enabled = False + engine.sweep_policy = SweepPolicy(True, {"0101": {"enabled": True, "level": "3", "limit": 3}}) + engine.auto = True + _, _, message = engine.poll() + self.assertIn("扫荡完成", message) + self.assertIn("金币 1", message) + + +class AnalysisGuiTests(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.app = W.QApplication.instance() or W.QApplication([]) + + def wait(self, predicate): + for _ in range(1000): + self.app.processEvents() + QTest.qWait(2) + if predicate(): + return + self.fail("Analysis rendering did not finish") + + def test_static_stage_selection_table_chart_and_source_filter(self): + catalog, snapshot = scenario() + store = SweepStatistics(catalog) + store.record(1, "0101", "3", "sweep", "one", 1, REWARD, spent=10) + store.record(1, "0101", "3", "sweep", "two", 2, {"items": []}, spent=10) + store.record(1, "0101", "3", "event", "three", 3, {"items": []}) + page = StatisticsPage(catalog) + try: + page.set_data(catalog, store.snapshot(1)) + self.wait(lambda: not page.row_batch.running) + self.assertEqual(page.current_key, ("0101", "3")) + self.assertIn("2 个已确认样本", page.summary.text()) + self.assertTrue(page.chart_view.chart().series()) + row = next(i for i in range(page.table.rowCount()) if page.table.item(i, 0).text() == catalog.data["item_names"]["30005"]) + self.assertEqual(page.table.item(row, 5).text(), "50.00%") + self.assertEqual(page.table.item(row, 7).text(), "0.25") + page.chart_metric.setCurrentIndex(page.chart_metric.findData("per_stamina")) + self.assertEqual(page.chart_view.chart().title(), "每点体力数量") + page.source.setCurrentIndex(page.source.findData("event")) + self.assertIn("1 个已确认样本", page.summary.text()) + page.tree.setCurrentItem(page.level_items["0102", "1"]) + self.assertIn("尚无此范围的样本", page.summary.text()) + self.assertTrue(all(page.table.item(i, 5).text() == "—" for i in range(page.table.rowCount()))) + finally: + page.row_batch.stop() + page.close() + + def test_analysis_tab_is_next_to_sweeping_and_refresh_is_local_only(self): + with workspace_temp() as folder: + window = Window(folder) + window.timer.stop() + try: + self.wait(lambda: not window.busy and window.engine.snapshot is not None) + labels = [window.tabs.tabText(i) for i in range(window.tabs.count())] + self.assertEqual(labels[labels.index("自动扫荡") + 1], "数据分析") + window.tabs.setCurrentWidget(window.analysis_page) + self.wait(lambda: not window.analysis_page.row_batch.running) + with patch.object(window.engine, "poll", side_effect=AssertionError("Analysis must not refresh game state")): + owner = window.engine.snapshot.raw["master"]["id"] + window.engine.sweeper.statistics.record(owner, "0101", "3", "sweep", "local-refresh", 1, REWARD, spent=16) + window.refresh_page(window.analysis_page) + self.wait(lambda: not window.busy) + window.tabs.setCurrentWidget(window.slot_page) + window.tabs.setCurrentWidget(window.analysis_page) + self.assertEqual(window.analysis_page.data["totals"]["0101:3:sweep"]["n"], 1) + self.assertIn("本地", window.log.toPlainText()) + finally: + window.close() + + def test_paused_large_stage_tree_resumes_when_new_statistics_arrive(self): + catalog = Catalog() + store = SweepStatistics(catalog) + page = StatisticsPage(catalog) + try: + page.set_data(catalog, store.snapshot(1)) + page.row_batch.stop() + store.record(1, "0101", "3", "sweep", "one", 1, REWARD, spent=16) + page.set_data(catalog, store.snapshot(1)) + self.wait(lambda: not page.row_batch.running) + self.assertEqual(len(page.level_items), sum(len(stage.get("level", {})) for stage in catalog.data["stage_info"].values())) + self.assertEqual(page.current_key, ("0101", "3")) + finally: + page.row_batch.stop() + page.close()