WSHCommon/Common/CommonAI/ZoneClient/ZoneObject.Spell.cs

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

namespace CommonAI.ZoneClient
{
    public class ZoneSpell : ZoneObject
    {
        public readonly SpellTemplate Info;

        public override string Name { get { return null; } }
        public override string DisplayName { get { return Info.Name; } }
        public override float X { get { return mLocalPos.X; } }
        public override float Y { get { return mLocalPos.Y; } }
        public override float Z { get { return mLocal_Z; } }
        public override float RadiusSize { get { return mDisplaySize; } }

        public ZoneObject Sender { get; internal set; }
        public ZoneUnit Launcher { get; internal set; }
        public ZoneUnit Target { get; internal set; }
        public Vector2 TargetPos { get; internal set; }
        public Vector2 StartPos { get { return mStartPos; } }

        public float LaunchHeight { get { return mStartHeight; } set { this.mStartHeight = value; this.mLocal_Z = value; } }

        public float BodySize { get { return mDisplaySize; } }
        public float Distance { get { return mDisplayDistance; } }
        public int PassTimeMS { get { return mPassTimeMS; } }

        private Vector2 mLocalPos = new Vector2();
        private float mLocal_Z = 0;
        private float mSizeLimit, mDisplaySize;
        private float mDistanceLimit, mDisplayDistance;
        private Vector2 mStartPos = new Vector2();
        private float mStartDirection;
        private float mStartHeight;
        private int mPassTimeMS;
        private float mSpeed;

        private float mMoveDistance;
        private int mCurveMissileIndex = -1;

        private PopupKeyFrames<SpellTemplate.KeyFrame> mKeyFrames;
        private TimeInterval<SpellTemplate.KeyFrame> mHitIntervalTicker;

        private AddSpellEvent mAddEvent;

        public System.Action OnTargetChanged = null;

        private static HashMap<string, int> hashCurveMissileCnt = new HashMap<string, int>();
        private string strCurveMissileIndexKey;
        public ZoneSpell(SpellTemplate info, SyncSpellInfo syn, ZoneLayer parent, AddSpellEvent add)
            : base(syn.ObjectID, parent)
        {
            this.Info = info;

			this.mStartPos.SetX(syn.x);
			this.mStartPos.SetY(syn.y);
			this.mPos.SetX(syn.x);
			this.mPos.SetY(syn.y);
			this.mLocalPos.SetX(syn.x);
            this.mLocalPos.SetY(syn.y);
            this.mDirection = this.mStartDirection = syn.direction;
            this.mDistanceLimit = this.mDisplayDistance = info.Distance;
            this.mSizeLimit = this.mDisplaySize = info.BodySize;
            this.mPassTimeMS = 0;
            this.mAddEvent = add;
            if (add != null && add.IsHeight)
            {
                this.mLocal_Z = add.height;
            }
            this.mKeyFrames = new PopupKeyFrames<SpellTemplate.KeyFrame>();
            this.mKeyFrames.AddRange(info.KeyFrames);
            this.mHitIntervalTicker = new TimeInterval<SpellTemplate.KeyFrame>(info.HitIntervalMS);
            this.mHitIntervalTicker.Tag = info.HitIntervalKeyFrame;
            this.mSpeed = info.MSpeedSEC;
            this.mMoveDistance = 0;
            if (syn.HasSpeed)
            {
                this.mSpeed = syn.CurSpeed;
            }
            if(info.MType == SpellTemplate.MotionType.CurveMissile)
            {
                int cnt;
                strCurveMissileIndexKey = add.sender_unit_id.ToString() + ":" + info.TemplateID.ToString();
                if (hashCurveMissileCnt.TryGetValue(strCurveMissileIndexKey, out cnt))
                {
                    hashCurveMissileCnt[strCurveMissileIndexKey] = ++cnt;
                }
                else
                {
                    hashCurveMissileCnt.Add(strCurveMissileIndexKey, 1);
                    cnt = 1;
                }
                mCurveMissileIndex = cnt-1;
            }
        }

