fix: respawn hybrid NetworkObject on NetworkShow after NetworkHide (#4236)

* fix: respawn hybrid NetworkObject on NetworkShow after NetworkHide

On a client, despawning a hybrid NetworkObject leaves its GameObject to N4E,
and NetworkHide does not make the ghost irrelevant, so the instance survives.
Its pending ghost spawn entry was consumed on first spawn, so the CreateObjectMessage
sent by NetworkShow waited for a ghost spawn that never came.

The client now re-registers the surviving instance as a pending ghost spawn;
NetworkObject.OnDestroy already drops the entry if N4E later destroys it.

* fix: keep a re-shown hybrid instance usable after NetworkHide

The despawn on NetworkHide marks the instance and its NetworkBehaviours as destroying,
which stuck once the instance survived, so AttachableBehaviour could no longer detach on
the client. The surviving instance now clears that flag.

A retained child that NGO parented is no longer a root GameObject, so NetworkShow threw
in MoveGameObjectToScene. Only root instances are moved into the active scene.

Author: NoelStephensUnity

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

@@ -702,6 +702,14 @@ internal void SetIsDestroying()
             IsDestroying = true;
         }
 
+        /// <summary>
+        /// Invoked by <see cref="NetworkObject.ResetIsDestroying"/>.
+        /// </summary>
+        internal void ResetIsDestroying()
+        {
+            IsDestroying = false;
+        }
+
         /// <summary>
         /// Updates properties with network session related
         /// dependencies such as a NetworkObject's spawned

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

@@ -1953,14 +1953,29 @@ internal void SetIsDestroying()
                 {
                     // Tell the childBehaviour that this NetworkObject is being destroyed.
                     // Keeping the property a private set to assure this is
-                    // the only way it can be set as it should never be reset
-                    // back to false once invoked.
+                    // the only way it can be set. Only a hybrid instance that
+                    // its ghost keeps alive resets it (ResetIsDestroying).
                     childBehaviour?.SetIsDestroying();
                 }
             }
             IsDestroying = true;
         }
 
