EnermyAI.cs

using UnityEngine;
using System.Collections;
using SmoothMoves;

[RequireComponent (typeof (PlatformInputController_NPC))]

public class EnermyAI : MonoBehaviour
{

    public BoneAnimation character;

    public GameObject mainTarget;
    public int alertLevel=1;
    public int stateLevel=1;
    public float alertLevelOneSeeDistance=100.0F;
    public float alertLevelTwoSeeDistance=200.0F;
    public float alertLevelThreeSeeDistance=300.0F;
    public float alertLevelFourSeeDistance=400.0F;
    public float alertLevelFiveSeeDistance=500.0F;
    public float alertLevelTwoFadeTimePeriod=6.0f;
    public int alertFadeDistance=120;
    public float attackRange=180f;
    public float attackDelay=2f;
    public float movingLimitOnLeftX;
    public float movingLimitOnRightX;
    public float seekAreaRange=200f;
    public string seekAnimation;
    public float seekWaitingTime=5f;
    //time that enemy igores Player's behaviour
    public float alertCooldownTime=8f;
    public bool noChat;
    public float[] waypointXValue;
    public float[] waypointWaitingTime;
    public string[] waypointAnimation;
    public bool playerSneak;
    public bool playerCrawl;
    public bool interactWithPlayer;
    public bool playAnimation;
    public bool playSound;
    public float runSpeed=7f;
    public float walkSpeed=4f;
    public bool facingRight;

    public string walkingStyleAnimation;
    public string idleStyleAnimation;
    public string alertAnimation;
    public string attackAnimation;
    public GameObject bullet;
    public float bulletVelocity;

    private enum NPCBehaviour
    {
        Guard,
        Patrol,
        InteractWithPlayer,
        SeekPlayer,
        AttackPlayer,
        Shocked,
        AlertHit,
        AlertPatrol
    };
    private NPCBehaviour myBehaviour;

    private enum NPCMovingStyle
    {
        Walk,
        Run
    };
    private NPCMovingStyle myMovingStyle;

    private int NoOfWaypoint;
    private int currentWaypoint;
    private float waitingStartTime;
    private float positionGap;
    private int previousWaypoint;
    private float moveSpeed;
    private float distanceToTarget;
    private bool ifTargetInHideZone;
    private bool ifTargetSneaking;
    private bool ifTargetCrawling;
    private bool ifTargetRunning;
    private bool ifTargetIdling;
    private int raycastDistance;

    private Vector3 raycastHeightOne;
    private Vector3 raycastHeightTwo;
    private Vector3 raycastHeightThree;
    private Vector3 raycastHeightFour;
    private Vector3 raycastHeightFive;
    private Vector3 raycastHeightSix ;

    private bool alertLevelTwoFadeActivation;
    private float alertLevelTwoFadeStartingTime;
    private NPCBehaviour previousBehaviour;
    private float previousAlertLocation;
    private bool alertHitted;
    private bool alertPatrolled;
    private float targetPreviousPosition;
    private NPCBehaviour tempBehaviour;
    private float alertCooldownStartingTime;
    private bool alertReaction;

    private float lastPlayerPosition;
    private const int threeSeekPosition = 3;
    private int currentSeekOrder;
    private float[] seekPositions;
    private float seekingStartingTime;

    private bool isAttacking;
    private float attackStartingTime;
    private const float attackPeriod = 1.0f;
    private const float pullGunPeriod = 0.9f;
    private float pullGunStartingTime;
    private bool hasPulledGun;

    // Use this for initialization
    void Start ()
    {
        bool waypointCheck = false;
        //Error check
        if (alertLevel < 1 || alertLevel > 5)
            Debug.LogError("Alert Level has to be 1, 2, 3, 4 or 5");
        if (stateLevel < 1 || stateLevel > 4)
            Debug.LogError("State Level has to be 1, 2, 3 or 4");
        if (waypointXValue.Length == waypointWaitingTime.Length &&
            waypointXValue.Length == waypointAnimation.Length)
        {
            NoOfWaypoint = waypointXValue.Length;
        }
        else
        {
            Debug.LogError ("Setup of waypoint is wrong");
        }
        foreach (float waypointX in waypointXValue)
        {
            if (waypointX <= movingLimitOnLeftX ||
                waypointX >= movingLimitOnRightX)
                waypointCheck = true;
        }
        if (movingLimitOnLeftX >= movingLimitOnRightX ||
            transform.position.x <= movingLimitOnLeftX ||
            transform.position.x >= movingLimitOnRightX ||
            waypointCheck)
        {
            Debug.LogError ("movingLimit Error");
        }


        myBehaviour = NPCBehaviour.Patrol;
        myMovingStyle = NPCMovingStyle.Walk;
        tempBehaviour = myBehaviour;

        //set speed for different style
        if (myMovingStyle == NPCMovingStyle.Walk)
        {
            moveSpeed = walkSpeed;
        }
        else
        {
            moveSpeed = runSpeed;
        }
        positionGap = 1.0f;
        waitingStartTime = -100.0f;
        distanceToTarget = Mathf.Abs(mainTarget.transform.position.x - transform.position.x);
        ifTargetInHideZone = mainTarget.GetComponent <PlayerStatus> ().ifInHideZone ();
        ifTargetSneaking = mainTarget.GetComponent <PlayerStatus> ().ifSneaking ();
        ifTargetCrawling = mainTarget.GetComponent <PlayerStatus> ().ifCrawling ();
        ifTargetRunning = mainTarget.GetComponent <PlayerStatus> ().ifRunning ();
        ifTargetIdling = mainTarget.GetComponent <PlayerStatus> ().ifIdlling ();

        if (facingRight)
            raycastDistance = 10000;
        else
            raycastDistance = -10000;

        raycastHeightOne= new Vector3 (transform.position.x, transform.position.y + 25, transform.position.z);
        raycastHeightTwo = new Vector3 (transform.position.x, transform.position.y + 50, transform.position.z);
        raycastHeightThree = new Vector3 (transform.position.x, transform.position.y + 75, transform.position.z);
        raycastHeightFour = new Vector3 (transform.position.x, transform.position.y + 100, transform.position.z);
        raycastHeightFive = new Vector3 (transform.position.x, transform.position.y + 125, transform.position.z);
        raycastHeightSix = new Vector3 (transform.position.x, transform.position.y + 150, transform.position.z);

        alertLevelTwoFadeStartingTime = -999;
        alertCooldownStartingTime = -999;
        alertReaction = true;
        seekingStartingTime = -999;
        lastPlayerPosition = 0.001f;
        seekPositions = new float[3];
    }

