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

using CommonAI.Data;
using CommonAI.RTS;
using CommonAI.Zone.EventTrigger;
using CommonAI.Zone.Formula;
using CommonAI.Zone.Helper;
using CommonAI.ZoneClient;
using CommonAI.ZoneEditor;
using CommonAI.ZoneServer.JSGModule;
using CommonLang;
using CommonLang.Concurrent;
using CommonLang.IO;
using CommonLang.Log;
using CommonLang.Property;
using CommonLang.Vector;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using static CommonAI.Zone.SpellTemplate;
using static CommonAI.Zone.UnitInfo;

namespace CommonAI.Zone.Instance
{
    /// <summary>
    /// 服务端场景
    /// </summary>
    public partial class InstanceZone : GameEntity
    {
        private static AtomicInteger s_alloc_zone_count = new AtomicInteger(0);
        private static AtomicInteger s_active_zone_count = new AtomicInteger(0);

        /// <summary>
        /// 分配实例数量
        /// </summary>
        public static int AllocZoneCount { get { return s_alloc_zone_count.Value; } }
        /// <summary>
        /// 未释放实例数量
        /// </summary>
        public static int ActiveZoneCount { get { return s_active_zone_count.Value; } }

        //------------------------------------------------------------------------
        // 基础数据

        private InstanceZoneListener mListener;
        private TemplateManager mTemplates;
        private IFormula mFormula = TemplateManager.Factory.Formula;
        private IQuestAdapter mQuestAdapter;

        private SyncMessageQueue<Action> mSyncActionQueue = new SyncMessageQueue<Action>();
        private Queue<Event> mSendingEvents = new Queue<Event>();
        private InstanceZoneObjectMap mObjects;

        public TemplateManager Templates { get { return mTemplates; } }
        public IQuestAdapter QuestAdapter { get { return mQuestAdapter; } }
        public int UpdateIntervalMS { get { return mLastInterval; } }

        private readonly int mMaxUnitCount;
        private int mLastInterval = 0;
        private ulong mTimer = 0;
        private long mCurPassTimeMS = 0;
        private long mQueryPassTimeMS = 0;
        private int mQueryPassTimeSEC = 0;
        private bool mHalfSync = false;

        readonly private Random random;
        readonly private Logger log;

        public string UUID { get; set; }

        //------------------------------------------------------------------------
        readonly private ZoneInfo m_TerrainSrc;
        readonly private SpaceDivision mSpaceDiv;

        public ZoneInfo TerrainSrc { get { return m_TerrainSrc; } }
        public ZoneInfo Terrain { get { return path_terrain_data.Data; } }

        public int SpaceDivSize { get; private set; }
        [Desc("单位当前帧位移的最小距离")]
        public float MinStep { get; private set; }
        [Desc("最大单位数量")]
        public int MaxUnitCount { get { return mMaxUnitCount; } }
        [Desc("场景中是否存在Area")]
        public bool HasArea { get { return mHasArea; } }

        //山大王id
        protected int mKingID;
        //绑定服务器
        protected string mBindGameSrvId;

        //------------------------------------------------------------------------
        /// <summary>
        /// 
        /// </summary>
        /// <param name="templates"></param>
        /// <param name="listener">消息接收者</param>
        /// <param name="data">场景数据</param>
        /// <param name="spaceDivSize">空间分割参数</param>
        /// <param name="maxUnitCount">最大单位数</param>
        /// <param name="randomSeed">随机种子</param>
        internal InstanceZone(TemplateManager templates, InstanceZoneListener listener, ZoneEditor.SceneData data, GSCreateAreaData gsData,
            int spaceDivSize, int maxUnitCount, int randomSeed)
        {
            InstanceZone.s_alloc_zone_count++;
            InstanceZone.s_active_zone_count++;
            var info = data.ZoneData;
            this.log = LoggerFactory.GetLogger(string.Format("InstanceZone({0})", info.TemplateID));
            this.random = TemplateManager.Factory.CreateRandom(randomSeed);// new Random(randomSeed);
            this.mTemplates = templates;
            this.IsSyncZ = false;
            this.MinStep = MoveHelper.GetDistance(1000 / templates.CFG.SYSTEM_FPS, templates.CFG.OBJECT_MOVE_TO_MIN_STEP_SEC);
            if (spaceDivSize < 1)
            {
                throw new Exception("SpaceDivSize must large than map 1 !");
            }
            this.mMaxUnitCount = maxUnitCount;
            this.mListener = listener;
            this.m_TerrainSrc = info;
            this.SpaceDivSize = spaceDivSize;
            this.mSpaceDiv = new SpaceDivision(
                m_TerrainSrc.TotalWidth,
                m_TerrainSrc.TotalHeight,
                spaceDivSize * m_TerrainSrc.GridCellW,
                spaceDivSize * m_TerrainSrc.GridCellH);
            this.mObjects = new InstanceZoneObjectMap("zoneId:" + this.GetSceneID());
            //             this.path_terrain_data = new InstanceZoneManhattanMap(templates, info.Clone() as ZoneInfo);
            //             this.path_finder = new AstarManhattan(path_terrain_data, true, spaceDivSize);
            //             this.path_terrain_area_gen = new ManhattanMapAreaGenerator(path_terrain_data.Data);
            this.InitTerrain(data, spaceDivSize, out this.path_terrain_data, out this.path_finder, out this.path_terrain_area_gen);
            this.mQuestAdapter = TemplateManager.Factory.CreateQuestAdapter(this);
			this.baseInit(data, gsData);			
		}

		protected virtual void baseInit(ZoneEditor.SceneData data, GSCreateAreaData gsData)
		{

		}


        // -----------------------------------------------------------------------------------
        ~InstanceZone()
        {
            InstanceZone.s_alloc_zone_count--;
        }
        protected override void Disposing()
        {
            base.Disposing();
            this.ClearEvents();
            foreach (var obj in mObjects.Objects)
            {
                obj.Dispose();
            }
            this.mObjects.Dispose();
            this.mObjects = null;
            foreach (var flg in mFlags.Values)
            {
                flg.Dispose();
            }
            this.mFlags.Clear();
            this.DisposeTerrain();
            this.mSpaceDiv.Dispose();

            this.mQuestAdapter.Dispose();
            this.mQuestAdapter = null;
            this.mListener = null;
            this.mTemplates = null;
            this.mFormula = null;
            this.mSyncActionQueue = null;
            this.mSendingEvents = null;
            this.mTasks.Clear();
            this.mTasks = null;
            this.mTimeTasks.Dispose();
            this.mTimeTasks = null;
            this.EnvironmentVarMap.Clear();
            this.mFlags.Clear();

            this.m_UnitsPos.Clear();
            this.m_UnitsStates.Clear();

            InstanceZone.s_active_zone_count--;
        }
        // -----------------------------------------------------------------------------------
        protected Logger Log { get { return log; } }

        public int TotalWidth { get { return m_TerrainSrc.TotalWidth; } }
        public int TotalHeight { get { return m_TerrainSrc.TotalHeight; } }
        public int GridCellW { get { return m_TerrainSrc.GridCellW; } }
        public int GridCellH { get { return m_TerrainSrc.GridCellH; } }
        public int XCount { get { return m_TerrainSrc.XCount; } }
        public int YCount { get { return m_TerrainSrc.YCount; } }
        public ulong Tick { get { return mTimer; } }

        /// <summary>
        /// 是否发 SyncPosEvent 包
        /// </summary>
        public bool SyncPos
        {
            get { return sync_pos_list.Enable; }
            set { sync_pos_list.Enable = value; }
        }
        /// <summary>
        /// 是否为低速率网络同步(将优化为半字通信)
        /// </summary>
        public bool IsHalfSync
        {
            get { return mHalfSync; }
            set
            {
                if (value && TotalWidth <= 255 && TotalHeight <= 255)
                {
                    mHalfSync = value;
                }
                else
                {
                    mHalfSync = false;
                }
            }
        }
        /// <summary>
        /// 同步包是否包含Z
        /// </summary>
        public bool IsSyncZ
        {
            get;
            set;
        }
        public long PassTimeMS { get { return mQueryPassTimeMS; } }
        public int PassTimeSEC { get { return mQueryPassTimeSEC; } }
        public Random RandomN { get { return random; } }
        //         public void Trace(string text)
        //         {
        //             log.Info(text);
        //         }

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

        #region TIMING_AND_TASK

        private SyncMessageQueue<Action<InstanceZone>> mTasks = new SyncMessageQueue<Action<InstanceZone>>();
        private TimeTaskQueue mTimeTasks = new TimeTaskQueue();

        private void doTask(Action<InstanceZone> task)
        {
            task(this);
        }
        /// <summary>
        /// 【线程安全】向主线程排一个任务
        /// </summary>
        /// <param name="task"></param>
        public void queueTask(Action<InstanceZone> task)
        {
            mTasks.Enqueue(task);
        }

		public string GetInfo()
		{
			if(this.mObjects == null)
			{
				return "对象：-1";
			}
			
			return "对象：" + AllObjectsCount + ", 单位：" + AllUnitsCount + ", 法术：" + AllSpellsCount + ", 道具：" + AllItemsCount + ", 玩家：" + AllPlayersCount;
		}

		/// <summary>
		/// 【线程安全】增加时间任务
		/// </summary>
        /// <param name="intervalMS"></param>
        /// <param name="delayMS"></param>
        /// <param name="repeat"></param>
        /// <param name="handler"></param>
        public TimeTaskMS AddTimeTask(int intervalMS, int delayMS, int repeat, TickHandler handler)
        {
            return mTimeTasks.AddTimeTask(intervalMS, delayMS, repeat, handler);
        }
        /// <summary>
        /// 【线程安全】增加延时回调方法
        /// </summary>
        /// <param name="delayMS"></param>
        /// <param name="handler"></param>
        public TimeTaskMS AddTimeDelayMS(int delayMS, TickHandler handler)
        {
            return mTimeTasks.AddTimeDelayMS(delayMS, handler);
        }
        /// <summary>
        /// 【线程安全】增加定时回调方法
        /// </summary>
        /// <param name="intervalMS"></param>
        /// <param name="handler"></param>
        public TimeTaskMS AddTimePeriodicMS(int intervalMS, TickHandler handler)
        {
			if(intervalMS <= 0)
			{
				log.Error("增加定时任务异常：" + intervalMS);
				return null;
			}
            return mTimeTasks.AddTimePeriodicMS(intervalMS, handler);
        }

        #endregion

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

        /// <summary>
        /// 【线程安全】向当前场景输入指令
        /// </summary>
        /// <param name="act"></param>
        public void pushAction(Action act)
        {
            mSyncActionQueue.Enqueue(act);
        }
        protected internal void queueEventInternal(Event evt)
        {
            mSendingEvents.Enqueue(evt);
        }
        /// <summary>
        /// 【内部调用】输出消息
        /// </summary>
        public void queueEvent(ZoneEvent evt, GameEntity sender = null)
        {
            if (sender != null) { evt.sender = sender; }
            this.queueEventInternal(evt);
        }
        /// <summary>
        /// 【内部调用】输出消息
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="evt"></param>
        public void queueObjectEvent(InstanceZoneObject obj, ObjectEvent evt, bool force = false)
        {
			if(mSendingEvents == null)
			{
				if(mObjects == null)
				{
					log.Warn("queueObjectEvent exception1： " + this.GetSceneID() + ", mObjects null, " + this.UUID + ", " + evt.GetType()
                        + ", " + new StackTrace().ToString());
				}
				else
				{
					log.Warn("queueObjectEvent exception2： " + this.GetSceneID() + ", Players: " + this.AllPlayersCount + ", Items: "
					+ this.AllItemsCount + ", Units: " + this.AllUnitsCount + ", " + this.UUID + ", " + evt.GetType() + ", " + new StackTrace().ToString());
				}
				
				return;
			}

            if (obj.ID == 0)
                return;
            if (!force && !obj.IsInZone)
                return;
            obj.onSendingEvent(ref evt);
            if (evt != null)
            {
                evt.object_id = obj.ID;
                evt.sender = obj;
                mSendingEvents.Enqueue(evt);
            }
        }
        /// <summary>
        /// 立即发送指令
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="req"></param>
        /// <param name="rsp"></param>
        public void sendActorResponse(InstanceZoneObject obj, ActorRequest req, ActorResponse rsp)
        {
            if (obj.ID == 0)
                return;
            if (!obj.IsInZone)
                return;
            rsp.MessageID = req.MessageID;
            rsp.object_id = obj.ID;
            rsp.sender = obj;
            mSendingEvents.Enqueue(rsp);
        }

