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



public interface IState
{
    void OnEnter();
    void Update();
    void FixedUpdate();
    void OnExit();
}

public enum AnimationState
{
    Walk = 0,
    SpeedMatch = 0,
    Idle = 0,
    Action = 2,
    Dead = 3,
    GoldWalk = 4,
}

public enum CurrentPath
{
    Up,
    Mid,
    Down
}
public enum Opposition
{
    Elfs,
    Pieten
}

public enum UnitClass
{
    Melee,
    Ranged,
    Caster,
    Buff,
    Collector,
    Base

}
public delegate void GotHit(int recievedDamage, int currentHealth);
public class UnitBehaviours : MonoBehaviour
{
    public Opposition _Side;
    public IState _State;
    public AnimationState _AnimationState;
    public UnitClass _Class;

    public Transform _Sprite;
    public Animator _Animator;
    public CapsuleCollider _Colloder;
    public SpriteRenderer _Renderer;

    public LaneManager _PathChoice;

    public List<Transform> _Points;
    public Transform[] _Path;
    public Transform _Destination;
    public int _DestinationIndex;
    public bool _PathSet, HasGold, _IsBuffed;

    // BaseStats
    public int _BaseHealth, _BaseDamage, _BaseGold;
    public float _BaseSpeed, _BaseRange;

    public Vector3 _BaseRangeOffset;
    // currenStats
    public int _Health, _Damage, _Gold;
    public float _Speed, _Range;
    public Vector3 _RangeOffset;
    public float _CastTimeInSecondes, _DistanceToProceed;
    public int _Cost;


    public event GotHit _GotHit;

    public UnitBehaviours _Tower;

    [SerializeField]public ParticleSystem _BuffParticle, _ActionParticle;


    private void OnDrawGizmos()
    {

        _Colloder = GetComponent<CapsuleCollider>();
        Gizmos.color = Color.green;
        Gizmos.DrawWireSphere(transform.position, _DistanceToProceed);
        Gizmos.color = Color.red;
        Gizmos.DrawWireSphere((transform.position + (new Vector3(0, _Colloder.height) * 0.5f)) + ( _RangeOffset), _Range);
    }
    private void Awake()
    {
        _Health = _BaseHealth;
        _Damage = _BaseDamage;
        _Gold = _BaseGold;
        _Speed = _BaseSpeed;
        _Range = _BaseRange;
        _RangeOffset = _BaseRangeOffset;

        _Colloder = GetComponent<CapsuleCollider>();
        _Animator = _Sprite.GetComponent<Animator>();
        _Renderer = _Sprite.GetComponent<SpriteRenderer>();


        foreach (Transform child in GameObject.Find("WayPoints").transform)
        {
            _Points.Add(child);
        }

        switch (_Side)
        {
            case Opposition.Elfs:
                _PathChoice = GameObject.Find("LaneChooseElfs").GetComponent<LaneManager>();
                _Tower = GameObject.Find("BaseElf").GetComponent<UnitBehaviours>();

                break;
            case Opposition.Pieten:
                _Points.Reverse();
                _RangeOffset.x = -Mathf.Abs(_RangeOffset.x);
                _PathChoice = GameObject.Find("LaneChoosePieten").GetComponent<LaneManager>();
                _Tower = GameObject.Find("BasePiet").GetComponent<UnitBehaviours>();
                break;
        }


        if (_Class == UnitClass.Collector)
        {
            _Colloder.enabled = false;
            _Path = new Transform[]
        {
            _Points[0],
            _Points[2],
        };
        }
        else
        {
            _Path = new Transform[]
        {
            _Points[0],
            _Points[2],
            _Points[5],
            _Points[7]
        };
        }


        _DestinationIndex = 1;
        _Destination = _Path[_DestinationIndex];

        _State = new Walk(this);

    }
    void Start()
    {
        if (_Class != UnitClass.Base)
        {
            transform.position = _Path[0].position;
        }
    }

