car ai doesnt drive around objectsh

Unity Engine
1

hello

i followed a tutorial on youtube for the car ai tutorial

this is the script from that

var centerOfMass : Vector3; 
var path : Array; 
var pathGroup : Transform; 
var maxSteer : float = 15.0; 
var wheelFL : WheelCollider;  
var wheelFR : WheelCollider; 
var wheelRL : WheelCollider;  
var wheelRR : WheelCollider; 
var currentPathObj : int; 
var distFromPath : float = 20; 
var maxTorque : float = 50; 
var currentSpeed : float; 
var topSpeed : float = 150; 
var decellarationSpeed : float = 10; 
var breakingMesh : Renderer; 
var idleBreakLight : Material; 
var activeBreakLight : Material; 
var isBreaking : boolean; 
var inSector : boolean; 
var sensorLength : float = 5; 
var frontSensorStartPoint : float = 5; 
var frontSensorSideDist : float = 5; 
var frontSensorsAngle : float = 30; 
var sidewaySensorLength : float = 5; 
var avoidSpeed : float = 10; 
private var flag : int = 0; 
var reversing : boolean = false; 
var reverCounter : float = 0.0; 
var waitToReverse : float = 2.0; 
var reverFor : float = 1.5; 
var respawnWait: float = 5; 
var respawnCounter : float = 0.0; 
 
 
 
function Start () { 
rigidbody.centerOfMass = centerOfMass; 
GetPath(); 
} 
 
function GetPath (){ 
var path_objs : Array = pathGroup.GetComponentsInChildren(Transform); 
path = new Array(); 
 
for (var path_obj : Transform in path_objs){ 
if (path_obj != pathGroup) 
  path [path.length] = path_obj; 
} 
} 
 
 
function Update () { 
if (flag == 0) 
GetSteer(); 
Move(); 
BreakingEffect (); 
Sensors(); 
Respawn (); 
} 
 
function GetSteer(){ 
var steerVector : Vector3 = transform.InverseTransformPoint(Vector3(path[currentPathObj].position.x,transform.position.y,path[currentPathObj].position.z)); 
var newSteer : float = maxSteer * (steerVector.x / steerVector.magnitude); 
wheelFL.steerAngle = newSteer; 
wheelFR.steerAngle = newSteer; 
 
if (steerVector.magnitude <= distFromPath){ 
currentPathObj++; 
if (currentPathObj >= path.length) 
currentPathObj = 0; 
} 
 
} 
 
function Move (){ 
currentSpeed = 2*(22/7)*wheelRL.radius*wheelRL.rpm * 60 / 1000; 
currentSpeed = Mathf.Round (currentSpeed); 
if (currentSpeed <= topSpeed && !inSector){ 
if (!reversing){ 
wheelRL.motorTorque = maxTorque; 
wheelRR.motorTorque = maxTorque; 
} 
else { 
wheelRL.motorTorque = -maxTorque; 
wheelRR.motorTorque = -maxTorque; 
} 
wheelRL.brakeTorque = 0; 
wheelRR.brakeTorque = 0; 
} 
else if (!inSector){ 
wheelRL.motorTorque = 0; 
wheelRR.motorTorque = 0; 
wheelRL.brakeTorque = decellarationSpeed; 
wheelRR.brakeTorque = decellarationSpeed; 
} 
} 
 
function BreakingEffect (){ 
if (isBreaking){ 
breakingMesh.material = activeBreakLight; 
} 
else { 
breakingMesh.material = idleBreakLight; 
} 
 
} 
 