        public void sendMessageBox(string msg)
        {
            queueEventInternal(new TestMessageBox(msg));
        }

        public virtual int GetSceneID() { return 0; }


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

        public void RecvMessageFromGameServer(ZoneServer.SendMessageR2B msg)
        {
            LastRecvMessageR2B = msg;
            if (mOnRecvFromGS != null)
            {
                mOnRecvFromGS.Invoke(this, msg);
            }
        }
        public void SendMessageToGameServer(string msg)
        {
            ZoneServer.SendMessageB2R b2r = new ZoneServer.SendMessageB2R();
            b2r.Message = msg;
            LastSentMessageB2R = b2r;
            if (mOnSendToGS != null)
            {
                mOnSendToGS.Invoke(this, b2r);
            }
        }

        public void SendEventToGameServer(IExternalizable evt)
        {
            ZoneServer.SendEventB2R b2r = new ZoneServer.SendEventB2R();
            b2r.evt = evt;
            if (mOnSendMessageB2REvent != null)
            {
                mOnSendMessageB2REvent.Invoke(this, b2r);
            }
        }

        public bool CheckAutoDropItem()
        {
            return this.mListener.CheckDropItem();
        }

        //-----------------------------------------------------------------------------------
        public virtual void Update(int intervalMS, bool slowRefresh)
        {
            beginEventsRecord();
            this.mLastInterval = intervalMS;
            this.MinStep = MoveHelper.GetDistance(intervalMS, Templates.CFG.OBJECT_MOVE_TO_MIN_STEP_SEC);
            if (mTimer == 0)
            {
                mCurPassTimeMS = 0;
                mQueryPassTimeMS = 0;
                mQueryPassTimeSEC = 0;
                foreach (InstanceFlag f in mFlags.Values)
                {
                    f.OnStart();
                }
                if (mOnInit != null)
                    mOnInit.Invoke(this);
            }

            mTasks.ProcessMessages(doTask);
            mSyncActionQueue.ProcessMessages(updateAction);

            mObjects.Refresh();
            var objetes = mObjects.Objects;
            {
                // clean space div state
                foreach (InstanceZoneObject u in objetes)
                {
                    u.onUpdate(this, slowRefresh);
                }
                mSpaceDiv.ClearSpaceNearChanges();
                bool dirty = false;
                foreach (InstanceZoneObject u in objetes)
                {
                    if (u.Enable)
                    {
                        dirty = u.updatePos(this);
                        u.mCurCellNode.MarkPosDirty(dirty);
                        if (dirty && u.ClientVisible && u.SyncPos)
                        {
                            if (mOnObjectPosChanged != null)
                            {
                                mOnObjectPosChanged.Invoke(this, u);
                            }
                            sync_pos_list.Add(u);
                        }
                    }
                }
            }
            foreach (InstanceFlag f in mFlags.Values)
            {
                f.update();
            }
            if (mOnUpdate != null)
            {
                mOnUpdate.Invoke(this);
            }

            updateEvents();

            mTimeTasks.Update(intervalMS);

            mCurPassTimeMS += intervalMS;
            mQueryPassTimeMS = mCurPassTimeMS;
            mQueryPassTimeSEC = (int)(mCurPassTimeMS / 1000);
            mTimer++;
        }

        private void updateAction(Action act)
        {
            if (act is SystemMessage)
            {
                processSystemMessage(act as SystemMessage);
            }
            else if (act is ObjectAction)
            {
                ObjectAction oa = (ObjectAction)act;
                InstanceUnit unit = act.sender as InstanceUnit;
                if (unit == null)
                {
                    unit = mObjects.GetObject<InstanceUnit>(oa.object_id);
                }
                if (unit != null)
                {
                    unit.doAction(oa);
                    if (mOnHandleObjectAction != null)
                    {
                        mOnHandleObjectAction.Invoke(unit, oa);
                    }
                    mFormula.OnUnitHandleNetMessage(unit, oa);
                }
                else
                {
                    log.Info("Drop message : " + oa);
                }
            }
            else
            {
                if (mOnHandleAction != null)
                {
                    mOnHandleAction.Invoke(this, act);
                }
                mFormula.OnZoneHandleNetMessage(this, act);
            }
        }
        private void updateEvents()
        {
            if (sync_pos_list.Enable)
            {
                queueEvent(sync_pos_list.AsEvent(this));
            }
            sync_pos_list.Clear();

            while (mSendingEvents.Count > 0)
            {
                Event evt = mSendingEvents.Dequeue();

                //log.Info("---->onEvent:" + evt.ToString());
                mListener.onEventHandler(evt);
                if (mOnPostEvent != null)
                {
                    mOnPostEvent.Invoke(this, evt);
                }
                if (evt is GameOverEvent && mOnGameOver != null)
                {
                    mOnGameOver.Invoke(this, evt as GameOverEvent);
                }
            }
        }

        virtual protected void processSystemMessage(SystemMessage msg)
        {
            if (msg is Ping)
            {
                queueEventInternal(new Pong(msg as Ping));
            }
        }

        //-------------------------------------------------------------------------------------------
        #region OBJECTS

        private uint mObjectIDIndexer = 0;

        internal uint genObjectID()
        {
            mObjectIDIndexer++;
            return mObjectIDIndexer;
        }

        // 获取一个单位
        public T getObject<T>(uint obj_id) where T : InstanceZoneObject
        {
            if (obj_id == 0) return null;
            T go = mObjects.GetObject<T>(obj_id);
            if (go != null)
            {
                return go;
            }
            return null;
        }

        public InstanceUnit getUnit(uint obj_id)
        {
            if (obj_id == 0) return null;
            return mObjects.GetObject<InstanceUnit>(obj_id);
        }


        public InstanceUnit getUnitByTemplateID(int templateId)
        {
            if (templateId == 0) return null;
            foreach (InstanceUnit u in mObjects.Units)
            {
                if (u.Info.TemplateID == templateId)
                {
                    return u;
                }
            }
            return null;
        }

        public InstanceUnit getUnitByName(string name)
        {
            if (string.IsNullOrEmpty(name))
            {
                return null;
            }
            foreach (InstanceUnit u in mObjects.Units)
            {
                if (name.Equals(u.Name))
                {
                    return u;
                }
            }
            return null;
        }
        public InstancePlayer getPlayerByUUID(string playerUUID)
        {
            if (string.IsNullOrEmpty(playerUUID))
            {
                return null;
            }

            return mObjects.GetPlayer(playerUUID);
        }
        public InstanceItem getItemByName(string name)
        {
            if (string.IsNullOrEmpty(name))
            {
                return null;
            }
            foreach (InstanceItem u in mObjects.Items)
            {
                if (name.Equals(u.Name))
                {
                    return u;
                }
            }
            return null;
        }

        public InstanceUnit getUnitByID(int UnitID)
        {
            foreach (InstanceUnit obj in mObjects.Units)
            {
                if (obj.ID == UnitID)
                {
                    return obj;
                }
            }

            return null;
        }


        public IEnumerable<InstancePlayer> AllPlayers { get { return mObjects.Players; } }
        public int AllPlayersCount { get { return mObjects.PlayersCount; } }

        public IEnumerable<InstanceUnit> AllUnits { get { return mObjects.Units; } }
        public int AllUnitsCount { get { return mObjects.UnitsCount; } }

        public IEnumerable<InstanceSpell> AllSpells { get { return mObjects.Spells; } }
        public int AllSpellsCount { get { return mObjects.SpellsCount; } }

        public IEnumerable<InstanceItem> AllItems { get { return mObjects.Items; } }
        public int AllItemsCount { get { return mObjects.ItemsCount; } }

        public IEnumerable<InstanceZoneObject> AllObjects { get { return mObjects.Objects; } }
        public int AllObjectsCount { get { return mObjects.ObjectsCount; } }


        [Obsolete("use {@link #AllUnits} {@link #AllSpells} {@link #AllItems} for best performance!")]
        public IEnumerable<InstanceZoneObject> allObjs()
        {
            return mObjects.Objects;
        }
        [Obsolete("use {@link #AllUnitsCount} {@link #AllSpellsCount} {@link #AllItemsCount}  for best performance!")]
        public int allObjsCount()
        {
            return mObjects.ObjectsCount;
        }


        [Obsolete]
        public List<T> selectUnits<T>(Predicate<T> select) where T : InstanceUnit
        {
            List<T> ret = new List<T>(mObjects.UnitsCount);
            foreach (InstanceUnit obj in mObjects.Units)
            {
                if (select(obj as T))
                {
                    ret.Add(obj as T);
                }
            }
            return ret;
        }
        public void selectUnits<T>(Predicate<T> select, List<T> ret) where T : InstanceUnit
        {
            foreach (InstanceUnit obj in mObjects.Units)
            {
                if (select(obj as T))
                {
                    ret.Add(obj as T);
                }
            }
        }
        public T selectRandomUnit<T>(Predicate<T> select) where T : InstanceUnit
        {
            T ret = null;
            using (var list = ListObjectPool<InstanceUnit>.AllocAutoRelease())
            {
                foreach (InstanceUnit obj in mObjects.Units)
                {
                    if (obj is T && select(obj as T))
                    {
                        list.Add(obj as T);
                    }
                }
                if (list.Count > 0)
                {
                    ret = CUtils.GetRandomInArray<InstanceUnit>(list, random) as T;
                }
            }
            return ret;
        }
        public T selectUnit<T>(Predicate<T> select) where T : InstanceUnit
        {
            foreach (InstanceUnit obj in mObjects.Units)
            {
                if (select(obj as T))
                {
                    return obj as T;
                }
            }
            return null;
        }

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

        /// <summary>
        /// 创建一个单位实体
        /// </summary>
        virtual public InstanceZoneObject CreateUnit(UnitInfo info, string name, int force, int alliesForce, int level)
        {
            InstanceUnit unit = TemplateManager.Factory.CreateUnit(this, info, name, force, alliesForce, level);
            if (unit != null)
            {
                return unit;
            }
            switch (info.UType)
            {
                case UnitInfo.UnitType.TYPE_PLAYER:
                    return new InstancePlayer(this, info, name, force, level, alliesForce);
                case UnitInfo.UnitType.TYPE_MANUAL:
                    return new InstanceManual(this, info, name, force, level);
                case UnitInfo.UnitType.TYPE_PET:
                    return new InstancePet(this, info, name, force, level);
                case UnitInfo.UnitType.TYPE_SUMMON:
                    return new InstanceSummon(this, info, name, force, level);
                case UnitInfo.UnitType.TYPE_BUILDING:
                    return new InstanceBuilding(this, info, name, force, level);
                case UnitInfo.UnitType.TYPE_MONSTER:
                    return new InstanceGuard(this, info, name, force, level);
                case UnitInfo.UnitType.TYPE_NPC:
                    return new InstanceGuard(this, info, name, force, level);
                default:
                    return new InstanceGuard(this, info, name, force, level);
            }
        }

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

        public InstanceUnit AddUnit(int unitTemplateID, string name, int force, int level, float x, float y, float direction, bool pointLv = false)
        {
            UnitInfo info = Templates.getUnit(unitTemplateID);
            if (info != null)
            {
                return AddUnit(info, name, force, level, x, y, direction, null, "", 0, pointLv);
            }
            return null;
        }