    // Update is called once per frame
    void Update ()
    {
//      Debug.Log (myBehaviour + " " + tempBehaviour + " " + previousBehaviour);
//      Debug.Log (ifTargetSneaking + " " + ifTargetCrawling + " " + ifTargetRunning + " " + ifTargetIdling);
        //Calculate the distance between target and enermy
        distanceToTarget = Mathf.Abs(mainTarget.transform.position.x - transform.position.x);
        //Debug.Log(distanceToTarget);

        //Check if target is in hide zone
        ifTargetInHideZone = mainTarget.GetComponent <PlayerStatus> ().ifInHideZone ();
        //Debug.Log(ifTargetInHideZone);
        ifTargetSneaking = mainTarget.GetComponent <PlayerStatus> ().ifSneaking ();
        ifTargetCrawling = mainTarget.GetComponent <PlayerStatus> ().ifCrawling ();
        ifTargetRunning = mainTarget.GetComponent <PlayerStatus> ().ifRunning ();
        ifTargetIdling = mainTarget.GetComponent <PlayerStatus> ().ifIdlling ();

        //Set speed for different style
        if (myMovingStyle == NPCMovingStyle.Walk)
        {
            moveSpeed = walkSpeed;
        }
        else
        {
            moveSpeed = runSpeed;
        }

        //Back to first waypoint
        if (currentWaypoint >= NoOfWaypoint)
        {
            currentWaypoint = 0;
        }

        //Going out of Limit area
        if (outOfLimitZone ())
        {
//          Debug.Log (myBehaviour + " " + tempBehaviour);
            myBehaviour = tempBehaviour;
            if (myBehaviour == NPCBehaviour.AlertPatrol)
                myBehaviour = previousBehaviour;
            alertCooldownStartingTime = Time.time;
            currentSeekOrder = 0;
        }

        //The Alert Cooldown time has passed
        if (Time.time <= alertCooldownStartingTime + alertCooldownTime)
        {
            alertReaction = false;
        }
        else
        {
            alertReaction = true;
        }

        //If player just Make Noise for state level 1
        if (alertLevelTwoFadeActivation)
        {
            if (Time.time >= alertLevelTwoFadeStartingTime + alertLevelTwoFadeTimePeriod)
            {
                decreaseAggressive ();
                alertLevelTwoFadeStartingTime = -999;
                myBehaviour = previousBehaviour;
                alertLevelTwoFadeActivation = false;
            }
        }

        switch (alertLevel)
        {
            case 1:
                break;
            case 2:
//              Debug.Log ("GO");
                if (SeesPlayer (alertLevelTwoSeeDistance))
                {
//                  Debug.Log ("Distance: " + Mathf.Abs(transform.position.x - mainTarget.transform.position.x));
//                  Debug.Log (ifTargetSneaking + " " + ifTargetCrawling + " " + ifTargetRunning + " " + ifTargetIdling);
                }
                break;
            case 3:
                if (SeesPlayer (alertLevelThreeSeeDistance) &&
                    alertReaction &&
                    (myBehaviour != NPCBehaviour.AlertHit) &&
                    (myBehaviour != NPCBehaviour.AttackPlayer))
                {
                    alertCooldownStartingTime = Time.time;
                    tempBehaviour = myBehaviour;
                    myBehaviour = NPCBehaviour.AttackPlayer;
//                  Debug.Log ("my " + myBehaviour);
                }
                break;
            case 4:
                if (SeesPlayer (alertLevelFourSeeDistance))
                {

                }
                break;
            case 5:
                if (SeesPlayer (alertLevelFiveSeeDistance))
                {

                }
                break;
        }

        switch (stateLevel)
        {
            case 1:
                break;
            case 2:
                break;
            case 3:
                break;
            case 4:
                break;
        }

        switch (myBehaviour)
        {
            case NPCBehaviour.Guard:
                Guard ();
                break;
            case NPCBehaviour.Patrol:
                Patrol ();
                break;
            case NPCBehaviour.InteractWithPlayer:
                InteractWithPlayer ();
                break;
            case NPCBehaviour.SeekPlayer:
                SeekPlayer ();
                break;
            case NPCBehaviour.AttackPlayer:
                if (alertLevel == 1 ||
                    alertLevel == 2)
                    AttackPlayer ();
                else
                    rangeAttackPlayer ();
                break;
            case NPCBehaviour.Shocked:
                Shocked ();
                break;
            case NPCBehaviour.AlertHit:
                AlertHit ();
                break;
            case NPCBehaviour.AlertPatrol:
                alertPatrol ();
                break;
        }

        raycastHeightOne= new Vector3 (transform.position.x, transform.position.y + 25, transform.position.z);
        raycastHeightTwo = new Vector3 (transform.position.x, transform.position.y + 50, transform.position.z);
        raycastHeightThree = new Vector3 (transform.position.x, transform.position.y + 75, transform.position.z);
        raycastHeightFour = new Vector3 (transform.position.x, transform.position.y + 100, transform.position.z);
        raycastHeightFive = new Vector3 (transform.position.x, transform.position.y + 125, transform.position.z);
        raycastHeightSix = new Vector3 (transform.position.x, transform.position.y + 150, transform.position.z);

    }

