fix: issue #1151 - client RPCs invoked in OnNetworkSpawn being dropped (#1218)

ShadauxCat · web-flow · commit 40011ed886ee · 2021-10-08T13:54:35.000-07:00
* fix: issue #1151 - client RPCs invoked in OnNetworkSpawn being dropped
diff --git a/com.unity.netcode.gameobjects/Runtime/Core/NetworkBehaviour.cs b/com.unity.netcode.gameobjects/Runtime/Core/NetworkBehaviour.cs
@@ -75,7 +75,16 @@ internal void __sendServerRpc(FastBufferWriter writer, uint rpcMethodId, ServerR
             if (IsHost || IsServer)
             {
                 using var tempBuffer = new FastBufferReader(writer, Allocator.Temp);
-                message.Handle(tempBuffer, NetworkManager, NetworkManager.ServerClientId);
+                var context = new NetworkContext
+                {
+                    SenderId = NetworkManager.ServerClientId,
+                    Timestamp = Time.realtimeSinceStartup,
+                    SystemOwner = NetworkManager,
+                    // header information isn't valid since it's not a real message.
+                    // Passing false to canDefer prevents it being accessed.
+                    Header = new MessageHeader()
+                };
+                message.Handle(tempBuffer, context, NetworkManager, NetworkManager.ServerClientId, false);
                 rpcMessageSize = tempBuffer.Length;
             }
             else
@@ -172,7 +181,16 @@ internal unsafe void __sendClientRpc(FastBufferWriter writer, uint rpcMethodId,
             if (shouldSendToHost)
             {
                 using var tempBuffer = new FastBufferReader(writer, Allocator.Temp);
-                message.Handle(tempBuffer, NetworkManager, NetworkManager.ServerClientId);
+                var context = new NetworkContext
+                {
+                    SenderId = NetworkManager.ServerClientId,
+                    Timestamp = Time.realtimeSinceStartup,
+                    SystemOwner = NetworkManager,
+                    // header information isn't valid since it's not a real message.
+                    // Passing false to canDefer prevents it being accessed.
+                    Header = new MessageHeader()
+                };
+                message.Handle(tempBuffer, context, NetworkManager, NetworkManager.ServerClientId, false);
                 messageSize = tempBuffer.Length;
             }
 
diff --git a/com.unity.netcode.gameobjects/Runtime/Core/NetworkManager.cs b/com.unity.netcode.gameobjects/Runtime/Core/NetworkManager.cs
@@ -56,7 +56,7 @@ internal static string PrefabDebugHelper(NetworkPrefab networkPrefab)
         internal SnapshotSystem SnapshotSystem { get; private set; }
         internal NetworkBehaviourUpdater BehaviourUpdater { get; private set; }
 
-        private MessagingSystem m_MessagingSystem;
+        internal MessagingSystem MessagingSystem { get; private set; }
 
         private NetworkPrefabHandler m_PrefabHandler;
 
@@ -244,7 +244,7 @@ public ulong LocalClientId
             internal set
             {
                 m_LocalClientId = value;
-                m_MessagingSystem.SetLocalClientId(value);
+                MessagingSystem.SetLocalClientId(value);
             }
         }
 
@@ -497,15 +497,15 @@ private void Initialize(bool server)
             this.RegisterNetworkUpdate(NetworkUpdateStage.EarlyUpdate);
             this.RegisterNetworkUpdate(NetworkUpdateStage.PostLateUpdate);
 
-            m_MessagingSystem = new MessagingSystem(new NetworkManagerMessageSender(this), this, ulong.MaxValue);
+            MessagingSystem = new MessagingSystem(new NetworkManagerMessageSender(this), this, ulong.MaxValue);
 
-            m_MessagingSystem.Hook(new NetworkManagerHooks(this));
+            MessagingSystem.Hook(new NetworkManagerHooks(this));
 #if DEVELOPMENT_BUILD || UNITY_EDITOR
-            m_MessagingSystem.Hook(new ProfilingHooks());
+            MessagingSystem.Hook(new ProfilingHooks());
 #endif
 
 #if MULTIPLAYER_TOOLS
-            m_MessagingSystem.Hook(new MetricHooks(this));
+            MessagingSystem.Hook(new MetricHooks(this));
 #endif
             LocalClientId = ulong.MaxValue;
 
@@ -847,7 +847,7 @@ public SocketTasks StartClient()
             }
 
             Initialize(false);
