using System;
using UnityEngine;
using Random = UnityEngine.Random;
using System.Collections;
using System.Collections.Generic;

public class vehicleAINavMesh : AINavMesh
{
    [Space]
    [Header ("Vehicle AI Navmesh Custom Settings")]
    [Space]

    public bool vehicleAIActive = true;

    public bool useNavmeshActive;

    public bool autoBrakeOnRemoveTarget;

    [Space]

    public bool checkCurrentTargetStateEnabled;
    public float checkCurrentTargetStateRate = 0.3f;

    [Space]

    // This script provides input to the car controller in the same way that the user control script does.
    // As such, it is really 'driving' the car, with no special physics or animation tricks to make the car behave properly.

    // "wandering" is used to give the cars a more human, less robotic feel. They can waver slightly
    // in speed and direction while driving towards their target.

    [SerializeField][Range (0, 1)] float m_CautiousSpeedFactor = 0.05f;
    // percentage of max speed to use when being maximally cautious
    [SerializeField][Range (0, 180)] float m_CautiousMaxAngle = 50f;
    // angle of approaching corner to treat as warranting maximum caution
    [SerializeField] float m_CautiousMaxDistance = 100f;
    // distance at which distance-based cautiousness begins
    [SerializeField] float m_CautiousAngularVelocityFactor = 30f;
    // how cautious the AI should be when considering its own current angular velocity (i.e. easing off acceleration if spinning!)
    [SerializeField] float m_SteerSensitivity = 0.05f;
    // how sensitively the AI uses steering input to turn to the desired direction
    [SerializeField] float m_AccelSensitivity = 0.04f;
    // How sensitively the AI uses the accelerator to reach the current desired speed
    [SerializeField] float m_BrakeSensitivity = 1f;
    // How sensitively the AI uses the brake to reach the current desired speed
    [SerializeField] float m_LateralWanderDistance = 3f;
    // how far the car will wander laterally towards its target
    [SerializeField] float m_LateralWanderSpeed = 0.1f;
    // how fast the lateral wandering will fluctuate
    [SerializeField][Range (0, 1)] float m_AccelWanderAmount = 0.1f;
    // how much the cars acceleration will wander
    [SerializeField] float m_AccelWanderSpeed = 0.1f;
    // how fast the cars acceleration wandering will fluctuate
    [SerializeField] BrakeCondition m_BrakeCondition = BrakeCondition.TargetDistance;
    // what should the AI consider when accelerating/braking?

    // whether the AI is currently actively driving or stopped.

    // 'target' the target object to aim for.
    [SerializeField] bool m_StopWhenTargetReached = false;
    // should we stop driving when we reach the target?
    [SerializeField] float m_ReachTargetThreshold = 2;
    // proximity to target to consider we 'reached' it, and stop driving.

    public float maxSpeed;

    [Space]
    [Header ("Obstacle Detection Settings")]
    [Space]

    public LayerMask obstacleInFrontLayermask;
    public float obstacleInFrontRaycastDistance = 2;
    public float obstacleInFrontRaycastOffset = 2;

    [Space]

    public bool stopIfCertainObstacleLayerDetected;
    public LayerMask layermaskToStopIfDetected;
    public float capsuleCastRadiusToStopIfDetected;
    public float capsuleCastDistanceToStopIfDetected;

    [Space]
    [Header ("Reverse Direction Settings")]
    [Space]

    public float reversingAccelereationDuration = 3;

    public float minWaitToActivateReversing = 2;

    [Space]
    [Header ("Debug")]
    [Space]

    public bool showVehicleDebugPrint;

    public Vector2 currentInputValues;

    public bool driving;

    public bool usingTrackActive;

    public bool reversingActiveTemporaly;

    public bool obstacleToStopDetected;

    [Space]

    public bool currentTargetIsCharacter;
    public bool currentTargetIsVehicle;
    public bool currentTargetIsDriving;

    [Space]
    [Header ("Components")]
    [Space]

