# Product Promise & Conventions

```mermaid
mindmap
  root((One tactical-action universe))
    Shared spine
      Operator roster
      Creator suite
      Online backbone
      Shadow War narrative
    Per-ruleset feel
      Tactical FPS
      Stealth tactics
      Action RPG
      Real-time strategy
      Run and gun
    Shipping discipline
      Original IP posture
      Target artifacts
      Evidence before status
      Stable naming
```

The promise has two equally binding halves: each ruleset preserves its genre's
feel, while shared identity, creation, online, and narrative systems prevent the
cells from becoming unrelated games. The conventions below keep that balance
inspectable as designs become code and evidence.

V4 is one Unreal Engine 5.5 game that has to feel like a dozen different games
at once — a Rainbow Six breach, a Hitman sandbox kill, a Commandos squad
infiltration, a Black Myth: Wukong boss duel, a StarCraft ladder match, a Contra
run-and-gun stage — **without becoming a compromise blend of any of them**. That
is the product promise, and every other V4 feature exists to serve it. The
organizing idea is **per-ruleset feel, one shared spine**: a mission in the
Hitman ruleset must feel like Hitman; a Wukong boss must feel like a souls-like;
a base-build must feel like StarCraft — yet all of them share one operator/hero/
unit roster, one creator suite, one online backbone, and one unifying narrative
(The Shadow War). This page is the **orientation door** to the V4 feature
catalogue. It states what V4 commits to as a tactical-action universe, separates
what is real on disk from what is spec, and then fixes the **conventions** —
naming, IP posture, cross-references, repository surfaces, and the
target-artifact discipline — that the rest of the catalogue runs on. It is the
features-side companion to the architecture's product-promise page and hands the
deep mechanics off to its siblings rather than re-deriving them. The feature map
this page belongs to is [../V4_features.md](../V4_features.md).

## What ships, honestly

The **module skeleton is real and drift-free.** `V4/ue/V4.uproject` pins
`"EngineAssociation": "5.5"` and declares **28 C++ modules**; exactly 28
directories exist under `V4/ue/Source/`, and the tree carries **272 `.cpp` and
189 `.h`** of genuine, domain-specific gameplay code. Several modules carry real
weight rather than stubs. `V4Gameplay` is the Gameplay Ability System spine:
`Source/V4Gameplay/Public/V4AttributeSets.h` defines a shared
`UV4AttributeSetBase` plus six per-cell attribute sets that are mutually
exclusive at runtime — `UV4Attr_Tactical`, `UV4Attr_Stealth`, `UV4Attr_Tactics`,
`UV4Attr_ARPG`, `UV4Attr_RTS`, `UV4Attr_Arcade`. `V4Tactical` ships authored
components — `UV4AimComponent`, `UV4CoverComponent`, `UV4GrenadeComponent`,
`UV4StanceComponent`, a `UV4WeaponRecoilCurveAsset`, and weapon-attachment /
weapon-switch / revive components. `V4Tests` is the largest module at **92
`.cpp`** of per-cell automation specs
(`V4ModeStealthHitmanTests/HitmanSpec.cpp`,
`V4ModeARPGWukongTests/WukongSpec.cpp`,
`V4ModeRTSAsymmetricTests/AsymmetricRTSSpec.cpp`, and dozens more) — a harness,
not a token directory.

The **per-cell netcode is real, and its determinism lives in code, not in
compiler flags** — the single most important honest distinction from V2. V2
enforces rollback determinism through strict-FP build-target flags; **V4's build
targets carry no such flags.** Instead, `V4Netcode` implements determinism as
runtime logic: `UV4RTSLockstepSubsystem`
(`Source/V4Netcode/Public/V4RTSLockstepSubsystem.h`) runs seed-configured
lockstep with per-frame state hashing — `ConfigureMatch`,
`AdvanceLockstepFrame`, `CheckRemoteFrameHash` for desync detection,
`RecoverFromDesync`, `BuildLateJoinerRebuildFrame`, a deterministic
`DrawMatchRandomInt`, and a `ValidateRngConsumptionOrder` audit, backed by the
seeded streams in `V4LocalDeterminism.h`. Twitch PvP gets
`UV4RollbackEmulatedComponent`; dedicated-server modes get
`UV4ServerAuthorityComponent` plus a `UV4ReplicationBandBudgeter`. The three
netcode strategies the promise names are each a distinct C++ surface. Three
build targets compile the same source for three roles: `V4.Target.cs` (Game),
`V4Editor.Target.cs` (Editor), and `V4TournamentServer.Target.cs` — a real
`TargetType.Server`. The cloud backend under `apps/v4/` is a genuine Rust + axum
0.7 Cargo workspace (`shared`, `telemetry-ingest`, `online-services`).

