WSHCommon/XmdsServerCS/XmdsServerNode/Node/ServerZoneNode.cs

using CommonAI.Zone;
using CommonAI.Zone.Instance;
using CommonAI.ZoneServer;
using CommonLang;
using CommonLang.ByteOrder;
using CommonLang.Concurrent;
using CommonLang.IO;
using CommonLang.IO.Attribute;
using CommonLang.Property;
using CommonLang.Protocol;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using XmdsCommon.Message;
using XmdsCommon.Plugin;
using XmdsCommonServer.Message;
using XmdsCommonServer.Plugin;
using XmdsServerNode.Node.Interface;
using CommonAIServer.Node;
using CommonAI.ZoneClient;
using XmdsCommonServer.Plugin.Units;
using XmdsCommonServer.Plugin.Scene;
using CommonAI.Zone.ZoneEditor;
using System.Dynamic;
using XmdsServerNode.CheatingDeath;
using Pomelo;
using System.Web.Helpers;
using static CommonAI.XmdsConstConfig;
using CommonAI.Zone.Helper;
using CommonAI.Data;

namespace XmdsServerNode.Node
{
    public class ServerZoneNode : CommonAIServer.Node.ZoneNode
    {
        private GameOverEvent mGameOver = null;
        public bool PauseOnNoPlayer { get; set; }
        public string UUID { get { return Zone.UUID; } }
        public bool IsGameOver { get { return mGameOver != null; } }

        public ICEZoneSession Callback;
        private readonly string BindGameServerId;


		public ServerZoneNode(string gameServerId) : base(ZoneNodeManager.Templates, ZoneNodeManager.NodeConfig)
        {
            this.BindGameServerId = gameServerId;
            PauseOnNoPlayer = false;
        }

		public string GetBindGameSrvId()
		{
			return this.BindGameServerId;
		}

		/// <summary>
		/// 房间初始化
		/// </summary>
		public void Start(string instanceID, int scene_id, string monsterHard, byte allowAutoGuard, bool calPKValue, 
			int average_level, double monsterAddPropPercentWithFloor, double monsterAddPropRatioWithLv, int killInterval,
			int killMax, int killMaxCoolTime, bool usespaceDiv, CommonAI.Data.SceneType scenetype, GSCreateAreaData areaData, 
			CommonAI.XmdsConstConfig.AreaType areaType, bool isteam = false, bool canRiding = true)
        {
            try
            {
				var sd = base.DataRoot.LoadScene_Server(scene_id, true, false);
                sd.DefaultUnitLevel = average_level;
                sd.MonsterAddPropPercentWithFloor = monsterAddPropPercentWithFloor;
                sd.MonsterAddPropRatioWithLv = monsterAddPropRatioWithLv;
                sd.canRiding = canRiding;
				sd.killInterval = killInterval;
                sd.killMax = killMax;
                sd.killMaxCoolTime = killMaxCoolTime;
                sd.isTeam = isteam;
                sd.sceneType = scenetype;

				XmdsSceneProperties zsp = sd.Properties as XmdsSceneProperties;
                XmdsServerSceneData sceneData = new XmdsServerSceneData();
                sceneData.AllowAutoGuard = allowAutoGuard;
                sceneData.CalPKValue = calPKValue;
                sceneData.SceneHard = monsterHard;
                sceneData.UsespaceDiv = usespaceDiv;
                sceneData.CurAreaType = areaType;
                zsp.ServerSceneData = sceneData;				

				base.Start(sd, areaData, this.BindGameServerId);
                base.Zone.UUID = instanceID;
			}
            catch (System.Exception e)
            {
                throw new Exception(string.Format("scene {0} start error : {1}", scene_id, e.ToString()), e);
            }
        }

        public void QueueTaskAsync(System.Action<EditorScene> action)
        {
            base.QueueTask(() =>
            {
                action(base.Zone);
            });
        }
        public void QueueTaskAsync(System.Action action)
        {
            base.QueueTask(() =>
            {
                action();
            });
        }

