diff --git a/public/js/screens/stats.js b/public/js/screens/stats.js
new file mode 100644
index 00000000..16f1bc1f
--- /dev/null
+++ b/public/js/screens/stats.js
@@ -0,0 +1,316 @@
+// The local stats viewer (per-browser match record, viewer + data management. Opened imperatively from the
+// title screen / lobby (`openStats()`);
is mounted once by main.js like
.
+//
+// The page aggregates over the records of ui/stats.js (one per finished match the local player took part in):
+// 总览 – games, wins, win rate, hidden-core reaches / clears, per-difficulty rows
+// 策略 – per band: games used / passed (self alive on a winning team) / pass rate (the user's ask)
+// 称号 – each of config.titles' six 评语 with its count
+// 战斗累计– the self player's summed combat bookkeeping
+// 最近对局– the newest RECENT_SHOW records as rows; a row click re-views that match as its settlement
+// screen (the record is inverted into an m.result payload for
)
+// Everything is 本机数据 (localStorage, `sp.pref.stats`): the note under the title says so, and 导出/导入
+// (JSON file, merge-by-record-id on the way in) moves it between devices; 清空 resets after a confirm press.
+
+import { useEffect, useRef, useState } from '../../vendor/hooks.module.js';
+import { DIFFICULTY_NAMES, PHASE } from '../../../shared/constants.js';
+import { html, Icon, MicroLabel, Spinner, Button } from '../ui/components.js';
+import { useGameData, BandIcon, Img } from '../ui/gameComponents.js';
+import { data, useData } from '../data.js';
+import { fmtNum } from '../ui/gameLogic.js';
+import { titleIconUrl } from '../ui/assetUrls.js';
+import { createStore, useStore, store, emptyMatch } from '../store.js';
+import { ResultScreen } from './result.js';
+import { toast, toastError } from '../ui/toasts.js';
+import {
+ loadStats, saveStats, emptyStats, importStats, exportStats, aggregateStats, recordToResult, RECENT_SHOW,
+} from '../ui/stats.js';
+import { t, N_ } from '../../../shared/i18n.js';
+
+const cx = (...p) => p.flat().filter(Boolean).join(' ');
+
+const statsStore = createStore({ open: false });
+
+/** Open the stats viewer (title screen / lobby entry points). */
+export function openStats() {
+ data.load('config');
+ data.load('bands');
+ data.load('assets');
+ statsStore.set({ open: true });
+}
+export const closeStats = () => {
+ // a replayed settlement is synthetic store state — take it away with the viewer
+ if (store.get().match.result) store.set({ match: emptyMatch() });
+ statsStore.set({ open: false });
+};
+
+/**
+ * 最近对局行点击: one stored match re-viewed as its settlement screen, INSIDE the stats viewer — the
+ * record is inverted into an m.result payload (ui/stats.js recordToResult) into store.match.result, and
+ * StatsHost swaps its panel for the real
while a result exists (the settlement's
+ * 返回大厅 empties match again → back to the list, ready to view the next row). Refused while a match
+ * is actually live: the overlay is global and clobbering a running match's state would be destructive.
+ * @param {any} rec
+ */
+export function openRecordResult(rec) {
+ const s = store.get();
+ if ((s.match.public && s.match.public.phase !== PHASE.LOBBY) || s.room?.inMatch) {
+ toast(t('对局进行中，暂不能回看历史结算'), 'warn');
+ return;
+ }
+ const res = recordToResult(rec);
+ if (!res) return;
+ store.set({ match: { ...emptyMatch(), public: { phase: PHASE.RESULT }, result: res } });
+}
+
+const pct = (n, d) => (d > 0 ? `${Math.round((n / d) * 100)}%` : '—');
+const dateTime = (t) => {
+ if (!t) return '—';
+ const d = new Date(t);
+ const p = (n) => String(n).padStart(2, '0');
+ return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())} ${p(d.getHours())}:${p(d.getMinutes())}`;
+};
+const minsOf = (ms) => (ms > 0 ? Math.round(ms / 60000) : null);
+
+/** One labelled number card. */
+function StatCard({ label, micro, value, tone }) {
+ return html`
+ <${MicroLabel} tone=${tone === 'gold' ? 'gold' : 'mint'}>${micro}
+ ${value}
+ ${label}
+
`;
+}
+
+function Section({ title, micro, children }) {
+ return html`
+ ${title} <${MicroLabel}>${micro} `;
+}
+
+/** 总览: cards + the per-difficulty table. */
+function Overview({ agg }) {
+ const rows = Object.entries(agg.byDifficulty).sort((a, b) => b[1].games - a[1].games);
+ const playedMins = minsOf(agg.duration.totalMs);
+ return html`<${Section} title=${t('总览')} micro="OVERVIEW">
+
+ <${StatCard} micro="GAMES" value=${fmtNum(agg.count)} label=${t('总局数')} />
+ <${StatCard} micro="WINS" value=${fmtNum(agg.wins)} label=${t('胜场')} tone="mint" />
+ <${StatCard} micro="WIN RATE" value=${pct(agg.wins, agg.count)} label=${t('胜率')} tone="gold" />
+ <${StatCard} micro="HIDDEN CORE" value=${fmtNum(agg.hidden.reached)} label=${t('到达隐秘核心')} />
+ <${StatCard} micro="HIDDEN CLEAR" value=${fmtNum(agg.hidden.cleared)} label=${t('通关隐秘核心')} />
+ <${StatCard} micro="BEST ROUND" value=${fmtNum(agg.rounds.max)} label=${t('最远回合')} />
+ ${playedMins != null ? html`<${StatCard} micro="TIME PLAYED" value=${t('{n} 分', { n: fmtNum(playedMins) })} label=${t('累计时长')} />` : null}
+
+ ${rows.length ? html`
+ ${t('难度')} ${t('局数')} ${t('胜场')} ${t('胜率')} ${t('隐秘核心通关')}
+ ${rows.map(([d, v]) => html`
+ ${DIFFICULTY_NAMES[d] || d}
+ ${fmtNum(v.games)}
+ ${fmtNum(v.wins)}
+ ${pct(v.wins, v.games)}
+ ${fmtNum(v.hiddenCleared)}
+ `)}
+
+
` : null}
+ `;
+}
+
+/** 策略: per-band used / passed / pass rate, most used first (the user's headline ask). */
+function Bands({ agg, gd }) {
+ const rows = Object.entries(agg.bands).sort((a, b) => b[1].games - a[1].games);
+ if (!rows.length) return null;
+ return html`<${Section} title=${t('策略')} micro="BANDS">
+
+ ${t('策略')} ${t('使用局数')} ${t('通过局数')} ${t('通过率')}
+ ${rows.map(([bandId, v]) => {
+ const band = gd.band(bandId);
+ return html`
+ ${band ? html`<${BandIcon} bandId=${band.bandId} size="xs" />${band.name}` : bandId}
+ ${fmtNum(v.games)}
+ ${fmtNum(v.wins)}
+ ${pct(v.wins, v.games)}
+ `;
+ })}
+
+
+ `;
+}
+
+/** 称号: all six 评语 with counts (0 dimmed), official order. */
+function Titles({ agg, gd }) {
+ const list = (Array.isArray(gd.config?.titles) ? gd.config.titles : [])
+ .map((t) => ({ ...t, count: agg.titles[t.id]?.count || 0 }));
+ if (!list.length) return null;
+ return html`<${Section} title=${t('称号')} micro="TITLES">
+
+ ${list.map((t) => html`
+ <${Img} src=${titleIconUrl(gd.m, t.picId)} class="stit__icon" fallback=${html`<${Icon} name="crown" />`} />
+
${t.name} ${fmtNum(t.count)}
+
`)}
+
+ `;
+}
+
+const SUM_ROWS = [
+ ['kills', N_('击倒敌人')], ['bossDamage', N_('领袖伤害')], ['dmgDealt', N_('造成伤害')], ['activatedLayers', N_('盟约层数')],
+ ['merges', N_('晋升次数')], ['itemsEquipped', N_('配发装备')], ['gold', N_('消耗资金')], ['perfectRounds', N_('完美作战')],
+ ['refreshes', N_('刷新次数')], ['leaks', N_('未击倒')], ['lpLost', N_('损失生命')],
+];
+
+/** 战斗累计: the self player's sums. */
+function CombatSums({ agg }) {
+ const rows = SUM_ROWS.filter(([k]) => Number.isFinite(agg.sums[k]));
+ if (!rows.length) return null;
+ return html`<${Section} title=${t('战斗累计')} micro="COMBAT TOTALS">
+
+ ${rows.map(([k, label]) => html`
${t(label)} ${fmtNum(agg.sums[k])}
`)}
+
+ `;
+}
+
+/** 最近对局: newest RECENT_SHOW records (records are stored newest first). A row click re-views that
+ match as its settlement screen (openRecordResult → match.result →
). */
+function Recent({ records, gd }) {
+ const rows = records.slice(0, RECENT_SHOW);
+ if (!rows.length) return null;
+ return html`<${Section} title=${t('最近对局')} micro=${`RECENT · ${records.length}`}>
+
+ ${t('时间')} ${t('难度')} ${t('模式')} ${t('策略')} ${t('结果')} ${t('回合')}
+ ${rows.map((r) => {
+ const self = r.players.find((p) => p.playerId === r.selfId) || r.players[0] || null;
+ const won = self ? !!self.victory : !!r.victory;
+ const band = self?.bandId ? gd.band(self.bandId) : null;
+ return html` openRecordResult(r)}>
+ ${dateTime(r.t)}
+ ${DIFFICULTY_NAMES[r.difficulty] || r.difficulty || '—'}
+ ${r.roomMode === 'solo' ? t('单人') : r.roomMode === 'coop' ? t('同盟') : '—'}
+ ${band ? band.name : self?.bandId || '—'}
+ ${won ? t('胜') : t('负')}
+ ${fmtNum(r.roundsPassed)}
+ <${Icon} name="chevronRight" />
+ `;
+ })}
+
+
+
${t('点击任意一行，回看该局结算。')}
+ `;
+}
+
+/** 导出 / 导入 / 清空, with the two-step clear confirm. */
+function DataActions({ stats, onReload }) {
+ const fileRef = useRef(null);
+ const [confirming, setConfirming] = useState(false);
+ useEffect(() => {
+ if (!confirming) return undefined;
+ const t = setTimeout(() => setConfirming(false), 3000);
+ return () => clearTimeout(t);
+ }, [confirming]);
+
+ const doExport = () => {
+ try {
+ const payload = exportStats(stats);
+ const blob = new Blob([JSON.stringify(payload, null, 1)], { type: 'application/json' });
+ const a = document.createElement('a');
+ const d = new Date();
+ const p = (n) => String(n).padStart(2, '0');
+ a.href = URL.createObjectURL(blob);
+ a.download = `stronghold-stats-${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}-${p(d.getHours())}${p(d.getMinutes())}.json`;
+ a.click();
+ setTimeout(() => URL.revokeObjectURL(a.href), 4000);
+ toast(t('已导出 {n} 条对局记录', { n: payload.records.length }), 'success');
+ } catch (err) {
+ toastError(err);
+ }
+ };
+
+ const doFile = async (e) => {
+ const file = e.currentTarget.files?.[0];
+ e.currentTarget.value = ''; // allow re-picking the same file
+ if (!file) return;
+ try {
+ const raw = JSON.parse(await file.text());
+ const { stats: merged, added, skipped } = importStats(raw, stats);
+ saveStats(merged);
+ onReload();
+ toast(added ? t('已导入 {added} 条记录{tail}', { added, tail: skipped ? t('（跳过重复 {skipped} 条）', { skipped }) : '' }) : t('没有新记录（全部与现有数据重复）'), 'success');
+ } catch (err) {
+ toastError(err.code === 'stats-newer-version' ? err : new Error(t('导入失败：不是有效的统计导出文件')));
+ }
+ };
+
+ const doClear = () => {
+ if (!confirming) { setConfirming(true); return; }
+ saveStats(emptyStats());
+ setConfirming(false);
+ onReload();
+ toast(t('已清空本机统计数据'), 'success');
+ };
+
+ return html`
+ <${Button} size="sm" icon="exit" onClick=${doExport}>${t('导出')}
+ <${Button} size="sm" icon="plus" onClick=${() => fileRef.current?.click()}>${t('导入')}
+
`;
+}
+
+/**
+ * Global stats viewer host — mounted once by main.js. Waits only on the files the page reads (config for the
+ * title list, bands for names/icons, assets for the picture URLs), not all of useGameData's files.
+ */
+export function StatsHost() {
+ const { open } = useStore((s) => s, Object.is, statsStore);
+ const replaying = useStore((s) => !!s.match.result); // a replayed settlement replaces the whole panel
+ const ready = useData('config', 'bands', 'assets');
+ const gd = useGameData();
+ const [stats, setStats] = useState(() => emptyStats());
+ const boxRef = useRef(null);
+ const reload = () => setStats(loadStats());
+
+ useEffect(() => {
+ if (!open) return undefined;
+ setStats(loadStats());
+ const onKey = (e) => {
+ if (e.key === 'Escape') { e.preventDefault(); e.stopPropagation(); e.stopImmediatePropagation(); closeStats(); }
+ };
+ window.addEventListener('keydown', onKey, true);
+ const t = setTimeout(() => boxRef.current?.focus?.(), 30);
+ return () => { window.removeEventListener('keydown', onKey, true); clearTimeout(t); };
+ }, [open]);
+
+ if (!open) return null;
+ if (replaying) {
+ // the record re-viewed as its settlement (openRecordResult): the real
, full-bleed;
+ // its 返回大厅 empties match.result and lands back on the list
+ return html`
`;
+ }
+ const agg = aggregateStats(stats.records);
+ return html`
{ if (e.target === e.currentTarget) closeStats(); }}>
+
+
+
+ ${!ready ? html`
<${Spinner} size="md" />
`
+ : stats.newer ? html`
${t('检测到更新版本的统计数据，请先升级客户端再查看，以免覆盖数据。')}
`
+ : !stats.records.length ? html`
${t('还没有记录 —— 完成一局对局后，这里会开始积累。')}
`
+ : html`<${Overview} agg=${agg} />
+ <${Bands} agg=${agg} gd=${gd} />
+ <${Titles} agg=${agg} gd=${gd} />
+ <${CombatSums} agg=${agg} />
+ <${Recent} records=${stats.records} gd=${gd} />`}
+
+
+
`;
+}
diff --git a/public/js/screens/title.js b/public/js/screens/title.js
index 2ff7873d..d9a4997e 100644
--- a/public/js/screens/title.js
+++ b/public/js/screens/title.js
@@ -14,6 +14,7 @@ import { useMemo, useState } from '../../vendor/hooks.module.js';
import { NAME_MAX_LEN, APP_VERSION, DEV_BUILD } from '../../../shared/constants.js';
import { html, Button, Icon, MicroLabel, TextField, PingPill } from '../ui/components.js';
import { GuideButton } from '../ui/guide.js';
+import { openStats } from './stats.js';
import { toast } from '../ui/toasts.js';
import { net, identity } from '../net.js';
import { store, useStore, shallowEqual } from '../store.js';
@@ -272,6 +273,7 @@ export function TitleScreen() {
${STATUS_TEXT[conn.status] ? t(STATUS_TEXT[conn.status]) : conn.status}
${conn.status === 'online' ? html`<${PingPill} ms=${conn.ping} />` : null}
+ <${Button} variant="ghost" size="sm" icon="signal" onClick=${openStats} title=${t('统计数据')}>${t('统计')}
<${GuideButton} class="title-guide" label=${t('玩法说明')} />
setSettingsOpen(true)}><${GIcon} name="gear" />
diff --git a/public/js/ui/stats.js b/public/js/ui/stats.js
new file mode 100644
index 00000000..bc8cc9c3
--- /dev/null
+++ b/public/js/ui/stats.js
@@ -0,0 +1,469 @@
+// Local match statistics: every finished match the local player took part in is appended as one record to
+// localStorage (`sp.pref.stats`, the loadPref/savePref convention of store.js). Per-browser only — the server
+// keeps matches in memory and has no identity, so there is nowhere else for cross-match numbers to live; the
+// stats page labels itself 本机数据 and offers JSON export / import for moving between devices.
+//
+// The record keeps everything the settlement offers (m.result is free-form, server/match/results.js buildResult):
+// the match frame (difficulty, mode, boss, seed, duration, hidden-core outcome, reason) plus one row per player
+// — band, title (评语), lineup, bonds and the full stat block — even where today's page aggregates only a part.
+// Whatever a future statistics view needs should already be in the record; display is the only thing that lags.
+//
+// Format evolution: the envelope carries a version (`STATS_VERSION`); `migrateStats` walks records through a
+// chain of per-version steps and every loaded / imported record passes `normalizeRecord`, which fills defaults
+// for missing fields and PRESERVES unknown ones — so data written by an older build reads fine after an
+// upgrade, and fields added by a newer writer survive a round-trip through this one. An envelope from a newer
+// version than this build is refused (never silently downgraded and written back).
+//
+// Pure logic, no Preact / DOM: Node-testable (test/ui/stats.test.js); localStorage is touched only through
+// loadStats / saveStats.
+
+import { loadPref } from '../store.js';
+import { t } from '../../../shared/i18n.js';
+
+/** Current record-envelope version (bump + add a MIGRATIONS step when the record shape changes). */
+export const STATS_VERSION = 1;
+/** localStorage key under the app's `sp.pref.` prefix (store.js loadPref). */
+export const STATS_PREF_KEY = 'stats';
+/** Oldest records are dropped beyond this (rough sizing: ~1.5 kB/record ⇒ ~1.5 MB of a ~5 MB quota). */
+export const MAX_RECORDS = 1000;
+/** How many games the page's 最近对局 list shows. */
+export const RECENT_SHOW = 20;
+
+const FULL_KEY = `sp.pref.${STATS_PREF_KEY}`;
+
+/** @returns {{ v: number, records: Array }} a fresh empty envelope */
+export const emptyStats = () => ({ v: STATS_VERSION, records: [] });
+
+const isObj = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
+const int = (v, d) => (Number.isFinite(v) ? Math.round(v) : d);
+const num = (v) => (Number.isFinite(v) ? v : null);
+const bool = (v, d = false) => (typeof v === 'boolean' ? v : d);
+const str = (v) => (typeof v === 'string' && v.length ? v : null);
+
+/**
+ * Copy only the finite numeric keys of a stats block (the settlement's numbers; unknown numeric fields are
+ * kept too — display can lag, data must not).
+ * @param {any} raw
+ * @returns {Record
}
+ */
+function normalizeStatBlock(raw) {
+ const out = {};
+ if (!isObj(raw)) return out;
+ for (const [k, v] of Object.entries(raw)) if (Number.isFinite(v)) out[k] = v;
+ return out;
+}
+
+/**
+ * FNV-1a 32-bit, hex — a content hash needs no crypto, only stability across sessions.
+ * @param {string} s
+ * @returns {string}
+ */
+function fnv1a(s) {
+ let h = 0x811c9dc5;
+ for (let i = 0; i < s.length; i++) {
+ h ^= s.charCodeAt(i);
+ h = (h + ((h << 1) + (h << 4) + (h << 7) + (h << 8) + (h << 24))) >>> 0;
+ }
+ return h.toString(16).padStart(8, '0');
+}
+
+/**
+ * The record's dedupe id, from match facts the server replays byte-identically on reconnect / reload
+ * (server/lobby.js result replay): seed + duration + mode + rounds + outcome + who I was. Two distinct
+ * matches colliding on all of these is not a real scenario; a replayed m.result hits the same id and is
+ * dropped, which is the point (recording happens on every m.result arrival, replays included).
+ * @param {any} res raw m.result payload
+ * @param {string|null|undefined} myId the local player's id at that moment
+ * @returns {string}
+ */
+export function recordId(res, myId) {
+ const r = isObj(res) ? res : {};
+ return `r1.${fnv1a([r.seed ?? '-', r.durationMs ?? '-', r.modeId ?? '-', r.roundsPassed ?? '-', r.victory ? 1 : 0, myId ?? '-'].join('|'))}`;
+}
+
+/**
+ * Normalize ONE player row: known fields defaulted, unknown fields preserved (forward compat).
+ * @param {any} raw
+ * @returns {any}
+ */
+function normalizePlayerRow(raw) {
+ const p = isObj(raw) ? raw : {};
+ const title = isObj(p.title)
+ ? { id: str(p.title.id) || '', name: str(p.title.name) || '', picId: str(p.title.picId) || '', text: str(p.title.text) || '' }
+ : null;
+ const lineup = (Array.isArray(p.lineup) ? p.lineup : []).filter(isObj).slice(0, 12).map((u) => ({
+ // ids only — the tile position (row/col) is replay detail, not a statistic; items kept (配发装备统计)
+ id: str(u.id) || '', golden: bool(u.golden), tier: int(u.tier, 0),
+ items: (Array.isArray(u.items) ? u.items : []).filter((i) => typeof i === 'string' && i.length),
+ })).filter((u) => u.id);
+ const bonds = (Array.isArray(p.bonds) ? p.bonds : []).filter(isObj).map((b) => ({
+ bondId: str(b.bondId) || str(b.id) || '', layers: int(b.layers, 0), active: bool(b.active),
+ })).filter((b) => b.bondId);
+ return {
+ ...p, // unknown / future fields pass through untouched
+ playerId: str(p.playerId) || '',
+ seat: int(p.seat, 0),
+ name: str(p.name) || t('博士'),
+ isBot: bool(p.isBot),
+ left: bool(p.left),
+ alive: bool(p.alive, true),
+ victory: bool(p.victory), // server semantics: team won AND this player was still in at the end
+ roundsPassed: int(p.roundsPassed, 0),
+ eliminatedRound: num(p.eliminatedRound),
+ lp: num(p.lp),
+ bandId: str(p.bandId),
+ title,
+ trophies: int(p.trophies, 0),
+ reward: int(p.reward, 0),
+ lineup,
+ bonds,
+ stats: normalizeStatBlock(p.stats),
+ };
+}
+
+/**
+ * Normalize ONE match record to the current shape. Missing fields get defaults; unknown fields (a newer
+ * writer's additions) survive untouched, so import → export does not lose them.
+ * @param {any} raw
+ * @returns {any|null} null when the row is not salvageable (no players array at all)
+ */
+export function normalizeRecord(raw) {
+ const r = isObj(raw) ? raw : {};
+ // same rule as buildRecord: a record IS a played match — no usable players array, no record
+ if (!Array.isArray(r.players) || !r.players.length) return null;
+ const base = {
+ id: str(r.id) || '',
+ v: STATS_VERSION,
+ t: int(r.t, 0),
+ victory: bool(r.victory),
+ roundsPassed: int(r.roundsPassed, 0),
+ lastRound: num(r.lastRound),
+ hiddenReached: bool(r.hiddenReached),
+ hiddenCleared: bool(r.hiddenCleared),
+ reason: str(r.reason),
+ modeId: str(r.modeId),
+ difficulty: str(r.difficulty),
+ stageId: str(r.stageId),
+ bossId: str(r.bossId),
+ hiddenBossId: str(r.hiddenBossId),
+ seed: num(r.seed),
+ durationMs: num(r.durationMs),
+ teamLp: num(r.teamLp),
+ roomMode: r.roomMode === 'solo' || r.roomMode === 'coop' ? r.roomMode : null,
+ selfId: str(r.selfId),
+ players: r.players.filter(isObj).map(normalizePlayerRow),
+ };
+ return { ...r, ...base };
+}
+
+/**
+ * The MIGRATIONS chain: `MIGRATIONS[v]` upgrades a v-envelope to v+1, for v = STATS_VERSION and down.
+ * Empty at v1 — the steps exist so the next format change lands as one function here and every stored /
+ * imported envelope walks the whole chain.
+ * @type {Record any>}
+ */
+export const MIGRATIONS = {};
+
+/**
+ * Bring any stored / imported envelope to the current version.
+ * @param {any} raw
+ * @returns {{ stats: { v: number, records: any[] }, changed: boolean, newer: boolean }}
+ * `newer` = the data was written by a NEWER build: returned untouched, callers must not save over it.
+ */
+export function migrateStats(raw) {
+ if (!isObj(raw) || !Array.isArray(raw.records)) return { stats: emptyStats(), changed: false, newer: false };
+ if ((raw.v ?? 0) > STATS_VERSION) {
+ return { stats: { v: raw.v, records: raw.records }, changed: false, newer: true };
+ }
+ let v = raw.v ?? 0;
+ let records = raw.records;
+ let changed = v !== STATS_VERSION;
+ while (v < STATS_VERSION) {
+ const step = MIGRATIONS[v];
+ if (typeof step === 'function') records = step({ v, records }).records;
+ v++;
+ }
+ const normalized = [];
+ for (const r of records) {
+ const rec = normalizeRecord(r);
+ if (rec) normalized.push(rec);
+ }
+ changed ||= normalized.length !== records.length;
+ return { stats: { v: STATS_VERSION, records: normalized }, changed, newer: false };
+}
+
+/**
+ * Read + migrate the persisted envelope; self-heals older shapes back to storage.
+ * @returns {{ v: number, records: any[], newer: boolean }}
+ */
+export function loadStats() {
+ const { stats, changed, newer } = migrateStats(loadPref(STATS_PREF_KEY, null));
+ if (!newer && changed) saveStats(stats);
+ return { ...stats, newer };
+}
+
+/**
+ * Persist the envelope. savePref swallows quota errors — here losing a record silently would do exactly
+ * that, so the write reports failure and shrinks the history (oldest quarter) before retrying.
+ * @param {{ v: number, records: any[] }} stats
+ * @returns {boolean} whether a write stuck
+ */
+export function saveStats(stats) {
+ const env = { v: STATS_VERSION, records: stats.records };
+ try {
+ globalThis.localStorage?.setItem(FULL_KEY, JSON.stringify(env));
+ return true;
+ } catch { /* quota — fall through to shrinking */ }
+ let recs = stats.records;
+ // two quarter-shrinks at most; records are newest first, so the tail (oldest) is what goes;
+ // a small history that still does not fit is foreign quota pressure — giving up beats gradually erasing it
+ for (let i = 0; i < 2 && recs.length > 8; i++) {
+ recs = recs.slice(0, recs.length - Math.ceil(recs.length / 4));
+ try {
+ globalThis.localStorage?.setItem(FULL_KEY, JSON.stringify({ v: STATS_VERSION, records: recs }));
+ return true;
+ } catch { /* keep shrinking */ }
+ }
+ return false;
+}
+
+/**
+ * Derive the room shape ('solo' | 'coop') the way constants.js modeIdFor builds modeIds.
+ * @param {string|null|undefined} modeId
+ * @param {string|null|undefined} roomMode room.state `mode` when known
+ * @returns {'solo'|'coop'|null}
+ */
+export function roomModeOf(modeId, roomMode) {
+ if (roomMode === 'solo' || roomMode === 'coop') return roomMode;
+ if (typeof modeId !== 'string') return null;
+ if (modeId.includes('_single_')) return 'solo';
+ if (modeId.includes('_multi_')) return 'coop';
+ return null;
+}
+
+/**
+ * Build one record from a raw m.result payload (+ context). Null when there is nothing to store: payloads
+ * without players (the error-path settlement) or matches the local player did not take part in (spectator
+ * seats get every result pushed too — eliminated players, who ARE in players[], keep recording).
+ * @param {any} res raw m.result payload
+ * @param {{ myId?: string|null, roomMode?: string|null, now?: number }} ctx
+ * @returns {any|null}
+ */
+export function buildRecord(res, ctx = {}) {
+ const r = isObj(res) ? res : {};
+ if (!Array.isArray(r.players) || !r.players.length) return null;
+ const myId = str(ctx.myId);
+ const selfRow = r.players.find((p) => isObj(p) && p.playerId === myId);
+ if (!selfRow) return null; // spectator / observer: not my match
+ const rec = normalizeRecord({
+ v: STATS_VERSION,
+ t: int(ctx.now, 0),
+ id: recordId(r, myId),
+ victory: bool(r.victory),
+ roundsPassed: int(r.roundsPassed, 0),
+ lastRound: num(r.lastRound),
+ hiddenReached: bool(r.hiddenReached),
+ hiddenCleared: bool(r.hiddenCleared),
+ reason: str(r.reason),
+ modeId: str(r.modeId),
+ difficulty: str(r.difficulty),
+ stageId: str(r.stageId),
+ bossId: str(r.bossId),
+ hiddenBossId: str(r.hiddenBossId),
+ seed: num(r.seed),
+ durationMs: num(r.durationMs),
+ teamLp: num(r.teamLp),
+ roomMode: roomModeOf(str(r.modeId), ctx.roomMode),
+ selfId: myId,
+ players: r.players,
+ });
+ return rec;
+}
+
+/**
+ * The m.result-shaped payload behind a record — the inverse of buildRecord. The stats page's 最近对局
+ * rows hand this to the settlement screen (screens/result.js reads store.match.result through
+ * normalizeResult): a finished match can be RE-VIEWED because the record kept every field the payload
+ * had. Whatever a record never stored (older / hand-made rows) is simply absent and normalizeResult
+ * defaults it, exactly like a tolerant live payload.
+ * @param {any} rec
+ * @returns {any|null} null when the row is not a usable record
+ */
+export function recordToResult(rec) {
+ const r = normalizeRecord(rec);
+ if (!r) return null;
+ const res = {
+ victory: r.victory,
+ roundsPassed: r.roundsPassed,
+ hiddenReached: r.hiddenReached,
+ hiddenCleared: r.hiddenCleared,
+ reason: r.reason,
+ modeId: r.modeId,
+ difficulty: r.difficulty,
+ bossId: r.bossId,
+ hiddenBossId: r.hiddenBossId,
+ seed: r.seed,
+ durationMs: r.durationMs,
+ teamLp: r.teamLp,
+ players: r.players,
+ };
+ if (Number.isFinite(r.lastRound)) res.lastRound = r.lastRound;
+ return res;
+}
+
+/**
+ * Append one record: replays (same content id) are dropped, newest first, capped at MAX_RECORDS.
+ * @param {{ v: number, records: any[] }} stats
+ * @param {any} record
+ * @returns {{ stats: { v: number, records: any[] }, added: boolean }}
+ */
+export function appendRecord(stats, record) {
+ if (!record || !record.id) return { stats, added: false };
+ if (stats.records.some((r) => r.id === record.id)) return { stats, added: false };
+ const records = [record, ...stats.records].slice(0, MAX_RECORDS);
+ return { stats: { v: STATS_VERSION, records }, added: true };
+}
+
+/**
+ * Record a finished match end-to-end (load → append → save). Returns the built record, or null when
+ * nothing was stored (no players / not my match / replay).
+ * @param {any} res raw m.result payload
+ * @param {{ myId?: string|null, roomMode?: string|null, now?: number }} [ctx]
+ * @returns {any|null}
+ */
+export function recordResult(res, ctx = {}) {
+ const rec = buildRecord(res, ctx);
+ if (!rec) return null;
+ const stats = loadStats();
+ const { stats: next, added } = appendRecord(stats, rec);
+ if (added && !saveStats(next)) console.warn('[stats] localStorage write failed (quota?), record not persisted');
+ return added ? rec : null;
+}
+
+/**
+ * Merge two envelopes (import into existing): union by record id, chronological, capped.
+ * @param {{ records: any[] }} a current (wins ties)
+ * @param {{ records: any[] }} b incoming
+ * @returns {{ v: number, records: any[] }}
+ */
+export function mergeStats(a, b) {
+ const byId = new Map();
+ for (const r of [...(Array.isArray(b?.records) ? b.records : []), ...(Array.isArray(a?.records) ? a.records : [])]) {
+ const rec = normalizeRecord(r);
+ // id-less (hand-made) rows fall back to a CONTENT hash so both copies land on the same key
+ if (rec) byId.set(rec.id || `c.${fnv1a(JSON.stringify(rec))}`, rec);
+ }
+ const records = [...byId.values()].sort((x, y) => (x.t - y.t) || (x.id < y.id ? -1 : 1)).slice(-MAX_RECORDS);
+ return { v: STATS_VERSION, records };
+}
+
+/**
+ * Parse + migrate + merge an exported / pasted payload into the current data.
+ * @param {any} raw parsed JSON of the imported file
+ * @param {{ records: any[] }} current current envelope
+ * @returns {{ stats: { v: number, records: any[] }, added: number, skipped: number }}
+ */
+export function importStats(raw, current) {
+ const { stats: incoming, newer } = migrateStats(raw);
+ if (newer) {
+ const err = new Error('该文件由更新版本的客户端导出，请先升级后再导入');
+ err.code = 'stats-newer-version';
+ throw err;
+ }
+ const merged = mergeStats(current, incoming);
+ const added = merged.records.length - (Array.isArray(current?.records) ? current.records.length : 0);
+ return { stats: merged, added: Math.max(0, added), skipped: incoming.records.length - Math.max(0, added) };
+}
+
+/**
+ * The payload the export button downloads (envelope + a little provenance).
+ * @param {{ records: any[] }} stats
+ * @returns {{ app: string, kind: string, v: number, exportedAt: string, records: any[] }}
+ */
+export function exportStats(stats) {
+ return {
+ app: 'stronghold-protocol',
+ kind: 'local-stats',
+ v: STATS_VERSION,
+ exportedAt: new Date().toISOString(),
+ records: Array.isArray(stats?.records) ? stats.records : [],
+ };
+}
+
+// ---- aggregation (what the page shows; records may hold more than any view uses) ------------------------
+
+const SELF_STATS = ['dmgDealt', 'kills', 'bossDamage', 'activatedLayers', 'merges', 'itemsEquipped', 'gold', 'perfectRounds', 'refreshes', 'leaks', 'lpLost'];
+
+/**
+ * The row that "is me" in a record: selfId, else the only human, else seat 0 — records written by
+ * recordResult always have selfId; the fallbacks only serve imported / hand-made data.
+ * @param {any} rec
+ * @returns {any|null}
+ */
+export function selfRowOf(rec) {
+ const ps = Array.isArray(rec?.players) ? rec.players : [];
+ return ps.find((p) => p.playerId && p.playerId === rec.selfId)
+ || ps.find((p) => !p.isBot)
+ || ps[0]
+ || null;
+}
+
+/** Whether this record counts as a win for its self player (per-row victory = team won AND still in). */
+const selfWon = (rec, self) => (self ? !!self.victory : !!rec.victory);
+
+/**
+ * Aggregate records for the stats page. Everything is keyed by ids (bandId / titleId / difficulty); the
+ * page maps them to names and icons through the game data.
+ * @param {any[]} records
+ * @returns {any}
+ */
+export function aggregateStats(records) {
+ const rs = Array.isArray(records) ? records : [];
+ const out = {
+ count: rs.length, wins: 0,
+ rounds: { total: 0, max: 0 },
+ duration: { totalMs: 0 },
+ hidden: { reached: 0, cleared: 0 },
+ byDifficulty: {}, byMode: { solo: 0, coop: 0 },
+ titles: {}, bands: {}, sums: {},
+ };
+ for (const rec of rs) {
+ const self = selfRowOf(rec);
+ const won = selfWon(rec, self);
+ if (won) out.wins++;
+ out.rounds.total += int(rec.roundsPassed, 0);
+ out.rounds.max = Math.max(out.rounds.max, int(rec.roundsPassed, 0));
+ out.duration.totalMs += num(rec.durationMs) || 0;
+ if (rec.hiddenReached) out.hidden.reached++;
+ if (rec.hiddenCleared) out.hidden.cleared++;
+
+ const d = rec.difficulty || t('未知');
+ const bd = (out.byDifficulty[d] ||= { games: 0, wins: 0, hiddenCleared: 0 });
+ bd.games++;
+ if (won) bd.wins++;
+ if (rec.hiddenCleared) bd.hiddenCleared++;
+
+ if (rec.roomMode === 'solo' || rec.roomMode === 'coop') out.byMode[rec.roomMode]++;
+
+ const titleId = self?.title?.id;
+ if (titleId) {
+ const t = (out.titles[titleId] ||= { count: 0 });
+ t.count++;
+ }
+
+ const bandId = self?.bandId;
+ if (bandId) {
+ const b = (out.bands[bandId] ||= { games: 0, wins: 0 });
+ b.games++;
+ if (won) b.wins++;
+ }
+
+ if (self && isObj(self.stats)) {
+ for (const k of SELF_STATS) {
+ const v = self.stats[k];
+ if (Number.isFinite(v)) out.sums[k] = (out.sums[k] || 0) + v;
+ }
+ }
+ }
+ return out;
+}
diff --git a/test/ui/stats.test.js b/test/ui/stats.test.js
new file mode 100644
index 00000000..ecdfbfae
--- /dev/null
+++ b/test/ui/stats.test.js
@@ -0,0 +1,318 @@
+// Unit tests (Node) for the 本机对局统计 record store (public/js/ui/stats.js):
+// record building from a raw m.result (spectator copies and player-less error results build nothing),
+// replay dedupe by content id (the lobby re-pushes m.result on reconnect / reload),
+// the MAX_RECORDS cap, migration / normalization (old + partial + unknown fields preserved, newer refused),
+// import merge semantics and the aggregate the stats page renders.
+// localStorage is faked per test (Node has none); recordResult / loadStats / saveStats go through it.
+
+import { test, describe, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import {
+ STATS_VERSION, MAX_RECORDS, emptyStats, buildRecord, recordId, appendRecord, recordResult,
+ loadStats, saveStats, migrateStats, normalizeRecord, mergeStats, importStats, exportStats,
+ aggregateStats, selfRowOf, roomModeOf, recordToResult, MIGRATIONS,
+} from '../../public/js/ui/stats.js';
+import { normalizeResult } from '../../public/js/ui/gameLogic.js';
+
+/** A realistic m.result in the shape server/match/results.js buildResult emits (replayed byte-identically). */
+function baseResult(over = {}) {
+ return {
+ t: 'm.result',
+ victory: true, roundsPassed: 15, hiddenReached: true, hiddenCleared: true, reason: 'hidden_cleared',
+ teamLp: 24, modeId: 'mode_single_hard', difficulty: 'HARD', stageId: 'stage_hard', bossId: 'enemy_boss', hiddenBossId: 'enemy_hidden',
+ seed: 123456789, durationMs: 952123,
+ players: [
+ {
+ playerId: 'p1', seat: 0, name: '罗宾', isBot: false, left: false, alive: true, victory: true,
+ roundsPassed: 16, eliminatedRound: null, lp: 24, bandId: 'band_amiya',
+ title: { id: 'comment_1', name: '卫戍之星', picId: 'comment_icon_1', text: '对敌方领袖造成伤害最高（仅胜利时）' },
+ trophies: 30, reward: 88,
+ lineup: [{ id: 'char_290_vigna', golden: false, tier: 2, row: 10, col: 5, items: ['item_eq_1'] }],
+ bonds: [{ bondId: 'steadShip', layers: 12, active: true }],
+ stats: { dmgDealt: 15234.7, kills: 41, leaks: 2, gold: 880, refreshes: 5, merges: 6, itemsEquipped: 4, bossDamage: 5000.5, activatedLayers: 99, lpLost: 3, perfectRounds: 7 },
+ },
+ {
+ playerId: 'p2', seat: 1, name: '队友B', isBot: false, left: false, alive: false, victory: false,
+ roundsPassed: 9, eliminatedRound: 10, lp: 0, bandId: 'band_fang', title: null, trophies: 0, reward: 40,
+ lineup: [], bonds: [], stats: { kills: 3 },
+ },
+ ],
+ ...over,
+ };
+}
+
+/** Fake localStorage: Map-backed, with an optional byte budget that makes setItem throw like a full quota. */
+function fakeStorage({ budget = Infinity } = {}) {
+ const m = new Map();
+ const calls = [];
+ return {
+ calls,
+ getItem: (k) => (m.has(k) ? m.get(k) : null),
+ setItem(k, v) { calls.push(v.length); if (v.length > budget) { const e = new Error('quota'); e.name = 'QuotaExceededError'; throw e; } m.set(k, String(v)); },
+ removeItem: (k) => m.delete(k),
+ get raw() { return m.get('sp.pref.stats') ?? null; },
+ };
+}
+
+describe('local stats: record building', () => {
+ test('builds one full record from a raw m.result (frame + players + self marking)', () => {
+ const rec = buildRecord(baseResult(), { myId: 'p1', roomMode: 'solo', now: 1700000000000 });
+ assert.ok(rec);
+ assert.equal(rec.v, STATS_VERSION);
+ assert.equal(rec.t, 1700000000000);
+ assert.equal(rec.selfId, 'p1');
+ assert.equal(rec.victory, true);
+ assert.equal(rec.difficulty, 'HARD');
+ assert.equal(rec.seed, 123456789);
+ assert.equal(rec.durationMs, 952123);
+ assert.equal(rec.roomMode, 'solo');
+ assert.equal(rec.id, recordId(baseResult(), 'p1'));
+ assert.equal(rec.players.length, 2);
+ const self = rec.players[0];
+ assert.equal(self.bandId, 'band_amiya');
+ assert.equal(self.title.id, 'comment_1');
+ assert.equal(self.stats.bossDamage, 5000.5);
+ assert.deepEqual(self.lineup, [{ id: 'char_290_vigna', golden: false, tier: 2, items: ['item_eq_1'] }]);
+ assert.deepEqual(self.bonds, [{ bondId: 'steadShip', layers: 12, active: true }]);
+ });
+
+ test('a spectator seat copy (my id not among players) records nothing; so do player-less error results', () => {
+ assert.equal(buildRecord(baseResult(), { myId: 'spec9', now: 1 }), null);
+ assert.equal(buildRecord(baseResult({ players: [] }), { myId: 'p1', now: 1 }), null);
+ assert.equal(buildRecord(null, { myId: 'p1' }), null);
+ });
+
+ test('roomMode falls back to the modeId (single → solo, multi → coop, else null)', () => {
+ assert.equal(roomModeOf('mode_multi_funny', null), 'coop');
+ assert.equal(roomModeOf('mode_single_normal', 'coop'), 'coop'); // explicit room mode wins
+ assert.equal(roomModeOf('mode_training_1', null), null);
+ assert.equal(buildRecord(baseResult({ modeId: 'mode_multi_hard' }), { myId: 'p1', now: 1 }).roomMode, 'coop');
+ });
+});
+
+describe('local stats: replay dedupe + cap', () => {
+ test('the replayed m.result (same content) appends once; a different seed is a new game', () => {
+ let stats = emptyStats();
+ const res = baseResult();
+ const first = appendRecord(stats, buildRecord(res, { myId: 'p1', now: 1000 }));
+ assert.equal(first.added, true);
+ const replay = appendRecord(first.stats, buildRecord(res, { myId: 'p1', now: 999000 }));
+ assert.equal(replay.added, false); // the reload / reconnect replay
+ assert.equal(replay.stats.records.length, 1);
+ assert.equal(replay.stats.records[0].t, 1000); // the FIRST arrival's timestamp is kept
+ const other = appendRecord(replay.stats, buildRecord(baseResult({ seed: 42, durationMs: 55555 }), { myId: 'p1', now: 2000 }));
+ assert.equal(other.added, true);
+ assert.equal(other.stats.records.length, 2);
+ assert.equal(other.stats.records[0].id, recordId(baseResult({ seed: 42, durationMs: 55555 }), 'p1'));
+ });
+
+ test('recordResult end-to-end over faked localStorage: replay arrives, nothing is written twice', () => {
+ globalThis.localStorage = fakeStorage();
+ try {
+ const res = baseResult();
+ const rec = recordResult(res, { myId: 'p1', roomMode: 'solo', now: 1000 });
+ assert.ok(rec);
+ assert.equal(recordResult(res, { myId: 'p1', roomMode: 'solo', now: 2000 }), null); // replay dropped
+ const loaded = loadStats();
+ assert.equal(loaded.records.length, 1);
+ assert.equal(loaded.records[0].id, rec.id);
+ } finally { delete globalThis.localStorage; }
+ });
+
+ test(`the store caps at MAX_RECORDS (${MAX_RECORDS}), dropping the oldest`, () => {
+ let stats = emptyStats();
+ for (let i = 0; i < MAX_RECORDS + 30; i++) {
+ stats = appendRecord(stats, buildRecord(baseResult({ seed: i }), { myId: 'p1', now: i })).stats;
+ }
+ assert.equal(stats.records.length, MAX_RECORDS);
+ assert.equal(stats.records[0].t, MAX_RECORDS + 29); // newest first
+ assert.equal(stats.records.at(-1).t, 30); // oldest 30 dropped
+ });
+});
+
+describe('local stats: migration / normalization', () => {
+ test('an unversioned envelope (older shape) normalizes with defaults and self-heals on load', () => {
+ globalThis.localStorage = fakeStorage();
+ try {
+ const old = { records: [{ players: [{ playerId: 'p1', stats: { kills: 2 }, futureField: { x: 1 } }] }] };
+ globalThis.localStorage.setItem('sp.pref.stats', JSON.stringify(old));
+ const loaded = loadStats();
+ assert.equal(loaded.v, STATS_VERSION);
+ assert.equal(loaded.records.length, 1);
+ const rec = loaded.records[0];
+ assert.equal(rec.victory, false);
+ assert.equal(rec.roundsPassed, 0);
+ assert.equal(rec.selfId, null);
+ assert.equal(rec.players[0].roundsPassed, 0);
+ assert.equal(rec.players[0].alive, true);
+ assert.deepEqual(rec.players[0].stats, { kills: 2 });
+ assert.deepEqual(rec.players[0].futureField, { x: 1 }); // unknown fields survive for a newer reader
+ const rewritten = JSON.parse(globalThis.localStorage.getItem('sp.pref.stats'));
+ assert.ok(rewritten);
+ assert.equal(rewritten.v, STATS_VERSION); // self-healed back to storage
+ } finally { delete globalThis.localStorage; }
+ });
+
+ test('broken records are dropped; a NEWER envelope is returned untouched and flagged (never saved over)', () => {
+ globalThis.localStorage = fakeStorage();
+ try {
+ globalThis.localStorage.setItem('sp.pref.stats', JSON.stringify({ v: STATS_VERSION, records: [null, { nope: 1 }, { players: [] }, baseResult()] }));
+ // baseResult is an m.result (players present) → normalizes into a record; the rest are dropped
+ const loaded = loadStats();
+ assert.equal(loaded.records.length, 1);
+
+ const newer = { v: STATS_VERSION + 5, records: [{ players: [], brandNew: true }] };
+ const mig = migrateStats(newer);
+ assert.equal(mig.newer, true);
+ assert.equal(mig.changed, false);
+ assert.deepEqual(mig.stats, { v: STATS_VERSION + 5, records: newer.records });
+ assert.equal(loadStats().newer, false);
+ } finally { delete globalThis.localStorage; }
+ });
+
+ test('the MIGRATIONS hook runs: v → v+1 steps apply in order (dry-run with a temporary step)', () => {
+ const original = MIGRATIONS[0];
+ MIGRATIONS[0] = ({ records }) => ({ v: 1, records: records.map((r) => ({ ...r, migrated: true })) });
+ try {
+ const { stats, changed } = migrateStats({ v: 0, records: [{ players: [{ playerId: 'p1' }] }] });
+ assert.equal(changed, true);
+ assert.equal(stats.records[0].migrated, true);
+ assert.equal(stats.v, STATS_VERSION);
+ } finally {
+ if (original === undefined) delete MIGRATIONS[0]; else MIGRATIONS[0] = original;
+ }
+ });
+
+ test('saveStats shrinks the history when the quota rejects the full write', () => {
+ // budget fits ~35 records but not 60: the full write throws, two quarter-shrinks land at 33
+ const probe = JSON.stringify({ v: STATS_VERSION, records: [baseResult()] });
+ globalThis.localStorage = fakeStorage({ budget: probe.length * 35 });
+ try {
+ let stats = emptyStats();
+ for (let i = 0; i < 60; i++) stats = appendRecord(stats, buildRecord(baseResult({ seed: i }), { myId: 'p1', now: i })).stats;
+ assert.equal(saveStats(stats), true);
+ const back = JSON.parse(globalThis.localStorage.getItem('sp.pref.stats'));
+ assert.ok(back.records.length < 60 && back.records.length > 8); // shrank instead of failing
+ assert.equal(back.records[0].t, 59); // newest kept, oldest dropped
+ } finally { delete globalThis.localStorage; }
+ });
+});
+
+describe('local stats: export / import merge', () => {
+ test('export → import round-trips; merge unions by id and counts added / skipped', () => {
+ globalThis.localStorage = fakeStorage();
+ try {
+ const rec = recordResult(baseResult(), { myId: 'p1', now: 1000 });
+ const exported = exportStats(loadStats());
+ assert.equal(exported.kind, 'local-stats');
+ assert.equal(exported.records.length, 1);
+ assert.equal(exported.records[0].id, rec.id);
+
+ // importing into the SAME store: everything is a duplicate
+ const same = importStats(exported, loadStats());
+ assert.equal(same.added, 0);
+ assert.equal(same.skipped, 1);
+ assert.equal(same.stats.records.length, 1);
+
+ // a second device's store (one shared + one new record) merges by id
+ const theirs = exportStats({ records: [rec, buildRecord(baseResult({ seed: 777 }), { myId: 'p1', now: 5000 })] });
+ const merged = importStats(theirs, loadStats());
+ assert.equal(merged.added, 1);
+ assert.equal(merged.stats.records.length, 2);
+ assert.equal(merged.stats.records[0].t, 1000); // chronological
+ saveStats(merged.stats);
+ assert.equal(loadStats().records.length, 2);
+ } finally { delete globalThis.localStorage; }
+ });
+
+ test('importing a NEWER export refuses with a clear error instead of downgrading', () => {
+ assert.throws(() => importStats({ v: STATS_VERSION + 1, records: [] }, emptyStats()), (e) => e.code === 'stats-newer-version');
+ });
+
+ test('garbage import is an ordinary empty envelope, not a crash in merge', () => {
+ const out = importStats({ hello: 'world' }, emptyStats());
+ assert.equal(out.added, 0);
+ assert.equal(out.stats.records.length, 0);
+ });
+});
+
+describe('local stats: aggregation (what the page renders)', () => {
+ const records = [
+ buildRecord(baseResult(), { myId: 'p1', roomMode: 'solo', now: 1000 }),
+ buildRecord(baseResult({ victory: false, roundsPassed: 8, hiddenReached: false, hiddenCleared: false, difficulty: 'NORMAL', modeId: 'mode_multi_normal', durationMs: 300000, seed: 2,
+ players: [
+ { ...baseResult().players[0], alive: true, victory: false, roundsPassed: 8, title: null, stats: { kills: 10, gold: 200 } },
+ baseResult().players[1],
+ ] }), { myId: 'p1', roomMode: 'coop', now: 2000 }),
+ ];
+ const agg = aggregateStats(records);
+
+ test('totals, wins (per-row victory), rounds and duration', () => {
+ assert.equal(agg.count, 2);
+ assert.equal(agg.wins, 1); // game 2 was a loss
+ assert.equal(agg.rounds.max, 15);
+ assert.equal(agg.rounds.total, 23);
+ assert.equal(agg.duration.totalMs, 952123 + 300000);
+ assert.equal(agg.hidden.reached, 1);
+ assert.equal(agg.hidden.cleared, 1);
+ assert.equal(agg.byMode.solo, 1);
+ assert.equal(agg.byMode.coop, 1);
+ });
+
+ test('per-difficulty rows', () => {
+ assert.deepEqual(agg.byDifficulty.HARD, { games: 1, wins: 1, hiddenCleared: 1 });
+ assert.deepEqual(agg.byDifficulty.NORMAL, { games: 1, wins: 0, hiddenCleared: 0 });
+ });
+
+ test('per-band games / passed and self titles', () => {
+ assert.deepEqual(agg.bands.band_amiya, { games: 2, wins: 1 });
+ assert.equal(agg.titles.comment_1.count, 1); // only the win granted 卫戍之星
+ });
+
+ test('combat sums over the self player only', () => {
+ assert.equal(agg.sums.kills, 41 + 10);
+ assert.equal(agg.sums.gold, 880 + 200);
+ assert.equal(agg.sums.leaks, 2); // game 2's self row has no leaks → skipped, not NaN
+ });
+
+ test('selfRowOf fallbacks: selfId, else first human, else first row; anonymous record → null', () => {
+ assert.equal(selfRowOf(records[0]).playerId, 'p1');
+ const noSelf = normalizeRecord({ players: [{ playerId: 'a', isBot: true }, { playerId: 'b', isBot: false }] });
+ assert.equal(selfRowOf(noSelf).playerId, 'b');
+ assert.equal(selfRowOf({ players: [] }), null);
+ });
+});
+
+describe('local stats: recordToResult (最近对局行 → 结算页回看)', () => {
+ test('record → m.result payload → normalizeResult renders the same settlement the live push did', () => {
+ const rec = buildRecord(baseResult(), { myId: 'p1', roomMode: 'solo', now: 1000 });
+ const res = recordToResult(rec);
+ assert.ok(res);
+ const view = normalizeResult(res, null);
+ assert.equal(view.victory, true);
+ assert.equal(view.difficulty, 'HARD');
+ assert.equal(view.modeId, 'mode_single_hard');
+ assert.equal(view.roundsPassed, 15);
+ assert.equal(view.hiddenReached, true);
+ assert.equal(view.hiddenCleared, true);
+ assert.equal(view.durationMs, 952123);
+ assert.equal(view.players.length, 2);
+ const self = view.players.find((p) => p.playerId === 'p1');
+ assert.equal(self.bandId, 'band_amiya');
+ assert.equal(self.title.id, 'comment_1');
+ assert.equal(self.stats.kills, 41);
+ assert.equal(self.stats.bossDamage, 5000.5);
+ assert.equal(self.lineup[0].id, 'char_290_vigna');
+ assert.equal(self.lineup[0].golden, false);
+ const mate = view.players.find((p) => p.playerId === 'p2');
+ assert.equal(mate.alive, false);
+ assert.equal(mate.roundsPassed, 9);
+ });
+
+ test('a null lastRound is passed through as absent (normalizeResult defaults it); garbage → null', () => {
+ const rec = buildRecord(baseResult({ lastRound: undefined }), { myId: 'p1', now: 1 });
+ assert.equal('lastRound' in recordToResult(rec), false);
+ assert.equal(recordToResult(null), null);
+ assert.equal(recordToResult({ players: [] }), null);
+ });
+});