WSHCommon/Common/CommonAI/Zone/Helper/Motions.cs

using System;
using System.Collections.Generic;
using CommonLang.Vector;
using CommonLang;
using CommonAI.Zone.Instance;
using CommonAI.RTS.Manhattan;
using CommonLang.IO;

namespace CommonAI.Zone.Helper
{
    public class MoveHelper
    {
        public static readonly int POS_PRECISION = 255;
		public static readonly float ToDirectionD8_VALUE = (float)POS_PRECISION /CMath.PI_MUL_2;

		/// <summary>
		/// 更新速度
		/// </summary>
		public static void UpdateSpeed(int intervalMS, ref float speedSec, float addSec, float accSec)
        {
            float add = 0;
            float acc = 0;
            if (addSec != 0)
            {
                add = MoveHelper.GetDistance(intervalMS, addSec);
            }
            if (accSec != 0)
            {
                acc = MoveHelper.GetDistance(intervalMS, speedSec * accSec);
            }
            speedSec += (add + acc);
        }
        public static void UpdateSpeed(int intervalMS, ref float speedSec, float addSec, float accSec, float speedMin, float speedMax)
        {
            float add = 0;
            float acc = 0;
            if (addSec != 0)
            {
                add = MoveHelper.GetDistance(intervalMS, addSec);
            }
            if (accSec != 0)
            {
                acc = MoveHelper.GetDistance(intervalMS, speedSec * accSec);
            }
            speedSec += (add + acc);
            if (speedSec > speedMax) { speedSec = speedMax; }
            if (speedSec < speedMin) { speedSec = speedMin; }
        }

        public static void UpdateMoveDistance(int intervalMS, ref float moveDistance, float speed)
        {
            moveDistance += MoveHelper.GetDistance(intervalMS, speed);
        }

        #region IO

        public static byte ToDirectionD8(float d)
        {
            return (byte)(CMath.OpitimizeRadians(d) * ToDirectionD8_VALUE);
		}
        public static float ToDirectionF32(byte d8)
        {
            return d8 * CMath.PI_MUL_2 / POS_PRECISION;
        }
        public static ushort ToPos16(float x)
        {
            return (ushort)(x * POS_PRECISION);
        }
        public static float ToPosF32(ushort x)
        {
            return ((float)x) / POS_PRECISION;
        }

        public static void WritePos(bool half, float x, IOutputStream output)
        {
            if (half)
            {
                output.PutU16(ToPos16(x));
            }
            else
            {
                output.PutF32(x);
            }
        }
        public static void WritePos(bool half, float x, float y, IOutputStream output)
        {
            if (half)
            {
                output.PutU16(ToPos16(x));
                output.PutU16(ToPos16(y));
            }
            else
            {
                output.PutF32(x);
                output.PutF32(y);
            }
        }
        public static void WriteDirection(bool half, float direction, IOutputStream output)
        {
            if (half)
            {
                output.PutU8(ToDirectionD8(direction));
            }
            else
            {
                output.PutF32(direction);
            }
        }
        public static void WritePosAndDirection(bool half, float x, float y, float direction, IOutputStream output)
        {
            if (half)
            {
                output.PutU16(ToPos16(x));
                output.PutU16(ToPos16(y));
                output.PutU8(ToDirectionD8(direction));
            }
            else
            {
                output.PutF32(x);
                output.PutF32(y);
                output.PutF32(direction);
            }
        }

        public static void ReadPos(bool half, out float x, IInputStream input)
        {
            if (half)
            {
                x = ToPosF32(input.GetU16());
            }
            else
            {
                x = input.GetF32();
            }
        }
        public static void ReadPos(bool half, out float x, out float y, IInputStream input)
        {
            if (half)
            {
                x = ToPosF32(input.GetU16());
                y = ToPosF32(input.GetU16());
            }
            else
            {
                x = input.GetF32();
                y = input.GetF32();
            }
        }

		public static void ReadPos(bool half, ref Vector2 pos, IInputStream input)
		{
			if (half)
			{
				pos.SetX(ToPosF32(input.GetU16()));
				pos.SetY(ToPosF32(input.GetU16()));
			}
			else
			{
				pos.SetX(input.GetF32());
				pos.SetY(input.GetF32());
			}
		}

