fix and style

Fixing several issues with NetworkObjectSceneMigrationTests.
Fixing several formatting issues.

Author: NoelStephensUnity

com.unity.netcode.gameobjects/Editor/NetworkManagerHelper.cs

@@ -195,11 +195,11 @@ public bool NotifyUserOfNestedNetworkManager(NetworkManager networkManager, bool
                 {
                     return isParented;
                 }
-                else // If we are no longer a child, then we can remove ourself from this list
-                    if (transform.root == gameObject.transform)
-                    {
-                        s_LastKnownNetworkManagerParents.Remove(networkManager);
-                    }
+                else if (transform.root == gameObject.transform)
+                {
+                    // If we are no longer a child, then we can remove ourself from this list
+                    s_LastKnownNetworkManagerParents.Remove(networkManager);
+                }
             }
             if (!EditorApplication.isUpdating && isParented)
             {

com.unity.netcode.gameobjects/Runtime/Components/Interpolator/BufferedLinearInterpolator.cs

@@ -467,20 +467,20 @@ internal T Update(float deltaTime, double tickLatencyAsTime, double minDeltaTime
                         InterpolateState.CurrentValue = InterpolateState.NextValue;
                     }
                 }
-                else // If the target is reached and we have no more state updates, we want to check to see if we need to reset.
-                    if (m_BufferQueue.Count == 0)
+                // If the target is reached and we have no more state updates, we want to check to see if we need to reset.
+                else if (m_BufferQueue.Count == 0)
+                {
+                    // When the delta between the time sent and the current tick latency time-window is greater than the max delta time
+                    // plus the minimum delta time (a rough estimate of time to wait before we consider rate of change equal to zero),
+                    // we will want to reset the interpolator with the current known value. This prevents the next received state update's
+                    // time to be calculated against the last calculated time which if there is an extended period of time between the two
+                    // it would cause a large delta time period between the two states (i.e. it stops moving for a second or two and then
+                    // starts moving again).
+                    if ((tickLatencyAsTime - InterpolateState.Target.Value.TimeSent) > InterpolateState.MaxDeltaTime + minDeltaTime)
                     {
-                        // When the delta between the time sent and the current tick latency time-window is greater than the max delta time
-                        // plus the minimum delta time (a rough estimate of time to wait before we consider rate of change equal to zero),
-                        // we will want to reset the interpolator with the current known value. This prevents the next received state update's
-                        // time to be calculated against the last calculated time which if there is an extended period of time between the two
-                        // it would cause a large delta time period between the two states (i.e. it stops moving for a second or two and then
-                        // starts moving again).
-                        if ((tickLatencyAsTime - InterpolateState.Target.Value.TimeSent) > InterpolateState.MaxDeltaTime + minDeltaTime)
-                        {
-                            InterpolateState.Reset(InterpolateState.CurrentValue);
-                        }
+                        InterpolateState.Reset(InterpolateState.CurrentValue);
                     }
+                }
             }
             m_NbItemsReceivedThisFrame = 0;
             return InterpolateState.CurrentValue;
@@ -595,18 +595,18 @@ public T Update(float deltaTime, double renderTime, double serverTime)
             }
             else // If the target is reached and we have no more state updates, we want to check to see if we need to reset.
                 if (InterpolateState.TargetReached && m_BufferQueue.Count == 0)
+            {
+                // When the delta between the time sent and the current tick latency time-window is greater than the max delta time
+                // plus the minimum delta time (a rough estimate of time to wait before we consider rate of change equal to zero),
+                // we will want to reset the interpolator with the current known value. This prevents the next received state update's
+                // time to be calculated against the last calculated time which if there is an extended period of time between the two
+                // it would cause a large delta time period between the two states (i.e. it stops moving for a second or two and then
+                // starts moving again).
+                if ((renderTime - InterpolateState.Target.Value.TimeSent) > 0.3f) // If we haven't recevied anything within 300ms, assume we stopped motion.
                 {
-                    // When the delta between the time sent and the current tick latency time-window is greater than the max delta time
-                    // plus the minimum delta time (a rough estimate of time to wait before we consider rate of change equal to zero),
-                    // we will want to reset the interpolator with the current known value. This prevents the next received state update's
-                    // time to be calculated against the last calculated time which if there is an extended period of time between the two
-                    // it would cause a large delta time period between the two states (i.e. it stops moving for a second or two and then
-                    // starts moving again).
-                    if ((renderTime - InterpolateState.Target.Value.TimeSent) > 0.3f) // If we haven't recevied anything within 300ms, assume we stopped motion.
-                    {
-                        InterpolateState.Reset(InterpolateState.CurrentValue);
-                    }
+                    InterpolateState.Reset(InterpolateState.CurrentValue);
                 }
+            }
             m_NbItemsReceivedThisFrame = 0;
             return InterpolateState.CurrentValue;
         }

