Adding ConnectionManager skeleton

Author: LPLafontaineB

Assets/BossRoom/Scripts/Gameplay/ConnectionManagement/ClientConnectionManager.cs

@@ -0,0 +1,111 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using Unity.Multiplayer.Samples.BossRoom.Shared;
+using Unity.Multiplayer.Samples.Utilities;
+using Unity.Netcode;
+using Unity.Services.Authentication;
+using Unity.Services.Core;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+
+namespace Unity.Multiplayer.Samples.BossRoom.Client
+{
+    enum ConnectionState
+    {
+        Offline,
+        Connecting,
+        Connected,
+        Reconnecting
+    }
+
+    public class ClientConnectionManager : MonoBehaviour
+    {
+        NetworkManager m_NetworkManager;
+        ProfileManager m_ProfileManager;
+        ConnectionState m_ConnectionState;
+        ConnectStatus m_ConnectStatus;
+
+        /// <summary>
+        /// the name of the player chosen at game start
+        /// </summary>
+        public string PlayerName;
+
+        void Awake()
+        {
+            m_NetworkManager.OnClientConnectedCallback += OnClientConnected;
+            m_NetworkManager.OnClientDisconnectCallback += OnClientDisconnect;
+        }
+
+        void Destroy()
+        {
+            m_NetworkManager.OnClientConnectedCallback -= OnClientConnected;
+            m_NetworkManager.OnClientDisconnectCallback -= OnClientDisconnect;
+        }
+
+        void OnClientDisconnect(ulong clientId)
+        {
+            throw new NotImplementedException();
+        }
+
+        void OnClientConnected(ulong clientId)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void OnUserDisconnectRequest()
+        {
+
+        }
+
+        public void StartClientLobby()
+        {
+
+        }
+
+        public void StartClientIp()
+        {
+
+        }
+
+        void ConnectClient()
+        {
+            var payload = JsonUtility.ToJson(new ConnectionPayload()
+            {
+                playerId = GetPlayerId(),
+                clientScene = SceneManager.GetActiveScene().buildIndex,
+                playerName = PlayerName,
+                isDebug = Debug.isDebugBuild
+            });
+
+            var payloadBytes = System.Text.Encoding.UTF8.GetBytes(payload);
+
+            m_NetworkManager.NetworkConfig.ConnectionData = payloadBytes;
+
+            //and...we're off! Netcode will establish a socket connection to the host.
+            //  If the socket connection fails, we'll hear back by getting an ReceiveServerToClientSetDisconnectReason_CustomMessage callback for ourselves and get a message telling us the reason
+            //  If the socket connection succeeds, we'll get our ReceiveServerToClientConnectResult_CustomMessage invoked. This is where game-layer failures will be reported.
+            m_NetworkManager.StartClient();
+            SceneLoaderWrapper.Instance.AddOnSceneEventCallback();
+
+            // should only do this once StartClient has been called (start client will initialize CustomMessagingManager
+            NetworkManager.Singleton.CustomMessagingManager.RegisterNamedMessageHandler(nameof(ReceiveServerToClientSetDisconnectReason_CustomMessage), ReceiveServerToClientSetDisconnectReason_CustomMessage);
+        }
+
+        public void ReceiveServerToClientSetDisconnectReason_CustomMessage(ulong clientID, FastBufferReader reader)
+        {
+            reader.ReadValueSafe(out ConnectStatus status);
+            m_ConnectStatus = status;
+        }
+
+        public string GetPlayerId()
+        {
+            if (UnityServices.State != ServicesInitializationState.Initialized)
+            {
+                return ClientPrefs.GetGuid() + m_ProfileManager.Profile;
+            }
+
+            return AuthenticationService.Instance.IsSignedIn ? AuthenticationService.Instance.PlayerId : ClientPrefs.GetGuid() + m_ProfileManager.Profile;
+        }
+    }
+}

Assets/BossRoom/Scripts/Gameplay/ConnectionManagement/ClientConnectionManager.cs.meta

