WSHCommon/Common/CommonAI/Zone/Instance/InstanceUnit.cs

using System;
using System.Collections.Generic;
using System.Text;
using CommonAI.RTS;
using CommonLang.Vector;
using CommonAI.Zone;
using CommonAI.Zone.Instance;
using CommonAI.RTS.Manhattan;
using CommonLang;
using CommonLang.Log;
using CommonAI.Zone.Formula;

using CommonAI.ZoneClient;
using CommonAI.Zone.Helper;
using CommonLang.Property;
using CommonAI.Zone.Attributes;
using CommonAI.Zone.EventTrigger;
using CommonAI.Zone.Instance.Helper;
using CommonAI.Data;
using static CommonAI.Zone.UnitInfo;
using CommonAI.data;
using CommonAI.ZoneServer.JSGModule;

namespace CommonAI.Zone.Instance
{
    abstract public partial class InstanceUnit : InstanceZoneObject
    {
        private readonly UnitInfo mInfo;
        private readonly DropItemGenerator mDropItems;

        /// <summary>
        /// 统计信息
        /// </summary>
        public IUnitStatistic Statistic { get; private set; }

        //最后一次受伤时间
        public long mLastDamageTime;
        //最后一次攻击事件
        public long mLastHitOtherTime;
        //上一次处理死亡回调时间
        public long mProcessDeadCallbackTime;

        private IFormula mFormula = TemplateManager.Factory.Formula;

        private IVirtualUnit mUnitVirtual;
        private readonly string mName;
        private int mForce = 0;
        private int mAlliesForce = 0;       // 服务器对战情况下，有盟友服务器
        private int mLevel = 0;
        private int mMoney = 0;
        private readonly bool mIsAttackRangeIncludeBodySize;
        // 当前HP
        private readonly RangeValue __mCurrentHP;
        // 当前MP
        private readonly RangeValue __mCurrentMP;
        // 当前移动速度加成
        private float __mCurrentMoveSpeedSEC = 0;
        // 攻速
        private int __mCurrentAttackSpeed = 10000;
        // 当前技能速度加成
        private float __mSkillActionSpeedRate = 0;
        // 当前快速施法速度
        private float mFastCastRate = 0;
        /// <summary>
        /// 当前单位是否地图阻挡
        /// </summary>
        private bool mIntersectMap = false;
        /// <summary>
        /// 当前单位是否单位阻挡
        /// </summary>
        private bool mIntersectObj = false;

        // 当前技能cd减少
        private float __mCurrentSkillCdReduce;

        // 控制减速，韧性
        private float __mCurrentControledTimeReduce;

        // 控制增幅
        private float __mControledTimeAdd;

        /// 单位最后死亡时间
        public long mDeadTime = 0;

        //游戏服标记字段，怪物死亡的时候，回传给游戏服
        public int gameServerFlag = 0;

        //回血
        public int recoverHP = 0;

        //随从最后一次瞬移时间
        public long petTeleportTime = 0;

        //最后一次返回召回随从操作频繁时间
        public long lastTeleportTime = 0;

        //绑定攻击玩家
        private string mBindAttackPlayerId;
        //主人id
        private long mRemoveSelfTime;
        private InstanceUnit mBindMaster;
        //检测散开间隔
        protected long mCheckAttackSpread = 0;

        /// <summary>
        /// 自动恢复计数器 
        /// </summary>
        private TimeInterval<int> mRecoveryTime = null;

        public InstanceUnit(InstanceZone zone, UnitInfo uinfo, string name, int force, int level, bool is_static_block = false, int alliesForce = 0)
            : base(zone, is_static_block)
        {
            this.mInfo = (UnitInfo)uinfo.Clone();
            this.mName = string.IsNullOrEmpty(name) ? "" : name;
            this.mIsAttackRangeIncludeBodySize = zone.Templates.CFG.OBJECT_ATTACK_RANGE_INCLUDE_BODYSIZE;
            this.mForce = force;
            this.mAlliesForce = alliesForce;
            this.mLevel = level;
            this.mIntersectMap = true;
            this.mIntersectObj = !Templates.CFG.OBJECT_NONE_TOUCH && (mInfo.BodySize > 0);
            this.mSyncInfo = new SyncUnitInfo(zone.IsHalfSync);
            this.mSyncInfo.Name = mName;
            this.mSyncInfo.TemplateID = mInfo.ID;

            this.__mCurrentHP = new RangeValue(mInfo.HealthPoint, 0, mInfo.HealthPoint);
            this.__mCurrentMP = new RangeValue(mInfo.ManaPoint, 0, mInfo.ManaPoint);
            this.__mCurrentMoveSpeedSEC = mInfo.MoveSpeedSEC;
            this.mDropItems = new DropItemGenerator(uinfo.DropItemsSet);
            this.mTriggerHelper = new UnitTriggerHelper(this);
            if (mInfo.IdleRecover && mInfo.RecoveryIntervalMS > 0)
            {
                this.mRecoveryTime = new TimeInterval<int>(mInfo.RecoveryIntervalMS);
                this.recoverHP = Info.HealthRecoveryPoint;
            }
            this.InitTimeLines();
            this.InitBagSlots();
            this.InitSkills(mInfo.BaseSkillID, mInfo.Skills.ToArray());
            this.Statistic = this.CreateUnitStatistic();
            this.mUnitVirtual = TemplateManager.Factory.CreateUnitVirtual(this);
        }

        public override bool IsNeedProcessDead()
        {
            return this.mProcessDeadTime == 0;
        }

        protected override void Disposing()
        {
            //if(this.IsMonster && (this.mProcessDeadTime == 0 || this.CurrentHP > 0 || this.mProcessDeadTime == 0))
            //{
            //	log.Info("单位Disposing：" + this.Parent.UUID + ", " + this.Parent.GetSceneID() + ", " + this.ID + ", " + this.CurrentHP + "," +
            //		this.IsMonster + ", " + mProcessDeadTime);
            //}

            if (mUnitVirtual != null)
            {
                mUnitVirtual.OnDispose(this);
            }
            base.Disposing();
            this.clearBindEvents();
            this.clearSkills();
            this.clearBuffs();
            this.clearItemSlots();
            this.clearTriggers();

            this.mNoneBlockTimeMS.Disposing();
            this.mStunTimeMS.Disposing();
            this.mInvisibleTimeMS.Disposing();
            this.mInvincibleTimeMS.Disposing();
            this.mSilentTimeMS.Disposing();
            this.mCannotMoveTimeMS.Disposing();
            this.mIgnoreControl.Disposing();

            foreach (MultiTimeLine timeLine in mMultiTimeLineGroup)
            {
                timeLine.Disposing();
            }
            this.mMultiTimeLineGroup.Clear();
            this.mMultiTimeLineGroup = null;
            this.mMultiTimeLineSync = null;
        }

        protected override void onAdded(bool pointLv)
        {
            if (this.mUnitVirtual != null)
            {
                this.mUnitVirtual.OnInit(this, pointLv);
                if (this.mRecoveryTime != null && this.Info.UType == UnitType.TYPE_MONSTER)
                {
                    this.recoverHP = Info.HealthRecoveryPoint == 0 ? (int)(this.MaxHP * 0.005f) : Info.HealthRecoveryPoint;
                }
            }

            this.mSyncInfo.ObjectID = base.ID;
            this.mSyncInfo.IsTouchObj = this.mIntersectObj;
            this.mSyncInfo.IsTouchMap = this.mIntersectMap;
            this.mSyncInfo.IsStaticBlockable = this.IsStaticBlockable;
            this.mSyncInfo.fateType = (byte)this.Virtual.GetUnitFateType();

            if (mInfo.SpawnTimeMS > 0)
            {
                this.SetInvincibleTimeMS(mInfo.SpawnTimeMS);
            }

            if (this.mInfo.InventoryList != null)
            {
                foreach (InventoryItem item in mInfo.InventoryList)
                {
                    ItemTemplate temp = Templates.getItem(item.ItemTemplateID);
                    if (temp != null)
                    {
                        AddItemToEmptyInventory(temp, item.Count);
                    }
                }
            }
            if (mInfo.Events != null)
            {
                foreach (int evt_id in mInfo.Events)
                {
                    this.BindUnitEvent(evt_id);
                }
            }

            if (mOnAdded != null)
            {
                mOnAdded.Invoke(this);
            }
        }
        protected override void onRemoved()
        {
            if (mOnRemoved != null)
            {
                mOnRemoved.Invoke(this);
            }
            foreach (UnitEventTriggerCollection uc in mBindEvents.Values)
            {
                uc.Dispose();
            }
            mBindEvents.Clear();
            if (Info.RemovedEffect != null)
            {
                Parent.queueEvent(new AddEffectEvent(0/*this.ID*/, X, Y, Direction, Info.RemovedEffect));
            }
        }

