Vehicles System

Purpose and Scope

The Vehicles System in RPG Engine v6 provides drivable wheeled transport for the player, including entering and exiting vehicles, driver and passenger occupancy, possession flow, movement, fuel usage, damage processing, destruction, visual deformation, state handling, UI, and save/load support.

The core parent class for all drivable cars in the project is BP_Vehicle_Drivable, from which concrete vehicle pawns such as BP_SportsCar_Pawn and BP_OffroadCar_Pawn inherit.

This document targets gameplay programmers and technical designers and focuses on runtime architecture: character-side vehicle logic, vehicle-side modules, movement actor setup, fuel and health management, vehicle data assets, interaction flow, state system, and integrations with other project systems.

It does not cover step-by-step setup of new vehicle blueprints, detailed Chaos physics tuning, or per-vehicle balancing. Those topics belong in dedicated how-to and reference documents.

---

High-Level Architecture

The Vehicles System is split between the character and the vehicle actor.

On the character side, BP_VehicleComponent manages entering and leaving vehicles, possession/unpossession, safe exit checks, input context switching, and character-related vehicle states.

It drives a set of vehicle-related character states, including:

• CharacterStates.UnusualSkills.PossessToVehicle — entering a vehicle as driver.
• CharacterStates.UnusualSkills.FuelVehicle — fueling a vehicle when the player has a compatible canister in inventory.
• CharacterStates.UnusualSkills.RepairVehicle — repairing a vehicle by interacting with appropriate zones.
• CharacterStates.UnusualSkills.EnterToVehiclePassenger — entering as passenger.
• CharacterStates.UnusualSkills.ExitVehiclePassenger — leaving the car as passenger.
• CharacterStates.UnusualSkills.UnpossessVehicle — unpossessing the vehicle as driver.
• CharacterStates.Effects.PawnInsideVehicle — indicates that the character is currently inside a vehicle.
• CharacterStates.Global.Respawn — used when the player is killed inside a vehicle and needs a dedicated respawn flow.

When the character possesses a vehicle as driver, input mapping is switched to the vehicle-specific context IMC_Vehicle_Driver.

This mapping context is resolved through the DT_InputContexts DataTable, and the row to use is selected by the vehicle’s clarification asset BP_DA_VehicleClar via the NewInputMappingContext parameter.

Internally this is a map like:

• enum_drive → DT_InputContexts, row VehicleDriver
• enum_passenger → DT_InputContexts, row VehiclePassenger

When the player becomes a driver, the Drive entry is used.

When the player enters as a passenger, the character is attached to a vehicle socket without possession, and the input context switches to the passenger entry.

On the vehicle side, BP_VehicleModulesMediator and BP_MainVehicleComponent handle the vehicle’s own state logic, fuel and health, occupant tracking, destruction state, visual damage, and integration with the drivable pawn.

Vehicles use the same mediator pattern as characters, but with their own vehicle-side components and data:

• BP_VehicleModulesMediator — vehicle mediator component.
• DT_VehicleStates — vehicle state table.
• DA_VehicleModulesHUB — vehicle module hub asset.

The core drivable base actor is BP_Vehicle_Drivable, which inherits from WheeledVehiclePawn.

Project-specific vehicle classes such as BP_SportsCar_Pawn and BP_OffroadCar_Pawn inherit from this base and reuse the same shared runtime stack.

---

Core Runtime Classes

BP_VehicleComponent

BP_VehicleComponent is attached to the player character and is the main bridge between the character and any drivable vehicle.

Its responsibilities include:

• entering a vehicle as driver or passenger,
• leaving a vehicle as driver or passenger,
• handling possess/unpossess transitions,
• switching input context between character and vehicle,
• handling character death while inside a vehicle,
• synchronizing these actions across networked gameplay,
• managing collision and safe exit logic.

Important behavior and flags include:

• storing references to the current player and vehicle,
• handling bThrowKilledOwnerFromVehicle,
• handling bOwnerKilledInsideVehicle,
• controlling seat enter/exit states,
• controlling collision changes and ragdoll/camera transitions when needed.

