feat: OnConnectionEvent callback usage in project and Utilities package [MTTB-1147] (#907)

fernando-cortez · web-flow · commit 279e34896591 · 2025-04-07T17:41:24.000-04:00
* refactor project and Utilities package to use OnConnectionEvent callback

* changelog additions

* fix addition to changelog

* formatting fix
diff --git a/Assets/Scripts/ConnectionManagement/ConnectionManager.cs b/Assets/Scripts/ConnectionManagement/ConnectionManager.cs
@@ -93,8 +93,7 @@ void Start()
 
             m_CurrentState = m_Offline;
 
-            NetworkManager.OnClientConnectedCallback += OnClientConnectedCallback;
-            NetworkManager.OnClientDisconnectCallback += OnClientDisconnectCallback;
+            NetworkManager.OnConnectionEvent += OnConnectionEvent;
             NetworkManager.OnServerStarted += OnServerStarted;
             NetworkManager.ConnectionApprovalCallback += ApprovalCheck;
             NetworkManager.OnTransportFailure += OnTransportFailure;
@@ -103,8 +102,7 @@ void Start()
 
         void OnDestroy()
         {
-            NetworkManager.OnClientConnectedCallback -= OnClientConnectedCallback;
-            NetworkManager.OnClientDisconnectCallback -= OnClientDisconnectCallback;
+            NetworkManager.OnConnectionEvent -= OnConnectionEvent;
             NetworkManager.OnServerStarted -= OnServerStarted;
             NetworkManager.ConnectionApprovalCallback -= ApprovalCheck;
             NetworkManager.OnTransportFailure -= OnTransportFailure;
@@ -123,14 +121,17 @@ internal void ChangeState(ConnectionState nextState)
             m_CurrentState.Enter();
         }
 
-        void OnClientDisconnectCallback(ulong clientId)
+        void OnConnectionEvent(NetworkManager networkManager, ConnectionEventData connectionEventData)
         {
-            m_CurrentState.OnClientDisconnect(clientId);
-        }
-
-        void OnClientConnectedCallback(ulong clientId)
-        {
-            m_CurrentState.OnClientConnected(clientId);
+            switch (connectionEventData.EventType)
+            {
+                case ConnectionEvent.ClientConnected:
+                    m_CurrentState.OnClientConnected(connectionEventData.ClientId);
+                    break;
+                case ConnectionEvent.ClientDisconnected:
+                    m_CurrentState.OnClientDisconnect(connectionEventData.ClientId);
+                    break;
+            }
         }
 
         void OnServerStarted()
diff --git a/Assets/Scripts/Gameplay/GameState/ServerBossRoomState.cs b/Assets/Scripts/Gameplay/GameState/ServerBossRoomState.cs
@@ -79,7 +79,7 @@ void OnNetworkSpawn()
             m_PersistentGameState.Reset();
             m_LifeStateChangedEventMessageSubscriber.Subscribe(OnLifeStateChangedEventMessage);
 
-            NetworkManager.Singleton.OnClientDisconnectCallback += OnClientDisconnect;
+            NetworkManager.Singleton.OnConnectionEvent += OnConnectionEvent;
             NetworkManager.Singleton.SceneManager.OnLoadEventCompleted += OnLoadEventCompleted;
             NetworkManager.Singleton.SceneManager.OnSynchronizeComplete += OnSynchronizeComplete;
 
@@ -93,7 +93,7 @@ void OnNetworkDespawn()
                 m_LifeStateChangedEventMessageSubscriber.Unsubscribe(OnLifeStateChangedEventMessage);
             }
 
-            NetworkManager.Singleton.OnClientDisconnectCallback -= OnClientDisconnect;
+            NetworkManager.Singleton.OnConnectionEvent -= OnConnectionEvent;
             NetworkManager.Singleton.SceneManager.OnLoadEventCompleted -= OnLoadEventCompleted;
             NetworkManager.Singleton.SceneManager.OnSynchronizeComplete -= OnSynchronizeComplete;
         }
@@ -138,12 +138,15 @@ void OnLoadEventCompleted(string sceneName, LoadSceneMode loadSceneMode, List<ul
             }
         }
 