        public void SendToGameServer(string name, Object param)
        {
            if (Callback == null)
            {
                this.Callback = IceManager.instance().getCallback(this.BindGameServerId);
                log.Warn("SendToGameServer callback - 1 - null : " + this.BindGameServerId + ", name:" + name + ", data:" + param);
            }

            if (Callback != null && Callback.callback != null)
            {
				try
                {
					//ZoneManagerCallbackPrxHelper temp = (ZoneManagerCallbackPrxHelper)Callback.callback;
					//Ice.AsyncResult<Ice.Callback_Object_ice_getConnection> test1 = Callback.callback.begin_ice_getConnection();
					//Ice.AsyncResult test2 = Callback.callback.begin_ice_getConnection();
					//Ice.AsyncResult<Ice.Callback_Object_ice_ping> test3 = Callback.callback.begin_ice_ping();
					//Ice.Connection test4 = Callback.callback.ice_getCachedConnection();
					//Ice.Communicator test5 = Callback.callback.ice_getCommunicator();
					//Callback.callback.ice_ping();
					string json = Json.Encode(param);
                    Callback.callback.eventNotify(name, json);
                }
				catch (Exception err)
				{
					log.Error(err.Message, err);
					EventNotifyFail();
				}
			}
            else
            {
                log.Warn("SendToGameServer callback - 2- null : " + this.BindGameServerId + ", name:" + name + ", data:" + param);
            }
        }

		private void EventNotifyFail()
		{
			try
			{
				if (Callback.callback.ice_getCachedConnection() == null)
				{
					Callback.failTimes++;
					if (Callback.fastSession != null && Callback.failTimes >= 3)
					{
						Callback.fastSession.doClose();
						Callback.failTimes = 0;
						log.Warn("EventNotifyFail 重置连接: " + Callback.fastSession.GetDescribe());
					}
					else
					{
						log.Error("EventNotifyFail fastSession null:" + Callback.callback.ToString());
					}
				}
			}
			catch (System.Exception e)
			{
				log.Error("EventNotifyFail catch:" + e);
			}
		}


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

		#region _主线程内回调_线程安全_

		public override bool ZoneUpdate(int intervalMS)
        {
            if (PauseOnNoPlayer && base.PlayerCount == 0) { intervalMS = 0; }
            return base.ZoneUpdate(intervalMS);
        }

        //过滤游戏场景推送出的消息//
        protected override bool OnMessageHandlerFromInstanceZone(Event e)
        {
            //战斗服To游戏服.
            if (e is MessagePlayerEventB2R)
            {
                e.sender = null;
                var msg = e as MessagePlayerEventB2R;
                msg.eventName = e.GetType().Name;
                SendToGameServer("playerEvent", e);
                return true;
            }
            else if (e is MessageZoneEventB2R)
            {
                e.sender = null;
                var msg = e as MessageZoneEventB2R;
                msg.eventName = e.GetType().Name;
                SendToGameServer("zoneEvent", e);
                return true;
            }
			else if(e is MessageMapEventB2R)
			{
				var msg = e as MessageMapEventB2R;
				msg.eventName = e.GetType().Name;
				SendToGameServer("mapNotify", e);
				return true;
			}
            else if (e is GameOverEvent)
            {
                if (mGameOver == null)
                {
                    mGameOver = e as GameOverEvent;
                    var eventParam = new
                    {
                        eventName = "gameOver",
                        instanceId = this.UUID,
                        winForce = mGameOver.WinForce
                    };
                    SendToGameServer("areaEvent", eventParam);
                }
            }
            return false;
        }


        protected override void OnEndUpdate()
        {
            base.ForEachPlayers((c) =>
            {
                var zone_client = c.Client as ZoneNodePlayer;
                zone_client.Flush();
            });
        }