-            m_MessagingSystem.ClientConnected(ServerClientId);
+            MessagingSystem.ClientConnected(ServerClientId);
 
             var socketTasks = NetworkConfig.NetworkTransport.StartClient();
 
@@ -893,7 +893,7 @@ public SocketTasks StartHost()
             Initialize(true);
 
             var socketTasks = NetworkConfig.NetworkTransport.StartServer();
-            m_MessagingSystem.ClientConnected(ServerClientId);
+            MessagingSystem.ClientConnected(ServerClientId);
             LocalClientId = ServerClientId;
             NetworkMetrics.SetConnectionId(LocalClientId);
 
@@ -1003,9 +1003,9 @@ public void Shutdown()
             if (IsServer)
             {
                 // make sure all messages are flushed before transport disconnect clients
-                if (m_MessagingSystem != null)
+                if (MessagingSystem != null)
                 {
-                    m_MessagingSystem.ProcessSendQueues();
+                    MessagingSystem.ProcessSendQueues();
                 }
 
                 var disconnectedIds = new HashSet<ulong>();
@@ -1066,10 +1066,10 @@ public void Shutdown()
                 NetworkTickSystem = null;
             }
 
-            if (m_MessagingSystem != null)
+            if (MessagingSystem != null)
             {
-                m_MessagingSystem.Dispose();
-                m_MessagingSystem = null;
+                MessagingSystem.Dispose();
+                MessagingSystem = null;
             }
 
             NetworkConfig.NetworkTransport.OnTransportEvent -= HandleRawTransportPoll;
@@ -1145,7 +1145,7 @@ private void OnNetworkEarlyUpdate()
                 // Only do another iteration if: there are no more messages AND (there is no limit to max events or we have processed less than the maximum)
             } while (IsListening && networkEvent != NetworkEvent.Nothing);
 
-            m_MessagingSystem.ProcessIncomingMessageQueue();
+            MessagingSystem.ProcessIncomingMessageQueue();
 
 #if DEVELOPMENT_BUILD || UNITY_EDITOR
             s_TransportPoll.End();
@@ -1177,8 +1177,9 @@ private void OnNetworkPreUpdate()
 
         private void OnNetworkPostLateUpdate()
         {
-            m_MessagingSystem.ProcessSendQueues();
+            MessagingSystem.ProcessSendQueues();
             NetworkMetrics.DispatchFrame();
+            SpawnManager.CleanupStaleTriggers();
         }
 
         /// <summary>
@@ -1240,7 +1241,7 @@ private void HandleRawTransportPoll(NetworkEvent networkEvent, ulong clientId, A
 #if DEVELOPMENT_BUILD || UNITY_EDITOR
                     s_TransportConnect.Begin();
 #endif
-                    m_MessagingSystem.ClientConnected(clientId);
+                    MessagingSystem.ClientConnected(clientId);
                     if (IsServer)
                     {
                         if (NetworkLog.CurrentLogLevel <= LogLevel.Developer)
@@ -1332,9 +1333,9 @@ internal unsafe int SendMessage<TMessageType, TClientIdListType>(in TMessageType
                 {
                     return 0;
                 }
-                return m_MessagingSystem.SendMessage(message, delivery, nonServerIds, newIdx);
+                return MessagingSystem.SendMessage(message, delivery, nonServerIds, newIdx);
             }
-            return m_MessagingSystem.SendMessage(message, delivery, clientIds);
+            return MessagingSystem.SendMessage(message, delivery, clientIds);
         }
 
         internal unsafe int SendMessage<T>(in T message, NetworkDelivery delivery,
@@ -1360,10 +1361,10 @@ internal unsafe int SendMessage<T>(in T message, NetworkDelivery delivery,
                 {
                     return 0;
                 }
-                return m_MessagingSystem.SendMessage(message, delivery, nonServerIds, newIdx);
+                return MessagingSystem.SendMessage(message, delivery, nonServerIds, newIdx);
             }
 
-            return m_MessagingSystem.SendMessage(message, delivery, clientIds, numClientIds);
+            return MessagingSystem.SendMessage(message, delivery, clientIds, numClientIds);
         }
 
         internal unsafe int SendMessage<T>(in T message, NetworkDelivery delivery, in NativeArray<ulong> clientIds)
@@ -1380,7 +1381,7 @@ internal int SendMessage<T>(in T message, NetworkDelivery delivery, ulong client
             {
                 return 0;
             }
-            return m_MessagingSystem.SendMessage(message, delivery, clientId);
+            return MessagingSystem.SendMessage(message, delivery, clientId);
         }
 
         internal void HandleIncomingData(ulong clientId, ArraySegment<byte> payload, float receiveTime)
@@ -1389,7 +1390,7 @@ internal void HandleIncomingData(ulong clientId, ArraySegment<byte> payload, flo
             s_HandleIncomingData.Begin();
 #endif
 
-            m_MessagingSystem.HandleIncomingData(clientId, payload, receiveTime);
+            MessagingSystem.HandleIncomingData(clientId, payload, receiveTime);
 
 #if DEVELOPMENT_BUILD || UNITY_EDITOR
             s_HandleIncomingData.End();
@@ -1485,7 +1486,7 @@ private void OnClientDisconnectFromServer(ulong clientId)
 
                 m_ConnectedClients.Remove(clientId);
             }
-            m_MessagingSystem.ClientDisconnected(clientId);
+            MessagingSystem.ClientDisconnected(clientId);
         }
 
         private void SyncTime()