		public static void ReadDirection(bool half, out float direction, IInputStream input)
        {
            if (half)
            {
                direction = ToDirectionF32(input.GetU8());
            }
            else
            {
                direction = input.GetF32();
            }
        }
        public static void ReadPosAndDirection(bool half, out float x, out float y, out float direction, IInputStream input)
        {
            if (half)
            {
                x = ToPosF32(input.GetU16());
                y = ToPosF32(input.GetU16());
                direction = ToDirectionF32(input.GetU8());
            }
            else
            {
                x = input.GetF32();
                y = input.GetF32();
                direction = input.GetF32();
            }
        }

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

        public static float GetDistance(int timeMS, float speedSEC)
        {
            return speedSEC * timeMS / 1000f;
        }

        /// <summary>
        /// 转身算法
        /// </summary>
        /// <param name="dstD">目标角度</param>
        /// <param name="curD">当前角度</param>
        /// <param name="turnSpeedSEC">角速度</param>
        /// <param name="intervalMS">时间间隔</param>
        /// <returns></returns>
        public static float DirectionChange(float dstD, float curD, float turnSpeedSEC, int intervalMS)
        {
            if (turnSpeedSEC > 0)
            {
                float delta = turnSpeedSEC * intervalMS / 1000f;
                float dd = CMath.OpitimizeRadians(dstD) + CMath.PI_MUL_2;
                float cd = CMath.OpitimizeRadians(curD) + CMath.PI_MUL_2;
                float distanceL = Math.Abs(dd - cd);
                float distanceR = CMath.PI_MUL_2 - distanceL;
                if (distanceL > distanceR)
                {
                    if (distanceR <= delta)
                    {
                        return dstD;
                    }
                    if (dd > cd)
                    {
                        curD -= delta;
                    }
                    else
                    {
                        curD += delta;
                    }
                }
                else
                {
                    if (distanceL <= delta)
                    {
                        return dstD;
                    }
                    if (dd > cd)
                    {
                        curD += delta;
                    }
                    else
                    {
                        curD -= delta;
                    }
                }
                return curD;
            }
            return dstD;
        }

        /// <summary>
        /// 导弹一样飞向目标，并自动调整方向
        /// </summary>
        /// <param name="pos"></param>
        /// <param name="direction"></param>
        /// <param name="targetX"></param>
        /// <param name="targetY"></param>
        /// <param name="speedSEC"></param>
        /// <param name="turnSpeedSEC"></param>
        /// <param name="intervalMS"></param>
        public static void MoveToTargetTunning(ref Vector2 sPos, ref float direction, float targetX, float targetY, float speedSEC, float turnSpeedSEC, int intervalMS)
        {
            float dstD = MathVector.getDegree(targetX - sPos.X, targetY - sPos.Y);
            direction = DirectionChange(dstD, direction, turnSpeedSEC, intervalMS);
            MathVector.movePolar(ref sPos, direction, speedSEC, intervalMS);
        }


        /// <summary>
        /// 预估击飞到落下的时间
        /// </summary>
        /// <param name="z">要计算的高度</param>
        /// <param name="z_speed">Z速度</param>
        /// <param name="z_limit">Z坐标上限</param>
        /// <param name="gravity">重力加速度</param>
        /// <param name="intervalMS">时间精度，越小越精确，一般10足够精度</param>
        /// <returns></returns>
        public static int CalculateFlyTimeMS(float z, float z_speed, float z_limit, float gravity, int intervalMS = 10)
        {
            int time = 0;
            float tick_g = GetDistance(intervalMS, gravity);
            do
            {
                time += intervalMS;
                float sd = GetDistance(intervalMS, z_speed);
                z += sd;
                if (z < 0)
                {
                    time -= (int)Math.Abs(intervalMS * (z / sd));
                }
                if (z_limit != 0 && z_speed > 0 && z > z_limit)
                {
                    z_speed = 0;
                }
                z_speed -= tick_g;
            }
            while (z > 0);
            return time;
        }
        /// <summary>
        /// 给定最大距离和总时间，计算当前抛物线高度
        /// y = ax2 + bx + c;
        /// </summary>
        /// <param name="maxHeight"></param>
        /// <param name="totalTimeMS"></param>
        /// <param name="currentTimeMS"></param>
        /// <returns></returns>
        public static float CalulateParabolicHeight(float maxHeight, int totalTimeMS, int currentTimeMS)
        {
            float pct = currentTimeMS / (float)totalTimeMS;
            // 用正弦函数模拟 //
            float y = (float)(Math.Sin(pct * CMath.PI_F) * maxHeight);
            return y;
        }

