# Mode Catalog, Training & Replay

```mermaid
stateDiagram-v2
  [*] --> Browsing
  Browsing --> Configuring: mode ruleset roster and options selected
  Configuring --> Loading: load plan and content versions validate
  Configuring --> Refused: entitlement platform or compatibility failure
  Loading --> Active: deterministic session begins
  Active --> TrainingPaused: training tool or replay takeover
  TrainingPaused --> Active
  Active --> Completed: mode terminal condition
  Completed --> Recording: replay results and progression commit
  Recording --> Theater: compatible replay available
  Theater --> Active: governed replay takeover or rematch
  Refused --> [*]
```

Mode configuration, content loading, deterministic play, training control,
result settlement, replay publication, and takeover are distinct states with
different compatibility and recovery requirements.

This is the player-facing tour of _where V2 sends you when you press Start_: the
arcade ladders and story campaigns, the booker sims and card-collector seasons,
the bonus stages and arcade cabinets, the frame-accurate practice lab, and the
replay theater that records every match as re-simulatable inputs. V2's pitch is
that one fighting game can host fifty-odd distinct experiences without any of
them forking the deterministic match loop — a CPU arcade run, a 30-entrant Royal
Rumble, and a turn-based hex campaign all bottom out in the same simulation. The
seam that makes that work is a **registry of mode definitions** rather than
fifty hand-written game modes, and the companion architecture page,
[../architecture/game-modes-training-and-replay.md](../architecture/game-modes-training-and-replay.md),
explains the registry, the load-plan builder, and the replay codec on the engine
side. This page stays on the player's side of the menu: what each surface _is_,
what you actually do in it, and which parts are shipped C++ versus a named
target waiting on content. The two largest standalone modes — the Hades-style
roguelike, the 100-player Battle Royale, the world boss, karaoke, and the
signature live events — get their own page,
[./signature-events-and-standalone-modes.md](./signature-events-and-standalone-modes.md);
the moment-to-moment fight these modes all run is in
[./combat-systems-defense-and-game-feel.md](./combat-systems-defense-and-game-feel.md).
For the full feature scope this slots into, start at the hub:
[../V2_features.md](../V2_features.md).

## What ships, honestly

The **mode machinery is real, complete, and heavily tested**; the _content_ each
mode points at is mostly named-but-unbuilt. `UV2ModeRegistrySubsystem`
(`V2Modes/Public/V2ModeRegistrySubsystem.h`) implements registration,
validation, the load-plan builder, activation/deactivation, and a seven-state
lifecycle as ordinary C++ that compiles into the editor and runs headless under
automation. `FV2ModeCatalog::BuildDefaultModeDefinitions()` builds a fixed
roster of **52 canonical modes** (`Modes.Reserve(52)`,
`V2ModeCatalog.cpp:6287`+), and the per-mode content builders carry real domain
math — the arcade scoring evaluator, Royal Rumble entry scheduling, the MyGM
booking sim. The data behind it is enormous: `V2ModeTypes.h` is a 347 KB header
declaring 135 `enum class`es and 286 `USTRUCT`s. The single spec
`V2Tests/Automation/Modes.Module.spec.cpp` carries **705**
`TestTrue`/`TestEqual`/`TestNotNull` assertions over the registry and catalogue.

Four honest qualifications. **First**, the per-mode Game Feature plugins and
maps **do not exist on disk**: `MakeMode` synthesizes each definition's
`GameFeaturePluginURL` and `PrimaryMapPath` by convention, but a scan of
`V2/ue/Plugins` finds only **three** real `.uplugin` files (`V2AICommentary`,
`V2AdaptiveAI`, `V2AssetLinter`) and none named `V2Mode_*`. The nine tracked
`.uasset`s (eight region-variant data assets under `ue/Content/V2/Regions`, plus
one editor frame-data inspector) are not mode content — there are no shipped
fighter or stage binaries. These URLs are _target artifacts_ the registry can
plan against today and content production fills in later. **Second**, activation
**records the plan; it does not execute a GameFeature load** — it loads required
C++ modules for real through `FModuleManager`, but never calls
`UGameFeaturesSubsystem` or opens a level. **Third**, the training and replay
_tooling specs_ are real, validated C++ data contracts plus a native screen
class; the visual overlays they describe bind on the presentation side of the
sim/present split, which is the engine-integration boundary. **Fourth**, a
spec/code discrepancy on the replay budget: prose says "≤ 1 MB / 5-min," but the
shipped `FV2ReplayFileCompressionProfile` pins
`TargetMaxBytesPerMinute = 1048576` — 1 MiB _per minute_. The code is the
authority.

