Guide to Car Tutorial (Unity3d) part 3 of 3
- Tutorial
Part 1
Part 2
Before we begin, I want to offer scripts rewritten in C #. because half the scripts in JS, I decided to rewrite them under C # (I’m more familiar with C #). Download
There is also an active “analysis” of the project for beginners “Project: Survival shooter” , video tutorials are presented in the next Playlist , additional video tutorials for Survival shooter . I personally express my gratitude to this channel for their hard work.
ps at the end of this manual there is a video review in which examples compare two implemented methods of driving.
So, let's start studying our guide.
We have already seen how to assemble a working machine from a 3D model, scripts and built-in components. We also got acquainted with public variables and how they can be used to fine-tune the car.
Now we will focus on studying the operation of the Car script .
• Double-click on the Car.js script to open it in the code editor.
This script can be a little intimidating at first glance, having more than 500 lines of code and comments and a lot of variables and functions. Do not despair. Our script is built in such a way that we have relatively small functions with meaningful names that indicate what is performed in each function. And also in the code there are comments that explain a specific section of the code.
So we suggest you take a look at it, starting from the “entry” points of the script study and following the guide. In this case, these entry points will be the Start () , Update (), and FixedUpdate () functions.
Each of these “core” functions invokes other functions. Therefore, when we start with the Start () function , we will see that the function first called the SetupWheelColliders () function . Find this function in the code and examine what it does, and then go back to the Start () function and go to the next SetupCenterOfMass () function. By studying this code you will understand how the car functions. In the future, we will consider all these functions. We will not explain each line of code, but we will study all the functions in order.
Working in Unity is easy in many ways, thanks to such things: built-in components, editor, D&D features. Car tuning is half the work - Unity takes care of importing models , collision components , rendering and physics can be added to an object by clicking on the add the Components button .
Inside our script, we will mainly work on manipulating these components. You will certainly come across a lot of calculations and formulas that we use to determine what happens to the car. This is the inevitable part that makes games realistic: you have to set some logic, for example by writing scripts when you want to do more than just basic functions. These formulas and calculations are used in our components.
If you see that the code is not at all familiar and do not know where to start, you can try our approach, which consists in focusing on the following points, and also considering how and what works:
• Rigidbody
• Wheel Colliders
• Calculations and formulas that we draw up, as well as their order.
Think of it this way:
• When adding a Rigidbody to our car model, we have a way to control its physical abilities. We can do this by calculating the forces that move it forward, which slow it down.
• When adding Wheel Colliders, we gain control over where the car collides with the road.
This is where we do the initialization necessary for the car. The Start () function is executed only once, at the beginning of the script, before the Update functions . Therefore, Start () is often used to set the initial values necessary for components in the code.
We have four wheels attached to our car, and we put them in the FrontWheels and RearWheels arrays in the inspector. In this function, we create real colliders , creating the possibility of the interaction of the wheels with the surface and the car. We start with the SetupWheelFrictionCurve () function .
In SetupWheelFrictionCurve (), we simply create a new WheelFrictionCurve and assign it a value that we consider appropriate for our car. WheelFrictionCurve uses WheelColliders to describe the friction properties of wheel tires. If you want to learn the process of creating a car in Unity in more detail, built using WheelColliders , then read the documentation.
After adjusting the curve , we returned to the SetupWheelColliders () script , now we are ready to create colliders and wheel objects . This is done by calling the SetupWheel () function for each of our wheels. If you look at this function, you will see that it has two parameters: Transform and boolean , and returns a Wheel object . We need this in order to change the location of the wheels, as well as to indicate the wheel refers to the front of the car or not. Then the function creates and returns the object Wheel , which we put in the array wheelscontaining all our wheels for the rest of the script:
In this loop, we create a new game object, and call the SetupWheel () function , pass the object coordinates as the first argument, specify TRUE or FALSE as the second parameter , if TRUE , then the created wheel will be front, if it is FALSE then back. Then we add the WheelCollider component to this game object. We set the WheelCollider properties from the suspension variables that we discussed when setting up the car (suspension range, suspension spring and damper) (suspension range, spring and damper).
Necessary properties: collider (collider)we already created, the WheelFrictionCurve is created in the WheelFrictionCurve () function , the graphics for the wheel ( we dragged the DiscBrake object in the inspector when we created the car) and the graphics for the tires (which is a child of DiscBrake ).
We will set the radius of the wheel automatically, depending on the size of the tire:
Finally, we check the wheel we just created, whether it is the front wheel or the rear wheel, looking at the TRUE or FALSE value. Later in the code, we must check that the car touches the ground with at least one front and one rear wheel.
In addition, we make a small reception for the front wheel, creating an additional game object that we install between the car body and the wheel. This is the Steer Column (front pillar) , which we will use later to rotate the wheel when turning. Finally, we create a wheel that returns to the array of wheels “Wheel” and when we have processed all the wheels we return to the Start () function .
This is the next feature we will look at. This is a very small function that will set the center of mass in the Rigidbody to the CenterOfMass we created earlier. If the center of mass has not been set, Rigidbody will use the default center of mass , which will calculate Unity automatically. Then we will convert the maximum speed entered in the inspector using a small useful function:
The function simply multiplies the TopSpeed variable by the number 0.44704, which translates it into meters per second. This is the setting, so we can enter the desired speed in the inspector in miles / hour. When computing physics, we work with m / s. We also have a small function that does the inverse calculation, which is very useful if you want to display the speed of the car in miles / hour.
The gear is automatically calculated in this function by assigning the maximum speed to each gear and calculating how much power is needed to accelerate the car to a given speed in each gear. Power is calculated using the values of friction and resistance, supplied to any variables, which means the main calculations along the Z axis, the calculation of friction occurs in the Update () function. The coefficient is multiplied by the value of this power so that the car accelerates to high speed.
This function finds the Skidmark game object in the scene and stores a link to it using ParticleEmitter to create smoke. The code for skidmarks is not covered in this guide, but it should not stop you from opening the script and exploring it as you wish. At the end of Start (), we assign the X values of our dragMultiplier array to a variable:
It is saved because we change the X variable dragMultiplier when we use the handbrake , and then we need to return to the original value again when we do not use the hand brake .
To set the initial values, use the Start () function . To regularly change these values, use the Update () function .
Update () is called every frame of the game if MonoBehaviour is enabled.
Update () is the most commonly used function to implement the gameplay.
The first thing we do in each frame is different actions from the keyboard by calling the GetInput () function . The first two lines are read from the vertical (vertical) and horizontal (horizontal) axes and stored in the throttle and steer variables :
Vertical and horizontal axes can be set in the Unity Input Manager (Edit -> Project Settings -> Input) . By default, the vertical axis is set to the keys “W”, “up arrow” for moving forward and the keys “S”, “arrow down” for moving backward and the value that we use here is stored in the throttle variable . the horizontal axis is set as the “A” and “left arrow” keys to turn left, as well as the “D” and “right arrow” keys to turn right.
After learning GetInput to drive, we call the CheckHandbrake () function . This is a specific function that checks whether the Space key is pressed or not, and applies certain logic accordingly:
When we first press Space , we set the handbrake variable to true , this starts the hand brake mechanism and changes the value of dragMultiplier.x (It creates a vibration braking on the road, reminiscent of a real hand brake).
When Space (Space)not pressed, the code will be executed differently until the key is pressed. This again means that the handbrake code will not work only when the user releases Space for the first time , because we set the handbrake variable to false inside the block. The StopHandbraking () function will be activated:
StopHandbraking () accepts an input variable that defines the number of seconds it takes to return dragMultiplier.x back to its original state. This value must be at least 5 for the handbraking timer we just started. The function then counts down the specified number of seconds, after which it sets the dragMultiplier.x variable to the default value , this creates the car's movement again normal.
Returning to the Update () function, we will now examine the Check_If_Car_Is_Flipped () function to check if the machine has turned upside down. Inside this function we will check the inverted machine. This is absolutely true for a car that will be turned upside down or turned for example at extreme bends, if we have an accident or do some tricks, but we want to exclude the possibility of a car overturn. Therefore, we check if the car turned over at a certain angle, at which the car is not on the move anymore, and if so, we add the resetTimer variable from the moment of the last frame . If this value ultimately comes down to exceeding the value that we set for resetTime(5 seconds by default), we call the FlipCar () function . If the car is at an angle with which you can ride, we set the timer back to zero.
In FlipCar () we get the car back on wheels and set its speed to 0, so that we can start moving again from this place.
This is the longest and most complex function that is called from Update () . Fortunately, there is this large section that deals only with the placement of tire tracks . An important role in relation to the wheels is played by updating their location and rotation angle in this function.
We start each wheel by checking whether it touches the ground or not. If it concerns the ground, then we set wheelGraphic (the graphics of the wheel) to the position in which it should be, it depends on the height and radius of the wheel. This will move the wheel center to the correct position with respect to the chassis of the vehicle.
After installing the wheel, we get the speed of the RigidBody at the point of contact with the ground, in order to transfer it to local space and store its coordinates in our object.
If the wheel does not currently touch the ground, then we set the wheel’s position based on its coordinates, the suspension range and the “wheels of the parents” suspension itself .
The last function called in the Update () function is UpdateGear () , which calculates the current “transmission” of the car, based on the values set in SetupGears () and the current speed. In the last section of the manual, we should consider the rest of the main cycle, namely, the physical calculations that occur inside the FixedUpdate () function .
When dealing with physics, it is important that the calculations and actions are strictly controlled so that the result is good. FixedUpdate () is created for this purpose. This ensures that code runs at a fixed time interval. The frequency of calling the FixedUpdate () function : “It can be called several times in a frame if the frame rate is low; or can be called up after several frames if the frame rate is high. All calculations and physics updates are called immediately before FixedUpdate () . ” We have a number of functions performed inside FixedUpdate () , and they all relate to calculating and applying force to the car.
This means that with increasing speed - the resistance increases even more. Squaring the speed in the calculation of resistance is based on the present resistance formula used in physics.
After relativeDrag (Relative Resistance) and scalable dragMultiplier (resistance multipliers) which we have already considered, we took into account that the car's profile is very different in appearance from the front, side and top views.
If we are to the hand brakeapply additional forces to the lateral and frontal resistance values, based on how fast the car goes. Notice how we use the scalar product between the speed and the front direction of the car to calculate the additional resistance. This equation leads to additional resistance in front of the car when the car goes forward without turning (braking faster) and slower braking on drifts and turns. For the value of X resistance, the same thing: for a car while sliding sideways. After that, we gradually increase the resistance value X to slow down the car instead of letting it slide on the road always.
If we will not use the hand brake, we will only update the value of X :
This is done for a comfortable ride on the car - we increase the lateral resistance, this gradually slows down the car when skidding until the car completes the skid.
At the end of the function, we apply forces to the RigidBody :
The resistance force is opposite to the speed of the car, we apply it to the RigidBody , as a result of which the car slows down.
This function monitors the friction that is created between the wheels of the car and the surface of our route. It's very simple because we use the WheelFrictionCurve function that we configured at the very beginning. The friction of the wheel gives power to the “output” of the function, based on the tire slip measurements that we passed into the function. This force is divided into two directions: frontal friction (responsible for acceleration and braking) and lateral friction (responsible for the proper maintenance of the car on the ground). Previously, we assigned the value of the friction of the wheels, now we need to take care of updating the friction between the wheel and the surface:
We perform one action - we change the value of the friction of the car based on the current speed of the car and the direction of the car (normal driving - ForwardFriction , and based on skidding the car - "sideways" sidewaysfriction ).
The calculation of engine power, which we later use to apply force to RigidBody, is relatively simple, but it has a few "quirks."
• If we do not throttle , we simply reduce the engine power, thereby slowing down the car.
• If we throttle in the same direction that the car is currently moving (we check this using the HaveSameSign () function) and calculate the value that we add to the power of the engine. What we see may seem a little strange: we calculate the rate of force, which is the product of the current engine power divided by the maximum engine power (yielding a result between 0 and 1), and then multiply by 2 times. The result will be between 0 (when we stand still or eat very slowly) and 2 (when we eat at maximum power). Then we call the helper function EvaluateNormPower () . This function looks at the transmitted value and returns a number between 1 and 0 if the power norm is from 0 to 1. If the power norm is from 1 to 2, the function will return a value between 0 and 1. Are you surprised? The number used in the formula, which adds strength to the engine:
The end result is that we add more power when we press the "gas" button and the car drives slowly from the beginning, gradually accelerating. In the end, when the car reaches maximum speed, no additional forces are no longer used to add to
engine power.
• If you use throttling in the opposite direction, this is equivalent to braking. In this case, we will subtract the engine power for some time.
Finally, the engine power is calculated between the current gear and the previous gear in order to avoid the possibility of abruptly changing the values in the calculation formula.
This is a small function that we will look at now because we need to know which car wheels are on the ground. It makes this check very simple:
• We set the canDrive and canSteer variables to False by default.
• Then we check each wheel in the Wheels array to check which wheel touches the ground and which does not:
If the wheel is on the ground, we check what type of wheel it is. If it is a front wheel, then canDrive is set to True . If this is the rear wheel, then steerWheel is set to True . This function has done its job, if at least one wheel (rear wheel) touches the ground, then we can control our car. If at least one wheel (front wheel) touches the ground, we can turn.
It remains to consider the last two functions that actually relate to our calculations for a RigidBody car. We will look in more detail here so that you understand the logic of work and the calculation formulas that ultimately create the movement of the car.
This function will work if the CalculateState () function sets the canDrive variable to True (this means that there is at least one drive wheel on the road). If we can control, we start by comparing the variable throttle (which is a keystroke from the keyboard) and the variable relativeVelocity.z in which the value of the vehicle’s speed. If these values have the same sign - defined in the HaveSameSign () function - this means that we throttle in the same direction that the car is going, and in this case we add throttle force to RigidBody :
If the throttle value is negative (the user presses the brake button), the sign will be -1 and we will calculate the negative throttleForce (throttle force) that we add to the machine, we also know that the throttle force has a negative speed. Therefore, we will throttle back faster. The opposite effect when the user presses the gas button. Then we add a “positive” throttleForce to a car that is already driving ahead.
If relativeVelocity.z and throttle have different signs, then this should mean that we will add throttle force in the opposite direction from the direction the car is currently traveling. In other words, the car slows down or slows down. We do this by setting the Brakeforce variable based on the mass of the car and the power of the first gear of the engine:
Again we use throttle because we know throttle in this case has the opposite sign of speed, as a result of which, we calculate the force opposite to the force that drives the car.
When we finish determining what the car needs to accelerate or decelerate, we apply the calculated forces in the direction of movement of the Rigidbody:
If you are not creating a drag racing game where you are trying to set a world speed record in a straight run, steering control is just as important as throttling, so let's explore this feature. We do not apply any throttle force as long as the drive wheels do not touch the ground, and the same for this function, where we cannot drive a car as long as the steer wheels do not touch the ground.
At the beginning of the function, we calculate the value of a variable called turnRadius , based on the input data. The equation increases the value of turnRadius when you turn to either side. We calculate the value of minMaxTurn by calling the functionEvaluateSpeedToTurn () .
This function returns the turn value depending on how fast the car is going, this is described in more detail in the second chapter of our manual. If the car goes fast, this value will be closer to minimumTurn , which makes it harder to turn the car during fast movement. Let's go back to the ApplySteering () function , where turnSpeed refers directly to the calculation of turnRadius in the car. The larger the radius, the smaller the rotation angle, because the rotation circle is larger.
We turn the car according to the formula:
Function RotateAround () rotates around the axis transformed at a predetermined point and makes an angle which is a sum of rotations (turns) .
• The pivot point is exactly in the middle of the car when we do not turn the car at all. When we start to press the control key, the point is removed from the car, in the direction we are turning. Remember that the Steer variable has been extracted from the horizontal axis, which is negative when we turn left and positive when we turn right. TurnRadius will grow more and more if we turn in one direction. When TurnRadius is multiplied by transform.right vectorwe get a point that is based in the center of the car and moved to the side to which we turn, as shown in the following images:
• The axes rotate around the Y axis (up) , this means that we turn the car in the X plane - we will turn the car to the line shown in the image.
• The rotation angle is calculated based on turnSpeed times Steer to rotate left / right .
Now consider from the inside:
As we recall, in the handbraking function, we checked whether at least one front wheel touches the ground or not.
If the car does not stand still, then we check the car is currently turning or not, looking at the values of angularVelocity.y in RigidBody . If this value is zero or very small, we do not rotate or rotate very few degrees, and then apply a random value in the direction in which the rotation is made. This will simulate the unsteadiness of the car while using the hand brake .
If the value is not very low, then instead of applying the actual value of angularVelocity.y in the direction of rotation. During a turn to the left, the value will be -1, when turning to the right, the value will be 1.
When using the hand brake, the car turns around, but another point of support is used for braking:
This point is located between the two front wheels when the car rotates around, the result is that the rear of the car moves in the direction of rotation of the car, and the front part holds its position - allowing the car to glide at high speed when using the hand brake .
Now the circle is closed and the functions Update () and LateUpdate () will work together. I hope you enjoyed learning about creating a car by playing with its variables and looking inside the code with us.
In the Project view, you will find a folder named ~ AlternatePhysicsModel . This folder contains some Prefabs scripts and examples for simulating realistic car physics in Unity . The simulation presented here does not use Unity's wheel colliders , but instead we implement our own wheel colliders in a script based on Physics.Raycast . Then he uses the Pacejka script of the “magic formula / Magic Formula” - based on the tire model to calculate the wheel force that is applicable to the car this will give better results.
Most likely, you do not need to know about the internal workings of the physical model. You can just experiment with the settings of prefabs already created . If you open the scripts, you will see that all parameters are explained in the comments. Try changing the settings slightly and driving.
The folder contains five cars in Prefabs and brake tracks (skidmarks) in Prefabs . To try them, just drag one of the cars and the brake tracks (Skidmarks Prefab) onto the stage (of course, Prefabs skidmarks are probably already in the scene). You should now be able to drive around the scene with the car using the arrow keys.
There are also four more realistic cars with very different characteristics for you to experiment with different physical settings and one sports car with more “cool” settings (unrealistically high grip).
The scripts are based on the real laws of physics, with the exception of the TractionHelper scriptwhich is designed to make cars more manageable with the help of joysticks.
AerodynamicResistance.cs : This script must be added to each car in order to calculate the aerodynamic friction of the car.
AntiRollBar.cs : Add as needed to simulate the anti-roll bar for better handling.
CarController.cs : script for handling car controls. This script is required for each car. You can edit this script if you want to change the control of the car or implement AI. It also establishes some characteristics of the car body, such as the center of gravity and inertia.
Drivetrain.cs : car engine and transmission. This script contains the gearbox and engine. One of the scripts needed in the car.
Skidmarks.cs: Global Brake Track Manager (Skidmarks) . Add a Skidmark Prefab to the scene that this class uses to visualize and manage Skidmarks on all cars.
SoundController.cs : A simple class to play car sounds and other sounds. This script must be added to the car.
TractionHelper.cs : If necessary, add this script to the car to make it more stable. This script is designed to help set up flexible vehicle controls.
Wheel.cs : This script mimics tire models and wheel suspensions, and acts as a replacement for the built-in component in UnityWheel Collider.
Wing.cs : Add one script or more than one if you want to simulate the downforce of aerodynamics for your car.
I studied 2 methods of driving, the first method turned out to be easier to drive and in the concept of scripts, but it has its drawbacks:
1) it goes uphill, does not go down the mountain at an angle of 70 degrees even with gravity.
2) when driving forward, and if you sharply reverse and release the key, the car will sharply go forward.
3) the car “flies” on an uneven road and does not land realistically.
4) even if you manually include Drag and Angular Drag in the Rigidbody (in fact, the resistance during the interaction of physical models) will still go up a steep mountain)).
The second method is actually more realistic and devoid of these shortcomings. (~ AlternatePhysicsModel).
Here's the actual video: Lambordgine - method 2, The standard machine in the example method 1.
Conclusion : for those who create “Futuristic Races” we study method 1. For those who create more realistic races - method 2.
Part 2
Before we begin, I want to offer scripts rewritten in C #. because half the scripts in JS, I decided to rewrite them under C # (I’m more familiar with C #). Download
There is also an active “analysis” of the project for beginners “Project: Survival shooter” , video tutorials are presented in the next Playlist , additional video tutorials for Survival shooter . I personally express my gratitude to this channel for their hard work.
ps at the end of this manual there is a video review in which examples compare two implemented methods of driving.
So, let's start studying our guide.
Part 3: Under the hood
We have already seen how to assemble a working machine from a 3D model, scripts and built-in components. We also got acquainted with public variables and how they can be used to fine-tune the car.
Now we will focus on studying the operation of the Car script .
• Double-click on the Car.js script to open it in the code editor.
This script can be a little intimidating at first glance, having more than 500 lines of code and comments and a lot of variables and functions. Do not despair. Our script is built in such a way that we have relatively small functions with meaningful names that indicate what is performed in each function. And also in the code there are comments that explain a specific section of the code.
So we suggest you take a look at it, starting from the “entry” points of the script study and following the guide. In this case, these entry points will be the Start () , Update (), and FixedUpdate () functions.
Each of these “core” functions invokes other functions. Therefore, when we start with the Start () function , we will see that the function first called the SetupWheelColliders () function . Find this function in the code and examine what it does, and then go back to the Start () function and go to the next SetupCenterOfMass () function. By studying this code you will understand how the car functions. In the future, we will consider all these functions. We will not explain each line of code, but we will study all the functions in order.
What things do you need to know?
Working in Unity is easy in many ways, thanks to such things: built-in components, editor, D&D features. Car tuning is half the work - Unity takes care of importing models , collision components , rendering and physics can be added to an object by clicking on the add the Components button .
Inside our script, we will mainly work on manipulating these components. You will certainly come across a lot of calculations and formulas that we use to determine what happens to the car. This is the inevitable part that makes games realistic: you have to set some logic, for example by writing scripts when you want to do more than just basic functions. These formulas and calculations are used in our components.
If you see that the code is not at all familiar and do not know where to start, you can try our approach, which consists in focusing on the following points, and also considering how and what works:
• Rigidbody
• Wheel Colliders
• Calculations and formulas that we draw up, as well as their order.
Think of it this way:
• When adding a Rigidbody to our car model, we have a way to control its physical abilities. We can do this by calculating the forces that move it forward, which slow it down.
• When adding Wheel Colliders, we gain control over where the car collides with the road.
Start () - Installation
This is where we do the initialization necessary for the car. The Start () function is executed only once, at the beginning of the script, before the Update functions . Therefore, Start () is often used to set the initial values necessary for components in the code.
SetupWheelColliders ()
We have four wheels attached to our car, and we put them in the FrontWheels and RearWheels arrays in the inspector. In this function, we create real colliders , creating the possibility of the interaction of the wheels with the surface and the car. We start with the SetupWheelFrictionCurve () function .
SetupWheelFrictionCurve ()
In SetupWheelFrictionCurve (), we simply create a new WheelFrictionCurve and assign it a value that we consider appropriate for our car. WheelFrictionCurve uses WheelColliders to describe the friction properties of wheel tires. If you want to learn the process of creating a car in Unity in more detail, built using WheelColliders , then read the documentation.
SetupWheel ()
After adjusting the curve , we returned to the SetupWheelColliders () script , now we are ready to create colliders and wheel objects . This is done by calling the SetupWheel () function for each of our wheels. If you look at this function, you will see that it has two parameters: Transform and boolean , and returns a Wheel object . We need this in order to change the location of the wheels, as well as to indicate the wheel refers to the front of the car or not. Then the function creates and returns the object Wheel , which we put in the array wheelscontaining all our wheels for the rest of the script:
for (var t : Transform in frontWheels) {
wheels[wheelCount] = SetupWheel(t, true);
wheelCount++;
}
In this loop, we create a new game object, and call the SetupWheel () function , pass the object coordinates as the first argument, specify TRUE or FALSE as the second parameter , if TRUE , then the created wheel will be front, if it is FALSE then back. Then we add the WheelCollider component to this game object. We set the WheelCollider properties from the suspension variables that we discussed when setting up the car (suspension range, suspension spring and damper) (suspension range, spring and damper).
Necessary properties: collider (collider)we already created, the WheelFrictionCurve is created in the WheelFrictionCurve () function , the graphics for the wheel ( we dragged the DiscBrake object in the inspector when we created the car) and the graphics for the tires (which is a child of DiscBrake ).
We will set the radius of the wheel automatically, depending on the size of the tire:
wheel.collider.radius = wheel.tireGraphic.renderer.bounds.size.y / 2;
Finally, we check the wheel we just created, whether it is the front wheel or the rear wheel, looking at the TRUE or FALSE value. Later in the code, we must check that the car touches the ground with at least one front and one rear wheel.
In addition, we make a small reception for the front wheel, creating an additional game object that we install between the car body and the wheel. This is the Steer Column (front pillar) , which we will use later to rotate the wheel when turning. Finally, we create a wheel that returns to the array of wheels “Wheel” and when we have processed all the wheels we return to the Start () function .
SetupCenterOfMass ()
This is the next feature we will look at. This is a very small function that will set the center of mass in the Rigidbody to the CenterOfMass we created earlier. If the center of mass has not been set, Rigidbody will use the default center of mass , which will calculate Unity automatically. Then we will convert the maximum speed entered in the inspector using a small useful function:
topSpeed = Convert_Miles_Per_Hour_To_Meters_Per_Second(topSpeed);
The function simply multiplies the TopSpeed variable by the number 0.44704, which translates it into meters per second. This is the setting, so we can enter the desired speed in the inspector in miles / hour. When computing physics, we work with m / s. We also have a small function that does the inverse calculation, which is very useful if you want to display the speed of the car in miles / hour.
SetupGears ()
The gear is automatically calculated in this function by assigning the maximum speed to each gear and calculating how much power is needed to accelerate the car to a given speed in each gear. Power is calculated using the values of friction and resistance, supplied to any variables, which means the main calculations along the Z axis, the calculation of friction occurs in the Update () function. The coefficient is multiplied by the value of this power so that the car accelerates to high speed.
SetupSkidmarks ()
This function finds the Skidmark game object in the scene and stores a link to it using ParticleEmitter to create smoke. The code for skidmarks is not covered in this guide, but it should not stop you from opening the script and exploring it as you wish. At the end of Start (), we assign the X values of our dragMultiplier array to a variable:
initialDragMultiplierX = dragMultiplier.x;
It is saved because we change the X variable dragMultiplier when we use the handbrake , and then we need to return to the original value again when we do not use the hand brake .
To set the initial values, use the Start () function . To regularly change these values, use the Update () function .
Update ()
Update () is called every frame of the game if MonoBehaviour is enabled.
Update () is the most commonly used function to implement the gameplay.
GetInput ()
The first thing we do in each frame is different actions from the keyboard by calling the GetInput () function . The first two lines are read from the vertical (vertical) and horizontal (horizontal) axes and stored in the throttle and steer variables :
throttle = Input.GetAxis(“Vertical”);
steer = Input.GetAxis(“Horizontal”);
Vertical and horizontal axes can be set in the Unity Input Manager (Edit -> Project Settings -> Input) . By default, the vertical axis is set to the keys “W”, “up arrow” for moving forward and the keys “S”, “arrow down” for moving backward and the value that we use here is stored in the throttle variable . the horizontal axis is set as the “A” and “left arrow” keys to turn left, as well as the “D” and “right arrow” keys to turn right.
CheckHandbrake ()
After learning GetInput to drive, we call the CheckHandbrake () function . This is a specific function that checks whether the Space key is pressed or not, and applies certain logic accordingly:
When we first press Space , we set the handbrake variable to true , this starts the hand brake mechanism and changes the value of dragMultiplier.x (It creates a vibration braking on the road, reminiscent of a real hand brake).
When Space (Space)not pressed, the code will be executed differently until the key is pressed. This again means that the handbrake code will not work only when the user releases Space for the first time , because we set the handbrake variable to false inside the block. The StopHandbraking () function will be activated:
StartCoroutine(StopHandbraking(Mathf.Min(5, Time.time - handbrakeTime)));
StopHandbraking ()
StopHandbraking () accepts an input variable that defines the number of seconds it takes to return dragMultiplier.x back to its original state. This value must be at least 5 for the handbraking timer we just started. The function then counts down the specified number of seconds, after which it sets the dragMultiplier.x variable to the default value , this creates the car's movement again normal.
Check_If_Car_Is_Flipped ()
Returning to the Update () function, we will now examine the Check_If_Car_Is_Flipped () function to check if the machine has turned upside down. Inside this function we will check the inverted machine. This is absolutely true for a car that will be turned upside down or turned for example at extreme bends, if we have an accident or do some tricks, but we want to exclude the possibility of a car overturn. Therefore, we check if the car turned over at a certain angle, at which the car is not on the move anymore, and if so, we add the resetTimer variable from the moment of the last frame . If this value ultimately comes down to exceeding the value that we set for resetTime(5 seconds by default), we call the FlipCar () function . If the car is at an angle with which you can ride, we set the timer back to zero.
FlipCar ()
In FlipCar () we get the car back on wheels and set its speed to 0, so that we can start moving again from this place.
UpdateWheelGraphics ()
This is the longest and most complex function that is called from Update () . Fortunately, there is this large section that deals only with the placement of tire tracks . An important role in relation to the wheels is played by updating their location and rotation angle in this function.
We start each wheel by checking whether it touches the ground or not. If it concerns the ground, then we set wheelGraphic (the graphics of the wheel) to the position in which it should be, it depends on the height and radius of the wheel. This will move the wheel center to the correct position with respect to the chassis of the vehicle.
w.wheelGraphic.localPosition = wheel.transform.up * (wheelRadius + wheel.transform.InverseTransformPoint(wh.point).y);
After installing the wheel, we get the speed of the RigidBody at the point of contact with the ground, in order to transfer it to local space and store its coordinates in our object.
w.wheelVelo = rigidbody.GetPointVelocity(wh.point);
w.groundSpeed = w.wheelGraphic.InverseTransformDirection(w.wheelVelo);
If the wheel does not currently touch the ground, then we set the wheel’s position based on its coordinates, the suspension range and the “wheels of the parents” suspension itself .
UpdateGear ()
The last function called in the Update () function is UpdateGear () , which calculates the current “transmission” of the car, based on the values set in SetupGears () and the current speed. In the last section of the manual, we should consider the rest of the main cycle, namely, the physical calculations that occur inside the FixedUpdate () function .
FixedUpdate () - All of our physics
When dealing with physics, it is important that the calculations and actions are strictly controlled so that the result is good. FixedUpdate () is created for this purpose. This ensures that code runs at a fixed time interval. The frequency of calling the FixedUpdate () function : “It can be called several times in a frame if the frame rate is low; or can be called up after several frames if the frame rate is high. All calculations and physics updates are called immediately before FixedUpdate () . ” We have a number of functions performed inside FixedUpdate () , and they all relate to calculating and applying force to the car.
UpdateDrag ()
This means that with increasing speed - the resistance increases even more. Squaring the speed in the calculation of resistance is based on the present resistance formula used in physics.
After relativeDrag (Relative Resistance) and scalable dragMultiplier (resistance multipliers) which we have already considered, we took into account that the car's profile is very different in appearance from the front, side and top views.
If we are to the hand brakeapply additional forces to the lateral and frontal resistance values, based on how fast the car goes. Notice how we use the scalar product between the speed and the front direction of the car to calculate the additional resistance. This equation leads to additional resistance in front of the car when the car goes forward without turning (braking faster) and slower braking on drifts and turns. For the value of X resistance, the same thing: for a car while sliding sideways. After that, we gradually increase the resistance value X to slow down the car instead of letting it slide on the road always.
If we will not use the hand brake, we will only update the value of X :
drag.x *= topSpeed / relativeVelocity.magnitude;
This is done for a comfortable ride on the car - we increase the lateral resistance, this gradually slows down the car when skidding until the car completes the skid.
At the end of the function, we apply forces to the RigidBody :
rigidbody.AddForce(transform.TransformDirection(drag) * rigidbody.mass * Time.deltaTime);
The resistance force is opposite to the speed of the car, we apply it to the RigidBody , as a result of which the car slows down.
UpdateFriction ()
This function monitors the friction that is created between the wheels of the car and the surface of our route. It's very simple because we use the WheelFrictionCurve function that we configured at the very beginning. The friction of the wheel gives power to the “output” of the function, based on the tire slip measurements that we passed into the function. This force is divided into two directions: frontal friction (responsible for acceleration and braking) and lateral friction (responsible for the proper maintenance of the car on the ground). Previously, we assigned the value of the friction of the wheels, now we need to take care of updating the friction between the wheel and the surface:
w.collider.sidewaysFriction = wfc;
w.collider.forwardFriction = wfc;
We perform one action - we change the value of the friction of the car based on the current speed of the car and the direction of the car (normal driving - ForwardFriction , and based on skidding the car - "sideways" sidewaysfriction ).
CalculateEnginePower ()
The calculation of engine power, which we later use to apply force to RigidBody, is relatively simple, but it has a few "quirks."
• If we do not throttle , we simply reduce the engine power, thereby slowing down the car.
• If we throttle in the same direction that the car is currently moving (we check this using the HaveSameSign () function) and calculate the value that we add to the power of the engine. What we see may seem a little strange: we calculate the rate of force, which is the product of the current engine power divided by the maximum engine power (yielding a result between 0 and 1), and then multiply by 2 times. The result will be between 0 (when we stand still or eat very slowly) and 2 (when we eat at maximum power). Then we call the helper function EvaluateNormPower () . This function looks at the transmitted value and returns a number between 1 and 0 if the power norm is from 0 to 1. If the power norm is from 1 to 2, the function will return a value between 0 and 1. Are you surprised? The number used in the formula, which adds strength to the engine:
currentEnginePower += Time.deltaTime * 200 * EvaluateNormPower(normPower);
The end result is that we add more power when we press the "gas" button and the car drives slowly from the beginning, gradually accelerating. In the end, when the car reaches maximum speed, no additional forces are no longer used to add to
engine power.
• If you use throttling in the opposite direction, this is equivalent to braking. In this case, we will subtract the engine power for some time.
Finally, the engine power is calculated between the current gear and the previous gear in order to avoid the possibility of abruptly changing the values in the calculation formula.
CalculateState ()
This is a small function that we will look at now because we need to know which car wheels are on the ground. It makes this check very simple:
• We set the canDrive and canSteer variables to False by default.
• Then we check each wheel in the Wheels array to check which wheel touches the ground and which does not:
if(w.collider.isGrounded)
If the wheel is on the ground, we check what type of wheel it is. If it is a front wheel, then canDrive is set to True . If this is the rear wheel, then steerWheel is set to True . This function has done its job, if at least one wheel (rear wheel) touches the ground, then we can control our car. If at least one wheel (front wheel) touches the ground, we can turn.
It remains to consider the last two functions that actually relate to our calculations for a RigidBody car. We will look in more detail here so that you understand the logic of work and the calculation formulas that ultimately create the movement of the car.
ApplyThrottle ()
This function will work if the CalculateState () function sets the canDrive variable to True (this means that there is at least one drive wheel on the road). If we can control, we start by comparing the variable throttle (which is a keystroke from the keyboard) and the variable relativeVelocity.z in which the value of the vehicle’s speed. If these values have the same sign - defined in the HaveSameSign () function - this means that we throttle in the same direction that the car is going, and in this case we add throttle force to RigidBody :
throttleForce = Mathf.Sign(throttle) * currentEnginePower * rigidbody.mass;
If the throttle value is negative (the user presses the brake button), the sign will be -1 and we will calculate the negative throttleForce (throttle force) that we add to the machine, we also know that the throttle force has a negative speed. Therefore, we will throttle back faster. The opposite effect when the user presses the gas button. Then we add a “positive” throttleForce to a car that is already driving ahead.
If relativeVelocity.z and throttle have different signs, then this should mean that we will add throttle force in the opposite direction from the direction the car is currently traveling. In other words, the car slows down or slows down. We do this by setting the Brakeforce variable based on the mass of the car and the power of the first gear of the engine:
brakeForce = Mathf.Sign(throttle) * engineForceValues[0] * rigidbody.mass;
Again we use throttle because we know throttle in this case has the opposite sign of speed, as a result of which, we calculate the force opposite to the force that drives the car.
When we finish determining what the car needs to accelerate or decelerate, we apply the calculated forces in the direction of movement of the Rigidbody:
rigidbody.AddForce(transform.forward * Time.deltaTime * (throttleForce + brakeForce));
ApplySteering ()
If you are not creating a drag racing game where you are trying to set a world speed record in a straight run, steering control is just as important as throttling, so let's explore this feature. We do not apply any throttle force as long as the drive wheels do not touch the ground, and the same for this function, where we cannot drive a car as long as the steer wheels do not touch the ground.
At the beginning of the function, we calculate the value of a variable called turnRadius , based on the input data. The equation increases the value of turnRadius when you turn to either side. We calculate the value of minMaxTurn by calling the functionEvaluateSpeedToTurn () .
EvaluateSpeedToTurn ()
This function returns the turn value depending on how fast the car is going, this is described in more detail in the second chapter of our manual. If the car goes fast, this value will be closer to minimumTurn , which makes it harder to turn the car during fast movement. Let's go back to the ApplySteering () function , where turnSpeed refers directly to the calculation of turnRadius in the car. The larger the radius, the smaller the rotation angle, because the rotation circle is larger.
We turn the car according to the formula:
transform.RotateAround( transform.position + transform.right * turnRadius * steer, transform.up, turnSpeed * Mathf.Rad2Deg * Time.deltaTime * steer );
Function RotateAround () rotates around the axis transformed at a predetermined point and makes an angle which is a sum of rotations (turns) .
• The pivot point is exactly in the middle of the car when we do not turn the car at all. When we start to press the control key, the point is removed from the car, in the direction we are turning. Remember that the Steer variable has been extracted from the horizontal axis, which is negative when we turn left and positive when we turn right. TurnRadius will grow more and more if we turn in one direction. When TurnRadius is multiplied by transform.right vectorwe get a point that is based in the center of the car and moved to the side to which we turn, as shown in the following images:
• The axes rotate around the Y axis (up) , this means that we turn the car in the X plane - we will turn the car to the line shown in the image.
• The rotation angle is calculated based on turnSpeed times Steer to rotate left / right .
Now consider from the inside:
if(initialDragMultiplierX > dragMultiplier.x)
As we recall, in the handbraking function, we checked whether at least one front wheel touches the ground or not.
If the car does not stand still, then we check the car is currently turning or not, looking at the values of angularVelocity.y in RigidBody . If this value is zero or very small, we do not rotate or rotate very few degrees, and then apply a random value in the direction in which the rotation is made. This will simulate the unsteadiness of the car while using the hand brake .
If the value is not very low, then instead of applying the actual value of angularVelocity.y in the direction of rotation. During a turn to the left, the value will be -1, when turning to the right, the value will be 1.
When using the hand brake, the car turns around, but another point of support is used for braking:
frontWheels[0].localPosition + frontWheels[1].localPosition) * 0.5
This point is located between the two front wheels when the car rotates around, the result is that the rear of the car moves in the direction of rotation of the car, and the front part holds its position - allowing the car to glide at high speed when using the hand brake .
Now the circle is closed and the functions Update () and LateUpdate () will work together. I hope you enjoyed learning about creating a car by playing with its variables and looking inside the code with us.
Real physical model
In the Project view, you will find a folder named ~ AlternatePhysicsModel . This folder contains some Prefabs scripts and examples for simulating realistic car physics in Unity . The simulation presented here does not use Unity's wheel colliders , but instead we implement our own wheel colliders in a script based on Physics.Raycast . Then he uses the Pacejka script of the “magic formula / Magic Formula” - based on the tire model to calculate the wheel force that is applicable to the car this will give better results.
Most likely, you do not need to know about the internal workings of the physical model. You can just experiment with the settings of prefabs already created . If you open the scripts, you will see that all parameters are explained in the comments. Try changing the settings slightly and driving.
Prefabs Included
The folder contains five cars in Prefabs and brake tracks (skidmarks) in Prefabs . To try them, just drag one of the cars and the brake tracks (Skidmarks Prefab) onto the stage (of course, Prefabs skidmarks are probably already in the scene). You should now be able to drive around the scene with the car using the arrow keys.
There are also four more realistic cars with very different characteristics for you to experiment with different physical settings and one sports car with more “cool” settings (unrealistically high grip).
The scripts are based on the real laws of physics, with the exception of the TractionHelper scriptwhich is designed to make cars more manageable with the help of joysticks.
Included Scripts
AerodynamicResistance.cs : This script must be added to each car in order to calculate the aerodynamic friction of the car.
AntiRollBar.cs : Add as needed to simulate the anti-roll bar for better handling.
CarController.cs : script for handling car controls. This script is required for each car. You can edit this script if you want to change the control of the car or implement AI. It also establishes some characteristics of the car body, such as the center of gravity and inertia.
Drivetrain.cs : car engine and transmission. This script contains the gearbox and engine. One of the scripts needed in the car.
Skidmarks.cs: Global Brake Track Manager (Skidmarks) . Add a Skidmark Prefab to the scene that this class uses to visualize and manage Skidmarks on all cars.
SoundController.cs : A simple class to play car sounds and other sounds. This script must be added to the car.
TractionHelper.cs : If necessary, add this script to the car to make it more stable. This script is designed to help set up flexible vehicle controls.
Wheel.cs : This script mimics tire models and wheel suspensions, and acts as a replacement for the built-in component in UnityWheel Collider.
Wing.cs : Add one script or more than one if you want to simulate the downforce of aerodynamics for your car.
Analysis and conclusion from the translator
I studied 2 methods of driving, the first method turned out to be easier to drive and in the concept of scripts, but it has its drawbacks:
1) it goes uphill, does not go down the mountain at an angle of 70 degrees even with gravity.
2) when driving forward, and if you sharply reverse and release the key, the car will sharply go forward.
3) the car “flies” on an uneven road and does not land realistically.
4) even if you manually include Drag and Angular Drag in the Rigidbody (in fact, the resistance during the interaction of physical models) will still go up a steep mountain)).
The second method is actually more realistic and devoid of these shortcomings. (~ AlternatePhysicsModel).
Here's the actual video: Lambordgine - method 2, The standard machine in the example method 1.
Conclusion : for those who create “Futuristic Races” we study method 1. For those who create more realistic races - method 2.