BP_VehicleComponent also integrates with the character-side mediator and state machine via:

• BPI_VehicleComponent_C
• BPI_StateMachine_C
• BP_ModulesMediator_C

This makes it the central player-side module for all vehicle interactions.

BP_VehicleModulesMediator

BP_VehicleModulesMediator is the vehicle-side mediator used to activate and deactivate vehicle gameplay states.

It plays the same architectural role for vehicle modules that BP_ModulesMediator plays for character modules.

Vehicle state logic is driven through this mediator and the vehicle state table DT_VehicleStates rather than being hardcoded directly inside the pawn.

The mediator also uses a dedicated module hub asset:

• DA_VehicleModulesHUB — configures which vehicle-specific components are active for a given vehicle type.

BP_MainVehicleComponent

BP_MainVehicleComponent is the central gameplay component attached to drivable vehicles.

It is responsible for vehicle health, fuel, occupants, destruction state, morph target damage deformation, save/load integration, handling skills or effects applied to the vehicle, and vehicle state handling.

Parent class and interfaces:

• ActorComponent — base parent class.
• BPI_SaveSystem_C — used for saving and loading vehicle data.
• BPI_VehicleMainComponent_C — main interface for vehicle-specific interactions.
• BPI_StateMachine_C — used for vehicle state machine integration.

Main variables:

• DriverPawn (Pawn) — current driver pawn controlling the vehicle.
• FuelAmount (real) — current amount of fuel in the vehicle.
• FuelMaximal (real) — maximum possible fuel capacity.
• Fuel Consuming Timer Ticks Every N Seconds (real) — timer interval used for periodic fuel consumption.
• Fuel Amount of Consuming Per Second (real) — amount of fuel consumed every second while fuel usage is active.
• HealthAmount (real) — current health of the vehicle.
• MaxHealth (real) — maximum vehicle health.
• NoFuel (bool) — flag indicating that the vehicle has no fuel left.
• InfiniteHealth (bool) — flag that prevents the vehicle from taking damage.
• TurnOnState (bool) — flag indicating whether the vehicle is turned on.
• bVehicleDestroyed (bool) — flag indicating that the vehicle is destroyed.
• PawnsInside (Pawn Array) — array of all pawns currently inside the vehicle.
• PassengerPlacesBusyTags (Name Array) — array of passenger seat tags currently marked as occupied.
• DamageCauser (Actor) — actor that caused the most recent damage event.
• VehicleDataAsset (BP_DA_VehicleClar_C) — data asset with vehicle sounds, VFX, tuning, and interaction settings.
• MorphTargets (S_MorphTargets) — structure storing morph target deformation data for the damaged vehicle mesh.
• ChaosWheeledVehicleComponent (ChaosWheeledVehicleMovementComponent) — movement component used for wheel physics and vehicle driving behavior.

Delegates and callbacks:

• OnFuelRunOut — called when fuel reaches zero.
• OnTurnOn — called when the vehicle is turned on.
• OnTurnOff — called when the vehicle is turned off.
• OnLightsState — called when light state changes.
• OnBrakeLightsState — called when brake light state changes.
• OnHealthChanged — called when vehicle health changes.
• OnDestroyed — called when the vehicle is destroyed.
• OnDestroyedActivateEffects — called when destruction effects should be activated.
• OnRepair — called when the vehicle is repaired.
• OnFueled — called when the vehicle is refueled.

Core responsibilities:

• Tracks the current driver and passengers.
• Synchronizes occupant references through multicast functions such as Multicast_SetDriverPawnReference and Multicast_SetPawnsInside.
• Reacts to possession changes through events such as BPI VMC NewPawnPossessedTo.
• Handles vehicle exit through ExitVehicle (Server) and ExitFromVehicle (Owning Client), including input shutdown and camera transition.
• Maintains passenger occupancy through PassengerPlacesBusyTags.
• Integrates gameplay skills and effects that target the vehicle.

Fuel management:

• Fuel Consuming Process is a timer-based process that periodically decreases fuel.
• ActivateFuelConsumingState starts the fuel consumption timer.
• End Fuel Consumption Process stops the fuel consumption timer.
• When fuel reaches zero, OnFuelRunOut is triggered and the NoFuel flag becomes true.