    bool outOfLimitZone ()
    {
//      Debug.Log ("tell: " + transform.position.x + " " + movingLimitOnRightX + " " + myBehaviour + " " + tempBehaviour);
        if (transform.position.x >= movingLimitOnRightX ||
            transform.position.x <= movingLimitOnLeftX)
            return true;
        else
            return false;
    }

    bool SeesPlayer (float seeDistance)
    {
        if (isOnFront ())
        {
            if (ifTargetRunning)
            {
                //Simple Running
                if (!ifTargetSneaking && !ifTargetCrawling)
                {
                    if (isInSeeRange (seeDistance))
                    {
                        lastPlayerPosition = mainTarget.transform.position.x;
                        return true;
                    }
                    return false;
                }
                //Sneak Running
                else if (ifTargetSneaking)
                {
                    if (isInSeeRange (seeDistance * 0.85f))
                    {
                        lastPlayerPosition = mainTarget.transform.position.x;
                        return true;
                    }
                    return false;
                }
                //Crawl Running
                else if (ifTargetCrawling)
                {
                    if (isInSeeRange (seeDistance * 0.7f))
                    {
                        lastPlayerPosition = mainTarget.transform.position.x;
                        return true;
                    }
                    return false;
                }
                else
                {
                    Debug.Log ("Player Running Status Error");
                }
            }
            else if (ifTargetIdling)
            {
                //Simple Idling
                if (!ifTargetSneaking && !ifTargetCrawling)
                {
                    if (isInSeeRange (seeDistance))
                    {
                        lastPlayerPosition = mainTarget.transform.position.x;
                        return true;
                    }
                    return false;
                }
                //Sneak Idling
                else if (ifTargetSneaking)
                {
                    if (isInSeeRange (seeDistance * 0.7f))
                    {
                        lastPlayerPosition = mainTarget.transform.position.x;
                        return true;
                    }
                    return false;
                }
                //Crawl Idling
                else if (ifTargetCrawling)
                {
                    if (isInSeeRange (seeDistance * 0.55f))
                    {
                        lastPlayerPosition = mainTarget.transform.position.x;
                        return true;
                    }
                    return false;
                }
                else
                {
                    Debug.Log ("Player Idling Status Error");
                }
            }
            else
            {
                Debug.Log ("Player Status Error");
            }
        }
        else
        {
            if (ifTargetRunning)
            {
                //Simple Running
                if (!ifTargetSneaking && !ifTargetCrawling)
                {
                    if (isInSeeRange (seeDistance * 0.7f))
                    {
                        lastPlayerPosition = mainTarget.transform.position.x;
                        return true;
                    }
                    return false;
                }
                //Sneak Running
                else if (ifTargetSneaking)
                {
                    return false;
                }
                //Crawl Running
                else if (ifTargetCrawling)
                {
                    return false;
                }
                else
                {
                    Debug.Log ("Player Running Status Error");
                }
            }
            else if (ifTargetIdling)
            {
                //Simple Idling
                if (!ifTargetSneaking && !ifTargetCrawling)
                {
                    return false;
                }
                //Sneak Idling
                else if (ifTargetSneaking)
                {
                    return false;
                }
                //Crawl Idling
                else if (ifTargetCrawling)
                {
                    return false;
                }
                else
                {
                    Debug.Log ("Player Idling Status Error");
                }
            }
            else
            {
                Debug.Log ("Player Status Error");
            }
        }
        return false;
    }

    //MainTarget is on the front of the enemy
    bool isOnFront ()
    {
        if ((facingRight &&
            mainTarget.transform.position.x >= transform.position.x) ||
            (!facingRight &&
            mainTarget.transform.position.x <= transform.position.x))
        {
            return true;
        }
        return false;
    }

    bool isInSeeRange (float seeDistance)
    {
        if ((mainTarget.transform.position.x >= transform.position.x &&
            mainTarget.transform.position.x <= transform.position.x + seeDistance) ||
            (mainTarget.transform.position.x <= transform.position.x &&
            mainTarget.transform.position.x >= transform.position.x - seeDistance))
        {
            return true;
        }
        return false;
    }

