Fighting Game · Guides & deep dives

V2 Documentation Guide

The map is a reading model, not a completion claim.

6sections4 minread1table

On this page

This guide is the curated front door to V2: the Unreal Engine 5 competitive fighting game, its racing and open-world extensions, its online and esports services, and the production system that turns authored combat data into a deterministic, supportable release. It explains which document answers which question and keeps product intent separate from implementation evidence.

V2 is unusually broad for a fighter. Its canonical scope includes multiple combat ruleset families, tag and assist play, training and replay, signature modes, a large roster, ranked and tournament operations, a peer racing game, community and commerce, accessibility, localization, and platform production. The documentation therefore has two levels: complete feature and architecture hubs that preserve stable anchors, and focused pages that make individual systems readable and code-grounded.

Documentation map#

V2 documentationMind map: 25 ideas.V2 documentationProductCombat and game feelModes roster and stagesOnline esports and liveserviceRacing and open worldAccessibility productionand launchArchitectureDeterministic combat coreRollback and onlinebackbonePresentation and interfaceVehicles and world modesBuild data telemetry andsecurityDelivery truthV2 backlogDependency registryProduct reviewVerification remediationBalance and patchevidenceOperator detailAgent executionDecisionsIntegration notesTelemetryLegal and release records
Mind map: V2 documentation. Mind map: 25 ideas.

Drawn from its Mermaid source.

As text
Tree:
- V2 documentation
  - Product
    - Combat and game feel
    - Modes roster and stages
    - Online esports and live service
    - Racing and open world
    - Accessibility production and launch
  - Architecture
    - Deterministic combat core
    - Rollback and online backbone
    - Presentation and interface
    - Vehicles and world modes
    - Build data telemetry and security
  - Delivery truth
    - V2 backlog
    - Dependency registry
    - Product review
    - Verification remediation
    - Balance and patch evidence
  - Operator detail
    - Agent execution
    - Decisions
    - Integration notes
    - Telemetry
    - Legal and release records
Show source
mindmap
  root((V2 documentation))
    Product
      Combat and game feel
      Modes roster and stages
      Online esports and live service
      Racing and open world
      Accessibility production and launch
    Architecture
      Deterministic combat core
      Rollback and online backbone
      Presentation and interface
      Vehicles and world modes
      Build data telemetry and security
    Delivery truth
      V2 backlog
      Dependency registry
      Product review
      Verification remediation
      Balance and patch evidence
    Operator detail
      Agent execution
      Decisions
      Integration notes
      Telemetry
      Legal and release records

The map is a reading model, not a completion claim. The feature and architecture documents describe the intended contract and its known implementation shape; the backlog, current code, tests, builds, provider readback, and dated release evidence establish what is actually supported.

Start with the question#

Question Canonical starting point What it proves
What does V2 promise players? Feature hub and focused feature index Product scope, surfaces, modes, user-visible behavior, and explicit spec-only seams.
How does combat remain deterministic? Architecture hub, combat core, and rollback Frame authority, data ownership, rollback/resimulation, tag simulation, and validation boundaries.
How do online, ranked, tournament, and esports paths compose? Online feature guide, online backbone, and esports services Player contract plus service topology, competitive-integrity controls, and broadcast/companion boundaries.
Is racing a mini-game or a peer system? Racing features and vehicle architecture Vehicle data, physics, tracks, online racing, crossover modes, and shared platform seams.
What is implemented now? V2 backlog, product review, current tests/builds, and dated verification records The most conservative evidence-backed completion state.
Which external or shared systems are required? Dependency registry Ownership, version, integration, and fallback expectations.
How should an implementation task be executed? Agent execution and the affected focused feature/architecture pages Change order, evidence expectations, and nearby contracts.
Where are the visual models? V2 diagram atlas and the generated Docs Center diagram gallery Curated product/runtime mental models and every authored diagram by source heading.

Truth and release model#

State diagramState diagram: 10 states and 10 transitions.approved data assets or configuration existruntime code consumes the contractgame service and platform paths composedeterministic automated and platform evidence passescook certification operations and rollback passnamed production or integration seam remainsprovider platform or evidence is unavailablenewer evidence breaks the supported claimrepair returns below the release gateSpecifiedAuthoredImplementedIntegratedVerifiedReleaseReadySpecOnlyWithheldRegressed
State machine: State diagram. State diagram: 10 states and 10 transitions.

This picture is wider than it can be shown here. Move across it, or read it as text.

Drawn from its Mermaid source.

As text
Parts:
- Start (initial)
- Specified
- Authored
- Implemented
- Integrated
- Verified
- ReleaseReady
- SpecOnly
- Withheld
- Regressed

Connections:
- Start to Specified
- Specified to Authored: approved data assets or configuration exist
- Authored to Implemented: runtime code consumes the contract
- Implemented to Integrated: game service and platform paths compose
- Integrated to Verified: deterministic automated and platform evidence passes
- Verified to ReleaseReady: cook certification operations and rollback pass
- Implemented to SpecOnly: named production or integration seam remains
- Integrated to Withheld: provider platform or evidence is unavailable
- Verified to Regressed: newer evidence breaks the supported claim
- Regressed to Implemented: repair returns below the release gate
Show source
stateDiagram-v2
  [*] --> Specified
  Specified --> Authored: approved data assets or configuration exist
  Authored --> Implemented: runtime code consumes the contract
  Implemented --> Integrated: game service and platform paths compose
  Integrated --> Verified: deterministic automated and platform evidence passes
  Verified --> ReleaseReady: cook certification operations and rollback pass
  Implemented --> SpecOnly: named production or integration seam remains
  Integrated --> Withheld: provider platform or evidence is unavailable
  Verified --> Regressed: newer evidence breaks the supported claim
  Regressed --> Implemented: repair returns below the release gate

