New stateless approach working flawless

Author: Extrys

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

@@ -1821,8 +1821,6 @@ 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))
@@ -1855,24 +1853,27 @@ 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
+        /// Serializes the given instantiation data and stores it to be used during the spawn process
+        /// by a compatible <see cref="INetworkPrefabInstanceHandlerWithData{T}"/>
         /// </summary>
-        internal void InjectInstantiationData()
+        public void InjectInstantiationData<T>(T data) where T : struct, INetworkSerializable
         {
-            if (NetworkManager.PrefabHandler.TryGetHandlerWithData(this.GlobalObjectIdHash, out var prefabHandler))
+            if (!NetworkManager.PrefabHandler.TryGetHandlerWithData(GlobalObjectIdHash, out var prefabHandler) || !prefabHandler.HandlesDataType<T>())
             {
-                var serializer = new BufferSerializer<BufferSerializerWriter>(new BufferSerializerWriter(new FastBufferWriter(4, Collections.Allocator.Temp, int.MaxValue)));
-                try
-                {
-                    prefabHandler.OnSynchronizeInstantiationData(ref serializer);
-                    InstantiationData = serializer.GetFastBufferWriter().ToArray();
-                }
-                catch (Exception ex)
-                {
-                    serializer.GetFastBufferWriter().Dispose();
-                    NetworkLog.LogError($"[InstantiationData] Handler failed during synchronization for injection (Write): {ex.Message}");
-                    return;
-                }
+                throw new Exception("[InstantiationData] Cannot inject data: no compatible handler found for the specified data type.");
+            }
+
+            using var writer = new FastBufferWriter(4, Collections.Allocator.Temp, int.MaxValue);
+            var serializer = new BufferSerializer<BufferSerializerWriter>(new BufferSerializerWriter(writer));
+
+            try
+            {
+                data.NetworkSerialize(serializer);
+                InstantiationData = writer.ToArray();
+            }
+            catch (Exception ex)
+            {
+                NetworkLog.LogError($"[InstantiationData] Failed to serialize instantiation data for {nameof(NetworkObject)} '{gameObject.name}': {ex}");
             }
         }
 

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

@@ -1,16 +1,50 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
 namespace Unity.Netcode
 {
     /// <summary>
-    /// Specialized version of <see cref="INetworkPrefabInstanceHandler"/> that supports synchronizing
-    /// custom data prior to the instantiation of a <see cref="NetworkObject"/>.
+    /// Specialized version of <see cref="INetworkPrefabInstanceHandler"/> that receives
+    /// custom instantiation data injected by the server before spawning.
+    /// </summary>
+    public interface INetworkPrefabInstanceHandlerWithData<T> : INetworkPrefabInstanceHandlerWithData where T : struct, INetworkSerializable
+    {
+        static readonly Dictionary<INetworkPrefabInstanceHandlerWithData, T> _table = new();
+
+        NetworkObject INetworkPrefabInstanceHandler.Instantiate(ulong ownerClientId, Vector3 position, Quaternion rotation) => Instantiate(ownerClientId, position, rotation, _table[this]);
+        void INetworkPrefabInstanceHandlerWithData.RemoveDataEntry(INetworkPrefabInstanceHandlerWithData instance) => _table.Remove(instance);
+        bool INetworkPrefabInstanceHandlerWithData.HandlesDataType<U>() => typeof(T) == typeof(U);
+        void INetworkPrefabInstanceHandlerWithData.OnReadInstantiationData<RW>(ref BufferSerializer<RW> serializer)
+        {
+            _table.TryGetValue(this, out var value);
+            serializer.SerializeValue(ref value);
+            _table[this] = value;
+        }
+
+        NetworkObject Instantiate(ulong ownerClientId, Vector3 position, Quaternion rotation, T instantiationData);
+    }
+
+    /// <summary>
+    /// Internal use only. Do not implement directly. Use <see cref="INetworkPrefabInstanceHandlerWithData{T}"/> instead.
     /// </summary>
     public interface INetworkPrefabInstanceHandlerWithData : INetworkPrefabInstanceHandler
     {
         /// <summary>
-        /// Allows synchronizing custom instantiation data before the object is instantiated. <br/>
-        /// Called before <see cref="INetworkPrefabInstanceHandler.Instantiate"/>.
+        /// Invoked during deserialization to read the instantiation data associated with this prefab instance.
+        /// </summary>
+        void OnReadInstantiationData<Y>(ref BufferSerializer<Y> serializer) where Y : IReaderWriter;
+
+        /// <summary>
+        /// Removes the data entry for the given instance.
+        /// Is important to call this when the instance isnt referenced to avoid memory leaks.
+        /// </summary>
+        /// <param name="instance"></param>
+        void RemoveDataEntry(INetworkPrefabInstanceHandlerWithData instance);
+
+        /// <summary>
+        /// Returns true if <typeparamref name="T"/> matches the expected instantiation data type for this handler.
         /// </summary>
-        /// <param name="serializer">The serializer used to synchronize the custom instantiation data.</param>
-        void OnSynchronizeInstantiationData<T>(ref BufferSerializer<T> serializer) where T : IReaderWriter;
+        bool HandlesDataType<T>() where T : struct, INetworkSerializable;
     }
 }

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

