public override AIStates OnGetHit( Mobile by, AIStates AIState, int dmg )
 {
     if ( AIState != AIStates.Attack && AIState != AIStates.Fighting )
     {
         OnBeginFight( by );
         return AIStates.BeingAttacked;
     }
     return AIState;
 }

	/// <summary>
	/// TargetCoords is used when a ship has been hit and it will try and destroy
	/// this ship
	/// </summary>
	/// <param name="row">row generated around the hit tile</param>
	/// <param name="column">column generated around the hit tile</param>
	private void TargetCoords(ref int row, ref int column)
	{
		Location l = _Targets.Pop();

		if ((_Targets.Count == 0))
			_CurrentState = AIStates.Searching;
		row = l.Row;
		column = l.Column;
	}

    /// <summary>
    /// ProcessShot will be called uppon when a ship is found.
    /// It will create a stack with targets it will try to hit. These targets
    /// will be around the tile that has been hit.
    /// </summary>
    /// <param name="row">the row it needs to process</param>
    /// <param name="col">the column it needs to process</param>
    /// <param name="result">the result og the last shot (should be hit)</param>
    protected override void ProcessShot(int row, int col, AttackResult result)
    {
        if (result.Value == ResultOfAttack.Hit) {
            _CurrentState = AIStates.Searching;

        } else if (result.Value == ResultOfAttack.ShotAlready) {
            throw new ApplicationException("Error in AI");
        }
    }

 /// <summary>
 /// ProcessShot will be called uppon when a ship is found.
 /// It will create a stack with targets it will try to hit. These targets
 /// will be around the tile that has been hit.
 /// </summary>
 /// <param name="row">the row it needs to process</param>
 /// <param name="col">the column it needs to process</param>
 /// <param name="result">the result og the last shot (should be hit)</param>
 protected override void ProcessShot(int row, int col, AttackResult result)
 {
     if (result.Value == ResultOfAttack.Hit) {
         _CurrentState = AIStates.TargetingShip;
         AddTarget(row - 1, col);
         AddTarget(row, col - 1);
         AddTarget(row + 1, col);
         AddTarget(row, col + 1);
     } else if (result.Value == ResultOfAttack.ShotAlready) {
         throw new ApplicationException("Error in AI");
     }
 }

 /// <summary>
 /// ProcessShot will be called uppon when a ship is found.
 /// It will create a stack with targets it will try to hit. These targets
 /// will be randomly assigned.
 /// </summary>
 /// <param name="row">the row it needs to process</param>
 /// <param name="rowOld">the row it contained before hit</param>
 /// <param name="col">the column it needs to process</param>
 /// <param name="colOld">the column it contained before hit</param>
 /// <param name="result">the result of the last shot (should be hit)</param>
 protected override void ProcessShot(int row, int col, AttackResult result)
 {
     if (result.Value == ResultOfAttack.Hit) {
         _CurrentState = AIStates.Searching;
         int rowOld = row;
         int colOld = col;
         SearchCoords(ref row, ref col);
         AddTarget(row, colOld);
         AddTarget(rowOld, col);
     } else if (result.Value == ResultOfAttack.ShotAlready) {
         throw new ApplicationException("Error in AI");
     }
 }

 public override AIStates OnGetHit( Mobile by, AIStates AIState, int dmg )
 {
     if ( AIState != AIStates.Attack && AIState != AIStates.Fighting )
     {
         OnBeginFight( by );
         if ( by == From )
             From.AttackTarget = From.LastOffender;
         else
             From.AttackTarget = by;
         return AIStates.BeingAttacked;
     }
     return AIState;
 }

 void UpdateState()
 {
     if (health < 1) curstate = AIStates.Dead;
 }

        public override void Update(GameTime gameTime)
        {
            Player player = GetNeareastPlayer();

            switch (AIState)
            {
                case AIStates.DODGE:

                    break;
                case AIStates.ATTACK:

                    break;
                case AIStates.ROAM:
                    if (!(Vector2.Distance(DestinationPos, Position) < 5))
                    {
                        var dir = DestinationPos - Position;
                        dir.Normalize();
                        Position += dir * 5f;
                    }
                    else
                    {
                        destPos = new Vector2(rand.Next(width / 2 + 5, Game1.GAME_WIDTH - width / 2),
                            rand.Next(height / 2 + 5, Game1.GAME_HEIGHT - height / 2));
                    }
                    break;
                default:
                    AIState = AIStates.DODGE;
                    break;
            }

            foreach (Player p in GameplayState.Players)
            {
                // Why would I check if my bullets hit me? Well... there's probably many
                //     resons but for now, keep it my way.
                if (p == this) continue;

                // Laser guns are an exception to bullet checks... instead, they're just a
                // giant rectangle.  The laser isn't removed if it's hitting me
                if (p.equippedWeapon.GetType() == typeof(LaserGun))
                {
                    var weapon = (LaserGun)p.equippedWeapon;
                    if (weapon.Laser.Bounds.Intersects(Bounds) && weapon.Laser.IsActive)
                        Damage(p.equippedWeapon.Damage);
                }
                else
                {
                    // Here's the bullet foreach loop, it just uses a fancy lambda expression
                    p.equippedWeapon.Bullets.ForEach((b) =>
                    {
                        // If there's no forcefield then KILL ME
                        if (!forceField)
                        {
                            if (b.Bounds.Intersects(Bounds))
                            {
                                Damage(p.equippedWeapon.Damage);
                                b.DestroyMe = true;
                            }
                        }
                        // If there is a force field then don't kill me
                        else
                        {
                            if (b.Bounds.Intersects(ForceFieldBounds))
                            {
                                b.DestroyMe = true;
                            }
                        }
                    });
                }
            }

            equippedWeapon.Update(gameTime);
        }

    /** Initializes reference variables.
     * If you override this function you should in most cases call base.Awake () at the start of it.
      * */
    protected virtual void Awake()
    {
        seeker = GetComponent<Seeker>();

        AnimControl = GetComponent<AIStates>();

        //This is a simple optimization, cache the transform component lookup
        tr = transform;

        //Make sure we receive callbacks when paths complete
        seeker.pathCallback += OnPathComplete;

        //Cache some other components (not all are necessarily there)
        controller = GetComponent<CharacterController>();
        navController = GetComponent<NavmeshController>();
        rigid = rigidbody;
    }

    // Use this for initialization
    void Start()
    {
        textPanel.SetActive(false);
        updateLocation();
        if(board == null) {
            board = GameObject.Find("Board");
        }
        if(goalPoint == null) {
            // Debug.Log("goal being set");

            chooseNewGoal();
            //  Debug.Log(string.Format("the goalpoint name is {0}", goalPoint));
            findPath();
            state = AIStates.IDLE;
            // state = (AIStates)Random.Range(0, 3);
        }
        Player.turn += StateMachine;

        // this flags all the squares as hot
        foreach(GameObject square in persueRoom) {
            square.GetComponent<ClickObject>().personalSquare();
        }
    }

	// Here we check to see if we can attack and what distance away we are.
	// If we are holding a throwable, the distance will be increased so that
	// we can throw it at a further range.
	void AttemptAttack(float distFromTarget)
	{
		if(targetCharStatus == null || (detectionRadius.inCloseRangeChar.Count == 0
		   && anim.GetInteger("HoldStage") != 1)) // HoldStage 1 means we are holding a throwable.
			return;
		float minDistUsing = minAttackDist;
		float maxDistUsing = maxAttackDist;
		bool holdingThrowable = false;
		if(anim.GetInteger("HoldStage") == 1)
		{
			maxDistUsing = maxAttackDist + 3;
			holdingThrowable = true;
		}

		// This part determines if we are in range to attack.
		if(distFromTarget > minDistUsing && distFromTarget < maxDistUsing)
		{
			// Face our target when within range and in idle. Otherwise just get the angle from us
			// facing our target currently.
			float angle = FaceCharacterTarget();
			// If facing our target by a good amount and making sure
			// they are vulnerable and are not guarding. If they are, they will
			// have a small chance of attacking.
			if(targetCharStatus.Vulnerable) // Make sure they are Vulnerable.
			{
				if(angle < 55
				   && (!targetCharStatus.BaseStateInfo.IsTag("Guard")
				   || (targetCharStatus.BaseStateInfo.IsTag("Guard") && Random.value > 0.95f)))
				{
					if(Random.Range(0, 100) < attackRatio)
					{
						if(!holdingThrowable)
						{
							// Attempt a grab. Grabs are done by moving slightly.
							if(canUseGrabs && _charItem.ItemHolding == null && anim.GetFloat("Move") > 0.2f && Random.value > 0.7f)
								_charAttacking.AttackSetup(3, 0); // Attempt grab.
							else
							{
								int attackUsed = 1;
								if(anim.GetFloat("Move") > 0.94f)
									attackUsed = 2; // If moving too fast, go for the slide attack.
								float vDir = 0;
								// If we are next to an itemStorer, we will use our
								// low attack and kick it.
								if(detectionRadius.NextToItemStorer && detectionRadius.inCloseRangeChar.Count == 0)
									vDir = -1;
								_charAttacking.AttackSetup(attackUsed, vDir);
							}
						}
						// If we are holding a throwable, then throw it!
						else _charItem.Throw();
					}
				}
			}
			else // They aren't vulnerable so a random chance to retreat below.
				// if they aren't simply dodging.
			{
				if(!targetCharStatus.BaseStateInfo.IsTag("Dodging"))
					if(Random.Range(0f, 20f) > 19f)
						aiState = AIStates.Retreat;
			}
		}
	}

 void Stabalize()
 {
     if (_currentAIState == AIStates.PARALYZED)
     {
         if (Time.time > stablizeTime + stablizeCooldown)
         {
             stablizeTime = Time.time;
             rb.velocity = Vector3.zero;
             rb.angularVelocity = Vector3.zero;
             _currentAIState = AIStates.DECIDING;
         }
     }
     else if (_currentPlayingState == PlayingState.STUNNED)
     {
         if (Time.time > playStablizeTime + playStablizeCooldown)
         {
             playStablizeTime = Time.time;
             rb.velocity = Vector3.zero;
             rb.angularVelocity = Vector3.zero;
             _currentPlayingState = PlayingState.SETTING_UP;
         }
     }
 }

        /// <summary>
        /// ProcessHit gets the last hit location coordinates and will ask AddTarget to
        /// create targets around that location by calling the method four times each time with
        /// a new location around the last hit location.
        /// It will then set the state of the AI and if it's not Searching or targetingShip then
        /// start ReOrderTargets.
        /// </summary>
        /// <param name="row"></param>
        /// <param name="col"></param>
        private void ProcessHit(int row, int col)
        {
            _LastHit.Add(_CurrentTarget);

            //Uses _CurrentTarget as the source
            AddTarget(row - 1, col);
            AddTarget(row, col - 1);
            AddTarget(row + 1, col);
            AddTarget(row, col + 1);

            if (_CurrentState == AIStates.Searching)
            {
                _CurrentState = AIStates.TargetingShip;
            }
            else
            {
                //either targetting or hitting... both are the same here
                _CurrentState = AIStates.HittingShip;

                ReOrderTargets();
            }
        }

        void CheckParalyze()
        {
            if (rb.velocity != Vector3.zero && rb.angularVelocity != Vector3.zero)
            {
                if (_currentAIState == AIStates.PLAYING)
                    _currentPlayingState = PlayingState.STUNNED;
                else
                    _currentAIState = AIStates.PARALYZED;

            }

            //_currentAIState = AIStates.IDLING;
        }

        //Pet bobs around a point.
        void Idle()
        {
            switch (_currentIdleState)
            {
                case IdleState.NONE:
                    break;
                case IdleState.RECORDING_POSITON:
                    lastLocation = transform.position;
                    _currentIdleState = IdleState.DOIN_MY_THANG;
                    break;
                case IdleState.DOIN_MY_THANG:
                    transform.position = new Vector3(transform.position.x,lastLocation.y + ((float)Math.Sin(Time.time) / floatingStrength),transform.position.z);
                    idleTimeLeft -= Time.deltaTime;
                    if (idleTimeLeft < 0f)
                        _currentAIState = AIStates.DECIDING;

                    break;
            }
            //Currently Only Moves Up and Down.
        }

    // States: Wander, Persue, Idle
    void StateMachine()
    {
        // Debug.Log("statemachine being called at time " + Time.time);
        //Debug.Log(string.Format("at time {0} the state is {1}", Time.time, state));
        checkRoomInvasion();
        switch(state) {
            case AIStates.WANDER:
                if(goalPoint == null) {
                    selectRandomState();
                    chooseNewGoal();
                    return;
                }
                if(currentSquare.Equals(goalPoint)) {
                    // you done!
                    // choose a new state and return
                    //     Debug.Log("we have moved into the goal square so we are calculating a new square to wander to");
                    selectRandomState();
                    chooseNewGoal();
                    cleanPathNodes();
                    findPath();
                    //      Debug.Log(goalPoint);
                    return;
                }
                // sets the current square to not holding this character anymore in anticipation for the move
                // then choose a square that advances the ai towards the target square

                currentSquare = findNextMove();
                updateLocation();
                break;
            case AIStates.PERSUE:
             //   Debug.Log("You GETTIN CHASED");
                foreach(GameObject square in persueRoom) {
                    if(squareContainsPlayer(square)) {
                        // we do a persuit
                        goalPoint = square;
                        cleanPathNodes();
                        findPath();
                        currentSquare = findNextMove();
                        updateLocation();
                        return;
                    }
                }
                selectRandomState();
                // this is not in use for now
                // selectRandomState();
                break;
            case AIStates.IDLE:
                state = AIStates.WANDER;
                goalPoint = null;
                break;
            default:
                break;
        }
    }

 // Use this for initialization
 void Start()
 {
     myState = AIStates.Roaming;
 }

 public override AIStates OnGetHit( Mobile by, AIStates AIState, int dmg )
 {
     if ( by != summonedFrom && AIState != AIStates.Attack && AIState != AIStates.Fighting )
         return AIStates.BeingAttacked;
     return AIState;
 }

    // Update is called once per frame
    void Update()
    {
        switch(currentState) {

        case AIStates.MOVING_RIGHT:
            transform.Translate(new Vector3(moveSpeed * Time.deltaTime, 0, 0), Space.World);

            if(transform.position.x - player.position.x > 5)
                currentState = AIStates.MOVING_LEFT;

            break;

        case AIStates.MOVING_LEFT:
            transform.Translate(new Vector3(-moveSpeed * Time.deltaTime, 0, 0), Space.World);

            if(transform.position.x - player.position.x < -5) {
                // Set up the swoop info
                startPosition = transform.position;
                endPosition = player.transform.position;
                swoopCenter = player.transform.position;
                swoopCenter.y = transform.position.y; // above the player at the bee's level

                startSwoop = startPosition - swoopCenter;
                endSwoop = endPosition - swoopCenter;

                currentState = AIStates.SWOOPING_DOWN;
            }

            break;

        case AIStates.SWOOPING_DOWN:
            swoopTime += Time.deltaTime;
            transform.position = Vector3.Slerp(startSwoop, endSwoop, swoopTime * 2);
            transform.position += swoopCenter;
            if(swoopTime > 0.5f) {
                swoopTime = 0.0f;

                // Calculate second half of swoop
                Vector3 temp = startPosition;
                startPosition = endPosition;
                endPosition = temp + new Vector3(10, 0, 0);

                startSwoop = startPosition - swoopCenter;
                endSwoop = endPosition - swoopCenter;

                currentState = AIStates.SWOOPING_UP;
            }

            break;

        case AIStates.SWOOPING_UP:
            swoopTime += Time.deltaTime;
            transform.position = Vector3.Slerp(startSwoop, endSwoop, swoopTime * 2);
            transform.position += swoopCenter;
            if(swoopTime > 0.5f) {
                swoopTime = 0.0f;

                currentState = AIStates.MOVING_LEFT;
            }

            break;
        default:
            break;

        }

        switch(currentHealth) {
        case 3:
            transform.Find("MeanBee").renderer.material.mainTexture = beeTextures[0];
            break;
        case 2:
            transform.Find("MeanBee").renderer.material.mainTexture = beeTextures[1];
            break;
        case 1:
            transform.Find("MeanBee").renderer.material.mainTexture = beeTextures[2];
            break;
        default:
            // Empty the bar, then destroy the Bee object
            Destroy(beeHealthBarFill);
            Destroy(gameObject);
            break;

        }
    }

 // Use this for initialization
 void Start()
 {
     currentHealth = MAX_HEALTH;
     _pixelInset = beeHealthBarFill.pixelInset;
     currentState = AIStates.MOVING_RIGHT;
 }