        /// <summary>
        /// 计算单位击退方向
        /// </summary>
        /// <param name="damage">受击者</param>
        /// <param name="attacker">攻击者</param>
        /// <param name="mtype"></param>
        /// <returns></returns>
        public static float CalculateHitMoveDirection(InstanceUnit damage, InstanceZoneObject attacker, AttackProp.HitMoveType mtype)
        {
            switch (mtype)
            {
                case AttackProp.HitMoveType.BySenderPosition:
                    return MathVector.getDegree(attacker.X, attacker.Y, damage.X, damage.Y);
                case AttackProp.HitMoveType.BySenderDirection:
                    return attacker.Direction;
                case AttackProp.HitMoveType.BySenderLeftRight:
                    float fx = attacker.X;
                    float fy = attacker.Y;
                    MathVector.movePolar(ref fx, ref fy, attacker.Direction, 10);
                    if (CMath.PointOnLine(attacker.X, attacker.Y, fx, fy, damage.X, damage.Y) == CMath.PointOnLineResult.Left)
                    {
                        return attacker.Direction - CMath.PI_DIV_2;
                    }
                    else
                    {
                        return attacker.Direction + CMath.PI_DIV_2;
                    }
                case AttackProp.HitMoveType.ToSenderCenter:
                case AttackProp.HitMoveType.ToSenderBodySize:
                    return attacker.Direction + CMath.PI_F;
            }
            return damage.Direction + CMath.PI_F;
        }

    }



    public class PopupKeyFrames<K> : IComparer<K> where K : BaseKeyFrame
    {
        readonly private List<K> list = new List<K>();

        public int Count
        {
            get { return list.Count; }
        }

        public PopupKeyFrames()
        {
        }

        public void AddRange(ICollection<K> frames)
        {
            list.AddRange(frames);
            list.Sort(this);
        }

        /// <summary>
        /// 取出所有到时间的关键帧
        /// </summary>
        /// <param name="passTimeMS"></param>
        /// <param name="ret"></param>
        /// <returns></returns>
        public int PopKeyFrames(int passTimeMS, List<K> ret = null)
        {
            int count = 0;
            while (list.Count > 0)
            {
                int i = list.Count - 1;
                K kf = list[i];

				//不足一帧的，当帧处理
                if (kf.FrameMS <= passTimeMS + XmdsConstConfig.GAME_UPDATE_INTERVAL_MS)
                {
                    list.RemoveAt(i);
                    if (ret != null) { ret.Add(kf); }
                    count++;
                }
                else
                {
                    return count;
                }
            }
            return count;
        }

        public int Compare(K x, K y)
        {
            return y.FrameMS - x.FrameMS;
        }

    }

    public enum MoveResult : byte
    {
        MOVE_SMOOTH = 0,
        /// <summary>
        /// 标志状态，本次移动任何方向接触过地图
        /// </summary>
        MOVE_RESULT_TOUCH_MAP_ALL = 0x10,
        /// <summary>
        /// 标志状态，阻挡的单位同意让开
        /// </summary>
        MOVE_RESULT_TOUCH_OBJ_GETAWAY = 0x20,
        /// <summary>
        /// 标志状态，本次移动等等
        /// </summary>
        MOVE_RESULT_HOLD = 0x40,
        /// <summary>
        /// 标志状态，无法移动
        /// </summary>
        MOVE_RESULT_NO_WAY = 0x80,