        /// <summary>
        /// 添加一个单位
        /// </summary>
        /// <param name="info">单位模板</param>
        /// <param name="name">场景中名字（Key）</param>
        /// <param name="force">单位阵营</param>
        /// <param name="level">单位等级</param>
        /// <param name="x">坐标</param>
        /// <param name="y">坐标</param>
        /// <param name="direction">方向</param>
        /// <param name="summoner">召唤者</param>
        /// <returns></returns>
        public InstanceUnit AddUnit(UnitInfo info, string name, int force, int level, float x, float y, float direction,
            InstanceUnit summoner = null, String clientShowName = "", int gsFlag = 0, bool pointLv = false)
        {
            AddUnitEvent add;
            return AddUnit(info, name, force, level, x, y, direction, out add, summoner, clientShowName, gsFlag, 0, pointLv);
        }
        /// <summary>
        /// 添加一个单位
        /// </summary>
        /// <param name="info">单位模板</param>
        /// <param name="name">场景中名字（Key）</param>
        /// <param name="force">单位阵营</param>
        /// <param name="level">单位等级</param>
        /// <param name="x">坐标</param>
        /// <param name="y">坐标</param>
        /// <param name="direction">方向</param>
        /// <param name="add">输出事件</param>
        /// <param name="summoner">召唤者</param>
        /// <returns></returns>
        /// 

        private long mAddUnitPrintTime = 0;

        public InstanceUnit AddUnit(UnitInfo info, string name, int force, int level, float x, float y, float direction, 
            out AddUnitEvent add, InstanceUnit summoner = null, String clientShowName = "", int gsFlag = 0, int alliesForce = 0, bool pointLv = false)
        {
            add = null;
			if (mObjects.UnitsCount >= mMaxUnitCount)
			{
                if(mAddUnitPrintTime < CommonLang.CUtils.localTimeMS)
                {
                    mAddUnitPrintTime = CommonLang.CUtils.localTimeMS + 3000;
                    log.Warn(string.Format("--Zone AddUnit to max: {0}, UUID: {1}, ID: {2} 单位数量：{3}", this.GetSceneID(), this.UUID, info.TemplateID, GetZoneUnitInfo()));
                }
				
				return null;
			}

			if (mTryAddUnit != null && !mTryAddUnit.Invoke(info))
            {
                //log.Info(string.Format("Zone Unit TryAdd max: {0}, {1}, 单位数量：{2}", this.TerrainSrc.ID, info.TemplateID, mObjects.UnitsCount));
                return null;
            }

            // 创建实体单位
            InstanceZoneObject ret = CreateUnit(info, name, force, alliesForce, level);
            // 存入单位列表
            if (ret is InstanceUnit)
            {
                InstanceUnit unit = ret as InstanceUnit;
                //unit.Name = name;
                unit.gameServerFlag = gsFlag;
                // 存入单位列表
                if (unit.tryAdd(x, y, direction))
                {
                    mObjects.AddObject(unit);
                    this.LastAddedUnit = unit;
                    if (unit is ISummonedUnit)
                    {
                        ((ISummonedUnit)unit).SummonerUnit = summoner;
                    }                   
                   
                    try
                    {
                        unit.onAdded(this, pointLv);
                        if (mOnUnitAdded != null)
                            mOnUnitAdded.Invoke(this, unit);

                        add = new AddUnitEvent();
                        add.sender = unit;
                        if (unit.ClientVisible)
                        {
                            if (clientShowName != null && !unit.IsPlayer && clientShowName.Length > 0)
                            {
                                unit.SetDiaplayerName(clientShowName);
                            }

                            //// 阵营判断
                            //if(info.UType == UnitType.TYPE_MONSTER && force > 1)
                            //{
                            //	add.flag = 1;
                            //}

                            queueEvent(add);
                        }
                    }
                    catch (Exception err)
                    {
                        log.Warn("AddUnit catch :" + name + ", e:" + err);
                        add.ErrorMessage = err.Message;
                        return null;
                    }
                    finally
                    {
                        add.Sync = unit.GenSyncUnitInfo(true);
                    }
                    return unit;
                }
            }
            return null;
        }

        /** 获取场景单位异常信息 */
        private string GetZoneUnitInfo(int nMinNums = 50)
        {
            HashMap<int, int> mInfo = new HashMap<int, int>();
            foreach (InstanceUnit obj in mObjects.Units)
            {
                mInfo.Put(obj.Info.ID, mInfo.Get(obj.Info.ID) + 1);
            }

            string finalStr = "";
            foreach(int unitID in mInfo.Keys)
            {
                int count = mInfo.Get(unitID);
                if (count < nMinNums)
                {
                    continue;
                }
                finalStr = finalStr + (unitID) + "-" + count + ", ";
            }

            return finalStr;
        }


        public InstanceItem AddItem(ItemTemplate template, string name, float x, float y, float direction, int force, string disPlayName,
			out AddItemEvent add, InstanceUnit creater,int from)
        {
			add = null;
			if (mTryAddItem != null && !mTryAddItem.Invoke(template))
			{
				//log.Info(string.Format("Zone item TryAdd max: {0}, {1}", this.mSceneType, template.TemplateID));
				return null;
			}

			InstanceItem ret = TemplateManager.Factory.CreateItem(this, template, name, force, creater, disPlayName,from);
            ret.setPos(x, y);
            if (ret.tryAdd(x, y, direction))
            {
                mObjects.AddObject(ret);
                this.LastCreatedInstanceItem = ret;
                add = new AddItemEvent();
                add.sender = ret;
                if (ret.ClientVisible)
                {
                    queueEvent(add);
                }
                try
                {
                    ret.onAdded(this);
                    if (mItemAdded != null)
                        mItemAdded.Invoke(this, ret, creater);
                }
                catch (Exception err)
                {
                    log.Warn("AddItem: " + template.ID + ", catch: " + err);
                    add.ErrorMessage = err.Message;
                    return null;
                }
                finally
                {
                    add.Sync = ret.GenSyncItemInfo(true, null);
                }
                return ret;
            }
            return null;
        }

        public InstanceItem AddItem(ItemTemplate template, string name, float x, float y, float direction, int force, string disPlayName, InstanceUnit creater,int from=0)
        {
            AddItemEvent add;
            return AddItem(template, name, x, y, direction, force, disPlayName, out add, creater,from);
        }


        /// <summary>
        /// 添加一个法术或飞行道具
        /// </summary>
        /// <param name="template"></param>
        /// <param name="launch"></param>
        /// <param name="sender"></param>
        /// <param name="launcher">此法术的最初发起者</param>
        /// <param name="target_obj_id"></param>
        /// <param name="targetPos"></param>
        /// <param name="startX"></param>
        /// <param name="startY"></param>
        /// <param name="direction"></param>
        /// <param name="chain"></param>
        /// <returns></returns>
        public InstanceSpell AddSpell(
            XmdsSkillType fromSkillType,
            SpellTemplate template,
            LaunchSpell launch,
            InstanceZoneObject sender,
            InstanceUnit launcher,
            uint target_obj_id,
            Vector2 targetPos,
            float startX,
            float startY,
            float direction,
            SpellChainLevelInfo chain = null, 
            int actionIndex = -1,
            int maxAffectUnit = 0,
			Dictionary<uint, InstanceUnit> damageList = null,
			int spellIndex = 0,
			JSGCreateSpellData createData = null)
        {
            if (template != null && sender != null)
            {
                InstanceUnit target = getUnit(target_obj_id);
                switch (template.MType)
                {
                    //                     case SpellTemplate.MotionType.Missile:
                    //                         if (target == null)
                    //                         {
                    //                             return null;
                    //                         }
                    //                         break;
                    case SpellTemplate.MotionType.BindingTarget:
                        if (target == null)
                        {
                            return null;
                        }
                        startX = target.X;
                        startY = target.Y;
                        break;
                    case SpellTemplate.MotionType.SelectTarget:
                        if (targetPos != null)
                        {
                            startX = targetPos.X;
                            startY = targetPos.Y;
                        }
                        break;
                    case SpellTemplate.MotionType.SeekerMissile:
                    case SpellTemplate.MotionType.SeekerSelectTarget:
                        {
                            target = null;
                            target_obj_id = 0;
                        }
                        break;
                    case SpellTemplate.MotionType.Chain:
                        if (target == null)
                        {
                            return null;
                        }
                        break;
                    case SpellTemplate.MotionType.Cannon:
                        if (target == null && targetPos == null)
                        {
                            targetPos = new Vector2(startX, startY);
                        }
                        break;
                }
                // 创建实体单位
                //InstanceSpell ret = new InstanceSpell(this, template, launch, launcher, sender, chainLevel);
                InstanceSpell ret = TemplateManager.Factory.CreateSpell(this, template, launch, launcher, sender, fromSkillType, damageList, spellIndex, createData);
				//ret.Direction = direction;
				ret.BindActionIndex = actionIndex;
                ret.MaxAffectUnit = (maxAffectUnit == 0) ? ret.Info.MaxAffectUnit : maxAffectUnit;
                ret.faceTo(direction);
                ret.setChainInfo(chain);
                ret.setTargetPos(targetPos);
                ret.setTarget(target);				

				// 存入单位列表
				float xChanage, yChange;
				launch.GetXModify(launcher, out xChanage, out yChange);
				if (ret.tryAdd(startX + xChanage, startY + yChange, direction))
                {
					//System.Console.WriteLine("--AddSpell: " + ret.Info.ID + ", " + ret.ID);
					launcher.Virtual.DispatchSendSpellOverEvent(launch, template, ret.X, ret.Y);

					mObjects.AddObject(ret);
                    this.LastLaunchSpell = ret.Info;
                    ret.onAdded(this);

                    if (ret.ClientVisible)
                    {
                        // 产生事件
                        AddSpellEvent evt = new AddSpellEvent(ret);
                        evt.sender = ret;

                        queueEvent(evt);
                    }

                    return ret;
                }
            }
            return null;
        }

        // 移除一个单位
        public bool RemoveObject(InstanceZoneObject obj)
        {
            //Console.WriteLine("RemoveObject : " + obj.ID);
            if (mObjects.RemoveObject(obj))
            {
                obj.onRemoved(this);
                if (obj is InstanceUnit)
                {
                    InstanceUnit unit = obj as InstanceUnit;
                    mFormula.OnUnitRemoved(unit);
                    if (mOnUnitRemoved != null)
                        mOnUnitRemoved.Invoke(this, unit);
                }
				else if(obj is InstanceItem)
				{
					if (this.mOnItemRemoved != null)
						this.mOnItemRemoved.Invoke(this, (InstanceItem)obj);
				}


                if (obj.ClientVisible)
                {
                    RemoveObjectEvent remove = new RemoveObjectEvent(obj.ID);
                    remove.sender = obj;
                    queueEvent(remove);
                }
                obj.Dispose();
                return true;
            }
            return false;
        }

        public InstanceZoneObject RemoveObjectByID(uint oid)
        {
            var obj = mObjects.GetObject<InstanceZoneObject>(oid);
            if (obj != null && RemoveObject(obj))
            {
                return obj;
            }
            return null;
        }

        public InstanceZoneObject RemoveUnitByID(uint unitTemplateId)
        {
            InstanceUnit obj = mObjects.GetUnit(unitTemplateId);
            if (obj != null && RemoveObject(obj))
            {
                return obj;
            }
            return null;
        }

        public InstanceZoneObject RemoveSpellByLaunchIDAndSpellID(int launchId, int spellId)
        {
            InstanceSpell spell = mObjects.GetSpllByLanuchAndSpellId(launchId, spellId);
            if(spell != null && RemoveObject(spell))
            {
                return spell;
            }
            return null;
        }


        public InstanceZoneObject RemoveItemByID(uint unitTemplateId)
		{
			InstanceItem obj = mObjects.GetItem(unitTemplateId);
			if (obj != null && RemoveObject(obj))
			{
                Console.WriteLine("成功移除单位：" + unitTemplateId);
                return obj;
            }
            return null;
        }

        public int GetZoneKingID()
        {
            return this.mKingID;
        }

        public string GetBindGameSrvID()
        {
            return this.mBindGameSrvId;
        }

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

        private class InstanceZoneObjectMap
        {
            private class DirtyList<K, T> where T : InstanceZoneObject
            {
                private static Logger log = LoggerFactory.GetLogger("DirtyList");

                private bool dirty = true;
                private List<T> mObjectsCollection = new List<T>();
                private HashMap<K, T> mObjects = new HashMap<K, T>();

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

