# Subsystem Glossary & Plugins ```mermaid mindmap root((V4 runtime vocabulary)) Foundation modules Core and gameplay Input and UI Netcode and online Ruleset cells Tactical Stealth tactics Action RPG Strategy Arcade Game Feature plugins Activation policy Cell-specific abilities Content and maps Shared services Progression Creator Telemetry Tests ``` This vocabulary separates durable engine services from the plugins that supply ruleset-specific feel. Follow a leaf from player capability to module or Game Feature plugin, then use the evidence notes below to distinguish implemented code from a named target artifact. This is the orientation page for the V4 feature set — the page to read before any of the deep feature pages, so that when a later page says "the cover lean reads `V4Tactical`'s `V4CoverComponent`," or "the Showdown timer lives in the `V4Mode_RTST_Desperados` plugin," or "the leaderboard upload goes through `V4OnlineServices`," the name already lands on something real you can open. V4 is a single Unreal Engine 5.5 tactical-action game whose ambition is **per-cell feel**: one shared roster, one creator suite, and one online backbone, with five ruleset cells — tactical FPS, real-time stealth tactics, action RPG, real-time strategy, and 2D run-and-gun — swapped in as plugins so that a Hitman mission feels like Hitman and a StarCraft skirmish feels like StarCraft. That promise is a code-organization decision before it is a design one, and this page maps it: the named subsystem that delivers each advertised player capability, the plugin and cell structure that keeps the cells from bleeding into each other, and the repository surfaces the game talks to. It is the **product-side companion** to the architecture glossary. Where the architecture page [../architecture/glossary.md](../architecture/glossary.md) reconciles the engine module graph against the compiler — the acyclic `Build.cs` dependency edges, the `PreDefault`/`Default` load phases, the minimal build targets — this page reads the same disk from the player-feature angle: which named subsystem delivers which advertised capability, and where the glossary's name and the disk's reality diverge. The single source of truth for completion state remains the backlog (`V4_TODOS.md`); this page is the index, not the checklist. It is the foundations companion to the feature catalogue at [../V4_features.md](../V4_features.md). ## What ships, honestly **Real and on-disk (the compiler agrees).** The UE project at `V4/ue/` is substantial and the glossary names resolve cleanly to it. There are **28 C++ module directories** under `V4/ue/Source/`, each with a `*.Build.cs`, a `Public/`/`Private/` split, and a module class; the `.uproject` `Modules` array lists the matching 28. The Subsystem Glossary's **27 engine rows** (`V4Core` … `V4Tests`) map **one-to-one** onto 27 of those directories — there are no spec-only modules here, unlike V2 — and the 28th directory is the thin `V4` primary game module the glossary table omits. Across the 28 modules sit **461 `.cpp`+`.h` files**, with depth concentrated where the genre needs it: `V4OnlineServices` is the deepest at 34 files, then `V4Tactical` (24), `V4ActionRPG` and `V4RTS` (22 each), `V4Core` and `V4Netcode` (19 each). The `V4Tests` module carries **90 `*Spec.cpp`** automation specs (`CoverSpec`, `CoDWarzoneSpec`, `CommandosSpec`, `ContractScheduleSpec`, `AIDirectorSpec`, …). The cells are real code, not content shells: the **28 enabled `V4Mode_*` plugins** ship their own runtime C++ modules totalling **~234 authored `.cpp`+`.h` files** under `V4/ue/Plugins/` (the gitignored UHT codegen under `Intermediate/Build` is not counted). **Where the product glossary and the disk diverge** (found by reading both), labelled: - **The "hot-swap" framing is aspirational.** The Game-Feature Plugins table bills each cell as a `GameFeatures` plugin "enabled per build target and DLC-gated post-launch without rebuilding." On disk every `V4Mode_*` `.uplugin` sets `"EnabledByDefault": false` but is **force-enabled by the `.uproject`**, and none is `ExplicitlyLoaded` — so they cook in as ordinary plugins, not runtime-toggled features. The activation _machinery_ is nonetheless real: `V4Modes` ships `UV4GameFeatureAction_ActivateModeAssets` and `V4ModeSubsystem`. - **"Mode-specific HUD" lives in `V4UI`, not `V4Modes`.** The glossary attributes the per-mode HUD to `V4Modes`, but the module is a registry (`V4ModeSubsystem`, `V4QuickPlayPlaylistRunner`, `V4ModeRoutingActor`); the HUD view-models (`V4HUDViewModel`, `V4StealthBowTieWidget`) are in `V4UI`, which for that reason depends on `V4Stealth` — an edge the architecture table omits. - **`V4Audio` and `V4VFX` are thin seams over engine plugins.** `V4Audio` (12 files) names "the MetaSounds pipeline" and `V4VFX` (4 files) names Niagara, but the heavy capability is delivered by the force-enabled engine plugins (`Metasound`, `Niagara`); the modules are the gameplay-facing seams that drive them. By contrast `V4OnlineServices` is **not** a thin seam — at 34 files it is the deepest module in the project, the opposite of V2's 8-file online stub. - **The editor capability is split, and one editor is undocumented.** The glossary's `V4Editor` line promises "Mission editor, contract author, RTS map editor, 2D level editor," but the `V4Editor` Source module is 5 files of in-editor schedule/contract tooling; the authoring surfaces live in the `V4Mode_Editor_Mission`/`V4Mode_Editor_Workshop` plugins plus two editor linters (`V4Tools_AssetLinter`, and the **undocumented** `V4Tools_DataLinter`). - **V4 has no TypeScript footprint and a compact Rust backend.** There is no `libs/v4`, no `libs/contracts/src/v4`, no `apps/v4`, and no web tile under `apps/oshun/web`. The "Online services backend (cloud)" surface is a **three-crate Rust workspace** (`shared`, `telemetry-ingest`, `online-services`), not nine separate services. Everything below is grounded in those files; where a claim is the glossary's intent rather than shipped code, it is labelled. ## The subsystem glossary, mapped to code The glossary's 27 rows describe the shared spine, the five cells' gameplay, the AI senses, and the presentation/online/tooling seams. The happy V4 finding is that the **advertised capability lines resolve almost word-for-word to real, named UE components** in each module — the cell tables below are not aspiration. Each name resolves to its directory under `V4/ue/Source/`, with the load-bearing classes named and the honest caveats kept. | Glossary subsystem | On disk (`Source/`, files) | Anchor classes that deliver the line | Notes | | -------------------- | ------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------- | | **V4Core** | `V4Core/` (19) | engine subsystems, tag registry, save scaffold, dev cheats | Graph sink; links no `V4*` module | | **V4Gameplay** | `V4Gameplay/` (15) | `UAbilitySystemComponent` GAS layer, attribute sets, gameplay effects, match-state | `GameplayAbilities`+`GameplayTags`+`GameplayTasks` | | **V4Tactical** | `V4Tactical/` (24) | `V4AimComponent`, `V4CoverComponent`, `V4StanceComponent`, `V4WeaponRecoilCurveAsset`, `V4WeaponAttachmentComponent` | FPS aim/ADS/recoil/lean/cover/attachments — 1:1 | | **V4Stealth** | `V4Stealth/` (16) | `V4LightGaugeComponent`, `V4SoundFootprintComponent`, `V4BodyDragComponent`, `V4DisguiseComponent`, `V4MarkAndExecuteComponent` | Light/shadow, footstep, body-drag, disguise — 1:1 | | **V4Tactics** | `V4Tactics/` (16) | `V4PartyComponent`, `V4CommandQueueComponent`, `V4VisionConeComponent`, `V4ShowdownModeSubsystem`, `V4BodyDisposalComponent` | RTST party/queue/cones; `Showdown` = time-stop — 1:1 | | **V4ActionRPG** | `V4ActionRPG/` (22) | `V4StaminaComponent`, `V4ParryComponent`, `V4DodgeComponent`, `V4PostureComponent`, `V4TransformationComponent`, `V4SpellCraftComponent` | Souls-like stamina/parry/posture/transforms — 1:1 | | **V4RTS** | `V4RTS/` (22) | `V4ResourceComponent`, `V4BuildComponent`, `V4TrainComponent`, `V4FogOfWarComponent`, `V4TechTreeComponent`, `V4AgeUpComponent`, `V4WonderComponent` | Economy/build-orders/fog/tech/age-up/wonders — 1:1 | | **V4Arcade** | `V4Arcade/` (18) | `V4SideScrollComponent`, `V4WeaponPickupComponent`, `V4PowerUpComponent`, `V4LivesComponent`, `V4LadderClimbComponent` | 2D scroll/pickups/lives over `Paper2D` — 1:1 | | **V4Perception** | `V4Perception/` (10) | `V4PerceptionComponent`, `V4SuspicionStateMachine`, `V4VisionConeDecalRendererComponent`, `V4PerceptionSenseLibrary` | One sight/sound/suspicion model shared across cells | | **V4Crowd** | `V4Crowd/` (4) | `V4CrowdSubsystem`, `V4CrowdTypes` | Lean in files; Mass-ECS crowd (links 6 Mass modules) | | **V4Schedules** | `V4Schedules/` (12) | `V4ScheduleAsset`, `V4ScheduleComponent`, `V4ScheduleTaskLibrary`, `V4ScheduleLaunchCatalog` | NPC daily routines/patrols; pulls `UMG` for the editor widget | | **V4Animation** | `V4Animation/` (10) | AnimBP/motion-matching binders | Binds `PoseSearch`/`Mover`/`Chooser`/`MotionWarping` plugins | | **V4Input** | `V4Input/` (14) | Enhanced-Input wrappers, cover-stick, aim-assist, tac-map cursor | Wraps `EnhancedInput` | | **V4Netcode** | `V4Netcode/` (19) | `V4ClientServerNetcode`, `V4RTSLockstepSubsystem`, `V4RollbackEmulatedComponent`, `V4LocalDeterminism`, `V4AntiCheatSubsystem` | All three net paths are real, named classes | | **V4Modes** | `V4Modes/` (14) | `V4ModeSubsystem`, `V4ModeBootstrapSubsystem`, `V4GameFeatureAction_ActivateModeAssets`, `V4QuickPlayPlaylistRunner` | Registry + GameFeature activation; HUD is actually in `V4UI` | | **V4UI** | `V4UI/` (17) | `V4HUDViewModel`, `V4MVVMRegistry`, `V4AccessibilitySubsystem`, `V4FocusGraphAsset`, `V4StealthBowTieWidget` | CommonUI/MVVM; depends on `V4Stealth` (table omits) | | **V4Audio** | `V4Audio/` (12) | `V4Audio` subsystem + types | **Thin seam** — `Metasound`/`SteamAudio` are engine plugins | | **V4VFX** | `V4VFX/` (4) | `V4VFX` subsystem + types | **Thin seam** — `Niagara` is the engine plugin | | **V4Cinematics** | `V4Cinematics/` (8) | Sequencer-driven setpiece/boss-intro/finisher hooks | `Sequencer` + `MovieRenderPipeline` (editor-gated) | | **V4Persistence** | `V4Persistence/` (18) | save-game, profile, currency ledger, contract progress, replays | `Serialization`; substantial, not a stub | | **V4OnlineServices** | `V4OnlineServices/` (34) | `V4LoginSubsystem`, `V4FriendsSubsystem`, `V4PartySubsystem`, `V4MatchmakingSubsystem`, `V4LeaderboardSubsystem`, `V4ReplayUploadSubsystem`, `V4CrossplaySubsystem` | **Deepest module** — rides `OnlineServicesEOS`; cloud is Rust | | **V4Telemetry** | `V4Telemetry/` (4) | on-device event emitter | Pipeline is the `telemetry-ingest` Rust crate | | **V4Editor** | `V4Editor/` (5) | in-editor schedule/contract tooling | Authoring UIs live in `V4Mode_Editor_*` + `V4Tools_*` plugins | | **V4Vehicles** | `V4Vehicles/` (10) | helo/light-vehicle + RTS unit-vehicle bridge | `ChaosVehicles` + `GeometryCollectionEngine` | | **V4Procgen** | `V4Procgen/` (4) | roguelike layout generator | `PCG` | | **V4LevelOps** | `V4LevelOps/` (8) | NPC-schedule and environmental-kill authoring | Layered over `V4Schedules` | | **V4Tests** | `V4Tests/` (96) | 90 `*Spec.cpp` + gauntlet/golden-replay harness | Depends on every runtime module **and** the `V4Mode_*` plugins | ### The cell modules deliver their advertised feel The product's whole "per-cell feel" thesis rests on the cell modules, and the disk backs it concretely: each cell's glossary line is a list of components that actually exist. `V4Stealth` is the clearest case — its line "light/shadow gauge, sound footprint, body-drag, disguise" ships as exactly `V4LightGaugeComponent`, `V4SoundFootprintComponent`, `V4BodyDragComponent`, and `V4DisguiseComponent`. `V4RTS` spells "economy, build orders, unit production, fog of war, tech" onto `V4ResourceComponent`/`V4BuildComponent`/`V4TrainComponent`/`V4FogOfWarComponent`/ `V4TechTreeComponent`, with `V4WonderComponent` for the Age-of-Empires lineage and `V4PathfindingSubsystem` for the micro. `V4Tactics` carries the Commandos/ Desperados party on `V4PartyComponent` and `V4CommandQueueComponent`, with the Desperados Showdown time-stop in its own `V4ShowdownModeSubsystem`. This is the load-bearing difference from V2's glossary: there, three subsystems were thin seams; here, the cell modules are where the file count and the design vocabulary both concentrate. The deep treatment of each cell is the shared-engine page, [./shared-cross-cell-engine.md](./shared-cross-cell-engine.md). ### The shared spine, the AI senses, and the net paths Beneath the cells sit the modules every cell leans on. `V4Core` is the graph sink — the tag registry, save scaffolding, and dev cheats — and `V4Gameplay` is the GAS layer (abilities, attribute sets, gameplay effects, match-state) that the cell abilities (`V4TacticalAbilities`, `V4StealthAbilities`, `V4RTSAbilities`, …) extend. `V4Animation`, `V4Input`, and the AI trio (`V4Perception`, `V4Crowd`, `V4Schedules`) are shared services: `V4Perception` is the **one** sight/sound model — `V4PerceptionComponent` feeding a `V4SuspicionStateMachine`, rendered by `V4VisionConeDecalRendererComponent` — that the stealth, tactics, and tactical cells all query, so "vision cones" mean the same thing in Hitman and in Commandos. `V4Netcode` is where the glossary's three-net-path promise is real code rather than prose: `V4ClientServerNetcode` for the default, the `V4RTSLockstepSubsystem`/`V4RTSLockstepReplay` pair for RTS deterministic lockstep, and `V4RollbackEmulatedComponent` for rollback-emulated PvP, with `V4LocalDeterminism` and `V4AntiCheatSubsystem` alongside. The architecture companion's caveat applies in full: that determinism logic lives **inside** `V4Netcode`/`V4RTS`, not stamped onto the build by a `.Target.cs`, so read the determinism posture as a module-level intent — see [./product-promise-and-conventions.md](./product-promise-and-conventions.md) for how that shapes the product promise. ### Presentation, online, persistence, and the thin seams `V4UI` (17 files) is the CommonUI/MVVM front-end — `V4HUDViewModel`, `V4MVVMRegistry`, and the accessibility surface (`V4AccessibilitySubsystem`, `V4FocusGraphAsset`) — and it is where the glossary's "mode-specific HUD" genuinely lives, which is why it depends on `V4Stealth`. The honest seams to keep in mind are `V4Audio` (12 files) and `V4VFX` (4 files): they own the gameplay-facing subsystem but bind capability the engine plugins (`Metasound`, `SteamAudio`, `Niagara`) provide. The counter-example is `V4OnlineServices`: at 34 files it is the **deepest module on disk**, owning the login/friends/party/ matchmaking/leaderboard/replay-upload/crossplay subsystems — the client half of the online surface, with the Rust `online-services` crate as the cloud half. `V4Persistence` (18 files) carries the save/currency-ledger/ contract-progress data, `V4Telemetry` (4 files) is the on-device emitter whose pipeline is the `telemetry-ingest` crate, and `V4Vehicles`/`V4Procgen`/ `V4LevelOps` round out the world layer. ## The plugin and cell structure The cells become a shippable product through the **28 enabled `V4Mode_*` plugins** that live **directly under `V4/ue/Plugins/`** (not in a `Plugins/GameFeatures/` subfolder). Each is a code+content plugin: a `.uplugin` declaring a `Runtime` module, a `Source/` tree, and a `Content/` tree. The glossary's plugin table lists 27 of them — five tactical (`V4Mode_Tactical_RavenShield`/`R6Modern`/`CoDCampaign`/`CoDMultiplayer`/ `CoDWarzone`), four stealth (`SplinterCell`/`SpiesVsMercs`/`Hitman`/ `ContractsAuthor`), the two RTST (`Commandos`/`Desperados`), two ARPG, three RTS, two arcade, and the cross-cell modes (`SpecOps_Coop`, `HordeDefense`, `Roguelike_TacticalCampaign`, the two `Editor_*`, `Replay`, `Spectator`, `Training_Range`, `Lobby_BattleHub`). Their depth tracks the cell complexity: `V4Mode_Tactical_CoDWarzone` is the heaviest, the campaign and asymmetric tactical plugins are mid-weight, and the lighter arcade/ARPG modes are leaner — all real C++, ~234 authored `.cpp`+`.h` files across the plugin tree. ### How a cell plugin is wired A representative plugin is `V4Mode_ARPG_Wukong`. Its runtime `Build.cs` depends on exactly `Core`, `CoreUObject`, `Engine`, `GameplayTags`, plus `V4Core`, `V4Modes`, and `V4ActionRPG` — i.e. the plugin binds its **cell module** to the **mode-registration layer**. This is the structural shape of every cell plugin: it contributes no new gameplay system of its own, it composes one cell module with `V4Modes` and content. The `.uplugin` sets `"EnabledByDefault": false`, and the `.uproject` then force-enables it — which is why the "hot-swap / DLC-gate without a rebuild" billing is aspirational: the plugins are not `ExplicitlyLoaded` runtime features. The activation hook the framing _wants_ does exist, as `UV4GameFeatureAction_ActivateModeAssets` inside `V4Modes`; it is wired, just not exercised as a true runtime toggle yet. ### What the plugin table omits Reading `Plugins/` against the glossary table turns up three honest additions: - **`V4Mode_Crossover_ShadowWar`** — a real, enabled crossover plugin (ten `.cpp`+`.h`) that the 27-row table does not list. It is the disk's expression of the unifying "Shadow War" narrative that lets a Hitman target matter to a StarCraft skirmish. - **`V4Tools_DataLinter`** — a second editor linter alongside the documented `V4Tools_AssetLinter`. Both are editor plugins, neither is a runtime cell. - **Four `V4DLC_*` plugins** (`ADR_CommunityRemix01`, `ADR_ParodyPack01`, `Campaign_Season01_Blacksite`, `Operator_Season01_Nyx`) that are **content-only** (zero `.cpp`) and **not enabled** in the `.uproject` — season containers, not runtime code. They are the only place the "DLC-gated plugin" shape literally exists, and they are empty of logic by design. Note also the omitted-from-the-table `V4` **primary game module** (six files): unlike V2's composition root, it depends on **no** `V4*` module — its `Build.cs` lists only `Core`/`CoreUObject`/`Engine`/`GameplayTags`/`InputCore` — and is a thin bootstrap (`UV4BootstrapSubsystem`) named by all three build targets. The real fusing happens through the cell plugins, not a monolithic root. ## Repository surfaces V4 is unusually self-contained; four homes hold all of it, and three are under `V4/` itself. Target paths are real today except where marked **planned**. | Surface | Target path | State | | ------------------------- | ------------------------------------------ | -------------------------------------------------------------------------- | | Game client | `V4/ue/` | Real — 28 modules, 3 targets, 28 `V4Mode_*` + 2 `V4Tools_*` plugins | | Marketing site | `apps/v4/web/` | Real — `@v4/web`, Next.js (port 3045) | | Spectator / esports | `apps/v4/spectator/` | Real — `@v4/spectator`, Next.js (port 3044) | | Companion app | `apps/v4/companion/` | Real — `@v4/companion`, Expo/React Native (AR replay) | | Esports toolkit | `V4/tools/esports/` | Real — the only populated `tools/` subdir | | Online services backend | `apps/v4/` | Real — **3 Rust crates** (`shared`, `telemetry-ingest`, `online-services`) | | Mission / RTS / art tools | `V4/tools/{missions,rts-maps,arcade-art}/` | **Planned — not created** | The game client carries three build targets — `V4` (Game), `V4Editor` (Editor), and `V4TournamentServer` (Server) — all minimal; the server target adds only four broadcast defines (`V4_TOURNAMENT_BUILD`, `V4_BROADCAST_TOOLS`, `V4_OBSERVER_CAMERAS`, `V4_PAUSE_ON_DISCONNECT`) and no extra source. The Rust backend folds the layout's nine-service list into one large `online-services` crate (~8,581 lines: OAuth, matchmaking, brackets/leaderboards, an SFU, and the HTTP surface) plus the lean `shared` (343) and `telemetry-ingest` (587) crates. Because there is no `libs/contracts/src/v4`, V4's data contracts live in UE C++ `UDataAsset`/`DataTable` types and the per-service Rust structs, not a shared cross-language registry — the same posture V2 took, a deliberate contrast with V3. The many top-level `V4/` directories (`balance/`, `modes/`, `maps/`, `codex/`, `narrative/`, `liveops/`, `progression/`, `loc/`, …) are JSON/Markdown authoring and ops data, not compiled code — V4 ships essentially no binary content (one `.uasset`/`.umap` in the whole tree); it is a C++ logic skeleton. ## Cross-reference conventions The whole feature set uses one citation grammar so a reference is never ambiguous about which document it points into: - **Bare `§N` / `§N.M` → `V4_TODOS.md`.** The backlog is the only V4 document with section numbering used as hyperlinks, so an unqualified `§40` means `V4_TODOS.md` §40. - **`deps§N` → `V4_DEPENDENCIES.md`** (e.g. `deps§14`). - **`arch§""` → `V4_ARCHITECTURE.md`** by named section anchor. - **`features§""` → this document set** by named anchor. `V4_features.md` and `V4_ARCHITECTURE.md` (and these split pages) use **named anchors, not numbers**, precisely so they never duplicate or drift from the backlog's numbering scheme. When a page cites a feature by name, follow the anchor; when it cites a `§`, open the backlog. ## Where to go next - The promise these foundations serve, and the player-facing conventions: [./product-promise-and-conventions.md](./product-promise-and-conventions.md). - The shared spine and the five cells as player features — GAS, perception, netcode, and per-cell feel: [./shared-cross-cell-engine.md](./shared-cross-cell-engine.md). - The authoritative engine module map, dependency graph, and build targets: [../architecture/glossary.md](../architecture/glossary.md). - The feature catalogue this page indexes: [../V4_features.md](../V4_features.md).