Health and damage management:

• ApplyDamage processes incoming damage unless InfiniteHealth is enabled.
• HealthChanged updates current health state and propagates it to UI/effects.
• When health reaches zero, destruction-related states and effects are activated.
• Apply Damage to Each Pawn Vehicle Destroyed applies damage to all pawns inside the vehicle when the vehicle is destroyed.

Morph target integration:

• Morph target functions are used to deform the vehicle mesh based on damage.
• ProcessMorphTargets finds and applies morph target deformation.
• OnRep_MorphTargets reacts to replicated morph target changes on clients.

State machine integration:

• Activate State Solver, Cancel State Solver, ActivateStates, and Deactivate States are used to manage vehicle states.
• Gameplay tags are used to identify and switch between runtime vehicle states such as turned on, turned off, fueling, repair, driver exit, destroyed, and similar conditions.

Collision, hit, and feedback:

• The component reacts to vehicle collision and hit-related events such as On Main Skeletal Mesh Hit and OnCharacterHitZoneBeginOverlap.
• It triggers hit sounds, visual effects, and damage responses depending on impact conditions.

Summary of role:

• BP_MainVehicleComponent is the gameplay core of the vehicle system.
• It manages health, fuel, destruction, occupants, and state transitions.
• It connects save/load, damage handling, morph targets, effects, skills, and vehicle interaction into one central runtime component.

BP_Vehicle_Drivable

BP_Vehicle_Drivable is the main drivable vehicle actor and inherits from WheeledVehiclePawn.

All gameplay cars such as BP_SportsCar_Pawn and BP_OffroadCar_Pawn inherit from this parent and reuse its component stack.

Key components on the actor include:

• Main skeletal Mesh
• ChaosWheeledVehicleMovementComponent
• BackSpringArm
• BackCamera
• AudioComponent
• SynthComponentMoto
• DriverZone
• PassengerZone
• CharacterHitZone BW
• CharacterHitZone FW
• AlternativeExit_1
• AlternativeExit_2
• AlternativeExit_3
• AlternativeExit_4
• hit zone BoxComponents
• ContextualAnimSceneActorComponent
• InRadiusWidget
• BP_MainVehicleComponent
• BP_VehicleModulesMediator
• LowHealthEffect
• TiresDrift

It contains the actual movement-facing actor logic:

• getting wheel references,
• movement and RPM processing,
• gear shifting,
• braking and handbrake behavior,
• drifting detection,
• airborne detection,
• camera interpolation,
• audio and effect playback,
• reacting to turn on/off and destruction,
• implementing save support through BPI_SaveSystem_C.

Derived classes currently include sports and offroad variants, but the documentation should treat the system as common and reusable rather than per-car specific.

Interaction Zones and Hit Logic

Alternative exit points

AlternativeExit_X billboard components define candidate positions for safe exit.

If the primary exit is blocked, the system iterates through these components and uses BPI_VP_GetAlternativeExitPositions to build a list of world transforms to test for free space.

If more exit components are added, they must also be added to the output array in BPI_VP_GetAlternativeExitPositions.

Driver and passenger zones

DriverZone and PassengerZone are BoxComponents used during interaction tracing.

When the player attempts to interact with the vehicle, a line trace is emitted in the direction of the camera.

If the trace hits a component whose owner implements BPI_VehiclePawn, BPI_VP_GetInteractionTypeVehicle is called.

Inside that function, the interact component is compared to specific vehicle components:

• If the interact component is DriverZone, the player enters as driver.
• If the interact component is PassengerZone, the player enters as passenger.
• If the interact component is RepairZone, a repair attempt is triggered.
• If the interact component is FuelZone, a fueling attempt is triggered.

Character hit zones

CharacterHitZone FW and CharacterHitZone BW are BoxComponents that overlap only with pawns.

On overlap:

• the overlapped component is checked,
• it must have the tag configured in DA_GS_Equipment.Trigger tag for Affecting with different effects,
• and it must implement BPI_MulticlassData.

