WSHCommon/Common/CommonTickBattle/Battle/Host/BattleHost.cs

using CommonAI.Zone.ZoneEditor;
using CommonLang;

namespace CommonTickBattle.Battle.Host
{
    public class BattleHost : Battle
    {
        private HashMap<string, ISession> mPlayers = new HashMap<string, ISession>();

        public BattleHost(EditorTemplates data_root, TBConfig cfg)
            : base(data_root, cfg)
        {
        }
        protected override void OnDispose()
        {
            base.OnDispose();
            foreach (var player in mPlayers.Values)
            {
                player.OnReceived -= OnReceivedRequest;
            }
            mPlayers.Clear();
        }

        /// <summary>
        /// 增加一个玩家
        /// </summary>
        /// <param name="player"></param>
        public void BindSession(ISession player)
        {
            lock (this)
            {
                mPlayers.Add(player.PlayerUUID, player);
                player.OnReceived += OnReceivedRequest;
            }
        }

        /// <summary>
        /// 收到玩家操作消息
        /// </summary>
        /// <param name="player"></param>
        /// <param name="req"></param>
        protected virtual void OnReceivedRequest(ISession player, TBRequest req)
        {
            if (this.PushAction(req))
            {
                TBResponse rsp = new TBResponse();
                rsp.MessageID = req.MessageID;
                rsp.result = TBResponse.Result.OK;
                player.Send(rsp);

                TBNotify ntf = new TBNotify();
                ntf.action = req.action;
                ntf.action_tick = req.action_tick;
                ntf.player_uuid = player.PlayerUUID;
                this.Broadcast(ntf);
            }
            else
            {
                TBResponse rsp = new TBResponse();
                rsp.MessageID = req.MessageID;
                rsp.result = TBResponse.Result.TimeOut;
                player.Send(rsp);
            }
        }
        /// <summary>
        /// 广播操作消息
        /// </summary>
        /// <param name="ntf"></param>
        protected virtual void Broadcast(TBMessage ntf)
        {
            foreach (var p in mPlayers.Values)
            {
                p.Send(ntf);
            }
        }

        /// <summary>
        /// 想在未来某个时间点执行一个动作
        /// </summary>
        /// <param name="req"></param>
        /// <returns></returns>
        protected virtual bool PushAction(TBRequest req)
        {
            lock (this)
            {
                if (req.send_tick + this.RequestLaggingTick < this.CurrentTick)
                {
                    //如果客户端时间+延迟时间小于本地时间，表示客户端上传请求已超时//
                    log.ErrorFormat("客户端发送请求已超时 : CT={0} : {1}", req.send_tick, req.action);
                    return false;
                }
                else if (req.action_tick < (this.CurrentTick + this.ResponseLaggingTick))
                {
                    //如果执行动作时间，不够发送延迟时间，表示可能发送不成功，本次指令上传失败//
                    log.ErrorFormat("客户端请求动作时间已超时 : AT={0} : {1}", req.action_tick, req.action);
                    return false;
                }
                else
                {
                    return base.PushAction(req.action, req.action_tick);
                }
            }
        }
    }
}