VehicleAI

using UnityEngine;

public class VehiclesAI : MonoBehaviour {

    #region InspectorField
    public VehiclesController vehicle;
    public float recalculateDelay = 0.75f, angularBrakingSpeed = 20;
    #endregion

    #region PublicField
    [HideInInspector]
    public Vector3 target;
    #endregion

    #region PrivateField
    private NavMeshPath path;
    private float acceleration, steering, steeringAngle, angle, handBraking;
    private bool possiblePath, pointBehind;

    private Transform carTransform;
    //private Transform carTransform {
    //    get {
    //        return vehicle.transform;
    //    }
    //}
    private Vector3 carPos {
        get {
            return carTransform.position;
        }
    }
    private Vector3 carFwr {
        get {
            return carTransform.forward;
        }
    }
    private Vector3 currentPoint {
        get {
            if (path.corners.Length > 1)
                return path.corners[1];
            else
                return carPos;
        }
    }
    private Vector3 currentPointDirection {
        get {
            return currentPoint - carPos;
        }
    }
    private float currentPointDistance {
        get {
            return currentPointDirection.magnitude;
        }
    }
    private bool completedPath {
        get {
            return currentPointDistance < 3f && path.corners.Length <= 2;
        }
    }
    private bool nearPoint {
        get {
            return vehicle.velocity > currentPointDistance + angularBrakingSpeed;
        }
    }
    #endregion

    #region PrivateMethods
    void Start() {
        SetIATransform();

        foreach (var w in vehicle.wheels)
            if (w.maxSteeringAngle > steeringAngle)
                steeringAngle = w.maxSteeringAngle;

        if (steeringAngle == 0) {
            steeringAngle = 1;
            Debug.LogError("This vehicle don't steer");
        }

        path = new NavMeshPath();
        InvokeRepeating("CalculatePath", 0f, recalculateDelay);
    }

    void Update() {
        StabilizePathHeight();
        CalculateAngle();
        ControlVehicle();
    }

    void SetIATransform() {
        carTransform = (Instantiate(new GameObject()) as GameObject).transform;
        carTransform.parent = vehicle.transform;
        carTransform.name = "IAPoint";
        carTransform.localPosition = Vector3.forward * vehicle.GetComponentInChildren<MeshCollider>().bounds.extents.z;
        carTransform.localRotation = Quaternion.identity;

    }

    void ControlVehicle() {
        pointBehind = carTransform.InverseTransformPoint(currentPoint).z < 0;

        CalculateSteering();
        CalculateAcceleration();
        CalculateHandBraking();

        vehicle.inputs.vertical = acceleration;
        vehicle.inputs.horizontal = steering;
        vehicle.inputs.handbraking = handBraking;
    }

    void CalculateAcceleration() {
        if (!possiblePath || completedPath) {
            acceleration = 0;
            return;
        }

        acceleration = Mathf.Clamp(1 - Mathf.Abs(steering), .5f, 1f);

        if (nearPoint)
            acceleration = -Mathf.Sign(acceleration);

        else if (pointBehind) {
            if (vehicle.velocity > -10)
                acceleration = -1f;
            else
                acceleration *= -1f;
        }

        else if (vehicle.velocity < 10f)
            acceleration = 1f;

        acceleration = Mathf.Clamp(acceleration, -1, 1);
    }

    void CalculateSteering() {
        //steering = Mathf.Clamp(angle / steeringAngle, -1, 1);

        steering = angle / steeringAngle;

        steering *= vehicle.engine.reversing ? -1f : 1f;

        steering = Mathf.Clamp(steering, -1, 1);
    }

    void CalculateHandBraking() {
        handBraking = !possiblePath || completedPath ? 1f : 0f;
    }

    void CalculatePath() {
        possiblePath = NavMesh.CalculatePath(carPos, target, NavMesh.AllAreas, path);
        StabilizePathHeight();
    }

    void CalculateAngle() {
        if (path.corners.Length > 1)
            angle = Vector3.Angle(carFwr, currentPointDirection);
        else
            angle = 0;

        if (Vector3.Cross(carFwr, currentPointDirection).y < 0)
            angle *=-1;
    }

    void StabilizePathHeight() {
        for (int c = 0; c < path.corners.Length; c++)
            path.corners[c].y = carPos.y;
    }

#if UNITY_EDITOR
    void OnDrawGizmos() {
        if (UnityEditor.EditorApplication.isPlaying && isActiveAndEnabled) {
            for (int i = 0; i < path.corners.Length - 1; i++)
                if (i + 1 <= path.corners.Length)
                    Gizmos.DrawLine(path.corners[i], path.corners[i + 1]);

            Gizmos.color = Color.black;
            Gizmos.DrawRay(carPos, currentPointDirection);
        }
    }
#endif
    #endregion
}