WSHCommon/Common/CommonAI/ZoneClient/ZoneObject.Unit.Status.cs

using CommonAI.RTS;
using CommonLang.Vector;
using CommonAI.Zone;
using CommonAI.Zone.Attributes;
using CommonAI.Zone.Helper;
using CommonLang;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using CommonAI.Zone.Formula;
using System.Collections;
using CommonLang.Log;

namespace CommonAI.ZoneClient
{
    public partial class ZoneUnit
    {        //--------------------------------------------------------------------------------

        #region DamageDeadFly

        private TimeExpire<UnitDamageEvent> mDamageTime;
        private TimeExpire<UnitDeadEvent> mDeadTime;
        private FallingDown mHitFlyState;

        public FallingDown StartFly(float z_speed, float gravity, float z_limit)
        {
            if (!Parent.IsSyncZ && z_speed != 0)
            {
                mHitFlyState = new FallingDown(this, z_speed, gravity, z_limit);
                return mHitFlyState;
            }
            return null;
        }

        protected virtual void DoDamage(UnitDamageEvent e)
        {
            mDamageTime = new TimeExpire<UnitDamageEvent>(e, e.DamageTimeMS);
            if (e.HasFly)
            {
                StartFly(e.ZSpeedSEC, e.ZGravity, e.ZLimit);
            }
            if (Info.DamageEffect != null)
            {
                Parent.PreQueueEvent(new UnitEffectEvent(this.ObjectID, Info.DamageEffect));
            }
            SetCurrentState(UnitActionStatus.Damage, e);

        }
        protected virtual void DoJump(UnitJumpEvent e)
        {
            StartFly(e.ZSpeed, e.ZGravity, e.ZLimit);
        }

        protected virtual void DoDead(UnitDeadEvent me)
        {
            if (me.RebirthTimeMS > 0)
            {
                mDeadTime = new TimeExpire<UnitDeadEvent>(me, me.RebirthTimeMS);
            }
            //所有的怪都清了一遍，都是先下发UnitDeadEvent，然后在下发死亡状态，为了防止切换状态的时候清掉特效，逻辑层的死亡特效屏蔽掉，放在表现层下
            //if (Info.DeadEffect != null)
            //{
            //    Parent.PreQueueEvent(new UnitEffectEvent(this.ObjectID, Info.DeadEffect));
            //}
            if (me.Crushed)
            {
                if (Info.CrushEffect != null)
                {
                    Parent.PreQueueEvent(new UnitEffectEvent(this.ObjectID, Info.CrushEffect));
                }
            }
        }


        private void UpdateDamage(int intervalMS)
        {
            if (mDeadTime != null && mDeadTime.Update(intervalMS))
            {
                mDeadTime = null;
            }
            if (mDamageTime != null && mDamageTime.Update(intervalMS))
            {
                mDamageTime = null;
            }
        }


        /// <summary>
        /// 落体运动
        /// </summary>
        public class FallingDown
        {
            private readonly ZoneUnit unit;
            private readonly float gravity;
            private readonly float z_limit;
            private float z_speed;
            public FallingDown(ZoneUnit unit, float zspeed, float zgravity, float zlimit)
            {
                this.unit = unit;
                this.z_limit = zlimit;
                this.z_speed = zspeed;
                this.gravity = zgravity == 0 ? unit.Templates.CFG.GLOBAL_GRAVITY : zgravity;
                this.ExpectTimeMS = MoveHelper.CalculateFlyTimeMS(unit.Z, zspeed, zlimit, gravity, 10);
                this.IsEnd = false;
            }
            public bool Update(int intervalMS)
            {
                //向上受到ZLimit限制//
                unit.Z += MoveHelper.GetDistance(intervalMS, z_speed);
                unit.Z = Math.Max(0, unit.Z);
                this.IsEnd = unit.Z <= 0;
                //骤停//
                if (z_limit != 0 && z_speed > 0 && unit.Z > z_limit)
                {
                    z_speed = 0;
                }
                this.z_speed -= MoveHelper.GetDistance(intervalMS, gravity);

                return IsEnd;
            }
            public bool IsEnd { get; private set; }
            public int ExpectTimeMS { get; private set; }
            public float ZSpeedSEC { get { return z_speed; } }
            public float ZLimit { get { return z_limit; } }
        }

        #endregion


        //--------------------------------------------------------------------------------
        #region Skill

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

        internal void SyncSkillStatus(ClientStruct.UnitSkillStatus[] skills)
        {
            if (skills != null)
            {
                foreach (ClientStruct.UnitSkillStatus st in skills)
                {
                    SkillState status = this.GetSkillState(st.SkillTemplateID);
                    if (status != null)
                    {
                        status.Sync(st);
                    }
                }
            }
        }

        public virtual void InitSkills()
        {
            mSkillStatus.Clear();
            if (Info.BaseSkillID != null)
            {
                BaseSkillID = Info.BaseSkillID.SkillID;
                if (BaseSkillID != 0)
                {
                    SkillTemplate skt = Templates.getSkill(BaseSkillID);
                    if(skt == null)
                    {
                        ClientLog.LogError("Skill template({0}@{1}) Not Found.", BaseSkillID, Info.Name);
                        return;
                    }
                    mSkillStatus.Put(new SkillState(skt, this));
                }
            }
            else
            {
                BaseSkillID = 0;
            }

            foreach (LaunchSkill skid in Info.Skills)
            {
                if (skid.SkillID != 0)
                {
                    SkillTemplate skt = Templates.getSkill(skid.SkillID);
                    if (skt == null)
                    {
                        ClientLog.LogError("Skill template({0}@{1}) Not Found.", skid.SkillID, Info.Name);
                        return;
                    }
                    mSkillStatus.Put(new SkillState(skt, this));
                }
            }

            if (mOnSkillChanged != null)
            {
                mOnSkillChanged.Invoke(SkillOption.Init, this, BaseSkillID, mSkillStatus.Keys.ToArray());
            }
        }
        protected virtual void DoSkillChanged(PlayerSkillChangedEvent e)
        {
            this.mFastCastRate = e.unitFastCastRate;

            //一项一项排查，是不是有不同
            bool dif = false;
            if(e.baseSkill != null && e.baseSkill.TemplateID == BaseSkillID)
            {
                if(e.skills.Count == mSkillStatus.Count - 1)
                {
                    foreach(var skt in e.skills)
                    {
                        if(!mSkillStatus.ContainsKey(skt.TemplateID))
                        {
                            dif = true;
                            break;
                        }
                    }
                }
                else
                {
                    dif = true;
                }
            }
            else
            {
                dif = true;
            }

            if (!dif)
            {
                //YXJDebug.logDebug(">skills are exactly the same, why you post >PlayerSkillChangedEvent");
                return;
            }

            mSkillStatus.Clear();
            if (e.baseSkill != null)
            {
                BaseSkillID = e.baseSkill.TemplateID;
                mSkillStatus.Put(new SkillState(e.baseSkill, this));
            }
            else
            {
                BaseSkillID = 0;
            }
            foreach (var skt in e.skills)
            {
                mSkillStatus.Put(new SkillState(skt, this));
            }

            if (mOnSkillChanged != null)
            {
                mOnSkillChanged.Invoke(SkillOption.Reset, this, BaseSkillID, mSkillStatus.Keys.ToArray());
            }
        }
        protected virtual void DoPlayerSkillActiveChangedEvent(PlayerSkillActiveChangedEvent e)
        {
            for (int i = e.Skills.Count - 1; i >= 0; --i)
            {
                PlayerSkillActiveChangedEvent.State sat = e.Skills[i];
                SkillState ss = GetSkillState(sat.SkillTemplateID);
                if (ss != null)
                {
                    ss.SetActive(sat.ST);
                }
            }
            if (mOnSkillChanged != null)
            {
                mOnSkillChanged.Invoke(SkillOption.ActiveChange, this, 0, null);
            }
        }
        protected void AddSkill(SkillTemplate skill, bool isDefault)
        {
            mSkillStatus.Put(new SkillState(skill, this));
            if (isDefault)
            {
                BaseSkillID = skill.ID;
            }
            if (mOnSkillChanged != null)
            {
                mOnSkillChanged.Invoke(SkillOption.Add, this, skill.ID, mSkillStatus.Keys.ToArray());
            }
        }
        protected void RemoveSkill(int skillTemplateID)
        {
            if (mSkillStatus.RemoveByKey(skillTemplateID) != null)
            {
                if (BaseSkillID == skillTemplateID)
                {
                    BaseSkillID = 0;
                }
                if (mOnSkillChanged != null)
                {
                    mOnSkillChanged.Invoke(SkillOption.Remove, this, skillTemplateID, mSkillStatus.Keys.ToArray());
                }
            }
        }