com.unity.netcode.gameobjects/Runtime/Components/NetworkAnimator.cs

@@ -1180,26 +1180,25 @@ internal void CheckForAnimatorChanges()
                 {
                     SendAnimStateRpc(m_AnimationMessage);
                 }
+                else if(!IsServer && IsOwner)
+                {
+                    SendServerAnimStateRpc(m_AnimationMessage);
+                }
                 else
-                    if (!IsServer && IsOwner)
-                    {
-                        SendServerAnimStateRpc(m_AnimationMessage);
-                    }
-                    else
+                {
+                    // Just notify all remote clients and not the local server
+                    m_TargetGroup.Clear();
+                    foreach (var clientId in LocalNetworkManager.ConnectionManager.ConnectedClientIds)
                     {
-                        // Just notify all remote clients and not the local server
-                        m_TargetGroup.Clear();
-                        foreach (var clientId in LocalNetworkManager.ConnectionManager.ConnectedClientIds)
+                        if (clientId == LocalNetworkManager.LocalClientId || !NetworkObject.Observers.Contains(clientId))
                         {
-                            if (clientId == LocalNetworkManager.LocalClientId || !NetworkObject.Observers.Contains(clientId))
-                            {
-                                continue;
-                            }
-                            m_TargetGroup.Add(clientId);
+                            continue;
                         }
-                        m_RpcParams.Send.Target = m_TargetGroup.Target;
-                        SendClientAnimStateRpc(m_AnimationMessage, m_RpcParams);
+                        m_TargetGroup.Add(clientId);
                     }
+                    m_RpcParams.Send.Target = m_TargetGroup.Target;
+                    SendClientAnimStateRpc(m_AnimationMessage, m_RpcParams);
+                }
             }
         }
 
@@ -1348,23 +1347,23 @@ private unsafe void WriteParameters(ref FastBufferWriter writer)
                 }
                 else
                     if (cacheValue.Type == AnimationParamEnumWrapper.AnimatorControllerParameterBool)
+                {
+                    var valueBool = m_Animator.GetBool(hash);
+                    fixed (void* value = cacheValue.Value)
                     {
-                        var valueBool = m_Animator.GetBool(hash);
-                        fixed (void* value = cacheValue.Value)
-                        {
-                            UnsafeUtility.WriteArrayElement(value, 0, valueBool);
-                            BytePacker.WriteValuePacked(writer, valueBool);
-                        }
+                        UnsafeUtility.WriteArrayElement(value, 0, valueBool);
+                        BytePacker.WriteValuePacked(writer, valueBool);
                     }
-                    else if (cacheValue.Type == AnimationParamEnumWrapper.AnimatorControllerParameterFloat)
+                }
+                else if (cacheValue.Type == AnimationParamEnumWrapper.AnimatorControllerParameterFloat)
+                {
+                    var valueFloat = m_Animator.GetFloat(hash);
+                    fixed (void* value = cacheValue.Value)
                     {
-                        var valueFloat = m_Animator.GetFloat(hash);
-                        fixed (void* value = cacheValue.Value)
-                        {
-                            UnsafeUtility.WriteArrayElement(value, 0, valueFloat);
-                            BytePacker.WriteValuePacked(writer, valueFloat);
-                        }
+                        UnsafeUtility.WriteArrayElement(value, 0, valueFloat);
+                        BytePacker.WriteValuePacked(writer, valueFloat);
                     }
+                }
             }
         }
 

com.unity.netcode.gameobjects/Runtime/Components/NetworkTransform.cs

@@ -2515,24 +2515,24 @@ private bool CheckForStateChange(ref NetworkTransformState networkState, bool is
                     }
                 }
             }