    public void LoadScene(int sceneindex)
    {
        Application.LoadLevel(sceneindex);
    }
    void FixedUpdate()
    {
        _State.FixedUpdate();
    }
    void Update()
    {
        _State.Update();

        if (_Class != UnitClass.Collector)
        {

            if (_PathSet == false)
            {
                switch (_PathChoice._ChosenPath)
                {
                    case ChosenPath.Up:
                        _Path = new Transform[]
                       {
                        _Points[0],
                        _Points[2],
                        _Points[1],
                        _Points[6],
                        _Points[5],
                        _Points[7]
                       };

                        break;
                    case ChosenPath.Mid:
                        _Path = new Transform[]
                        {
                        _Points[0],
                        _Points[2],
                        _Points[5],
                        _Points[7]
                        };
                        break;
                    case ChosenPath.Down:
                        _Path = new Transform[]
                       {
                        _Points[0],
                        _Points[2],
                        _Points[3],
                        _Points[4],
                        _Points[5],
                        _Points[7]
                       };
                        break;
                }
            }
        }

        if (_IsBuffed)
        {
            _BuffParticle.gameObject.SetActive(true);
        }

        if (_Health <= 0)
        {
            if (_Class == UnitClass.Base)
            {
                if (_Side == Opposition.Elfs)
                {
                    LoadScene(4);
                }
                else if (_Side == Opposition.Pieten)
                {
                    LoadScene(3);
                }
            }
        }
    }
    public void SetAnimation(AnimationState aninemationstate)
    {
        _AnimationState = aninemationstate;
    }
    public void SwitchState(IState state)
    {
        _State.OnExit();
        _State = state;
        _State.OnEnter();
        _Animator.SetInteger("State", (int)_AnimationState);
    }


    public void SubtractHealth(int recievedDamage)
    {
        _Health -= recievedDamage;
    }
    public void AddHealth(int recievedHealth)
    {
        _Health += recievedHealth;
    }
    public void RecieveHit(int recievedDamage)
    {
        _State = new HitStun(this, _State, recievedDamage);
        _State.OnEnter();
        SubtractHealth(recievedDamage);
        if (_GotHit != null)
        {
            _GotHit(recievedDamage, _Health);
        }

    }


}
public class Idle : IState
{
    UnitBehaviours _Unit;
    public Idle(UnitBehaviours unit)
    {
        _Unit = unit;
    }
    public void OnEnter()
    {
        _Unit.SetAnimation(AnimationState.Idle);
    }

    public void Update()
    {
        Collider[] hits = Physics.OverlapSphere((_Unit.transform.position + (new Vector3(0, _Unit._Colloder.height) * 0.5f)) + ( _Unit._RangeOffset), _Unit._Range);

        if (hits.Length == 0)
        {
            //_Unit.SwitchState(new Walk(_Unit));
        }

        if (hits.Length == 1)
        {
            if (hits[0].gameObject == _Unit.gameObject)
            {
                _Unit.SwitchState(new Walk(_Unit));
            }
        }


        if (hits.Length > 1)
        {
            for (int i = 0; i < hits.Length; i++)
            {
                switch (_Unit._Side)
                {
                    case Opposition.Elfs:
                        if (hits[i].gameObject.GetComponent<UnitBehaviours>()._Side == Opposition.Pieten)
                        {
                            _Unit.SwitchState(new Action(_Unit));
                        }
                        break;
                    case Opposition.Pieten:
                        if (hits[i].gameObject.GetComponent<UnitBehaviours>()._Side == Opposition.Elfs)
                        {
                            _Unit.SwitchState(new Action(_Unit));
                        }
                        break;
                }
            }
        }

        if (_Unit._Health <= 0)
        {
            _Unit.SwitchState(new Dead(_Unit));
        }
    }

    public void FixedUpdate()
    {

    }

    public void OnExit()
    {

    }
}
public class Walk : IState
{
    UnitBehaviours _Unit;
    Vector3 _Direction;
    float _Speed;
    public Walk(UnitBehaviours unit)
    {
        _Unit = unit;
        _Speed = _Unit._Speed;
    }
    public void OnEnter()
    {
        _Unit.SetAnimation(AnimationState.Walk);

    }

    public void Update()
    {
        WayPointManager();

        if (_Unit._Class != UnitClass.Collector)
        {
            CheckForConflict();
        }


        if (_Unit._Health <= 0)
        {
            _Unit.SwitchState(new Dead(_Unit));
        }
        _Unit.transform.Translate(_Direction.normalized * _Unit._Speed * Time.deltaTime);
    }