        private void UpdateSkills(int intervalMS)
        {
            for (int i = 0; i < mSkillStatus.Count; i++)
            {
                SkillState ss = mSkillStatus.GetAt(i);
                ss.Update(intervalMS);
            }
            if (mChantingSkill != null && mChantingSkill.Update(intervalMS))
            {
                mChantingSkill = null;
            }
        }

        //新增技能使用次数
        protected virtual void DoPlayerSkillUseTimeChangedEvent(PlayerSkillUseTimeChangedEvent evt)
        {
            SkillState ss = mSkillStatus.Get(evt.SkillTemplateID);
            if (ss != null)
            {
                //UnityEngine.Debug.LogError("PlayerSkillUseTimeChangedEvent usetimes = " + evt.useTimes);
                ss.SyncSkillUseTimes(evt.useTimes);
            }
        }

        protected virtual void DoSkillAdded(PlayerSkillAddedEvent e)
        {
            this.AddSkill(e.Skill, e.IsDefault);
        }
        protected virtual void DoSkillRemoved(PlayerSkillRemovedEvent e)
        {
            this.RemoveSkill(e.SkillID);
        }

        protected virtual void DoLaunchSkill(UnitLaunchSkillEvent me)
        {
            //ClientLog.LogWarning(">doLaunchSkillAction>{0} @ {1}", me.action_index, me.skill_id);
            SkillState ss = mSkillStatus.Get(me.skill_id);
            if (ss != null)
            {
                this.mLastLaunchSkill = ss;
                ss.Launch(me);
            }
            doLaunchSkillAction(me);
            if (mOnLaunchSkill != null)
            {
                mOnLaunchSkill.Invoke(this, ss, me);
            }
        }
        protected virtual void DoSkillCDChanged(PlayerCDEvent evt)
        {
            if (evt.is_all)
            {
                for (int i = 0; i < mSkillStatus.Count; i++)
                {
                    SkillState ss = mSkillStatus.GetAt(i);
                    if (evt.is_clear)
                        ss.ClearCD();
                    else if (evt.is_decrease_time)
                        ss.DecreaseCD(evt.decrease_timeMS);
                    else if (evt.is_decrease_pct)
                        ss.DecreaseCD_Pct(evt.decrease_pct);
                }
            }
            else
            {
                SkillState ss = mSkillStatus.Get(evt.skill_template_id);
                if (ss != null)
                {
                    if (evt.is_clear)
                        ss.ClearCD();
                    else if (evt.is_decrease_time)
                        ss.DecreaseCD(evt.decrease_timeMS);
                    else if (evt.is_decrease_pct)
                        ss.DecreaseCD_Pct(evt.decrease_pct);
                }
            }
        }
        protected virtual void DoChangeAction(UnitSkillActionChangeEvent e)
        {
            if (mLastLaunchSkill != null)
            {
                mLastLaunchSkill.ChangeAction(e.ActionIndex);
            }
            if (mCurrentSkillAction != null)
            {
                mCurrentSkillAction.onUnitSkillActionChangeEvent(e);
            }
            if (mLastLaunchSkill != null && mOnSkillActionChanged != null)
            {
                mOnSkillActionChanged.Invoke(this, mLastLaunchSkill, e.ActionIndex);
            }
        }
        protected virtual void DoPlayerSkillStopEvent(PlayerSkillStopEvent e)
        {
            SkillState ss = mSkillStatus.Get(e.SkillID);
            if (ss != null)
            {
                ss.PlayerStop(e);
            }
            mChantingSkill = null;
            clearSkillAction();
        }
        protected virtual void DoPlayerSkillTimeChangedEvent(PlayerSkillTimeChangedEvent e)
        {
            SkillState ss = mSkillStatus.Get(e.SkillTemplateID);
            if (ss != null)
            {
                ss.TimeChange(e);
            }
        }
        public int BaseSkillID { get; private set; }

        internal SkillMap mSkillStatus = new SkillMap();
        private SkillState mLastLaunchSkill;

        public class SkillMap
        {
            private HashMap<int, SkillState> Map = new HashMap<int, SkillState>();
            private List<SkillState> For = new List<SkillState>();

            public int Count { get { return For.Count; } }
            public ICollection<int> Keys { get { return Map.Keys; } }
            public IEnumerable<SkillState> Skills { get { return For; } }
            public SkillState[] SkillsArray { get { return For.ToArray(); } }