-        void OnClientDisconnect(ulong clientId)
+        void OnConnectionEvent(NetworkManager networkManager, ConnectionEventData connectionEventData)
         {
-            if (clientId != NetworkManager.Singleton.LocalClientId)
+            if (connectionEventData.EventType == ConnectionEvent.ClientDisconnected)
             {
-                // If a client disconnects, check for game over in case all other players are already down
-                StartCoroutine(WaitToCheckForGameOver());
+                if (connectionEventData.ClientId != networkManager.LocalClientId)
+                {
+                    // If a client disconnects, check for game over in case all other players are already down
+                    StartCoroutine(WaitToCheckForGameOver());
+                }
             }
         }
 
diff --git a/Assets/Scripts/Gameplay/GameState/ServerCharSelectState.cs b/Assets/Scripts/Gameplay/GameState/ServerCharSelectState.cs
@@ -184,11 +184,11 @@ IEnumerator WaitToEndSession()
             SceneLoaderWrapper.Instance.LoadScene("BossRoom", useNetworkSceneManager: true);
         }
 
-        public void OnNetworkDespawn()
+        void OnNetworkDespawn()
         {
             if (NetworkManager.Singleton)
             {
-                NetworkManager.Singleton.OnClientDisconnectCallback -= OnClientDisconnectCallback;
+                NetworkManager.Singleton.OnConnectionEvent -= OnConnectionEvent;
                 NetworkManager.Singleton.SceneManager.OnSceneEvent -= OnSceneEvent;
             }
             if (networkCharSelection)
@@ -197,15 +197,15 @@ public void OnNetworkDespawn()
             }
         }
 
-        public void OnNetworkSpawn()
+        void OnNetworkSpawn()
         {
             if (!NetworkManager.Singleton.IsServer)
             {
                 enabled = false;
             }
             else
             {
-                NetworkManager.Singleton.OnClientDisconnectCallback += OnClientDisconnectCallback;
+                NetworkManager.Singleton.OnConnectionEvent += OnConnectionEvent;
                 networkCharSelection.OnClientChangedSeat += OnClientChangedSeat;
 
                 NetworkManager.Singleton.SceneManager.OnSceneEvent += OnSceneEvent;
@@ -276,22 +276,25 @@ void SeatNewPlayer(ulong clientId)
             }
         }
 
-        void OnClientDisconnectCallback(ulong clientId)
+        void OnConnectionEvent(NetworkManager networkManager, ConnectionEventData connectionEventData)
         {
-            // clear this client's PlayerNumber and any associated visuals (so other players know they're gone).
-            for (int i = 0; i < networkCharSelection.sessionPlayers.Count; ++i)
+            if (connectionEventData.EventType == ConnectionEvent.ClientDisconnected)
             {
-                if (networkCharSelection.sessionPlayers[i].ClientId == clientId)
+                // clear this client's PlayerNumber and any associated visuals (so other players know they're gone).
+                for (int i = 0; i < networkCharSelection.sessionPlayers.Count; ++i)
                 {
-                    networkCharSelection.sessionPlayers.RemoveAt(i);
-                    break;
+                    if (networkCharSelection.sessionPlayers[i].ClientId == connectionEventData.ClientId)
+                    {
+                        networkCharSelection.sessionPlayers.RemoveAt(i);
+                        break;
+                    }
                 }
-            }
 
-            if (!networkCharSelection.IsSessionClosed.Value)
-            {
-                // If the Session is not already closing, close if the remaining players are all ready
-                CloseSessionIfReady();
+                if (!networkCharSelection.IsSessionClosed.Value)
+                {
+                    // If the Session is not already closing, close if the remaining players are all ready
+                    CloseSessionIfReady();
+                }
             }
         }
     }
diff --git a/Assets/Scripts/Infrastructure/PubSub/NetworkedMessageChannel.cs b/Assets/Scripts/Infrastructure/PubSub/NetworkedMessageChannel.cs
@@ -26,7 +26,7 @@ public NetworkedMessageChannel()
         void InjectDependencies(NetworkManager networkManager)
         {
             m_NetworkManager = networkManager;
-            m_NetworkManager.OnClientConnectedCallback += OnClientConnected;
+            m_NetworkManager.OnConnectionEvent += OnConnectionEvent;
             if (m_NetworkManager.IsListening)
             {
                 RegisterHandler();
@@ -40,14 +40,18 @@ public override void Dispose()
                 if (m_NetworkManager != null && m_NetworkManager.CustomMessagingManager != null)
                 {
                     m_NetworkManager.CustomMessagingManager.UnregisterNamedMessageHandler(m_Name);
+                    m_NetworkManager.OnConnectionEvent -= OnConnectionEvent;
                 }
             }
             base.Dispose();
         }
 