    public void FixedUpdate()
    {

    }
    private void WayPointManager()
    {

        if (_Unit._Class == UnitClass.Collector)
        {
            if (Vector3.Distance(_Unit.transform.position, _Unit._Destination.position) <= _Unit._DistanceToProceed)
            {
                if (_Unit._DestinationIndex == 0)
                {
                    _Unit._DestinationIndex = 1;
                    _Unit._Destination = _Unit._Path[_Unit._DestinationIndex];
                    _Unit._Renderer.flipX ^= true;
                }
                else if (_Unit._DestinationIndex == 1)
                {
                    _Unit._DestinationIndex = 0;
                    _Unit._Destination = _Unit._Path[_Unit._DestinationIndex];
                    _Unit._Renderer.flipX ^= true;
                    _Unit.SwitchState(new Action(_Unit));
                }
            }
        }
        else
        {
            if (Vector3.Distance(_Unit.transform.position, _Unit._Destination.position) <= _Unit._DistanceToProceed)
            {
                if (_Unit._DestinationIndex != _Unit._Path.Length - 1)
                {
                    _Unit._DestinationIndex++;
                    _Unit._Destination = _Unit._Path[_Unit._DestinationIndex];
                    if (_Unit._DestinationIndex == 2)
                    {
                        _Unit._PathSet = true;
                    }
                }
            }
        }
        _Direction = (_Unit._Destination.position - _Unit.transform.position);
    }

