2. 程式人生 > >《Unity 3D遊戲客戶端基礎框架》訊息系統

《Unity 3D遊戲客戶端基礎框架》訊息系統

阿新 • • 發佈：2019-01-09

功能分析：

首先，我們必須先明確一個訊息系統的核心功能：

  • 一個通用的事件監聽器
  • 管理各個業務監聽的事件型別（註冊和解綁事件監聽器）
  • 全域性廣播事件
  • 廣播事件所傳引數數量和資料型別都是可變的（數量可以是 0~3，資料型別是泛型）

設計思路：

清楚了上述的幾個要求之後，我們不難自行定製一個業務層的訊息系統，即在訊息系統初始化時將每個模組繫結的訊息列表，根據訊息型別分類（用一個 string 型別的資料類標識），即建立一個字典 Dictionary<string,List<Model>> 每條訊息觸發時需要通知的模組列表，即某條訊息觸發，遍歷字典中繫結的模組列表，然後有兩種選擇方案：

  • 假如模組是與 gameObject 繫結的繼承自 MonoBehaviour 的指令碼，通過 Unity 原生的向指定模組傳送訊息的介面 gameObject.SendMessage(message) 傳送訊息，模組用則用 public void getMessage(string message) 函式接收訊息；

  • 假如模組是獨立的 C# 例項，則可以給模組設計一個基類，基類中有一個虛構函式，在具體模組中重寫這個函式，這樣訊息中心要想模組傳送觸發訊息時，直接將模組字典中繫結的模組引用強轉為基類型別，然後呼叫該虛構函式。

然而，這樣的 DIY 的訊息管理系統最常見的問題就是：模組已經銷燬了，但在字典中的引用還在，那麼訊息要傳遞給模組的時候，就會觸發 MissingReferenceException

或者 NullReferenceException 這類空引用錯誤。

外掛簡介：

Advanced CSharp Messenger 是一個 C# 高階版本的訊息傳遞系統 。它將會在載入一個新的 level 後自動清理其事件表。這將防止程式設計師意外地呼叫被毀壞的方法，從而將有助於防止很多 MissingReferenceExceptions。此訊息傳遞系統基於杆海德 CSharpMessenger 和馬格努斯沃爾費爾特的CSharpMessenger 擴充套件。

核心功能：

1.註冊一個事件監聽器：

Messenger.AddListener<T>( "訊息型別標識"
 
, OnCallback);
//事件回撥函式
void OnCallback(T data){

}

監聽事件可以帶參也可不帶參，引數型別是泛型，既可以傳遞基礎資料型別，也可以傳遞 gameObject 物件，當然兩種情況屬於完全不同的時間，用一個字串來表示事件的型別，OnCallback 是事件出發時的回撥函式，回撥函式的引數表與監聽格式一致。

2.取消註冊事件監聽器：

這裡需要注意的就是與註冊時的引數格式完全一致，只是把 AddListener 改成 RemoveListener：

Messenger.RemoveListener<T>( "訊息型別標識", OnCallback);

3.廣播事件：

//不帶參
Messenger.Broadcast( "訊息型別標識");
//帶參
Messenger.Broadcast<T>( "訊息型別標識", data1);

第一個引數是事件型別標識，後面的引數表是與 <T> 中指定的資料型別對應的回傳資料。

外掛引入：

只需在當前專案組新增一下兩個指令碼，即可開始使用 Advanced CSharp Messenger 這個訊息管理器來管理我們專案的訊息了。

Callback.cs

public delegate void Callback();
public delegate void Callback<T>(T arg1);
public delegate void Callback<T, U>(T arg1, U arg2);
public delegate void Callback<T, U, V>(T arg1, U arg2, V arg3);

Messenger.cs