## The mode catalog

Every mode is one `FV2ModeDefinition` value carrying an id, a category
(`EV2ModeCategory`, 14 values), a network model (`EV2ModeNetworkModel`, 7
values), a save model (`EV2ModeSaveModel`, 8 values), player/spectator bands,
and a set of capability flags (`bSupportsReplay`,
`bSupportsRollbackDeterminism`, `bAvailableAtLaunch`). `IsValidDefinition()` is
a real gate, not a truthiness check — it rejects a definition with no id, no
design-section reference, an inverted player range, or an invalid dependency.
The catalog the player sees groups out of those 52 entries roughly like this:

- **Single-player core** — three Arcade variants (`Mode.Arcade.Classic`,
  `Mode.Arcade.Survivor`, `Mode.Arcade.GhostBattle`), the 12-chapter branching
  `Mode.Story`, and the MK-lineage Tower/Tournament/Survivor family. Arcade is a
  classic 8-fighter ladder with a mid-ladder rival, a sub-boss, a final boss,
  and per-fighter ending; each fight is graded by a genuine algorithm —
  `EvaluateArcadeFightScore` (`V2ModeCatalog.cpp:4778`) computes a real
  `TimeBonus = max(0, 6000 − seconds×40)`, a `+500` flawless bonus, a
  `min(combo×120, 2400)` combo bonus, and a flat `1500` finisher bonus over a
  `1000` base, not a hardcoded grade.
- **Single-player expansions** — the Krypt reward vault, the 100-player Battle
  Hub (`Mode.BattleHub`, `ClientServerHub`, 1–100 players), open-world
  `Mode.WorldTour`, the `Tekken Force` brawler, `Devil Within`, and the
  MK-lineage Konquest open-realm campaign.
- **Sports-entertainment** — `Mode.WWE.Universe` (a weekly-TV/PPV booker sim
  with a real auto-book pass), MyCAREER/MyRISE/MyGM, the UFC GOAT career, and
  `Mode.MyFaction`, a Bronze→Pink Diamond card collector. The MyGM economy
  carries a real `SalaryCapCents = 60000000` salary-cap constraint, not a flavor
  string.
- **Multi-fighter** — `Mode.RoyalRumble` (a 30-entrant timed-entry elimination
  ruleset, `BattleRoyal` category, up to 30 players), tag-team 2v2/3v3, and the
  three 100-player Battle Royale variants up to `Mode.BattleRoyale.Hybrid100`.
- **Strategy / street / specialty** — `Mode.ChessKombat` (`LocalTurnBased` hex
  tactics), the SoulCalibur strategy-RPG suite, Def Jam story and tag battle,
  and three specialty rulesets (boxing sim, Bushido Blade one-hit, MK one-hit
  tournament).

Requesting a mode runs it through `BuildModeLoadPlan`, which **refuses online
modes when the request disallows online services** — asking for `Mode.BattleHub`
offline never produces a plan, because its `ClientServerHub` model trips
`RequiresNetworkServices()`. That single predicate is the player-visible reason
a mode greys out when you're not signed in. The match-flow _variants_ (Local
Versus, Time/Score Attack, Wager, Handicap, First Blood, Best-of-N, LAN) are
lightweight wrappers around a standard fight, catalogued as design intent rather
than separate plugin directories.

## Bonus modes & mini-games

