Unreal Engine 5.8: Build a Complete Racing Game

In this lesson, we turn the prepared skeletal car into a working Chaos Vehicle in Unreal Engine 5.8.

We’ll create the vehicle Blueprint, assign the skeletal mesh and animation system, build the front and rear wheel Blueprints, configure steering, braking, handbrake behavior, wheel radius, and finally connect all four wheels to the Chaos Wheeled Vehicle Movement Component.

In this lesson, you will:

• Verify the vehicle’s Physics Asset and simulation setup

• Create a Chaos Wheeled Vehicle Pawn Blueprint

• Assign the prepared skeletal vehicle mesh

• Configure the Chaos Wheeled Vehicle Movement Component

• Create a Vehicle Animation Blueprint

• Set the correct vehicle animation parent class

• Assign the vehicle skeleton to the Animation Blueprint

• Connect the Animation Blueprint to the vehicle

• Create separate Front Wheel and Rear Wheel Blueprints

• Configure wheel radius and wheel dimensions

• Enable steering for the front wheels

• Set the steering angle

• Configure braking behavior

• Enable handbrake control for the rear wheels

• Adjust wheel traction-related settings

• Duplicate and organize wheel Blueprint assets

• Assign all four wheel classes to the vehicle movement component

• Match each wheel setup to the correct wheel bone

• Compile and test the complete Chaos Vehicle setup

• Prepare the car for player input and driving controls

By the end of this lesson, the race car will have a complete Chaos Vehicle Blueprint with properly configured front and rear wheels, ready for throttle, steering, brake, and camera controls in the next lessons.

In this lesson, we make the race car drivable for the first time by creating the basic vehicle-control logic in Unreal Engine 5.8.

We’ll set up keyboard input for throttle and steering, connect those values to the Chaos Wheeled Vehicle Movement Component, and test how positive and negative input values affect the vehicle. We’ll also inspect the engine RPM and begin tuning the vehicle so the controls feel more responsive.

In this lesson, you will:

• Create the basic vehicle input controls

• Set up keyboard input for driving

• Use W for forward throttle

• Use S for reverse input

• Use A and D for steering

• Work with positive and negative input values

• Create Float values for throttle and steering

• Scale input values using Multiply

• Access the Chaos Wheeled Vehicle Movement Component

• Use Set Throttle Input

• Apply steering input to the vehicle

• Reset input values when keys are released

• Compile and test the vehicle Blueprint

• Observe how the car responds during gameplay

• Inspect Engine RPM

• Check maximum engine RPM values

• Make initial movement and responsiveness adjustments

• Verify that the Chaos Vehicle setup is working correctly

By the end of this lesson, the race car will have working forward, reverse, and steering controls, giving us a playable foundation for the complete vehicle-control system.

Next: We’ll move to a more organized Enhanced Input setup and add the GameMode and driving camera.

In this lesson, we organize the race project by creating a dedicated GameMode, setting the race car as the default playable vehicle, building the driving camera, and moving the vehicle controls to Unreal Engine 5.8’s Enhanced Input system.

We’ll create the Input Mapping Context and Input Actions for throttle, steering, braking, and camera control, then connect those inputs to the vehicle Blueprint so the control system is cleaner and easier to expand.

In this lesson, you will:

• Create a dedicated Race GameMode

• Assign the race car as the Default Pawn Class

• Set the GameMode for the level

• Verify that the player automatically possesses the vehicle

• Add and configure a Spring Arm Component

• Add the vehicle Camera Component

• Adjust camera position and distance

• Configure camera collision behavior

• Set up the Enhanced Input system

• Create an Input Mapping Context

• Add the mapping context when the vehicle begins play

• Access the Enhanced Input Local Player Subsystem

• Create Input Actions for Throttle

• Create Input Actions for Steering

• Create Input Actions for Brake / Reverse

• Create input for camera look

• Configure keyboard keys for vehicle controls

• Configure mouse input for camera movement

• Use Negate modifiers for opposite-direction inputs

• Work with Axis input values

• Connect Enhanced Input actions to the Chaos Vehicle Movement Component

• Test the new input and camera system during gameplay

By the end of this lesson, the race car will use a structured GameMode, driving camera, and Enhanced Input setup, ready for completing the full control system in the next lesson.

In this lesson, we complete the main driving controls for the race car in Unreal Engine 5.8.

Building on the Enhanced Input setup from the previous lesson, we’ll connect steering, braking, reverse movement, and camera-look controls to the vehicle. We’ll also make sure input values reset correctly when keys are released so the car responds smoothly and predictably.

In this lesson, you will:

• Set up steering input

• Connect steering to the Chaos Vehicle Movement Component

• Add brake controls

• Configure reverse driving

• Understand how throttle and braking work together

• Add player-controlled camera look

• Configure horizontal and vertical camera movement

• Work with Enhanced Input axis values

• Use Triggered and Completed input events

• Reset steering, throttle, and brake values when input is released

• Test acceleration, steering, braking, reverse, and camera movement

• Fine-tune the controls for a smoother driving experience

By the end of this lesson, the race car will have a complete basic driving control system with acceleration, steering, braking, reverse movement, and camera control.

Next: We’ll move on to refining the vehicle behaviour and building the next stage of the racing game.

In this lesson, we begin creating the race track environment in Unreal Engine 5.8.

After making a few final adjustments to the vehicle handling and camera, we establish the race starting area, create the landscape, and use Landscape Splines to design the road layout. You’ll learn how to place and manipulate control points, shape corners, and build a smoother track that the vehicle can follow naturally.

In this lesson, you will:

• Make final adjustments to vehicle handling and reduce unwanted sliding

• Refine the gameplay camera position

• Establish the race starting position and direction

• Create the base landscape for the racing environment

• Plan the initial racetrack layout

• Work with Landscape Splines

• Create and position spline control points

• Connect control points to form the road

• Rotate and adjust control points to create corners

• Smooth the spline to improve track flow

• Edit and remove unwanted spline sections