                public void Add(K key, T obj)
                {
                    dirty = true;
                    mObjects.Add(key, obj);
                }
                public void Put(K key, T obj)
                {
                    dirty = true;
                    mObjects.Put(key, obj);
                }
                public bool Remove(K key)
                {
                    if (mObjects.Remove(key))
                    {
                        dirty = true;
                        return true;
                    }
                    return false;
                }

                public void Dispose()
                {
                    mObjectsCollection.Clear();
                    mObjects.Clear();
                }
                public T Get(K key)
                {
                    return mObjects.Get(key);
                }
                public bool ContainsKey(K key)
                {
                    return mObjects.ContainsKey(key);
                }
                public IEnumerable<T> GetCollection(string logFlag)
                {
                    try
                    {
                        if (dirty)
                        {
                            dirty = false;
                            mObjectsCollection.Clear();
                            mObjectsCollection.AddRange(mObjects.Values);
                        }
                        return mObjectsCollection;
                    }
                    catch (Exception err)
                    {
                        log.Warn("GetCollectioncatch:" + logFlag + ", CollectCnt: " + mObjectsCollection.Count +
                            ", mObjectsCnt: " + mObjects.Count + ", e:" + err);
                    }
                    return mObjects.Values;
                }
            }

            private DirtyList<uint, InstanceZoneObject> mObjects = new DirtyList<uint, InstanceZoneObject>();
            private DirtyList<uint, InstanceUnit> mObjects_MirrorUnits = new DirtyList<uint, InstanceUnit>();
            private DirtyList<uint, InstanceSpell> mObjects_MirrorSpells = new DirtyList<uint, InstanceSpell>();
            private DirtyList<uint, InstanceItem> mObjects_MirrorItems = new DirtyList<uint, InstanceItem>();
            private DirtyList<string, InstancePlayer> mObjects_MirrorPlayers = new DirtyList<string, InstancePlayer>();

            private string logFlag = "";


            public InstanceZoneObjectMap(string logFlag)
            {
                this.logFlag = logFlag;
            }

            internal void Refresh()
            {
                //mObjects.Refresh();
                //mObjects_MirrorUnits.Refresh();
                //mObjects_MirrorSpells.Refresh();
                //mObjects_MirrorItems.Refresh();
                //mObjects_MirrorPlayers.Refresh();
            }

            public void AddObject(InstanceZoneObject obj)
            {
                mObjects.Add(obj.ID, obj);
                if (obj is InstanceUnit)
                {
                    mObjects_MirrorUnits.Add(obj.ID, obj as InstanceUnit);
                }
                else if (obj is InstanceSpell)
                {
                    mObjects_MirrorSpells.Add(obj.ID, obj as InstanceSpell);
                }
                else if (obj is InstanceItem)
                {
                    mObjects_MirrorItems.Add(obj.ID, obj as InstanceItem);
                }
                if (obj is InstancePlayer)
                {
                    var p = obj as InstancePlayer;
                    mObjects_MirrorPlayers.Put(p.PlayerUUID, p);
                }
            }
            public bool RemoveObject(InstanceZoneObject obj)
            {
                if (mObjects.Remove(obj.ID))
                {
                    if (obj is InstanceUnit)
                    {
                        mObjects_MirrorUnits.Remove(obj.ID);
                    }
                    else if (obj is InstanceSpell)
                    {
                        mObjects_MirrorSpells.Remove(obj.ID);
                    }
                    else if (obj is InstanceItem)
                    {
                        mObjects_MirrorItems.Remove(obj.ID);
                    }
                    if (obj is InstancePlayer)
                    {
                        var p = obj as InstancePlayer;
                        mObjects_MirrorPlayers.Remove(p.PlayerUUID);
                    }
                    return true;
                }
                return false;
            }
            private InstanceZoneObject GetObject(uint id)
            {
                return mObjects.Get(id);
            }
            public bool ContainsObject(InstanceZoneObject obj)
            {
                return mObjects.ContainsKey(obj.ID);
            }
            public bool ContainsObjectByKey(uint id)
            {
                return mObjects.ContainsKey(id);
            }
            public void Dispose()
            {
                mObjects.Dispose();
                mObjects_MirrorUnits.Dispose();
                mObjects_MirrorSpells.Dispose();
                mObjects_MirrorItems.Dispose();
                mObjects_MirrorPlayers.Dispose();
            }

            public T GetObject<T>(uint id) where T : InstanceZoneObject
            {
                Type type = typeof(T);
                if (type.IsSubclassOf(typeof(InstanceUnit)))
                {
                    return mObjects_MirrorUnits.Get(id) as T;
                }
                else if (type.IsSubclassOf(typeof(InstanceSpell)))
                {
                    return mObjects_MirrorSpells.Get(id) as T;
                }
                else if (type.IsSubclassOf(typeof(InstanceItem)))
                {
                    return mObjects_MirrorItems.Get(id) as T;
                }
                else
                {
                    return mObjects.Get(id) as T;
                }
            }

            public InstanceUnit GetUnit(uint unitTemplateId)
            {
                foreach (InstanceUnit obj in mObjects_MirrorUnits.GetCollection(logFlag))
                {
                    if (obj.Info.ID == unitTemplateId)
                    {
                        return obj;
                    }
                }

                return null;
            }

            public InstanceSpell GetSpllByLanuchAndSpellId(int launchId, int spellId)
            {
                foreach (InstanceSpell obj in mObjects_MirrorSpells.GetCollection(logFlag))
                {
                    if (obj.Info.ID == spellId && obj.LauncherID == launchId)
                    {
                        return obj;
                    }
                }
                return null;
            }

            public InstanceItem GetItem(uint itemId)
            {
                return mObjects_MirrorItems.Get(itemId);
            }


            public InstancePlayer GetPlayer(string uuid)
            {
                return mObjects_MirrorPlayers.Get(uuid);
            }

            public int ObjectsCount { get { return mObjects.Count; } }
            public IEnumerable<InstanceZoneObject> Objects { get { return mObjects.GetCollection(logFlag); } }

            public int UnitsCount { get { return mObjects_MirrorUnits.Count; } }
            public IEnumerable<InstanceUnit> Units { get { return mObjects_MirrorUnits.GetCollection(logFlag); } }

            public int SpellsCount { get { return mObjects_MirrorSpells.Count; } }
            public IEnumerable<InstanceSpell> Spells { get { return mObjects_MirrorSpells.GetCollection(logFlag); } }

            public int ItemsCount { get { return mObjects_MirrorItems.Count; } }
            public IEnumerable<InstanceItem> Items { get { return mObjects_MirrorItems.GetCollection(logFlag); } }

            public int PlayersCount { get { return mObjects_MirrorPlayers.Count; } }
            public IEnumerable<InstancePlayer> Players { get { return mObjects_MirrorPlayers.GetCollection(logFlag); } }
        }

        #endregion
        //------------------------------------------------------------------------------------
        #region CALL_BACK

        internal void cb_unitDamageCallBack(InstanceUnit target, InstanceUnit attacker, int reduceHP, AttackSource source)
        {
            LastHittedUnit = target;
            LastAttackUnit = attacker;

            if (attacker != null)
                attacker.callback_onAttack(this, target, reduceHP, source);
            if (target != null)
                target.callback_onDamage(this, attacker, reduceHP, source);
            if (mOnUnitDamage != null)
                mOnUnitDamage.Invoke(this, target, attacker, reduceHP, source);
        }
        internal void cb_unitDeadCallBack(InstanceUnit obj, InstanceUnit attacker)
        {
            statisticForceDead(obj);

            LastHittedUnit = obj;
            LastKilledUnit = obj;

            //if (attacker == null)
            //    attacker = obj;
            LastAttackUnit = attacker;

            obj.doDead(attacker);

			if(attacker != null)
			{
				obj.deadDropItems(attacker.Force);
				attacker.CurrentMoney += obj.Info.DropMoney;
			}           

            mFormula.OnUnitDead(obj, attacker);

            obj.callback_onDead(this, attacker);
            if (mOnUnitDead != null)
                mOnUnitDead.Invoke(this, obj, attacker);

			obj.mProcessDeadCallbackTime = CommonLang.CUtils.localTimeMS + 1000;
        }
        internal void cb_unitActivatedCallBack(InstanceUnit obj)
        {
            nearChange(obj);

            LastActivatedUnit = obj;
            obj.callback_onActivated(this);
            if (mOnUnitActivated != null)
                mOnUnitActivated.Invoke(this, obj);
        }
        internal void cb_unitRebirthCallBack(InstanceUnit obj)
        {
            LastRebirthUnit = obj;
            obj.callback_onRebirth(this);
            if (mOnUnitRebirth != null)
                mOnUnitRebirth.Invoke(this, obj);

        }
        internal void cb_unitGotInventoryItemCallBack(InstanceUnit obj, ItemTemplate item, int count)
        {
            LastUnitGotInventoryItem = item;
            obj.callback_onGotInventoryItem(this, item);
            if (mOnUnitGotInventoryItem != null)
                mOnUnitGotInventoryItem.Invoke(this, obj, item, count);
        }
        internal void cb_unitLostInventoryItemCallBack(InstanceUnit obj, ItemTemplate item, int count)
        {
            LastUnitLostInventoryItem = item;
            obj.callback_onLostInventoryItem(this, item);
            if (mOnUnitLostInventoryItem != null)
                mOnUnitLostInventoryItem.Invoke(this, obj, item, count);
        }
        internal int cb_unitGotInstanceItemCallBack(InstanceUnit obj, InstanceItem item)
        {
            LastUnitGotInstanceItem = item;
            obj.callback_onGotInstanceItem(this, item);
            short times = 0;
            if (mOnUnitGotInstanceItem != null)
            {
                InstancePlayer player = (obj as InstancePlayer);
                if (player == null)
                {
                    return 0;
                }

                if (item.unitPickInfo != null)
                {
                    if (item.Info.maxPickTimes > 0)
                    {
                        times = item.unitPickInfo.Get(player.PlayerUUID);
                        if (times >= item.Info.maxPickTimes)
                        {
                            player.Virtual.SendMsgToClient(XmdsConstConfig.TIPS_PICK_MAX);
                            return item.Info.maxPickTimes;
                        }
                    }
                    item.unitPickInfo.Put(player.PlayerUUID, ++times);
                    item.TotalPickTimes++;
                }

                mOnUnitGotInstanceItem.Invoke(this, obj, item);
            }

            return times;
        }

        internal void cb_unitUseItemCallBack(InstanceUnit obj, ItemTemplate item, InstanceUnit item_creater)
        {
            LastUnitUseItem = item;
            obj.callback_onUseItem(this, item, item_creater);
            if (mOnUnitUseItem != null)
                mOnUnitUseItem.Invoke(this, obj, item, item_creater);
        }
        internal void cb_unitGotBuffCallBack(InstanceUnit obj, InstanceUnit.BuffState buff)
        {
            LastUnitGotBuff = buff.Data;
            obj.callback_onGotBuff(this, buff);
            if (mOnUnitGotBuff != null)
                mOnUnitGotBuff.Invoke(this, obj, buff);
        }
        internal void cb_unitLostBuffCallBack(InstanceUnit obj, InstanceUnit.BuffState buff)
        {
            obj.callback_onLostBuff(this, buff);
            if (mOnUnitLostBuff != null)
                mOnUnitLostBuff.Invoke(this, obj, buff);
        }
        internal void cb_unitGotMoneyCallBack(InstanceUnit obj, int add_money)
        {
            if (mOnUnitGotMoney != null)
            {
                mOnUnitGotMoney.Invoke(obj, add_money);
            }
        }
        internal void cb_unitPickUnitCallBack(InstanceUnit src, InstanceUnit pickable)
        {
            LastPickableUnit = pickable;
            if (mOnUnitPickUnit != null)
            {
                mOnUnitPickUnit.Invoke(this, src, pickable);
            }
        }

        public void cb_unitOutBattleCallBack(InstanceUnit obj)
        {
            if (mOnUnitOutBattle != null)
            {
                mOnUnitOutBattle.Invoke(this, obj);
            }
        }


