Message Queue System For Multiplayer Networking

In this example, we will show how to use the ObservedQueue class in Unity to manage a message queue for multiplayer networking. The idea is to receive incoming network messages on a separate thread, and notify subscribers whenever a new message is added to the queue.

1. Define the NetworkMessage class

First, let's define a simple class to represent a network message:

public class NetworkMessage
{
    public int senderId;
    public string message;

    public NetworkMessage(int senderId, string message)
    {
        this.senderId = senderId;
        this.message = message;
    }
}

2. Create the MultiplayerNetworkManager class

Next, let's create the MultiplayerNetworkManager class that will handle the message queue and subscribers:

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

public class MultiplayerNetworkManager : MonoBehaviour
{
    private ObservedQueue<NetworkMessage> messageQueue = new ObservedQueue<NetworkMessage>();
    private List<Action<NetworkMessage>> subscribers = new List<Action<NetworkMessage>>();

    private void Start()
    {
        // Subscribe to the messageQueue's events
        messageQueue.Subscribe((message, changeType) =>
        {
            if (changeType == ChangeType.Added)
            {
                // Notify subscribers of new message
                foreach (var subscriber in subscribers)
                {
                    subscriber(message);
                }
            }
        });

        // Start the worker thread that listens for incoming network messages
        StartCoroutine(ReceiveMessages());
    }

    private IEnumerator ReceiveMessages()
    {
        while (true)
        {
            // Pretend to receive a network message
            NetworkMessage receivedMessage = new NetworkMessage(0, "Hello from player 0");
            messageQueue.Enqueue(receivedMessage);
            yield return null;
        }
    }

    public void SubscribeToNetworkMessages(Action<NetworkMessage> callback)
    {
        subscribers.Add(callback);
    }

    public void UnsubscribeFromNetworkMessages(Action<NetworkMessage> callback)
    {
        subscribers.Remove(callback);
    }
}

3. Create a subscriber class

Finally, let's create a class that will be a subscriber to the message queue:

using UnityEngine;

public class NetworkMessageDisplay : MonoBehaviour
{
    private void Start()
    {
        // Subscribe to network messages
        MultiplayerNetworkManager networkManager = GetComponent<MultiplayerNetworkManager>();
        networkManager.SubscribeToNetworkMessages(OnNetworkMessageReceived);
    }

    private void OnNetworkMessageReceived(NetworkMessage message)
    {
        Debug.Log($"Received message from player {message.senderId}: {message.message}");
    }
}

With these classes, you now have a basic setup for receiving and handling network messages in a multi-threaded environment in Unity. The ObservedQueue class allows you to efficiently manage and notify subscribers of changes to the message queue, making it a great solution for multiplayer networking.