    void Guard ()
    {
        if (alertLevel == 1 ||
            alertLevel == 2 ||
            alertLevel == 3)
        {

        }
        else
        {

        }
        hasPulledGun = false;
    }

    void Patrol ()
    {
        //calculate previous waypoint waiting time
        if (currentWaypoint == 0)
        {
            previousWaypoint = waypointWaitingTime.Length - 1;
        }
        else
        {
            previousWaypoint = currentWaypoint - 1;
        }
        //Waiting time has finished
        if (Time.time >= waitingStartTime + waypointWaitingTime[previousWaypoint])
        {
            //Arrive new Waypoint
            if (transform.position.x <= waypointXValue[currentWaypoint] + positionGap &&
                transform.position.x >= waypointXValue[currentWaypoint] - positionGap)
            {
                waitingStartTime = Time.time;
                BroadcastMessage ("NoMove");
                character.CrossFade (waypointAnimation[currentWaypoint]);
                currentWaypoint++;
            }
            //Waypoint is on left
            else if (transform.position.x <= waypointXValue[currentWaypoint])
            {
                BroadcastMessage ("RightMove", moveSpeed);
                character.CrossFade (walkingStyleAnimation);
                //Flip animation
                if (!facingRight)
                {
                    transform.localScale = new Vector3(-1 * transform.localScale.x, 1 * transform.localScale.y, 1 * transform.localScale.z);
                    facingRight = true;
                    raycastDistance *= -1;
                }
            }
            //Waypoint is on Right
            else
            {
                BroadcastMessage ("LeftMove", moveSpeed);
                character.CrossFade (walkingStyleAnimation);
                //Flip animation
                if (facingRight)
                {
                    transform.localScale = new Vector3(-1 * transform.localScale.x, 1 * transform.localScale.y, 1 * transform.localScale.z);
                    facingRight = false;
                    raycastDistance *= -1;
                }
            }
        }
        //waiting
        else
        {
        }
//        Debug.DrawRay(transform.position, new Vector3 (raycastDistance, 0, 0), Color.red);
        ifCanSeeTargetByRaycast ();

        hasPulledGun = false;
    }

    void InteractWithPlayer ()
    {

        hasPulledGun = false;
    }

    void SeekPlayer ()
    {
        if (alertLevel == 1 ||
            alertLevel == 2)
        {
            myBehaviour = NPCBehaviour.Patrol;
        }

        if (Time.time >= seekingStartingTime + seekWaitingTime)
        {
            //When all three seek position has been walked to
            if (currentSeekOrder >= threeSeekPosition)
            {
                myBehaviour = tempBehaviour;
                currentSeekOrder = 0;
            }

            //Arrive new Seekpoint
            if (transform.position.x <= seekPositions[currentSeekOrder] + positionGap &&
                transform.position.x >= seekPositions[currentSeekOrder] - positionGap)
            {
                seekingStartingTime = Time.time;
                currentSeekOrder++;
                BroadcastMessage ("NoMove");
                character.CrossFade (seekAnimation);
            }
            //Seekpoint is on left
            else if (transform.position.x <= seekPositions[currentSeekOrder])
            {
                BroadcastMessage ("RightMove", moveSpeed);
                character.CrossFade (walkingStyleAnimation);
                //Flip animation
                if (!facingRight)
                {
                    transform.localScale = new Vector3(-1 * transform.localScale.x, 1 * transform.localScale.y, 1 * transform.localScale.z);
                    facingRight = true;
                    raycastDistance *= -1;
                }
            }
            //Seekpoint is on Right
            else
            {
                BroadcastMessage ("LeftMove", moveSpeed);
                character.CrossFade (walkingStyleAnimation);
                //Flip animation
                if (facingRight)
                {
                    transform.localScale = new Vector3(-1 * transform.localScale.x, 1 * transform.localScale.y, 1 * transform.localScale.z);
                    facingRight = false;
                    raycastDistance *= -1;
                }
            }
        }

    }