-        void OnClientConnected(ulong clientId)
+        void OnConnectionEvent(NetworkManager networkManager, ConnectionEventData connectionEventData)
         {
-            RegisterHandler();
+            if (connectionEventData.EventType == ConnectionEvent.ClientConnected)
+            {
+                RegisterHandler();
+            }
         }
 
         void RegisterHandler()
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -26,26 +26,27 @@ Additional documentation and release notes are available at [Multiplayer Documen
 * VContainer package upgraded from v1.11.0 to v1.14.0 (#896) This upgrade removes warning messages related to IL weaving as code gen is refactored in v1.14.0
 * Upgraded the project to the New Input System v1.11.2 (#897) Compatibility mode with the previous version has been disabled.
 * Upgraded editor version to 6000.0.42f1 and upgraded packages (#901):
- * com.unity.ai.navigation from v2.0.5 to v2.0.6
- * com.unity.collab-proxy from v2.6.0 to v2.7.1
- * com.unity.inputsystem from v1.11.2 to v1.13.1
- * com.unity.learn.iet-framework from v4.0.3 to v4.0.4
- * com.unity.memoryprofiler from v1.1.3 to v1.1.5
- * com.unity.netcode.gameobjects from v2.1.1 to v2.2.0
- * com.unity.render-pipelines-universal from v17.0.3 to v17.0.4
- * com.unity.services.multiplayer from v1.1.0 to v1.1.1
- * com.unity.test-framework from v1.4.5 to v1.4.6
+  * com.unity.ai.navigation from v2.0.5 to v2.0.6
+  * com.unity.collab-proxy from v2.6.0 to v2.7.1
+  * com.unity.inputsystem from v1.11.2 to v1.13.1
+  * com.unity.learn.iet-framework from v4.0.3 to v4.0.4
+  * com.unity.memoryprofiler from v1.1.3 to v1.1.5
+  * com.unity.netcode.gameobjects from v2.1.1 to v2.2.0
+  * com.unity.render-pipelines-universal from v17.0.3 to v17.0.4
+  * com.unity.services.multiplayer from v1.1.0 to v1.1.1
+  * com.unity.test-framework from v1.4.5 to v1.4.6
 * Upgraded editor version to 6000.0.44f1 and upgraded packages (#902):
- * com.unity.ide.rider from v3.0.34 to v3.0.35
- * com.unity.services.multiplayer from v1.1.1 to v1.1.2
- * com.unity.test-framework from v1.4.6 to v1.5.1
- * com.unity.transport from v2.4.0 to v2.5.0
- * com.unity.cinemachine from v.3.1.2 to 3.1.3
- * com.unity.services.authentication from 3.4.0 to 3.4.1
- * jp.hadashikick.vcontainer from 1.14.0 to 1.16.8
- * com.unity.memoryprofiler from 1.1.5 to 1.1.6
- * com.unity.timeline from 1.8.7 to 1.8.8
+  * com.unity.ide.rider from v3.0.34 to v3.0.35
+  * com.unity.services.multiplayer from v1.1.1 to v1.1.2
+  * com.unity.test-framework from v1.4.6 to v1.5.1
+  * com.unity.transport from v2.4.0 to v2.5.0
+  * com.unity.cinemachine from v.3.1.2 to 3.1.3
+  * com.unity.services.authentication from 3.4.0 to 3.4.1
+  * jp.hadashikick.vcontainer from 1.14.0 to 1.16.8
+  * com.unity.memoryprofiler from 1.1.5 to 1.1.6
+  * com.unity.timeline from 1.8.7 to 1.8.8
 * Upgraded Unity Transport package to 2.5.1 (#906)
+* Upgraded the project to use Netcode for GameObject's recommended OnConnectionEvent callback (#907)
 
 ### Cleanup
 * Removed ParrelSync from the project (#890)
@@ -61,6 +62,7 @@ Additional documentation and release notes are available at [Multiplayer Documen
 * Fixed a visual issue where a selected party member's party HUD slot would be displayed as selected (green) when the same or new party member joins the session in-game (#899)
 * Fixed Render Graph API compatibility mode warning and switched active input handling settings to "both" for removing InvalidOperationException (#901) 
 * Fixed error logged when unsubscribing from Session events when removed from a Session (#905)
+* Fixed error logged when attempting to despawn an already despawned LoadingProgressTracker NetworkObject (#907)
 
 ## [2.5.0] - 2024-04-18
 
diff --git a/Packages/com.unity.multiplayer.samples.coop/CHANGELOG.md b/Packages/com.unity.multiplayer.samples.coop/CHANGELOG.md
@@ -4,12 +4,13 @@
 
 ### Changed
 * Replaced Lobby and Relay standalone packages with the Multiplayer Services package v1.0.2 (#892)
-* Removed UnityRelayUtilities
+  * Removed UnityRelayUtilities
 * Upgrading Editor version dependency to 6000.0 (#902)
 Upgrading package dependencies:
- *   Tutorial Framework upgraded to  v4.0.4
- *   Multiplayer Tools to v2.2.3
- *   Netcode for GameObjects to v2.2.0 
+  * Tutorial Framework upgraded to  v4.0.4
+  * Multiplayer Tools to v2.2.3
+  * Netcode for GameObjects to v2.2.0
+* Upgraded Utilities package to use Netcode for GameObject's recommended OnConnectionEvent callback (#907)
 
 ## [1.9.0] - 2024-04-18
 
diff --git a/Packages/com.unity.multiplayer.samples.coop/Utilities/SceneManagement/LoadingProgressManager.cs b/Packages/com.unity.multiplayer.samples.coop/Utilities/SceneManagement/LoadingProgressManager.cs
@@ -50,8 +50,7 @@ public AsyncOperation LocalLoadOperation
         /// </summary>
         public float LocalProgress
         {
-            get => IsSpawned && ProgressTrackers.ContainsKey(NetworkManager.LocalClientId) ?
-                ProgressTrackers[NetworkManager.LocalClientId].Progress.Value : m_LocalProgress;
+            get => IsSpawned && ProgressTrackers.ContainsKey(NetworkManager.LocalClientId) ? ProgressTrackers[NetworkManager.LocalClientId].Progress.Value : m_LocalProgress;
             private set
             {
                 if (IsSpawned && ProgressTrackers.ContainsKey(NetworkManager.LocalClientId) && ProgressTrackers[NetworkManager.LocalClientId].IsSpawned)
@@ -69,18 +68,17 @@ public override void OnNetworkSpawn()
         {
             if (IsServer)
             {
-                NetworkManager.OnClientConnectedCallback += AddTracker;
-                NetworkManager.OnClientDisconnectCallback += RemoveTracker;
-                AddTracker(NetworkManager.LocalClientId);
+                NetworkManager.OnConnectionEvent += OnConnectionEvent;
             }
         }
+
         public override void OnNetworkDespawn()
         {
             if (IsServer)
             {
-                NetworkManager.OnClientConnectedCallback -= AddTracker;
-                NetworkManager.OnClientDisconnectCallback -= RemoveTracker;
+                NetworkManager.OnConnectionEvent -= OnConnectionEvent;
             }
+
             ProgressTrackers.Clear();
             onTrackersUpdated?.Invoke();
         }
@@ -120,9 +118,30 @@ void ClientUpdateTrackersRpc()
                     }
                 }
             }
+
             onTrackersUpdated?.Invoke();
         }
 
+        void OnConnectionEvent(NetworkManager networkManager, ConnectionEventData connectionEventData)
+        {
+            if (IsServer)
+            {
+                switch (connectionEventData.EventType)
+                {
+                    case ConnectionEvent.ClientConnected:
+                    {
+                        AddTracker(connectionEventData.ClientId);
+                        break;
+                    }
+                    case ConnectionEvent.ClientDisconnected:
+                    {
+                        RemoveTracker(connectionEventData.ClientId);
+                        break;
+                    }
+                }
+            }
+        }
+
         void AddTracker(ulong clientId)
         {
             if (IsServer)
@@ -141,9 +160,7 @@ void RemoveTracker(ulong clientId)
             {
                 if (ProgressTrackers.ContainsKey(clientId))
                 {
-                    var tracker = ProgressTrackers[clientId];
                     ProgressTrackers.Remove(clientId);
-                    tracker.NetworkObject.Despawn();
                     ClientUpdateTrackersRpc();
                 }
             }
diff --git a/Packages/com.unity.multiplayer.samples.coop/Utilities/SceneManagement/ServerAdditiveSceneLoader.cs b/Packages/com.unity.multiplayer.samples.coop/Utilities/SceneManagement/ServerAdditiveSceneLoader.cs
@@ -54,7 +54,7 @@ public override void OnNetworkSpawn()
             {
                 // Adding this to remove all pending references to a specific client when they disconnect, since objects
                 // that are destroyed do not generate OnTriggerExit events.
-                NetworkManager.OnClientDisconnectCallback += RemovePlayer;
+                NetworkManager.OnConnectionEvent += OnConnectionEvent;
 
                 NetworkManager.SceneManager.OnSceneEvent += OnSceneEvent;
                 m_PlayersInTrigger = new List<ulong>();
@@ -65,7 +65,7 @@ public override void OnNetworkDespawn()
         {
             if (IsServer)
             {
-                NetworkManager.OnClientDisconnectCallback -= RemovePlayer;
+                NetworkManager.OnConnectionEvent -= OnConnectionEvent;
                 NetworkManager.SceneManager.OnSceneEvent -= OnSceneEvent;
             }
         }
@@ -136,11 +136,14 @@ void FixedUpdate()
             }
         }
 
-        void RemovePlayer(ulong clientId)
+        void OnConnectionEvent(NetworkManager networkManager, ConnectionEventData connectionEventData)
         {
-            // remove all references to this clientId. There could be multiple references if a single client owns
-            // multiple NetworkObjects with the m_PlayerTag, or if this script's GameObject has overlapping colliders
-            while (m_PlayersInTrigger.Remove(clientId)) { }
+            if (connectionEventData.EventType == ConnectionEvent.ClientDisconnected)
+            {
+                // remove all references to this clientId. There could be multiple references if a single client owns
+                // multiple NetworkObjects with the m_PlayerTag, or if this script's GameObject has overlapping colliders
+                while (m_PlayersInTrigger.Remove(connectionEventData.ClientId)) { }
+            }
         }
 
         IEnumerator WaitToUnloadCoroutine()

Original file line number	Diff line number	Diff line change
`@@ -79,7 +79,7 @@ void OnNetworkSpawn()`
`79`	`79`	`m_PersistentGameState.Reset();`
`80`	`80`	`m_LifeStateChangedEventMessageSubscriber.Subscribe(OnLifeStateChangedEventMessage);`
`81`	`81`
`82`		`- NetworkManager.Singleton.OnClientDisconnectCallback += OnClientDisconnect;`
	`82`	`+ NetworkManager.Singleton.OnConnectionEvent += OnConnectionEvent;`
`83`	`83`	`NetworkManager.Singleton.SceneManager.OnLoadEventCompleted += OnLoadEventCompleted;`
`84`	`84`	`NetworkManager.Singleton.SceneManager.OnSynchronizeComplete += OnSynchronizeComplete;`
`85`	`85`
`@@ -93,7 +93,7 @@ void OnNetworkDespawn()`
`93`	`93`	`m_LifeStateChangedEventMessageSubscriber.Unsubscribe(OnLifeStateChangedEventMessage);`
`94`	`94`	`}`
`95`	`95`
`96`		`- NetworkManager.Singleton.OnClientDisconnectCallback -= OnClientDisconnect;`
	`96`	`+ NetworkManager.Singleton.OnConnectionEvent -= OnConnectionEvent;`
`97`	`97`	`NetworkManager.Singleton.SceneManager.OnLoadEventCompleted -= OnLoadEventCompleted;`
`98`	`98`	`NetworkManager.Singleton.SceneManager.OnSynchronizeComplete -= OnSynchronizeComplete;`
`99`	`99`	`}`
`@@ -138,12 +138,15 @@ void OnLoadEventCompleted(string sceneName, LoadSceneMode loadSceneMode, List<ul`
`138`	`138`	`}`
`139`	`139`	`}`
`140`	`140`
`141`		`- void OnClientDisconnect(ulong clientId)`
	`141`	`+ void OnConnectionEvent(NetworkManager networkManager, ConnectionEventData connectionEventData)`
`142`	`142`	`{`
`143`		`- if (clientId != NetworkManager.Singleton.LocalClientId)`
	`143`	`+ if (connectionEventData.EventType == ConnectionEvent.ClientDisconnected)`
`144`	`144`	`{`
`145`		`- // If a client disconnects, check for game over in case all other players are already down`
`146`		`- StartCoroutine(WaitToCheckForGameOver());`
	`145`	`+ if (connectionEventData.ClientId != networkManager.LocalClientId)`
	`146`	`+ {`
	`147`	`+ // If a client disconnects, check for game over in case all other players are already down`
	`148`	`+ StartCoroutine(WaitToCheckForGameOver());`
	`149`	`+ }`
`147`	`150`	`}`
`148`	`151`	`}`
`149`	`152`
Original file line number	Diff line number	Diff line change
`@@ -184,11 +184,11 @@ IEnumerator WaitToEndSession()`
`184`	`184`	`SceneLoaderWrapper.Instance.LoadScene("BossRoom", useNetworkSceneManager: true);`
`185`	`185`	`}`
`186`	`186`
`187`		`- public void OnNetworkDespawn()`
	`187`	`+ void OnNetworkDespawn()`
`188`	`188`	`{`
`189`	`189`	`if (NetworkManager.Singleton)`
`190`	`190`	`{`
`191`		`- NetworkManager.Singleton.OnClientDisconnectCallback -= OnClientDisconnectCallback;`
	`191`	`+ NetworkManager.Singleton.OnConnectionEvent -= OnConnectionEvent;`
`192`	`192`	`NetworkManager.Singleton.SceneManager.OnSceneEvent -= OnSceneEvent;`
`193`	`193`	`}`
`194`	`194`	`if (networkCharSelection)`
`@@ -197,15 +197,15 @@ public void OnNetworkDespawn()`
`197`	`197`	`}`
`198`	`198`	`}`
`199`	`199`
`200`		`- public void OnNetworkSpawn()`
	`200`	`+ void OnNetworkSpawn()`
`201`	`201`	`{`
`202`	`202`	`if (!NetworkManager.Singleton.IsServer)`
`203`	`203`	`{`
`204`	`204`	`enabled = false;`
`205`	`205`	`}`
`206`	`206`	`else`
`207`	`207`	`{`
`208`		`- NetworkManager.Singleton.OnClientDisconnectCallback += OnClientDisconnectCallback;`
	`208`	`+ NetworkManager.Singleton.OnConnectionEvent += OnConnectionEvent;`
`209`	`209`	`networkCharSelection.OnClientChangedSeat += OnClientChangedSeat;`
`210`	`210`
`211`	`211`	`NetworkManager.Singleton.SceneManager.OnSceneEvent += OnSceneEvent;`
`@@ -276,22 +276,25 @@ void SeatNewPlayer(ulong clientId)`
`276`	`276`	`}`
`277`	`277`	`}`
`278`	`278`
`279`		`- void OnClientDisconnectCallback(ulong clientId)`
	`279`	`+ void OnConnectionEvent(NetworkManager networkManager, ConnectionEventData connectionEventData)`
`280`	`280`	`{`
`281`		`- // clear this client's PlayerNumber and any associated visuals (so other players know they're gone).`
`282`		`- for (int i = 0; i < networkCharSelection.sessionPlayers.Count; ++i)`
	`281`	`+ if (connectionEventData.EventType == ConnectionEvent.ClientDisconnected)`
`283`	`282`	`{`
`284`		`- if (networkCharSelection.sessionPlayers[i].ClientId == clientId)`
	`283`	`+ // clear this client's PlayerNumber and any associated visuals (so other players know they're gone).`
	`284`	`+ for (int i = 0; i < networkCharSelection.sessionPlayers.Count; ++i)`
`285`	`285`	`{`
`286`		`- networkCharSelection.sessionPlayers.RemoveAt(i);`
`287`		`- break;`
	`286`	`+ if (networkCharSelection.sessionPlayers[i].ClientId == connectionEventData.ClientId)`
	`287`	`+ {`
	`288`	`+ networkCharSelection.sessionPlayers.RemoveAt(i);`
	`289`	`+ break;`
	`290`	`+ }`
`288`	`291`	`}`
`289`		`- }`
`290`	`292`
`291`		`- if (!networkCharSelection.IsSessionClosed.Value)`
`292`		`- {`
`293`		`- // If the Session is not already closing, close if the remaining players are all ready`
`294`		`- CloseSessionIfReady();`
	`293`	`+ if (!networkCharSelection.IsSessionClosed.Value)`
	`294`	`+ {`
	`295`	`+ // If the Session is not already closing, close if the remaining players are all ready`
	`296`	`+ CloseSessionIfReady();`
	`297`	`+ }`
`295`	`298`	`}`
`296`	`299`	`}`
`297`	`300`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ public NetworkedMessageChannel()`
`26`	`26`	`void InjectDependencies(NetworkManager networkManager)`
`27`	`27`	`{`
`28`	`28`	`m_NetworkManager = networkManager;`
`29`		`- m_NetworkManager.OnClientConnectedCallback += OnClientConnected;`
	`29`	`+ m_NetworkManager.OnConnectionEvent += OnConnectionEvent;`
`30`	`30`	`if (m_NetworkManager.IsListening)`
`31`	`31`	`{`
`32`	`32`	`RegisterHandler();`
`@@ -40,14 +40,18 @@ public override void Dispose()`
`40`	`40`	`if (m_NetworkManager != null && m_NetworkManager.CustomMessagingManager != null)`
`41`	`41`	`{`
`42`	`42`	`m_NetworkManager.CustomMessagingManager.UnregisterNamedMessageHandler(m_Name);`
	`43`	`+ m_NetworkManager.OnConnectionEvent -= OnConnectionEvent;`
`43`	`44`	`}`
`44`	`45`	`}`
`45`	`46`	`base.Dispose();`
`46`	`47`	`}`
`47`	`48`
`48`		`- void OnClientConnected(ulong clientId)`
	`49`	`+ void OnConnectionEvent(NetworkManager networkManager, ConnectionEventData connectionEventData)`
`49`	`50`	`{`
`50`		`- RegisterHandler();`
	`51`	`+ if (connectionEventData.EventType == ConnectionEvent.ClientConnected)`
	`52`	`+ {`
	`53`	`+ RegisterHandler();`
	`54`	`+ }`
`51`	`55`	`}`
`52`	`56`
`53`	`57`	`void RegisterHandler()`
Original file line number	Diff line number	Diff line change
`@@ -50,8 +50,7 @@ public AsyncOperation LocalLoadOperation`
`50`	`50`	`/// </summary>`
`51`	`51`	`public float LocalProgress`
`52`	`52`	`{`
`53`		`- get => IsSpawned && ProgressTrackers.ContainsKey(NetworkManager.LocalClientId) ?`
`54`		`- ProgressTrackers[NetworkManager.LocalClientId].Progress.Value : m_LocalProgress;`
	`53`	`+ get => IsSpawned && ProgressTrackers.ContainsKey(NetworkManager.LocalClientId) ? ProgressTrackers[NetworkManager.LocalClientId].Progress.Value : m_LocalProgress;`
`55`	`54`	`private set`
`56`	`55`	`{`
`57`	`56`	`if (IsSpawned && ProgressTrackers.ContainsKey(NetworkManager.LocalClientId) && ProgressTrackers[NetworkManager.LocalClientId].IsSpawned)`
`@@ -69,18 +68,17 @@ public override void OnNetworkSpawn()`
`69`	`68`	`{`
`70`	`69`	`if (IsServer)`
`71`	`70`	`{`
`72`		`- NetworkManager.OnClientConnectedCallback += AddTracker;`
`73`		`- NetworkManager.OnClientDisconnectCallback += RemoveTracker;`
`74`		`- AddTracker(NetworkManager.LocalClientId);`
	`71`	`+ NetworkManager.OnConnectionEvent += OnConnectionEvent;`
`75`	`72`	`}`
`76`	`73`	`}`
	`74`	`+`
`77`	`75`	`public override void OnNetworkDespawn()`
`78`	`76`	`{`
`79`	`77`	`if (IsServer)`
`80`	`78`	`{`
`81`		`- NetworkManager.OnClientConnectedCallback -= AddTracker;`
`82`		`- NetworkManager.OnClientDisconnectCallback -= RemoveTracker;`
	`79`	`+ NetworkManager.OnConnectionEvent -= OnConnectionEvent;`
`83`	`80`	`}`
	`81`	`+`
`84`	`82`	`ProgressTrackers.Clear();`
`85`	`83`	`onTrackersUpdated?.Invoke();`
`86`	`84`	`}`
`@@ -120,9 +118,30 @@ void ClientUpdateTrackersRpc()`
`120`	`118`	`}`
`121`	`119`	`}`
`122`	`120`	`}`
	`121`	`+`
`123`	`122`	`onTrackersUpdated?.Invoke();`
`124`	`123`	`}`
`125`	`124`
	`125`	`+ void OnConnectionEvent(NetworkManager networkManager, ConnectionEventData connectionEventData)`
	`126`	`+ {`
	`127`	`+ if (IsServer)`
	`128`	`+ {`
	`129`	`+ switch (connectionEventData.EventType)`
	`130`	`+ {`
	`131`	`+ case ConnectionEvent.ClientConnected:`
	`132`	`+ {`
	`133`	`+ AddTracker(connectionEventData.ClientId);`
	`134`	`+ break;`
	`135`	`+ }`
	`136`	`+ case ConnectionEvent.ClientDisconnected:`
	`137`	`+ {`
	`138`	`+ RemoveTracker(connectionEventData.ClientId);`
	`139`	`+ break;`
	`140`	`+ }`
	`141`	`+ }`
	`142`	`+ }`
	`143`	`+ }`
	`144`	`+`
`126`	`145`	`void AddTracker(ulong clientId)`
`127`	`146`	`{`
`128`	`147`	`if (IsServer)`
`@@ -141,9 +160,7 @@ void RemoveTracker(ulong clientId)`
`141`	`160`	`{`
`142`	`161`	`if (ProgressTrackers.ContainsKey(clientId))`
`143`	`162`	`{`
`144`		`- var tracker = ProgressTrackers[clientId];`
`145`	`163`	`ProgressTrackers.Remove(clientId);`
`146`		`- tracker.NetworkObject.Despawn();`
`147`	`164`	`ClientUpdateTrackersRpc();`
`148`	`165`	`}`
`149`	`166`	`}`
Original file line number	Diff line number	Diff line change
`@@ -54,7 +54,7 @@ public override void OnNetworkSpawn()`
`54`	`54`	`{`
`55`	`55`	`// Adding this to remove all pending references to a specific client when they disconnect, since objects`
`56`	`56`	`// that are destroyed do not generate OnTriggerExit events.`
`57`		`- NetworkManager.OnClientDisconnectCallback += RemovePlayer;`
	`57`	`+ NetworkManager.OnConnectionEvent += OnConnectionEvent;`
`58`	`58`
`59`	`59`	`NetworkManager.SceneManager.OnSceneEvent += OnSceneEvent;`
`60`	`60`	`m_PlayersInTrigger = new List<ulong>();`
`@@ -65,7 +65,7 @@ public override void OnNetworkDespawn()`
`65`	`65`	`{`
`66`	`66`	`if (IsServer)`
`67`	`67`	`{`
`68`		`- NetworkManager.OnClientDisconnectCallback -= RemovePlayer;`
	`68`	`+ NetworkManager.OnConnectionEvent -= OnConnectionEvent;`
`69`	`69`	`NetworkManager.SceneManager.OnSceneEvent -= OnSceneEvent;`
`70`	`70`	`}`
`71`	`71`	`}`
`@@ -136,11 +136,14 @@ void FixedUpdate()`
`136`	`136`	`}`
`137`	`137`	`}`
`138`	`138`
`139`		`- void RemovePlayer(ulong clientId)`
	`139`	`+ void OnConnectionEvent(NetworkManager networkManager, ConnectionEventData connectionEventData)`
`140`	`140`	`{`
`141`		`- // remove all references to this clientId. There could be multiple references if a single client owns`
`142`		`- // multiple NetworkObjects with the m_PlayerTag, or if this script's GameObject has overlapping colliders`
`143`		`- while (m_PlayersInTrigger.Remove(clientId)) { }`
	`141`	`+ if (connectionEventData.EventType == ConnectionEvent.ClientDisconnected)`
	`142`	`+ {`
	`143`	`+ // remove all references to this clientId. There could be multiple references if a single client owns`
	`144`	`+ // multiple NetworkObjects with the m_PlayerTag, or if this script's GameObject has overlapping colliders`
	`145`	`+ while (m_PlayersInTrigger.Remove(connectionEventData.ClientId)) { }`
	`146`	`+ }`
`144`	`147`	`}`
`145`	`148`
`146`	`149`	`IEnumerator WaitToUnloadCoroutine()`