• Set up Landscape Layers

• Sculpt and refine the terrain around the racetrack

• Test the developing track with the player vehicle

By the end of this lesson, you’ll have the foundation of a custom race course with a properly shaped landscape and spline-based track layout.

Next: We’ll continue developing the race environment and improve the road, terrain, and overall track presentation.

In this lesson, we improve the race car’s tire grip and handling in Unreal Engine 5.8 to reduce excessive sliding and drifting.

We’ll tune important Chaos Vehicle wheel settings, explore how friction values affect the car, and use Physical Materials to control how different surfaces interact with the tires.

In this lesson, you will:

• Identify why the vehicle is sliding or drifting too much

• Adjust the wheel Friction Force Multiplier

• Understand how increasing tire grip changes vehicle behaviour

• Tune Cornering Stiffness

• Review slip-related wheel settings

• Configure front and rear wheel Blueprints

• Understand Friction Combine Mode

• Create and configure a Physical Material

• Apply Physical Materials to track surfaces

• Control how tire and surface friction work together

• Compare higher-grip and lower-grip surfaces

• Test the vehicle for sliding, drifting, and understeer

• Fine-tune the values to achieve more stable racing behaviour

By the end of this lesson, the race car will have improved traction and more predictable handling, while also giving you a foundation for creating different driving surfaces such as road, dirt, or low-grip areas.

Next: We’ll continue developing the race track and vehicle systems while refining the overall racing experience.

In this lesson, we refine the race track created with Landscape Splines and fix the collision issues that can affect the vehicle while driving in Unreal Engine 5.8.

We’ll adjust spline control points and road segments, improve the road shape, and troubleshoot areas where the vehicle does not interact correctly with the track surface.

In this lesson, you will:

• Refine the existing Landscape Spline road

• Adjust spline control points and road segments

• Correct vertical positioning and uneven road sections

• Smooth problematic areas of the racetrack

• Duplicate and modify spline sections where needed

• Reapply road meshes to updated spline segments

• Inspect the road collision

• Identify collision problems affecting the vehicle

• Simplify collision where necessary

• Enable collision visualization for debugging

• Check how the vehicle tires interact with the road surface

• Test the updated track by driving through problem areas

By the end of this lesson, the racetrack will have a cleaner road shape and more reliable collision, giving the vehicle a smoother and more stable surface to drive on.

Next: We’ll continue improving the race environment and prepare the track for the remaining gameplay systems.

In this lesson, we improve the race car camera so it feels smoother, more responsive, and better suited for racing gameplay in Unreal Engine 5.8.

We’ll fine-tune the Spring Arm and camera behaviour, adjust how closely the camera follows the car, and use camera lag settings to create a more natural sense of speed without making the view feel too loose or delayed.

In this lesson, you will:

• Refine the existing Spring Arm setup

• Adjust the camera distance from the vehicle

• Improve the camera follow position

• Enable and tune Camera Lag

• Adjust lag values for smoother movement

• Reduce excessive camera delay

• Improve how the camera reacts during acceleration

• Fine-tune forward and backward camera movement

• Balance responsiveness and smoothness

• Test different values while driving

• Create a more stable and comfortable racing camera

By the end of this lesson, the vehicle camera will feel more polished and better connected to the car, giving the player a clearer and more enjoyable driving experience.

Next: We’ll continue improving the overall racing experience with the next gameplay system.

In this lesson, we add dynamic engine audio to the race car and make the sound respond to the vehicle’s RPM in Unreal Engine 5.8.

You’ll import the engine sound, attach it to the vehicle, configure looping and attenuation, then read the engine rotation speed from the Chaos Vehicle Movement Component. We’ll convert that RPM value into a usable range and use it to control the sound’s pitch and volume during gameplay.

In this lesson, you will:

• Import the provided engine audio

• Create and configure the vehicle sound asset

• Enable looping for continuous engine sound

• Add an Audio Component to the race car

• Attach the audio to the vehicle

• Configure attenuation and spatial sound behaviour

• Read Engine Rotation Speed

• Compare current RPM with maximum engine RPM

• Create a normalized RPM value

• Use Abs, Divide, and Clamp for RPM calculations

• Create a reusable engine-audio update function

• Control Pitch Multiplier using RPM

• Control Volume Multiplier using RPM

• Tune the sound response for smoother acceleration

• Test the engine audio while driving

By the end of this lesson, the race car will have responsive engine audio that changes dynamically as the engine RPM rises and falls.

Next: We’ll continue adding polish and feedback systems to improve the overall racing experience.

In this lesson, we fine-tune the Chaos Vehicle setup to improve the race car’s stability, suspension response, braking, and overall handling in Unreal Engine 5.8.

We’ll adjust important vehicle parameters, inspect the suspension with debug tools, and refine the Center of Mass so the car feels more controlled during acceleration, braking, and cornering.

In this lesson, you will:

• Tune the vehicle’s engine RPM and related movement settings

• Review transmission and differential behaviour

• Improve braking response

• Adjust Suspension Max Raise and Suspension Max Drop

• Tune suspension stiffness and damping

• Reduce excessive bouncing and body movement

• Understand how suspension travel affects wheel contact

• Use Chaos Vehicle debug visualization

• Inspect wheel and suspension behaviour while driving

• Check vehicle collision during testing

• Adjust the Center of Mass

• Understand how center-of-mass position affects body roll

• Improve stability during cornering

• Reduce unwanted rolling and unstable handling

• Test and fine-tune the vehicle using real-time feedback

By the end of this lesson, the race car will feel more stable, predictable, and better balanced, with improved suspension behaviour and overall handling.

Next: We’ll continue polishing the vehicle and race-game systems as we move closer to the finished racing experience.

In this lesson, we begin building the core race progression system by creating reusable checkpoints in Unreal Engine 5.8.

We’ll create a checkpoint Blueprint that detects when a racer passes through it, finds the racer’s progress component, and sends the checkpoint information for validation. This approach keeps the checkpoint logic reusable and allows the same system to work with both the player and AI racers later in the course.

