Test fixes

noellie-velez · noellie-velez · commit ae5c41a0a6a8 · 2026-01-19T20:09:27.000+01:00
diff --git a/com.unity.netcode.gameobjects/Runtime/Core/NetworkObject.cs b/com.unity.netcode.gameobjects/Runtime/Core/NetworkObject.cs
@@ -403,21 +403,21 @@ public void DeferDespawn(int tickOffset, bool destroy = true)
             {
                 if (NetworkManager.LogLevel == LogLevel.Error)
                 {
-                    NetworkLog.LogErrorServer($"[Attempted deferred despawn while un-spawned]");
+                    NetworkLog.LogErrorServer("[Attempted deferred despawn while un-spawned]");
                 }
 
                 return;
             }
 
             if (!NetworkManagerOwner.DistributedAuthorityMode)
             {
-                NetworkLog.LogError($"This method is only available in distributed authority mode.");
+                NetworkLog.LogErrorServer("This method is only available in distributed authority mode.");
                 return;
             }
 
             if (!HasAuthority)
             {
-                NetworkLog.LogError($"Only the authority can invoke {nameof(DeferDespawn)} and local Client-{NetworkManagerOwner.LocalClientId} is not the authority of {name}!");
+                NetworkLog.LogErrorServer($"Only the authority can invoke {nameof(DeferDespawn)} and local Client-{NetworkManagerOwner.LocalClientId} is not the authority of {name}!");
                 return;
             }
 
@@ -1139,15 +1139,8 @@ public bool HasOwnershipStatus(OwnershipStatus status)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private bool InternalHasAuthority()
         {
-            if (!IsSpawned)
-            {
-                if (NetworkManager.LogLevel == LogLevel.Error)
-                {
-                    NetworkLog.LogErrorServer("[Attempted authority check while un-spawned]");
-                }
-                return false;
-            }
-            return NetworkManagerOwner.DistributedAuthorityMode ? OwnerClientId == NetworkManagerOwner.LocalClientId : NetworkManagerOwner.IsServer;
+            var networkManager = NetworkManager;
+            return networkManager.DistributedAuthorityMode ? OwnerClientId == networkManager.LocalClientId : networkManager.IsServer;
         }
 
         /// <summary>
@@ -1536,7 +1529,6 @@ public static void NetworkShow(List<NetworkObject> networkObjects, ulong clientI
 
                 if (!networkObject.IsSpawned)
                 {
-                    // CHECK replace this by  NetworkLog.LogWarning($"Trying to show object but is not spawned!"); continue; (change all in another PR)
                     throw new SpawnStateException("Object is not spawned");
                 }
 
@@ -1726,7 +1718,6 @@ public static void NetworkHide(List<NetworkObject> networkObjects, ulong clientI
                     }
                 }
 
-                // CHECK, should I address this comment and replace all exceptions with log warnings/errors? (yes, in another PR, same as the comment below)
                 // CLIENT SPAWNING TODO: Log error and continue as opposed to throwing an exception
                 if (!networkObject.IsSpawned)
                 {
@@ -1761,9 +1752,7 @@ private void OnDestroy()
 
             // 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 (IsSpawned && !isAuthorityDestroy && networkManager.IsListening &&
+            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.
@@ -1791,11 +1780,6 @@ private void OnDestroy()
                         }
                         return;
                     }
-                    else
-                    {
-                        // If the destroy was authority scene event triggered, then mark this destroy as authority triggered.
-                        isAuthorityDestroy = true;
-                    }
                 }
                 // Otherwise, clients can despawn NetworkObjects while shutting down and should not generate any messages when this happens
             }