        internal bool cb_unitTryPickItem(InstanceUnit unit, InstanceItem item)
        {
            LastPickingItem = item;
            LastPickingItemUnit = unit;
            bool ret = true;
            if (mTryPickItem != null)
            {
                foreach (TryPickItemHandler trypick in mTryPickItem.GetInvocationList())
                {
                    if (!trypick.Invoke(this, unit, item))
                    {
                        ret = false;
                    }
                }
            }
            return ret;
        }
        internal void cb_unitFinishPickItem(InstanceUnit unit, InstanceItem item)
        {
            if (mFinishPickItem != null)
            {
                mFinishPickItem.Invoke(this, unit, item);
            }
        }
        internal void cb_unitLaunchSkill(InstanceUnit unit, CommonAI.Zone.Instance.InstanceUnit.SkillState ss)
        {
            LastLaunchSkill = ss.Data;
            LastLaunchSkillUnit = unit;
            if (mOnUnitLaunchSkill != null)
            {
                mOnUnitLaunchSkill.Invoke(this, unit, ss);
            }
        }
        internal void cb_playerReady(InstancePlayer player)
        {
            if (mPlayerReady != null)
            {
                mPlayerReady.Invoke(player);
            }
        }

        #endregion

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

        #region UNIT_ATTACK

        /// <summary>
        /// 获得两个对象是否是队友
        /// </summary>
        /// <param name="src"></param>
        /// <param name="dst"></param>
        /// <returns></returns>
        public virtual bool IsTeammates(InstanceUnit src, InstanceUnit dst)
        {
            return false;
        }

        /// <summary>
        /// 测试是否可见，单位间可交互（AOI）
        /// </summary>
        /// <param name="src"></param>
        /// <param name="dst"></param>
        /// <returns></returns>
        public virtual bool IsVisibleAOI(InstanceZoneObject src, InstanceZoneObject dst)
        {
            if (src.AoiStatus == dst.AoiStatus)
            {
                if (dst is InstanceUnit)
                {
                    return (dst as InstanceUnit).IsVisible;
                }
                return true;
            }
            else if (src.AoiStatus != null)
            {
                return src.AoiStatus.CanSeeOther;
            }
            else if (dst.AoiStatus != null)
            {
                return dst.AoiStatus.CanSeeMe;
            }
            return false;
        }


        /// <summary>
        /// 测试是否可攻击
        /// </summary>
        /// <param name="src"></param>
        /// <param name="target"></param>
        /// <param name="expectTarget"></param>
        /// <param name="reason"></param>
        /// <param name="weapon"></param>
        /// <returns></returns>
        public virtual bool IsAttackable(InstanceUnit src, InstanceUnit target, SkillTemplate.CastTarget expectTarget, AttackReason reason, ITemplateData weapon)
        {
			if(src == null || target == null)
			{
				return false;
			}

            if (!IsVisibleAOI(src, target))
            {
                return false;
            }
            if (target.CanWhiplashDeadBody)
            {
                if (!target.IsAttackable)
                    return false;
                if (!target.IsVisible)
                    return false;
                if (target.IsInvincible)
                    return false;
            }
            else
            {
                if (!target.IsActive)
                    return false;
                if (!target.IsVisible)
                    return false;
                if (target.IsInvincible)
                    return false;
            }
            switch (expectTarget)
            {
                case SkillTemplate.CastTarget.Enemy:
                    return src.Force != target.Force;
                case SkillTemplate.CastTarget.PetForMaster:
                    if (src is InstancePet)
                    {
                        return (src as InstancePet).Master == target;
                    }
                    return false;
                case SkillTemplate.CastTarget.Alias:
                    return (src != target) && (src.Force == target.Force);

                case SkillTemplate.CastTarget.AlliesIncludeSelf:
                    return (src.Force == target.Force);
                case SkillTemplate.CastTarget.AlliesExcludeSelf:
                    return (src != target) && (src.Force == target.Force);

                case SkillTemplate.CastTarget.EveryOne:
                    return true;
                case SkillTemplate.CastTarget.EveryOneExcludeSelf:
                    return (src != target);

                case SkillTemplate.CastTarget.Self:
                    return src == target;
                case SkillTemplate.CastTarget.EnemyAndSelf:
                    return src.Force != target.Force || src == target;
                case SkillTemplate.CastTarget.NA:
                default:
                    return false;
            }
        }

        /// <summary>
        /// 扫描所有可攻击对象
        /// </summary>
        /// <param name="src"></param>
        /// <param name="list"></param>
        /// <param name="expectTarget"></param>
        /// <param name="reason"></param>
        /// <param name="weapon"></param>
        public void getAttackableUnits(InstanceUnit src, List<InstanceUnit> list, SkillTemplate.CastTarget expectTarget, AttackReason reason, ITemplateData weapon)
        {
            for (int i = list.Count - 1; i >= 0; --i)
            {
                InstanceUnit o = list[i];
                if (!IsAttackable(src, o, expectTarget, reason, weapon))
                {
                    list.RemoveAt(i);
                }
            }
        }

        /// <summary>
        /// 对单个单位攻击。
        /// </summary>
        /// <param name="src"></param>
        /// <param name="attack"></param>
        /// <param name="target"></param>
        /// <param name="expectTarget">判断IsAttackable</param>
        /// <returns></returns>
        public bool unitAttackSingle(
            InstanceUnit src,
            AttackSource attack,
            InstanceUnit target,
            SkillTemplate.CastTarget expectTarget)
        {
            if (IsAttackable(src, target, expectTarget, AttackReason.Attack, attack.Weapon))
            {
                target.doHitAttack(src, attack);
                return true;
            }
            return false;
        }

        /// <summary>
        /// 某个单位对指定列表里的 IsAttackable 单位发起攻击。
        /// 此操作会修改List
        /// </summary>
        /// <param name="src"></param>
        /// <param name="attack"></param>
        /// <param name="list">调用完成后，列表中未命中单位会自动移除。</param>
        /// <param name="expectTarget">判断IsAttackable</param>
        /// <returns></returns>
        public int unitAttack(
            InstanceUnit src,
            AttackSource attack,
            List<InstanceUnit> list,
            SkillTemplate.CastTarget expectTarget)
        {
            int count = 0;
            for (int i = list.Count - 1; i >= 0; --i)
            {
                InstanceUnit o = list[i];
                if (IsAttackable(src, o, expectTarget, AttackReason.Attack, attack.Weapon))
                {
                    o.doHitAttack(src, attack);
                    count++;
                }
                else
                {
                    list.RemoveAt(i);
                }
            }
            return count;
        }

        /// <summary>
        /// 直接对列表中的单位攻击，不做任何判断。
        /// </summary>
        /// <param name="src"></param>
        /// <param name="attack"></param>
        /// <param name="list"></param>
        public int unitAttackDirect(
           InstanceUnit src,
           AttackSource attack,
           List<InstanceUnit> list)
        {
            int count = 0;
            for (int i = list.Count - 1; i >= 0; --i)
            {
                InstanceUnit o = list[i];
                o.doHitAttack(src, attack);
                count++;
            }
            return count;
        }


        /// <summary>
        /// 某个单位发起周身攻击
        /// </summary>
        /// <param name="src"></param>
        /// <param name="attack"></param>
        /// <param name="range"></param>
        /// <param name="expectTarget"></param>
        /// <returns></returns>
        public int unitAttackRound(
            InstanceUnit src,
            AttackSource attack,
            float range,
            SkillTemplate.CastTarget expectTarget)
        {
            using (var list = ListObjectPool<InstanceUnit>.AllocAutoRelease())
            {
                getObjectsRoundRange<InstanceUnit>(
                    Collider.Object_HitBody_TouchRound,
                    src.X, src.Y, range,
                    list, src.AoiStatus);
                return unitAttack(src, attack, list, expectTarget);
            }
        }

        /// <summary>
        /// 某个单位发起扇形范围攻击
        /// </summary>
        /// <param name="src"></param>
        /// <param name="attack"></param>
        /// <param name="direction"></param>
        /// <param name="range"></param>
        /// <param name="angle"></param>
        /// <param name="expectTarget"></param>
        /// <returns></returns>
        public int unitAttackFan(
            InstanceUnit src,
            AttackSource attack,
            float direction,
            float range,
            float angle,
            SkillTemplate.CastTarget expectTarget)
        {
            float dr = angle / 2;
            using (var list = ListObjectPool<InstanceUnit>.AllocAutoRelease())
            {
                getObjectsFanRange<InstanceUnit>(
                    Collider.Object_HitBody_TouchFan,
                    src.X, src.Y, range,
                    direction - dr,
                    direction + dr,
                    list, src.AoiStatus);
                return unitAttack(src, attack, list, expectTarget);
            }
        }

        //-------------------------------------------------------------------------------------------------------
        // 单位释放法术
        //-------------------------------------------------------------------------------------------------------

