Solved late-join problems

Author: Extrys

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

@@ -57,6 +57,13 @@ public uint PrefabIdHash
             }
         }
 
+        /// <summary>
+        /// InstantiationData sent during the instantiation process.
+        /// Retrieved in <see cref="INetworkPrefabInstanceHandlerWithData.OnSynchronizeInstantiationData{T}(ref BufferSerializer{T})"/>
+        /// and available to INetworkPrefabInstanceHandler.Instantiate() for custom handling by user code.
+        /// </summary>
+        internal byte[] InstantiationData;
+
         /// <summary>
         /// All <see cref="NetworkTransform"/> component instances associated with a <see cref="NetworkObject"/> component instance.
         /// </summary>
@@ -1814,6 +1821,8 @@ internal void SpawnInternal(bool destroyWithScene, ulong ownerClientId, bool pla
                 }
             }
 
+            InjectInstantiationData();
+
             NetworkManager.SpawnManager.SpawnNetworkObjectLocally(this, NetworkManager.SpawnManager.GetNetworkObjectId(), IsSceneObject.HasValue && IsSceneObject.Value, playerObject, ownerClientId, destroyWithScene);
 
             if ((NetworkManager.DistributedAuthorityMode && NetworkManager.DAHost) || (!NetworkManager.DistributedAuthorityMode && NetworkManager.IsServer))
@@ -1845,6 +1854,20 @@ internal void SpawnInternal(bool destroyWithScene, ulong ownerClientId, bool pla
             }
         }
 
+        /// <summary>
+        /// Injects the instantiation data into the <see cref="InstantiationData"/> if available. This is used to synchronize
+        /// </summary>
+        internal void InjectInstantiationData()
+        {
+            if (NetworkManager.PrefabHandler.TryGetHandlerWithData(this.GlobalObjectIdHash, out var prefabHandler))
+            {
+                // Creates the instantiateData array for the newtwork object
+                var serializer = new BufferSerializer<BufferSerializerWriter>(new BufferSerializerWriter(new FastBufferWriter(4, Collections.Allocator.Temp, int.MaxValue)));
+                prefabHandler.OnSynchronizeInstantiationData(ref serializer);
+                InstantiationData = serializer.GetFastBufferWriter().ToArray();
+            }
+        }
+
         /// <summary>
         /// This invokes <see cref="NetworkSpawnManager.InstantiateAndSpawn(NetworkObject, ulong, bool, bool, bool, Vector3, Quaternion)"/>.
         /// </summary>
@@ -2984,7 +3007,8 @@ public void Serialize(FastBufferWriter writer)
 
                 if (HasInstantiationData)
                 {
-                    OwnerObject.NetworkManager.PrefabHandler.SynchronizeInstantiationData(Hash, ref bufferSerializer);
+                    writer.WriteValueSafe(OwnerObject.InstantiationData.Length);
+                    writer.WriteBytesSafe(OwnerObject.InstantiationData);
                 }
 
                 OwnerObject.SynchronizeNetworkBehaviours(ref bufferSerializer, TargetClientId);
@@ -3164,9 +3188,8 @@ internal SceneObject GetMessageSceneObject(ulong targetClientId = NetworkManager
                 Hash = CheckForGlobalObjectIdHashOverride(),
                 OwnerObject = this,
                 TargetClientId = targetClientId,
-                HasInstantiationData = NetworkManager.PrefabHandler.ContainsHandlerWithData(GlobalObjectIdHash),
+                HasInstantiationData = InstantiationData != null && InstantiationData.Length > 0
             };