        protected override void OnPlayerEntered(PlayerClient client)
        {
            base.OnPlayerEntered(client);
            CheatingDeath.CheatingDeathManager.OnPlayerEnter(client.Actor);

            //进去默认自动战斗的情况下
            if(this.SceneData.Properties.GetAutoFightFlag() == 3 && !client.Actor.IsGuard)
            {
                client.Actor.IsGuard = true;
            }

            client.Actor.Virtual.doEvent(JSGCustomOpType.UpdateAutoBattleFlag);
        }
        protected override void OnPlayerLeft(PlayerClient client)
        {
            base.OnPlayerLeft(client);
            this.KillPlayerAOIObjects(client);
        }

        //干掉所有和玩家同一位面单位//
        protected void KillPlayerAOIObjects(PlayerClient client)
        {
            var player = client.Actor;
            if (player != null && player.AoiStatus != null)
            {
                var src_aoi = player.AoiStatus as XmdsPlayerAOI;
                if (src_aoi.Owner == player)
                {
                    src_aoi.Cleanup();
                }
            }
        }

        #endregion

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

        #region _游戏服控制玩家_

        /// <summary>
        /// 单位进入场景
        /// </summary>
        /// <param name="player"></param>
        /// <param name="enter"></param>
        public void OnPlayerEnter(IPlayer player, PlayerEnterRoomS2R enter, Action<PlayerClient> callback, Action<Exception> callerror)
        {
            if (enter == null)
            {
                // 建立绑定关系 //
                var zone_player = new ZoneNodePlayer(this, player);
                base.PlayerEnter(zone_player, null, 0, 0, 0, null,0, callback, callerror);
            }
            else
            {
                // 有出生点则放入出生点 //
                CommonLang.Vector.Vector2 enterPos = enter.Pos;
                if (enterPos.X == 0 && enterPos.Y == 0)
                {
                    enterPos = null;
                }
                if (!string.IsNullOrEmpty(enter.FlagName))
                {
                    InstanceFlag p = Zone.getFlag(enter.FlagName);
					if(p != null)
					{
	                    if (p is ZoneRegion)
	                    {
	                        // Region随机取一个坐标
	                        var pos = (p as ZoneRegion).getRandomPos(Zone.RandomN);
	                        enterPos.SetX(pos.X);
	                        enterPos.SetY(pos.Y);
	                    }
	                    else
	                    {
	                        enterPos = p.Pos;
	                    }
					}
                }
                UnitInfo temp = ZoneNodeManager.Templates.Templates.getUnit(enter.UnitData.UnitTemplateID);
                if (temp != null)
                {
                    temp = temp.Clone() as UnitInfo;
                    temp.UType = UnitInfo.UnitType.TYPE_PLAYER;
                    XmdsUnitProperties tprop = (temp.Properties as XmdsUnitProperties);

                    //临时代码.
                    //默认无限等待.
                    temp.RebirthTimeMS = int.MaxValue;

                    // 插入玩家能力属性 //
                    tprop.ServerData = ((enter.UnitData.UnitPropData) as XmdsUnitProperties).ServerData;

                    // 建立绑定关系 //
                    var zone_player = new ZoneNodePlayer(this, player);
                    base.PlayerEnter(zone_player, temp, enter.UnitData.Force, enter.UnitData.alliesForce, 
                        tprop.ServerData.BaseInfo.UnitLv, enterPos,enter.direction, callback, callerror);
                }
                else
                {
                    throw new Exception("Unit template not exist : " + enter);
                }
            }
        }

        /// <summary>
        /// 单位离开场景
        /// </summary>
        /// <param name="player"></param>
        public void OnPlayerLeave(InstancePlayer player, Action<PlayerClient> callback, Action<Exception> callerror, bool keep_object = false)
        {
            if (player != null)
            {
                base.PlayerLeave(player, callback, callerror, keep_object);
            }
        }