        public void unitLaunchSpell(
            XmdsSkillType fromSkillType,
            InstanceUnit launcher,
            LaunchSpell launch,
            float startX,
            float startY,
            uint targetUnitID = 0,
            Vector2 targetPos = null, int actionIndex = -1, int maxAffectUnit = 0, float pointDir = 0)
        {
            if(launch == null)
            {
                log.Error("单位释放技能异常： " + launcher.Info.ID + ", " + new StackTrace().ToString());
                return;
            }

            if (CUtils.RandomPercent(RandomN, launch.LaunchPercent))
            {
                float direction = pointDir == 0 ? launcher.Direction : pointDir;
                if (targetPos != null)
                {
                    //direction = MathVector.getDegree(startX, startY, targetPos.x, targetPos.y);
                    targetPos = (Vector2)targetPos.Clone();
                }
                SpellTemplate spell = Templates.getSpell(launch.SpellID);
				if(spell == null)
				{
					log.Error("unitLaunchSpell找不到法术模板：" + launcher.PlayerUUID + ", " + launch.SpellID + ", SN: " + launch.SerialNumber);
					return;
				}
				JSGCreateSpellData createData;
				if (spell != null && launch.Count > 0 && mFormula.TryLaunchSpell(launcher, launch, ref spell, out createData, ref startX, ref startY))
                {
                    SpellChainLevelInfo chain = null;
                    if (launch.ChainLevel > 0)
                    {
                        chain = new SpellChainLevelInfo(launch);
                    }
                    switch (launch.PType)
                    {
                        case LaunchSpell.PosType.POS_TYPE_FAN:
                            {
                                float startAngle = direction - launch.Angle / 2f;// + launch.StartAngle;
                                float interAngle = launch.Count > 0 ? launch.Angle / (launch.Count - 1) : 0;
                                for (int i = 0; i < launch.Count; i++)
                                {
                                    AddSpell(fromSkillType, spell, launch, launcher, launcher,
                                        targetUnitID, targetPos, startX, startY,
                                        startAngle + interAngle * i, chain, actionIndex, maxAffectUnit);
                                }
                            }
                            break;
                        case LaunchSpell.PosType.POS_TYPE_TOSAMETARGET:
                            {
                                InstanceUnit target = SeekSpellAttackable(launcher, spell, launcher.AoiStatus, startX, startY, launch.SeekingTargetRange,
                                    spell.ExpectTarget, SeekingExpect.Nearest, null);
                                if (target != null)
                                {
                                    launcher.faceTo(target.X, target.Y);
                                    launcher.SendForceSync();
                                    targetPos = new Vector2(target.X, target.Y);
                                    //Console.WriteLine("-------------targetPos 1 - " + target.X + ", " + target.Y);
                                    //Console.WriteLine("-------------targetPos 2 - " + targetPos);
                                    int[] index = { 0, -1, 1 };
                                    float testAngle = (float)Math.Atan2(targetPos.Y - launcher.Y, targetPos.X - launcher.X);
                                    float xBase = 3.0f;
                                    float xAdd = (float)(xBase * Math.Sin(testAngle));                 //角Dir的对边
                                    float yAdd = (float)(xBase * Math.Cos(testAngle));                 //Dir的邻边                                               

                                    for (int i = 0; i < launch.Count; i++)
                                    {
                                        float tempX = startX - xAdd * index[i];
                                        float tempY = startY + yAdd * index[i];
                                        float angle = (float)Math.Atan2(targetPos.Y - tempY, targetPos.X - tempX);
                                        AddSpell(fromSkillType, spell, launch, launcher, launcher,
                                            targetUnitID, targetPos, tempX, tempY,
                                            angle, chain, actionIndex, maxAffectUnit);
                                    }
                                }
                                else
                                {
                                    int[] index = { 0, -1, 1 };
                                    float xBase = 3.0f;
                                    float xAdd = (float)(xBase * Math.Sin(direction));                 //角Dir的对边
                                    float yAdd = (float)(xBase * Math.Cos(direction));                 //Dir的邻边
                                    float[] startAngleTemp = { 0, launch.Angle, launch.Angle * 1.2f, launch.Angle * 1.4f, launch.Angle * 1.5f };

                                    for (int i = 0; i < launch.Count; i++)
                                    {
                                        float tempX = startX - xAdd * index[i];
                                        float tempY = startY + yAdd * index[i];
                                        AddSpell(fromSkillType, spell, launch, launcher, launcher,
                                            targetUnitID, targetPos, tempX, tempY,
                                             direction - startAngleTemp[i] * index[i], chain, actionIndex, maxAffectUnit);
                                    }
                                }
                            }
                            break;
                        case LaunchSpell.PosType.POS_TYPE_CYCLE:
                            {
                                float startAngle = direction + launch.StartAngle;
                                float interAngle = CMath.PI_MUL_2 / launch.Count;

                                InstanceSpell[] spellBrothers = null;
                                if (launch.Count > 1 && spell.MType == SpellTemplate.MotionType.Foxfire)
                                {
                                    spellBrothers = new InstanceSpell[launch.Count];
                                }

                                for (int i = 0; i < launch.Count; i++)
                                {
                                    var sb = AddSpell(fromSkillType, spell, launch, launcher, launcher,
                                        targetUnitID, targetPos, startX, startY,
                                        startAngle + interAngle * i, chain, actionIndex, maxAffectUnit);
                                    if (spellBrothers != null)
                                    {
                                        spellBrothers[i] = sb;
                                        sb.brothers = spellBrothers;
                                    }
                                }
                            }
                            break;
                        case LaunchSpell.PosType.POS_TYPE_X:
                            {
								float startAngle = direction + launch.StartAngle;
								float[] interAngle = { launch.Angle, CMath.PI_F - launch.Angle, CMath.PI_F + launch.Angle, CMath.PI_F * 2 - launch.Angle };
								Dictionary<uint, InstanceUnit> damageList = (spell.HitIntervalMS <= 0 ? new Dictionary<uint, InstanceUnit>() : null);

								for (int i = 0; i < 4; i++)
								{
									AddSpell(fromSkillType, spell, launch, launcher, launcher, targetUnitID, targetPos, 
										startX, startY, startAngle + interAngle[i], chain, actionIndex, maxAffectUnit, damageList);
								}
							}
							break;
						case LaunchSpell.PosType.POS_TYPE_RANDOM_DIRECTION:
                            {
                                for (int i = 0; i < launch.Count; i++)
                                {
                                    float d = (float)(random.NextDouble() * CMath.PI_MUL_2);
                                    AddSpell(fromSkillType, spell, launch, launcher, 
                                        launcher, targetUnitID, targetPos, startX,
                                        startY, d, chain, actionIndex, maxAffectUnit);
                                }
                            }
                            break;
                        case LaunchSpell.PosType.POS_TYPE_AREA:
                            using (var enemy_list = ListObjectPool<InstanceUnit>.AllocAutoRelease())
                            {
                                SeekSpellAttackable(enemy_list, startX, startY, launcher, spell, launch, chain);
                                for (int i = 0; i < launch.Count && i < enemy_list.Count; i++)
                                {
                                    AddSpell(fromSkillType, spell, launch, launcher, launcher, enemy_list[i].ID, null,
                                        startX, startY, direction, chain, actionIndex, maxAffectUnit);
                                }
                            }
                            break;
                        case LaunchSpell.PosType.POS_TYPE_RANDOM_FOR_SPELL:
                            launch_randomTypeSpell(fromSkillType, spell, launcher, launch, chain, launcher, actionIndex);
                            break;
                        case LaunchSpell.PosType.POS_TYPE_RANDOM_POS:
                            launch_randomPosSpell(fromSkillType, spell, launcher, launch, chain, launcher, actionIndex);
                            break;
                        case LaunchSpell.PosType.POS_TYPE_MANY_CANNON:
                            launch_ManyCannon(fromSkillType, spell, launcher, launch, chain, launcher, targetUnitID, actionIndex, createData);
                            break;
                        case LaunchSpell.PosType.POS_TYPE_DEFAULT_SINGLE:
                        default:
                            {
                                AddSpell(fromSkillType, spell, launch, launcher, launcher,
                                    targetUnitID, targetPos, startX, startY,
                                    direction + launch.StartAngle, chain, actionIndex, maxAffectUnit);
                            }
                            break;
                    }

                }
            }
        }


        // 单位释放法术
        public void spellLaunchSpell(
            XmdsSkillType fromSkillType, 
            InstanceSpell sender,
            LaunchSpell launch,
            float startX,
            float startY,
            uint targetUnitID = 0,
            Vector2 targetPos = null, int actionIndex = -1, int maxAffectUnit = 0)
        {
            switch (launch.SenderUnit)
            {
                case LaunchSpell.LaunchSpllSenderUnit.Launcher:
                    this.unitLaunchSpell(fromSkillType, sender.Launcher, launch, startX, startY, targetUnitID, targetPos);
                    return;
            }
            if (CUtils.RandomPercent(RandomN, launch.LaunchPercent))
            {
                SpellChainLevelInfo chain = sender.ChainInfo;
                if (chain != null)
                {
                    if (!chain.TryLaunch(launch.SpellID))
                    {
                        // chain is end //
                        return;
                    }
                }
                SpellTemplate spell = Templates.getSpell(launch.SpellID);
                JSGCreateSpellData createData;
                if (spell != null && launch.Count > 0 && mFormula.TryLaunchSpell(sender.Launcher, launch, ref spell, out createData, ref startX, ref startY))
                {
                    float direction = sender.Direction;
                    if (targetPos != null)
                    {
                        direction = MathVector.getDegree(startX, startY, targetPos.X, targetPos.Y);
                        targetPos = (Vector2)targetPos.Clone();
                    }

                    switch (launch.PType)
                    {
                        case LaunchSpell.PosType.POS_TYPE_FAN:
                            {
                                float startAngle = direction - launch.Angle / 2f + launch.StartAngle;
                                float interAngle = launch.Count > 0 ? launch.Angle / (launch.Count - 1) : 0;
                                for (int i = 0; i < launch.Count; i++)
                                {
                                    AddSpell(fromSkillType, spell, launch, sender, sender.Launcher,
                                        targetUnitID, targetPos, startX, startY, 
                                        startAngle + interAngle * i, chain, actionIndex, maxAffectUnit);
                                }
                            }
                            break;
                        case LaunchSpell.PosType.POS_TYPE_CYCLE:
                            {
                                float startAngle = direction + launch.StartAngle;
                                float interAngle = CMath.PI_MUL_2 / launch.Count;
                                for (int i = 0; i < launch.Count; i++)
                                {
                                    AddSpell(fromSkillType, spell, launch, sender, sender.Launcher, 
                                        targetUnitID, targetPos, startX, startY, 
                                        startAngle + interAngle * i, chain, actionIndex, maxAffectUnit);
                                }
                            }
                            break;
						case LaunchSpell.PosType.POS_TYPE_X:
							{
								float startAngle = direction + launch.StartAngle;
								float[] interAngle = { launch.Angle, CMath.PI_F - launch.Angle, CMath.PI_F + launch.Angle, CMath.PI_F * 2 - launch.Angle };
								Dictionary<uint, InstanceUnit> damageList = (spell.HitIntervalMS <= 0 ? new Dictionary<uint, InstanceUnit>() : null);

								for (int i = 0; i < launch.Count; i++)
								{
									AddSpell(fromSkillType, spell, launch, sender, sender.Launcher, targetUnitID, 
										targetPos, startX, startY, startAngle + interAngle[i], chain, actionIndex, maxAffectUnit, damageList);
								}
							}
							break;
						case LaunchSpell.PosType.POS_TYPE_RANDOM_FOR_SPELL:
                            launch_randomTypeSpell(fromSkillType, spell, sender, launch, chain, sender.Launcher, actionIndex);
                            break;
                        case LaunchSpell.PosType.POS_TYPE_MANY_CANNON:
                            launch_ManyCannon(fromSkillType, spell, sender, launch, chain, sender.Launcher, targetUnitID, actionIndex, createData);
                            break;
                        case LaunchSpell.PosType.POS_TYPE_RANDOM_POS:
                            launch_randomPosSpell(fromSkillType, spell, sender, launch, chain, sender.Launcher, actionIndex);
                            break;
						case LaunchSpell.PosType.POS_TYPE_RANDOM_DIRECTION:
                            {
                                for (int i = 0; i < launch.Count; i++)
                                {
                                    float d = (float)(random.NextDouble() * CMath.PI_MUL_2);
                                    AddSpell(fromSkillType, spell, launch, sender, sender.Launcher, 
                                        targetUnitID, targetPos, startX, startY, d, chain, actionIndex, maxAffectUnit);
                                }
                            }
                            break;
                        case LaunchSpell.PosType.POS_TYPE_AREA:
                            using (var enemy_list = ListObjectPool<InstanceUnit>.AllocAutoRelease())
                            {
                                SeekSpellAttackable(enemy_list, startX, startY, sender.Launcher, spell, launch, chain);
                                for (int i = 0; i < launch.Count && i < enemy_list.Count; i++)
                                {
                                    AddSpell(fromSkillType, spell, launch, sender, sender.Launcher, 
                                        enemy_list[i].ID, targetPos, startX, startY, direction, chain, actionIndex, maxAffectUnit);
                                }
                            }
                            break;
                        case LaunchSpell.PosType.POS_TYPE_DEFAULT_SINGLE:
                        default:
                            {
                                AddSpell(fromSkillType, spell, launch, sender, sender.Launcher, 
                                    targetUnitID, targetPos, startX, startY, direction, chain, actionIndex, maxAffectUnit);
                            }
                            break;
                    }

                }
            }
        }