The **Game Feature plugins are real on disk.** Unlike V2 — whose mode plugins
were _planned_ surfaces with no on-disk presence — V4 ships **34 plugin
directories** under `V4/ue/Plugins/`, each with a valid `.uplugin` descriptor:
28 `V4Mode_*` cells/modes, 4 `V4DLC_*` content packs, and 2 `V4Tools_*` linters.
Those 28 mode plugins carry **343 `.cpp`** of module code, and their descriptors
encode real inter-plugin dependencies (e.g. `V4Mode_Tactical_CoDWarzone` builds
on `V4Mode_Tactical_CoDMultiplayer`).

Four honest gaps keep this page from over-claiming ship-state, and the catalogue
names them rather than implying otherwise:

- **No authored binary content.** `V4/ue/Content/` holds **0 `.uasset` and 1
  `.umap`** (`V4Core/Maps/BootMap.umap`). What it _does_ hold is **407
  `*.v4asset.json`** manifest sidecars (377 of them `*.uasset.v4asset.json`) —
  for example `DA_ShaderWarmupPlan.uasset.v4asset.json`, a structured
  PSO-precache / per-cell shader-prewarm / regression-budget plan
  (`missingPsoEntryBudget: 0`, `failBuildOnMissingEntry: true`, a 98%
  prewarm-coverage telemetry target). V4 is a **logic-and-manifest skeleton**:
  real C++ systems and real data manifests, but no hand-authored meshes,
  MetaHumans, mocap, VO, or cinematics in-tree. Every "AAA SOTA quality" claim
  depends on art/audio production not in the repository.
- **No `GameFeatureData.uasset` binaries.** The mode plugins' code and
  descriptors are real, but the `.uplugin` files declare
  `"EnabledByDefault": false` and there are zero binary GameFeature data assets
  that would hot-activate them at runtime.
- **Reserved compile seams.** `V4TournamentServer.Target.cs` adds
  `V4_TOURNAMENT_BUILD`, `V4_BROADCAST_TOOLS`, `V4_OBSERVER_CAMERAS`, and
  `V4_PAUSE_ON_DISCONNECT` as global definitions, but no `.cpp`/`.h` branches on
  them yet — they are reserved seams, the same honesty caveat V2 carries for its
  determinism defines.
- **Provider-gated and ops-gated surfaces.** Cross-play and cross-progression
  across the 9 day-one platforms depend on `OnlineServices`/`EOSShared` and
  per-platform back ends awaiting credentials; with launch dated 2026-10-01, the
  planning corpus marks real-world operations claims `[~]` per
  `V4/REMEDIATION_2026-06-12.md`.

Notably, **verification is by UE automation, not a checker army.** All of V4
holds exactly **one** `.py` file; the verification backbone is `V4Tests` run
through the on-box editor by `V4/.ci/run-ue-automation-all.sh`
(`-ExecCmds="Automation RunTests V4.;Quit"`, re-execed as the `ueagent` user
because the editor refuses root), with companion `run-gauntlet-feel-tests.sh`
and `run-golden-replays.sh` for feel-gates and replay regression. The deeper
enforcement story — how a promise becomes a contract becomes an automation gate
— is the architecture companion
[../architecture/product-promise.md](../architecture/product-promise.md).

## The product promise — what V4 commits to

V4's promise, authored in `V4_features.md` under the "V4 Product Promise"
section, is a small set of non-negotiable commitments. The ones that matter for
orientation:

- **One product, not five.** Per-ruleset feel with **no compromise blends** —
  Hitman ruleset feels like Hitman, Wukong like a souls-like, StarCraft like
  StarCraft — held together by one shared roster, one creator suite, one online
  backbone, and one narrative. Cell identity is routed at runtime by
  `UV4ModeSubsystem` (`RegisterMode`, `TransitionToMode`, `GetCurrentModeId`,
  `SelectQuickPlayMode`) rather than hard-compiled into the menu.
- **A per-cell netcode envelope, not one strategy.** Dedicated-server
  client-server netcode is the **default** for tactical PvP (5v5, 6v6,
  100-player BR); deterministic lockstep serves RTS (1v1 / 2v2 / 4v4);
  rollback-emulated client prediction serves tight twitch PvP (TDM,
  Spies-vs-Mercs). No single strategy fits a battle royale, a 2v2 RTS, and a 60
  Hz duel, so the promise draws the line and the code mirrors it with the three
  distinct `V4Netcode` surfaces above.
