WSHCommon/Common/CommonAI/ZoneClient/ZoneObject.Unit.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 CommonAI.ZoneClient.Agent;

namespace CommonAI.ZoneClient
{
    public partial class ZoneUnit : ZoneObject
    {
        public readonly SyncUnitInfo SyncInfo;
        public readonly UnitInfo Info;
        public readonly bool IsAttackRangeIncludeBodySize;

        // Status
        private int mHP;
        private int mMP;
        private int mSP;
        private int mMaxHP;
        private int mMaxMP;
        private int mMaxSP;
        private float mMoveSpeedSEC;
        private float mFastCastRate;
        private int mMoney;
        private string mName;
        private string mDisplayName;

        public string TemplateName { get { return Info.Name; } }
        public int TemplateID { get { return Info.ID; } }
        public override string Name { get { return mName; } }
        public override string DisplayName { get { return mDisplayName; } }
        public float BodySize { get { return Info.BodySize; } }
        public float BodyHitSize { get { return Info.BodyHitSize; } }
        public override float RadiusSize { get { return BodySize; } }

        public string Alias { get { return SyncInfo.Alias; } }
        public int Force { get { return SyncInfo.Force; } }
        public int HP { get { return mHP; } }
        public int MP { get { return mMP; } }
        public int SP { get { return mSP; } }
        public int MaxHP { get { return mMaxHP; } }
        public int MaxMP { get { return mMaxMP; } }
        public int MaxSP { get { return mMaxSP; } }
        public float MoveSpeedSEC { get { return mMoveSpeedSEC; } }
        public float TurnSpeedSEC { get { return mTurnSpeedSEC; } set { mTurnSpeedSEC = value; } }
        public float FastCastRate { get { return mFastCastRate; } }
        public int Money { get { return mMoney; } }
        public string PlayerUUID { get { return SyncInfo.PlayerUUID; } }
        public int Level { get { return SyncInfo.Level; } }
        public int Dummy_0 { get; private set; }
        public int Dummy_1 { get; private set; }
        public int Dummy_2 { get; private set; }
        public int Dummy_3 { get; private set; }
        public int Dummy_4 { get; private set; }
        public int Dummy_5 { get; private set; }



        public bool IsTurning
        {
            get { return mDirectionChange != mDirection; }
        }
        override public float Direction
        {
            get { return mDirection; }
            internal set
            {
                mDirectionChange = value;
                if (Info.UType == UnitInfo.UnitType.TYPE_BUILDING)
                {
                    mDirection = value;
                }
            }
        }

        public float ServerDirection { get { return mDirectionChange; } }
        public override float X { get { return mLocalPos.X; } }
        public override float Y { get { return mLocalPos.Y; } }
        public override bool TouchObj { get { return (mTouchObj) && (CurrentState != UnitActionStatus.Dead) && (mHP > 0); } }
        public override bool TouchMap { get { return mTouchMap; } }
        public bool IsStaticBlockable { get { return mIsStaticBlockable; } }
        virtual public bool IsActive { get { return (HP > 0); } }

        private bool mTouchObj;
        private bool mTouchMap;
        private bool mIsStaticBlockable;
        protected float mDirectionChange;
        protected float mTurnSpeedSEC;
        protected Vector2 mLocalPos = new Vector2();
        protected SyncPosEvent.UnitState mRemoteState;
        private State<UnitActionStatus> mState = new State<UnitActionStatus>(UnitActionStatus.Idle);
        private State<byte> mSubState = new State<byte>(0);
        protected HashMap<string, object> mEnvironmentVarMap = new HashMap<string, object>();
        private IVirtualClientUnit mVirtual;

        //新增技能Move标记（本地预演）
        protected bool mIsSkillMove;

        public IVirtualClientUnit Virtual { get { return mVirtual; } }

        public UnitActionStatus CurrentState
        {
            get { return mState.Value; }
        }
        public byte CurrentSubState
        {
            get { return mSubState.Value; }
        }