        protected override void Disposing()
        {
            if (!string.IsNullOrEmpty(strCurveMissileIndexKey))
            {
                int cnt;
                if (hashCurveMissileCnt.TryGetValue(strCurveMissileIndexKey, out cnt))
                {
                    if (cnt <= 1)
                    {
                        hashCurveMissileCnt.Remove(strCurveMissileIndexKey);
                    }
                    else
                    {
                        hashCurveMissileCnt[strCurveMissileIndexKey] = cnt - 1;
                    }
                }
            }
            base.Disposing();
        }

        protected internal override void OnAdded()
        {
            base.OnAdded();

            float radius = 0;
            if (mAddEvent != null)
            {
                if (mAddEvent.LaunchData.FromUnitBody && Sender != null && (Sender is ZoneUnit))
                {
                    radius = (Sender as ZoneUnit).Info.LaunchSpellRadius;
                }
                else
                {
                    radius = mAddEvent.LaunchData.LaunchSpellRadius;
                }
            }

            if (!Info.IsLaunchSpellEventSyncPos)
            {
                switch (Info.MType)
                {
                    case SpellTemplate.MotionType.SelectTarget:
                        if (Target != null)
                        {
                            mStartPos.SetX(Target.X);
                            mStartPos.SetY(Target.Y);
                            mLocal_Z = Target.Z;
                            mStartDirection = Target.ServerDirection;
                        }
                        MathVector.movePolar(mStartPos, mStartDirection, radius);
                        break;
                    case SpellTemplate.MotionType.SelectLauncher:
                        if (Launcher != null)
                        {
                            mStartPos.SetX(Launcher.X);
                            mStartPos.SetY(Launcher.Y);
                            mLocal_Z = Launcher.Z;
                            mStartDirection = Launcher.ServerDirection;
                        }
                        MathVector.movePolar(mStartPos, mStartDirection, radius);
                        break;
                    case SpellTemplate.MotionType.Chain:
                        if (Sender != null)
                        {
                            mStartPos.SetX(Sender.X);
                            mStartPos.SetY(Sender.Y);
                            mLocal_Z = Sender.Z;
                        }
                        break;

                    case SpellTemplate.MotionType.AOE_Binding:
                    case SpellTemplate.MotionType.Binding:
                        if (Sender != null)
                        {
                            mStartPos.SetX(Sender.X);
                            mStartPos.SetY(Sender.Y);
                            mLocal_Z = Sender.Z;
                        }
                        break;
                    case SpellTemplate.MotionType.AOE_BindingTarget:
                    case SpellTemplate.MotionType.BindingTarget:
                        if (Target != null)
                        {
                            mStartPos.SetX(Target.X);
                            mStartPos.SetY(Target.Y);
                            mLocal_Z = Target.Z;
                        }
                        break;
                }
				this.mPos.SetX(this.mStartPos.X);
				this.mPos.SetY(this.mStartPos.Y);
				this.mLocalPos.SetX(this.mStartPos.X);
                this.mLocalPos.SetY(this.mStartPos.Y);
                this.mDirection = this.mStartDirection;
            }
            if (Info.TargetEffect != null)
            {
                if (Target != null)
                {
                    Parent.PreQueueEvent(new UnitEffectEvent(Target.ObjectID, Info.TargetEffect));
                }
                else if (TargetPos != null)
                {
                    Parent.PreQueueEvent(new AddEffectEvent(0,TargetPos.X, TargetPos.Y, mDirection, Info.TargetEffect));
                }
            }
        }

        public override void ForceSyncPos(float x, float y)
        {
			this.mPos.SetX(x);
			this.mPos.SetY(y);
			this.mLocalPos.SetX(x);
			this.mLocalPos.SetY(y);
		}