- **One shared AI perception model** across every NPC in every cell. A Hitman
  guard, a Commandos patrol, a Splinter Cell mercenary, and a Wukong yaoguai all
  read stimuli from the same `UV4PerceptionComponent` and the same
  `UV4SuspicionStateMachine` (`V4Perception`), with a
  `UV4VisionConeDecalRendererComponent` drawing the RTST cells' ground cones.
- **Complete launch content** across every advertised mode — no "coming soon"
  panels, no skeleton cells — and **first-class single-player** per cell with
  mocap principals, launch-language VO, and 4K cinematics. The 34 plugins are on
  disk; the authored content that dresses them is the production-gated gap
  above.
- **Degrade safely** under offline, partial-net, low-bandwidth, controller-loss,
  mid-match-disconnect, and provider-outage conditions (RTS pause-on-disconnect,
  local single-player saves reconciled on reconnect, sub-2-second host
  migration).
- **Run on 9 platforms day-one** (Windows, PS5/PS5 Pro, Xbox Series X|S, Switch
  2, macOS, Linux/Steam Deck, iPad Pro, Android tablets) plus a PixelStreaming
  thin-client where contract permits — per-platform scope is
  `.Target.cs`-driven, cross-play provider-gated.
- **Live service from day one** — seasonal contracts, out-of-band balance
  hot-fixes, and a **public balance ledger**. That ledger is not aspirational
  copy: `V4/balance/public-balance-ledger.json` defines a weekly Friday
  publication cadence at a `/balance-ledger` route with telemetry-evidence
  gating (`minimumMatchCount: 10000`), alongside a `gadget-balance-ledger.csv`.

## The multi-cell product vision — per-ruleset feel, one spine

The five **ruleset cells** are V4's player-facing organizing principle: Tactical
FPS, Real-Time Stealth Tactics, Action RPG, RTS, and 2D Run-and-Gun. Each is a
self-contained gameplay framework with its own pacing, camera discipline, AI
personality, HUD vocabulary, and audio identity, implemented as a cluster of
GameFeature plugins on top of shared engine subsystems.

A nuance, surfaced honestly: the player-facing count is **five ruleset cells**
(stealth folds into the Tactical FPS bucket alongside Splinter Cell and Hitman),
but the disk carries **six distinct engine cell modules** — `V4Tactical`,
`V4Stealth`, `V4Tactics`, `V4ActionRPG`, `V4RTS`, `V4Arcade` — because stealth
is split out as its own module (`UV4LightGaugeComponent`, sound-footprint,
body-drag, disguise). The 2026-06-12 remediation canonicalized this to **six
launch cells** across the gate language (`V4/REMEDIATION_2026-06-12.md`), which
is why the subsystem glossary speaks of "all six launch cells" while the
overview speaks of five rulesets. Both numbers are correct at different layers.

The cells are held together — not blended — by shared infrastructure. Perception
is the clearest example: every hunter NPC reads the one `UV4PerceptionComponent`
and `UV4SuspicionStateMachine`, with `V4Crowd` (Mass-backed) layering
Hitman-style crowd density and panic on top. Mutually-exclusive per-cell
attribute sets are what let one character be a Tactical operator in one match
and an ARPG hero in the next without their stat blocks colliding, and
`UV4ModeSubsystem` plus a `UV4GameFeatureAction_ActivateModeAssets` route which
cell's ruleset and HUD are live. Each cell also ships a **feel test** — a
curated scenario reviewers run to confirm the cell hits its inspiration's
hallmark (a Raven Shield two-squad breach, a Commandos no-respawn alarm, a
Wukong 6-frame parry window) — wired into the nightly Gauntlet run, where a
failing feel test blocks that ruleset's release. The tactical FPS cell, which
alone spans five sub-rulesets (Raven Shield, R6 Siege-era, CoD, Splinter Cell,
Hitman), is the subject of its own deep-dive at
[./cell-tactical-fps.md](./cell-tactical-fps.md).

## Conventions

The catalogue is held to a fixed set of conventions so prose cannot drift ahead
of the tree. These are load-bearing; the rest of the feature pages assume them.

### IP posture — original IP, inspiration-only vocabulary

V4 is **original IP**. The eleven named franchises it draws on (Rainbow Six,
Call of Duty, Splinter Cell, Hitman, Commandos, Desperados, Black Myth: Wukong,
StarCraft, Age of Empires, Contra, and others) are **design inspirations only**.
V4 reuses their published gameplay-system _vocabulary_ — "vision cones",
"Showdown Mode", "Mark and Execute", "Spies vs Mercs", "Killstreak", "Wonder
victory" — as terminology shorthand for established mechanic patterns, the same
way V2 references "Drive Impact" or "Heat / Rage Arts". V4 does **not** reuse
any inspiration's character names, faction/civ/unit names (beyond historical or
public-domain terms), voice-line scripts, marketing copy, trademarks, map
identities, music, or visual identity. All cast and licensed terms are tracked
in the §81 IP / NIL / licensing register; where a mechanic name is itself
trademarked, the shipping product substitutes an original name, with the
placeholder kept here only to make design intent legible.