    private void CheckForConflict()
    {
        Collider[] hits = Physics.OverlapSphere((_Unit.transform.position + (new Vector3(0, _Unit._Colloder.height) * 0.5f)) + ( _Unit._RangeOffset), _Unit._Range);


        for (int i = 0; i < hits.Length; i++)
        {
            switch (_Unit._Side)
            {
                case Opposition.Elfs:
                    if (hits[i].gameObject.GetComponent<UnitBehaviours>()._Side == Opposition.Pieten && hits[i].GetComponent<UnitBehaviours>()._AnimationState != AnimationState.Dead)
                    {
                        _Unit.SwitchState(new Action(_Unit));
                    }
                    if (hits[i].gameObject.GetComponent<UnitBehaviours>()._Class != UnitClass.Collector)
                    {
                        if (hits[i].gameObject.GetComponent<UnitBehaviours>()._Side == Opposition.Elfs && hits[i].GetComponent<UnitBehaviours>()._AnimationState != AnimationState.Dead && hits[i].gameObject != _Unit.gameObject && hits[i].gameObject.GetComponent<UnitBehaviours>()._AnimationState != AnimationState.Walk && hits[i].gameObject.GetComponent<UnitBehaviours>()._AnimationState != AnimationState.SpeedMatch)
                        {
                            if (_Unit._Class == UnitClass.Caster && hits[i].gameObject.GetComponent<UnitBehaviours>()._AnimationState == AnimationState.Action)
                            {
                                _Unit.SwitchState(new Action(_Unit));
                            }
                            else if (_Unit._Class == UnitClass.Ranged && hits[i].gameObject.GetComponent<UnitBehaviours>()._AnimationState == AnimationState.Action)
                            {
                                Collider[] hits2 = Physics.OverlapSphere((hits[i].transform.position + (new Vector3(0, _Unit._Colloder.height) * 0.5f)) + ( _Unit._RangeOffset), _Unit._Range);
                                bool attack = false;

                                for (int u = 0; u < hits2.Length; u++)
                                {

                                    if (hits2[u] != hits[i] && hits2[u].gameObject.GetComponent<UnitBehaviours>()._Side == Opposition.Pieten && hits[i].gameObject.GetComponent<UnitBehaviours>()._Class != UnitClass.Buff && attack == false)
                                    {
                                        attack = true;


                                    }
                                    else if (attack == false)
                                    {
                                        attack = false;

                                    }
                                }

                                if (attack == true)
                                {
                                    _Unit.SwitchState(new Action(_Unit));
                                }
                                else
                                {
                                    _Unit.SwitchState(new Idle(_Unit));
                                }
                            }
                            else
                            {
                                _Unit.SwitchState(new Idle(_Unit));
                            }
                        }
                        else if (hits[i].gameObject.GetComponent<UnitBehaviours>()._Side == Opposition.Elfs && hits[i].GetComponent<UnitBehaviours>()._AnimationState != AnimationState.Dead && hits[i].gameObject != _Unit.gameObject && hits[i].gameObject.GetComponent<UnitBehaviours>()._Speed < _Unit._Speed && hits[i].gameObject.GetComponent<UnitBehaviours>()._AnimationState == AnimationState.Walk)
                        {
                            _Unit.SwitchState(new SpeedMatch(_Unit));
                        }
                        else if (hits[i].gameObject.GetComponent<UnitBehaviours>()._Side == Opposition.Elfs && hits[i].GetComponent<UnitBehaviours>()._AnimationState != AnimationState.Dead && hits[i].gameObject != _Unit.gameObject && hits[i].gameObject.GetComponent<UnitBehaviours>()._Speed < _Unit._Speed && hits[i].gameObject.GetComponent<UnitBehaviours>()._AnimationState == AnimationState.SpeedMatch)
                        {
                            _Unit.SwitchState(new SpeedMatch(_Unit));
                        }
                        else if (hits[i].gameObject.GetComponent<UnitBehaviours>()._Side == Opposition.Elfs && hits[i].GetComponent<UnitBehaviours>()._AnimationState != AnimationState.Dead && hits[i].gameObject != _Unit.gameObject && hits[i].gameObject.GetComponent<UnitBehaviours>()._Speed >= _Unit._Speed && hits[i].gameObject.GetComponent<UnitBehaviours>()._AnimationState == AnimationState.SpeedMatch)
                        {
                            _Unit.SwitchState(new Idle(_Unit));
                        }

                    }

                    break;
                case Opposition.Pieten:
                    if (hits[i].gameObject.GetComponent<UnitBehaviours>()._Side == Opposition.Elfs && hits[i].GetComponent<UnitBehaviours>()._AnimationState != AnimationState.Dead)
                    {
                        _Unit.SwitchState(new Action(_Unit));
                    }

                    if (hits[i].gameObject.GetComponent<UnitBehaviours>()._Class != UnitClass.Collector)
                    {
                        if (hits[i].gameObject.GetComponent<UnitBehaviours>()._Side == Opposition.Pieten && hits[i].GetComponent<UnitBehaviours>()._AnimationState != AnimationState.Dead && hits[i].gameObject != _Unit.gameObject && hits[i].gameObject.GetComponent<UnitBehaviours>()._AnimationState != AnimationState.Walk && hits[i].gameObject.GetComponent<UnitBehaviours>()._AnimationState != AnimationState.SpeedMatch)
                        {
                            if (_Unit._Class == UnitClass.Caster && hits[i].gameObject.GetComponent<UnitBehaviours>()._AnimationState == AnimationState.Action)
                            {
                                _Unit.SwitchState(new Action(_Unit));
                            }
                            else if (_Unit._Class == UnitClass.Ranged && hits[i].gameObject.GetComponent<UnitBehaviours>()._AnimationState == AnimationState.Action)
                            {
                                Collider[] hits2 = Physics.OverlapSphere((hits[i].transform.position + (new Vector3(0, _Unit._Colloder.height) * 0.5f)) + ( _Unit._RangeOffset), _Unit._Range);
                                bool attack = false;

                                for (int u = 0; u < hits2.Length; u++)
                                {

                                    if (hits2[u] != hits[i] && hits2[u].gameObject.GetComponent<UnitBehaviours>()._Side == Opposition.Elfs && hits[i].gameObject.GetComponent<UnitBehaviours>()._Class != UnitClass.Buff && attack == false )
                                    {
                                         attack = true;


                                    }
                                    else if (attack == false)
                                    {
                                         attack = false;

                                    }
                                }

                                if (attack == true)
                                {
                                    _Unit.SwitchState(new Action(_Unit));
                                }
                                else
                                {
                                    _Unit.SwitchState(new Idle(_Unit));
                                }
                            }
                            else
                            {
                                _Unit.SwitchState(new Idle(_Unit));
                            }
                        }
                        else if (hits[i].gameObject.GetComponent<UnitBehaviours>()._Side == Opposition.Pieten && hits[i].GetComponent<UnitBehaviours>()._AnimationState != AnimationState.Dead && hits[i].gameObject != _Unit.gameObject && hits[i].gameObject.GetComponent<UnitBehaviours>()._Speed < _Unit._Speed && hits[i].gameObject.GetComponent<UnitBehaviours>()._AnimationState == AnimationState.Walk)
                        {
                            _Unit.SwitchState(new SpeedMatch(_Unit));
                        }
                        else if (hits[i].gameObject.GetComponent<UnitBehaviours>()._Side == Opposition.Pieten && hits[i].GetComponent<UnitBehaviours>()._AnimationState != AnimationState.Dead && hits[i].gameObject != _Unit.gameObject && hits[i].gameObject.GetComponent<UnitBehaviours>()._Speed < _Unit._Speed && hits[i].gameObject.GetComponent<UnitBehaviours>()._AnimationState == AnimationState.SpeedMatch)
                        {
                            _Unit.SwitchState(new SpeedMatch(_Unit));
                        }
                        else if (hits[i].gameObject.GetComponent<UnitBehaviours>()._Side == Opposition.Pieten && hits[i].GetComponent<UnitBehaviours>()._AnimationState != AnimationState.Dead && hits[i].gameObject != _Unit.gameObject && hits[i].gameObject.GetComponent<UnitBehaviours>()._Speed >= _Unit._Speed && hits[i].gameObject.GetComponent<UnitBehaviours>()._AnimationState == AnimationState.SpeedMatch)
                        {
                            _Unit.SwitchState(new Idle(_Unit));
                        }

                    }
                    break;
            }
        }

    }
    public void OnExit()
    {
        _Unit._Speed = _Speed;
    }
}