            public SkillState GetAt(int i)
            {
                return For[i];
            }
            public SkillState Get(int id)
            {
                return Map.Get(id);
            }
            public void Put(SkillState state)
            {
                SkillState old = Map.Get(state.Data.ID);
                if (old != null)
                {
                    For.Remove(old);
                }
                Map.Put(state.Data.ID, state);
                For.Add(state);
            }
            public SkillState RemoveByKey(int id)
            {
                SkillState ret = Map.RemoveByKey(id);
                if (ret != null)
                {
                    For.Remove(ret);
                }
                return ret;
            }
            public bool ContainsKey(int id)
            {
                return Map.ContainsKey(id);
            }
            public void Clear()
            {
                Map.Clear();
                For.Clear();
            }
        }
        public class SkillState
        {
            readonly public SkillTemplate Data;
            readonly public ZoneUnit Owner;

            private SkillActiveState current_state;
            private int all_action_time_ms;
            private int pass_time_ms;
            private int stop_time_ms;
            private float percent = 1f;
            private float action_speed = 1f;
            private int total_cd_time_ms;
            private bool is_in_mutil_time = false;
            private bool is_period_cd_end = false;

            //新增蓄力
            private ActionEnum action_type;
            //新增使用次数
            private int use_Times;
            private bool is_use_tiems = false;
            private bool is_skill_end = false;
            private bool is_Skill_Block = false;
            //新增技能描述类型
            private SkillDescType skill_desc_type = SkillDescType.None;

            //当前技能是否还从未触发过
            private bool is_skill_never_launch;

            //CD状态变化事件
            public System.Action OnCDStateChange;

            //蓄力状态发生了变化
            public System.Action OnChargeStateChange;
            //蓄力条进度
            public float ChargeProgress { private set; get; }

            internal SkillState(SkillTemplate data, ZoneUnit owner)
            {
                this.Data = data;
                this.Owner = owner;
                this.all_action_time_ms = Data.ActionQueueTimeMS;
                this.total_cd_time_ms = data.CoolDownMS;
                this.pass_time_ms = stop_time_ms = FullCDTimeMS;
                this.pass_time_ms = data.CoolDownMS;
                this.is_in_mutil_time = Data.IsSingleAction;
                this.use_Times = (int)data.CurUseTimes;
                this.is_use_tiems = this.use_Times >= 0 ? true : false;
                //以服务器为主，服务器那边目前没有做具体细分
                if (data.ActionPriority < 0)
                {
                    skill_desc_type = SkillDescType.Displacement;
                }
                this.is_skill_never_launch = true;
            }

            internal bool TryLaunch(UnitLaunchSkillAction act)
            {
                if (IsActive &&
                    Owner.MP >= Data.CostMP &&
                    Owner.HP >= Data.CostHP &&
                    (!IsCD))
                {
                    return true;
                }
                return false;
            }

            internal void Launch(UnitLaunchSkillEvent evt)
            {
                this.is_skill_never_launch = false;
                this.percent = 0;
                this.pass_time_ms = 0;
                this.is_skill_end = false;
                this.CurrentActionID = evt.action_index;
                this.action_type = Data.ActionQueue[evt.action_index].SigleActionType;
                this.is_Skill_Block = Data.ActionQueue[evt.action_index].IsAddSkillBtnBlock;
                //ClientLog.LogWarning(">launch SkillState >{0} @ {1}, isMulti:{2}", CurrentActionID, this.Data.TemplateID, this.is_in_mutil_time);

                if (CurrentActionID + 1 == Data.ActionQueue.Count)
                {
                    this.is_period_cd_end = this.Data.IsSingleAction;
                }
                if (evt.IsActionSpeedUP)
                {
                    this.action_speed = evt.action_speed;
                }
                else
                {
                    this.action_speed = 1f;
                }
                if (evt.IsChangeTotalCDTime)
                {
                    this.total_cd_time_ms = evt.TotalCDTimeMS;
                }
                else
                {
                    this.total_cd_time_ms = ToFullTimeCD();
                    this.is_skill_end = true;
                    //ClientLog.LogError("is_skill_end: true");
                }
                OnCDStateChange?.Invoke();
                if (Data.ActionQueue[CurrentActionID].ShowChargeTimeMS > 0)
                {
                    ChargeProgress = 0f;
                    OnChargeStateChange?.Invoke();
                }
                else if (ChargeProgress > 0 && ChargeProgress < 1)
                {
                    ChargeProgress = 1f;
                    OnChargeStateChange?.Invoke();
                }
            }
            public byte NextAction()
            {
                if (Data.IsSingleAction)
                {
                    int action_step = CurrentActionID;
                    int action_time = this.FullCDTimeMS;
                    if (Data.IsCoolDownWithAction)
                    {
                        action_time = Data.ActionQueue[action_step % Data.ActionQueue.Count].TotalTimeMS;
                    }
                    // 是放技能时，处于多段攻击连击冷却时间范围
                    if (pass_time_ms - stop_time_ms < Data.SingleActionCoolDownMS || pass_time_ms < (action_time + Data.SingleActionCoolDownMS))
                    {
                        action_step += 1;
                        action_step = (byte)(action_step % Data.ActionQueue.Count);
                        return (byte)action_step;
                    }
                }
                return 0;
            }

            private int ToFullTimeCD()
            {
                if (Data.IsCoolDownWithAction)
                {
                    if (Data.IsSingleAction)
                    {
                        return Data.ActionQueue[CurrentActionID].TotalTimeMS;
                    }
                    else
                    {
                        return all_action_time_ms;
                    }
                }
                return Data.ToUnitSkillTotalTime(Owner.mFastCastRate);
            }
            internal void SetActive(SkillActiveState state)
            {
                this.current_state = state;
            }
            internal void ChangeAction(int step)
            {
                this.CurrentActionID = step;
            }
            internal void ClearCD()
            {
                this.pass_time_ms = FullCDTimeMS;
            }
            internal void DecreaseCD(int ms)
            {
                this.pass_time_ms += ms;
            }
            internal void DecreaseCD_Pct(float pct)
            {
                this.pass_time_ms += (int)(FullCDTimeMS * pct);
            }
            internal void PlayerStop(PlayerSkillStopEvent stop)
            {
                this.stop_time_ms = pass_time_ms;
                this.is_skill_end = true;
                this.is_Skill_Block = false;
                if (ChargeProgress > 0 && ChargeProgress < 1)
                {
                    ChargeProgress = 1f;
                    OnChargeStateChange?.Invoke();
                }
            }
            internal void Sync(ClientStruct.UnitSkillStatus syn)
            {
                this.pass_time_ms = syn.PassTime;
                this.use_Times = syn.useTimes;
                this.is_use_tiems = syn.useTimes >= 0 ? true : false;
                internal_update();
            }
            internal void TimeChange(PlayerSkillTimeChangedEvent e)
            {
                if (this.is_skill_never_launch)
                {
                    //重新登录后，技能的状态会丢失，这里重新算一下
                    if(e.SkillPassTimeMS < e.SkillTotalTimeMS)
                    {
                        //CD未结束的技能，action都是在最后一段（不然不会有CD）
                        this.CurrentActionID = Data.ActionQueue.Count - 1;
                    }
                }

                this.pass_time_ms = e.SkillPassTimeMS;
                this.total_cd_time_ms = e.SkillTotalTimeMS;
                this.is_in_mutil_time = this.Data.IsSingleAction;
                this.is_period_cd_end = this.Data.IsSingleAction;
                this.is_Skill_Block = false;
                this.is_skill_end = true;
                internal_update();
                OnCDStateChange?.Invoke();
                if(ChargeProgress > 0 && ChargeProgress < 1)
                {
                    ChargeProgress = 1f;
                    OnChargeStateChange?.Invoke();
                }
            }
            internal void Update(int intervalMS)
            {
                if (!IsActive && IsPauseOnDeactive) { return; }
                this.pass_time_ms += intervalMS;
                internal_update();
                if (this.isPeriodCDEnd)
                {
                    SetMutilTime();
                }

                var aq = Data.ActionQueue[CurrentActionID];
                if (aq.ShowChargeTimeMS > 0)
                {
                    if (ChargeProgress < 1)
                    {
                        ChargeProgress = pass_time_ms / aq.ShowChargeTimeMS;
                        if (ChargeProgress > 1) ChargeProgress = 1f;
                        OnChargeStateChange?.Invoke();
                    }
                }
                else if (ChargeProgress > 0 && ChargeProgress < 1)
                {
                    ChargeProgress = 1f;
                    OnChargeStateChange?.Invoke();
                }
            }
            internal void SetPassTime(int passTime)
            {
                this.pass_time_ms = passTime;
                internal_update();
            }

