# Racing × Fighting Crossover, Open World & Ops ```mermaid stateDiagram-v2 [*] --> Driving Driving --> VehicleCombat: governed pickup collision or weapon intent VehicleCombat --> Driving: vehicle remains operable Driving --> Disabled: damage or scripted crossover threshold Disabled --> OnFoot: safe egress and fighter state initialized OnFoot --> Fighting: compatible combat ruleset begins Fighting --> Driving: eligible vehicle re-entry Fighting --> Resolved: crossover objective completes Driving --> Resolved: race or world objective completes Disabled --> Recovering: egress or authority failure Recovering --> Driving: prior checkpoint restored ``` Vehicle, on-foot, and fight states use different simulation contracts. The crossover must transfer authority, inventory, health, objective, camera, and accessibility state explicitly rather than treating egress as a cosmetic cue. V2 ships a fighting game and a racing game that share one roster, one online backbone, one store, one Battle Pass, and one currency ledger — and the place those two genres actually _touch_ is the crossover. A roster fighter can climb into any vehicle; a totaled car can dump its driver onto the asphalt to settle the race with fists in the ruleset of their choice; a ram at speed can be an intentional melee attack that combos through the same GAS layer the stand-up fight uses. This page covers that seam — the **Racing × Fighting crossover** (Fighter-Driver and Get-Out-and-Fight, §118), the **vehicle-combat crossover** modes that weaponize the city (Demolition Derby, Vehicle-Hijack, Fight-On- Vehicle, truck-bike chases, convoy raids, §123) — plus the **open-world content** those modes inhabit (the Convoy free-roam lobby, the co-op Heist, the persistent city) and the **racing compliance, trophies, anti-cheat, and accessibility ops** (§119) that have to be in place before any of it ships. It is the feature-side companion to the racing component; the section hub is [../V2_features.md](../V2_features.md). ## What ships, honestly Every crossover and compliance surface on this page is a **validated C++ data catalogue with a deterministic resolver and a contract automation spec**, built to the same target-artifact discipline as the rest of V2 — the logic is real and the binaries it names are not yet on disk. - **The crossover catalogues are real, validated, and exercise genuine runtime math.** `FV2RacingFightingCrossoverCatalog` (§118) and `FV2VehicleCombatCrossoverCatalog` (§123) live in the `V2RaceModes` module, each built by a `BlueprintPure` factory, each gated by an `IsValidCatalog` validator with a human-readable failure reason, each pinned by a dedicated spec (`V2/ue/Source/V2Tests/Private/Racing/RacingFightingCrossover.spec.cpp`, `VehicleCombatCrossover.spec.cpp`). The Get-Out transition, the vehicle-melee damage split, and the demolition-round resolution are **deterministic functions asserted against exact numbers** — not stubs. - **The compliance/cert catalogue is real and registered.** `FV2RacingComplianceCertCatalog` (§119, `V2Racing` module) carries the licensing, region, content-safety, trophy, anti-cheat, cert, and accessibility specs, validates as a unit, hashes to a deterministic signature, and registers into `UV2RaceRegistrySubsystem`. - **No binaries ship for any of it.** `Race.Crossover.GetOutAndFight` is a synthesized Game Feature plugin _URL_, not a `.uplugin` on disk; the cinematic ids (`Cine.Crossover.DriverExit.VehicleKO`) and arena ids are convention strings; there are no `.umap`/`.uasset` crossover arenas. The resolvers compute the _outcome_ of a get-out-and-fight or a derby round; the cinematic, the arena spawn, and the GAS handoff that would play that outcome are target artifacts. - **One honest correction to the architecture notes.** The open-world architecture companion files the Convoy free-roam lobby under "`V2RaceModes`." In the shipped tree it actually lives in **`V2OnlineServices`** (`FV2ConvoyFreeRoamLobbyCatalog`, spec `V2.Online.ConvoyFreeRoamLobby.Contract`) with its cooked data under `V2/balance/racing/`. The capability is real; the module attribution in prose was off by one. The deeper module topology, the analytical physics solver, the vehicle data model, and the determinism boundary that all of this rests on are documented in [../architecture/racing-and-vehicle-architecture.md](../architecture/racing-and-vehicle-architecture.md); the persistent-world and co-op surfaces are in [../architecture/open-world-coop-and-special-modes.md](../architecture/open-world-coop-and-special-modes.md). This page stays on the feature surface and dips into C++ only where a claim needs backing. ## The crossover: Fighter-Driver & Get-Out-and-Fight (§118) ### Fighter-as-driver Every roster fighter is also a driver. `FV2RosterFighterDriverSpec` (`V2RaceModeTypes.h:2761`) binds a `FighterId` to a `SignatureVehicleId`, a `DrivingPersonality` (an `EV2AIDriverPersonality`), and per-fighter and per-matchup banter line-sets, and the §118 catalogue ships a sample roster of **at least eight** fighter-drivers (`Catalog.FighterDrivers.Num() >= 8`). The validator (`IsValidFighterDriver`, `V2RaceModeTypes.cpp:1885`) encodes two design rules worth calling out because they are _enforced_, not aspirational. First, **a fighter can drive any vehicle** while their signature vehicle is gated behind both Mastery _and_ a Side Story (`bCanDriveAnyVehicle && bSignatureVehicleUnlockedViaMastery && bSignatureVehicleUnlockedViaSideStory`). Second — and this is the one that protects competitive integrity — **a fighter's driving personality affects AI drivers only and must never bias the player's own handling** (`bAIPersonalityAffectsAIDriverOnly && bPlayerDrivenIgnoresPersonalityBias`). The catalogue's spec actively _rejects_ a build where `bPlayerDrivenIgnoresPersonalityBias` is flipped off, so a personality bias can never silently leak into a human's inputs. Banter is likewise required to extend to racing events with per-fighter and per-matchup driving-context lines. ### Get-Out-and-Fight, resolved The headline crossover mechanic is the transition itself. `FV2GetOutAndFightTransitionSpec` (`V2RaceModeTypes.h:2862`) pins `RaceModeId = "Race.Crossover.GetOutAndFight"`, a vehicle-KO state of `VehicleDamage.Totaled`, a driver-exit cinematic id, and a `SupportedRulesets` list that must cover all seven fighting families — MK, SF, Tekken, WWE, UFC, SC, and DJ (`EV2CrossoverFightingRuleset`, `HasRequiredRulesets`, `V2RaceModeTypes.cpp:1906`). When a car is totaled, the driver gets out and the match resumes as a stand-up fight in the chosen ruleset, on the same GAS combat core as the rest of the game. The resolver is a pure function: `ResolveTransition(bool bDriverAVehicleTotaled, bool bDriverBVehicleTotaled)` (`V2RaceModeTypes.cpp:1942`) returns an `FV2GetOutTransitionResult` describing who exits and whether a fight begins. Its behaviour is asserted exactly: - One car totaled (`true, false`) → that driver alone exits and the fight begins; the other keeps driving; `bBothOut` stays false. - Both totaled (`true, true`) → `bBothTotaledForcesBothDriversOut` fires, both drivers are out, and the fight begins. - Neither totaled (`false, false`) → nobody exits, no fight. This is the runtime expression of the `V2Vehicles` damage model's `bTotaledTriggersRetireOrGetOutAndFight` hook (see the racing architecture companion): the five-tier damage ladder bottoms out at `Totaled`, and `Totaled` is where racing hands off to fighting. The fight plays on a `FV2CrossoverStageArenaSpec` — a designated **track stretch or off-track area** turned into an arena, with environmental finishers eligible and cross-referenced to the §14/§15 hotspot finisher library. The outcome (`FV2CrossoverFightOutcomeSpec`) returns the winner to a salvageable vehicle — their own or, optionally, the loser's claimed car — and eliminates the loser from the race. ### Vehicle-on-vehicle melee Combat racing lets a ram _be_ an attack. `FV2VehicleMeleeCombatSpec` cross- references Combat Racing (§104) and the GAS layer (§2), and tracks melee damage separately from raw collision damage (`bMeleeDamageTrackedSeparatelyFromSpeedDamage` — a flag the spec rejects merging). Its resolver `ResolveImpactDamage(float ImpactSpeedKph, bool bIntentionalRam)` (`V2RaceModeTypes.cpp:1994`) computes `SpeedDamage = round(speed × 0.5)` for _every_ impact and adds `MeleeDamage = round(20 + speed × 0.3)` only when the ram was intentional. The spec nails the arithmetic: a 120 kph intentional ram books **60** speed damage and **56** melee damage; the same speed as an incidental bump books 60 speed damage and **zero** melee. Intent, not just velocity, is what turns a collision into a combo opener. The crossover catalogue rounds out with a signature-event sequence (race-to-venue beats), a per-fighter get-out cinematic library (get-out → stance → return → re-enter → drive-away), a **shared economy** that spends Fighter Coins and Racing Coins against one store plus a shared Battle Pass, and an **opt-in ranked queue with MMR separate from pure racing** (`bSeparateMMRFromRacing`, rejected if shared). The whole catalogue hashes through `BuildRacingFightingCrossoverCatalogSignature` so any content drift trips CI, and its cooked mirror is `V2/balance/racing/racing-fighting-crossover.json`. The `Race.Crossover.GetOutAndFight` plugin descriptor is registered in the race-mode plugin catalogue with `Kind == Crossover` and `RequiredModules` that include `V2Combat` and `V2Cinematics`. ## Vehicle-combat crossover modes (§123) `FV2VehicleCombatCrossoverCatalog` collects the modes where vehicles and fists mix on the open road. The contract spec validates §123 and rejects a long list of malformed builds (a derby below four cars, a hijack without the input RPS, a fight-on-vehicle without pod-racer compatibility, a convoy raid without the armored-helicopter cargo, a queue without separate MMR). - **Demolition Derby** is an enclosed-bowl, last-vehicle-standing arena for **4–16** cars (`MinVehicles == 4`, `MaxVehicles == 16`) with per-vehicle HP, collision damage, and driver melee weapons — punch-through-window, headbutt, and mounted weapons (cross-ref §104.2). Arena types must cover classic bowl, figure-8, industrial yard, stadium, and parking-garage multi-level; KO uses the §97.8 `Totaled` state with a cinematic flaming-vehicle KO; team formats cover 2v2/4v4 with a shared-HP-pool option. Its resolver `ResolveDerbyRound(const TArray& VehicleHP)` (`V2RaceModeTypes.cpp:2211`) counts survivors, lists eliminated indices, and ends the match at one (or zero) survivor: `{100, 0, 50, 0, 80}` → 3 survive, 2 wrecked, match continues; `{0, 0, 0, 90}` → match over, sole winner at index 3; a total wipeout ends with `WinnerVehicleIndex == -1`. - **Vehicle-Hijack** is a mid-race steal: enabled only under the Combat Racing crossover ruleset (§104), it triggers when alongside an opponent, runs a driver-side-window melee **input-RPS contest**, and on success transfers both the vehicle and the race position — at a meter or power-up cost, with a per-hijack cinematic and attacker/defender input prompts. - **Fight-On-Vehicle** is cinematic two-fighter combat on a moving vehicle along an open-world street route, with passing-traffic, overpass, and cop-pursuit hazards. Compatibility covers convertibles, trucks, bike-rider-vs-rider, and pod-racer-cockpit-vs-cockpit, each with an authored fight stage, and its finishers adapt the §14.2 hotspot library to the road: toss an opponent into oncoming traffic, ram a bike into a pillar, throw a rival from a pod-racer into a chasm. - **Truck-Bike Chase** is one heavy truck pursuing **1–3** bike riders who attack the truck (climb-aboard finisher, lasso a truck pillar) while the truck rams them off the road, across bandit/cartel/rival-crew/cop-vs-fugitive scenarios. - **Convoy Raid** is **2–4** attackers versus an AI convoy defending valuable cargo (armored car, truck, multi-vehicle convoy, armored helicopter, celebrity mobile stage): the crew splits into drivers who chase and fighters who board and steal, while defenders fight back and call backup. All five modes expose a ranked queue, and the catalogue enforces **separate MMR per queue** for every one of them. Cooked data: `V2/balance/racing/vehicle-combat-crossover.json`. ## Open-world content the crossover lives in ### Convoy & free-roam lobby (§121) The social space the crossover modes spawn from is the free-roam lobby — implemented in `V2OnlineServices` as `FV2ConvoyFreeRoamLobbyCatalog` (`V2OnlineServicesTypes.h:10994`), validated by the `V2.Online.ConvoyFreeRoamLobby.Contract` spec. The `FV2FreeRoamLobbySpec` places **8–32** players into open-world Metro City on a client-server instance (`ModeId "Mode.Racing.FreeRoamLobby"`), with a **synchronized day/night and weather** state shared across the instance — the spec rejects a lobby capped below 32, a lobby with unsynchronized weather, or any attempt to attach ranked progression (`bNoRank` is mandatory). `FV2ConvoyFormationSpec` locks **2–8** players into a shared waypoint with a `ResolveFormation(...)` resolver returning an `FV2ConvoyFormationState`, and a challenge library that must include cop-pursuit. Around it sit district hot-spots (the harbor pier among them), a cruise photo session where one player drives the camera, open-world chat with platform-compliance gating and a cosmetic horn library, and co-op cruise objectives (escort fragile cargo, and friends) — all cosmetic/XP only, never ranked. Cooked data: `V2/balance/racing/convoy-free-roam-lobby.json`. ### Heist & the persistent city The Heist (§122) is V2's co-op crossover campaign — a 1–4 player mission that chains stealth, driving, and fighting through five authored stages (Recon → Approach → Infiltration → Extraction → Resolution), implemented entirely on-device as `FV2HeistModeCatalog` in `V2Modes` with the deterministic `ResolveHeistRun(const TArray&)` resolver and cooked data at `V2/balance/racing/heist-mode.json`. Its Infiltration stage runs the same GAS combat as the stand-up game, which is exactly why it belongs to the crossover family. The living backdrop for all of this is the §130 persistent world economy — a `V2World` module with deterministic supply/demand pricing, NPC daily-routine scheduling, and a crime-gauge→heat→lockdown chain (`V2/balance/world/persistent-world-economy.json`). Both are covered in depth in [../architecture/open-world-coop-and-special-modes.md](../architecture/open-world-coop-and-special-modes.md); this page notes only that the crossover modes inhabit them rather than re-deriving them. ## Racing compliance, trophies, anti-cheat & accessibility (§119) None of the above is shippable without the §119 compliance/cert layer, which V2 models as one validated catalogue, `FV2RacingComplianceCertCatalog` (`V2RaceTypes.h:1046`, `SectionId "119"`), registered into the race registry (`RegisterRacingComplianceCertCatalog`) and asserted across `Racing.Module.spec.cpp:155–166`. **Licensing and damage.** Every licensed vehicle carries an `FV2RacingVehicleLicenseContractSpec` recording a manufacturer-signed contract with term, royalty schedule, removal clause, and a **damage-portrayal clause**. Permissibility is per-manufacturer via `FV2RacingManufacturerDamagePolicySpec`: `LicensedLuxuryPermission` defaults to `CosmeticOnly` while `OriginalIPPermission` allows `FullDamage` — so a licensed luxury brand never visibly deforms past the Scuffed tier while original-IP vehicles run the whole five-tier ladder to Totaled. This is the contract side of the `V2Vehicles` damage model. **Content rules and regions.** `FV2RacingRegionVariantSpec` switches the speed display between km/h and mph, localizes the number-plate format, and carries a `bChinaPublisherSKUAdjustsCopVisuals` flag (the spec checks `RegionVariants[2]` sets it) and a combat-racing-weaponry variant. `FV2RacingContentSafetyPolicySpec` hard-codes the bright lines: **no drunk or impaired-driving depiction anywhere**, **no cop killing outside the Death Race ruleset**, pursuit rules that "incapacitate, not kill," and lethal language confined to Death Race. The catalogue points at the real region doc `V2/docs/regions/racing-variant.md`. **Trophies and anti-cheat.** `FV2RacingTrophyAchievementPlanSpec` spans per-platform targets and objective kinds — per-mode completion, per-vehicle-class unlock, per-rank-tier promotion, and special-condition unlocks such as `Achievement.Racing.CanyonNoFlashback`. Anti-cheat (`FV2RacingAntiCheatGateSpec`) is server-side by design — racing runs client-server, not rollback — and layers three gates: **per-section physics-impossible-time detection** (a sector time below the achievable minimum flags, cross-ref §112.7), the **replay-determinism gate** on race-record writes (`Gate.Racing.RecordWrite.ReplayDeterminism`), and **tuning-range enforcement** against a valid-ranges table (`Table.Racing.Tuning.ValidRanges`) that flags any out-of-range tune. **Peripherals and accessibility.** `FV2RacingCertWheelSupportSpec` certifies force-feedback wheels (the five primary vendors in `EV2RacingWheelVendor`), streaming cinematic-camera capture, and photo-mode capture, with per-vehicle FFB tuning. `FV2RacingAccessibilityExtendedSpec` makes the full assist library toggleable, adds an **auto-throttle mode for severely motor-impaired players**, steps difficulty down after consecutive career losses (§90.2), and clamps motion blur and camera shake in a reduced-motion racing camera (§53.2). The catalogue hashes through `BuildRacingComplianceCertCatalogSignature` and mirrors to `V2/balance/racing/racing-compliance-cert.json`. The broader accessibility, localization, and platform-cert program these racing specs slot into is on [./platform-accessibility-localization-and-production.md](./platform-accessibility-localization-and-production.md). ## Related - [Racing: Vehicles, Modes & Online](./racing-vehicles-modes-and-online.md) — the vehicle data model, race-mode catalogue, physics, careers, and racing online this crossover shares a roster and backbone with - [Platform, Accessibility, Localization & Production](./platform-accessibility-localization-and-production.md) — the game-wide accessibility, region-rating, and platform-cert program the §119 racing specs feed into - [../architecture/racing-and-vehicle-architecture.md](../architecture/racing-and-vehicle-architecture.md) — the seven racing modules, the analytical physics solver, the damage model's Get-Out-and-Fight hook, and the §119 compliance catalogue in depth - [../architecture/open-world-coop-and-special-modes.md](../architecture/open-world-coop-and-special-modes.md) — the Heist co-op campaign, the persistent world economy, and the open-world surfaces the crossover modes inhabit - The section hub: [../V2_features.md](../V2_features.md)