public class SpeedMatch : IState
{
    UnitBehaviours _Unit;
    Vector3 _Direction;
    float _Speed;
    public SpeedMatch(UnitBehaviours unit)
    {
        _Unit = unit;
        _Speed = _Unit._Speed;
    }
    public void OnEnter()
    {
        _Unit.SetAnimation(AnimationState.SpeedMatch);
    }

    public void Update()
    {
        Collider[] hits = Physics.OverlapSphere((_Unit.transform.position + (new Vector3(0, _Unit._Colloder.height) * 0.5f)) + ( _Unit._RangeOffset), _Unit._Range);
        if (hits.Length == 1)
        {
            if (hits[0].gameObject == _Unit.gameObject)
            {
                _Unit.SwitchState(new Walk(_Unit));
            }

        }
        WayPointManager();
        if (_Unit._Class != UnitClass.Collector)
        {
            CheckForConflict();
        }
        if (_Unit._Health <= 0)
        {
            _Unit.SwitchState(new Dead(_Unit));
        }
    }

    public void FixedUpdate()
    {
        _Unit.transform.Translate(_Direction.normalized * _Unit._Speed * Time.fixedDeltaTime);
    }
    private void WayPointManager()
    {
        if (Vector3.Distance(_Unit.transform.position, _Unit._Destination.position) <= _Unit._DistanceToProceed)
        {
            if (_Unit._DestinationIndex != _Unit._Path.Length - 1)
            {
                _Unit._DestinationIndex++;
                _Unit._Destination = _Unit._Path[_Unit._DestinationIndex];
                if (_Unit._DestinationIndex == 2)
                {
                    _Unit._PathSet = true;
                }
            }
        }
        _Direction = (_Unit._Destination.position - _Unit.transform.position);
    }