Use the lowest state current evidence supports. A populated roster table is not a cooked roster; an ability class is not a balanced match; a rollback unit test is not an online tournament; a service adapter is not a production provider; and a checked backlog item is not newer than a failing build or certification result. Focused pages deliberately label implemented, scaffolded, fixture, spec-only, and deferred behavior.

From V2 question to verified changeUser journey: 8 stages.1Open the feature index and release scopeOrient. Product, Design. Score 5 of 5.2Pair the feature with its architecture pageOrient. Engineering. Score 5 of 5.3Follow authored data through runtime and servicesTrace. Engineering. Score 5 of 5.4Inspect authority determinism and failure pathsTrace. Engineering, QA. Score 5 of 5.5Check backlog dependencies and dated evidenceEstablish truth. Product, QA. Score 5 of 5.6Reproduce focused and end-to-end testsEstablish truth. QA. Score 5 of 5.7Validate cook performance certification and rollbackRelease. Release, SRE. Score 5 of 5.8Update docs diagrams and evidence togetherRelease. Owners. Score 5 of 5.
User journey: From V2 question to verified change. User journey: 8 stages.

Drawn from its Mermaid source.

As text
Steps:
- 1. Open the feature index and release scope (good). Orient. Product, Design. Score 5 of 5.
- 2. Pair the feature with its architecture page (good). Orient. Engineering. Score 5 of 5.
- 3. Follow authored data through runtime and services (good). Trace. Engineering. Score 5 of 5.
- 4. Inspect authority determinism and failure paths (good). Trace. Engineering, QA. Score 5 of 5.
- 5. Check backlog dependencies and dated evidence (good). Establish truth. Product, QA. Score 5 of 5.
- 6. Reproduce focused and end-to-end tests (good). Establish truth. QA. Score 5 of 5.
- 7. Validate cook performance certification and rollback (good). Release. Release, SRE. Score 5 of 5.
- 8. Update docs diagrams and evidence together (good). Release. Owners. Score 5 of 5.
Show source
journey
  title From V2 question to verified change
  section Orient
    Open the feature index and release scope: 5: Product, Design
    Pair the feature with its architecture page: 5: Engineering
  section Trace
    Follow authored data through runtime and services: 5: Engineering
    Inspect authority determinism and failure paths: 5: Engineering, QA
  section Establish truth
    Check backlog dependencies and dated evidence: 5: Product, QA
    Reproduce focused and end-to-end tests: 5: QA
  section Release
    Validate cook performance certification and rollback: 5: Release, SRE
    Update docs diagrams and evidence together: 5: Owners

Product, design, and balance#

Begin with the focused feature index, then read the relevant combat, mode, roster, online, racing, platform, or launch page. Pair it with the owning architecture page before changing frame data, economies, entitlements, matchmaking, or live-service behavior. Balance changelogs and patch notes are atomic records; they supplement rather than replace the system contract.

Engineering and technical art#

Begin with the architecture index. Trace a feature through authored data, UE modules/plugins, deterministic simulation, presentation, online services, persistence, telemetry, build/cook, and tests. Confirm whether referenced paths are implemented or target paths—the V2 docs explicitly retain planned paths when the corresponding backlog task has not yet created them.

QA, competitive integrity, and accessibility#

Test local and online success, disconnect, rollback, replay takeover, stale input, version mismatch, denial, platform loss, long content, assistive technology, and recovery states. Competitive claims require deterministic hash/replay evidence and real server authority; accessibility claims require the actual supported device and modality, not only a settings schema.

Release, security, support, and live operations#

Read the telemetry/performance/release, security/compliance, live-ops, support, and balance-operations pages together. Verify store/platform configuration, entitlement and refund behavior, anti-cheat/provider posture, observability, content compatibility, rollback, and current operator evidence.

Page-set organization#

  • Feature index — 16 focused topics grouped by orientation, combat, modes, roster/creator, online/live service, racing, and platform/launch.
  • Architecture index — 16 focused topics grouped by deterministic core, presentation, world/vehicles, services, and platform engineering.
  • V2 diagram atlas — the cross-system visual vocabulary for matches, identity, replay, modes, modules, production, and release.
  • Backlog and dependencies — delivery order and external/shared requirements.
  • balance/, docs/decisions/, docs/integration/, and docs/telemetry/ — intentionally atomic operational and decision records.

Documentation quality contract#

A V2 documentation change is complete when the focused page remains substantial, its product and architecture boundaries agree, all focused pages remain indexed exactly once, complex relationships have an adjacent diagram, status language matches current evidence, links and source paths resolve, and the generated reader/search/diagram views render on desktop and mobile. Changes to behavior must update code, contracts, tests, backlog state, and release or operator evidence as applicable—not prose alone.

The Docs Center HTML is generated. Edit Markdown, canonical code, schemas, or evidence; then regenerate and pass integrity, freshness, focused unit, and browser checks.