V2 honors the genre tradition of short, self-contained, non-canonical loops.
Each has its own scoring and leaderboard; none are ranked-eligible, and all are
reachable as **Battle Hub arcade cabinets**. The classics are here — SF II
car/barrel destruction and the Tekken Force board breaker as fixed-timer
object-clearing challenges, Tekken Bowl (ten-frame bowling with per-fighter
signature animation), Tekken Ball (charge-a-hit-to-raise-ball-damage
volleyball), MK Test Your Luck's random modifier roll, the SC Tower of Lost
Souls floor-climb, Boss Rush with an HP-carry-over option, and King-of-the-Hill
/ Endless Versus winner-stays rotation.

The one bonus surface that lives as **shipped external data** is the arcade
mini-game suite. `V2/balance/modes/arcade-mini-game-suite.json` (schema
`v2.modes.arcade-mini-game-suite-data.v1`, section 133) enumerates **eight
cabinets** — Pinball, Air Hockey, Mini-Golf, Darts, Pool/Billiards, Cooking,
Photo Tournament, Tekken Bowl — each with its real authored parameters
(Pinball's faction-themed playfields, bumpers/ramps/flippers/jackpot, multiball,
controller tilt; Mini-Golf's 18- and 9-hole counts with authored hazards and a
community course editor). Those eight match `EV2ArcadeMiniGameSuiteKind`
one-for-one, and `BuildDefaultArcadeMiniGameSuiteCatalog()` is the validated
runtime mirror. The cabinet economy is data too: `coinInputCostFighterCoins: 1`,
with free play for ambassadors and pro players, and a per-cabinet leaderboard
granting cosmetic top-N rewards. The playable cabinets themselves — the actual
pinball physics — are the named-but-unbuilt content layer; the _suite
definition, economy, and scoring contract_ are real and tested. Unlocks come via
Krypt chests, Tower clears, or seasonal events, and any un-earned bonus mode can
be made default-available as an accessibility accommodation rather than gated
behind grind.

## Training tools — a first-class product surface

Training is not a separate engine; it is the **same deterministic simulation as
a live match, with non-deterministic tooling layered on the presentation side**
— overlays attach to `FV2PresentWorld`, never to the integer-frame
`FV2SimWorld`, so determinism is preserved by construction (see the combat and
netcode pages). The contract for the whole workspace is one validated struct,
`FV2TrainingModeToolingSpec` (`V2UI/Public/V2UITypes.h:16614`), surfaced by the
native `UV2TrainingToolsScreen`, with `BuildDefaultTrainingModeToolingSpec()`
(`V2UIConfigAsset.cpp:6873`) authoring the shipped defaults and `IsValidSpec()`
gating them. This is real C++: `HasRequiredToolCoverage()`
(`V2UITypes.cpp:21720`) **fails the spec unless all eight rulesets, all ten
specialized trainers, and all four range visualizers are present**, and the
top-level flags `bFrameAccurateSimulation`, `bLosslessOnlineRulesParity`,
`bReducedMotionSafe`, and `bGameplayInertUI` are each required to pass.

**Dummy programming** (`FV2TrainingDummyProgrammingSpec`) is the heart of it: a
state set (Stand / Crouch / Jump), six block modes (Auto / All / FirstHit / None
/ Random / AfterFirstHit), throw-tech toggle, six wakeup actions (None /
Reversal / Random / GetUpAttack / RollForward / RollBack), five behavior presets
(Aggressive / Defensive / ThrowHappy / ReversalOnWake / Random), three
frame-step modes (one frame / N frames / until-next-hit), and an **8-slot action
recorder** — each slot clamped to 1–60 seconds, with Loop / Random / Sequential
playback and a trigger on hit / block / whiff / neutral. There are 10 lab save
slots per fighter, an always-counter-hit toggle, shareable lab-setup codes, and
step-simulation-while-paused.