    private void CheckForConflict()
    {
        Collider[] hits = Physics.OverlapSphere((_Unit.transform.position + (new Vector3(0, _Unit._Colloder.height) * 0.5f)) + ( _Unit._RangeOffset), _Unit._Range);
        if (hits.Length == 1)
        {
            if (hits[0].gameObject == _Unit.gameObject)
            {
                _Unit.SwitchState(new Walk(_Unit));
            }

        }
        for (int i = 0; i < hits.Length; i++)
        {


            switch (_Unit._Side)
            {
                case Opposition.Elfs:
                    if (hits[i].gameObject.GetComponent<UnitBehaviours>()._Side == Opposition.Pieten && hits[i].GetComponent<UnitBehaviours>()._AnimationState != AnimationState.Dead)
                    {
                        _Unit.SwitchState(new Action(_Unit));
                    }

                    if (hits[i].gameObject.GetComponent<UnitBehaviours>()._Class != UnitClass.Collector)
                    {
                        if (hits[i].gameObject.GetComponent<UnitBehaviours>()._Side == Opposition.Elfs && hits[i].GetComponent<UnitBehaviours>()._AnimationState != AnimationState.Dead && hits[i].gameObject != _Unit.gameObject && hits[i].gameObject.GetComponent<UnitBehaviours>()._AnimationState != AnimationState.Walk && hits[i].gameObject.GetComponent<UnitBehaviours>()._AnimationState != AnimationState.SpeedMatch)
                        {
                            if (_Unit._Class == UnitClass.Caster && hits[i].gameObject.GetComponent<UnitBehaviours>()._AnimationState == AnimationState.Action)
                            {
                                _Unit.SwitchState(new Action(_Unit));
                            }
                            else if (_Unit._Class == UnitClass.Ranged && hits[i].gameObject.GetComponent<UnitBehaviours>()._AnimationState == AnimationState.Action)
                            {
                                Collider[] hits2 = Physics.OverlapSphere((hits[i].transform.position + (new Vector3(0, _Unit._Colloder.height) * 0.5f)) + ( _Unit._RangeOffset), _Unit._Range);

                                for (int u = 0; u < hits2.Length; u++)
                                {

                                    if (hits2[u] != hits[i] && hits2[u].gameObject.GetComponent<UnitBehaviours>()._Side == Opposition.Pieten && hits[i].gameObject.GetComponent<UnitBehaviours>()._Class != UnitClass.Buff)
                                    {
                                        _Unit.SwitchState(new Action(_Unit));

                                        break;
                                    }
                                    else
                                    {
                                        _Unit.SwitchState(new Idle(_Unit));
                                        break;
                                    }
                                }
                            }
                            else
                            {
                                _Unit.SwitchState(new Idle(_Unit));
                            }

                        }
                        if (hits[i].gameObject.GetComponent<UnitBehaviours>()._Side == Opposition.Elfs && hits[i].GetComponent<UnitBehaviours>()._AnimationState != AnimationState.Dead && hits[i].gameObject != _Unit.gameObject && hits[i].gameObject.GetComponent<UnitBehaviours>()._Speed < _Unit._Speed && hits[i].gameObject.GetComponent<UnitBehaviours>()._AnimationState == AnimationState.Walk)
                        {
                            _Unit._Speed = hits[i].gameObject.GetComponent<UnitBehaviours>()._Speed;
                        }
                        if (hits[i].gameObject.GetComponent<UnitBehaviours>()._Side == Opposition.Elfs && hits[i].GetComponent<UnitBehaviours>()._AnimationState != AnimationState.Dead && hits[i].gameObject != _Unit.gameObject && hits[i].gameObject.GetComponent<UnitBehaviours>()._Speed == _Unit._Speed && hits[i].gameObject.GetComponent<UnitBehaviours>()._AnimationState == AnimationState.Walk)
                        {
                            _Unit.SwitchState(new Idle(_Unit));
                        }

                    }
                    break;
                case Opposition.Pieten:
                    if (hits[i].gameObject.GetComponent<UnitBehaviours>()._Side == Opposition.Elfs && hits[i].GetComponent<UnitBehaviours>()._AnimationState != AnimationState.Dead)
                    {
                        _Unit.SwitchState(new Action(_Unit));
                    }

                    if (hits[i].gameObject.GetComponent<UnitBehaviours>()._Class != UnitClass.Collector)
                    {


                        if (hits[i].gameObject.GetComponent<UnitBehaviours>()._Side == Opposition.Pieten && hits[i].GetComponent<UnitBehaviours>()._AnimationState != AnimationState.Dead && hits[i].gameObject != _Unit.gameObject && hits[i].gameObject.GetComponent<UnitBehaviours>()._AnimationState != AnimationState.Walk && hits[i].gameObject.GetComponent<UnitBehaviours>()._AnimationState != AnimationState.SpeedMatch)
                        {
                            if (_Unit._Class == UnitClass.Caster && hits[i].gameObject.GetComponent<UnitBehaviours>()._AnimationState == AnimationState.Action)
                            {
                                _Unit.SwitchState(new Action(_Unit));
                            }
                            else if (_Unit._Class == UnitClass.Ranged && hits[i].gameObject.GetComponent<UnitBehaviours>()._AnimationState == AnimationState.Action)
                            {
                                Collider[] hits2 = Physics.OverlapSphere((hits[i].transform.position + (new Vector3(0, _Unit._Colloder.height) * 0.5f)) + ( _Unit._RangeOffset), _Unit._Range);

                                for (int u = 0; u < hits2.Length; u++)
                                {

                                    if (hits2[u] != hits[i] && hits2[u].gameObject.GetComponent<UnitBehaviours>()._Side == Opposition.Elfs && hits[i].gameObject.GetComponent<UnitBehaviours>()._Class != UnitClass.Buff)
                                    {
                                        _Unit.SwitchState(new Action(_Unit));

                                        break;
                                    }
                                    else
                                    {
                                        _Unit.SwitchState(new Idle(_Unit));
                                        break;
                                    }
                                }
                            }
                            else
                            {
                                _Unit.SwitchState(new Idle(_Unit));
                            }

                        }
                        if (hits[i].gameObject.GetComponent<UnitBehaviours>()._Side == Opposition.Pieten && hits[i].GetComponent<UnitBehaviours>()._AnimationState != AnimationState.Dead && hits[i].gameObject != _Unit.gameObject && hits[i].gameObject.GetComponent<UnitBehaviours>()._Speed < _Unit._Speed && hits[i].gameObject.GetComponent<UnitBehaviours>()._AnimationState == AnimationState.Walk)
                        {
                            _Unit._Speed = hits[i].gameObject.GetComponent<UnitBehaviours>()._Speed;
                        }
                        if (hits[i].gameObject.GetComponent<UnitBehaviours>()._Side == Opposition.Pieten && hits[i].GetComponent<UnitBehaviours>()._AnimationState != AnimationState.Dead && hits[i].gameObject != _Unit.gameObject && hits[i].gameObject.GetComponent<UnitBehaviours>()._Speed == _Unit._Speed && hits[i].gameObject.GetComponent<UnitBehaviours>()._AnimationState == AnimationState.Walk)
                        {
                            _Unit.SwitchState(new Idle(_Unit));
                        }

                    }

                    break;
            }
        }

    }
    public void OnExit()
    {
        _Unit._Speed = _Speed;
    }
}
public class GoldWalk : IState
{
    UnitBehaviours _Unit;
    Vector3 _Direction;
    float _Speed;
    public GoldWalk(UnitBehaviours unit)
    {
        _Unit = unit;
        _Speed = _Unit._Speed;
    }
    public void OnEnter()
    {
        _Unit.SetAnimation(AnimationState.GoldWalk);

    }

