fix/mttb-1377/synchronize-despawn-to-client

Author: EmandM

com.unity.netcode.gameobjects/Runtime/Connection/NetworkConnectionManager.cs

@@ -7,6 +7,7 @@
 using Unity.Collections.LowLevel.Unsafe;
 using Unity.Profiling;
 using UnityEngine;
+using Object = UnityEngine.Object;
 
 namespace Unity.Netcode
 {
@@ -1126,36 +1127,15 @@ internal void OnClientDisconnectFromServer(ulong clientId)
                 {
                     if (!playerObject.DontDestroyWithOwner)
                     {
-                        // If a player NetworkObject is being despawned, make sure to remove all children if they are marked to not be destroyed
-                        // with the owner.
-                        if (NetworkManager.DAHost)
-                        {
-                            // Remove any children from the player object if they are not going to be destroyed with the owner
-                            var childNetworkObjects = playerObject.GetComponentsInChildren<NetworkObject>();
-                            foreach (var child in childNetworkObjects)
-                            {
-                                // TODO: We have always just removed all children, but we might think about changing this to preserve the nested child hierarchy.
-                                if (child.DontDestroyWithOwner && child.transform.transform.parent)
-                                {
-                                    // If we are here, then we are running in DAHost mode and have the authority to remove the child from its parent
-                                    child.AuthorityAppliedParenting = true;
-                                    child.TryRemoveParentCachedWorldPositionStays();
-                                }
-                            }
-                        }
-
-                        if (NetworkManager.PrefabHandler.ContainsHandler(playerObject.GlobalObjectIdHash))
-                        {
-                            // Despawn but don't destroy. DA Host will act like the service and send despawn notifications.
-                            NetworkManager.SpawnManager.DespawnObject(playerObject, false, NetworkManager.DistributedAuthorityMode);
-                            // Let the prefab handler determine if it will be destroyed
-                            NetworkManager.PrefabHandler.HandleNetworkPrefabDestroy(playerObject);
-                        }
-                        else if (playerObject.IsSpawned)
+                        if (playerObject.IsSpawned)
                         {
                             // Call despawn to assure NetworkBehaviour.OnNetworkDespawn is invoked on the server-side (when the client side disconnected).
                             // This prevents the issue (when just destroying the GameObject) where any NetworkBehaviour component(s) destroyed before the NetworkObject would not have OnNetworkDespawn invoked.
-                            NetworkManager.SpawnManager.DespawnObject(playerObject, true, NetworkManager.DistributedAuthorityMode);
+                            NetworkManager.SpawnManager.DespawnObject(playerObject, true, true);
+                        }
+                        else
+                        {
+                            Object.Destroy(playerObject.gameObject);
                         }
                     }
                     else if (!NetworkManager.ShutdownInProgress)
@@ -1180,18 +1160,13 @@ internal void OnClientDisconnectFromServer(ulong clientId)
                         // Handle an object with no observers other than the current disconnecting client as destroying with owner
                         if (!ownedObject.DontDestroyWithOwner && (ownedObject.Observers.Count == 0 || (ownedObject.Observers.Count == 1 && ownedObject.Observers.Contains(clientId))))
                         {
-                            if (NetworkManager.PrefabHandler.ContainsHandler(ownedObject.GlobalObjectIdHash))
+                            if (ownedObject.IsSpawned)
                             {
-                                if (ownedObject.IsSpawned)
-                                {
-                                    // Don't destroy (prefab handler will determine this, but always notify
-                                    NetworkManager.SpawnManager.DespawnObject(ownedObject, false, true);
-                                }
-                                NetworkManager.PrefabHandler.HandleNetworkPrefabDestroy(ownedObject);
+                                NetworkManager.SpawnManager.DespawnObject(ownedObject, true, true);
                             }
                             else
                             {
-                                NetworkManager.SpawnManager.DespawnObject(ownedObject, true, true);
+                                Object.Destroy(ownedObject.gameObject);
                             }
                         }
                         else if (!NetworkManager.ShutdownInProgress)

com.unity.netcode.gameobjects/Runtime/Messaging/Messages/DestroyObjectMessage.cs

@@ -1,22 +1,19 @@
 using System.Linq;
 using System.Runtime.CompilerServices;
+using UnityEngine;
 
 namespace Unity.Netcode
 {
     internal struct DestroyObjectMessage : INetworkMessage, INetworkSerializeByMemcpy
     {
         private const int k_OptimizeDestroyObjectMessage = 1;
-        public int Version => k_OptimizeDestroyObjectMessage;
+        private const int k_AllowDestroyGameInPlaced = 2;
+        public int Version => k_AllowDestroyGameInPlaced;
 
         private const string k_Name = "DestroyObjectMessage";
 
         public ulong NetworkObjectId;
 
-        /// <summary>
-        /// Used to communicate whether to destroy the associated game object.
-        /// Should be false if the object is InScenePlaced and true otherwise
-        /// </summary>
-        public bool DestroyGameObject;
         private byte m_DestroyFlags;
 
         internal int DeferredDespawnTick;
@@ -25,32 +22,29 @@ internal struct DestroyObjectMessage : INetworkMessage, INetworkSerializeByMemcp
 
         internal bool IsDistributedAuthority;
 
-        private const byte k_ClientTargetedDestroy = 0x01;
-        private const byte k_DeferredDespawn = 0x02;
-
         internal bool IsTargetedDestroy
         {
-            get => GetFlag(k_ClientTargetedDestroy);
+            get => ByteUtility.GetBit(m_DestroyFlags, 0);
 
-            set => SetFlag(value, k_ClientTargetedDestroy);
+            set => ByteUtility.SetBit(ref m_DestroyFlags, 0, value);
         }
 
         private bool IsDeferredDespawn
         {
-            get => GetFlag(k_DeferredDespawn);
+            get => ByteUtility.GetBit(m_DestroyFlags, 1);
 
-            set => SetFlag(value, k_DeferredDespawn);
+            set => ByteUtility.SetBit(ref m_DestroyFlags, 1, value);
         }
 
-        private bool GetFlag(int flag)
+        /// <summary>
+        /// Used to communicate whether to destroy the associated game object.
+        /// Should be false if the object is InScenePlaced and true otherwise
+        /// </summary>
+        public bool DestroyGameObject
         {
-            return (m_DestroyFlags & flag) != 0;
-        }
+            get => ByteUtility.GetBit(m_DestroyFlags, 2);
 
-        private void SetFlag(bool set, byte flag)
-        {
-            if (set) { m_DestroyFlags = (byte)(m_DestroyFlags | flag); }
-            else { m_DestroyFlags = (byte)(m_DestroyFlags & ~flag); }
+            set => ByteUtility.SetBit(ref m_DestroyFlags, 2, value);
         }
 
         public void Serialize(FastBufferWriter writer, int targetVersion)
@@ -73,6 +67,9 @@ public void Serialize(FastBufferWriter writer, int targetVersion)
                 {
                     BytePacker.WriteValueBitPacked(writer, DeferredDespawnTick);
                 }
+            } else if (targetVersion >= k_AllowDestroyGameInPlaced)
+            {
+                writer.WriteByteSafe(m_DestroyFlags);
             }
 
             if (targetVersion < k_OptimizeDestroyObjectMessage)
@@ -102,11 +99,15 @@ public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int
                 {
                     ByteUnpacker.ReadValueBitPacked(reader, out DeferredDespawnTick);
                 }
+            } else if (receivedMessageVersion >= k_AllowDestroyGameInPlaced)
+            {
+                reader.ReadByteSafe(out m_DestroyFlags);
             }
 
             if (receivedMessageVersion < k_OptimizeDestroyObjectMessage)
             {
-                reader.ReadValueSafe(out DestroyGameObject);
+                reader.ReadValueSafe(out bool destroyGameObject);
+                DestroyGameObject = destroyGameObject;
             }
 
             if (networkManager.SpawnManager.SpawnedObjects.ContainsKey(NetworkObjectId))
@@ -169,7 +170,7 @@ public void Handle(ref NetworkContext context)
             }
 
             // Otherwise just despawn the NetworkObject right now
-            networkManager.SpawnManager.OnDespawnNonAuthorityObject(networkObject);
+            networkManager.SpawnManager.OnDespawnNonAuthorityObject(networkObject, DestroyGameObject);
             networkManager.NetworkMetrics.TrackObjectDestroyReceived(context.SenderId, networkObject, context.MessageSize);
         }
 
@@ -208,7 +209,7 @@ private void HandleDeferredDespawn(ref NetworkManager networkManager, ref Networ
         {
             networkObject.DeferredDespawnTick = DeferredDespawnTick;
             var hasCallback = networkObject.OnDeferredDespawnComplete != null;
-            networkManager.SpawnManager.DeferDespawnNetworkObject(NetworkObjectId, DeferredDespawnTick, hasCallback);
+            networkManager.SpawnManager.DeferDespawnNetworkObject(NetworkObjectId, DeferredDespawnTick, hasCallback, DestroyGameObject);
         }
     }
 }