        internal protected override void DoEvent(ObjectEvent e)
        {
            if (e is SpellLockTargetEvent)
            {
                doSpellLockTargetEvent(e as SpellLockTargetEvent);
            }
            else if (e is ObjectForceSyncPosEvent)
            {
                var oe = e as ObjectForceSyncPosEvent;
                this.ForceSyncPos(oe.X, oe.Y);
                this.Direction = oe.Direction;
            }
        }
        private void doSpellLockTargetEvent(SpellLockTargetEvent e)
        {
            if (Parent == null)
            {
                log.Error("doSpellLockTargetEvent -> Parent == null");
            }
            if (Info == null)
            {
                log.Error("doSpellLockTargetEvent -> Info == null");
            }
            if (e == null)
            {
                log.Error("doSpellLockTargetEvent -> e == null");
            }
            this.Target = Parent.GetUnit(e.target_obj_id);
            if(OnTargetChanged != null)
            {
                OnTargetChanged();
            }
            switch (Info.MType)
            {
                case SpellTemplate.MotionType.SeekerSelectTarget:
                    if (Target != null)
                    {
                        this.mLocalPos.SetX(Target.X);
                        this.mLocalPos.SetY(Target.Y);
                        this.mLocal_Z = Target.Z;
                    }
                    break;
            }
        }

        protected internal override void UpdateAI()
        {
        }

        internal protected override void Update()
        {
            int intervalMS = Parent.CurrentIntervalMS;
            mPassTimeMS += intervalMS;

            if (Parent.ActorSyncMode != SyncMode.ForceByServer && (Info.MaxMoveDistance == 0 || mMoveDistance < Info.MaxMoveDistance))
            {
                updateMotion(intervalMS);
            }
            updateZPos();

            switch (Info.MType)
            {
                case SpellTemplate.MotionType.AOE:
                case SpellTemplate.MotionType.AOE_Binding:
                case SpellTemplate.MotionType.AOE_BindingTarget:
                    updateAOE(intervalMS);
                    break;
            }
            switch (Info.BodyShape)
            {
                case SpellTemplate.Shape.StripRayTouchEnd:
                    updateRayTouchEnd();
                    break;
                case SpellTemplate.Shape.LineToStart:
                case SpellTemplate.Shape.LineToTarget:
                    updateLineToTarget();
                    break;
            }
            if (Info.IsMoveable && (Info.MaxMoveDistance == 0 || mMoveDistance < Info.MaxMoveDistance))
            {
                MoveHelper.UpdateSpeed(intervalMS, ref mSpeed, Info.MSpeedAdd, Info.MSpeedAcc);
                MoveHelper.UpdateMoveDistance(intervalMS, ref mMoveDistance, mSpeed);
            }
            updateKeyFrames();
        }

        public override void SyncPos(ref SyncPosEvent.UnitPos pos)
        {
            base.SyncPos(ref pos);
            if (Parent.ActorSyncMode == SyncMode.ForceByServer)
            {
                mLocalPos.SetX(pos.X);
                mLocalPos.SetY(pos.Y);
                if (Parent.IsSyncZ) { this.Z = pos.Z; }
            }
        }

        //-----------------------------------------------------------------------
        #region _UpdateMotions_

        float foxfireRoundAngle = 0f;

        float foxfireSeekWait = 0f;

        private Logger log = LoggerFactory.GetLogger("ZoneClient");