If both checks pass, damage is processed:

• if vehicle velocity is higher than StartVelocityToReactVehicleHit and higher than BP_StatsComponent.StartVelocityToReact of the victim, damage is applied,
• if velocity is higher than BP_StatsComponent.DeathVelocityHit of the victim, the victim is killed and launched away from the vehicle.

MotoSynth engine sound

SynthComponentMoto is initialized from the BP_DA_VehicleClar asset via the MotosynthPreset parameter in the vehicle class function AssignMotoPreset.

It uses the MotoSynth plugin to generate procedural engine sound based on runtime RPM and movement state.

Low health visual effect

LowHealthEffect is a Niagara component that plays a dark smoke effect when the vehicle health is low.

The smoke intensity increases as the vehicle health decreases.

---

Interaction and Occupancy

Entering vehicles

The player enters vehicles through the regular interaction layer:

• BP_InteractComponent
• BPI_Interactables

This keeps vehicles aligned with the same interaction architecture used by other world objects.

On interaction, the system determines whether the player should become driver or passenger using the relevant vehicle zones and BPI_VP_GetInteractionTypeVehicle.

Seats and occupant tracking

The system supports:

• one driver,
• one or more passengers.

Passenger occupancy is tracked in BP_MainVehicleComponent through:

• PassengerPlacesBusyTags (Name Array)

This array stores seat occupancy information and is used to determine whether a passenger seat is available.

Exiting vehicles

Vehicle exit is validated before the player is released from the car.

The system:

• checks that the vehicle is not moving,
• requests alternative exit positions from the vehicle through BPI_VP_GetAlternativeExitPositions,
• tests predefined exit points around the vehicle for safe placement.

These points are represented by components such as:

• AlternativeExit_1
• AlternativeExit_2
• AlternativeExit_3
• AlternativeExit_4

The returned world transforms are checked for overlap and safe exit conditions before the character is placed there.

---

State System

Vehicles use their own mediator and their own state table:

• DT_VehicleStates

Vehicle states are activated through BP_VehicleModulesMediator, while BP_MainVehicleComponent is the main component that works with that mediator and state machine functions such as:

• ActivateStateSolver
• Cancel State Solver
• ActivateStates
• Deactivate States

Vehicle states cover runtime conditions such as:

• turned on / turned off,
• fueling,
• repair,
• driver exit,
• destroyed / dead.

One explicit example is:

• VehicleStates.Effects.Dead

This state is activated when the vehicle is destroyed and transitions the car into its dead or non-drivable state.

The vehicle state system is separate from character states, while still following the same modular architecture pattern.

---

Data Model

Instance-editable component parameters

A significant part of runtime vehicle configuration is stored directly as instance-editable variables in BP_MainVehicleComponent.

This includes key gameplay values such as:

• fuel,
• health,
• seat occupancy,
• destruction state,
• references to current driver and passengers.

Item data and clarification asset

Vehicles also have item-related data assets such as:

• DA_Car
• DA_SportCar

These use the item data layer and point to the vehicle clarification asset.

The clarification-type data asset is:

• BP_DA_VehicleClar

This asset must be assigned in the vehicle item data and contains the audiovisual and behavioral tuning for the vehicle, including input mapping context selection for driver and passenger modes through NewInputMappingContext.

BP_DA_VehicleClar

BP_DA_VehicleClar is a PrimaryDataAsset that stores configuration data, audio assets, visual effects, and gameplay tuning parameters for a vehicle.

Below are the main parameters of this asset:

• MotosynthPreset (MotoSynthPreset) — preset for the procedural engine sound synthesizer.
• Looping Audio (all) (SoundBase) — main looping engine sound played while the vehicle is running.
• Backfire nl (SoundBase) — backfire or exhaust pop sound.
• Ignition On nl (SoundBase) — sound played when the ignition is turned on.
• Ignition Off nl (SoundBase) — sound played when the ignition is turned off.
• Door Open nl (SoundBase) — door opening sound.
• Door Close nl (SoundBase) — door closing sound.
• Gear Shift nl (SoundBase) — gear shift sound.
• Brake Pedal nl (SoundBase) — brake pedal press sound.
• Engine Begin Slow Accel nl (SoundBase) — sound played when the engine begins slow acceleration.
• Engine Begin Slow Deccel nl (SoundBase) — sound played when the engine begins slow deceleration.
• Engine Begin Fast Accel nl (SoundBase) — sound played when the engine begins fast acceleration.
• Engine Begin Fast Deccel nl (SoundBase) — sound played when the engine begins fast deceleration.
• Suspention Light nl (SoundBase) — light suspension movement sound.
• Suspention Heavy nl (SoundBase) — heavy suspension movement sound.
• Suspention Med nl (SoundBase) — medium suspension movement sound.
• Tire Bump Soft nl (SoundBase) — soft wheel bump sound.
• Tire Bump Med nl (SoundBase) — medium wheel bump sound.
• Tire Bump Hard nl (SoundBase) — hard wheel bump sound.
• Tire Drifting Start nl (SoundBase) — sound played when tire drifting starts.
• Tire Drifting End nl (SoundBase) — sound played when tire drifting ends.
• Tire Handbrake Start nl (SoundBase) — sound played when handbrake skid starts.
• Vehicle Max MPH (real) — maximum vehicle speed.
• Vehicle RPM Min (real) — minimum engine RPM value.
• Vehicle RPM Max (real) — maximum engine RPM value.
• ToRPMRange (Vector2D) — target RPM range used for mapping or interpolation.
• FromRPMRange (Vector2D) — source RPM range used for interpolation.
• ShiftTimeThreshold (real) — minimum time between gear shifts.
• Gear Acceleration Rates (real) — acceleration coefficient used for gear behavior.
• Accel Interpolation Speed (real) — interpolation speed for acceleration changes.
• Deccel Interpolation Speed (real) — interpolation speed for deceleration changes.
• ShowDebug? (bool) — flag that enables debug information display.
• Base Acceleration Rate (real) — base acceleration speed value.
• Base Decceleration Rate (real) — base deceleration speed value.
• Moto LPF While Drifting (real) — low-pass filter value for engine sound while drifting.
• Cutoff Speed For Slow/Fast Accel/Deccel (real) — speed threshold used to distinguish slow and fast acceleration or deceleration states.
• Minimum Speed For Drifting Skids (real) — minimum speed required to activate drifting skid sounds or effects.
• Minimum Speed For Handbrake Skids (real) — minimum speed required to activate handbrake skid sounds or effects.
• Target RPM Error Tollerance (real) — allowed error tolerance when comparing current RPM and target RPM during shifting.
• Drifting Skid LPF Cutoff Freq (real) — low-pass filter cutoff frequency for drifting skid sound.
• Randomized RPM "To" Value (real) — randomized RPM target value used to add variation to shift behavior and sound.
• Speed For Idle Fadded Out (real) — speed at which idle engine sound starts fading out.
• HearVehicleShift? (bool) — flag that enables gear shift sound playback.
• Tire Roll Start nl (SoundBase) — sound played when tire rolling or skidding starts.
• Minimum Speed For Motosynth Modulation (real) — minimum speed required for motosynth modulation.
• CarEngineBreakdownSound (SoundBase) — sound played when the engine breaks down.
• CarEngineBreakdownPitch (real) — pitch multiplier for the engine breakdown sound.
• AirborneRamp (SoundBase) — sound played when the vehicle becomes airborne.
• AirborneRampPitchMod (real) — pitch modifier for airborne sound.
• AirborneRampVolumeMode (real) — volume modifier for airborne sound.
• CarEngineBreakdownVolume (real) — volume multiplier for the engine breakdown sound.
• FuelSoundEffect (SoundBase) — sound played during fueling.
• RepairSoundEffect (SoundBase) — sound played during repair.
• FuelNiagaraEffect (NiagaraSystem) — visual effect played during fueling.
• RepairNiagaraEffect (NiagaraSystem) — visual effect played during repair.
• HealthIconUI (Texture2D) — UI icon representing vehicle health.
• MorphTargets (Name) — morph target name used for vehicle mesh deformation visuals.
• Fuel (DataTableRowHandle) — row handle pointing to the fuel data entry.
• NewInputMappingContext (E_InteractionTypeVehicle) — input interaction mode or context used while controlling the vehicle.