        public void BindAttackPlayer(string playerId)
        {
            this.mBindAttackPlayerId = playerId;
        }

        public string GetAttackPlayer()
        {
            return this.mBindAttackPlayerId;
        }

        public void BindMasterId(int masterId)
        {
            InstanceUnit master = this.Parent.getUnitByID(masterId);
            if (master == null)
            {
                log.Error("BindMasterId找不到单位：" + this.Parent.GetSceneID() + ", " + masterId);
                return;
            }

            if (this.mBindMaster != null)
            {
                log.Error("BindMasterId重复：" + this.Info.ID + ", " + master.PlayerUUID);
                return;
            }

            this.mBindMaster = master;
        }


        //--------------------------------------------------------------------------
        /// <summary>
        /// 扩展功能绑定接口
        /// </summary>
        public IVirtualUnit Virtual { get { return mUnitVirtual; } }
        /// <summary>
        /// 扩展数据
        /// </summary>
        public virtual IUnitProperties Properties { get { return mInfo.Properties; } }

        //--------------------------------------------------------------------------

        //--------------------------------------------------------------------------

        public UnitInfo Info { get { return mInfo; } }
        public string Name { get { return mName; } }
        public string Alias { get { return mSyncInfo.Alias; } set { if (value != null) { mSyncInfo.Alias = value; } } }
        public int Force { get { return mForce; } protected set { mForce = value; } }
        public int AlliesForce { get { return mAlliesForce; } protected set { mAlliesForce = value; } }
        public float MoveSpeedSEC { get { return __mCurrentMoveSpeedSEC; } }

        public float SkillCdReduce { get { return __mCurrentSkillCdReduce; } }
        public float ControledTimeReduce { get { return __mCurrentControledTimeReduce; } }

        public float ControledTimeAdd { get { return __mControledTimeAdd; } }

        public float FastCastRate { get { return mFastCastRate; } }
        public override float BodyBlockSize { get { return mInfo.BodySize; } }
        public override float BodyHitSize { get { return mInfo.BodyHitSize; } }
        public override float BodyHeight { get { return mInfo.BodyHeight; } }
        public override float Weight { get { return mInfo.Weight; } }
        public override bool IntersectMap { get { return mIntersectMap; } }
        public override bool IntersectObj { get { return mIntersectObj && IsVisible; } }
        public override bool Moveable { get { return mInfo.IsMoveable; } }
        public override bool ClientVisible { get { return true; } }
        public override bool SyncPos { get { return true; } }
        public override bool IsDead() { return __mCurrentHP.Value <= 0; }
        public int DeadCount { get { return Statistic.DeadCount; } }
        public long LastDeadTimeMS { get { return mDeadTime; } }
        public bool CanWhiplashDeadBody { get { return Templates.CFG.UNIT_CAN_WHIPLASH_BODY && (LastDeadTimeMS + mInfo.DeadTimeMS > Parent.PassTimeMS); } }
        /// <summary>
        /// 是否为玩家
        /// </summary>
        virtual public bool IsPlayer { get { return false; } }
        virtual public bool IsMonster { get { return false; } }
        virtual public bool IsPet { get { return false; } }
        //玩家或者宠物合集
        virtual public bool IsPlayerUnit { get { return false; } }

        virtual public void OnUnitDead() { }

        /// <summary>
        /// 是否中立
        /// </summary>
        virtual public bool IsNature { get { return false; } }
        /// <summary>
        /// 此单位是否能被攻击并且活着
        /// </summary>
        virtual public bool IsActive { get { return (__mCurrentHP.Value > 0) && (base.Enable)/*&& !IsInvincible && IsVisible*/; } }
        /// <summary>
        /// 此单位是否可以被打到，包括鞭尸
        /// </summary>
        virtual public bool IsAttackable { get { return (base.Enable) /*&& !IsInvincible && IsVisible*/; } }
        /// <summary>
        /// 此单位是否无技能
        /// </summary>
        public bool IsNoneSkill { get { return mSkillStatus.Count == 0; } }
        /// <summary>
        /// 技能可产生位移，或者多段由服务器决定
        /// </summary>
        virtual public bool IsSkillControllableByServer { get { return true; } }
        /// <summary>
        /// 单位是否可控
        /// </summary>
        virtual public bool IsControllable { get { return IsActive && !IsStun && CurrentActionStatus != UnitActionStatus.Damage; } }

        /// <summary>
        /// 用于显示的，单位横向数据
        /// </summary>
        public ZoneClient.IUnitVisibleData VisibleInfo { get { return mSyncInfo.VisibleInfo; } }


        //-----------------------------------------------------------------------------------------------------//
        protected virtual IUnitStatistic CreateUnitStatistic()
        {
            return new UnitStatistic(this);
        }

        //-----------------------------------------------------------------------------------------------------//

        #region __StateMachine__

        private bool is_init = false;
        private State current_state = null;
        private State next_state;
        private Queue<State> next_state_queue = new Queue<State>();
        /// <summary>
        /// 当前状态机
        /// </summary>
        public State CurrentState { get { return current_state; } }

        //状态机额外数据
        public long chuangongTime = 0;

        /// <summary>
        /// 下一个状态
        /// </summary>
        protected State NextState { get { return next_state; } }
        /// <summary>
        /// 死亡状态可能的状态机，一般配合<see cref="IsDead"/>使用
        /// </summary>
        public bool IsStateDead
        {
            get
            {
                if ((current_state is StateDead) ||
                    (current_state is StateDamage) ||
                    (current_state is StateDeadFuck) ||
                    (current_state is StateDeadFuckFuck) ||
                    (current_state is StateRebirth) ||
                    (next_state is StateDead) ||
                    (next_state is StateDamage) ||
                    (next_state is StateDeadFuck) ||
                    (next_state is StateDeadFuckFuck) ||
                    (next_state is StateRebirth))
                {
                    return true;
                }
                return false;
            }
        }

        public void queueState(State s)
        {
            next_state_queue.Enqueue(s);
        }

        public bool TryEnqueueIdleState()
        {
            if (next_state_queue.Count > 0)
            {
                return false;
            }
            next_state_queue.Enqueue(new StateIdle(this));
            return true;
        }

        public void queueCurrentState(State s)
        {
            if (current_state != null)
            {
                if (!changeState(s))
                {
                    State.StateStopHandler onstop = new State.StateStopHandler((obj, st) =>
                    {
                        changeState(s);
                    });
                    current_state.AddStopOnce(onstop);
                }
            }
            else
            {
                changeState(s);
            }
        }
        public bool changeState(State s, bool force = false)
        {
            if (s == current_state)
            {
                return true;
            }
            if (s == next_state)
            {
                return true;
            }
            if (s.unit != this)
            {
                throw new Exception("State is not Owner unit : " + s);
            }
            if (current_state == null || current_state.onBlock(s) || force)
            {
                if (next_state == null || next_state.onBlock(s) || force)
                {
                    if (next_state != null)
                    {
                        next_state.stop();
                    }
                    onNewStateBeginChange(current_state, ref s);
                    next_state = s;

                    return true;
                }
            }
            return false;
        }

