Used inheritance to simplify Reconnecting state

LPLafontaineB · LPLafontaineB · commit ac49f7c3dae2 · 2022-06-02T14:43:26.000-04:00
* Reconnecting now inherits from Offline * Also extracted GetPlayerId() to Offline state (cherry picked from commit 4f1c105)
diff --git a/Assets/Scripts/Gameplay/ConnectionManagement/ConnectionManager.cs b/Assets/Scripts/Gameplay/ConnectionManagement/ConnectionManager.cs
@@ -7,10 +7,7 @@
 using Unity.Multiplayer.Samples.BossRoom.Shared;
 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 Unity.Services.Authentication;
-using Unity.Services.Core;
 using UnityEngine;
 
 namespace Unity.Multiplayer.Samples.BossRoom
@@ -76,10 +73,10 @@ void Start()
         {
             m_Logics = new Dictionary<ConnectionStateType, ConnectionState>()
             {
-                [ConnectionStateType.Offline] = new OfflineConnectionState(this, m_LobbyServiceFacade, m_LocalLobby),
+                [ConnectionStateType.Offline] = new OfflineConnectionState(this, m_LobbyServiceFacade, m_LocalLobby, m_ProfileManager),
                 [ConnectionStateType.Connecting] = new ConnectingConnectionState(this, m_QuitGameSessionPublisher, m_ConnectStatusPublisher),
                 [ConnectionStateType.Connected] = new ConnectedConnectionState(this, m_QuitGameSessionPublisher, m_ConnectStatusPublisher),
-                [ConnectionStateType.Reconnecting] = new ReconnectingConnectionState(this, m_LobbyServiceFacade, m_LocalLobby, m_ReconnectMessagePublisher),
+                [ConnectionStateType.Reconnecting] = new ReconnectingConnectionState(this, m_LobbyServiceFacade, m_LocalLobby, m_ReconnectMessagePublisher, m_ProfileManager),
                 [ConnectionStateType.Hosting] = new HostingConnectionState(this, m_LobbyServiceFacade, m_ConnectionEventPublisher)
             };
             m_CurrentState = ConnectionStateType.Offline;
@@ -135,22 +132,22 @@ void ApprovalCheck(byte[] connectionData, ulong clientId, NetworkManager.Connect
 
         public Task StartClientLobbyAsync(string playerName, Action<string> onFailure)
         {
-            return m_Logics[m_CurrentState].StartClientLobbyAsync(playerName, GetPlayerId(), onFailure);
+            return m_Logics[m_CurrentState].StartClientLobbyAsync(playerName, onFailure);
         }
 
         public void StartClientIp(string playerName, string ipaddress, int port)
         {
-            m_Logics[m_CurrentState].StartClientIP(GetPlayerId(), playerName, ipaddress, port);
+            m_Logics[m_CurrentState].StartClientIP(playerName, ipaddress, port);
         }
 
         public void StartHostLobby(string playerName)
         {
-            m_Logics[m_CurrentState].StartHostLobbyAsync(GetPlayerId(), playerName);
+            m_Logics[m_CurrentState].StartHostLobbyAsync(playerName);
         }
 
         public bool StartHostIp(string playerName, string ipaddress, int port)
         {
-            return m_Logics[m_CurrentState].StartHostIP(GetPlayerId(), playerName, ipaddress, port);
+            return m_Logics[m_CurrentState].StartHostIP(playerName, ipaddress, port);
         }
 
         public void RequestShutdown()
@@ -198,15 +195,5 @@ public static void SendServerToClientSetDisconnectReason(ulong clientID, Connect
             writer.WriteValueSafe(status);
             NetworkManager.Singleton.CustomMessagingManager.SendNamedMessage(nameof(ClientGameNetPortal.ReceiveServerToClientSetDisconnectReason_CustomMessage), clientID, writer);
         }
-
-        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;
-        }
     }
 }
diff --git a/Assets/Scripts/Gameplay/ConnectionManagement/ConnectionState/ConnectionState.cs b/Assets/Scripts/Gameplay/ConnectionManagement/ConnectionState/ConnectionState.cs
@@ -20,19 +20,19 @@ public ConnectionState(ConnectionManager connectionManager)
         public virtual void OnClientConnected(ulong clientId) {}
         public virtual void OnClientDisconnect(ulong clientId) {}
 
-        public virtual void StartClientIP(string playerId, string playerName, string ipaddress, int port) {}
+        public virtual void StartClientIP(string playerName, string ipaddress, int port) {}
 
