public void StopThis()
 {
     Debug.Log("Stopping Path", this);
     currentTarget = transform.position;
     foundTarget   = false;
     stateSet      = false;
     state         = state_fakeagent.idle;
 }
 public void GoHere(Vector3 here)
 {
     Debug.Log("Doing Path", this);
     foundTarget   = false;
     currentTarget = here;
     Timer         = 100;
     state         = state_fakeagent.dopath;
     stateSet      = false;
 }
    // Update is called once per frame
    void Update()
    {
        if (!debugGameLoaded)
        {
            if (GameController.instance.doGameplay)
            {
                Player          = GameController.instance.player;
                debugGameLoaded = true;
                checkPlayer     = true;
            }
        }
        else
        {
            switch (state)
            {
            case state_fakeagent.idle:
            {
                if (!stateSet)
                {
                    playerCheck = foundPlayer;
                    Animator.SetBool("move", false);
                    Agent.isStopped = true;
                    destSet         = false;
                    stateSet        = true;
                    Timer           = Random.Range(defIdle, defIdle + 3);
                    if (isDebuggin)
                    {
                        Debug.Log("Volviendo a Idle");
                    }
                }
                break;
            }

            case state_fakeagent.dopath:
            {
                if (!stateSet)
                {
                    playerCheck = foundPlayer;
                    Animator.SetBool("move", true);
                    Agent.isStopped = false;
                    Agent.speed     = walkSpeed;
                    Agent.SetDestination(currentTarget);
                    stateSet = true;
                    if (isDebuggin)
                    {
                        Debug.Log("Starting path");
                    }
                }
                else if (!Agent.pathPending && Agent.hasPath && Agent.remainingDistance < 1)
                {
                    state = state_fakeagent.ignoreall;
                    Animator.SetBool("move", false);
                    Timer    = 45;
                    stateSet = true;
                    if (isDebuggin)
                    {
                        Debug.Log("Ending path");
                    }
                }
                Timer = 10;
                break;
            }

            case state_fakeagent.attack:
            {
                Animator.SetBool("move", true);
                Animator.SetTrigger("reset");

                transform.rotation = Quaternion.Lerp(transform.rotation, Quaternion.LookRotation(lookAt), 5 * Time.deltaTime);
                playerCheck        = foundPlayerRun;
                if (playerDistance < AttackDistance && GameController.instance.isAlive)
                {
                    Audio.PlayOneShot(Hit);
                    GameController.instance.playercache.Death(0);
                    GameController.instance.deathmsg = Localization.GetString("deathStrings", "death_mtf");
                    Agent.isStopped = true;
                    Animator.SetTrigger("attack" + Random.Range(1, 3));
                }
                else
                {
                    Agent.isStopped = false;
                    Agent.speed     = runSpeed;
                    if (CheckPlayer())
                    {
                        Agent.SetDestination(Player.transform.position);
                    }
                }
                break;
            }

            case state_fakeagent.patrol:
            {
                if (!stateSet)
                {
                    //PlayVoice(1);

                    playerCheck = foundPlayer;
                    Animator.SetBool("move", true);
                    Agent.isStopped = false;
                    Agent.speed     = walkSpeed;
                    if (!WorldSearch)
                    {
                        Agent.SetDestination(patrol[currentNode].position);
                    }
                    else
                    {
                        Agent.SetDestination(GameController.instance.GetPatrol(transform.position, 6, 0));
                    }
                    Timer = Random.Range(defWalk, defWalk + 3);
                    if (!WorldSearch)
                    {
                        Timer = Random.Range(1, defWalk - 2);
                    }

                    stateSet = true;
                    if (isDebuggin)
                    {
                        Debug.Log("Caminata");
                    }
                }
                else if (Agent.remainingDistance < 1)
                {
                    if (!WorldSearch)
                    {
                        /*currentNode += 1;
                         * if (currentNode >= patrol.Length)
                         *  currentNode = 0;*/
                        currentNode = Random.Range(0, patrol.Length);
                        Agent.SetDestination(patrol[currentNode].position);
                        //stateSet = false;
                    }
                    else
                    {
                        Agent.SetDestination(GameController.instance.GetPatrol(transform.position, 6, 0));
                    }
                }
                break;
            }

            case state_fakeagent.run:
            {
                if (destSet == false)
                {
                    playerCheck = foundPlayerRun;
                    Animator.SetBool("move", true);
                    Agent.isStopped = false;
                    Agent.speed     = runSpeed;
                    Agent.SetDestination(currentTarget);
                    destSet = true;
                    if (isDebuggin)
                    {
                        Debug.Log(soundlevel + "Corro hacia el!");
                    }
                    PlayVoice(4);
                }
                else if (Agent.remainingDistance < 1)
                {
                    destSet     = false;
                    foundTarget = false;
                    state       = state_fakeagent.idle;
                }
                break;
            }

            case state_fakeagent.walk:
            {
                if (destSet == false)
                {
                    playerCheck = foundPlayer;
                    PlayVoice(3);
                    Animator.SetBool("move", true);
                    Agent.isStopped = false;
                    Agent.speed     = walkSpeed;
                    Agent.SetDestination(currentTarget);
                    destSet = true;
                    if (isDebuggin)
                    {
                        Debug.Log(soundlevel + "Camino hacia el!");
                    }
                }
                else if (Agent.remainingDistance < 1)
                {
                    destSet     = false;
                    foundTarget = false;
                    state       = state_fakeagent.idle;
                }
                break;
            }

            case state_fakeagent.hearing:
            {
                transform.rotation = Quaternion.Lerp(transform.rotation, Quaternion.LookRotation(lookAt), 5 * Time.deltaTime);

                if (!stateSet)
                {
                    Agent.isStopped = true;
                    Animator.SetBool("move", false);
                    Animator.SetTrigger("look");
                    destSet = false;
                    Timer   = HearingTimer;
                    if (isDebuggin)
                    {
                        Debug.Log(soundlevel + "Escuche algo?");
                    }
                    stateSet = true;
                }
                break;
            }

            case state_fakeagent.hearing2:
            {
                transform.rotation = Quaternion.Lerp(transform.rotation, Quaternion.LookRotation(lookAt), 5 * Time.deltaTime);


                if (!stateSet)
                {
                    Agent.isStopped = true;
                    Animator.SetBool("move", false);
                    Animator.SetTrigger("vocal");
                    destSet = false;
                    Timer   = Hearing2Timer;
                    if (isDebuggin)
                    {
                        Debug.Log(soundlevel + "Si escuche!");
                    }
                    stateSet = true;
                    PlayVoice(2);
                }
                break;
            }
            }

            Timer       -= Time.deltaTime;
            AttackTimer -= Time.deltaTime;

            if ((state != state_fakeagent.run && state != state_fakeagent.walk && state != state_fakeagent.attack && state != state_fakeagent.dopath) && Timer <= 0)
            {
                foundTarget = false;
                stateSet    = false;

                switch (state)
                {
                case state_fakeagent.idle:
                {
                    state = state_fakeagent.patrol;
                    break;
                }

                case state_fakeagent.patrol:
                {
                    state = state_fakeagent.idle;
                    break;
                }

                case state_fakeagent.ignoreall:
                {
                    state = state_fakeagent.patrol;
                    break;
                }
                }
            }
            if (state == state_fakeagent.run || state == state_fakeagent.walk || state == state_fakeagent.patrol || state == state_fakeagent.attack || state == state_fakeagent.dopath)
            {
                if (Agent.isOnOffMeshLink)
                {
                    Animator.SetFloat("speed", 2);
                }
                else
                {
                    Animator.SetFloat("speed", Agent.velocity.magnitude);
                }

                if (debugSpeed)
                {
                    Debug.Log(Agent.velocity.magnitude);
                }
            }



            if (foundTarget == false && state != state_fakeagent.attack && state != state_fakeagent.dopath && state != state_fakeagent.ignoreall)
            {
                CheckSounds();
                if (foundTarget)
                {
                    stateSet = false;

                    if (SoundLevel == 0)
                    {
                        switch (state)
                        {
                        case state_fakeagent.hearing2:
                        {
                            state = state_fakeagent.walk;
                            break;
                        }

                        case state_fakeagent.run:
                        {
                            state = state_fakeagent.hearing2;
                            break;
                        }

                        case state_fakeagent.hearing:
                        {
                            state = state_fakeagent.hearing2;
                            break;
                        }

                        default:
                        {
                            Debug.Log("Cambiando a hearing!");
                            state = state_fakeagent.hearing;
                            break;
                        }
                        }
                    }
                    if (SoundLevel == 1)
                    {
                        switch (state)
                        {
                        case state_fakeagent.hearing2:
                        {
                            state = state_fakeagent.walk;
                            break;
                        }

                        case state_fakeagent.hearing:
                        {
                            state = state_fakeagent.walk;
                            break;
                        }

                        case state_fakeagent.run:
                        {
                            state = state_fakeagent.walk;
                            break;
                        }

                        default:
                        {
                            state = state_fakeagent.hearing2;
                            break;
                        }
                        }
                    }
                    if (SoundLevel > 1)
                    {
                        switch (state)
                        {
                        case state_fakeagent.hearing2:
                        {
                            state = state_fakeagent.run;
                            break;
                        }

                        case state_fakeagent.run:
                        {
                            state = state_fakeagent.run;
                            break;
                        }

                        default:
                        {
                            state = state_fakeagent.walk;
                            break;
                        }
                        }
                    }
                }
                else
                {
                    if (state != state_fakeagent.idle && state != state_fakeagent.patrol)
                    {
                        state = state_fakeagent.idle;
                    }
                }
            }

            if (checkPlayer)
            {
                playerDistance = Vector3.Distance(Player.transform.position, transform.position);
            }
            lookAt = new Vector3(Player.transform.position.x, transform.position.y, Player.transform.position.z) - transform.position;
            if (debugPlayerPos)
            {
                Debug.Log("Producto dot " + Vector3.Dot(transform.forward, lookAt.normalized));
            }

            if (playerDistance < playerCheck)
            {
                if (state != state_fakeagent.attack && state != state_fakeagent.dopath && Vector3.Dot(transform.forward, lookAt.normalized) > 0.4f && CheckPlayer())
                {
                    foundTarget = false;
                    stateSet    = false;
                    PlayVoice(4);

                    if (state == state_fakeagent.run)
                    {
                        Animator.SetTrigger("leap");
                    }
                    state = state_fakeagent.attack;
                }
            }
            else if (state == state_fakeagent.attack)
            {
                state = state_fakeagent.idle;
            }
        }
    }