    public void Update()
    {
        WayPointManager();


        if (_Unit._Health <= 0)
        {
            _Unit.SwitchState(new Dead(_Unit));
        }
        _Unit.transform.Translate(_Direction.normalized * _Unit._Speed * Time.deltaTime);
    }

    public void FixedUpdate()
    {

    }
    private void WayPointManager()
    {


        if (Vector3.Distance(_Unit.transform.position, _Unit._Destination.position) <= _Unit._DistanceToProceed)
        {
            if (_Unit._DestinationIndex == 0)
            {
                _Unit._DestinationIndex = 1;
                _Unit._Destination = _Unit._Path[_Unit._DestinationIndex];
                _Unit._Renderer.flipX ^= true;
                _Unit._Tower._Gold += _Unit._Gold;
                _Unit.SwitchState(new Walk(_Unit));

            }
            else if (_Unit._DestinationIndex == 1)
            {
                _Unit._DestinationIndex = 0;
                _Unit._Destination = _Unit._Path[_Unit._DestinationIndex];
                _Unit._Renderer.flipX ^= true;
                _Unit.SwitchState(new Action(_Unit));
            }
        }


        _Direction = (_Unit._Destination.position - _Unit.transform.position);
    }


    public void OnExit()
    {
        _Unit._Speed = _Speed;
    }
}
public class Action : IState
{
    UnitBehaviours _Unit;
    float _Height, _Radius;
    public Action(UnitBehaviours unit)
    {
        _Unit = unit;
    }
    public void OnEnter()
    {
        _Unit.SetAnimation(AnimationState.Action);
        if (_Unit._Class == UnitClass.Collector)
        {
            _Radius = _Unit._Colloder.radius;
            _Height = _Unit._Colloder.height;
            _Unit._Colloder.radius = 0;
            _Unit._Colloder.height = 0;
        }
    }