        /// <summary>
        /// 更新移动行为
        /// </summary>
        private void updateMotion(int intervalMS)
        {
            float speed_distance = MoveHelper.GetDistance(intervalMS, mSpeed);
            try
            {
                switch (Info.MType)
                {
                    case SpellTemplate.MotionType.SelectLauncher:
                    case SpellTemplate.MotionType.SelectTarget:
                        break;

                    case SpellTemplate.MotionType.Cannon:
                    case SpellTemplate.MotionType.Straight:
                        MathVector.movePolar(mLocalPos, mStartDirection, speed_distance);
                        break;
                    case SpellTemplate.MotionType.StraightAndStop:
                        if (PassTimeMS < Info.BoomerangFlyTime)
                        {
                            MathVector.movePolar(mLocalPos, mStartDirection, speed_distance);
                        }
                        //else if (PassTimeMS > Info.BoomerangFlyTime + Info.BoomerangHangtime)
                        //{
                        //    PreFlyTo(Sender.X, Sender.Y, mSpeed * 1.8f, intervalMS);
                        //}
                        break;
                    case SpellTemplate.MotionType.Boomerang1:
                        if (PassTimeMS < Info.BoomerangFlyTime)
                        {
                            MathVector.movePolar(mLocalPos, mStartDirection, speed_distance);
                        }
                        else if (Sender != null && PassTimeMS > Info.BoomerangFlyTime + Info.BoomerangHangtime)
                        {
                            PreFlyTo(Sender.X, Sender.Y, mSpeed * 1.4f, intervalMS);
                        }
                        break;
                    case SpellTemplate.MotionType.Boomerang2:
                        if (PassTimeMS < Info.BoomerangFlyTime)
                        {
                            MathVector.movePolar(mLocalPos, mStartDirection, speed_distance);
                        }
                        else if (PassTimeMS > Info.BoomerangFlyTime + Info.BoomerangHangtime)
                        {
                            PreFlyTo(mStartPos.X, mStartPos.Y, mSpeed * 1.4f, intervalMS);
                        }
                        break;
                    case SpellTemplate.MotionType.Immovability:
                    case SpellTemplate.MotionType.AOE:
						mLocalPos.SetX(mPos.X);
                        mLocalPos.SetY(mPos.Y);
                        break;


                    case SpellTemplate.MotionType.AOE_Binding:
                    case SpellTemplate.MotionType.Binding:
                        if (Sender != null)
                        {
                            updateBinding(Sender.X, Sender.Y, Sender.Direction, intervalMS);
                        }
                        else
                        {
                            adjustPos(speed_distance);
                        }
                        break;
                    case SpellTemplate.MotionType.AOE_BindingTarget:
                    case SpellTemplate.MotionType.BindingTarget:
                        if (Target != null)
                        {
                            updateBinding(Target.X, Target.Y, Target.Direction, intervalMS);
                        }
                        else
                        {
                            adjustPos(speed_distance);
                        }
                        break;

                    case SpellTemplate.MotionType.Missile:
					case SpellTemplate.MotionType.MissileAttackRoute:
						if (Target != null)
                        {
                            if (Info.RotateSpeedSEC == 0)
                            {
                                PreFaceTo(Target.X, Target.Y);
                            }
                            PreFlyTo(Target.X, Target.Y, mSpeed, intervalMS);
                        }
                        else
                        {
                            MathVector.movePolar(mLocalPos, mStartDirection, speed_distance);
                        }
                        break;
                    case SpellTemplate.MotionType.SeekerMissile:
                        if (Target != null)
                        {
                            if (Info.SeekingTurningAngleSEC != 0)
                            {
                                FlyToTargetTunning(Target.X, Target.Y, mSpeed, Info.SeekingTurningAngleSEC, intervalMS);
                            }
                            else
                            {
                                PreFaceTo(Target.X, Target.Y);
                                PreFlyTo(Target.X, Target.Y, mSpeed, intervalMS);
                            }
                        }
                        else
                        {
                            MathVector.movePolar(mLocalPos, mStartDirection, speed_distance);
                        }
                        break;
                    case SpellTemplate.MotionType.SeekerSelectTarget:
                        break;
                    case SpellTemplate.MotionType.Chain:
                        if (Sender != null && Sender.IsEnable && Target != null && Target.IsActive)
                        {
                            mLocalPos.SetX(Sender.X);
                            mLocalPos.SetY(Sender.Y);
                            PreFaceTo(Target.X, Target.Y);
                        }
                        break;
					case SpellTemplate.MotionType.CurveMissile:
						IPosBase targetPos = Target == null ? (IPosBase)TargetPos : (IPosBase)Target;
						if(targetPos == null)
						{
							PreFlyTo(mStartDirection, mSpeed, intervalMS);
						}
						else if (Info.SeekingTurningAngleSEC != 0)
						{
							FlyToTargetTunning(targetPos.X, targetPos.Y, mSpeed, Info.SeekingTurningAngleSEC, intervalMS);
						}
						else
						{
							PreFaceTo(targetPos.X, targetPos.Y);
							PreFlyTo(targetPos.X, targetPos.Y, mSpeed, intervalMS);
						}
						break;
					case SpellTemplate.MotionType.Foxfire:
                        if (Target == null)
                        {
                            var mLaunchData = mAddEvent.LaunchData;
                            foxfireRoundAngle = mStartDirection + PassTimeMS * 0.001f * 3;
                            var x = (float)(Math.Cos(foxfireRoundAngle + 0.3f) * mLaunchData.LaunchSpellRadius);
                            var y = (float)(Math.Sin(foxfireRoundAngle + 0.3f) * mLaunchData.LaunchSpellRadius);
                            if (Sender != null)
                            {
                                x = Sender.X + x;
                                y = Sender.Y + y;
                            }
                            else
                            {
                                x = mStartPos.X + x;
                                y = mStartPos.Y + y;
                            }
                            PreFlyTo(x, y, mSpeed, intervalMS);
                            if (Info.RotateSpeedSEC == 0)
                            {
                                PreFaceTo(foxfireRoundAngle + (float)Math.PI * 0.25f);
                            }
                            foxfireSeekWait += intervalMS;
                        }
                        else
                        {
                            if (Info.SeekingTurningAngleSEC != 0)
                            {
                                FlyToTargetTunning(Target.X, Target.Y, mSpeed, Info.SeekingTurningAngleSEC, intervalMS);
                            }
                            else
                            {
                                PreFaceTo(Target.X, Target.Y);
                                PreFlyTo(Target.X, Target.Y, mSpeed, intervalMS);
                            }
                        }
                        break;
                }
                if (Info.BodyShape == SpellTemplate.Shape.LineToTarget)
                {
                    if (Target != null)
                    {
                        PreFaceTo(Target.X, Target.Y);
                    }
                }
                else if (Info.BodyShape == SpellTemplate.Shape.LineToStart)
                {
                    PreFaceTo(StartPos.X, StartPos.Y);
                }
                else if (Info.RotateSpeedSEC != 0 && Info.MType != SpellTemplate.MotionType.SeekerMissile)
                {
                    this.mDirection += MoveHelper.GetDistance(intervalMS, Info.RotateSpeedSEC);
                }
            }
            catch (Exception e) {
                log.Error(e.Message + "\n" + "Info.MType = " + Info.MType + "  Info.BodyShape = " + Info.BodyShape);
            }
            
        }

