Skip to content

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.

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.py
new file mode 100644
index 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 out
diff --git a/dodaios/progression/rules.py b/dodaios/progression/rules.py
index 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
+
+
# ------------------------------------------------------------------ ranks
RankTier = Literal["deck", "line", "command", "flag"]
diff --git a/dodaios/progression/service.py b/dodaios/progression/service.py
index 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 annotations
import asyncio
+import dataclasses
import logging
+import threading
import time
-from collections.abc import Callable
+from collections.abc import Callable, Mapping
from datetime import datetime
from pathlib import Path
from typing import Any
+from .duel_stats import DuelResult, DuelResultError, DuelStatsStore, parse_duel_result
from .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, ProgressionStore
log = 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 = False
self._bus = bus
self._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 handlers
async 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.ts
index 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.tsx
index 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.tsx
new file mode 100644
index 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.json
index 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.json
index 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.json
index 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.json
index 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.json
index 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.py
index 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 is
the 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.py
new file mode 100644
index 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.py
new file mode 100644
index 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() == 0
diff --git a/tests/unit/progression/test_duel_service.py b/tests/unit/progression/test_duel_service.py
new file mode 100644
index 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.py
new file mode 100644
index 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.py
index 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.py
index 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.h
new file mode 100644
index 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_TESTS
diff --git a/unreal/Verse/Source/VerseBridge/Private/Duel/Tests/VerseDuelReporterTest.cpp b/unreal/Verse/Source/VerseBridge/Private/Duel/Tests/VerseDuelReporterTest.cpp
new file mode 100644
index 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_TESTS
diff --git a/unreal/Verse/Source/VerseBridge/Private/Duel/VerseDuelReporter.cpp b/unreal/Verse/Source/VerseBridge/Private/Duel/VerseDuelReporter.cpp
new file mode 100644
index 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.h
new file mode 100644
index 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.cpp
new file mode 100644
index 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.h
new file mode 100644
index 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.cpp
new file mode 100644
index 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.h
new file mode 100644
index 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.h
new file mode 100644
index 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.cs
index 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 : ModuleRules
PCHUsage = 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.cpp
new file mode 100644
index 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_NAMESPACE
diff --git a/unreal/Verse/Source/VerseUI/Private/ServiceRecord/SVerseServiceRecord.h b/unreal/Verse/Source/VerseUI/Private/ServiceRecord/SVerseServiceRecord.h
new file mode 100644
index 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.cpp
new file mode 100644
index 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_TESTS
diff --git a/unreal/Verse/Source/VerseUI/Private/ServiceRecord/VerseServiceRecordModel.cpp b/unreal/Verse/Source/VerseUI/Private/ServiceRecord/VerseServiceRecordModel.cpp
new file mode 100644
index 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.cpp
new file mode 100644
index 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.h
new file mode 100644
index 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.h
new file mode 100644
index 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.cs
index 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 : ModuleRules
PCHUsage = 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" });
}
}