Subsystem Glossary & Plugins

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 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.

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.

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.

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 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.

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§"<anchor>" → V4_ARCHITECTURE.md by named section anchor.
• features§"<anchor>" → 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.
• The shared spine and the five cells as player features — GAS, perception, netcode, and per-cell feel: ./shared-cross-cell-engine.md.
• The authoritative engine module map, dependency graph, and build targets: ../architecture/glossary.md.
• The feature catalogue this page indexes: ../V4_features.md.