    public void Update()
    {
        if (_Unit._Class != UnitClass.Collector)
        {
            Collider[] hits = Physics.OverlapSphere((_Unit.transform.position + (new Vector3(0, _Unit._Colloder.height) * 0.5f)) + ( _Unit._RangeOffset), _Unit._Range);
            if (hits.Length == 0)
            {
                _Unit.SwitchState(new Walk(_Unit));
            }
            if (hits.Length == 1)
            {
                if (hits[0].gameObject == _Unit.gameObject)
                {
                    _Unit.SwitchState(new Walk(_Unit));
                }

            }

            if (hits.Length > 1)
            {
                for (int i = 0; i < hits.Length; i++)
                {

                    if (hits[i].GetComponent<UnitBehaviours>()._AnimationState == AnimationState.Dead)
                    {
                        try
                        {
                            if (hits.Length > i)
                            {
                                if (hits[i + 1].GetComponent<UnitBehaviours>()._AnimationState == AnimationState.Dead && _Unit._AnimationState != AnimationState.Action)
                                {
                                    _Unit.SwitchState(new Walk(_Unit));
                                }
                            }
                        }
                        catch
                        {

                        }

                    }
                }

                if (_Unit._Health <= 0)
                {
                    _Unit.SwitchState(new Dead(_Unit));
                }

            }
        }

    }

    public void FixedUpdate()
    {

    }

    public void OnExit()
    {
        if (_Unit._ActionParticle != null)
        {
            _Unit._ActionParticle.Stop();
        }
        if (_Unit._Class == UnitClass.Collector)
        {
            _Unit._Colloder.radius = _Radius;
            _Unit._Colloder.height = _Height;
        }
    }
}

public class HitStun : IState
{
    UnitBehaviours _Unit;
    IState _PreviousState;
    float _TimeInHitLag;

    Vector2 _Preposition;

    int _Damage;
    public HitStun(UnitBehaviours unit, IState previousState, int damage)
    {
        _Unit = unit;
        _PreviousState = previousState;
        _Damage = damage;
        _TimeInHitLag = _Damage * Time.deltaTime * 1.6f;

    }
    public void OnEnter()
    {
        _Unit._Animator.speed = 0;
        _Unit._Renderer.color = Color.red;
        _Preposition = _Unit._Sprite.position;

    }

    public void Update()
    {

        _TimeInHitLag -= Time.deltaTime;
        _Unit._Sprite.position = _Preposition + (Random.insideUnitCircle * _Damage * 0.05f);



        if (_TimeInHitLag <= 0)
        {
            _Unit.SwitchState(_PreviousState);
        }
    }

    public void FixedUpdate()
    {

    }

    public void OnExit()
    {
        _Unit._Renderer.color = Color.white;
        _Unit._Animator.speed = 1;

        _Unit._Sprite.position = _Preposition;
    }
}

public class HitLag : IState
{
    UnitBehaviours _Unit;
    IState _PreviousState;
    float _TimeInHitLag;
    Vector2 _Preposition;
    int _Damage;

    public HitLag(UnitBehaviours unit, IState previousState, int damage)
    {
        _Unit = unit;
        _PreviousState = previousState;
        _Damage = damage;
        _TimeInHitLag = _Damage * Time.deltaTime * 1.6f;
        _Preposition = _Unit.transform.position;
    }
    public void OnEnter()
    {
        _Unit._Animator.speed = 0;

    }

    public void Update()
    {
        _TimeInHitLag -= Time.deltaTime;

        if (_TimeInHitLag <= 0)
        {
            _Unit.SwitchState(_PreviousState);
        }
    }

    public void FixedUpdate()
    {

    }

    public void OnExit()
    {
        _Unit._Animator.speed = 1;

        _Unit.transform.position = _Preposition;
    }
}

public class Dead : IState
{
    UnitBehaviours _Unit;

    public Dead(UnitBehaviours unit)
    {
        _Unit = unit;

    }
    public void OnEnter()
    {
        _Unit._Colloder.enabled = false;
        _Unit._Renderer.color = Color.white;
        _Unit.SetAnimation(AnimationState.Dead);
    }

    public void Update()
    {

    }

    public void FixedUpdate()
    {

    }

    public void OnExit()
    {

    }
}