/*
 * Advanced C# messenger by Ilya Suzdalnitski. V1.0
 * 
 * Based on Rod Hyde's "CSharpMessenger" and Magnus Wolffelt's "CSharpMessenger Extended".
 * 
 * Features:
    * Prevents a MissingReferenceException because of a reference to a destroyed message handler.
    * Option to log all messages
    * Extensive error detection, preventing silent bugs
 * 
 * Usage examples:
    1. Messenger.AddListener<GameObject>("prop collected", PropCollected);
       Messenger.Broadcast<GameObject>("prop collected", prop);
    2. Messenger.AddListener<float>("speed changed", SpeedChanged);
       Messenger.Broadcast<float>("speed changed", 0.5f);
 * 
 * Messenger cleans up its evenTable automatically upon loading of a new level.
 * 
 * Don't forget that the messages that should survive the cleanup, should be marked with Messenger.MarkAsPermanent(string)
 * 
 */

//#define LOG_ALL_MESSAGES
//#define LOG_ADD_LISTENER
//#define LOG_BROADCAST_MESSAGE
#define REQUIRE_LISTENER

using System;
using System.Collections.Generic;
using UnityEngine;

static internal class Messenger {
    #region Internal variables

    //Disable the unused variable warning
#pragma warning disable 0414
    //Ensures that the MessengerHelper will be created automatically upon start of the game.
    static private MessengerHelper messengerHelper = ( new GameObject("MessengerHelper") ).AddComponent< MessengerHelper >();
#pragma warning restore 0414

    static public Dictionary<string, Delegate> eventTable = new Dictionary<string, Delegate>();

    //Message handlers that should never be removed, regardless of calling Cleanup
    static public List< string > permanentMessages = new List< string > ();
    #endregion
    #region Helper methods
    //Marks a certain message as permanent.
    static public void MarkAsPermanent(string eventType) {
#if LOG_ALL_MESSAGES
        Debug.Log("Messenger MarkAsPermanent \t\"" + eventType + "\"");
#endif

        permanentMessages.Add( eventType );
    }


    static public void Cleanup()
    {
#if LOG_ALL_MESSAGES
        Debug.Log("MESSENGER Cleanup. Make sure that none of necessary listeners are removed.");
#endif

        List< string > messagesToRemove = new List<string>();

        foreach (KeyValuePair<string, Delegate> pair in eventTable) {
            bool wasFound = false;

            foreach (string message in permanentMessages) {
                if (pair.Key == message) {
                    wasFound = true;
                    break;
                }
            }

            if (!wasFound)
                messagesToRemove.Add( pair.Key );
        }

        foreach (string message in messagesToRemove) {
            eventTable.Remove( message );
        }
    }

    static public void PrintEventTable()
    {
        Debug.Log("\t\t\t=== MESSENGER PrintEventTable ===");

        foreach (KeyValuePair<string, Delegate> pair in eventTable) {
            Debug.Log("\t\t\t" + pair.Key + "\t\t" + pair.Value);
        }

        Debug.Log("\n");
    }
    #endregion

    #region Message logging and exception throwing
    static public void OnListenerAdding(string eventType, Delegate listenerBeingAdded) {
#if LOG_ALL_MESSAGES || LOG_ADD_LISTENER
        Debug.Log("MESSENGER OnListenerAdding \t\"" + eventType + "\"\t{" + listenerBeingAdded.Target + " -> " + listenerBeingAdded.Method + "}");
#endif

        if (!eventTable.ContainsKey(eventType)) {
            eventTable.Add(eventType, null );
        }

        Delegate d = eventTable[eventType];
        if (d != null && d.GetType() != listenerBeingAdded.GetType()) {
            throw new ListenerException(string.Format("Attempting to add listener with inconsistent signature for event type {0}. Current listeners have type {1} and listener being added has type {2}", eventType, d.GetType().Name, listenerBeingAdded.GetType().Name));
        }
    }