### Subsystem glossary and the GameFeature plugin family

V4 uses a **fixed subsystem vocabulary** — `V4Core`, `V4Gameplay`, `V4Tactical`,
`V4Stealth`, `V4Tactics`, `V4ActionRPG`, `V4RTS`, `V4Arcade`, `V4Perception`,
`V4Crowd`, `V4Schedules`, `V4Animation`, `V4Input`, `V4Netcode`, `V4Modes`,
`V4UI`, `V4Audio`, `V4VFX`, `V4Cinematics`, `V4Persistence`, `V4OnlineServices`,
`V4Telemetry`, `V4Vehicles`, `V4Procgen`, `V4LevelOps`, `V4Tests`, and the
editor/primary modules — each name resolving to exactly one directory under
`V4/ue/Source/`. Each ruleset's mode set is packaged as a **`GameFeatures`
plugin** (`V4Mode_Tactical_RavenShield`, `V4Mode_Stealth_Hitman`,
`V4Mode_ARPG_Wukong`, `V4Mode_RTS_Asymmetric`, `V4Mode_Arcade_Contra`, and 23
more) so a ruleset can be enabled per build target and DLC-gated post-launch
without rebuilding the shipping executable. Each plugin owns its content root,
asset-linter rules, and per-mode test coverage. The full module map and the
complete plugin catalogue — including the cross-cell support modules
(`V4Schedules`, `V4Vehicles`, `V4Procgen`, `V4LevelOps`) — are the subject of
[./subsystem-glossary-and-plugins.md](./subsystem-glossary-and-plugins.md).

### Cross-reference convention

Throughout the catalogue, **bare `§N` and `§N.M` references resolve to
`V4_TODOS.md`** — the only V4 document whose numbered sections are used as
hyperlink anchors. Explicit prefixes are used where ambiguity matters: `deps§N`
→ `V4_DEPENDENCIES.md`, `arch§"<anchor>"` → `V4_ARCHITECTURE.md` by section
anchor, and `features§"<anchor>"` → `V4_features.md` by anchor. This features
tree and the architecture tree use **named anchors** rather than numbered
sections; only `V4_TODOS.md` and `V4_DEPENDENCIES.md` carry numbered section
ids. The backlog (`V4_TODOS.md`) remains the source of truth for completion
state; this catalogue describes product shape, not checkbox status.

### Repository surfaces and target-artifact discipline

V4 is one game but the product reaches well beyond `V4/ue/`. The real subtrees
on disk include the game client (`V4/ue/`), a Next.js marketing/wiki web app
(`apps/v4/web/`), a React Native companion-app scaffold
(`apps/v4/companion/App.tsx`, `app.config.js`), a Next.js spectator portal
(`apps/v4/spectator/`), the Rust online backbone (`apps/v4/`), and the live-ops
and compliance surfaces (`V4/esports/` with
`pro-circuit`/`hall-of-fame`/`calendar`, `V4/balance/`, `V4/liveops/`,
`V4/store/`, `V4/progression/`, `V4/legal/`). All of them hang off the one spine
rather than forking it, which is the structural form of the "live service from
day one" promise.

The discipline that keeps the catalogue honest is **target-artifact naming**:
where a section names a module or path, it names a _target artifact_ unless the
path already exists in the repo, and the backlog task that first references it
owns creating it with tests and validation. Some surfaces the feature monolith
lists — `V4/tools/missions/`, `V4/tools/rts-maps/`, `V4/tools/arcade-art/`,
`V4/tools/release/` — are explicitly flagged "planned — not yet created" in the
repository-surfaces table itself. That is the convention working: a named path
is either a file on disk or a declared target, never a silent claim of
completion.

## Related

- [../V4_features.md](../V4_features.md) — the V4 feature map this page orients
- [./subsystem-glossary-and-plugins.md](./subsystem-glossary-and-plugins.md) —
  the full 28-module / 34-plugin map and the fixed subsystem vocabulary behind
  every claim here
- [./cell-tactical-fps.md](./cell-tactical-fps.md) — the Tactical FPS cell
  deep-dive (Raven Shield planning, R6 destruction, CoD campaign/MP/BR, Splinter
  Cell stealth, Hitman sandbox) that this page hands the deep mechanics to
- [../architecture/product-promise.md](../architecture/product-promise.md) — the
  architecture companion: how the promise becomes a contract becomes an
  automation gate, and the runtime topology behind the cells