        public ZoneUnit(UnitInfo info, SyncUnitInfo syn, ZoneLayer parent, AddUnitEvent add)
            : base(syn.ObjectID, parent)
        {
            this.SyncInfo = syn;
            this.mName = syn.Name;
            this.mDisplayName = TemplateManager.Factory.ToClientDisplayName(info, syn);
            this.Info = info;
            this.IsAttackRangeIncludeBodySize = parent.Templates.CFG.OBJECT_ATTACK_RANGE_INCLUDE_BODYSIZE;
            this.mPos.SetX(syn.x);
            this.mPos.SetY(syn.y);
            this.mMoveSpeedSEC = info.MoveSpeedSEC;
            this.mTurnSpeedSEC = float.IsNaN(info.TurnSpeedSEC) ? Templates.CFG.UNIT_TURN_SPEED_SEC : info.TurnSpeedSEC;
            this.mFastCastRate = 0;
            this.mLocalPos.SetX(syn.x);
            this.mLocalPos.SetY(syn.y);
            this.mDirection = this.mDirectionChange = syn.direction;
            this.mIsStaticBlockable = syn.IsStaticBlockable;
            this.mTouchObj = syn.IsTouchObj;
            this.mTouchMap = syn.IsTouchMap;
            this.mState.ChangeState((UnitActionStatus)syn.status);
            this.mSubState.ChangeState(syn.sub_status);
            this.mRemoteState.UnitMainState = (UnitActionStatus)syn.status;
            this.mRemoteState.UnitSubState = syn.sub_status;
            switch (Info.UType)
            {
                case UnitInfo.UnitType.TYPE_PET:
                case UnitInfo.UnitType.TYPE_TRIGGER:
                    mTouchObj = false;
                    break;
                case UnitInfo.UnitType.TYPE_BUILDING:
                    mTouchObj = (info.BodySize > 0);
                    break;
            }
            DoSync(syn.fields);
            InitSkills();
            //this.mVirtual = TemplateManager.Factory.CreateClientUnitVirtual(this);
        }

        public void SendPlayPetTeleport()
        {
            Parent.SendAction(new PlayPetTeleportAction());
        }

        protected override void Disposing()
        {
            base.Disposing();
            this.clearEvents();
            /*if (mVirtual != null)
            {
                mVirtual.OnDispose(this);
            }
            this.mVirtual = null;*/
            this.mBuffStatus.Clear();
            this.mChantingSkill = null;
            this.mCurrentSkillAction = null;
            this.mDamageTime = null;
            this.mHitFlyState = null;
            this.mLastLaunchSkill = null;
            this.mPickEvent = null;
            this.mEnvironmentVarMap.Clear();
            this.mSkillStatus.Clear();
        }

        protected internal override void OnAdded()
        {
            /*if (mVirtual != null)
            {
                mVirtual.OnInit(this);
            }*/
            this.SyncBuffStatus(SyncInfo.CurrentBuffStatus);
            base.OnAdded();
        }


        //--------------------------------------------------------------------------------
        #region State

        public override void SetClientLocalCurrentState(UnitActionStatus state, object evt)
        {
            this.SetCurrentState(state);
        }

        protected void SetCurrentState(ref SyncPosEvent.UnitState pos)
        {           
            this.SetCurrentState(pos.UnitMainState, pos.UnitSubState, null);
        }
        protected void SetCurrentState(UnitActionStatus state)
        {
            this.SetCurrentState(state, CurrentSubState, null);
        }
        protected void SetCurrentState(UnitActionStatus state, object evt)
        {
            this.SetCurrentState(state, CurrentSubState, evt);
        }
        protected void SetCurrentState(UnitActionStatus state, byte substate, object evt)
        {
            //不能移动切入，状态置成Idle（不应该有互斥状态存在 跑和不能移动）
            if (state == UnitActionStatus.Move && (substate & (byte)UnitActionSubStatus.CanNotMove) != 0)
            {
                state = UnitActionStatus.Idle;
            }

            if (mState.ChangeState(state))
            {
                if (mOnActionChanged != null)
                {
                    mOnActionChanged.Invoke(this, mState.Value, evt);
                }
            }
            SetCurrentSubState(substate);
        }
        protected void SetCurrentSubState(byte substate)
        {
            if (mSubState.ChangeState(substate))
            {
                if (mOnActionSubStatusChanged != null)
                {
                    mOnActionSubStatusChanged.Invoke(this, mSubState.Value, null);
                }
            }
        }

        #endregion

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

        override internal protected void Update()
        {
            int intervalMS = Parent.CurrentIntervalMS;
            if (mHitFlyState != null && mHitFlyState.Update(intervalMS))
            {
                mHitFlyState = null;
            }
            UpdatePos(intervalMS);
            UpdateDamage(intervalMS);
            UpdateSkills(intervalMS);
            UpdateBuffs(intervalMS);
            UpdatePickEvent(intervalMS);
        }

