Merge branch 'chore/simplify-accessors-network-object' of https://github.com/Unity-Technologies/com.unity.netcode.gameobjects into chore/simplify-accessors-network-object

Author: noellie-velez

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

@@ -1750,43 +1750,37 @@ private void OnDestroy()
                 return;
             }
 
-            // An authorized destroy is when done by the authority instance or done due to a scene event and the NetworkObject
-            // was marked as destroy pending scene event (which means the destroy with scene property was set).
-            if (IsSpawned && !(HasAuthority || networkManager.DAHost || DestroyPendingSceneEvent) && networkManager.IsListening &&
-                (IsSceneObject == null || IsSceneObject.Value != true))
-            {
-                // If we destroyed a GameObject with a NetworkObject component on the non-authority side, handle cleaning up the SceneMigrationSynchronization.
-                networkManager.SpawnManager?.RemoveNetworkObjectFromSceneChangedUpdates(this);
-
-                // Clients should not despawn NetworkObjects while connected to a session, but we don't want to destroy the current call stack
-                // if this happens. Instead, we should just generate a network log error and exit early (as long as we are not shutting down).
-                if (!networkManager.ShutdownInProgress)
-                {
-                    // Since we still have a session connection, log locally and on the server to inform user of this issue.
-                    // If the NetworkObject's GameObject is not valid or the scene is no longer valid or loaded, then this was due to the
-                    // unloading of a scene which is done by the authority...
-                    if (gameObject != null && gameObject.scene.IsValid() && gameObject.scene.isLoaded)
+            // Always attempt to remove from scene changed updates
+            networkManager.SpawnManager?.RemoveNetworkObjectFromSceneChangedUpdates(this);
+
+            if (IsSpawned && !networkManager.ShutdownInProgress)
+            {
+                // An authorized destroy is when done by the authority instance or done due to a scene event and the NetworkObject
+                // was marked as destroy pending scene event (which means the destroy with scene property was set).
+                var isAuthorityDestroy = HasAuthority || NetworkManager.DAHost || DestroyPendingSceneEvent;
+
+                // If the NetworkObject's GameObject is still valid and the scene is still valid and loaded, then we are still valid
+                var isStillValid = gameObject != null && gameObject.scene.IsValid() && gameObject.scene.isLoaded;
+
+                // If we're not the authority and everything is valid and dynamically spawned, then the destroy is not valid.
+                if (!isAuthorityDestroy && IsSceneObject == false && isStillValid)
+                {
+                    if (networkManager.LogLevel <= LogLevel.Error)
                     {
-                        if (networkManager.LogLevel <= LogLevel.Error)
+                        if (networkManager.DistributedAuthorityMode)
                         {
-                            if (networkManager.DistributedAuthorityMode)
-                            {
-                                NetworkLog.LogError($"[Invalid Destroy][{gameObject.name}][NetworkObjectId:{NetworkObjectId}] Destroy a spawned {nameof(NetworkObject)} on a non-owner client is not valid during a distributed authority session. Call {nameof(Destroy)} or {nameof(Despawn)} on the client-owner instead.");
-                            }
-                            else
-                            {
-                                NetworkLog.LogErrorServer($"[Invalid Destroy][{gameObject.name}][NetworkObjectId:{NetworkObjectId}] Destroy a spawned {nameof(NetworkObject)} on a non-host client is not valid. Call {nameof(Destroy)} or {nameof(Despawn)} on the server/host instead.");
-                            }
+                            NetworkLog.LogError($"[Invalid Destroy][{gameObject.name}][NetworkObjectId:{NetworkObjectId}] Destroy a spawned {nameof(NetworkObject)} on a non-owner client is not valid during a distributed authority session. Call {nameof(Destroy)} or {nameof(Despawn)} on the client-owner instead.");
+                        }
+                        else
+                        {
+                            NetworkLog.LogErrorServer($"[Invalid Destroy][{gameObject.name}][NetworkObjectId:{NetworkObjectId}] Destroy a spawned {nameof(NetworkObject)} on a non-host client is not valid. Call {nameof(Destroy)} or {nameof(Despawn)} on the server/host instead.");
                         }
-                        return;
                     }
+
+                    return;
                 }
-                // Otherwise, clients can despawn NetworkObjects while shutting down and should not generate any messages when this happens
             }
 
-            // Always attempt to remove from scene changed updates
-            networkManager.SpawnManager?.RemoveNetworkObjectFromSceneChangedUpdates(this);
-
             if (networkManager.SpawnManager != null && networkManager.SpawnManager.SpawnedObjects.TryGetValue(NetworkObjectId, out var networkObject))
             {
                 if (this == networkObject)

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

@@ -1160,7 +1160,7 @@ internal void SpawnNetworkObjectLocallyCommon(NetworkObject networkObject, ulong
             // If this the player and the client is the owner, then lock ownership by default
             if (NetworkManager.DistributedAuthorityMode && NetworkManager.LocalClientId == ownerClientId && playerObject)
             {
-                networkObject.SetOwnershipLock();
+                networkObject.AddOwnershipExtended(NetworkObject.OwnershipStatusExtended.Locked);
             }
 
             networkObject.IsSpawned = true;
@@ -1400,46 +1400,53 @@ internal void DespawnAndDestroyNetworkObjects()
             var networkObjects = UnityEngine.Object.FindObjectsOfType<NetworkObject>();
 #endif
 
-            for (int i = 0; i < networkObjects.Length; i++)
+            foreach (var networkObject in networkObjects)
             {
-                if (networkObjects[i].NetworkManager == NetworkManager)
+                // We are not the authority of this NetworkObject
+                // Mostly used for integration testing
+                if (networkObject.NetworkManager != NetworkManager)
                 {
-                    if (NetworkManager.PrefabHandler.ContainsHandler(networkObjects[i]))
-                    {
-                        OnDespawnObject(networkObjects[i], false);
-                        // Leave destruction up to the handler
-                        NetworkManager.PrefabHandler.HandleNetworkPrefabDestroy(networkObjects[i]);
-                    }
-                    else
-                    {
-                        // If it is an in-scene placed NetworkObject then just despawn and let it be destroyed when the scene
-                        // is unloaded. Otherwise, despawn and destroy it.
-                        var shouldDestroy = !(networkObjects[i].IsSceneObject == null || (networkObjects[i].IsSceneObject != null && networkObjects[i].IsSceneObject.Value));
+                    continue;
+                }
+
+                // The NetworkManagerOwner field must be set before calling OnDespawnObject
+                networkObject.NetworkManagerOwner = NetworkManager;
+
+                if (NetworkManager.PrefabHandler.ContainsHandler(networkObject))
+                {
+                    OnDespawnObject(networkObject, false);
+                    // Leave destruction up to the handler
+                    NetworkManager.PrefabHandler.HandleNetworkPrefabDestroy(networkObject);
+                }
+                else
+                {
+                    // If it is an in-scene placed NetworkObject then just despawn and let it be destroyed when the scene
+                    // is unloaded. Otherwise, despawn and destroy it.
+                    var shouldDestroy = !(networkObject.IsSceneObject == null || (networkObject.IsSceneObject != null && networkObject.IsSceneObject.Value));
 
-                        // If we are going to destroy this NetworkObject, check for any in-scene placed children that need to be removed
-                        if (shouldDestroy)
+                    // If we are going to destroy this NetworkObject, check for any in-scene placed children that need to be removed
+                    if (shouldDestroy)
+                    {
+                        // Check to see if there are any in-scene placed children that are marked to be destroyed with the scene
+                        var childrenObjects = networkObject.GetComponentsInChildren<NetworkObject>();
+                        foreach (var childObject in childrenObjects)
                         {
-                            // Check to see if there are any in-scene placed children that are marked to be destroyed with the scene
-                            var childrenObjects = networkObjects[i].GetComponentsInChildren<NetworkObject>();
-                            foreach (var childObject in childrenObjects)
+                            if (childObject == networkObject)
                             {
-                                if (childObject == networkObjects[i])
-                                {
-                                    continue;
-                                }
+                                continue;
+                            }
 
-                                // If the child is an in-scene placed NetworkObject then remove the child from the parent (which was dynamically spawned)
-                                // and set its parent to root
-                                if (childObject.IsSceneObject != null && childObject.IsSceneObject.Value)
-                                {
-                                    childObject.TryRemoveParent(childObject.WorldPositionStays());
-                                }
+                            // If the child is an in-scene placed NetworkObject then remove the child from the parent (which was dynamically spawned)
+                            // and set its parent to root
+                            if (childObject.IsSceneObject != null && childObject.IsSceneObject.Value)
+                            {
+                                childObject.TryRemoveParent(childObject.WorldPositionStays());
                             }
                         }
-
-                        //Despawn and potentially destroy.
-                        OnDespawnObject(networkObjects[i], shouldDestroy);
                     }
+
+                    //Despawn and potentially destroy.
+                    OnDespawnObject(networkObject, shouldDestroy);
                 }
             }
         }