        /// <summary>
        /// 标志判断，到达目标
        /// </summary>
        MOVE_RESULT_ARRIVED = 0x01,
        /// <summary>
        /// 标志判断，被单位阻挡
        /// </summary>
        MOVE_RESULT_BLOCK_OBJ = 0x02,
        /// <summary>
        /// 标志判断，被地图阻挡
        /// </summary>
        MOVE_RESULT_BLOCK_MAP = 0x04,
        /// <summary>
        /// 标志判断，没有达到预期距离或者移动距离太小
        /// </summary>
        MOVE_RESULT_MIN_STEP = 0x08,

        /// <summary>
        /// 【标志判断组】，被任何东西阻挡
        /// </summary>
        RESULTS_BLOCK_ANY = MOVE_RESULT_BLOCK_OBJ | MOVE_RESULT_BLOCK_MAP,
        /// <summary>
        /// 【标志判断】，移动结束（被阻挡或者到达目标）
        /// </summary>
        RESULTS_MOVE_END = MOVE_RESULT_ARRIVED | MOVE_RESULT_BLOCK_OBJ | MOVE_RESULT_BLOCK_MAP | MOVE_RESULT_NO_WAY,
    }

    public enum MoveImpactResult : byte
    {
        MOVE_SMOOTH = MoveResult.MOVE_SMOOTH,

        /// <summary>
        /// 标志状态，本次移动任何方向接触过地图
        /// </summary>
        MOVE_RESULT_TOUCH_MAP = MoveResult.MOVE_RESULT_TOUCH_MAP_ALL,
        /// <summary>
        /// 标志状态，阻挡的单位同意让开
        /// </summary>
        MOVE_RESULT_TOUCH_OBJ = MoveResult.MOVE_RESULT_TOUCH_OBJ_GETAWAY,


        /// <summary>
        /// 标志判断，被单位阻挡
        /// </summary>
        MOVE_RESULT_BLOCK_OBJ = MoveResult.MOVE_RESULT_BLOCK_OBJ,
        /// <summary>
        /// 标志判断，被地图阻挡
        /// </summary>
        MOVE_RESULT_BLOCK_MAP = MoveResult.MOVE_RESULT_BLOCK_MAP,
        /// <summary>
        /// 标志判断，没有达到预期距离或者移动距离太小
        /// </summary>
        MOVE_RESULT_MIN_STEP = MoveResult.MOVE_RESULT_MIN_STEP,

        /// <summary>
        /// 【标志判断组】，被任何东西阻挡
        /// </summary>
        RESULTS_CAN_NOT_MOVE = MOVE_RESULT_BLOCK_OBJ | MOVE_RESULT_BLOCK_MAP | MOVE_RESULT_MIN_STEP,
    }

    public struct MoveBlockResult
    {
        public MoveResult result;
        public InstanceZoneObject obj;

        public MoveBlockResult(MoveResult r)
        {
            this.result = r;
            this.obj = null;
        }
        public bool HasFlag(MoveResult flag)
        {
            return (result & flag) != 0;
        }
    }

    public struct TMoveTarget : IPositionObject
    {
        private float x;
        private float y;
        public TMoveTarget(float x, float y)
        {
            this.x = x;
            this.y = y;
        }
        public float X { get { return x; } }
        public float Y { get { return y; } }
        public float Direction { get { return 0; } }
        public float RadiusSize { get { return 0; } }
    }


    public class MoveAI
    {
        public readonly InstanceUnit unit;
        public readonly InstanceZone zone;

        private MoveTurnPosObject turnLR;
        private MoveTurnPosMapBlock turnMap;
        private AstarManhattan.MWayPoint next_path;
        private TimeExpire<int> holdTime;
        private bool mPause = true;
        private bool mOverrideActionStatus;

        private readonly int hold_time;
        private readonly int hold_max_time;
        private readonly int hold_min_time;

        public IPositionObject Target { get; private set; }

        public bool IsBypass { get; set; }
        public bool IsTurnLR { get { return turnLR != null; } }
        public float TargetX { get { return Target.X; } }
        public float TargetY { get { return Target.Y; } }
        public bool IsNoWay { get; private set; }
        public bool IsNoWayAutoFindNear { get; set; }

