Unity中接收服务器消息并广播事件的实现

最近接触的项目，是一个棋牌游戏，棋牌游戏需要在前端进行一些操作，然后向服务器发送数据包，在服务器接收到客户端的数据后，会在服务端进行一系列的判断之后，然后发送给客户端一个返回数据，客户端接收到这个返回数据后，需要作出一系列的响应。那么，就针对于这一整个服务器<--->客户端的通讯过程，看看是如何来实现的。

1. 报文（消息结构体）的商定。

　客户端向服务器发送消息，客户端接收服务器的消息，都是一系列的数据，那么这些数据到底是代表了什么，应该以什么样的方式解读？这些东西，在刚开始开发的时候，客户端与服务器就需要定好相关的内容，这个东西呢，也就是消息报文啦！在消息报文中，会定义一些常用的东西：

　　a、游戏状态

　　b、游戏通讯协议定义

　　c、游戏具体的数据包结构

    /// <summary>
    /// 游戏状态定义
    /// </summary>
    public enum GameState : byte
    {
        GS_WAIT_SETGAME = 0,

        GS_WAIT_AGREE = 1,

        GS_NOTE_STATE = 20,
    }

    /// <summary>
    /// 游戏通讯协议定义
    /// </summary>
    public struct ProtocolID
    {
        public const int S_C_IS_SUPER_USER = 78;//超端用户消息
        public const int C_S_SUPER_SET = 79;//超端设置
        public const int S_C_SUPER_SET_RESULT = 80;//超端设置结果
    }

 /// <summary>
    ///游戏基础数据
    /// </summary>
    [System.Serializable]
    [StructLayout(LayoutKind.Sequential, Pack = ClientPlat.PlatFormConfig.HallPack)]
    public struct GameStationBase
    {
        /// <summary>
        ///上庄列表
        /// </summary>
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = GameConst.PlayerCount)]
        public byte[] byZhuangList;
        /// <summary>
        /// 路子信息
        /// </summary>
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = GameConst.GameMaxCount)]
        public LuziData[] TLuziData;

        public int iXiaZhuTime;        /// 下注时间                    
        public int iKaiPaiTime;        /// 开牌时间    
        public int iFreeTime;          /// 空闲时间    
        public int iShowWinTime;       /// 显示中奖时间
        public int iNtStation;         //庄家位置
        public int iNtPlayCount;       //庄家坐庄次数
        public long i64NtMoney;         //庄家金币
        public long i64NtWinMoney;      //庄家输赢情况
        public long i64UserWin;         //个人输赢
        public long i64MyMoney;         //个人金币数 -从服务端发送过去
        public long i64UserMaxNote;         ///玩家最大下注数
        public long i64ShangZhuangLimit; /// 上庄需要的最少金币

    }

说明：消息报文需要严格遵循前后关系，如果客户端与服务器消息报文顺序不一致，那么会导致数据混乱。

2. 消息报文确定以后，需要根据消息报文脚本中确定的ProtocolID来定义对应的事件，而且这些事件都会实现某一个接口，方便事件中心触发。

 public class GameStationBase_Event : IEvent
    {
        public Enum EventType
        {
            get
            {
                return DataEventID.GameStationBase;
            }
        }

        public GameStationBase data;

        public GameStationBase_Event(GameStationBase _data)
        {
            data = _data;
        }

        public virtual string ToSring()
        {
            string msg = string.Format("EventType:{0}", DataEventID.GameStationBase.ToString());
            return msg;
        }

        public void DestroySelf()
        {
        }
    }

　　a、从上面的代码可以看到，这个GameStationBase_Event 类实现了接口IEvent，并且实现了它的DestroySelf方法，这样的好处后面点儿会讲到。

　　b、GameStationBase_Event 有一个public的枚举类型EventType 变量，并且直接返回的就是 消息报文中的“游戏通讯协议定义”，这样一来，GameStationBase_Event 就与“游戏通讯协议定义”中的每一个枚举一一对应。

　　c、GameStationBase_Event还有一个 GameStationBase 类型的变量data，同时还有一个有参的构造器，直接初始化变量data，这样一来，GameStationBase_Event 就与“游戏具体的数据包结构”一一对应了。

　　废话了这么多，其实也就是一句话，一个 事件类，对应着一个游戏通讯协议与一个消息结构体，并且实现了一个通用的接口IEvent。

3、既然消息该如何发送，该如何接受解析已经定义好了，那么接下来是不是就该发送接受消息了呢？没错，接下来，就开始定义我们向服务器发送消息时该做些什么，接收到服务器的消息时，我们又该做些什么。

　　接下来，顶一个消息处理脚本，叫做 GameLogicTable，至于为什么叫这个，我也不知道 - -！

　　