    static public void OnListenerRemoving(string eventType, Delegate listenerBeingRemoved) {
#if LOG_ALL_MESSAGES
        Debug.Log("MESSENGER OnListenerRemoving \t\"" + eventType + "\"\t{" + listenerBeingRemoved.Target + " -> " + listenerBeingRemoved.Method + "}");
#endif

        if (eventTable.ContainsKey(eventType)) {
            Delegate d = eventTable[eventType];

            if (d == null) {
                throw new ListenerException(string.Format("Attempting to remove listener with for event type \"{0}\" but current listener is null.", eventType));
            } else if (d.GetType() != listenerBeingRemoved.GetType()) {
                throw new ListenerException(string.Format("Attempting to remove listener with inconsistent signature for event type {0}. Current listeners have type {1} and listener being removed has type {2}", eventType, d.GetType().Name, listenerBeingRemoved.GetType().Name));
            }
        } else {
            throw new ListenerException(string.Format("Attempting to remove listener for type \"{0}\" but Messenger doesn't know about this event type.", eventType));
        }
    }

    static public void OnListenerRemoved(string eventType) {
        if (eventTable[eventType] == null) {
            eventTable.Remove(eventType);
        }
    }

    static public void OnBroadcasting(string eventType) {
#if REQUIRE_LISTENER
        if (!eventTable.ContainsKey(eventType)) {
            throw new BroadcastException(string.Format("Broadcasting message \"{0}\" but no listener found. Try marking the message with Messenger.MarkAsPermanent.", eventType));
        }
#endif
    }

    static public BroadcastException CreateBroadcastSignatureException(string eventType) {
        return new BroadcastException(string.Format("Broadcasting message \"{0}\" but listeners have a different signature than the broadcaster.", eventType));
    }

    public class BroadcastException : Exception {
        public BroadcastException(string msg)
            : base(msg) {
        }
    }

    public class ListenerException : Exception {
        public ListenerException(string msg)
            : base(msg) {
        }
    }
    #endregion

    #region AddListener
    //No parameters
    static public void AddListener(string eventType, Callback handler) {
        OnListenerAdding(eventType, handler);
        eventTable[eventType] = (Callback)eventTable[eventType] + handler;
    }

    //Single parameter
    static public void AddListener<T>(string eventType, Callback<T> handler) {
        OnListenerAdding(eventType, handler);
        eventTable[eventType] = (Callback<T>)eventTable[eventType] + handler;
    }

    //Two parameters
    static public void AddListener<T, U>(string eventType, Callback<T, U> handler) {
        OnListenerAdding(eventType, handler);
        eventTable[eventType] = (Callback<T, U>)eventTable[eventType] + handler;
    }

    //Three parameters
    static public void AddListener<T, U, V>(string eventType, Callback<T, U, V> handler) {
        OnListenerAdding(eventType, handler);
        eventTable[eventType] = (Callback<T, U, V>)eventTable[eventType] + handler;
    }
    #endregion

    #region RemoveListener
    //No parameters
    static public void RemoveListener(string eventType, Callback handler) {
        OnListenerRemoving(eventType, handler);   
        eventTable[eventType] = (Callback)eventTable[eventType] - handler;
        OnListenerRemoved(eventType);
    }

    //Single parameter
    static public void RemoveListener<T>(string eventType, Callback<T> handler) {
        OnListenerRemoving(eventType, handler);
        eventTable[eventType] = (Callback<T>)eventTable[eventType] - handler;
        OnListenerRemoved(eventType);
    }

    //Two parameters
    static public void RemoveListener<T, U>(string eventType, Callback<T, U> handler) {
        OnListenerRemoving(eventType, handler);
        eventTable[eventType] = (Callback<T, U>)eventTable[eventType] - handler;
        OnListenerRemoved(eventType);
    }

    //Three parameters
    static public void RemoveListener<T, U, V>(string eventType, Callback<T, U, V> handler) {
        OnListenerRemoving(eventType, handler);
        eventTable[eventType] = (Callback<T, U, V>)eventTable[eventType] - handler;
        OnListenerRemoved(eventType);
    }
    #endregion

