Dodaios is an open-source agent OS for your desktop: it runs your coding agents, browser and apps by voice or chat, on your own machine. Formerly Personal Jarvis.
Python agent-orchestrationai-agentai-coding-assistantclaude-codecoding-agentcomputer-usedesktop-applocal-firstmcppersonal-jarvisvoice-assistantvoice-coding
feat(verse): add duel progression and duel stats in both service records (#1132)
Ruben Lütke836e0ee20876
diff --git a/dodaios/progression/duel_stats.py b/dodaios/progression/duel_stats.pynew file mode 100644index 0000000000..9d059f77ff--- /dev/null+++ b/dodaios/progression/duel_stats.py@@ -0,0 +1,672 @@+"""Duel statistics: one row per ``duel.result`` and the running totals.++The hangar duel reports one result per set (``docs/verse/unreal/contracts/+bridge-protocol.md`` 10): ``won`` or ``lost`` for a finished set, ``unfinished``+for a set left mid-way. Every result lands here, whether it paid XP or not,+so the service record can show sets, wins, K/D, headshots, finishers and the+best streak, per opponent tier and per weapon.++The tables live in the progression database next to the XP ledger+(``<data_dir>/progression.db``), opened on first use (AP-26). ``match_id`` is+the primary key, so a result sent twice is stored once. Parsing clamps what a+client could inflate (more than one kill per two seconds of match time) and+reports every clamp, so the service can log it.+"""++from __future__ import annotations++import json+import math+import sqlite3+import threading+import time+from collections.abc import Callable, Mapping+from dataclasses import dataclass, field+from pathlib import Path+from typing import Any++from .rules import DUEL_END_REASONS, DUEL_OUTCOMES, DUEL_SECONDS_PER_KILL, duel_tier_key++__all__ = [+ "DuelResult",+ "DuelResultError",+ "DuelStatsStore",+ "DuelWeapon",+ "SCHEMA_VERSION",+ "parse_duel_result",+]++#: Largest count any one stat may carry; anything above is a broken client.+_MAX_COUNT = 1_000_000+#: Longest set the store believes (a day of match time).+_MAX_MATCH_TIME_S = 86_400.0+_MAX_ID = 80+_MAX_WEAPONS = 32+#: Tier keys the bridge's ``duel_stats.by_tier`` may carry.+BRIDGE_TIERS: tuple[str, ...] = ("normal", "hard", "elite", "adaptive")++_STAT_FIELDS: tuple[str, ...] = (+ "kills",+ "deaths",+ "headshots",+ "finishers",+ "melee_kills",+ "shots_fired",+ "shots_hit",+ "damage_dealt",+ "damage_taken",+ "walls_breached",+ "bulwarks_placed",+ "best_streak",+)+++class DuelResultError(ValueError):+ """A ``duel.result`` the server cannot read; the bridge answers ``bad_request``."""++ code = "bad_request"+++@dataclass(frozen=True, slots=True)+class DuelWeapon:+ weapon_id: str+ kills: int = 0+ headshots: int = 0+ shots_fired: int = 0+ shots_hit: int = 0+++@dataclass(frozen=True, slots=True)+class DuelResult:+ match_id: str+ session_id: str+ set_index: int+ mode: str+ ruleset: str+ opponent_kind: str+ tier: str+ adaptive: bool+ started_at: float+ ended_at: float+ match_time_s: float+ end_reason: str+ outcome: str+ score_player: int+ score_opponent: int+ stats: dict[str, int]+ weapons: tuple[DuelWeapon, ...] = ()+ build_version: str = ""+ build_changelist: str = ""+ #: What parsing had to clamp, ``field: sent -> kept``; empty for a plausible result.+ clamped: tuple[str, ...] = field(default=())++ @property+ def tier_key(self) -> str:+ return duel_tier_key(self.opponent_kind, self.tier, self.adaptive)+++# ------------------------------------------------------------------ parsing+++def _text(value: Any, name: str, *, required: bool = False, limit: int = _MAX_ID) -> str:+ if value is None:+ value = ""+ if not isinstance(value, str):+ raise DuelResultError(f"{name} must be a string")+ value = value.strip()+ if required and not value:+ raise DuelResultError(f"{name} is required")+ return value[:limit]+++def _count(value: Any, name: str) -> int:+ if value is None:+ return 0+ if isinstance(value, bool) or not isinstance(value, (int, float)):+ raise DuelResultError(f"{name} must be a number")+ if isinstance(value, float) and not math.isfinite(value):+ raise DuelResultError(f"{name} must be finite")+ return max(0, min(_MAX_COUNT, int(value)))+++def _seconds(value: Any, name: str) -> float:+ if value is None:+ return 0.0+ if isinstance(value, bool) or not isinstance(value, (int, float)):+ raise DuelResultError(f"{name} must be a number")+ number = float(value)+ if not math.isfinite(number):+ raise DuelResultError(f"{name} must be finite")+ return number+++def _mapping(value: Any, name: str) -> Mapping[str, Any]:+ if value is None:+ return {}+ if not isinstance(value, Mapping):+ raise DuelResultError(f"{name} must be an object")+ return value+++def parse_duel_result(data: Any) -> DuelResult:+ """Validate a ``duel.result`` payload and clamp its implausible numbers.++ Raises :class:`DuelResultError` for a payload that is not a result at all+ (no ``match_id``, an unknown ``outcome``, a wrong type). Numbers a client+ could inflate are clamped, never refused: the set still counts.+ """+ if not isinstance(data, Mapping):+ raise DuelResultError("duel.result data must be an object")+ clamped: list[str] = []++ def clamp(name: str, value: int, ceiling: int) -> int:+ if value > ceiling:+ clamped.append(f"{name}: {value} -> {ceiling}")+ return ceiling+ return value++ match_id = _text(data.get("match_id"), "match_id", required=True)+ outcome = _text(data.get("outcome"), "outcome", required=True)+ if outcome not in DUEL_OUTCOMES:+ raise DuelResultError(f"unknown outcome {outcome!r}")+ end_reason = _text(data.get("end_reason"), "end_reason") or "unknown"+ if end_reason not in DUEL_END_REASONS:+ end_reason = "unknown"++ match_time = _seconds(data.get("match_time_s"), "match_time_s")+ if match_time < 0:+ clamped.append(f"match_time_s: {match_time} -> 0")+ match_time = 0.0+ if match_time > _MAX_MATCH_TIME_S:+ clamped.append(f"match_time_s: {match_time} -> {_MAX_MATCH_TIME_S}")+ match_time = _MAX_MATCH_TIME_S++ opponent = _mapping(data.get("opponent"), "opponent")+ adaptive = opponent.get("adaptive", False)+ if not isinstance(adaptive, bool):+ raise DuelResultError("opponent.adaptive must be a boolean")++ raw_stats = _mapping(data.get("stats"), "stats")+ stats = {name: _count(raw_stats.get(name), f"stats.{name}") for name in _STAT_FIELDS}+ # One kill per DUEL_SECONDS_PER_KILL of match time is the most a set can hold.+ kill_ceiling = int(match_time // DUEL_SECONDS_PER_KILL)+ stats["kills"] = clamp("kills", stats["kills"], kill_ceiling)+ stats["deaths"] = clamp("deaths", stats["deaths"], kill_ceiling)+ for name in ("headshots", "finishers", "melee_kills", "best_streak"):+ stats[name] = clamp(name, stats[name], stats["kills"])+ stats["shots_hit"] = clamp("shots_hit", stats["shots_hit"], stats["shots_fired"])++ score = _mapping(data.get("score"), "score")+ score_player = clamp("score.player", _count(score.get("player"), "score.player"), kill_ceiling)+ score_opponent = clamp(+ "score.opponent", _count(score.get("opponent"), "score.opponent"), kill_ceiling+ )++ raw_weapons = data.get("weapons")+ if raw_weapons is None:+ raw_weapons = []+ if not isinstance(raw_weapons, list):+ raise DuelResultError("weapons must be a list")+ merged: dict[str, list[int]] = {}+ for entry in raw_weapons[:_MAX_WEAPONS]:+ entry = _mapping(entry, "weapons[]")+ weapon_id = _text(entry.get("weapon_id"), "weapons[].weapon_id", limit=40)+ if not weapon_id:+ continue+ row = merged.setdefault(weapon_id, [0, 0, 0, 0])+ for i, name in enumerate(("kills", "headshots", "shots_fired", "shots_hit")):+ row[i] = min(_MAX_COUNT, row[i] + _count(entry.get(name), f"weapons[].{name}"))+ weapons: list[DuelWeapon] = []+ kills_left = stats["kills"]+ for weapon_id, (kills, headshots, fired, hit) in merged.items():+ kills = clamp(f"weapons.{weapon_id}.kills", kills, kills_left)+ kills_left -= kills+ headshots = clamp(f"weapons.{weapon_id}.headshots", headshots, kills)+ hit = clamp(f"weapons.{weapon_id}.shots_hit", hit, fired)+ weapons.append(DuelWeapon(weapon_id, kills, headshots, fired, hit))++ build = _mapping(data.get("build"), "build")+ set_index = data.get("set_index", 0)+ if isinstance(set_index, bool) or not isinstance(set_index, (int, float)):+ raise DuelResultError("set_index must be a number")+ return DuelResult(+ match_id=match_id,+ session_id=_text(data.get("session_id"), "session_id"),+ set_index=max(0, int(set_index)),+ mode=_text(data.get("mode"), "mode", limit=40),+ ruleset=_text(data.get("ruleset"), "ruleset", limit=40),+ opponent_kind=_text(opponent.get("kind"), "opponent.kind", limit=20) or "bot",+ tier=_text(opponent.get("tier"), "opponent.tier", limit=20),+ adaptive=adaptive,+ started_at=_seconds(data.get("started_at"), "started_at"),+ ended_at=_seconds(data.get("ended_at"), "ended_at"),+ match_time_s=round(match_time, 3),+ end_reason=end_reason,+ outcome=outcome,+ score_player=score_player,+ score_opponent=score_opponent,+ stats=stats,+ weapons=tuple(weapons),+ build_version=_text(build.get("version"), "build.version", limit=40),+ build_changelist=_text(build.get("changelist"), "build.changelist", limit=40),+ clamped=tuple(clamped),+ )+++# ------------------------------------------------------------------ store++#: Bumped with every entry of :data:`_MIGRATIONS`.+SCHEMA_VERSION = 1++_MIGRATIONS: tuple[str, ...] = (+ # 1: results, per-weapon lines.+ """+ CREATE TABLE IF NOT EXISTS duel_results (+ match_id TEXT PRIMARY KEY,+ session_id TEXT NOT NULL DEFAULT '',+ set_index INTEGER NOT NULL DEFAULT 0,+ mode TEXT NOT NULL DEFAULT '',+ ruleset TEXT NOT NULL DEFAULT '',+ opponent_kind TEXT NOT NULL DEFAULT 'bot',+ tier TEXT NOT NULL DEFAULT '',+ adaptive INTEGER NOT NULL DEFAULT 0,+ tier_key TEXT NOT NULL DEFAULT 'unknown',+ outcome TEXT NOT NULL CHECK (outcome IN ('won', 'lost', 'unfinished')),+ end_reason TEXT NOT NULL DEFAULT 'unknown',+ started_at REAL NOT NULL DEFAULT 0,+ ended_at REAL NOT NULL DEFAULT 0,+ match_time_s REAL NOT NULL DEFAULT 0,+ score_player INTEGER NOT NULL DEFAULT 0,+ score_opponent INTEGER NOT NULL DEFAULT 0,+ kills INTEGER NOT NULL DEFAULT 0,+ deaths INTEGER NOT NULL DEFAULT 0,+ headshots INTEGER NOT NULL DEFAULT 0,+ finishers INTEGER NOT NULL DEFAULT 0,+ melee_kills INTEGER NOT NULL DEFAULT 0,+ shots_fired INTEGER NOT NULL DEFAULT 0,+ shots_hit INTEGER NOT NULL DEFAULT 0,+ damage_dealt INTEGER NOT NULL DEFAULT 0,+ damage_taken INTEGER NOT NULL DEFAULT 0,+ walls_breached INTEGER NOT NULL DEFAULT 0,+ bulwarks_placed INTEGER NOT NULL DEFAULT 0,+ best_streak INTEGER NOT NULL DEFAULT 0,+ build_version TEXT NOT NULL DEFAULT '',+ build_changelist TEXT NOT NULL DEFAULT '',+ clamped TEXT NOT NULL DEFAULT '[]',+ awards TEXT NOT NULL DEFAULT '[]',+ awards_done INTEGER NOT NULL DEFAULT 0,+ recorded_ms INTEGER NOT NULL+ );+ CREATE INDEX IF NOT EXISTS idx_duel_results_recorded ON duel_results (recorded_ms);+ CREATE TABLE IF NOT EXISTS duel_weapons (+ match_id TEXT NOT NULL REFERENCES duel_results (match_id),+ weapon_id TEXT NOT NULL,+ kills INTEGER NOT NULL DEFAULT 0,+ headshots INTEGER NOT NULL DEFAULT 0,+ shots_fired INTEGER NOT NULL DEFAULT 0,+ shots_hit INTEGER NOT NULL DEFAULT 0,+ PRIMARY KEY (match_id, weapon_id)+ );+ """,+)++_RESULT_COLUMNS: tuple[str, ...] = (+ "match_id",+ "session_id",+ "set_index",+ "mode",+ "ruleset",+ "opponent_kind",+ "tier",+ "adaptive",+ "tier_key",+ "outcome",+ "end_reason",+ "started_at",+ "ended_at",+ "match_time_s",+ "score_player",+ "score_opponent",+ *_STAT_FIELDS,+ "build_version",+ "build_changelist",+ "clamped",+ "recorded_ms",+)+++def _kd(kills: int, deaths: int) -> float:+ return round(kills / deaths, 2) if deaths > 0 else float(kills)+++class DuelStatsStore:+ """The duel tables of the progression database. Synchronous; call off the loop."""++ def __init__(self, path: Path, *, clock: Callable[[], int] | None = None) -> None:+ self._path = Path(path)+ self._clock = clock or (lambda: int(time.time() * 1000))+ self._conn: sqlite3.Connection | None = None+ self._lock = threading.Lock()++ def _connection(self) -> sqlite3.Connection:+ if self._conn is None:+ self._path.parent.mkdir(parents=True, exist_ok=True)+ conn = sqlite3.connect(+ self._path, isolation_level=None, check_same_thread=False, timeout=5.0+ )+ conn.row_factory = sqlite3.Row+ # The XP ledger may be creating the same file on another thread; a+ # journal-mode switch then reports "locked" without waiting.+ for attempt in range(50):+ try:+ conn.execute("PRAGMA journal_mode=WAL")+ self._migrate(conn)+ break+ except sqlite3.OperationalError as exc:+ if "locked" not in str(exc) or attempt == 49:+ conn.close()+ raise+ time.sleep(0.05)+ self._conn = conn+ return self._conn++ @staticmethod+ def _migrate(conn: sqlite3.Connection) -> None:+ """Apply every migration newer than the stored version, each in its own transaction.++ The version lives in its own table, because ``PRAGMA user_version``+ belongs to the whole database and the XP ledger shares it.+ """+ conn.execute(+ "CREATE TABLE IF NOT EXISTS duel_schema (id INTEGER PRIMARY KEY CHECK (id = 1),"+ " version INTEGER NOT NULL)"+ )+ row = conn.execute("SELECT version FROM duel_schema WHERE id = 1").fetchone()+ current = int(row[0]) if row else 0+ for version, script in enumerate(_MIGRATIONS, start=1):+ if version <= current:+ continue+ conn.execute("BEGIN IMMEDIATE")+ try:+ for statement in script.split(";"):+ if statement.strip():+ conn.execute(statement)+ conn.execute(+ "INSERT INTO duel_schema (id, version) VALUES (1, ?)"+ " ON CONFLICT(id) DO UPDATE SET version = excluded.version",+ (version,),+ )+ except Exception:+ conn.execute("ROLLBACK")+ raise+ conn.execute("COMMIT")++ def schema_version(self) -> int:+ with self._lock:+ row = (+ self._connection()+ .execute("SELECT version FROM duel_schema WHERE id = 1")+ .fetchone()+ )+ return int(row[0]) if row else 0++ def close(self) -> None:+ with self._lock:+ if self._conn is not None:+ self._conn.close()+ self._conn = None++ # ------------------------------------------------------------ writes++ def insert(self, result: DuelResult) -> bool:+ """Store ``result``; ``False`` when its ``match_id`` is already stored."""+ values: dict[str, Any] = {+ "match_id": result.match_id,+ "session_id": result.session_id,+ "set_index": result.set_index,+ "mode": result.mode,+ "ruleset": result.ruleset,+ "opponent_kind": result.opponent_kind,+ "tier": result.tier,+ "adaptive": int(result.adaptive),+ "tier_key": result.tier_key,+ "outcome": result.outcome,+ "end_reason": result.end_reason,+ "started_at": result.started_at,+ "ended_at": result.ended_at,+ "match_time_s": result.match_time_s,+ "score_player": result.score_player,+ "score_opponent": result.score_opponent,+ **{name: result.stats[name] for name in _STAT_FIELDS},+ "build_version": result.build_version,+ "build_changelist": result.build_changelist,+ "clamped": json.dumps(list(result.clamped)),+ "recorded_ms": self._clock(),+ }+ columns = ", ".join(_RESULT_COLUMNS)+ marks = ", ".join("?" for _ in _RESULT_COLUMNS)+ with self._lock:+ conn = self._connection()+ conn.execute("BEGIN IMMEDIATE")+ try:+ cur = conn.execute(+ f"INSERT OR IGNORE INTO duel_results ({columns}) VALUES ({marks})", # noqa: S608 - constant columns+ tuple(values[c] for c in _RESULT_COLUMNS),+ )+ inserted = cur.rowcount == 1+ if inserted:+ conn.executemany(+ "INSERT INTO duel_weapons"+ " (match_id, weapon_id, kills, headshots, shots_fired, shots_hit)"+ " VALUES (?, ?, ?, ?, ?, ?)",+ [+ (+ result.match_id,+ w.weapon_id,+ w.kills,+ w.headshots,+ w.shots_fired,+ w.shots_hit,+ )+ for w in result.weapons+ ],+ )+ except Exception:+ conn.execute("ROLLBACK")+ raise+ conn.execute("COMMIT")+ return inserted++ def finish(self, match_id: str, awards: list[dict[str, Any]]) -> None:+ """Mark the result's awards as paid and keep what they were."""+ with self._lock:+ self._connection().execute(+ "UPDATE duel_results SET awards = ?, awards_done = 1 WHERE match_id = ?",+ (json.dumps(awards), match_id),+ )++ def paid_awards(self, subject_id: str, ref: str) -> list[dict[str, Any]]:+ """Every award the XP ledger holds for ``ref``, oldest first.++ The ledger (``progression_awards``, store.py) lives in the same file. A+ resend after a crash between paying and ``finish`` pays nothing new (the+ ledger refuses a repeated ref), so its summaries come from here.+ """+ with self._lock:+ rows = (+ self._connection()+ .execute(+ "SELECT source, xp, seq FROM progression_awards"+ " WHERE subject_id = ? AND ref = ? ORDER BY seq",+ (subject_id, ref),+ )+ .fetchall()+ )+ return [{"xp_source": r[0], "xp": int(r[1]), "seq": int(r[2])} for r in rows]++ # ------------------------------------------------------------ reads++ def get(self, match_id: str) -> dict[str, Any] | None:+ with self._lock:+ row = (+ self._connection()+ .execute("SELECT * FROM duel_results WHERE match_id = ?", (match_id,))+ .fetchone()+ )+ return self._row(row) if row is not None else None++ @staticmethod+ def _row(row: sqlite3.Row) -> dict[str, Any]:+ data = dict(row)+ data["adaptive"] = bool(data["adaptive"])+ data["awards_done"] = bool(data["awards_done"])+ data["awards"] = json.loads(data["awards"] or "[]")+ data["clamped"] = json.loads(data["clamped"] or "[]")+ return data++ def count(self) -> int:+ with self._lock:+ row = self._connection().execute("SELECT COUNT(*) FROM duel_results").fetchone()+ return int(row[0]) if row else 0++ def totals(self) -> dict[str, Any]:+ """Running totals over every stored result, per tier and per weapon."""+ aggregate = """+ COUNT(*) AS matches,+ COALESCE(SUM(outcome = 'won'), 0) AS wins,+ COALESCE(SUM(outcome = 'lost'), 0) AS losses,+ COALESCE(SUM(outcome = 'unfinished'), 0) AS unfinished,+ COALESCE(SUM(kills), 0) AS kills,+ COALESCE(SUM(deaths), 0) AS deaths,+ COALESCE(SUM(headshots), 0) AS headshots,+ COALESCE(SUM(finishers), 0) AS finishers,+ COALESCE(SUM(melee_kills), 0) AS melee_kills,+ COALESCE(MAX(best_streak), 0) AS best_streak,+ COALESCE(SUM(match_time_s), 0) AS match_time_s+ """+ with self._lock:+ conn = self._connection()+ total = conn.execute(f"SELECT {aggregate} FROM duel_results").fetchone() # noqa: S608 - constant SQL+ tiers = conn.execute(+ f"SELECT tier_key, {aggregate} FROM duel_results GROUP BY tier_key" # noqa: S608 - constant SQL+ " ORDER BY tier_key"+ ).fetchall()+ weapons = conn.execute(+ "SELECT weapon_id, SUM(kills) AS kills, SUM(headshots) AS headshots,"+ " SUM(shots_fired) AS shots_fired, SUM(shots_hit) AS shots_hit"+ " FROM duel_weapons GROUP BY weapon_id ORDER BY weapon_id"+ ).fetchall()++ def block(row: sqlite3.Row) -> dict[str, Any]:+ data = {+ key: int(row[key])+ for key in (+ "matches",+ "wins",+ "losses",+ "unfinished",+ "kills",+ "deaths",+ "headshots",+ "finishers",+ "melee_kills",+ "best_streak",+ )+ }+ data["kd"] = _kd(data["kills"], data["deaths"])+ data["match_time_s"] = round(float(row["match_time_s"]), 1)+ return data++ result = block(total)+ result["by_tier"] = {row["tier_key"]: block(row) for row in tiers}+ result["by_weapon"] = {+ row["weapon_id"]: {+ "kills": int(row["kills"]),+ "headshots": int(row["headshots"]),+ "shots_fired": int(row["shots_fired"]),+ "shots_hit": int(row["shots_hit"]),+ "accuracy": round(int(row["shots_hit"]) / int(row["shots_fired"]), 3)+ if int(row["shots_fired"]) > 0+ else 0.0,+ }+ for row in weapons+ }+ return result++ def bridge_totals(self) -> dict[str, Any]:+ """The totals as ``verse.bridge/1`` carries them (``duel_stats`` in the golden schema).++ The bridge shape is strict: the core counts, and per bot tier only+ wins and losses; sets against a player or an unknown tier stay out of+ ``by_tier`` but count in the totals.+ """+ full = self.totals()+ keys = (+ "matches",+ "wins",+ "losses",+ "unfinished",+ "kills",+ "deaths",+ "headshots",+ "finishers",+ "best_streak",+ )+ return {+ **{key: full[key] for key in keys},+ "by_tier": {+ tier: {"wins": row["wins"], "losses": row["losses"]}+ for tier, row in full["by_tier"].items()+ if tier in BRIDGE_TIERS+ },+ }++ def recent(self, *, limit: int = 20) -> list[dict[str, Any]]:+ """The newest results first, each with its awards and weapon lines."""+ limit = max(1, min(100, int(limit)))+ with self._lock:+ conn = self._connection()+ rows = conn.execute(+ "SELECT * FROM duel_results ORDER BY recorded_ms DESC, rowid DESC LIMIT ?",+ (limit,),+ ).fetchall()+ ids = [row["match_id"] for row in rows]+ lines: dict[str, list[dict[str, Any]]] = {i: [] for i in ids}+ if ids:+ marks = ", ".join("?" for _ in ids)+ for line in conn.execute(+ f"SELECT * FROM duel_weapons WHERE match_id IN ({marks})" # noqa: S608 - placeholders only+ " ORDER BY kills DESC, weapon_id",+ ids,+ ).fetchall():+ entry = dict(line)+ lines[entry.pop("match_id")].append(entry)+ out = []+ for row in rows:+ data = self._row(row)+ out.append(+ {+ "match_id": data["match_id"],+ "session_id": data["session_id"],+ "set_index": data["set_index"],+ "mode": data["mode"],+ "outcome": data["outcome"],+ "end_reason": data["end_reason"],+ "opponent": {+ "kind": data["opponent_kind"],+ "tier": data["tier"],+ "adaptive": data["adaptive"],+ },+ "tier_key": data["tier_key"],+ "match_time_s": data["match_time_s"],+ "score": {"player": data["score_player"], "opponent": data["score_opponent"]},+ "stats": {name: data[name] for name in _STAT_FIELDS},+ "kd": _kd(data["kills"], data["deaths"]),+ "weapons": lines.get(data["match_id"], []),+ "xp": sum(int(a.get("xp", 0)) for a in data["awards"]),+ "awards": data["awards"],+ "clamped": bool(data["clamped"]),+ "recorded_ms": data["recorded_ms"],+ }+ )+ return outdiff --git a/dodaios/progression/rules.py b/dodaios/progression/rules.pyindex 2aaf682045..c21a167dde 100644--- a/dodaios/progression/rules.py+++ b/dodaios/progression/rules.py@@ -134,6 +134,11 @@ RULES: Final[tuple[XpRule, ...]] = (XpRule("simulator_record", "person", 15, "world", cooldown_s=45, daily_cap=60),XpRule("team_briefing", "person", 10, "world", cooldown_s=600, daily_cap=40),XpRule("inspection", "person", 15, "world", once_per_ref=True, daily_cap=30),+ # The commander, in the hangar duel. Server rules: only a ``duel.result``+ # reaches them (``record_duel``), never ``POST /actions``.+ XpRule("duel_won", "person", 40, "server", daily_cap=200),+ XpRule("duel_lost", "person", 10, "server", daily_cap=50),+ XpRule("duel_finisher", "person", 5, "server", daily_cap=25),# The crew: finished work is what counts.XpRule("task_done", "agent", 40, "server"),XpRule("task_blocked", "agent", 8, "server", daily_cap=40),@@ -171,6 +176,81 @@ RETIRED_SOURCES: Final[frozenset[str]] = frozenset()+# ------------------------------------------------------------------ duel rules++#: The duel sources, in rulebook order (``docs/verse/unreal/contracts/bridge-protocol.md`` 10).+DUEL_SOURCES: Final[tuple[str, ...]] = ("duel_won", "duel_lost", "duel_finisher")++#: ``duel.result`` outcomes, from the person's side: a finished set is won or+#: lost; a set left mid-way (or cut short by Verse quitting) is unfinished.+DUEL_OUTCOMES: Final[tuple[str, ...]] = ("won", "lost", "unfinished")++#: Why a set ended. ``crash_recovered`` is a pending result the next launch sent.+DUEL_END_REASONS: Final[tuple[str, ...]] = (+ "set_complete",+ "player_left",+ "verse_quit",+ "crash_recovered",+ "app_quit",+)++#: Game modes whose sets pay XP in ``verse.bridge/1``. Every mode counts in the statistics.+DUEL_PAYING_MODES: Final[frozenset[str]] = frozenset({"deathmatch_1v1"})++#: A finished set shorter than this (match time, pauses excluded) pays nothing.+DUEL_MIN_PAYING_TIME_S: Final[float] = 60.0++#: More kills than one per this many seconds of match time is implausible; the+#: server clamps the numbers to this rate and logs it.+DUEL_SECONDS_PER_KILL: Final[float] = 2.0++#: Multiplier on ``duel_won`` by the opponent's tier; an adaptive bot pays as+#: ``adaptive`` whatever tier it started on. Unknown tiers pay 1.0.+DUEL_TIER_MULTIPLIERS: Final[dict[str, float]] = {+ "normal": 1.0,+ "hard": 1.5,+ "elite": 2.0,+ "adaptive": 1.5,+}+++def duel_tier_key(opponent_kind: str, tier: str, adaptive: bool) -> str:+ """The key a set is filed and paid under: ``adaptive``, a bot tier, or ``player``.++ ``opponent.kind`` is ``bot`` or ``player`` (another person, later).+ """+ if opponent_kind == "bot":+ if adaptive:+ return "adaptive"+ return tier if tier in DUEL_TIER_MULTIPLIERS else "unknown"+ return opponent_kind or "unknown"+++def duel_awards(+ *, mode: str, outcome: str, match_time_s: float, tier_key: str, finishers: int+) -> list[tuple[str, int]]:+ """The ``(source, xp)`` pairs one set pays before the daily caps.++ Only a finished set (``won`` or ``lost``) of a paying mode that lasted at+ least :data:`DUEL_MIN_PAYING_TIME_S` pays; ``unfinished`` never does. A won+ set pays ``duel_won`` times the tier multiplier, a lost one ``duel_lost``;+ either pays ``duel_finisher`` once per finisher.+ """+ if mode not in DUEL_PAYING_MODES or outcome not in ("won", "lost"):+ return []+ if match_time_s < DUEL_MIN_PAYING_TIME_S:+ return []+ awards: list[tuple[str, int]] = []+ if outcome == "won":+ base = RULES_BY_SOURCE["duel_won"].xp+ awards.append(("duel_won", int(round(base * DUEL_TIER_MULTIPLIERS.get(tier_key, 1.0)))))+ else:+ awards.append(("duel_lost", RULES_BY_SOURCE["duel_lost"].xp))+ if finishers > 0:+ awards.append(("duel_finisher", RULES_BY_SOURCE["duel_finisher"].xp * int(finishers)))+ return awards++# ------------------------------------------------------------------ ranksRankTier = Literal["deck", "line", "command", "flag"]diff --git a/dodaios/progression/service.py b/dodaios/progression/service.pyindex 55a73a6a97..163972284f 100644--- a/dodaios/progression/service.py+++ b/dodaios/progression/service.py@@ -18,13 +18,16 @@ not at boot (AP-26). Writes run off the event loop.from __future__ import annotationsimport asyncio+import dataclassesimport logging+import threadingimport time-from collections.abc import Callable+from collections.abc import Callable, Mappingfrom datetime import datetimefrom pathlib import Pathfrom typing import Any+from .duel_stats import DuelResult, DuelResultError, DuelStatsStore, parse_duel_resultfrom .rules import (LEAD_AGENT_ID,PERSON_ID,@@ -32,6 +35,7 @@ from .rules import (VERSE_DECKS,WORLD_ACTIONS,agent_subject,+ duel_awards,looks_between,pet_subject,progress_for_xp,@@ -43,7 +47,7 @@ from .store import Award, ProgressionStorelog = logging.getLogger(__name__)-__all__ = ["VERSE_DECKS", "ProgressionService", "UnknownAction"]+__all__ = ["VERSE_DECKS", "DuelResultError", "ProgressionService", "UnknownAction"]class UnknownAction(ValueError):@@ -61,6 +65,10 @@ class ProgressionService:) -> None:self._clock = clock or (lambda: int(time.time() * 1000))self.store = ProgressionStore(db_path, clock=self._clock)+ self.duels = DuelStatsStore(db_path, clock=self._clock)+ # One duel result at a time: its row, its awards and its mark are one step.+ self._duel_lock = threading.Lock()+ self._ledger_open = Falseself._bus = busself._pet_id = pet_id or (lambda: "gigi")self._attached = False@@ -92,6 +100,7 @@ class ProgressionService:def close(self) -> None:for task in list(self._tasks):task.cancel()+ self.duels.close()self.store.close()async def drain(self) -> None:@@ -202,6 +211,110 @@ class ProgressionService:if agent_id and agent_id != LEAD_AGENT_ID:self._later((PERSON_ID, "agent_hired", f"agent:{agent_id}"))+ # ------------------------------------------------------------ duels++ async def record_duel(self, data: Mapping[str, Any]) -> dict[str, Any]:+ """Store one ``duel.result`` (bridge-protocol 10) and pay its XP.++ Idempotent on ``match_id``: a result sent again stores nothing, pays+ nothing and answers with the awards the first one paid. Implausible+ numbers are clamped and logged. Raises :class:`DuelResultError` for a+ payload that is not a result (the bridge answers ``bad_request``).+ """+ result = parse_duel_result(data)+ if result.clamped:+ log.warning(+ "progression: duel %s clamped: %s", result.match_id, "; ".join(result.clamped)+ )+ fresh, awards, paid = await asyncio.to_thread(self._record_duel_locked, result)+ for award in paid:+ await self._announce(award)+ if fresh:+ await self._announce_duel(result)+ totals = await asyncio.to_thread(self.duels.bridge_totals)+ # Exactly the reply result of bridge-protocol 10 (golden schema ``result.duel.result``).+ return {+ "recorded": True,+ "awards": [{"xp_source": a["xp_source"], "xp": a["xp"]} for a in awards],+ "duel_stats": totals,+ }++ def _record_duel_locked(+ self, result: DuelResult+ ) -> tuple[bool, list[dict[str, Any]], list[Award]]:+ """Store the row and pay its rules; returns (fresh, award summaries, new awards)."""+ with self._duel_lock:+ self._ledger_first()+ fresh = self.duels.insert(result)+ row = self.duels.get(result.match_id)+ if row is not None and row["awards_done"]:+ return fresh, list(row["awards"]), []+ # A new row, or one whose awards a crash interrupted: the ledger's+ # per-ref uniqueness keeps a rerun from paying anything twice.+ ref = f"duel:{result.match_id}"+ paid: list[Award] = []+ for source, xp in duel_awards(+ mode=result.mode,+ outcome=result.outcome,+ match_time_s=result.match_time_s,+ tier_key=result.tier_key,+ finishers=result.stats["finishers"],+ ):+ rule = dataclasses.replace(RULES_BY_SOURCE[source], xp=xp)+ award = self.store.award(PERSON_ID, rule, ref=ref)+ if award is not None:+ paid.append(award)+ # Summaries from the ledger, not only from this run: after a crash+ # between paying and finish() the rerun pays nothing new, yet the+ # set still paid what the ledger holds for its ref.+ summaries = self.duels.paid_awards(PERSON_ID, ref)+ self.duels.finish(result.match_id, summaries)+ return fresh, summaries, paid++ async def _announce_duel(self, result: DuelResult) -> None:+ """Publish ``VerseDuelRecorded`` once the bus has the event (WP17 adds it)."""+ if self._bus is None:+ return+ from dodaios.core import events++ event_type = getattr(events, "VerseDuelRecorded", None)+ if event_type is None:+ log.debug("progression: VerseDuelRecorded not defined yet; %s not announced",+ result.match_id)+ return+ try:+ await self._bus.publish(+ event_type(+ source_layer="progression",+ match_id=result.match_id,+ outcome=result.outcome,+ kills=result.stats["kills"],+ deaths=result.stats["deaths"],+ )+ )+ except Exception: # noqa: BLE001 - the row is stored; the read path still has it+ log.debug("progression: duel %s not announced", result.match_id, exc_info=True)++ def _ledger_first(self) -> None:+ """Open the XP ledger before the duel tables, so one connection creates the file."""+ if not self._ledger_open:+ self.store.latest_seq()+ self._ledger_open = True++ def duel_stats(self) -> dict[str, Any]:+ """Duel totals for ``GET /api/progression`` and the bridge snapshot."""+ self._ledger_first()+ return self.duels.totals()++ def bridge_duel_stats(self) -> dict[str, Any]:+ """Duel totals in the strict ``duel_stats`` shape of ``progression.snapshot``."""+ self._ledger_first()+ return self.duels.bridge_totals()++ def recent_duels(self, limit: int = 20) -> list[dict[str, Any]]:+ self._ledger_first()+ return self.duels.recent(limit=limit)+# ------------------------------------------------------------ bus handlersasync def _on_chat_turn(self, event: Any) -> None:diff --git a/dodaios/ui/web/frontend/src/components/society/progression/levelCatalog.ts b/dodaios/ui/web/frontend/src/components/society/progression/levelCatalog.tsindex 5d34e5afeb..f595f44a78 100644--- a/dodaios/ui/web/frontend/src/components/society/progression/levelCatalog.ts+++ b/dodaios/ui/web/frontend/src/components/society/progression/levelCatalog.ts@@ -44,6 +44,7 @@ export const REWARD_LEVELS: Readonly<Record<RewardId, RewardLevels>> = {export const XP_SOURCES = ["chat_turn", "voice_turn", "quest_posted", "quest_completed", "agent_hired", "mission_completed","daily_visit", "deck_discovered", "simulator_round", "simulator_record", "team_briefing", "inspection",+ "duel_won", "duel_lost", "duel_finisher","task_done", "task_blocked", "quest_done", "answered_teammate","jarvis_answered", "delegated", "walk_together",] as const;diff --git a/dodaios/ui/web/frontend/src/components/society/verse/ranks/ServiceRecord.tsx b/dodaios/ui/web/frontend/src/components/society/verse/ranks/ServiceRecord.tsxindex 4625d839d9..cb15088c31 100644--- a/dodaios/ui/web/frontend/src/components/society/verse/ranks/ServiceRecord.tsx+++ b/dodaios/ui/web/frontend/src/components/society/verse/ranks/ServiceRecord.tsx@@ -2,7 +2,9 @@* The service record: an accessible dialog with five pages.** - Record: the commander's plate, rank, level, XP, the next rank and what is- * still missing, the ribbons held, the log of recent awards, the bell.+ * still missing, the duel record (sets, won / lost, K/D, headshots,+ * finishers, best streak, the latest sets), the ribbons held, the log of+ * recent awards, the bell.* - Ladder: every rank by tier; held ranks plain, the current one marked in* red, the ones ahead dimmed with the XP still missing.* - Quartermaster: the uniforms issued by tier (the commander picks one, or@@ -15,7 +17,7 @@*/import * as Dialog from "@radix-ui/react-dialog";import * as Tabs from "@radix-ui/react-tabs";-import { useMemo } from "react";+import { useEffect, useMemo, useState } from "react";import { useLocaleChunk, useT, useUiLanguage } from "@/i18n";import { issuedUniforms, unlockedFor, xpUntilLevel, type UniformChoice } from "../../progression/cosmetics";import { rewardKey, type RibbonId, type SubjectKind } from "../../progression/levelCatalog";@@ -112,6 +114,7 @@ function RecordPage() {</div></div><div className="vr-bar" aria-hidden><span style={{ width: `${(view.fraction * 100).toFixed(1)}%` }} /></div>+ <DuelSection /><section className="vr-section"><h3 className="vr-caps">{t("verse.ranks.record.ribbons")}</h3>{ribbons.length > 0@@ -140,6 +143,151 @@ function RecordPage() {);}+// ------------------------------------------------------------------ duels++/** Duel totals as `GET /api/progression/duels` sends them (`duel_stats`). */+export interface DuelTotals {+ matches: number;+ wins: number;+ losses: number;+ unfinished: number;+ kills: number;+ deaths: number;+ kd: number;+ headshots: number;+ finishers: number;+ bestStreak: number;+}++/** One set of the duels read, newest first. */+export interface DuelSet {+ matchId: string;+ outcome: "won" | "lost" | "unfinished";+ tierKey: string;+ player: number;+ opponent: number;+ xp: number;+ recordedMs: number;+}++export interface DuelRecord {+ totals: DuelTotals;+ sets: DuelSet[];+}++const DUEL_OUTCOMES = ["won", "lost", "unfinished"] as const;+const DUEL_TIERS = ["normal", "hard", "elite", "adaptive", "player"] as const;+/** How many of the latest sets the record lists. */+export const DUEL_SETS_SHOWN = 5;++type RawObject = Record<string, unknown>;+const asObject = (v: unknown): RawObject => (v && typeof v === "object" ? (v as RawObject) : {});+const count = (v: unknown): number => (typeof v === "number" && Number.isFinite(v) ? v : 0);++/** Forgiving parse of the duels read: missing fields read as zero, unknown outcomes are left out. */+export function parseDuelRecord(raw: unknown): DuelRecord {+ const body = asObject(raw);+ const s = asObject(body.duel_stats);+ const totals: DuelTotals = {+ matches: count(s.matches), wins: count(s.wins), losses: count(s.losses), unfinished: count(s.unfinished),+ kills: count(s.kills), deaths: count(s.deaths), kd: count(s.kd), headshots: count(s.headshots),+ finishers: count(s.finishers), bestStreak: count(s.best_streak),+ };+ const sets = (Array.isArray(body.duels) ? body.duels : []).flatMap((row): DuelSet[] => {+ const r = asObject(row);+ const outcome = r.outcome;+ if (!(DUEL_OUTCOMES as readonly unknown[]).includes(outcome)) return [];+ const score = asObject(r.score);+ return [{+ matchId: typeof r.match_id === "string" ? r.match_id : "",+ outcome: outcome as DuelSet["outcome"],+ tierKey: typeof r.tier_key === "string" ? r.tier_key : "unknown",+ player: count(score.player), opponent: count(score.opponent), xp: count(r.xp), recordedMs: count(r.recorded_ms),+ }];+ });+ return { totals, sets };+}++/** How often an open record reads the duels again; sets that pay nothing raise no award. */+export const DUEL_REFRESH_MS = 30_000;++/**+ * The duel record, read when the record opens, after every award (a paid set is+ * an award), when the window gets focus again, and every DUEL_REFRESH_MS while+ * open, so sets that pay nothing (unfinished, under 60 s, past the daily cap)+ * still show up.+ */+function useDuelRecord(): DuelRecord | null {+ const latestSeq = useProgression((s) => s.snapshot?.latestSeq ?? 0);+ const [record, setRecord] = useState<DuelRecord | null>(null);+ useEffect(() => {+ let live = true;+ const read = async () => {+ try {+ const res = await fetch(`/api/progression/duels?limit=${DUEL_SETS_SHOWN}`);+ if (!res.ok) return;+ const parsed = parseDuelRecord(await res.json());+ if (live) setRecord(parsed);+ } catch (error) {+ // An older backend without duels, or none at all: the section says "no sets yet".+ console.debug("Duel record not read", error);+ }+ };+ void read();+ const onFocus = () => { void read(); };+ window.addEventListener("focus", onFocus);+ const timer = window.setInterval(() => { void read(); }, DUEL_REFRESH_MS);+ return () => {+ live = false;+ window.removeEventListener("focus", onFocus);+ window.clearInterval(timer);+ };+ }, [latestSeq]);+ return record;+}++function DuelSection() {+ const t = useT();+ const record = useDuelRecord();+ const totals = record?.totals;+ const tierWord = (key: string) => t(`verse.ranks.record.duel.tier.${(DUEL_TIERS as readonly string[]).includes(key) ? key : "unknown"}`);+ return (+ <section className="vr-section" data-section="duels">+ <h3 className="vr-caps">{t("verse.ranks.record.duel.title")}</h3>+ {!record || !totals || totals.matches === 0 ? <p className="vr-hint">{t("verse.ranks.record.duel.empty")}</p> : (+ <>+ <div className="vr-facts">+ <div className="vr-fact" data-stat="sets"><span className="vr-caps">{t("verse.ranks.record.duel.sets")}</span><span className="vr-num">{figure(totals.matches)}</span></div>+ <div className="vr-fact" data-stat="record">+ <span className="vr-caps">{t("verse.ranks.record.duel.record")}</span>+ <span className="vr-num">{fill(t("verse.ranks.record.duel.won_lost"), { won: figure(totals.wins), lost: figure(totals.losses) })}</span>+ {totals.unfinished > 0 && <small className="vr-caps">{t("verse.ranks.record.duel.unfinished")} {figure(totals.unfinished)}</small>}+ </div>+ <div className="vr-fact" data-stat="kd"><span className="vr-caps">{t("verse.ranks.record.duel.kd")}</span><span className="vr-num">{totals.kd.toFixed(2)}</span></div>+ <div className="vr-fact" data-stat="headshots"><span className="vr-caps">{t("verse.ranks.record.duel.headshots")}</span><span className="vr-num">{figure(totals.headshots)}</span></div>+ <div className="vr-fact" data-stat="finishers"><span className="vr-caps">{t("verse.ranks.record.duel.finishers")}</span><span className="vr-num">{figure(totals.finishers)}</span></div>+ <div className="vr-fact" data-stat="best_streak"><span className="vr-caps">{t("verse.ranks.record.duel.best_streak")}</span><span className="vr-num">{figure(totals.bestStreak)}</span></div>+ </div>+ {record.sets.length > 0 && (+ <>+ <h4 className="vr-caps">{t("verse.ranks.record.duel.recent")}</h4>+ <ul className="vr-log" aria-label={t("verse.ranks.record.duel.recent")}>+ {record.sets.map((set) => (+ <li key={set.matchId} data-outcome={set.outcome}>+ <span>{t(`verse.ranks.record.duel.outcome.${set.outcome}`)} · {tierWord(set.tierKey)}</span>+ <span className="vr-num">{fill(t("verse.ranks.record.duel.score"), { player: set.player, opponent: set.opponent })}</span>+ <span className="vr-num vr-xp">{set.xp > 0 ? `+${set.xp}` : "—"}</span>+ </li>+ ))}+ </ul>+ </>+ )}+ </>+ )}+ </section>+ );+}+function LadderPage() {const t = useT();const { view } = useCommander();diff --git a/dodaios/ui/web/frontend/src/components/society/verse/ranks/serviceRecordDuels.test.tsx b/dodaios/ui/web/frontend/src/components/society/verse/ranks/serviceRecordDuels.test.tsxnew file mode 100644index 0000000000..affa93d7fe--- /dev/null+++ b/dodaios/ui/web/frontend/src/components/society/verse/ranks/serviceRecordDuels.test.tsx@@ -0,0 +1,101 @@+/**+ * The service record's duel section (WP21.5): it reads `/api/progression/duels`,+ * shows sets, won / lost, K/D, headshots, finishers and the best streak, lists+ * the latest sets, and says "no sets yet" when the backend has none or is gone.+ */+import { cleanup, render, screen, waitFor, within } from "@testing-library/react";+import { afterEach, beforeAll, describe, expect, it, vi } from "vitest";+import { loadLocaleChunk } from "@/i18n";+import { LEVEL_XP } from "../../progression/levelCatalog";+import { LOCAL_REWARDS } from "../../progression/progressionApi";+import { useProgression } from "../../progression/progressionStore";+import { ServiceRecord, parseDuelRecord } from "./ServiceRecord";++const DUELS = {+ duel_stats: {+ matches: 13, wins: 8, losses: 4, unfinished: 1, kills: 96, deaths: 81, kd: 1.19,+ headshots: 31, finishers: 4, melee_kills: 2, best_streak: 6, by_tier: {}, by_weapon: {},+ },+ duels: [+ { match_id: "m3", outcome: "won", tier_key: "hard", score: { player: 10, opponent: 7 }, xp: 60, recorded_ms: 3 },+ { match_id: "m2", outcome: "unfinished", tier_key: "adaptive", score: { player: 2, opponent: 3 }, xp: 0, recorded_ms: 2 },+ { match_id: "m1", outcome: "draw", tier_key: "hard", score: {}, xp: 0, recorded_ms: 1 },+ ],+};++function openRecord() {+ useProgression.setState({+ snapshot: {+ subjects: [], petId: "gigi", recent: [], latestSeq: 0, maxLevel: 50, levelXp: [...LEVEL_XP], rules: [],+ rewards: [...LOCAL_REWARDS], ranks: [], titles: { person: [], agent: [], pet: [] }, looks: {},+ },+ subjects: {}, banners: [], toasts: [], popups: [], record: "record", uniform: "auto",+ });+}++beforeAll(async () => {+ await loadLocaleChunk("ship");+});++afterEach(() => {+ cleanup();+ vi.unstubAllGlobals();+});++describe("parseDuelRecord", () => {+ it("reads totals and sets, leaves unknown outcomes out and zeroes what is missing", () => {+ const record = parseDuelRecord(DUELS);+ expect(record.totals).toMatchObject({ matches: 13, wins: 8, losses: 4, kd: 1.19, headshots: 31, finishers: 4, bestStreak: 6 });+ expect(record.sets.map((s) => s.matchId)).toEqual(["m3", "m2"]);+ expect(parseDuelRecord(null).totals.matches).toBe(0);+ expect(parseDuelRecord({ duels: "x" }).sets).toEqual([]);+ });+});++describe("ServiceRecord duel section", () => {+ it("shows the duel numbers the backend sends", async () => {+ const fetchMock = vi.fn(async () => new Response(JSON.stringify(DUELS), { status: 200 }));+ vi.stubGlobal("fetch", fetchMock);+ openRecord();+ render(<ServiceRecord />);+ const dialog = screen.getByRole("dialog");+ await waitFor(() => expect(dialog.querySelector('[data-stat="sets"]')).toBeTruthy());+ expect(fetchMock).toHaveBeenCalledWith("/api/progression/duels?limit=5");+ const stat = (id: string) => dialog.querySelector(`[data-stat="${id}"] .vr-num`)?.textContent;+ expect(stat("sets")).toBe("13");+ expect(stat("record")).toBe("8 / 4");+ expect(stat("kd")).toBe("1.19");+ expect(stat("headshots")).toBe("31");+ expect(stat("finishers")).toBe("4");+ expect(stat("best_streak")).toBe("6");+ const list = within(screen.getByRole("list", { name: "Recent sets" }));+ const rows = list.getAllByRole("listitem");+ expect(rows.map((r) => r.getAttribute("data-outcome"))).toEqual(["won", "unfinished"]);+ expect(rows[0].textContent).toContain("Won · Hard");+ expect(rows[0].textContent).toContain("10 : 7");+ expect(rows[0].textContent).toContain("+60");+ expect(rows[1].textContent).toContain("Unfinished · Adaptive");+ });++ it("reads again on focus, so a set that paid nothing still shows up", async () => {+ const fewer = { ...DUELS, duel_stats: { ...DUELS.duel_stats, matches: 12 } };+ let calls = 0;+ const fetchMock = vi.fn(async () => new Response(JSON.stringify(calls++ === 0 ? fewer : DUELS), { status: 200 }));+ vi.stubGlobal("fetch", fetchMock);+ openRecord();+ render(<ServiceRecord />);+ const dialog = screen.getByRole("dialog");+ const sets = () => dialog.querySelector('[data-stat="sets"] .vr-num')?.textContent;+ await waitFor(() => expect(sets()).toBe("12"));+ window.dispatchEvent(new Event("focus"));+ await waitFor(() => expect(sets()).toBe("13"));+ });++ it("says no sets yet without a backend", async () => {+ vi.stubGlobal("fetch", vi.fn(async () => { throw new Error("offline"); }));+ openRecord();+ render(<ServiceRecord />);+ const section = screen.getByRole("dialog").querySelector('[data-section="duels"]');+ expect(section?.textContent).toContain("No duel sets yet");+ });+});diff --git a/dodaios/ui/web/frontend/src/i18n/locales/ship/ranks.de.json b/dodaios/ui/web/frontend/src/i18n/locales/ship/ranks.de.jsonindex be443696d2..1e618de4a1 100644--- a/dodaios/ui/web/frontend/src/i18n/locales/ship/ranks.de.json+++ b/dodaios/ui/web/frontend/src/i18n/locales/ship/ranks.de.json@@ -73,6 +73,9 @@"simulator_record": "Simulatorrekord","team_briefing": "Teambesprechung","inspection": "Deckinspektion",+ "duel_won": "Duellsatz gewonnen",+ "duel_lost": "Duellsatz verloren",+ "duel_finisher": "Duell-Finisher","task_done": "Aufgabe erledigt","task_blocked": "Aufgabe als blockiert gemeldet","quest_done": "Quest abgeschlossen",@@ -95,6 +98,9 @@"simulator_record": "Einen neuen Bestwert im Simulatorraum aufstellen.","team_briefing": "Eine Teambesprechung im Besprechungsraum abhalten.","inspection": "Jeden Raum eines Decks abgehen, einmal pro Deck und Tag.",+ "duel_won": "Gewinne einen Duellsatz in der Hangar-Arena; stärkere Gegner zahlen mehr.",+ "duel_lost": "Spiele einen Duellsatz von mindestens einer Minute zu Ende, auch wenn du ihn verlierst.",+ "duel_finisher": "Setze einen Finisher in einem Duellsatz, der zählt.","task_done": "Eine Aufgabe erledigen.","task_blocked": "Eine Aufgabe mit Begründung als blockiert melden.","quest_done": "Eine Quest abschließen.",@@ -155,7 +161,34 @@"earn_hint": "Jede Vergabe wird gegen das Logbuch des Schiffs geprüft: Dasselbe zahlt nie zweimal.","crew_empty": "Noch keine Offiziere an Bord.","companion": "Begleitdrohne",- "sound": "Schiffsglocke bei Beförderungen"+ "sound": "Schiffsglocke bei Beförderungen",+ "duel": {+ "title": "Duelle",+ "empty": "Noch keine Duellsätze. Starte einen an der Waffenkammer im Hangar.",+ "sets": "Sätze",+ "record": "Gewonnen / verloren",+ "won_lost": "{won} / {lost}",+ "kd": "K/D",+ "headshots": "Kopftreffer",+ "finishers": "Finisher",+ "best_streak": "Beste Serie",+ "unfinished": "Abgebrochen",+ "recent": "Letzte Sätze",+ "score": "{player} : {opponent}",+ "outcome": {+ "won": "Gewonnen",+ "lost": "Verloren",+ "unfinished": "Abgebrochen"+ },+ "tier": {+ "normal": "Normal",+ "hard": "Schwer",+ "elite": "Elite",+ "adaptive": "Adaptiv",+ "player": "Andere Person",+ "unknown": "Gegner"+ }+ }},"promo": {"eyebrow": "Beförderung",diff --git a/dodaios/ui/web/frontend/src/i18n/locales/ship/ranks.en.json b/dodaios/ui/web/frontend/src/i18n/locales/ship/ranks.en.jsonindex c88315c36d..668014931a 100644--- a/dodaios/ui/web/frontend/src/i18n/locales/ship/ranks.en.json+++ b/dodaios/ui/web/frontend/src/i18n/locales/ship/ranks.en.json@@ -73,6 +73,9 @@"simulator_record": "Simulator record","team_briefing": "Team briefing","inspection": "Deck inspection",+ "duel_won": "Duel set won",+ "duel_lost": "Duel set lost",+ "duel_finisher": "Duel finisher","task_done": "Task done","task_blocked": "Task reported blocked","quest_done": "Quest done",@@ -95,6 +98,9 @@"simulator_record": "Set a new best in the simulator room.","team_briefing": "Hold a team briefing in the briefing room.","inspection": "Walk every room of a deck, once per deck a day.",+ "duel_won": "Win a duel set in the hangar arena; harder opponents pay more.",+ "duel_lost": "Play a duel set of at least a minute to the end, even when you lose it.",+ "duel_finisher": "Land a finisher in a duel set that pays.","task_done": "Finish a task.","task_blocked": "Report a task as blocked, with the reason.","quest_done": "Complete a quest.",@@ -155,7 +161,34 @@"earn_hint": "Every award is checked against the ship's own ledger: the same thing never pays twice.","crew_empty": "No officers aboard yet.","companion": "Companion drone",- "sound": "Ship's bell on promotions"+ "sound": "Ship's bell on promotions",+ "duel": {+ "title": "Duels",+ "empty": "No duel sets yet. Start one at the armoury in the hangar.",+ "sets": "Sets",+ "record": "Won / lost",+ "won_lost": "{won} / {lost}",+ "kd": "K/D",+ "headshots": "Headshots",+ "finishers": "Finishers",+ "best_streak": "Best streak",+ "unfinished": "Left unfinished",+ "recent": "Recent sets",+ "score": "{player} : {opponent}",+ "outcome": {+ "won": "Won",+ "lost": "Lost",+ "unfinished": "Unfinished"+ },+ "tier": {+ "normal": "Normal",+ "hard": "Hard",+ "elite": "Elite",+ "adaptive": "Adaptive",+ "player": "Another player",+ "unknown": "Opponent"+ }+ }},"promo": {"eyebrow": "Promotion",diff --git a/dodaios/ui/web/frontend/src/i18n/locales/ship/ranks.es.json b/dodaios/ui/web/frontend/src/i18n/locales/ship/ranks.es.jsonindex 1dd9cf47b7..7fcf6e0510 100644--- a/dodaios/ui/web/frontend/src/i18n/locales/ship/ranks.es.json+++ b/dodaios/ui/web/frontend/src/i18n/locales/ship/ranks.es.json@@ -73,6 +73,9 @@"simulator_record": "Récord en el simulador","team_briefing": "Reunión de equipo","inspection": "Inspección de cubierta",+ "duel_won": "Set de duelo ganado",+ "duel_lost": "Set de duelo perdido",+ "duel_finisher": "Remate en duelo","task_done": "Tarea hecha","task_blocked": "Tarea notificada como bloqueada","quest_done": "Misión completada",@@ -95,6 +98,9 @@"simulator_record": "Marca un nuevo récord en la sala del simulador.","team_briefing": "Celebra una reunión de equipo en la sala de reuniones.","inspection": "Recorre todas las salas de una cubierta, una vez por cubierta al día.",+ "duel_won": "Gana un set de duelo en la arena del hangar; los rivales más duros pagan más.",+ "duel_lost": "Juega hasta el final un set de duelo de al menos un minuto, aunque lo pierdas.",+ "duel_finisher": "Logra un remate en un set de duelo que puntúe.","task_done": "Termina una tarea.","task_blocked": "Notifica una tarea como bloqueada, con el motivo.","quest_done": "Completa una misión.",@@ -155,7 +161,34 @@"earn_hint": "Cada recompensa se comprueba con la bitácora de la nave: lo mismo nunca paga dos veces.","crew_empty": "Aún no hay oficiales a bordo.","companion": "Dron de compañía",- "sound": "Campana de a bordo en los ascensos"+ "sound": "Campana de a bordo en los ascensos",+ "duel": {+ "title": "Duelos",+ "empty": "Aún no hay sets de duelo. Empieza uno en la armería del hangar.",+ "sets": "Sets",+ "record": "Ganados / perdidos",+ "won_lost": "{won} / {lost}",+ "kd": "K/D",+ "headshots": "Disparos a la cabeza",+ "finishers": "Remates",+ "best_streak": "Mejor racha",+ "unfinished": "Sin terminar",+ "recent": "Sets recientes",+ "score": "{player} : {opponent}",+ "outcome": {+ "won": "Ganado",+ "lost": "Perdido",+ "unfinished": "Sin terminar"+ },+ "tier": {+ "normal": "Normal",+ "hard": "Difícil",+ "elite": "Élite",+ "adaptive": "Adaptativo",+ "player": "Otro jugador",+ "unknown": "Rival"+ }+ }},"promo": {"eyebrow": "Ascenso",diff --git a/dodaios/ui/web/frontend/src/i18n/locales/ship/ranks.pt.json b/dodaios/ui/web/frontend/src/i18n/locales/ship/ranks.pt.jsonindex b55ce7382a..f49fa34138 100644--- a/dodaios/ui/web/frontend/src/i18n/locales/ship/ranks.pt.json+++ b/dodaios/ui/web/frontend/src/i18n/locales/ship/ranks.pt.json@@ -73,6 +73,9 @@"simulator_record": "Recorde no simulador","team_briefing": "Reunião de equipa","inspection": "Inspeção de convés",+ "duel_won": "Set de duelo vencido",+ "duel_lost": "Set de duelo perdido",+ "duel_finisher": "Finalização em duelo","task_done": "Tarefa feita","task_blocked": "Tarefa comunicada como bloqueada","quest_done": "Missão concluída",@@ -95,6 +98,9 @@"simulator_record": "Bate um novo recorde na sala do simulador.","team_briefing": "Faz uma reunião de equipa na sala de reuniões.","inspection": "Percorre todas as salas de um convés, uma vez por convés e por dia.",+ "duel_won": "Vença um set de duelo na arena do hangar; adversários mais duros pagam mais.",+ "duel_lost": "Jogue até o fim um set de duelo de pelo menos um minuto, mesmo que perca.",+ "duel_finisher": "Faça uma finalização num set de duelo que conte.","task_done": "Termina uma tarefa.","task_blocked": "Comunica uma tarefa como bloqueada, com o motivo.","quest_done": "Conclui uma missão.",@@ -155,7 +161,34 @@"earn_hint": "Cada atribuição é verificada no diário de bordo da nave: a mesma coisa nunca paga duas vezes.","crew_empty": "Ainda não há oficiais a bordo.","companion": "Drone de companhia",- "sound": "Sino de bordo nas promoções"+ "sound": "Sino de bordo nas promoções",+ "duel": {+ "title": "Duelos",+ "empty": "Ainda não há sets de duelo. Comece um no arsenal do hangar.",+ "sets": "Sets",+ "record": "Vencidos / perdidos",+ "won_lost": "{won} / {lost}",+ "kd": "K/D",+ "headshots": "Tiros na cabeça",+ "finishers": "Finalizações",+ "best_streak": "Melhor sequência",+ "unfinished": "Não terminados",+ "recent": "Sets recentes",+ "score": "{player} : {opponent}",+ "outcome": {+ "won": "Vencido",+ "lost": "Perdido",+ "unfinished": "Não terminado"+ },+ "tier": {+ "normal": "Normal",+ "hard": "Difícil",+ "elite": "Elite",+ "adaptive": "Adaptativo",+ "player": "Outro jogador",+ "unknown": "Adversário"+ }+ }},"promo": {"eyebrow": "Promoção",diff --git a/dodaios/ui/web/frontend/src/i18n/locales/ship/ranks.zh.json b/dodaios/ui/web/frontend/src/i18n/locales/ship/ranks.zh.jsonindex 242dfa2081..36e202dbe1 100644--- a/dodaios/ui/web/frontend/src/i18n/locales/ship/ranks.zh.json+++ b/dodaios/ui/web/frontend/src/i18n/locales/ship/ranks.zh.json@@ -73,6 +73,9 @@"simulator_record": "模拟器纪录","team_briefing": "团队简报","inspection": "甲板巡视",+ "duel_won": "决斗局获胜",+ "duel_lost": "决斗局落败",+ "duel_finisher": "决斗终结技","task_done": "完成工作","task_blocked": "报告工作受阻","quest_done": "完成任务",@@ -95,6 +98,9 @@"simulator_record": "在模拟室创下新纪录。","team_briefing": "在简报室召开团队简报。","inspection": "走遍一层甲板的所有房间,每层甲板每天一次。",+ "duel_won": "在机库竞技场赢下一局决斗;对手越强,奖励越多。",+ "duel_lost": "打完一局至少一分钟的决斗,即使输了也算。",+ "duel_finisher": "在计分的决斗局中完成一次终结技。","task_done": "完成一项工作。","task_blocked": "说明原因并报告工作受阻。","quest_done": "完成一项任务。",@@ -155,7 +161,34 @@"earn_hint": "每次奖励都会对照舰上的日志核验:同一件事绝不会奖励两次。","crew_empty": "舰上还没有军官。","companion": "随行机器人",- "sound": "晋升时鸣响船钟"+ "sound": "晋升时鸣响船钟",+ "duel": {+ "title": "决斗",+ "empty": "还没有决斗记录。到机库的军械库开始一局。",+ "sets": "局数",+ "record": "胜 / 负",+ "won_lost": "{won} / {lost}",+ "kd": "击杀/死亡",+ "headshots": "爆头",+ "finishers": "终结技",+ "best_streak": "最佳连杀",+ "unfinished": "未完成",+ "recent": "最近的对局",+ "score": "{player} : {opponent}",+ "outcome": {+ "won": "胜",+ "lost": "负",+ "unfinished": "未完成"+ },+ "tier": {+ "normal": "普通",+ "hard": "困难",+ "elite": "精英",+ "adaptive": "自适应",+ "player": "其他玩家",+ "unknown": "对手"+ }+ }},"promo": {"eyebrow": "晋升",diff --git a/dodaios/ui/web/progression_routes.py b/dodaios/ui/web/progression_routes.pyindex 0cfabae52d..72f6327823 100644--- a/dodaios/ui/web/progression_routes.py+++ b/dodaios/ui/web/progression_routes.py@@ -1,8 +1,13 @@"""REST API of the Dodaios Verse level system (``dodaios/progression``).- ``GET /api/progression`` → every subject's level, the rulebook and recent awards+- ``GET /api/progression/duels`` → duel totals and the most recent duel sets- ``POST /api/progression/actions`` → report a world action from the Verse (metered server-side)+Duel XP is never a world action: ``duel_won``, ``duel_lost`` and+``duel_finisher`` are server rules that only a ``duel.result`` from the Unreal+Verse pays (``ProgressionService.record_duel``), so ``/actions`` refuses them.+Live awards travel as ``ProgressionAwarded`` over the WebSocket; this API isthe first read and the catch-up after a reconnect."""@@ -76,20 +81,35 @@ async def get_progression(after_seq: int = Query(0, ge=0, description="Only awards newer than this sequence number"),) -> dict[str, Any]:service = _service(request)- subjects, recent, latest = await asyncio.gather(+ subjects, recent, latest, duel_stats = await asyncio.gather(asyncio.to_thread(service.snapshot),asyncio.to_thread(service.store.recent, after_seq=after_seq, limit=50),asyncio.to_thread(service.store.latest_seq),+ asyncio.to_thread(service.duel_stats),)return {"subjects": subjects,"pet_id": service.current_pet(),"recent": recent,"latest_seq": latest,+ "duel_stats": duel_stats,**_rulebook(),}[email protected]("/duels", summary="Duel totals and the most recent duel sets, newest first")+async def get_duels(+ request: Request,+ limit: int = Query(20, ge=1, le=100, description="How many recent sets to list"),+) -> dict[str, Any]:+ service = _service(request)+ duels, duel_stats = await asyncio.gather(+ asyncio.to_thread(service.recent_duels, limit),+ asyncio.to_thread(service.duel_stats),+ )+ return {"duels": duels, "duel_stats": duel_stats}++class WorldAction(BaseModel):action: str = Field(..., max_length=40, description="A world-action source from the rulebook")ref: str = Field(diff --git a/tests/unit/progression/test_duel_parity.py b/tests/unit/progression/test_duel_parity.pynew file mode 100644index 0000000000..8d37902a9b--- /dev/null+++ b/tests/unit/progression/test_duel_parity.py@@ -0,0 +1,58 @@+"""The Unreal copies of the progression rulebook match the server (WP21.6, WP21.7).++The Unreal service record draws the rank ladder from its own table and the+duel reporter spells the ``end_reason`` values itself; both must equal+``dodaios/progression/rules.py`` or a rank would read wrong and a result+would be refused.+"""++from __future__ import annotations++import re+from pathlib import Path++import pytest++from dodaios.progression.rules import DUEL_END_REASONS, DUEL_OUTCOMES, RANKS++_SOURCE = Path(__file__).resolve().parents[3] / "unreal/Verse/Source"+_MODEL = _SOURCE / "VerseUI/Private/ServiceRecord/VerseServiceRecordModel.cpp"+_CODEC = _SOURCE / "VerseBridge/Private/Duel/VerseDuelResultCodec.cpp"+++def test_the_unreal_service_record_draws_the_servers_ladder():+ text = _MODEL.read_text(encoding="utf-8")+ block = re.search(r"VERSE_RANK_LADDER_BEGIN(.*?)VERSE_RANK_LADDER_END", text, re.S)+ assert block, "ladder markers missing"+ rows = re.findall(r'\{TEXT\("([a-z_]+)"\), (\d+), TEXT\("([a-z]+)"\)\}', block.group(1))+ assert [(int(level), rank, tier) for rank, level, tier in rows] == list(RANKS)+++def test_the_unreal_reporter_spells_every_end_reason_and_outcome():+ text = _CODEC.read_text(encoding="utf-8")+ block = re.search(r"EndReasonNames\[\] = \{(.*?)\};", text, re.S)+ assert block, "EndReasonNames not found"+ assert re.findall(r'TEXT\("([a-z_]+)"\)', block.group(1)) == list(DUEL_END_REASONS)+ for outcome in DUEL_OUTCOMES:+ assert f'TEXT("{outcome}")' in text+++ "path",+ sorted((_SOURCE / "VerseBridge/Private/Duel").rglob("*.*")),+ ids=lambda p: p.name,+)+def test_the_reporter_never_includes_combat(path: Path):+ """combat-state.md 11.2: VerseBridge reads FVerseSetSummary from Core, never VerseCombat."""+ text = path.read_text(encoding="utf-8")+ includes = re.findall(r'#include\s+"([^"]+)"', text)+ combat = [+ i+ for i in includes+ if i.startswith("VerseCombat")+ or (+ (_SOURCE / "VerseCombat/Public" / i).exists()+ and not (_SOURCE / "VerseCore/Public" / i).exists()+ )+ ]+ assert combat == []diff --git a/tests/unit/progression/test_duel_routes.py b/tests/unit/progression/test_duel_routes.pynew file mode 100644index 0000000000..2043bc8717--- /dev/null+++ b/tests/unit/progression/test_duel_routes.py@@ -0,0 +1,62 @@+"""Duel reads over REST, and the refusal of duel XP as a world action (WP21.4, A21.5)."""++from __future__ import annotations++from pathlib import Path++import pytest+from fastapi import FastAPI+from fastapi.testclient import TestClient++from dodaios.progression.rules import DUEL_SOURCES, RULES_BY_SOURCE, WORLD_ACTIONS+from dodaios.progression.service import ProgressionService+from dodaios.ui.web.progression_routes import router++from .test_duel_service import duel+++def setup(tmp_path: Path):+ app = FastAPI()+ app.include_router(router)+ service = ProgressionService(tmp_path / "progression.db", pet_id=lambda: "miso")+ app.state.progression = service+ with TestClient(app) as client:+ yield client, service+ service.close()+++def test_the_first_read_carries_duel_totals(setup):+ client, service = setup+ body = client.get("/api/progression").json()+ assert body["duel_stats"]["matches"] == 0+ client.portal.call(service.record_duel, duel("m1"))+ body = client.get("/api/progression").json()+ stats = body["duel_stats"]+ assert (stats["matches"], stats["wins"], stats["kills"], stats["deaths"]) == (1, 1, 10, 7)+ assert stats["by_tier"]["hard"]["wins"] == 1+ assert {r["source"] for r in body["rules"]} >= set(DUEL_SOURCES)+ assert next(r for r in body["rules"] if r["source"] == "duel_won")["trigger"] == "server"+++def test_the_duels_read_lists_recent_sets_newest_first(setup):+ client, service = setup+ for i in range(25):+ client.portal.call(service.record_duel, duel(f"m{i:02d}", set_index=i + 1))+ body = client.get("/api/progression/duels").json()+ assert len(body["duels"]) == 20+ assert body["duel_stats"]["matches"] == 25+ assert body["duels"][0]["set_index"] == 25+ assert len(client.get("/api/progression/duels?limit=3").json()["duels"]) == 3+ assert client.get("/api/progression/duels?limit=0").status_code == 422+ assert client.get("/api/progression/duels?limit=101").status_code == 422++[email protected]("source", DUEL_SOURCES)+def test_duel_xp_is_never_a_world_action(setup, source):+ client, service = setup+ assert RULES_BY_SOURCE[source].trigger == "server"+ assert source not in WORLD_ACTIONS+ res = client.post("/api/progression/actions", json={"action": source, "ref": "m1"})+ assert res.status_code == 422+ assert service.store.latest_seq() == 0diff --git a/tests/unit/progression/test_duel_service.py b/tests/unit/progression/test_duel_service.pynew file mode 100644index 0000000000..657b226dcb--- /dev/null+++ b/tests/unit/progression/test_duel_service.py@@ -0,0 +1,371 @@+"""``record_duel``: one row and one payment per set, within every cap (WP21 A21.1-A21.3)."""++from __future__ import annotations++import asyncio+import copy+import json+import logging+from dataclasses import dataclass+from pathlib import Path+from typing import Any++import pytest++from dodaios.core import events+from dodaios.core.bus import EventBus+from dodaios.core.events import Event, ProgressionAwarded+from dodaios.progression.duel_stats import DuelResultError+from dodaios.progression.service import ProgressionService++_GOLDEN = (+ Path(__file__).resolve().parents[1] / "verse_host/fixtures/bridge/replies/duel.result.json"+)+++def duel(match_id: str = "m_1", **over: Any) -> dict[str, Any]:+ """A ``duel.result`` payload as bridge-protocol 10 shows it: a won set against hard."""+ data: dict[str, Any] = {+ "match_id": match_id,+ "session_id": "s_1",+ "set_index": 1,+ "mode": "deathmatch_1v1",+ "ruleset": "endless/1",+ "opponent": {"kind": "bot", "tier": "hard", "adaptive": False},+ "started_at": 1793612200.0,+ "ended_at": 1793612500.0,+ "match_time_s": 296.4,+ "end_reason": "set_complete",+ "outcome": "won",+ "score": {"player": 10, "opponent": 7},+ "stats": {+ "kills": 10,+ "deaths": 7,+ "headshots": 4,+ "finishers": 0,+ "melee_kills": 1,+ "shots_fired": 540,+ "shots_hit": 201,+ "damage_dealt": 2760,+ "damage_taken": 2210,+ "walls_breached": 2,+ "bulwarks_placed": 3,+ "best_streak": 4,+ },+ "weapons": [+ {+ "weapon_id": "graveline",+ "kills": 8,+ "headshots": 4,+ "shots_fired": 410,+ "shots_hit": 152,+ }+ ],+ "build": {"version": "0.1.0", "changelist": "a1b2c3d"},+ }+ for key, value in over.items():+ if key in ("stats", "opponent", "score") and isinstance(value, dict):+ data[key] = {**data[key], **value}+ else:+ data[key] = value+ return data+++class Clock:+ def __init__(self, start_ms: int = 1_790_000_000_000) -> None:+ self.now = start_ms++ def __call__(self) -> int:+ return self.now+++async def setup(tmp_path: Path):+ bus = EventBus()+ seen: list[ProgressionAwarded] = []++ async def on_award(event: ProgressionAwarded) -> None:+ seen.append(event)++ bus.subscribe(ProgressionAwarded, on_award)+ clock = Clock()+ service = ProgressionService(tmp_path / "progression.db", bus=bus, clock=clock)+ try:+ yield service, bus, seen, clock+ finally:+ service.close()+++def _person_xp(service: ProgressionService) -> int:+ return next((r["xp"] for r in service.snapshot() if r["subject_id"] == "person"), 0)+++def _ledger(service: ProgressionService) -> list[tuple[str, int]]:+ return [(r["source"], r["xp"]) for r in service.store.recent(limit=200)]+++# ------------------------------------------------------------------ A21.1 idempotency+++async def test_a_hundred_sends_of_one_match_store_one_row_and_pay_once(setup):+ service, _, seen, _ = setup+ first = await service.record_duel(duel("m_same"))+ replies = [await service.record_duel(duel("m_same")) for _ in range(99)]+ assert service.duels.count() == 1+ assert _ledger(service) == [("duel_won", 60)]+ assert len(seen) == 1+ assert first["awards"] == [{"xp_source": "duel_won", "xp": 60}]+ for reply in replies:+ assert reply["recorded"] is True+ assert reply["awards"] == first["awards"]+ assert reply["duel_stats"]["matches"] == 1+++async def test_concurrent_sends_of_one_match_still_pay_once(setup):+ service, _, _, _ = setup+ await asyncio.gather(*(service.record_duel(duel("m_race")) for _ in range(100)))+ assert service.duels.count() == 1+ assert _ledger(service) == [("duel_won", 60)]+ assert _person_xp(service) == 60+++async def test_a_row_whose_awards_a_crash_cut_off_is_paid_on_the_next_send(setup):+ service, _, _, _ = setup+ from dodaios.progression.duel_stats import parse_duel_result++ service.duels.insert(parse_duel_result(duel("m_cut"))) # stored, never paid+ reply = await service.record_duel(duel("m_cut"))+ assert reply["awards"][0]["xp_source"] == "duel_won"+ again = await service.record_duel(duel("m_cut"))+ assert again["awards"] == reply["awards"]+ assert _ledger(service) == [("duel_won", 60)]+++async def test_a_crash_after_paying_before_finish_keeps_the_paid_awards(setup, monkeypatch):+ service, _, _, _ = setup+ real_finish = service.duels.finish+ monkeypatch.setattr(service.duels, "finish", lambda *a, **k: None) # the crash+ first = await service.record_duel(duel("m_paid"))+ assert _ledger(service) == [("duel_won", 60)]+ assert service.duels.get("m_paid")["awards_done"] is False+ monkeypatch.setattr(service.duels, "finish", real_finish)+ again = await service.record_duel(duel("m_paid"))+ assert [(a["xp_source"], a["xp"]) for a in again["awards"]] == [("duel_won", 60)]+ assert again["awards"] == first["awards"]+ stored = service.duels.get("m_paid")+ assert stored["awards_done"] is True+ assert [(a["xp_source"], a["xp"]) for a in stored["awards"]] == [("duel_won", 60)]+ assert _ledger(service) == [("duel_won", 60)]+++# ------------------------------------------------------------------ A21.2 XP+++ ("tier", "adaptive", "xp"),+ [+ ("normal", False, 40),+ ("hard", False, 60),+ ("elite", False, 80),+ ("elite", True, 60),+ ("mystery", False, 40),+ ],+)+async def test_a_won_set_pays_the_tier_multiplier(setup, tier, adaptive, xp):+ service, _, _, _ = setup+ reply = await service.record_duel(duel(opponent={"tier": tier, "adaptive": adaptive}))+ assert reply["awards"] == [{"xp_source": "duel_won", "xp": xp}]+++async def test_a_lost_set_pays_duel_lost_and_finishers_pay_in_a_paying_set(setup):+ service, _, _, _ = setup+ await service.record_duel(duel("m_l", outcome="lost", stats={"finishers": 2}))+ assert _ledger(service) == [("duel_lost", 10), ("duel_finisher", 10)]+++async def test_the_daily_caps_hold(setup):+ service, _, _, clock = setup+ for i in range(10): # 10 x 80 (elite) asks for 800; the cap is 200+ await service.record_duel(duel(f"w{i}", opponent={"tier": "elite"}, stats={"finishers": 3}))+ clock.now += 1000+ for i in range(10): # 10 x 10 asks for 100; the cap is 50+ await service.record_duel(duel(f"l{i}", outcome="lost"))+ clock.now += 1000+ paid: dict[str, int] = {}+ for source, xp in _ledger(service):+ paid[source] = paid.get(source, 0) + xp+ assert paid == {"duel_won": 200, "duel_lost": 50, "duel_finisher": 25}+ # The next local day the caps open again.+ clock.now += 86_400_000+ reply = await service.record_duel(duel("next_day"))+ assert [a["xp"] for a in reply["awards"]] == [60]+++async def test_a_set_under_sixty_seconds_pays_nothing_but_counts(setup):+ service, _, _, _ = setup+ reply = await service.record_duel(+ duel("short", match_time_s=59.0, stats={"kills": 10, "finishers": 1})+ )+ assert reply["awards"] == []+ assert _person_xp(service) == 0+ assert reply["duel_stats"]["matches"] == 1 and reply["duel_stats"]["wins"] == 1+++async def test_an_unfinished_set_pays_nothing_and_still_updates_the_stats(setup):+ service, _, _, _ = setup+ reply = await service.record_duel(+ duel(+ "left", outcome="unfinished", end_reason="player_left", stats={"kills": 3, "deaths": 2}+ )+ )+ assert reply["awards"] == []+ assert _person_xp(service) == 0+ stats = reply["duel_stats"]+ assert (stats["matches"], stats["unfinished"], stats["kills"], stats["deaths"]) == (1, 1, 3, 2)+++async def test_a_mode_that_does_not_pay_still_counts(setup):+ service, _, _, _ = setup+ reply = await service.record_duel(duel("tdm", mode="team_deathmatch"))+ assert reply["awards"] == [] and reply["duel_stats"]["wins"] == 1+++# ------------------------------------------------------------------ A21.3 clamp+++async def test_more_than_one_kill_per_two_seconds_is_clamped_and_logged(setup, caplog):+ service, _, _, _ = setup+ caplog.set_level(logging.WARNING, logger="dodaios.progression.service")+ reply = await service.record_duel(+ duel(+ "fast",+ match_time_s=100.0,+ stats={"kills": 80, "deaths": 60, "headshots": 70, "best_streak": 80},+ score={"player": 80},+ )+ )+ stats = reply["duel_stats"]+ assert (stats["kills"], stats["deaths"], stats["headshots"], stats["best_streak"]) == (+ 50,+ 50,+ 50,+ 50,+ )+ row = service.duels.get("fast")+ assert row is not None and "kills: 80 -> 50" in row["clamped"]+ assert any(+ "duel fast clamped" in r.getMessage() and "kills: 80 -> 50" in r.getMessage()+ for r in caplog.records+ )+ # Weapon kills never exceed the set's kills.+ assert service.duel_stats()["by_weapon"]["graveline"]["kills"] <= 50+++async def test_a_plausible_set_is_not_clamped(setup, caplog):+ service, _, _, _ = setup+ caplog.set_level(logging.WARNING, logger="dodaios.progression.service")+ await service.record_duel(duel("ok"))+ assert service.duels.get("ok")["clamped"] == []+ assert not [r for r in caplog.records if "clamped" in r.getMessage()]+++# ------------------------------------------------------------------ refusals and events+++ "bad",+ [+ {},+ {"match_id": ""},+ {"match_id": "x", "outcome": "draw"},+ {"match_id": "x", "outcome": "won", "stats": {"kills": "ten"}},+ {"match_id": "x", "outcome": "won", "opponent": {"adaptive": "yes"}},+ {"match_id": "x", "outcome": "won", "weapons": {}},+ ],+)+async def test_a_payload_that_is_no_result_is_a_bad_request(setup, bad):+ service, _, _, _ = setup+ with pytest.raises(DuelResultError) as err:+ await service.record_duel(bad)+ assert err.value.code == "bad_request"+ assert service.duels.count() == 0+++async def test_every_award_is_announced_and_the_set_is_published_once(setup, monkeypatch):+ service, bus, seen, _ = setup++ @dataclass(frozen=True, slots=True, kw_only=True)+ class FakeVerseDuelRecorded(Event):+ match_id: str = ""+ outcome: str = ""+ kills: int = 0+ deaths: int = 0++ monkeypatch.setattr(events, "VerseDuelRecorded", FakeVerseDuelRecorded, raising=False)+ published: list[Any] = []++ async def on_duel(event: Any) -> None:+ published.append(event)++ bus.subscribe(FakeVerseDuelRecorded, on_duel)+ for _ in range(3):+ await service.record_duel(duel("m_ev", stats={"finishers": 1}))+ assert [(e.xp_source, e.xp) for e in seen] == [("duel_won", 60), ("duel_finisher", 5)]+ assert [(e.match_id, e.outcome, e.kills, e.deaths) for e in published] == [+ ("m_ev", "won", 10, 7)+ ]+++async def test_without_the_event_type_the_result_still_records(setup, monkeypatch):+ service, _, _, _ = setup+ monkeypatch.delattr(events, "VerseDuelRecorded", raising=False)+ reply = await service.record_duel(duel("m_noevent"))+ assert reply["recorded"] is True+++_SCHEMA = (+ Path(__file__).resolve().parents[3]+ / "unreal/Verse/Tests/Data/bridge/verse.bridge.1.schema.json"+)++[email protected](not _SCHEMA.exists(), reason="G0.11 bridge schema not on this branch")+async def test_every_reply_and_the_snapshot_stats_match_the_bridge_schema(setup):+ jsonschema = pytest.importorskip("jsonschema")+ schema = json.loads(_SCHEMA.read_text(encoding="utf-8"))++ def check(def_name: str, value: Any) -> None:+ jsonschema.validate(value, {**schema, "$ref": f"#/$defs/{def_name}"})++ service, _, _, _ = setup+ payloads = [+ duel("a"),+ duel("b", outcome="lost", stats={"finishers": 2}),+ duel("c", outcome="unfinished", opponent={"tier": "elite", "adaptive": True}),+ duel("d", opponent={"kind": "player", "tier": None}),+ duel("a"),+ ]+ for payload in payloads:+ if payload["opponent"].get("tier") is None:+ payload["opponent"].pop("tier")+ else:+ check("data.duel.result", payload)+ check("result.duel.result", await service.record_duel(payload))+ check("duel_stats", service.bridge_duel_stats())+ assert set(service.bridge_duel_stats()["by_tier"]) == {"hard", "adaptive"}++[email protected](not _GOLDEN.exists(), reason="G0.11 golden fixtures not on this branch")+async def test_the_golden_duel_results_record_with_the_replies_awards(setup):+ """Every golden ``duel.result`` records; the reply pays at least the golden awards."""+ service, _, _, _ = setup+ pairs = json.loads(_GOLDEN.read_text(encoding="utf-8"))+ for pair in pairs:+ reply = await service.record_duel(copy.deepcopy(pair["request"]["data"]))+ golden = pair["reply"]["data"]["result"]+ assert reply["recorded"] is golden["recorded"]+ mine = [(a["xp_source"], a["xp"]) for a in reply["awards"]]+ for award in golden["awards"]:+ assert (award["xp_source"], award["xp"]) in mine+ if not golden["awards"]:+ assert mine == []diff --git a/tests/unit/progression/test_duel_stats.py b/tests/unit/progression/test_duel_stats.pynew file mode 100644index 0000000000..e926241590--- /dev/null+++ b/tests/unit/progression/test_duel_stats.py@@ -0,0 +1,182 @@+"""The duel stats store: migration, totals, per tier and per weapon (WP21.1)."""++from __future__ import annotations++import sqlite3+from pathlib import Path++import pytest++from dodaios.progression.duel_stats import (+ SCHEMA_VERSION,+ DuelResultError,+ DuelStatsStore,+ parse_duel_result,+)+from dodaios.progression.rules import DUEL_TIER_MULTIPLIERS, duel_awards, duel_tier_key+from dodaios.progression.store import ProgressionStore++from .test_duel_service import duel+++def store(tmp_path: Path):+ s = DuelStatsStore(tmp_path / "progression.db", clock=lambda: 1_790_000_000_000)+ yield s+ s.close()+++def test_the_migration_runs_once_and_shares_the_ledger_database(tmp_path: Path):+ path = tmp_path / "progression.db"+ ledger = ProgressionStore(path)+ assert ledger.latest_seq() == 0+ first = DuelStatsStore(path)+ assert first.schema_version() == SCHEMA_VERSION+ first.insert(parse_duel_result(duel("a")))+ first.close()+ again = DuelStatsStore(path) # reopening keeps the rows and the version+ assert again.schema_version() == SCHEMA_VERSION and again.count() == 1+ again.close()+ ledger.close()+ tables = {+ row[0]+ for row in sqlite3.connect(path).execute(+ "SELECT name FROM sqlite_master WHERE type='table'"+ )+ }+ assert {"progression_awards", "duel_results", "duel_weapons", "duel_schema"} <= tables+++def test_one_match_id_is_one_row(store: DuelStatsStore):+ result = parse_duel_result(duel("same"))+ assert store.insert(result) is True+ assert store.insert(result) is False+ assert store.count() == 1+++def test_totals_add_up_per_tier_and_per_weapon(store: DuelStatsStore):+ store.insert(parse_duel_result(duel("w1")))+ store.insert(+ parse_duel_result(+ duel(+ "l1",+ outcome="lost",+ stats={"kills": 6, "deaths": 10, "headshots": 2, "finishers": 1, "best_streak": 6},+ weapons=[+ {"weapon_id": "graveline", "kills": 4, "shots_fired": 100, "shots_hit": 40},+ {"weapon_id": "sidearm_k", "kills": 2, "shots_fired": 20, "shots_hit": 10},+ ],+ )+ )+ )+ store.insert(+ parse_duel_result(+ duel(+ "u1",+ outcome="unfinished",+ opponent={"tier": "elite", "adaptive": True},+ stats={"kills": 1, "deaths": 0, "headshots": 0, "best_streak": 1},+ weapons=[],+ )+ )+ )+ totals = store.totals()+ assert {k: totals[k] for k in ("matches", "wins", "losses", "unfinished")} == {+ "matches": 3,+ "wins": 1,+ "losses": 1,+ "unfinished": 1,+ }+ assert (totals["kills"], totals["deaths"], totals["headshots"], totals["finishers"]) == (+ 17,+ 17,+ 6,+ 1,+ )+ assert totals["kd"] == 1.0 and totals["best_streak"] == 6+ assert set(totals["by_tier"]) == {"hard", "adaptive"}+ assert totals["by_tier"]["hard"]["matches"] == 2+ assert totals["by_tier"]["adaptive"]["unfinished"] == 1+ assert totals["by_weapon"]["graveline"]["kills"] == 12+ assert totals["by_weapon"]["sidearm_k"] == {+ "kills": 2,+ "headshots": 0,+ "shots_fired": 20,+ "shots_hit": 10,+ "accuracy": 0.5,+ }+++def test_an_empty_store_reads_zeroes(store: DuelStatsStore):+ totals = store.totals()+ assert totals["matches"] == 0 and totals["kd"] == 0.0+ assert totals["by_tier"] == {} and totals["by_weapon"] == {}+ assert store.recent() == []+++def test_recent_lists_newest_first_with_weapons_and_awards(tmp_path: Path):+ now = {"ms": 1_000}+ store = DuelStatsStore(tmp_path / "p.db", clock=lambda: now["ms"])+ for i in range(25):+ store.insert(parse_duel_result(duel(f"m{i:02d}", set_index=i + 1)))+ store.finish(f"m{i:02d}", [{"xp_source": "duel_won", "xp": 60, "seq": i + 1}])+ now["ms"] += 10+ rows = store.recent(limit=20)+ assert len(rows) == 20 and rows[0]["match_id"] == "m24" and rows[-1]["match_id"] == "m05"+ assert rows[0]["xp"] == 60 and rows[0]["weapons"][0]["weapon_id"] == "graveline"+ assert rows[0]["opponent"] == {"kind": "bot", "tier": "hard", "adaptive": False}+ store.close()+++def test_parsing_keeps_unknown_end_reasons_as_unknown_and_merges_weapon_lines():+ result = parse_duel_result(+ duel(+ "x",+ end_reason="meteor",+ weapons=[+ {"weapon_id": "graveline", "kills": 3},+ {"weapon_id": "graveline", "kills": 2, "headshots": 1},+ {"weapon_id": "", "kills": 9},+ ],+ )+ )+ assert result.end_reason == "unknown"+ assert [(w.weapon_id, w.kills, w.headshots) for w in result.weapons] == [("graveline", 5, 1)]+++def test_negative_and_float_counts_are_floored_at_zero():+ result = parse_duel_result(duel("x", stats={"kills": -4, "deaths": 3.9}))+ assert result.stats["kills"] == 0 and result.stats["deaths"] == 3+++def test_a_non_finite_number_is_refused():+ with pytest.raises(DuelResultError):+ parse_duel_result(duel("x", match_time_s=float("nan")))+++def test_the_rulebook_pays_per_the_contract():+ assert DUEL_TIER_MULTIPLIERS == {"normal": 1.0, "hard": 1.5, "elite": 2.0, "adaptive": 1.5}+ assert duel_tier_key("bot", "elite", True) == "adaptive"+ assert duel_tier_key("player", "", False) == "player"+ pay = dict(+ duel_awards(+ mode="deathmatch_1v1", outcome="won", match_time_s=60.0, tier_key="hard", finishers=2+ )+ )+ assert pay == {"duel_won": 60, "duel_finisher": 10}+ assert (+ duel_awards(+ mode="deathmatch_1v1", outcome="won", match_time_s=59.99, tier_key="hard", finishers=0+ )+ == []+ )+ assert (+ duel_awards(+ mode="deathmatch_1v1",+ outcome="unfinished",+ match_time_s=600.0,+ tier_key="hard",+ finishers=3,+ )+ == []+ )diff --git a/tests/unit/progression/test_frontend_parity.py b/tests/unit/progression/test_frontend_parity.pyindex 721f9d093e..2752f10e55 100644--- a/tests/unit/progression/test_frontend_parity.py+++ b/tests/unit/progression/test_frontend_parity.py@@ -109,3 +109,12 @@ def test_every_agent_look_is_a_real_accessory():(_SOCIETY / "companion/accessories.json").read_text(encoding="utf-8"))assert set(LOOK_UNLOCKS) == {item["id"] for item in catalog["items"]}+++def test_the_duel_sources_are_server_rules_the_web_knows():+ """Duel rows (WP21): the web lists the duel sources, and never as a world action."""+ from dodaios.progression.rules import DUEL_SOURCES++ sources = _ts_list("XP_SOURCES")+ assert [s for s in sources if s in DUEL_SOURCES] == list(DUEL_SOURCES)+ assert not set(DUEL_SOURCES) & _ts_union("WorldAction")diff --git a/tests/unit/progression/test_rules.py b/tests/unit/progression/test_rules.pyindex 769977de12..f4f170f619 100644--- a/tests/unit/progression/test_rules.py+++ b/tests/unit/progression/test_rules.py@@ -122,6 +122,7 @@ def test_the_server_rules_keep_their_amounts():"chat_turn": 5, "voice_turn": 5, "quest_posted": 15, "quest_completed": 20,"agent_hired": 50, "mission_completed": 30, "task_done": 40, "task_blocked": 8,"quest_done": 60, "answered_teammate": 5, "jarvis_answered": 4, "delegated": 10,+ "duel_won": 40, "duel_lost": 10, "duel_finisher": 5,}diff --git a/unreal/Verse/Source/VerseBridge/Private/Duel/Tests/Fakes/FakeDuelResultSink.h b/unreal/Verse/Source/VerseBridge/Private/Duel/Tests/Fakes/FakeDuelResultSink.hnew file mode 100644index 0000000000..5eefa1c2d4--- /dev/null+++ b/unreal/Verse/Source/VerseBridge/Private/Duel/Tests/Fakes/FakeDuelResultSink.h@@ -0,0 +1,63 @@+#pragma once++#if WITH_DEV_AUTOMATION_TESTS++#include "CoreMinimal.h"+#include "Duel/VerseDuelResultCodec.h"+#include "Duel/VerseDuelResultSink.h"+#include "HAL/PlatformTime.h"++namespace VerseDuel+{+ /**+ * Stands in for the WP17 bridge client: records every duel.result and answers it as told.+ * With bAnswerAtOnce the reply comes back inside SendDuelResult (a local server); otherwise+ * the callbacks wait in Held until the test calls Answer (a slow one, or a dead one).+ */+ class FFakeDuelResultSink final : public IDuelResultSink+ {+ public:+ struct FSent+ {+ TSharedPtr<FJsonObject> Data;+ double AtSeconds = 0.0;+ };++ bool bReady = true;+ bool bAnswerAtOnce = true;+ ESendResult Answer = ESendResult::Stored;+ TArray<FSent> Sent;+ TArray<TFunction<void(ESendResult)>> Held;++ virtual bool IsReady() const override { return bReady; }++ virtual void SendDuelResult(const TSharedRef<FJsonObject>& Data, TFunction<void(ESendResult)> OnDone) override+ {+ FSent Entry;+ Entry.Data = FromJsonString(ToJsonString(Data)); // a deep copy+ Entry.AtSeconds = FPlatformTime::Seconds();+ Sent.Add(MoveTemp(Entry));+ if (bAnswerAtOnce)+ {+ OnDone(Answer);+ }+ else+ {+ Held.Add(MoveTemp(OnDone));+ }+ }++ /** Answer every held send with Result. */+ void AnswerHeld(ESendResult Result)+ {+ TArray<TFunction<void(ESendResult)>> Calls = MoveTemp(Held);+ Held.Reset();+ for (TFunction<void(ESendResult)>& Call : Calls)+ {+ Call(Result);+ }+ }+ };+}++#endif // WITH_DEV_AUTOMATION_TESTSdiff --git a/unreal/Verse/Source/VerseBridge/Private/Duel/Tests/VerseDuelReporterTest.cpp b/unreal/Verse/Source/VerseBridge/Private/Duel/Tests/VerseDuelReporterTest.cppnew file mode 100644index 0000000000..fc20322677--- /dev/null+++ b/unreal/Verse/Source/VerseBridge/Private/Duel/Tests/VerseDuelReporterTest.cpp@@ -0,0 +1,354 @@+#include "Duel/Tests/Fakes/FakeDuelResultSink.h"+#include "Duel/VerseDuelReporter.h"+#include "Duel/VerseDuelResultCodec.h"+#include "Engine/Engine.h"+#include "Engine/World.h"+#include "Events/VerseEventHub.h"+#include "HAL/FileManager.h"+#include "Misc/AutomationTest.h"+#include "Misc/FileHelper.h"+#include "Misc/Guid.h"+#include "Misc/Paths.h"++#if WITH_DEV_AUTOMATION_TESTS++// Verse.Bridge.Duel.*: the duel.result reporter of WP21.6 against the G0.11 golden fixtures and a+// fake bridge sink. Synthetic FVerseSetSummary events stand in for WP11's ruleset.++#define VERSE_DUEL_TEST_FLAGS (EAutomationTestFlags_ApplicationContextMask | EAutomationTestFlags::EngineFilter)++namespace VerseDuelTest+{+ using namespace VerseDuel;++ /** The set of the contract's example (bridge-protocol.md 10, golden messages/duel.result.json[0]). */+ FVerseSetSummary GoldenSet()+ {+ FVerseSetSummary Set;+ Set.MatchId = TEXT("m_01JD…");+ Set.SessionId = TEXT("s_01JD…");+ Set.SetIndex = 3;+ Set.RulesetId = FName(TEXT("endless/1"));+ Set.BotTier = FName(TEXT("hard"));+ Set.Outcome = EVerseSetOutcome::Won;+ Set.StartedAtUnix = 1793612200.0;+ Set.EndedAtUnix = 1793612500.0;+ Set.MatchTimeS = 296.4f;+ FVerseSetLine& P = Set.Person;+ P.Kills = 10;+ P.Deaths = 7;+ P.Headshots = 4;+ P.Finishers = 1;+ P.MeleeKills = 1;+ P.ShotsFired = 540;+ P.ShotsHit = 201;+ P.DamageDealt = 2760;+ P.DamageTaken = 2210;+ P.WallsBreached = 2;+ P.BulwarksPlaced = 3;+ P.BestStreak = 4;+ P.PerWeapon.Add(FName(TEXT("graveline")), FIntVector4(8, 4, 410, 152));+ Set.Opponent.bIsBot = true;+ Set.Opponent.Kills = 7;+ return Set;+ }++ FVerseSetSummary SetNamed(const FString& MatchId, EVerseSetOutcome Outcome)+ {+ FVerseSetSummary Set = GoldenSet();+ Set.MatchId = MatchId;+ Set.Outcome = Outcome;+ return Set;+ }++ FBuildStamp GoldenBuild()+ {+ FBuildStamp Build;+ Build.Version = TEXT("0.1.0");+ Build.Changelist = TEXT("a1b2c3d");+ return Build;+ }++ /** A fresh pending folder under Saved/Automation, removed by the caller through Cleanup. */+ FString TempDir()+ {+ return FPaths::Combine(FPaths::ProjectSavedDir(), TEXT("Automation"), TEXT("WP21"), FGuid::NewGuid().ToString(EGuidFormats::Digits));+ }++ void Cleanup(const FString& Dir)+ {+ IFileManager::Get().DeleteDirectory(*Dir, false, true);+ }++ int32 FilesIn(const FString& Dir)+ {+ TArray<FString> Files;+ IFileManager::Get().FindFiles(Files, *FPaths::Combine(Dir, TEXT("*.json")), true, false);+ return Files.Num();+ }++ TSharedRef<FDuelReporter> MakeReporter(const FString& Dir, const FString& LaunchId, const TSharedPtr<FFakeDuelResultSink>& Sink)+ {+ FDuelReporter::FConfig Config;+ Config.PendingDir = Dir;+ Config.LaunchId = LaunchId;+ Config.Build = GoldenBuild();+ TSharedRef<FDuelReporter> Reporter = MakeShared<FDuelReporter>(MoveTemp(Config));+ Reporter->SetSink(Sink);+ return Reporter;+ }++ /** JSON equality with numbers compared to a millionth (a float match time round-trips). */+ bool SameJson(FAutomationTestBase& Test, const FString& Path, const TSharedPtr<FJsonValue>& A, const TSharedPtr<FJsonValue>& B)+ {+ if (!A.IsValid() || !B.IsValid())+ {+ Test.AddError(FString::Printf(TEXT("%s: missing value"), *Path));+ return false;+ }+ if (A->Type != B->Type)+ {+ Test.AddError(FString::Printf(TEXT("%s: type %d vs %d"), *Path, int32(A->Type), int32(B->Type)));+ return false;+ }+ switch (A->Type)+ {+ case EJson::Number:+ if (!FMath::IsNearlyEqual(A->AsNumber(), B->AsNumber(), 1e-6 * FMath::Max(1.0, FMath::Abs(B->AsNumber()))))+ {+ Test.AddError(FString::Printf(TEXT("%s: %f vs %f"), *Path, A->AsNumber(), B->AsNumber()));+ return false;+ }+ return true;+ case EJson::String:+ if (A->AsString() != B->AsString())+ {+ Test.AddError(FString::Printf(TEXT("%s: '%s' vs '%s'"), *Path, *A->AsString(), *B->AsString()));+ return false;+ }+ return true;+ case EJson::Boolean:+ return A->AsBool() == B->AsBool() || (Test.AddError(Path + TEXT(": bool differs")), false);+ case EJson::Array:+ {+ const TArray<TSharedPtr<FJsonValue>>& X = A->AsArray();+ const TArray<TSharedPtr<FJsonValue>>& Y = B->AsArray();+ if (X.Num() != Y.Num())+ {+ Test.AddError(FString::Printf(TEXT("%s: %d vs %d items"), *Path, X.Num(), Y.Num()));+ return false;+ }+ bool bSame = true;+ for (int32 I = 0; I < X.Num(); ++I)+ {+ bSame &= SameJson(Test, FString::Printf(TEXT("%s[%d]"), *Path, I), X[I], Y[I]);+ }+ return bSame;+ }+ case EJson::Object:+ {+ const TSharedPtr<FJsonObject> X = A->AsObject();+ const TSharedPtr<FJsonObject> Y = B->AsObject();+ bool bSame = X->Values.Num() == Y->Values.Num();+ if (!bSame)+ {+ TArray<FString> KX, KY;+ X->Values.GetKeys(KX);+ Y->Values.GetKeys(KY);+ Test.AddError(FString::Printf(TEXT("%s: keys {%s} vs {%s}"), *Path, *FString::Join(KX, TEXT(",")), *FString::Join(KY, TEXT(","))));+ }+ for (const TPair<FString, TSharedPtr<FJsonValue>>& Pair : Y->Values)+ {+ bSame &= SameJson(Test, Path + TEXT(".") + Pair.Key, X->TryGetField(Pair.Key), Pair.Value);+ }+ return bSame;+ }+ default:+ return true;+ }+ }++ TSharedPtr<FJsonObject> GoldenData(FAutomationTestBase& Test, int32 Index)+ {+ const FString Path = FPaths::Combine(FPaths::ProjectDir(), TEXT("Tests/Data/bridge/messages/duel.result.json"));+ FString Text;+ if (!Test.TestTrue(TEXT("golden duel.result fixture is readable"), FFileHelper::LoadFileToString(Text, *Path)))+ {+ return nullptr;+ }+ TArray<TSharedPtr<FJsonValue>> Frames;+ const TSharedRef<TJsonReader<TCHAR>> Reader = TJsonReaderFactory<TCHAR>::Create(Text);+ if (!FJsonSerializer::Deserialize(Reader, Frames) || !Frames.IsValidIndex(Index))+ {+ Test.AddError(TEXT("golden duel.result fixture does not parse"));+ return nullptr;+ }+ return Frames[Index]->AsObject()->GetObjectField(TEXT("data"));+ }+}++IMPLEMENT_SIMPLE_AUTOMATION_TEST(FVerseDuelCodecGoldenTest, "Verse.Bridge.Duel.Codec.Golden", VERSE_DUEL_TEST_FLAGS)+bool FVerseDuelCodecGoldenTest::RunTest(const FString& Parameters)+{+ using namespace VerseDuelTest;+ const TSharedPtr<FJsonObject> Golden = GoldenData(*this, 0);+ if (!Golden.IsValid())+ {+ return false;+ }+ const TSharedRef<FJsonObject> Mine = EncodeResult(GoldenSet(), EEndReason::SetComplete, GoldenBuild());+ SameJson(*this, TEXT("data"), MakeShared<FJsonValueObject>(Mine), MakeShared<FJsonValueObject>(Golden));+ // The text round trip keeps every field (what the pending file holds).+ const TSharedPtr<FJsonObject> Back = FromJsonString(ToJsonString(Mine));+ TestTrue(TEXT("round trip parses"), Back.IsValid());+ if (Back.IsValid())+ {+ SameJson(*this, TEXT("round_trip"), MakeShared<FJsonValueObject>(Back), MakeShared<FJsonValueObject>(Golden));+ }+ return true;+}++IMPLEMENT_SIMPLE_AUTOMATION_TEST(FVerseDuelCodecOutcomesTest, "Verse.Bridge.Duel.Codec.Outcomes", VERSE_DUEL_TEST_FLAGS)+bool FVerseDuelCodecOutcomesTest::RunTest(const FString& Parameters)+{+ using namespace VerseDuelTest;+ FVerseSetSummary Left = SetNamed(TEXT("m_left"), EVerseSetOutcome::Unfinished);+ Left.BotTier = FName(TEXT("adaptive"));+ Left.Person.PerWeapon.Add(FName(TEXT("Side Arm-K")), FIntVector4(1, 0, 20, 9));+ const TSharedRef<FJsonObject> Data = EncodeResult(Left, DefaultEndReason(Left), GoldenBuild());+ TestEqual(TEXT("unfinished outcome"), Data->GetStringField(TEXT("outcome")), FString(TEXT("unfinished")));+ TestEqual(TEXT("left mid-set"), Data->GetStringField(TEXT("end_reason")), FString(TEXT("player_left")));+ const TSharedPtr<FJsonObject> Opponent = Data->GetObjectField(TEXT("opponent"));+ TestEqual(TEXT("adaptive bot starts on hard"), Opponent->GetStringField(TEXT("tier")), FString(TEXT("hard")));+ TestTrue(TEXT("adaptive flag"), Opponent->GetBoolField(TEXT("adaptive")));+ const TArray<TSharedPtr<FJsonValue>>& Weapons = Data->GetArrayField(TEXT("weapons"));+ TestEqual(TEXT("two weapons"), Weapons.Num(), 2);+ TestEqual(TEXT("wire ids sort and sanitise"), Weapons[1]->AsObject()->GetStringField(TEXT("weapon_id")), FString(TEXT("side_arm_k")));++ // A finished set always completed, whatever reason the caller had in mind.+ const TSharedRef<FJsonObject> Won = EncodeResult(GoldenSet(), EEndReason::AppQuit, GoldenBuild());+ TestEqual(TEXT("won is set_complete"), Won->GetStringField(TEXT("end_reason")), FString(TEXT("set_complete")));+ const TSharedRef<FJsonObject> Quit = EncodeResult(Left, EEndReason::VerseQuit, GoldenBuild());+ TestEqual(TEXT("quit mid-set"), Quit->GetStringField(TEXT("end_reason")), FString(TEXT("verse_quit")));++ FVerseSetSummary Versus = GoldenSet();+ Versus.Opponent.bIsBot = false;+ const TSharedPtr<FJsonObject> Player = EncodeResult(Versus, EEndReason::SetComplete, GoldenBuild())->GetObjectField(TEXT("opponent"));+ TestEqual(TEXT("person opponent"), Player->GetStringField(TEXT("kind")), FString(TEXT("player")));+ TestFalse(TEXT("no tier for a person"), Player->HasField(TEXT("tier")));++ EEndReason Parsed = EEndReason::SetComplete;+ TestTrue(TEXT("crash_recovered parses"), ParseEndReason(TEXT("crash_recovered"), Parsed) && Parsed == EEndReason::CrashRecovered);+ TestFalse(TEXT("unknown reason refused"), ParseEndReason(TEXT("meteor"), Parsed));+ return true;+}++IMPLEMENT_SIMPLE_AUTOMATION_TEST(FVerseDuelOnePerSetTest, "Verse.Bridge.Duel.OneResultPerSet", VERSE_DUEL_TEST_FLAGS)+bool FVerseDuelOnePerSetTest::RunTest(const FString& Parameters)+{+ using namespace VerseDuelTest;+ const FString Dir = TempDir();+ UWorld* World = UWorld::CreateWorld(EWorldType::Game, false, TEXT("VerseDuelTestWorld"));+ UVerseEventHub* Hub = World ? World->GetSubsystem<UVerseEventHub>() : nullptr;+ if (!TestNotNull(TEXT("game world has the hub"), Hub))+ {+ return false;+ }+ TSharedPtr<FFakeDuelResultSink> Sink = MakeShared<FFakeDuelResultSink>();+ TSharedRef<FDuelReporter> Reporter = MakeReporter(Dir, TEXT("launch-a"), Sink);+ Reporter->Bind(*Hub);++ Hub->OnSetEnded.Broadcast(SetNamed(TEXT("set-1"), EVerseSetOutcome::Won));+ Hub->OnSetEnded.Broadcast(SetNamed(TEXT("set-2"), EVerseSetOutcome::Lost));+ Hub->OnSetEnded.Broadcast(SetNamed(TEXT("set-2"), EVerseSetOutcome::Lost)); // raised twice: still one result+ Reporter->NotifyQuitting(EEndReason::VerseQuit);+ Hub->OnSetEnded.Broadcast(SetNamed(TEXT("set-3"), EVerseSetOutcome::Unfinished));++ TestEqual(TEXT("one duel.result per set"), Sink->Sent.Num(), 3);+ TArray<FString> Reasons;+ for (const FFakeDuelResultSink::FSent& Sent : Sink->Sent)+ {+ Reasons.Add(Sent.Data->GetStringField(TEXT("match_id")) + TEXT(":") + Sent.Data->GetStringField(TEXT("outcome")) + TEXT(":") + Sent.Data->GetStringField(TEXT("end_reason")));+ }+ TestEqual(TEXT("results in order"), FString::Join(Reasons, TEXT(",")),+ FString(TEXT("set-1:won:set_complete,set-2:lost:set_complete,set-3:unfinished:verse_quit")));+ TestEqual(TEXT("stored results leave no pending file"), FilesIn(Dir), 0);++ Reporter->Unbind();+ Hub->OnSetEnded.Broadcast(SetNamed(TEXT("set-4"), EVerseSetOutcome::Won));+ TestEqual(TEXT("unbound reporter hears nothing"), Sink->Sent.Num(), 3);++ World->DestroyWorld(false);+ Cleanup(Dir);+ return true;+}++IMPLEMENT_SIMPLE_AUTOMATION_TEST(FVerseDuelCrashRecoveryTest, "Verse.Bridge.Duel.CrashRecovery", VERSE_DUEL_TEST_FLAGS)+bool FVerseDuelCrashRecoveryTest::RunTest(const FString& Parameters)+{+ using namespace VerseDuelTest;+ const FString Dir = TempDir();+ {+ // Launch A: the set ends, the result goes out, and Verse dies before any reply.+ TSharedPtr<FFakeDuelResultSink> Dead = MakeShared<FFakeDuelResultSink>();+ Dead->bAnswerAtOnce = false;+ TSharedRef<FDuelReporter> A = MakeReporter(Dir, TEXT("launch-a"), Dead);+ A->HandleSetEnded(SetNamed(TEXT("m-crash"), EVerseSetOutcome::Won));+ TestEqual(TEXT("sent once before the crash"), Dead->Sent.Num(), 1);+ TestEqual(TEXT("the pending result is on disk"), FilesIn(Dir), 1);+ // The process dies: the reporter goes away without a reply; a late reply is harmless.+ }+ TestEqual(TEXT("the pending result survives the crash"), FilesIn(Dir), 1);++ // Launch B: the bridge says welcome; the leftover goes out at once as crash_recovered.+ TSharedPtr<FFakeDuelResultSink> Sink = MakeShared<FFakeDuelResultSink>();+ Sink->bAnswerAtOnce = false;+ TSharedRef<FDuelReporter> B = MakeReporter(Dir, TEXT("launch-b"), Sink);+ const double Welcome = FPlatformTime::Seconds();+ B->HandleWelcome();+ if (!TestEqual(TEXT("one result sent on welcome"), Sink->Sent.Num(), 1))+ {+ Cleanup(Dir);+ return false;+ }+ const FFakeDuelResultSink::FSent& Sent = Sink->Sent[0];+ TestTrue(TEXT("A21.4: sent within 10 s of welcome"), Sent.AtSeconds - Welcome < 10.0);+ TestEqual(TEXT("same match id"), Sent.Data->GetStringField(TEXT("match_id")), FString(TEXT("m-crash")));+ TestEqual(TEXT("end_reason crash_recovered"), Sent.Data->GetStringField(TEXT("end_reason")), FString(TEXT("crash_recovered")));+ TestEqual(TEXT("outcome kept"), Sent.Data->GetStringField(TEXT("outcome")), FString(TEXT("won")));++ // A second welcome while the first send is in flight sends nothing new.+ B->HandleWelcome();+ TestEqual(TEXT("no double send in flight"), Sink->Sent.Num(), 1);+ // No reply (link dropped): kept, and the next welcome sends it again.+ Sink->AnswerHeld(ESendResult::Failed);+ TestEqual(TEXT("kept after a failed send"), FilesIn(Dir), 1);+ B->HandleWelcome();+ TestEqual(TEXT("re-sent on the next welcome"), Sink->Sent.Num(), 2);+ Sink->AnswerHeld(ESendResult::Stored);+ TestEqual(TEXT("stored: the pending file is gone"), FilesIn(Dir), 0);+ TestEqual(TEXT("nothing pending"), B->PendingMatchIds().Num(), 0);++ // A result the server refuses is dropped, never retried forever.+ Sink->bAnswerAtOnce = true;+ Sink->Answer = ESendResult::Rejected;+ B->HandleSetEnded(SetNamed(TEXT("m-bad"), EVerseSetOutcome::Lost));+ TestEqual(TEXT("rejected result dropped"), FilesIn(Dir), 0);++ // Without a link the result waits on disk and goes out on the welcome of the same launch.+ Sink->Answer = ESendResult::Stored;+ Sink->bReady = false;+ B->HandleSetEnded(SetNamed(TEXT("m-offline"), EVerseSetOutcome::Lost));+ TestEqual(TEXT("offline: pending on disk"), FilesIn(Dir), 1);+ const int32 Before = Sink->Sent.Num();+ Sink->bReady = true;+ B->HandleWelcome();+ TestEqual(TEXT("sent on welcome"), Sink->Sent.Num(), Before + 1);+ TestEqual(TEXT("same launch keeps its own reason"), Sink->Sent.Last().Data->GetStringField(TEXT("end_reason")), FString(TEXT("set_complete")));+ TestEqual(TEXT("then gone"), FilesIn(Dir), 0);++ Cleanup(Dir);+ return true;+}++#endif // WITH_DEV_AUTOMATION_TESTSdiff --git a/unreal/Verse/Source/VerseBridge/Private/Duel/VerseDuelReporter.cpp b/unreal/Verse/Source/VerseBridge/Private/Duel/VerseDuelReporter.cppnew file mode 100644index 0000000000..f570d82583--- /dev/null+++ b/unreal/Verse/Source/VerseBridge/Private/Duel/VerseDuelReporter.cpp@@ -0,0 +1,262 @@+#include "Duel/VerseDuelReporter.h"++#include "Events/VerseEventHub.h"+#include "HAL/FileManager.h"+#include "Misc/FileHelper.h"+#include "Misc/Guid.h"+#include "Misc/Paths.h"+#include "VerseLog.h"++namespace VerseDuel+{+ namespace+ {+ const TCHAR* const PendingExtension = TEXT(".json");++ /** A file name for a match id: safe characters plus a hash, so two ids never share a file. */+ FString FileStem(const FString& MatchId)+ {+ FString Safe;+ Safe.Reserve(MatchId.Len());+ for (const TCHAR Char : MatchId)+ {+ const bool bOk = FChar::IsAlnum(Char) && Char < 128;+ Safe.AppendChar(bOk || Char == TEXT('_') || Char == TEXT('-') ? Char : TEXT('_'));+ }+ return FString::Printf(TEXT("%s_%08x"), *Safe.Left(48), FCrc::StrCrc32(*MatchId));+ }+ }++ FString FDuelReporter::DefaultPendingDir()+ {+ return FPaths::Combine(FPaths::ProjectSavedDir(), TEXT("Verse"), TEXT("Duel"), TEXT("Pending"));+ }++ FDuelReporter::FDuelReporter(FConfig InConfig)+ : Config(MoveTemp(InConfig))+ {+ if (Config.LaunchId.IsEmpty())+ {+ Config.LaunchId = FGuid::NewGuid().ToString(EGuidFormats::Digits);+ }+ }++ FDuelReporter::~FDuelReporter()+ {+ Unbind();+ }++ void FDuelReporter::SetSink(TSharedPtr<IDuelResultSink> InSink)+ {+ Sink = MoveTemp(InSink);+ }++ void FDuelReporter::Bind(UVerseEventHub& Hub)+ {+ Unbind();+ BoundHub = &Hub;+ SetEndedHandle = Hub.OnSetEnded.AddSP(AsShared(), &FDuelReporter::HandleSetEnded);+ }++ void FDuelReporter::Unbind()+ {+ if (UVerseEventHub* Hub = BoundHub.Get())+ {+ Hub->OnSetEnded.Remove(SetEndedHandle);+ }+ BoundHub.Reset();+ SetEndedHandle.Reset();+ }++ void FDuelReporter::UnbindFrom(const UVerseEventHub& Hub)+ {+ if (BoundHub.Get() == &Hub)+ {+ Unbind();+ }+ }++ FString FDuelReporter::PathFor(const FString& MatchId) const+ {+ return FPaths::Combine(Config.PendingDir, FileStem(MatchId) + PendingExtension);+ }++ void FDuelReporter::LoadPendingFromDisk()+ {+ if (bLoaded)+ {+ return;+ }+ bLoaded = true;+ TArray<FString> Files;+ IFileManager::Get().FindFiles(Files, *FPaths::Combine(Config.PendingDir, FString(TEXT("*")) + PendingExtension), true, false);+ Files.Sort();+ for (const FString& File : Files)+ {+ const FString Path = FPaths::Combine(Config.PendingDir, File);+ FString Text;+ TSharedPtr<FJsonObject> Root;+ if (FFileHelper::LoadFileToString(Text, *Path))+ {+ Root = FromJsonString(Text);+ }+ const TSharedPtr<FJsonObject>* Data = nullptr;+ FString MatchId;+ if (!Root.IsValid() || !Root->TryGetObjectField(TEXT("data"), Data) || !Data || !(*Data)->TryGetStringField(TEXT("match_id"), MatchId) || MatchId.IsEmpty())+ {+ UE_LOG(LogVerseBridge, Warning, TEXT("duel: dropping unreadable pending result %s"), *File);+ IFileManager::Get().Delete(*Path, false, true, true);+ continue;+ }+ if (Pending.ContainsByPredicate([&MatchId](const FPending& P) { return P.MatchId == MatchId; }))+ {+ continue;+ }+ FPending Entry;+ Entry.MatchId = MatchId;+ Entry.LaunchId = Root->GetStringField(TEXT("launch_id"));+ Entry.Data = *Data;+ Pending.Add(MoveTemp(Entry));+ }+ }++ bool FDuelReporter::Persist(const FPending& Entry) const+ {+ TSharedRef<FJsonObject> Root = MakeShared<FJsonObject>();+ Root->SetStringField(TEXT("launch_id"), Entry.LaunchId);+ Root->SetObjectField(TEXT("data"), Entry.Data);+ const FString Path = PathFor(Entry.MatchId);+ const FString Temp = Path + TEXT(".tmp");+ IFileManager::Get().MakeDirectory(*Config.PendingDir, true);+ if (!FFileHelper::SaveStringToFile(ToJsonString(Root), *Temp, FFileHelper::EEncodingOptions::ForceUTF8WithoutBOM))+ {+ return false;+ }+ return IFileManager::Get().Move(*Path, *Temp, true, true);+ }++ void FDuelReporter::Forget(const FString& MatchId)+ {+ Pending.RemoveAll([&MatchId](const FPending& P) { return P.MatchId == MatchId; });+ IFileManager::Get().Delete(*PathFor(MatchId), false, true, true);+ }++ void FDuelReporter::HandleSetEnded(const FVerseSetSummary& Summary)+ {+ LoadPendingFromDisk();+ if (Summary.MatchId.IsEmpty())+ {+ UE_LOG(LogVerseBridge, Warning, TEXT("duel: a set ended without a match id; not reported"));+ return;+ }+ if (Stored.Contains(Summary.MatchId) || Pending.ContainsByPredicate([&Summary](const FPending& P) { return P.MatchId == Summary.MatchId; }))+ {+ return;+ }+ EEndReason Reason = DefaultEndReason(Summary);+ if (Summary.Outcome == EVerseSetOutcome::Unfinished && QuitReason.IsSet())+ {+ Reason = QuitReason.GetValue();+ }+ FPending Entry;+ Entry.MatchId = Summary.MatchId;+ Entry.LaunchId = Config.LaunchId;+ Entry.Data = EncodeResult(Summary, Reason, Config.Build);+ if (!Persist(Entry))+ {+ UE_LOG(LogVerseBridge, Warning, TEXT("duel: pending result %s not saved; a crash before its reply loses it"), *Entry.MatchId);+ }+ Pending.Add(MoveTemp(Entry));+ Send(Pending.Last());+ }++ void FDuelReporter::HandleWelcome()+ {+ LoadPendingFromDisk();+ // Send from a copy of the ids: a sink that answers at once changes the list.+ TArray<FString> Ids = PendingMatchIds();+ for (const FString& Id : Ids)+ {+ FPending* Entry = Pending.FindByPredicate([&Id](const FPending& P) { return P.MatchId == Id; });+ if (!Entry || Entry->bInFlight)+ {+ continue;+ }+ if (Entry->LaunchId != Config.LaunchId)+ {+ // A leftover of a launch that never got its reply: it is recovered now.+ Entry->Data->SetStringField(TEXT("end_reason"), EndReasonName(EEndReason::CrashRecovered));+ Entry->LaunchId = Config.LaunchId;+ Persist(*Entry);+ }+ Send(*Entry);+ }+ }++ void FDuelReporter::NotifyQuitting(EEndReason Reason)+ {+ QuitReason = Reason;+ }++ TArray<FString> FDuelReporter::PendingMatchIds() const+ {+ TArray<FString> Ids;+ for (const FPending& Entry : Pending)+ {+ Ids.Add(Entry.MatchId);+ }+ return Ids;+ }++ void FDuelReporter::Send(FPending& Entry)+ {+ if (!Sink.IsValid() || !Sink->IsReady() || Entry.bInFlight)+ {+ return;+ }+ Entry.bInFlight = true;+ ++SentCount;+ const FString MatchId = Entry.MatchId;+ TWeakPtr<FDuelReporter> Weak = AsShared();+ Sink->SendDuelResult(Entry.Data.ToSharedRef(), [Weak, MatchId](ESendResult Result)+ {+ if (TSharedPtr<FDuelReporter> Self = Weak.Pin())+ {+ Self->OnSent(MatchId, Result);+ }+ });+ }++ void FDuelReporter::OnSent(const FString& MatchId, ESendResult Result)+ {+ switch (Result)+ {+ case ESendResult::Stored:+ Stored.Add(MatchId);+ Forget(MatchId);+ break;+ case ESendResult::Rejected:+ UE_LOG(LogVerseBridge, Warning, TEXT("duel: the server refused result %s (bad_request); dropped"), *MatchId);+ Forget(MatchId);+ break;+ default:+ if (FPending* Entry = Pending.FindByPredicate([&MatchId](const FPending& P) { return P.MatchId == MatchId; }))+ {+ Entry->bInFlight = false;+ }+ break;+ }+ }++ FDuelReporter& ProcessReporter()+ {+ static TSharedRef<FDuelReporter> Reporter = []()+ {+ FDuelReporter::FConfig Config;+ Config.PendingDir = FDuelReporter::DefaultPendingDir();+ Config.Build = FBuildStamp::Current();+ return MakeShared<FDuelReporter>(MoveTemp(Config));+ }();+ return *Reporter;+ }+}diff --git a/unreal/Verse/Source/VerseBridge/Private/Duel/VerseDuelReporter.h b/unreal/Verse/Source/VerseBridge/Private/Duel/VerseDuelReporter.hnew file mode 100644index 0000000000..b840d9c053--- /dev/null+++ b/unreal/Verse/Source/VerseBridge/Private/Duel/VerseDuelReporter.h@@ -0,0 +1,97 @@+#pragma once++#include "Combat/VerseCombatTypes.h"+#include "CoreMinimal.h"+#include "Duel/VerseDuelResultCodec.h"+#include "Duel/VerseDuelResultSink.h"+#include "Templates/SharedPointer.h"++class UVerseEventHub;++// The duel.result reporter (WP21.6, bridge-protocol.md 10, combat-state.md 9.1).+//+// One result per set: every FVerseSetSummary the hub raises on OnSetEnded becomes one+// duel.result. Before it is sent it is written to a pending file, and only a `reply` that says+// stored removes the file. A Verse that dies after a set therefore still has the result on the+// next launch, which sends it on its first `welcome` with end_reason `crash_recovered`. The+// server is idempotent on match_id, so a result sent twice is harmless.++namespace VerseDuel+{+ class FDuelReporter : public TSharedFromThis<FDuelReporter>+ {+ public:+ struct FConfig+ {+ /** Folder of the pending results; created on first write. */+ FString PendingDir;+ /** Unique per process launch; a pending file of another launch is a crash leftover. */+ FString LaunchId;+ FBuildStamp Build;+ };++ /** Pending folder of the running build: `Saved/Verse/Duel/Pending`. */+ static FString DefaultPendingDir();++ explicit FDuelReporter(FConfig InConfig);+ ~FDuelReporter();++ /** The bridge connection to send through; null while there is none. */+ void SetSink(TSharedPtr<IDuelResultSink> InSink);++ /** Listen to OnSetEnded of a world's hub (one hub at a time). */+ void Bind(UVerseEventHub& Hub);+ void Unbind();+ /** Unbind only when bound to this hub (a second world must not cut the first one's link). */+ void UnbindFrom(const UVerseEventHub& Hub);++ /** One set ended (finished, or left mid-way): persist it, then send it. */+ void HandleSetEnded(const FVerseSetSummary& Summary);++ /** `welcome` arrived: send every pending result, an earlier launch's as crash_recovered. */+ void HandleWelcome();++ /** Verse or the app is going away: an unfinished set from now on ends with this reason. */+ void NotifyQuitting(EEndReason Reason);++ /** Match ids of the results not yet stored by the server, in send order. */+ TArray<FString> PendingMatchIds() const;++ /** How many results this reporter has sent (every attempt counts). */+ int32 NumSent() const { return SentCount; }++ private:+ struct FPending+ {+ FString MatchId;+ FString LaunchId;+ TSharedPtr<FJsonObject> Data;+ bool bInFlight = false;+ };++ FString PathFor(const FString& MatchId) const;+ void LoadPendingFromDisk();+ bool Persist(const FPending& Pending) const;+ void Forget(const FString& MatchId);+ void Send(FPending& Pending);+ void OnSent(const FString& MatchId, ESendResult Result);++ FConfig Config;+ TSharedPtr<IDuelResultSink> Sink;+ TArray<FPending> Pending;+ /** Match ids the server has confirmed during this launch; a repeat raise is dropped. */+ TSet<FString> Stored;+ TWeakObjectPtr<UVerseEventHub> BoundHub;+ FDelegateHandle SetEndedHandle;+ TOptional<EEndReason> QuitReason;+ bool bLoaded = false;+ int32 SentCount = 0;+ };++ /**+ * The reporter of this process, created on first use with the default pending folder. The+ * bridge client (WP17) hands it the sink and calls HandleWelcome on every `welcome`;+ * UVerseDuelReporterSubsystem binds it to the game world's hub.+ */+ FDuelReporter& ProcessReporter();+}diff --git a/unreal/Verse/Source/VerseBridge/Private/Duel/VerseDuelReporterSubsystem.cpp b/unreal/Verse/Source/VerseBridge/Private/Duel/VerseDuelReporterSubsystem.cppnew file mode 100644index 0000000000..041a86ed1a--- /dev/null+++ b/unreal/Verse/Source/VerseBridge/Private/Duel/VerseDuelReporterSubsystem.cpp@@ -0,0 +1,37 @@+#include "Duel/VerseDuelReporterSubsystem.h"++#include "Duel/VerseDuelReporter.h"+#include "Events/VerseEventHub.h"+#include "Engine/World.h"+#include "Misc/CoreMisc.h"+#include "Subsystems/SubsystemCollection.h"++bool UVerseDuelReporterSubsystem::DoesSupportWorldType(const EWorldType::Type WorldType) const+{+ // The duel runs in the game world (and in play-in-editor); editor and preview worlds never report.+ return WorldType == EWorldType::Game || WorldType == EWorldType::PIE;+}++void UVerseDuelReporterSubsystem::Initialize(FSubsystemCollectionBase& Collection)+{+ Super::Initialize(Collection);+ UVerseEventHub* Hub = Collection.InitializeDependency<UVerseEventHub>();+ // Automation worlds raise synthetic sets; they must never become pending results that a+ // real launch would send. The reporter's own tests drive FDuelReporter directly.+ if (Hub && !GIsAutomationTesting)+ {+ VerseDuel::ProcessReporter().Bind(*Hub);+ }+}++void UVerseDuelReporterSubsystem::Deinitialize()+{+ if (const UWorld* World = GetWorld())+ {+ if (const UVerseEventHub* Hub = World->GetSubsystem<UVerseEventHub>())+ {+ VerseDuel::ProcessReporter().UnbindFrom(*Hub);+ }+ }+ Super::Deinitialize();+}diff --git a/unreal/Verse/Source/VerseBridge/Private/Duel/VerseDuelReporterSubsystem.h b/unreal/Verse/Source/VerseBridge/Private/Duel/VerseDuelReporterSubsystem.hnew file mode 100644index 0000000000..e1cce80cb6--- /dev/null+++ b/unreal/Verse/Source/VerseBridge/Private/Duel/VerseDuelReporterSubsystem.h@@ -0,0 +1,24 @@+#pragma once++#include "CoreMinimal.h"+#include "Subsystems/WorldSubsystem.h"++#include "VerseDuelReporterSubsystem.generated.h"++/**+ * Binds the process duel reporter (VerseDuel::ProcessReporter) to the hub of each game world,+ * so every FVerseSetSummary raised on UVerseEventHub::OnSetEnded becomes one duel.result.+ * Reads Core types only; never includes VerseCombat (combat-state.md 11.2).+ */+UCLASS()+class UVerseDuelReporterSubsystem : public UWorldSubsystem+{+ GENERATED_BODY()++public:+ virtual void Initialize(FSubsystemCollectionBase& Collection) override;+ virtual void Deinitialize() override;++protected:+ virtual bool DoesSupportWorldType(const EWorldType::Type WorldType) const override;+};diff --git a/unreal/Verse/Source/VerseBridge/Private/Duel/VerseDuelResultCodec.cpp b/unreal/Verse/Source/VerseBridge/Private/Duel/VerseDuelResultCodec.cppnew file mode 100644index 0000000000..d593ed2394--- /dev/null+++ b/unreal/Verse/Source/VerseBridge/Private/Duel/VerseDuelResultCodec.cpp@@ -0,0 +1,219 @@+#include "Duel/VerseDuelResultCodec.h"++#include "Misc/ConfigCacheIni.h"+#include "Misc/EngineVersion.h"+#include "Policies/CondensedJsonPrintPolicy.h"+#include "Serialization/JsonReader.h"+#include "Serialization/JsonSerializer.h"+#include "Serialization/JsonWriter.h"++namespace VerseDuel+{+ namespace+ {+ const TCHAR* const EndReasonNames[] = {+ TEXT("set_complete"),+ TEXT("player_left"),+ TEXT("verse_quit"),+ TEXT("crash_recovered"),+ TEXT("app_quit"),+ };++ bool IsWireTier(const FString& Tier)+ {+ return Tier == TEXT("normal") || Tier == TEXT("hard") || Tier == TEXT("elite");+ }++ /** Seconds rounded to the millisecond, so a float match time reads as the clock showed it. */+ double Millis(double Seconds)+ {+ return FMath::RoundToDouble(FMath::Max(0.0, Seconds) * 1000.0) / 1000.0;+ }++ void SetCount(FJsonObject& Object, const TCHAR* Name, int32 Value)+ {+ Object.SetNumberField(Name, double(FMath::Max(0, Value)));+ }+ }++ const TCHAR* EndReasonName(EEndReason Reason)+ {+ const int32 Index = int32(Reason);+ return Index >= 0 && Index < UE_ARRAY_COUNT(EndReasonNames) ? EndReasonNames[Index] : EndReasonNames[1];+ }++ bool ParseEndReason(const FString& Name, EEndReason& Out)+ {+ for (int32 Index = 0; Index < UE_ARRAY_COUNT(EndReasonNames); ++Index)+ {+ if (Name == EndReasonNames[Index])+ {+ Out = EEndReason(Index);+ return true;+ }+ }+ return false;+ }++ const TCHAR* OutcomeName(EVerseSetOutcome Outcome)+ {+ switch (Outcome)+ {+ case EVerseSetOutcome::Won:+ return TEXT("won");+ case EVerseSetOutcome::Lost:+ return TEXT("lost");+ default:+ return TEXT("unfinished");+ }+ }++ FBuildStamp FBuildStamp::Current()+ {+ FBuildStamp Stamp;+ if (GConfig)+ {+ GConfig->GetString(TEXT("/Script/EngineSettings.GeneralProjectSettings"), TEXT("ProjectVersion"), Stamp.Version, GGameIni);+ }+ if (Stamp.Version.IsEmpty())+ {+ Stamp.Version = TEXT("0.0.0");+ }+ const uint32 Changelist = FEngineVersion::Current().GetChangelist();+ Stamp.Changelist = Changelist != 0 ? FString::Printf(TEXT("%u"), Changelist) : FString(TEXT("local"));+ return Stamp;+ }++ FString WireId(FName Id)+ {+ FString Out = Id.ToString().ToLower();+ for (TCHAR& Char : Out)+ {+ const bool bOk = (Char >= TEXT('a') && Char <= TEXT('z')) || (Char >= TEXT('0') && Char <= TEXT('9')) || Char == TEXT('_');+ if (!bOk)+ {+ Char = TEXT('_');+ }+ }+ return Out.IsEmpty() ? FString(TEXT("unknown")) : Out;+ }++ EEndReason DefaultEndReason(const FVerseSetSummary& Summary)+ {+ return Summary.Outcome == EVerseSetOutcome::Unfinished ? EEndReason::PlayerLeft : EEndReason::SetComplete;+ }++ TSharedRef<FJsonObject> EncodeResult(const FVerseSetSummary& Summary, EEndReason EndReason, const FBuildStamp& Build)+ {+ // A finished set always completed; only an unfinished one carries a leave reason.+ if (Summary.Outcome != EVerseSetOutcome::Unfinished && EndReason != EEndReason::CrashRecovered)+ {+ EndReason = EEndReason::SetComplete;+ }+ else if (Summary.Outcome == EVerseSetOutcome::Unfinished && EndReason == EEndReason::SetComplete)+ {+ EndReason = EEndReason::PlayerLeft;+ }++ const FVerseSetLine& Person = Summary.Person;+ TSharedRef<FJsonObject> Data = MakeShared<FJsonObject>();+ Data->SetStringField(TEXT("match_id"), Summary.MatchId);+ Data->SetStringField(TEXT("session_id"), Summary.SessionId.IsEmpty() ? Summary.MatchId : Summary.SessionId);+ Data->SetNumberField(TEXT("set_index"), double(FMath::Max(1, Summary.SetIndex)));+ Data->SetStringField(TEXT("mode"), DeathmatchMode);+ Data->SetStringField(TEXT("ruleset"), Summary.RulesetId.IsNone() ? FString(TEXT("endless/1")) : Summary.RulesetId.ToString());++ TSharedRef<FJsonObject> Opponent = MakeShared<FJsonObject>();+ if (Summary.Opponent.bIsBot)+ {+ Opponent->SetStringField(TEXT("kind"), TEXT("bot"));+ const FString Tier = Summary.BotTier.IsNone() ? FString() : Summary.BotTier.ToString().ToLower();+ const bool bAdaptive = Tier == TEXT("adaptive");+ if (bAdaptive)+ {+ Opponent->SetStringField(TEXT("tier"), AdaptiveStartTier);+ }+ else if (IsWireTier(Tier))+ {+ Opponent->SetStringField(TEXT("tier"), Tier);+ }+ Opponent->SetBoolField(TEXT("adaptive"), bAdaptive);+ }+ else+ {+ Opponent->SetStringField(TEXT("kind"), TEXT("player"));+ Opponent->SetBoolField(TEXT("adaptive"), false);+ }+ Data->SetObjectField(TEXT("opponent"), Opponent);++ Data->SetNumberField(TEXT("started_at"), FMath::Max(0.0, Summary.StartedAtUnix));+ Data->SetNumberField(TEXT("ended_at"), FMath::Max(0.0, Summary.EndedAtUnix));+ Data->SetNumberField(TEXT("match_time_s"), Millis(Summary.MatchTimeS));+ Data->SetStringField(TEXT("end_reason"), EndReasonName(EndReason));+ Data->SetStringField(TEXT("outcome"), OutcomeName(Summary.Outcome));++ TSharedRef<FJsonObject> Score = MakeShared<FJsonObject>();+ SetCount(*Score, TEXT("player"), Person.Kills);+ SetCount(*Score, TEXT("opponent"), Summary.Opponent.Kills);+ Data->SetObjectField(TEXT("score"), Score);++ TSharedRef<FJsonObject> Stats = MakeShared<FJsonObject>();+ SetCount(*Stats, TEXT("kills"), Person.Kills);+ SetCount(*Stats, TEXT("deaths"), Person.Deaths);+ SetCount(*Stats, TEXT("headshots"), Person.Headshots);+ SetCount(*Stats, TEXT("finishers"), Person.Finishers);+ SetCount(*Stats, TEXT("melee_kills"), Person.MeleeKills);+ SetCount(*Stats, TEXT("shots_fired"), Person.ShotsFired);+ SetCount(*Stats, TEXT("shots_hit"), Person.ShotsHit);+ SetCount(*Stats, TEXT("damage_dealt"), Person.DamageDealt);+ SetCount(*Stats, TEXT("damage_taken"), Person.DamageTaken);+ SetCount(*Stats, TEXT("walls_breached"), Person.WallsBreached);+ SetCount(*Stats, TEXT("bulwarks_placed"), Person.BulwarksPlaced);+ SetCount(*Stats, TEXT("best_streak"), Person.BestStreak);+ Data->SetObjectField(TEXT("stats"), Stats);++ // Weapons in id order, so the same set always encodes to the same text.+ TArray<FName> WeaponIds;+ Person.PerWeapon.GetKeys(WeaponIds);+ WeaponIds.Sort([](const FName& A, const FName& B) { return A.LexicalLess(B); });+ TArray<TSharedPtr<FJsonValue>> Weapons;+ for (const FName& Id : WeaponIds)+ {+ const FIntVector4& Line = Person.PerWeapon.FindChecked(Id);+ TSharedRef<FJsonObject> Weapon = MakeShared<FJsonObject>();+ Weapon->SetStringField(TEXT("weapon_id"), WireId(Id));+ SetCount(*Weapon, TEXT("kills"), Line.X);+ SetCount(*Weapon, TEXT("headshots"), Line.Y);+ SetCount(*Weapon, TEXT("shots_fired"), Line.Z);+ SetCount(*Weapon, TEXT("shots_hit"), Line.W);+ Weapons.Add(MakeShared<FJsonValueObject>(Weapon));+ }+ Data->SetArrayField(TEXT("weapons"), Weapons);++ TSharedRef<FJsonObject> BuildObject = MakeShared<FJsonObject>();+ BuildObject->SetStringField(TEXT("version"), Build.Version.IsEmpty() ? FString(TEXT("0.0.0")) : Build.Version);+ BuildObject->SetStringField(TEXT("changelist"), Build.Changelist.IsEmpty() ? FString(TEXT("local")) : Build.Changelist);+ Data->SetObjectField(TEXT("build"), BuildObject);+ return Data;+ }++ FString ToJsonString(const TSharedRef<FJsonObject>& Object)+ {+ FString Out;+ const TSharedRef<TJsonWriter<TCHAR, TCondensedJsonPrintPolicy<TCHAR>>> Writer =+ TJsonWriterFactory<TCHAR, TCondensedJsonPrintPolicy<TCHAR>>::Create(&Out);+ FJsonSerializer::Serialize(Object, Writer);+ return Out;+ }++ TSharedPtr<FJsonObject> FromJsonString(const FString& Text)+ {+ TSharedPtr<FJsonObject> Object;+ const TSharedRef<TJsonReader<TCHAR>> Reader = TJsonReaderFactory<TCHAR>::Create(Text);+ if (!FJsonSerializer::Deserialize(Reader, Object))+ {+ return nullptr;+ }+ return Object;+ }+}diff --git a/unreal/Verse/Source/VerseBridge/Private/Duel/VerseDuelResultCodec.h b/unreal/Verse/Source/VerseBridge/Private/Duel/VerseDuelResultCodec.hnew file mode 100644index 0000000000..59f8440f48--- /dev/null+++ b/unreal/Verse/Source/VerseBridge/Private/Duel/VerseDuelResultCodec.h@@ -0,0 +1,57 @@+#pragma once++#include "Combat/VerseCombatTypes.h"+#include "CoreMinimal.h"+#include "Dom/JsonObject.h"++// duel.result codec (bridge-protocol.md 10): FVerseSetSummary (combat-state.md 11.1) field for+// field onto the payload, plus the two fields the summary does not carry (mode and end reason)+// and the build stamp. Core types only; this module never includes VerseCombat.++namespace VerseDuel+{+ /** Why a set ended, as the wire spells it (bridge-protocol.md 10, `end_reason`). */+ enum class EEndReason : uint8+ {+ SetComplete,+ PlayerLeft,+ VerseQuit,+ CrashRecovered,+ AppQuit,+ };++ /** The only mode that exists in verse.bridge/1; every set the hub raises is one of it. */+ inline const TCHAR* const DeathmatchMode = TEXT("deathmatch_1v1");++ /** The tier an adaptive bot starts on (bot.md 9.2, StartSkill 0.5 = hard). */+ inline const TCHAR* const AdaptiveStartTier = TEXT("hard");++ const TCHAR* EndReasonName(EEndReason Reason);+ bool ParseEndReason(const FString& Name, EEndReason& Out);+ const TCHAR* OutcomeName(EVerseSetOutcome Outcome);++ /** The build stamp a result carries (`build`); both fields are never empty. */+ struct FBuildStamp+ {+ FString Version;+ FString Changelist;++ /** Project version and engine build version of the running build. */+ static FBuildStamp Current();+ };++ /** A weapon id as the wire allows it: lower case, `[a-z0-9_]`, other characters become `_`. */+ FString WireId(FName Id);++ /**+ * The `data` object of one duel.result. A won or lost set ends with `set_complete`; an+ * unfinished one with the reason the caller names (player_left by default).+ */+ TSharedRef<FJsonObject> EncodeResult(const FVerseSetSummary& Summary, EEndReason EndReason, const FBuildStamp& Build);++ /** The reason a set ends with when nothing else is known: complete for finished, left otherwise. */+ EEndReason DefaultEndReason(const FVerseSetSummary& Summary);++ FString ToJsonString(const TSharedRef<FJsonObject>& Object);+ TSharedPtr<FJsonObject> FromJsonString(const FString& Text);+}diff --git a/unreal/Verse/Source/VerseBridge/Private/Duel/VerseDuelResultSink.h b/unreal/Verse/Source/VerseBridge/Private/Duel/VerseDuelResultSink.hnew file mode 100644index 0000000000..d9040ac517--- /dev/null+++ b/unreal/Verse/Source/VerseBridge/Private/Duel/VerseDuelResultSink.h@@ -0,0 +1,35 @@+#pragma once++#include "CoreMinimal.h"+#include "Dom/JsonObject.h"+#include "Templates/Function.h"++// The seam between the duel reporter and the bridge client (WP17). The client implements it:+// IsReady once `welcome` arrived on the current connection, SendDuelResult as one `duel.result`+// command whose `reply` it hands back exactly once. Tests use FFakeDuelResultSink.++namespace VerseDuel+{+ /** How a sent result came back. */+ enum class ESendResult : uint8+ {+ /** `reply` with `ok: true`: the server stored it (or already had it). */+ Stored,+ /** `reply` with `ok: false` and `bad_request`: the server will never take it. */+ Rejected,+ /** No answer (link dropped, timeout, any other error code): try again on the next welcome. */+ Failed,+ };++ class IDuelResultSink+ {+ public:+ virtual ~IDuelResultSink() = default;++ /** True between `welcome` and the end of the connection. */+ virtual bool IsReady() const = 0;++ /** Sends one `duel.result` with `Data` as its payload; calls OnDone exactly once. */+ virtual void SendDuelResult(const TSharedRef<FJsonObject>& Data, TFunction<void(ESendResult)> OnDone) = 0;+ };+}diff --git a/unreal/Verse/Source/VerseBridge/VerseBridge.Build.cs b/unreal/Verse/Source/VerseBridge/VerseBridge.Build.csindex 68e509ed18..51651f54e5 100644--- a/unreal/Verse/Source/VerseBridge/VerseBridge.Build.cs+++ b/unreal/Verse/Source/VerseBridge/VerseBridge.Build.cs@@ -9,5 +9,7 @@ public class VerseBridge : ModuleRulesPCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine" });PublicDependencyModuleNames.AddRange(new string[] { "VerseCore" });+ // Json: the duel.result codec and its pending store (WP21.6, bridge-protocol.md 10).+ PrivateDependencyModuleNames.AddRange(new string[] { "Json" });}}diff --git a/unreal/Verse/Source/VerseUI/Private/ServiceRecord/SVerseServiceRecord.cpp b/unreal/Verse/Source/VerseUI/Private/ServiceRecord/SVerseServiceRecord.cppnew file mode 100644index 0000000000..d9b7914f2e--- /dev/null+++ b/unreal/Verse/Source/VerseUI/Private/ServiceRecord/SVerseServiceRecord.cpp@@ -0,0 +1,246 @@+#include "ServiceRecord/SVerseServiceRecord.h"++#include "Styling/CoreStyle.h"+#include "Widgets/Layout/SBorder.h"+#include "Widgets/Layout/SBox.h"+#include "Widgets/Layout/SUniformGridPanel.h"+#include "Widgets/Notifications/SProgressBar.h"+#include "Widgets/SBoxPanel.h"+#include "Widgets/Text/STextBlock.h"++#define LOCTEXT_NAMESPACE "VerseServiceRecord"++namespace+{+ const FLinearColor ColPanel(0.018f, 0.018f, 0.022f, 0.94f);+ const FLinearColor ColRaised(0.045f, 0.045f, 0.052f, 1.f);+ const FLinearColor ColText(0.92f, 0.91f, 0.88f, 1.f);+ const FLinearColor ColMuted(0.55f, 0.54f, 0.52f, 1.f);+ const FLinearColor ColGold(0.86f, 0.66f, 0.30f, 1.f);++ FSlateFontInfo RecordFont(int32 Size, bool bBold = false)+ {+ return FCoreStyle::GetDefaultFontStyle(bBold ? "Bold" : "Regular", Size);+ }++ // The record's figures are culture-invariant, like the web record's (rankModel.ts figure()):+ // thousands grouped with a space, no decimals. Both records show the same characters.+ FText Figure(int64 Value)+ {+ return FText::FromString(SVerseServiceRecord::FormatFigure(Value));+ }++ FText TierName(FName Tier)+ {+ if (Tier == TEXT("deck")) return LOCTEXT("tier.deck", "Deck ratings");+ if (Tier == TEXT("line")) return LOCTEXT("tier.line", "Line officers");+ if (Tier == TEXT("command")) return LOCTEXT("tier.command", "Command");+ return LOCTEXT("tier.flag", "Flag officers");+ }++ TSharedRef<SWidget> MakeFact(const FText& Caption, const TAttribute<FText>& Value)+ {+ return SNew(SBorder)+ .BorderImage(FCoreStyle::Get().GetBrush("WhiteBrush"))+ .BorderBackgroundColor(ColRaised)+ .Padding(FMargin(10.f, 8.f))+ [+ SNew(SVerticalBox)+ + SVerticalBox::Slot().AutoHeight()+ [+ SNew(STextBlock).Text(Caption).Font(RecordFont(8)).ColorAndOpacity(ColMuted)+ ]+ + SVerticalBox::Slot().AutoHeight()+ [+ SNew(STextBlock).Text(Value).Font(RecordFont(14)).ColorAndOpacity(ColText)+ ]+ ];+ }+}++FText VerseRankName(FName RankId)+{+ static const TMap<FName, FText> Names = {+ {FName(TEXT("recruit")), LOCTEXT("rank.recruit", "Recruit")},+ {FName(TEXT("deckhand")), LOCTEXT("rank.deckhand", "Deckhand")},+ {FName(TEXT("technician")), LOCTEXT("rank.technician", "Technician")},+ {FName(TEXT("senior_technician")), LOCTEXT("rank.senior_technician", "Senior Technician")},+ {FName(TEXT("ensign")), LOCTEXT("rank.ensign", "Ensign")},+ {FName(TEXT("lieutenant")), LOCTEXT("rank.lieutenant", "Lieutenant")},+ {FName(TEXT("senior_lieutenant")), LOCTEXT("rank.senior_lieutenant", "Senior Lieutenant")},+ {FName(TEXT("commander")), LOCTEXT("rank.commander", "Commander")},+ {FName(TEXT("captain")), LOCTEXT("rank.captain", "Captain")},+ {FName(TEXT("line_captain")), LOCTEXT("rank.line_captain", "Line Captain")},+ {FName(TEXT("commodore")), LOCTEXT("rank.commodore", "Commodore")},+ {FName(TEXT("rear_admiral")), LOCTEXT("rank.rear_admiral", "Rear Admiral")},+ {FName(TEXT("vice_admiral")), LOCTEXT("rank.vice_admiral", "Vice Admiral")},+ {FName(TEXT("admiral")), LOCTEXT("rank.admiral", "Admiral")},+ {FName(TEXT("fleet_admiral")), LOCTEXT("rank.fleet_admiral", "Fleet Admiral")},+ };+ const FText* Found = Names.Find(RankId);+ return Found ? *Found : FText::FromName(RankId);+}++void SVerseServiceRecord::Construct(const FArguments& InArgs, TSharedRef<FVerseServiceRecordModel> InModel)+{+ Model = InModel;+ TWeakPtr<FVerseServiceRecordModel> Weak = InModel;+ auto Live = [this](const FString Key)+ {+ return TAttribute<FText>::CreateLambda([this, Key]()+ {+ const FText* Value = Model.IsValid() ? DescribeFacts(*Model).Find(Key) : nullptr;+ return Value ? *Value : FText::GetEmpty();+ });+ };++ ChildSlot+ [+ SNew(SBox)+ .WidthOverride(560.f)+ [+ SNew(SBorder)+ .BorderImage(FCoreStyle::Get().GetBrush("WhiteBrush"))+ .BorderBackgroundColor(ColPanel)+ .Padding(FMargin(20.f))+ [+ SNew(SVerticalBox)+ + SVerticalBox::Slot().AutoHeight().Padding(0.f, 0.f, 0.f, 12.f)+ [+ SNew(STextBlock).Text(LOCTEXT("title", "SERVICE RECORD")).Font(RecordFont(10, true)).ColorAndOpacity(ColGold)+ ]+ + SVerticalBox::Slot().AutoHeight()+ [+ SNew(STextBlock).Text(Live(TEXT("tier"))).Font(RecordFont(8)).ColorAndOpacity(ColMuted)+ ]+ + SVerticalBox::Slot().AutoHeight().Padding(0.f, 2.f, 0.f, 12.f)+ [+ SNew(STextBlock).Text(Live(TEXT("rank"))).Font(RecordFont(22, true)).ColorAndOpacity(ColText)+ ]+ + SVerticalBox::Slot().AutoHeight()+ [+ SNew(SUniformGridPanel).SlotPadding(FMargin(1.f))+ + SUniformGridPanel::Slot(0, 0)[MakeFact(LOCTEXT("level", "LEVEL"), Live(TEXT("level")))]+ + SUniformGridPanel::Slot(1, 0)[MakeFact(LOCTEXT("total_xp", "TOTAL XP"), Live(TEXT("total_xp")))]+ + SUniformGridPanel::Slot(2, 0)[MakeFact(LOCTEXT("this_level", "THIS LEVEL"), Live(TEXT("xp")))]+ + SUniformGridPanel::Slot(3, 0)[MakeFact(LOCTEXT("next_rank", "NEXT RANK"), Live(TEXT("next")))]+ ]+ + SVerticalBox::Slot().AutoHeight().Padding(0.f, 6.f, 0.f, 16.f)+ [+ SNew(SBox).HeightOverride(4.f)+ [+ SNew(SProgressBar)+ .FillColorAndOpacity(ColGold)+ .Percent_Lambda([Weak]() -> TOptional<float>+ {+ const TSharedPtr<FVerseServiceRecordModel> M = Weak.Pin();+ if (!M.IsValid() || M->Commander().ForNext <= 0)+ {+ return 1.f;+ }+ return float(double(M->Commander().IntoLevel) / double(M->Commander().ForNext));+ })+ ]+ ]+ + SVerticalBox::Slot().AutoHeight().Padding(0.f, 0.f, 0.f, 6.f)+ [+ SNew(STextBlock).Text(LOCTEXT("duels", "DUELS")).Font(RecordFont(8, true)).ColorAndOpacity(ColMuted)+ ]+ + SVerticalBox::Slot().AutoHeight()+ [+ SNew(SUniformGridPanel).SlotPadding(FMargin(1.f))+ + SUniformGridPanel::Slot(0, 0)[MakeFact(LOCTEXT("sets", "SETS"), Live(TEXT("sets")))]+ + SUniformGridPanel::Slot(1, 0)[MakeFact(LOCTEXT("won_lost", "WON / LOST"), Live(TEXT("won_lost")))]+ + SUniformGridPanel::Slot(2, 0)[MakeFact(LOCTEXT("kd", "K/D"), Live(TEXT("kd")))]+ + SUniformGridPanel::Slot(0, 1)[MakeFact(LOCTEXT("headshots", "HEADSHOTS"), Live(TEXT("headshots")))]+ + SUniformGridPanel::Slot(1, 1)[MakeFact(LOCTEXT("finishers", "FINISHERS"), Live(TEXT("finishers")))]+ + SUniformGridPanel::Slot(2, 1)[MakeFact(LOCTEXT("best_streak", "BEST STREAK"), Live(TEXT("best_streak")))]+ ]+ ]+ ]+ ];+}++TMap<FString, FText> SVerseServiceRecord::DescribeFacts(const FVerseServiceRecordModel& RecordModel)+{+ TMap<FString, FText> Facts;+ const FVerseCommanderRecord& C = RecordModel.Commander();+ const FVerseRankRow& Rank = FVerseServiceRecordModel::RankFor(C.Level);+ const FVerseRankRow* Next = FVerseServiceRecordModel::NextRank(C.Level);+ Facts.Add(TEXT("rank"), VerseRankName(Rank.Id));+ Facts.Add(TEXT("tier"), TierName(Rank.Tier));+ Facts.Add(TEXT("level"), Figure(C.Level));+ Facts.Add(TEXT("total_xp"), Figure(C.TotalXp));+ Facts.Add(TEXT("xp"), C.ForNext > 0+ ? FText::Format(LOCTEXT("xp_of", "{0} / {1}"), Figure(C.IntoLevel), Figure(C.ForNext))+ : LOCTEXT("at_cap", "-"));+ Facts.Add(TEXT("next"), Next ? VerseRankName(Next->Id) : LOCTEXT("top_rank", "Highest rank"));++ const FVerseDuelTotals& D = RecordModel.Duels();+ Facts.Add(TEXT("sets"), Figure(D.Matches));+ Facts.Add(TEXT("won_lost"), FText::Format(LOCTEXT("won_lost_value", "{0} / {1}"), Figure(D.Wins), Figure(D.Losses)));+ Facts.Add(TEXT("kd"), FText::FromString(SVerseServiceRecord::FormatRatio(D.KillDeathRatio())));+ Facts.Add(TEXT("headshots"), Figure(D.Headshots));+ Facts.Add(TEXT("finishers"), Figure(D.Finishers));+ Facts.Add(TEXT("best_streak"), Figure(D.BestStreak));+ return Facts;+}++void SVersePromotionNotice::Construct(const FArguments& InArgs, const FVersePromotion& InPromotion)+{+ Promotion = InPromotion;+ ChildSlot+ [+ SNew(SBorder)+ .BorderImage(FCoreStyle::Get().GetBrush("WhiteBrush"))+ .BorderBackgroundColor(ColPanel)+ .Padding(FMargin(24.f, 14.f))+ [+ SNew(SVerticalBox)+ + SVerticalBox::Slot().AutoHeight()+ [+ SNew(STextBlock).Text(Headline()).Font(RecordFont(9, true)).ColorAndOpacity(ColGold)+ ]+ + SVerticalBox::Slot().AutoHeight().Padding(0.f, 4.f, 0.f, 0.f)+ [+ SNew(STextBlock).Text(Detail()).Font(RecordFont(18, true)).ColorAndOpacity(ColText)+ ]+ ]+ ];+}++FText SVersePromotionNotice::Headline() const+{+ return Promotion.IsNewRank() ? LOCTEXT("promoted", "PROMOTED") : LOCTEXT("level_up", "LEVEL UP");+}++FText SVersePromotionNotice::Detail() const+{+ return Promotion.IsNewRank()+ ? FText::Format(LOCTEXT("promoted_detail", "{0}, level {1}"), VerseRankName(Promotion.RankId), FText::AsNumber(Promotion.Level))+ : FText::Format(LOCTEXT("level_detail", "Level {0}"), FText::AsNumber(Promotion.Level));+}++FString SVerseServiceRecord::FormatFigure(int64 Value)+{+ const bool bNegative = Value < 0;+ const FString Digits = FString::Printf(TEXT("%lld"), bNegative ? -Value : Value);+ FString Out;+ for (int32 i = 0; i < Digits.Len(); ++i)+ {+ if (i > 0 && (Digits.Len() - i) % 3 == 0)+ {+ Out.AppendChar(TEXT(' '));+ }+ Out.AppendChar(Digits[i]);+ }+ return bNegative ? TEXT("-") + Out : Out;+}++FString SVerseServiceRecord::FormatRatio(float Value)+{+ // Two decimals with a point, as the web's toFixed(2); Printf ignores the running culture.+ return FString::Printf(TEXT("%.2f"), Value);+}++#undef LOCTEXT_NAMESPACEdiff --git a/unreal/Verse/Source/VerseUI/Private/ServiceRecord/SVerseServiceRecord.h b/unreal/Verse/Source/VerseUI/Private/ServiceRecord/SVerseServiceRecord.hnew file mode 100644index 0000000000..025641847b--- /dev/null+++ b/unreal/Verse/Source/VerseUI/Private/ServiceRecord/SVerseServiceRecord.h@@ -0,0 +1,48 @@+#pragma once++#include "CoreMinimal.h"+#include "ServiceRecord/VerseServiceRecordModel.h"+#include "Widgets/DeclarativeSyntaxSupport.h"+#include "Widgets/SCompoundWidget.h"++/** The words of a rank id (`verse.ranks.rank.<id>` on the web). */+VERSEUI_API FText VerseRankName(FName RankId);++/**+ * The service record panel: the commander's rank, level and XP, the next rank, and the duel+ * record (sets, won / lost, K/D, headshots, finishers, best streak). Reads the model live.+ */+class VERSEUI_API SVerseServiceRecord : public SCompoundWidget+{+public:+ SLATE_BEGIN_ARGS(SVerseServiceRecord) {}+ SLATE_END_ARGS()++ void Construct(const FArguments& InArgs, TSharedRef<FVerseServiceRecordModel> InModel);++ /** The texts the panel shows, keyed by fact (`rank`, `level`, `xp`, `next`, `sets`, ...). */+ static TMap<FString, FText> DescribeFacts(const FVerseServiceRecordModel& RecordModel);+ /** A whole number as both records print it: thousands grouped with a space ("12 340"). */+ static FString FormatFigure(int64 Value);+ /** A ratio as both records print it: two decimals with a point ("1.19"), in every culture. */+ static FString FormatRatio(float Value);++private:+ TSharedPtr<FVerseServiceRecordModel> Model;+};++/** The promotion notice: the new rank (or level) of the oldest promotion not shown yet. */+class VERSEUI_API SVersePromotionNotice : public SCompoundWidget+{+public:+ SLATE_BEGIN_ARGS(SVersePromotionNotice) {}+ SLATE_END_ARGS()++ void Construct(const FArguments& InArgs, const FVersePromotion& InPromotion);++ FText Headline() const;+ FText Detail() const;++private:+ FVersePromotion Promotion;+};diff --git a/unreal/Verse/Source/VerseUI/Private/ServiceRecord/Tests/VerseServiceRecordTest.cpp b/unreal/Verse/Source/VerseUI/Private/ServiceRecord/Tests/VerseServiceRecordTest.cppnew file mode 100644index 0000000000..63ca68d505--- /dev/null+++ b/unreal/Verse/Source/VerseUI/Private/ServiceRecord/Tests/VerseServiceRecordTest.cpp@@ -0,0 +1,242 @@+#include "Framework/Application/SlateApplication.h"+#include "Internationalization/Culture.h"+#include "Internationalization/Internationalization.h"+#include "Misc/AutomationTest.h"+#include "Misc/FileHelper.h"+#include "Misc/Paths.h"+#include "Serialization/JsonReader.h"+#include "Serialization/JsonSerializer.h"+#include "ServiceRecord/SVerseServiceRecord.h"+#include "ServiceRecord/VerseServiceRecordModel.h"+#include "ServiceRecord/VerseServiceRecordSubsystem.h"++#if WITH_DEV_AUTOMATION_TESTS++// Verse.UI.ServiceRecord.*: the Unreal service record of WP21.7 against the G0.11 fake bridge's+// `awards` scenario (unreal/Verse/Tests/Data/bridge/scenarios/awards.json).++#define VERSE_RECORD_TEST_FLAGS (EAutomationTestFlags_ApplicationContextMask | EAutomationTestFlags::EngineFilter)++namespace VerseRecordTest+{+ TSharedPtr<FJsonObject> Scenario(FAutomationTestBase& Test)+ {+ const FString Path = FPaths::Combine(FPaths::ProjectDir(), TEXT("Tests/Data/bridge/scenarios/awards.json"));+ FString Text;+ TSharedPtr<FJsonObject> Root;+ if (!Test.TestTrue(TEXT("awards scenario is readable"), FFileHelper::LoadFileToString(Text, *Path)))+ {+ return nullptr;+ }+ const TSharedRef<TJsonReader<TCHAR>> Reader = TJsonReaderFactory<TCHAR>::Create(Text);+ if (!Test.TestTrue(TEXT("awards scenario parses"), FJsonSerializer::Deserialize(Reader, Root) && Root.IsValid()))+ {+ return nullptr;+ }+ return Root;+ }++ TSharedPtr<FJsonObject> Snapshot(const FJsonObject& Scenario)+ {+ return Scenario.GetObjectField(TEXT("state"))->GetObjectField(TEXT("progression.snapshot"));+ }++ /** Feed every `progression.awarded` step of the scenario; returns how many queued a notice. */+ int32 PlayAwards(const FJsonObject& Scenario, FVerseServiceRecordModel& Model)+ {+ int32 Queued = 0;+ for (const TSharedPtr<FJsonValue>& Step : Scenario.GetArrayField(TEXT("steps")))+ {+ const TSharedPtr<FJsonObject>* Frame = nullptr;+ if (Step->AsObject()->TryGetObjectField(TEXT("frame"), Frame) && (*Frame)->GetStringField(TEXT("type")) == TEXT("progression.awarded"))+ {+ Queued += Model.ApplyAwarded(*(*Frame)->GetObjectField(TEXT("data"))) ? 1 : 0;+ }+ }+ return Queued;+ }+}++IMPLEMENT_SIMPLE_AUTOMATION_TEST(FVerseRecordCurveTest, "Verse.UI.ServiceRecord.Rulebook", VERSE_RECORD_TEST_FLAGS)+bool FVerseRecordCurveTest::RunTest(const FString& Parameters)+{+ // Reference numbers from dodaios/progression/rules.py (progress_for_xp, total_xp_for_level).+ TestEqual(TEXT("level 1 -> 2 costs 40"), FVerseServiceRecordModel::XpToNext(1), int64(40));+ TestEqual(TEXT("level 10 -> 11 costs 320"), FVerseServiceRecordModel::XpToNext(10), int64(320));+ TestEqual(TEXT("level 49 -> 50 costs 1805"), FVerseServiceRecordModel::XpToNext(49), int64(1805));+ TestEqual(TEXT("cap costs nothing"), FVerseServiceRecordModel::XpToNext(50), int64(0));+ TestEqual(TEXT("level 50 total"), FVerseServiceRecordModel::TotalXpForLevel(50), int64(43230));+ TestEqual(TEXT("39 XP is level 1"), FVerseServiceRecordModel::LevelForXp(39), 1);+ TestEqual(TEXT("40 XP is level 2"), FVerseServiceRecordModel::LevelForXp(40), 2);+ TestEqual(TEXT("5230 XP is level 18"), FVerseServiceRecordModel::LevelForXp(5230), 18);+ TestEqual(TEXT("15 ranks"), FVerseServiceRecordModel::Ladder().Num(), 15);+ TestEqual(TEXT("level 14 holds lieutenant"), FVerseServiceRecordModel::RankFor(14).Id.ToString(), FString(TEXT("lieutenant")));+ TestEqual(TEXT("level 16 still lieutenant"), FVerseServiceRecordModel::RankFor(16).Id.ToString(), FString(TEXT("lieutenant")));+ TestEqual(TEXT("next after 14"), FVerseServiceRecordModel::NextRank(14)->Id.ToString(), FString(TEXT("senior_lieutenant")));+ TestNull(TEXT("nothing above the top"), FVerseServiceRecordModel::NextRank(50));+ return true;+}++IMPLEMENT_SIMPLE_AUTOMATION_TEST(FVerseRecordSnapshotTest, "Verse.UI.ServiceRecord.Snapshot", VERSE_RECORD_TEST_FLAGS)+bool FVerseRecordSnapshotTest::RunTest(const FString& Parameters)+{+ using namespace VerseRecordTest;+ const TSharedPtr<FJsonObject> Root = Scenario(*this);+ if (!Root.IsValid())+ {+ return false;+ }+ FVerseServiceRecordModel Model;+ TestTrue(TEXT("snapshot applies"), Model.ApplySnapshot(*Snapshot(*Root)));+ const FVerseCommanderRecord& C = Model.Commander();+ TestEqual(TEXT("level"), C.Level, 14);+ TestEqual(TEXT("total xp"), C.TotalXp, int64(5230));+ TestEqual(TEXT("into level as the server says"), C.IntoLevel, int64(130));+ TestEqual(TEXT("for next as the server says"), C.ForNext, int64(600));+ TestEqual(TEXT("told seq"), Model.ToldSeq(), int64(897));+ const FVerseDuelTotals& D = Model.Duels();+ TestEqual(TEXT("sets"), D.Matches, 12);+ TestEqual(TEXT("wins"), D.Wins, 7);+ TestEqual(TEXT("losses"), D.Losses, 5);+ TestEqual(TEXT("headshots"), D.Headshots, 31);+ TestEqual(TEXT("finishers"), D.Finishers, 4);+ TestEqual(TEXT("best streak"), D.BestStreak, 6);+ TestTrue(TEXT("K/D 96 / 81"), FMath::IsNearlyEqual(D.KillDeathRatio(), 96.f / 81.f));+ TestTrue(TEXT("hard tier 5 / 3"), D.ByTier.FindRef(TEXT("hard")) == FIntPoint(5, 3));+ FJsonObject NotASnapshot;+ TestFalse(TEXT("a frame without subjects is refused"), Model.ApplySnapshot(NotASnapshot));+ return true;+}++IMPLEMENT_SIMPLE_AUTOMATION_TEST(FVerseRecordToldTest, "Verse.UI.ServiceRecord.PromotionTold", VERSE_RECORD_TEST_FLAGS)+bool FVerseRecordToldTest::RunTest(const FString& Parameters)+{+ using namespace VerseRecordTest;+ const TSharedPtr<FJsonObject> Root = Scenario(*this);+ if (!Root.IsValid())+ {+ return false;+ }+ TSharedRef<FVerseServiceRecordModel> Model = MakeShared<FVerseServiceRecordModel>();+ TArray<int64> Told;+ Model->SendTold = [&Told](int64 Seq) { Told.Add(Seq); };+ Model->ApplySnapshot(*Snapshot(*Root));+ TestEqual(TEXT("only the commander's level-up queues a notice"), PlayAwards(*Root, *Model), 1);+ const FVersePromotion* Pending = Model->PendingPromotion();+ if (!TestNotNull(TEXT("a promotion waits"), Pending))+ {+ return false;+ }+ TestEqual(TEXT("seq 905"), Pending->Seq, int64(905));+ TestEqual(TEXT("level 15"), Pending->Level, 15);+ TestFalse(TEXT("14 -> 15 keeps the rank"), Pending->IsNewRank());+ TestEqual(TEXT("commander now level 15"), Model->Commander().Level, 15);++ // No screen: the notice waits and nothing is told.+ FVersePromotionPresenter Headless(Model, [](const FVersePromotion&) { return false; }, []() {});+ for (int32 I = 0; I < 50; ++I)+ {+ Headless.Tick(0.1f);+ }+ TestEqual(TEXT("nothing told without a screen"), Told.Num(), 0);++ // On screen for NoticeSeconds, then told exactly once.+ int32 Shows = 0;+ int32 Hides = 0;+ FVersePromotionPresenter Presenter(Model, [&Shows](const FVersePromotion&) { ++Shows; return true; }, [&Hides]() { ++Hides; });+ Presenter.Tick(0.f);+ TestTrue(TEXT("on screen"), Presenter.IsShowing());+ Presenter.Tick(FVersePromotionPresenter::NoticeSeconds * 0.5f);+ TestEqual(TEXT("not told while on screen"), Told.Num(), 0);+ Presenter.Tick(FVersePromotionPresenter::NoticeSeconds);+ TestEqual(TEXT("progression.told sent once"), Told.Num(), 1);+ TestEqual(TEXT("with seq 905"), Told.Num() > 0 ? Told[0] : int64(0), int64(905));+ TestEqual(TEXT("shown once, hidden once"), Shows * 10 + Hides, 11);+ for (int32 I = 0; I < 50; ++I)+ {+ Presenter.Tick(0.1f);+ }+ TestEqual(TEXT("no second notice"), Shows, 1);++ // A level-up shown once is never shown again: a replay of the award or an older snapshot.+ PlayAwards(*Root, *Model);+ Model->ApplySnapshot(*Snapshot(*Root));+ TestNull(TEXT("replay queues nothing"), Model->PendingPromotion());+ TestEqual(TEXT("told seq kept"), Model->ToldSeq(), int64(905));++ // A promotion the web app showed first (told_seq moved past it) is dropped untold.+ TSharedRef<FVerseServiceRecordModel> Fresh = MakeShared<FVerseServiceRecordModel>();+ Fresh->SendTold = [&Told](int64 Seq) { Told.Add(Seq); };+ Fresh->ApplySnapshot(*Snapshot(*Root));+ PlayAwards(*Root, *Fresh);+ FString SnapshotText;+ FJsonSerializer::Serialize(Snapshot(*Root).ToSharedRef(), TJsonWriterFactory<>::Create(&SnapshotText));+ TSharedPtr<FJsonObject> Later;+ FJsonSerializer::Deserialize(TJsonReaderFactory<>::Create(SnapshotText), Later);+ Later->SetNumberField(TEXT("told_seq"), 905);+ Fresh->ApplySnapshot(*Later);+ TestNull(TEXT("told elsewhere: dropped"), Fresh->PendingPromotion());+ TestEqual(TEXT("and not told again"), Told.Num(), 1);+ return true;+}++IMPLEMENT_SIMPLE_AUTOMATION_TEST(FVerseRecordViewTest, "Verse.UI.ServiceRecord.View", VERSE_RECORD_TEST_FLAGS)+bool FVerseRecordViewTest::RunTest(const FString& Parameters)+{+ using namespace VerseRecordTest;+ const TSharedPtr<FJsonObject> Root = Scenario(*this);+ if (!Root.IsValid())+ {+ return false;+ }+ TSharedRef<FVerseServiceRecordModel> Model = MakeShared<FVerseServiceRecordModel>();+ Model->ApplySnapshot(*Snapshot(*Root));+ TMap<FString, FText> Facts = SVerseServiceRecord::DescribeFacts(*Model);+ auto Fact = [&Facts](const TCHAR* Key) { const FText* T = Facts.Find(Key); return T ? T->ToString() : FString(); };+ TestEqual(TEXT("rank"), Fact(TEXT("rank")), FString(TEXT("Lieutenant")));+ TestEqual(TEXT("level"), Fact(TEXT("level")), FString(TEXT("14")));+ TestEqual(TEXT("next rank"), Fact(TEXT("next")), FString(TEXT("Senior Lieutenant")));+ TestEqual(TEXT("sets"), Fact(TEXT("sets")), FString(TEXT("12")));+ TestEqual(TEXT("won / lost"), Fact(TEXT("won_lost")), FString(TEXT("7 / 5")));+ // The value itself, then the text: two decimals with a point in every culture, as the web's toFixed(2).+ TestTrue(TEXT("K/D value"), FMath::IsNearlyEqual(Model->Duels().KillDeathRatio(), 1.185f, 0.01f));+ TestEqual(TEXT("K/D"), Fact(TEXT("kd")), FString(TEXT("1.19")));+ {+ // A culture with a decimal comma must not change the record's characters.+ const FString Previous = FInternationalization::Get().GetCurrentCulture()->GetName();+ FInternationalization::Get().SetCurrentCulture(TEXT("de"));+ const TMap<FString, FText> German = SVerseServiceRecord::DescribeFacts(*Model);+ FInternationalization::Get().SetCurrentCulture(Previous);+ const FText* Kd = German.Find(TEXT("kd"));+ TestEqual(TEXT("K/D under de"), Kd ? Kd->ToString() : FString(), FString(TEXT("1.19")));+ }+ TestEqual(TEXT("figure grouping"), SVerseServiceRecord::FormatFigure(1234567), FString(TEXT("1 234 567")));+ TestEqual(TEXT("figure small"), SVerseServiceRecord::FormatFigure(999), FString(TEXT("999")));+ TestEqual(TEXT("figure negative"), SVerseServiceRecord::FormatFigure(-1234), FString(TEXT("-1 234")));+ TestEqual(TEXT("headshots"), Fact(TEXT("headshots")), FString(TEXT("31")));+ TestEqual(TEXT("finishers"), Fact(TEXT("finishers")), FString(TEXT("4")));+ TestEqual(TEXT("best streak"), Fact(TEXT("best_streak")), FString(TEXT("6")));++ PlayAwards(*Root, *Model);+ Facts = SVerseServiceRecord::DescribeFacts(*Model);+ TestEqual(TEXT("live: level after the award"), Fact(TEXT("level")), FString(TEXT("15")));++ FVersePromotion Promotion;+ Promotion.Level = 21;+ Promotion.PreviousLevel = 20;+ Promotion.RankId = TEXT("commander");+ Promotion.PreviousRankId = TEXT("senior_lieutenant");+ if (!FSlateApplication::IsInitialized())+ {+ AddInfo(TEXT("no Slate application in this run; the widgets themselves are not built"));+ return true;+ }+ TSharedRef<SVerseServiceRecord> View = SNew(SVerseServiceRecord, Model);+ TestTrue(TEXT("record widget builds"), View->GetChildren()->Num() > 0);+ TSharedRef<SVersePromotionNotice> Notice = SNew(SVersePromotionNotice, Promotion);+ TestEqual(TEXT("new rank headline"), Notice->Headline().ToString(), FString(TEXT("PROMOTED")));+ TestEqual(TEXT("new rank detail"), Notice->Detail().ToString(), FString(TEXT("Commander, level 21")));+ return true;+}++#endif // WITH_DEV_AUTOMATION_TESTSdiff --git a/unreal/Verse/Source/VerseUI/Private/ServiceRecord/VerseServiceRecordModel.cpp b/unreal/Verse/Source/VerseUI/Private/ServiceRecord/VerseServiceRecordModel.cppnew file mode 100644index 0000000000..831157df48--- /dev/null+++ b/unreal/Verse/Source/VerseUI/Private/ServiceRecord/VerseServiceRecordModel.cpp@@ -0,0 +1,265 @@+#include "ServiceRecord/VerseServiceRecordModel.h"+#include "Dom/JsonObject.h"++#include "VerseLog.h"++namespace+{+ int64 NumberOr(const FJsonObject& Object, const TCHAR* Field, int64 Fallback)+ {+ double Value = 0.0;+ return Object.TryGetNumberField(Field, Value) && FMath::IsFinite(Value) ? int64(Value) : Fallback;+ }++ FString StringOr(const FJsonObject& Object, const TCHAR* Field)+ {+ FString Value;+ return Object.TryGetStringField(Field, Value) ? Value : FString();+ }++ int32 Count(const FJsonObject& Object, const TCHAR* Field)+ {+ return int32(FMath::Clamp<int64>(NumberOr(Object, Field, 0), 0, MAX_int32));+ }+}++int64 FVerseServiceRecordModel::XpToNext(int32 Level)+{+ if (Level >= MaxLevel)+ {+ return 0;+ }+ const int32 L = FMath::Max(1, Level);+ const double Raw = 40.0 + 25.0 * FMath::Pow(double(L - 1), 1.1);+ return int64(FMath::RoundToDouble(Raw / 5.0) * 5.0);+}++int64 FVerseServiceRecordModel::TotalXpForLevel(int32 Level)+{+ const int32 Target = FMath::Clamp(Level, 1, MaxLevel);+ int64 Total = 0;+ for (int32 Step = 1; Step < Target; ++Step)+ {+ Total += XpToNext(Step);+ }+ return Total;+}++int32 FVerseServiceRecordModel::LevelForXp(int64 TotalXp)+{+ int32 Level = 1;+ int64 Remaining = FMath::Max<int64>(0, TotalXp);+ while (Level < MaxLevel)+ {+ const int64 Need = XpToNext(Level);+ if (Remaining < Need)+ {+ break;+ }+ Remaining -= Need;+ ++Level;+ }+ return Level;+}++const TArray<FVerseRankRow>& FVerseServiceRecordModel::Ladder()+{+ // VERSE_RANK_LADDER_BEGIN (read by tests/unit/progression/test_duel_parity.py)+ static const TArray<FVerseRankRow> Rows = {+ {TEXT("recruit"), 1, TEXT("deck")},+ {TEXT("deckhand"), 3, TEXT("deck")},+ {TEXT("technician"), 5, TEXT("deck")},+ {TEXT("senior_technician"), 8, TEXT("deck")},+ {TEXT("ensign"), 11, TEXT("line")},+ {TEXT("lieutenant"), 14, TEXT("line")},+ {TEXT("senior_lieutenant"), 17, TEXT("line")},+ {TEXT("commander"), 21, TEXT("line")},+ {TEXT("captain"), 25, TEXT("line")},+ {TEXT("line_captain"), 29, TEXT("command")},+ {TEXT("commodore"), 33, TEXT("command")},+ {TEXT("rear_admiral"), 37, TEXT("flag")},+ {TEXT("vice_admiral"), 41, TEXT("flag")},+ {TEXT("admiral"), 45, TEXT("flag")},+ {TEXT("fleet_admiral"), 50, TEXT("flag")},+ };+ // VERSE_RANK_LADDER_END+ return Rows;+}++const FVerseRankRow& FVerseServiceRecordModel::RankFor(int32 Level)+{+ const TArray<FVerseRankRow>& Rows = Ladder();+ const FVerseRankRow* Held = &Rows[0];+ for (const FVerseRankRow& Row : Rows)+ {+ if (Level >= Row.Level)+ {+ Held = &Row;+ }+ }+ return *Held;+}++const FVerseRankRow* FVerseServiceRecordModel::NextRank(int32 Level)+{+ for (const FVerseRankRow& Row : Ladder())+ {+ if (Row.Level > Level)+ {+ return &Row;+ }+ }+ return nullptr;+}++void FVerseServiceRecordModel::SetCommander(int32 Level, int64 TotalXp, const FString& Title)+{+ Record.Level = FMath::Clamp(Level, 1, MaxLevel);+ Record.TotalXp = FMath::Max<int64>(0, TotalXp);+ Record.ForNext = XpToNext(Record.Level);+ // The server's level wins; the bar is placed inside it even when the numbers disagree.+ Record.IntoLevel = FMath::Clamp<int64>(Record.TotalXp - TotalXpForLevel(Record.Level), 0, Record.ForNext);+ Record.Title = Title;+}++bool FVerseServiceRecordModel::ApplySnapshot(const FJsonObject& Data)+{+ const TArray<TSharedPtr<FJsonValue>>* Subjects = nullptr;+ if (!Data.TryGetArrayField(TEXT("subjects"), Subjects) || !Subjects)+ {+ return false;+ }+ for (const TSharedPtr<FJsonValue>& Value : *Subjects)+ {+ const TSharedPtr<FJsonObject>* Subject = nullptr;+ FString Id;+ if (Value.IsValid() && Value->TryGetObject(Subject) && Subject && (*Subject)->TryGetStringField(TEXT("subject_id"), Id) && Id == TEXT("person"))+ {+ const FJsonObject& Person = **Subject;+ SetCommander(int32(NumberOr(Person, TEXT("level"), 1)), NumberOr(Person, TEXT("total_xp"), 0), StringOr(Person, TEXT("title")));+ const int64 Into = NumberOr(Person, TEXT("into_level"), -1);+ const int64 ForNext = NumberOr(Person, TEXT("for_next"), -1);+ if (Into >= 0 && ForNext >= 0)+ {+ Record.IntoLevel = Into;+ Record.ForNext = ForNext;+ }+ }+ }+ Latest = FMath::Max(Latest, NumberOr(Data, TEXT("latest_seq"), 0));+ Told = FMath::Max(Told, NumberOr(Data, TEXT("told_seq"), 0));+ const TSharedPtr<FJsonObject>* Stats = nullptr;+ if (Data.TryGetObjectField(TEXT("duel_stats"), Stats) && Stats)+ {+ ApplyDuelStats(**Stats);+ }+ bHasSnapshot = true;+ DropToldPromotions();+ OnChanged.Broadcast();+ return true;+}++bool FVerseServiceRecordModel::ApplyAwarded(const FJsonObject& Data)+{+ FString Subject;+ if (!Data.TryGetStringField(TEXT("subject_id"), Subject) || Subject != TEXT("person"))+ {+ return false; // officers and the drone have their own surfaces+ }+ const int64 Seq = NumberOr(Data, TEXT("seq"), 0);+ const int32 Level = int32(NumberOr(Data, TEXT("level"), Record.Level));+ const int32 Previous = int32(NumberOr(Data, TEXT("previous_level"), Level));+ SetCommander(Level, NumberOr(Data, TEXT("total_xp"), Record.TotalXp), StringOr(Data, TEXT("title")));+ Latest = FMath::Max(Latest, Seq);++ bool bQueued = false;+ const bool bKnown = Promotions.ContainsByPredicate([Seq](const FVersePromotion& P) { return P.Seq == Seq; });+ if (Level > Previous && Seq > Told && !bKnown)+ {+ FVersePromotion Promotion;+ Promotion.Seq = Seq;+ Promotion.Level = Level;+ Promotion.PreviousLevel = Previous;+ Promotion.RankId = RankFor(Level).Id;+ Promotion.PreviousRankId = RankFor(Previous).Id;+ const TArray<TSharedPtr<FJsonValue>>* Unlocked = nullptr;+ if (Data.TryGetArrayField(TEXT("unlocked"), Unlocked) && Unlocked)+ {+ for (const TSharedPtr<FJsonValue>& Item : *Unlocked)+ {+ FString Id;+ if (Item.IsValid() && Item->TryGetString(Id))+ {+ Promotion.Unlocked.Add(Id);+ }+ }+ }+ Promotions.Add(MoveTemp(Promotion));+ bQueued = true;+ }+ OnChanged.Broadcast();+ return bQueued;+}++void FVerseServiceRecordModel::ApplyDuelStats(const FJsonObject& Stats)+{+ FVerseDuelTotals Next;+ Next.Matches = Count(Stats, TEXT("matches"));+ Next.Wins = Count(Stats, TEXT("wins"));+ Next.Losses = Count(Stats, TEXT("losses"));+ Next.Unfinished = Count(Stats, TEXT("unfinished"));+ Next.Kills = Count(Stats, TEXT("kills"));+ Next.Deaths = Count(Stats, TEXT("deaths"));+ Next.Headshots = Count(Stats, TEXT("headshots"));+ Next.Finishers = Count(Stats, TEXT("finishers"));+ Next.BestStreak = Count(Stats, TEXT("best_streak"));+ const TSharedPtr<FJsonObject>* Tiers = nullptr;+ if (Stats.TryGetObjectField(TEXT("by_tier"), Tiers) && Tiers)+ {+ for (const TPair<FString, TSharedPtr<FJsonValue>>& Pair : (*Tiers)->Values)+ {+ const TSharedPtr<FJsonObject>* Row = nullptr;+ if (Pair.Value.IsValid() && Pair.Value->TryGetObject(Row) && Row)+ {+ Next.ByTier.Add(Pair.Key, FIntPoint(Count(**Row, TEXT("wins")), Count(**Row, TEXT("losses"))));+ }+ }+ }+ DuelTotals = MoveTemp(Next);+ OnChanged.Broadcast();+}++const FVersePromotion* FVerseServiceRecordModel::PendingPromotion() const+{+ return Promotions.Num() > 0 ? &Promotions[0] : nullptr;+}++void FVerseServiceRecordModel::MarkPromotionShown()+{+ if (Promotions.Num() == 0)+ {+ return;+ }+ const int64 Seq = Promotions[0].Seq;+ Promotions.RemoveAt(0);+ if (Seq > Told)+ {+ Told = Seq;+ if (SendTold)+ {+ SendTold(Seq);+ }+ else+ {+ UE_LOG(LogVerseUI, Verbose, TEXT("service record: promotion %lld shown with no bridge to tell"), Seq);+ }+ }+ DropToldPromotions();+ OnChanged.Broadcast();+}++void FVerseServiceRecordModel::DropToldPromotions()+{+ // Shown elsewhere (or earlier): told_seq covers it, so it is never shown again.+ Promotions.RemoveAll([this](const FVersePromotion& P) { return P.Seq <= Told; });+}diff --git a/unreal/Verse/Source/VerseUI/Private/ServiceRecord/VerseServiceRecordSubsystem.cpp b/unreal/Verse/Source/VerseUI/Private/ServiceRecord/VerseServiceRecordSubsystem.cppnew file mode 100644index 0000000000..408cbe9a97--- /dev/null+++ b/unreal/Verse/Source/VerseUI/Private/ServiceRecord/VerseServiceRecordSubsystem.cpp@@ -0,0 +1,184 @@+#include "ServiceRecord/VerseServiceRecordSubsystem.h"+#include "Dom/JsonObject.h"++#include "Engine/Engine.h"+#include "Engine/GameInstance.h"+#include "Engine/GameViewportClient.h"+#include "HAL/IConsoleManager.h"+#include "ServiceRecord/SVerseServiceRecord.h"+#include "VerseLog.h"+#include "Widgets/Layout/SBox.h"++namespace+{+ constexpr int32 RecordZOrder = 40;+ constexpr int32 NoticeZOrder = 45;++ FAutoConsoleCommandWithWorld ToggleCommand(+ TEXT("Verse.UI.ServiceRecord"),+ TEXT("Open or close the service record (commander rank, level, XP and duel record)."),+ FConsoleCommandWithWorldDelegate::CreateLambda([](UWorld* World)+ {+ UGameInstance* Instance = World ? World->GetGameInstance() : nullptr;+ if (UVerseServiceRecordSubsystem* Record = Instance ? Instance->GetSubsystem<UVerseServiceRecordSubsystem>() : nullptr)+ {+ Record->ToggleRecord();+ }+ }));+}++// ------------------------------------------------------------------ presenter++FVersePromotionPresenter::FVersePromotionPresenter(TSharedRef<FVerseServiceRecordModel> InModel,+ TFunction<bool(const FVersePromotion&)> InShow, TFunction<void()> InHide)+ : Model(InModel)+ , Show(MoveTemp(InShow))+ , Hide(MoveTemp(InHide))+{+}++void FVersePromotionPresenter::Tick(float DeltaSeconds)+{+ const FVersePromotion* Next = Model->PendingPromotion();+ if (bShowing)+ {+ // Told elsewhere while on screen (the web app showed it): take it down without telling.+ if (!Next || Next->Seq != ShowingSeq)+ {+ Hide();+ bShowing = false;+ return;+ }+ Elapsed += DeltaSeconds;+ if (Elapsed >= NoticeSeconds)+ {+ Hide();+ bShowing = false;+ Model->MarkPromotionShown();+ }+ return;+ }+ if (Next && Show(*Next))+ {+ bShowing = true;+ ShowingSeq = Next->Seq;+ Elapsed = 0.f;+ }+}++// ------------------------------------------------------------------ subsystem++void UVerseServiceRecordSubsystem::Initialize(FSubsystemCollectionBase& Collection)+{+ Super::Initialize(Collection);+ Model = MakeShared<FVerseServiceRecordModel>();+ TWeakObjectPtr<UVerseServiceRecordSubsystem> Weak(this);+ Presenter = MakeUnique<FVersePromotionPresenter>(Model.ToSharedRef(),+ [Weak](const FVersePromotion& Promotion) { return Weak.IsValid() && Weak->ShowNotice(Promotion); },+ [Weak]() { if (Weak.IsValid()) { Weak->HideNotice(); } });+ TickHandle = FTSTicker::GetCoreTicker().AddTicker(FTickerDelegate::CreateUObject(this, &UVerseServiceRecordSubsystem::Tick), 0.1f);+}++void UVerseServiceRecordSubsystem::Deinitialize()+{+ FTSTicker::GetCoreTicker().RemoveTicker(TickHandle);+ CloseRecord();+ HideNotice();+ Presenter.Reset();+ Super::Deinitialize();+}++bool UVerseServiceRecordSubsystem::HandleBridgeMessage(const FString& Type, const FJsonObject& Data)+{+ if (Type == TEXT("progression.snapshot"))+ {+ return Model->ApplySnapshot(Data);+ }+ if (Type == TEXT("progression.awarded"))+ {+ Model->ApplyAwarded(Data);+ return true;+ }+ return false;+}++void UVerseServiceRecordSubsystem::SetToldSender(TFunction<void(int64 Seq)> Sender)+{+ Model->SendTold = MoveTemp(Sender);+}++bool UVerseServiceRecordSubsystem::Tick(float DeltaSeconds)+{+ if (Presenter)+ {+ Presenter->Tick(DeltaSeconds);+ }+ return true;+}++void UVerseServiceRecordSubsystem::OpenRecord()+{+ UGameViewportClient* Viewport = GetGameInstance() ? GetGameInstance()->GetGameViewportClient() : nullptr;+ if (RecordWidget.IsValid() || !Viewport)+ {+ return;+ }+ RecordWidget = SNew(SBox)+ .HAlign(HAlign_Center)+ .VAlign(VAlign_Center)+ [+ SNew(SVerseServiceRecord, Model.ToSharedRef())+ ];+ Viewport->AddViewportWidgetContent(RecordWidget.ToSharedRef(), RecordZOrder);+}++void UVerseServiceRecordSubsystem::CloseRecord()+{+ if (!RecordWidget.IsValid())+ {+ return;+ }+ if (UGameViewportClient* Viewport = GetGameInstance() ? GetGameInstance()->GetGameViewportClient() : nullptr)+ {+ Viewport->RemoveViewportWidgetContent(RecordWidget.ToSharedRef());+ }+ RecordWidget.Reset();+}++void UVerseServiceRecordSubsystem::ToggleRecord()+{+ IsRecordOpen() ? CloseRecord() : OpenRecord();+}++bool UVerseServiceRecordSubsystem::ShowNotice(const FVersePromotion& Promotion)+{+ UGameViewportClient* Viewport = GetGameInstance() ? GetGameInstance()->GetGameViewportClient() : nullptr;+ if (!Viewport)+ {+ return false; // no screen: the promotion waits, and nothing is told+ }+ HideNotice();+ NoticeWidget = SNew(SBox)+ .HAlign(HAlign_Center)+ .VAlign(VAlign_Top)+ .Padding(FMargin(0.f, 72.f, 0.f, 0.f))+ [+ SNew(SVersePromotionNotice, Promotion)+ ];+ Viewport->AddViewportWidgetContent(NoticeWidget.ToSharedRef(), NoticeZOrder);+ UE_LOG(LogVerseUI, Log, TEXT("service record: promotion %lld to level %d on screen"), Promotion.Seq, Promotion.Level);+ return true;+}++void UVerseServiceRecordSubsystem::HideNotice()+{+ if (!NoticeWidget.IsValid())+ {+ return;+ }+ if (UGameViewportClient* Viewport = GetGameInstance() ? GetGameInstance()->GetGameViewportClient() : nullptr)+ {+ Viewport->RemoveViewportWidgetContent(NoticeWidget.ToSharedRef());+ }+ NoticeWidget.Reset();+}diff --git a/unreal/Verse/Source/VerseUI/Public/ServiceRecord/VerseServiceRecordModel.h b/unreal/Verse/Source/VerseUI/Public/ServiceRecord/VerseServiceRecordModel.hnew file mode 100644index 0000000000..271677d96d--- /dev/null+++ b/unreal/Verse/Source/VerseUI/Public/ServiceRecord/VerseServiceRecordModel.h@@ -0,0 +1,121 @@+#pragma once++#include "CoreMinimal.h"+class FJsonObject;+#include "Templates/Function.h"++// The Unreal service record's data (WP21.7): the commander's level, XP and rank, the duel totals,+// and the promotion notices still to show. Fed from the bridge's progression topic+// (bridge-protocol.md 9, 10, 14): `progression.snapshot` and `progression.awarded` in,+// `progression.told {seq}` out once a promotion was on screen, so it is never shown twice.+// The rulebook numbers (level curve, rank ladder) are the server's (dodaios/progression/rules.py);+// tests/unit/progression/test_duel_parity.py holds this copy to them.++/** One step of the fleet's rank ladder. */+struct FVerseRankRow+{+ FName Id;+ int32 Level = 1;+ FName Tier;+};++/** Duel totals as `duel_stats` carries them. */+struct FVerseDuelTotals+{+ int32 Matches = 0;+ int32 Wins = 0;+ int32 Losses = 0;+ int32 Unfinished = 0;+ int32 Kills = 0;+ int32 Deaths = 0;+ int32 Headshots = 0;+ int32 Finishers = 0;+ int32 BestStreak = 0;+ /** Tier -> (wins, losses). */+ TMap<FString, FIntPoint> ByTier;++ /** Kills per death; the kills themselves with no deaths yet. */+ float KillDeathRatio() const { return Deaths > 0 ? float(Kills) / float(Deaths) : float(Kills); }+};++/** The commander's standing. */+struct FVerseCommanderRecord+{+ int32 Level = 1;+ int64 TotalXp = 0;+ int64 IntoLevel = 0;+ int64 ForNext = 0;+ FString Title;+};++/** A level-up of the commander the person has not seen yet. */+struct FVersePromotion+{+ int64 Seq = 0;+ int32 Level = 1;+ int32 PreviousLevel = 1;+ FName RankId;+ FName PreviousRankId;+ TArray<FString> Unlocked;++ /** True when the level-up also reached a new rank (not only a level). */+ bool IsNewRank() const { return RankId != PreviousRankId; }+};++class VERSEUI_API FVerseServiceRecordModel+{+public:+ static constexpr int32 MaxLevel = 50;++ /** XP from Level to the next (0 at the cap); rules.py xp_to_next. */+ static int64 XpToNext(int32 Level);+ /** Total XP at which Level starts; rules.py total_xp_for_level. */+ static int64 TotalXpForLevel(int32 Level);+ static int32 LevelForXp(int64 TotalXp);++ /** The rank ladder, lowest first; rules.py RANKS. */+ static const TArray<FVerseRankRow>& Ladder();+ static const FVerseRankRow& RankFor(int32 Level);+ /** The next rank above Level, or nullptr at the top. */+ static const FVerseRankRow* NextRank(int32 Level);++ /** `progression.snapshot` data. False when it is not one (nothing changes). */+ bool ApplySnapshot(const FJsonObject& Data);+ /** `progression.awarded` data. True when it queued a promotion notice. */+ bool ApplyAwarded(const FJsonObject& Data);+ /** The `duel_stats` object of a snapshot or of a duel.result reply. */+ void ApplyDuelStats(const FJsonObject& Stats);++ const FVerseCommanderRecord& Commander() const { return Record; }+ const FVerseDuelTotals& Duels() const { return DuelTotals; }+ bool HasSnapshot() const { return bHasSnapshot; }+ int64 LatestSeq() const { return Latest; }+ int64 ToldSeq() const { return Told; }++ /** The oldest promotion not yet shown, or nullptr. */+ const FVersePromotion* PendingPromotion() const;+ int32 NumPendingPromotions() const { return Promotions.Num(); }++ /**+ * The pending promotion has been on screen: drop it and report `progression.told` with its+ * seq through SendTold, once per seq.+ */+ void MarkPromotionShown();++ /** Sends `progression.told {seq}` (the bridge client; a test's recorder). */+ TFunction<void(int64 Seq)> SendTold;++ /** Fired after every change, for the views. */+ FSimpleMulticastDelegate OnChanged;++private:+ void SetCommander(int32 Level, int64 TotalXp, const FString& Title);+ void DropToldPromotions();++ FVerseCommanderRecord Record;+ FVerseDuelTotals DuelTotals;+ TArray<FVersePromotion> Promotions;+ int64 Latest = 0;+ int64 Told = 0;+ bool bHasSnapshot = false;+};diff --git a/unreal/Verse/Source/VerseUI/Public/ServiceRecord/VerseServiceRecordSubsystem.h b/unreal/Verse/Source/VerseUI/Public/ServiceRecord/VerseServiceRecordSubsystem.hnew file mode 100644index 0000000000..170dccf45b--- /dev/null+++ b/unreal/Verse/Source/VerseUI/Public/ServiceRecord/VerseServiceRecordSubsystem.h@@ -0,0 +1,76 @@+#pragma once++#include "Containers/Ticker.h"+#include "CoreMinimal.h"+#include "ServiceRecord/VerseServiceRecordModel.h"+#include "Subsystems/GameInstanceSubsystem.h"++#include "VerseServiceRecordSubsystem.generated.h"++class SWidget;++/**+ * Shows the oldest unseen promotion for a while, then tells the model it was shown (which sends+ * `progression.told`). Show and Hide put the notice on screen; with no screen it waits.+ */+class VERSEUI_API FVersePromotionPresenter+{+public:+ /** How long a notice stays up. */+ static constexpr float NoticeSeconds = 3.0f;++ FVersePromotionPresenter(TSharedRef<FVerseServiceRecordModel> InModel,+ TFunction<bool(const FVersePromotion&)> InShow, TFunction<void()> InHide);++ /** Advance by DeltaSeconds: start the next notice, or end the one on screen. */+ void Tick(float DeltaSeconds);++ bool IsShowing() const { return bShowing; }++private:+ TSharedRef<FVerseServiceRecordModel> Model;+ TFunction<bool(const FVersePromotion&)> Show;+ TFunction<void()> Hide;+ bool bShowing = false;+ int64 ShowingSeq = 0;+ float Elapsed = 0.f;+};++/**+ * The service record of the game instance (WP21.7): the model the bridge's progression topic+ * feeds, the record panel and the promotion notice on the game viewport. The bridge client+ * (WP17) calls HandleBridgeMessage for `progression.snapshot` / `progression.awarded` and gives+ * SetToldSender its `progression.told` sender. Console: `Verse.UI.ServiceRecord` toggles the panel.+ */+UCLASS()+class VERSEUI_API UVerseServiceRecordSubsystem : public UGameInstanceSubsystem+{+ GENERATED_BODY()++public:+ virtual void Initialize(FSubsystemCollectionBase& Collection) override;+ virtual void Deinitialize() override;++ TSharedRef<FVerseServiceRecordModel> GetModel() const { return Model.ToSharedRef(); }++ /** One frame of the progression topic; false when the type is not one it reads. */+ bool HandleBridgeMessage(const FString& Type, const FJsonObject& Data);++ void SetToldSender(TFunction<void(int64 Seq)> Sender);++ void OpenRecord();+ void CloseRecord();+ void ToggleRecord();+ bool IsRecordOpen() const { return RecordWidget.IsValid(); }++private:+ bool Tick(float DeltaSeconds);+ bool ShowNotice(const FVersePromotion& Promotion);+ void HideNotice();++ TSharedPtr<FVerseServiceRecordModel> Model;+ TUniquePtr<FVersePromotionPresenter> Presenter;+ TSharedPtr<SWidget> RecordWidget;+ TSharedPtr<SWidget> NoticeWidget;+ FTSTicker::FDelegateHandle TickHandle;+};diff --git a/unreal/Verse/Source/VerseUI/VerseUI.Build.cs b/unreal/Verse/Source/VerseUI/VerseUI.Build.csindex 650ebf81aa..6cc4046799 100644--- a/unreal/Verse/Source/VerseUI/VerseUI.Build.cs+++ b/unreal/Verse/Source/VerseUI/VerseUI.Build.cs@@ -9,5 +9,7 @@ public class VerseUI : ModuleRulesPCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine" });PublicDependencyModuleNames.AddRange(new string[] { "VerseCore", "VerseBridge", "VerseCombat", "VerseCrew", "VerseDecks" });+ // Json: station command data; Slate: the plain station overlay until WP18's UI root (WP16, request to the integration owner).+ PrivateDependencyModuleNames.AddRange(new string[] { "Json", "Slate", "SlateCore" });}}