        public MoveAI(InstanceUnit owner, bool overrideActionStatus = true, int holdTimeMS = -1)
        {
            this.unit = owner;
            this.zone = owner.Parent;
            this.mOverrideActionStatus = overrideActionStatus;
            if (holdTimeMS < 0)
            {
                hold_time = unit.Templates.CFG.AI_MOVE_AI_HOLD_TIME_MS;
            }
            else
            {
                hold_time = holdTimeMS;
            }
            this.holdTime = new TimeExpire<int>(hold_time);
            this.turnLR = new MoveTurnPosObject(unit);
            this.turnMap = new MoveTurnPosMapBlock(unit);
            this.holdTime.End();
            this.hold_max_time = hold_time;
            this.hold_min_time = hold_time / 2;
            this.IsNoWayAutoFindNear = true;
        }

        public void Hold(int timeMS = 0)
        {
            if (timeMS <= 0)
            {
                timeMS = unit.RandomN.Next(hold_min_time, hold_max_time);
            }
            holdTime.Reset(timeMS);
        }

        public void FindPath(float x, float y)
        {
            this.FindPath(new TMoveTarget(x, y));
        }
        public void FindPath(IPositionObject target)
        {
            if (target != null)
            {
                this.Target = target;
                this.next_path = zone.findPath(unit.X, unit.Y, TargetX, TargetY);
                if (next_path == null)
                {
                    holdTime.Reset(hold_time);
                    IsNoWay = true;

                    var dis = MathVector.getDistance(unit.X, unit.Y, TargetX, TargetY);
                    //如果不能到达目的地，则找个靠近点
                    float fixx = -1, fixy = -1;
                    if (zone.GetNearWay(unit.X, unit.Y, TargetX, TargetY, dis - 1, ref fixx, ref fixy))
                    {
                        Target = new TMoveTarget(fixx, fixy);
                        next_path = zone.findPath(unit.X, unit.Y, TargetX, TargetY);
                        IsNoWay = next_path == null;
                    }
                }
                this.mPause = false;
            }
        }

        public void Pause()
        {
            this.next_path = null;
            this.turnLR.Stop();
            this.turnMap.Stop();
            this.holdTime.End();
            this.mPause = true;
        }

        public bool IsDirectLookTarget()
        {
            //if ((Target is InstanceUnit) && CMath.includeRoundPoint(unit.X, unit.Y, unit.Info.GuardRangeLimit, TargetX, TargetY))
           if ((Target is InstanceUnit))
           {
                // 地图连线无阻挡 //
                if (!zone.RaycastMap(unit, unit.X, unit.Y, TargetX, TargetY))
                {
                    return true;
                }
            }
            return false;
        }

