fix: scenemanager clean up ScenesLoaded after synch unloading of remaining scenes not used (#2971)

* fix

This resolves an issue where if you set remaining loaded scenes to be unloaded after synchronization the synchronized scenes loaded list is not updated which provides a false positive of a scene being loaded and synchronized.

* fix

Fixing issue with 6000.0.11f1 changes to velocity and isKinematic.

* fix

Missed one spot where Rigidbody2D.velocity was being used.
Noticed a bug where it was using Rigidbody2D.velocity as opposed to Rigidbody2D.angularVelocity.

* test

adding validation test for PR fixes

* update

adding changelog entries.

Author: NoelStephensUnity

com.unity.netcode.gameobjects/CHANGELOG.md

@@ -12,6 +12,8 @@ Additional documentation and release notes are available at [Multiplayer Documen
 
 ### Fixed
 
+- Fixed issue where `NetworkManager.ScenesLoaded` was not being updated if `PostSynchronizationSceneUnloading` was set and any loaded scenes not used during synchronization were unloaded. (#2971)
+- Fixed issue where `Rigidbody2d` under Unity 6000.0.11f1 has breaking changes where `velocity` is now `linearVelocity` and `isKinematic` is replaced by `bodyType`. (#2971)
 - Fixed issue where `NetworkSpawnManager.InstantiateAndSpawn` and `NetworkObject.InstantiateAndSpawn` were not honoring the ownerClientId parameter when using a client-server network topology. (#2968)
 - Fixed issue where internal delta serialization could not have a byte serializer defined when serializing deltas for other types. Added `[GenerateSerializationForType(typeof(byte))]` to both the `NetworkVariable` and `AnticipatedNetworkVariable` classes to assure a byte serializer is defined.(#2962)
 - Fixed issue when scene management was disabled and the session owner would still try to synchronize a late joining client. (#2962)

com.unity.netcode.gameobjects/Runtime/Components/NetworkRigidBodyBase.cs

@@ -177,7 +177,11 @@ public void SetLinearVelocity(Vector3 linearVelocity)
         {
             if (m_IsRigidbody2D)
             {
+#if COM_UNITY_MODULES_PHYSICS2D_LINEAR
+                m_Rigidbody2D.linearVelocity = linearVelocity;
+#else
                 m_Rigidbody2D.velocity = linearVelocity;
+#endif
             }
             else
             {
@@ -197,7 +201,11 @@ public Vector3 GetLinearVelocity()
         {
             if (m_IsRigidbody2D)
             {
+#if COM_UNITY_MODULES_PHYSICS2D_LINEAR
+                return m_Rigidbody2D.linearVelocity;
+#else
                 return m_Rigidbody2D.velocity;
+#endif
             }
             else
             {
@@ -238,7 +246,7 @@ public Vector3 GetAngularVelocity()
         {
             if (m_IsRigidbody2D)
             {
-                return Vector3.forward * m_Rigidbody2D.velocity;
+                return Vector3.forward * m_Rigidbody2D.angularVelocity;
             }
             else
             {
@@ -481,7 +489,7 @@ public bool IsKinematic()
         {
             if (m_IsRigidbody2D)
             {
-                return m_Rigidbody2D.isKinematic;
+                return m_Rigidbody2D.bodyType == RigidbodyType2D.Kinematic;
             }
             else
             {
@@ -510,7 +518,7 @@ public void SetIsKinematic(bool isKinematic)
         {
             if (m_IsRigidbody2D)
             {
-                m_Rigidbody2D.isKinematic = isKinematic;
+                m_Rigidbody2D.bodyType = isKinematic ? RigidbodyType2D.Kinematic : RigidbodyType2D.Dynamic;
             }
             else
             {
@@ -715,7 +723,11 @@ private void ApplyFixedJoint2D(NetworkRigidbodyBase bodyToConnect, Vector3 posit
 
             if (zeroVelocity)
             {
+#if COM_UNITY_MODULES_PHYSICS2D_LINEAR
+                m_Rigidbody2D.linearVelocity = Vector2.zero;
+#else
                 m_Rigidbody2D.velocity = Vector2.zero;
+#endif
                 m_Rigidbody2D.angularVelocity = 0.0f;
             }
 

com.unity.netcode.gameobjects/Runtime/SceneManagement/DefaultSceneManagerHandler.cs

@@ -227,6 +227,11 @@ public void UnloadUnassignedScenes(NetworkManager networkManager = null)
             foreach (var sceneToUnload in m_ScenesToUnload)
             {
                 SceneManager.UnloadSceneAsync(sceneToUnload);
+                // Update the ScenesLoaded when we unload scenes
+                if (sceneManager.ScenesLoaded.ContainsKey(sceneToUnload.handle))
+                {
+                    sceneManager.ScenesLoaded.Remove(sceneToUnload.handle);
+                }
             }
         }
 

com.unity.netcode.gameobjects/Runtime/SceneManagement/NetworkSceneManager.cs

@@ -2406,16 +2406,6 @@ private void HandleClientSceneEvent(uint sceneEventId)
                                 NetworkManager.ConnectionManager.CreateAndSpawnPlayer(NetworkManager.LocalClientId);
                             }
 
-                            // Client is now synchronized and fully "connected".  This also means the client can send "RPCs" at this time
-                            NetworkManager.ConnectionManager.InvokeOnClientConnectedCallback(NetworkManager.LocalClientId);
-
-                            // Notify the client that they have finished synchronizing
-                            OnSceneEvent?.Invoke(new SceneEvent()
-                            {
-                                SceneEventType = sceneEventData.SceneEventType,
-                                ClientId = NetworkManager.LocalClientId, // Client sent this to the server
-                            });
-
                             // Process any SceneEventType.ObjectSceneChanged messages that
                             // were deferred while synchronizing and migrate the associated
                             // NetworkObjects to their newly assigned scenes.
@@ -2429,6 +2419,16 @@ private void HandleClientSceneEvent(uint sceneEventId)
                                 SceneManagerHandler.UnloadUnassignedScenes(NetworkManager);
                             }
 
+                            // Client is now synchronized and fully "connected".  This also means the client can send "RPCs" at this time
+                            NetworkManager.ConnectionManager.InvokeOnClientConnectedCallback(NetworkManager.LocalClientId);
+
+                            // Notify the client that they have finished synchronizing
+                            OnSceneEvent?.Invoke(new SceneEvent()
+                            {
+                                SceneEventType = sceneEventData.SceneEventType,
+                                ClientId = NetworkManager.LocalClientId, // Client sent this to the server
+                            });
+
                             OnSynchronizeComplete?.Invoke(NetworkManager.LocalClientId);
 
                             if (NetworkLog.CurrentLogLevel <= LogLevel.Developer)

com.unity.netcode.gameobjects/Runtime/com.unity.netcode.runtime.asmdef

@@ -72,6 +72,11 @@
             "name": "com.unity.services.multiplayer",
             "expression": "0.2.0",
             "define": "MULTIPLAYER_SERVICES_SDK_INSTALLED"
+        },
+        {
+            "name": "Unity",
+            "expression": "6000.0.11f1",
+            "define": "COM_UNITY_MODULES_PHYSICS2D_LINEAR"
         }
     ],
     "noEngineReferences": false

com.unity.netcode.gameobjects/TestHelpers/Runtime/IntegrationTestSceneHandler.cs

@@ -677,6 +677,11 @@ public void UnloadUnassignedScenes(NetworkManager networkManager = null)
             foreach (var sceneToUnload in m_ScenesToUnload)
             {
                 SceneManager.UnloadSceneAsync(sceneToUnload.Key);
+                // Update the ScenesLoaded when we unload scenes
+                if (sceneManager.ScenesLoaded.ContainsKey(sceneToUnload.Key.handle))
+                {
+                    sceneManager.ScenesLoaded.Remove(sceneToUnload.Key.handle);
+                }
             }
         }
 

testproject/Assets/Tests/Runtime/NetworkSceneManager/NetworkSceneManagerSeneVerification.cs

@@ -361,11 +361,28 @@ public IEnumerator SceneVerifyBeforeLoadTest()
             }
 
             m_IsTestingVerifyScene = false;
+            var currentSceneName = m_CurrentScene;
             Assert.AreEqual(m_ServerNetworkManager.SceneManager.UnloadScene(m_CurrentScene), SceneEventProgressStatus.Started);
 
             // Now wait for scenes to unload
             yield return WaitForConditionOrTimeOut(ConditionPassed);
             AssertOnTimeout($"Timed out waiting for all clients to unload {m_CurrentSceneName}!\n{PrintFailedCondition()}");
+
+            // Verify that all NetworkSceneManager instances reflect the change in scenes synchronized
+            var scenesSynchronized = m_ServerNetworkManager.SceneManager.GetSynchronizedScenes();
+            foreach (var scene in scenesSynchronized)
+            {
+                Assert.False(scene.name.Equals(currentSceneName), $"Host still thinks scene {currentSceneName} is loaded and synchronized!");
+            }
+
+            foreach (var client in m_ClientNetworkManagers)
+            {
+                scenesSynchronized = client.SceneManager.GetSynchronizedScenes();
+                foreach (var scene in scenesSynchronized)
+                {
+                    Assert.False(scene.name.Equals(currentSceneName), $"Client-{client.LocalClientId} still thinks scene {currentSceneName} is loaded and synchronized!");
+                }
+            }
         }
     }
 }