　　d、其它的东西，比如来个静态的实例啊什么的，见代码：

 public class GameLogicTable : GameLogicBase
    {

       //声明一个静态实例
        private static GameLogicTable instance;
      //公有的静态实例获取方法
        public static GameLogicTable Instance
        {
            get
            {
                if (instance == null)
                {
                    instance = new GameLogicTable(0, 180);
                }
                return instance;
            }

        }

/// <summary>
        /// 通讯协议（服务器==》客户端）
        /// </summary>
        /// <param name="data"></param>
        /// <param name="bAssistantID"></param>
        private void ProcessGameLogic(byte[] data, uint bAssistantID)
        {
            //Debug.LogError("========数据接受处理=======>>" + bAssistantID.ToString());
            switch (bAssistantID)
            {
                case ProtocolID.S_C_APPLY_ZHUANG_RESULT:
                    {
                        S_C_ApplyZhuangResult ndata = new S_C_ApplyZhuangResult();
                        ndata = (S_C_ApplyZhuangResult)HNNetToolKit.Instance.BytesToStruct(data, ndata.GetType());
                        ApplyZhuangResult_Event evt = new ApplyZhuangResult_Event(ndata);
                        EventCenter.Instance.TriggerEvent(evt);
                    }
                    break;
                default:
                break;
               }
         }
/// <summary>
        /// 初始化游戏
        /// </summary>
        /// <param name="data">Data.</param>
        public void InitGameState(byte[] data)
        {

            GameState gs = (GameState)base.GameStatus;
            //Debug.LogError("=========数据接收=========>>"+ gs.ToString());


            switch (gs)
            {
                case GameState.GS_WAIT_SETGAME://无庄等待状态
                case GameState.GS_WAIT_AGREE:
                case GameState.GS_WAIT_NEXT:
                    {
                        GameStationBase pState = new GameStationBase();
                        if (!HNNetToolKit.Instance.AssertSize(data.Length, pState.GetType())) return;
                        pState = (GameStationBase)HNNetToolKit.Instance.BytesToStruct(data, pState.GetType());
                        GameStationBase_Event evt = new GameStationBase_Event(pState);
                        EventCenter.Instance.TriggerEvent(evt);  
                    }
                    break;
             }
        }        
/// <summary>
        /// 通讯协议（客户端==》服务端）
        /// </summary>
        #region

        //超端设置
        public void SuperSet(SuperUserSetData node)
        {
            SendData(ProtocolID.C_S_SUPER_SET,node);
        }

　　a、客户端--->服务端：向客户端发送一个消息ID，然后附上对应结构的数据node。

　　b、服务端--->客户端：根据接收到的消息ID，来做出对应的处理：

　　　　1.新建一个对应消息ID的数据报文 ndata；

　　　　2.将接受到的消息data的内容赋值给ndata；

　　　　3.新建一个对应消息ID的 事件类，并且将ndata作为参数传递给构造器。

　　　　4.使用事件中心，触发事件。（为什么不在这里处理，还要添加事件呢？）

4. 现在虽然定义好了收到消息与发送消息的行为，那么现在还差一个东西，那就是接受到服务器消息时，触发事件的EventCenter，这个EventCenter的作用很简单，就是让需要监听服务器消息的地方可以注册监听，然后当服务器发送对应消息时，就触发事件即可。那么这个EventCenter是如何设计的呢？

　　a、首先，增加一个Dictionary<enum,IEventHandlerManger> 类型的 eventHandlers，用来保存消息ID与对应 要触发的 方法。

　　b、然后，增加一个HNSafeQueue<IEvent> 类型eventQueue，用来保存需要触发的事件列表。

　　c、写一个public的Addlistener(enum,IEventHandlerManger)方法，用于事件的注册

　　d、写一个public的TriggerEvent(IEvent eve)方法，用于触发事件。在这个TriggerEvent方法中，其实就是将eve传入到eventQueue队列中，等待被触发。

　　e、写一个BroadcastEvent()方法，该方法就是将eventQueue队列中的eve事件一个个取出，然后调用封装好的事件触发方法触发事件回调。

　　e、在该脚本的Updata() 方法中，一直调用BroadcastEvent()方法。

　　f、其它一些逻辑处理，例如初始化啦、清空啦，删除事件注册啦等等，这里就不一一介绍了。

public class EventCenter : HNBehaviourSingleton<EventCenter>, IEventCenter
    {
        /// <summary>
        /// 保存事件监听处理列表，对应说明a
        /// </summary>
        private Dictionary<Enum, IEventHandlerManger> eventHandlers = new Dictionary<Enum, IEventHandlerManger>();

 /// <summary>
        /// 事件队列，对应说明b
        /// </summary>
        private HNSafeQueue<IEvent> eventQueue = new HNSafeQueue<IEvent>();

//对应说明f
 public void Update()
        {
            BoardCastEvent();
        }

//广播事件方法，对应说明中的e
   public void BoardCastEvent()
        {
            if ( eventQueue.Count < 1 )
            {
                return;
            }
            IEvent evt = eventQueue.Dequeue();
            BoardCastEvent(evt);
        }
//触发事件方法，对应说明中的d
public void TriggerEvent(IEvent evt)
        {
            string msg = string.Format("TriggerEvent :{0}", evt.ToSring());
            HNLogger.Log(msg);
            this.eventQueue.Enqueue(evt);
        }

//注册事件监听方法
        public bool AddEventListener(Enum eventType, EventHandle eventHandle, bool isPermanently = false)
        {
            bool flag = false;
            if ( !this.eventHandlers.ContainsKey(eventType) )
            {
                this.eventHandlers[eventType] = new EventReceiver();
             }
             flag = this.eventHandlers[eventType].AddHandler(eventHandle);
            }
            return flag;
        }

5.到了这里，其实就可以知道为什么在 定义事件类的时候，需要让事件类来实现IEvent接口了，因为当接收到服务器消息时，会通过EventCenter的 TriggerEvent(IEvent eve)方法将接受到的数据转化为对应的事件类，然后加入到eventQueue队列中，而加入

eventQueue队列，则需要是IEvent接口类型的方可，所以定义事件类型的时候必须要实现IEvent接口方可。

最后附上一张关系图：