-        public virtual Task StartClientLobbyAsync(string playerName, string playerId, Action<string> onFailure)
+        public virtual Task StartClientLobbyAsync(string playerName, Action<string> onFailure)
         {
             return Task.CompletedTask;
         }
 
-        public virtual bool StartHostIP(string playerId, string playerName, string ipaddress, int port)
+        public virtual bool StartHostIP(string playerName, string ipaddress, int port)
         {
             return false;
         }
 
-        public virtual Task StartHostLobbyAsync(string playerId, string playerName)
+        public virtual Task StartHostLobbyAsync(string playerName)
         {
             return Task.CompletedTask;
         }
diff --git a/Assets/Scripts/Gameplay/ConnectionManagement/ConnectionState/OfflineConnectionState.cs b/Assets/Scripts/Gameplay/ConnectionManagement/ConnectionState/OfflineConnectionState.cs
@@ -1,44 +1,59 @@
 using System;
 using System.Threading.Tasks;
+using Unity.Multiplayer.Samples.BossRoom.Client;
+using Unity.Multiplayer.Samples.BossRoom.Shared;
 using Unity.Multiplayer.Samples.BossRoom.Shared.Net.UnityServices.Lobbies;
 using Unity.Multiplayer.Samples.Utilities;
 using Unity.Netcode;
 using Unity.Netcode.Transports.UTP;