        protected internal override void UpdateAI()
        {
            int intervalMS = Parent.CurrentIntervalMS;
            updateSkillAction(intervalMS);
        }

        protected internal virtual void UpdatePos(int intervalMS)
        {
            if (mDirection != mDirectionChange)
            {
                mDirection = MoveHelper.DirectionChange(
                    mDirectionChange,
                    mDirection,
                    mTurnSpeedSEC,
                    intervalMS);
            }
            if (Parent.ActorSyncMode != SyncMode.ForceByServer)
            {
                if (!FixPos(intervalMS, mLocalPos, mPos))
                {
                    if(CurrentState == UnitActionStatus.Move && mRemoteState.UnitMainState != UnitActionStatus.Move)
                    {
                        this.SetCurrentState(ref mRemoteState);
                    }
                }
                else
                {
                    //if(this is ZoneActor)
                    //    CommonLang.Log.ClientLog.LogWarning(">>UpdatePos:{0},{1}-->{2},{3}", mLocalPos.X, mLocalPos.Y, mPos.X, mPos.Y);
                }
            }
        }

        public override void ForceSyncPos(float x, float y)
        {
			//YXJDebug.logWarning("{0}>>ForceSyncPos:{1},{2}", Name, x, y);
			this.mPos.SetX(x);
			this.mPos.SetY(y);
            this.mLocalPos.SetX(x);
            this.mLocalPos.SetY(y);
        }
        public override void SyncPos(ref SyncPosEvent.UnitState pos)
        {
            this.mRemoteState = pos;
            if (Parent.ActorSyncMode == SyncMode.ForceByServer)
            {
                this.SetCurrentState(ref mRemoteState);
            }
            else
            {
                var rst = mRemoteState;
                if (CurrentState == UnitActionStatus.Move && mRemoteState.UnitMainState == UnitActionStatus.Idle)
                {
                    if (IsNeedFixPos(mLocalPos, mPos))
                    {
                        rst.UnitMainState = UnitActionStatus.Move;
                    }
                }
                this.SetCurrentState(ref rst);
            }
        }