@@ -0,0 +1,271 @@
+using System.Collections;
+using System.Collections.Generic;
+using Unity.Collections;
+using Unity.Multiplayer.Samples.BossRoom.Client;
+using Unity.Multiplayer.Samples.BossRoom.Shared.Infrastructure;
+using Unity.Multiplayer.Samples.BossRoom.Shared.Net.UnityServices.Lobbies;
+using Unity.Multiplayer.Samples.Utilities;
+using Unity.Netcode;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+
+namespace Unity.Multiplayer.Samples.BossRoom.Server
+{
+    public class ServerConnectionManager : MonoBehaviour
+    {
+        [SerializeField]
+        NetworkObject m_GameState;
+
+        // used in ApprovalCheck. This is intended as a bit of light protection against DOS attacks that rely on sending silly big buffers of garbage.
+        const int k_MaxConnectPayload = 1024;
+
+        /// <summary>
+        /// Keeps a list of what clients are in what scenes.
+        /// </summary>
+        Dictionary<ulong, int> m_ClientSceneMap = new Dictionary<ulong, int>();
+
+        /// <summary>
+        /// The active server scene index.
+        /// </summary>
+        static int ServerScene => SceneManager.GetActiveScene().buildIndex;
+
+        NetworkManager m_NetworkManager;
+        LobbyServiceFacade m_LobbyServiceFacade;
+
+        IPublisher<ConnectionEventMessage> m_ConnectionEventPublisher;
+
+        [Inject]
+        void InjectDependencies(LobbyServiceFacade lobbyServiceFacade, IPublisher<ConnectionEventMessage> connectionEventPublisher)
+        {
+            m_LobbyServiceFacade = lobbyServiceFacade;
+            m_ConnectionEventPublisher = connectionEventPublisher;
+        }
+
+        void Start()
+        {
+            m_NetworkManager.ConnectionApprovalCallback += ApprovalCheck;
+            m_NetworkManager.OnServerStarted += ServerStartedHandler;
+            m_NetworkManager.OnClientDisconnectCallback += OnClientDisconnect;
+        }
+
+        void OnDestroy()
+        {
+            if (m_NetworkManager != null)
+            {
+                m_NetworkManager.ConnectionApprovalCallback -= ApprovalCheck;
+                m_NetworkManager.OnServerStarted -= ServerStartedHandler;
+                m_NetworkManager.OnClientDisconnectCallback -= OnClientDisconnect;
+            }
+        }
+
+        /// <summary>
+        /// Handles the case where NetworkManager has told us a client has disconnected. This includes ourselves, if we're the host,
+        /// and the server is stopped."
+        /// </summary>
+        void OnClientDisconnect(ulong clientId)
+        {
+            m_ClientSceneMap.Remove(clientId);
+
+            if (clientId == m_NetworkManager.LocalClientId)
+            {
+                //the ServerGameNetPortal may be initialized again, which will cause its OnNetworkSpawn to be called again.
+                //Consequently we need to unregister anything we registered, when the NetworkManager is shutting down.
+                m_NetworkManager.OnClientDisconnectCallback -= OnClientDisconnect;
+                if (m_LobbyServiceFacade.CurrentUnityLobby != null)
+                {
+                    m_LobbyServiceFacade.DeleteLobbyAsync(m_LobbyServiceFacade.CurrentUnityLobby.Id);
+                }
+                SessionManager<SessionPlayerData>.Instance.OnServerEnded();
+            }
+            else
+            {
+                var playerId = SessionManager<SessionPlayerData>.Instance.GetPlayerId(clientId);
+                if (playerId != null)
+                {
+                    if (m_LobbyServiceFacade.CurrentUnityLobby != null)
+                    {
+                        m_LobbyServiceFacade.RemovePlayerFromLobbyAsync(playerId, m_LobbyServiceFacade.CurrentUnityLobby.Id);
+                    }
+
+                    var sessionData = SessionManager<SessionPlayerData>.Instance.GetPlayerData(playerId);
+                    if (sessionData.HasValue)
+                    {
+                        m_ConnectionEventPublisher.Publish(new ConnectionEventMessage() { ConnectStatus = ConnectStatus.GenericDisconnect, PlayerName = sessionData.Value.PlayerName });
+                    }
+                    SessionManager<SessionPlayerData>.Instance.DisconnectClient(clientId);
+                }
+            }
+        }
+
+        public void OnClientSceneChanged(ulong clientId, int sceneIndex)
+        {
+            m_ClientSceneMap[clientId] = sceneIndex;
+        }
+
+        /// <summary>
+        /// Handles the flow when a user has requested a disconnect via UI (which can be invoked on the Host, and thus must be
+        /// handled in server code).
+        /// </summary>
+        public void OnUserDisconnectRequest()
+        {
+            if (m_NetworkManager.IsHost)
+            {
+                SendServerToAllClientsSetDisconnectReason(ConnectStatus.HostEndedSession);
+                // Wait before shutting down to make sure clients receive that message before they are disconnected
+                StartCoroutine(WaitToShutdown());
+            }
+            Clear();
+        }
+
+        void Clear()
+        {
+            //resets all our runtime state.
+            m_ClientSceneMap.Clear();
+        }
+
+        public bool AreAllClientsInServerScene()
+        {
+            foreach (var kvp in m_ClientSceneMap)
+            {
+                if (kvp.Value != ServerScene) { return false; }
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// This logic plugs into the "ConnectionApprovalCallback" exposed by Netcode.NetworkManager, and is run every time a client connects to us.
+        /// See ClientGameNetPortal.StartClient for the complementary logic that runs when the client starts its connection.
+        /// </summary>
+        /// <remarks>
+        /// Since our game doesn't have to interact with some third party authentication service to validate the identity of the new connection, our ApprovalCheck
+        /// method is simple, and runs synchronously, invoking "callback" to signal approval at the end of the method. Netcode currently doesn't support the ability
+        /// to send back more than a "true/false", which means we have to work a little harder to provide a useful error return to the client. To do that, we invoke a
+        /// custom message in the same channel that Netcode uses for its connection callback. Since the delivery is NetworkDelivery.ReliableSequenced, we can be
+        /// confident that our login result message will execute before any disconnect message.
+        /// </remarks>
+        /// <param name="connectionData">binary data passed into StartClient. In our case this is the client's GUID, which is a unique identifier for their install of the game that persists across app restarts. </param>
+        /// <param name="clientId">This is the clientId that Netcode assigned us on login. It does not persist across multiple logins from the same client. </param>
+        /// <param name="connectionApprovedCallback">The delegate we must invoke to signal that the connection was approved or not. </param>
+        void ApprovalCheck(byte[] connectionData, ulong clientId, NetworkManager.ConnectionApprovedDelegate connectionApprovedCallback)
+        {
+            if (connectionData.Length > k_MaxConnectPayload)
+            {
+                // If connectionData too high, deny immediately to avoid wasting time on the server. This is intended as
+                // a bit of light protection against DOS attacks that rely on sending silly big buffers of garbage.
+                connectionApprovedCallback(false, 0, false, null, null);
+                return;
+            }
+
+            // Approval check happens for Host too, but obviously we want it to be approved
+            if (clientId == NetworkManager.Singleton.LocalClientId)
+            {
+                SessionManager<SessionPlayerData>.Instance.SetupConnectingPlayerSessionData(clientId, m_Portal.GetPlayerId(),
+                    new SessionPlayerData(clientId, m_Portal.PlayerName, m_Portal.AvatarRegistry.GetRandomAvatar().Guid.ToNetworkGuid(), 0, true));
+
+                connectionApprovedCallback(true, null, true, null, null);
+                return;
+            }
+
+            var payload = System.Text.Encoding.UTF8.GetString(connectionData);
+            var connectionPayload = JsonUtility.FromJson<ConnectionPayload>(payload); // https://docs.unity3d.com/2020.2/Documentation/Manual/JSONSerialization.html
+            var gameReturnStatus = GetConnectStatus(connectionPayload);
+
+            if (gameReturnStatus == ConnectStatus.Success)
+            {
+                SessionManager<SessionPlayerData>.Instance.SetupConnectingPlayerSessionData(clientId, connectionPayload.playerId,
+                    new SessionPlayerData(clientId, connectionPayload.playerName, m_Portal.AvatarRegistry.GetRandomAvatar().Guid.ToNetworkGuid(), 0, true));
+
+                //Populate our client scene map
+                m_ClientSceneMap[clientId] = connectionPayload.clientScene;
+
+                // connection approval will create a player object for you
+                connectionApprovedCallback(true, null, true, Vector3.zero, Quaternion.identity);
+
+                m_ConnectionEventPublisher.Publish(new ConnectionEventMessage() { ConnectStatus = ConnectStatus.Success, PlayerName = SessionManager<SessionPlayerData>.Instance.GetPlayerData(clientId)?.PlayerName });
+            }
+            else
+            {
+                //TODO-FIXME:Netcode Issue #796. We should be able to send a reason and disconnect without a coroutine delay.
+                //TODO:Netcode: In the future we expect Netcode to allow us to return more information as part of the
+                //approval callback, so that we can provide more context on a reject. In the meantime we must provide
+                //the extra information ourselves, and then wait a short time before manually close down the connection.
+                SendServerToClientSetDisconnectReason(clientId, gameReturnStatus);
+                StartCoroutine(WaitToDenyApproval(connectionApprovedCallback));
+                if (m_LobbyServiceFacade.CurrentUnityLobby != null)
+                {
+                    m_LobbyServiceFacade.RemovePlayerFromLobbyAsync(connectionPayload.playerId, m_LobbyServiceFacade.CurrentUnityLobby.Id);
+                }
+            }
+        }
+
+        ConnectStatus GetConnectStatus(ConnectionPayload connectionPayload)
+        {
+            if (m_NetworkManager.ConnectedClientsIds.Count >= CharSelectData.k_MaxLobbyPlayers)
+            {
+                return ConnectStatus.ServerFull;
+            }
+
+            if (connectionPayload.isDebug != Debug.isDebugBuild)
+            {
+                return ConnectStatus.IncompatibleBuildType;
+            }
+
+            return SessionManager<SessionPlayerData>.Instance.IsDuplicateConnection(connectionPayload.playerId) ?
+                ConnectStatus.LoggedInAgain : ConnectStatus.Success;
+        }
+
+        static IEnumerator WaitToDenyApproval(NetworkManager.ConnectionApprovedDelegate connectionApprovedCallback)
+        {
+            yield return new WaitForSeconds(0.5f);
+            connectionApprovedCallback(false, 0, false, null, null);
+        }
+
+        IEnumerator WaitToShutdown()
+        {
+            yield return null;
+            m_NetworkManager.Shutdown();
+            SessionManager<SessionPlayerData>.Instance.OnServerEnded();
+        }
+
+        /// <summary>
+        /// Sends a DisconnectReason to all connected clients. This should only be done on the server, prior to disconnecting the client.
+        /// </summary>
+        /// <param name="status"> The reason for the upcoming disconnect.</param>
+        static void SendServerToAllClientsSetDisconnectReason(ConnectStatus status)
+        {
+            var writer = new FastBufferWriter(sizeof(ConnectStatus), Allocator.Temp);
+            writer.WriteValueSafe(status);
+            NetworkManager.Singleton.CustomMessagingManager.SendNamedMessageToAll(nameof(ClientGameNetPortal.ReceiveServerToClientSetDisconnectReason_CustomMessage), writer);
+        }
+
+        /// <summary>
+        /// Sends a DisconnectReason to the indicated client. This should only be done on the server, prior to disconnecting the client.
+        /// </summary>
+        /// <param name="clientID"> id of the client to send to </param>
+        /// <param name="status"> The reason for the upcoming disconnect.</param>
+        static void SendServerToClientSetDisconnectReason(ulong clientID, ConnectStatus status)
+        {
+            var writer = new FastBufferWriter(sizeof(ConnectStatus), Allocator.Temp);
+            writer.WriteValueSafe(status);
+            NetworkManager.Singleton.CustomMessagingManager.SendNamedMessage(nameof(ClientGameNetPortal.ReceiveServerToClientSetDisconnectReason_CustomMessage), clientID, writer);
+        }
+
+        /// <summary>
+        /// Called after the server is created-  This is primarily meant for the host server to clean up or handle/set state as its starting up
+        /// </summary>
+        void ServerStartedHandler()
+        {
+            // server spawns game state
+            var gameState = Instantiate(m_GameState);
+
+            gameState.Spawn();
+
+            SceneLoaderWrapper.Instance.AddOnSceneEventCallback();
+
+            //The "BossRoom" server always advances to CharSelect immediately on start. Different games
+            //may do this differently.
+            SceneLoaderWrapper.Instance.LoadScene("CharSelect", useNetworkSceneManager: true);
+        }
+    }
+}