    void AttackPlayer ()
    {
        //Switch moving style
        if (alertLevel == 1 ||
            alertLevel == 2)
        {
            myMovingStyle = NPCMovingStyle.Walk;
        }
        else
        {
            myMovingStyle = NPCMovingStyle.Run;
        }

        //If target is in hidezone or blocked by something
        if ((ifTargetInHideZone && distanceToTarget >= alertFadeDistance) ||
            (ifTargetInHideZone && !ifCanSeeTargetByRaycast ()))
        {
            Debug.Log (ifTargetInHideZone + " " + distanceToTarget + " " + alertFadeDistance + " " +
            ifTargetInHideZone + " " + ifCanSeeTargetByRaycast ());
            myBehaviour = NPCBehaviour.SeekPlayer;
            currentSeekOrder = 0;
            seekingStartingTime = Time.time;
            BroadcastMessage ("NoMove");
            character.CrossFade (seekAnimation);
            if (lastPlayerPosition == 0.001f)
            {
                lastPlayerPosition = transform.position.x;
            }
            seekPositions[0] = lastPlayerPosition - 0.5f * seekAreaRange;
            seekPositions[1] = lastPlayerPosition + seekAreaRange;
            seekPositions[2] = lastPlayerPosition - seekAreaRange;
        }

        //if is in attacking animation
        if (Time.time >= attackStartingTime + attackPeriod)
            isAttacking = false;

        //When target is in the attack range!
        if (((mainTarget.transform.position.x >= transform.position.x &&
            mainTarget.transform.position.x <= transform.position.x + attackRange) ||
            (mainTarget.transform.position.x <= transform.position.x &&
            mainTarget.transform.position.x >= transform.position.x - attackRange))
            && !isAttacking)
        {
            if (transform.position.x < mainTarget.transform.position.x &&
                !facingRight)
            {
                transform.localScale = new Vector3(-1 * transform.localScale.x, 1 * transform.localScale.y, 1 * transform.localScale.z);
                facingRight = true;
                raycastDistance *= -1;
            }
            else if (transform.position.x > mainTarget.transform.position.x &&
                    facingRight)
            {
                transform.localScale = new Vector3(-1 * transform.localScale.x, 1 * transform.localScale.y, 1 * transform.localScale.z);
                facingRight = false;
                raycastDistance *= -1;
            }
            if (Time.time >= attackStartingTime + attackDelay)
            {
                //Start Attack
                BroadcastMessage ("NoMove", moveSpeed);
                character.CrossFade (attackAnimation);
                attackStartingTime = Time.time;
                isAttacking = true;
            }
            else
            {
                character.CrossFade (idleStyleAnimation);
            }
        }
        else if (mainTarget.transform.position.x > transform.position.x && !isAttacking)
        {
            if (!facingRight)
            {
                transform.localScale = new Vector3(-1 * transform.localScale.x, 1 * transform.localScale.y, 1 * transform.localScale.z);
                facingRight = true;
                raycastDistance *= -1;
            }
            BroadcastMessage ("RightMove", moveSpeed);
            character.CrossFade (walkingStyleAnimation);
        }
        else if (mainTarget.transform.position.x < transform.position.x && !isAttacking)
        {
            if (facingRight)
            {
                transform.localScale = new Vector3(-1 * transform.localScale.x, 1 * transform.localScale.y, 1 * transform.localScale.z);
                facingRight = false;
                raycastDistance *= -1;
            }
            BroadcastMessage ("LeftMove", moveSpeed);
            character.CrossFade (walkingStyleAnimation);
        }


    }

    void rangeAttackPlayer ()
    {
        //Switch moving style ALERT level 1, 2 (WALK) Alert level 3, 4 (RUN)
        if (alertLevel == 1 ||
            alertLevel == 2)
        {
            myMovingStyle = NPCMovingStyle.Walk;
        }
        else
        {
            myMovingStyle = NPCMovingStyle.Run;
        }

        //If target is in hidezone or blocked by something
        if ((ifTargetInHideZone && distanceToTarget >= alertFadeDistance) ||
            (ifTargetInHideZone && !ifCanSeeTargetByRaycast ()))
        {
            Debug.Log (ifTargetInHideZone + " " + distanceToTarget + " " + alertFadeDistance + " " +
            ifTargetInHideZone + " " + ifCanSeeTargetByRaycast ());
            myBehaviour = NPCBehaviour.SeekPlayer;
            currentSeekOrder = 0;
            seekingStartingTime = Time.time;
            BroadcastMessage ("NoMove");
            character.CrossFade (seekAnimation);
            if (lastPlayerPosition == 0.001f)
            {
                lastPlayerPosition = transform.position.x;
            }
            seekPositions[0] = lastPlayerPosition - 0.5f * seekAreaRange;
            seekPositions[1] = lastPlayerPosition + seekAreaRange;
            seekPositions[2] = lastPlayerPosition - seekAreaRange;
        }

        //if is in attacking animation
        if (Time.time >= attackStartingTime + attackPeriod)
            isAttacking = false;

        //When target is in the attack range!
        if (((mainTarget.transform.position.x >= transform.position.x &&
            mainTarget.transform.position.x <= transform.position.x + attackRange) ||
            (mainTarget.transform.position.x <= transform.position.x &&
            mainTarget.transform.position.x >= transform.position.x - attackRange))
            && !isAttacking)
        {
            //facing to target
            if (transform.position.x < mainTarget.transform.position.x &&
                !facingRight)
            {
                transform.localScale = new Vector3(-1 * transform.localScale.x, 1 * transform.localScale.y, 1 * transform.localScale.z);
                facingRight = true;
                raycastDistance *= -1;
            }
            else if (transform.position.x > mainTarget.transform.position.x &&
                    facingRight)
            {
                transform.localScale = new Vector3(-1 * transform.localScale.x, 1 * transform.localScale.y, 1 * transform.localScale.z);
                facingRight = false;
                raycastDistance *= -1;
            }
            //Check if have the Ranged animation playing
            if (!hasPulledGun)
            {
                hasPulledGun = true;
                pullGunStartingTime = Time.time;
            }

            //Display the SwitchRanged Animation First
            if (Time.time < pullGunStartingTime + pullGunPeriod)
            {
                BroadcastMessage ("NoMove", moveSpeed);
                isAttacking = true;
                character.CrossFade ("SwitchRanged");
            }
            else if (Time.time >= attackStartingTime + attackDelay)
            {
                //Start Attack
                BroadcastMessage ("NoMove", moveSpeed);
                character.CrossFade (attackAnimation);
                attackStartingTime = Time.time;
                isAttacking = true;
                Transform gunPos = transform.Find ("Root/Main/Abdomen/Chest/RightShoulder/RightArm/RightHand/Weapon/Weapon_Sprite");
                GameObject instBullet = (GameObject) Instantiate (bullet, gunPos.position, bullet.transform.rotation);
                Vector2 speed = new Vector2 (mainTarget.transform.position.x - gunPos.position.x,
                                            mainTarget.transform.position.y - gunPos.position.y);
                speed.Normalize ();
                Vector2 origin = new Vector2 (1, 0);
                Vector2 newDir = new Vector2 (mainTarget.transform.position.x - gunPos.position.x,
                                                mainTarget.transform.position.y - gunPos.position.y);
                float degree = Vector2.Angle (origin, newDir);
                Debug.Log ("Tell " + degree + " " + origin + " " + newDir);
                instBullet.rigidbody.velocity = speed * bulletVelocity;
                if (gunPos.position.x < mainTarget.transform.position.x)
                {
                    instBullet.transform.Rotate (new Vector3 (degree, 0, 0));
                }
                else
                {
                    instBullet.transform.Rotate (new Vector3 (degree, 0, 0));
                }
            }
            else
            {
                character.CrossFade ("RangedIDLE");
            }
        }
        else if (mainTarget.transform.position.x > transform.position.x && !isAttacking)
        {
            if (!facingRight)
            {
                transform.localScale = new Vector3(-1 * transform.localScale.x, 1 * transform.localScale.y, 1 * transform.localScale.z);
                facingRight = true;
                raycastDistance *= -1;
            }
            BroadcastMessage ("RightMove", moveSpeed);
            character.CrossFade (walkingStyleAnimation);
        }
        else if (mainTarget.transform.position.x < transform.position.x && !isAttacking)
        {
            if (facingRight)
            {
                transform.localScale = new Vector3(-1 * transform.localScale.x, 1 * transform.localScale.y, 1 * transform.localScale.z);
                facingRight = false;
                raycastDistance *= -1;
            }
            BroadcastMessage ("LeftMove", moveSpeed);
            character.CrossFade (walkingStyleAnimation);
        }

    }