This asset is the main authoring point for the non-physics expressive behavior and input mode configuration of each vehicle model.

---

Movement, Input, and Camera

Vehicle input is received by the vehicle actor itself rather than routed as normal on-foot character movement input.

BP_Vehicle_Drivable handles:

• throttle,
• brake,
• steering,
• handbrake,
• lights,
• exit actions,
• camera interpolation,
• reset and speed-related logic.

The movement backbone is ChaosWheeledVehicleMovementComponent, which provides the physical wheel-based motion model.

The actor then layers project gameplay behavior on top:

• RPM calculation,
• gear state updates,
• drifting state,
• airborne detection,
• skid effects,
• braking effects,
• wheel suspension feedback.

The camera uses BackCamera and BackSpringArm, giving the vehicle its own follow-camera setup rather than reusing the standard on-foot camera directly.

Normal on-foot combat is disabled while driving, and input context is switched according to the driver or passenger mapping specified in BP_DA_VehicleClar.

---

Fuel System

The project uses a single shared fuel logic rather than separate fuel or electric systems.

Fuel is handled primarily by BP_MainVehicleComponent through:

• FuelAmount
• FuelMaximal
• Fuel Consuming Timer Ticks Every N Seconds
• Fuel Amount of Consuming Per Second

Fuel consumption works through a timer-driven process:

• ActivateFuelConsumingState starts the fuel consumption timer,
• the timer reduces fuel over time,
• End Fuel Consumption Process stops the timer when needed.

When fuel reaches zero:

• OnFuelRunOut is called,
• NoFuel becomes true,
• movement is stopped.

A vehicle can still function partially without fuel. For example, lights may still work even if the car can no longer drive.

Fuel item or type data is linked through the Fuel field in BP_DA_VehicleClar, and the character-side state CharacterStates.UnusualSkills.FuelVehicle is used to initiate fueling through interaction.

---

Health, Damage, and Destruction

Health model

Vehicle health is stored in:

• HealthAmount
• MaxHealth

Damage is ignored if InfiniteHealth is enabled.

Otherwise, incoming damage reduces vehicle health and can eventually destroy the vehicle.

Damage entry points

Vehicle damage is processed through actor-level damage events such as:

• Event PointDamage
• Event RadialDamage

These events call ApplyDamage(Server).

ApplyDamage(Server):

• checks InfiniteHealth,
• records DamageCauser,
• subtracts incoming damage from HealthAmount,
• clamps health to a minimum of zero,
• updates health state and delegates,
• activates the dead state when health reaches zero.

Hit zones and occupant damage

Vehicles use BoxComponent hit zones for additional overlap and impact logic.

Examples include:

• CharacterHitZone FW
• CharacterHitZone BW

When overlap conditions are valid, the system can build a HitResult, call Apply Point Damage, and play impact effects.

When the vehicle is destroyed, it can also damage all pawns inside through Apply Damage to Each Pawn Vehicle Destroyed.

The character hit zones additionally support high-velocity impacts against pawns:

• the overlapped component must carry the required trigger tag from DA_GS_Equipment,
• it must implement BPI_MulticlassData,
• if vehicle velocity exceeds StartVelocityToReactVehicleHit and the victim’s BP_StatsComponent.StartVelocityToReact, damage is applied,
• if velocity exceeds BP_StatsComponent.DeathVelocityHit, the victim is killed and launched away from the car.

Morph targets and visual damage

Visual damage is represented through morph targets.

ProcessMorphTargets updates the damaged appearance of the vehicle mesh, and OnRep_MorphTargets synchronizes that deformation across the network.

This allows the body of the vehicle to visibly deform rather than relying only on abstract health values.

Effects and destruction result

Damage feedback uses:

• audio or effect data tables such as DT_ImpactVehicleAudio,
• Niagara effects,
• decals,
• impact sounds,
• low-health effects,
• breakdown sounds.

