public override void ActivatePusher(AI ai, int turn)
 {
     if (ActiveTurns[turn])
     {
         Board.MoveAIOnce(ai, Direction);
     }
 }

	// Use this for initialization
	public override void Initialize (AI parent)
	{
		base.Initialize(parent);
		transparent = false;
		ActionName = "AIMove";
		started = Time.time;
	}

    void ChangeAI()
    {
        AIState state = lastAI.GetNextState ();
        lastAI.Finish ();

        if (state == AIState.None)
        {
            Instantiate(Resources.Load("Prefabs/Interact"));
            Destroy(gameObject);
            return;
        }

        AI ai;
        switch (state) {
        case AIState.Stay:
            ai = new AIStay();
            break;
        case AIState.Run:
            ai = new AIRun();
        break;
        case AIState.Sit:
            ai = new AISit();
            break;
        default:
            ai = new AISit();
            break;
        }

        ai.Start(this);
        lastAI = ai;
    }

    // Use this for initialization
    void Start()
    {
        if(thoughtMan==null) thoughtMan = GameObject.Find("ThoughtManager").GetComponent<ThoughtManager>();
        myAI = GetComponent<AI> ();

        InitIdeas();
    }

    /// <summary>
    /// Reset the fade delay and grab the fader
    /// </summary>
    /// <param name="ai">The AI executing this action</param>
    public override void Start(AI ai)
    {
        base.Start(ai);

        fader = ai.Body.GetComponentInChildren<FadeToBlack>();
        fadeDelay = 5f;
    }

    private void DoAvoidance(AI ai, RAINAspect aspect)
    {
        between = ai.Kinematic.Position - aspect.Position;
        avoidVector = Vector3.Cross(Vector3.up, between);

        Vector3 avoidPoint;

        int direction = Random.Range(0, 100);

        avoidVector.Normalize();

        if(direction < 50)
            avoidVector *= -1;

        avoidPoint = GetPositionOnNavMesh(avoidVector, ai);

        if(avoidPoint == Vector3.zero)
        {
            avoidVector *= -1;
            avoidPoint = GetPositionOnNavMesh(avoidVector, ai);
        }

        if(avoidPoint == Vector3.zero)
        {
            Debug.Log("Avoid not possible!");

            // Change destination
            ai.WorkingMemory.SetItem("hasArrived", true);

            return;
        }

        ai.Motor.MoveTo(ai.Kinematic.Position + avoidPoint);
        Debug.Log (ai.Body.name + " is avoiding " + aspect.Entity.Form.name);
    }

    public override ActionResult Execute(AI ai)
    {
        //enemyObject = enemy.Evaluate(ai.DeltaTime, ai.WorkingMemory).GetValue<GameObject>();
        if( ai.WorkingMemory.GetItem("Wizard").GetValue<RAIN.Entities.Aspects.VisualAspect>() == null )
        {
            enemyObject = null;
            ai.WorkingMemory.SetItem("ShouldAttack", false );
            return ActionResult.SUCCESS;
        }
        else
            enemyObject = ai.WorkingMemory.GetItem("Wizard").GetValue<RAIN.Entities.Aspects.VisualAspect>().Entity.Form;
        if( enemyObject != null )
        {
            //if( enemyObject.GetPhotonView().isMine )
            {
                if ((int)enemyObject.GetPhotonView().owner.customProperties["Health"] <= 0 )
                {
                    ai.WorkingMemory.SetItem("ShouldAttack", false );
                }
                else
                {
                    ai.WorkingMemory.SetItem("ShouldAttack", true );
                }
            }

        }

        return ActionResult.SUCCESS;
    }

 public void Register(AI.AI ai)
 {
     if (!_AIs.ContainsKey(ai.ID))
     {
         _AIs.Add(ai.ID, ai);
     }
 }

    private void DoAvoidance(AI ai, RAINAspect aspect)
    {
        between = ai.Kinematic.Position - aspect.Position;
        avoidVector = Vector3.Cross(Vector3.up, between);

        int direction = Random.Range(0, 100);

        avoidVector.Normalize();

        if (direction < 50)
            avoidVector *= -1;

        if (!CheckPositionOnNavMesh(avoidVector, ai))
            avoidVector *= -1;

        if (!CheckPositionOnNavMesh(avoidVector, ai))
        {
            //Debug.Log("Avoid not possible!");
            return;
        }

        Vector3 destination = ai.Kinematic.Position + avoidVector;
        //ai.Motor.MoveTo(destination);
        //ai.Kinematic.Position += avoidVector;
        ai.Kinematic.Position = Vector3.Lerp(ai.Kinematic.Position, destination, 0.3f);
        ai.Motor.FaceAt(avoidVector);
    }

 public override ActionResult Execute(AI ai)
 {
     Debug.Log ("execute");
     //	Dialoguer.
     //return ActionResult.SUCCESS;
     return ActionResult.FAILURE;
 }

    /// <summary>
    /// Release the cover point on Stop
    /// </summary>
    /// <param name="ai">The AI executing the action</param>
    public override void Stop(AI ai)
    {
        //Vacate will release the cover point
        Vacate(ai);

        base.Stop(ai);
    }

    /// <summary>
    /// Executing this action just checks to make sure we have a valid cover point that we still own.
    /// </summary>
    /// <param name="ai">The AI executing the action</param>
    /// <returns>FAILURE if we don't have a valid cover point.  Otherwise this action will continue to
    /// return RUNNING.  This means you should use it in a Parallel only.</returns>
    public override ActionResult Execute(AI ai)
    {
        if ((_currentCoverPoint == null) || (_currentCoverPoint.Occupant != ai.Body))
            return ActionResult.FAILURE;

        return ActionResult.RUNNING;
    }

    public override ActionResult Execute(AI ai)
    {
		Vector3 loc = Vector3.zero;//Default
		//Create a navigation graph collection
		List<RAINNavigationGraph> found = new List<RAINNavigationGraph>();
		
		//Create a vector location based on our AI current location 
		//plus random range values for x and z coordinates
		do
		{
			loc = new Vector3(ai.Kinematic.Position.x + Random.Range(-8f, 8f),
			                  ai.Kinematic.Position.y,
			                  ai.Kinematic.Position.z + Random.Range(-8f, 8f));
			
			//We will create navigation points using the above calculated value, the AI current positon and ensure it is within the bounds of our navigation graph
			found = NavigationManager.instance.GraphsForPoints(ai.Kinematic.Position, loc, ai.Motor.StepUpHeight, NavigationManager.GraphType.Navmesh, ((BasicNavigator)ai.Navigator).GraphTags);
			
		} while ((Vector3.Distance(ai.Kinematic.Position, loc) < 2f) || (found.Count == 0)); //We want to be sure the location found is far enough away from each one we move to so we don't pick anything to close or the same one
		
		//We will define a runtime variable in the AIRigs Memory element panel. You can select this in your inspector to see the output at runtime.
		ai.WorkingMemory.SetItem<Vector3>("varMoveTo", loc);

		if(_startTime > 500f)
		{
			ai.WorkingMemory.SetItem("isSearching", false);
			_startTime = 0;
		}

        return ActionResult.SUCCESS;
    }

    /// <summary>
    /// When executing, this action checks to see if the AI "enemy" variable has a value.  If so,
    /// and if the enemy has an aimpoint aspect, that is used as the aim target.  If the aimpoint doesn't
    /// exist, then the enemy is used directly.  If neither exists, firing still occurs but aiming does not.
    /// </summary>
    /// <param name="ai">The AI executing the action</param>
    /// <returns>FAILURE if the AimAndFireElement is missing, SUCCESS otherwise</returns>
    public override ActionResult Execute(AI ai)
    {
        if (_aimAndFire == null)
            return ActionResult.FAILURE;

        //Use the AI enemy variable as the aim target
        GameObject tAimObject = ai.WorkingMemory.GetItem<GameObject>("enemy");

        //If the target exists, set the aim target
        if (tAimObject != null)
        {
            RAINAspect tAimPoint = null;

            //Look for an aimpoint aspect and use that if possible
            EntityRig tEntity = tAimObject.GetComponentInChildren<EntityRig>();
            if (tEntity != null)
                tAimPoint = tEntity.Entity.GetAspect("aimpoint");

            //Otherwise just use the enemy object plus a default height
            if (tAimPoint == null)
                _aimAndFire.SetAimTarget(tAimObject.transform.position + new Vector3(0, 1.5f, 0));
            else
                _aimAndFire.SetAimTarget(tAimPoint.Position);
        }

        //Fire away
        _aimAndFire.FireWeapon();

        return ActionResult.SUCCESS;
    }

    public override ActionResult Execute(AI ai)
    {
        if (_children.Count == 0)
        {
            return ActionResult.FAILURE;
        }

        int successes = 0;
        for (int i = 0; i < _children.Count; i++)
        {
            var result = _children[i].Run(ai);

            if (result == ActionResult.SUCCESS)
            {
                _children[i].Reset();
                successes++;
            }
            else if (result == ActionResult.FAILURE)
            {
                return ActionResult.FAILURE;
            }
        }      

        if (ai.Body.transform.position == ai.Motor.MoveTarget.Position && successes == _children.Count)
        {
            return ActionResult.SUCCESS;
        }
        return ActionResult.RUNNING;
    }

    /// <summary>
    /// Start finds and stores the AimAndFireElement
    /// </summary>
    /// <param name="ai">The AI executing the action</param>
    public override void Start(AI ai)
    {
        base.Start(ai);

        if (_aimAndFire == null)
            _aimAndFire = ai.GetCustomElement<AimAndFireElement>();
    }

 public override ActionResult Execute(AI ai)
 {
     Environment.FACTIONS f=control.faction;
     Debug.Log("Execute Movement Action: "+f);
     ai.WorkingMemory.SetItem<Transform>("movementTarget",SelectKeyLoc());
     return ActionResult.SUCCESS;
 }

    public override ActionResult Execute(AI ai)
    {
        Vector3 loc = Vector3.zero;

        List<RAINNavigationGraph> found = new List<RAINNavigationGraph>();
        do
        {
            loc = new Vector3(ai.Kinematic.Position.x + Random.Range(-5f, 5f),
                              ai.Kinematic.Position.y,
                              ai.Kinematic.Position.z + Random.Range(-5f, 5f));

            setFlushToSurface(loc);

            found = NavigationManager.Instance.GraphsForPoints(
                ai.Kinematic.Position,
                _target.Position,
                ai.Motor.StepUpHeight,
                NavigationManager.GraphType.Navmesh,
                ((BasicNavigator)ai.Navigator).GraphTags);

        } while ((Vector3.Distance(ai.Kinematic.Position, _target.Position) < 2f) || (found.Count == 0));

        ai.WorkingMemory.SetItem<Vector3>("wanderTarget", _target.Position);
        Debug.Log ("wander Target is " + _target.Position);

        return ActionResult.SUCCESS;
    }

    public string RadioDispatcher(AI cop, Transform player, float currentTime)
    {
        float firstObservedTime = cop.WorkingMemory.GetItem <float> ("FirstObservedTime");

        //Debug.Log (cop.Body.name + ": firstObservedTime = " + firstObservedTime);
        //Debug.Log (cop.Body.name + ": currentTime - firstObservedTime = " + (currentTime - firstObservedTime));
        if ((firstObservedTime != 0) && ((currentTime - firstObservedTime) > 1.0f)) {
            if (HasPlayerNotMovedFromLastObjectDetection (cop, player)) {
                //		Debug.Log (cop.Body.name + "Player is linger enough to cause suspicion. Calling dispatcher");
                RadioManager.Singleton.RadioDispatcher (cop, player, currentTime);

                //		Debug.Log ("Suspicion Level = " + StateManager.GetSuspicion());
                if (StateManager.instance.GetSuspicion () >= StateManager.MAXIMUM_SUSPICION_LEVEL) {
                    return "arrest";
                } else {
                    return "observe";
                }

            }
        }

        //Debug.Log (cop.Body.name + "did not radio dispatcher");

        return "observe";
    }

    /// <summary>
    /// Remove colliders, entity rigs, rigid bodies, and character controllers
    /// </summary>
    /// <param name="ai">The AI executing the action</param>
    /// <returns>ActionResult.SUCCESS</returns>
    public override ActionResult Execute(AI ai)
    {
        //COLLIDERS
        Collider[] activeColliders = ai.Body.GetComponents<Collider>();
        foreach (Collider tCollider in activeColliders)
            if (tCollider != null)
                GameObject.DestroyImmediate(tCollider);

        //ENTITY RIGS ARE DEACTIVATED, NOT DESTROYED
        EntityRig tEntityRig = ai.Body.GetComponentInChildren<EntityRig>();
        if (tEntityRig != null)
            tEntityRig.Entity.DeactivateEntity();

        //RIGID BODIES (only 1 expected)
        Rigidbody tRigidBody = ai.Body.GetComponent<Rigidbody>();
        if (tRigidBody != null)
            tRigidBody.isKinematic = true;

        //CHARACTER CONTROLLERS (only 1 expected)
        CharacterController tCController = ai.Body.GetComponent<CharacterController>();
        if (tCController != null)
            GameObject.DestroyImmediate(tCController);

        return ActionResult.SUCCESS;
    }