Waypoint navigation help

Unity Engine
1

HI I am trying to make my car navigate around a set of waypoints. I am having problems with the steering, the wheels do not calculate the angle correctly and the car with go in the wrong direction.

If I change the RelativeWaypointPosition.magnitude < 0 to a higher number, the current waypoints will just keep on looping and the car will travel backwards.

Thanks

// These variables allow the script to power the wheels of the car.
var FrontLeftWheel : WheelCollider;
var FrontRightWheel : WheelCollider;
var RearRightWheel : WheelCollider;
var RearLeftWheel : WheelCollider;

var FrontLeft : Transform;
var FrontRight : Transform;
var RearLeft : Transform;
var RearRight : Transform;
// These variables are for the gears, the array is the list of ratios. The script
// uses the defined gear ratios to determine how much torque to apply to the wheels.
var GearRatio : float[];
var CurrentGear : int = 0;


// These variables are just for applying torque to the wheels and shifting gears.
// using the defined Max and Min Engine RPM, the script can determine what gear the
// car needs to be in.
var EngineTorque : float = 800;
var MaxEngineRPM : float = 3000.0;
var MinEngineRPM : float = 1000.0;
private var EngineRPM : float = 0.0;

// Here's all the variables for the AI, the waypoints are determined in the "GetWaypoints" function.
// the waypoint container is used to search for all the waypoints in the scene, and the current
// waypoint is used to determine which waypoint in the array the car is aiming for.
var waypointContainer : GameObject;
private var waypoints : Array;
var currentWaypoint : int = 0;

// input steer and input torque are the values substituted out for the player input. The 
// "NavigateTowardsWaypoint" function determines values to use for these variables to move the car
// in the desired direction.
private var  inputSteer : float = 0.0;
private var inputTorque : float = 0.0;

function Start () {
	// I usually alter the center of mass to make the car more stable. I'ts less likely to flip this way.
	rigidbody.centerOfMass.y = -2.8;
	
	// Call the function to determine the array of waypoints. This sets up the array of points by finding
	// transform components inside of a source container.
	GetWaypoints();
}

function Update () {
	//This is to make the wheels rotate
	FrontLeft.Rotate(FrontLeftWheel.rpm/60*360*Time.deltaTime,0,0);
	FrontRight.Rotate(FrontRightWheel.rpm/60*360*Time.deltaTime,0,0);
	RearLeft.Rotate(RearLeftWheel.rpm/60*360*Time.deltaTime,0,0);
	RearRight.Rotate(RearRightWheel.rpm/60*360*Time.deltaTime,0,0);
	// This is to limith the maximum speed of the car, adjusting the drag probably isn't the best way of doing it,
	// but it's easy, and it doesn't interfere with the physics processing.
	rigidbody.drag = rigidbody.velocity.magnitude / 250;
	
	// Call the funtion to determine the desired input values for the car. This essentially steers and
	// applies gas to the engine.
	NavigateTowardsWaypoint();
	
	// Compute the engine RPM based on the average RPM of the two wheels, then call the shift gear function
	EngineRPM = (FrontLeftWheel.rpm + FrontRightWheel.rpm)/2 * GearRatio[CurrentGear];
	ShiftGears();

	// set the audio pitch to the percentage of RPM to the maximum RPM plus one, this makes the sound play
	// up to twice it's pitch, where it will suddenly drop when it switches gears.
	//audio.pitch = Mathf.Abs(EngineRPM / MaxEngineRPM) + 1.0 ;
	// this line is just to ensure that the pitch does not reach a value higher than is desired.
//	if ( audio.pitch > 2.0 ) {
//		audio.pitch = 2.0;
//	}
	
	// finally, apply the values to the wheels.	The torque applied is divided by the current gear, and
	// multiplied by the calculated AI input variable.
	FrontLeftWheel.motorTorque = EngineTorque / GearRatio[CurrentGear]*inputTorque;
	FrontRightWheel.motorTorque = EngineTorque / GearRatio[CurrentGear]*inputTorque;
	
	//GearRatio[CurrentGear]
		
	// the steer angle is an arbitrary value multiplied by the calculated AI input.
	FrontLeftWheel.steerAngle = 10 * inputSteer;
	FrontRightWheel.steerAngle = 10 * inputSteer;
}

