fix: soft synchronization error occurs on late-joining client when an in-scene placed NetworkObject has been parented to another dynamically spawned NetworkObject [MTT-3615]

com.unity.netcode.gameobjects/CHANGELOG.md

@@ -21,6 +21,7 @@ Additional documentation and release notes are available at [Multiplayer Documen
 
 ### Fixed
 
+- Fixed issue where late joining clients would get a soft synchronization error if any in-scene placed NetworkObjects were parented under another `NetworkObject`. (#1985)
 - Fixed issue where `NetworkBehaviourReference` would throw a type cast exception if using `NetworkBehaviourReference.TryGet` and the component type was not found. (#1984)
 - Fixed `NetworkSceneManager` was not sending scene event notifications for the currently active scene and any additively loaded scenes when loading a new scene in `LoadSceneMode.Single` mode. (#1975)
 - Fixed issue where one or more clients disconnecting during a scene event would cause `LoadEventCompleted` or `UnloadEventCompleted` to wait until the `NetworkConfig.LoadSceneTimeOut` period before being triggered. (#1973)

com.unity.netcode.gameobjects/Runtime/Core/NetworkObject.cs

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Runtime.CompilerServices;
 using UnityEngine;
+using UnityEngine.SceneManagement;
 
 namespace Unity.Netcode
 {
@@ -180,9 +181,58 @@ public bool IsNetworkVisibleTo(ulong clientId)
             return Observers.Contains(clientId);
         }
 
+        /// <summary>
+        ///  In the event the scene of origin gets unloaded, we keep
+        ///  the most important part to uniquely identify in-scene
+        ///  placed NetworkObjects
+        /// </summary>
+        internal int SceneOriginHandle = 0;
+
+        private Scene m_SceneOrigin;
+        /// <summary>
+        /// The scene where the NetworkObject was first instantiated
+        /// Note: Primarily for in-scene placed NetworkObjects
+        /// We need to keep track of the original scene of origin for
+        /// the NetworkObject in order to be able to uniquely identify it
+        /// using the scene of origin's handle.
+        /// </summary>
+        internal Scene SceneOrigin
+        {
+            get
+            {
+                return m_SceneOrigin;
+            }
+
+            set
+            {
+                // The scene origin should only be set once.
+                // Once set, it should never change.
+                if (SceneOriginHandle == 0 && value.IsValid() && value.isLoaded)
+                {
+                    m_SceneOrigin = value;
+                    SceneOriginHandle = value.handle;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Helper method to return the correct scene handle
+        /// Note: Do not use this within NetworkSpawnManager.SpawnNetworkObjectLocallyCommon
+        /// </summary>
+        internal int GetSceneOriginHandle()
+        {
+            // Sanity check to make sure nothing
+            if (SceneOriginHandle == 0 && IsSpawned)
+            {
+                throw new Exception($"{nameof(GetSceneOriginHandle)} called when {nameof(SceneOriginHandle)} is still zero but the {nameof(NetworkObject)} is already spawned!");
+            }
+            return SceneOriginHandle != 0 ? SceneOriginHandle : gameObject.scene.handle;
+        }
+
         private void Awake()
         {
             SetCachedParent(transform.parent);
+            SceneOrigin = gameObject.scene;
         }
 
         /// <summary>
@@ -909,7 +959,7 @@ public unsafe void Serialize(FastBufferWriter writer)
                 // sizes for dynamically spawned NetworkObjects.
                 if (Header.IsSceneObject)
                 {
-                    writer.WriteValue(OwnerObject.gameObject.scene.handle);
+                    writer.WriteValue(OwnerObject.GetSceneOriginHandle());
                 }
 
                 OwnerObject.WriteNetworkVariableData(writer, TargetClientId);
@@ -959,7 +1009,7 @@ public unsafe void Deserialize(FastBufferReader reader)
                 // NetworkObject instance.
                 if (Header.IsSceneObject)
                 {
-                    reader.ReadValue(out NetworkSceneHandle);
+                    reader.ReadValueSafe(out NetworkSceneHandle);
                 }
             }
         }

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

@@ -1520,6 +1520,13 @@ private void OnClientLoadedScene(uint sceneEventId, Scene scene)
             EndSceneEvent(sceneEventId);
         }
 
+        /// <summary>
+        /// Used for integration testing, due to the complexities of having all clients loading scenes
+        /// this is needed to "filter" out the scenes not loaded by NetworkSceneManager
+        /// (i.e. we don't want a late joining player to load all of the other client scenes)
+        /// </summary>
+        internal Func<Scene, bool> ExcludeSceneFromSychronization;
+
         /// <summary>
         /// Server Side:
         /// This is used for players that have just had their connection approved and will assure they are synchronized
@@ -1546,6 +1553,13 @@ internal void SynchronizeNetworkObjects(ulong clientId)
             {
                 var scene = SceneManager.GetSceneAt(i);
 
+                // NetworkSceneManager does not synchronize scenes that are not loaded by NetworkSceneManager
+                // unless the scene in question is the currently active scene.
+                if (ExcludeSceneFromSychronization != null && !ExcludeSceneFromSychronization(scene))
+                {
+                    continue;
+                }
+
                 var sceneHash = SceneHashFromNameOrPath(scene.path);
 
                 // This would depend upon whether we are additive or not
@@ -1563,7 +1577,6 @@ internal void SynchronizeNetworkObjects(ulong clientId)
                 {
                     continue;
                 }
-
                 sceneEventData.AddSceneToSynchronize(sceneHash, scene.handle);
             }
 
@@ -2020,10 +2033,9 @@ internal void PopulateScenePlacedObjects(Scene sceneToFilterBy, bool clearSceneP
             foreach (var networkObjectInstance in networkObjects)
             {
                 var globalObjectIdHash = networkObjectInstance.GlobalObjectIdHash;
-                var sceneHandle = networkObjectInstance.gameObject.scene.handle;
+                var sceneHandle = networkObjectInstance.GetSceneOriginHandle();
                 // We check to make sure the NetworkManager instance is the same one to be "NetcodeIntegrationTestHelpers" compatible and filter the list on a per scene basis (for additive scenes)
-                if (networkObjectInstance.IsSceneObject != false && networkObjectInstance.NetworkManager == m_NetworkManager && networkObjectInstance.gameObject.scene == sceneToFilterBy &&
-                    sceneHandle == sceneToFilterBy.handle)
+                if (networkObjectInstance.IsSceneObject != false && networkObjectInstance.NetworkManager == m_NetworkManager && sceneHandle == sceneToFilterBy.handle)
                 {
                     if (!ScenePlacedObjects.ContainsKey(globalObjectIdHash))
                     {
@@ -2032,6 +2044,10 @@ internal void PopulateScenePlacedObjects(Scene sceneToFilterBy, bool clearSceneP
 
                     if (!ScenePlacedObjects[globalObjectIdHash].ContainsKey(sceneHandle))
                     {
+                        if (sceneToFilterBy.name == "InSceneNetworkObject")
+                        {
+                            var matchingEntry = ServerSceneHandleToClientSceneHandle.Where((c) => c.Value == sceneHandle).FirstOrDefault();
+                        }
                         ScenePlacedObjects[globalObjectIdHash].Add(sceneHandle, networkObjectInstance);
                     }
                     else

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

@@ -388,7 +388,6 @@ internal void WriteSceneSynchronizationData(FastBufferWriter writer)
             writer.WriteValueSafe(ScenesToSynchronize.ToArray());
             writer.WriteValueSafe(SceneHandlesToSynchronize.ToArray());
 
-
             // Store our current position in the stream to come back and say how much data we have written
             var positionStart = writer.Position;
 
@@ -399,13 +398,13 @@ internal void WriteSceneSynchronizationData(FastBufferWriter writer)
             int totalBytes = 0;
 
             // Write the number of NetworkObjects we are serializing
-            writer.WriteValueSafe(m_NetworkObjectsSync.Count());
+            BytePacker.WriteValuePacked(writer, m_NetworkObjectsSync.Count());
             // Serialize all NetworkObjects that are spawned
             for (var i = 0; i < m_NetworkObjectsSync.Count(); ++i)
             {
                 var noStart = writer.Position;
                 var sceneObject = m_NetworkObjectsSync[i].GetMessageSceneObject(TargetClientId);
-                writer.WriteValueSafe(m_NetworkObjectsSync[i].gameObject.scene.handle);
+                BytePacker.WriteValuePacked(writer, m_NetworkObjectsSync[i].GetSceneOriginHandle());
                 sceneObject.Serialize(writer);
                 var noStop = writer.Position;
                 totalBytes += (int)(noStop - noStart);
@@ -418,8 +417,8 @@ internal void WriteSceneSynchronizationData(FastBufferWriter writer)
             {
                 var noStart = writer.Position;
                 var sceneObject = m_DespawnedInSceneObjectsSync[i].GetMessageSceneObject(TargetClientId);
-                writer.WriteValueSafe(m_DespawnedInSceneObjectsSync[i].gameObject.scene.handle);
-                writer.WriteValueSafe(m_DespawnedInSceneObjectsSync[i].GlobalObjectIdHash);
+                BytePacker.WriteValuePacked(writer, m_DespawnedInSceneObjectsSync[i].GetSceneOriginHandle());
+                BytePacker.WriteValuePacked(writer, m_DespawnedInSceneObjectsSync[i].GlobalObjectIdHash);
                 var noStop = writer.Position;
                 totalBytes += (int)(noStop - noStart);
             }
@@ -714,14 +713,15 @@ internal void SynchronizeSceneNetworkObjects(NetworkManager networkManager)
             try
             {
                 // Process all spawned NetworkObjects for this network session
-                InternalBuffer.ReadValueSafe(out int newObjectsCount);
+                ByteUnpacker.ReadValuePacked(InternalBuffer, out int newObjectsCount);
+
 
                 for (int i = 0; i < newObjectsCount; i++)
                 {
                     // We want to make sure for each NetworkObject we have the appropriate scene selected as the scene that is
                     // currently being synchronized.  This assures in-scene placed NetworkObjects will use the right NetworkObject
                     // from the list of populated <see cref="NetworkSceneManager.ScenePlacedObjects"/>
-                    InternalBuffer.ReadValueSafe(out int handle);
+                    ByteUnpacker.ReadValuePacked(InternalBuffer, out int handle);
                     m_NetworkManager.SceneManager.SetTheSceneBeingSynchronized(handle);
 
                     var sceneObject = new NetworkObject.SceneObject();
@@ -742,8 +742,8 @@ internal void SynchronizeSceneNetworkObjects(NetworkManager networkManager)
                 for (int i = 0; i < despawnedObjectsCount; i++)
                 {
                     // We just need to get the scene
-                    InternalBuffer.ReadValueSafe(out int networkSceneHandle);
-                    InternalBuffer.ReadValueSafe(out uint globalObjectIdHash);
+                    ByteUnpacker.ReadValuePacked(InternalBuffer, out int networkSceneHandle);
+                    ByteUnpacker.ReadValuePacked(InternalBuffer, out uint globalObjectIdHash);
                     var sceneRelativeNetworkObjects = new Dictionary<uint, NetworkObject>();
                     if (!sceneCache.ContainsKey(networkSceneHandle))
                     {
@@ -753,8 +753,8 @@ internal void SynchronizeSceneNetworkObjects(NetworkManager networkManager)
                             if (m_NetworkManager.SceneManager.ScenesLoaded.ContainsKey(localSceneHandle))
                             {
                                 var objectRelativeScene = m_NetworkManager.SceneManager.ScenesLoaded[localSceneHandle];
-                                var inSceneNetworkObjects = UnityEngine.Object.FindObjectsOfType<NetworkObject>().Where((c) => c.gameObject.scene == objectRelativeScene &&
-                                c.gameObject.scene.handle == localSceneHandle && (c.IsSceneObject != false)).ToList();
+                                var inSceneNetworkObjects = UnityEngine.Object.FindObjectsOfType<NetworkObject>().Where((c) =>
+                                c.GetSceneOriginHandle() == localSceneHandle && (c.IsSceneObject != false)).ToList();
 
                                 foreach (var inSceneObject in inSceneNetworkObjects)
                                 {
@@ -789,9 +789,9 @@ internal void SynchronizeSceneNetworkObjects(NetworkManager networkManager)
                             m_NetworkManager.SceneManager.ScenePlacedObjects.Add(globalObjectIdHash, new Dictionary<int, NetworkObject>());
                         }
 
-                        if (!m_NetworkManager.SceneManager.ScenePlacedObjects[globalObjectIdHash].ContainsKey(sceneRelativeNetworkObjects[globalObjectIdHash].gameObject.scene.handle))
+                        if (!m_NetworkManager.SceneManager.ScenePlacedObjects[globalObjectIdHash].ContainsKey(sceneRelativeNetworkObjects[globalObjectIdHash].GetSceneOriginHandle()))
                         {
-                            m_NetworkManager.SceneManager.ScenePlacedObjects[globalObjectIdHash].Add(sceneRelativeNetworkObjects[globalObjectIdHash].gameObject.scene.handle, sceneRelativeNetworkObjects[globalObjectIdHash]);
+                            m_NetworkManager.SceneManager.ScenePlacedObjects[globalObjectIdHash].Add(sceneRelativeNetworkObjects[globalObjectIdHash].GetSceneOriginHandle(), sceneRelativeNetworkObjects[globalObjectIdHash]);
                         }
 
                     }

com.unity.netcode.gameobjects/Runtime/Spawning/NetworkSpawnManager.cs

@@ -477,16 +477,16 @@ private void SpawnNetworkObjectLocallyCommon(NetworkObject networkObject, ulong
                 return;
             }
 
-            // this initialization really should be at the bottom of the function
             networkObject.IsSpawned = true;
-
-            // this initialization really should be at the top of this function. If and when we break the
-            //  NetworkVariable dependency on NetworkBehaviour, this otherwise creates problems because
-            //  SetNetworkVariableData above calls InitializeVariables, and the 'baked out' data isn't ready there;
-            //  the current design banks on getting the network behaviour set and then only reading from it after the
-            //  below initialization code. However cowardice compels me to hold off on moving this until that commit
             networkObject.IsSceneObject = sceneObject;
 
+            // Always check to make sure our scene of origin is properly set for in-scene placed NetworkObjects
+            // Note: Always check SceneOriginHandle directly at this specific location.
+            if (networkObject.IsSceneObject != false && networkObject.SceneOriginHandle == 0)
+            {
+                networkObject.SceneOrigin = networkObject.gameObject.scene;
+            }
+
             // For integration testing, this makes sure that the appropriate NetworkManager is assigned to
             // the NetworkObject since it uses the NetworkManager.Singleton when not set
             if (networkObject.NetworkManagerOwner != NetworkManager)

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

@@ -147,7 +147,7 @@ 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
-            var inSceneNetworkObjects = Object.FindObjectsOfType<NetworkObject>().Where((c) => c.IsSceneObject != false && c.gameObject.scene.handle == scene.handle);
+            var inSceneNetworkObjects = Object.FindObjectsOfType<NetworkObject>().Where((c) => c.IsSceneObject != false && c.GetSceneOriginHandle() == scene.handle);
             foreach (var sobj in inSceneNetworkObjects)
             {
                 if (sobj.NetworkManagerOwner != networkManager)
@@ -322,7 +322,7 @@ internal Scene GetAndAddNewlyLoadedSceneByName(string sceneName)
                     var skip = false;
                     foreach (var networkManager in NetworkManagers)
                     {
-                        if (NetworkManager.LocalClientId == networkManager.LocalClientId)
+                        if (NetworkManager.LocalClientId == networkManager.LocalClientId || !networkManager.IsListening)
                         {
                             continue;
                         }
@@ -352,12 +352,22 @@ internal Scene GetAndAddNewlyLoadedSceneByName(string sceneName)
             throw new Exception($"Failed to find any loaded scene named {sceneName}!");
         }
 
+        private bool ExcludeSceneFromSynchronizationCheck(Scene scene)
+        {
+            if (!NetworkManager.SceneManager.ScenesLoaded.ContainsKey(scene.handle) && SceneManager.GetActiveScene().handle != scene.handle)
+            {
+                return false;
+            }
+            return true;
+        }
+
         /// <summary>
         /// Constructor now must take NetworkManager
         /// </summary>
         public IntegrationTestSceneHandler(NetworkManager networkManager)
         {
             networkManager.SceneManager.OverrideGetAndAddNewlyLoadedSceneByName = GetAndAddNewlyLoadedSceneByName;
+            networkManager.SceneManager.ExcludeSceneFromSychronization = ExcludeSceneFromSynchronizationCheck;
             NetworkManagers.Add(networkManager);
             NetworkManagerName = networkManager.name;
             if (s_WaitForSeconds == null)

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

@@ -409,6 +409,22 @@ protected void ClientNetworkManagerPostStartInit()
             {
                 ClientNetworkManagerPostStart(networkManager);
             }
+            if (m_UseHost)
+            {
+                var clientSideServerPlayerClones = Object.FindObjectsOfType<NetworkObject>().Where((c) => c.IsPlayerObject && c.OwnerClientId == m_ServerNetworkManager.LocalClientId);
+                foreach (var playerNetworkObject in clientSideServerPlayerClones)
+                {
+                    // When the server is not the host this needs to be done
+                    if (!m_PlayerNetworkObjects.ContainsKey(playerNetworkObject.NetworkManager.LocalClientId))
+                    {
+                        m_PlayerNetworkObjects.Add(playerNetworkObject.NetworkManager.LocalClientId, new Dictionary<ulong, NetworkObject>());
+                    }
+                    if (!m_PlayerNetworkObjects[playerNetworkObject.NetworkManager.LocalClientId].ContainsKey(m_ServerNetworkManager.LocalClientId))
+                    {
+                        m_PlayerNetworkObjects[playerNetworkObject.NetworkManager.LocalClientId].Add(m_ServerNetworkManager.LocalClientId, playerNetworkObject);
+                    }
+                }
+            }
         }
 
         /// <summary>