refactor project and Utilities package to use OnConnectionEvent callback

fernando-cortez · fernando-cortez · commit 593a960f1356 · 2025-04-04T19:38:15.000-04:00
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/Packages/com.unity.multiplayer.samples.coop/Utilities/SceneManagement/LoadingProgressManager.cs b/Packages/com.unity.multiplayer.samples.coop/Utilities/SceneManagement/LoadingProgressManager.cs
@@ -69,17 +69,14 @@ 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();
@@ -122,6 +119,26 @@ 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)
         {
@@ -141,9 +158,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
`@@ -69,17 +69,14 @@ public override void OnNetworkSpawn()`
`69`	`69`	`{`
`70`	`70`	`if (IsServer)`
`71`	`71`	`{`
`72`		`- NetworkManager.OnClientConnectedCallback += AddTracker;`
`73`		`- NetworkManager.OnClientDisconnectCallback += RemoveTracker;`
`74`		`- AddTracker(NetworkManager.LocalClientId);`
	`72`	`+ NetworkManager.OnConnectionEvent += OnConnectionEvent;`
`75`	`73`	`}`
`76`	`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`	`}`
`84`	`81`	`ProgressTrackers.Clear();`
`85`	`82`	`onTrackersUpdated?.Invoke();`
`@@ -122,6 +119,26 @@ void ClientUpdateTrackersRpc()`
`122`	`119`	`}`
`123`	`120`	`onTrackersUpdated?.Invoke();`
`124`	`121`	`}`
	`122`	`+`
	`123`	`+ void OnConnectionEvent(NetworkManager networkManager, ConnectionEventData connectionEventData)`
	`124`	`+ {`
	`125`	`+ if (IsServer)`
	`126`	`+ {`
	`127`	`+ switch (connectionEventData.EventType)`
	`128`	`+ {`
	`129`	`+ case ConnectionEvent.ClientConnected:`
	`130`	`+ {`
	`131`	`+ AddTracker(connectionEventData.ClientId);`
	`132`	`+ break;`
	`133`	`+ }`
	`134`	`+ case ConnectionEvent.ClientDisconnected:`
	`135`	`+ {`
	`136`	`+ RemoveTracker(connectionEventData.ClientId);`
	`137`	`+ break;`
	`138`	`+ }`
	`139`	`+ }`
	`140`	`+ }`
	`141`	`+ }`
`125`	`142`
`126`	`143`	`void AddTracker(ulong clientId)`
`127`	`144`	`{`
`@@ -141,9 +158,7 @@ void RemoveTracker(ulong clientId)`
`141`	`158`	`{`
`142`	`159`	`if (ProgressTrackers.ContainsKey(clientId))`
`143`	`160`	`{`
`144`		`- var tracker = ProgressTrackers[clientId];`
`145`	`161`	`ProgressTrackers.Remove(clientId);`
`146`		`- tracker.NetworkObject.Despawn();`
`147`	`162`	`ClientUpdateTrackersRpc();`
`148`	`163`	`}`
`149`	`164`	`}`
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()`