    void Shocked ()
    {
        BroadcastMessage ("NoMove", moveSpeed);
        character.CrossFade (alertAnimation);
    }

    void AlertHit ()
    {

        //if is in attacking animation
        if (Time.time >= attackStartingTime + attackPeriod)
            isAttacking = false;

        //Going to attack
        if (!alertHitted)
        {
            //When target is in the attack range!
            if ((mainTarget.transform.position.x >= transform.position.x &&
                mainTarget.transform.position.x <= transform.position.x + attackRange) ||
                (mainTarget.transform.position.x <= transform.position.x &&
                mainTarget.transform.position.x >= transform.position.x - attackRange))
            {
                //Start Attack
                BroadcastMessage ("NoMove", moveSpeed);
                character.CrossFade (attackAnimation);
                alertHitted = true;
                attackStartingTime = Time.time;
                isAttacking = true;
            }
            else if (mainTarget.transform.position.x > transform.position.x)
            {
                if (!facingRight)
                {
                    transform.localScale = new Vector3(-1 * transform.localScale.x, 1 * transform.localScale.y, 1 * transform.localScale.z);
                    facingRight = true;
                    raycastDistance *= -1;
                }
                BroadcastMessage ("RightMove", moveSpeed);
                character.CrossFade (walkingStyleAnimation);
            }
            else if (mainTarget.transform.position.x < transform.position.x)
            {
                if (facingRight)
                {
                    transform.localScale = new Vector3(-1 * transform.localScale.x, 1 * transform.localScale.y, 1 * transform.localScale.z);
                    facingRight = false;
                    raycastDistance *= -1;
                }
                BroadcastMessage ("LeftMove", moveSpeed);
                character.CrossFade (walkingStyleAnimation);
            }
        }
        //On the way back
        else
        {
            Debug.Log ("WayBack");
            //When back to position
            if ((previousAlertLocation >= transform.position.x &&
                previousAlertLocation <= transform.position.x + 5) ||
                (previousAlertLocation <= transform.position.x &&
                previousAlertLocation >= transform.position.x - 5))
            {
                Debug.Log ("AllDone " + myBehaviour + previousBehaviour);
                BroadcastMessage ("NoMove", moveSpeed);
                character.CrossFade (idleStyleAnimation);
                alertHitted = false;
                myBehaviour = previousBehaviour;
                decreaseAggressive ();
            }
            else if (previousAlertLocation > transform.position.x)
            {
                if (!facingRight)
                {
                    transform.localScale = new Vector3(-1 * transform.localScale.x, 1 * transform.localScale.y, 1 * transform.localScale.z);
                    facingRight = true;
                    raycastDistance *= -1;
                }
                BroadcastMessage ("RightMove", moveSpeed);
                character.CrossFade (walkingStyleAnimation);
            }
            else if (previousAlertLocation < transform.position.x)
            {
                if (facingRight)
                {
                    transform.localScale = new Vector3(-1 * transform.localScale.x, 1 * transform.localScale.y, 1 * transform.localScale.z);
                    facingRight = false;
                    raycastDistance *= -1;
                }
                BroadcastMessage ("LeftMove", moveSpeed);
                character.CrossFade (walkingStyleAnimation);
            }
        }
    }