    #region Broadcast
    //No parameters
    static public void Broadcast(string eventType) {
#if LOG_ALL_MESSAGES || LOG_BROADCAST_MESSAGE
        Debug.Log("MESSENGER\t" + System.DateTime.Now.ToString("hh:mm:ss.fff") + "\t\t\tInvoking \t\"" + eventType + "\"");
#endif
        OnBroadcasting(eventType);

        Delegate d;
        if (eventTable.TryGetValue(eventType, out d)) {
            Callback callback = d as Callback;

            if (callback != null) {
                callback();
            } else {
                throw CreateBroadcastSignatureException(eventType);
            }
        }
    }

    //Single parameter
    static public void Broadcast<T>(string eventType, T arg1) {
#if LOG_ALL_MESSAGES || LOG_BROADCAST_MESSAGE
        Debug.Log("MESSENGER\t" + System.DateTime.Now.ToString("hh:mm:ss.fff") + "\t\t\tInvoking \t\"" + eventType + "\"");
#endif
        OnBroadcasting(eventType);

        Delegate d;
        if (eventTable.TryGetValue(eventType, out d)) {
            Callback<T> callback = d as Callback<T>;

            if (callback != null) {
                callback(arg1);
            } else {
                throw CreateBroadcastSignatureException(eventType);
            }
        }
    }

    //Two parameters
    static public void Broadcast<T, U>(string eventType, T arg1, U arg2) {
#if LOG_ALL_MESSAGES || LOG_BROADCAST_MESSAGE
        Debug.Log("MESSENGER\t" + System.DateTime.Now.ToString("hh:mm:ss.fff") + "\t\t\tInvoking \t\"" + eventType + "\"");
#endif
        OnBroadcasting(eventType);

        Delegate d;
        if (eventTable.TryGetValue(eventType, out d)) {
            Callback<T, U> callback = d as Callback<T, U>;

            if (callback != null) {
                callback(arg1, arg2);
            } else {
                throw CreateBroadcastSignatureException(eventType);
            }
        }
    }

    //Three parameters
    static public void Broadcast<T, U, V>(string eventType, T arg1, U arg2, V arg3) {
#if LOG_ALL_MESSAGES || LOG_BROADCAST_MESSAGE
        Debug.Log("MESSENGER\t" + System.DateTime.Now.ToString("hh:mm:ss.fff") + "\t\t\tInvoking \t\"" + eventType + "\"");
#endif
        OnBroadcasting(eventType);

        Delegate d;
        if (eventTable.TryGetValue(eventType, out d)) {
            Callback<T, U, V> callback = d as Callback<T, U, V>;

            if (callback != null) {
                callback(arg1, arg2, arg3);
            } else {
                throw CreateBroadcastSignatureException(eventType);
            }
        }
    }
    #endregion
}

//This manager will ensure that the messenger's eventTable will be cleaned up upon loading of a new level.
public sealed class MessengerHelper : MonoBehaviour {
    void Awake ()
    {
        DontDestroyOnLoad(gameObject);  
    }

    //Clean up eventTable every time a new level loads.
    public void OnLevelWasLoaded(int unused) {
        Messenger.Cleanup();
    }
}

當然，假如為了指令碼管理方便，也可將兩部分程式碼都合併在同一個指令碼中，而且事件繫結的 key 都是以一個 string 來標誌的，為了統一管理訊息，這裡我又建立了一個指令碼 Msg_Define.cs：

public class Msg_Define{
    public const string MSG_START = "MSG_START";
    public const string MSG_AWAKE = "MSG_AWAKE";
}

測試例項：

這裡我們可以直接在一個測試場景中新建一個C#測試指令碼，並都繫結到場景中的相機上（保證點選Unity執行時，指令碼會處於工作狀態），然後通過在指令碼中廣播一個事件（以多種傳參形式），然後在指令碼自身進行監聽，如此完成自發自收的測試：