        private void updateState()
        {
            //绑定主人类怪物，脱战或者主人移除自杀
            if (mRemoveSelfTime == 0)
            {
                if (this.mBindMaster != null && (!this.mBindMaster.IsActive || this.mBindMaster.Virtual.GetBattleStatus() <= BattleStatus.ReadyBattle))
                {
                    //添加移除逻辑
                    mRemoveSelfTime = CommonLang.CUtils.localTimeMS + 3000;
                }
            }
            else if (mRemoveSelfTime < CommonLang.CUtils.localTimeMS)
            {
                this.kill(null, false);
            }

            if (IsDead() && (!IsStateDead))
            {
                changeState(new StateDead(this, this, false), true);                
                queueEvent(new UnitDeadEvent(ID, this.ID, false, mInfo.RebirthTimeMS));

                if(this.mProcessDeadCallbackTime < CommonLang.CUtils.localTimeMS)
                {
                    log.Warn("手动调用死亡逻辑2：" + this.PlayerUUID + ", " + this.mZone.GetSceneID() + ", templateID:" + this.Info.ID + ", state: " + this.current_state);
                    Parent.cb_unitDeadCallBack(this, this);
                }
            }
            else if (next_state == null && next_state_queue.Count > 0)
            {
                // 尝试从队列中取一个状态机，有机会就执行 //
                while (next_state_queue.Count > 0)
                {
                    State queued_state = next_state_queue.Peek();
                    if (changeState(queued_state))
                    {
                        next_state_queue.Dequeue();
                    }
                    else { break; }
                }
            }
            if (next_state != null && next_state != current_state)
            {
                State old_state = current_state;
                if (old_state != null)
                {
                    old_state.stop();
                }
                this.current_state = next_state;
                this.next_state = null;
                this.current_state.start();
                this.onStateChanged(old_state, current_state);
                if (mOnStateChanged != null)
                {
                    mOnStateChanged.Invoke(this, old_state, current_state);
                }
            }
            if (current_state != null)
            {
                current_state.update();
            }

            UpdateTimeLines(Parent.UpdateIntervalMS);
        }

        #endregion


        protected virtual void onUpdateRecover()
        {
            //自动恢复  
            if (this.recoverHP > 0 && mRecoveryTime != null && this.CurrentHP < this.MaxHP && CurrentActionStatus != UnitActionStatus.Damage
                && this.Virtual.GetBattleStatus() == BattleStatus.None && !IsDead())
            {
                if (mRecoveryTime.Update(Parent.UpdateIntervalMS))
                {
                    AddHP(this.recoverHP, null);
                    //AddMP(Info.ManaRecoveryPoint);
                }
            }
        }

        override protected void onUpdate(bool slowRefresh)
        {
            if (!is_init)
            {
                is_init = true;
                onInit();
            }
            if (!IsPaused)
            {
                updatePhysical();

                updateState();

                onUpdateRecover();

                updateSkills();

                updateBuffs();

                updateTriggers(slowRefresh);

                updateItems();

                if (mOnUpdate != null)
                {
                    mOnUpdate.Invoke(this);
                }
            }
            updateSyncFields();
            updateSyncSkillActives();
        }

        internal void doAction(ObjectAction act)
        {
            this.onAction(act);
            if (mOnHandleObjectAction != null)
            {
                mOnHandleObjectAction.Invoke(this, act);
            }
        }

        private void doRebirth(int max_hp, int max_mp)
        {
            next_state_queue.Clear();
            if (this.Moveable)
            {
                this.mIntersectObj = !Templates.CFG.OBJECT_NONE_TOUCH && (mInfo.BodySize > 0);
            }
            else
            {
                this.mIntersectObj = (mInfo.BodySize > 0);
            }

            if (max_hp == 0) max_hp = this.MaxHP;
            if (max_mp == 0) max_mp = this.MaxMP;

            if (max_hp != 0) this.__mCurrentHP.SetValue(max_hp);
            if (max_mp != 0) this.__mCurrentMP.SetValue(max_mp);
            syncFields(UnitFieldChangedEvent.MASK_HP | UnitFieldChangedEvent.MASK_MP);
            Parent.cb_unitRebirthCallBack(this);
            queueEvent(new UnitRebirthEvent(ID));
        }

        public void updateContinueKills()
        {
            if (this.Statistic.continueKills < short.MaxValue)
            {
                ++this.Statistic.continueKills;
            }
            UnitContinueKillValue temp = new UnitContinueKillValue(this.ID, this.Statistic.continueKills);
            queueEvent(temp);
        }

        public void resetContinueKills()
        {
            this.Statistic.continueKills = 0;
        }

        private void doActivated()
        {
            next_state_queue.Clear();
            if (this.Moveable)
            {
                this.mIntersectObj = !Templates.CFG.OBJECT_NONE_TOUCH && (mInfo.BodySize > 0);
            }
            else
            {
                this.mIntersectObj = (mInfo.BodySize > 0);
            }
            this.addTriggers(mInfo.Triggers);
            Parent.cb_unitActivatedCallBack(this);
        }

        internal void doDead(InstanceUnit killer)
        {
            if (killer != null)
            {
                this.Statistic.LogDead(killer.Statistic);
            }

            this.mIntersectObj = false;
            this.clearBuffs();
            //吴永辉：5v5人物死亡后会重置技能CD  无论在哪个地图死亡都不能重置  你可能要指给黄鱼 bugid=2748
            //this.ClearAllSkillCD();
            this.resetAI();
        }
        //------------------------------------------------------------------------------------------------------//
        internal void callback_onActivated(InstanceZone zone)
        {
            if (this.mOnActivated != null)
                this.mOnActivated.Invoke(this);
        }
        internal void callback_onAttack(InstanceZone zone, InstanceUnit target, int reduceHP, AttackSource source)
        {
            if (this.mOnAttack != null)
                this.mOnAttack(this, target, reduceHP, source);
        }
        internal void callback_onDamage(InstanceZone zone, InstanceUnit attacker, int reduceHP, AttackSource source)
        {
            if (this.mOnDamage != null)
                this.mOnDamage.Invoke(this, attacker, reduceHP, source);
        }

        public long mProcessDeadTime = 0;

        internal void callback_onDead(InstanceZone zone, InstanceUnit attacker)
        {
            this.mProcessDeadTime = CommonLang.TimeUtil.GetTimestampMS();
            this.OnUnitDead();
            if (this.mOnDead != null)
                this.mOnDead.Invoke(this, attacker);
        }
        internal void callback_onRebirth(InstanceZone zone)
        {
            if (this.mOnRebirth != null)
                this.mOnRebirth.Invoke(this);
        }
        internal void callback_onGotInstanceItem(InstanceZone zone, InstanceItem item)
        {
            if (this.mOnGotInstanceItem != null)
                this.mOnGotInstanceItem.Invoke(this, item);
        }
        internal void callback_onGotInventoryItem(InstanceZone zone, ItemTemplate item)
        {
            if (this.mOnGotInventoryItem != null)
                this.mOnGotInventoryItem.Invoke(this, item);
        }
        internal void callback_onLostInventoryItem(InstanceZone zone, ItemTemplate item)
        {
            if (this.mOnLostInventoryItem != null)
                this.mOnLostInventoryItem.Invoke(this, item);
        }
        internal void callback_onUseItem(InstanceZone zone, ItemTemplate item, InstanceUnit item_creater)
        {
            if (this.mOnUseItem != null)
                this.mOnUseItem.Invoke(this, item, item_creater);
        }
        internal void callback_onGotBuff(InstanceZone zone, InstanceUnit.BuffState buff)
        {
            if (this.mOnGotBuff != null)
                this.mOnGotBuff.Invoke(this, buff);
        }
        internal void callback_onLostBuff(InstanceZone zone, InstanceUnit.BuffState buff)
        {
            if (this.mOnLostBuff != null)
                this.mOnLostBuff.Invoke(this, buff);
        }