In this lesson, you will:

• Create the main Race Checkpoint Blueprint

• Add a collision trigger for checkpoint detection

• Detect racers using Actor Begin Overlap

• Access the racer’s progress component

• Use Get Component by Class to avoid tightly coupling checkpoints to one vehicle

• Pass the checkpoint index to the racer-progress system

• Create reusable checkpoint-processing logic

• Check that the required component is valid before continuing

• Add temporary Print String messages for debugging

• Test checkpoint overlaps with the player vehicle

• Keep checkpoint logic separate from race-progress logic

• Prepare the system for checkpoint order, laps, and AI racers

By the end of this lesson, the race car will be able to pass through checkpoints and send that information into the race-progress system.

Next: We’ll expand the racer-progress logic and begin validating checkpoints in the correct sequence.

In this lesson, we expand the checkpoint system by assigning a unique Checkpoint Index to every checkpoint and connecting those values to the racer-progress logic.

We’ll organize the checkpoints around the circuit in the correct sequence, track which checkpoint the racer is expected to hit next, and prepare the system for proper checkpoint validation and lap counting.

In this lesson, you will:

• Add a unique Checkpoint Index to each checkpoint

• Make the checkpoint number editable in the level

• Pass the checkpoint index into the racer-progress component

• Create input parameters for the checkpoint-processing function

• Track the racer’s NextCheckpointIndex

• Number checkpoints around the circuit in sequence

• Treat the track as a circular checkpoint system

• Use temporary debug messages to display checkpoint numbers

• Prepare the logic for checkpoint validation

• Build the foundation for lap counting and race progression

By the end of this lesson, every checkpoint will have a clear identity and the racer-progress system will know which checkpoint should come next.

Next: We’ll validate checkpoint order so skipped or incorrect checkpoints cannot advance the race.

In this lesson, we make the checkpoint system reliable by validating whether the racer has passed through the correct checkpoint in the expected sequence.

We’ll compare the incoming checkpoint index with NextCheckpointIndex, accept the checkpoint only when the values match, and reject skipped or incorrect checkpoints. After a valid pass, the system updates the next expected checkpoint.

In this lesson, you will:

• Compare the incoming checkpoint with NextCheckpointIndex

• Use an integer comparison to validate checkpoint order

• Add a Branch for accepted and rejected paths

• Display temporary Accepted and Rejected debug messages

• Prevent skipped checkpoints from advancing race progress

• Reject checkpoints triggered in the wrong order

• Update the next expected checkpoint after a valid pass

• Test the system by intentionally driving through incorrect checkpoints

• Verify that the race sequence remains accurate

• Prepare the system for lap counting and race completion

By the end of this lesson, racers will only make progress when checkpoints are passed in the correct order.

Next: We’ll connect the checkpoint sequence to lap progression and continue building the complete race system.

In this lesson, we improve the race checkpoint system by calculating the next expected checkpoint automatically using modulo logic in Unreal Engine 5.8.

Because the race track is circular, the checkpoint sequence must loop back to the beginning after the final checkpoint. We’ll use the formula:

NextCheckpointIndex = (IncomingIndex + 1) % TotalCheckpoints

This allows the sequence to move forward correctly from checkpoint 0 → 1 → 2 → 3 → 4 → 5 → 0.

In this lesson, you will:

• Understand what the Modulo / Percent Integer operation does

• Learn why modulo is useful for a circular checkpoint system

• Calculate the next checkpoint automatically

• Add 1 to the incoming checkpoint index

• Use % TotalCheckpoints to wrap the sequence back to 0

• Handle the final checkpoint correctly

• Update NextCheckpointIndex

• Test checkpoint progression around the full race track

• Verify that checkpoint 5 correctly returns to checkpoint 0

• Use debug messages to confirm the expected checkpoint

• Prepare the checkpoint system for lap counting and finish-line logic

By the end of this lesson, the checkpoint system will automatically advance through the full circuit and loop back to the start correctly.

Next: We’ll use checkpoint 0 as the start/finish checkpoint and continue building the lap-counting logic.

In this lesson, we complete the player-side race finish behaviour in Unreal Engine 5.8.

Once the race is finished, the player should no longer be able to continue driving normally. We’ll use the race-progress component to detect the finished state, apply the handbrake, and prevent throttle, steering, braking, and other player inputs from continuing after race completion.

In this lesson, you will:

• Detect when the racer has finished the race

• Use a Boolean finished state to control gameplay

• Apply the vehicle Handbrake after finishing

• Stop the car from continuing to accelerate

• Prevent steering input after race completion

• Disable throttle and brake control when required

• Add finished-state checks to the player input logic

• Reuse the existing Race Progress Component

• Keep race-finish logic separate from normal driving controls

• Test the vehicle after crossing the final checkpoint

• Verify that the player can no longer control the car after finishing

• Clean up and organize the finished-race Blueprint logic

By the end of this lesson, the player vehicle will correctly transition from active racing to a completed state and stop responding to normal driving controls.

Next: We’ll centralize the race flow inside a Race Manager and create the pre-race countdown system.

In this lesson, we create a centralized Race Manager to control the overall flow of the race in Unreal Engine 5.8.

We’ll build a countdown using timers, create race states to clearly represent each stage of the race, and connect the checkpoint-progress system to the Race Manager for centralized debugging and race-status reporting.

In this lesson, you will:

• Create the main Race Manager Blueprint

• Build a reusable race countdown

• Use a timer that executes once every second

• Store and manage the timer using a Timer Handle

• Create a countdown value and decrease it over time

• Stop the timer when the countdown reaches zero

• Create an Enum for race states

• Organize race flow using states such as:

  • Waiting

  • Countdown

  • Racing / Started

  • Finished

• Change the race state when the countdown completes

• Create a reference from the racer-progress component to the Race Manager

• Report accepted checkpoints to the manager

• Report rejected checkpoints to the manager

