Паттерн StateBus вместо MessageBus в Unity3D

using System;
using System.Collections.Generic;
 
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);
 
public enum MessengerMode {
    DONT_REQUIRE_LISTENER,
    REQUIRE_LISTENER,
}
 
 
static internal class MessengerInternal {
    static public Dictionary<string, Delegate> eventTable = new Dictionary<string, Delegate>();
    static public readonly MessengerMode DEFAULT_MODE = MessengerMode.DONT_REQUIRE_LISTENER;
 
    static public void OnListenerAdding(string eventType, Delegate listenerBeingAdded) {
        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 (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, MessengerMode mode) {
        if (mode == MessengerMode.REQUIRE_LISTENER && !eventTable.ContainsKey(eventType)) {
            throw new MessengerInternal.BroadcastException(string.Format("Broadcasting message {0} but no listener found.", eventType));
        }
    }
 
    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) {
        }
    }
}
 
 
// No parameters
static public class Messenger {
    private static Dictionary<string, Delegate> eventTable = MessengerInternal.eventTable;
 
    static public void AddListener(string eventType, Callback handler) {
        MessengerInternal.OnListenerAdding(eventType, handler);
        eventTable[eventType] = (Callback)eventTable[eventType] + handler;
    }
 
    static public void RemoveListener(string eventType, Callback handler) {
        MessengerInternal.OnListenerRemoving(eventType, handler);   
        eventTable[eventType] = (Callback)eventTable[eventType] - handler;
        MessengerInternal.OnListenerRemoved(eventType);
    }
 
    static public void Broadcast(string eventType) {
        Broadcast(eventType, MessengerInternal.DEFAULT_MODE);
    }
 
    static public void Broadcast(string eventType, MessengerMode mode) {
        MessengerInternal.OnBroadcasting(eventType, mode);
        Delegate d;
        if (eventTable.TryGetValue(eventType, out d)) {
            Callback callback = d as Callback;
            if (callback != null) {
                callback();
            } else {
                throw MessengerInternal.CreateBroadcastSignatureException(eventType);
            }
        }
    }
}
 
// One parameter
static public class Messenger<T> {
    private static Dictionary<string, Delegate> eventTable = MessengerInternal.eventTable;
 
    static public void AddListener(string eventType, Callback<T> handler) {
        MessengerInternal.OnListenerAdding(eventType, handler);
        eventTable[eventType] = (Callback<T>)eventTable[eventType] + handler;
    }
 
    static public void RemoveListener(string eventType, Callback<T> handler) {
        MessengerInternal.OnListenerRemoving(eventType, handler);
        eventTable[eventType] = (Callback<T>)eventTable[eventType] - handler;
        MessengerInternal.OnListenerRemoved(eventType);
    }
 
    static public void Broadcast(string eventType, T arg1) {
        Broadcast(eventType, arg1, MessengerInternal.DEFAULT_MODE);
    }
 
    static public void Broadcast(string eventType, T arg1, MessengerMode mode) {
        MessengerInternal.OnBroadcasting(eventType, mode);
        Delegate d;
        if (eventTable.TryGetValue(eventType, out d)) {
            Callback<T> callback = d as Callback<T>;
            if (callback != null) {
                callback(arg1);
            } else {
                throw MessengerInternal.CreateBroadcastSignatureException(eventType);
            }
        }
    }
}
 
 
// Two parameters
static public class Messenger<T, U> {
    private static Dictionary<string, Delegate> eventTable = MessengerInternal.eventTable;
 
    static public void AddListener(string eventType, Callback<T, U> handler) {
        MessengerInternal.OnListenerAdding(eventType, handler);
        eventTable[eventType] = (Callback<T, U>)eventTable[eventType] + handler;
    }
 
    static public void RemoveListener(string eventType, Callback<T, U> handler) {
        MessengerInternal.OnListenerRemoving(eventType, handler);
        eventTable[eventType] = (Callback<T, U>)eventTable[eventType] - handler;
        MessengerInternal.OnListenerRemoved(eventType);
    }
 
    static public void Broadcast(string eventType, T arg1, U arg2) {
        Broadcast(eventType, arg1, arg2, MessengerInternal.DEFAULT_MODE);
    }
 
    static public void Broadcast(string eventType, T arg1, U arg2, MessengerMode mode) {
        MessengerInternal.OnBroadcasting(eventType, mode);
        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 MessengerInternal.CreateBroadcastSignatureException(eventType);
            }
        }
    }
}
 
 
// Three parameters
static public class Messenger<T, U, V> {
    private static Dictionary<string, Delegate> eventTable = MessengerInternal.eventTable;
 
    static public void AddListener(string eventType, Callback<T, U, V> handler) {
        MessengerInternal.OnListenerAdding(eventType, handler);
        eventTable[eventType] = (Callback<T, U, V>)eventTable[eventType] + handler;
    }
 
    static public void RemoveListener(string eventType, Callback<T, U, V> handler) {
        MessengerInternal.OnListenerRemoving(eventType, handler);
        eventTable[eventType] = (Callback<T, U, V>)eventTable[eventType] - handler;
        MessengerInternal.OnListenerRemoved(eventType);
    }
 
    static public void Broadcast(string eventType, T arg1, U arg2, V arg3) {
        Broadcast(eventType, arg1, arg2, arg3, MessengerInternal.DEFAULT_MODE);
    }
 
    static public void Broadcast(string eventType, T arg1, U arg2, V arg3, MessengerMode mode) {
        MessengerInternal.OnBroadcasting(eventType, mode);
        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 MessengerInternal.CreateBroadcastSignatureException(eventType);
            }
        }
    }
}