        //-----------------------------------------------------------------------------------------------------//

        private void onInit()
        {
            syncFields(UnitFieldChangedEvent.MASK_ALL);

            if (mInfo.SpawnTimeMS > 0)
            {
                changeState(new StateSpawn(this, mInfo.SpawnTimeMS));
            }
            else
            {
                changeState(new StateIdle(this));
                doActivated();
            }
        }

        #region _Overrideable_

        /// <summary>
        /// 收到协议
        /// </summary>
        /// <param name="act"></param>
        virtual protected void onAction(ObjectAction act) { }
        /// <summary>
        /// 新的状态将要切换时回调
        /// </summary>
        virtual protected void onNewStateBeginChange(State old_state, ref State new_state) { }
        /// <summary>
        /// 状态已切换时回调
        /// </summary>
        /// <param name="old_state"></param>
        /// <param name="state"></param>
        virtual protected void onStateChanged(State old_state, State state) { }

        // 被攻击时回调
        virtual protected void onDamaged(InstanceUnit attacker, AttackSource source, int reduceHP) { }

        virtual protected void onDead(InstanceUnit killer) { }

        #endregion

        /// <summary>
        /// 单位被攻击核心函数，里面处理受击状态，死亡状态
        /// </summary>
        /// <param name="attacker"></param>
        /// <param name="source"></param>
        virtual protected internal void doHitAttack(InstanceUnit attacker, AttackSource source)
        {
            if (IsDead())
            {
                //死亡后鞭尸//
                if (Moveable && CanWhiplashDeadBody)
                {
                    source.Begin(this);
                    changeState(new StateDamage(this, source, attacker));
                }
                doHitAttackEndEffect(attacker, source);
                return;
            }
            else
            {
                if (current_state is StateDamage)
                {
                    StateDamage state_damage = current_state as StateDamage;
                    if (state_damage.IsDamageProtect)
                    {
                        return;
                    }
                }
                // TODO HP //
                source.Begin(this);
                int reduceHP = mFormula.OnHit(attacker, source, this);

                // 统计 //                
                reduceHP = this.AddHP(-reduceHP, attacker, !source.OutSendEvent, source);
                //this.Statistic.LogDamage(attacker.Statistic, reduceHP);

                AttackProp attack = source.Attack;
                // Post Event //
                if (source.OutSendEvent)
                {
                    UnitHitEvent evt = new UnitHitEvent(ID);
                    evt.senderId = attacker.ID;
                    evt.senderMasterId = attacker.Virtual.GetMasterID();
                    evt.hitMasterId = this.Virtual.GetMasterID();

                    evt.hp = reduceHP;
                    evt.isDead = IsDead();
                    evt.isCritical = source.Attack.MaskMustCritical;
                    evt.effect = source.OutHitEffect;
                    evt.SourceAttack = source.Attack;
                    evt.client_state = source.OutClientState;
                    if (source != null && attacker != null && source.FromSkillType == XmdsSkillType.cardSkill && this.IsMonster && attacker.IsMonster)
                    {
                        evt.InViewForceSend = true;
                    }

                    queueEvent(evt);
                }
                if (reduceHP > 0)
                {
                    source.HasHitted = true;
                    onDamaged(attacker, source, reduceHP);
                    Parent.cb_unitDamageCallBack(this, attacker, reduceHP, source);
                    if (IsDead())
                    {
                        //doDeadProcess(attacker, source);
                        return;
                    }
                }

                // 非免控，才会有受击
                if (!this.IsIgnoreControl && source.OutIsDamage && Moveable)
                {
                    changeState(new StateDamage(this, source, attacker));
                }
                doHitAttackEndEffect(attacker, source);
                return;
            }
        }

        /** 执行死亡处理逻辑 */
        private void doDeadProcess(InstanceUnit attacker, AttackSource source)
        {
            try
            {
                onDead(attacker);
                Parent.cb_unitDeadCallBack(this, attacker);

                if (source == null)
                {
                    queueEvent(new UnitDeadEvent(ID, attacker == null ? 0 : attacker.ID, false, mInfo.RebirthTimeMS));
                    changeState(new StateDead(this, attacker, true));
                }
                else
                {
                    queueEvent(new UnitDeadEvent(ID, attacker.ID, source.OutIsCrush, mInfo.RebirthTimeMS));

                    // 被击碎，秒杀 //
                    if (source.OutIsCrush)
                    {
                        Parent.queueEvent(new AddEffectEvent(this.ID, X, Y, Direction, source.Attack.CrushEffect));
                        changeState(new StateDead(this, attacker, true));
                    }
                    else
                    {
                        if (!Moveable)
                        {
                            changeState(new StateDead(this, attacker));
                        }
                        else if (source.OutHasKnockDown || source.OutHasFly)
                        {
                            if (!changeState(new StateDamage(this, source, attacker)))
                            {
                                changeState(new StateDead(this, attacker));
                            }
                        }
                        else
                        {
                            changeState(new StateDead(this, attacker));
                        }
                    }
                    doHitAttackEndEffect(attacker, source);
                }
            }
            catch (Exception e)
            {
                log.Warn("doDeadProcess catch:" + this.Info.ID + ", AttackId: " + (attacker == null ? -1 : attacker.Info.ID), e);
            }
        }


        /// <summary>
        /// 死亡后自爆或者触发法术
        /// </summary>
        /// <param name="attacker"></param>
        /// <param name="source"></param>
        private void doHitAttackEndEffect(InstanceUnit attacker, AttackSource source)
        {
            if (source.Attack.Buff != null)
            {
                AddBuff(source.Attack.Buff, attacker);
            }
            if (source.Attack.Spell != null)
            {
                Parent.attackLaunchSpell(source.FromSkillType, attacker, this, source);
            }
        }

        // 单位获取道具 
        protected virtual bool tryGotItem(InstanceItem item, out bool removeItem)
        {
            if (!Parent.IsVisibleAOI(this, item))
            {
                removeItem = false;
                return false;
            }
            if (item.Info.DropMoneyMin > 0 && item.Info.DropMoneyMax > 0)
            {
                int min = Math.Min(item.Info.DropMoneyMin, item.Info.DropMoneyMax);
                int max = Math.Max(item.Info.DropMoneyMin, item.Info.DropMoneyMax);
                int money = RandomN.Next(min, max + 1);
                this.CurrentMoney += money;
                removeItem = item.Info.RemoveOnFinishPick;
                return true;
            }
            if (item.Info.GotOnUse)
            {
                // 获取后立即使用 //
                if (UseItem(item.Info, item.ItemCreater))
                {
                    removeItem = item.Info.RemoveOnFinishPick;
                    return true;
                }
            }
            else
            {
                // 获取后进背包 //
                if (AddItemToEmptyInventory(item.Info) > 0)
                {
                    removeItem = item.Info.RemoveOnFinishPick;
                    return true;
                }
            }
            removeItem = false;
            return false;
        }

        internal bool doGotInstanceItem(InstanceItem item, out bool removeItem, out int pickTimes)
        {
            pickTimes = 0;
            var ret = tryGotItem(item, out removeItem);
            if (ret)
            {
                pickTimes = Parent.cb_unitGotInstanceItemCallBack(this, item);
                if (item.Info.GotEffect != null)
                {
                    queueEvent(new UnitEffectEvent(ID, item.Info.GotEffect));
                }
            }
            return ret;
        }

