/// <summary>
    /// Sets the new actor  that is being controlled
    /// </summary>
    /// <param name="rActor"></param>
    public void SetActor(ActorController rActor)
    {
        if (rActor == null) { return; }

        if (Actor != null)
        {
            ActorDriver lOldDriver = Actor.gameObject.GetComponent<ActorDriver>();
            if (lOldDriver != null) { lOldDriver.IsEnabled = false; }
        }

        ActorDriver lNewDriver = rActor.gameObject.GetComponent<ActorDriver>();
        if (lNewDriver != null) { lNewDriver.IsEnabled = true; }

        Actor = rActor;

        if (mCameraRig != null)
        {
            mCameraRig.Anchor = Actor.transform;
        }
        else if (mCamera != null)
        {
            mCamera.transform.parent = Actor.transform;
            mCamera.transform.localPosition = new Vector3(0f, 1.5f, -4f);

            Vector3 lLookTarget = Actor.transform.position + (Actor.transform.up * 1f);
            mCamera.transform.rotation = Quaternion.LookRotation(lLookTarget - mCamera.transform.position, Actor.transform.up);
        }

        if (mActorText != null && mActorDescriptions.ContainsKey(rActor.gameObject.name))
        {
            mActorTextTimer = 0f;
            mActorText.text = mActorDescriptions[rActor.gameObject.name];
            mActorText.enabled = true;
        }
    }

	protected override void OnInvokeStart()
	{
		base.OnInvokeStart();

		controller = source.GetComponent<ActorController>();
		controller.actor.body.SetAnimatorThrow();
    }

 public static ActorController FindMinDistEnemy(ActorController actor, float findDist)
 {
     if (actor == null)
     {
         return null;
     }
     float num = 3.40282347E+38f;
     ActorController result = null;
     List<ActorController> actors = Globals.Instance.ActorMgr.Actors;
     for (int i = 0; i < actors.Count; i++)
     {
         ActorController actorController = actors[i];
         if (actorController && !actorController.IsDead && (!actorController.IsImmunity || actorController.ActorType != ActorController.EActorType.EMonster) && actor.IsHostileTo(actorController))
         {
             float num2 = actor.GetDistance2D(actorController);
             if (num2 <= findDist)
             {
                 if (actorController.ActorType == ActorController.EActorType.EPlayer)
                 {
                     num2 *= 1.5f;
                     if (num2 < 1.5f)
                     {
                         num2 = 1.5f;
                     }
                 }
                 if (num2 < num)
                 {
                     num = num2;
                     result = actorController;
                 }
             }
         }
     }
     return result;
 }

 protected void DoInstantiate(ActorController actor, string socketName, bool onlyUseSocketPosition)
 {
     this.DoInstantiate(actor);
     if (this.go != null && !string.IsNullOrEmpty(socketName))
     {
         GameObject gameObject = ObjectUtil.FindChildObject(actor.gameObject, socketName);
         if (gameObject == null)
         {
             return;
         }
         if (onlyUseSocketPosition)
         {
             this.go.transform.position = gameObject.transform.position;
         }
         else
         {
             Transform transform = this.go.transform;
             transform.parent = gameObject.transform;
             transform.localPosition = Vector3.zero;
             transform.localRotation = Quaternion.identity;
             transform.localScale = Vector3.one;
             actor.AddPoolSocket(transform);
         }
     }
 }

	protected override void OnInvokeStart()
	{
		base.OnInvokeStart();

		controller = source.GetComponent<ActorController>();
        controller.actor.Turn(angleDegrees);
    }

	protected override void OnInvokeStart()
	{
		base.OnInvokeStart();

		controller = target.GetComponent<ActorController>();
		controller.actionLocked = true;
	}

	protected override void OnInvokeStart()
	{
		base.OnInvokeStart();

		controller = source.GetComponent<ActorController>();
        controller.actor.physics.velocity += Vector3.up * force;
		AudioManager.Instance.PlayOneShot(controller.actor.audioSource, AudioManager.Instance.jump);
    }

	protected override void OnInvokeStart()
	{
		base.OnInvokeStart();

		controller = source.GetComponent<ActorController>();
        Ball ball = Field.Instance.ball;
        controller.actor.TryTakePossession(ball, this.range);
    }

	protected override void OnInvokeStart()
	{
		base.OnInvokeStart();

        controller = source.GetComponent<ActorController>();
        controller.actor.body.SetAnimatorThrow();
        Ball ball = Field.Instance.ball;
        controller.actor.TrySwatBall(ball, this.range, this.yRange);
    }

 public static void ChangeControllerGloss(ActorController controller, Color color, float gloss, float lerp, float hold)
 {
     List<CharacterMeshInfo> meshInfos = controller.MeshInfos;
     for (int i = 0; i < meshInfos.Count; i++)
     {
         CharacterMeshInfo characterMeshInfo = meshInfos[i];
         characterMeshInfo.ChangeToColor(color, gloss, lerp, hold);
     }
 }

 public void SetTarget(ActorController target, float attackDistance)
 {
     if (this.Target != null)
     {
         this.Target.AiCtrler.ReleaseChaser(this.actorCtrler);
     }
     this.Target = target;
     this.distance = attackDistance;
 }

 public void Init(ActorController target)
 {
     if (target == null)
     {
         return;
     }
     this.mTargetUnit = target;
     this.mSizeY = ((!(this.mTargetUnit.collider == null)) ? this.mTargetUnit.collider.bounds.size.y : 0f);
     this.Show();
 }

 public void RequestShow(ActorController actor, EShowType showType, int value = 0, string text = null, int type = 0)
 {
     ShowData showData = new ShowData();
     showData.actor = actor;
     showData.showType = showType;
     showData.type = type;
     showData.value = value;
     showData.text = text;
     this.textLists.Add(showData);
 }

    //List<Collider> ignore = new List<Collider>();
    // Use this for initialization
    void Start()
    {
        Messenger.AddListener("start_voyage", SetCanRepel);

        capsuleCollider = GetComponent<CapsuleCollider>() as CapsuleCollider;

        actorController = transform.gameObject.GetComponent<ActorController>();

        health = transform.GetComponent<Health>() as Health;

        //InvokeRepeating("CheckContact", 0, 0.05f);
    }

        /// <summary>
        /// Once the objects are instanciated, awake is called before start. Use it
        /// to setup references to other objects
        /// </summary>
        protected virtual void Awake()
        {
            // Grab the actor controller so we can set it's values later
            mActorController = gameObject.GetComponent<ActorController>();

            // Object that will provide access to the keyboard, mouse, etc
            if (InputSourceOwner != null) { mInputSource = InterfaceHelper.GetComponent<IInputSource>(InputSourceOwner); }

            // Default speed we'll use to rotate. To help smooth out the rotation,
            // We make it consistant even in low frame rates, by set the standard to be a
            // rotation if we're running at 60 frames per second. 
            mDegreesPer60FPSTick = RotationSpeed / 60f;
        }

 public void SetInfoLabel(ActorController actor, string strBoxInfo)
 {
     if (actor != null)
     {
         float num = (!(actor.gameObject.collider == null)) ? ((BoxCollider)actor.gameObject.collider).size.y : 0f;
         float y = actor.transform.position.y + num * actor.transform.localScale.y + 0.4f;
         this.initPosition = actor.transform.position;
         this.initPosition.y = y;
         Vector3 position = GameUIManager.mInstance.uiCamera.camera.ViewportToWorldPoint(Camera.main.WorldToViewportPoint(this.initPosition));
         position.z = 0f;
         base.transform.position = position;
         this.mInfo.text = strBoxInfo;
     }
 }

 public override void OnFindEnemy(ActorController enemy)
 {
     base.OnFindEnemy(enemy);
     if (!this.dialog)
     {
         this.dialog = true;
         base.StopAttack();
         this.AllActorStop();
         if (GameUIManager.mInstance.ShowPlotDialog(1002, new GUIPlotDialog.FinishCallback(this.DialogFinish), null))
         {
             Globals.Instance.ActorMgr.Pause(true);
         }
     }
 }

 public bool SetAttackTarget(ActorController _target, int _skillIndex, bool _focusTarget)
 {
     if (_target == null || _target.IsDead)
     {
         return true;
     }
     this.target = _target;
     this.skillIndex = _skillIndex;
     this.focusTarget = _focusTarget;
     this.actorCtrler.AiCtrler.Locked = true;
     if (this.focusTarget)
     {
         Globals.Instance.ActorMgr.SetSelectTarget(_target);
     }
     return this.TryTestGoal();
 }

 public void InitWithActorController(ActorController target, string content, float showTime)
 {
     if (target == null)
     {
         return;
     }
     if (this.mContentDesc == null)
     {
         this.CreateObjects();
     }
     this.mContentDesc.text = content;
     this.mTargetUnit = target;
     this.mSizeY = ((!(this.mTargetUnit.collider == null)) ? this.mTargetUnit.collider.bounds.size.y : 0f);
     this.mShowTipTimer = showTime;
     this.Show();
 }

 public void AttackTarget(ActorController target, int skillIndex, bool focusTarget = true)
 {
     if (this.curGoal != null)
     {
         this.curGoal.OnInterrupt();
         this.curGoal = null;
     }
     if (this.attackTargetGoal == null)
     {
         this.attackTargetGoal = new GoalAttackTarget(this.actorCtrler);
     }
     if (!this.attackTargetGoal.SetAttackTarget(target, skillIndex, focusTarget))
     {
         this.curGoal = this.attackTargetGoal;
     }
 }