        public void attackLaunchSpell(
            XmdsSkillType fromSkillType,
            InstanceUnit attacker,
            InstanceUnit damage,
            AttackSource source,
            int serverExt = 0)
        {
            LaunchSpell launch = source.Attack.Spell;
            if (launch == null)
                return;
            InstanceZoneObject sender;
            if (source.FromSpellUnit != null)
            {
                sender = source.FromSpellUnit;
            }
            else
            {
                sender = attacker;
            }
            switch (launch.SenderUnit)
            {
                case LaunchSpell.LaunchSpllSenderUnit.Launcher:
                    sender = attacker;
                    break;
                case LaunchSpell.LaunchSpllSenderUnit.DamagedUnit:
                    sender = damage;
                    break;
            }
            if (CUtils.RandomPercent(RandomN, launch.LaunchPercent))
            {
                float startX = damage.X;
                float startY = damage.Y;

                SpellTemplate spell = Templates.getSpell(launch.SpellID);
				JSGCreateSpellData createData;
				if (spell != null && launch.Count > 0 && mFormula.TryLaunchSpell(attacker, launch, ref spell, out createData, ref startX, ref startY))
                {                    
                    SpellChainLevelInfo chain = null;
                    if (source.FromSpellUnit != null && source.FromSpellUnit.ChainInfo != null)
                    {
                        chain = source.FromSpellUnit.ChainInfo;
                        if (!chain.TryLaunch(launch.SpellID))
                        {
                            // chain is end //
                            return;
                        }
                    }
                    switch (launch.PType)
                    {
                        case LaunchSpell.PosType.POS_TYPE_FAN:
                            {
                                float startAngle = sender.Direction - launch.Angle / 2f + launch.StartAngle;
                                float interAngle = launch.Count > 0 ? launch.Angle / (launch.Count - 1) : 0;
                                for (int i = 0; i < launch.Count; i++)
                                {
                                    AddSpell(fromSkillType, spell, launch, sender, attacker, damage.ID, null,
                                        startX, startY, startAngle + interAngle * i, chain, serverExt);
                                }
                            }
                            break;
                        case LaunchSpell.PosType.POS_TYPE_CYCLE:
                            {
                                float startAngle = sender.Direction + launch.StartAngle;
                                float interAngle = CMath.PI_MUL_2 / launch.Count;
                                for (int i = 0; i < launch.Count; i++)
                                {
                                    AddSpell(fromSkillType, spell, launch, sender, attacker, damage.ID, null,
                                        startX, startY, startAngle + interAngle * i, chain, serverExt);
                                }
                            }
                            break;
                        case LaunchSpell.PosType.POS_TYPE_X:
                            {
                                float startAngle = sender.Direction + launch.StartAngle;
                                float[] interAngle = { launch.Angle, CMath.PI_F - launch.Angle, CMath.PI_F + launch.Angle, CMath.PI_F * 2 - launch.Angle };
                                Dictionary<uint, InstanceUnit> damageList = (spell.HitIntervalMS <= 0 ? new Dictionary<uint, InstanceUnit>() : null);

                                for (int i = 0; i < launch.Count; i++)
                                {
                                    AddSpell(fromSkillType, spell, launch, sender, attacker, damage.ID, null,
                                        startX, startY, startAngle + interAngle[i], chain, serverExt, 0, damageList);
                                }
                            }
                            break;
                        case LaunchSpell.PosType.POS_TYPE_RANDOM_FOR_SPELL:
                            launch_randomTypeSpell(fromSkillType, spell, sender, launch, chain, attacker, serverExt);
                            break;
                        case LaunchSpell.PosType.POS_TYPE_MANY_CANNON:
                            launch_ManyCannon(fromSkillType, spell, sender, launch, chain, attacker, damage.ID, serverExt, createData);
                            break;
                        case LaunchSpell.PosType.POS_TYPE_RANDOM_POS:
                            launch_randomPosSpell(fromSkillType, spell, sender, launch, chain, attacker, serverExt);
                            break;
                        case LaunchSpell.PosType.POS_TYPE_RANDOM_DIRECTION:
                            {
                                for (int i = 0; i < launch.Count; i++)
                                {
                                    float d = (float)(random.NextDouble() * CMath.PI_MUL_2);
                                    AddSpell(fromSkillType, spell, launch, sender, attacker, damage.ID, null,
                                        startX, startY, d, chain, serverExt);
                                }
                            }
                            break;
                        case LaunchSpell.PosType.POS_TYPE_AREA:
                            using (var enemy_list = ListObjectPool<InstanceUnit>.AllocAutoRelease())
                            {
                                SeekSpellAttackable(enemy_list, startX, startY, attacker, spell, launch, chain);
                                for (int i = 0; i < launch.Count && i < enemy_list.Count; i++)
                                {
                                    AddSpell(fromSkillType, spell, launch, sender, attacker, enemy_list[i].ID, null,
                                        startX, startY, 0, chain, serverExt);
                                }
                            }
                            break;
                        case LaunchSpell.PosType.POS_TYPE_DEFAULT_SINGLE:
                        default:
                            {
                                AddSpell(fromSkillType, spell, launch, sender, attacker, damage.ID, null,
                                    startX, startY, sender.Direction, chain, serverExt);
                            }
                            break;
                    }
                }
            }
        }


        private void launch_randomTypeSpell(XmdsSkillType fromSkillType, SpellTemplate spell, InstanceZoneObject sender,
            LaunchSpell launch, SpellChainLevelInfo chain, InstanceUnit attacker,  int serverExt = 0)
        {
            using (var list = ListObjectPool<InstanceUnit>.AllocAutoRelease())
            {
                attacker.Parent.getObjectsRoundRange<InstanceUnit>(
                    (obj, dx, dy, dr) =>
                    {
                        var u = obj as InstanceUnit;

                        //己方单位.
                        if ((attacker.IsPlayer && !u.IsPlayer) || (!attacker.IsPlayer && u.IsPlayer))
                        {
                            return CMath.includeRoundPoint(dx, dy, dr, u.X, u.Y);
                        }

                        return false;
                    },
                    attacker.X,
                    attacker.Y,
                    launch.SeekingTargetRange,
                    list, attacker.AoiStatus);
                
                int maxCount = launch.Count == 0 ? list.Count : Math.Min(launch.Count, list.Count);
                for (int i = 0; i < maxCount; i++)
                {
                    float r = (float)(random.NextDouble() * spell.BodySize);
                    float a = (float)(random.NextDouble() * CMath.PI_MUL_2);
                    float x = (float)(list[i].X + Math.Cos(a) * r);
                    float y = (float)(list[i].Y + Math.Sin(a) * r);
                    float d = (float)(random.NextDouble() * CMath.PI_MUL_2);
                    AddSpell(fromSkillType, spell, launch, sender, attacker, 0, null,
                        x, y, d, chain, serverExt);
                }
            }
        }

        private void launch_randomPosSpell(XmdsSkillType fromSkillType, SpellTemplate spell, InstanceZoneObject sender,
            LaunchSpell launch, SpellChainLevelInfo chain, InstanceUnit attacker, int serverExt = 0)
        {
			for (int i = 0; i < launch.Count; i++)
			{
				float x = (float)(random.NextDouble() * launch.SpellRange/2);
				float y = (float)(random.NextDouble() * launch.SpellRange/2);
				float d = (float)(random.NextDouble() * CMath.PI_MUL_2);
				int randX = random.Next() % 2 == 0 ? 1 : -1;
				int randY = random.Next() % 2 == 0 ? 1 : -1;
				AddSpell(fromSkillType, spell, launch, sender, attacker, 0, null,
					sender.X + x * randX, sender.Y + y * randY, d, chain, serverExt);
			}
		}

		public InstanceSpell launch_ManyCannon(XmdsSkillType fromSkillType, SpellTemplate spell, InstanceZoneObject sender,
			LaunchSpell launch, SpellChainLevelInfo chain, InstanceUnit attacker, uint targetUnitID, int serverExt, JSGCreateSpellData createData)
		{
			//float angleOffset = targetUnitID == 0 ? launch.StartAngle / 3 : launch.StartAngle;
			float angleOffset = JSGModule.GetCurveStartAngleOffect(attacker, getUnit(targetUnitID), launch.StartAngle, spell.SeekingRange);
			float startAngle = CMath.OpitimizeRadians(attacker.Direction) + angleOffset;
			float launchX = attacker.X - (float)(1.0f * Math.Cos(attacker.Direction)); 
			float launchY = attacker.Y - (float)(1.0f * Math.Sin(attacker.Direction));

			Vector2 targetPos = JSGModule.GetCurveDefaultTargetPos(attacker, spell.SeekingRange);
			//System.Console.WriteLine("targetPos: " + targetPos.X + ", " + targetPos.Y);

			int totalCount = createData == null ? launch.Count : createData.mMaxSpellCount;
			return AddSpell(fromSkillType, spell, launch, sender, attacker, targetUnitID, targetPos,
					launchX, launchY, startAngle, chain, serverExt, 0, null, totalCount-1, createData);
		}

		public void spellSummonUnit(InstanceSpell summoner, SummonUnit summon)
        {
            float x = summoner.X;
            float y = summoner.Y;
            float radius = summoner.BodyBlockSize;

            UnitInfo info = Templates.getUnit(summon.UnitTemplateID);
            if (info.UType != UnitType.TYPE_SUMMON || info.LifeTimeMS <= 0)
            {
                log.Warn("召唤非召唤类单位1：" + summoner.ID + ", 召唤id： " + summon.UnitTemplateID);
                return;
            }
            //UnitInfo un = (UnitInfo)info.Clone();
            //un.UType = UnitInfo.UnitType.TYPE_SUMMON;
            string name = null;
            if (TemplateManager.Formula.TrySummonUnit(summoner.Launcher, summon, ref info, ref name))
            {
                for (int i = 0; i < summon.Count; i++)
                {
                    float dx, dy, dr;

                    //float angle = (float)RandomN.NextDouble() * CMath.PI_MUL_2;
                    //float lengt = (float)RandomN.NextDouble() * radius;
                    //dx = x + (float)Math.Cos(angle) * lengt;
                    //dy = y + (float)Math.Sin(angle) * lengt;
                    //dr = (float)RandomN.NextDouble() * CMath.PI_MUL_2;

                    //召唤单位时判断当前位置能否行走，防止被召唤单位卡在地图里.Editor by Alex.
                    var pos = PathFinder.FindNearRandomMoveableNode(RandomN, x, y, radius, true);
                    if (pos == null)
                    {
                        dx = summoner.Launcher.X;
                        dy = summoner.Launcher.Y;
                    }
                    else
                    {
                        dx = pos.PosX;
                        dy = pos.PosY;
                    }

                    dr = summoner.Direction;
                    InstanceUnit unit = null;
                    if (!summoner.Launcher.IsActive)
                    {
                        unit = AddUnit(info, name, summoner.Launcher.Force, summon.UnitLevel, dx, dy, dr, null);
                    }
                    else
                    {
                        unit = AddUnit(info, name, summoner.Launcher.Force, summon.UnitLevel, dx, dy, dr, summoner.Launcher);
                    }
                    
                    if (unit != null)
                    {
                        if (info.LifeTimeMS > 0)
                        {
                            AddTimeDelayMS(info.LifeTimeMS, (task) =>
                            {
                                unit.kill();
                            });
                        }
                        if (summon.Effect != null)
                        {
                            queueEvent(new AddEffectEvent(unit.ID, dx, dy, dr, summon.Effect));
                        }
                    }

                }
            }
        }

        public void unitSummonUnit(InstanceUnit summoner, SummonUnit summon)
        {
            float x = summoner.X;
            float y = summoner.Y;
            MathVector.movePolar(ref x, ref y, summoner.Direction, summoner.BodyBlockSize * 4);
            float radius = summoner.BodyBlockSize * 2;

            UnitInfo info = Templates.getUnit(summon.UnitTemplateID);
            if (info.UType != UnitType.TYPE_SUMMON || info.LifeTimeMS <= 0)
            {
                log.Warn("召唤非召唤类单位2：" + summoner.ID + ", 召唤id： " + summon.UnitTemplateID);
                return;
            }

            //UnitInfo un = (UnitInfo)info.Clone();
            //un.UType = UnitInfo.UnitType.TYPE_SUMMON;
            string name = null;
            if (TemplateManager.Formula.TrySummonUnit(summoner, summon, ref info, ref name))
            {
                for (int i = 0; i < summon.Count; i++)
                {
                    float angle = (float)RandomN.NextDouble() * CMath.PI_MUL_2;
                    float lengt = (float)RandomN.NextDouble() * radius;
                    float dx = x + (float)Math.Cos(angle) * lengt;
                    float dy = y + (float)Math.Sin(angle) * lengt;
                    float dr = (float)RandomN.NextDouble() * CMath.PI_MUL_2;

                    InstanceUnit unit = AddUnit(info, name, summoner.Force, summon.UnitLevel, dx, dy, dr, summoner);
                    if (unit != null)
                    {
                        if (info.LifeTimeMS > 0)
                        {
                            AddTimeDelayMS(info.LifeTimeMS, (task) =>
                            {
                                unit.kill();
                            });
                        }
                        if (summon.Effect != null)
                        {
                            queueEvent(new AddEffectEvent(unit.ID, dx, dy, dr, summon.Effect));
                        }
                    }
                }
            }
        }

        public InstanceUnit summonUnit(InstanceUnit summoner, UnitInfo info, string name, int level, float x, float y, float direction)
        {
            if (info.UType != UnitType.TYPE_SUMMON || info.LifeTimeMS <= 0)
            {
                log.Warn("召唤非召唤类单位3：" + summoner.ID + ", 召唤id： " + info.ID);
                return null;
            }

            InstanceUnit unit = AddUnit(info, name, summoner.Force, level, x, y, direction, summoner);
            if (unit != null)
            {
                if (info.LifeTimeMS > 0)
                {
                    AddTimeDelayMS(info.LifeTimeMS, (task) =>
                    {
                        unit.kill();
                    });
                }
            }
            return unit;
        }