            void SetMutilTime()
            {
                if (CDPercent < 1)
                {
                    this.is_in_mutil_time = false;
                }
                else
                {
                    this.is_in_mutil_time = true;
                    this.is_period_cd_end = false;
                }
            }

            private void internal_update()
            {
                if (pass_time_ms >= FullCDTimeMS)
                {
                    if (percent < 1)
                    {
                        percent = 1f;
                        stop_time_ms = pass_time_ms;
                        OnCDStateChange?.Invoke();
                    }
                }
                else
                {
                    percent = (float)pass_time_ms / FullCDTimeMS;
                }
            }

            //新增技能使用次数
            internal void SyncSkillUseTimes(int usetimes)
            {
                this.use_Times = usetimes;
                this.is_use_tiems = true;
            }

            public int FullCDTimeMS
            {
                get
                {
                    return total_cd_time_ms;
                }
            }

            public bool isMutilTime
            {
                get { return this.is_in_mutil_time; }
            }

            public bool isPeriodCDEnd
            {
                get { return this.is_period_cd_end; }
            }

            public bool IsCD
            {
                get
                {
                    if (Data.IsCoolDownWithAction)
                    {
                        return false;
                    }
                    return (percent < 1f);
                }
            }
            public float CDPercent
            {
                get
                {
                    if (Data.IsCoolDownWithAction)
                    {
                        return 1f;
                    }
                    return percent;
                }
            }
            public float ActionSpeed { get { return action_speed; } }
            public int PassTimeMS { get { return pass_time_ms; } }
            public int StopTimeMS { get { return stop_time_ms; } }
            public int CurrentActionID { get; private set; }
            public SkillActiveState ActiveState { get { return current_state; } }
            public bool IsActive { get { return current_state == SkillActiveState.Active || current_state == SkillActiveState.ActiveAndHide; } }
            public bool IsPauseOnDeactive { get { return current_state == SkillActiveState.DeactiveAndPause; } }
            public ActionEnum ActionType { get { return action_type; } }
            public int UseTimes { get { return this.use_Times; } }
            public bool IsUseTimes { get { return this.is_use_tiems; } }
            //目前仅用于蓄力，后面如果有其它类型需要用到，注意TimeChange和StopSkill消息的顺序.......
            public bool IsSkillEnd {
                get { return this.is_skill_end; }
            }
            public bool IsSkillBlock { get { return this.is_Skill_Block; } }
            public SkillDescType SkillType { get { return this.skill_desc_type; } }
        }

        [Obsolete]
        public List<SkillState> GetSkillStatus()
        {
            return new List<SkillState>(mSkillStatus.Skills);
        }
        public void GetSkillStatus(List<SkillState> ret)
        {
            ret.AddRange(mSkillStatus.Skills);
        }

        public SkillState GetSkillState(int templateID)
        {
            return mSkillStatus.Get(templateID);
        }

        #endregion

        //---------------------------------------------------------------------------
        // skill action
        //---------------------------------------------------------------------------
        #region SkillAction

        /// <summary>
        /// 是否正在吟唱
        /// </summary>
        public bool IsChanttingSkill
        {
            get { return mChantingSkill != null; }
        }
        public int ChantingSkillPassMS
        {
            get { return (mChantingSkill != null) ? mChantingSkill.PassTimeMS : 0; }
        }
        public int ChantingSkillTotalMS
        {
            get { return (mChantingSkill != null) ? mChantingSkill.TotalTimeMS : 0; }
        }
        public SkillTemplate ChantingSkillData
        {
            get { return (mChantingSkill != null) ? mChantingSkill.Tag : null; }
        }
        public SkillState ChantingSkill
        {
            get { if (mChantingSkill != null) { return GetSkillState(mChantingSkill.Tag.TemplateID); } return null; }
        }
        private TimeExpire<SkillTemplate> mChantingSkill;

        protected virtual void DoUnitChantSkillEvent(UnitChantSkillEvent e)
        {
            var temp = Templates.getSkill(e.skill_id);
            mChantingSkill = new TimeExpire<SkillTemplate>(temp, e.chant_ms);
            SkillState ss = GetSkillState(e.skill_id);
            if (ss != null)
            {
                if (mOnChantSkill != null)
                {
                    mOnChantSkill.Invoke(this, e, mChantingSkill);
                }
            }
        }
        protected virtual void doLaunchSkillAction(UnitLaunchSkillEvent me)
        {
            clearSkillAction();
            var temp = Templates.getSkill(me.skill_id);
            if (temp != null)
            {
                mCurrentSkillAction = new UnitSkillAction(this, temp);
                mCurrentSkillAction.onLaunch(me);
                invokeSkillActionStart(mCurrentSkillAction);
            }
        }
        protected virtual void invokeSkillActionStart(ISkillAction act)
        {
            if (mOnSkillActionStart != null)
            {
                mOnSkillActionStart.Invoke(this, act);
            }
        }
        public virtual ISkillAction CurrentSkillAction
        {
            get { return mCurrentSkillAction; }
        }
        public virtual UnitActionData CurrentSkillActionData
        {
            get
            {
                if (CurrentSkillAction != null)
                {
                    return CurrentSkillAction.CurrentAction;
                }
                return null;
            }
        }