function Sensors(){ 
flag = 0; 
var avoidSenstivity : float = 0; 
var pos : Vector3; 
var hit : RaycastHit; 
var rightAngle = Quaternion.AngleAxis(frontSensorsAngle,transform.up) * transform.forward; 
var leftAngle = Quaternion.AngleAxis(-frontSensorsAngle,transform.up) * transform.forward; 
 
 
 
pos = transform.position; 
pos += transform.forward*frontSensorStartPoint; 
 
//BRAKING SENSOR 
 
if (Physics.Raycast(pos,transform.forward,hit,sensorLength)){ 
if (hit.transform.tag != "Terrain"){ 
flag++; 
wheelRL.brakeTorque = decellarationSpeed; 
wheelRR.brakeTorque = decellarationSpeed; 
Debug.DrawLine(pos,hit.point,Color.red); 
} 
} 
else { 
wheelRL.brakeTorque = 0; 
wheelRR.brakeTorque = 0; 
} 
 
 
//Front Straight Right Sensor 
pos += transform.right*frontSensorSideDist; 
 
if (Physics.Raycast(pos,transform.forward,hit,sensorLength)){ 
if (hit.transform.tag != "Terrain"){ 
flag++; 
avoidSenstivity -= 1;  
Debug.Log("Avoiding"); 
Debug.DrawLine(pos,hit.point,Color.white); 
} 
} 
else if (Physics.Raycast(pos,rightAngle,hit,sensorLength)){ 
if (hit.transform.tag != "Terrain"){ 
avoidSenstivity -= 0.5;  
flag++; 
Debug.DrawLine(pos,hit.point,Color.white); 
} 
} 
 
 
//Front Straight left Sensor 
pos = transform.position; 
pos += transform.forward*frontSensorStartPoint; 
pos -= transform.right*frontSensorSideDist; 
 
if (Physics.Raycast(pos,transform.forward,hit,sensorLength)){ 
if (hit.transform.tag != "Terrain"){ 
flag++; 
avoidSenstivity += 1;  
Debug.Log("Avoiding"); 
Debug.DrawLine(pos,hit.point,Color.white); 
} 
} 
else if (Physics.Raycast(pos,leftAngle,hit,sensorLength)){ 
if (hit.transform.tag != "Terrain"){ 
flag++; 
avoidSenstivity += 0.5; 
Debug.DrawLine(pos,hit.point,Color.white); 
} 
} 
 
//Right SideWay Sensor 
if (Physics.Raycast(transform.position,transform.right,hit,sidewaySensorLength)){ 
if (hit.transform.tag != "Terrain"){ 
flag++; 
avoidSenstivity -= 0.5; 
Debug.DrawLine(transform.position,hit.point,Color.white); 
} 
} 
 
 
//Left SideWay Sensor 
if (Physics.Raycast(transform.position,-transform.right,hit,sidewaySensorLength)){ 
if (hit.transform.tag != "Terrain"){ 
flag++; 
avoidSenstivity += 0.5; 
Debug.DrawLine(transform.position,hit.point,Color.white); 
} 
} 
 
pos = transform.position; 
pos += transform.forward*frontSensorStartPoint; 
//Front Mid Sensor 
if (avoidSenstivity == 0){ 
 
if (Physics.Raycast(pos,transform.forward,hit,sensorLength)){ 
if (hit.transform.tag != "Terrain"){ 
if (hit.normal.x < 0 ) 
avoidSenstivity = -1; 
else  
avoidSenstivity = 1; 
Debug.DrawLine(pos,hit.point,Color.white); 
} 
} 
} 
 
 
if (rigidbody.velocity.magnitude < 2 && !reversing){ 
reverCounter += Time.deltaTime; 
if (reverCounter >= waitToReverse){ 
reverCounter = 0; 
reversing = true; 
} 
} 
else if (!reversing){ 
reverCounter = 0;  
} 
 
 
if (reversing){ 
avoidSenstivity *= -1; 
reverCounter += Time.deltaTime; 
if (reverCounter >= reverFor){ 
reverCounter = 0; 
reversing = false; 
} 
} 
 
 
if (flag != 0) 
AvoidSteer (avoidSenstivity); 
 
 
} 
 
 
function AvoidSteer (senstivity : float){ 
wheelFL.steerAngle = avoidSpeed*senstivity; 
wheelFR.steerAngle = avoidSpeed*senstivity; 
 
} 
 
 
function Respawn (){ 
if (rigidbody.velocity.magnitude < 2){ 
respawnCounter += Time.deltaTime; 
if (respawnCounter >= respawnWait){ 
if (currentPathObj == 0){ 
transform.position = path[path.length-1].position; 
} 
else{ 
transform.position = path[currentPathObj-1].position; 
} 
respawnCounter = 0; 
transform.localEulerAngles.z = 0; 
} 
} 
}

but for some reason.
in the video when i putt an object on the path the car drives around it but at my car it doesnt do that

does somebody know why

2

I’ve tested this script and it works, although the code that is used for the avoidance is quirky

If the car is avoiding static or slow moving objects, you’ll need to make the sensor lengths much longer than the defaults.

The only problem with this is that nearby obstacles (including other AI cars) might not be avoided in time.

You could also consider

  • Adding both short range and long range sensors
  • Using raycast layers since using strings (i.e. tag and object names) in an update loop should be avoided
  • Doing ray cast calculations at a lower rate or spreading their calculations across frames