• Move debugging and race-status reporting into one central Blueprint

• Prepare the Race Manager for later player and AI race control

By the end of this lesson, the project will have a centralized race-management system capable of controlling the countdown, tracking race states, and receiving progress information from racers.

Next: We’ll expand the Race Manager and use it to control the full race start sequence for both the player and AI racers.

In this lesson, we create the race timer system that tracks how long the player has been racing in Unreal Engine 5.8.

Instead of starting the timer as soon as the level begins, we’ll connect it to the Race Manager so timing starts only when the actual race begins. We’ll record the start time, calculate the current elapsed race time, and prepare the value so it can later be displayed in the racing HUD and used for finish results.

In this lesson, you will:

• Create variables for Race Start Time and current race time

• Read the game’s current time

• Store the exact moment the race begins

• Calculate elapsed race time using
  Current Time − Race Start Time

• Update the race timer continuously

• Use the existing Race State to control when timing should run

• Prevent the timer from running during the waiting or countdown states

• Start timing only when the race officially begins

• Use temporary Print String debugging to verify the timer

• Work with Float values for accurate race timing

• Prepare the timer value for the race HUD

• Stop or preserve the timing data when the race finishes

By the end of this lesson, the Race Manager will accurately track the elapsed race time from the moment the race starts.

Next: We’ll display the countdown information on screen and begin building the race UI.

In this lesson, we turn the Race Manager countdown into a visual on-screen race countdown in Unreal Engine 5.8.

We’ll create the countdown text, connect it to the Race Manager, and update it dynamically as the countdown progresses. We’ll also format and position the text so it stays centered and clearly visible during the race-start sequence.

In this lesson, you will:

• Create the main Countdown Text for the race UI

• Connect the displayed text to the Race Manager countdown value

• Convert countdown values into text

• Update the countdown display dynamically

• Handle the countdown reaching zero

• Display the final GO message

• Test the complete 3 → 2 → 1 → GO sequence

• Position the countdown at the center of the screen

• Configure anchors for consistent screen positioning

• Adjust text alignment and justification

• Change the font size and appearance

• Import and use the provided custom font

• Keep the countdown centered at different screen resolutions

• Clean up temporary Print String debugging once the UI is working

By the end of this lesson, the game will have a clear visual countdown that communicates exactly when the race begins.

Next: We’ll continue expanding the race interface with additional gameplay information for the player.

In this lesson, we connect the countdown system to the actual race start logic in Unreal Engine 5.8.

Until the countdown is complete, the player should not be able to drive and the checkpoint system should not record race progress. We’ll use Boolean controls to keep both systems disabled during the countdown and enable them only when the race officially begins.

In this lesson, you will:

• Create a Boolean to control racer progress

• Add bProgressEnabled to the Race Progress Component

• Prevent checkpoints from being processed before the race starts

• Initialize the player’s progress state correctly

• Keep player controls disabled during the countdown

• Enable vehicle controls when the race begins

• Enable race-progress tracking at the same time

• Connect the logic to the Race Manager

• Trigger the race start after the countdown completes

• Prevent early movement and premature checkpoint detection

• Hide/remove the countdown display after the race begins

• Add a short delay before clearing the countdown UI

• Test the complete Countdown → GO → Race Start sequence

• Verify that controls and progress activate at the correct moment

By the end of this lesson, the player will remain locked during the countdown and become fully active only when the race officially starts, while checkpoint progress begins tracking at exactly the same time.

Next: We’ll continue connecting the remaining race systems and expand the project toward a complete player-versus-AI racing experience.

In this lesson, we add the live race timer to the player HUD and connect it to the timing system created earlier in Unreal Engine 5.8.

We’ll take the current elapsed race time from the Race Manager, convert the Float value into clean readable text, control the number of decimal places, and design a simple timer display that updates continuously while the race is running.

In this lesson, you will:

• Add a Race Timer display to the HUD

• Access the current elapsed race time

• Connect the HUD to the Race Manager

• Convert a Float value into text for the UI

• Configure minimum and maximum fractional digits

• Remove unnecessary decimal precision

• Display race time in a clean readable format

• Update the timer continuously during the race

• Create a label for the elapsed race time

• Organize timer elements using a Horizontal Box

• Adjust text size, alignment, and spacing

• Center and position the timer correctly

• Use anchors for consistent screen placement

• Replace temporary Print String debugging with the actual HUD display

• Test the timer from race start and confirm that it updates correctly

By the end of this lesson, the player HUD will display a clean real-time race timer that begins with the race and continuously shows the elapsed time.

Next: We’ll continue developing the racing HUD and add more useful race information for the player.

In this lesson, we build the race finish results display so the player receives clear feedback when the race is completed in Unreal Engine 5.8.

We’ll capture the final race time when the player finishes, prevent the timer from continuing to update, send the finish information through the Race Manager, and format the result text for display in the HUD.

In this lesson, you will:

• Detect when the race has been finished

• Capture the player’s final race time

• Stop the displayed race time from continuing after completion

• Pass finish information to the Race Manager

• Create a function for reporting race-finish data

• Work with formatted text and multiple input values

• Build a clean results message

• Create variables for race-result text

• Display the final race time on screen

• Add and position the finish-results UI

• Adjust text size, alignment, and screen anchors

• Change text styling and color for the completed-race state

• Test the complete finish sequence

• Verify that the final result remains visible after the race ends

By the end of this lesson, the game will display a clear race-complete result with the player’s final time, giving the race a much more complete and polished ending.

Next: We’ll continue expanding the race-result system and add more information such as finishing position and racer results.

In this lesson, we expand the race HUD to display the player’s lap progress and next checkpoint information in Unreal Engine 5.8.

We’ll take the progress data already calculated inside the racer progress system, send it through the Race Manager, and update the HUD whenever a valid checkpoint is passed.

In this lesson, you will:

• Set and use the race Total Laps

• Access Completed Laps

• Track the Next Checkpoint Index

• Send racer-progress information to the Race Manager