        /// <summary>
        /// 玩家网络状况改变
        /// </summary>
        /// <param name="player"></param>
        /// <param name="state"></param>
        public void OnPlayerNetStateChanged(IPlayer player, string state)
        {
            QueueTask(() =>
            {
                var zc = player.BindingObject;
                if (zc != null)
                {
                    zc.NetStateChanged(state);
                }
            });
        }

        /// <summary>
        /// 单位收到来自客户端的消息
        /// </summary>
        /// <param name="client"></param>
        /// <param name="message"></param>
        public void OnPlayerReceivedMessage(IPlayer player, byte[] msg)
        {
            QueueTask(() =>
            {
                //if (doDecodePing(player, msg))
                //{
                //    return;
                //}
                //else
                {
                    var zone_player = player.BindingObject;
                    if (zone_player != null)
                    {
                        zone_player.Recv(msg);
                    }
                }
            });
        }

        public void ReceiveMsgR2B(IPlayer client, object status)
        {
            QueueTask(() =>
            {
                var zc = client.BindingObject;

                if (zc != null && zc.BindingActor != null)
                {
                    XmdsVirtual zv = (XmdsVirtual)zc.BindingActor.Virtual;
                    zv.ReceiveMsgR2B(status);
                }
            });
        }

        /// <summary>
        /// 玩家复活，分原地复活和复活点复活
        /// </summary>
        /// <param name="client"></param>
        /// <param name="status"></param>
        public void OnHelpPlayerRebirth(IPlayer player, IPlayer revivePlayer, int time)
        {
            QueueTask(() =>
            {
                var p = player.BindingObject;
                var r = revivePlayer.BindingObject;

                if (p != null && r != null && p.BindingActor != null && r.BindingActor != null)
                {
                    PlayerSaveEventR2B r2b = new PlayerSaveEventR2B();
                    XmdsVirtual Decedent = (XmdsVirtual)(r.BindingActor).Virtual;
                    XmdsVirtual Saver = (XmdsVirtual)(p.BindingActor).Virtual;
                    r2b.Decedent = Decedent.mUnit;
                    r2b.Saver = Saver.mUnit;
                    r2b.SaveTime = time;
                    Saver.ReceiveMsgR2B(r2b);
                }
            });

        }

        public void OnPlayerReadyR2B(IPlayer client)
        {
            QueueTask(() =>
            {
                InstancePlayer out_player;
                PlayerClient out_client;
                if (GetPlayerAndClient(client.PlayerUUID, out out_player, out out_client))
                {
                    if (out_player != null && out_client != null)
                    {
                        (out_player as XmdsInstancePlayer).PlayerReady();
                    }
                }
            });
        }

        public void OnPlayerReviveTeamInfoEventR2B(IPlayer client, TeamInfoEventR2B team)
        {
            QueueTask(() =>
            {
                InstancePlayer out_player;
                PlayerClient out_client;
                if (GetPlayerAndClient(client.PlayerUUID, out out_player, out out_client))
                {
                    if (out_player != null && out_client != null)
                    {
                        (out_client as BindingPlayerClient).OnPlayerReviveTeamInfoEventR2B(team);
                        var zv = (XmdsVirtual)out_player.Virtual;
                        zv.ReceiveMsgR2B(team);
                    }
                }
            });
        }

        public void OnPlayerAddHPByItem(List<IPlayer> notifyPlayers, IPlayer client, int addHP)
        {
            QueueTask(() =>
            {
                var nodePlayer = client.BindingObject as ZoneNodePlayer;

                if (nodePlayer != null)
                {
                    XmdsVirtual zv = (nodePlayer.BindingActor.Virtual) as XmdsVirtual;
                    int finalHp = zv.AddHPByItem(addHP);
                    ZoneNodePlayer temp = null;

                    foreach (IPlayer p in notifyPlayers)
                    {
                        temp = p.BindingObject as ZoneNodePlayer;
                        XmdsVirtual notifyPlayer = null;

                        if (temp != null)
                        {
                            notifyPlayer = (temp.BindingActor.Virtual) as XmdsVirtual;
                            notifyPlayer.SendHPChangeMessage(zv.mUnit.ID, finalHp);
                        }
                    }
                }
            });
        }