        internal void doGotInventoryItem(InventorySlot slot, ItemTemplate item, int index, int count)
        {
            mFormula.OnGotInventoryItem(this, item);
            queueEvent(new UnitSyncInventoryItemEvent(ID, item.ID, index, slot.Count));
            Parent.cb_unitGotInventoryItemCallBack(this, item, count);
            // 添加装备Buff //
            if (item.EquipBuffs != null)
            {
                foreach (LaunchBuff buff in item.EquipBuffs)
                {
                    AddBuff(buff, this, true);
                }
            }
        }
        internal void doLostInventoryItem(InventorySlot slot, ItemTemplate item, int index, int count)
        {
            mFormula.OnLostInventoryItem(this, item);
            queueEvent(new UnitSyncInventoryItemEvent(ID, item.ID, index, slot.Count));
            Parent.cb_unitLostInventoryItemCallBack(this, item, count);
            // 移除装备Buff //
            if (item.EquipBuffs != null)
            {
                foreach (LaunchBuff buff in item.EquipBuffs)
                {
                    removeBuff(buff.BuffID);
                }
            }
        }

        // 单位获取道具 
        internal void doGotBuff(InstanceUnit.BuffState buff)
        {
            Parent.cb_unitGotBuffCallBack(this, buff);
        }
        internal void doLostBuff(InstanceUnit.BuffState buff)
        {
            Parent.cb_unitLostBuffCallBack(this, buff);
        }
        public bool UseItem(int itemTemplateID, InstanceUnit item_creater = null)
        {
            ItemTemplate item = Templates.getItem(itemTemplateID);
            if (item != null)
            {
                return UseItem(item, item_creater);
            }
            return false;
        }
        public bool UseItem(ItemTemplate item, InstanceUnit item_creater = null)
        {
            if (item_creater == null)
            {
                item_creater = this;
            }
            if (tryUseItem(item, item_creater))
            {
                beginUseItem(item);

                // 如果关键帧绑定特效
                if (item.UseEffect != null)
                {
                    queueEvent(new UnitEffectEvent(ID, item.UseEffect));
                }
                // 如果关键帧绑定释放法术
                if (item.UseSpell != null)
                {
                    Parent.unitLaunchSpell(XmdsSkillType.none, item_creater, item.UseSpell, X, Y);
                }
                if (item.UseSummon != null)
                {
                    Parent.unitSummonUnit(item_creater, item.UseSummon);
                }
                // 如果关键帧绑定自己释放BUFF
                if (item.UseBuffs != null)
                {
                    foreach (LaunchBuff buff in item.UseBuffs)
                    {
                        this.AddBuff(buff, item_creater);
                    }
                }

                mFormula.OnUseItem(this, item, item_creater);
                queueEvent(new UnitUseItemEvent(ID, item.ID));
                Parent.cb_unitUseItemCallBack(this, item, item_creater);
                Statistic.LogUseItem(item);

                return true;
            }
            return false;
        }

        //-----------------------------------------------------------------------------------------------------//
        /// <summary>
        /// 有伤害源的扣血
        /// </summary>
        /// <param name="hp"></param>
        /// <param name="attacker"></param>
        /// <param name="sendHit"></param>
        /// <param name="hitMessage"></param>
        /// force: 忽略无敌效果，强制扣血
        public int ReduceHP(int hp, InstanceUnit attacker, AttackSource source, bool sendHit = true, UnitHitEvent hitMessage = null,
            bool IngoreHealEffect = false, DamageSource dmgSrc = DamageSource.Def, bool force = false)
        {
            //1.目标无敌，不扣血
            if (IsDead() || hp == 0 || (hp > 0 && this.IsInvincible && !force))
            {
                return 0;
            }

            //2. 针对有发送者的伤害来源
            if (attacker != null)
            {
                if (hp < 0 && !IngoreHealEffect)
                {
                    int healedEffect = this.Virtual.GetHealedEffect();
                    int healEffect = (attacker.Virtual.GetUnitPro() == XmdsUnitPro.Priest) ? attacker.Virtual.GetHealEffect() : 0;
                    if (healedEffect != 0 || healEffect != 0)
                    {
                        hp = CUtils.CastInt(hp * (1 + healEffect * 0.0001) * (1 + healedEffect * 0.0001));
                    }
                }

                if (hp < 0)
                {
                    //传递加血事件
                    hp = attacker.Virtual.DispatchAddOtherHPEvent(hp, this, source);

                    //2 道灵对宠物加血，需要有个系数
                    if (attacker.IsPlayer && this.IsPet && attacker.Virtual.GetUnitPro() == XmdsUnitPro.Priest)
                    {
                        hp = (int)(hp * XmdsConstConfig.PET_HEALD_RATIO);
                    }
                }
                else
                {
                    //传递单位-被其他人扣血
                    hp = this.Virtual.DispatchAddOtherHPEvent(hp, attacker, source);
                    if (this.IsPlayer && attacker.IsMonster)
                    {
                        //2.3 如果玩家受伤，伤害来源存在且为怪物，宠物可以分担伤害
                        InstanceUnit petUnit = this.Virtual.GetPetUnit();
                        if (petUnit != null)
                        {
                            int petShareDmg = Math.Max(1, (int)(hp * XmdsConstConfig.PET_SHARE_MASTERDMG_RATIO));
                            hp = Math.Max(1, hp - petShareDmg);
                            petUnit.PetShareDamage(petShareDmg, this);
                        }
                    }
                }

                this.Statistic.LogDamage(attacker.Statistic, hp);
            }

            this.DoAddHP(-hp);

            if (attacker != null && sendHit)
            {
                if (hitMessage == null)
                {
                    hitMessage = new UnitHitEvent();
                }
                hitMessage.object_id = this.ID;

                hitMessage.senderId = attacker == null ? 0 : attacker.ID;

                hitMessage.senderMasterId = attacker == null ? 0 : attacker.Virtual.GetMasterID();

                hitMessage.hitMasterId = this.Virtual.GetMasterID();

                hitMessage.hp = hp;

                hitMessage.isSpecialHit = dmgSrc != DamageSource.Def;

                hitMessage.dmgSrc = dmgSrc;

                hitMessage.isDead = IsDead();

                queueEvent(hitMessage);
            }

            //if (IsDead())
            //{
            //    changeState(new StateDead(this, attacker, false));
            //    Parent.cb_unitDeadCallBack(this, attacker);
            //    queueEvent(new UnitDeadEvent(ID, attacker == null ? 0 : attacker.ID, false, mInfo.RebirthTimeMS));
            //}

            if (hp > 0 && this.IsDead())
            {
                this.doDeadProcess(attacker, source);
            }

            return hp;
        }

        public void AddMP(int mp, InstanceUnit sender, bool sendMsg = true, bool force = false, AttackSource source = null)
        {
            if (mp == 0 || this.MaxMP <= 0)
            {
                return;
            }

            //传递扣定力事件
            if (mp < 0 && sender != null)
            {
                int finalHP = mp;
                sender.Virtual.DispatchAddMPEvent(mp, this, out finalHP, source);
                mp = finalHP;
            }

            this.DoAddMP(mp, force);
        }


        public void removeFromParent()
        {
            Parent.RemoveObjectByID(ID);
        }
        public void kill(InstanceUnit killer = null, bool sendHit = true, UnitHitEvent hitMessage = null)
        {
            ReduceHP(this.CurrentHP, killer, null, sendHit, hitMessage, true);
        }

        virtual protected void onResetAI()
        {
            this.doSomething();
        }

        public void resetAI()
        {
            next_state_queue.Clear();
            onResetAI();
        }

        public override void faceTo(float d)
        {
            if (Info.IsTurnable) { base.faceTo(d); }
        }
        public override void faceTo(float x, float y)
        {
            if (Info.IsTurnable) { base.faceTo(x, y); }
        }


        /// <summary>
        /// 瞬移
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        public void transport(float x, float y, bool setDirction = false, float direction = 0)
        {
            this.SetActionStatus(UnitActionStatus.Transport);
            this.changeState(new StateTransport(this), true);

            setPos(x, y);
            if (setDirction)
            {
                this.faceTo(direction);
            }
            SendForceSync();

            if (mOnRegionTransport != null)
            {
                mOnRegionTransport.Invoke();
            }
        }

        //-----------------------------------------------------------------------------------------------------//