• Extend the existing checkpoint reporting logic

• Create HUD update inputs for lap and checkpoint data

• Create an Update Progress Display function

• Format lap information for the UI

• Display values such as Lap 1 / 3

• Display the player’s next expected checkpoint

• Update the HUD when a checkpoint is accepted

• Position and style the new progress text

• Use anchors to keep the HUD elements correctly positioned

• Remove temporary progress/debug text once the final HUD is working

• Test lap and checkpoint updates during gameplay

By the end of this lesson, the player HUD will clearly show current lap progress and the next checkpoint, making the race state easier to understand while driving.

Next: We’ll continue expanding the race HUD and add more race information and gameplay feedback.

In this lesson, we improve the race HUD by giving the player clear feedback when they pass through a checkpoint in the wrong order.

We’ll take the rejected-checkpoint information from the race-progress system, send the expected checkpoint number to the HUD, and display a temporary warning such as “Wrong Checkpoint – Expected 03”. We’ll also make sure this feedback is shown only for the player vehicle and not for other racers.

In this lesson, you will:

• Extend the existing Checkpoint Rejected logic

• Pass the expected NextCheckpointIndex with the rejection event

• Add an integer input for the expected checkpoint

• Format checkpoint information into readable HUD text

• Create a Wrong Checkpoint warning message

• Display the expected checkpoint number to the player

• Style the warning with clear color and typography

• Position the warning near the bottom-center of the screen

• Show the message only temporarily

• Add a short delay before hiding the warning

• Access the owner of the Race Progress Component

• Store/reference the Player Car

• Compare the racer with the player reference

• Prevent AI or other racers from triggering the player's warning UI

• Test valid and invalid checkpoint sequences in gameplay

By the end of this lesson, the player will receive immediate visual feedback whenever they take the wrong checkpoint, along with information showing which checkpoint they should reach next.

Next: We’ll continue refining the race HUD and gameplay feedback systems.

In this lesson, we calculate the race car’s real-time speed from the Chaos Vehicle Movement Component and prepare that value for the speedometer HUD in Unreal Engine 5.8.

We’ll read the vehicle’s Forward Speed, handle negative values while reversing, convert Unreal Engine’s speed from centimeters per second into kilometers per hour, and organize the calculation inside a reusable function.

In this lesson, you will:

• Access the Chaos Wheeled Vehicle Movement Component

• Read the vehicle’s Forward Speed

• Understand why reverse movement produces negative speed values

• Use Absolute (Abs) to keep the displayed speed positive

• Convert speed from cm/s to km/h

• Use the conversion: Speed × 0.036

• Create a reusable speed calculation function

• Store the calculated vehicle speed

• Convert Float speed values into clean whole numbers

• Remove unnecessary decimal values from the HUD

• Connect the calculated speed to the Race HUD

• Add the numerical speed text

• Add the KM/H label

• Position and anchor the speed display correctly

• Prepare the value for the speedometer needle and gauge

• Test the speed display while driving and reversing

By the end of this lesson, the HUD will have an accurate real-time KM/H speed value driven directly by the Chaos Vehicle system.

Next: We’ll use this calculated speed to control and animate the speedometer needle.

In this lesson, we bring the speedometer to life by making the needle rotate according to the vehicle’s speed and smoothing its movement for a more polished racing HUD.

We’ll convert the calculated speed into a rotation angle, clamp the value to the speedometer’s working range, apply that angle to the needle’s Render Transform, and use interpolation with Delta Seconds so the needle moves smoothly instead of snapping instantly.

In this lesson, you will:

• Use the vehicle’s calculated speed value

• Define the speedometer’s minimum and maximum range

• Convert vehicle speed into a needle rotation angle

• Clamp the calculated value to the correct range

• Create variables for the current and target needle values

• Use Float Interpolation to smooth needle movement

• Use Delta Seconds for frame-independent animation

• Adjust the interpolation speed

• Prevent the needle from jumping instantly between values

• Apply the result to Render Transform Angle

• Configure the needle’s Pivot Point

• Correct the needle’s rotation position

• Match the needle movement to the speedometer artwork

• Test minimum and maximum speed values

• Fine-tune the animation during acceleration and deceleration

• Create a cleaner and more realistic dashboard response

By the end of this lesson, the speedometer needle will rotate smoothly and accurately with the vehicle’s speed, giving the HUD a much more professional racing-game feel.

Next: We’ll enhance the speedometer further by adding a dynamic radial speed gauge.

In this lesson, we continue refining the vehicle speedometer by adding a Radial Slider that visually fills as the car gains speed.

We’ll connect the vehicle’s speed value to the radial gauge, normalize the speed into a usable 0–1 range, and fine-tune the slider’s start angle, appearance, and styling so it matches the speedometer needle and artwork.

In this lesson, you will:

• Add a Radial Slider to the speedometer HUD

• Match the radial gauge with the existing speedometer design

• Adjust the slider’s Start Angle

• Correct alignment between the gauge and speedometer needle

• Read the vehicle’s current speed

• Use the configured Maximum Speed

• Divide current speed by maximum speed to create a percentage

• Convert the speed into a normalized 0–1 value

• Set the slider’s minimum and maximum values

• Connect the normalized speed to the Radial Slider

• Make the gauge increase dynamically as the vehicle accelerates

• Keep the gauge synchronized with the animated needle

• Adjust the radial slider’s thickness and visual style

• Fine-tune its size and screen position

• Anchor the speedometer correctly in the HUD

• Test and polish the completed speed gauge during gameplay

By the end of this lesson, the speedometer will have both a smooth animated needle and a dynamic radial progress gauge, giving the HUD a more polished racing-game appearance.

Next: We’ll continue refining the HUD and complete the remaining speedometer and race-interface elements.

In this lesson, we improve the overall race experience by adding audio feedback for important gameplay events and making a few final HUD adjustments in Unreal Engine 5.8.