        private void updateZPos()
        {
            switch (Info.MType)
            {
                case SpellTemplate.MotionType.Immovability:
                case SpellTemplate.MotionType.SelectTarget:
                case SpellTemplate.MotionType.SelectLauncher:
                case SpellTemplate.MotionType.AOE:
                    updateFloatingZ(mStartHeight);
                    break;
                case SpellTemplate.MotionType.Straight:
                case SpellTemplate.MotionType.Boomerang1:
                case SpellTemplate.MotionType.Boomerang2:
                case SpellTemplate.MotionType.StraightAndStop:
                    updateFloatingZ(mStartHeight);
                    break;
                case SpellTemplate.MotionType.AOE_Binding:
                case SpellTemplate.MotionType.Binding:
                    if (Sender != null)
                    {
                        this.mLocal_Z = Sender.Z;
                    }
                    break;
                case SpellTemplate.MotionType.AOE_BindingTarget:
                case SpellTemplate.MotionType.BindingTarget:
                    if (Target != null)
                    {
                        this.mLocal_Z = Target.Z;
                    }
                    break;
                case SpellTemplate.MotionType.Cannon:
                    if (TargetPos != null)
                    {
                        updateTargetZ(TargetPos, 0);
                    }
                    break;
                case SpellTemplate.MotionType.Missile:
                case SpellTemplate.MotionType.SeekerMissile:
				case SpellTemplate.MotionType.MissileAttackRoute:
					if (Target != null)
                    {
                        updateTargetZ(new TVector2(Target.X, Target.Y), Target.Z + Target.Info.BodyHeight * 0.6f);
                    }
                    break;
                case SpellTemplate.MotionType.CurveMissile:
                    if (Target != null)
                    {
                        updata3DParabola(new TVector2(Target.X, Target.Y));
                    }
                    break;
            }
        }

