Record sweep rewards and add local drop and stamina analysis
This commit is contained in:
@@ -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保留条件、随机刷新间隔及到期独立同步的回归测试。
|
||||
双账号与大量库存的界面响应继续通过测试;测试使用本地模拟数据和模拟服务,不操作真实账号库存。
|
||||
- 网络写请求发生异常后不会直接重试,以免重复消耗魔物或物品。
|
||||
|
||||
@@ -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):
|
||||
|
||||
@@ -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
|
||||
@@ -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
@@ -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"):
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
Reference in New Issue
Block a user