Record sweep rewards and add local drop and stamina analysis

This commit is contained in:
AttilaNet
2026-11-08 11:56:29 +08:00
parent e3d806a167
commit b172d1ffb9
10 changed files with 890 additions and 16 deletions
+8 -1
View File
@@ -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保留条件、随机刷新间隔及到期独立同步的回归测试。
双账号与大量库存的界面响应继续通过测试;测试使用本地模拟数据和模拟服务,不操作真实账号库存。
- 网络写请求发生异常后不会直接重试,以免重复消耗魔物或物品。
+2 -1
View File
@@ -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):
+293
View File
@@ -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
+6 -4
View File
@@ -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)
+46 -2
View File
@@ -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"):
+5 -2
View File
@@ -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)
+242
View File
@@ -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()
+30 -5
View File
@@ -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})
@@ -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())
@@ -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()