        private void updata3DParabola(IVector2 targetPos)
        {
            TVector2 nowPos = new TVector2(mLocalPos.X, mLocalPos.Y);
            TVector2 vcStart = new TVector2(mStartPos.X, mStartPos.Y);
            TVector2 vcEnd = new TVector2(targetPos.X, targetPos.Y);
            TVector2 v1 = nowPos - vcStart;
            TVector2 v2 = vcEnd - vcStart;
            float a = (float)Math.Atan2(v1.Y, v1.X);
            float b = (float)Math.Atan2(v2.Y, v2.X);
            if (float.Equals(a, b) || float.Equals(Math.PI, Math.Abs(a - b)))
            {
                mLocal_Z = Target.Z;
            }
            else
            {
                float dis = nowPos.DistanceTo(vcStart) * (float)Math.Abs(Math.Sin(a - b));
                mLocal_Z = this.mStartHeight + dis *1.6f* (float)Math.Sin(Math.PI / 6 * mCurveMissileIndex);
                //ClientLog.LogWarning(">z:{0}, index:{1}, ({2},{3})->({4},{5})->({6},{7})", mLocal_Z, mCurveMissileIndex, mStartPos.X, mStartPos.Y, TargetPos.X, targetPos.Y, nowPos.X, nowPos.Y);
            }
        }

        /// <summary>
        /// 计算有固定目标Z坐标
        /// </summary>
        /// <param name="targetPos"></param>
        /// <param name="targetZ"></param>
        private void updateTargetZ(IVector2 targetPos, float targetZ)
        {
            float fdis = MathVector.getDistance(mStartPos, targetPos);
            float odis = MathVector.getDistance(mStartPos, mLocalPos);
            float pct = CMath.getInRange((fdis == 0 ? 0 : (odis / fdis)), 0, 1);//生命周期百分比//
            float dz = CMath.getMiddleValue(pct, mStartHeight, targetZ);//和目标高度差//
            float ph = 0;//抛物线相对高度//
            if (Info.ParabolaHeight != 0)
            {
                //计算抛物线//
                ph = (float)Math.Sin(pct * CMath.PI_F) * Info.ParabolaHeight;
            }
            this.mLocal_Z = dz + ph;
        }
        private void updateFloatingZ(float targetZ)
        {
            float pct = (float)mPassTimeMS / (float)Info.LifeTimeMS;//生命周期百分比//
            float dz = CMath.getMiddleValue(pct, mStartHeight, targetZ);//和目标高度差//
            float ph = 0;//抛物线相对高度//
            if (Info.ParabolaHeight != 0)
            {
                //计算抛物线//
                ph = (float)Math.Sin(pct * CMath.PI_F) * Info.ParabolaHeight;
            }
            this.mLocal_Z = dz + ph;
        }

        private void updateBinding(float x, float y, float direction, int intervalMS)
        {
            if (Info.IsBindingDirection)
            {
                mDirection = direction;
            }
            if (Info.IsBindingOrbit)
            {
                float dadd = Info.OrbitDistance;
                float ox = (float)Math.Cos(Direction) * dadd;
                float oy = (float)Math.Sin(Direction) * dadd;
                mLocalPos.SetX(x + ox);
                mLocalPos.SetY(y + oy);
            }
            else
            {
                mLocalPos.SetX(x);
                mLocalPos.SetY(y);
            }
        }