+        /// <summary>
+        /// Clears the despawning flag of a hybrid instance that its ghost keeps alive, and of its child NetworkBehaviours.
+        /// </summary>
+        internal void ResetIsDestroying()
+        {
+            if (ChildNetworkBehaviours != null)
+            {
+                foreach (var childBehaviour in ChildNetworkBehaviours.Values)
+                {
+                    childBehaviour?.ResetIsDestroying();
+                }
+            }
+            IsDestroying = false;
+        }
+
         private void OnDestroy()
         {
             SceneManager.activeSceneChanged -= CurrentlyActiveSceneChanged;

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

@@ -115,7 +115,11 @@ internal bool TryGetGhostNetworkObjectForSpawn(NetworkObject.SerializedObject se
 
             // TODO-UNIFIED: We need a better way to preserve any hybrid instances pending NGO spawn.
             // NOTE: We might be able to use the NetworkSceneHandle to get the associated local scene handle to which we can use to get the targeted scene.
-            UnityEngine.SceneManagement.SceneManager.MoveGameObjectToScene(networkObject.gameObject, UnityEngine.SceneManagement.SceneManager.GetActiveScene());
+            // A child kept alive by its ghost (NetworkHide) is still parented and stays in its parent's scene.
+            if (networkObject.transform.parent == null)
+            {
+                UnityEngine.SceneManagement.SceneManager.MoveGameObjectToScene(networkObject.gameObject, UnityEngine.SceneManagement.SceneManager.GetActiveScene());
+            }
             return true;
         }
 

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

@@ -1958,7 +1958,12 @@ internal void OnDespawnObject([NotNull] NetworkObject networkObject, bool destro
             // Unified netcode handles destroying the instance of the object on the non-authority side when the object has a ghost representation.
             if (destroyGameObject && networkObject.HasGhost && !NetworkManager.IsServer)
             {
-                // exit early
+                // A NetworkHide leaves the ghost alive, so the instance waits for a later NetworkShow (removed again if N4E destroys it).
+                if (networkObject && NetworkManager.IsConnectedClient && !NetworkManager.ShutdownInProgress)
+                {
+                    networkObject.ResetIsDestroying();
+                    GhostSpawnManager.RegisterGhostPendingSpawn(networkObject, networkObject.NetworkObjectId);
+                }
                 return;
             }
 #endif

com.unity.netcode.gameobjects/Tests/Runtime/NetworkObject/HybridNetworkShowHideTests.cs

@@ -0,0 +1,152 @@
+#if UNIFIED_NETCODE
+using System;
+using System.Collections;
+using NUnit.Framework;
+using Unity.Netcode.Components;
+using Unity.Netcode.TestHelpers.Runtime;
+using UnityEngine;
+using UnityEngine.TestTools;
+
+namespace Unity.Netcode.RuntimeTests
+{
+    /// <summary>
+    /// Validates that hiding and then showing a spawned hybrid instance respawns it on the client.
+    /// </summary>
+    [TestFixture(HostOrServer.UnifiedHost)]
+    [TestFixture(HostOrServer.UnifiedServer)]
+    internal class HybridNetworkShowHideTests : NetcodeIntegrationTest
+    {
+        protected override int NumberOfClients => 1;
+
+        private GameObject m_HybridPrefab;
+        private GameObject m_AttachablePrefab;
+        private GameObject m_AttachableNodePrefab;
+        private ulong m_NetworkObjectId;
+
+        public HybridNetworkShowHideTests(HostOrServer hostOrServer) : base(hostOrServer) { }
+
+        protected override bool UseUnifiedTests()
+        {
+            return true;
+        }
+
+        protected override void OnServerAndClientsCreated()
+        {
+            m_HybridPrefab = CreateNetworkObjectPrefab("HybridShowHide");
+            m_AttachablePrefab = CreateNetworkObjectPrefab("HybridAttachable");
+            var attachableChild = new GameObject("AttachableChild");
+            attachableChild.transform.parent = m_AttachablePrefab.transform;
+            attachableChild.AddComponent<AttachableBehaviour>();
+            m_AttachableNodePrefab = CreateNetworkObjectPrefab("HybridAttachableNode");
+            var nodeChild = new GameObject("NodeChild");
+            nodeChild.transform.parent = m_AttachableNodePrefab.transform;
+            nodeChild.AddComponent<AttachableNode>();
+            base.OnServerAndClientsCreated();
+        }
+
+        private bool IsSpawnedOnClient()
+        {
+            return GetNonAuthorityNetworkManager().SpawnManager.SpawnedObjects.ContainsKey(m_NetworkObjectId);
+        }
+
+        private IEnumerator SpawnOnAll(GameObject prefab, Action<NetworkObject> onSpawned)
+        {
+            var authorityInstance = SpawnObject(prefab, GetAuthorityNetworkManager()).GetComponent<NetworkObject>();
+            yield return WaitForSpawnedOnAllOrTimeOut(authorityInstance);
+            AssertOnTimeout($"[Setup] {authorityInstance.name} was not spawned on all instances!");
+            onSpawned(authorityInstance);
+        }
+
+        private IEnumerator HideThenShow(NetworkObject authorityInstance, string context)
+        {
+            var nonAuthority = GetNonAuthorityNetworkManager();
+            m_NetworkObjectId = authorityInstance.NetworkObjectId;
+            authorityInstance.NetworkHide(nonAuthority.LocalClientId);
+            yield return WaitForConditionOrTimeOut(() => !IsSpawnedOnClient());
+            AssertOnTimeout($"[{context}] {authorityInstance.name} was not despawned on Client-{nonAuthority.LocalClientId}!");
+
+            authorityInstance.NetworkShow(nonAuthority.LocalClientId);
+            yield return WaitForConditionOrTimeOut(IsSpawnedOnClient);
+            AssertOnTimeout($"[{context}] {authorityInstance.name} was not respawned on Client-{nonAuthority.LocalClientId}!");
+        }
+
+        [UnityTest]
+        public IEnumerator HideThenShowRespawnsOnClient()
+        {
+            var nonAuthority = GetNonAuthorityNetworkManager();
+            NetworkObject authorityInstance = null;
+            yield return SpawnOnAll(m_HybridPrefab, spawned => authorityInstance = spawned);
+            var clientInstance = nonAuthority.SpawnManager.SpawnedObjects[authorityInstance.NetworkObjectId];
+
+            // A second cycle shows the respawned instance can be hidden and shown again.
+            for (int i = 0; i < 2; i++)
+            {
+                yield return HideThenShow(authorityInstance, $"Cycle {i}");
+                Assert.AreSame(clientInstance, nonAuthority.SpawnManager.SpawnedObjects[m_NetworkObjectId], $"[Cycle {i}] Client-{nonAuthority.LocalClientId} did not respawn the instance its ghost kept alive!");
+            }
+        }
+
+        [UnityTest]
+        public IEnumerator HideThenShowParentedChild()
+        {
+            var nonAuthority = GetNonAuthorityNetworkManager();
+            NetworkObject parent = null;
+            NetworkObject child = null;
+            yield return SpawnOnAll(m_HybridPrefab, spawned => parent = spawned);
+            yield return SpawnOnAll(m_HybridPrefab, spawned => child = spawned);
+            var clientParent = nonAuthority.SpawnManager.SpawnedObjects[parent.NetworkObjectId].transform;
+            var clientChild = nonAuthority.SpawnManager.SpawnedObjects[child.NetworkObjectId].transform;
+            Assert.IsTrue(child.TrySetParent(parent, false), $"{nameof(NetworkObject.TrySetParent)} failed!");
+            yield return WaitForConditionOrTimeOut(() => clientChild.parent == clientParent);
+            AssertOnTimeout($"[Setup] {child.name} was not parented on Client-{nonAuthority.LocalClientId}!");
+
+            yield return HideThenShow(child, "Parented");
+            Assert.AreSame(clientParent, clientChild.parent, $"Client-{nonAuthority.LocalClientId} did not keep {child.name} parented!");
+        }
+
+        [UnityTest]
+        public IEnumerator HideThenShowThenAttachAndDetach()
+        {
+            var nonAuthority = GetNonAuthorityNetworkManager();
+            NetworkObject source = null;
+            NetworkObject node = null;
+            yield return SpawnOnAll(m_AttachablePrefab, spawned => source = spawned);
+            yield return SpawnOnAll(m_AttachableNodePrefab, spawned => node = spawned);
+            yield return HideThenShow(source, "Attachable");
+
+            var clientSource = nonAuthority.SpawnManager.SpawnedObjects[source.NetworkObjectId].transform;
+            var clientAttachable = clientSource.GetComponentInChildren<AttachableBehaviour>().transform;
+            var clientNode = nonAuthority.SpawnManager.SpawnedObjects[node.NetworkObjectId].GetComponentInChildren<AttachableNode>().transform;
+            var attachable = source.GetComponentInChildren<AttachableBehaviour>();
+
+            attachable.Attach(node.GetComponentInChildren<AttachableNode>());
+            yield return WaitForConditionOrTimeOut(() => clientAttachable.parent == clientNode);
+            AssertOnTimeout($"Client-{nonAuthority.LocalClientId} did not attach {clientAttachable.name}!");
+
+            attachable.Detach();
+            yield return WaitForConditionOrTimeOut(() => clientAttachable.parent == clientSource);
+            AssertOnTimeout($"Client-{nonAuthority.LocalClientId} did not detach {clientAttachable.name}!");
+        }
+
+        [UnityTest]
+        public IEnumerator DespawnWhileHiddenReleasesClientInstance()
+        {
+            var nonAuthority = GetNonAuthorityNetworkManager();
+            NetworkObject authorityInstance = null;
+            yield return SpawnOnAll(m_HybridPrefab, spawned => authorityInstance = spawned);
+            m_NetworkObjectId = authorityInstance.NetworkObjectId;
+            var clientInstance = nonAuthority.SpawnManager.SpawnedObjects[m_NetworkObjectId];
+
+            authorityInstance.NetworkHide(nonAuthority.LocalClientId);
+            yield return WaitForConditionOrTimeOut(() => !IsSpawnedOnClient());
+            AssertOnTimeout($"[Setup] {authorityInstance.name} was not despawned on Client-{nonAuthority.LocalClientId}!");
+            Assert.IsTrue(nonAuthority.SpawnManager.GhostSpawnManager.IsGhostPendingSpawn(m_NetworkObjectId), $"Client-{nonAuthority.LocalClientId} is not holding the hidden instance for a later show!");
+
+            authorityInstance.Despawn();
+            yield return WaitForConditionOrTimeOut(() => clientInstance == null);
+            AssertOnTimeout($"N4E did not destroy the hidden instance on Client-{nonAuthority.LocalClientId}!");
+            Assert.IsFalse(nonAuthority.SpawnManager.GhostSpawnManager.IsGhostPendingSpawn(m_NetworkObjectId), $"Client-{nonAuthority.LocalClientId} still holds the destroyed instance as pending!");
+        }
+    }
+}
+#endif