    public inputActionManager mainInputActionManager;
    public Rigidbody m_Rigidbody;
    public Transform m_Target;
    public Transform vehicleTransform;
    public vehicleHUDManager mainVehicleHudManager;
    public AIPatrolSystem AIPatrolManager;

    float m_RandomPerlin;
    // A random value for the car to base its wander on (so that AI cars don't all wander in the same pattern)
    float m_AvoidOtherCarTime;
    // time until which to avoid the car we recently collided with
    float m_AvoidOtherCarSlowdown;
    // how much to slow down due to colliding with another car, whilst avoiding
    float m_AvoidPathOffset;
    // direction (-1 or 1) in which to offset path to avoid other car, whilst avoiding

    float currentSpeed;

    public enum BrakeCondition
    {
        NeverBrake,
        // the car simply accelerates at full throttle all the time.
        TargetDirectionDifference,
        // the car will brake according to the upcoming change in direction of the target. Useful for route-based AI, slowing for corners.
        TargetDistance,
        // the car will brake as it approaches its target, regardless of the target's direction. Useful if you want the car to
        // head for a stationary target and come to rest when it arrives there.
    }

    Vector3 currentVelocity;

    Vector2 moveInput;

    float cautiousnessRequired;
    float spinningAngle;

    float lastTimeReversingActive;

    float lastTimeReversingDisabled;

    float lastSteerDirection = 0;

    bool AIPatrolManagerLocated;

    float lastTimeCheckCurrentTargetState;


    [Space]
    [Space]

    [TextArea (3, 10)]
    public string explanation = "Enable the field Use Navmesh Active on this component if you want to use navmesh on this AI vehicle" +
        "instead of the race track system, which is just to follow a group of waypoints.\n\n" +
        "The navmesh option allows to set the movement based on the navigation path to reach a target, along with using the AI patrol on" +
        "vheicles as well.";


    void Awake ()
    {
        // give the random perlin a random value
        m_RandomPerlin = Random.value * 100;

        if (m_Rigidbody == null) {
            m_Rigidbody = GetComponent<Rigidbody> ();
        }

        if (vehicleTransform == null) {
            vehicleTransform = transform;
        }

        AIPatrolManagerLocated = AIPatrolManager != null;
    }

    public override void Start ()
    {
        base.Start ();

        if (gameObject.activeSelf) {
            mainVehicleHudManager.setUsedByAIState (true);
        }
    }

    void FixedUpdate ()
    {
        if (!vehicleAIActive) {
            return;
        }

        if (usingTrackActive) {
            updateVehicleTrack ();
        }
    }