指令碼 TestMsg.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class TestMsg : MonoBehaviour {

    void Awake()
    {
        //監聽訊息
        Messenger.AddListener(Msg_Define.MSG_AWAKE, OnAwakeCall);
        Messenger.AddListener<int>(Msg_Define.MSG_START, OnStartCall);
        //傳送不帶引數廣播
        Messenger.Broadcast(Msg_Define.MSG_AWAKE);
    }

    void Start()
    {
        //傳送帶引數廣播
        Messenger.Broadcast<int>(Msg_Define.MSG_START,666);
    }

    void OnDestroy()
    {
        //移除監聽
        Messenger.RemoveListener(Msg_Define.MSG_AWAKE, OnAwakeCall);
        Messenger.RemoveListener<int>(Msg_Define.MSG_START, OnStartCall);
    }
    //訊息回撥
    void OnAwakeCall()
    {
        Debug.logger.Log("awake");
    }

    void OnStartCall(int num)
    {
        Debug.logger.Log("start"+num);
    }
}

執行 Unity，可以在 Unity 的 Console 面板中看到輸出結果：

awake
UnityEngine.Logger:Log(Object)
start666
UnityEngine.Logger:Log(Object)

參考資料：

相關推薦

《Unity 3D遊戲客戶端基礎框架》訊息系統

功能分析： 首先，我們必須先明確一個訊息系統的核心功能： 一個通用的事件監聽器 管理各個業務監聽的事件型別（註冊和解綁事件監聽器） 全域性廣播事件 廣播事件所傳引數數量和資料型別都是可變的（數量可以是 0~3，資料型別是泛型） 設計思路： 清楚了

《Unity 3D遊戲客戶端基礎框架》概述

框架概述： 做了那麼久的業務開發，也做了一年多的核心戰鬥開發，最近想著自己倒騰一套遊戲框架，當然暫不涉及核心玩法型別和戰鬥框架，核心戰鬥的設計要根據具體的遊戲型別而定製，這裡只是一些通用的基礎系統的框架搭建，其中包括： UI框架（NGUI + MVC） 訊

《Unity 3D遊戲客戶端基礎框架》protobuf 導excel表格資料

前言：        之前使用NPOI外掛編寫的導表工具，其實就是直接將資料進行序列化，解析時還需要進行反序列化，步驟比較繁複，最近看到Google的一個開源的專案protobuf，不僅可以用於進行ex

《Unity 3D遊戲客戶端基礎框架》 protobuf網路框架

前言：        protobuf是google的一個開源專案，主要的用途是：1.資料儲存（序列化和反序列化），這個功能類似xml和json等；2.製作網路通訊協議；一、資源下載：二、資料儲存：        C#語言方式的導表和解析過程，在之前的篇章中已經有詳細的闡述：

《Unity 3D遊戲客戶端基礎框架》多執行緒非同步 Socket 框架構建

