Check cached usage and cleanup

noellie-velez · noellie-velez · commit 02d061d6487d · 2026-01-09T19:42:44.000+01:00
diff --git a/com.unity.netcode.gameobjects/Runtime/Core/NetworkObject.cs b/com.unity.netcode.gameobjects/Runtime/Core/NetworkObject.cs
@@ -340,17 +340,18 @@ private void CheckForInScenePlaced()
 
         internal bool HasParentNetworkObject(Transform transform)
         {
-            if (m_CachedParent != null)
+            var parent = transform.parent;
+            if (parent != null)
             {
-                var networkObject = m_CachedParent.GetComponent<NetworkObject>();
+                var networkObject = parent.GetComponent<NetworkObject>();
                 if (networkObject != null && networkObject != this)
                 {
                     return true;
                 }
 
                 if (m_CachedParent.parent != null)
                 {
-                    return HasParentNetworkObject(m_CachedParent);
+                    return HasParentNetworkObject(parent);
                 }
             }
             return false;
@@ -400,7 +401,7 @@ public void DeferDespawn(int tickOffset, bool destroy = true)
         {
             if (!IsSpawned)
             {
-                NetworkLog.LogError($"Cannot defer despawning {name} because it is not spawned!");
+                NetworkLog.LogError($"Cannot defer despawn because [{name}] is not spawned!");
                 return;
             }
 
@@ -770,7 +771,7 @@ public OwnershipRequestStatus RequestOwnership()
             {
                 if (NetworkManagerOwner.LogLevel <= LogLevel.Normal)
                 {
-                    NetworkLog.LogWarning($"Trying to perform an ownership request but {name} is not spawned!");
+                    NetworkLog.LogWarning($"Trying to perform an ownership request but [{name}] is not spawned!");
                 }
 
                 return OwnershipRequestStatus.Invalid;
@@ -1137,6 +1138,10 @@ private bool InternalHasAuthority()
         {
             if (!IsSpawned)
             {
+                if (NetworkManagerOwner.LogLevel <= LogLevel.Normal)
+                {
+                    NetworkLog.LogWarning($"Trying to check authority but {name} is not spawned yet!");
+                }
                 return false;
             }
             return NetworkManagerOwner.DistributedAuthorityMode ? OwnerClientId == NetworkManagerOwner.LocalClientId : NetworkManagerOwner.IsServer;
@@ -1200,7 +1205,7 @@ private bool InternalHasAuthority()
         /// <summary>
         /// Gets whether or not the object is owned by anyone
         /// </summary>
-        public bool IsOwnedByServer => IsSpawned && OwnerClientId == NetworkManager.ServerClientId;
+        public bool IsOwnedByServer => OwnerClientId == NetworkManager.ServerClientId;
 
         /// <summary>
         /// Gets if the object has yet been spawned across the network
@@ -1543,9 +1548,9 @@ public static void NetworkShow(List<NetworkObject> networkObjects, ulong clientI
 
                 // Distributed authority mode adjustments to log a network error and continue when trying to show a NetworkObject
                 // that the local instance does not own
-                if (!networkObjects[i].HasAuthority)
+                if (!networkObject.HasAuthority)
                 {
-                    if (networkObjects[i].NetworkManagerOwner.DistributedAuthorityMode)
+                    if (networkManager.DistributedAuthorityMode)
                     {
                         // It will log locally and to the "master-host".
                         NetworkLog.LogErrorServer("Only the owner-authority can change visibility when distributed authority mode is enabled!");
@@ -1558,14 +1563,14 @@ public static void NetworkShow(List<NetworkObject> networkObjects, ulong clientI
                 }
 
 
-                if (networkObjects[i].Observers.Contains(clientId))
+                if (networkObject.Observers.Contains(clientId))
                 {
-                    throw new VisibilityChangeException($"{nameof(NetworkObject)} with NetworkId: {networkObjects[i].NetworkObjectId} is already visible");
+                    throw new VisibilityChangeException($"{nameof(NetworkObject)} with NetworkId: {networkObject.NetworkObjectId} is already visible");
                 }
 
-                if (networkObjects[i].NetworkManagerOwner != networkManager)
+                if (networkObject.NetworkManagerOwner != networkManager)
                 {
-                    throw new ArgumentNullException("All " + nameof(NetworkObject) + "s must belong to the same " + nameof(NetworkManagerOwner));
+                    throw new ArgumentNullException("All " + nameof(NetworkObject) + "s must belong to the same " + nameof(networkManager));
                 }
             }
 
@@ -1703,9 +1708,9 @@ public static void NetworkHide(List<NetworkObject> networkObjects, ulong clientI
 
                 // Distributed authority mode adjustments to log a network error and continue when trying to show a NetworkObject
                 // that the local instance does not own
-                if (!networkObjects[i].HasAuthority)
+                if (!networkObject.HasAuthority)
                 {
-                    if (networkObjects[i].NetworkManagerOwner.DistributedAuthorityMode)
+                    if (networkObject.NetworkManagerOwner.DistributedAuthorityMode)
                     {
                         // It will log locally and to the "master-host".
                         NetworkLog.LogErrorServer($"Only the owner-authority can change hide a {nameof(NetworkObject)} when distributed authority mode is enabled!");
@@ -1718,19 +1723,20 @@ public static void NetworkHide(List<NetworkObject> networkObjects, ulong clientI
                 }
 
                 // CLIENT SPAWNING TODO: Log error and continue as opposed to throwing an exception
-                if (!networkObjects[i].IsSpawned)
+                // CHECK, should I replace this?
+                if (!networkObject.IsSpawned)
                 {
                     throw new SpawnStateException("Object is not spawned");
                 }
 
-                if (!networkObjects[i].Observers.Contains(clientId))
+                if (!networkObject.Observers.Contains(clientId))
                 {
-                    throw new VisibilityChangeException($"{nameof(NetworkObject)} with {nameof(NetworkObjectId)}: {networkObjects[i].NetworkObjectId} is already hidden");
+                    throw new VisibilityChangeException($"{nameof(NetworkObject)} with {nameof(NetworkObjectId)}: {networkObject.NetworkObjectId} is already hidden");
                 }
 
-                if (networkObjects[i].NetworkManagerOwner != networkManager)
+                if (networkObject.NetworkManagerOwner != networkManager)
                 {
-                    throw new ArgumentNullException("All " + nameof(NetworkObject) + "s must belong to the same " + nameof(NetworkManagerOwner));
+                    throw new ArgumentNullException("All " + nameof(NetworkObject) + "s must belong to the same " + nameof(networkManager));
                 }
             }
 
@@ -1742,7 +1748,6 @@ public static void NetworkHide(List<NetworkObject> networkObjects, ulong clientI
 
         private void OnDestroy()
         {
-            // TODO Can we destroy an object before it is spawned?
             var networkManager = NetworkManager;
             // If no NetworkManager is assigned, then just exit early
             if (!networkManager)
@@ -2013,7 +2018,7 @@ public void Despawn(bool destroy = true)
         {
             if (!IsSpawned)
             {
-                NetworkLog.LogErrorServer("Object is not spawned!");
+                NetworkLog.LogErrorServer($"Cannot despawn [{name}] as it is not spawned!");
                 return;
             }
 
@@ -2041,7 +2046,7 @@ public void RemoveOwnership()
         {
             if (!IsSpawned)
             {
-                NetworkLog.LogErrorServer("Trying to remove ownership on an object that is not spawned!");
+                NetworkLog.LogErrorServer($"Trying to remove the ownership of [{name}] but it is not spawned!");
                 return;
             }
             NetworkManagerOwner.SpawnManager.RemoveOwnership(this);
@@ -2055,7 +2060,7 @@ public void ChangeOwnership(ulong newOwnerClientId)
         {
             if (!IsSpawned)
             {
-                NetworkLog.LogWarning("Trying to change ownership on an not spawned object!");
+                NetworkLog.LogWarning($"Trying to change ownership on [{name}] but it is not spawned!");
                 return;
             }
 
@@ -2070,7 +2075,7 @@ internal void InvokeBehaviourOnOwnershipChanged(ulong originalOwnerClientId, ulo
         {
             if (!IsSpawned)
             {
-                NetworkLog.LogWarning("Trying to change ownership on an not spawned object!");
+                NetworkLog.LogWarning($"Trying to change ownership on [{name}] but it is not spawned!");
                 return;
             }
 
@@ -2267,7 +2272,7 @@ public bool TryRemoveParent(bool worldPositionStays = true)
         /// </summary>
         /// <param name="parent">The new parent for this NetworkObject transform will be the child of.</param>
         /// <param name="worldPositionStays">If true, the parent-relative position, scale and rotation are modified such that the object keeps the same world space position, rotation and scale as before.</param>
-        /// <returns>Whether or not re-parenting was successful.</returns>
+        /// <returns>Whether or not reparenting was successful.</returns>
         public bool TrySetParent(NetworkObject parent, bool worldPositionStays = true)
         {
             if (!AutoObjectParentSync || !IsSpawned || !NetworkManagerOwner.IsListening)
@@ -2279,7 +2284,7 @@ public bool TrySetParent(NetworkObject parent, bool worldPositionStays = true)
             // It wouldn't make sense to not allow parenting, but keeping this note here as a reminder.
             var isAuthority = HasAuthority || (AllowOwnerToParent && IsOwner);
 
-            // If we don't have authority, and we are not shutting down, then don't allow any parenting.
+            // If we don't have authority and we are not shutting down, then don't allow any parenting.
             // If we are shutting down and don't have authority then allow it.
             if (!isAuthority && !NetworkManagerOwner.ShutdownInProgress)
             {
@@ -2291,9 +2296,9 @@ public bool TrySetParent(NetworkObject parent, bool worldPositionStays = true)
 
         internal bool InternalTrySetParent(NetworkObject parent, bool worldPositionStays = true)
         {
-            if (parent && (IsSpawned ^ parent.IsSpawned) && !NetworkManagerOwner.ShutdownInProgress)
+            if (parent && (IsSpawned ^ parent.IsSpawned) && !NetworkManager.ShutdownInProgress)
             {
-                if (NetworkManagerOwner.LogLevel <= LogLevel.Developer)
+                if (NetworkManager.LogLevel <= LogLevel.Developer)
                 {
                     var nameOfNotSpawnedObject = IsSpawned ? $" the parent ({parent.name})" : $"the child ({name})";
                     NetworkLog.LogWarning($"Parenting failed because {nameOfNotSpawnedObject} is not spawned!");
@@ -2303,7 +2308,7 @@ internal bool InternalTrySetParent(NetworkObject parent, bool worldPositionStays
 
             m_CachedWorldPositionStays = worldPositionStays;
 
-            if (!parent)
+            if (parent == null)
             {
                 CurrentParent = null;
                 transform.SetParent(null, worldPositionStays);
@@ -2319,7 +2324,6 @@ internal bool InternalTrySetParent(NetworkObject parent, bool worldPositionStays
 
         private void OnTransformParentChanged()
         {
-            // Shouldn't we do our if not spawned check here?
             if (!AutoObjectParentSync)
             {
                 return;
@@ -2345,7 +2349,7 @@ private void OnTransformParentChanged()
                     return;
                 }
                 transform.parent = m_CachedParent;
-                Debug.LogException(new NotListeningException($"{nameof(networkManager)} is not listening, start a server or host before re-parenting"));
+                Debug.LogException(new NotListeningException($"{nameof(networkManager)} is not listening, start a server or host before reparenting"));
                 return;
             }
             var isAuthority = false;
@@ -2362,18 +2366,17 @@ private void OnTransformParentChanged()
                 if (distributedAuthority)
                 {
                     transform.parent = m_CachedParent;
-                    NetworkLog.LogError($"[Not Owner] Only the owner-authority of child {gameObject.name}'s {nameof(NetworkObject)} component can re-parent it!");
+                    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 re-parent {nameof(NetworkObject)}s"));
+                    Debug.LogException(new NotServerException($"Only the server can reparent {nameof(NetworkObject)}s"));
                 }
                 return;
             }
 
 
-            //Shouldn't this be done first? if the object is not, spawned we enter the first if (!IsSpawned || !NetworkManager.IsListening)
             if (!IsSpawned)
             {
                 AuthorityAppliedParenting = false;
@@ -2387,7 +2390,7 @@ private void OnTransformParentChanged()
                 else
                 {
                     transform.parent = m_CachedParent;
-                    Debug.LogException(new SpawnStateException($"{nameof(NetworkObject)} can only be re-parented after being spawned"));
+                    Debug.LogException(new SpawnStateException($"{nameof(NetworkObject)} can only be reparented after being spawned"));
                 }
                 return;
             }
@@ -2406,7 +2409,7 @@ private void OnTransformParentChanged()
                 {
                     transform.parent = m_CachedParent;
                     AuthorityAppliedParenting = false;
-                    Debug.LogException(new SpawnStateException($"{nameof(NetworkObject)} can only be re-parented under another spawned {nameof(NetworkObject)}"));
+                    Debug.LogException(new SpawnStateException($"{nameof(NetworkObject)} can only be reparented under another spawned {nameof(NetworkObject)}"));
                     return;
                 }
 
@@ -2507,7 +2510,7 @@ internal bool ApplyNetworkParenting(bool removeParent = false, bool ignoreNotSpa
                 var parentNetworkObject = transform.parent.GetComponent<NetworkObject>();
 
                 // If parentNetworkObject is null then the parent is a GameObject without a NetworkObject component
-                // attached. Under this case, we preserve the hierarchy, but we don't keep track of the parenting.
+                // attached. Under this case, we preserve the hierarchy but we don't keep track of the parenting.
                 // Note: We only start tracking parenting if the user removes the child from the standard GameObject
                 // parent and then re-parents the child under a GameObject with a NetworkObject component attached.
                 if (parentNetworkObject == null)
@@ -2618,7 +2621,7 @@ internal void InvokeBehaviourNetworkSpawn()
         {
             if (!IsSpawned)
             {
-                Debug.LogError("Not spawned!");
+                NetworkLog.LogWarning($"Trying to invoke network spawn behavior on {name} but is not spawned!");
                 return;
             }
             NetworkManagerOwner.SpawnManager.UpdateOwnershipTable(this, OwnerClientId);
@@ -2688,7 +2691,7 @@ internal void InvokeBehaviourNetworkDespawn()
         {
             if (!IsSpawned)
             {
-                Debug.LogError("Cannot despawn if is not spawned!");
+                NetworkLog.LogWarning($"Trying to invoke network despawn behavior on {name} but is not spawned!");
                 return;
             }
             // Invoke OnNetworkPreDespawn on all child behaviours
@@ -2782,7 +2785,7 @@ internal void SynchronizeOwnerNetworkVariables(ulong originalOwnerId, ulong orig
         {
             if (!IsSpawned)
             {
-                Debug.LogError("Cannot synchronize network variables if not spawned!");
+                NetworkLog.LogWarning($"Trying to synchronize network variables on {name} but is not spawned!");
                 return;
             }
             var currentOwnerId = OwnerClientId;
@@ -3019,7 +3022,6 @@ public struct TransformData : INetworkSerializeByMemcpy
 
             public void Serialize(FastBufferWriter writer)
             {
-                // CHECK should we check if OwnerObject.IsSpawned here?
                 if (OwnerObject.NetworkManager.DistributedAuthorityMode)
                 {
                     HasOwnershipFlags = true;
@@ -3235,7 +3237,6 @@ internal void SynchronizeNetworkBehaviours<T>(ref BufferSerializer<T> serializer
 
         internal SceneObject GetMessageSceneObject(ulong targetClientId = NetworkManager.ServerClientId, bool syncObservers = false)
         {
-            // CHECK can we use NetworkManagerOwner here? if we do, also replace here:CheckForGlobalObjectIdHashOverride
             var obj = new SceneObject
             {
                 HasParent = transform.parent != null,
@@ -3508,9 +3509,8 @@ private void CurrentlyActiveSceneChanged(Scene current, Scene next)
         /// </summary>
         internal void SceneChangedUpdate(Scene scene, bool notify = false)
         {
-            //CHECK
-            // Avoiding edge case scenarios, if no NetworkSceneManager exit early
-            if (NetworkManagerOwner.SceneManager == null || !IsSpawned)
+            // Avoiding edge case scenarios, if not spawned or no NetworkSceneManager exit early
+            if (!IsSpawned || NetworkManagerOwner.SceneManager == null)
             {
                 return;
             }

Original file line number	Diff line number	Diff line change
`@@ -340,17 +340,18 @@ private void CheckForInScenePlaced()`
`340`	`340`
`341`	`341`	`internal bool HasParentNetworkObject(Transform transform)`
`342`	`342`	`{`
`343`		`- if (m_CachedParent != null)`
	`343`	`+ var parent = transform.parent;`
	`344`	`+ if (parent != null)`
`344`	`345`	`{`
`345`		`- var networkObject = m_CachedParent.GetComponent<NetworkObject>();`
	`346`	`+ var networkObject = parent.GetComponent<NetworkObject>();`
`346`	`347`	`if (networkObject != null && networkObject != this)`
`347`	`348`	`{`
`348`	`349`	`return true;`
`349`	`350`	`}`
`350`	`351`
`351`	`352`	`if (m_CachedParent.parent != null)`
`352`	`353`	`{`
`353`		`- return HasParentNetworkObject(m_CachedParent);`
	`354`	`+ return HasParentNetworkObject(parent);`
`354`	`355`	`}`
`355`	`356`	`}`
`356`	`357`	`return false;`
`@@ -400,7 +401,7 @@ public void DeferDespawn(int tickOffset, bool destroy = true)`
`400`	`401`	`{`
`401`	`402`	`if (!IsSpawned)`
`402`	`403`	`{`
`403`		`- NetworkLog.LogError($"Cannot defer despawning {name} because it is not spawned!");`
	`404`	`+ NetworkLog.LogError($"Cannot defer despawn because [{name}] is not spawned!");`
`404`	`405`	`return;`
`405`	`406`	`}`
`406`	`407`
`@@ -770,7 +771,7 @@ public OwnershipRequestStatus RequestOwnership()`
`770`	`771`	`{`
`771`	`772`	`if (NetworkManagerOwner.LogLevel <= LogLevel.Normal)`
`772`	`773`	`{`
`773`		`- NetworkLog.LogWarning($"Trying to perform an ownership request but {name} is not spawned!");`
	`774`	`+ NetworkLog.LogWarning($"Trying to perform an ownership request but [{name}] is not spawned!");`
`774`	`775`	`}`
`775`	`776`
`776`	`777`	`return OwnershipRequestStatus.Invalid;`
`@@ -1137,6 +1138,10 @@ private bool InternalHasAuthority()`
`1137`	`1138`	`{`
`1138`	`1139`	`if (!IsSpawned)`
`1139`	`1140`	`{`
	`1141`	`+ if (NetworkManagerOwner.LogLevel <= LogLevel.Normal)`
	`1142`	`+ {`
	`1143`	`+ NetworkLog.LogWarning($"Trying to check authority but {name} is not spawned yet!");`
	`1144`	`+ }`
`1140`	`1145`	`return false;`
`1141`	`1146`	`}`
`1142`	`1147`	`return NetworkManagerOwner.DistributedAuthorityMode ? OwnerClientId == NetworkManagerOwner.LocalClientId : NetworkManagerOwner.IsServer;`
`@@ -1200,7 +1205,7 @@ private bool InternalHasAuthority()`
`1200`	`1205`	`/// <summary>`
`1201`	`1206`	`/// Gets whether or not the object is owned by anyone`
`1202`	`1207`	`/// </summary>`
`1203`		`- public bool IsOwnedByServer => IsSpawned && OwnerClientId == NetworkManager.ServerClientId;`
	`1208`	`+ public bool IsOwnedByServer => OwnerClientId == NetworkManager.ServerClientId;`
`1204`	`1209`
`1205`	`1210`	`/// <summary>`
`1206`	`1211`	`/// Gets if the object has yet been spawned across the network`
`@@ -1543,9 +1548,9 @@ public static void NetworkShow(List<NetworkObject> networkObjects, ulong clientI`
`1543`	`1548`
`1544`	`1549`	`// Distributed authority mode adjustments to log a network error and continue when trying to show a NetworkObject`
`1545`	`1550`	`// that the local instance does not own`
`1546`		`- if (!networkObjects[i].HasAuthority)`
	`1551`	`+ if (!networkObject.HasAuthority)`
`1547`	`1552`	`{`
`1548`		`- if (networkObjects[i].NetworkManagerOwner.DistributedAuthorityMode)`
	`1553`	`+ if (networkManager.DistributedAuthorityMode)`
`1549`	`1554`	`{`
`1550`	`1555`	`// It will log locally and to the "master-host".`
`1551`	`1556`	`NetworkLog.LogErrorServer("Only the owner-authority can change visibility when distributed authority mode is enabled!");`
`@@ -1558,14 +1563,14 @@ public static void NetworkShow(List<NetworkObject> networkObjects, ulong clientI`
`1558`	`1563`	`}`
`1559`	`1564`
`1560`	`1565`
`1561`		`- if (networkObjects[i].Observers.Contains(clientId))`
	`1566`	`+ if (networkObject.Observers.Contains(clientId))`
`1562`	`1567`	`{`
`1563`		`- throw new VisibilityChangeException($"{nameof(NetworkObject)} with NetworkId: {networkObjects[i].NetworkObjectId} is already visible");`
	`1568`	`+ throw new VisibilityChangeException($"{nameof(NetworkObject)} with NetworkId: {networkObject.NetworkObjectId} is already visible");`
`1564`	`1569`	`}`
`1565`	`1570`
`1566`		`- if (networkObjects[i].NetworkManagerOwner != networkManager)`
	`1571`	`+ if (networkObject.NetworkManagerOwner != networkManager)`
`1567`	`1572`	`{`
`1568`		`- throw new ArgumentNullException("All " + nameof(NetworkObject) + "s must belong to the same " + nameof(NetworkManagerOwner));`
	`1573`	`+ throw new ArgumentNullException("All " + nameof(NetworkObject) + "s must belong to the same " + nameof(networkManager));`
`1569`	`1574`	`}`
`1570`	`1575`	`}`
`1571`	`1576`
`@@ -1703,9 +1708,9 @@ public static void NetworkHide(List<NetworkObject> networkObjects, ulong clientI`
`1703`	`1708`
`1704`	`1709`	`// Distributed authority mode adjustments to log a network error and continue when trying to show a NetworkObject`
`1705`	`1710`	`// that the local instance does not own`
`1706`		`- if (!networkObjects[i].HasAuthority)`
	`1711`	`+ if (!networkObject.HasAuthority)`
`1707`	`1712`	`{`
`1708`		`- if (networkObjects[i].NetworkManagerOwner.DistributedAuthorityMode)`
	`1713`	`+ if (networkObject.NetworkManagerOwner.DistributedAuthorityMode)`
`1709`	`1714`	`{`
`1710`	`1715`	`// It will log locally and to the "master-host".`
`1711`	`1716`	`NetworkLog.LogErrorServer($"Only the owner-authority can change hide a {nameof(NetworkObject)} when distributed authority mode is enabled!");`
`@@ -1718,19 +1723,20 @@ public static void NetworkHide(List<NetworkObject> networkObjects, ulong clientI`
`1718`	`1723`	`}`
`1719`	`1724`
`1720`	`1725`	`// CLIENT SPAWNING TODO: Log error and continue as opposed to throwing an exception`
`1721`		`- if (!networkObjects[i].IsSpawned)`
	`1726`	`+ // CHECK, should I replace this?`
	`1727`	`+ if (!networkObject.IsSpawned)`
`1722`	`1728`	`{`
`1723`	`1729`	`throw new SpawnStateException("Object is not spawned");`
`1724`	`1730`	`}`
`1725`	`1731`
`1726`		`- if (!networkObjects[i].Observers.Contains(clientId))`
	`1732`	`+ if (!networkObject.Observers.Contains(clientId))`
`1727`	`1733`	`{`
`1728`		`- throw new VisibilityChangeException($"{nameof(NetworkObject)} with {nameof(NetworkObjectId)}: {networkObjects[i].NetworkObjectId} is already hidden");`
	`1734`	`+ throw new VisibilityChangeException($"{nameof(NetworkObject)} with {nameof(NetworkObjectId)}: {networkObject.NetworkObjectId} is already hidden");`
`1729`	`1735`	`}`
`1730`	`1736`
`1731`		`- if (networkObjects[i].NetworkManagerOwner != networkManager)`
	`1737`	`+ if (networkObject.NetworkManagerOwner != networkManager)`
`1732`	`1738`	`{`
`1733`		`- throw new ArgumentNullException("All " + nameof(NetworkObject) + "s must belong to the same " + nameof(NetworkManagerOwner));`
	`1739`	`+ throw new ArgumentNullException("All " + nameof(NetworkObject) + "s must belong to the same " + nameof(networkManager));`
`1734`	`1740`	`}`
`1735`	`1741`	`}`
`1736`	`1742`
`@@ -1742,7 +1748,6 @@ public static void NetworkHide(List<NetworkObject> networkObjects, ulong clientI`
`1742`	`1748`
`1743`	`1749`	`private void OnDestroy()`
`1744`	`1750`	`{`
`1745`		`- // TODO Can we destroy an object before it is spawned?`
`1746`	`1751`	`var networkManager = NetworkManager;`
`1747`	`1752`	`// If no NetworkManager is assigned, then just exit early`
`1748`	`1753`	`if (!networkManager)`
`@@ -2013,7 +2018,7 @@ public void Despawn(bool destroy = true)`
`2013`	`2018`	`{`
`2014`	`2019`	`if (!IsSpawned)`
`2015`	`2020`	`{`
`2016`		`- NetworkLog.LogErrorServer("Object is not spawned!");`
	`2021`	`+ NetworkLog.LogErrorServer($"Cannot despawn [{name}] as it is not spawned!");`
`2017`	`2022`	`return;`
`2018`	`2023`	`}`
`2019`	`2024`
`@@ -2041,7 +2046,7 @@ public void RemoveOwnership()`
`2041`	`2046`	`{`
`2042`	`2047`	`if (!IsSpawned)`
`2043`	`2048`	`{`
`2044`		`- NetworkLog.LogErrorServer("Trying to remove ownership on an object that is not spawned!");`
	`2049`	`+ NetworkLog.LogErrorServer($"Trying to remove the ownership of [{name}] but it is not spawned!");`
`2045`	`2050`	`return;`
`2046`	`2051`	`}`
`2047`	`2052`	`NetworkManagerOwner.SpawnManager.RemoveOwnership(this);`
`@@ -2055,7 +2060,7 @@ public void ChangeOwnership(ulong newOwnerClientId)`
`2055`	`2060`	`{`
`2056`	`2061`	`if (!IsSpawned)`
`2057`	`2062`	`{`
`2058`		`- NetworkLog.LogWarning("Trying to change ownership on an not spawned object!");`
	`2063`	`+ NetworkLog.LogWarning($"Trying to change ownership on [{name}] but it is not spawned!");`
`2059`	`2064`	`return;`
`2060`	`2065`	`}`
`2061`	`2066`
`@@ -2070,7 +2075,7 @@ internal void InvokeBehaviourOnOwnershipChanged(ulong originalOwnerClientId, ulo`
`2070`	`2075`	`{`
`2071`	`2076`	`if (!IsSpawned)`
`2072`	`2077`	`{`
`2073`		`- NetworkLog.LogWarning("Trying to change ownership on an not spawned object!");`
	`2078`	`+ NetworkLog.LogWarning($"Trying to change ownership on [{name}] but it is not spawned!");`
`2074`	`2079`	`return;`
`2075`	`2080`	`}`
`2076`	`2081`
`@@ -2267,7 +2272,7 @@ public bool TryRemoveParent(bool worldPositionStays = true)`
`2267`	`2272`	`/// </summary>`
`2268`	`2273`	`/// <param name="parent">The new parent for this NetworkObject transform will be the child of.</param>`
`2269`	`2274`	`/// <param name="worldPositionStays">If true, the parent-relative position, scale and rotation are modified such that the object keeps the same world space position, rotation and scale as before.</param>`
`2270`		`- /// <returns>Whether or not re-parenting was successful.</returns>`
	`2275`	`+ /// <returns>Whether or not reparenting was successful.</returns>`
`2271`	`2276`	`public bool TrySetParent(NetworkObject parent, bool worldPositionStays = true)`
`2272`	`2277`	`{`
`2273`	`2278`	`if (!AutoObjectParentSync \|\| !IsSpawned \|\| !NetworkManagerOwner.IsListening)`
`@@ -2279,7 +2284,7 @@ public bool TrySetParent(NetworkObject parent, bool worldPositionStays = true)`
`2279`	`2284`	`// It wouldn't make sense to not allow parenting, but keeping this note here as a reminder.`
`2280`	`2285`	`var isAuthority = HasAuthority \|\| (AllowOwnerToParent && IsOwner);`
`2281`	`2286`
`2282`		`- // If we don't have authority, and we are not shutting down, then don't allow any parenting.`
	`2287`	`+ // If we don't have authority and we are not shutting down, then don't allow any parenting.`
`2283`	`2288`	`// If we are shutting down and don't have authority then allow it.`
`2284`	`2289`	`if (!isAuthority && !NetworkManagerOwner.ShutdownInProgress)`
`2285`	`2290`	`{`
`@@ -2291,9 +2296,9 @@ public bool TrySetParent(NetworkObject parent, bool worldPositionStays = true)`
`2291`	`2296`
`2292`	`2297`	`internal bool InternalTrySetParent(NetworkObject parent, bool worldPositionStays = true)`
`2293`	`2298`	`{`
`2294`		`- if (parent && (IsSpawned ^ parent.IsSpawned) && !NetworkManagerOwner.ShutdownInProgress)`
	`2299`	`+ if (parent && (IsSpawned ^ parent.IsSpawned) && !NetworkManager.ShutdownInProgress)`
`2295`	`2300`	`{`
`2296`		`- if (NetworkManagerOwner.LogLevel <= LogLevel.Developer)`
	`2301`	`+ if (NetworkManager.LogLevel <= LogLevel.Developer)`
`2297`	`2302`	`{`
`2298`	`2303`	`var nameOfNotSpawnedObject = IsSpawned ? $" the parent ({parent.name})" : $"the child ({name})";`
`2299`	`2304`	`NetworkLog.LogWarning($"Parenting failed because {nameOfNotSpawnedObject} is not spawned!");`
`@@ -2303,7 +2308,7 @@ internal bool InternalTrySetParent(NetworkObject parent, bool worldPositionStays`
`2303`	`2308`
`2304`	`2309`	`m_CachedWorldPositionStays = worldPositionStays;`
`2305`	`2310`
`2306`		`- if (!parent)`
	`2311`	`+ if (parent == null)`
`2307`	`2312`	`{`
`2308`	`2313`	`CurrentParent = null;`
`2309`	`2314`	`transform.SetParent(null, worldPositionStays);`
`@@ -2319,7 +2324,6 @@ internal bool InternalTrySetParent(NetworkObject parent, bool worldPositionStays`
`2319`	`2324`
`2320`	`2325`	`private void OnTransformParentChanged()`
`2321`	`2326`	`{`
`2322`		`- // Shouldn't we do our if not spawned check here?`
`2323`	`2327`	`if (!AutoObjectParentSync)`
`2324`	`2328`	`{`
`2325`	`2329`	`return;`
`@@ -2345,7 +2349,7 @@ private void OnTransformParentChanged()`
`2345`	`2349`	`return;`
`2346`	`2350`	`}`
`2347`	`2351`	`transform.parent = m_CachedParent;`
`2348`		`- Debug.LogException(new NotListeningException($"{nameof(networkManager)} is not listening, start a server or host before re-parenting"));`
	`2352`	`+ Debug.LogException(new NotListeningException($"{nameof(networkManager)} is not listening, start a server or host before reparenting"));`
`2349`	`2353`	`return;`
`2350`	`2354`	`}`
`2351`	`2355`	`var isAuthority = false;`
`@@ -2362,18 +2366,17 @@ private void OnTransformParentChanged()`
`2362`	`2366`	`if (distributedAuthority)`
`2363`	`2367`	`{`
`2364`	`2368`	`transform.parent = m_CachedParent;`
`2365`		`- NetworkLog.LogError($"[Not Owner] Only the owner-authority of child {gameObject.name}'s {nameof(NetworkObject)} component can re-parent it!");`
	`2369`	`+ NetworkLog.LogError($"[Not Owner] Only the owner-authority of child {gameObject.name}'s {nameof(NetworkObject)} component can reparent it!");`
`2366`	`2370`	`}`
`2367`	`2371`	`else`
`2368`	`2372`	`{`
`2369`	`2373`	`transform.parent = m_CachedParent;`
`2370`		`- Debug.LogException(new NotServerException($"Only the server can re-parent {nameof(NetworkObject)}s"));`
	`2374`	`+ Debug.LogException(new NotServerException($"Only the server can reparent {nameof(NetworkObject)}s"));`
`2371`	`2375`	`}`
`2372`	`2376`	`return;`
`2373`	`2377`	`}`
`2374`	`2378`
`2375`	`2379`
`2376`		`- //Shouldn't this be done first? if the object is not, spawned we enter the first if (!IsSpawned \|\| !NetworkManager.IsListening)`
`2377`	`2380`	`if (!IsSpawned)`
`2378`	`2381`	`{`
`2379`	`2382`	`AuthorityAppliedParenting = false;`
`@@ -2387,7 +2390,7 @@ private void OnTransformParentChanged()`
`2387`	`2390`	`else`
`2388`	`2391`	`{`
`2389`	`2392`	`transform.parent = m_CachedParent;`
`2390`		`- Debug.LogException(new SpawnStateException($"{nameof(NetworkObject)} can only be re-parented after being spawned"));`
	`2393`	`+ Debug.LogException(new SpawnStateException($"{nameof(NetworkObject)} can only be reparented after being spawned"));`
`2391`	`2394`	`}`
`2392`	`2395`	`return;`
`2393`	`2396`	`}`
`@@ -2406,7 +2409,7 @@ private void OnTransformParentChanged()`
`2406`	`2409`	`{`
`2407`	`2410`	`transform.parent = m_CachedParent;`
`2408`	`2411`	`AuthorityAppliedParenting = false;`
`2409`		`- Debug.LogException(new SpawnStateException($"{nameof(NetworkObject)} can only be re-parented under another spawned {nameof(NetworkObject)}"));`
	`2412`	`+ Debug.LogException(new SpawnStateException($"{nameof(NetworkObject)} can only be reparented under another spawned {nameof(NetworkObject)}"));`
`2410`	`2413`	`return;`
`2411`	`2414`	`}`
`2412`	`2415`
`@@ -2507,7 +2510,7 @@ internal bool ApplyNetworkParenting(bool removeParent = false, bool ignoreNotSpa`
`2507`	`2510`	`var parentNetworkObject = transform.parent.GetComponent<NetworkObject>();`
`2508`	`2511`
`2509`	`2512`	`// If parentNetworkObject is null then the parent is a GameObject without a NetworkObject component`
`2510`		`- // attached. Under this case, we preserve the hierarchy, but we don't keep track of the parenting.`
	`2513`	`+ // attached. Under this case, we preserve the hierarchy but we don't keep track of the parenting.`
`2511`	`2514`	`// Note: We only start tracking parenting if the user removes the child from the standard GameObject`
`2512`	`2515`	`// parent and then re-parents the child under a GameObject with a NetworkObject component attached.`
`2513`	`2516`	`if (parentNetworkObject == null)`
`@@ -2618,7 +2621,7 @@ internal void InvokeBehaviourNetworkSpawn()`
`2618`	`2621`	`{`
`2619`	`2622`	`if (!IsSpawned)`
`2620`	`2623`	`{`
`2621`		`- Debug.LogError("Not spawned!");`
	`2624`	`+ NetworkLog.LogWarning($"Trying to invoke network spawn behavior on {name} but is not spawned!");`
`2622`	`2625`	`return;`
`2623`	`2626`	`}`
`2624`	`2627`	`NetworkManagerOwner.SpawnManager.UpdateOwnershipTable(this, OwnerClientId);`
`@@ -2688,7 +2691,7 @@ internal void InvokeBehaviourNetworkDespawn()`
`2688`	`2691`	`{`
`2689`	`2692`	`if (!IsSpawned)`
`2690`	`2693`	`{`
`2691`		`- Debug.LogError("Cannot despawn if is not spawned!");`
	`2694`	`+ NetworkLog.LogWarning($"Trying to invoke network despawn behavior on {name} but is not spawned!");`
`2692`	`2695`	`return;`
`2693`	`2696`	`}`
`2694`	`2697`	`// Invoke OnNetworkPreDespawn on all child behaviours`
`@@ -2782,7 +2785,7 @@ internal void SynchronizeOwnerNetworkVariables(ulong originalOwnerId, ulong orig`
`2782`	`2785`	`{`
`2783`	`2786`	`if (!IsSpawned)`
`2784`	`2787`	`{`
`2785`		`- Debug.LogError("Cannot synchronize network variables if not spawned!");`
	`2788`	`+ NetworkLog.LogWarning($"Trying to synchronize network variables on {name} but is not spawned!");`
`2786`	`2789`	`return;`
`2787`	`2790`	`}`
`2788`	`2791`	`var currentOwnerId = OwnerClientId;`
`@@ -3019,7 +3022,6 @@ public struct TransformData : INetworkSerializeByMemcpy`
`3019`	`3022`
`3020`	`3023`	`public void Serialize(FastBufferWriter writer)`
`3021`	`3024`	`{`
`3022`		`- // CHECK should we check if OwnerObject.IsSpawned here?`
`3023`	`3025`	`if (OwnerObject.NetworkManager.DistributedAuthorityMode)`
`3024`	`3026`	`{`
`3025`	`3027`	`HasOwnershipFlags = true;`
`@@ -3235,7 +3237,6 @@ internal void SynchronizeNetworkBehaviours<T>(ref BufferSerializer<T> serializer`
`3235`	`3237`
`3236`	`3238`	`internal SceneObject GetMessageSceneObject(ulong targetClientId = NetworkManager.ServerClientId, bool syncObservers = false)`
`3237`	`3239`	`{`
`3238`		`- // CHECK can we use NetworkManagerOwner here? if we do, also replace here:CheckForGlobalObjectIdHashOverride`
`3239`	`3240`	`var obj = new SceneObject`
`3240`	`3241`	`{`
`3241`	`3242`	`HasParent = transform.parent != null,`
`@@ -3508,9 +3509,8 @@ private void CurrentlyActiveSceneChanged(Scene current, Scene next)`
`3508`	`3509`	`/// </summary>`
`3509`	`3510`	`internal void SceneChangedUpdate(Scene scene, bool notify = false)`
`3510`	`3511`	`{`
`3511`		`- //CHECK`
`3512`		`- // Avoiding edge case scenarios, if no NetworkSceneManager exit early`
`3513`		`- if (NetworkManagerOwner.SceneManager == null \|\| !IsSpawned)`
	`3512`	`+ // Avoiding edge case scenarios, if not spawned or no NetworkSceneManager exit early`
	`3513`	`+ if (!IsSpawned \|\| NetworkManagerOwner.SceneManager == null)`
`3514`	`3514`	`{`
`3515`	`3515`	`return;`
`3516`	`3516`	`}`