    void updateVehicleTrack ()
    {
        currentVelocity = m_Rigidbody.linearVelocity;

        currentSpeed = currentVelocity.magnitude * 2.23693629f;

        if (m_Target == null || !driving) {
            // Car should not be moving,
            // use handbrake to stop
            currentInputValues = Vector2.zero;

            mainInputActionManager.overrideInputValues (currentInputValues, -1, 1, true);
        } else {
            Vector3 fwd = vehicleTransform.forward;

            if (currentVelocity.magnitude > maxSpeed * 0.1f) {
                fwd = currentVelocity;
            }

            float desiredSpeed = maxSpeed;

            // now it's time to decide if we should be slowing down...
            switch (m_BrakeCondition) {

                case BrakeCondition.TargetDirectionDifference:

                    // the car will brake according to the upcoming change in direction of the target. Useful for route-based AI, slowing for corners.

                    // check out the angle of our target compared to the current direction of the car
                    float approachingCornerAngle = Vector3.Angle (m_Target.forward, fwd);

                    // also consider the current amount we're turning, multiplied up and then compared in the same way as an upcoming corner angle
                    spinningAngle = m_Rigidbody.angularVelocity.magnitude * m_CautiousAngularVelocityFactor;

                    // if it's different to our current angle, we need to be cautious (i.e. slow down) a certain amount
                    cautiousnessRequired = Mathf.InverseLerp (0, m_CautiousMaxAngle, Mathf.Max (spinningAngle, approachingCornerAngle));

                    desiredSpeed = Mathf.Lerp (maxSpeed, maxSpeed * m_CautiousSpeedFactor, cautiousnessRequired);

                    break;

                case BrakeCondition.TargetDistance:

                    // the car will brake as it approaches its target, regardless of the target's direction. Useful if you want the car to
                    // head for a stationary target and come to rest when it arrives there.

                    // check out the distance to target
                    Vector3 delta = Vector3.zero;

                    if (useNavmeshActive) {
                        delta = new Vector3 (AIMoveInput.moveInput.x, 0, AIMoveInput.moveInput.z);
                    } else {
                        delta = m_Target.position - vehicleTransform.position;
                    }

                    float distanceCautiousFactor = Mathf.InverseLerp (m_CautiousMaxDistance, 0, delta.magnitude);

                    // also consider the current amount we're turning, multiplied up and then compared in the same way as an upcoming corner angle
                    spinningAngle = m_Rigidbody.angularVelocity.magnitude * m_CautiousAngularVelocityFactor;

                    // if it's different to our current angle, we need to be cautious (i.e. slow down) a certain amount
                    cautiousnessRequired = Mathf.Max (Mathf.InverseLerp (0, m_CautiousMaxAngle, spinningAngle), distanceCautiousFactor);

                    desiredSpeed = Mathf.Lerp (maxSpeed, maxSpeed * m_CautiousSpeedFactor, cautiousnessRequired);

                    break;

                case BrakeCondition.NeverBrake:
                    break;
            }

            // Evasive action due to collision with other cars:

            // our target position starts off as the 'real' target position
            Vector3 offsetTargetPos = m_Target.position;

            // if are we currently taking evasive action to prevent being stuck against another car:
            if (Time.time < m_AvoidOtherCarTime) {
                // slow down if necessary (if we were behind the other car when collision occured)
                desiredSpeed *= m_AvoidOtherCarSlowdown;

                // and veer towards the side of our path-to-target that is away from the other car
                offsetTargetPos += m_AvoidPathOffset * m_Target.right;
            } else {
                // no need for evasive action, we can just wander across the path-to-target in a random way,
                // which can help prevent AI from seeming too uniform and robotic in their driving
                offsetTargetPos += ((Mathf.PerlinNoise (Time.time * m_LateralWanderSpeed, m_RandomPerlin) * 2 - 1) * m_LateralWanderDistance) * m_Target.right;
            }

            // use different sensitivity depending on whether accelerating or braking:
            float accelBrakeSensitivity = (desiredSpeed < currentSpeed) ? m_BrakeSensitivity : m_AccelSensitivity;

            // decide the actual amount of accel/brake input to achieve desired speed.
            float accel = Mathf.Clamp ((desiredSpeed - currentSpeed) * accelBrakeSensitivity, -1, 1);

            // add acceleration 'wander', which also prevents AI from seeming too uniform and robotic in their driving
            // i.e. increasing the accel wander amount can introduce jostling and bumps between AI cars in a race
            accel *= (1 - m_AccelWanderAmount) + (Mathf.PerlinNoise (Time.time * m_AccelWanderSpeed, m_RandomPerlin) * m_AccelWanderAmount);

            // calculate the local-relative position of the target, to steer towards
            Vector3 localTarget = vehicleTransform.InverseTransformPoint (offsetTargetPos);

            // work out the local angle towards the target
            float targetAngle = Mathf.Atan2 (localTarget.x, localTarget.z) * Mathf.Rad2Deg;

            // get the amount of steering needed to aim the car towards the target
            float steer = Mathf.Clamp (targetAngle * m_SteerSensitivity, -1, 1) * Mathf.Sign (currentSpeed);

            // feed input to the car controller.

            currentInputValues = new Vector2 (steer, accel);

            mainInputActionManager.overrideInputValues (currentInputValues, accel, 0, true);

            // if appropriate, stop driving when we're close enough to the target.
            if (m_StopWhenTargetReached && localTarget.magnitude < m_ReachTargetThreshold) {
                setDrivingState (false);
            }
        }
    }