    void alertPatrol ()
    {
        //On the way going to patrol the point
        if (!alertPatrolled)
        {
            //When in the alert position
            if ((targetPreviousPosition >= transform.position.x &&
                targetPreviousPosition <= transform.position.x + 5) ||
                (targetPreviousPosition <= transform.position.x &&
                targetPreviousPosition >= transform.position.x - 5))
            {
                //Start Attack
                BroadcastMessage ("NoMove", moveSpeed);
                alertPatrolled = true;
                myBehaviour = NPCBehaviour.SeekPlayer;
                currentSeekOrder = 0;
                seekingStartingTime = Time.time;
                character.CrossFade (idleStyleAnimation);
                if (lastPlayerPosition == 0.001f)
                {
                    lastPlayerPosition = transform.position.x;
                }
                seekPositions[0] = lastPlayerPosition - 0.5f * seekAreaRange;
                seekPositions[1] = lastPlayerPosition + seekAreaRange;
                seekPositions[2] = lastPlayerPosition - seekAreaRange;

            }
            else if (targetPreviousPosition > transform.position.x)
            {
                if (!facingRight)
                {
                    transform.localScale = new Vector3(-1 * transform.localScale.x, 1 * transform.localScale.y, 1 * transform.localScale.z);
                    facingRight = true;
                    raycastDistance *= -1;
                }
                BroadcastMessage ("RightMove", moveSpeed);
                character.CrossFade (walkingStyleAnimation);
            }
            else if (targetPreviousPosition < transform.position.x)
            {
                if (facingRight)
                {
                    transform.localScale = new Vector3(-1 * transform.localScale.x, 1 * transform.localScale.y, 1 * transform.localScale.z);
                    facingRight = false;
                    raycastDistance *= -1;
                }
                BroadcastMessage ("LeftMove", moveSpeed);
                character.CrossFade (walkingStyleAnimation);
            }
        }
        else
        {
            //When back to position
            if ((previousAlertLocation >= transform.position.x &&
                previousAlertLocation <= transform.position.x + 5) ||
                (previousAlertLocation <= transform.position.x &&
                previousAlertLocation >= transform.position.x - 5))
            {
                BroadcastMessage ("NoMove", moveSpeed);
                character.CrossFade (idleStyleAnimation);
                alertPatrolled = false;
                myBehaviour = previousBehaviour;
            }
            else if (previousAlertLocation > transform.position.x)
            {
                if (!facingRight)
                {
                    transform.localScale = new Vector3(-1 * transform.localScale.x, 1 * transform.localScale.y, 1 * transform.localScale.z);
                    facingRight = true;
                    raycastDistance *= -1;
                }
                BroadcastMessage ("RightMove", moveSpeed);
                character.CrossFade (walkingStyleAnimation);
            }
            else if (previousAlertLocation < transform.position.x)
            {
                if (facingRight)
                {
                    transform.localScale = new Vector3(-1 * transform.localScale.x, 1 * transform.localScale.y, 1 * transform.localScale.z);
                    facingRight = false;
                    raycastDistance *= -1;
                }
                BroadcastMessage ("LeftMove", moveSpeed);
                character.CrossFade (walkingStyleAnimation);
            }
        }
    }