        public virtual void doSomething()
        {
            startIdle();
        }

        /// <summary>
        /// 单位待机
        /// </summary>
        public bool startIdle(bool force = false)
        {
            if (current_state is StateIdle)
            {
            }
            else
            {
                return changeState(new StateIdle(this), force);
            }
            return false;
        }

        /// <summary>
        /// 直接复活
        /// </summary>
        public bool startRebirth(int max_hp = 0, int max_mp = 0)
        {
            if (IsDead())
            {
                //this.DeadHide = false;
                this.mProcessDeadCallbackTime = 0;
                return changeState(new StateRebirth(this, max_hp, max_mp));
            }
            return false;
        }

        /// <summary>
        /// 单位移动
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        public bool startMoveTo(float x, float y)
        {
            return changeState(new StateMove(this, x, y));
        }
        /// <summary>
        /// 调整射击位置
        /// </summary>
        /// <param name="expect_skill"></param>
        /// <param name="target"></param>
        /// <param name="onEndAction"></param>
        public bool startAdjustLaunchSkill(SkillTemplate expect_skill, InstanceUnit target, Predicate<StateMove> onEndAction)
        {
            if (expect_skill.AttackKeepRange > 0 && expect_skill.AttackRange > expect_skill.AttackKeepRange)
            {
                float keep_range = GetSkillAttackRange(expect_skill.AttackKeepRange) + target.BodyBlockSize;
                float distance = MathVector.getDistance(this.X, this.Y, target.X, target.Y);
                if (distance < keep_range)
                {
                    var half = (expect_skill.AttackRange - expect_skill.AttackKeepRange) / 2;
                    var md = (keep_range - distance) + (float)(RandomN.NextDouble() * half);
                    var target_pos = new Vector2(this.X, this.Y);
                    var rd = (CMath.PI_DIV_2 / 4);
                    var target_direction = this.Direction + CMath.PI_F - (rd / 2 + (float)(RandomN.NextDouble() * rd));
                    MathVector.movePolar(target_pos, target_direction, md);
                    if (!Parent.TryTouchMap(this, target_pos.X, target_pos.Y))
                    {
                        var back_pos = new Vector2(this.X, this.Y);
                        MathVector.movePolar(back_pos, target_direction, this.BodyBlockSize);
                        if (!Parent.TryTouchMap(this, back_pos.X, back_pos.Y))
                        {
                            var move = new StateMove(this, target_pos.X, target_pos.Y);
                            move.MinStepCheckCount = 0;
                            move.StopOnTouchMap = true;
                            move.EndMoveAction = onEndAction;
                            return this.changeState(move);
                        }
                    }
                }
            }
            return false;
        }
        /// <summary>
        /// 单位移动
        /// </summary>
        /// <param name="obj"></param>
        public bool startFollowTo(InstanceZoneObject obj)
        {
            return changeState(new StateFollowObject(this, obj));
        }
        /// <summary>
        /// 单位逃跑
        /// </summary>
        /// <param name="timeMS"></param>
        /// <param name="distance"></param>
        public bool startEscape(int timeMS, float distance = 0)
        {
            return changeState(new StateEscape(this, timeMS, distance));
        }

        /// <summary>
        /// 和自身交互（搓炉石）
        /// </summary>
        /// <param name="timeMS"></param>
        /// <param name="done"></param>
        /// <param name="status"></param>
        public StatePickObject startPickProgressSelf(int timeMS, StatePickObject.OnPickDone done, string status = null)
        {
            StatePickObject picking = new StatePickObject(this, this, timeMS, status, done);
            changeState(picking);
            return picking;
        }
        /// <summary>
        /// 和目标交互
        /// </summary>
        /// <param name="item"></param>
        /// <param name="timeMS"></param>
        /// <param name="done"></param>
        /// <param name="status"></param>
        /// <returns></returns>
        public StatePickObject startPickProgressObject(InstanceZoneObject item, int timeMS, StatePickObject.OnPickDone done, string status = null)
        {
            StatePickObject picking = new StatePickObject(this, item, timeMS, status, done);
            changeState(picking);
            return picking;
        }


        //-----------------------------------------------------------------------------------------------------------------
        #region _SKILL_
        //-----------------------------------------------------------------------------------------------------------------
        public float GetSkillAttackRange(SkillTemplate skill, InstanceUnit targetUnit)
        {
            return mIsAttackRangeIncludeBodySize ? (BodyBlockSize + skill.AttackRange + targetUnit.BodyBlockSize) : skill.AttackRange;
            //return mIsAttackRangeIncludeBodySize ? (BodyBlockSize + skill.AttackRange) : skill.AttackRange;
        }

        public float GetSkillAttackRange(SkillTemplate skill)
        {
            return mIsAttackRangeIncludeBodySize ? (BodyBlockSize + skill.AttackRange) : skill.AttackRange;
        }

        public float GetSkillAttackRange(float range)
        {
            return (mIsAttackRangeIncludeBodySize ? BodyBlockSize + range : range);
        }
        /// <summary>
        /// 判断当前目标在攻击范围内
        /// </summary>
        /// <param name="skill"></param>
        /// <param name="unit"></param>
        /// <returns></returns>
        public bool IsTargetInSkillRange(SkillTemplate skill, InstanceUnit unit)
        {
            float rg = GetSkillAttackRange(skill);
            float dr = skill.AttackAngle / 2;
            if (Collider.Object_HitBody_TouchFan(unit, X, Y, rg, Direction - dr, Direction + dr))
            {
                return true;
            }
            return false;
        }

        [Obsolete]
        public List<InstanceUnit> getSkillAttackableTargets(SkillTemplate skill, AttackReason reason)
        {
            float rg = GetSkillAttackRange(skill);
            List<InstanceUnit> list = Parent.getObjectsRoundRange<InstanceUnit>(Collider.Object_HitBody_TouchRound, X, Y, rg, this.AoiStatus);
            Parent.getAttackableUnits(this, list, skill.ExpectTarget, reason, skill);
            return list;
        }
        public void getSkillAttackableTargets(SkillTemplate skill, List<InstanceUnit> list, AttackReason reason)
        {
            float rg = GetSkillAttackRange(skill);
            Parent.getObjectsRoundRange<InstanceUnit>(Collider.Object_HitBody_TouchRound, X, Y, rg, list, this.AoiStatus);
            Parent.getAttackableUnits(this, list, skill.ExpectTarget, reason, skill);
        }

        /// <summary>
        /// 获得可用的技能
        /// </summary>
        /// <param name="expect"></param>
        /// <returns></returns>
        public SkillState getAvailableSkill(SkillTemplate.CastTarget expect)
        {
            for (int si = mAllSkills.Count - 1; si >= 0; --si)
            {
                SkillTemplate st = mAllSkills[si];
                if (st.ExpectTarget == expect)
                {
                    SkillState sst = mSkillStatus.Get(st.GetID());
                    if (sst.IsActive && sst.IsDone)
                    {
                        return sst;
                    }
                }
            }
            return null;
        }

        /** 获取当前可自动释放的技能 */
        public SkillState getAvailableAutoLaunchSkill(SkillTemplate.CastTarget expect)
        {
            for (int si = mAllSkills.Count - 1; si >= 0; --si)
            {
                SkillTemplate st = mAllSkills[si];
                if (st.ExpectTarget == expect)
                {
                    SkillState sst = mSkillStatus.Get(st.GetID());
                    if (sst.IsActive && sst.IsDone && sst.LaunchSkill.AutoLaunch && sst.CanAutoLaunch())
                    {
                        return sst;
                    }
                }
            }
            return null;
        }