    void OnCollisionStay (Collision col)
    {
        // detect collision against other cars, so that we can take evasive action
        if (col.rigidbody != null) {
            var otherAI = applyDamage.getVehicle (col.gameObject);

            if (otherAI != null) {
                // we'll take evasive action for 1 second
                m_AvoidOtherCarTime = Time.time + 1;

                // but who's in front?...
                if (Vector3.Angle (vehicleTransform.forward, otherAI.transform.position - vehicleTransform.position) < 90) {
                    // the other ai is in front, so it is only good manners that we ought to brake...
                    m_AvoidOtherCarSlowdown = 0.5f;
                } else {
                    // we're in front! ain't slowing down for anybody...
                    m_AvoidOtherCarSlowdown = 1;
                }

                // both cars should take evasive action by driving along an offset from the path centre,
                // away from the other car
                var otherCarLocalDelta = vehicleTransform.InverseTransformPoint (otherAI.transform.position);

                float otherCarAngle = Mathf.Atan2 (otherCarLocalDelta.x, otherCarLocalDelta.z);

                m_AvoidPathOffset = m_LateralWanderDistance * -Mathf.Sign (otherCarAngle);
            }
        }
    }

    public void enableOrDisableAIObject (bool state)
    {
        if (state) {
            if (!gameObject.activeSelf) {
                gameObject.SetActive (state);

                pauseAI (false);

                setUsedByAIState (state);
            }
        } else {
            if (mainVehicleHudManager.currentDriverIsAI ()) {
                return;
            }

            if (gameObject.activeSelf) {
                pauseAI (true);

                gameObject.SetActive (state);

                setUsedByAIState (state);

                mainInputActionManager.overrideInputValues (Vector2.zero, -1, 0, false);
            }
        }
    }

    public void enableOrDisableAIObjectWithoutActivatingDrivingState (bool state)
    {
        if (state) {
            if (!gameObject.activeSelf) {
                gameObject.SetActive (state);

                pauseAI (false);

                setUsedByAIStateWithoutActivatingDrvingState (state);
            }
        } else {
            if (mainVehicleHudManager.currentDriverIsAI ()) {
                return;
            }

            if (gameObject.activeSelf) {
                pauseAI (true);

                gameObject.SetActive (state);

                setUsedByAIStateWithoutActivatingDrvingState (state);

                mainInputActionManager.overrideInputValues (Vector2.zero, -1, 0, false);
            }
        }
    }

    public void setUsedByAIState (bool state)
    {
        mainVehicleHudManager.setUsedByAIState (state);
    }

    public void setUsedByAIStateWithoutActivatingDrvingState (bool state)
    {
        mainVehicleHudManager.setUsedByAIStateWithoutActivatingDrvingState (state);
    }

    public void enableOrDisablePatrolState (bool state)
    {
        if (AIPatrolManagerLocated) {
            if (state) {
                if (!AIPatrolManager.isPatrolPaused ()) {

                    setPatrolPauseState (false);

                    AIPatrolManager.setClosestWayPoint ();

                    AIPatrolManager.setReturningToPatrolState (true);

                    setTargetType (false, true);

                    setPatrolState (false);
                }
            } else {
                setPatrolPauseState (true);

                setPatrolState (false);
            }
        }
    }

    public override void setPatrolTarget (Transform newTarget)
    {
        if (patrollingPaused) {
            return;
        }

        follow (newTarget);

        setTargetType (false, true);
    }

    public void SetTarget (Transform target)
    {
        m_Target = target;

        setDrivingState (true);
    }

    public void setDrivingState (bool state)
    {
        driving = state;

        reversingActiveTemporaly = false;

        lastSteerDirection = 0;

        lastTimeReversingActive = 0;

        lastTimeReversingDisabled = 0;
    }