-            else // Just apply the full local scale when synchronizing
-                if (SynchronizeScale)
+            // Just apply the full local scale when synchronizing
+            else if (SynchronizeScale)
+            {
+                var localScale = CachedTransform.localScale;
+                if (!UseHalfFloatPrecision)
                 {
-                    var localScale = CachedTransform.localScale;
-                    if (!UseHalfFloatPrecision)
-                    {
 
-                        networkState.ScaleX = localScale.x;
-                        networkState.ScaleY = localScale.y;
-                        networkState.ScaleZ = localScale.z;
-                    }
-                    else
-                    {
-                        networkState.Scale = localScale;
-                    }
-                    flagStates.MarkChanged(AxialType.Scale, true);
-                    isScaleDirty = true;
+                    networkState.ScaleX = localScale.x;
+                    networkState.ScaleY = localScale.y;
+                    networkState.ScaleZ = localScale.z;
                 }
+                else
+                {
+                    networkState.Scale = localScale;
+                }
+                flagStates.MarkChanged(AxialType.Scale, true);
+                isScaleDirty = true;
+            }
             isDirty |= isPositionDirty || isRotationDirty || isScaleDirty;
 
             if (isDirty)
@@ -3488,12 +3488,12 @@ private void NonAuthorityFinalizeSynchronization()
                         child.InternalInitialization();
                     }
                 }
-                else // Otherwise, just run through standard synchronization of this instance
-                    if (!CanCommitToTransform)
-                    {
-                        ApplySynchronization();
-                        InternalInitialization();
-                    }
+                // Otherwise, just run through standard synchronization of this instance
+                else if (!CanCommitToTransform)
+                {
+                    ApplySynchronization();
+                    InternalInitialization();
+                }
             }
         }
 

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

@@ -967,19 +967,18 @@ internal void ProcessClientsToDisconnect()
             {
                 return (true, playerPrefabHash.Value);
             }
-            else
-                if (NetworkManager.NetworkConfig.PlayerPrefab != null)
+            else if (NetworkManager.NetworkConfig.PlayerPrefab != null)
+            {
+                var networkObject = NetworkManager.NetworkConfig.PlayerPrefab.GetComponent<NetworkObject>();
+                if (networkObject != null)
                 {
-                    var networkObject = NetworkManager.NetworkConfig.PlayerPrefab.GetComponent<NetworkObject>();
-                    if (networkObject != null)
-                    {
-                        return (true, networkObject.GlobalObjectIdHash);
-                    }
-                    else
-                    {
-                        NetworkManager.Log.Error(new Logging.Context(LogLevel.Error, $"Player prefab {NetworkManager.NetworkConfig.PlayerPrefab.name} has no {nameof(NetworkObject)}!"));
-                    }
+                    return (true, networkObject.GlobalObjectIdHash);
                 }
+                else
+                {
+                    NetworkManager.Log.Error(new Logging.Context(LogLevel.Error, $"Player prefab {NetworkManager.NetworkConfig.PlayerPrefab.name} has no {nameof(NetworkObject)}!"));
+                }
+            }
             return (false, 0);
         }
 

com.unity.netcode.gameobjects/Runtime/SceneManagement/DefaultSceneManagerHandler.cs

@@ -359,14 +359,14 @@ public void SetClientSynchronizationMode(ref NetworkManager networkManager, Load
                 }
                 return;
             }
-            else // Warn users if they are changing this after there are clients already connected and synchronized
-                if (!networkManager.DistributedAuthorityMode && networkManager.ConnectedClientsIds.Count > (networkManager.IsHost ? 1 : 0) && sceneManager.ClientSynchronizationMode != mode)
+            // Warn users if they are changing this after there are clients already connected and synchronized
+            else if (!networkManager.DistributedAuthorityMode && networkManager.ConnectedClientsIds.Count > (networkManager.IsHost ? 1 : 0) && sceneManager.ClientSynchronizationMode != mode)
+            {
+                if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
                 {
-                    if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
-                    {
-                        NetworkLog.LogWarning("Server is changing client synchronization mode after clients have been synchronized! It is recommended to do this before clients are connected!");
-                    }
+                    NetworkLog.LogWarning("Server is changing client synchronization mode after clients have been synchronized! It is recommended to do this before clients are connected!");
                 }
+            }
 
             // For additive client synchronization, we take into consideration scenes
             // already loaded.