-
             // Handle Parenting
             if (!AlwaysReplicateAsRoot && obj.HasParent)
             {
@@ -3234,7 +3257,7 @@ internal static NetworkObject AddSceneObject(in SceneObject sceneObject, FastBuf
             //Synchronize the instantiation data if needed
             if (sceneObject.HasInstantiationData)
             {
-                networkManager.PrefabHandler.SynchronizeInstantiationData(sceneObject.Hash, ref bufferSerializer);
+                networkManager.PrefabHandler.ReadInstantiationData(sceneObject.Hash, ref bufferSerializer);
             }
 
             //Attempt to create a local NetworkObject

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

@@ -226,13 +226,6 @@ public bool RemoveHandler(uint globalObjectIdHash)
         /// <returns>true or false</returns>
         internal bool ContainsHandler(uint networkPrefabHash) => m_PrefabAssetToPrefabHandler.ContainsKey(networkPrefabHash) || m_PrefabInstanceToPrefabAsset.ContainsKey(networkPrefabHash);
 
-        /// <summary>
-        /// Check to see if a <see cref="NetworkObject.GlobalObjectIdHash"/> is registered to an <see cref="INetworkPrefabInstanceHandlerWithData"/> implementation
-        /// </summary>
-        /// <param name="objectHash"></param>
-        /// <returns></returns>
-        internal bool ContainsHandlerWithData(uint objectHash) => TryGetHandlerWithData(objectHash, out _);
-
         /// <summary>
         /// Returns the <see cref="INetworkPrefabInstanceHandlerWithData"/> implementation for a given <see cref="NetworkObject.GlobalObjectIdHash"/>
         /// </summary>
@@ -259,68 +252,36 @@ internal bool TryGetHandlerWithData(uint objectHash, out INetworkPrefabInstanceH
         /// <typeparam name="T"></typeparam>
         /// <param name="objectHash"></param>
         /// <param name="serializer"></param>
-        internal void SynchronizeInstantiationData<T>(uint objectHash, ref BufferSerializer<T> serializer) where T : IReaderWriter
+        internal void ReadInstantiationData<T>(uint objectHash, ref BufferSerializer<T> serializer) where T : IReaderWriter
         {
-            if (!TryGetHandlerWithData(objectHash, out INetworkPrefabInstanceHandlerWithData synchronizableHandler))
+            if (!serializer.IsReader || !TryGetHandlerWithData(objectHash, out INetworkPrefabInstanceHandlerWithData synchronizableHandler))
             {
                 return;
             }
 
-            if (serializer.IsWriter)
-            {
-                // Reserves space to write the instantiation data size later
-                FastBufferWriter fastBufferWriter = serializer.GetFastBufferWriter();
-                int dataSizePos = fastBufferWriter.Position;
-                fastBufferWriter.WriteValueSafe(0); // placeholder for size, correctly writen at the end
-
-                int dataStartPos = fastBufferWriter.Position;
-                try
-                {
-                    synchronizableHandler.OnSynchronizeInstantiationData(ref serializer);
-                }
-                catch (Exception ex)
-                {
-                    // Resets to start position to avoid writing corrupted data
-                    fastBufferWriter.Seek(dataSizePos);
-                    NetworkLog.LogError($"[InstantiationData] Handler failed during synchronization (Write): {ex.Message}");
-                    return;
-                }
+            FastBufferReader fastBufferReader = serializer.GetFastBufferReader();
+            // Reads the expected size of the instantiation data
+            fastBufferReader.ReadValueSafe(out int dataSize);
+            int dataStartPos = fastBufferReader.Position;
 
-                // Compute and write actual instantiation data size
-                int dataEndPos = fastBufferWriter.Position;
-                int dataSize = dataEndPos - dataStartPos;
-                // Goes back and write the real size
-                fastBufferWriter.Seek(dataSizePos);
-                fastBufferWriter.WriteValueSafe(dataSize);
-                // Restores to end
-                fastBufferWriter.Seek(dataEndPos);
+            try
+            {
+                synchronizableHandler.OnSynchronizeInstantiationData(ref serializer);
             }
-            else
+            catch (Exception ex)
             {
-                FastBufferReader fastBufferReader = serializer.GetFastBufferReader();
-                // Reads the expected size of the instantiation data
-                fastBufferReader.ReadValueSafe(out int dataSize);
-                int dataStartPos = fastBufferReader.Position;
-
-                try
-                {
-                    synchronizableHandler.OnSynchronizeInstantiationData(ref serializer);
-                }
-                catch (Exception ex)
-                {
-                    // Skips the unread instantiation data bytes
-                    fastBufferReader.Seek(dataStartPos + dataSize);
-                    NetworkLog.LogError($"[InstantiationData] Handler failed during synchronization (Read): {ex.Message}");
-                    return;
-                }
+                // Skips the unread instantiation data bytes
+                fastBufferReader.Seek(dataStartPos + dataSize);
+                NetworkLog.LogError($"[InstantiationData] Handler failed during synchronization (Read): {ex.Message}");
+                return;
+            }
 
-                // Validates if expected number of bytes were read
-                int dataEndPos = fastBufferReader.Position;
-                if (dataEndPos != dataStartPos + dataSize)
-                {
-                    NetworkLog.LogWarning($"[InstantiationData] Read {dataEndPos - dataStartPos} bytes, expected {dataSize}");
-                    fastBufferReader.Seek(dataStartPos + dataSize);
-                }
+            // Validates if expected number of bytes were read
+            int dataEndPos = fastBufferReader.Position;
+            if (dataEndPos != dataStartPos + dataSize)
+            {
+                NetworkLog.LogWarning($"[InstantiationData] Read {dataEndPos - dataStartPos} bytes, expected {dataSize}");
+                fastBufferReader.Seek(dataStartPos + dataSize);
             }
         }