        //-------------------------------------------------------------------------------------------
        // unit impl
        private UnitSkillAction mCurrentSkillAction;
        private void updateSkillAction(int intervalMS)
        {
            if (mCurrentSkillAction != null)
            {
                //UnityEngine.Debug.LogError("2 mCurrentSkillAction = " + mCurrentSkillAction.SkillData.TemplateID + "  actionIndex = " + mCurrentSkillAction.CurrentActionIndex);
                mCurrentSkillAction.onUpdate(intervalMS);
                if (mCurrentSkillAction.IsDone)
                {
                    clearSkillAction();
                }
            }
        }
        private void clearSkillAction()
        {
            if (mCurrentSkillAction != null)
            {
                mCurrentSkillAction.onStop();
                mCurrentSkillAction = null;
            }
        }

        public abstract class ISkillAction
        {
            private BitSet8 current_action_status = new BitSet8();
            public bool IsControlMoveable { get { return current_action_status.Get(0); } protected set { current_action_status.Set(0, value); } }
            public bool IsControlFaceable { get { return current_action_status.Get(1); } protected set { current_action_status.Set(1, value); } }
            public bool IsCancelableBySkill { get { return current_action_status.Get(2); } protected set { current_action_status.Set(2, value); } }
            public bool IsCancelableByMove { get { return current_action_status.Get(3); } protected set { current_action_status.Set(3, value); } }
            public bool IsNoneBlock { get { return current_action_status.Get(4); } protected set { current_action_status.Set(4, value); } }
            public bool IsNoneTouch { get { return current_action_status.Get(5); } protected set { current_action_status.Set(5, value); } }
            public bool IsFaceToTarget { get { return current_action_status.Get(6); } protected set { current_action_status.Set(6, value); } }

            public abstract SkillTemplate SkillData { get; }
            public abstract UnitLaunchSkillEvent LaunchEvent { get; }
            public abstract bool IsDone { get; }
            public abstract float ActionSpeed { get; }
            public abstract byte ActionStepIndex { get; }
            public abstract int[] ActionTimeArray { get; }
            public abstract int TotalTimeMS { get; }
            public abstract int CurrentActionIndex { get; }
            public abstract string CurrentActionName { get; }
            public abstract UnitActionData CurrentAction { get; }
            public abstract float ExpirePercent { get; }

            //把当前的执行时间抛出去给客户端用，很违和的做法，没办法数据配在扩展属性里面
            //CommonAI取不出来，强行操作会引发不可控的Bug
            public abstract int CurPassTimeMS { get; }

            public abstract bool IsJumpAction { get; }
            
            internal abstract void onLaunch(UnitLaunchSkillEvent e);
            internal abstract void onUnitSkillActionChangeEvent(UnitSkillActionChangeEvent evt);
            internal abstract void onUpdate(int intervalMS);
            internal abstract void onStop();
            internal abstract void RestJumpAction(bool isJumpAction);
        }

        public class UnitSkillAction : ISkillAction
        {
            readonly private ZoneUnit ownerUnit;
            readonly private SkillTemplate skill;
            private UnitLaunchSkillEvent launch_event;

            private int current_pass_time = 0;
            private int total_pass_time = 0;
            private int total_time_ms = 0;
            private bool is_done = false;
            private bool is_jump_action = false;
            private Queue<UnitActionData> action_queue;
            private int current_action_index = 0;
            private UnitActionData current_action = null;
            private PopupKeyFrames<UnitActionData.KeyFrame> current_frames = new PopupKeyFrames<UnitActionData.KeyFrame>();
            private int current_action_total_time = 0;
            private int[] action_time_array;

            public ZoneLayer Parent { get { return ownerUnit.Parent; } }

            public override int[] ActionTimeArray { get { return action_time_array; } }
            public override int TotalTimeMS { get { return total_time_ms; } }
            
            public override byte ActionStepIndex { get { return (launch_event != null) ? launch_event.action_index : (byte)0; } }
            public override int CurrentActionIndex { get { return current_action_index; } }
            public override string CurrentActionName { get { return (current_action != null) ? current_action.ActionName : null; } }
            public override UnitActionData CurrentAction { get { return current_action; } }
            public override float ExpirePercent { get { return total_pass_time / (float)TotalTimeMS; } }
            public override SkillTemplate SkillData { get { return skill; } }
            public override UnitLaunchSkillEvent LaunchEvent { get { return launch_event; } }
            public override bool IsDone { get { return is_done; } }
            public override int CurPassTimeMS { get { return current_pass_time; } }

            protected internal UnitSkillAction(ZoneUnit actor, SkillTemplate skill)
            {
                this.skill = skill;
                this.ownerUnit = actor;
                this.action_time_array = skill.ActionQueueTimeArray;
            }

            public override float ActionSpeed
            {
                get
                {
                    if (launch_event != null)
                    {
                        if(launch_event.action_speed_add != null && launch_event.action_index < launch_event.action_speed_add.Length)
                        {
                            return launch_event.action_speed + launch_event.action_speed_add[launch_event.action_index];
                        }

                        return launch_event.action_speed;
                    }

                    return 1f;
                }
            }

            public override bool IsJumpAction
            {
                get
                {
                    return is_jump_action;
                }
            }

