Please help to transform Car script to XZ plane

[kenneth-huynh]

Hi jongallant,

Thank you so much for sharing your code! I am very appreciative of your work.

I have been trying for the last few days to transform your car script to work on the XZ plane using Rigidbody instead of Rigidbody2D. The World to Local space vector transformation is doing my head in, and still I can't get it to work correclty. I have tried almost everything from renaming .y ->.x, to using LocalVelocity = transform.InverseTransformDirection(Velocity) and Acceleration = transform.TransformDirection(LocalAcceleration);... My car moves sideways?!? I have tried using Local and World rotation on the LocalAcceleration and still it is behaving very strangely....

Can you please help?

Many thanks.
Ken.

[SunQdev]

[XLIVE99]

I have managed to convert the code to XZ plane. I have used Dot product instead of using HeadingAngle to convert vectors. Here are the steps:

I have named my RigidBody as body

Car.cs:

1. Change HeadingAngle calculation to (Found in Start() and FixedUpdate())

Vector3 forw = body.rotation * Vector3.forward;
HeadingAngle = Mathf.Atan2(forw.x, forw.z);

2. Remove float sin = Mathf.Sin(HeadingAngle); and float cos = Mathf.Sin(HeadingAngle); in FixedUpdate()
3. Calculate LocalVelocity by

LocalVelocity.x = Vector3.Dot(body.transform.forward, rawVelocity);
LocalVelocity.y = Vector3.Dot(body.transform.right, rawVelocity);

4. Calculate Acceleration by

Vector2 projectedForw = new Vector2(body.transform.forward.x, body.transform.forward.z);
Vector2 projectedRight = new Vector2(body.transform.right.x, body.transform.right.z);
Acceleration = projectedForw * LocalAcceleration.x + projectedRight * LocalAcceleration.y;

Don't forget to change other Rigidbody2D classes to Rigidbody

If your car still doesn't move or moves too fast, just adjust the RigidBody mass. Sample project's engine variables is good enough with 600 mass.

These steps are optional as it may depend on my project:

Fixing center of gravity position
Center of gravity position might be mirrored. We just have to change sum and subtract symbols
Car.cs:

1. AxleFront.TireLeft.ActiveWeight = weightFront - transferY; change the - to + on all 4 of these. It should look like this:

AxleFront.TireLeft.ActiveWeight = weightFront + transferY;
AxleFront.TireRight.ActiveWeight = weightFront - transferY;
AxleRear.TireLeft.ActiveWeight = weightRear + transferY;
AxleRear.TireRight.ActiveWeight = weightRear - transferY;

Fixing steering is reverse
Car might go right even though you want to go left. Just change SteerInput values to negative ones in Car.cs

My full Car.cs code

Changes I made

• I don't like using GameObject.Find() method, I made them available in inspector
• Converted CenterOfGravity object position to XZ plane
• Since my car setup is different than sample project, CenterOfGravity object's position calculation might be wrong in your project
• Changed tire rotation axis
• Changed HeadingAngle calculation
• Changed Vector2.Distance(...) calculations to Vector3.Distance(...)

using UnityEngine;
using System.Collections.Generic;

public class Car : MonoBehaviour
{
	[SerializeField]
	bool IsPlayerControlled = false;

	[SerializeField]
	[Range(0f, 1f)]
	float CGHeight = 0.55f;

	[SerializeField]
	[Range(0f, 2f)]
	float InertiaScale = 1f;

	[SerializeField]
	float BrakePower = 12000;

	[SerializeField]
	float EBrakePower = 5000;

	[SerializeField]
	[Range(0f, 1f)]
	float WeightTransfer = 0.35f;

	[SerializeField]
	[Range(0f, 1f)]
	float MaxSteerAngle = 0.75f;

	[SerializeField]
	[Range(0f, 20f)]
	float CornerStiffnessFront = 5.0f;

	[SerializeField]
	[Range(0f, 20f)]
	float CornerStiffnessRear = 5.2f;

	[SerializeField]
	[Range(0f, 20f)]
	float AirResistance = 2.5f;