We’ll add simple 2D sounds for the race start and checkpoint events, reuse the same approach for other race notifications, and test the sounds together with the existing Race Manager and Racer Progress systems.

In this lesson, you will:

• Add audio feedback to the race countdown and GO event

• Use Play Sound 2D for UI and gameplay sounds

• Assign and test race-start audio

• Add sound feedback when the player passes a checkpoint

• Connect checkpoint audio to the existing Race Progress logic

• Reuse the audio setup for additional race events

• Add feedback for lap-completion and race-finish events

• Keep audio events synchronized with gameplay logic

• Test sounds while driving through the checkpoint sequence

• Adjust the existing warning-message appearance

• Refine warning text size and screen position

• Test the complete race flow with visual and audio feedback

By the end of this lesson, the race will provide much clearer audio and visual feedback for countdowns, checkpoints, lap progress, and race events, making the gameplay feel more responsive and polished.

In this lesson, we upgrade the vehicle’s engine sound into a more convincing RPM-driven audio system in Unreal Engine 5.8.

We’ll calculate a normalized engine RPM value, smooth rapid changes caused by gear shifts, prepare multiple engine sound layers, and blend between them using crossfading. We’ll also refine attenuation and volume so the engine audio behaves more naturally around the vehicle.

In this lesson, you will:

• Refine the engine audio attenuation settings

• Control how far the vehicle engine can be heard

• Access the vehicle’s Engine Rotation Speed

• Calculate a normalized engine RPM value

• Divide current RPM by maximum RPM

• Clamp the normalized value between 0 and 1

• Create a reusable RPM calculation function

• Smooth sudden RPM changes during automatic gear shifts

• Use interpolation to make audio transitions more natural

• Adjust interpolation speed for faster or slower response

• Prepare separate low, mid, and high RPM engine sounds

• Enable looping for continuous engine audio

• Create multiple engine audio layers

• Use Crossfade to blend sounds based on RPM

• Configure the crossfade ranges for each engine layer

• Adjust engine audio volume and balance

• Keep the engine sound synchronized with vehicle acceleration

• Test the system through acceleration and gear changes

By the end of this lesson, the race car will have a much more dynamic engine sound that smoothly transitions between different RPM ranges instead of relying on a single looping audio clip.

Next: We’ll continue improving the vehicle audio system and fine-tune the engine sounds for a more polished racing experience.

In this lesson, we add dynamic tire smoke effects to the race car in Unreal Engine 5.8.

We’ll create a particle system for tire smoke, attach the effect to the vehicle wheels, and use the Chaos Vehicle’s wheel-state information to control when the smoke should appear. Instead of constantly emitting smoke, the effect will react to actual tire slipping and skidding.

In this lesson, you will:

• Create a new tire smoke particle system

• Build a simple smoke emitter

• Adjust particle spawn rate

• Control smoke particle size over lifetime

• Scale particles from small to larger as the smoke expands

• Adjust particle lifetime and appearance

• Modify velocity so smoke rises naturally

• Add gravity/force adjustments for better smoke movement

• Position the emitter correctly near the tire contact area

• Attach the tire smoke system to the player vehicle

• Access the Chaos Wheeled Vehicle Movement Component

• Read individual wheel-state data

• Work with wheel indices for front and rear wheels

• Access tire Slip/Skid Magnitude

• Detect when a tire is actually slipping

• Use a Branch to enable or disable the smoke

• Convert slip magnitude into a particle spawn value

• Control particle emission using a User Parameter

• Increase smoke intensity as tire slip becomes stronger

• Prevent smoke from appearing when the tire has sufficient grip

• Test the system during acceleration, braking, cornering, and wheel slip

By the end of this lesson, the race car will generate tire smoke dynamically based on actual Chaos Vehicle wheel behavior, giving drifting, skidding, and hard acceleration much more convincing visual feedback.

Next: We can expand this system further with different tire effects for asphalt, dirt, and other physical surfaces.

In this lesson, we improve the tire-smoke effect by creating an animated smoke flipbook material and connecting it to the Niagara particle system in Unreal Engine 5.8.

We’ll import a transparent smoke sprite sheet, build the translucent particle material, configure Niagara to play the flipbook animation, and then refine the particles so the smoke blends more naturally with the road instead of appearing as obvious flat sprites.

In this lesson, you will:

• Import a transparent smoke flipbook texture

• Create a dedicated tire-smoke particle material

• Configure the material for Translucency

• Use the texture’s color and alpha information

• Connect Particle Color for Niagara control

• Apply the material to the Niagara Sprite Renderer

• Configure the flipbook’s Sub Image Size

• Set up an 8 × 8 sprite sheet

• Animate the flipbook across the particle lifetime

• Verify that each smoke particle plays the animation

• Adjust particle spawn rate and lifetime

• Refine smoke size and scale

• Control upward/downward particle movement

• Add gradual particle fading

• Improve smoke opacity

• Use Depth Fade to soften intersections with the ground

• Reduce visible hard edges where smoke meets the road

• Fine-tune the smoke until it feels softer and more natural

• Test the completed effect on the race car

By the end of this lesson, the tire smoke will use an animated flipbook instead of a static sprite, with smoother fading and better blending against the road surface.

Next: We can continue refining the tire FX with skid marks and surface-dependent effects.

In this lesson, we add dynamic tire skid marks to the race car using wheel-slip data and decal spawning in Unreal Engine 5.8.

We’ll use the same Chaos Vehicle wheel information from the tire-smoke system to detect when a wheel is skidding, then spawn decals at the wheel’s contact point. We’ll also align each skid mark to the road surface and create a decal material that blends correctly with the ground.

In this lesson, you will:

• Reuse the vehicle’s wheel slip and skid data

• Detect when a wheel is actually skidding

• Add conditions so decals are created only when needed

• Access the wheel’s contact location

• Spawn skid marks at the tire contact point

• Work with wheel index data

• Calculate the correct decal position

• Use surface/contact information for decal placement

• Create the correct decal rotation

• Break and rebuild rotation values where required