		public float GetDropRange(int items)
		{
			if(items >= 10)
			{
				return 5.0f;
			}
			if (items >= 7)
			{
				return 4.0f;
			}
			else if(items > 4)
			{
				return 3.6f;
			}
			return 2.8f;
		}

		public float GetDropOffect(float dropRange)
		{
			int index = (this.Zone.RandomN.Next() % 2 == 0) ? 1 : -1;
			return dropRange * this.Zone.RandomN.Next(0, 100) / 100f * index;
		}

        public void AddDropItem(float x, float y, dynamic items)
        {
            QueueTask(() =>
            {
				//阿基米德螺线<-装B用，实际不需要这样
				//20170621wuyonghui修改为随机掉落位置算法
				float dropRange = GetDropRange(((DynamicJsonArray)items).Length);// 掉落半径范围为5
				bool addSuc = false;
                foreach (dynamic obj in items)
                {
                    XmdsCommon.Message.DropItem di = new XmdsCommon.Message.DropItem();
                    di.FileName = (string)obj.showId;
                    di.FreezeTime = (int)obj.freezeTime;
                    di.Name = (string)obj.name;
                    di.ObjID = (string)obj.id;
                    di.ProtectTime = (int)obj.protectTime;
                    di.Qty = (int)obj.groupCount;
                    di.Quality = (int)obj.qColor;
                    di.TemplateID = (int)obj.itemTypeId;
                    di.TTL = (int)obj.lifeTime;
					di.PlayerUUID = new List<string>();
					di.Mode = (byte)obj.distributeType;
                    di.OriginX = x;
                    di.OriginY = y;
					bool showLifeTimes = (bool)obj.showLifeTime;
					di.code = (String)obj.code;
					di.bindPlayerId = obj.bindPlayerId;
					di.createTime = (int)(CommonLang.CUtils.S_LOCAL_TIMESTAMPMS/1000);

					if (obj.PlayerUUID != null)
					{
						foreach (dynamic playeruuid in obj.PlayerUUID)
						{
							di.PlayerUUID.Add(playeruuid);
						}
					}
				
                    di.IconName = (string)obj.IconName;

					ItemTemplate templateTemp = Zone.Templates.getItem(di.TemplateID);
					if(templateTemp == null)
					{
						log.Warn("AddDropItem没有对应单位信息:" + di.TemplateID + ", " + di.code);
						return;
					}

					ItemTemplate template = templateTemp.Clone() as ItemTemplate;
                    //每个物品类型可能有多个显示模型，所以按游戏服传过来的策划配置模型名称
                    template.FileName = di.FileName;
                    //修改模板的部分数据，由于模板是共享的，所以必须每次都把以下数据完整覆盖
                    template.LifeTimeMS = di.TTL;
                    template.GotCoolDownTimeMS = di.FreezeTime;
                    template.DropForAll = true;
                    template.GotOnUse = true;
					template.showLifeTime = showLifeTimes;
					//template.Pickable = false;//这里注释掉，直接用模板里的值，不要改变
					XmdsItemProperties props = template.Properties as XmdsItemProperties;
                    props.ItemType = XmdsItemProperties.XmdsItemType.Equip;

                    float x1 = this.GetDropOffect(dropRange);//获得X偏移量
                    float y1 = this.GetDropOffect(dropRange);//获得Y偏移量
                    if(Zone.TryTouchMap(null,x+x1,y+y1))
                    {
                        x1 = 0;
                        y1 = 0;
                    }

					//System.Console.WriteLine("掉落物：" + di.Name + ", 偏移：" + x1 + ", " + y1 + "----" + (x + x1) + ", " + (y + y1));
                    AddItemEvent aie;
                    XmdsDropableInstanceItem drop_item = Zone.AddItem(template, obj.name, x + x1, y + y1, 0, 0, obj.name, out aie, null,1);
					if(drop_item == null || aie == null)
					{
						log.Warn("添加bs掉落物失败：" + template.ID + ", " + template.Name + ", " + this.SceneID);
						return;
					}
                    aie.Sync.ExtData = di;
					if(drop_item != null)
					{
						addSuc = true;						
					}
				}

				if (addSuc)
				{
					base.RecordDropItem();
				}
            });
        }