    public void setUsingTrackActive (bool state)
    {
        usingTrackActive = state;
    }

    public void setVehicleAIActiveState (bool state)
    {
        vehicleAIActive = state;
    }

    public override void updateAIControllerInputValues ()
    {
        if (!usingTrackActive) {
            if (isFollowingTarget ()) {
                Vector3 fwd = vehicleTransform.forward;

                if (currentVelocity.magnitude > maxSpeed * 0.1f) {
                    fwd = currentVelocity;
                }

                float desiredSpeed = maxSpeed;

                Vector3 delta = new Vector3 (AIMoveInput.moveInput.x, 0, AIMoveInput.moveInput.z);

                float distanceCautiousFactor = Mathf.InverseLerp (m_CautiousMaxDistance, 0, delta.magnitude);

                // also consider the current amount we're turning, multiplied up and then compared in the same way as an upcoming corner angle
                spinningAngle = m_Rigidbody.angularVelocity.magnitude * m_CautiousAngularVelocityFactor;

                // if it's different to our current angle, we need to be cautious (i.e. slow down) a certain amount
                cautiousnessRequired = Mathf.Max (Mathf.InverseLerp (0, m_CautiousMaxAngle, spinningAngle), distanceCautiousFactor);

                desiredSpeed = Mathf.Lerp (maxSpeed, maxSpeed * m_CautiousSpeedFactor, cautiousnessRequired);


                Vector3 lastPosition = vehicleTransform.position;

                //				if (canReachCurrentTarget) {
                int pathCornersCount = pathCorners.Count;

                if (pathCornersCount > 0) {
                    if (pathCornersCount > 1) {
                        lastPosition = pathCorners [1];
                    } else {
                        lastPosition = pathCorners [0];
                    }
                } else {
                    if (currentTarget != null) {
                        lastPosition = currentTarget.position;
                    }
                }
                //				} else {
                //
                //				}

                m_Target.position = lastPosition;
                m_Target.rotation = Quaternion.LookRotation (delta);

                // Evasive action due to collision with other cars:

                // our target position starts off as the 'real' target position
                Vector3 offsetTargetPos = m_Target.position;

                // if are we currently taking evasive action to prevent being stuck against another car:
                if (Time.time < m_AvoidOtherCarTime) {
                    // slow down if necessary (if we were behind the other car when collision occured)
                    desiredSpeed *= m_AvoidOtherCarSlowdown;

                    // and veer towards the side of our path-to-target that is away from the other car
                    offsetTargetPos += m_AvoidPathOffset * m_Target.right;
                } else {
                    // no need for evasive action, we can just wander across the path-to-target in a random way,
                    // which can help prevent AI from seeming too uniform and robotic in their driving
                    offsetTargetPos += ((Mathf.PerlinNoise (Time.time * m_LateralWanderSpeed, m_RandomPerlin) * 2 - 1) * m_LateralWanderDistance) * m_Target.right;
                }

                // use different sensitivity depending on whether accelerating or braking:
                float accelBrakeSensitivity = (desiredSpeed < currentSpeed) ? m_BrakeSensitivity : m_AccelSensitivity;

                // decide the actual amount of accel/brake input to achieve desired speed.
                float accel = Mathf.Clamp ((desiredSpeed - currentSpeed) * accelBrakeSensitivity, -1, 1);

                // add acceleration 'wander', which also prevents AI from seeming too uniform and robotic in their driving
                // i.e. increasing the accel wander amount can introduce jostling and bumps between AI cars in a race
                accel *= (1 - m_AccelWanderAmount) + (Mathf.PerlinNoise (Time.time * m_AccelWanderSpeed, m_RandomPerlin) * m_AccelWanderAmount);

                // calculate the local-relative position of the target, to steer towards
                Vector3 localTarget = vehicleTransform.InverseTransformPoint (offsetTargetPos);

                // work out the local angle towards the target
                float targetAngle = Mathf.Atan2 (localTarget.x, localTarget.z) * Mathf.Rad2Deg;

                // get the amount of steering needed to aim the car towards the target
                float steer = Mathf.Clamp (targetAngle * m_SteerSensitivity, -1, 1) * Mathf.Sign (currentSpeed);

                // feed input to the car controller.

                float inputAngleWithVehicle = Vector3.Angle (getDesiredVelocity (), vehicleTransform.forward);

                //				print (inputAngleWithVehicle);

                float inputAngleWithVehicleABS = Math.Abs (inputAngleWithVehicle);

                float brakeValue = 0;

                if (reversingActiveTemporaly) {
                    accel *= -1;

                    if (lastSteerDirection != 0) {
                        steer = -lastSteerDirection;
                    }

                    bool disableReversingResult = false;

                    if (Time.time > lastTimeReversingActive + reversingAccelereationDuration) {
                        disableReversingResult = true;

                        if (showVehicleDebugPrint) {
                            print ("disabling reversing direction after wait time");
                        }
                    }

                    if (inputAngleWithVehicleABS < 45) {
                        disableReversingResult = true;

                        if (showVehicleDebugPrint) {
                            print ("disabling reversing direction from right angle");
                        }
                    }

                    //					print (Math.Abs (inputAngleWithVehicleABS - 180) + " " + Math.Abs (steer) + " " +
                    //					(Math.Abs (steer) < 0.3f) + "" + (Math.Abs (inputAngleWithVehicleABS - 180) < 20));
                    //					Math.Abs (steer) < 0.3f ||

                    if (lastSteerDirection == 0 && Math.Abs (inputAngleWithVehicleABS - 180) < 10 && Time.time > lastTimeReversingActive + 0.5f) {
                        disableReversingResult = true;

                        if (showVehicleDebugPrint) {
                            print ("disabling reversing direction after movement in opposite direction");
                        }
                    }

                    if (disableReversingResult) {
                        reversingActiveTemporaly = false;

                        lastTimeReversingDisabled = Time.time;

                        lastSteerDirection = 0;
                    }
                } else {
                    if (lastTimeReversingDisabled == 0 || Time.time > lastTimeReversingDisabled + minWaitToActivateReversing) {
                        if (inputAngleWithVehicleABS > 70) {
                            if (checkIfObstacleInFront ()) {
                                reversingActiveTemporaly = true;

                                lastTimeReversingActive = Time.time;

                                if (Math.Abs (steer) > 0.1f) {
                                    lastSteerDirection = steer;
                                }

                                if (showVehicleDebugPrint) {
                                    print ("reversing direction from obstacle and direction too off");
                                }
                            }
                        } else if (inputAngleWithVehicleABS > 60 && Mathf.Abs (currentVelocity.magnitude) < 10) {
                            if (checkIfObstacleInFront ()) {
                                reversingActiveTemporaly = true;

                                lastTimeReversingActive = Time.time;

                                if (Math.Abs (steer) > 0.1f) {
                                    lastSteerDirection = steer;
                                }

                                if (showVehicleDebugPrint) {
                                    print ("reversing direction from obstacle and direction too off");
                                }
                            }
                        }
                    }

                    if (stopIfCertainObstacleLayerDetected) {
                        obstacleToStopDetected = checkIfObstacleToStopInFront ();

                        if (obstacleToStopDetected) {
                            steer = 0;
                            accel = 0;

                            brakeValue = 1;
                        }
                    }
                }

                currentInputValues = new Vector2 (steer, accel);

                mainInputActionManager.overrideInputValues (currentInputValues, accel, brakeValue, true);

                setOnGroundState (mainVehicleHudManager.isVehicleOnGround ());
            } else {
                currentInputValues = Vector2.zero;

                mainInputActionManager.overrideInputValues (currentInputValues, -1, 1, true);
            }
        }

        if (checkCurrentTargetStateEnabled) {
            if (Time.time > lastTimeCheckCurrentTargetState + checkCurrentTargetStateRate) {
                checkCurrentTargetState ();
            }
        }
    }