function ShiftGears() {
	// this funciton shifts the gears of the vehcile, it loops through all the gears, checking which will make
	// the engine RPM fall within the desired range. The gear is then set to this "appropriate" value.
	if ( EngineRPM >= MaxEngineRPM ) {
		var AppropriateGear : int = CurrentGear;
		
		for ( var i = 0; i < GearRatio.length; i ++ ) {
			if ( FrontLeftWheel.rpm * GearRatio[i] < MaxEngineRPM ) {
				AppropriateGear = i;
				break;
			}
		}
		
		CurrentGear = AppropriateGear;
	}
	
	if ( EngineRPM <= MinEngineRPM ) {
		AppropriateGear = CurrentGear;
		
		for ( var j = GearRatio.length-1; j >= 0; j -- ) {
			if ( FrontLeftWheel.rpm * GearRatio[j] > MinEngineRPM ) {
				AppropriateGear = j;
				break;
			}
		}
		
		CurrentGear = AppropriateGear;
	}
}

function GetWaypoints () {
	// Now, this function basically takes the container object for the waypoints, then finds all of the transforms in it,
	// once it has the transforms, it checks to make sure it's not the container, and adds them to the array of waypoints.
	var potentialWaypoints : Array = waypointContainer.GetComponentsInChildren( Transform );
	waypoints = new Array();
	
	for ( var potentialWaypoint : Transform in potentialWaypoints ) {
		if ( potentialWaypoint != waypointContainer.transform ) {
			waypoints[ waypoints.length ] = potentialWaypoint;
		}
	}
}

function NavigateTowardsWaypoint () {
	// now we just find the relative position of the waypoint from the car transform,
	// that way we can determine how far to the left and right the waypoint is.
	var target  : Vector3 = waypoints[currentWaypoint].position;
	var moveDirection : Vector3 = target - transform.position;
	var RelativeWaypointPosition : Vector3 = transform.InverseTransformPoint(Vector3(waypoints[currentWaypoint].position.x,transform.position.y,waypoints[currentWaypoint].position.z));
																				
	// by dividing the horizontal position by the magnitude, we get a decimal percentage of the turn angle that we can use to drive the wheels
	inputSteer = RelativeWaypointPosition.x / RelativeWaypointPosition.magnitude;
	
	// now we do the same for torque, but make sure that it doesn't apply any engine torque when going around a sharp turn...
	if ( Mathf.Abs( inputSteer ) < 0.5 ) {
		inputTorque = RelativeWaypointPosition.z / RelativeWaypointPosition.magnitude - Mathf.Abs( inputSteer );
	}else{
		inputTorque = 0.0;
	}
	
	// this just checks if the car's position is near enough to a waypoint to count as passing it, if it is, then change the target waypoint to the
	// next in the list.
	if ( RelativeWaypointPosition.magnitude < 0) {
		currentWaypoint ++;
		
		if ( currentWaypoint >= waypoints.length ) {
			currentWaypoint = 0;
		}
	}
	
}
2

I have also tried some other code which is a lot simpler but I can’t get the rotation of the car working.

function GetWaypoints(){

		var path_objs : Array = waypointContainer.GetComponentsInChildren.<Transform>();  
		path =  new Array();  
		
		for (var path_obj : Transform in path_objs){  
			if (path_obj != waypointContainer)  
			path [path.length] = path_obj;  
		}
		Debug.Log(path.length);

}  





function GetSteer(){
		var path : Transform[];
 		path = waypointContainer.GetComponentsInChildren.<Transform>();
		var target  : Vector3 = path[currentWaypoint].position;
		var moveDirection : Vector3 = target - transform.position;
		var velocity = rigidbody.velocity;
		var player = GameObject.FindGameObjectWithTag("Player").transform;
		var targetRotation = Quaternion.LookRotation(target - transform.position, Vector3.up);
		var step = speed * Time.deltaTime;
		var newDir = Vector3.RotateTowards(transform.forward, moveDirection,step, 0.0);
		//var steerVector : Vector3 = transform.InverseTransformPoint(Vector3(path[currentWaypoint].position.x,transform.position.y,path[currentWaypoint].position.z));  
		//var newSteer : float = maxSteer * (moveDirection.x / moveDirection.magnitude);  
//		wheelFL.steerAngle = newSteer;  
//		wheelFR.steerAngle = newSteer;
		
		if (moveDirection.magnitude < 5){  
		currentWaypoint++;
		player.rotation = Quaternion.LookRotation(newDir);
		//moveAndRotateToThis(target,4);
		}
		else{
		 velocity = moveDirection.normalized*topSpeed;  
		} 
		if (currentWaypoint >= path.length) { 
		currentWaypoint = 0;  
		}  
		 rigidbody.velocity = velocity; 
	}
3

Anyone? I’ve been stuck for hours :((