            internal override void onLaunch(UnitLaunchSkillEvent e)
            {
                //UnityEngine.Debug.LogError("SkillID = " + e.skill_id + "   ActionSpeed = " + e.action_speed + "   action_index = " + e.action_index);
                this.launch_event = e;
                this.total_pass_time = 0;
                this.current_pass_time = 0;
                if (e.action_time_array != null && e.action_time_array.Length > 0)
                {
                    this.total_time_ms = e.TotalActionTimeMS;
                    this.action_time_array = e.action_time_array;
                }
                else if (skill.IsSingleAction)
                {
                    this.total_time_ms = skill.ActionQueue[launch_event.action_index].TotalTimeMS;
                    this.action_time_array = new int[] { TotalTimeMS };
                }
                else
                {
                    this.total_time_ms = skill.ActionQueueTimeMS;
                    this.action_time_array = skill.ActionQueueTimeArray;
                }
                if (skill.IsSingleAction)
                {
                    var sa = skill.ActionQueue[launch_event.action_index];
                    this.action_queue = new Queue<UnitActionData>(1);
                    this.action_queue.Enqueue(sa);
                    this.current_action_index = launch_event.action_index;
                }
                else
                {
                    this.action_queue = new Queue<UnitActionData>(skill.ActionQueue);
                    this.current_action_index = launch_event.action_index;
                }

                this.current_action = null;
                this.nextAction(this.current_action_index);
            }
            internal override void onUnitSkillActionChangeEvent(UnitSkillActionChangeEvent e)
            {
                while (this.CurrentActionIndex < e.ActionIndex)
                {
                    if (!nextAction(current_action_index + 1))
                    {
                        this.total_pass_time = TotalTimeMS;
                        this.is_done = true;
                        break;
                    }
                }
            }
            internal override void onStop()
            {
                this.is_done = true;
                this.total_pass_time = TotalTimeMS;
            }
            internal override void onUpdate(int intervalMS)
            {
                int time_pass = (int)(intervalMS * ActionSpeed);
                this.total_pass_time += time_pass;
                this.total_pass_time = Math.Min(total_pass_time, TotalTimeMS);
                this.current_pass_time += time_pass;

                if (current_action == null)
                {
                    nextAction(current_action_index + 1);
                }
                if (current_action == null)
                {
                    this.is_done = true;
                    this.total_pass_time = TotalTimeMS;
                }
                else
                {
                    // 关键帧 //
                    using (var kfs = ListObjectPool<UnitActionData.KeyFrame>.AllocAutoRelease())
                    {
                        if (current_frames.PopKeyFrames(current_pass_time, kfs) > 0)
                        {
                            for (int i = 0; i < kfs.Count; i++)
                            {
                                doKeyFrame(kfs[i]);
                            }
                        }
                    }
                    // 下段动作 //
                    if ((current_action != null) && (current_pass_time >= current_action_total_time))
                    {
                        current_action = null;
                        if (action_queue.Count == 0)
                        {
                            this.is_done = true;
                            this.total_pass_time = TotalTimeMS;
                        }
                    }
                }
            }

            private bool nextAction(int index)
            {
                if (action_queue != null && action_queue.Count > 0)
                {
                    this.current_action_index = index;
                    this.current_action = action_queue.Dequeue();
                    if (current_action != null)
                    {
                        this.current_frames.AddRange(current_action.KeyFrames);
                        this.current_pass_time = 0;
                        //NewAction//
                        if (launch_event.action_time_array != null)
                        {
                            if (skill.IsSingleAction)
                            {
                                this.current_action_total_time = launch_event.TotalActionTimeMS;
                            }
                            else if (current_action_index < launch_event.action_time_array.Length)
                            {
                                this.current_action_total_time = launch_event.action_time_array[current_action_index];
                            }
                        }
                        else
                        {
                            this.current_action_total_time = current_action.TotalTimeMS;
                        }
                        this.IsCancelableBySkill = current_action.IsCancelableBySkill;
                        this.IsNoneBlock = current_action.IsNoneBlock;
                        this.IsNoneTouch = current_action.IsNoneTouch;
                        this.IsFaceToTarget = current_action.IsFaceToTarget;
                        this.IsCancelableByMove = current_action.IsCancelable;
                        this.IsControlMoveable = current_action.IsControlMoveable;
                        this.IsControlFaceable = current_action.IsControlFaceable;
                        return true;
                    }
                }
                current_action = null;
                return false;
            }

            private void doKeyFrame(UnitActionData.KeyFrame kf)
            {
                // 关键帧改变状态
                if (kf.ChangeStatus != null)
                {
                    this.IsNoneBlock = kf.ChangeStatus.IsNoneBlock;
                    this.IsNoneTouch = kf.ChangeStatus.IsNoneTouch;
                    this.IsFaceToTarget = kf.ChangeStatus.IsFaceToTarget;
                    this.IsCancelableByMove = kf.ChangeStatus.IsCancelable;
                    this.IsCancelableBySkill = kf.ChangeStatus.IsCancelableBySkill;
                    this.IsControlMoveable = kf.ChangeStatus.IsControlMoveable;
                    this.IsControlFaceable = kf.ChangeStatus.IsControlFaceable;
                }
            }

            internal override void RestJumpAction(bool isJumpAction)
            {
                is_jump_action = isJumpAction;
            }
        }

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

        #endregion

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

        #region Buff

        internal BuffMap mBuffStatus = new BuffMap();

        internal void SyncBuffStatus(ClientStruct.UnitBuffStatus[] buffs)
        {
            if (buffs != null)
            {
                for (int i = 0; i < buffs.Length; i++)
                {
                    ClientStruct.UnitBuffStatus st = buffs[i];
                    TryAddBuff(st.BuffTemplateID, st.SenderID, st.IsEquip, st.TotalTime, st.OverlayLevel, st.PassTime);
                }
            }
        }

        protected void SyncBuffOverlayLevel(BuffDataNotify data)
        {
            BuffState bs = mBuffStatus.Get(data.buffId, data.senderId);
            if (bs != null)
            {
                bs.SyncBuffExtData(data.overlayLevel, bs.BuffExtendData);
                //YXJDebug.logError(data.buffId + " , level:" + bs.OverlayLevel + " time = " + bs.BuffTotalTime + ", per:"+bs.CDPercent);
                if (mOnBuffChanged != null)
                {
                    mOnBuffChanged.Invoke(this, bs);
                }
            }
        }

        protected virtual void DoLaunchBuff(UnitLaunchBuffEvent me)
        {
            //YXJDebug.logError(me.buffTemplateID +  " overlayLevel = " + me.overlayLevel + " time = " + me.buffTimeMS);
            TryAddBuff(me.buffTemplateID, me.senderID, me.IsEquip, me.buffTimeMS, me.overlayLevel, 0, me.buffExtData);
        }

        protected virtual void DoStopBuff(UnitStopBuffEvent e)
        {
            TryRemoveBuff(e.buffTemplateID, e.senderID);
        }

        //新增Buff接口
        protected virtual void DoRemoveOverlayLevelBuff(SyncUnitBuffState e)
        {
            //UnityEngine.Debug.LogError("DoRemoveOverlayLevelBuff overlayLevel = " + e.overlayLevel + "   buffExtData = " + e.buffExtData);
            if (e.buffExtData > 0)
            {
                var bs = mBuffStatus.Get(e.buffTemplateID, e.ObjectID);
                if (bs != null && mOnRemoveBuffByOverlayLeveled != null)
                {
                    mOnRemoveBuffByOverlayLeveled(this, bs);
                    bs.SyncBuffExtData(e.overlayLevel, e.buffExtData);
                }
            }
            else
            {
                TryRemoveBuff(e.buffTemplateID, e.ObjectID);
            }
        }