@@ -2343,7 +2327,8 @@ internal bool InternalTrySetParent(NetworkObject parent, bool worldPositionStays
 
         private void OnTransformParentChanged()
         {
-            if (!AutoObjectParentSync)
+            var networkManager = NetworkManager;
+            if (!AutoObjectParentSync || networkManager.ShutdownInProgress)
             {
                 return;
             }
@@ -2353,16 +2338,11 @@ private void OnTransformParentChanged()
                 return;
             }
 
-            var networkManager = NetworkManager;
-            if (!IsSpawned || !networkManager.IsListening)
+            if (networkManager == null || !networkManager.IsListening)
             {
-                if (networkManager.ShutdownInProgress)
-                {
-                    return;
-                }
                 // DANGO-TODO: Review as to whether we want to provide a better way to handle changing parenting of objects when the
                 // object is not spawned. Really, we shouldn't care about these types of changes.
-                if (NetworkManager.DistributedAuthorityMode && m_CachedParent != null && transform.parent == null)
+                if (networkManager.DistributedAuthorityMode && m_CachedParent != null && transform.parent == null)
                 {
                     m_CachedParent = null;
                     return;
@@ -2371,29 +2351,6 @@ private void OnTransformParentChanged()
                 Debug.LogException(new NotListeningException($"{nameof(networkManager)} is not listening, start a server or host before reparenting"));
                 return;
             }
-            var isAuthority = false;
-            // With distributed authority, we need to track "valid authoritative" parenting changes.
-            // So, either the authority or AuthorityAppliedParenting is considered a "valid parenting change".
-            isAuthority = HasAuthority || AuthorityAppliedParenting || (AllowOwnerToParent && IsOwner);
-            var distributedAuthority = NetworkManagerOwner.DistributedAuthorityMode;
-
-            // If we do not have authority
-            if (!isAuthority)
-            {
-                // If the cached parent has not already been set, and we are in distributed authority mode, then log an exception and exit early as a non-authority instance
-                // is trying to set the parent.
-                if (distributedAuthority)
-                {
-                    transform.parent = m_CachedParent;
-                    NetworkLog.LogError($"[Not Owner] Only the owner-authority of child {gameObject.name}'s {nameof(NetworkObject)} component can reparent it!");
-                }
-                else
-                {
-                    transform.parent = m_CachedParent;
-                    Debug.LogException(new NotServerException($"Only the server can reparent {nameof(NetworkObject)}s"));
-                }
-                return;
-            }
 
             if (!IsSpawned)
             {
@@ -2412,11 +2369,32 @@ private void OnTransformParentChanged()
                 }
                 return;
             }
+
+            // With distributed authority, we need to track "valid authoritative" parenting changes.
+            // So, either the authority or AuthorityAppliedParenting is considered a "valid parenting change".
+            // If we do not have authority and we are spawned
+            if (!(HasAuthority || AuthorityAppliedParenting || (AllowOwnerToParent && IsOwner)))
+            {
+                transform.parent = m_CachedParent;
+                if (networkManager.LogLevel >= LogLevel.Normal)
+                {
+                    if (networkManager.DistributedAuthorityMode)
+                    {
+                        NetworkLog.LogError($"[Not Owner] Only the owner-authority of child {gameObject.name}'s {nameof(NetworkObject)} component can reparent it!");
+                    }
+                    else
+                    {
+                        Debug.LogException(new NotServerException($"Only the server can reparent {nameof(NetworkObject)}s"));
+                    }
+                }
+                return;
+            }
+
             var removeParent = false;
             var parentTransform = transform.parent;
             if (parentTransform != null)
             {
-                if (!parentTransform.TryGetComponent(out NetworkObject parentObject))
+                if (!transform.parent.TryGetComponent(out NetworkObject parentObject))
                 {
                     transform.parent = m_CachedParent;
                     AuthorityAppliedParenting = false;
@@ -2465,28 +2443,28 @@ private void OnTransformParentChanged()
             }
 
             // If we're not the server, we should tell the server about this parent change
-            if (!NetworkManagerOwner.IsServer)
+            if (!networkManager.IsServer)
             {
                 // Don't send a message in DA mode if we're the only observers of this object (we're the only authority).
-                if (distributedAuthority && Observers.Count <= 1)
+                if (networkManager.DistributedAuthorityMode && Observers.Count <= 1)
                 {
                     return;
                 }
 
-                NetworkManagerOwner.ConnectionManager.SendMessage(ref message, MessageDeliveryType<ParentSyncMessage>.DefaultDelivery, NetworkManager.ServerClientId);
+                networkManager.ConnectionManager.SendMessage(ref message, MessageDeliveryType<ParentSyncMessage>.DefaultDelivery, NetworkManager.ServerClientId);
                 return;
             }
 
             // Otherwise we are a Server (client-server or DAHost). Send to all observers
-            foreach (var clientId in NetworkManagerOwner.ConnectionManager.ConnectedClientIds)
+            foreach (var clientId in networkManager.ConnectionManager.ConnectedClientIds)
             {
                 if (clientId == NetworkManager.ServerClientId)
                 {
                     continue;
                 }
                 if (Observers.Contains(clientId))
                 {
-                    NetworkManagerOwner.ConnectionManager.SendMessage(ref message, MessageDeliveryType<ParentSyncMessage>.DefaultDelivery, clientId);
+                    networkManager.ConnectionManager.SendMessage(ref message, MessageDeliveryType<ParentSyncMessage>.DefaultDelivery, clientId);
                 }
             }
         }
@@ -2702,15 +2680,6 @@ internal void InternalInSceneNetworkObjectsSpawned()
 
         internal void InvokeBehaviourNetworkDespawn()
         {
-            if (!IsSpawned)
-            {
-                if (NetworkManager.LogLevel == LogLevel.Error)
-                {
-                    NetworkLog.LogErrorServer("[Attempted network despawn behavior invoke while un-spawned]");
-                }
-
-                return;
-            }
             // Invoke OnNetworkPreDespawn on all child behaviours
             for (int i = 0; i < ChildNetworkBehaviours.Count; i++)
             {

Original file line number	Diff line number	Diff line change
`@@ -403,21 +403,21 @@ public void DeferDespawn(int tickOffset, bool destroy = true)`
`403`	`403`	`{`
`404`	`404`	`if (NetworkManager.LogLevel == LogLevel.Error)`
`405`	`405`	`{`
`406`		`- NetworkLog.LogErrorServer($"[Attempted deferred despawn while un-spawned]");`
	`406`	`+ NetworkLog.LogErrorServer("[Attempted deferred despawn while un-spawned]");`
`407`	`407`	`}`
`408`	`408`
`409`	`409`	`return;`
`410`	`410`	`}`
`411`	`411`
`412`	`412`	`if (!NetworkManagerOwner.DistributedAuthorityMode)`
`413`	`413`	`{`
`414`		`- NetworkLog.LogError($"This method is only available in distributed authority mode.");`
	`414`	`+ NetworkLog.LogErrorServer("This method is only available in distributed authority mode.");`
`415`	`415`	`return;`
`416`	`416`	`}`
`417`	`417`
`418`	`418`	`if (!HasAuthority)`
`419`	`419`	`{`
`420`		`- NetworkLog.LogError($"Only the authority can invoke {nameof(DeferDespawn)} and local Client-{NetworkManagerOwner.LocalClientId} is not the authority of {name}!");`
	`420`	`+ NetworkLog.LogErrorServer($"Only the authority can invoke {nameof(DeferDespawn)} and local Client-{NetworkManagerOwner.LocalClientId} is not the authority of {name}!");`
`421`	`421`	`return;`
`422`	`422`	`}`
`423`	`423`
`@@ -1139,15 +1139,8 @@ public bool HasOwnershipStatus(OwnershipStatus status)`
`1139`	`1139`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
`1140`	`1140`	`private bool InternalHasAuthority()`
`1141`	`1141`	`{`
`1142`		`- if (!IsSpawned)`
`1143`		`- {`
`1144`		`- if (NetworkManager.LogLevel == LogLevel.Error)`
`1145`		`- {`
`1146`		`- NetworkLog.LogErrorServer("[Attempted authority check while un-spawned]");`
`1147`		`- }`
`1148`		`- return false;`
`1149`		`- }`
`1150`		`- return NetworkManagerOwner.DistributedAuthorityMode ? OwnerClientId == NetworkManagerOwner.LocalClientId : NetworkManagerOwner.IsServer;`
	`1142`	`+ var networkManager = NetworkManager;`
	`1143`	`+ return networkManager.DistributedAuthorityMode ? OwnerClientId == networkManager.LocalClientId : networkManager.IsServer;`
`1151`	`1144`	`}`
`1152`	`1145`
`1153`	`1146`	`/// <summary>`
`@@ -1536,7 +1529,6 @@ public static void NetworkShow(List<NetworkObject> networkObjects, ulong clientI`
`1536`	`1529`
`1537`	`1530`	`if (!networkObject.IsSpawned)`
`1538`	`1531`	`{`
`1539`		`- // CHECK replace this by NetworkLog.LogWarning($"Trying to show object but is not spawned!"); continue; (change all in another PR)`
`1540`	`1532`	`throw new SpawnStateException("Object is not spawned");`
`1541`	`1533`	`}`
`1542`	`1534`
`@@ -1726,7 +1718,6 @@ public static void NetworkHide(List<NetworkObject> networkObjects, ulong clientI`
`1726`	`1718`	`}`
`1727`	`1719`	`}`
`1728`	`1720`
`1729`		`- // CHECK, should I address this comment and replace all exceptions with log warnings/errors? (yes, in another PR, same as the comment below)`
`1730`	`1721`	`// CLIENT SPAWNING TODO: Log error and continue as opposed to throwing an exception`
`1731`	`1722`	`if (!networkObject.IsSpawned)`
`1732`	`1723`	`{`
`@@ -1761,9 +1752,7 @@ private void OnDestroy()`
`1761`	`1752`
`1762`	`1753`	`// An authorized destroy is when done by the authority instance or done due to a scene event and the NetworkObject`
`1763`	`1754`	`// was marked as destroy pending scene event (which means the destroy with scene property was set).`
`1764`		`- var isAuthorityDestroy = HasAuthority \|\| networkManager.DAHost \|\| DestroyPendingSceneEvent;`
`1765`		`-`
`1766`		`- if (IsSpawned && !isAuthorityDestroy && networkManager.IsListening &&`
	`1755`	`+ if (IsSpawned && !(HasAuthority \|\| networkManager.DAHost \|\| DestroyPendingSceneEvent) && networkManager.IsListening &&`
`1767`	`1756`	`(IsSceneObject == null \|\| IsSceneObject.Value != true))`
`1768`	`1757`	`{`
`1769`	`1758`	`// If we destroyed a GameObject with a NetworkObject component on the non-authority side, handle cleaning up the SceneMigrationSynchronization.`
`@@ -1791,11 +1780,6 @@ private void OnDestroy()`
`1791`	`1780`	`}`
`1792`	`1781`	`return;`
`1793`	`1782`	`}`
`1794`		`- else`
`1795`		`- {`
`1796`		`- // If the destroy was authority scene event triggered, then mark this destroy as authority triggered.`
`1797`		`- isAuthorityDestroy = true;`
`1798`		`- }`
`1799`	`1783`	`}`
`1800`	`1784`	`// Otherwise, clients can despawn NetworkObjects while shutting down and should not generate any messages when this happens`
`1801`	`1785`	`}`
`@@ -2343,7 +2327,8 @@ internal bool InternalTrySetParent(NetworkObject parent, bool worldPositionStays`
`2343`	`2327`
`2344`	`2328`	`private void OnTransformParentChanged()`
`2345`	`2329`	`{`
`2346`		`- if (!AutoObjectParentSync)`
	`2330`	`+ var networkManager = NetworkManager;`
	`2331`	`+ if (!AutoObjectParentSync \|\| networkManager.ShutdownInProgress)`
`2347`	`2332`	`{`
`2348`	`2333`	`return;`
`2349`	`2334`	`}`
`@@ -2353,16 +2338,11 @@ private void OnTransformParentChanged()`
`2353`	`2338`	`return;`
`2354`	`2339`	`}`
`2355`	`2340`
`2356`		`- var networkManager = NetworkManager;`
`2357`		`- if (!IsSpawned \|\| !networkManager.IsListening)`
	`2341`	`+ if (networkManager == null \|\| !networkManager.IsListening)`
`2358`	`2342`	`{`
`2359`		`- if (networkManager.ShutdownInProgress)`
`2360`		`- {`
`2361`		`- return;`
`2362`		`- }`
`2363`	`2343`	`// DANGO-TODO: Review as to whether we want to provide a better way to handle changing parenting of objects when the`
`2364`	`2344`	`// object is not spawned. Really, we shouldn't care about these types of changes.`
`2365`		`- if (NetworkManager.DistributedAuthorityMode && m_CachedParent != null && transform.parent == null)`
	`2345`	`+ if (networkManager.DistributedAuthorityMode && m_CachedParent != null && transform.parent == null)`
`2366`	`2346`	`{`
`2367`	`2347`	`m_CachedParent = null;`
`2368`	`2348`	`return;`
`@@ -2371,29 +2351,6 @@ private void OnTransformParentChanged()`
`2371`	`2351`	`Debug.LogException(new NotListeningException($"{nameof(networkManager)} is not listening, start a server or host before reparenting"));`
`2372`	`2352`	`return;`
`2373`	`2353`	`}`
`2374`		`- var isAuthority = false;`
`2375`		`- // With distributed authority, we need to track "valid authoritative" parenting changes.`
`2376`		`- // So, either the authority or AuthorityAppliedParenting is considered a "valid parenting change".`
`2377`		`- isAuthority = HasAuthority \|\| AuthorityAppliedParenting \|\| (AllowOwnerToParent && IsOwner);`
`2378`		`- var distributedAuthority = NetworkManagerOwner.DistributedAuthorityMode;`
`2379`		`-`
`2380`		`- // If we do not have authority`
`2381`		`- if (!isAuthority)`
`2382`		`- {`
`2383`		`- // If the cached parent has not already been set, and we are in distributed authority mode, then log an exception and exit early as a non-authority instance`
`2384`		`- // is trying to set the parent.`
`2385`		`- if (distributedAuthority)`
`2386`		`- {`
`2387`		`- transform.parent = m_CachedParent;`
`2388`		`- NetworkLog.LogError($"[Not Owner] Only the owner-authority of child {gameObject.name}'s {nameof(NetworkObject)} component can reparent it!");`
`2389`		`- }`
`2390`		`- else`
`2391`		`- {`
`2392`		`- transform.parent = m_CachedParent;`
`2393`		`- Debug.LogException(new NotServerException($"Only the server can reparent {nameof(NetworkObject)}s"));`
`2394`		`- }`
`2395`		`- return;`
`2396`		`- }`
`2397`	`2354`
`2398`	`2355`	`if (!IsSpawned)`
`2399`	`2356`	`{`
`@@ -2412,11 +2369,32 @@ private void OnTransformParentChanged()`
`2412`	`2369`	`}`
`2413`	`2370`	`return;`
`2414`	`2371`	`}`
	`2372`	`+`
	`2373`	`+ // With distributed authority, we need to track "valid authoritative" parenting changes.`
	`2374`	`+ // So, either the authority or AuthorityAppliedParenting is considered a "valid parenting change".`
	`2375`	`+ // If we do not have authority and we are spawned`
	`2376`	`+ if (!(HasAuthority \|\| AuthorityAppliedParenting \|\| (AllowOwnerToParent && IsOwner)))`
	`2377`	`+ {`
	`2378`	`+ transform.parent = m_CachedParent;`
	`2379`	`+ if (networkManager.LogLevel >= LogLevel.Normal)`
	`2380`	`+ {`
	`2381`	`+ if (networkManager.DistributedAuthorityMode)`
	`2382`	`+ {`
	`2383`	`+ NetworkLog.LogError($"[Not Owner] Only the owner-authority of child {gameObject.name}'s {nameof(NetworkObject)} component can reparent it!");`
	`2384`	`+ }`
	`2385`	`+ else`
	`2386`	`+ {`
	`2387`	`+ Debug.LogException(new NotServerException($"Only the server can reparent {nameof(NetworkObject)}s"));`
	`2388`	`+ }`
	`2389`	`+ }`
	`2390`	`+ return;`
	`2391`	`+ }`
	`2392`	`+`
`2415`	`2393`	`var removeParent = false;`
`2416`	`2394`	`var parentTransform = transform.parent;`
`2417`	`2395`	`if (parentTransform != null)`
`2418`	`2396`	`{`
`2419`		`- if (!parentTransform.TryGetComponent(out NetworkObject parentObject))`
	`2397`	`+ if (!transform.parent.TryGetComponent(out NetworkObject parentObject))`
`2420`	`2398`	`{`
`2421`	`2399`	`transform.parent = m_CachedParent;`
`2422`	`2400`	`AuthorityAppliedParenting = false;`
`@@ -2465,28 +2443,28 @@ private void OnTransformParentChanged()`
`2465`	`2443`	`}`
`2466`	`2444`
`2467`	`2445`	`// If we're not the server, we should tell the server about this parent change`
`2468`		`- if (!NetworkManagerOwner.IsServer)`
	`2446`	`+ if (!networkManager.IsServer)`
`2469`	`2447`	`{`
`2470`	`2448`	`// Don't send a message in DA mode if we're the only observers of this object (we're the only authority).`
`2471`		`- if (distributedAuthority && Observers.Count <= 1)`
	`2449`	`+ if (networkManager.DistributedAuthorityMode && Observers.Count <= 1)`
`2472`	`2450`	`{`
`2473`	`2451`	`return;`
`2474`	`2452`	`}`
`2475`	`2453`
`2476`		`- NetworkManagerOwner.ConnectionManager.SendMessage(ref message, MessageDeliveryType<ParentSyncMessage>.DefaultDelivery, NetworkManager.ServerClientId);`
	`2454`	`+ networkManager.ConnectionManager.SendMessage(ref message, MessageDeliveryType<ParentSyncMessage>.DefaultDelivery, NetworkManager.ServerClientId);`
`2477`	`2455`	`return;`
`2478`	`2456`	`}`
`2479`	`2457`
`2480`	`2458`	`// Otherwise we are a Server (client-server or DAHost). Send to all observers`
`2481`		`- foreach (var clientId in NetworkManagerOwner.ConnectionManager.ConnectedClientIds)`
	`2459`	`+ foreach (var clientId in networkManager.ConnectionManager.ConnectedClientIds)`
`2482`	`2460`	`{`
`2483`	`2461`	`if (clientId == NetworkManager.ServerClientId)`
`2484`	`2462`	`{`
`2485`	`2463`	`continue;`
`2486`	`2464`	`}`
`2487`	`2465`	`if (Observers.Contains(clientId))`
`2488`	`2466`	`{`
`2489`		`- NetworkManagerOwner.ConnectionManager.SendMessage(ref message, MessageDeliveryType<ParentSyncMessage>.DefaultDelivery, clientId);`
	`2467`	`+ networkManager.ConnectionManager.SendMessage(ref message, MessageDeliveryType<ParentSyncMessage>.DefaultDelivery, clientId);`
`2490`	`2468`	`}`
`2491`	`2469`	`}`
`2492`	`2470`	`}`
`@@ -2702,15 +2680,6 @@ internal void InternalInSceneNetworkObjectsSpawned()`
`2702`	`2680`
`2703`	`2681`	`internal void InvokeBehaviourNetworkDespawn()`
`2704`	`2682`	`{`
`2705`		`- if (!IsSpawned)`
`2706`		`- {`
`2707`		`- if (NetworkManager.LogLevel == LogLevel.Error)`
`2708`		`- {`
`2709`		`- NetworkLog.LogErrorServer("[Attempted network despawn behavior invoke while un-spawned]");`
`2710`		`- }`
`2711`		`-`
`2712`		`- return;`
`2713`		`- }`
`2714`	`2683`	`// Invoke OnNetworkPreDespawn on all child behaviours`
`2715`	`2684`	`for (int i = 0; i < ChildNetworkBehaviours.Count; i++)`
`2716`	`2685`	`{`