        #endregion

        //---------------------------------------------------------------------------------------------------
        #region _UpdateShape_

        private void updateAOE(int intervalMS)
        {
            switch (Info.BodyShape)
            {
                case SpellTemplate.Shape.LineToTarget:
                case SpellTemplate.Shape.LineToStart:
                case SpellTemplate.Shape.Strip:
                case SpellTemplate.Shape.StripRay:
                case SpellTemplate.Shape.StripRayTouchEnd:
                case SpellTemplate.Shape.RectStrip:
                case SpellTemplate.Shape.RectStripRay:
                    updateAoeMotion(intervalMS, Info.Distance, ref mDistanceLimit);
                    mDisplayDistance = mDistanceLimit;
                    break;
                default:
                    updateAoeMotion(intervalMS, Info.BodySize, ref mSizeLimit);
                    mDisplaySize = mSizeLimit;
                    break;
            }
        }
        private void updateAoeMotion(int intervalMS, float base_value, ref float value)
        {
            switch (Info.AOEMType)
            {
                case SpellTemplate.AoeMotionType.Sine:
                    value = (float)Math.Sin(CMath.PI_F * mPassTimeMS / (float)Info.LifeTimeMS) * base_value;
                    break;
                case SpellTemplate.AoeMotionType.Linear:
                default:
                    value += MoveHelper.GetDistance(intervalMS, mSpeed);
                    break;
            }
        }

        private void updateRayTouchEnd()
        {
            if (Launcher != null)
            {
                float d_width = Info.RectWide / 2f;
                Vector2 p1 = new Vector2(X, Y);
                MathVector.movePolar(p1, this.Direction, this.mDistanceLimit);
                using (var list = ListObjectPool<ZoneUnit>.AllocAutoRelease())
                {
                    Parent.ForEachNearObjectsRect(this.X, this.Y, p1.X, p1.Y, (ZoneObject u, ref bool cancel) =>
                    {
                        if ((u is ZoneUnit))
                        {
                            ZoneUnit zu = u as ZoneUnit;
                            if (Parent.IsAttackable(Launcher, zu, Info.ExpectTarget))
                            {
                                if ((CMath.intersectLineRound(this.X, this.Y, p1.X, p1.Y, zu.X, zu.Y, d_width + zu.BodyHitSize)))
                                {
                                    list.Add(u as ZoneUnit);
                                }
                            }
                        }
                    });
                    if (list.Count > 0)
                    {
                        list.Sort(new ObjectBodySorterNearest<ZoneUnit>(this.X, this.Y, 0));
                        this.mDisplayDistance = CMath.getDistance(this.X, this.Y, list[0].X, list[0].Y);
                        this.mDisplayDistance = Math.Min(mDisplayDistance, this.mDistanceLimit);
                    }
                    else
                    {
                        this.mDisplayDistance = this.mDistanceLimit;
                    }
                }
            }
        }

        private void updateLineToTarget()
        {
            if (Info.BodyShape == SpellTemplate.Shape.LineToTarget)
            {
                if (Target != null)
                {
                    this.mDisplayDistance = CMath.getDistance(this.X, this.Y, Target.X, Target.Y);
                    this.mDisplayDistance = Math.Min(mDisplayDistance, this.mDistanceLimit);
                    PreFaceTo(Target.X, Target.Y);
                }
                else
                {
                    this.mDisplayDistance = 0;
                }
            }
            else if (Info.BodyShape == SpellTemplate.Shape.LineToStart)
            {
                this.mDisplayDistance = CMath.getDistance(this.X, this.Y, mStartPos.X, mStartPos.Y);
                this.mDisplayDistance = Math.Min(mDisplayDistance, this.mDistanceLimit);
                PreFaceTo(mStartPos.X, mStartPos.Y);
            }
            else
            {
                this.mDisplayDistance = 0;
            }
        }