        public void FinishPickItem(IPlayer player, string itemIcon, int quality, int num)
        {
            QueueTask(() =>
            {
                var p = player.BindingObject;
             
                if (p != null && p.BindingActor != null)
                {
                    PlayerGotItemB2C b2c = new PlayerGotItemB2C();
                    XmdsVirtual zv = (XmdsVirtual)(p.BindingActor).Virtual;
                    b2c.IconName = itemIcon;
                    b2c.Qty = num;
                    b2c.Quality = quality;
                    zv.mUnit.queueEvent(b2c);
                }
            });
        }


        #endregion

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

        #region _PingPong_

        //private static readonly int MSG_TYPE_ID_PING = PropertyUtil.GetAttribute<MessageTypeAttribute>(typeof(Ping)).MessageTypeID;
        //private static readonly int MSG_TYPE_ID_PONG = PropertyUtil.GetAttribute<MessageTypeAttribute>(typeof(Pong)).MessageTypeID;
        //private ArraySegment<byte> pong_data = new ArraySegment<byte>(new byte[8], 0, 8);

        //public bool doDecodePing(IPlayer player, byte[] data)
        //{
        //    int pos = 0;
        //    int msg_id = LittleEdian.GetS32(data, ref pos);
        //    if (msg_id == MSG_TYPE_ID_PING)
        //    {
        //        uint time = LittleEdian.GetU32(data, ref pos);
        //        pos = 0;
        //        LittleEdian.PutS32(pong_data.Array, ref pos, MSG_TYPE_ID_PONG);
        //        LittleEdian.PutU32(pong_data.Array, ref pos, time);
        //        player.SendToClient(pong_data);
        //        return true;
        //    }
        //    return false;
        //}

        #endregion

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

        protected override PlayerClient CreatePlayerClient(CommonAIServer.Node.Interface.IPlayer client, InstancePlayer actor)
        {
            var syncIn = base.Config.CLIENT_SYNC_OBJECT_IN_RANGE;
            var syncOut = base.Config.CLIENT_SYNC_OBJECT_OUT_RANGE;
            var zpp = base.SceneData.Properties as XmdsSceneProperties;
            if (zpp.AOIMinRange > 0 && zpp.AOIMaxRange > 0)
            {
                syncIn = zpp.AOIMinRange;
                syncOut = zpp.AOIMaxRange;
            }
            return new BindingPlayerClient(client, actor, this, syncIn, syncOut);
        }

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

        public class ZoneNodePlayer : CommonAIServer.Node.Interface.IPlayer
        {
            private static AtomicInteger s_alloc_object_count = new AtomicInteger(0);
            /// <summary>
            /// 分配实例数量
            /// </summary>
            public static int AllocCount { get { return s_alloc_object_count.Value; } }

            public readonly ZoneNode node;
            public readonly IPlayer player;

            private ZoneNodeCodec mCodec = new ZoneNodeCodec(ZoneNodeManager.MessageFactory);
            private AtomicReference<PlayerClient> binding_player = new AtomicReference<PlayerClient>(null);
            private Action<object> handler;
            private PackEvent mSendingQueue = new PackEvent();
            private AtomicInteger mSendingSequenceNo = new AtomicInteger(0);
            private string display_name = "";

            //private Queue<object> mPreQueue = new Queue<object>();

            internal ZoneNodePlayer(ZoneNode node, IPlayer player)
            {
                s_alloc_object_count++;
                this.node = node;
                this.player = player;
                this.player.BindingObject = this;
                this.Connected = true;
            }
            ~ZoneNodePlayer()
            {
                s_alloc_object_count--;
            }