When the vehicle is fully destroyed:

• destruction effects are played,
• lights and active effects are disabled,
• movement or input handling is disabled,
• the vehicle enters a destroyed state such as VehicleStates.Effects.Dead,
• the car explodes and remains in the world as a non-working object.

It does not simply disappear from the level.

---

Audio and Visual Effects

Vehicles have a large amount of audiovisual feedback configured through BP_DA_VehicleClar and driven by BP_Vehicle_Drivable plus BP_MainVehicleComponent.

Covered effect groups include:

• ignition on/off,
• looping engine sound,
• gear shifting,
• drifting,
• braking,
• suspension impacts,
• tire bumps,
• airborne events,
• low-health feedback,
• fueling,
• repairing,
• destruction.

Niagara components such as LowHealthEffect and TiresDrift are placed directly on the vehicle actor.

This gives the system both persistent attached effects and spawn-on-event effects.

Engine sound is additionally shaped using SynthComponentMoto and the MotosynthPreset from BP_DA_VehicleClar.

---

UI and Interaction Actions

The system has a dedicated runtime vehicle panel:

• WB_VehiclePanel

This panel displays:

• speed,
• current gear,
• fuel,
• durability or health.

Detailed UI widget structure is not essential for this document, but the panel should be noted as the main HUD element while driving.

Vehicle interactions such as:

• headlights,
• doors,
• trunk,
• horn

are triggered through input actions rather than through a separate radial interaction menu.

---

Save and Load

Vehicles are saved and restored.

The save layer stores at least:

• health,
• morph targets,
• fuel.

Vehicle save data is stored in:

• S_VehicleSaveData

This structure is part of the larger shared save structure:

• S_SaveContainer

BP_Vehicle_Drivable and BP_MainVehicleComponent both participate in save/load behavior through save interfaces and shared save data containers.

This allows a vehicle to be restored with its important gameplay state rather than always spawning in a default pristine condition.

---

Integration with Other Systems

Character and interaction systems

Vehicles integrate directly with:

• BP_InteractComponent
• BPI_Interactables
• character-side BP_VehicleComponent
• character state and mediator logic

This is what enables entering, exiting, possession flow, driver and passenger modes, fueling, repairing through character skills, and disabling normal combat while driving.

State system

Vehicles have their own vehicle-side state machine:

• DT_VehicleStates
• BP_VehicleModulesMediator
• BP_MainVehicleComponent via BPI_StateMachine_C

This keeps vehicle-specific runtime conditions separate from character states while still following the same modular architecture pattern used across the project.

Save system

Vehicles integrate with the shared save framework through:

• BPI_SaveSystem_C
• S_SaveContainer
• S_VehicleSaveData

Building and crafting related data layers

Vehicles also connect to the item/data layer through item data assets such as DA_Car and DA_SportCar, plus the clarification asset BP_DA_VehicleClar.

This aligns vehicles with the same project-wide data-driven content model used by other systems.

Combat and damage systems

Vehicles participate in the project’s broader damage ecosystem:

• point damage,
• radial damage,
• damage causers,
• impact effects,
• occupant damage when destroyed,
• high-velocity collisions with characters through hit zones.

---

Scope and Limitations

This document covers:

• vehicle architecture across character and vehicle actors,
• BP_VehicleComponent,
• BP_MainVehicleComponent,
• BP_VehicleModulesMediator,
• BP_Vehicle_Drivable,
• fuel,
• health,
• seats,
• lights,
• damage zones,
• morph targets,
• vehicle UI,
• save/load integration,
• input context switching,
• driver and passenger modes.

This document does not cover:

• per-vehicle tuning walkthroughs,
• multiplayer replication details,
• step-by-step creation of new car blueprints,
• cinematic or contextual animation authoring.

Those topics should live in separate how-to or reference documents.

---

Related docs

• state-system.md
• character-modules.md
• interaction-and-items.md
• save-load-system.md
• building-system.md
• crafting-system.md
• stats-and-survival-system.md
• ai-system.md
• map-and-minimap-system.md