引言： 之前寫過一個 demo 案例大致講解了 Socket 通訊的過程，並和自建的伺服器完成連線和簡單的資料通訊，詳細的內容可以檢視 Unity3D —— Socket通訊(C#)。但是在實際專案應用的過程中，這個 demo 的實現方式顯得異常簡陋，而且對應

遊戲客戶端面試（Unity）

推薦閱讀：  我的CSDN  我的部落格園  QQ群：704621321 一。最開始的兩家公司筆試面試題目       

Lua用於遊戲運行期熱更（不重啟遊戲客戶端）

服務端 道理 IT path 客戶 內存 每次 調用 清除 lua在Unity的熱更新中，一般是每次客戶端啟動的時候檢查是否有更新，然後加載。 如果要在運行期熱更，跟服務端做不停服熱更（比如java 用類構造啟動java腳本本身，或者luaJ）是一個道理。

2.GUI控件的使用 --《UNITY 3D 遊戲開發》筆記

div info art color text tar scrip 寬高 執行 1.Label 控件 編寫腳本文件，直接綁定在main camera上 public class labelScript : MonoBehaviour { //設定一個值來接收外部

3D遊戲的數學基礎

分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！        

Netty 一個非阻塞的客戶端/伺服器框架

分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！        

阿里雲MQTT 客戶端收發 MQTT 訊息（使用一個裝置控制另一個裝置）

https://help.aliyun.com/document_detail/44874.html?spm=a2c4g.11186623.6.721.qxegRK 1保證只有一組使用者AccessKey，怕衝突其他的可暫時禁用 (踩過的坑：域名必須是這個格式tcp://mqtt-c

Unity 3d遊戲開發者該掌握哪些內容？

視頻 內容 自學 開發者 真的 來看 文檔 shader 遊戲開發 unity3d學習該掌握哪些內容？ unity3d作為42%的用戶使用率，在VR，AR，MR，遊戲及虛擬仿真領域廣泛被使用。Unity3D入門容易，真的要精通，那是相當難的。不過，我們還是來看看想成為uni

目錄 1.1. Vue是什麼？？客戶端mvc框架，，功能類似springmvc 1 1.2. Why？為什麼使用它？？ 1 1.3. 包括哪些元件與內部構成與原理 1 2. Howto 怎麼使用 2

目錄 1.1. Vue是什麼？？客戶端mvc框架，，功能類似springmvc 1 1.2. Why？為什麼使用它？？ 1 1.3. 包括哪些元件與內部構成與原理 1 2. Howto 怎麼使用 2 2.1. 引入vue。Js 2 2.2. 建立模板 2 2.3. 建立測

onvif開發之利用gSOAP生成onvif客戶端程式碼框架

cd gsoap-2.8 ./configure make sudo make install 命令列模式下敲入命令：wsdl2h -V 檢視gSOAP軟體版本，有版本出現則安裝成功。 2. 利用gSOAP生成onvif客戶端程式碼框架 2.1 在當前目錄下

python搭建伺服器實現兩個Android客戶端間收發訊息

python伺服器 # coding:utf-8 import socket import threading import time def handle_client(client_socket, client_id): """處理客戶端請求

【Unity 3D 遊戲開發】Unity3D 入門

一. 工作區域詳解1. Scence檢視 (場景設計面板)scence檢視簡介 : 展示建立的遊戲物件, 可以對所有的遊戲物件進行 移動, 操作 和 放置;-- 示例 : 建立一個球體, 控制攝像機,

2018騰訊遊戲客戶端實習-電話面試過程記錄

電話面試是昨天，結束之後稍微總結了一下，今天寫篇文章記錄過程和內容。 首先在前天下午的時候，突然收到了一封簡訊，內容開頭是： XXX:你好，我是騰訊技術面試官（深圳），請問明天下午或晚上。。（略） 我一看，我不是XXX啊，雖然投了簡歷，但是筆試都沒

u3d遊戲客戶端架構

主要是mvc架構， M層為資料層，兩個用途：1儲存資料；2傳送資料更新資訊； V層為檢視層，兩個用途：1接受使用者從介面上的操作；2根據M層的資料顯示相應的介面； C層為控制層，兩個用途：1處理和介面無關的程式碼邏輯；2接受和處理網路資料； 繼續…… 按照自己的經驗，遊戲中

2018騰訊遊戲客戶端崗位暑期實習生面試

1. 流程 網申 線上筆試 面試 offer 2. 網申和筆試 網申和線上筆試不用多說，過了線上筆試才可以進入到關鍵的面試環節，筆試的話倒不是很難，基礎紮實就行，由選擇和程式設計題，其中程式設計題3題，300分，我對了180分，進入到了面試。騰訊會在很多城市

簡單Unity 3D遊戲加密dll檔案提取

大多數遊戲都是使用Unity 3D做的，我們逆向分析主要分析\assets\bin\Data\Managed中的Assembly-CSharp.dll檔案，當我們用.NET Reflector 或者dnSpy 開啟Assembly-CSharp.dll檔案時，有時候會發現什麼資訊也看不到