            public IPlayer SessionPlayer {get { return player; }}

            public PlayerClient BindingPlayer
            {
                get { return binding_player.Value; }
                set
                {
                    binding_player.Value = value;
                    if (value != null)
                    {
                        try
                        {
                            display_name = (value.Actor.Properties as XmdsUnitProperties).ServerData.BaseInfo.name;
                        }
                        catch (Exception err)
                        {
                            display_name = err.Message;
                        }
                    }
                }
            }
            public InstancePlayer BindingActor
            {
                get
                {
                    var player = binding_player.Value;
                    if (player != null)
                    {
                        return player.Actor;
                    }
                    return null;
                }
            }

            public bool Connected { get; private set; }

            internal void NetStateChanged(string state)
            {
                BaseZoneNode.log.InfoFormat("Player:{0} NetStateChanged:{1}", player.PlayerUUID, state);
                switch (state)
                {
                    case "disconnected":
                        this.Connected = false;
                        break;
                    case "connected":
                        this.Connected = true;
                        break;
                    default:
                        return;
                }
            }

            internal void Recv(byte[] data)
            {
                IMessage message;
                if (mCodec.doDecode(data, out message))
                {
                    //if(handler == null)
                    //{
                    //    mPreQueue.Enqueue(message);
                    //}
                    //else
                    //{
                    //    handler.Invoke(message);
                    //}
                    if (handler != null)
                    {
                        handler.Invoke(message);
                    }

                }
                else
                {
                    CheatingDeathManager.SendPlayerException(BindingActor, "decode error");
                }
            }
            public void Send(IMessage msg)
            {
                if (msg is PlayerLeaveScene)
                {
                    this.Flush();
                    this.ForceSend(msg);
                }
                else if (this.Connected)
                {
                    lock (mSendingQueue)
                    {
                        mSendingQueue.events.Add(msg);
                    }
                }
            }
            internal void Flush()
            {
                lock (mSendingQueue)
                {
                    if (mSendingQueue.events.Count > 0)
                    {
                        try
                        {
                            if (this.Connected)
                            {
                                mSendingQueue.sequenceNo = mSendingSequenceNo.GetAndIncrement();
                                ForceSend(mSendingQueue);
                            }
                        }
                        finally
                        {
                            mSendingQueue.events.Clear();
                        }
                    }
                }
            }
            internal void ForceSend(IMessage msg)
            {
                //BaseZoneNode.log.Debug("B2C msg>>>" + msg);
                ArraySegment<byte> data;
                if (mCodec.doEncode(msg, out data))
                {
                    this.player.SendToClient(data);
                }
            }
            #region CommonAIServer.Node.Interface.IPlayer.

            void CommonAIServer.Node.Interface.IPlayer.OnConnected(PlayerClient bindingg)
            {
            }
            void CommonAIServer.Node.Interface.IPlayer.OnDisconnect(PlayerClient bindingg)
            {
                this.player.BindingObject = null;
                this.player.Dispose();
            }
            string CommonAIServer.Node.Interface.IPlayer.DisplayName
            {
                get { return display_name; }
            }
            string CommonAIServer.Node.Interface.IPlayer.PlayerUUID
            {
                get { return player.PlayerUUID; }
            }
            object CommonAIServer.Node.Interface.IPlayer.GetAttribute(string key)
            {
                return player.GetAttribute(key);
            }
            bool CommonAIServer.Node.Interface.IPlayer.IsAttribute(string key)
            {
                return player.IsAttribute(key);
            }
            void CommonAIServer.Node.Interface.IPlayer.SetAttribute(string key, object value)
            {
                player.SetAttribute(key, value);
            }
            void CommonAIServer.Node.Interface.IPlayer.Listen(Action<object> handler)
            {
                this.handler = handler;
                //while(mPreQueue.Count > 0)
                //{
                //    this.handler.Invoke(mPreQueue.Dequeue());
                //}
            }
            #endregion

        }