        public override void SyncPos(ref SyncPosEvent.UnitPos pos)
        {
            bool bMoved = mPos.X != pos.X || mPos.Y != pos.Y;
            base.mPos.SetX(pos.X);
            base.mPos.SetY(pos.Y);
            this.mDirectionChange = pos.Direction;
            this.mDirection = MoveHelper.DirectionChange(
                mDirectionChange,
                mDirection,
                mTurnSpeedSEC,
                Parent.CurrentIntervalMS);
            if (Parent.IsSyncZ) { this.Z = pos.Z; }
            if (Parent.ActorSyncMode == SyncMode.ForceByServer)
            {
                //YXJDebug.logWarning(">>{0}>syncPos:{0},{1}-->forceByServerMode", Name, pos.X, pos.Y);
                mLocalPos.SetX(pos.X);
                mLocalPos.SetY(pos.Y);
            }
            else
            {
                var rst = mRemoteState;
                if (CurrentState == UnitActionStatus.Move && rst.UnitMainState == UnitActionStatus.Idle)
                {
                    rst.UnitMainState = UnitActionStatus.Move;
                }
                else if(bMoved && CurrentState == UnitActionStatus.Idle && rst.UnitMainState == UnitActionStatus.Idle && rst.UnitSubState == 0)
                {
                    //新创建的单位，丢失了move状态信息，打个补丁
                    rst.UnitMainState = UnitActionStatus.Move;
                }
                else if(rst.UnitMainState == UnitActionStatus.Skill)
                {
                    if ((rst.UnitSubState & (byte)UnitActionSubStatus.ChargeAtkIdle) != 0)
                    {
                       //YXJDebug.logDebug(">>下发SyncPosEvent的状态不对（蓄力idle中移动）");
                    }
                    else if((rst.UnitSubState & (byte)UnitActionSubStatus.Mocking) != 0)
                    {
                    }
                    else
                    {
                        //YXJDebug.logWarning(">>{0}>skill状态中syncPos, curState:{1}/{2}-->{3}/{4}", Name, (int)CurrentState, (int)CurrentSubState, (int)mRemoteState.UnitMainState, (int)mRemoteState.UnitSubState);
                    }
                }
                //YXJDebug.logWarning(">>{0}>UnitsyncPos, curState:{1}/{2}-->{3}/{4}, x:{5},y:{6}", Name, (int)CurrentState, (int)CurrentSubState, (int)mRemoteState.UnitMainState, (int)mRemoteState.UnitSubState, pos.X, pos.Y);
                this.SetCurrentState(ref rst);
            }
        }
        /// <summary>
        /// 修正本地坐标//
        /// </summary>
        public bool FixPos(int intervalMS, Vector2 local_pos, IVector2 remote_pos)
        {
            float fdistance = MathVector.getDistance(local_pos, remote_pos);
            if (fdistance > 0)
            {
                float dspeed = MoveHelper.GetDistance(intervalMS, MoveSpeedSEC);
                if (fdistance >= Parent.AsyncUnitPosModifyMaxRange)
                {
                    local_pos.SetX(remote_pos.X);
                    local_pos.SetY(remote_pos.Y);
                    return true;
                }
                else if (fdistance <= dspeed)
                {
                    //local_pos.x = remote_pos.X;
                    //local_pos.y = remote_pos.Y;
                    return false;
                }
                else if (CurrentState == UnitActionStatus.Move)
                {
                    float db = dspeed;
                    MathVector.moveTo(local_pos, remote_pos.X, remote_pos.Y, db);
                    return true;
                }
                else
                {
                    float db = dspeed * fdistance;
                    MathVector.moveTo(local_pos, remote_pos.X, remote_pos.Y, db);
                    return true;
                }
            }
            return false;
        }
        /// <summary>
        /// 是否需要修正坐标
        /// </summary>
        /// <returns></returns>
        public bool IsNeedFixPos(Vector2 local_pos, IVector2 remote_pos)
        {
            float fdistance = MathVector.getDistance(local_pos, remote_pos);
            return fdistance >= Parent.MinStep;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="direction"></param>
        /// <param name="smooth">是否慢慢转身</param>
        public void SetDirection(float direction, bool smooth = true)
        {
            if (smooth)
            {
                mDirectionChange = direction;
            }
            else
            {
                mDirectionChange = direction;
                mDirection = direction;
            }
        }
        public float GetDeadTimeCD()
        {
            if (mDeadTime != null)
            {
                return mDeadTime.Percent;
            }
            return 0;
        }

        override internal protected void DoEvent(ObjectEvent e)
        {
            if (e is UnitDamageEvent)
            {
                DoDamage(e as UnitDamageEvent);
            }
            else if (e is UnitLaunchSkillEvent)
            {
                DoLaunchSkill(e as UnitLaunchSkillEvent);
            }
            else if (e is UnitSkillActionChangeEvent)
            {
                DoChangeAction(e as UnitSkillActionChangeEvent);
            }
            else if (e is UnitDeadEvent)
            {
                DoDead(e as UnitDeadEvent);
            }
            else if (e is UnitLaunchBuffEvent)
            {
                DoLaunchBuff(e as UnitLaunchBuffEvent);
            }
            else if(e is BuffDataNotify)
            {
                SyncBuffOverlayLevel(e as BuffDataNotify);
            }
            else if (e is SyncUnitBuffState)
            {
                DoRemoveOverlayLevelBuff(e as SyncUnitBuffState);
            }
            else if (e is UnitStopBuffEvent)
            {
                DoStopBuff(e as UnitStopBuffEvent);
            }
            else if (e is UnitFieldChangedEvent)
            {
                DoSync(e as UnitFieldChangedEvent);
            }
            else if (e is UnitStartPickObjectEvent)
            {
                DoStartPick(e as UnitStartPickObjectEvent);
            }
            else if (e is UnitStopPickObjectEvent)
            {
                DoStopPick(e as UnitStopPickObjectEvent);
            }
            else if (e is UnitJumpEvent)
            {
                DoJump(e as UnitJumpEvent);
            }
            else if (e is UnitForceSyncPosEvent)
            {
                DoForceSyncPosEvent(e as UnitForceSyncPosEvent);
            }
            else if (e is UnitChantSkillEvent)
            {
                DoUnitChantSkillEvent(e as UnitChantSkillEvent);
            }
            else if (e is UnitSyncMultiTimeLine)
            {
                DoUnitSyncMultiTimeLine(e as UnitSyncMultiTimeLine);
            }
            //----------------------- player ----------------------//
            else if (e is PlayerCDEvent)
            {
                DoSkillCDChanged(e as PlayerCDEvent);
            }
            else if (e is PlayerSkillChangedEvent)
            {
                DoSkillChanged(e as PlayerSkillChangedEvent);
            }
            else if (e is PlayerSkillAddedEvent)
            {
                DoSkillAdded(e as PlayerSkillAddedEvent);
            }
            else if (e is PlayerSkillRemovedEvent)
            {
                DoSkillRemoved(e as PlayerSkillRemovedEvent);
            }
            else if (e is PlayerSkillTimeChangedEvent)
            {
                DoPlayerSkillTimeChangedEvent(e as PlayerSkillTimeChangedEvent);
            }
            else if (e is PlayerSyncEnvironmentVarEvent)
            {
                DoSyncUnitVarEvent(e as PlayerSyncEnvironmentVarEvent);
            }
            else if (e is PlayerSkillStopEvent)
            {
                DoPlayerSkillStopEvent(e as PlayerSkillStopEvent);
            }
            else if (e is PlayerScriptCommandEvent)
            {
                DoPlayerScriptCommandEvent(e as PlayerScriptCommandEvent);
            }
            else if (e is PlayerSkillActiveChangedEvent)
            {
                DoPlayerSkillActiveChangedEvent(e as PlayerSkillActiveChangedEvent);
            }
            //----------------------- player ----------------------//
            //新增技能层数的协议
            else if (e is PlayerSkillUseTimeChangedEvent)
            {
                DoPlayerSkillUseTimeChangedEvent(e as PlayerSkillUseTimeChangedEvent);
            }
            else if (e is UnitStealthInfo)
            {
                DoUnitStealthInfo(e as UnitStealthInfo);
            }
        }

        protected virtual void DoUnitStealthInfo(UnitStealthInfo e)
        {
            if (mOnSetStealtState != null)
                mOnSetStealtState(e.stealth, e.flag);
        }

        protected virtual void DoForceSyncPosEvent(UnitForceSyncPosEvent e)
        {
            //YXJDebug.logWarning(">{0}:{1}>>DoForceSyncPosEvent:{2},{3}, state:{4},{5}", ObjectID,Name, e.X, e.Y, e.UnitMainState, e.UnitSubState);
            if(this.Parent != null && this.Parent.IsSceneDujie() && e.UnitMainState == (byte)UnitActionStatus.Move)
            {
                //YXJDebug.logWarning(">IgnoreForceSyncPos_u@move: {0}{1}, state:{2},{3}", ObjectID, Name, e.UnitMainState, e.UnitSubState);
                return;
            }
            if (!mIsSkillMove)
            {
                mLocalPos.SetX(e.X);
                mLocalPos.SetY(e.Y);
            }
            mPos.SetX(e.X);
            mPos.SetY(e.Y);
            mDirection = mDirectionChange = e.Direction;

            mRemoteState.UnitMainState = (UnitActionStatus)e.UnitMainState;
            mRemoteState.UnitSubState = e.UnitSubState;
            this.SetCurrentState((UnitActionStatus)e.UnitMainState, e.UnitSubState, e);

        }
        protected virtual void DoSync(UnitFieldChangedEvent syn)
        {
            if ((syn.mask & UnitFieldChangedEvent.MASK_HP) != 0)
            {
                if (mHP != syn.currentHP)
                {
                    int old = mHP;
                    this.mHP = syn.currentHP;
                    if (mOnHPChanged != null)
                    {
                        mOnHPChanged.Invoke(this, old, syn.currentHP);
                    }
                }
            }
            if ((syn.mask & UnitFieldChangedEvent.MASK_MP) != 0)
            {
                if (mMP != syn.currentMP)
                {
                    int old = mMP;
                    this.mMP = syn.currentMP;
                    if (mOnMPChanged != null)
                    {
                        mOnMPChanged.Invoke(this, old, syn.currentMP);
                    }
                }
            }
            if ((syn.mask & UnitFieldChangedEvent.MASK_MAX_HP) != 0)
            {
                if (this.mMaxHP != syn.maxHP)
                {
                    int old = mMaxHP;
                    this.mMaxHP = syn.maxHP;
                    if (mOnMaxHPChanged != null)
                    {
                        mOnMaxHPChanged.Invoke(this, old, syn.maxHP);
                    }
                }
            }
            if ((syn.mask & UnitFieldChangedEvent.MASK_MAX_MP) != 0)
            {
                if (this.mMaxMP != syn.maxMP)
                {
                    int old = mMaxMP;
                    this.mMaxMP = syn.maxMP;
                    if (mOnMaxMPChanged != null)
                    {
                        mOnMaxMPChanged.Invoke(this, old, syn.maxMP);
                    }
                }
            }
            if ((syn.mask & UnitFieldChangedEvent.MASK_SP) != 0)
            {
                this.mSP = syn.currentSP;
            }
            if ((syn.mask & UnitFieldChangedEvent.MASK_MAX_SP) != 0)
            {
                this.mMaxSP = syn.maxSP;
            }
            if ((syn.mask & UnitFieldChangedEvent.MASK_SPEED) != 0) { this.mMoveSpeedSEC = syn.currentSpeed; }
            if ((syn.mask & UnitFieldChangedEvent.MASK_FCR) != 0) { this.mFastCastRate = syn.currentFCR; }
            if ((syn.mask & UnitFieldChangedEvent.MASK_MONEY) != 0)
            {
                if (mMoney != syn.currentMoney)
                {
                    int old = this.mMoney;
                    this.mMoney = syn.currentMoney;
                    if (mOnMoneyChanged != null)
                    {
                        mOnMoneyChanged.Invoke(this, old, syn.currentMoney);
                    }
                }
            }
            if ((syn.mask & UnitFieldChangedEvent.MASK_LEVEL) != 0) { this.SyncInfo.Level = syn.level; }
            if ((syn.mask & UnitFieldChangedEvent.MASK_DUMMY_0) != 0) { this.Dummy_0 = syn.dummy_0; }
            if ((syn.mask & UnitFieldChangedEvent.MASK_DUMMY_1) != 0) { this.Dummy_1 = syn.dummy_1; }
            if ((syn.mask & UnitFieldChangedEvent.MASK_DUMMY_2) != 0) { this.Dummy_2 = syn.dummy_2; }
            if ((syn.mask & UnitFieldChangedEvent.MASK_DUMMY_3) != 0) { this.Dummy_3 = syn.dummy_3; }
            if ((syn.mask & UnitFieldChangedEvent.MASK_DUMMY_4) != 0) { this.Dummy_4 = syn.dummy_4; }
            if ((syn.mask & UnitFieldChangedEvent.MASK_DUMMY_5) != 0) { this.Dummy_5 = syn.dummy_5; }
        }
        protected virtual void DoSyncUnitVarEvent(PlayerSyncEnvironmentVarEvent e)
        {
            mEnvironmentVarMap[e.Key] = e.Value;
        }
        protected virtual void DoPlayerScriptCommandEvent(PlayerScriptCommandEvent e)
        {
            if (mOnScriptCommand != null)
            {
                mOnScriptCommand.Invoke(this, e.message);
            }
        }
        //--------------------------------------------------------------------------------

        /// <summary>
        /// 获得当前单位服务端可同步环境变量
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public object GetEnvironmentVar(string key)
        {
            return mEnvironmentVarMap.Get(key);
        }

        /// <summary>
        /// 获得当前单位服务端可同步环境变量列表
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public IEnumerable<string> ListEnvironmentVars()
        {
            return mEnvironmentVarMap.Keys;
        }

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



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

        #region Delegate
        public enum SkillOption
        {
            Init,
            Reset,
            Add,
            Remove,
            ActiveChange
        }
        public delegate void OnSetStealtStateHandler(byte stealth, short flag);
        public delegate void OnSkillChangedHandler(SkillOption op, ZoneUnit unit, int baseSkillID, params int[] skills);
        public delegate void OnActionStatusChangedHandler(ZoneUnit unit, UnitActionStatus status, object evt);
        //新增子状态
        public delegate void OnActionSubStatusChangedHandler(ZoneUnit unit, byte status, object evt);
        public delegate void OnMoneyChangedHandler(ZoneUnit unit, int oldMoney, int newMoney);
        //public delegate void OnChantSkillHandler(ZoneUnit unit, SkillState skill, UnitChantSkillEvent evt);
        public delegate void OnChantSkillHandler(ZoneUnit unit, UnitChantSkillEvent evt, TimeExpire<SkillTemplate> timeExpire);
        public delegate void OnLaunchSkillHandler(ZoneUnit unit, SkillState skill, UnitLaunchSkillEvent evt);
        public delegate void OnHPChangedHandler(ZoneUnit unit, int oldHP, int newHP);
        public delegate void OnMPChangedHandler(ZoneUnit unit, int oldMP, int newMP);
        public delegate void OnMaxHPChangedHandler(ZoneUnit unit, int oldMaxHP, int newMaxHP);
        public delegate void OnMaxMPChangedHandler(ZoneUnit unit, int oldMaxMP, int newMaxMP);
        public delegate void OnStartPickObjectHandler(ZoneUnit unit, TimeExpire<UnitStartPickObjectEvent> start);
        public delegate void OnStopPickObjectHandler(ZoneUnit unit, UnitStopPickObjectEvent stop);
        public delegate void OnSkillActionChangedHandler(ZoneUnit unit, SkillState skill, byte index);
        public delegate void OnBuffAddedHandler(ZoneUnit unit, BuffState buff);
        public delegate void OnBuffChangedHandler(ZoneUnit unit, BuffState buff);
        public delegate void OnBuffRemovedHandler(ZoneUnit unit, BuffState buff);
        public delegate void OnRemoveBuffByOverlayLevelHandler(ZoneUnit unit, BuffState buff);
        public delegate void OnScriptCommandHandler(ZoneUnit unit, string msg);
        public delegate void OnSkillActionStartHandler(ZoneUnit unit, ISkillAction action);

        //客户端技能预演事件
        public delegate void OnClientSkillSimulationHandler(ZoneUnit unit, SimulationSkillEnum type);

        private OnSetStealtStateHandler mOnSetStealtState;
        private OnSkillChangedHandler mOnSkillChanged;
        private OnActionStatusChangedHandler mOnActionChanged;
        //新增子状态
        private OnActionSubStatusChangedHandler mOnActionSubStatusChanged;
        private OnMoneyChangedHandler mOnMoneyChanged;
        private OnChantSkillHandler mOnChantSkill;
        private OnLaunchSkillHandler mOnLaunchSkill;
        private OnHPChangedHandler mOnHPChanged;
        private OnMPChangedHandler mOnMPChanged;
        private OnMaxHPChangedHandler mOnMaxHPChanged;
        private OnMaxMPChangedHandler mOnMaxMPChanged;
        private OnStartPickObjectHandler mOnStartPickObject;
        private OnStopPickObjectHandler mOnStopPickObject;
        private OnSkillActionChangedHandler mOnSkillActionChanged;
        private OnBuffAddedHandler mOnBuffAdded;
        private OnBuffRemovedHandler mOnBuffRemoved;
        private OnBuffChangedHandler mOnBuffChanged;
        private OnRemoveBuffByOverlayLevelHandler mOnRemoveBuffByOverlayLeveled;
        private OnScriptCommandHandler mOnScriptCommand;
        private OnSkillActionStartHandler mOnSkillActionStart;
        private OnClientSkillSimulationHandler mOnClientSkillSimulation;

        private void clearEvents()
        {
            this.mOnSetStealtState = null;
            this.mOnSkillChanged = null;
            this.mOnActionChanged = null;
            this.mOnMoneyChanged = null;
            this.mOnChantSkill = null;
            this.mOnLaunchSkill = null;
            this.mOnHPChanged = null;
            this.mOnMPChanged = null;
            this.mOnMaxHPChanged = null;
            this.mOnMaxMPChanged = null;
            this.mOnStartPickObject = null;
            this.mOnStopPickObject = null;
            this.mOnSkillActionChanged = null;
            this.mOnBuffAdded = null;
            this.mOnBuffChanged = null;
            this.mOnBuffRemoved = null;
            this.mOnScriptCommand = null;
            this.mOnSkillActionStart = null;
            this.mOnRemoveBuffByOverlayLeveled = null;
            this.mOnClientSkillSimulation = null;
        }

        [EventTriggerDescAttribute("草丛隐身状态改变触发")]
        public event OnSetStealtStateHandler OnSetStealtState { add { mOnSetStealtState += value; } remove { mOnSetStealtState -= value; } }
        [EventTriggerDescAttribute("单位持有技能发生变化时触发")]
        public event OnSkillChangedHandler OnSkillChanged { add { mOnSkillChanged += value; } remove { mOnSkillChanged -= value; } }
        [EventTriggerDescAttribute("单位状态发生变化时触发")]
        public event OnActionStatusChangedHandler OnActionChanged { add { mOnActionChanged += value; } remove { mOnActionChanged -= value; } }
        [EventTriggerDescAttribute("单位子状态发生变化时触发")]
        public event OnActionSubStatusChangedHandler OnActionSubStatusChanged { add { mOnActionSubStatusChanged += value; } remove { mOnActionSubStatusChanged -= value; } }
        [EventTriggerDescAttribute("单位金币发生变化时触发")]
        public event OnMoneyChangedHandler OnMoneyChanged { add { mOnMoneyChanged += value; } remove { mOnMoneyChanged -= value; } }
        [EventTriggerDescAttribute("单位开始吟唱时触发")]
        public event OnChantSkillHandler OnChantSkill { add { mOnChantSkill += value; } remove { mOnChantSkill -= value; } }
        [EventTriggerDescAttribute("单位释放技能时触发")]
        public event OnLaunchSkillHandler OnLaunchSkill { add { mOnLaunchSkill += value; } remove { mOnLaunchSkill -= value; } }

        [EventTriggerDescAttribute("HP变化")]
        public event OnHPChangedHandler OnHPChanged { add { mOnHPChanged += value; } remove { mOnHPChanged -= value; } }
        [EventTriggerDescAttribute("MP变化")]
        public event OnMPChangedHandler OnMPChanged { add { mOnMPChanged += value; } remove { mOnMPChanged -= value; } }

        [EventTriggerDescAttribute("MaxHP变化")]
        public event OnMaxHPChangedHandler OnMaxHPChanged { add { mOnMaxHPChanged += value; } remove { mOnMaxHPChanged -= value; } }
        [EventTriggerDescAttribute("MaxMP变化")]
        public event OnMaxMPChangedHandler OnMaxMPChanged { add { mOnMaxMPChanged += value; } remove { mOnMaxMPChanged -= value; } }


        [EventTriggerDescAttribute("单位开始检取物品")]
        public event OnStartPickObjectHandler OnStartPickObject { add { mOnStartPickObject += value; } remove { mOnStartPickObject -= value; } }
        [EventTriggerDescAttribute("单位完成/结束检取物品")]
        public event OnStopPickObjectHandler OnStopPickObject { add { mOnStopPickObject += value; } remove { mOnStopPickObject -= value; } }
        [EventTriggerDescAttribute("单位技能动作发生变化")]
        public event OnSkillActionChangedHandler OnSkillActionChanged { add { mOnSkillActionChanged += value; } remove { mOnSkillActionChanged -= value; } }

        [EventTriggerDescAttribute("单位添加BUFF")]
        public event OnBuffAddedHandler OnBuffAdded { add { mOnBuffAdded += value; } remove { mOnBuffAdded -= value; } }
        [EventTriggerDescAttribute("单位BUFF状态改变")]
        public event OnBuffChangedHandler OnBuffChanged { add { mOnBuffChanged += value; } remove { mOnBuffChanged -= value; } }
        [EventTriggerDescAttribute("单位移除BUFF")]
        public event OnBuffRemovedHandler OnBuffRemoved { add { mOnBuffRemoved += value; } remove { mOnBuffRemoved -= value; } }

        [EventTriggerDescAttribute("移除层buff（剑雨新增）")]
        public event OnRemoveBuffByOverlayLevelHandler OnRemoveBuffByOverlayLevel { add { mOnRemoveBuffByOverlayLeveled += value; } remove { mOnRemoveBuffByOverlayLeveled -= value; } }

        [EventTriggerDescAttribute("服务端通知客户端执行指定脚本代码")]
        public event OnScriptCommandHandler OnScriptCommand { add { mOnScriptCommand += value; } remove { mOnScriptCommand -= value; } }

        [EventTriggerDescAttribute("技能动作开始")]
        public event OnSkillActionStartHandler OnSkillActionStart { add { mOnSkillActionStart += value; } remove { mOnSkillActionStart -= value; } }

        [EventTriggerDescAttribute("客户端技能模拟")]
        public event OnClientSkillSimulationHandler OnClickSkillSimulationEvent { add { mOnClientSkillSimulation += value; } remove { mOnClientSkillSimulation -= value; } }

        #endregion




    }



}