        private void TryAddBuff(int buffTempalteID, uint senderID, bool isEquip, int totalTime, byte overlayLevel, int passTime = 0, int buffExtData = 0)
        {
            BuffTemplate buff = Templates.getBuff(buffTempalteID);
            if (buff != null)
            {
                BuffState bs = mBuffStatus.Get(buffTempalteID, senderID);
                if (bs != null)
                {
                    bs.Sync(overlayLevel, totalTime, passTime, buffExtData);
                    if (mOnBuffChanged != null)
                    {
                        mOnBuffChanged.Invoke(this, bs);
                    }
                }
                else
                {
                    bs = new BuffState(buff, this, senderID, isEquip);
                    bs.Sync(overlayLevel, totalTime, passTime, buffExtData);
                    mBuffStatus.Put(bs);
                    if (mOnBuffAdded != null)
                    {
                        mOnBuffAdded.Invoke(this, bs);
                    }
                }

                //UnityEngine.Debug.LogError("Server buffID = " + buffTempalteID + "  LockStateAction = " + buff.LockStateAction);
                //新增单独状态
                if (!string.IsNullOrEmpty(buff.LockStateAction))
                {
                    this.SetCurrentState(UnitActionStatus.BuffLockStateAction, CurrentSubState, buff);
                }
            }
        }
        private void TryRemoveBuff(int buffTempalteID, uint senderID)
        {
            BuffState bs = mBuffStatus.RemoveByKey(buffTempalteID, senderID);
            if (bs != null)
            {
                bs.OnEnd();
                if (mOnBuffRemoved != null)
                {
                    mOnBuffRemoved.Invoke(this, bs);
                }

                //UnityEngine.Debug.LogError("RemoveBuff  CurrentState= " + CurrentState);
                //置回单独状态
                if (CurrentState == UnitActionStatus.BuffLockStateAction)
                {
                    this.SetCurrentState(UnitActionStatus.Idle);
                }
            }
        }
        private void UpdateBuffs(int intervalMS)
        {
            mBuffStatus.ForEachUpdate(intervalMS);
            //mBuffStatus.ForEach((bs) =>
            //{
            //    bs.OnUpdate(intervalMS);
            //});
        }

        //返回当前buff列表中，是否含有变身buff
        public bool HasMakeAvatarBuff()
        {
            bool has = false;
            mBuffStatus.ForEach((BuffState buf) => {
                if (buf.Data.MakeAvatar)
                {
                    has = true;
                }
            });
            return has;
        }
        //返回当前buff列表中，是否含有切换技能buff
        public bool HasChangeSkillBuff()
        {
            bool has = false;
            mBuffStatus.ForEach((BuffState buf) => {
                if (buf.Data.UnitChangeSkills)
                {
                    has = true;
                }
            });
            return has;
        }

        public class BuffMap
        {
            private HashMap<int, BuffList> Map = new HashMap<int, BuffList>();
            private List<BuffList> For = new List<BuffList>();

            public BuffState Get(int id, uint senderID)
            {
                var list = Map.Get(id);
                if (list != null)
                {
                    return list.Get(senderID);
                }
                return null;
            }
            internal void Put(BuffState state)
            {
                var list = Map.Get(state.BuffID);
                if (list == null)
                {
                    list = new BuffList(state.Data);
                    Map.Add(state.BuffID, list);
                    For.Add(list);
                }
                list.Add(state);
            }
            internal BuffState RemoveByKey(int id, uint senderID)
            {
                var list = Map.Get(id);
                if (list != null)
                {
                    var st = list.Get(senderID);
                    if (st != null)
                    {
                        var ret = list.Remove(senderID);
                        if (list.Count == 0)
                        {
                            For.Remove(list);
                            Map.Remove(id);
                        }
                        return ret;
                    }
                }
                return null;
            }
            internal void Clear()
            {
                For.Clear();
                Map.Clear();
            }

            public void ForEach(Action<BuffState> action)
            {
                for (int i = For.Count - 1; i >= 0; --i)
                {
                    For[i].ForEach(action);
                }
            }

            public int GetBuffCount()
            {
                return For.Count;
            }


            public void ForEachUpdate(int intervalMS)
            {
                for (int i = For.Count - 1; i >= 0; --i)
                {
                    For[i].ForEachUpdate(intervalMS);
                }
            }


            public class BuffList
            {
                public readonly BuffTemplate Data;
                private HashMap<uint, BuffState> Map = new HashMap<uint, BuffState>();
                private List<BuffState> For = new List<BuffState>();
                public int Count { get { return Map.Count; } }
                internal BuffList(BuffTemplate data)
                {
                    this.Data = data;
                }
                internal BuffState Remove(uint senderID)
                {
                    BuffState ret;
                    if (Data.IsDuplicating)
                    {
                        ret = Map.RemoveByKey(senderID);
                    }
                    else
                    {
                        ret = Map.RemoveByKey(0);
                    }
                    if (ret != null)
                    {
                        For.Remove(ret);
                    }
                    return ret;
                }
                internal void Add(BuffState state)
                {
                    if (Data.IsDuplicating)
                    {
                        Map.Add(state.SenderID, state);
                    }
                    else
                    {
                        Map.Add(0, state);
                    }
                    For.Add(state);
                }
                internal BuffState Get(uint senderID)
                {
                    if (Data.IsDuplicating)
                    {
                        if (senderID == 0 && Map.Count > 0)
                        {
                            return Map.First().Value;
                        }
                        else
                        {
                            return Map.Get(senderID);
                        }
                    }
                    else
                    {
                        return Map.Get(0);
                    }
                }

                internal void ForEach(Action<BuffState> action)
                {
                    for (int i = For.Count - 1; i >= 0; --i)
                    {
                        action(For[i]);
                    }
                }

                public void ForEachUpdate(int intervalMS)
                {
                    for (int i = For.Count - 1; i >= 0; --i)
                    {
                        For[i].OnUpdate(intervalMS);
                    }
                }
            }
        }
        public class BuffState
        {
            readonly public BuffTemplate Data;
            readonly public bool isEquip;
            readonly public ZoneUnit Owner;
            readonly public uint SenderID;

            private byte overlay_level;
            private int total_time;
            private int pass_time = 0;
            private float percent = 1f;
            private int buff_ext_data = 0;
            private int buff_ext_data_index = -1;

            private TimeInterval<BuffTemplate.KeyFrame> interval;
            private PopupKeyFrames<BuffTemplate.KeyFrame> keyframes;

            internal BuffState(BuffTemplate data, ZoneUnit owner, uint senderID, bool isEquip)
            {
                this.Data = data;
                this.isEquip = isEquip;
                this.Owner = owner;
                this.SenderID = senderID;
            }

