# Product Promise ```mermaid mindmap root((One open-world narrative universe)) Six ruleset cells Urban crime Period drama Frontier Monster hunter Squad science fiction Newtonian space simulation Shared player truth Cross-Continuum Bureau Mind Palace Relationships and consequence Production spine World partition Investigation and cases Online and creator Evidence-backed release ``` V5's breadth is constrained by shared player truth: six distinct ruleset cells may change movement, combat, and simulation, but they do not fork the roster, investigation record, or consequence model. The promise is therefore a coherent universe with deliberately different local grammars. V5 is the largest of the V-products: one Unreal Engine 5.5 open-world narrative-action game built as a universe of six **ruleset cells** — urban crime, period drama, frontier, monster hunter, and two sci-fi flavours (a Mass-Effect squad RPG and an Expanse-style Newtonian ship sim) — sharing one roster (the "Cross-Continuum Bureau"), one cross-cell Mind Palace deduction layer, one creator suite, and one online backbone. The promise is not a launcher bolted over unrelated titles; it is **per-genre feel on a single spine**. A Hong-Kong triad brawl, a 1947 noir interrogation, a frontier outlaw chase, a Witcher contract hunt, and a flip-and-burn ship duel must each feel like its own genre — yet all of them read stimuli from the same perception model, hang their stats off the same attribute spine, and deposit evidence into the same deduction graph. The architecture exists to make that shippable: each ruleset is a swappable gameplay layer over common engine modules, so cells can be enabled, stripped per platform, or DLC-gated without forking the foundation. This page is the **features-side orientation door** to that universe. Where the architecture companion [../architecture/promise-and-glossary.md](../architecture/promise-and-glossary.md) reconciles the engine module graph against the compiler — load phases, the acyclic `Build.cs` dependency graph, the dedicated-server slice — this page reads the same disk from the player-feature angle: what V5 commits to as a product, which named promise resolves to which real code, and where prose and tree diverge. It states the commitments, separates what is real on disk from what is spec, and hands the deep mechanics off to its siblings — the named-subsystem map in [./subsystem-glossary.md](./subsystem-glossary.md) and the cell-by-cell breakdown in [./ruleset-cells-overview.md](./ruleset-cells-overview.md) — rather than re-deriving them. The single source of truth for completion state remains the backlog; this page describes product shape, not checkbox status. The feature map this page belongs to is [../V5_features.md](../V5_features.md). ## What ships, honestly **The module skeleton is real and exactly consistent.** `V5/ue/V5.uproject` pins `"EngineAssociation": "5.5"`, sets `DisableEnginePluginsByDefault: true`, and declares **74 C++ modules** in its `Modules` array; `ls V5/ue/Source/` yields 74 module directories alongside five `*.Target.cs` files — the two sets are identical, with no spec-only modules and no orphan directories. The tree carries **328 `.cpp` and 341 `.h`** files of domain-specific gameplay code. Every module ships a `*.Build.cs`, a `Public/`/`Private/` split, and a module class, and depth is concentrated where the genre needs it. The deepest module is **`V5MindPalace` (36 files)** — the cross-cell deduction engine, exposing `UV5_MindPalace_AddEvidenceNode`, `UV5_MindPalace_AttemptDeduction`, `UV5_MindPalace_BuildHypothesisChain`, `UV5_MindPalace_MakeAccusation`, `UV5_MindPalace_CrossEraGate`, and an `FV5MindPalaceCloudSyncHttp` transport, all operating over a real `UV5_MindPalace_Graph`. `V5Spaceship` (20 files) carries a genuine `AV5_Ship_NewtonianPawn : APawn` with `ConfigureShip(...)`, `SetNewtonianState(...)`, and `RCSTorqueDegPerSecond` thruster math (`Source/V5Spaceship/Public/V5SpaceshipTypes.h`) — not a renamed CRUD shell. `V5Gameplay` is the GAS spine: `UV5_AttributeSet_Combat final : UAttributeSet` (`Source/V5Gameplay/Public/V5AttributeSets.h`) exposes Health/MaxHealth/Stamina plus genre-specific attributes — `ToxicityCurrent`/`ToxicityMax` for the alchemy cell, `ManaCurrent`/`ManaMax` for sign-casting, and a separate `UV5_AttributeSet_Honor` for the frontier — domain detail a generic stat block would not carry. **The single biggest honest correction** concerns where cell gameplay lives. The prose frames each mode as a hot-swappable `GameFeatures` **plugin**. On disk, the cell _code_ is instead statically compiled **Source modules**: `V5UrbanHeistCity`, `V5UrbanStreetTriad`, `V5HunterWitchersPath`, `V5FrontierOutlawTrail`, `V5SciFiGalacticSquad`, `V5SciFiHardVacuum`, `V5PeriodMadeMan`, `V5DetectiveMindPalace`, and a dozen more are real `Runtime` modules named in the `.uproject` `Modules` array, each with a colocated `Private/Tests/` spec. The matching `Plugins/V5Mode_*` directories are **content/manifest shells**: all **29** `V5Mode_*` plugins carry **zero `.cpp`**, declare `"EnabledByDefault": false`, hold only JSON under `Content/Data/`, and there are **zero `GameFeatureData.uasset`** binaries anywhere in `Plugins/`; none of the 29 appear in the `.uproject` `Plugins` array. So the "hot-swap GameFeatures" story is **half realized**: the runtime code exists and compiles into the monolith; the binary GameFeature data assets that would let it activate as a toggleable plugin are not yet authored. The cells are modular _by source module_, not yet by _runtime feature_. The honest gaps, named rather than implied: - **No authored binary content.** `V5/ue/Content/` holds **0 `.uasset` and 1 `.umap`** (`V5Core/Maps/BootMap.umap`), against **393 JSON** authoring/manifest sidecars. V5 is a **logic-and-manifest skeleton**: real C++ systems and structured data, but no hand-authored meshes, MetaHumans, mocap, VO, or cinematics in-tree. Every "AAA open-world" claim depends on art/audio production that is not in the repository. - **A deliberate cross-product reuse.** The `.uproject` `Plugins` array enables **`V8_Ariadne_CaseClient`** — a plugin owned by the V8 (Ariadne) detective product, not present under `V5/ue/Plugins/`. It builds _into_ V5 from elsewhere; treat it as intentional cross-cell case-client reuse, labelled here because the source is not local. - **The backend is TypeScript, not Rust.** `apps/v5/` is a NestJS-style TypeScript workspace — **234 `.ts` across 16 contract-tested services** (`auth`, `friends`, `parties`, `matchmaking`, `leaderboards`, `replays`, `telemetry`, `anti-cheat`, `mindpalace-cloud-sync`, `workshop`, `compliance-dsar`, `faction-rep`, …), each with its own `contract.json`. This is a real backbone, and a deliberate contrast with V4's Rust workspace. - **Provider- and ops-gated surfaces.** Cross-play, anti-cheat, store/cert, and the live-service cadence depend on platform credentials and real operations; `V5/REMEDIATION_2026-06-12.md` _removed a fabricated launch-readiness manifest_ rather than let prose imply ship-state, and marks these `[~]`. ## The product promise V5's promise, authored in `V5_features.md` under "V5 Product Promise" and mirrored in the architecture hub, is a small set of non-negotiable commitments. The unifying idea is **per-genre feel, one shared spine**, and each commitment has a code anchor or an honest status. | # | Commitment | Code-grounding / status | | --- | ---------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------- | | 1 | One coherent game delivering per-genre feel across all launch cells | 74 `Source/` modules incl. per-cell modules; identity routed by `V5Modes` + `EV5Cell` (`V5Core`) | | 2 | A per-cell netcode envelope (dedicated, rollback-emulated, offline) | `V5Netcode` hosts all three paths; `V5DedicatedServer.Target.cs` is a real `TargetType.Server` | | 3 | One shared AI perception model across every NPC in every cell | `V5Perception` — unified sight/hearing/suspicion (`V5PerceptionSystems.h`), consumed by every cell | | 4 | One shared roster, cell-specific overrides hung off a character record | `EV5Cell`-keyed character/save data in `V5Core` (`FV5SaveDocument`, `FV5BureauXPLedger`) | | 5 | One cross-cell Mind Palace deduction layer | `V5MindPalace` (36 files) — evidence graph, hypothesis chains, cross-era gate; every cell pushes evidence in | | 6 | One creator suite (Mission/Heist/Case/Workshop authoring) | `V5MissionEditor`, `V5HeistAuthor`, `V5CaseAuthor`, `V5WorkshopEditor` (`Editor`-type modules) + `tools/` | | 7 | Cells enable/disable per platform, per build target, per DLC | `Plugins/V5Mode_*` manifests + per-cell `Content/` roots; **gap:** no `GameFeatureData.uasset` to hot-activate | | 8 | One online backbone (auth, parties, matchmaking, replays, anti-cheat) | `apps/v5/` — 16 contract-tested services; `V5OnlineServices` engine module is the client | | 9 | Run across nine platforms, plus dedicated- and listen-server SKUs | Five `*.Target.cs`; `Platforms/` overrides for Windows/PS5/PS5Pro/XSX/XSS/Switch2/Mac/Linux/iPad | ### Per-genre feel, no compromise blends The promise is explicit that V5 is not "blend everything every match." When a mission is in the urban ruleset it must feel like a GTA-style sandbox; when it is a Witcher contract it must feel like a monster-hunter RPG; when it is a ship duel it must feel like Newtonian hard-sim. The architecture serves that by routing cell identity at runtime through `V5Modes` rather than hard-compiling a menu, and by keying character, save, and progression data on the `EV5Cell` enum (`V5/ue/Source/V5Core/Public/V5Types.h`) so one Bureau roster can carry distinct per-cell stat morphologies without colliding. The richest evidence that the feel is genre-specific and not a generic shell is the attribute spine itself: a single `UV5_AttributeSet_Combat` already distinguishes a toxicity budget (the alchemy cell's potion-overdose mechanic) from a mana pool (the sign-casting cell) from a separate Honor set (the frontier reputation curve). ### One shared spine Five things are shared, not duplicated per cell. **One roster** — the Cross-Continuum Bureau — is modelled as `EV5Cell`-keyed records in `V5Core`, where `FV5SaveDocument` carries a `FV5BureauXPLedger` with per-cell XP and a recalculated account tier. **One Mind Palace** (`V5MindPalace`) is the cross-cell deduction graph every cell feeds. **One perception model** (`V5Perception`) is the unified sight/hearing/suspicion machine a triad goon, a noir witness, an outlaw, a drowner, and a station guard all read. **One creator suite** is four `Editor`-type modules — `V5MissionEditor`, `V5HeistAuthor`, `V5CaseAuthor`, `V5WorkshopEditor`. **One online backbone** is the 16-service `apps/v5/` workspace, with `V5OnlineServices` as the in-engine client. The thin `V5` composition root itself (three files: `V5.Build.cs`, `Private/V5.cpp`, `Public/V5.h`) fuses nothing — it is named by every target via `ExtraModuleNames.Add("V5")` and exists only to be the executable's entry point, which is exactly why the cells can hang off the spine instead of forking it. ### A per-cell netcode envelope Commitment 2 is one decision expressed as a **per-cell envelope**, because no single strategy fits a 32-player open-world session, a co-op heist, and a 60 Hz ship duel. Dedicated-server client-server netcode is the default for open-world PvP and co-op; rollback-emulated prediction serves tight spaceship-PvP and squad combat; offline-deterministic single-player serves the campaigns. Like V4 (and unlike V2, which stamps strict-FP determinism on its build targets), V5 keeps that logic _inside_ `V5Netcode` rather than on the targets — none of the five `*.Target.cs` sets `/fp:strict` or a `DETERMINISM=*` define, so read the determinism prose as module-level intent, not a build-target guarantee. The targets do, however, do real work: `V5DedicatedServer.Target.cs` is a genuine `TargetType.Server` that, beyond a `V5_DEDICATED_SERVER=1` define, carries a real `DisablePlugins.AddRange` list of **29 plugins** (Niagara, Metasound, the Chaos cloth/flesh set, MetaHumanRuntime, CommonUI, EnhancedInput, the geometry- processing stack, PCG…), so the server build genuinely strips client-only rendering, audio, and physics — concrete per-target stripping rather than a flag. ### Complete content, safe degradation, nine platforms, live service The remaining commitments are the AAA-scope promises: **complete launch content** across every advertised mode (no "coming soon" panels, no skeleton cells), with first-class single-player per cell; **safe degradation** under offline, partial-net, controller-loss, mid-mission-disconnect, and provider-outage conditions (host-migration under two seconds, local saves reconciled on reconnect, an eight-frame rollback on ship-PvP packet loss, Mind Palace state surviving a crash); **nine platforms day-one** (Windows, PS5/PS5 Pro, Xbox Series X|S, Switch 2 scaled, macOS Apple Silicon, Linux/Steam Deck, iPad Pro) plus a PixelStreaming thin-client where contract permits; and **live service from day one** with per-cell seasonal contracts, out-of-band balance hot-fixes, and a public balance ledger. The five `*.Target.cs` files and the `Platforms/` overrides are the structural form of the platform promise; the authored content that dresses every "complete" claim is the production-gated gap named above. ## The six-cell open-world-narrative vision The cells are the product. The prompt frames V5 as **six ruleset cells** — urban crime, period drama, frontier, monster hunter, and two sci-fi flavours — and the disk bears that out, but the count needs care, because three different numbers are each correct in their own frame: - **Five launch cells** is the marketing/promise framing: Urban, Period, Frontier, Hunter, Sci-Fi. - **Six** is what you get counting the two distinct sci-fi gameplay modules separately: `V5SciFiGalacticSquad` (squad RPG) and `V5SciFiHardVacuum` (hard-sim Newtonian flight over `V5Spaceship`), with `V5SciFiPvP` for ship-duel deathmatch alongside them. - **Seven** is the canonical engine count. `EV5Cell` (`V5/ue/Source/V5Core/Public/V5Types.h`) enumerates `Urban, Period, Frontier, Hunter, SciFi, Steampunk, MindPalace` — the five launch cells plus the Brave New World **Steampunk Detective** DLC cell and the cross-cell **Mind Palace** meta-layer. Per-cell datasets and tests must size against `GetAllV5Cells()`, which returns all seven from the `GAllV5Cells` array in `V5Types.cpp`, not a literal 5 or 6 — the 2026-05-31 audit traced four automation failures to exactly that mismatch. Each cell is realized as a family of compiled Source modules layered over shared systems: **Urban** (`V5UrbanHeistCity`, `V5UrbanStreetTriad`, `V5UrbanOnline`, over `V5Heist`, `V5Wanted`, `V5Parkour`, `V5Karaoke`); **Period** (`V5PeriodMadeMan`, `V5PeriodViceSquad`, over `V5Interrogation`, `V5FaceCapture`, `V5PeriodAuth`); **Frontier** (`V5FrontierOutlawTrail`, `V5FrontierOnline`, over `V5Honor`, `V5Hunting`, `V5HorseAI`, `V5DeadEye`); **Hunter** (`V5HunterWitchersPath`, `V5HunterContractBoard`, `V5HunterCardGame`, over `V5Alchemy`, `V5Signs`, `V5MonsterHunt`); and **Sci-Fi** (`V5SciFiGalacticSquad`, `V5SciFiHardVacuum`, `V5SciFiPvP`, over `V5Spaceship`, `V5StarMap`, `V5Squad`). The cross-cell layers — `V5DetectiveMindPalace`, `V5DetectiveColdCases`, and the `V5SteampunkDetective` DLC cell — sit on top, and the mode-shaped modules (`V5SpecOpsCoop`, `V5HordeDefense`, `V5RoguelikeHunterRun`) reuse cell systems across the universe. ### Held together, not blended The cells are unified — not homogenized — by shared infrastructure. A triad goon, a 1947 witness, an outlaw, a drowner, and a station guard all read the _same_ `V5Perception` state machine. `V5MindPalace` links `V5Investigation` so a clue photographed in the urban cell can pair with a forensic note from the period cell and a track from the frontier cell into a single deduction — and the accusation system lets the _wrong_ answer ship, archiving it alongside the right one rather than forcing a retry. `V5Modes` gates which cell's ruleset and HUD are live, and the one-way `Build.cs` dependency declarations (`V5MindPalace → V5Core, V5Investigation`; `V5UrbanHeistCity → V5Core, V5Wanted`) keep the cross-cell shared modules forbidden from depending on any per-cell module — the acyclic property the [topology companion](../architecture/promise-and-glossary.md) audits in full. Testing is distributed to match: **73 of 74 modules** ship their own `Private/Tests/` directory, so the cell that owns a system owns its UE automation spec, and `V5Tests` is a lean harness rather than the bulk of the test code. ### How the promise stays honest Two conventions keep the prose from drifting ahead of the tree, and the [subsystem glossary](./subsystem-glossary.md) details both. First, the **target-artifact convention**: a section that names a module or path either points at a file that exists or declares a target the owning backlog task must build with tests. Second, the **cross-reference convention**: a bare `§N`/`§N.M` resolves to a numbered task in `V5_TODOS.md`, while `deps§N` → `V5_DEPENDENCIES.md`, `arch§"anchor"` → the architecture hub, and `features§"anchor"` → `V5_features.md`. The precise claim a reader can make today: V5's _systems_ — 74 modules, 669 source files, distributed UE automation — are real and compile; the _content_ that dresses them (meshes, MetaHumans, VO, cinematics, the `GameFeatureData.uasset` binaries that would hot-activate the mode plugins) is production-gated and not yet in-tree; and the _operations_ claims are marked `[~]` until they can occur. That separation is the product promise kept honest. ## Related - [../V5_features.md](../V5_features.md) — the V5 feature map this page orients, with the full cell-by-cell catalogue, modes, services, and exit criteria. - [./subsystem-glossary.md](./subsystem-glossary.md) — the named-subsystem map: every `V5*` module, the GameFeature-plugin family, IP posture, and the conventions behind every claim here. - [./ruleset-cells-overview.md](./ruleset-cells-overview.md) — the cell-by-cell overview: camera, pacing, AI personality, PvP posture, and feel tests per cell. - [../architecture/promise-and-glossary.md](../architecture/promise-and-glossary.md) — the architecture companion: the module graph against the compiler, build targets, the determinism posture, and the runtime topology behind the cells.