public enum MessageType
{
    NONE,
    LevelStart,
    LevelEnd,
    PlayerPosition
}
 
public struct Message
{
    public MessageType Type;
    public int IntValue;
    public float FloatValue;
    public Vector3 Vector3Value;
    public GameObject GameObjectValue;
}
 
public struct MessageSubscriber
{
    public MessageType[] MessageTypes;
    public MessageHandler Handler;
}
 
    ....
 
    Dictionary<MessageType, List<MessageSubscriber>> subscriberLists = new Dictionary<MessageType, List<MessageSubscriber>>();
 
    public void AddSubscriber( MessageSubscriber subscriber )
    {
        MessageType[] messageTypes = subscriber.MessageTypes;
        for (int i = 0; i < messageTypes.Length; i++)
            AddSubscriberToMessage (messageTypes[i], subscriber);
    }
 
    public void SendMessage (Message message)
    {
        if (!subscriberLists.ContainsKey (message.Type))
            return;
 
        List<MessageSubscriber> subscriberList = 
            subscriberLists [message.Type];
 
        for (int i = 0; i < subscriberList.Count; i++)
            SendMessageToSubscriber (message, subscriberList [i]);
    }
 
    ....
 
    void Start()
    {
        MessageSubscriber subscriber = new MessageSubscriber ();
        subscriber.MessageTypes = MessageTypes;
        subscriber.Handler = Handler;
 
        MessageBus.Instance.AddSubscriber (subscriber);
    }

public class EventAggregator
{
        public static UnitDiedEvent UnitDied;
}
 
....
 
private void Die()
{
        EventAggregator.UnitDied.Publish(this);
}
 
....
 
public class ScoresManager : MonoBehaviour
{
    public int Scores;
 
    public void Awake()
    {
        EventAggregator.UnitDied.Subscribe(OnUnitDied);
    }
 
    private void OnUnitDied(Unit unit)
    {
        Scores += CalculateScores(unit);
    }   
}

    /// <summary>
    /// Queue of states
    /// </summary>
    public class StateQueue<T>: IStateQueue
    {
        // Queue of events
        private Queue<QueueItem<T>> queue = new Queue<QueueItem<T>>();
 
        /// <summary>
        /// Current value of state (in current frame)
        /// </summary>
        public T Value { get; private set; }
 
        /// <summary>
        /// Put event to queue
        /// </summary>
        public void Enqueue(T value, float deltaTime = 0)
        {
            queue.Enqueue(new QueueItem<T>{Value = value, TimeToFire = Time.time + deltaTime});
        }
 
        /// <summary>
        /// Implicit conversion to T
        /// </summary>
        public static implicit operator T(StateQueue<T> val)
        {
            return val.Value;
        }
 
        /// <summary>
        /// Conversion to true/false
        /// </summary>
        public static bool operator true(StateQueue<T> val)
        {
            return !val.Value.Equals(default(T));
        }
 
        /// <summary>
        /// Conversion to true/false
        /// </summary>
        public static bool operator false(StateQueue<T> val)
        {
            return val.Value.Equals(default(T));
        }
 
        /// <summary>
        /// Put event to queue via operator +
        /// </summary>
        public static StateQueue<T> operator +(StateQueue<T> vq, T val)
        {
            vq.Enqueue(val);
            return vq;
        }
 
        /// <summary>
        /// Clear queue, set default value
        /// </summary>
        public void Reset()
        {
            queue.Clear();
            Value = default(T);
        }
 
        void IStateQueue.Dequeue()
        {
            var count = queue.Count;
            for (int i = 0; i < count; i++)
            {
                //get next event
                var item = queue.Dequeue();
 
                //time elapsed?
                if (item.TimeToFire <= Time.time)
                {
                    //set event to current value
                    Value = item.Value;
                    return;
                }
 
                //time is not elapsed => enqueue again
                queue.Enqueue(item);
            }
 
            //set default value
            Value = default(T);
        }
    }

public class MineController : MonoBehaviour
{
    private bool CanExplode;
 
    void Start ()
    {
        CanExplode = Random.value > 0.9;
    }
    
    void Update ()
    {
        //check distance to player
        if ((StateBus.PlayerTransform.position - transform.position).sqrMagnitude < 2)
        {
            if (CanExplode)
                // fire Explosion event, pass coordinates of explosion
                StateBus.Explosion += transform.position; 
            else
                // fire MineDeactivated event
                StateBus.MineDeactivated += true;
 
            Destroy(gameObject);
        }
 
        // if some mine is exploded => apply force
        if (StateBus.Explosion)
            GetComponent<Rigidbody>().AddExplosionForce(2000, StateBus.Explosion, 15);
    }
}

public class SoundController : MonoBehaviour
{
    public AudioClip Explision;
    public AudioClip Pickup;
    public AudioSource Source;
 
    void Update ()
    {
        if (StateBus.Explosion)
            Source.PlayOneShot(Explision);
 
        if (StateBus.MineDeactivated)
            Source.PlayOneShot(Pickup);
    }
}

public class GuiController : MonoBehaviour
{
    public Text DeactivatedText;
    public Text ExplodedText;
    private int deactivated = 0;
    private int exploded = 0;
 
    void Update ()
    {
        if (StateBus.MineDeactivated)
        {
            deactivated++;
            DeactivatedText.text = "Defused: " + deactivated;
        }
 
        if (StateBus.Explosion)
        {
            exploded++;
            ExplodedText.text = "Explosion: " + exploded;
        }
    }
}