WSHCommon/Common/CommonTickBattle/Battle/Local/BattleLocal.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using CommonAI.Zone.ZoneEditor;
using CommonLang;
using CommonAI.Zone.Helper;
using CommonLang.Concurrent;
using CommonLang.Log;

namespace CommonTickBattle.Battle.Local
{
    public class BattleLocal : Battle
    {
        private readonly IConnector mConnector;

        public BattleLocal(EditorTemplates data_root, TBConfig cfg, IConnector connector)
            : base(data_root, cfg)
        {
            this.mConnector = connector;
            this.mConnector.OnReceived += OnReceivedMessage;
        }

        protected override void OnDispose()
        {
            this.mConnector.OnReceived -= OnReceivedMessage;
            this.dispose_waiting_request();
            base.OnDispose();
        }
        public override void Update()
        {
            base.Update();
            this.check_request_timeout();
        }

        //------------------------------------------------------------------------------------------------------------------------------
        #region Receive

        /// <summary>
        /// 收到服务器发来的协议
        /// </summary>
        /// <param name="connector"></param>
        /// <param name="req"></param>
        protected virtual void OnReceivedMessage(IConnector connector, TBMessage req)
        {
            if (req is TBResponse)
            {
                this.on_received_response(req as TBResponse);
            }
            else if (req is TBNotify)
            {
                this.OnReceivedTBNotify(req as TBNotify);
            }
            else if (req is TBSyncTime)
            {
                this.OnReceivedTBSyncTime(req as TBSyncTime);
            }
            else if (req is TBSyncHistory)
            {
                this.OnReceivedTBSyncHistory(req as TBSyncHistory);
            }
        }
        protected virtual void OnReceivedTBNotify(TBNotify ntf)
        {
            base.PushAction(ntf.action, ntf.action_tick);
        }
        protected virtual void OnReceivedTBSyncTime(TBSyncTime syn)
        {

        }
        protected virtual void OnReceivedTBSyncHistory(TBSyncHistory syn)
        {

        }

        #endregion
        //------------------------------------------------------------------------------------------------------------------------------
        #region Request

        /// <summary>
        /// 发送请求
        /// </summary>
        /// <param name="msg"></param>
        /// <param name="handler"></param>
        /// <param name="timeout"></param>
        /// <param name="timeOutMS"></param>
        /// <returns></returns>
        public Request SendRequest(CommonAI.Zone.Action action, Action<Request> handler = null, Action<Request> timeout = null)
        {
            Request req = new Request(this, action, handler, timeout);
            lock (mListenRequests)
            {
                mListenRequests.Add(req.MessageID, req);
            }
            mConnector.Send(req.RequestMessage);
            return req;
        }

        private readonly HashMap<int, object> mListenRequests = new HashMap<int, object>();
        private readonly AtomicInteger mMessageIDGen = new AtomicInteger(1);

        private void dispose_waiting_request()
        {
            lock (mListenRequests)
            {
                foreach (Request req in mListenRequests.Values)
                {
                    req.onDispose();
                }
                mListenRequests.Clear();
            }
        }

        private void check_request_timeout()
        {
            long curTime = CUtils.CurrentTimeMS;
            lock (mListenRequests)
            {
                if (mListenRequests.Count > 0)
                {
                    using (var removing = ListObjectPool<Request>.AllocAutoRelease())
                    {
                        foreach (Request req in mListenRequests.Values)
                        {
                            if (req.IsTimeOut)
                            {
                                removing.Add(req);
                            }
                        }
                        if (removing.Count > 0)
                        {
                            foreach (Request remove in removing)
                            {
                                mListenRequests.RemoveByKey(remove.MessageID);
                                remove.onTimeout();
                            }
                        }
                    }
                }
            }
        }

        private bool on_received_response(TBResponse rsp)
        {
            Request request = null;
            lock (mListenRequests)
            {
                request = mListenRequests.RemoveByKey(rsp.MessageID) as Request;
            }
            if (request != null)
            {
                request.onRecivedMessage(rsp);
                return true;
            }
            return false;
        }

        public class Request
        {
            internal static Logger log = LoggerFactory.GetLogger("ZoneLayer.Request");

            private Action<Request> mHandler;
            private Action<Request> mTimeout;

            public BattleLocal Layer { get; private set; }
            public ulong SendTick { get; private set; }
            public ulong EndTick { get; private set; }
            public int MessageID { get; private set; }
            public TBRequest RequestMessage { get; protected set; }
            public TBResponse ResponseMessage { get; protected set; }

            public Request(BattleLocal client, CommonAI.Zone.Action action, Action<Request> handler = null, Action<Request> timeout = null)
            {
                this.Layer = client;
                this.RequestMessage = new TBRequest();
                this.RequestMessage.action = action;
                this.MessageID = RequestMessage.MessageID = client.mMessageIDGen.GetAndIncrement();
                this.SendTick = RequestMessage.send_tick = client.CurrentTick;
                this.EndTick = RequestMessage.action_tick = client.CurrentTick + client.RequestLaggingTick + client.ResponseLaggingTick;
                this.mHandler = handler;
                this.mTimeout = timeout;
            }

            public bool IsTimeOut
            {
                get { return Layer.CurrentTick > EndTick; }
            }

            internal void onDispose()
            {
                mHandler = null;
                mTimeout = null;
            }

            internal void onRecivedMessage(TBResponse msg)
            {
                ResponseMessage = msg;
                if (mHandler != null)
                {
                    try
                    {
                        mHandler.Invoke(this);
                    }
                    catch (Exception err)
                    {
                        log.Error(err.Message, err);
                    }
                }
                mHandler = null;
                mTimeout = null;
            }
            internal void onTimeout()
            {
                if (mTimeout != null)
                {
                    try
                    {
                        mTimeout.Invoke(this);
                    }
                    catch (Exception err)
                    {
                        log.Error(err.Message, err);
                    }
                }
                mHandler = null;
                mTimeout = null;
            }
        }
        #endregion
    }
}