	[SerializeField]
	[Range(0f, 20f)]
	float RollingResistance = 8.0f;

	[SerializeField]
	[Range(0f, 1f)]
	float EBrakeGripRatioFront = 0.9f;

	[SerializeField]
	[Range(0f, 5f)]
	float TotalTireGripFront = 2.5f;

	[SerializeField]
	[Range(0f, 1f)]
	float EBrakeGripRatioRear = 0.4f;

	[SerializeField]
	[Range(0f, 5f)]
	float TotalTireGripRear = 2.5f;

	[SerializeField]
	[Range(0f, 5f)]
	float SteerSpeed = 2.5f;

	[SerializeField]
	[Range(0f, 5f)]
	float SteerAdjustSpeed = 1f;

	[SerializeField]
	[Range(0f, 1000f)]
	float SpeedSteerCorrection = 300f;

	[SerializeField]
	[Range(0f, 20f)]
	float SpeedTurningStability = 10f;

	[SerializeField]
	[Range(0f, 10f)]
	float AxleDistanceCorrection = 2f;

	public float SpeedKilometersPerHour
	{
		get
		{
			return body.velocity.magnitude * 18f / 5f;
		}
	}

	// Variables that get initialized via code
	float Inertia = 1;
	float WheelBase = 1;
	float TrackWidth = 1;

	// Private vars
	float HeadingAngle;
	float AbsoluteVelocity;
	float AngularVelocity;
	float SteerDirection;
	float SteerAngle;

	Vector2 Velocity;
	Vector2 Acceleration;
	Vector2 LocalVelocity;
	Vector2 LocalAcceleration;

	float Throttle;
	float Brake;
	float EBrake;

	Rigidbody body;

	[SerializeField] Axle AxleFront;
	[SerializeField] Axle AxleRear;
	[SerializeField] Engine Engine;

	[SerializeField] GameObject CenterOfGravity;

	void Awake()
	{
		body = GetComponent<Rigidbody>();

		Init();
	}

	void Init()
	{

		Velocity = Vector2.zero;
		AbsoluteVelocity = 0;

		// Dimensions
		AxleFront.DistanceToCG = Vector3.Distance(CenterOfGravity.transform.position, AxleFront.transform.position);
		AxleRear.DistanceToCG = Vector3.Distance(CenterOfGravity.transform.position, AxleRear.transform.position);
		// Extend the calculations past actual car dimensions for better simulation
		AxleFront.DistanceToCG *= AxleDistanceCorrection;
		AxleRear.DistanceToCG *= AxleDistanceCorrection;

		WheelBase = AxleFront.DistanceToCG + AxleRear.DistanceToCG;
		Inertia = body.mass * InertiaScale;

		// Set starting angle of car
		body.rotation = transform.rotation;
		Vector3 forw = body.rotation * Vector3.forward;
		HeadingAngle = Mathf.Atan2(forw.x, forw.z);
	}

	void Start()
	{
		AxleFront.Init(body, WheelBase);
		AxleRear.Init(body, WheelBase);

		TrackWidth = Vector3.Distance(AxleRear.TireLeft.transform.position, AxleRear.TireRight.transform.position);
	}

