chore: migrating PR-2320 (FindObjectsByType) into v1.2.0 release branch (#2325)

NoelStephensUnity · web-flow · commit 2b630038c4d0 · 2022-12-01T09:50:18.000-08:00
fix: This fixes the issue with recent 2023 update where FindObjectsOfType was renamed to FindObjectsByType (#2320) * update Adding the 2023.1.a21 FindObjectsByType fix for NGO using the UNITY_2023_1_OR_NEWER define. Modified a few of the FindObjectsSortMode for areas that looked like they might require their results ordered by InstanceID.
diff --git a/com.unity.netcode.gameobjects/Editor/NetworkManagerHelper.cs b/com.unity.netcode.gameobjects/Editor/NetworkManagerHelper.cs
@@ -65,7 +65,11 @@ private static void ScenesInBuildActiveSceneCheck()
             var scenesList = EditorBuildSettings.scenes.ToList();
             var activeScene = SceneManager.GetActiveScene();
             var isSceneInBuildSettings = scenesList.Count((c) => c.path == activeScene.path) == 1;
+#if UNITY_2023_1_OR_NEWER
+            var networkManager = Object.FindFirstObjectByType<NetworkManager>();
+#else
             var networkManager = Object.FindObjectOfType<NetworkManager>();
+#endif
             if (!isSceneInBuildSettings && networkManager != null)
             {
                 if (networkManager.NetworkConfig != null && networkManager.NetworkConfig.EnableSceneManagement)
diff --git a/com.unity.netcode.gameobjects/Runtime/SceneManagement/NetworkSceneManager.cs b/com.unity.netcode.gameobjects/Runtime/SceneManagement/NetworkSceneManager.cs
@@ -2018,7 +2018,11 @@ internal void PopulateScenePlacedObjects(Scene sceneToFilterBy, bool clearSceneP
                 ScenePlacedObjects.Clear();
             }
 
+#if UNITY_2023_1_OR_NEWER
+            var networkObjects = UnityEngine.Object.FindObjectsByType<NetworkObject>(FindObjectsSortMode.InstanceID);
+#else
             var networkObjects = UnityEngine.Object.FindObjectsOfType<NetworkObject>();
+#endif
 
             // Just add every NetworkObject found that isn't already in the list
             // With additive scenes, we can have multiple in-scene placed NetworkObjects with the same GlobalObjectIdHash value
diff --git a/com.unity.netcode.gameobjects/Runtime/SceneManagement/SceneEventData.cs b/com.unity.netcode.gameobjects/Runtime/SceneManagement/SceneEventData.cs
@@ -269,7 +269,12 @@ internal void AddDespawnedInSceneNetworkObjects()
         {
             m_DespawnedInSceneObjectsSync.Clear();
             // Find all active and non-active in-scene placed NetworkObjects
+#if UNITY_2023_1_OR_NEWER
+            var inSceneNetworkObjects = UnityEngine.Object.FindObjectsByType<NetworkObject>(UnityEngine.FindObjectsInactive.Include, UnityEngine.FindObjectsSortMode.InstanceID).Where((c) => c.NetworkManager == m_NetworkManager);
+#else
             var inSceneNetworkObjects = UnityEngine.Object.FindObjectsOfType<NetworkObject>(includeInactive: true).Where((c) => c.NetworkManager == m_NetworkManager);
+
+#endif
             foreach (var sobj in inSceneNetworkObjects)
             {
                 if (sobj.IsSceneObject.HasValue && sobj.IsSceneObject.Value && !sobj.IsSpawned)
@@ -657,7 +662,11 @@ internal void ReadClientReSynchronizationData(FastBufferReader reader)
 
             if (networkObjectsToRemove.Length > 0)
             {
+#if UNITY_2023_1_OR_NEWER
+                var networkObjects = UnityEngine.Object.FindObjectsByType<NetworkObject>(UnityEngine.FindObjectsSortMode.InstanceID);
+#else
                 var networkObjects = UnityEngine.Object.FindObjectsOfType<NetworkObject>();
+#endif
                 var networkObjectIdToNetworkObject = new Dictionary<ulong, NetworkObject>();
                 foreach (var networkObject in networkObjects)
                 {
@@ -785,8 +794,14 @@ private void DeserializeDespawnedInScenePlacedNetworkObjects()
                             var objectRelativeScene = m_NetworkManager.SceneManager.ScenesLoaded[localSceneHandle];
 
                             // Find all active and non-active in-scene placed NetworkObjects
+#if UNITY_2023_1_OR_NEWER
+                            var inSceneNetworkObjects = UnityEngine.Object.FindObjectsByType<NetworkObject>(UnityEngine.FindObjectsInactive.Include, UnityEngine.FindObjectsSortMode.InstanceID).Where((c) =>
+                            c.GetSceneOriginHandle() == localSceneHandle && (c.IsSceneObject != false)).ToList();
+#else
                             var inSceneNetworkObjects = UnityEngine.Object.FindObjectsOfType<NetworkObject>(includeInactive: true).Where((c) =>
                             c.GetSceneOriginHandle() == localSceneHandle && (c.IsSceneObject != false)).ToList();
+#endif
+
 
                             foreach (var inSceneObject in inSceneNetworkObjects)
                             {
diff --git a/com.unity.netcode.gameobjects/Runtime/Spawning/NetworkSpawnManager.cs b/com.unity.netcode.gameobjects/Runtime/Spawning/NetworkSpawnManager.cs
@@ -658,7 +658,11 @@ internal void DespawnObject(NetworkObject networkObject, bool destroyObject = fa
         // Makes scene objects ready to be reused
         internal void ServerResetShudownStateForSceneObjects()
         {
+#if UNITY_2023_1_OR_NEWER
+            var networkObjects = UnityEngine.Object.FindObjectsByType<NetworkObject>(FindObjectsSortMode.InstanceID).Where((c) => c.IsSceneObject != null && c.IsSceneObject == true);
+#else
             var networkObjects = UnityEngine.Object.FindObjectsOfType<NetworkObject>().Where((c) => c.IsSceneObject != null && c.IsSceneObject == true);
+#endif
             foreach (var sobj in networkObjects)
             {
                 sobj.IsSpawned = false;
@@ -689,7 +693,11 @@ internal void ServerDestroySpawnedSceneObjects()
 
         internal void DespawnAndDestroyNetworkObjects()
         {
+#if UNITY_2023_1_OR_NEWER
+            var networkObjects = UnityEngine.Object.FindObjectsByType<NetworkObject>(FindObjectsSortMode.InstanceID);
+#else
             var networkObjects = UnityEngine.Object.FindObjectsOfType<NetworkObject>();
+#endif
 
             for (int i = 0; i < networkObjects.Length; i++)
             {
@@ -719,7 +727,11 @@ internal void DespawnAndDestroyNetworkObjects()
 
         internal void DestroySceneObjects()
         {
+#if UNITY_2023_1_OR_NEWER
+            var networkObjects = UnityEngine.Object.FindObjectsByType<NetworkObject>(FindObjectsSortMode.InstanceID);
+#else
             var networkObjects = UnityEngine.Object.FindObjectsOfType<NetworkObject>();
+#endif
 
             for (int i = 0; i < networkObjects.Length; i++)
             {
@@ -746,7 +758,11 @@ internal void DestroySceneObjects()
 
         internal void ServerSpawnSceneObjectsOnStartSweep()
         {
+#if UNITY_2023_1_OR_NEWER
+            var networkObjects = UnityEngine.Object.FindObjectsByType<NetworkObject>(FindObjectsSortMode.InstanceID);
+#else
             var networkObjects = UnityEngine.Object.FindObjectsOfType<NetworkObject>();
+#endif
             var networkObjectsToSpawn = new List<NetworkObject>();
 
             for (int i = 0; i < networkObjects.Length; i++)
diff --git a/com.unity.netcode.gameobjects/TestHelpers/Runtime/IntegrationTestSceneHandler.cs b/com.unity.netcode.gameobjects/TestHelpers/Runtime/IntegrationTestSceneHandler.cs
@@ -147,7 +147,12 @@ private static void SceneManager_sceneLoaded(Scene scene, LoadSceneMode loadScen
         private static void ProcessInSceneObjects(Scene scene, NetworkManager networkManager)
         {
             // Get all in-scene placed NeworkObjects that were instantiated when this scene loaded
+#if UNITY_2023_1_OR_NEWER
+            var inSceneNetworkObjects = Object.FindObjectsByType<NetworkObject>(FindObjectsSortMode.InstanceID).Where((c) => c.IsSceneObject != false && c.GetSceneOriginHandle() == scene.handle);
+#else
             var inSceneNetworkObjects = Object.FindObjectsOfType<NetworkObject>().Where((c) => c.IsSceneObject != false && c.GetSceneOriginHandle() == scene.handle);
+#endif
+
             foreach (var sobj in inSceneNetworkObjects)
             {
                 if (sobj.NetworkManagerOwner != networkManager)
diff --git a/com.unity.netcode.gameobjects/TestHelpers/Runtime/NetcodeIntegrationTest.cs b/com.unity.netcode.gameobjects/TestHelpers/Runtime/NetcodeIntegrationTest.cs
@@ -442,8 +442,13 @@ private void ClientNetworkManagerPostStart(NetworkManager networkManager)
                 m_PlayerNetworkObjects.Add(networkManager.LocalClientId, new Dictionary<ulong, NetworkObject>());
             }
 
+#if UNITY_2023_1_OR_NEWER
+            // Get all player instances for the current client NetworkManager instance
+            var clientPlayerClones = Object.FindObjectsByType<NetworkObject>(FindObjectsSortMode.None).Where((c) => c.IsPlayerObject && c.OwnerClientId == networkManager.LocalClientId).ToList();
+#else
             // Get all player instances for the current client NetworkManager instance
             var clientPlayerClones = Object.FindObjectsOfType<NetworkObject>().Where((c) => c.IsPlayerObject && c.OwnerClientId == networkManager.LocalClientId).ToList();
+#endif
             // Add this player instance to each client player entry
             foreach (var playerNetworkObject in clientPlayerClones)
             {
@@ -457,9 +462,13 @@ private void ClientNetworkManagerPostStart(NetworkManager networkManager)
                     m_PlayerNetworkObjects[playerNetworkObject.NetworkManager.LocalClientId].Add(networkManager.LocalClientId, playerNetworkObject);
                 }
             }
-
+#if UNITY_2023_1_OR_NEWER
+            // For late joining clients, add the remaining (if any) cloned versions of each client's player
+            clientPlayerClones = Object.FindObjectsByType<NetworkObject>(FindObjectsSortMode.None).Where((c) => c.IsPlayerObject && c.NetworkManager == networkManager).ToList();
+#else
             // For late joining clients, add the remaining (if any) cloned versions of each client's player
             clientPlayerClones = Object.FindObjectsOfType<NetworkObject>().Where((c) => c.IsPlayerObject && c.NetworkManager == networkManager).ToList();
+#endif
             foreach (var playerNetworkObject in clientPlayerClones)
             {
                 if (!m_PlayerNetworkObjects[networkManager.LocalClientId].ContainsKey(playerNetworkObject.OwnerClientId))
@@ -479,7 +488,11 @@ protected void ClientNetworkManagerPostStartInit()
             }
             if (m_UseHost)
             {
+#if UNITY_2023_1_OR_NEWER
+                var clientSideServerPlayerClones = Object.FindObjectsByType<NetworkObject>(FindObjectsSortMode.None).Where((c) => c.IsPlayerObject && c.OwnerClientId == m_ServerNetworkManager.LocalClientId);
+#else
                 var clientSideServerPlayerClones = Object.FindObjectsOfType<NetworkObject>().Where((c) => c.IsPlayerObject && c.OwnerClientId == m_ServerNetworkManager.LocalClientId);
+#endif
                 foreach (var playerNetworkObject in clientSideServerPlayerClones)
                 {
                     // When the server is not the host this needs to be done
@@ -535,8 +548,13 @@ protected IEnumerator StartServerAndClients()
 
                     if (m_UseHost || m_ServerNetworkManager.IsHost)
                     {
+#if UNITY_2023_1_OR_NEWER
+                        // Add the server player instance to all m_ClientSidePlayerNetworkObjects entries
+                        var serverPlayerClones = Object.FindObjectsByType<NetworkObject>(FindObjectsSortMode.None).Where((c) => c.IsPlayerObject && c.OwnerClientId == m_ServerNetworkManager.LocalClientId);
+#else
                         // Add the server player instance to all m_ClientSidePlayerNetworkObjects entries
                         var serverPlayerClones = Object.FindObjectsOfType<NetworkObject>().Where((c) => c.IsPlayerObject && c.OwnerClientId == m_ServerNetworkManager.LocalClientId);
+#endif
                         foreach (var playerNetworkObject in serverPlayerClones)
                         {
                             if (!m_PlayerNetworkObjects.ContainsKey(playerNetworkObject.NetworkManager.LocalClientId))
@@ -726,7 +744,11 @@ protected virtual bool CanDestroyNetworkObject(NetworkObject networkObject)
         /// </summary>
         protected void DestroySceneNetworkObjects()
         {
+#if UNITY_2023_1_OR_NEWER
+            var networkObjects = Object.FindObjectsByType<NetworkObject>(FindObjectsSortMode.InstanceID);
+#else
             var networkObjects = Object.FindObjectsOfType<NetworkObject>();
+#endif
             foreach (var networkObject in networkObjects)
             {
                 // This can sometimes be null depending upon order of operations
diff --git a/com.unity.netcode.gameobjects/Tests/Runtime/AddNetworkPrefabTests.cs b/com.unity.netcode.gameobjects/Tests/Runtime/AddNetworkPrefabTests.cs
@@ -45,14 +45,18 @@ protected override void OnServerAndClientsCreated()
 
         private EmptyComponent GetObjectForClient(ulong clientId)
         {
-            foreach (var component in Object.FindObjectsOfType<EmptyComponent>())
+#if UNITY_2023_1_OR_NEWER
+            var emptyComponents = Object.FindObjectsByType<EmptyComponent>(FindObjectsSortMode.InstanceID);
+#else
+            var emptyComponents = Object.FindObjectsOfType<EmptyComponent>();
+#endif
+            foreach (var component in emptyComponents)
             {
                 if (component.IsSpawned && component.NetworkManager.LocalClientId == clientId)
                 {
                     return component;
                 }
             }
-
             return null;
         }
 
diff --git a/com.unity.netcode.gameobjects/Tests/Runtime/DeferredMessagingTests.cs b/com.unity.netcode.gameobjects/Tests/Runtime/DeferredMessagingTests.cs
@@ -271,14 +271,19 @@ private IEnumerator SpawnClients(bool clearTestDeferredMessageManagerCallFlags =
 
         private T GetComponentForClient<T>(ulong clientId) where T : NetworkBehaviour
         {
-            foreach (var component in Object.FindObjectsOfType<T>())
+#if UNITY_2023_1_OR_NEWER
+            var componentsToFind = Object.FindObjectsByType<T>(FindObjectsSortMode.InstanceID);
+#else
+            var componentsToFind = Object.FindObjectsOfType<T>();
+#endif
+
+            foreach (var component in componentsToFind)
             {
                 if (component.IsSpawned && component.NetworkManager.LocalClientId == clientId)
                 {
                     return component;
                 }
             }
-
             return null;
         }
 
@@ -753,7 +758,13 @@ bool HaveAllClientsSpawned()
             {
                 var found1 = false;
                 var found2 = false;
-                foreach (var component in Object.FindObjectsOfType<DeferredMessageTestRpcComponent>())
+#if UNITY_2023_1_OR_NEWER
+                var deferredMessageTestRpcComponents = Object.FindObjectsByType<DeferredMessageTestRpcComponent>(FindObjectsSortMode.None);
+#else
+                var deferredMessageTestRpcComponents = Object.FindObjectsOfType<DeferredMessageTestRpcComponent>();
+#endif
+
+                foreach (var component in deferredMessageTestRpcComponents)
                 {
                     if (component.IsSpawned && component.NetworkManager.LocalClientId == client.LocalClientId)
                     {
diff --git a/com.unity.netcode.gameobjects/Tests/Runtime/IntegrationTestExamples.cs b/com.unity.netcode.gameobjects/Tests/Runtime/IntegrationTestExamples.cs
@@ -29,10 +29,15 @@ public IEnumerator MyFirstIntegationTest()
         {
             // Check the condition for this test and automatically handle varying processing
             // environments and conditions
+#if UNITY_2023_1_OR_NEWER
+            yield return WaitForConditionOrTimeOut(() =>
+            Object.FindObjectsByType<NetworkVisibilityComponent>(FindObjectsSortMode.None).Where(
+                (c) => c.IsSpawned).Count() == 2);
+#else
             yield return WaitForConditionOrTimeOut(() =>
             Object.FindObjectsOfType<NetworkVisibilityComponent>().Where(
                 (c) => c.IsSpawned).Count() == 2);
-
+#endif
             Assert.False(s_GlobalTimeoutHelper.TimedOut, "Timed out waiting for instances " +
                 "to be detected!");
         }
@@ -64,9 +69,15 @@ public IEnumerator MyFirstIntegationTest()
         {
             // Check the condition for this test and automatically handle varying processing
             // environments and conditions
+#if UNITY_2023_1_OR_NEWER
+            yield return WaitForConditionOrTimeOut(() =>
+            Object.FindObjectsByType<NetworkVisibilityComponent>(FindObjectsSortMode.None).Where(
+                (c) => c.IsSpawned).Count() == 2);
+#else
             yield return WaitForConditionOrTimeOut(() =>
             Object.FindObjectsOfType<NetworkVisibilityComponent>().Where(
                 (c) => c.IsSpawned).Count() == 2);
+#endif
 
             Assert.False(s_GlobalTimeoutHelper.TimedOut, "Timed out waiting for instances " +
                 "to be detected!");
diff --git a/com.unity.netcode.gameobjects/Tests/Runtime/NetworkObject/NetworkObjectNetworkClientOwnedObjectsTests.cs b/com.unity.netcode.gameobjects/Tests/Runtime/NetworkObject/NetworkObjectNetworkClientOwnedObjectsTests.cs
@@ -89,7 +89,12 @@ public IEnumerator WhenOwnershipIsChanged_OwnershipValuesUpdateCorrectly()
             Assert.IsFalse(serverBehaviour.IsOwnedByServer);
             Assert.AreEqual(m_ClientNetworkManagers[0].LocalClientId, serverBehaviour.OwnerClientId);
 
+#if UNITY_2023_1_OR_NEWER
+            var clientObject = Object.FindObjectsByType<NetworkObject>(FindObjectsSortMode.InstanceID).Where((obj) => obj.NetworkManagerOwner == m_ClientNetworkManagers[0]).FirstOrDefault();
+#else
             var clientObject = Object.FindObjectsOfType<NetworkObject>().Where((obj) => obj.NetworkManagerOwner == m_ClientNetworkManagers[0]).FirstOrDefault();
+#endif
+
 
             Assert.IsNotNull(clientObject);
             Assert.IsTrue(clientObject.IsOwner);
diff --git a/com.unity.netcode.gameobjects/Tests/Runtime/NetworkPrefabHandlerTests.cs b/com.unity.netcode.gameobjects/Tests/Runtime/NetworkPrefabHandlerTests.cs
@@ -186,7 +186,12 @@ public void TearDown()
             //Stop, shutdown, and destroy
             NetworkManagerHelper.ShutdownNetworkManager();
 
+#if UNITY_2023_1_OR_NEWER
+            var networkObjects = UnityEngine.Object.FindObjectsByType<NetworkObject>(FindObjectsSortMode.InstanceID).ToList();
+#else
             var networkObjects = UnityEngine.Object.FindObjectsOfType<NetworkObject>().ToList();
+#endif
+
             var networkObjectsList = networkObjects.Where(c => c.name.Contains(k_PrefabObjectName));
             foreach (var networkObject in networkObjectsList)
             {
diff --git a/com.unity.netcode.gameobjects/Tests/Runtime/NetworkVisibilityTests.cs b/com.unity.netcode.gameobjects/Tests/Runtime/NetworkVisibilityTests.cs
@@ -48,7 +48,12 @@ protected override IEnumerator OnServerAndClientsConnected()
         [UnityTest]
         public IEnumerator HiddenObjectsTest()
         {
+#if UNITY_2023_1_OR_NEWER
+            yield return WaitForConditionOrTimeOut(() => Object.FindObjectsByType<NetworkVisibilityComponent>(FindObjectsSortMode.None).Where((c) => c.IsSpawned).Count() == 2);
+#else
             yield return WaitForConditionOrTimeOut(() => Object.FindObjectsOfType<NetworkVisibilityComponent>().Where((c) => c.IsSpawned).Count() == 2);
+#endif
+
             Assert.IsFalse(s_GlobalTimeoutHelper.TimedOut, "Timed out waiting for the visible object count to equal 2!");
         }
     }
diff --git a/testproject/Assets/Tests/Manual/SceneTransitioningAdditive/NetworkManagerMonitor.cs b/testproject/Assets/Tests/Manual/SceneTransitioningAdditive/NetworkManagerMonitor.cs
@@ -10,7 +10,11 @@ public class NetworkManagerMonitor : MonoBehaviour
     // Start is called before the first frame update
     private void Start()
     {
+#if UNITY_2023_1_OR_NEWER
+        var networkManagerInstances = FindObjectsByType<NetworkManager>(FindObjectsSortMode.InstanceID);
+#else
         var networkManagerInstances = FindObjectsOfType<NetworkManager>();
+#endif
         foreach (var instance in networkManagerInstances)
         {
             if (instance.IsListening)
diff --git a/testproject/Assets/Tests/Runtime/AddressablesTests.cs b/testproject/Assets/Tests/Runtime/AddressablesTests.cs
@@ -67,7 +67,12 @@ private IEnumerator SpawnAndValidate(GameObject prefab, bool waitAndAddOnClient
             serverObj.GetComponent<NetworkObject>().NetworkManagerOwner = m_ServerNetworkManager;
             serverObj.GetComponent<NetworkObject>().Spawn();
 
+#if UNITY_2023_1_OR_NEWER
+            var objs = Object.FindObjectsByType<AddressableTestScript>(FindObjectsSortMode.InstanceID);
+#else
             var objs = Object.FindObjectsOfType<AddressableTestScript>();
+#endif
+
             // Prefabs loaded by addressables actually don't show up in this search.
             // Unlike other tests that make prefabs programmatically, those aren't added to the scene until they're instantiated
             Assert.AreEqual(1, objs.Length);
@@ -80,7 +85,11 @@ private IEnumerator SpawnAndValidate(GameObject prefab, bool waitAndAddOnClient
             {
                 // Since it's not added, after the CreateObjectMessage is received, it's not spawned yet
                 // Verify that to be the case as a precondition.
+#if UNITY_2023_1_OR_NEWER
+                objs = Object.FindObjectsByType<AddressableTestScript>(FindObjectsSortMode.InstanceID);
+#else
                 objs = Object.FindObjectsOfType<AddressableTestScript>();
+#endif
                 Assert.AreEqual(1, objs.Length);
                 yield return new WaitUntil(() => Time.realtimeSinceStartup - startTime >= m_ClientNetworkManagers[0].NetworkConfig.SpawnTimeout - 0.25);
                 foreach (var client in m_ClientNetworkManagers)
@@ -89,7 +98,11 @@ private IEnumerator SpawnAndValidate(GameObject prefab, bool waitAndAddOnClient
                 }
             }
 
+#if UNITY_2023_1_OR_NEWER
+            objs = Object.FindObjectsByType<AddressableTestScript>(FindObjectsSortMode.InstanceID);
+#else
             objs = Object.FindObjectsOfType<AddressableTestScript>();
+#endif
             Assert.AreEqual(NumberOfClients + 1, objs.Length);
             foreach (var obj in objs)
             {
diff --git a/testproject/Assets/Tests/Runtime/DontDestroyOnLoadTests.cs b/testproject/Assets/Tests/Runtime/DontDestroyOnLoadTests.cs
@@ -79,7 +79,12 @@ public IEnumerator Teardown()
             m_ServerNetworkManager = null;
             m_ClientNetworkManagers = null;
 
+#if UNITY_2023_1_OR_NEWER
+            var networkObjects = Object.FindObjectsByType<NetworkObject>(FindObjectsSortMode.InstanceID);
+#else
             var networkObjects = Object.FindObjectsOfType<NetworkObject>();
+#endif
+
             foreach (var netObject in networkObjects)
             {
                 Object.DestroyImmediate(netObject);
diff --git a/testproject/Assets/Tests/Runtime/MultiprocessRuntime/NetworkVariablePerformanceTests.cs b/testproject/Assets/Tests/Runtime/MultiprocessRuntime/NetworkVariablePerformanceTests.cs
diff --git a/testproject/Assets/Tests/Runtime/NetworkManagerTests.cs b/testproject/Assets/Tests/Runtime/NetworkManagerTests.cs
diff --git a/testproject/Assets/Tests/Runtime/NetworkVariableInitializationOnNetworkSpawnTest.cs b/testproject/Assets/Tests/Runtime/NetworkVariableInitializationOnNetworkSpawnTest.cs
diff --git a/testproject/Assets/Tests/Runtime/SceneObjectsNotDestroyedOnShutdownTest.cs b/testproject/Assets/Tests/Runtime/SceneObjectsNotDestroyedOnShutdownTest.cs

Original file line number	Diff line number	Diff line change
`@@ -658,7 +658,11 @@ internal void DespawnObject(NetworkObject networkObject, bool destroyObject = fa`
`658`	`658`	`// Makes scene objects ready to be reused`
`659`	`659`	`internal void ServerResetShudownStateForSceneObjects()`
`660`	`660`	`{`
	`661`	`+#if UNITY_2023_1_OR_NEWER`
	`662`	`+ var networkObjects = UnityEngine.Object.FindObjectsByType<NetworkObject>(FindObjectsSortMode.InstanceID).Where((c) => c.IsSceneObject != null && c.IsSceneObject == true);`
	`663`	`+#else`
`661`	`664`	`var networkObjects = UnityEngine.Object.FindObjectsOfType<NetworkObject>().Where((c) => c.IsSceneObject != null && c.IsSceneObject == true);`
	`665`	`+#endif`
`662`	`666`	`foreach (var sobj in networkObjects)`
`663`	`667`	`{`
`664`	`668`	`sobj.IsSpawned = false;`
`@@ -689,7 +693,11 @@ internal void ServerDestroySpawnedSceneObjects()`
`689`	`693`
`690`	`694`	`internal void DespawnAndDestroyNetworkObjects()`
`691`	`695`	`{`
	`696`	`+#if UNITY_2023_1_OR_NEWER`
	`697`	`+ var networkObjects = UnityEngine.Object.FindObjectsByType<NetworkObject>(FindObjectsSortMode.InstanceID);`
	`698`	`+#else`
`692`	`699`	`var networkObjects = UnityEngine.Object.FindObjectsOfType<NetworkObject>();`
	`700`	`+#endif`
`693`	`701`
`694`	`702`	`for (int i = 0; i < networkObjects.Length; i++)`
`695`	`703`	`{`
`@@ -719,7 +727,11 @@ internal void DespawnAndDestroyNetworkObjects()`
`719`	`727`
`720`	`728`	`internal void DestroySceneObjects()`
`721`	`729`	`{`
	`730`	`+#if UNITY_2023_1_OR_NEWER`
	`731`	`+ var networkObjects = UnityEngine.Object.FindObjectsByType<NetworkObject>(FindObjectsSortMode.InstanceID);`
	`732`	`+#else`
`722`	`733`	`var networkObjects = UnityEngine.Object.FindObjectsOfType<NetworkObject>();`
	`734`	`+#endif`
`723`	`735`
`724`	`736`	`for (int i = 0; i < networkObjects.Length; i++)`
`725`	`737`	`{`
`@@ -746,7 +758,11 @@ internal void DestroySceneObjects()`
`746`	`758`
`747`	`759`	`internal void ServerSpawnSceneObjectsOnStartSweep()`
`748`	`760`	`{`
	`761`	`+#if UNITY_2023_1_OR_NEWER`
	`762`	`+ var networkObjects = UnityEngine.Object.FindObjectsByType<NetworkObject>(FindObjectsSortMode.InstanceID);`
	`763`	`+#else`
`749`	`764`	`var networkObjects = UnityEngine.Object.FindObjectsOfType<NetworkObject>();`
	`765`	`+#endif`
`750`	`766`	`var networkObjectsToSpawn = new List<NetworkObject>();`
`751`	`767`
`752`	`768`	`for (int i = 0; i < networkObjects.Length; i++)`
Original file line number	Diff line number	Diff line change
`@@ -147,7 +147,12 @@ private static void SceneManager_sceneLoaded(Scene scene, LoadSceneMode loadScen`
`147`	`147`	`private static void ProcessInSceneObjects(Scene scene, NetworkManager networkManager)`
`148`	`148`	`{`
`149`	`149`	`// Get all in-scene placed NeworkObjects that were instantiated when this scene loaded`
	`150`	`+#if UNITY_2023_1_OR_NEWER`
	`151`	`+ var inSceneNetworkObjects = Object.FindObjectsByType<NetworkObject>(FindObjectsSortMode.InstanceID).Where((c) => c.IsSceneObject != false && c.GetSceneOriginHandle() == scene.handle);`
	`152`	`+#else`
`150`	`153`	`var inSceneNetworkObjects = Object.FindObjectsOfType<NetworkObject>().Where((c) => c.IsSceneObject != false && c.GetSceneOriginHandle() == scene.handle);`
	`154`	`+#endif`
	`155`	`+`
`151`	`156`	`foreach (var sobj in inSceneNetworkObjects)`
`152`	`157`	`{`
`153`	`158`	`if (sobj.NetworkManagerOwner != networkManager)`
Original file line number	Diff line number	Diff line change
`@@ -442,8 +442,13 @@ private void ClientNetworkManagerPostStart(NetworkManager networkManager)`
`442`	`442`	`m_PlayerNetworkObjects.Add(networkManager.LocalClientId, new Dictionary<ulong, NetworkObject>());`
`443`	`443`	`}`
`444`	`444`
	`445`	`+#if UNITY_2023_1_OR_NEWER`
	`446`	`+ // Get all player instances for the current client NetworkManager instance`
	`447`	`+ var clientPlayerClones = Object.FindObjectsByType<NetworkObject>(FindObjectsSortMode.None).Where((c) => c.IsPlayerObject && c.OwnerClientId == networkManager.LocalClientId).ToList();`
	`448`	`+#else`
`445`	`449`	`// Get all player instances for the current client NetworkManager instance`
`446`	`450`	`var clientPlayerClones = Object.FindObjectsOfType<NetworkObject>().Where((c) => c.IsPlayerObject && c.OwnerClientId == networkManager.LocalClientId).ToList();`
	`451`	`+#endif`
`447`	`452`	`// Add this player instance to each client player entry`
`448`	`453`	`foreach (var playerNetworkObject in clientPlayerClones)`
`449`	`454`	`{`
`@@ -457,9 +462,13 @@ private void ClientNetworkManagerPostStart(NetworkManager networkManager)`
`457`	`462`	`m_PlayerNetworkObjects[playerNetworkObject.NetworkManager.LocalClientId].Add(networkManager.LocalClientId, playerNetworkObject);`
`458`	`463`	`}`
`459`	`464`	`}`
`460`		`-`
	`465`	`+#if UNITY_2023_1_OR_NEWER`
	`466`	`+ // For late joining clients, add the remaining (if any) cloned versions of each client's player`
	`467`	`+ clientPlayerClones = Object.FindObjectsByType<NetworkObject>(FindObjectsSortMode.None).Where((c) => c.IsPlayerObject && c.NetworkManager == networkManager).ToList();`
	`468`	`+#else`
`461`	`469`	`// For late joining clients, add the remaining (if any) cloned versions of each client's player`
`462`	`470`	`clientPlayerClones = Object.FindObjectsOfType<NetworkObject>().Where((c) => c.IsPlayerObject && c.NetworkManager == networkManager).ToList();`
	`471`	`+#endif`
`463`	`472`	`foreach (var playerNetworkObject in clientPlayerClones)`
`464`	`473`	`{`
`465`	`474`	`if (!m_PlayerNetworkObjects[networkManager.LocalClientId].ContainsKey(playerNetworkObject.OwnerClientId))`
`@@ -479,7 +488,11 @@ protected void ClientNetworkManagerPostStartInit()`
`479`	`488`	`}`
`480`	`489`	`if (m_UseHost)`
`481`	`490`	`{`
	`491`	`+#if UNITY_2023_1_OR_NEWER`
	`492`	`+ var clientSideServerPlayerClones = Object.FindObjectsByType<NetworkObject>(FindObjectsSortMode.None).Where((c) => c.IsPlayerObject && c.OwnerClientId == m_ServerNetworkManager.LocalClientId);`
	`493`	`+#else`
`482`	`494`	`var clientSideServerPlayerClones = Object.FindObjectsOfType<NetworkObject>().Where((c) => c.IsPlayerObject && c.OwnerClientId == m_ServerNetworkManager.LocalClientId);`
	`495`	`+#endif`
`483`	`496`	`foreach (var playerNetworkObject in clientSideServerPlayerClones)`
`484`	`497`	`{`
`485`	`498`	`// When the server is not the host this needs to be done`
`@@ -535,8 +548,13 @@ protected IEnumerator StartServerAndClients()`
`535`	`548`
`536`	`549`	`if (m_UseHost \|\| m_ServerNetworkManager.IsHost)`
`537`	`550`	`{`
	`551`	`+#if UNITY_2023_1_OR_NEWER`
	`552`	`+ // Add the server player instance to all m_ClientSidePlayerNetworkObjects entries`
	`553`	`+ var serverPlayerClones = Object.FindObjectsByType<NetworkObject>(FindObjectsSortMode.None).Where((c) => c.IsPlayerObject && c.OwnerClientId == m_ServerNetworkManager.LocalClientId);`
	`554`	`+#else`
`538`	`555`	`// Add the server player instance to all m_ClientSidePlayerNetworkObjects entries`
`539`	`556`	`var serverPlayerClones = Object.FindObjectsOfType<NetworkObject>().Where((c) => c.IsPlayerObject && c.OwnerClientId == m_ServerNetworkManager.LocalClientId);`
	`557`	`+#endif`
`540`	`558`	`foreach (var playerNetworkObject in serverPlayerClones)`
`541`	`559`	`{`
`542`	`560`	`if (!m_PlayerNetworkObjects.ContainsKey(playerNetworkObject.NetworkManager.LocalClientId))`
`@@ -726,7 +744,11 @@ protected virtual bool CanDestroyNetworkObject(NetworkObject networkObject)`
`726`	`744`	`/// </summary>`
`727`	`745`	`protected void DestroySceneNetworkObjects()`
`728`	`746`	`{`
	`747`	`+#if UNITY_2023_1_OR_NEWER`
	`748`	`+ var networkObjects = Object.FindObjectsByType<NetworkObject>(FindObjectsSortMode.InstanceID);`
	`749`	`+#else`
`729`	`750`	`var networkObjects = Object.FindObjectsOfType<NetworkObject>();`
	`751`	`+#endif`
`730`	`752`	`foreach (var networkObject in networkObjects)`
`731`	`753`	`{`
`732`	`754`	`// This can sometimes be null depending upon order of operations`
Original file line number	Diff line number	Diff line change
`@@ -45,14 +45,18 @@ protected override void OnServerAndClientsCreated()`
`45`	`45`
`46`	`46`	`private EmptyComponent GetObjectForClient(ulong clientId)`
`47`	`47`	`{`
`48`		`- foreach (var component in Object.FindObjectsOfType<EmptyComponent>())`
	`48`	`+#if UNITY_2023_1_OR_NEWER`
	`49`	`+ var emptyComponents = Object.FindObjectsByType<EmptyComponent>(FindObjectsSortMode.InstanceID);`
	`50`	`+#else`
	`51`	`+ var emptyComponents = Object.FindObjectsOfType<EmptyComponent>();`
	`52`	`+#endif`
	`53`	`+ foreach (var component in emptyComponents)`
`49`	`54`	`{`
`50`	`55`	`if (component.IsSpawned && component.NetworkManager.LocalClientId == clientId)`
`51`	`56`	`{`
`52`	`57`	`return component;`
`53`	`58`	`}`
`54`	`59`	`}`
`55`		`-`
`56`	`60`	`return null;`
`57`	`61`	`}`
`58`	`62`
Original file line number	Diff line number	Diff line change
`@@ -271,14 +271,19 @@ private IEnumerator SpawnClients(bool clearTestDeferredMessageManagerCallFlags =`
`271`	`271`
`272`	`272`	`private T GetComponentForClient<T>(ulong clientId) where T : NetworkBehaviour`
`273`	`273`	`{`
`274`		`- foreach (var component in Object.FindObjectsOfType<T>())`
	`274`	`+#if UNITY_2023_1_OR_NEWER`
	`275`	`+ var componentsToFind = Object.FindObjectsByType<T>(FindObjectsSortMode.InstanceID);`
	`276`	`+#else`
	`277`	`+ var componentsToFind = Object.FindObjectsOfType<T>();`
	`278`	`+#endif`
	`279`	`+`
	`280`	`+ foreach (var component in componentsToFind)`
`275`	`281`	`{`
`276`	`282`	`if (component.IsSpawned && component.NetworkManager.LocalClientId == clientId)`
`277`	`283`	`{`
`278`	`284`	`return component;`
`279`	`285`	`}`
`280`	`286`	`}`
`281`		`-`
`282`	`287`	`return null;`
`283`	`288`	`}`
`284`	`289`
`@@ -753,7 +758,13 @@ bool HaveAllClientsSpawned()`
`753`	`758`	`{`
`754`	`759`	`var found1 = false;`
`755`	`760`	`var found2 = false;`
`756`		`- foreach (var component in Object.FindObjectsOfType<DeferredMessageTestRpcComponent>())`
	`761`	`+#if UNITY_2023_1_OR_NEWER`
	`762`	`+ var deferredMessageTestRpcComponents = Object.FindObjectsByType<DeferredMessageTestRpcComponent>(FindObjectsSortMode.None);`
	`763`	`+#else`
	`764`	`+ var deferredMessageTestRpcComponents = Object.FindObjectsOfType<DeferredMessageTestRpcComponent>();`
	`765`	`+#endif`
	`766`	`+`
	`767`	`+ foreach (var component in deferredMessageTestRpcComponents)`
`757`	`768`	`{`
`758`	`769`	`if (component.IsSpawned && component.NetworkManager.LocalClientId == client.LocalClientId)`
`759`	`770`	`{`