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

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

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

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

　　a、游戏状态

　　b、游戏通讯协议定义

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

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

         GS_WAIT_AGREE = ,

         GS_NOTE_STATE = ,
     }

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

  /// <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(, );
                 }
                 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 <  )
             {
                 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接口方可。

最后附上一张关系图：