    bool checkIfObstacleInFront ()
    {
        if (Physics.Raycast (vehicleTransform.position + obstacleInFrontRaycastOffset * vehicleTransform.forward,
                vehicleTransform.forward, obstacleInFrontRaycastDistance, obstacleInFrontLayermask)) {
            return true;
        }

        return false;
    }

    bool checkIfObstacleToStopInFront ()
    {
        Vector3 currentObjectPosition = vehicleTransform.position + obstacleInFrontRaycastOffset * vehicleTransform.forward;

        Vector3 targetDirection = vehicleTransform.forward;

        Vector3 point1 = currentObjectPosition;
        Vector3 point2 = point1 + capsuleCastDistanceToStopIfDetected * targetDirection;

        //		point1 = currentObjectPosition;
        //		point2 = currentRayTargetPosition.position + capsuleCastDistanceToStopIfDetected * targetDirection;

        RaycastHit [] hits = Physics.CapsuleCastAll (point1, point2, capsuleCastRadiusToStopIfDetected, targetDirection, 0, layermaskToStopIfDetected);

        bool surfaceFound = hits.Length > 0;

        if (surfaceFound) {
            //		if (Physics.CapsuleCast (point1, point2, capsuleCastRadiusToStopIfDetected, targetDirection, capsuleCastDistanceToStopIfDetected, layermaskToStopIfDetected)) {
            if (showGizmo) {
                Debug.DrawLine (point1, point2, Color.red, 2);
            }

            return true;
        } else {
            if (showGizmo) {
                Debug.DrawLine (point1, point2, Color.green, 2);
            }
        }

        return false;
    }