• Align the skid mark with the road surface

• Adjust decal size and scale

• Create a dedicated skid mark material

• Configure the material for the Deferred Decal domain

• Set up transparency for the skid texture

• Apply the skid material to the spawned decal

• Prevent unwanted decals when the wheel has normal grip

• Test the effect during braking, acceleration, and cornering

By the end of this lesson, the race car will leave dynamic tire skid marks based on actual wheel slip, making hard braking and skidding feel much more realistic.

Next: We can continue refining the tire FX by improving skid-mark continuity, fading, and surface-based variation.

In this lesson, we create and refine a custom road mesh for the race track in Unreal Engine 5.8, with special attention to spline deformation, collision, materials, and performance.

We’ll build the road geometry using Unreal Engine’s Modeling tools, add enough edge loops for smooth bends, remove unnecessary geometry, configure efficient collision, and prepare the finished mesh for use with the Landscape Spline system.

In this lesson, you will:

• Create a new road mesh using Modeling Mode

• Set the correct road dimensions and proportions

• Understand why spline meshes need enough geometry to bend smoothly

• Add additional edge loops and segments

• Improve deformation around corners

• Remove unnecessary faces and geometry

• Adjust vertices and edge loops for a cleaner road profile

• Refine the road thickness and side shape

• Prepare the mesh for Landscape Spline deformation

• Understand simple vs. complex collision

• Avoid unnecessarily expensive collision on the road

• Create and inspect collision for vehicle interaction

• Check collision using visualization/debug tools

• Apply the road material to the custom mesh

• Adjust material scale and alignment

• Set the correct mesh orientation for the spline

• Replace the previous road spline mesh with the optimized version

• Test the vehicle on the updated track

• Organize and save the completed road asset

By the end of this lesson, you’ll have a cleaner and more efficient race-track road mesh that bends smoothly along Landscape Splines and provides reliable vehicle collision.

Next: We’ll continue refining the race environment and prepare the track for the next stage of production.

In this lesson, we improve the race environment by creating more believable terrain erosion and landscape variation in Unreal Engine 5.8.

We’ll explore the landscape erosion workflow, experiment with different simulation settings, control the strength and scale of the erosion, and use the Landmass tools to create a more natural, non-destructive terrain around the race track.

In this lesson, you will:

• Refine the existing race-track landscape

• Use Erosion tools to break up artificial terrain shapes

• Simulate more natural mountain and hillside formations

• Adjust erosion strength and brush size

• Experiment with different erosion settings

• Preview erosion changes before finalizing them

• Understand how erosion changes slopes and vertical surfaces

• Create more believable terrain transitions

• Enable and use the Landmass plugin

• Work with Landscape Blueprint Brush tools

• Add erosion effects using a separate landscape layer

• Keep terrain adjustments more organized and non-destructive

• Modify the scale and influence of the erosion

• Add additional landscape detail around the race track

• Extend and refine the surrounding environment

• Test the landscape from the player’s driving perspective

By the end of this lesson, the race environment will have more natural terrain forms, erosion detail, and believable landscape variation, giving the track a stronger foundation for final environment production.

Next: We’ll continue developing the race environment and add more terrain, materials, and track-side detail

In this lesson, we improve the AI race car so it can control its speed intelligently through corners instead of driving at maximum throttle all the time.

We’ll first connect the AI system to the race countdown so the AI remains stationary until GO. Then we’ll calculate different target speeds for straights and corners, use steering intensity to determine how much the AI should slow down, and apply throttle or braking based on the vehicle’s current speed.

In this lesson, you will:

• Prevent the AI car from moving before the race starts

• Create an AI Enabled Boolean

• Activate the AI from the Race Manager on GO

• Gate the AI driving logic with a Branch

• Tune the AI’s maximum throttle

• Reduce excessive AI speed

• Create separate Straight Speed and Corner Speed values

• Use steering intensity to detect how sharp a corner is

• Clamp steering values into a usable range

• Blend between straight and corner target speeds

• Calculate the AI’s desired speed dynamically

• Read the vehicle’s current forward speed

• Convert vehicle speed into KM/H

• Use Absolute values to handle forward/reverse speed correctly

• Compare current speed with the target speed

• Reduce throttle as the AI approaches the target speed

• Apply braking when the AI is travelling too fast

• Smooth speed transitions between straights and corners

• Tune editable AI speed variables for easier balancing

• Test acceleration, corner entry, braking, and corner exit behavior

By the end of this lesson, the AI car will accelerate on straights, slow down for corners, apply braking when necessary, and begin driving only after the race countdown finishes.

Next: We’ll continue refining the AI racing behavior and make it more competitive and reliable around the complete track.

In this lesson, we improve the AI race car so it can control its speed intelligently through corners instead of driving at maximum throttle all the time.

We’ll first connect the AI system to the race countdown so the AI remains stationary until GO. Then we’ll calculate different target speeds for straights and corners, use steering intensity to determine how much the AI should slow down, and apply throttle or braking based on the vehicle’s current speed.

In this lesson, you will:

• Prevent the AI car from moving before the race starts

• Create an AI Enabled Boolean

• Activate the AI from the Race Manager on GO

• Gate the AI driving logic with a Branch

• Tune the AI’s maximum throttle

• Reduce excessive AI speed

• Create separate Straight Speed and Corner Speed values

• Use steering intensity to detect how sharp a corner is

• Clamp steering values into a usable range

• Blend between straight and corner target speeds

• Calculate the AI’s desired speed dynamically

• Read the vehicle’s current forward speed

• Convert vehicle speed into KM/H

• Use Absolute values to handle forward/reverse speed correctly

• Compare current speed with the target speed

• Reduce throttle as the AI approaches the target speed

• Apply braking when the AI is travelling too fast

• Smooth speed transitions between straights and corners

• Tune editable AI speed variables for easier balancing

• Test acceleration, corner entry, braking, and corner exit behavior

By the end of this lesson, the AI car will accelerate on straights, slow down for corners, apply braking when necessary, and begin driving only after the race countdown finishes.

