/// <summary>
        /// Determines whether this instance is satisfied.
        /// </summary>
        /// <param name="state">The state of the AI.</param>
        /// <returns></returns>
        /// <exception cref="System.Exception">Invalid equality type in IntCondtion.IsSatisfied().</exception>
        public override bool IsSatisfied(AIState state)
        {
            var value = state.GetInt(ID);

            if (!value.HasValue)
            {
                return false;
            }

            switch (Equality)
            {
                case EqualityType.Equals:
                    return value == Value;
                case EqualityType.NotEquals:
                    return value != Value;
                case EqualityType.GreaterThan:
                    return value > Value;
                case EqualityType.LessThan:
                    return value < Value;
                case EqualityType.GreaterThanOrEqual:
                    return value >= Value;
                case EqualityType.LessThanOrEqual:
                    return value <= Value;
                default:
                    throw new Exception("Invalid equality type in IntCondtion.IsSatisfied().");
            }
        }

        public override void Collided()
        {
            switch (State)
            {
                case AIState.Patrolling:
                    Target = Position;
                    break;
                case AIState.Chasing:
                    Target = Position;
                    State = AIState.FollowingPath;
                    break;
                case AIState.FollowingPath:
                    Target = Position;
                    regeneratePath = true;
                    break;
                case AIState.Attacking:
                    Target = Position;
                    //if ((Target - Position).Length() > 100f)
                    //{
                    //    Target = Position;
                    //    State = AIState.FollowingPath;
                    //    regeneratePath = true;
                    //}
                    break;
            }

            base.Collided();
        }

 public void Reset()
 {
     transform.position = m_Player.transform.position + (-m_Player.transform.forward * m_DistanceFromPlayer);
     m_Activated = false;
     m_IsMoving = false;
     m_State = AIState.IDLE;
 }

 //couroutine change AI state with a delay time
 IEnumerator ChangeAIStateDelay(AIState state, float time)
 {
     yield return new WaitForSeconds(time);
     currentState = state;
     iceChunkTimer = 1.0f;
     StopCoroutine("ChangeAIStateDelay");
 }

 public void guard()
 {
     releaseAI();
     state = AIState.guard;
     guardPos.parent = null;
     ai.followTranform = guardPos;
 }

 public void releaseAI()
 {
     state = AIState.free;
     guardPos.parent = transform;
     guardPos.localPosition = Vector3.zero;
     ai.followTranform = null;
 }

   public Enemy(String aiName,
       Vector2 position)
       : base(position, 
       Vector2.Zero, 
       Vector2.Zero, 
       new Vector2(MAX_VELOCITY_X, MAX_VELOCITY_Y),
       new Vector2(ACCELERATION_X, ACCELERATION_Y), 
       new Vector2(DECELERATION_X, DECELERATION_Y),
       TextureManager.GetTexture(TextureNames.PLAYER_TWO_IDLE))
   {
       behaviour = new AIStateMachine(XMLFILE, aiName);
       currentState = behaviour.GetCurrentState();
       
 
       // These should be loaded from either XML
       // or be statics in child-classes specific
       // to types of AIs.
       moveTime = new ParameterDouble();
       moveTime.alpha = 500;
       moveTime.beta = 500;
       moveTime.distribution = Distribution.Normal;
       // Temporary:
       timeBetweenFire = new ParameterDouble();
       timeBetweenFire.alpha = 1000;
       timeBetweenFire.beta = 1000;
       timeBetweenFire.distribution = Distribution.Normal;
   }

	// Use this for initialization
	void Start ()
	{
		initPos = transform.position;
		anim = gameObject.GetComponent<Animation> ();
		aiState = AIState.Idle;

	}

 /**
  * Constructor for manually-initialized AISMs
  **/
 public AIStateMachine(String aiName, int numStates, AIState[] stateNames, double[][] tmatrix)
 {
     machineName = aiName;
     rtransition = new Random();
     StateNames = new List<AIState>(numStates);
     TransitionMatrix = new Double[numStates][];
     Initialize(numStates, stateNames, tmatrix);
 }

    /// <summary>
    /// Forgets the old state and starts a new one.
    /// </summary>
    public void SwitchState(AIState state)
    {
        if (CurrentState != null)
            stateStack.Pop().OnStop(actor);

        stateStack.Push(state);
        state.OnStart(actor);
    }

	public AICohere(AIState state, Transform obj, float weight){
		trans = obj;
		go = new GameObject();
		average = go.transform;
		this.State = state;
		this.Weight = weight;
		Targets = new Transform[]{};
	}

 //init upon enabled, called faster than Start func
 void Awake()
 {
     origPos = transform.position;
     iceChunkArr = new GameObject[3];
     currentState = AIState.state_Spawn_Self;
     iceChunkTimer = 1.0f;
     iceChunkPooler = transform.FindChild("iceChunkPooler");
 }

        public Gateway(Game game, GraphicsDeviceManager graphics, Vector2 location)
            : base(game, graphics, "content/gateway", true)
        {
            this.mLocation = location;

            Random r = new Random();
            mCurrentState = (AIState)r.Next(0, 2);
        }

 public void PuckCollision()
 {
     if (state == AIState.Attack)
     {
         state = AIState.Defense;
         thinkTimer = 0.0f;
     }
 }

	// Use this for initialization
	void Start ()
	{
		initPos = transform.position;
		anim = gameObject.GetComponent<Animation> ();
		aiState = AIState.Idle;
		anim["Jump1"].speed = 2;
		anim["Jump2"].speed = 2;
		anim["Jump3"].speed = 2;
	}

        public AiStateMachine(Enemy owner, AIState constState, AIState startState)
        {
            this.owner = owner;
            this.constState = constState;
            this.dynamicState = startState;

            constState.Enter(owner);
            dynamicState.Enter(owner);
        }

 void Awake()
 {
     currentState = AIState.state_Spawn_self;
     leafPadPooler = transform.FindChild("leafPadPooler");
     leafPadArr = new GameObject[4];
     cannabisController = GetComponent<Animator>();
     theSmoke = Instantiate(smoke, Vector2.zero, Quaternion.identity) as GameObject;
     theSmoke.SetActive (false);
 }

 public static AISubstate[] GetSubstates(AIState parent)
 {
     AISubstate[] substates = new AISubstate[3];
     substates[0] = new AISubstate_GetSpace(parent);
     substates[1] = new AISubstate_GetBehind(parent);
     substates[2] = new AISubstate_Chase(parent); //maybe add missile lock state, maybe make it parallel
     //substates[3] = new AISubstate_AttackEvade --> if shit hits the fan can add a straight up evasion goal, cancelling attack.
     //if threat is tolerable blend attack vector with evasion vector. contains substates
     //substates[4] = new AISubstate_AttackAvoidCollision --> similar to AttackEvade
     return substates;
 }

        public ShipAI(Vector2 position, BulletManager bulletManager)
            : base(position, bulletManager)
        {
            _state = AIState.Wandering;
            MovementController.Rotation = _gen.Next(0, 360);
            StatRecorder = new AIShipStatRecorder(this);
            SeekingShip = -1;
            Name = "CPU" + ID;

            LevelManager.OnLevel += CheckReset;
        }

 public AISubstate(AIState parentState)
 {
     this.parentState = parentState;
     this.pilot = parentState.pilot;
     this.entity = parentState.pilot.entity;
     this.transform = entity.transform;
     this.sensorSystem = entity.sensorSystem;
     this.engineSystem = entity.engineSystem;
     this.weaponSystem = entity.weaponSystem;
     this.commSystem = entity.commSystem;
     this.navSystem = entity.navSystem;
 }