        public MoveBlockResult Update()
        {
            MoveBlockResult result = new MoveBlockResult();
            if (Target == null)
            {
                result.result = MoveResult.MOVE_RESULT_HOLD;
                return result;
            }
            if (mPause)
            {
                result.result = MoveResult.MOVE_RESULT_HOLD;
                return result;
            }
            else if (IsNoWay)
            {
                if (IsNoWayAutoFindNear && holdTime.Update(zone.UpdateIntervalMS))
                {
                    this.next_path = zone.findPath(
                        unit.X,
                        unit.Y,
                        TargetX + (float)(unit.Parent.GridCellW * ((unit.Parent.RandomN.NextDouble() * 2) - 1)),
                        TargetY + (float)(unit.Parent.GridCellH * ((unit.Parent.RandomN.NextDouble() * 2) - 1)));
                    IsNoWay = next_path == null;
                }
				//else
				//{
				//    unit.faceTo(Target.X, Target.Y);
				//    result = unit.moveBlockTo(Target.X, Target.Y, unit.MoveSpeedSEC, zone.UpdateIntervalMS);
				//    result.result = result.result | MoveResult.MOVE_RESULT_NO_WAY;
				//    return result;
				//}

				if (IsNoWay)
				{
					if (this.unit.IsFollowMaster() && mOverrideActionStatus && unit.CurrentActionStatus != UnitActionStatus.Idle)
					{
						this.unit.Virtual.SendMsgToClient(CommonAI.XmdsConstConfig.TIPS_FOLLOW_FAIL);
						unit.SetActionStatus(UnitActionStatus.Idle);
					}
						

					result.result = result.result | MoveResult.MOVE_RESULT_NO_WAY;
					return result;
				}				
			}


            //if (!holdTime.Update(zone.UpdateIntervalMS))
            //{
                //result.result = MoveResult.MOVE_RESULT_HOLD;
                //if (mOverrideActionStatus) unit.SetActionStatus(UnitActionStatus.Idle);
			//}
			//else
			//{
			if (mOverrideActionStatus) unit.SetActionStatus(UnitActionStatus.Move);
                if (!turnMap.IsEnd)
                {
                    // 如果向目标移动过程中被地块阻挡，则向左或右调整一段距离 //
                    if (turnMap.move(unit.MoveSpeedSEC, zone.UpdateIntervalMS, out result))
                    {
                        return result;
                    }
                }
                else if (!turnLR.IsEnd)
                {
                    // 如果向目标移动过程中被单位阻挡，则向左或右调整一段距离 //
                    if (turnLR.move(unit.MoveSpeedSEC, zone.UpdateIntervalMS, out result))
                    {
                        if ((result.result & MoveResult.MOVE_RESULT_ARRIVED) != 0)
                        {
                            result.result ^= MoveResult.MOVE_RESULT_ARRIVED;
                        }
                        if ((result.result & MoveResult.MOVE_RESULT_TOUCH_OBJ_GETAWAY) != 0)
                        {
                            Hold();
                            return result;
                        }
                        else if ((result.result & MoveResult.MOVE_RESULT_BLOCK_MAP) != 0)
                        {
                            Hold();
                        }
                    }
                }
                else if (next_path != null)
                {
                    //if (IsDirectLookTarget())
                    //{
                    //    next_path = null;
                    //}
                    //else
                    //{
                        // 如果向目标移动过程中被地图阻挡，则寻路 //
                        result = unit.moveBlockTo(next_path.PosX, next_path.PosY, unit.MoveSpeedSEC, zone.UpdateIntervalMS);
                        if ((result.result & MoveResult.MOVE_RESULT_MIN_STEP) != 0 ||
                            (result.result & MoveResult.MOVE_RESULT_ARRIVED) != 0)
                        {
                        }
                        else
                        {
                            unit.faceTo(next_path.PosX, next_path.PosY);
                        }
                        if ((result.result & MoveResult.MOVE_RESULT_ARRIVED) != 0)
                        {
                            next_path = next_path.Next;
                            if (next_path != null)
                            {
                                result.result ^= MoveResult.MOVE_RESULT_ARRIVED;
                                if (IsDirectLookTarget())
                                {
                                    next_path = null;
                                }
                            }
                            else
                            {
                                next_path = zone.findPath(unit.X, unit.Y, TargetX, TargetY);
                                if (next_path == null)
                                {
                                    Hold();
                                    IsNoWay = true;
                                }
                            }
                        }
                        else if ((result.result & MoveResult.MOVE_RESULT_TOUCH_MAP_ALL) != 0)
                        {
                            if ((result.result & MoveResult.MOVE_RESULT_MIN_STEP) != 0)
                            {
                                turnMap.Start(next_path.PosX, next_path.PosY);
                            }
                        }
                        else if ((result.result & MoveResult.MOVE_RESULT_NO_WAY) != 0)
                        {
                            next_path = null;
                            //unit.faceTo(TargetX, TargetY);
                            //result = unit.moveBlockTo(TargetX, TargetY, unit.MoveSpeedSEC, zone.UpdateIntervalMS);
                        }
                        else if ((result.result & MoveResult.MOVE_RESULT_BLOCK_MAP) != 0)
                        {
                            Hold();
                            next_path = null;
                            return result;
                        }
                    //}
                }
                else
                {
                    if (!IsDirectLookTarget())
                    {
                        next_path = zone.findPath(unit.X, unit.Y, TargetX, TargetY);
                        if (next_path == null)
                        {
                            Hold();
                            IsNoWay = true;
                        }
                    }
                    else
                    {
                        unit.faceTo(TargetX, TargetY);
                        result = unit.moveBlockTo(TargetX, TargetY, unit.MoveSpeedSEC, zone.UpdateIntervalMS);
                    }
                }
            //}
            return result;
        }