**Display tools** (`FV2TrainingDisplayToolsSpec`) give the hitbox/hurtbox viewer
color-coded by the same vulnerability bitmask the combat resolver reads, a
12-frame hit-active region trace, and a frame-data overlay surfacing
startup/active/recovery, on-hit/on-block advantage, and juggle proration. Input
display runs on both sides with frame numbers, negative-edge markers, and
motion-recognition highlights; the readouts add per-hit damage, the running
scaling factor, numeric ruleset meters, hitstun/blockstun countdown bars, a
reset-opportunity flag, and a whiff-punish window flash. **Stage/position**
offers seven presets (Corner / MidScreen / BehindOpponent / Wallsplat /
Knockdown / JumpArc / Custom), five reset triggers, and
Full/Half/OnePixel/Custom HP and meter resets with reset-on-first-hit auto-loop
for execution drills. **Combo tools** expose 0.25×/0.5×/0.75× slow-mo replay,
auto-loop on success, length/damage limit indicators, best-combo trackers _per
character and per starter_, a stored personal best, and a frame-perfect
just-frame marker.

Five tooling sub-systems make training a full product surface. **Replay Takeover
from training** saves the last match as a lab scenario preserving both fighters'
state, loads your own and cloud replays, pauses at any frame, and lets you take
over either side and continue the match. **Practice-during-loading**
(`Mode.Training.LoadingPractice`) hosts an ad-hoc dummy space on match-load
screens that auto-yields when the real match is ready. The **multiplayer
training lobby** tolerates up to 250 ms RTT, lets a friend join as opponent _or_
coach, and gives the coach the power to pause both clients, annotate frames,
drive dummy commands, and push notes over a client-server tooling channel. The
**ten specialized trainers** — Frame Trap Detector, Option Select Detector,
Hit-Confirm, Anti-Air, Wakeup, Cross-Up, Throw Shimmy, Reaction Time, Combo
Damage Optimizer, Defensive Option Chart — are each scenario-driven and
performance-scored, and the **four range visualizers** (Throw / Move Reach /
Punish / Anti-Air zone) draw from frame-accurate combat geometry. A drag-drop,
profile-saved, shareable-as-code HUD layout and a CSV/JSON match-data export
(every input, hit, and state transition, plus one-click community-lab import)
round out the spec.

**Mission & tutorial curriculum** is a parallel validated surface,
`FV2MissionTrialCurriculumSpec` (section 61, asserted by
`V2Tests/.../MissionTrialCurriculum.spec.cpp`): a 30-minute First-Boot Tutorial
that re-prompts after 3 consecutive losses and covers throw-tech and wakeup
choices, **eight ruleset tutorial tracks of eight lessons each** whose
completion unlocks that ruleset's Combat Trials, and **eight fighter trial
tracks totaling 160 combat trials** (`GetTotalCombatTrialCount()` returns
exactly 160 — 20 per fighter). The spec validates against the navigation graph,
so a trial that points at a non-existent screen fails the build.

## Replay theater, takeover & spectator

A V2 replay is **inputs plus determinism hashes, re-simulated rather than
recorded as video**. The file model lives in `V2Input/Public/V2InputTypes.h`:
`FV2ReplayFileHeader` carries the magic `V2RF`, format version,
replay/match/ruleset/ stage ids, build and content versions, the
`CosmeticManifestHash`, the **`RngSeed`**, a 60 Hz tick rate, total frames, and
three determinism anchors — `InputStreamHash`, `InitialStateHash`,
`FinalStateHash`. `FV2InputReplayEncoder` is a real binary serializer that
writes the literal `V`,`2`,`R`,`F` bytes and bails to an empty buffer on any
malformed field rather than emit a corrupt file. The byte budget is _computed_:
`EstimateCompressedBytesPerMinute()` does a real ceiling division against the
compression profile (1 MiB/min, codec non-`None`), and the CI **determinism
gate** re-plays each replay and fails on any `FinalStateHash` mismatch — the
same hashes the anti-cheat replay-drift pipeline reuses
(`Netcode/GoldenReplayCorpus.spec.cpp`).