diff --git a/com.unity.netcode.gameobjects/Runtime/Messaging/Messages/ChangeOwnershipMessage.cs b/com.unity.netcode.gameobjects/Runtime/Messaging/Messages/ChangeOwnershipMessage.cs
@@ -18,18 +18,14 @@ public static void Receive(FastBufferReader reader, in NetworkContext context)
                 return;
             }
             reader.ReadValueSafe(out ChangeOwnershipMessage message);
-            message.Handle(context.SenderId, networkManager, reader.Length);
+            message.Handle(reader, context, context.SenderId, networkManager, reader.Length);
         }
 
-        public void Handle(ulong senderId, NetworkManager networkManager, int messageSize)
+        public void Handle(FastBufferReader reader, in NetworkContext context, ulong senderId, NetworkManager networkManager, int messageSize)
         {
             if (!networkManager.SpawnManager.SpawnedObjects.TryGetValue(NetworkObjectId, out var networkObject))
             {
-                if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
-                {
-                    NetworkLog.LogWarning($"Trying to handle owner change but {nameof(NetworkObject)} #{NetworkObjectId} does not exist in {nameof(NetworkSpawnManager.SpawnedObjects)} anymore!");
-                }
-
+                networkManager.SpawnManager.TriggerOnSpawn(NetworkObjectId, reader, context);
                 return;
             }
 
diff --git a/com.unity.netcode.gameobjects/Runtime/Messaging/Messages/NetworkVariableDeltaMessage.cs b/com.unity.netcode.gameobjects/Runtime/Messaging/Messages/NetworkVariableDeltaMessage.cs
@@ -106,10 +106,10 @@ public static void Receive(FastBufferReader reader, in NetworkContext context)
             }
             reader.ReadValue(out message.NetworkObjectId);
             reader.ReadValue(out message.NetworkBehaviourIndex);
-            message.Handle(context.SenderId, reader, networkManager);
+            message.Handle(context.SenderId, reader, context, networkManager);
         }
 
-        public void Handle(ulong senderId, FastBufferReader reader, NetworkManager networkManager)
+        public void Handle(ulong senderId, FastBufferReader reader, in NetworkContext context, NetworkManager networkManager)
         {
             if (networkManager.SpawnManager.SpawnedObjects.TryGetValue(NetworkObjectId, out NetworkObject networkObject))
             {
@@ -214,12 +214,9 @@ public void Handle(ulong senderId, FastBufferReader reader, NetworkManager netwo
                     }
                 }
             }
-            else if (networkManager.IsServer)
+            else
             {
-                if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
-                {
-                    NetworkLog.LogWarning($"Network variable delta message received for a non-existent object with {nameof(NetworkObjectId)}: {NetworkObjectId}. This delta was lost.");
-                }
+                networkManager.SpawnManager.TriggerOnSpawn(NetworkObjectId, reader, context);
             }
         }
     }