com.unity.netcode.gameobjects/Runtime/SceneManagement/NetworkSceneManager.cs

@@ -1034,7 +1034,7 @@ internal void SetTheSceneBeingSynchronized(NetworkSceneHandle serverSceneHandle)
                 // Most common scenario for DontDestroyOnLoad is when NetworkManager is set to not be destroyed
                 if (serverSceneHandle == DontDestroyOnLoadScene.handle)
                 {
-                    SceneBeingSynchronized = NetworkManager.gameObject.scene;
+                    SceneBeingSynchronized = DontDestroyOnLoadScene;
                     return;
                 }
                 else
@@ -2260,20 +2260,13 @@ private void SynchronizeNetworkObjectScene()
                 {
                     networkObject.SceneOriginHandle = ServerSceneHandleToClientSceneHandle[networkObject.NetworkSceneHandle];
 
-
-
                     // If the NetworkObject does not have a parent and is not in the same scene as it is on the server side, then find the right scene
                     // and move it to that scene.
                     if (networkObject.gameObject.scene.handle != networkObject.SceneOriginHandle && networkObject.transform.parent == null)
                     {
                         if (ScenesLoaded.ContainsKey(networkObject.SceneOriginHandle))
                         {
                             var scene = ScenesLoaded[networkObject.SceneOriginHandle];
-                            if (scene == DontDestroyOnLoadScene)
-                            {
-                                Debug.Log($"{networkObject.gameObject.name} migrating into DDOL!");
-                            }
-
                             SceneManager.MoveGameObjectToScene(networkObject.gameObject, scene);
                         }
                         else if (NetworkManager.LogLevel <= LogLevel.Normal)
@@ -2897,6 +2890,13 @@ internal bool IsSceneUnloading(NetworkObject networkObject)
         /// </summary>
         internal void NotifyNetworkObjectSceneChanged(NetworkObject networkObject)
         {
+            Debug.Log($"{networkObject.name} changed scene to {networkObject.gameObject.scene.name}!");
+            if (networkObject.NetworkManagerOwner != NetworkManager)
+            {
+                Debug.Log($"!!!!!!!!!!!!! Integration test is registering for scene migration for instances outside of the bounds of this NetworkManager context !!!!!!!!!!!!!");
+                return;
+            }
+
             // Really, this should never happen but in case it does
             if (!networkObject.HasAuthority)
             {
@@ -2920,7 +2920,7 @@ internal void NotifyNetworkObjectSceneChanged(NetworkObject networkObject)
 
             // Ignore if the scene is the currently active scene and the NetworkObject is auto synchronizing/migrating
             // to the currently active scene.
-            if (networkObject.gameObject.scene == SceneManager.GetActiveScene() && networkObject.ActiveSceneSynchronization)
+            if (networkObject.gameObject.scene.name == SceneManager.GetActiveScene().name && networkObject.ActiveSceneSynchronization)
             {
                 return;
             }
@@ -2929,6 +2929,13 @@ internal void NotifyNetworkObjectSceneChanged(NetworkObject networkObject)
             // Note: This does not apply to SceneEventType.Synchronize since synchronization isn't a global connected client event.
             if (IsSceneEventInProgress())
             {
+                Debug.Log($"{networkObject.name} scene event in progress -- ignoring!");
+                return;
+            }
+
+            if (IsSceneUnloading(networkObject))
+            {
+                Debug.Log($"{networkObject.name} scene unloading in progress -- ignoring!");
                 return;
             }
 

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

@@ -341,11 +341,11 @@ internal void HandleNetworkPrefabDestroy(NetworkObject networkObjectInstance)
                     prefabInstanceHandler.Destroy(networkObjectInstance);
                 }
             }
-            else // Otherwise the NetworkObject is the source NetworkPrefab
-                if (m_PrefabAssetToPrefabHandler.TryGetValue(networkObjectInstanceHash, out var prefabInstanceHandler))
-                {
-                    prefabInstanceHandler.Destroy(networkObjectInstance);
-                }
+            // Otherwise the NetworkObject is the source NetworkPrefab
+            else if (m_PrefabAssetToPrefabHandler.TryGetValue(networkObjectInstanceHash, out var prefabInstanceHandler))
+            {
+                prefabInstanceHandler.Destroy(networkObjectInstance);
+            }
         }
 
         /// <summary>