        /// <summary>
        /// 获取当前最适合攻击的目标
        /// </summary>
        /// <param name="skill"></param>
        /// <param name="reason"></param>
        /// <param name="directionChange"></param>
        /// <returns></returns>
        public InstanceUnit getSkillAttackableFirstTarget(SkillTemplate skill, AttackReason reason, ref bool directionChange)
        {
            using (var list = ListObjectPool<InstanceUnit>.AllocAutoRelease())
            {
                getSkillAttackableTargets(skill, list, reason);
                if (list.Count > 0)
                {
                    float rg = GetSkillAttackRange(skill);
                    // 检测攻击范围内的单位 //
                    float dr = skill.AttackAngle / 2;
                    for (int i = 0; i < list.Count; i++)
                    {
                        InstanceUnit u = list[i];
                        if (Collider.Object_HitBody_TouchFan(u, X, Y, rg, Direction - dr, Direction + dr))
                        {
                            directionChange = false;
                            return u;
                        }
                    }
                    // 优先当前朝向的目标 //
                    dr = CMath.PI_DIV_2;
                    directionChange = true;
                    for (int i = 0; i < list.Count; i++)
                    {
                        InstanceUnit u = list[i];
                        if (Collider.Object_HitBody_TouchFan(u, X, Y, rg, Direction - dr, Direction + dr))
                        {
                            return u;
                        }
                    }
                    // 最后选取最近的目标 //
                    InstanceUnit min = null;
                    float min_len = float.MaxValue;
                    for (int i = 0; i < list.Count; i++)
                    {
                        InstanceUnit u = list[i];
                        float len = MathVector.getDistanceSquare(u.X, u.Y, X, Y);
                        if (min_len > len)
                        {
                            min_len = len;
                            min = u;
                        }
                    }
                    return min;
                }
            }
            return null;
        }

        public struct LaunchSkillParam
        {
            public uint TargetUnitID;
            public Vector2 SpellTargetPos;
            public bool AutoFocusNearTarget;
            public bool LaunchSetDirection;         // 释放时是否重新设置方向 
            public float direction;
            public bool IsAutoLaunch;               // 是否自动战斗时释放
            public bool IsInGuard;                  // 是否是自动战斗

            public LaunchSkillParam(uint targetUnitID = 0, Vector2 target_pos = null, bool autoFocusNearTarget = false,
                bool LaunchSetDirection = false, float direction = 0, bool IsAutoLaunch = false, bool IsInGuard = false)
            {
                this.TargetUnitID = targetUnitID;
                this.SpellTargetPos = target_pos;
                this.AutoFocusNearTarget = autoFocusNearTarget;
                this.LaunchSetDirection = LaunchSetDirection;
                this.direction = direction;
                this.IsAutoLaunch = IsAutoLaunch;
                this.IsInGuard = IsInGuard;
            }
        }

        public StateSkill launchSkill(SkillState ss, LaunchSkillParam param)
        {
            if (ss == null) return null;
            StateSkill current = CurrentState as StateSkill;
            if (current != null && current.SkillData.IsManuallyCancelable)
            {
                //如果当前技能为手动取消//
                if (current.Skill.ID == ss.ID)
                {
                    //判断停止当前技能//
                    if (current.IsCancelableBySkill)
                    {
                        current.block();
                    }
                }
                //手动取消技能禁止其他技能打断//
                return null;
            }
            if (ss.TryLaunch() && mFormula.TryLaunchSkill(this, ss, ref param))
            {
                if (param.IsAutoLaunch && !ss.CanAutoLaunch())
                {
                    return null;
                }

                //沉默不能释放其他技能//
                if (IsSilent && ss != mDefaultSkill)
                {
                    return null;
                }
                // 自动战斗下，释放技能要在范围内
                InstanceUnit target = null;
                if (ss.Data.AttackMustBeInRange)
                {
                    target = Parent.getUnit(param.TargetUnitID);
                    if (!ss.checkTargetRange(target))
                    {
                        return null;
                    }
                }

                //是否在合理的攻击范围内
                if (param.IsInGuard && !ss.checkTargetInAttackRange(target, param))
                {
                    return null;
                }

                if (ss.GetSkillType() == XmdsSkillType.petGiveAcitve)
                {
                    mFormula.TriggerPetSkill(this, ss, ref param);
                    return null;
                }

                StateSkill state = new StateSkill(this, ss, param, ss.ActionSpeed, (st) =>
                {
                    overLaunchSkill(ss, st);
                    if (mOnLaunchSkill != null)
                    {
                        mOnLaunchSkill.Invoke(this, ss);
                    }
                });

                if (state.tryLaunch())
                {
                    this.Virtual.SetCombatState(BattleStatus.ReadyBattle);
                    Parent.cb_unitLaunchSkill(this, ss);
                    if (changeState(state))
                    {
                        //释放成功
                        if (param.LaunchSetDirection)
                        {
                            //Console.WriteLine("launchSkill - 设置方向： " + param.direction + ", " + this.ID);
                            //this.faceTo(param.direction);
                            //this.SendForceSync();
                        }
                        return state;
                    }
                }
            }
            return null;
        }

        protected virtual void overLaunchSkill(SkillState ss, StateSkill state)
        {
            this.AddHP(-ss.Data.CostHP, null);
            this.AddMP(-ss.Data.CostMP, null);
        }

        /// <summary>
        /// 单位释放技能
        /// </summary>
        public StateSkill launchSkill(int skillID, LaunchSkillParam param)
        {
            SkillState skill = getSkillState(skillID);
            return launchSkill(skill, param);
        }

        /// <summary>
        /// 释放随机技能，一般用于AI
        /// </summary>
        /// <param name="expectTarget"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        public virtual StateSkill launchRandomSkill(SkillTemplate.CastTarget expectTarget, LaunchSkillParam param)
        {
            StateSkill current = CurrentState as StateSkill;
            if (current != null && !current.IsCancelableBySkill)
            {
                return null;
            }
            int rand = RandomN.Next(0, mAllSkills.Count);
            for (int si = mAllSkills.Count - 1; si >= 0; --si)
            {
                SkillTemplate st = mAllSkills[CMath.cycNum(rand, si, mAllSkills.Count)];
                if (st.ExpectTarget == expectTarget)
                {
                    SkillState sst = mSkillStatus.Get(st.GetID());
                    if (sst.LaunchSkill.AutoLaunch && sst.TryLaunch())
                    {
                        StateSkill state = launchSkill(sst, param);
                        if (state != null)
                        {
                            return state;
                        }
                    }
                }
            }
            return null;
        }
        public virtual StateSkill launchRandomSkillForAll(LaunchSkillParam param)
        {
            StateSkill current = CurrentState as StateSkill;
            if (current != null && !current.IsCancelableBySkill)
            {
                return null;
            }
            int rand = RandomN.Next(0, mAllSkills.Count);
            for (int si = mAllSkills.Count - 1; si >= 0; --si)
            {
                SkillTemplate st = mAllSkills[CMath.cycNum(rand, si, mAllSkills.Count)];
                SkillState sst = mSkillStatus.Get(st.GetID());
                if (sst.LaunchSkill.AutoLaunch && sst.TryLaunch())
                {
                    StateSkill state = launchSkill(sst, param);
                    if (state != null)
                    {
                        return state;
                    }
                }
            }
            return null;
        }

        /// <summary>
        /// 尝试取消当前技能，打出连击
        /// </summary>
        /// <param name="target"></param>
        /// <param name="autoFocusNearTarget"></param>
        /// <returns></returns>
        public virtual bool tryLaunchRandomSkillAndCancelCurrentSkill(InstanceUnit target, bool autoFocusNearTarget = false)
        {
            StateSkill current = CurrentState as StateSkill;
            if (current != null && !current.IsChanting && current.IsCancelableBySkill)
            {
                LaunchSkillParam param = new LaunchSkillParam(target.ID, null, autoFocusNearTarget);
                //优先多段攻击//
                if (current.SkillData.IsSingleAction)
                {
                    if (IsTargetInSkillRange(current.SkillData, target))
                    {
                        StateSkill st = launchSkill(current.SkillData.ID, param);
                        if (st != null)
                        {
                            return true;
                        }
                    }
                }
                //随机其他技能//
                int rand = RandomN.Next(0, mAllSkills.Count);
                for (int si = mAllSkills.Count - 1; si >= 0; --si)
                {
                    SkillTemplate st = mAllSkills[CMath.cycNum(rand, si, mAllSkills.Count)];
                    if (Parent.IsAttackable(this, target, st.ExpectTarget, AttackReason.Attack, st))
                    {
                        SkillState sst = mSkillStatus.Get(st.GetID());
                        if (sst.LaunchSkill.AutoLaunch && IsTargetInSkillRange(st, target))
                        {
                            StateSkill state = launchSkill(sst, param);
                            if (state != null)
                            {
                                return true;
                            }
                        }
                    }
                }
            }
            return false;
        }