diff --git a/com.unity.netcode.gameobjects/Runtime/Messaging/Messages/ParentSyncMessage.cs b/com.unity.netcode.gameobjects/Runtime/Messaging/Messages/ParentSyncMessage.cs
@@ -47,20 +47,20 @@ public static void Receive(FastBufferReader reader, in NetworkContext context)
                 }
             }
 
-            message.Handle(networkManager);
+            message.Handle(reader, context, networkManager);
         }
 
-        public void Handle(NetworkManager networkManager)
+        public void Handle(FastBufferReader reader, in NetworkContext context, NetworkManager networkManager)
         {
             if (networkManager.SpawnManager.SpawnedObjects.ContainsKey(NetworkObjectId))
             {
                 var networkObject = networkManager.SpawnManager.SpawnedObjects[NetworkObjectId];
                 networkObject.SetNetworkParenting(IsReparented, LatestParent);
                 networkObject.ApplyNetworkParenting();
             }
-            else if (NetworkLog.CurrentLogLevel <= LogLevel.Developer)
+            else
             {
-                NetworkLog.LogWarning($"Read {nameof(ParentSyncMessage)} for {nameof(NetworkObject)} #{NetworkObjectId} but could not find it in the {nameof(networkManager.SpawnManager.SpawnedObjects)}");
+                networkManager.SpawnManager.TriggerOnSpawn(NetworkObjectId, reader, context);
             }
         }
     }
diff --git a/com.unity.netcode.gameobjects/Runtime/Messaging/Messages/RpcMessage.cs b/com.unity.netcode.gameobjects/Runtime/Messaging/Messages/RpcMessage.cs
@@ -40,15 +40,23 @@ public static void Receive(FastBufferReader reader, in NetworkContext context)
                 throw new OverflowException("Not enough space in the buffer to read RPC data.");
             }
             reader.ReadValue(out message.Header);
-            message.Handle(reader, (NetworkManager)context.SystemOwner, context.SenderId);
+            message.Handle(reader, context, (NetworkManager)context.SystemOwner, context.SenderId, true);
         }
 