Next: We’ll continue refining the AI racing behavior and make it more competitive and reliable around the complete track.

In this lesson, we connect the AI race car to the existing Race Manager and Racer Progress systems so the AI follows the same race rules as the player.

We’ll create the necessary AI references inside the Race Manager, retrieve the AI car’s Racer Progress Component, initialize its race state correctly, and enable both AI driving and checkpoint progress when the countdown reaches GO.

In this lesson, you will:

• Integrate the AI vehicle with the existing Race Manager

• Create and store an AI Controller reference

• Create a reference to the AI Race Car

• Access the AI car’s Racer Progress Component

• Store the component as an AIProgress reference

• Assign the Race Manager reference to the AI progress component

• Use bProgressEnabled to control checkpoint processing

• Keep AI race progress disabled before the race starts

• Use bAIEnabled to control AI driving

• Enable the AI Controller when the countdown reaches GO

• Enable AI checkpoint and lap progress at race start

• Add validity checks for important Blueprint references

• Prevent invalid-reference errors

• Connect the AI to the existing checkpoint system

• Allow the AI to track completed laps and checkpoint order

• Keep player-specific HUD feedback separate from AI race events

• Test the player and AI starting the race together

• Verify that both racers use the same race-progress rules

By the end of this lesson, the AI car will be fully connected to the race system, starting at GO and correctly participating in checkpoints, lap counting, and race progress alongside the player.

Next: We’ll continue developing the AI racing system and prepare it for complete race competition.

In this lesson, we refine the AI race car so it follows the track more reliably and feels more natural during straights and corners.

We’ll tune the existing straight speed, corner speed, and look-ahead distance, expose important values so they can be adjusted directly from the Blueprint instance, and use debug visualization to understand exactly where the AI is trying to drive. We’ll also make a small engine-audio attenuation adjustment so the AI vehicle can be heard correctly during the race.

In this lesson, you will:

• Fine-tune the AI car’s Straight Speed

• Adjust the Corner Speed

• Balance AI acceleration and cornering behavior

• Refine the Look Ahead Distance

• Understand how look-ahead distance changes steering behavior

• Reduce unstable steering and loss of control

• Expose important AI variables as Instance Editable

• Tune AI settings directly from the level

• Visualize the look-ahead target with a Debug Sphere

• Check whether the AI target remains correctly positioned on the Race Spline

• Test different look-ahead values around the complete track

• Improve AI stability through difficult corners

• Balance steering responsiveness against speed

• Refine the AI vehicle through repeated gameplay testing

• Adjust engine audio attenuation distance

• Make the AI car’s engine easier to hear as it approaches and passes the player

By the end of this lesson, the AI race car will have more stable steering, better spline tracking, improved corner behavior, and more useful tuning controls for balancing the final race experience.

Next: We’ll continue developing the AI race system and move toward completing the full player-versus-AI race.

In this corrected lesson, we build the logic that determines which racer finishes first, stores each racer’s finishing position, freezes their final race time, and correctly stops both the player and AI after completing the race.

We’ll also add safeguards so repeated finish-line overlaps cannot register the same racer multiple times, and store the final result data inside the Racer Progress Component so it can be used later by the results HUD.

In this lesson, you will:

• Detect when a racer completes the final lap

• Handle both Player and AI race completion

• Stop processing checkpoints after a racer finishes

• Disable the player’s driving controls

• Disable the AI Controller after the AI finishes

• Apply brake/handbrake logic to stop finished vehicles

• Avoid running finish logic continuously every frame

• Create dedicated race-finish logic

• Freeze the racer’s Final Finish Time

• Store the current race time when the finish occurs

• Create a Finish Order array in the Race Manager

• Store racers in the exact order they finish

• Use Add Unique to avoid duplicate racers

• Check whether a racer has already finished

• Prevent multiple finish-line overlaps from changing the results

• Use the Finish Order array length to calculate position

• Determine 1st, 2nd, and later finishing places

• Store each racer’s Finish Place

• Store final time and position inside the Racer Progress Component

• Use the same reusable system for both player and AI racers

• Add validity checks before accessing Racer Progress Components

• Prepare the stored finish data for the final results interface

• Test different Player-vs-AI finishing orders

By the end of this lesson, the Race Manager will reliably know who finished first, each racer’s finishing position, and their frozen final race time, while preventing duplicate finish registrations.

In this lesson, we prepare a second race car for use with the existing Chaos Vehicle setup in Unreal Engine 5.8.

We’ll take a newly imported car, align it with the existing vehicle structure, reuse the current skeleton where possible, reposition wheel bones to match the new model, rebuild the Physics Asset, and apply skin weighting so the chassis and wheels move correctly.

In this lesson, you will:

• Import and prepare a second race car model

• Compare the new vehicle with the existing race car setup

• Reuse the existing vehicle skeleton

• Position the root and wheel bones for the new car

• Match wheel-bone locations to the actual wheel centers

• Copy and adjust bone-position values

• Create and edit the Physics Asset

• Remove incorrect auto-generated collision bodies

• Create a main chassis collision body

• Add sphere collision bodies for the wheels

• Adjust collision size and position

• Verify the vehicle collision setup

• Use Skin Weight / Skin Bind tools

• Assign the chassis to the root bone

• Assign each wheel to the correct wheel bone

• Remove unwanted bone influences

• Check the skin-weight preview

• Convert the prepared mesh into a Skeletal Mesh

• Use the existing skeleton during conversion

• Correct vehicle orientation where required

• Check materials such as body, tires, and glass

• Test the completed second vehicle setup

• Prepare the new car to use the same Chaos Vehicle driving system

By the end of this lesson, the new race car will be properly rigged, skinned, and physically prepared to work with the existing Chaos Vehicle system, making it possible to add multiple different cars without rebuilding the entire driving setup from scratch.

Next: We’ll connect the newly prepared car to the vehicle Blueprint and verify its driving behavior in the race game.