        /// <summary>
        /// 锁定范围内指定目标
        /// </summary>
        /// <param name="spell"></param>
        /// <param name="X"></param>
        /// <param name="Y"></param>
        /// <param name="range"></param>
        /// <param name="expectTarget"></param>
        /// <param name="expectSeeking"></param>
        /// <param name="chain"></param>
        /// <returns></returns>
        public virtual InstanceUnit SeekSpellAttackable(
            InstanceUnit launcher,
            SpellTemplate spellData,
            ObjectAoiStatus aoiStatus,
            float X, float Y, float range,
            SkillTemplate.CastTarget expectTarget,
            SpellTemplate.SeekingExpect expectSeeking,
            SpellChainLevelInfo chain)
        {
            using (var list = ListObjectPool<InstanceUnit>.AllocAutoRelease())
            {
                getObjectsRoundRange<InstanceUnit>((InstanceZoneObject o, float x, float y, float r) =>
                {
                    InstanceUnit u = o as InstanceUnit;
                    if (chain != null)
                    {
                        switch (expectSeeking)
                        {
                            case SpellTemplate.SeekingExpect.RandomIgnoreInChain:
                            case SpellTemplate.SeekingExpect.NearestIgnoreInChain:
                            case SpellTemplate.SeekingExpect.FarthestIgnoreInChain:
                                if (chain.ContainsTarget(u))
                                {
                                    return false;
                                }
                                break;
                            default:
                                if (chain.LastTarget == u)
                                {
                                    return false;
                                }
                                break;
                        }
                    }
                    if (IsAttackable(launcher, u, expectTarget, AttackReason.Look, spellData))
                    {
                        return CMath.intersectRound(x, y, r, o.X, o.Y, o.BodyHitSize);
                    }
                    return false;
                }, X, Y, range, list, aoiStatus);
                switch (expectSeeking)
                {
                    case SpellTemplate.SeekingExpect.Random:
                    case SpellTemplate.SeekingExpect.RandomIgnoreInChain:
                        CUtils.RandomList(RandomN, list);
                        break;
                    case SpellTemplate.SeekingExpect.Nearest:
                    case SpellTemplate.SeekingExpect.NearestIgnoreInChain:
                        list.Sort(new ObjectSorterNearest<InstanceUnit>(X, Y));
                        break;
                    case SpellTemplate.SeekingExpect.Farthest:
                    case SpellTemplate.SeekingExpect.FarthestIgnoreInChain:
                        list.Sort(new ObjectSorterFarthest<InstanceUnit>(X, Y));
                        break;
                }
                if (list.Count > 0)
                {
                    return list[0];
                }
            }
            return null;
        }

        public virtual void SeekSpellAttackable(List<InstanceUnit> ret, float X, float Y,
            InstanceUnit Launcher,
            SpellTemplate spell,
            LaunchSpell launch,
            SpellChainLevelInfo chain)
        {
            getObjectsRoundRange<InstanceUnit>((InstanceZoneObject o, float x, float y, float r) =>
            {
                InstanceUnit u = o as InstanceUnit;
                if (chain != null)
                {
                    switch (launch.SeekingTargetExpect)
                    {
                        case SpellTemplate.SeekingExpect.RandomIgnoreInChain:
                        case SpellTemplate.SeekingExpect.NearestIgnoreInChain:
                        case SpellTemplate.SeekingExpect.FarthestIgnoreInChain:
                            if (chain.ContainsTarget(u))
                            {
                                return false;
                            }
                            break;
                        default:
                            if (chain.LastTarget == u)
                            {
                                return false;
                            }
                            break;
                    }
                }
                if (IsAttackable(Launcher, u, spell.ExpectTarget, AttackReason.Look, spell))
                {
                    return CMath.intersectRound(x, y, r, o.X, o.Y, o.BodyHitSize);
                }
                return false;
            }, X, Y, launch.SeekingTargetRange, ret, Launcher.AoiStatus);

            switch (launch.SeekingTargetExpect)
            {
                case SpellTemplate.SeekingExpect.Random:
                case SpellTemplate.SeekingExpect.RandomIgnoreInChain:
                    CUtils.RandomList(RandomN, ret);
                    break;
                case SpellTemplate.SeekingExpect.Nearest:
                case SpellTemplate.SeekingExpect.NearestIgnoreInChain:
                    ret.Sort(new ObjectSorterNearest<InstanceUnit>(X, Y));
                    break;
                case SpellTemplate.SeekingExpect.Farthest:
                case SpellTemplate.SeekingExpect.FarthestIgnoreInChain:
                    ret.Sort(new ObjectSorterFarthest<InstanceUnit>(X, Y));
                    break;
            }
        }

        /**游戏服场景标识通知*/
        public virtual void GSZoneFlagNotifyMsg(int value1)
        {

        }

        #endregion

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

        #region EDITOR_AND_SCRIPT

        readonly private HashMap<string, InstanceFlag> mFlags = new HashMap<string, InstanceFlag>();

        private bool mHasArea = false;

        protected bool addFlag(InstanceFlag flag)
        {
            if (!mFlags.ContainsKey(flag.Name))
            {
                mFlags.Add(flag.Name, flag);
                flag.onAdded();
                if (flag is ZoneArea)
                {
                    mHasArea = true;
                }
                return true;
            }
            return false;
        }

        public InstanceFlag getFlag(string name)
        {
			if(string.IsNullOrEmpty(name))
			{
				return null;
			}
            return mFlags.Get(name);
        }

        public T getFlagAs<T>(string name) where T : InstanceFlag
        {
            return mFlags.Get(name) as T;
        }

        public bool setFlag(string name, bool enable)
        {
            InstanceFlag flag = getFlag(name);
            if (flag != null)
            {
                flag.Enable = enable;
                return true;
            }
            return false;
        }

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

        private HashMap<string, EnvironmentVar> EnvironmentVarMap = new HashMap<string, EnvironmentVar>();

        public void AddEnvironmentVar(string key, object value, bool syncToClient)
        {
            if (!string.IsNullOrEmpty(key))
            {
                EnvironmentVar var = EnvironmentVarMap.Get(key);
                if (var != null)
                {
                    if (EnvironmentVar.ALWAYS_SYNC_ENVIRONMENT_VAR || (var.SyncToClient && var.Value != value))
                    {
                        queueEvent(new SyncEnvironmentVarEvent(key, value));
                    }
                    var.Value = value;
                }
                else
                {
                    var = new EnvironmentVar(key, syncToClient, value);
                    EnvironmentVarMap.Add(key, var);
                    if (EnvironmentVar.ALWAYS_SYNC_ENVIRONMENT_VAR || var.SyncToClient)
                    {
                        queueEvent(new SyncEnvironmentVarEvent(key, value));
                    }
                }
            }
        }

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

        public ClientStruct.ZoneEnvironmentVar[] GetCurrentZoneVars()
        {
            ClientStruct.ZoneEnvironmentVar[] ret = new ClientStruct.ZoneEnvironmentVar[EnvironmentVarMap.Count];
            int i = 0;
            foreach (EnvironmentVar var in EnvironmentVarMap.Values)
            {
                ret[i] = new ClientStruct.ZoneEnvironmentVar();
                ret[i].Key = var.Key;
                ret[i].Value = var.Value;
                ret[i].SyncToClient = var.SyncToClient;
                i++;
            }
            return ret;
        }

        protected void BindZoneVar(ZoneVar var, BindValuesAdapter api)
        {
            if (string.IsNullOrEmpty(var.Key))
            {
                // Error
                return;
            }
            if (var.Value is IEditorValue)
            {
                IEditorValue evalue = (var.Value as IEditorValue);
                AddEnvironmentVar(var.Key, evalue.GetEnvValue(api), var.SyncToClient);
            }
            else if (var.Value is Array)
            {
                Array array = var.Value as Array;
                for (int i = 0; i < array.Length; i++)
                {
                    object e = array.GetValue(i);
                    if (e is IEditorValue)
                    {
                        string key = string.Format(var.Key + "[{0}]", i);
                        IEditorValue evalue = (e as IEditorValue);
                        AddEnvironmentVar(key, evalue.GetEnvValue(api), var.SyncToClient);
                    }
                }
            }
        }


        #endregion
        //-------------------------------------------------------------------------------------------------------//
        #region QUEST
        /// <summary>
        /// 【第三方系统通知】任务已接受
        /// </summary>
        /// <param name="playerUUID"></param>
        /// <param name="quest"></param>
        internal void gs_OnQuestAccepted(string playerUUID, string quest)
        {
            queueTask((InstanceZone zone) =>
            {
                InstancePlayer p = getPlayerByUUID(playerUUID);
                if (p != null)
                {
                    p.doQuestAccepted(quest);
                    if (mOnQuestAccepted != null)
                        mOnQuestAccepted.Invoke(p, quest);
                }
            });
        }
        /// <summary>
        /// 【第三方系统通知】任务已完成
        /// </summary>
        /// <param name="playerUUID"></param>
        /// <param name="quest"></param>
        internal void gs_OnQuestCommitted(string playerUUID, string quest)
        {
            queueTask((InstanceZone zone) =>
            {
                InstancePlayer p = getPlayerByUUID(playerUUID);
                if (p != null)
                {
                    if (mOnQuestCommitted != null)
                        mOnQuestCommitted.Invoke(p, quest);
                    p.doQuestCommitted(quest);
                }
            });
        }
        /// <summary>
        /// 【第三方系统通知】任务已放弃
        /// </summary>
        /// <param name="playerUUID"></param>
        /// <param name="quest"></param>
        internal void gs_OnQuestDropped(string playerUUID, string quest)
        {
            queueTask((InstanceZone zone) =>
            {
                InstancePlayer p = getPlayerByUUID(playerUUID);
                if (p != null)
                {
                    if (mOnQuestDropped != null)
                        mOnQuestDropped.Invoke(p, quest);
                    p.doQuestDropped(quest);
                }
            });
        }
        /// <summary>
        /// 【第三方系统通知】任务状态已改变
        /// </summary>
        /// <param name="playerUUID"></param>
        /// <param name="quest"></param>
        /// <param name="key"></param>
        /// <param name="value"></param>
        internal void gs_OnQuestStatusChanged(string playerUUID, string quest, string key, string value)
        {
            queueTask((InstanceZone zone) =>
            {
                InstancePlayer p = getPlayerByUUID(playerUUID);
                if (p != null)
                {
                    p.doQuestStatusChanged(quest, key, value);
                    if (mOnQuestStatusChanged != null)
                        mOnQuestStatusChanged.Invoke(p, quest, key, value);
                }
            });
        }

        //给单个玩家发送消息
        internal void doSendMsgToPlayer(InstancePlayer player, CommonLang.Protocol.IMessage msg)
        {
            mQuestAdapter.DoSendMsgToPlayer(player.PlayerUUID, msg);
        }

        /// <summary>
        /// 本地通知游戏服
        /// </summary>
        /// <param name="player"></param>
        /// <param name="quest"></param>
        /// <param name="args"></param>
        internal void doAcceptQuest(InstancePlayer player, string quest, string args)
        {
            mQuestAdapter.DoAcceptQuest(player.PlayerUUID, quest, args);
        }
        /// <summary>
        /// 本地通知游戏服
        /// </summary>
        /// <param name="player"></param>
        /// <param name="quest"></param>
        /// <param name="args"></param>
        internal void doCommitQuest(InstancePlayer player, string quest, string args)
        {
            mQuestAdapter.DoCommitQuest(player.PlayerUUID, quest, args);
        }
        /// <summary>
        /// 本地通知游戏服
        /// </summary>
        /// <param name="player"></param>
        /// <param name="quest"></param>
        /// <param name="args"></param>
        internal void doDropQuest(InstancePlayer player, string quest, string args)
        {
            mQuestAdapter.DoDropQuest(player.PlayerUUID, quest, args);
        }
        /// <summary>
        /// 本地通知游戏服
        /// </summary>
        /// <param name="player"></param>
        /// <param name="quest"></param>
        /// <param name="key"></param>
        /// <param name="value"></param>
        internal void doUpdateQuestStatus(InstancePlayer player, string quest, string key, string value)
        {
            mQuestAdapter.DoUpdateQuestStatus(player.PlayerUUID, quest, key, value);
        }


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

    }


}