-        public void Handle(FastBufferReader reader, NetworkManager networkManager, ulong senderId)
+        public void Handle(FastBufferReader reader, in NetworkContext context, NetworkManager networkManager, ulong senderId, bool canDefer)
         {
             if (NetworkManager.__rpc_func_table.ContainsKey(Header.NetworkMethodId))
             {
                 if (!networkManager.SpawnManager.SpawnedObjects.ContainsKey(Header.NetworkObjectId))
                 {
+                    if (canDefer)
+                    {
+                        networkManager.SpawnManager.TriggerOnSpawn(Header.NetworkObjectId, reader, context);
+                    }
+                    else
+                    {
+                        NetworkLog.LogError($"Tried to invoke an RPC on a non-existent {nameof(NetworkObject)} with {nameof(canDefer)}=false");
+                    }
                     return;
                 }
 
diff --git a/com.unity.netcode.gameobjects/Runtime/Spawning/NetworkSpawnManager.cs b/com.unity.netcode.gameobjects/Runtime/Spawning/NetworkSpawnManager.cs
diff --git a/testproject/Assets/Tests/Runtime/MessageOrdering.cs b/testproject/Assets/Tests/Runtime/MessageOrdering.cs
diff --git a/testproject/Assets/Tests/Runtime/Support/SpawnRpcDespawn.cs b/testproject/Assets/Tests/Runtime/Support/SpawnRpcDespawn.cs

Original file line number	Diff line number	Diff line change
`@@ -56,7 +56,7 @@ internal static string PrefabDebugHelper(NetworkPrefab networkPrefab)`
`56`	`56`	`internal SnapshotSystem SnapshotSystem { get; private set; }`
`57`	`57`	`internal NetworkBehaviourUpdater BehaviourUpdater { get; private set; }`
`58`	`58`
`59`		`- private MessagingSystem m_MessagingSystem;`
	`59`	`+ internal MessagingSystem MessagingSystem { get; private set; }`
`60`	`60`
`61`	`61`	`private NetworkPrefabHandler m_PrefabHandler;`
`62`	`62`
`@@ -244,7 +244,7 @@ public ulong LocalClientId`
`244`	`244`	`internal set`
`245`	`245`	`{`
`246`	`246`	`m_LocalClientId = value;`
`247`		`- m_MessagingSystem.SetLocalClientId(value);`
	`247`	`+ MessagingSystem.SetLocalClientId(value);`
`248`	`248`	`}`
`249`	`249`	`}`
`250`	`250`
`@@ -497,15 +497,15 @@ private void Initialize(bool server)`
`497`	`497`	`this.RegisterNetworkUpdate(NetworkUpdateStage.EarlyUpdate);`
`498`	`498`	`this.RegisterNetworkUpdate(NetworkUpdateStage.PostLateUpdate);`
`499`	`499`
`500`		`- m_MessagingSystem = new MessagingSystem(new NetworkManagerMessageSender(this), this, ulong.MaxValue);`
	`500`	`+ MessagingSystem = new MessagingSystem(new NetworkManagerMessageSender(this), this, ulong.MaxValue);`
`501`	`501`
`502`		`- m_MessagingSystem.Hook(new NetworkManagerHooks(this));`
	`502`	`+ MessagingSystem.Hook(new NetworkManagerHooks(this));`
`503`	`503`	`#if DEVELOPMENT_BUILD \|\| UNITY_EDITOR`
`504`		`- m_MessagingSystem.Hook(new ProfilingHooks());`
	`504`	`+ MessagingSystem.Hook(new ProfilingHooks());`
`505`	`505`	`#endif`
`506`	`506`
`507`	`507`	`#if MULTIPLAYER_TOOLS`
`508`		`- m_MessagingSystem.Hook(new MetricHooks(this));`
	`508`	`+ MessagingSystem.Hook(new MetricHooks(this));`
`509`	`509`	`#endif`
`510`	`510`	`LocalClientId = ulong.MaxValue;`
`511`	`511`
`@@ -847,7 +847,7 @@ public SocketTasks StartClient()`
`847`	`847`	`}`
`848`	`848`
`849`	`849`	`Initialize(false);`
`850`		`- m_MessagingSystem.ClientConnected(ServerClientId);`
	`850`	`+ MessagingSystem.ClientConnected(ServerClientId);`
`851`	`851`
`852`	`852`	`var socketTasks = NetworkConfig.NetworkTransport.StartClient();`
`853`	`853`
`@@ -893,7 +893,7 @@ public SocketTasks StartHost()`
`893`	`893`	`Initialize(true);`
`894`	`894`
`895`	`895`	`var socketTasks = NetworkConfig.NetworkTransport.StartServer();`
`896`		`- m_MessagingSystem.ClientConnected(ServerClientId);`
	`896`	`+ MessagingSystem.ClientConnected(ServerClientId);`
`897`	`897`	`LocalClientId = ServerClientId;`
`898`	`898`	`NetworkMetrics.SetConnectionId(LocalClientId);`
`899`	`899`
`@@ -1003,9 +1003,9 @@ public void Shutdown()`
`1003`	`1003`	`if (IsServer)`
`1004`	`1004`	`{`
`1005`	`1005`	`// make sure all messages are flushed before transport disconnect clients`
`1006`		`- if (m_MessagingSystem != null)`
	`1006`	`+ if (MessagingSystem != null)`
`1007`	`1007`	`{`
`1008`		`- m_MessagingSystem.ProcessSendQueues();`
	`1008`	`+ MessagingSystem.ProcessSendQueues();`
`1009`	`1009`	`}`
`1010`	`1010`
`1011`	`1011`	`var disconnectedIds = new HashSet<ulong>();`
`@@ -1066,10 +1066,10 @@ public void Shutdown()`
`1066`	`1066`	`NetworkTickSystem = null;`
`1067`	`1067`	`}`
`1068`	`1068`
`1069`		`- if (m_MessagingSystem != null)`
	`1069`	`+ if (MessagingSystem != null)`
`1070`	`1070`	`{`
`1071`		`- m_MessagingSystem.Dispose();`
`1072`		`- m_MessagingSystem = null;`
	`1071`	`+ MessagingSystem.Dispose();`
	`1072`	`+ MessagingSystem = null;`
`1073`	`1073`	`}`
`1074`	`1074`
`1075`	`1075`	`NetworkConfig.NetworkTransport.OnTransportEvent -= HandleRawTransportPoll;`
`@@ -1145,7 +1145,7 @@ private void OnNetworkEarlyUpdate()`
`1145`	`1145`	`// Only do another iteration if: there are no more messages AND (there is no limit to max events or we have processed less than the maximum)`
`1146`	`1146`	`} while (IsListening && networkEvent != NetworkEvent.Nothing);`
`1147`	`1147`
`1148`		`- m_MessagingSystem.ProcessIncomingMessageQueue();`
	`1148`	`+ MessagingSystem.ProcessIncomingMessageQueue();`
`1149`	`1149`
`1150`	`1150`	`#if DEVELOPMENT_BUILD \|\| UNITY_EDITOR`
`1151`	`1151`	`s_TransportPoll.End();`
`@@ -1177,8 +1177,9 @@ private void OnNetworkPreUpdate()`
`1177`	`1177`
`1178`	`1178`	`private void OnNetworkPostLateUpdate()`
`1179`	`1179`	`{`
`1180`		`- m_MessagingSystem.ProcessSendQueues();`
	`1180`	`+ MessagingSystem.ProcessSendQueues();`
`1181`	`1181`	`NetworkMetrics.DispatchFrame();`
	`1182`	`+ SpawnManager.CleanupStaleTriggers();`
`1182`	`1183`	`}`
`1183`	`1184`
`1184`	`1185`	`/// <summary>`
`@@ -1240,7 +1241,7 @@ private void HandleRawTransportPoll(NetworkEvent networkEvent, ulong clientId, A`
`1240`	`1241`	`#if DEVELOPMENT_BUILD \|\| UNITY_EDITOR`
`1241`	`1242`	`s_TransportConnect.Begin();`
`1242`	`1243`	`#endif`
`1243`		`- m_MessagingSystem.ClientConnected(clientId);`
	`1244`	`+ MessagingSystem.ClientConnected(clientId);`
`1244`	`1245`	`if (IsServer)`
`1245`	`1246`	`{`
`1246`	`1247`	`if (NetworkLog.CurrentLogLevel <= LogLevel.Developer)`
`@@ -1332,9 +1333,9 @@ internal unsafe int SendMessage<TMessageType, TClientIdListType>(in TMessageType`
`1332`	`1333`	`{`
`1333`	`1334`	`return 0;`
`1334`	`1335`	`}`
`1335`		`- return m_MessagingSystem.SendMessage(message, delivery, nonServerIds, newIdx);`
	`1336`	`+ return MessagingSystem.SendMessage(message, delivery, nonServerIds, newIdx);`
`1336`	`1337`	`}`
`1337`		`- return m_MessagingSystem.SendMessage(message, delivery, clientIds);`
	`1338`	`+ return MessagingSystem.SendMessage(message, delivery, clientIds);`
`1338`	`1339`	`}`
`1339`	`1340`
`1340`	`1341`	`internal unsafe int SendMessage<T>(in T message, NetworkDelivery delivery,`
`@@ -1360,10 +1361,10 @@ internal unsafe int SendMessage<T>(in T message, NetworkDelivery delivery,`
`1360`	`1361`	`{`
`1361`	`1362`	`return 0;`
`1362`	`1363`	`}`
`1363`		`- return m_MessagingSystem.SendMessage(message, delivery, nonServerIds, newIdx);`
	`1364`	`+ return MessagingSystem.SendMessage(message, delivery, nonServerIds, newIdx);`
`1364`	`1365`	`}`
`1365`	`1366`
`1366`		`- return m_MessagingSystem.SendMessage(message, delivery, clientIds, numClientIds);`
	`1367`	`+ return MessagingSystem.SendMessage(message, delivery, clientIds, numClientIds);`
`1367`	`1368`	`}`
`1368`	`1369`
`1369`	`1370`	`internal unsafe int SendMessage<T>(in T message, NetworkDelivery delivery, in NativeArray<ulong> clientIds)`
`@@ -1380,7 +1381,7 @@ internal int SendMessage<T>(in T message, NetworkDelivery delivery, ulong client`
`1380`	`1381`	`{`
`1381`	`1382`	`return 0;`
`1382`	`1383`	`}`
`1383`		`- return m_MessagingSystem.SendMessage(message, delivery, clientId);`
	`1384`	`+ return MessagingSystem.SendMessage(message, delivery, clientId);`
`1384`	`1385`	`}`
`1385`	`1386`
`1386`	`1387`	`internal void HandleIncomingData(ulong clientId, ArraySegment<byte> payload, float receiveTime)`
`@@ -1389,7 +1390,7 @@ internal void HandleIncomingData(ulong clientId, ArraySegment<byte> payload, flo`
`1389`	`1390`	`s_HandleIncomingData.Begin();`
`1390`	`1391`	`#endif`
`1391`	`1392`
`1392`		`- m_MessagingSystem.HandleIncomingData(clientId, payload, receiveTime);`
	`1393`	`+ MessagingSystem.HandleIncomingData(clientId, payload, receiveTime);`
`1393`	`1394`
`1394`	`1395`	`#if DEVELOPMENT_BUILD \|\| UNITY_EDITOR`
`1395`	`1396`	`s_HandleIncomingData.End();`
`@@ -1485,7 +1486,7 @@ private void OnClientDisconnectFromServer(ulong clientId)`
`1485`	`1486`
`1486`	`1487`	`m_ConnectedClients.Remove(clientId);`
`1487`	`1488`	`}`
`1488`		`- m_MessagingSystem.ClientDisconnected(clientId);`
	`1489`	`+ MessagingSystem.ClientDisconnected(clientId);`
`1489`	`1490`	`}`
`1490`	`1491`
`1491`	`1492`	`private void SyncTime()`
Original file line number	Diff line number	Diff line change
`@@ -18,18 +18,14 @@ public static void Receive(FastBufferReader reader, in NetworkContext context)`
`18`	`18`	`return;`
`19`	`19`	`}`
`20`	`20`	`reader.ReadValueSafe(out ChangeOwnershipMessage message);`
`21`		`- message.Handle(context.SenderId, networkManager, reader.Length);`
	`21`	`+ message.Handle(reader, context, context.SenderId, networkManager, reader.Length);`
`22`	`22`	`}`
`23`	`23`
`24`		`- public void Handle(ulong senderId, NetworkManager networkManager, int messageSize)`
	`24`	`+ public void Handle(FastBufferReader reader, in NetworkContext context, ulong senderId, NetworkManager networkManager, int messageSize)`
`25`	`25`	`{`
`26`	`26`	`if (!networkManager.SpawnManager.SpawnedObjects.TryGetValue(NetworkObjectId, out var networkObject))`
`27`	`27`	`{`
`28`		`- if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)`
`29`		`- {`
`30`		`- NetworkLog.LogWarning($"Trying to handle owner change but {nameof(NetworkObject)} #{NetworkObjectId} does not exist in {nameof(NetworkSpawnManager.SpawnedObjects)} anymore!");`
`31`		`- }`
`32`		`-`
	`28`	`+ networkManager.SpawnManager.TriggerOnSpawn(NetworkObjectId, reader, context);`
`33`	`29`	`return;`
`34`	`30`	`}`
`35`	`31`
Original file line number	Diff line number	Diff line change
`@@ -106,10 +106,10 @@ public static void Receive(FastBufferReader reader, in NetworkContext context)`
`106`	`106`	`}`
`107`	`107`	`reader.ReadValue(out message.NetworkObjectId);`
`108`	`108`	`reader.ReadValue(out message.NetworkBehaviourIndex);`
`109`		`- message.Handle(context.SenderId, reader, networkManager);`
	`109`	`+ message.Handle(context.SenderId, reader, context, networkManager);`
`110`	`110`	`}`
`111`	`111`
`112`		`- public void Handle(ulong senderId, FastBufferReader reader, NetworkManager networkManager)`
	`112`	`+ public void Handle(ulong senderId, FastBufferReader reader, in NetworkContext context, NetworkManager networkManager)`
`113`	`113`	`{`
`114`	`114`	`if (networkManager.SpawnManager.SpawnedObjects.TryGetValue(NetworkObjectId, out NetworkObject networkObject))`
`115`	`115`	`{`
`@@ -214,12 +214,9 @@ public void Handle(ulong senderId, FastBufferReader reader, NetworkManager netwo`
`214`	`214`	`}`
`215`	`215`	`}`
`216`	`216`	`}`
`217`		`- else if (networkManager.IsServer)`
	`217`	`+ else`
`218`	`218`	`{`
`219`		`- if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)`
`220`		`- {`
`221`		`- NetworkLog.LogWarning($"Network variable delta message received for a non-existent object with {nameof(NetworkObjectId)}: {NetworkObjectId}. This delta was lost.");`
`222`		`- }`
	`219`	`+ networkManager.SpawnManager.TriggerOnSpawn(NetworkObjectId, reader, context);`
`223`	`220`	`}`
`224`	`221`	`}`
`225`	`222`	`}`
Original file line number	Diff line number	Diff line change
`@@ -47,20 +47,20 @@ public static void Receive(FastBufferReader reader, in NetworkContext context)`
`47`	`47`	`}`
`48`	`48`	`}`
`49`	`49`
`50`		`- message.Handle(networkManager);`
	`50`	`+ message.Handle(reader, context, networkManager);`
`51`	`51`	`}`
`52`	`52`
`53`		`- public void Handle(NetworkManager networkManager)`
	`53`	`+ public void Handle(FastBufferReader reader, in NetworkContext context, NetworkManager networkManager)`
`54`	`54`	`{`
`55`	`55`	`if (networkManager.SpawnManager.SpawnedObjects.ContainsKey(NetworkObjectId))`
`56`	`56`	`{`
`57`	`57`	`var networkObject = networkManager.SpawnManager.SpawnedObjects[NetworkObjectId];`
`58`	`58`	`networkObject.SetNetworkParenting(IsReparented, LatestParent);`
`59`	`59`	`networkObject.ApplyNetworkParenting();`
`60`	`60`	`}`
`61`		`- else if (NetworkLog.CurrentLogLevel <= LogLevel.Developer)`
	`61`	`+ else`
`62`	`62`	`{`
`63`		`- NetworkLog.LogWarning($"Read {nameof(ParentSyncMessage)} for {nameof(NetworkObject)} #{NetworkObjectId} but could not find it in the {nameof(networkManager.SpawnManager.SpawnedObjects)}");`
	`63`	`+ networkManager.SpawnManager.TriggerOnSpawn(NetworkObjectId, reader, context);`
`64`	`64`	`}`
`65`	`65`	`}`
`66`	`66`	`}`
Original file line number	Diff line number	Diff line change
`@@ -40,15 +40,23 @@ public static void Receive(FastBufferReader reader, in NetworkContext context)`
`40`	`40`	`throw new OverflowException("Not enough space in the buffer to read RPC data.");`
`41`	`41`	`}`
`42`	`42`	`reader.ReadValue(out message.Header);`
`43`		`- message.Handle(reader, (NetworkManager)context.SystemOwner, context.SenderId);`
	`43`	`+ message.Handle(reader, context, (NetworkManager)context.SystemOwner, context.SenderId, true);`
`44`	`44`	`}`
`45`	`45`
`46`		`- public void Handle(FastBufferReader reader, NetworkManager networkManager, ulong senderId)`
	`46`	`+ public void Handle(FastBufferReader reader, in NetworkContext context, NetworkManager networkManager, ulong senderId, bool canDefer)`
`47`	`47`	`{`
`48`	`48`	`if (NetworkManager.__rpc_func_table.ContainsKey(Header.NetworkMethodId))`
`49`	`49`	`{`
`50`	`50`	`if (!networkManager.SpawnManager.SpawnedObjects.ContainsKey(Header.NetworkObjectId))`
`51`	`51`	`{`
	`52`	`+ if (canDefer)`
	`53`	`+ {`
	`54`	`+ networkManager.SpawnManager.TriggerOnSpawn(Header.NetworkObjectId, reader, context);`
	`55`	`+ }`
	`56`	`+ else`
	`57`	`+ {`
	`58`	`+ NetworkLog.LogError($"Tried to invoke an RPC on a non-existent {nameof(NetworkObject)} with {nameof(canDefer)}=false");`
	`59`	`+ }`
`52`	`60`	`return;`
`53`	`61`	`}`
`54`	`62`