        /// <summary>
        /// 如果向目标移动过程中被单位阻挡，则向左或右调整一段距离
        /// </summary>
        private class MoveTurnPosObject
        {
            public InstanceUnit Owner { get; private set; }
            public InstanceZoneObject Touched { get; private set; }
            public bool IsEnd { get; private set; }

            public float TargetX { get; private set; }
            public float TargetY { get; private set; }
            public bool FaceTo { get; private set; }

            public int TouchCount { get { return touched_list.Count; } }

            private Vector2 TargetPos;
            private HashMap<uint, InstanceZoneObject> touched_list = new HashMap<uint, InstanceZoneObject>();

            public MoveTurnPosObject(InstanceUnit owner)
            {
                this.Owner = owner;
                this.IsEnd = true;
            }

            public void Start(float targetX, float targetY, InstanceZoneObject touched)
            {
                this.Touched = touched;
                this.IsEnd = false;
                this.TargetPos = new Vector2(targetX, targetY);
                this.touched_list.Clear();
                TurnNearBypass();
            }


            public void Stop()
            {
                this.IsEnd = true;
            }

            /// <summary>
            /// 绕过某个单位移动
            /// </summary>
            /// <param name="speedSEC"></param>
            /// <param name="intervalMS"></param>
            /// <param name="result"></param>
            /// <returns>是否移动结束</returns>
            public bool move(float speedSEC, int intervalMS, out MoveBlockResult result)
            {
                Owner.faceTo(TargetX, TargetY);
                result = Owner.moveBlockTo(TargetX, TargetY, speedSEC, intervalMS);
                if (result.obj != null)
                {
                    Touched = result.obj;
                }
                if ((result.result & (MoveResult.MOVE_RESULT_BLOCK_MAP)) != 0)
                {
                    this.IsEnd = true;
                    return true;
                }
                else if ((result.result & (MoveResult.MOVE_RESULT_ARRIVED)) != 0)
                {
                    if (this.TargetX == Owner.X && this.TargetY == Owner.Y)
                    {
                        this.TargetX = TargetPos.X;
                        this.TargetY = TargetPos.Y;
                        this.IsEnd = true;
                        return true;
                    }
                }
                if (result.obj != null)
                {
                    //换一种躲避方法//
                    if (touched_list.ContainsKey(result.obj.ID))
                    {
                        TurnRandomBypass();
                    }
                    else
                    {
                        TurnNearBypass();
                        touched_list.Put(Touched.ID, Touched);
                    }
                }
                return false;
            }

            /// <summary>
            /// 获取绕过去，离目标最近的点
            /// </summary>
            /// <returns></returns>
            private Vector2 GetNearTurnPos(InstanceZoneObject obj)
            {
                float bodysize = Math.Max(Touched.BodyBlockSize, Owner.BodyBlockSize);
                float angle = MathVector.getDegree(obj.X - Owner.X, obj.Y - Owner.Y);
                Vector2 turnL = new Vector2(Owner.X, Owner.Y);
                Vector2 turnR = new Vector2(Owner.X, Owner.Y);
                MathVector.movePolar(turnL, angle + CMath.PI_DIV_2, bodysize);
                MathVector.movePolar(turnR, angle - CMath.PI_DIV_2, bodysize);
                float dl = MathVector.getDistanceSquare(turnL, TargetPos);
                float dr = MathVector.getDistanceSquare(turnR, TargetPos);
                if (dl < dr)
                {
                    return turnL;
                }
                else
                {
                    return turnR;
                }
            }