	void Update()
	{

		if (IsPlayerControlled)
		{

			// Handle Input
			Throttle = 0;
			Brake = 0;
			EBrake = 0;

			if (Input.GetKey(KeyCode.UpArrow))
			{
				Throttle = 1;
			}
			else if (Input.GetKey(KeyCode.DownArrow))
			{
				//Brake = 1;
				Throttle = -1;
			}
			if (Input.GetKey(KeyCode.Space))
			{
				EBrake = 1;
			}

			float steerInput = 0;
			if (Input.GetKey(KeyCode.LeftArrow))
			{
				steerInput = -1;
			}
			else if (Input.GetKey(KeyCode.RightArrow))
			{
				steerInput = 1;
			}

			if (Input.GetKeyDown(KeyCode.A))
			{
				Engine.ShiftUp();
			}
			else if (Input.GetKeyDown(KeyCode.Z))
			{
				Engine.ShiftDown();
			}

			// Apply filters to our steer direction
			SteerDirection = SmoothSteering(steerInput);
			SteerDirection = SpeedAdjustedSteering(SteerDirection);

			// Calculate the current angle the tires are pointing
			SteerAngle = SteerDirection * MaxSteerAngle;

			// Set front axle tires rotation
			AxleFront.TireRight.transform.localRotation = Quaternion.Euler(0, Mathf.Rad2Deg * SteerAngle, 0);
			AxleFront.TireLeft.transform.localRotation = Quaternion.Euler(0, Mathf.Rad2Deg * SteerAngle, 0);
		}


		// Calculate weight center of four tires
		// This is just to draw that red dot over the car to indicate what tires have the most weight
		Vector3 pos = Vector3.zero;
		if (LocalAcceleration.magnitude > 1f)
		{

			float wfl = Mathf.Max(0, (AxleFront.TireLeft.ActiveWeight - AxleFront.TireLeft.RestingWeight));
			float wfr = Mathf.Max(0, (AxleFront.TireRight.ActiveWeight - AxleFront.TireRight.RestingWeight));
			float wrl = Mathf.Max(0, (AxleRear.TireLeft.ActiveWeight - AxleRear.TireLeft.RestingWeight));
			float wrr = Mathf.Max(0, (AxleRear.TireRight.ActiveWeight - AxleRear.TireRight.RestingWeight));

			pos = (AxleFront.TireLeft.transform.localPosition + AxleFront.transform.localPosition) * wfl +
				(AxleFront.TireRight.transform.localPosition + AxleFront.transform.localPosition) * wfr +
				(AxleRear.TireLeft.transform.localPosition + AxleRear.transform.localPosition) * wrl +
				(AxleRear.TireRight.transform.localPosition + AxleRear.transform.localPosition) * wrr;

			float weightTotal = wfl + wfr + wrl + wrr;

			if (weightTotal > 0)
			{
				pos /= weightTotal;
				pos.Normalize();
				pos.x = Mathf.Clamp(pos.x, -0.6f, 0.6f);
			}
			else
			{
				pos = Vector3.zero;
			}
		}

		// Update the "Center Of Gravity" dot to indicate the weight shift
		CenterOfGravity.transform.localPosition = Vector3.Lerp(CenterOfGravity.transform.localPosition, pos, 0.1f);

		// Skidmarks
		if (Mathf.Abs(LocalAcceleration.y) > 18 || EBrake == 1)
		{
			AxleRear.TireRight.SetTrailActive(true);
			AxleRear.TireLeft.SetTrailActive(true);
		}
		else
		{
			AxleRear.TireRight.SetTrailActive(false);
			AxleRear.TireLeft.SetTrailActive(false);
		}

		// Automatic transmission
		Engine.UpdateAutomaticTransmission(body);
	}