On top of the file format sits a real theater. The viewer
(`Cinematics/ReplayViewer`, `ReplayFreeCamera`, `ReplayEntityTrackingCamera`,
`ReplayKillCam` specs) drives a `FV2ReplayViewerSessionRequest` with
player-authored camera keyframes, free-cam, and entity-tracking cuts;
**highlight detection** classifies moments through `EV2ReplayHighlightEventKind`
(Kill / LowHealth / Survival / RoundEnd) and `EV2ReplayHighlightMomentKind`
(MultiKill / ClutchPlay / NearDeathSurvival), and clip export builds an MP4 via
in-engine MoviePipeline (`ReplayClipExport.spec.cpp`). **Replay Takeover** is
implemented as fail-loud C++ in `V2OnlineServices`:
`UV2OnlineServicesSubsystem::CreateReplayTakeoverPracticeScenario` validates the
request, then **requires the replay to actually exist** — registered in
`CloudReplays` or queued as a local download — and returns false with a precise
reason otherwise, only then building a _new_ practice scenario while preserving
the original read-only. **Sharing** (`FV2ReplaySharingWorkflowSpec`,
`Online/ReplaySharing.spec.cpp`) uploads to the cloud, mints **HTTPS** share
links, downloads shared replays, opens them in-game, and **requires owner
consent** before any upload. **Spectator** supports an in-match observer cap
with a TO-controlled anti-spoiler delay, director-cam, and lower-thirds. The
scrubber's round-start / big-hit / combo / KO / finisher chapter markers are the
feature-prose intent that the shipped highlight-event vocabulary above begins to
realize.

## AI Director & adaptive difficulty

Above the per-bot Adaptive AI sits a session-level Director that tunes CPU
difficulty and pacing in **single-player modes only — never in ranked or
tournament**. The engine half is real: `V2AdaptiveAI` is one of the three
shipped `.uplugin`s, and `services/psyche-ai-director-hints` is real TypeScript
exporting `buildV2AdaptiveAILiveHintPlan`,
`buildV2AdaptiveAIMatchStartSnapshotPlan`, and
`queueV2AdaptiveAIMidMatchPsycheUpdateForNextMatch`, computing tendency hints
over observed actions through `@psyche/behavior-prediction`. Its defining
constant is
`V2_AI_DIRECTOR_HINT_ROLLBACK_POLICY = 'live-off-rollback-or-match-start-snapshot-only'`
— the Director's hints are consumed either off the rollback path or from a
match-start snapshot, so they **can never enter the deterministic frame loop**.
That, plus the per-skill-bucket MMR-matched CPU model, is the same
rollback-safe, out-of-band discipline the world-boss damage pipeline uses. The
named Calm→Build→Climax→Recovery state machine, the per-mode tuning table
(Arcade, Towers, Tekken Force, Devil Within, Konquest, Def Jam, MyCAREER), the
step-down-after-3-losses / step-up-after-5-perfects adaptive rules, and the EU
AI Act transparency toggle are design spec in the feature monolith, and the
`difficulty-analytics` service is the telemetry surface feeding them.

## How it connects

The mode registry is the orchestration layer almost every other V2 system hangs
off. The combat, juggle, blockstring, and golden-replay systems that training
and replay are built on are inventoried in
[./combat-systems-defense-and-game-feel.md](./combat-systems-defense-and-game-feel.md);
the heaviest standalone modes — roguelike, Battle Royale, world boss, karaoke,
specialty combat, and the signature live events that each ship as a removable
`UGameFeaturePlugin` — are in
[./signature-events-and-standalone-modes.md](./signature-events-and-standalone-modes.md).
For the registry machinery itself — the load-plan builder, the seven-state
lifecycle, HUD injection, the replay codec internals, and the Hathor UGC-world
bridge — read the architecture companion,
[../architecture/game-modes-training-and-replay.md](../architecture/game-modes-training-and-replay.md).

## Related

- The feature hub: [../V2_features.md](../V2_features.md)
- [Combat Systems, Defensive Options & Game Feel](./combat-systems-defense-and-game-feel.md)
  — the fight every mode runs, and the lab tools practice
- [Signature Events & Standalone Modes](./signature-events-and-standalone-modes.md)
  — roguelike, Battle Royale, world boss, karaoke, and the live-event plugins
- Architecture companion:
  [../architecture/game-modes-training-and-replay.md](../architecture/game-modes-training-and-replay.md)
  — the mode registry, load plan, replay format, and sim/present split