            /// <summary>
            /// 碰到障碍时，绕过去
            /// </summary>
            /// <param name="unit"></param>
            private void TurnRandomBypass()
            {
                float bodysize = (Touched.BodyBlockSize + Owner.BodyBlockSize); // 1~2个身位 //
                float distance = bodysize + (float)(Owner.RandomN.NextDouble() * bodysize);
                float angle = MathVector.getDegree(Touched.X, Touched.Y, Owner.X, Owner.Y);
                float factor = (float)(Owner.RandomN.NextDouble() * (CMath.PI_DIV_2 / 2f));
                if (Owner.RandomN.Next(0, 10) % 2 == 0)
                {
                    angle += CMath.PI_DIV_2 - factor;
                }
                else
                {
                    angle -= CMath.PI_DIV_2 + factor;
                }
                Vector2 turnLR = new Vector2(Owner.X, Owner.Y);
                MathVector.movePolar(turnLR, angle, distance);
                this.TargetX = turnLR.X;
                this.TargetY = turnLR.Y;
            }
            /// <summary>
            /// 从最近点绕过去
            /// </summary>
            private void TurnNearBypass()
            {
                float bodysize = Math.Max(Touched.BodyBlockSize, Owner.BodyBlockSize); // 1~2个身位 //
                float distance = bodysize + (float)(Owner.RandomN.NextDouble() * bodysize);
                float angle = MathVector.getDegree(Touched.X, Touched.Y, Owner.X, Owner.Y);
                Vector2 turnL = new Vector2(Owner.X, Owner.Y);
                Vector2 turnR = new Vector2(Owner.X, Owner.Y);
                MathVector.movePolar(turnL, angle + CMath.PI_DIV_2, distance);
                MathVector.movePolar(turnR, angle - CMath.PI_DIV_2, distance);
                float dl = MathVector.getDistanceSquare(turnL, TargetPos);
                float dr = MathVector.getDistanceSquare(turnR, TargetPos);
                if (dl < dr)
                {
                    this.TargetX = turnL.X;
                    this.TargetY = turnL.Y;
                }
                else
                {
                    this.TargetX = turnR.X;
                    this.TargetY = turnR.Y;
                }
            }




        }

        /// <summary>
        /// 如果向目标移动过程中被单位阻挡，则向左或右调整一段距离
        /// </summary>
        private class MoveTurnPosMapBlock
        {
            public InstanceUnit Owner { get; private set; }
            public bool IsEnd { get; private set; }

            private float tx;
            private float ty;

            public MoveTurnPosMapBlock(InstanceUnit owner)
            {
                this.Owner = owner;
                this.IsEnd = true;
            }

            public void Start(float target_x, float target_y)
            {
                float tdx = (target_x - Owner.X);
                float tdy = (target_y - Owner.Y);
                int ddx = (int)CMath.getDirect(tdx);
                int ddy = (int)CMath.getDirect(tdy);
                if (Math.Abs(tdx) < Math.Abs(tdy))
                {
                    float tw = ddx * (float)(Owner.Parent.GridCellW + (Owner.RandomN.NextDouble() * Owner.Parent.GridCellW / 2f));
                    tx = Owner.X + tw;
                    ty = Owner.Y;
                }
                else
                {
                    float th = ddy * (float)(Owner.Parent.GridCellH + (Owner.RandomN.NextDouble() * Owner.Parent.GridCellH / 2f));
                    tx = Owner.X;
                    ty = Owner.Y + th;
                }
                this.IsEnd = false;
            }

            public void Stop()
            {
                this.IsEnd = true;
            }

            /// <summary>
            /// 绕过某个单位移动
            /// </summary>
            /// <param name="speedSEC"></param>
            /// <param name="intervalMS"></param>
            /// <param name="result"></param>
            /// <returns>是否移动结束</returns>
            public bool move(float speedSEC, int intervalMS, out MoveBlockResult result)
            {
                Owner.faceTo(tx, ty);
                MoveImpactResult rst = Owner.moveImpactTo(tx, ty, speedSEC, intervalMS);
                result = new MoveBlockResult();
                result.result = (MoveResult)((byte)rst);

                if ((rst & MoveImpactResult.RESULTS_CAN_NOT_MOVE) != 0)
                {
                    this.IsEnd = true;
                    return true;
                }
                return false;
            }
        }
    }



}