    bool ifCanSeeTargetByRaycast ()
    {
        RaycastHit hitOne;
        RaycastHit hitTwo;
        RaycastHit hitThree;
        RaycastHit hitFour;
        RaycastHit hitFive;
        RaycastHit hitSix;
        RaycastHit hitSeven;

        int layermask = 1 << 8;

        bool detectedPlayerOne = false;
        bool detectedPlayerTwo = false;
        bool detectedPlayerThree = false;
        bool detectedPlayerFour = false;
        bool detectedPlayerFive = false;
        bool detectedPlayerSix = false;
        bool detectedPlayerSeven = false;

//      Test
//      Debug.Log (raycastHeightOne + " " + new Vector3 (raycastDistance, 0, 0));
//
//      Debug.DrawRay(transform.position, new Vector3 (raycastDistance, 0, 0), Color.green);
//      Debug.DrawRay(raycastHeightOne, new Vector3 (raycastDistance, 0, 0), Color.red);
//      Debug.DrawRay(raycastHeightTwo, new Vector3 (raycastDistance, 0, 0), Color.blue);

        if (Physics.Raycast(transform.position, new Vector3 (raycastDistance, 0, 0), out hitOne, Mathf.Infinity, layermask))
        {
//          Debug.DrawLine(transform.position, hitOne.point);
//          Debug.Log ("One " + hitOne.collider.name + " " + hitOne.collider.gameObject.layer);
            detectedPlayerOne = true;
        }

        if (Physics.Raycast(raycastHeightOne, new Vector3 (raycastDistance, 0, 0), out hitTwo, Mathf.Infinity, layermask))
        {
//          Debug.DrawLine(raycastHeightOne, hitTwo.point);
//          Debug.Log ("Two " + hitTwo.collider.name + " " + hitTwo.collider.gameObject.layer);
            detectedPlayerTwo = true;
        }

        if (Physics.Raycast(raycastHeightTwo, new Vector3 (raycastDistance, 0, 0), out hitThree, Mathf.Infinity, layermask))
        {
//          Debug.DrawLine(raycastHeightTwo, hitThree.point);
//          Debug.Log ("Three " + hitThree.collider.name + " " + hitThree.collider.gameObject.layer);
            detectedPlayerThree = true;
        }

        if (Physics.Raycast(raycastHeightThree, new Vector3 (raycastDistance, 0, 0), out hitFour, Mathf.Infinity, layermask))
        {
//          Debug.DrawLine(raycastHeightThree, hitFour.point);
//          Debug.Log ("One " + hitFour.collider.name);
            detectedPlayerFour = true;
        }

        if (Physics.Raycast(raycastHeightFour, new Vector3 (raycastDistance, 0, 0), out hitFive, Mathf.Infinity, layermask))
        {
//          Debug.DrawLine(raycastHeightFour, hitFive.point);
//          Debug.Log ("Two " + hitFive.collider.name);
            detectedPlayerFive = true;
        }

        if (Physics.Raycast(raycastHeightFive, new Vector3 (raycastDistance, 0, 0), out hitSix, Mathf.Infinity, layermask))
        {
//          Debug.DrawLine(raycastHeightFive, hitSix.point);
//          Debug.Log ("Three " + hitSix.collider.name);
            detectedPlayerSix = true;
        }

        if (Physics.Raycast(raycastHeightSix, new Vector3 (raycastDistance, 0, 0), out hitSeven, Mathf.Infinity, layermask))
        {
//          Debug.DrawLine(raycastHeightSix, hitSeven.point);
//          Debug.Log ("Three " + hitSeven.collider.name);
            detectedPlayerSeven = true;
        }

        if (detectedPlayerOne ||
            detectedPlayerTwo ||
            detectedPlayerThree ||
            detectedPlayerFour ||
            detectedPlayerFive ||
            detectedPlayerSix ||
            detectedPlayerSeven)
        {
            return true;
        }

        return false;
    }

    public void HearPlayer (float targetPosition)
    {
        if (alertLevel == 1)
        {
            if (stateLevel == 1)
            {
                increaseAggressive ();
                //Facing to Player
                FaceTarget ();
                alertLevelTwoFadeActivation = true;
                alertLevelTwoFadeStartingTime = Time.time;
                previousBehaviour = myBehaviour;
                myBehaviour = NPCBehaviour.Shocked;
            }
            else if (stateLevel == 2)
            {

                Debug.Log ("InSecond Stage");
                if (myBehaviour != NPCBehaviour.AlertHit)
                {
                    alertLevelTwoFadeActivation = false;
                    alertLevelTwoFadeStartingTime = -999;
                    previousAlertLocation = transform.position.x;
                    alertHitted = false;
    //              previousBehaviour = myBehaviour;
                    myBehaviour = NPCBehaviour.AlertHit;
                }
            }
            else
            {
                Debug.Log ("AlertHit Bug?");
            }
        }
        else if (alertLevel == 3)
        {
            if (myBehaviour != NPCBehaviour.AlertPatrol &&
                myBehaviour != NPCBehaviour.AttackPlayer)
            {
                FaceTarget ();
                previousBehaviour = myBehaviour;
                previousAlertLocation = transform.position.x;
                targetPreviousPosition = targetPosition;
                myBehaviour = NPCBehaviour.AlertPatrol;
            }
        }
        else if (alertLevel == 4)
        {
            if (myBehaviour != NPCBehaviour.AlertPatrol &&
                myBehaviour != NPCBehaviour.AttackPlayer)
            {
                FaceTarget ();
                previousBehaviour = myBehaviour;
                previousAlertLocation = transform.position.x;
                targetPreviousPosition = targetPosition;
                myBehaviour = NPCBehaviour.AlertPatrol;
            }
        }
        else if (alertLevel == 5)
        {
            if (myBehaviour != NPCBehaviour.AlertPatrol &&
                myBehaviour != NPCBehaviour.AttackPlayer)
            {
                FaceTarget ();
                previousBehaviour = myBehaviour;
                previousAlertLocation = transform.position.x;
                targetPreviousPosition = targetPosition;
                myBehaviour = NPCBehaviour.AlertPatrol;
            }
        }
    }

    public void FaceTarget ()
    {
        if (facingRight)
        {
            if (mainTarget.transform.position.x < transform.position.x)
            {
                transform.localScale = new Vector3(-1 * transform.localScale.x, 1 * transform.localScale.y, 1 * transform.localScale.z);
                facingRight = false;
                raycastDistance *= -1;
            }
        }
        else
        {
            if (mainTarget.transform.position.x > transform.position.x)
            {
                transform.localScale = new Vector3(-1 * transform.localScale.x, 1 * transform.localScale.y, 1 * transform.localScale.z);
                facingRight = true;
                raycastDistance *= -1;
            }
        }
    }

    public void increaseAggressive ()
    {
        if (stateLevel < 4)
            stateLevel ++;
    }

    public void decreaseAggressive ()
    {
        if (stateLevel > 0)
            stateLevel --;
    }

}