fix: distribute parented children distributing with root parent (#3203)

* fix

This is the initial fix for distributing parented children that have the distributable and/or transferrable permissions set and have the same owner as the root parent, that has the distributable permission set, upon the owning client disconnecting when using a distributed authority network topology.

* update

Adding initial change log entry.

* update

adding PR number to entry

* update

Handle check for parent earlier.
Add additional comment details.

* fix

Adding DAHost side object hierarchy redistribution when a client disconnects.
Adding a DA specific work around for integration testing when instantiating and spawning a player within the test runner scene.

* test

The test to validate these changes using a DAHost.

* style

Removing white spaces

* test

Adding ownership locking to the test.

Author: NoelStephensUnity

com.unity.netcode.gameobjects/CHANGELOG.md

@@ -14,12 +14,13 @@ Additional documentation and release notes are available at [Multiplayer Documen
 
 - Fixed exception being thrown when a `GameObject` with an associated `NetworkTransform` is disabled. (#3243)
 - Fixed `NetworkObject.DeferDespawn` to respect the `DestroyGameObject` parameter. (#3219)
-- Changed the `NetworkTimeSystem.Sync` method to use half RTT to calculate the desired local time offset as opposed to the full RTT. (#3212)
+- Fixed issue with distributing parented children that have the distributable and/or transferrable permissions set and have the same owner as the root parent, that has the distributable permission set, were not being distributed to the same client upon the owning client disconnecting when using a distributed authority network topology. (#3203)
 - Fixed issue where a spawned `NetworkObject` that was registered with a prefab handler and owned by a client would invoke destroy more than once on the host-server side if the client disconnected while the `NetworkObject` was still spawned. (#3200)
 - Fixed issue where `NetworkVariableBase` derived classes were not being re-initialized if the associated `NetworkObject` instance was not destroyed and re-spawned. (#3181)
 
 ### Changed
 
+- Changed the `NetworkTimeSystem.Sync` method to use half RTT to calculate the desired local time offset as opposed to the full RTT. (#3212)
 
 ## [2.2.0] - 2024-12-12
 

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

@@ -1225,7 +1225,7 @@ internal void OnClientDisconnectFromServer(ulong clientId)
                                     }
                                     NetworkManager.SpawnManager.ChangeOwnership(ownedObject, targetOwner, true);
                                     // DANGO-TODO: Should we try handling inactive NetworkObjects?
-                                    // Ownership gets passed down to all children
+                                    // Ownership gets passed down to all children that have the same owner.
                                     var childNetworkObjects = ownedObject.GetComponentsInChildren<NetworkObject>();
                                     foreach (var childObject in childNetworkObjects)
                                     {
@@ -1245,6 +1245,14 @@ internal void OnClientDisconnectFromServer(ulong clientId)
                                         {
                                             continue;
                                         }
+
+                                        // If the child's owner is not the client disconnected and the objects are marked with either distributable or transferable, then
+                                        // do not change ownership.
+                                        if (childObject.OwnerClientId != clientId && (childObject.IsOwnershipDistributable || childObject.IsOwnershipTransferable))
+                                        {
+                                            continue;
+                                        }
+
                                         NetworkManager.SpawnManager.ChangeOwnership(childObject, targetOwner, true);
                                         if (EnableDistributeLogging)
                                         {

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

@@ -1659,7 +1659,20 @@ internal void SpawnInternal(bool destroyWithScene, ulong ownerClientId, bool pla
                 }
                 if (NetworkManager.NetworkConfig.EnableSceneManagement)
                 {
-                    NetworkSceneHandle = NetworkManager.SceneManager.ClientSceneHandleToServerSceneHandle[gameObject.scene.handle];
+                    if (!NetworkManager.SceneManager.ClientSceneHandleToServerSceneHandle.ContainsKey(gameObject.scene.handle))
+                    {
+                        // Most likely this issue is due to an integration test
+                        if (NetworkManager.LogLevel <= LogLevel.Developer)
+                        {
+                            NetworkLog.LogWarning($"Failed to find scene handle {gameObject.scene.handle} for {gameObject.name}!");
+                        }
+                        // Just use the existing handle
+                        NetworkSceneHandle = gameObject.scene.handle;
+                    }
+                    else
+                    {
+                        NetworkSceneHandle = NetworkManager.SceneManager.ClientSceneHandleToServerSceneHandle[gameObject.scene.handle];
+                    }
                 }
                 if (DontDestroyWithOwner && !IsOwnershipDistributable)
                 {

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

@@ -1755,16 +1755,24 @@ internal void GetObjectDistribution(ref Dictionary<uint, Dictionary<ulong, List<
                     continue;
                 }
 
-                if (networkObject.IsOwnershipDistributable && !networkObject.IsOwnershipLocked)
+                // We first check for a parent and then if the parent is a NetworkObject
+                if (networkObject.transform.parent != null)
                 {
-                    if (networkObject.transform.parent != null)
+                    // If the parent is a NetworkObject, has the same owner, and this NetworkObject has the distributable =or= transferable permission
+                    // then skip this child (NetworkObjects are always parented directly under other NetworkObjects)
+                    // (later we determine if all children with the same owner will be transferred together as a group)
+                    var parentNetworkObject = networkObject.transform.parent.GetComponent<NetworkObject>();
+                    if (parentNetworkObject != null && parentNetworkObject.OwnerClientId == networkObject.OwnerClientId
+                        && (networkObject.IsOwnershipDistributable || networkObject.IsOwnershipTransferable))
                     {
-                        var parentNetworkObject = networkObject.transform.parent.GetComponent<NetworkObject>();
-                        if (parentNetworkObject != null && parentNetworkObject.OwnerClientId == networkObject.OwnerClientId)
-                        {
-                            continue;
-                        }
+                        continue;
                     }
+                }
+
+                // At this point we only allow things marked with the distributable permission and is not locked to be distributed
+                if (networkObject.IsOwnershipDistributable && !networkObject.IsOwnershipLocked)
+                {
+
                     // We have to check if it is an in-scene placed NetworkObject and if it is get the source prefab asset GlobalObjectIdHash value of the in-scene placed instance
                     // since all in-scene placed instances use unique GlobalObjectIdHash values.
                     var globalOjectIdHash = networkObject.IsSceneObject.HasValue && networkObject.IsSceneObject.Value ? networkObject.InScenePlacedSourceGlobalObjectIdHash : networkObject.GlobalObjectIdHash;
@@ -1879,8 +1887,29 @@ internal void DistributeNetworkObjects(ulong clientId)
                     {
                         if ((i % offsetCount) == 0)
                         {
+                            var children = ownerList.Value[i].GetComponentsInChildren<NetworkObject>();
+                            // Since the ownerList.Value[i] has to be distributable, then transfer all child NetworkObjects
+                            // with the same owner clientId and are marked as distributable also to the same client to keep
+                            // the owned distributable parent with the owned distributable children
+                            foreach (var child in children)
+                            {
+                                // Ignore the parent and any child that does not have the same owner or that is already owned by the currently targeted client
+                                if (child == ownerList.Value[i] || child.OwnerClientId != ownerList.Value[i].OwnerClientId || child.OwnerClientId == clientId)
+                                {
+                                    continue;
+                                }
+                                if ((!child.IsOwnershipDistributable || !child.IsOwnershipTransferable) && NetworkManager.LogLevel == LogLevel.Developer)
+                                {
+                                    NetworkLog.LogWarning($"Sibling {child.name} of root parent {ownerList.Value[i].name} is neither transferrable or distributable! Object distribution skipped and could lead to a potentially un-owned or owner-mismatched {nameof(NetworkObject)}!");
+                                    continue;
+                                }
+                                // Transfer ownership of all distributable =or= transferrable children with the same owner to the same client to preserve the sibling ownership tree.
+                                ChangeOwnership(child, clientId, true);
+                                // Note: We don't increment the distributed count for these children as they are skipped when getting the object distribution
+                            }
+                            // Finally, transfer ownership of the root parent
                             ChangeOwnership(ownerList.Value[i], clientId, true);
-                            //if (EnableDistributeLogging)
+                            if (EnableDistributeLogging)
                             {
                                 Debug.Log($"[Client-{ownerList.Key}][NetworkObjectId-{ownerList.Value[i].NetworkObjectId} Distributed to Client-{clientId}");
                             }