            internal void Sync(byte overlayLevel, int totalTime, int passTime, int buffExtData = 0)
            {
                this.overlay_level = overlayLevel;
                this.total_time = totalTime;
                if (passTime < this.pass_time || this.pass_time == 0)
                {
                    this.interval = new TimeInterval<BuffTemplate.KeyFrame>(Data.HitIntervalMS);
                    this.interval.Tag = Data.HitKeyFrame;
                    this.keyframes = new PopupKeyFrames<BuffTemplate.KeyFrame>();
                    this.keyframes.AddRange(Data.KeyFrames);
                    this.pass_time = 0;
                }
                if (passTime > this.pass_time)
                {
                    this.interval.SetPassTime(passTime);
                    this.keyframes.PopKeyFrames(passTime, null);
                    this.pass_time = passTime;
                }
                this.percent = Math.Min(1, pass_time / (float)total_time);
                this.buff_ext_data = buffExtData;
                SetBuffExtendDataIndex(buffExtData);
            }

            internal void OnEnd()
            {
                if (Data.EndKeyFrame != null && Data.EndKeyFrame.Effect != null)
                {
                    Owner.Parent.PreQueueEvent(new UnitEffectEvent(Owner.ObjectID, Data.EndKeyFrame.Effect));
                }
            }

            internal void OnUpdate(int intervalMS)
            {
                using (var kfs = ListObjectPool<BuffTemplate.KeyFrame>.AllocAutoRelease())
                {
                    if (keyframes.PopKeyFrames(pass_time, kfs) > 0)
                    {
                        for (int i = 0; i < kfs.Count; i++)
                        {
                            BuffTemplate.KeyFrame kf = kfs[i];
                            if (kf.Effect != null)
                            {
                                Owner.Parent.PreQueueEvent(new UnitEffectEvent(Owner.ObjectID, kf.Effect));
                            }
                        }
                    }
                }
                if (interval.Update(intervalMS))
                {
                    if (Data.HitKeyFrame != null && Data.HitKeyFrame.Effect != null)
                    {
                        Owner.Parent.PreQueueEvent(new UnitEffectEvent(Owner.ObjectID, Data.HitKeyFrame.Effect));
                    }
                }
                this.pass_time += intervalMS;
                if (percent < 1f)
                {
                    this.percent = Math.Min(1, pass_time / (float)total_time);
                }
            }

            public void SyncBuffExtData(byte overlayLevel, int buffExtData)
            {
                overlay_level = overlayLevel;
                buff_ext_data = buffExtData;
            }

            private void SetBuffExtendDataIndex(int curBuffExtData)
            {
                if (curBuffExtData < 1) return;
                if (curBuffExtData < 10)
                {
                    buff_ext_data_index = curBuffExtData;
                }
                else
                {
                    string curString = Convert.ToString(curBuffExtData);
                    var str = curString.Substring(curString.Length - 1, 1);
                    if (!string.IsNullOrEmpty(str))
                    {
                        int.TryParse(str, out buff_ext_data_index);
                    }
                }
            }
            
            public int BuffID { get { return Data.ID; } }
            public bool IsDone { get { return (isEquip) ? false : (percent >= 1f); } }
            public float CDPercent { get { return percent; } }
            public byte OverlayLevel { get { return overlay_level; } }

            public int BuffTotalTime { get { return total_time; } }
            public int BuffLeftTime { get { return total_time - pass_time; } }
            public int BuffExtendData { get { return buff_ext_data; } }
            public int BuffExtendDataIndex { get { return buff_ext_data_index; } }
        }

        [Obsolete]
        public List<BuffState> GetBuffStatus()
        {
            var list = new List<BuffState>();
            GetBuffStatus(list);
            return list;
        }
        public void GetBuffStatus(List<BuffState> ret)
        {
            mBuffStatus.ForEach((bs) => { ret.Add(bs); });
        }

        public int GetBuffStatusCount()
        {
            return mBuffStatus.GetBuffCount();
        }

        public BuffState GetBuff(int tempID, uint senderID)
        {
            return mBuffStatus.Get(tempID, senderID);
        }
        public BuffState GetBuff(int tempID)
        {
            return mBuffStatus.Get(tempID, 0);
        }

        #endregion

        //--------------------------------------------------------------------------------
        #region PickObject

        private TimeExpire<UnitStartPickObjectEvent> mPickEvent;
        public TimeExpire<UnitStartPickObjectEvent> PickEvent { get { return mPickEvent; } }

        protected virtual void DoStartPick(UnitStartPickObjectEvent pick)
        {
            mPickEvent = new TimeExpire<UnitStartPickObjectEvent>(pick, pick.PickTimeMS);
            SetCurrentState(UnitActionStatus.Pick, pick);
            if (mOnStartPickObject != null)
            {
                mOnStartPickObject.Invoke(this, mPickEvent);
            }
        }
        protected virtual void DoStopPick(UnitStopPickObjectEvent pick)
        {
            if (mPickEvent != null)
            {
                mPickEvent.End();
                mPickEvent = null;
            }
            if (mOnStopPickObject != null)
            {
                mOnStopPickObject.Invoke(this, pick);
            }
        }

        private void UpdatePickEvent(int intervalMS)
        {
            if (mPickEvent != null)
            {
                mPickEvent.Update(intervalMS);
            }
        }

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

        #region 本地技能预演
        protected virtual void DoJumpToTargetEnd()
        {
            if (mOnClientSkillSimulation != null)
            {
                mOnClientSkillSimulation.Invoke(this, SimulationSkillEnum.JumpEnd);
            }
        }
        #endregion 本地技能预演

        #region MultiTimeLine


        /// <summary>
        /// 是否可被发现
        /// </summary>
        virtual public bool IsVisible { get { return !IsTimeLineEnable(2); } }
        /// <summary>
        /// 是否无敌
        /// </summary>
        virtual public bool IsInvincible { get { return IsTimeLineEnable(3); } }
        /// <summary>
        /// 此单位是否霸体
        /// </summary>
        virtual public bool IsNoneBlock { get { return IsTimeLineEnable(0); } }
        /// <summary>
        /// 是否为眩晕
        /// </summary>
        virtual public bool IsStun { get { return IsTimeLineEnable(1); } }
        /// <summary>
        /// 是否沉默
        /// </summary>
        virtual public bool IsSilent { get { return IsTimeLineEnable(4); } }
        //--------------------------------------------------------------------------------

        private UnitSyncMultiTimeLine mMultiTimeLine;

        private void DoUnitSyncMultiTimeLine(UnitSyncMultiTimeLine e)
        {
            this.mMultiTimeLine = e;
        }

        /// <summary>
        /// 指定TimeLine是否还有任务
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public bool IsTimeLineEnable(int index)
        {
            if (mMultiTimeLine != null && mMultiTimeLine.timelines != null && index < mMultiTimeLine.timelines.Count && index >= 0)
            {
                return mMultiTimeLine.timelines[index];
            }
            return false;
        }

        public void GetMultiTimeLineStatus(List<bool> list)
        {
            if (mMultiTimeLine != null && mMultiTimeLine.timelines != null)
            {
                list.AddRange(mMultiTimeLine.timelines);
            }
        }

        #endregion
    }
}