    public override void updateAICameraInputValues ()
    {
        if (!usingTrackActive) {

        }
    }

    public override void removeTarget ()
    {
        setTarget (null);

        if (autoBrakeOnRemoveTarget) {
            mainVehicleHudManager.activateAutoBrakeOnGetOff ();
        }
    }

    public override void checkStateOnSetTarget ()
    {
        checkCurrentTargetState ();
    }

    void checkCurrentTargetState ()
    {
        if (checkCurrentTargetStateEnabled) {
            if (currentTarget != null) {
                currentTargetIsVehicle = applyDamage.isVehicle (currentTarget.gameObject);

                currentTargetIsCharacter = applyDamage.isCharacter (currentTarget.gameObject) && !currentTargetIsVehicle;

                if (currentTargetIsCharacter) {
                    currentTargetIsDriving = applyDamage.isCharacterDriving (currentTarget.gameObject);

                    if (currentTargetIsDriving) {
                        GameObject currentVehicle = applyDamage.getCharacterCurrentVehicle (currentTarget.gameObject);

                        if (currentVehicle != null) {
                            currentTarget = currentVehicle.transform;

                            currentTargetIsVehicle = true;

                            currentTargetIsCharacter = false;

                            if (showDebugPrint) {
                                print ("update target to vehicle " + currentTarget.name);
                            }
                        }
                    }
                } else {
                    GameObject lastDriverGameObject = applyDamage.getLastDriver (currentTarget.gameObject);

                    if (lastDriverGameObject != null) {
                        currentTargetIsDriving = applyDamage.isCharacterDriving (lastDriverGameObject);

                        if (!currentTargetIsDriving) {
                            currentTarget = lastDriverGameObject.transform;

                            currentTargetIsVehicle = false;

                            currentTargetIsCharacter = true;

                            if (showDebugPrint) {
                                print ("update target to character " + currentTarget.name);
                            }
                        }
                    }
                }

                lastTimeCheckCurrentTargetState = Time.time;
            }
        }
    }

    public void setAutoBrakeOnRemoveTargetState (bool state)
    {
        autoBrakeOnRemoveTarget = state;
    }
}