        /// <summary>
        /// 尝试在范围内找到目标释放技能，并进入StateFollowAndAttack，自己走过去打。
        /// </summary>
        /// <param name="range"></param>
        /// <param name="skill_auto_launchable"></param>
        /// <returns></returns>
        public virtual bool tryFollowAndLaunchRandomSkillToTargetInRange(float range, bool skill_auto_launchable = false)
        {
            if (!IsNoneSkill)
            {
                SkillState[] skills = mSkillStatus.SkillsArray;
                CUtils.RandomArray(RandomN, skills);

                using (var list = ListObjectPool<InstanceUnit>.AllocAutoRelease())
                {
                    //随机找个目标施法//
                    Parent.getObjectsRoundRange<InstanceUnit>(Collider.Object_Pos_IncludeInRound, X, Y, Info.GuardRange, list, this.AoiStatus);
                    DoAndRemoveCollection.UpdateAndRemove<InstanceUnit>(list, (InstanceUnit u) =>
                    {
                        return !u.IsActive;
                    });
                    if (list.Count == 0) { return false; }

                    CUtils.RandomList(Parent.RandomN, list);
                    foreach (SkillState skill in skills)
                    {
                        if ((!skill_auto_launchable || skill.LaunchSkill.AutoLaunch) && skill.TryLaunch())
                        {
                            for (int i = 0; i < list.Count; i++)
                            {
                                InstanceUnit u = list[i];
                                if (Parent.IsAttackable(this, u, skill.Data.ExpectTarget, AttackReason.Attack, skill.Data))
                                {
                                    //检测是否有可释放技能//
                                    changeState(new StateFollowAndAttack(this, u, skill.Data.ExpectTarget));
                                    return true;
                                }
                            }
                        }
                    }
                }
            }
            return false;
        }

        #endregion
        //-----------------------------------------------------------------------------------------------------------------

        internal void deadDropItems(int force)
        {
            foreach (KeyValuePair<ItemTemplate, DropItem> e in mDropItems.Drop(Parent, Parent.RandomN))
            {
                float x;
                float y;
                CMath.RandomPosInRound(RandomN, X, Y, e.Value.DropPosRange, out x, out y);
                Parent.AddItem(e.Key, e.Key.Name, x, y, CMath.RandomAngle(RandomN), force, e.Key.Name, this);
            }
        }

        protected bool tryPickObject(InstanceUnit unit)
        {
            if (!Parent.IsVisibleAOI(this, unit))
            {
                return false;
            }
            bool ret = true;
            if (mOnTryPickUnit != null)
            {
                foreach (TryPickUnitHandler trypick in mOnTryPickUnit.GetInvocationList())
                {
                    if (!trypick.Invoke(this, unit))
                    {
                        ret = false;
                    }
                }
            }

            return ret;
        }

        public void PickUnit(InstanceUnit pickable)
        {
            if (tryPickObject(pickable))
            {
                Parent.cb_unitPickUnitCallBack(this, pickable);
                if (mOnPickUnit != null)
                {
                    mOnPickUnit.Invoke(this, pickable);
                }
            }
        }

        public CommonAI.Data.SceneType GetSceneType()
        {
            return mZone.SceneType;
        }

        //-----------------------------------------------------------------------------------------------------//
        #region Environment
        //-----------------------------------------------------------------------------------------------------//

        private HashMap<string, EnvironmentVar> EnvironmentVarMap = new HashMap<string, EnvironmentVar>();
        public void SetEnvironmentVar(string key, object value, bool syncToClient = false)
        {
            if (!string.IsNullOrEmpty(key))
            {
                EnvironmentVar var = EnvironmentVarMap.Get(key);
                if (var != null)
                {
                    if (EnvironmentVar.ALWAYS_SYNC_ENVIRONMENT_VAR || (var.SyncToClient && var.Value != value))
                    {
                        queueEvent(new PlayerSyncEnvironmentVarEvent(ID, key, value));
                    }
                    var.Value = value;
                }
                else
                {
                    var = new EnvironmentVar(key, syncToClient, value);
                    EnvironmentVarMap.Add(key, var);
                    if (EnvironmentVar.ALWAYS_SYNC_ENVIRONMENT_VAR || var.SyncToClient)
                    {
                        queueEvent(new PlayerSyncEnvironmentVarEvent(ID, key, value));
                    }
                }
            }
        }
        public T GetEnvironmentVarAs<T>(string key)
        {
            if (!string.IsNullOrEmpty(key))
            {
                EnvironmentVar var = EnvironmentVarMap.Get(key);
                if (var != null)
                {
                    try
                    {
                        return (T)var.Value;
                    }
                    catch (Exception err)
                    {
                        log.Warn("GetEnvironmentVarAs : " + key + ", catch: " + err);
                    }
                }
            }
            return default(T);
        }
        public int ListEnvironmentVars(List<EnvironmentVar> list)
        {
            list.AddRange(EnvironmentVarMap.Values);
            return EnvironmentVarMap.Count;
        }
        public List<EnvironmentVar> ListEnvironmentVars()
        {
            return new List<EnvironmentVar>(EnvironmentVarMap.Values);
        }

        public ClientStruct.ZoneEnvironmentVar[] GetCurrentUnitVars()
        {
            ClientStruct.ZoneEnvironmentVar[] ret = new ClientStruct.ZoneEnvironmentVar[EnvironmentVarMap.Count];
            int i = 0;
            try
            {
                foreach (EnvironmentVar var in EnvironmentVarMap.Values)
                {
                    ret[i].Key = var.Key;
                    ret[i].Value = var.Value;
                    ret[i].SyncToClient = var.SyncToClient;
                    i++;
                }
            }
            catch (Exception e)
            {
                log.Warn("GetCurrentUnitVars catch: " + ret.Length + ", " + EnvironmentVarMap.Count + ", " + i + ", e: " + e);
            }

            return ret;
        }
        #endregion
        //-----------------------------------------------------------------------------------------------------//


        //-----------------------------------------------------------------------------------------------------//
        #region SceneEvents
        //-----------------------------------------------------------------------------------------------------//

        private HashMap<int, UnitEventTriggerCollection> mBindEvents = new HashMap<int, UnitEventTriggerCollection>();
        public void BindUnitEvent(int unit_event_id)
        {
            if (!mBindEvents.ContainsKey(unit_event_id))
            {
                UnitEventTemplate uet = Templates.getUnitEvent(unit_event_id);
                if (uet != null)
                {
                    uet = uet.Clone() as UnitEventTemplate;
                    UnitEventTriggerCollection bind_event = new UnitEventTriggerCollection(this);
                    bind_event.Bind(uet.Events);
                    mBindEvents.Add(unit_event_id, bind_event);
                }
            }
        }

        protected virtual void clearBindEvents()
        {
            foreach (var evt in mBindEvents.Values)
            {
                evt.Dispose();
            }
            mBindEvents.Clear();
        }

        /** 计算并获得伤害 */
        public virtual void PetShareDamage(int baseDmgValue, InstanceUnit sender)
        {
        }

        #endregion
        //-----------------------------------------------------------------------------------------------------//

        //-----------------------------------------------------------------------------------------------------//
    }

}