	void FixedUpdate()
	{

		// Update from rigidbody to retain collision responses
		Vector3 rawVelocity = body.velocity;
		Velocity = new Vector2(rawVelocity.x, rawVelocity.z);
		Vector3 forw = body.rotation * Vector3.forward;
		HeadingAngle = Mathf.Atan2(forw.x, forw.z);
		//HeadingAngle = 1.571f;
		//HeadingAngle = (body.rotation + 90) * Mathf.Deg2Rad;

		//float sin = Mathf.Sin(HeadingAngle);
		//float cos = Mathf.Cos(HeadingAngle);

		// Get local velocity
		//LocalVelocity.x = cos * Velocity.x + sin * Velocity.y;
		//LocalVelocity.y = cos * Velocity.y - sin * Velocity.x;

		LocalVelocity.x = Vector3.Dot(body.transform.forward, rawVelocity);
		LocalVelocity.y = Vector3.Dot(body.transform.right, rawVelocity);

		// Weight transfer
		float transferX = WeightTransfer * LocalAcceleration.x * CGHeight / WheelBase;
		float transferY = WeightTransfer * LocalAcceleration.y * CGHeight / TrackWidth * 20;        //exagerate the weight transfer on the y-axis

		// Weight on each axle
		float weightFront = body.mass * (AxleFront.WeightRatio * -Physics.gravity.y - transferX);
		float weightRear = body.mass * (AxleRear.WeightRatio * -Physics.gravity.y + transferX);

		// Weight on each tire
		AxleFront.TireLeft.ActiveWeight = weightFront + transferY;
		AxleFront.TireRight.ActiveWeight = weightFront - transferY;
		AxleRear.TireLeft.ActiveWeight = weightRear + transferY;
		AxleRear.TireRight.ActiveWeight = weightRear - transferY;

		// Velocity of each tire
		AxleFront.TireLeft.AngularVelocity = AxleFront.DistanceToCG * AngularVelocity;
		AxleFront.TireRight.AngularVelocity = AxleFront.DistanceToCG * AngularVelocity;
		AxleRear.TireLeft.AngularVelocity = -AxleRear.DistanceToCG * AngularVelocity;
		AxleRear.TireRight.AngularVelocity = -AxleRear.DistanceToCG * AngularVelocity;

		// Slip angle
		AxleFront.SlipAngle = Mathf.Atan2(LocalVelocity.y + AxleFront.AngularVelocity, Mathf.Abs(LocalVelocity.x)) - Mathf.Sign(LocalVelocity.x) * SteerAngle;
		AxleRear.SlipAngle = Mathf.Atan2(LocalVelocity.y + AxleRear.AngularVelocity, Mathf.Abs(LocalVelocity.x));

		// Brake and Throttle power
		float activeBrake = Mathf.Min(Brake * BrakePower + EBrake * EBrakePower, BrakePower);
		float activeThrottle = (Throttle * Engine.GetTorque(body)) * (Engine.GearRatio * Engine.EffectiveGearRatio);

		// Torque of each tire (rear wheel drive)
		AxleRear.TireLeft.Torque = activeThrottle / AxleRear.TireLeft.Radius;
		AxleRear.TireRight.Torque = activeThrottle / AxleRear.TireRight.Radius;

		// Grip and Friction of each tire
		AxleFront.TireLeft.Grip = TotalTireGripFront * (1.0f - EBrake * (1.0f - EBrakeGripRatioFront));
		AxleFront.TireRight.Grip = TotalTireGripFront * (1.0f - EBrake * (1.0f - EBrakeGripRatioFront));
		AxleRear.TireLeft.Grip = TotalTireGripRear * (1.0f - EBrake * (1.0f - EBrakeGripRatioRear));
		AxleRear.TireRight.Grip = TotalTireGripRear * (1.0f - EBrake * (1.0f - EBrakeGripRatioRear));

		AxleFront.TireLeft.FrictionForce = Mathf.Clamp(-CornerStiffnessFront * AxleFront.SlipAngle, -AxleFront.TireLeft.Grip, AxleFront.TireLeft.Grip) * AxleFront.TireLeft.ActiveWeight;
		AxleFront.TireRight.FrictionForce = Mathf.Clamp(-CornerStiffnessFront * AxleFront.SlipAngle, -AxleFront.TireRight.Grip, AxleFront.TireRight.Grip) * AxleFront.TireRight.ActiveWeight;
		AxleRear.TireLeft.FrictionForce = Mathf.Clamp(-CornerStiffnessRear * AxleRear.SlipAngle, -AxleRear.TireLeft.Grip, AxleRear.TireLeft.Grip) * AxleRear.TireLeft.ActiveWeight;
		AxleRear.TireRight.FrictionForce = Mathf.Clamp(-CornerStiffnessRear * AxleRear.SlipAngle, -AxleRear.TireRight.Grip, AxleRear.TireRight.Grip) * AxleRear.TireRight.ActiveWeight;

		// Forces
		float tractionForceX = AxleRear.Torque - activeBrake * Mathf.Sign(LocalVelocity.x);
		float tractionForceY = 0;

		float dragForceX = -RollingResistance * LocalVelocity.x - AirResistance * LocalVelocity.x * Mathf.Abs(LocalVelocity.x);
		float dragForceY = -RollingResistance * LocalVelocity.y - AirResistance * LocalVelocity.y * Mathf.Abs(LocalVelocity.y);

		float totalForceX = dragForceX + tractionForceX;
		float totalForceY = dragForceY + tractionForceY + Mathf.Cos(SteerAngle) * AxleFront.FrictionForce + AxleRear.FrictionForce;

		//adjust Y force so it levels out the car heading at high speeds
		if (AbsoluteVelocity > 10)
		{
			totalForceY *= (AbsoluteVelocity + 1) / (21f - SpeedTurningStability);
		}

		// If we are not pressing gas, add artificial drag - helps with simulation stability
		if (Throttle == 0)
		{
			Velocity = Vector2.Lerp(Velocity, Vector2.zero, 0.005f);
		}

		// Acceleration
		LocalAcceleration.x = totalForceX / body.mass;
		LocalAcceleration.y = totalForceY / body.mass;

		//Acceleration.x = cos * LocalAcceleration.x - sin * LocalAcceleration.y;
		//Acceleration.y = sin * LocalAcceleration.x + cos * LocalAcceleration.y;
		Vector2 projectedForw = new Vector2(body.transform.forward.x, body.transform.forward.z);
		Vector2 projectedRight = new Vector2(body.transform.right.x, body.transform.right.z);
		Acceleration = projectedForw * LocalAcceleration.x + projectedRight * LocalAcceleration.y;

		// Velocity and speed
		Velocity.x += Acceleration.x * Time.deltaTime;
		Velocity.y += Acceleration.y * Time.deltaTime;

		AbsoluteVelocity = Velocity.magnitude;

		// Angular torque of car
		float angularTorque = (AxleFront.FrictionForce * AxleFront.DistanceToCG) - (AxleRear.FrictionForce * AxleRear.DistanceToCG);

		// Car will drift away at low speeds
		if (AbsoluteVelocity < 0.5f && activeThrottle == 0)
		{
			LocalAcceleration = Vector2.zero;
			AbsoluteVelocity = 0;
			Velocity = Vector2.zero;
			angularTorque = 0;
			AngularVelocity = 0;
			Acceleration = Vector2.zero;
			body.angularVelocity = Vector3.zero;
		}

		var angularAcceleration = angularTorque / Inertia;

		// Update 
		AngularVelocity += angularAcceleration * Time.deltaTime;

		// Simulation likes to calculate high angular velocity at very low speeds - adjust for this
		if (AbsoluteVelocity < 1 && Mathf.Abs(SteerAngle) < 0.05f)
		{
			AngularVelocity = 0;
		}
		else if (SpeedKilometersPerHour < 0.75f)
		{
			AngularVelocity = 0;
		}

		HeadingAngle += AngularVelocity * Time.deltaTime;
		body.velocity = new Vector3(Velocity.x, body.velocity.y, Velocity.y);

		body.MoveRotation(Quaternion.AngleAxis(HeadingAngle * Mathf.Rad2Deg, Vector3.up));
	}

	float SmoothSteering(float steerInput)
	{

		float steer = 0;

		if (Mathf.Abs(steerInput) > 0.001f)
		{
			steer = Mathf.Clamp(SteerDirection + steerInput * Time.deltaTime * SteerSpeed, -1.0f, 1.0f);
		}
		else
		{
			if (SteerDirection > 0)
			{
				steer = Mathf.Max(SteerDirection - Time.deltaTime * SteerAdjustSpeed, 0);
			}
			else if (SteerDirection < 0)
			{
				steer = Mathf.Min(SteerDirection + Time.deltaTime * SteerAdjustSpeed, 0);
			}
		}

		return steer;
	}

	float SpeedAdjustedSteering(float steerInput)
	{
		float activeVelocity = Mathf.Min(AbsoluteVelocity, 250.0f);
		float steer = steerInput * (1.0f - (AbsoluteVelocity / SpeedSteerCorrection));
		return steer;
	}
}

[kenneth-huynh]

Wow! Thank you so much for the explanation and providing the full source code. I really appreciate it.