refactor

Had to make some minor adjustments in order to assure that users could handle sending any last micro-second tasks on any spawned instances prior to them despawning.

Added NetworkBehaviour.OnNetworkPreDespawn.
Did a slight order of operations on NetworkManager.Shutdown internal in order to assure sending RPCs during despawn would still work.

Minor adjustments to the new helper components associated with this PR.

Author: NoelStephensUnity

com.unity.netcode.gameobjects/Runtime/Components/Helpers/AttachableBehaviour.cs

@@ -333,6 +333,10 @@ internal void InternalDetach()
         /// </summary>
         public void Detach()
         {
+            if (!gameObject)
+            {
+                return;
+            }
             if (!IsSpawned)
             {
                 NetworkLog.LogError($"[{name}][Detach][Not Spawned] Cannot detach if not spawned!");
@@ -399,7 +403,7 @@ private void ChangeReference(NetworkBehaviourReference networkBehaviourReference
         }
 
         [Rpc(SendTo.NotMe)]
-        private void UpdateAttachStateRpc(NetworkBehaviourReference attachedNodeReference)
+        private void UpdateAttachStateRpc(NetworkBehaviourReference attachedNodeReference, RpcParams rpcParams = default)
         {
             ChangeReference(attachedNodeReference);
         }

com.unity.netcode.gameobjects/Runtime/Components/Helpers/AttachableNode.cs

@@ -19,6 +19,11 @@ public class AttachableNode : NetworkBehaviour
     /// </summary>
     public bool HasAttachments => m_AttachedBehaviours.Count > 0;
 
+    /// <summary>
+    /// When enabled, any attached <see cref="AttachableBehaviour"/>s will be automatically detached and re-parented under its original parent.
+    /// </summary>
+    public bool DetachOnDespawn = true;
+
     /// <summary>
     /// A <see cref="List{T}"/> of the currently attached <see cref="AttachableBehaviour"/>s.
     /// </summary>
@@ -29,12 +34,22 @@ public class AttachableNode : NetworkBehaviour
     /// If the <see cref="NetworkObject"/> this <see cref="AttachableNode"/> belongs to is despawned,
     /// then any attached <see cref="AttachableBehaviour"/> will be detached during <see cref="OnNetworkDespawn"/>.
     /// </remarks>
-    public override void OnNetworkDespawn()
+    public override void OnNetworkPreDespawn()
     {
-        for (int i = m_AttachedBehaviours.Count - 1; i > 0; i--)
+        if (IsSpawned && HasAuthority && DetachOnDespawn)
         {
-            m_AttachedBehaviours[i].InternalDetach();
+            for (int i = m_AttachedBehaviours.Count - 1; i >= 0; i--)
+            {
+                m_AttachedBehaviours[i]?.Detach();
+            }
         }
+        base.OnNetworkPreDespawn();
+    }
+
+    /// <inheritdoc/>
+    public override void OnNetworkDespawn()
+    {
+        m_AttachedBehaviours.Clear();
         base.OnNetworkDespawn();
     }
 

com.unity.netcode.gameobjects/Runtime/Components/Helpers/ComponentController.cs

@@ -462,7 +462,7 @@ protected virtual bool OnHasAuthority()
         }
 
         [Rpc(SendTo.NotMe)]
-        private void ToggleEnabledRpc(bool enabled)
+        private void ToggleEnabledRpc(bool enabled, RpcParams rpcParams = default)
         {
             ChangeEnabled(enabled);
         }

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

@@ -737,6 +737,11 @@ protected virtual void OnInSceneObjectsSpawned() { }
         /// </summary>
         public virtual void OnNetworkDespawn() { }
 
+        /// <summary>
+        /// Gets called before <see cref="OnNetworkDespawn"/> has been invoked for all <see cref="NetworkBehaviour"/>s associated with the currently spawned <see cref="NetworkObject"/> instance.
+        /// </summary>
+        public virtual void OnNetworkPreDespawn() { }
+
         internal void NetworkPreSpawn(ref NetworkManager networkManager)
         {
             try
@@ -816,6 +821,18 @@ internal void InSceneNetworkObjectsSpawned()
             }
         }
 
+        internal void InternalOnNetworkPreDespawn()
+        {
+            try
+            {
+                OnNetworkPreDespawn();
+            }
+            catch (Exception e)
+            {
+                Debug.LogException(e);
+            }
+        }
+
         internal void InternalOnNetworkDespawn()
         {
             IsSpawned = false;

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

@@ -1552,12 +1552,27 @@ internal void ShutdownInternal()
             DeferredMessageManager?.CleanupAllTriggers();
             CustomMessagingManager = null;
 
-            RpcTarget?.Dispose();
-            RpcTarget = null;
-
             BehaviourUpdater?.Shutdown();
             BehaviourUpdater = null;
 
+            /// Despawning upon shutdown
+
+            // We need to clean up NetworkObjects before we reset the IsServer
+            // and IsClient properties. This provides consistency of these two
+            // property values for NetworkObjects that are still spawned when
+            // the shutdown cycle begins.
+
+            // We need to handle despawning prior to shutting down the connection
+            // manager or disposing of the RpcTarget so any final updates can take
+            // place (i.e. sending any last state updates or the like).
+
+            SpawnManager?.DespawnAndDestroyNetworkObjects();
+            SpawnManager?.ServerResetShudownStateForSceneObjects();
+            ////
+
+            RpcTarget?.Dispose();
+            RpcTarget = null;
+
             // Shutdown connection manager last which shuts down transport
             ConnectionManager.Shutdown();
 
@@ -1567,17 +1582,12 @@ internal void ShutdownInternal()
                 MessageManager = null;
             }
 
-            // We need to clean up NetworkObjects before we reset the IsServer
-            // and IsClient properties. This provides consistency of these two
-            // property values for NetworkObjects that are still spawned when
-            // the shutdown cycle begins.
-            SpawnManager?.DespawnAndDestroyNetworkObjects();
-            SpawnManager?.ServerResetShudownStateForSceneObjects();
-            SpawnManager = null;
-
             // Let the NetworkSceneManager clean up its two SceneEvenData instances
             SceneManager?.Dispose();
             SceneManager = null;
+
+            SpawnManager = null;
+
             IsListening = false;
             m_ShuttingDown = false;
 

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

@@ -2604,6 +2604,12 @@ internal void InternalInSceneNetworkObjectsSpawned()
 
         internal void InvokeBehaviourNetworkDespawn()
         {
+            // Invoke OnNetworkPreDespawn on all child behaviours
+            for (int i = 0; i < ChildNetworkBehaviours.Count; i++)
+            {
+                ChildNetworkBehaviours[i].InternalOnNetworkPreDespawn();
+            }
+
             NetworkManager.SpawnManager.UpdateOwnershipTable(this, OwnerClientId, true);
             NetworkManager.SpawnManager.RemoveNetworkObjectFromSceneChangedUpdates(this);
 

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

@@ -1474,16 +1474,8 @@ internal void DespawnAndDestroyNetworkObjects()
                             }
                         }
 
-                        // If spawned, then despawn and potentially destroy.
-                        if (networkObjects[i].IsSpawned)
-                        {
-                            OnDespawnObject(networkObjects[i], shouldDestroy);
-                        }
-                        else // Otherwise, if we are not spawned and we should destroy...then destroy.
-                        if (shouldDestroy)
-                        {
-                            UnityEngine.Object.Destroy(networkObjects[i].gameObject);
-                        }
+                        //Despawn and potentially destroy.
+                        OnDespawnObject(networkObjects[i], shouldDestroy);
                     }
                 }
             }