Seek algorithm for cars

Question

I am trying to implement the seek algorithm of steering behaviors for cars. The way I have defined a path for the cars is by using spheres to signify waypoints.

I want the car to move along this waypoint using the seek algorithm. I am trying to do it in the following way. However, the car will only go to the first waypoint and get stuck there.

More specifically, my problem is that my implementation won't update wayIndex and this causes the target to never go to the next point in the waypoints array.

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class Follower : MonoBehaviour
{
    public GameObject vehicle;
    public float[] speeds = {15.0f,25.0f,35.0f};
    public int pathChoice;

    [SerializeField]
    public Transform[] waypoints;
    public Transform[] waypoints2;

    [SerializeField]
    public float speed;
    private int wayIndex = 0;

    private Vector3 target;
    private Vector3 steering;

    private void Start(){
        int speedIndex = UnityEngine.Random.Range(0, 3);
        int pathIndex = UnityEngine.Random.Range(0, 2);
        speed = speeds[speedIndex];
        pathChoice = pathIndex;

        if (pathIndex == 0){
            steering = Vector3.zero;
            target = waypoints[wayIndex].position;
            transform.position = waypoints[wayIndex].transform.position;
        }else if (pathIndex == 1){
            steering = Vector3.zero;
            target = waypoints2[wayIndex].position;
            transform.position = waypoints2[wayIndex].transform.position;
        }
    }

    private void Update(){
        MoveVehicle();
        // transform.Rotate(-90f,0,0,Space.Self);
    }

    private void MoveVehicle(){
        if (pathChoice == 0){
            if (wayIndex <= waypoints.Length - 1){
                target = waypoints[wayIndex].position;

                Vector3 velocity = (target - transform.position).normalized * speed;
                Vector3 seekForce = seek(target);

                steering = steering + seekForce;
                Vector3 finalVel = (velocity + steering);
                
                // transform.position = Vector3.MoveTowards(transform.position,target,speed * Time.deltaTime);
                transform.position = transform.position + finalVel * Time.deltaTime;
                transform.LookAt(target);

                // var targetRotation = Quaternion.LookRotation(target- transform.position);
                // transform.rotation = Quaternion.Slerp(transform.rotation, targetRotation, speed * Time.deltaTime);
                
                if (transform.position == waypoints[wayIndex].transform.position){
                    wayIndex += 1;
                }

                if (transform.position == waypoints[waypoints.Length - 1].position){
                    speed = 0.0f;
                }
            }
        }else if (pathChoice == 1){
            if (wayIndex <= waypoints2.Length - 1){
                target = waypoints2[wayIndex].position;
                transform.position = Vector3.MoveTowards(transform.position,target,speed * Time.deltaTime);

                // var targetRotation = Quaternion.LookRotation(target- transform.position);
                // transform.rotation = Quaternion.Slerp(transform.rotation, targetRotation, speed * Time.deltaTime);

                transform.LookAt(target);
                
                if (transform.position == waypoints2[wayIndex].transform.position){
                    wayIndex += 1;
                }

                if (transform.position == waypoints2[waypoints2.Length - 1].position){
                    speed = 0.0f;
                    vehicle.GetComponent<Follower>().enabled = false;
                    vehicle.GetComponent<Collisions>().enabled = false;
                    Destroy(vehicle);
                }
            } 
        }
    }

    private Vector3 seek(Vector3 target){
        Vector3 vel = (target - transform.position).normalized * speed;
        Vector3 desiredVel = (target - transform.position).normalized * speed;
        Vector3 steeringForce = desiredVel - vel;
        return steeringForce;
    }
}

Its exceptionally unlikely that the floating points in your transform equal the way point. You need to do a mire fuzzy comparison — BugFinder, Nov 24 '21 at 21:38

derHugo · Accepted Answer · 2021-11-25T06:54:41.010

Two issues I see

You are moving your object using
```
transform.position = transform.position + finalVel * Time.deltaTime;
```
So it might happen that this overshoots the target so the check
```
if (transform.position == waypoints[wayIndex].transform.position)
```
which uses a precision range of 0.00001 never becomes true.

Before this didn't happen because MoveTowards prevents any overshooting.

You will need to use a certain range and rather approximately check
```
if(Vector3.Distance(transform.position, waypoints[wayIndex].transform.position) <= THRESHOLD)
```
where THRESHOLD needs to be a range big enough to not to be overshooten by finalVel => Something greater than the maximum finalVel magnitude

In

 Vector3 vel = (target - transform.position).normalized * speed;
 Vector3 desiredVel = (target - transform.position).normalized * speed;
 Vector3 steeringForce = desiredVel - vel;

you store and substract the exact same vector .. your steeringForce is doomed to be always 0,0,0!

Seek algorithm for cars

1 Answers1