3

thx
i will try to make the sensors longer first.

thanks!

4

Sure, no problem.

Also, in case anyone is interested in a converted C# version (which uses standard arrays for the waypoints rather than the Array class)

C# version of Car AI

using UnityEngine;
using System.Collections;

public class AICar : MonoBehaviour {
  
    public Vector3 centerOfMass;
    private Transform[] path;
    public Transform pathGroup;
    public float maxSteer = 15.0f;
    public WheelCollider wheelFL;
    public WheelCollider wheelFR;
    public WheelCollider wheelRL;
    public WheelCollider wheelRR;
    public int currentPathObj;
    public float distFromPath = 20;
    public float maxTorque = 50;
    public float currentSpeed;
    public float topSpeed = 150;
    public float decellarationSpeed = 10;
    public Renderer breakingMesh;
    public Material idleBreakLight;
    public Material activeBreakLight;
    public bool  isBreaking;
    public bool  inSector;
    public float sensorLength = 5;
    public float frontSensorStartPoint = 5;
    public float frontSensorSideDist = 5;
    public float frontSensorsAngle = 30;
    public float sidewaySensorLength = 5;
    public float avoidSpeed = 10;
    private int flag = 0;
    public bool  reversing = false;
    private float reverCounter = 0.0f;
    public float waitToReverse = 2.0f;
    public float reverFor = 1.5f;
    public float respawnWait = 5;
    private float respawnCounter = 0.0f;
  
    void  Start (){
        rigidbody.centerOfMass = centerOfMass;
        GetPath();
    }
  
    void  GetPath (){
        Transform[] path_objs = pathGroup.GetComponentsInChildren<Transform>();
        path = new Transform[path_objs.Length - 1];
      
        int i = 0;
      
        foreach(Transform path_obj in path_objs){
            if (path_obj != pathGroup)
            {
                path [i] = path_obj;
                i++;
            }
        }
    }
  
  
    void  Update (){
        if (flag == 0)
            GetSteer();
        Move();
        BreakingEffect ();
        Sensors();
        Respawn ();
    }
  
    void  GetSteer (){
        Vector3 steerVector = transform.InverseTransformPoint(new Vector3(path[currentPathObj].position.x,transform.position.y,path[currentPathObj].position.z));
        float newSteer = maxSteer * (steerVector.x / steerVector.magnitude);
        wheelFL.steerAngle = newSteer;
        wheelFR.steerAngle = newSteer;

        if (steerVector.magnitude <= distFromPath){
            currentPathObj++;
            if (currentPathObj >= path.Length)
                currentPathObj = 0;
        }
      
    }
  
    void  Move (){
        currentSpeed = 2*(22/7)*wheelRL.radius*wheelRL.rpm * 60 / 1000;
        currentSpeed = Mathf.Round (currentSpeed);
        if (currentSpeed <= topSpeed && !inSector){
            if (!reversing){
                wheelRL.motorTorque = maxTorque;
                wheelRR.motorTorque = maxTorque;
            }
            else {
                wheelRL.motorTorque = -maxTorque;
                wheelRR.motorTorque = -maxTorque;
            }
            wheelRL.brakeTorque = 0;
            wheelRR.brakeTorque = 0;
        }
        else if (!inSector){
            wheelRL.motorTorque = 0;
            wheelRR.motorTorque = 0;
            wheelRL.brakeTorque = decellarationSpeed;
            wheelRR.brakeTorque = decellarationSpeed;
        }
    }
  
    void  BreakingEffect (){
        if (isBreaking && breakingMesh){
            breakingMesh.material = activeBreakLight;
        }
        else if (breakingMesh) {
            breakingMesh.material = idleBreakLight;
        }
      
    }
  