+using Unity.Services.Authentication;
+using Unity.Services.Core;
 using UnityEngine;
 using UnityEngine.SceneManagement;
 
 namespace Unity.Multiplayer.Samples.BossRoom
 {
     public class OfflineConnectionState : ConnectionState
     {
-        LobbyServiceFacade m_LobbyServiceFacade;
-        LocalLobby m_LocalLobby;
+        protected LobbyServiceFacade m_LobbyServiceFacade;
+        protected LocalLobby m_LocalLobby;
+        ProfileManager m_ProfileManager;
 
         /// <summary>
         /// How many connections we create a Unity relay allocation for
         /// </summary>
         private const int k_MaxUnityRelayConnections = 8;
 
-        public OfflineConnectionState(ConnectionManager connectionManager, LobbyServiceFacade lobbyServiceFacade, LocalLobby localLobby)
+        public OfflineConnectionState(ConnectionManager connectionManager, LobbyServiceFacade lobbyServiceFacade,
+            LocalLobby localLobby, ProfileManager profileManager)
             : base(connectionManager)
         {
             m_LobbyServiceFacade = lobbyServiceFacade;
             m_LocalLobby = localLobby;
+            m_ProfileManager = profileManager;
         }
 
         public override void Enter() { }
 
         public override void Exit() { }
 
-        public override void StartClientIP(string playerId, string playerName, string ipaddress, int port)
+        public override void StartClientIP(string playerName, string ipaddress, int port)
         {
             var utp = (UnityTransport)m_ConnectionManager.NetworkManager.NetworkConfig.NetworkTransport;
             utp.SetConnectionData(ipaddress, (ushort)port);
-            ConnectClient(playerId, playerName);
+            ConnectClient(GetPlayerId(), playerName);
             m_ConnectionManager.ChangeState(ConnectionStateType.Connecting);
         }
 
-        public override async Task StartClientLobbyAsync(string playerName, string playerId, Action<string> onFailure)
+        public override async Task StartClientLobbyAsync(string playerName, Action<string> onFailure)
+        {
+            if (await JoinRelayServerAsync(onFailure)) return;//not re-throwing, but still not allowing to connect
+
+            ConnectClient(GetPlayerId(), playerName);
+            m_ConnectionManager.ChangeState(ConnectionStateType.Connecting);
+        }
+
+        protected async Task<bool> JoinRelayServerAsync(Action<string> onFailure)
         {
             Debug.Log($"Setting Unity Relay client with join code {m_LocalLobby.RelayJoinCode}");
 
@@ -48,25 +63,24 @@ public override async Task StartClientLobbyAsync(string playerName, string playe
                     await UnityRelayUtilities.JoinRelayServerFromJoinCode(m_LocalLobby.RelayJoinCode);
 
                 await m_LobbyServiceFacade.UpdatePlayerRelayInfoAsync(allocationIdBytes.ToString(), m_LocalLobby.RelayJoinCode);
-                var utp = (UnityTransport)m_ConnectionManager.NetworkManager.NetworkConfig.NetworkTransport;
+                var utp = (UnityTransport) m_ConnectionManager.NetworkManager.NetworkConfig.NetworkTransport;
                 utp.SetClientRelayData(ipv4Address, port, allocationIdBytes, key, connectionData, hostConnectionData, isSecure: true);
             }
             catch (Exception e)
             {
                 onFailure?.Invoke(e.Message);
-                return;//not re-throwing, but still not allowing to connect
+                return true;
             }
 
-            ConnectClient(playerId, playerName);
-            m_ConnectionManager.ChangeState(ConnectionStateType.Connecting);
+            return false;
         }
 
-        public override bool StartHostIP(string playerId, string playerName, string ipaddress, int port)
+        public override bool StartHostIP(string playerName, string ipaddress, int port)
         {
             var utp = (UnityTransport)NetworkManager.Singleton.NetworkConfig.NetworkTransport;
             utp.SetConnectionData(ipaddress, (ushort)port);
 
-            var success = StartHost(playerId, playerName);
+            var success = StartHost(GetPlayerId(), playerName);
             if (success)
             {
                 m_ConnectionManager.ChangeState(ConnectionStateType.Hosting);
@@ -75,7 +89,7 @@ public override bool StartHostIP(string playerId, string playerName, string ipad
             return success;
         }
 
-        public override async Task StartHostLobbyAsync(string playerId, string playerName)
+        public override async Task StartHostLobbyAsync(string playerName)
         {
             Debug.Log("Setting up Unity Relay host");
 
@@ -99,7 +113,7 @@ public override async Task StartHostLobbyAsync(string playerId, string playerNam
                 throw;
             }
 
-            if (StartHost(playerId, playerName))
+            if (StartHost(GetPlayerId(), playerName))
             {
                 m_ConnectionManager.ChangeState(ConnectionStateType.Hosting);
             }
@@ -149,5 +163,15 @@ bool StartHost(string playerId, string playerName)
             SetConnectionPayload(playerId, playerName);
             return m_ConnectionManager.NetworkManager.StartHost();
         }
+
+        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;
+        }
     }
 }
diff --git a/Assets/Scripts/Gameplay/ConnectionManagement/ConnectionState/ReconnectingConnectionState.cs b/Assets/Scripts/Gameplay/ConnectionManagement/ConnectionState/ReconnectingConnectionState.cs
@@ -2,6 +2,7 @@
 using System.Collections;
 using System.Threading.Tasks;
 using Unity.Multiplayer.Samples.BossRoom.ApplicationLifecycle.Messages;
+using Unity.Multiplayer.Samples.BossRoom.Shared;
 using Unity.Multiplayer.Samples.BossRoom.Shared.Infrastructure;
 using Unity.Multiplayer.Samples.BossRoom.Shared.Net.UnityServices.Lobbies;
 using Unity.Multiplayer.Samples.Utilities;
@@ -11,24 +12,20 @@
 
 namespace Unity.Multiplayer.Samples.BossRoom
 {
-    public class ReconnectingConnectionState : ConnectionState
+    public class ReconnectingConnectionState : OfflineConnectionState
     {
         const int k_NbReconnectAttempts = 2;
 
-        LobbyServiceFacade m_LobbyServiceFacade;
-        LocalLobby m_LocalLobby;
         IPublisher<ReconnectMessage> m_ReconnectMessagePublisher;
 
         Coroutine m_ReconnectCoroutine;
         string m_LobbyCode = "";
         int m_NbAttempts;
 
         public ReconnectingConnectionState(ConnectionManager connectionManager, LobbyServiceFacade lobbyServiceFacade,
-            LocalLobby localLobby, IPublisher<ReconnectMessage> reconnectMessagePublisher)
-            : base(connectionManager)
+            LocalLobby localLobby, IPublisher<ReconnectMessage> reconnectMessagePublisher, ProfileManager profileManager)
+            : base(connectionManager, lobbyServiceFacade, localLobby, profileManager)
         {
-            m_LobbyServiceFacade = lobbyServiceFacade;
-            m_LocalLobby = localLobby;
             m_ReconnectMessagePublisher = reconnectMessagePublisher;
         }
 
@@ -81,6 +78,23 @@ public override void OnUserRequestedShutdown()
             m_ConnectionManager.ChangeState(ConnectionStateType.Offline);
         }
 
+        public override void StartClientIP(string playerName, string ipaddress, int port) {}
+
+        public override Task StartClientLobbyAsync(string playerName, Action<string> onFailure)
+        {
+            return Task.CompletedTask;
+        }
+
+        public override bool StartHostIP(string playerName, string ipaddress, int port)
+        {
+            return false;
+        }
+
+        public override Task StartHostLobbyAsync(string playerName)
+        {
+            return Task.CompletedTask;
+        }
+
         IEnumerator ReconnectCoroutine()
         {
             Debug.Log("Lost connection to host, trying to reconnect...");
@@ -90,6 +104,7 @@ IEnumerator ReconnectCoroutine()
             yield return new WaitWhile(() => NetworkManager.Singleton.ShutdownInProgress); // wait until NetworkManager completes shutting down
             Debug.Log($"Reconnecting attempt {m_NbAttempts + 1}/{k_NbReconnectAttempts}...");
             m_ReconnectMessagePublisher.Publish(new ReconnectMessage(m_NbAttempts, k_NbReconnectAttempts));
+            m_NbAttempts++;
             if (!string.IsNullOrEmpty(m_LobbyCode))
             {
                 var leavingLobby = m_LobbyServiceFacade.EndTracking();
@@ -99,39 +114,28 @@ IEnumerator ReconnectCoroutine()
                 if (joiningLobby.Result.Success)
                 {
                     m_LobbyServiceFacade.SetRemoteLobby(joiningLobby.Result.Lobby);
-                    var joiningRelay = JoinRelayServerAsync();
+                    var joiningRelay = JoinRelayServerAsync(null);
                     yield return new WaitUntil(() => joiningRelay.IsCompleted);
+                    if (joiningRelay.Result)
+                    {
+                        ConnectClient();
+                    }
+                    else
+                    {
+                        Debug.Log("Failed joining Relay server.");
+                        OnClientDisconnect(0);
+                    }
                 }
                 else
                 {
                     Debug.Log("Failed joining lobby.");
+                    OnClientDisconnect(0);
                 }
             }
             else
             {
                 ConnectClient();
             }
-
-            m_NbAttempts++;
-        }
-
-        async Task JoinRelayServerAsync()
-        {
-            try
-            {
-                var (ipv4Address, port, allocationIdBytes, connectionData, hostConnectionData, key) =
-                    await UnityRelayUtilities.JoinRelayServerFromJoinCode(m_LocalLobby.RelayJoinCode);
-
-                await m_LobbyServiceFacade.UpdatePlayerRelayInfoAsync(allocationIdBytes.ToString(), m_LocalLobby.RelayJoinCode);
-                var utp = (UnityTransport)m_ConnectionManager.NetworkManager.NetworkConfig.NetworkTransport;
-                utp.SetClientRelayData(ipv4Address, port, allocationIdBytes, key, connectionData, hostConnectionData, isSecure: true);
-            }
-            catch (Exception)
-            {
-                return;//not re-throwing, but still not allowing to connect
-            }
-
-            ConnectClient();
         }
 
         void ConnectClient()

Original file line number	Diff line number	Diff line change
`@@ -7,10 +7,7 @@`
`7`	`7`	`using Unity.Multiplayer.Samples.BossRoom.Shared;`
`8`	`8`	`using Unity.Multiplayer.Samples.BossRoom.Shared.Infrastructure;`
`9`	`9`	`using Unity.Multiplayer.Samples.BossRoom.Shared.Net.UnityServices.Lobbies;`
`10`		`-using Unity.Multiplayer.Samples.Utilities;`
`11`	`10`	`using Unity.Netcode;`
`12`		`-using Unity.Services.Authentication;`
`13`		`-using Unity.Services.Core;`
`14`	`11`	`using UnityEngine;`
`15`	`12`
`16`	`13`	`namespace Unity.Multiplayer.Samples.BossRoom`
`@@ -76,10 +73,10 @@ void Start()`
`76`	`73`	`{`
`77`	`74`	`m_Logics = new Dictionary<ConnectionStateType, ConnectionState>()`
`78`	`75`	`{`
`79`		`- [ConnectionStateType.Offline] = new OfflineConnectionState(this, m_LobbyServiceFacade, m_LocalLobby),`
	`76`	`+ [ConnectionStateType.Offline] = new OfflineConnectionState(this, m_LobbyServiceFacade, m_LocalLobby, m_ProfileManager),`
`80`	`77`	`[ConnectionStateType.Connecting] = new ConnectingConnectionState(this, m_QuitGameSessionPublisher, m_ConnectStatusPublisher),`
`81`	`78`	`[ConnectionStateType.Connected] = new ConnectedConnectionState(this, m_QuitGameSessionPublisher, m_ConnectStatusPublisher),`
`82`		`- [ConnectionStateType.Reconnecting] = new ReconnectingConnectionState(this, m_LobbyServiceFacade, m_LocalLobby, m_ReconnectMessagePublisher),`
	`79`	`+ [ConnectionStateType.Reconnecting] = new ReconnectingConnectionState(this, m_LobbyServiceFacade, m_LocalLobby, m_ReconnectMessagePublisher, m_ProfileManager),`
`83`	`80`	`[ConnectionStateType.Hosting] = new HostingConnectionState(this, m_LobbyServiceFacade, m_ConnectionEventPublisher)`
`84`	`81`	`};`
`85`	`82`	`m_CurrentState = ConnectionStateType.Offline;`
`@@ -135,22 +132,22 @@ void ApprovalCheck(byte[] connectionData, ulong clientId, NetworkManager.Connect`
`135`	`132`
`136`	`133`	`public Task StartClientLobbyAsync(string playerName, Action<string> onFailure)`
`137`	`134`	`{`
`138`		`- return m_Logics[m_CurrentState].StartClientLobbyAsync(playerName, GetPlayerId(), onFailure);`
	`135`	`+ return m_Logics[m_CurrentState].StartClientLobbyAsync(playerName, onFailure);`
`139`	`136`	`}`
`140`	`137`
`141`	`138`	`public void StartClientIp(string playerName, string ipaddress, int port)`
`142`	`139`	`{`
`143`		`- m_Logics[m_CurrentState].StartClientIP(GetPlayerId(), playerName, ipaddress, port);`
	`140`	`+ m_Logics[m_CurrentState].StartClientIP(playerName, ipaddress, port);`
`144`	`141`	`}`
`145`	`142`
`146`	`143`	`public void StartHostLobby(string playerName)`
`147`	`144`	`{`
`148`		`- m_Logics[m_CurrentState].StartHostLobbyAsync(GetPlayerId(), playerName);`
	`145`	`+ m_Logics[m_CurrentState].StartHostLobbyAsync(playerName);`
`149`	`146`	`}`
`150`	`147`
`151`	`148`	`public bool StartHostIp(string playerName, string ipaddress, int port)`
`152`	`149`	`{`
`153`		`- return m_Logics[m_CurrentState].StartHostIP(GetPlayerId(), playerName, ipaddress, port);`
	`150`	`+ return m_Logics[m_CurrentState].StartHostIP(playerName, ipaddress, port);`
`154`	`151`	`}`
`155`	`152`
`156`	`153`	`public void RequestShutdown()`
`@@ -198,15 +195,5 @@ public static void SendServerToClientSetDisconnectReason(ulong clientID, Connect`
`198`	`195`	`writer.WriteValueSafe(status);`
`199`	`196`	`NetworkManager.Singleton.CustomMessagingManager.SendNamedMessage(nameof(ClientGameNetPortal.ReceiveServerToClientSetDisconnectReason_CustomMessage), clientID, writer);`
`200`	`197`	`}`
`201`		`-`
`202`		`- string GetPlayerId()`
`203`		`- {`
`204`		`- if (UnityServices.State != ServicesInitializationState.Initialized)`
`205`		`- {`
`206`		`- return ClientPrefs.GetGuid() + m_ProfileManager.Profile;`
`207`		`- }`
`208`		`-`
`209`		`- return AuthenticationService.Instance.IsSignedIn ? AuthenticationService.Instance.PlayerId : ClientPrefs.GetGuid() + m_ProfileManager.Profile;`
`210`		`- }`
`211`	`198`	`}`
`212`	`199`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,19 +20,19 @@ public ConnectionState(ConnectionManager connectionManager)`
`20`	`20`	`public virtual void OnClientConnected(ulong clientId) {}`
`21`	`21`	`public virtual void OnClientDisconnect(ulong clientId) {}`
`22`	`22`
`23`		`- public virtual void StartClientIP(string playerId, string playerName, string ipaddress, int port) {}`
	`23`	`+ public virtual void StartClientIP(string playerName, string ipaddress, int port) {}`
`24`	`24`
`25`		`- public virtual Task StartClientLobbyAsync(string playerName, string playerId, Action<string> onFailure)`
	`25`	`+ public virtual Task StartClientLobbyAsync(string playerName, Action<string> onFailure)`
`26`	`26`	`{`
`27`	`27`	`return Task.CompletedTask;`
`28`	`28`	`}`
`29`	`29`
`30`		`- public virtual bool StartHostIP(string playerId, string playerName, string ipaddress, int port)`
	`30`	`+ public virtual bool StartHostIP(string playerName, string ipaddress, int port)`
`31`	`31`	`{`
`32`	`32`	`return false;`
`33`	`33`	`}`
`34`	`34`
`35`		`- public virtual Task StartHostLobbyAsync(string playerId, string playerName)`
	`35`	`+ public virtual Task StartHostLobbyAsync(string playerName)`
`36`	`36`	`{`
`37`	`37`	`return Task.CompletedTask;`
`38`	`38`	`}`