        #endregion
        //---------------------------------------------------------------------------------------------------
        #region _UpdateKeyFrames_


        /// <summary>
        /// 更新范围检测以及关键帧
        /// </summary>
        private void updateKeyFrames()
        {
            switch (Info.MType)
            {
                case SpellTemplate.MotionType.Missile:
                case SpellTemplate.MotionType.SeekerMissile:
                case SpellTemplate.MotionType.Cannon:
                case SpellTemplate.MotionType.Chain:
				case SpellTemplate.MotionType.CurveMissile:
                    break;
                default:
                    if (Info.BodyShape == SpellTemplate.Shape.LineToTarget || Info.BodyShape == SpellTemplate.Shape.LineToStart)
                    {

                    }
                    else
                    {
                        updateKeyFramesRanged();
                    }
                    break;
            }
        }

        private void updateKeyFramesRanged()
        {
            using (var kfs = ListObjectPool<SpellTemplate.KeyFrame>.AllocAutoRelease())
            {
               // int kfs_count = mKeyFrames.PopKeyFrames(PassTimeMS, kfs);
                bool is_interval_test = mHitIntervalTicker.Update(Parent.CurrentIntervalMS);
                //if (kfs_count > 0)
                //{
                //    for (int i = 0; i < kfs.Count; i++)
                //    {
                //        if (kfs[i].Effect != null)
                //        {
                //            Parent.PreQueueEvent(new UnitEffectEvent(ObjectID, kfs[i].Effect));
                //        }
                //    }
                //}
                if (Info.HitOnExplosion)
                {
                }
                else if (Info.HitIntervalMS == 0)
                {
                }
                else if (is_interval_test)
                {
                    if (Info.HitIntervalKeyFrame != null && Info.HitIntervalKeyFrame.Effect != null)
                    {
                        Parent.PreQueueEvent(new UnitEffectEvent(ObjectID, Info.HitIntervalKeyFrame.Effect));
                    }
                }
            }
        }

        #endregion
        //---------------------------------------------------------------------------------------------------
        private void adjustPos(float min_distance)
        {
            float fdistance = MathVector.getDistance(mLocalPos, mPos);
            if (fdistance < min_distance)
            {
                MathVector.moveTo(mLocalPos, mPos.X, mPos.Y, min_distance);
            }
            else
            {
                MathVector.moveTo(mLocalPos, mPos.X, mPos.Y, fdistance / 2f);
            }
        }

        private void PreFaceTo(float angle)
        {
            this.mDirection = angle;
        }

        private void PreFaceTo(float x, float y)
        {
            if (this.X == x && this.Y == y)
            {
                return;
            }
            this.mDirection = (float)(Math.Atan2(y - this.Y, x - this.X));
        }
        private void PreTurnTo(float add)
        {
            this.mDirection += add;
        }
        private void PreFlyTo(float x, float y, float speedSEC, int intervalMS)
        {
            float distance = MoveHelper.GetDistance(intervalMS, speedSEC);
            MathVector.moveTo(mLocalPos, x, y, distance);
        }
        private void PreFlyTo(float direction, float speedSEC, int intervalMS)
        {
            float distance = MoveHelper.GetDistance(intervalMS, speedSEC);
            float dx = (float)(Math.Cos(direction) * distance);
            float dy = (float)(Math.Sin(direction) * distance);
            mLocalPos.AddX(dx);
            mLocalPos.AddY(dy);
        }
        public void FlyToTargetTunning(float x, float y, float speedSEC, float tunningSpeedSEC, int intervalMS)
        {
            MoveHelper.MoveToTargetTunning(ref mLocalPos, ref mDirection, x, y, speedSEC, tunningSpeedSEC, intervalMS);
        }
    }
}