    void  Sensors (){
        flag = 0;
        float avoidSenstivity = 0;
        Vector3 pos;
        RaycastHit hit;
        Vector3 rightAngle = Quaternion.AngleAxis(frontSensorsAngle,transform.up) * transform.forward;
        Vector3 leftAngle = Quaternion.AngleAxis(-frontSensorsAngle,transform.up) * transform.forward;
      
      
      
        pos = transform.position;
        pos += transform.forward*frontSensorStartPoint;
      
        //BRAKING SENSOR
      
        if (Physics.Raycast(pos,transform.forward,out hit,sensorLength)){
            if (hit.transform.tag != "Terrain"){
                flag++;
                wheelRL.brakeTorque = decellarationSpeed;
                wheelRR.brakeTorque = decellarationSpeed;
                Debug.DrawLine(pos,hit.point,Color.red);
            }
        }
        else {
            wheelRL.brakeTorque = 0;
            wheelRR.brakeTorque = 0;
        }
      
      
        //Front Straight Right Sensor
        pos += transform.right*frontSensorSideDist;
      
        if (Physics.Raycast(pos,transform.forward,out hit,sensorLength)){
            if (hit.transform.tag != "Terrain"){
                flag++;
                avoidSenstivity -= 1;
                Debug.Log("Avoiding");
                Debug.DrawLine(pos,hit.point,Color.white);
            }
        }
        else if (Physics.Raycast(pos,rightAngle,out hit,sensorLength)){
            if (hit.transform.tag != "Terrain"){
                avoidSenstivity -= 0.5f;
                flag++;
                Debug.DrawLine(pos,hit.point,Color.white);
            }
        }
      
      
        //Front Straight left Sensor
        pos = transform.position;
        pos += transform.forward*frontSensorStartPoint;
        pos -= transform.right*frontSensorSideDist;
      
        if (Physics.Raycast(pos,transform.forward,out hit,sensorLength)){
            if (hit.transform.tag != "Terrain"){
                flag++;
                avoidSenstivity += 1;
                Debug.Log("Avoiding");
                Debug.DrawLine(pos,hit.point,Color.white);
            }
        }
        else if (Physics.Raycast(pos,leftAngle,out hit,sensorLength)){
            if (hit.transform.tag != "Terrain"){
                flag++;
                avoidSenstivity += 0.5f;
                Debug.DrawLine(pos,hit.point,Color.white);
            }
        }
      
        //Right SideWay Sensor
        if (Physics.Raycast(transform.position,transform.right,out hit,sidewaySensorLength)){
            if (hit.transform.tag != "Terrain"){
                flag++;
                avoidSenstivity -= 0.5f;
                Debug.DrawLine(transform.position,hit.point,Color.white);
            }
        }
      
      
        //Left SideWay Sensor
        if (Physics.Raycast(transform.position,-transform.right,out hit,sidewaySensorLength)){
            if (hit.transform.tag != "Terrain"){
                flag++;
                avoidSenstivity += 0.5f;
                Debug.DrawLine(transform.position,hit.point,Color.white);
            }
        }
      
        pos = transform.position;
        pos += transform.forward*frontSensorStartPoint;
        //Front Mid Sensor
        if (avoidSenstivity == 0){
          
            if (Physics.Raycast(pos,transform.forward,out hit,sensorLength)){
                if (hit.transform.tag != "Terrain"){
                    if (hit.normal.x < 0 )
                        avoidSenstivity = -1;
                    else
                        avoidSenstivity = 1;
                    Debug.DrawLine(pos,hit.point,Color.white);
                }
            }
        }
      
      
        if (rigidbody.velocity.magnitude < 2 && !reversing){
            reverCounter += Time.deltaTime;
            if (reverCounter >= waitToReverse){
                reverCounter = 0;
                reversing = true;
            }
        }
        else if (!reversing){
            reverCounter = 0;
        }
      
      
        if (reversing){
            avoidSenstivity *= -1;
            reverCounter += Time.deltaTime;
            if (reverCounter >= reverFor){
                reverCounter = 0;
                reversing = false;
            }
        }
      
      
        if (flag != 0)
            AvoidSteer (avoidSenstivity);
      
      
    }
  
  
    void  AvoidSteer ( float senstivity  ){
        wheelFL.steerAngle = avoidSpeed*senstivity;
        wheelFR.steerAngle = avoidSpeed*senstivity;
      
    }
  
  
    void  Respawn (){
        if (rigidbody.velocity.magnitude < 2){
            respawnCounter += Time.deltaTime;
            if (respawnCounter >= respawnWait){
                if (currentPathObj == 0){
                    transform.position = path[path.Length-1].position;
                }
                else{
                    transform.position = path[currentPathObj-1].position;
                }
                respawnCounter = 0;
                transform.localEulerAngles.Set (transform.localEulerAngles.x, 0, transform.localEulerAngles.z);
            }
        }
    }
}
5

thanks again i can understand C# better then js

6

that’s true and i’m stuck there, i mean the car doesn’t avoid close object … also when i have many cars (like 6 of them). the cars form a “queue” and follow each other like babies , do you know why ??