@@ -22,7 +22,7 @@ public interface INetworkPrefabInstanceHandler
         /// via the  <see cref="GameObject.SetActive(bool)"/> method.
         /// 
         /// If you need to pass custom data at instantiation time (e.g., selecting a variant, setting initialization parameters, or choosing a pre-instantiated object),
-        /// implement <see cref="INetworkPrefabInstanceHandlerWithData"/> alongside this interface to receive the data before instantiation.
+        /// implement <see cref="INetworkPrefabInstanceHandlerWithData{T}"/> instead.
         /// </summary>
         /// <param name="ownerClientId">the owner for the <see cref="NetworkObject"/> to be instantiated</param>
         /// <param name="position">the initial/default position for the <see cref="NetworkObject"/> to be instantiated</param>
@@ -212,7 +212,11 @@ public bool RemoveHandler(uint globalObjectIdHash)
                 m_PrefabInstanceToPrefabAsset.Remove(networkPrefabHashKey);
             }
 
-            m_PrefabAssetToPrefabHandlerWithData.Remove(globalObjectIdHash);
+            if(m_PrefabAssetToPrefabHandlerWithData.TryGetValue(globalObjectIdHash, out var handlerWithData))
+            {
+                handlerWithData.RemoveDataEntry(handlerWithData);
+                m_PrefabAssetToPrefabHandlerWithData.Remove(globalObjectIdHash);
+            }
             return m_PrefabAssetToPrefabHandler.Remove(globalObjectIdHash);
         }
 
@@ -268,7 +272,7 @@ internal void ReadInstantiationData<T>(uint objectHash, ref BufferSerializer<T>
 
             try
             {
-                synchronizableHandler.OnSynchronizeInstantiationData(ref serializer);
+                synchronizableHandler.OnReadInstantiationData(ref serializer);
             }
             catch (Exception ex)
             {

com.unity.netcode.gameobjects/Tests/Runtime/Prefabs/NetworkPrefabHandlerWithDataTests.cs

@@ -86,7 +86,6 @@ public IEnumerator InstantiationPayload_SyncsCorrectly()
             yield return NetcodeIntegrationTestHelpers.WaitForClientsConnectedToServer(server, clients.Length + 1, null, 512);
 
             //Sets the values to synchronize
-            server_handler.ValueToSynchronize = 48;
             server_handler.networksSerializableToSynchronize = new NetworkSerializableTest() { Value = 12, Value2 = 3.14f };
 
             // Spawn the prefab on the server
@@ -95,7 +94,7 @@ public IEnumerator InstantiationPayload_SyncsCorrectly()
 
             // wait for the clients to receive the instantiation payload
             var timeoutHelper = new TimeoutHelper();
-            yield return NetcodeIntegrationTest.WaitForConditionOrTimeOut(() => client_handlers.All(handler => handler.ValueToSynchronize == server_handler.ValueToSynchronize));
+            yield return NetcodeIntegrationTest.WaitForConditionOrTimeOut(() => client_handlers.All(handler => (handler.networksSerializableToSynchronize.Value == server_handler.networksSerializableToSynchronize.Value)&& (handler.networksSerializableToSynchronize.Value2 == server_handler.networksSerializableToSynchronize.Value2)));
             Assert.False(timeoutHelper.TimedOut, "Did not successfully sync all handlers");
 
             // Check that the values are synchronized
@@ -105,25 +104,17 @@ public IEnumerator InstantiationPayload_SyncsCorrectly()
             }
         }
 
-        private class PrefabInstanceHandlerWithData : INetworkPrefabInstanceHandlerWithData
+        private class PrefabInstanceHandlerWithData : INetworkPrefabInstanceHandlerWithData<NetworkSerializableTest>
         {
             public GameObject Prefab;
-            public int ValueToSynchronize;
             public NetworkSerializableTest networksSerializableToSynchronize;
-
             public PrefabInstanceHandlerWithData(GameObject prefab)
             {
                 Prefab = prefab;
             }
-
-            public virtual void OnSynchronizeInstantiationData<T>(ref BufferSerializer<T> serializer) where T : IReaderWriter
-            {
-                serializer.SerializeValue(ref ValueToSynchronize);
-                serializer.SerializeValue(ref networksSerializableToSynchronize);
-            }
-
-            public NetworkObject Instantiate(ulong ownerClientId, Vector3 position, Quaternion rotation)
+            public NetworkObject Instantiate(ulong ownerClientId, Vector3 position, Quaternion rotation, NetworkSerializableTest data)
             {
+                networksSerializableToSynchronize = data;
                 var instance = GameObject.Instantiate(Prefab, position, rotation).GetComponent<NetworkObject>();
                 return instance;
             }
@@ -139,7 +130,6 @@ public bool IsSynchronizedWith(PrefabInstanceHandlerWithData other)
                     return false;
 
                 bool isSynchronized = true;
-                isSynchronized &= ValueToSynchronize == other.ValueToSynchronize;
                 isSynchronized &= networksSerializableToSynchronize.Value == other.networksSerializableToSynchronize.Value;
                 isSynchronized &= networksSerializableToSynchronize.Value2 == other.networksSerializableToSynchronize.Value2;
                 return isSynchronized;