public override ActionResult Execute(RAIN.Core.AI ai)
    {
        Animator animator = ai.Body.GetComponent<Animator>();
        animator.SetBool("run", true);

        NavMeshAgent myAgent = ai.Body.GetComponent<NavMeshAgent>();
        Vector3 myDestiny = ai.WorkingMemory.GetItem<Vector3>("destination");
        Vector3 myPos = ai.Body.transform.position;

        float distance = Vector3.Distance(myPos, myDestiny);
        float myRadius = ai.Body.GetComponent<CapsuleCollider>().radius;

        //Debug.Log ("distance" + distance);
        //Debug.Log ("my rad" + myRadius);
        //Debug.Log ("-------------------------------------");

        //if the cop has reached his destination, search for a bit
        if(distance < 1 ){
            ai.WorkingMemory.SetItem<bool>("isSearching", true);
            //ai.WorkingMemory.SetItem<bool>("hasDestination", false);
            //Debug.Log ("MOVE ON TO SEARCHING");
            return ActionResult.SUCCESS;
        }

        return ActionResult.RUNNING;
    }

 public override ActionResult Execute(RAIN.Core.AI ai)
 {
     ai.Motor.Stop ();
     VariableManager.StartInteractingWithPlayer (ai);
     //Vector3 targetPosition = ai.WorkingMemory.GetItem<Vector3>("player") - ai.Body.transform.forward;
     return ActionResult.SUCCESS;
 }

 public override ActionResult Execute(RAIN.Core.AI ai)
 {
     _Time = _Time + Time.deltaTime;
     float phase = Mathf.Sin(_Time / _Period);
     ai.Kinematic.Rotation = new Vector3(0, phase * _Angle, 0);
     return ActionResult.SUCCESS;
 }

 public override ActionResult Execute(RAIN.Core.AI ai)
 {
     NPC npc=  ai.Body.GetComponent<NPC>();
     npc.AnimRange=NPC.AI_ANIM_ATTACK_BASH;
     //gob.executeAttack();
     return ActionResult.SUCCESS;
 }

    public override ActionResult Execute(RAIN.Core.AI ai)
    {
        if (!targetObject)
            return ActionResult.FAILURE;

        //Resource 를 Target 에 전달
        GameObject agent = ai.Body;
        Component cpnt = agent.GetComponent<CInventory>();

        if (cpnt)
        {
            ArrayList item = ((CInventory)cpnt).PopItem("Resource");

            cpnt = targetObject.GetComponent<CInventory>();
            if (cpnt)
            {
                ((CInventory)cpnt).AddItem("Resource", item);
            }
        }
        else
        {
            return ActionResult.FAILURE;
        }

        return ActionResult.SUCCESS;
    }

 public override void Start(RAIN.Core.AI ai)
 {
     R = Random.Range (0.0f, 1.0f);
     G = Random.Range (0.0f, 1.0f);
     B = Random.Range (0.0f, 1.0f);
     base.Start(ai);
 }

 public override ActionResult Execute(RAIN.Core.AI ai)
 {
     //ai.WorkingMemory.GetItem<Vector3>("moveStartPoint");
     ai.WorkingMemory.SetItem<Vector3>("MoveTarget",ai.WorkingMemory.GetItem<Vector3>("moveStartPoint"));
     //ai.WorkingMemory.SetItem<bool>("isMovingRandom",false);
     return ActionResult.SUCCESS;
 }

    public override ActionResult Execute(RAIN.Core.AI ai)
    {
        GameObject agent = ai.Body;
        Vector2 target = ai.WorkingMemory.GetItem<Vector2>("WanderTarget");
        Vector2 position = agent.transform.position;

        if (position != beforePos)
        {
            return ActionResult.FAILURE;
        }

        Vector2 move = (target - position).normalized * moveSpeed * ai.DeltaTime;
        agent.transform.Translate(move);                
        ai.Motor.UpdateMotionTransforms();
        beforePos = agent.transform.position;
        
        if ( (position - target).magnitude < 0.1f)
        {
            return ActionResult.SUCCESS;
        }
        else
        {
            return ActionResult.RUNNING;
        }
    }

    public override void Start(RAIN.Core.AI ai)
    {
        base.Start(ai);

        _lastRunning = 0;
        m_TurretController = ai.Body.GetComponent<TurretController>();
    }

 public override void Start(RAIN.Core.AI ai)
 {
     base.Start(ai);
     m_Angle = 0.0f;
     m_TurretController = ai.Body.GetComponent<TurretController>();
     m_Turret = m_TurretController.m_ShellSpawner.transform.parent.gameObject;
 }

    public override ActionResult Execute(RAIN.Core.AI ai)
    {
        _allMatches = suspects.Evaluate<IList<RAIN.Entities.Aspects.RAINAspect>>(ai.DeltaTime, ai.WorkingMemory);
        if (_allMatches == null || _hellephant == null)
        {
            ai.WorkingMemory.SetItem<GameObject>(boyObject.VariableName, null);
            return ActionResult.FAILURE;
        }
        AIRig attackedAI = _hellephant.GetComponentInChildren<AIRig>();
        _attacker = attackedAI.AI.WorkingMemory.GetItem<GameObject>("attacker");

        GameObject result = null;
        Debug.Log("isIn:\n\tCount: " + _allMatches.Count);
        foreach (RAIN.Entities.Aspects.RAINAspect aspect in _allMatches)
        {
            Debug.Log("isIn:\n\tTAG: " + aspect.Entity.Form.tag);
            if (aspect.Entity.Form.GetInstanceID() == _attacker.GetInstanceID())
            {
                result = _attacker;
                break;
            }
        }
        ai.WorkingMemory.SetItem<GameObject>(boyObject.VariableName, result);
        return ActionResult.SUCCESS;
    }

 public override ActionResult Execute(RAIN.Core.AI ai)
 {
     if( ai.Body.GetComponent<Passant>().sceneLeader.GetComponent<Musicien>()!=null)
         return ActionResult.SUCCESS;
     else
         return ActionResult.FAILURE;
 }

 public override void Start(RAIN.Core.AI ai)
 {
     //Change the FOV Color
     FOV2DVisionCone FOV = ai.Body.transform.Find("FOV2D").GetComponent<FOV2DVisionCone>();
     FOV.status = FOV2DVisionCone.Status.Idle;
     base.Start(ai);
 }

    public override ActionResult Execute(RAIN.Core.AI ai)
    {
        RAINSensor sensor = ai.Senses.GetSensor("AttackRangeSensor");

        Vector3 targetPos = TargetPos.Evaluate<Vector3>(ai.DeltaTime, ai.WorkingMemory);
        float speed = MoveSpeed.Evaluate<float>(ai.DeltaTime, ai.WorkingMemory);
        float range = Range.Evaluate<float>(ai.DeltaTime, ai.WorkingMemory);

        float distanceToTarget = Vector3.Distance(ai.Body.transform.position, targetPos);
        if (distanceToTarget > range)
        {
            Vector3 dirToTarget = targetPos - ai.Body.transform.position;
            dirToTarget *= range/dirToTarget.magnitude;
            ai.Motor.Speed = speed;
            ai.Motor.MoveTo(ai.Body.transform.position + dirToTarget);
            m_TurretController.TurnTurretForward();
        }
        else
        {
            targetPos.y = m_TurretController.Turret.transform.position.y;
            m_TurretController.TurretLookAt(targetPos);
        }

        return ActionResult.SUCCESS;
    }

    public override RAIN.Action.Action.ActionResult Execute(RAIN.Core.Agent agent, float deltaTime)
    {
        SetVariables(agent);
        if(isPlayer == 1)
            return RAIN.Action.Action.ActionResult.SUCCESS;
        /*if(unit == null)
            unit = agent.Avatar.GetComponent<Unit>();
        Unit nearestEnemy = unit.DetectEnemies(agent,enemy);
        if(nearestEnemy != null)
        {
            unit.Shoot(agent,deltaTime,nearestEnemy);
        }

        if(orders == Order.stop)
        {
            agent.MoveTo(agent.Avatar.transform.position,deltaTime);
            return RAIN.Action.Action.ActionResult.FAILURE;
        }*/
        /*Transform target = unit.GetMoveTarget();
        if(target != null)
        {

            //agent.MoveTo(agent.Avatar.transform.position,deltaTime);
            //return RAIN.Action.Action.ActionResult.FAILURE;
        }*/
        //if(agent.MoveTo(target.position,deltaTime))
            return RAIN.Action.Action.ActionResult.SUCCESS;
        //return RAIN.Action.Action.ActionResult.RUNNING;
    }

 public override ActionResult Execute(RAIN.Core.AI ai)
 {
     if (ai.WorkingMemory.GetItem<GameObject>("target") != null)
         return ActionResult.SUCCESS;
     else
         return ActionResult.FAILURE;
 }

 // Action RAIN pour faire appel à la fonction correspondante du passant
 public override ActionResult Execute(RAIN.Core.AI ai)
 {
     ai.Body.GetComponent<Passant>().SelectAndEnterScene();
     ai.WorkingMemory.SetItem<bool>("destinationReached", true);// si le passant entre dans une scène on considère qu'il a atteint sa destination
     ai.WorkingMemory.SetItem<bool>("moving", false); // booléen moving utilisé pour les mouvements hors scene
     return ActionResult.SUCCESS;
 }

 public override ActionResult Execute(RAIN.Core.AI ai)
 {
     if ((Physics2D.Raycast(origen_up_left, new Vector2(0, distancia), distancia) ||
         Physics2D.Raycast(origen_up_right, new Vector2(0, distancia), distancia)) &&
         ai.WorkingMemory.GetItem<string>("direccion") != "down")
     {
         return ActionResult.SUCCESS;
     }
     else if ((Physics2D.Raycast(origen_down_left, new Vector2(0, -distancia), distancia) ||
             Physics2D.Raycast(origen_down_right, new Vector2(0, -distancia), distancia)) &&
             ai.WorkingMemory.GetItem<string>("direccion") != "up")
     {
         return ActionResult.SUCCESS;
     }
     else if ((Physics2D.Raycast(origen_right_up, new Vector2(distancia, 0), distancia) ||
             Physics2D.Raycast(origen_right_down, new Vector2(distancia, 0), distancia)) &&
             ai.WorkingMemory.GetItem<string>("direccion") != "left")
     {
         return ActionResult.SUCCESS;
     }
     else if ((Physics2D.Raycast(origen_left_up, new Vector2(-distancia, 0), distancia) ||
             Physics2D.Raycast(origen_left_down, new Vector2(-distancia, 0), distancia)) &&
             ai.WorkingMemory.GetItem<string>("direccion") != "right")
     {
         return ActionResult.SUCCESS;
     }
     else
     {
         return ActionResult.FAILURE;
     }
 }

    public override ActionResult Execute(RAIN.Core.AI ai)
    {
        if (!WanderTargetVariable.IsVariable)
            throw new Exception("The Choose Wander Position node requires a valid Wander Target Variable");

        float tWanderDistance = 0f;
        if (WanderDistance.IsValid)
            tWanderDistance = WanderDistance.Evaluate<float>(ai.DeltaTime, ai.WorkingMemory);

        if (tWanderDistance <= 0f)
            tWanderDistance = _defaultWanderDistance;

        Vector3 tDirection = new Vector3(UnityEngine.Random.Range(-1f, 1f), 0f, UnityEngine.Random.Range(-1f, 1f));
        tDirection *= tWanderDistance;

        Vector3 tDestination = ai.Kinematic.Position + tDirection;
        if (StayOnGraph.IsValid && (StayOnGraph.Evaluate<bool>(ai.DeltaTime, ai.WorkingMemory)))
        {
            if (NavigationManager.Instance.GraphForPoint(tDestination, ai.Motor.MaxHeightOffset, NavigationManager.GraphType.Navmesh, ((BasicNavigator)ai.Navigator).GraphTags).Count == 0)
                return ActionResult.FAILURE;
        }

        ai.WorkingMemory.SetItem<Vector3>(WanderTargetVariable.VariableName, tDestination);

        return ActionResult.SUCCESS;
    }

    public override ActionResult Execute(RAIN.Core.AI ai)
    {
        //Debug.Log ("SELECTTARG");
        if (target == null) {
            //Debut de la partie
            int targetIndex = Random.Range (0, ai.Body.GetComponent<Musicien>().targets.Count );
            Debug.Log(ai.Body.name + " : targetIndex : " + targetIndex);
            target = ai.Body.GetComponent<Musicien>().targets [targetIndex];

        } else {
            //pourcentage pour retour au target précédent
            float percent = Random.Range(0,100);

            //choix random du target suivant
            int targetIndex = Random.Range (0, target.GetComponent<navigationScript>().targets.Count );

            //si le target choisi est le précédent, on a un 75% de probabilités de recommencer cette action
            if (ai.Body.GetComponent<Musicien>().previousTarget == target.GetComponent<navigationScript>().targets[targetIndex] &&  percent < 75)
                return ActionResult.RUNNING;

            //set le target précédent
            ai.Body.GetComponent<Musicien>().previousTarget = target;

            //set le target actuel
            target = target.GetComponent<navigationScript>().targets [targetIndex];
        }
        ai.WorkingMemory.SetItem<bool>("destinationReached", false);
        return ActionResult.SUCCESS;
    }