        public class BindingPlayerClient : PlayerClient
        {
            private readonly ZoneNodePlayer Xmds_client;
            private readonly HashSet<string> team_info = new HashSet<string>();
            private List<string> team_removing = new List<string>(1);

            internal BindingPlayerClient(CommonAIServer.Node.Interface.IPlayer client, InstancePlayer actor, CommonAIServer.Node.ZoneNode node, float syncIn, float syncOut)
                : base(client, actor, node, syncIn, syncOut)
            {
                this.Xmds_client = client as ZoneNodePlayer;
            }
            protected override void OnStart()
            {
                base.OnStart();
                foreach (var obj in base.Zone.AllUnits)
                {
                    if (IsStaticUnit(obj))
                    {
                        base.ForceAddObjectInView(obj);
                    }
                }
            }
            private bool IsStaticUnit(InstanceZoneObject obj)
            {
                if (obj is InstanceUnit)
                {
                    XmdsUnitProperties prop = (obj as InstanceUnit).Info.Properties as XmdsUnitProperties;
                    return prop.IsStaticUnit;
                }
                return false;
            }
            protected override bool IsLookInRange(InstanceZoneObject obj)
            {
                if (obj is InstancePlayer)
                {
                    //组队列表中的单位永远不出视野//
                    var player = obj as InstancePlayer;
                    if (team_info.Contains(player.PlayerUUID))
                    {
                        return true;
                    }

					//if((player.CurrentActionSubstate & (byte)UnitActionSubStatus.Stealth) > 0 
     //                   && (this.Actor.CurrentActionSubstate & (byte)UnitActionSubStatus.Stealth) <= 0)
					//{
					//	return false;
					//}
                }
                else if (IsStaticUnit(obj))
                {
                    return true;
                }
                return base.IsLookInRange(obj);
            }
            protected override bool IsLookOutRange(InstanceZoneObject obj)
            {
                if (obj is InstancePlayer)
                {
                    //组队列表中的单位永远不出视野//
                    var player = obj as InstancePlayer;
                    if (team_info.Contains(player.PlayerUUID))
                    {
                        return false;
                    }

     //               if ((player.CurrentActionSubstate & (byte)UnitActionSubStatus.Stealth) > 0
     //                   && (this.Actor.CurrentActionSubstate & (byte)UnitActionSubStatus.Stealth) <= 0
     //                   && !player.Virtual.IsAllies(this.Actor.Virtual))                  
					//{
					//	return true;
					//}
				}
                else if (IsStaticUnit(obj))
                {
                    return false;
                }
                return base.IsLookOutRange(obj);
            }

			public override bool RemoveInRange(InstanceZoneObject o)
			{
				if (IsLookOutRange(o))
				{
					m_RemovingList.Add(o.ID);
					OnLeaveView(o);

					return true;
				}

				return false;
			}

			internal void OnPlayerReviveTeamInfoEventR2B(TeamInfoEventR2B team)
            {
                if (team.UUIDList != null)
                {
                    //检测加入队伍//
                    foreach (var uuid in team.UUIDList)
                    {
                        if (!string.IsNullOrEmpty(uuid) && !team_info.Contains(uuid))
                        {
                            InstancePlayer tu = base.Zone.getPlayerByUUID(uuid);
                            if (tu != null)
                            {
                                team_info.Add(uuid);
                                base.ForceAddObjectInView(tu);
                            }
                        }
                    }
                    //检测离开队伍//
                    team_removing.Clear();
                    foreach (var uuid in team_info)
                    {
                        if (!team.UUIDList.Contains(uuid))
                        {
                            team_removing.Add(uuid);
                        }
                    }
                    if (team_removing.Count > 0)
                    {
                        foreach (var uuid in team_removing)
                        {
                            team_info.Remove(uuid);
                        }
                    }
                }
            }
        }

        //------------------------------------------------------------------------------------------------------------
    }

}