fix: Use Time.unscaledDeltaTime instead of Time.deltaTime as time step (#2187)

* fix: Use Time.unscaledDeltaTime instead of Time.deltaTime as time step (#2171)

This fixes the case of Time.timeScale = 0 stopping the NetworkManager to update.
This as no influence on all projects that always have Time.timeScale = 1.

+ Add tests
+ Change existing test using Assert.Equal(boolExpr) to the correct Assert function to display real values expected instead of just "true" or "false"

* style: removing unrelated stylistic differences. Fixing brackets placement (netcode.standards)

* test: test adjustments

* test: test adjustments

* test: Applying PR review suggestion of saving the time scale

* test: Applying PR review suggestion of saving the time scale, second location

* Reverted changes to AddNetworkPrefabTests and fixed instabilities caused by NetworkManager.Singleton (can we get rid of that completely soon?)

* reverting unwanted whitespace change

* reducing the test cases to 0.0f, 1.0f and 2.0f timescales

* Revert "Reverted changes to AddNetworkPrefabTests and fixed instabilities caused by NetworkManager.Singleton (can we get rid of that completely soon?)"

This reverts commit 02a222e.

Co-authored-by: PitouGames <pitou.games@gmail.com>
Co-authored-by: Kitty Draper <kitty.draper@unity3d.com>

Author: 3 people

com.unity.netcode.gameobjects/CHANGELOG.md

@@ -21,6 +21,7 @@ Additional documentation and release notes are available at [Multiplayer Documen
 - Fixed ClientRpcs always reporting in the profiler view as going to all clients, even when limited to a subset of clients by `ClientRpcParams`. (#2144)
 - Fixed RPC codegen failing to choose the correct extension methods for `FastBufferReader` and `FastBufferWriter` when the parameters were a generic type (i.e., List<int>) and extensions for multiple instantiations of that type have been defined (i.e., List<int> and List<string>) (#2142)
 - Fixed throwing an exception in `OnNetworkUpdate` causing other `OnNetworkUpdate` calls to not be executed. (#1739)
+- Fixed synchronisation when Time.timeScale is set to 0. This changes timing update to use unscaled deltatime. Now network updates rate are independant from the local time scale. (#2171)
 
 ## [1.0.1] - 2022-08-23
 

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

@@ -1560,7 +1560,7 @@ private void OnNetworkPreUpdate()
             }
 
             // Only update RTT here, server time is updated by time sync messages
-            var reset = NetworkTimeSystem.Advance(Time.deltaTime);
+            var reset = NetworkTimeSystem.Advance(Time.unscaledDeltaTime);
             if (reset)
             {
                 NetworkTickSystem.Reset(NetworkTimeSystem.LocalTime, NetworkTimeSystem.ServerTime);
@@ -1569,7 +1569,7 @@ private void OnNetworkPreUpdate()
 
             if (IsServer == false)
             {
-                NetworkTimeSystem.Sync(NetworkTimeSystem.LastSyncedServerTimeSec + Time.deltaTime, NetworkConfig.NetworkTransport.GetCurrentRtt(ServerClientId) / 1000d);
+                NetworkTimeSystem.Sync(NetworkTimeSystem.LastSyncedServerTimeSec + Time.unscaledDeltaTime, NetworkConfig.NetworkTransport.GetCurrentRtt(ServerClientId) / 1000d);
             }
         }
 

com.unity.netcode.gameobjects/Runtime/Timing/NetworkTime.cs

@@ -25,7 +25,7 @@ public struct NetworkTime
         public double TickOffset => m_CachedTickOffset;
 
         /// <summary>
-        /// Gets the current time. This is a non fixed time value and similar to <see cref="Time.time"/>
+        /// Gets the current time. This is a non fixed time value and similar to <see cref="Time.time"/>.
         /// </summary>
         public double Time => m_TimeSec;
 
@@ -35,13 +35,13 @@ public struct NetworkTime
         public float TimeAsFloat => (float)m_TimeSec;
 
         /// <summary>
-        /// Gets he current fixed network time. This is the time value of the last network tick. Similar to <see cref="Time.fixedTime"/>
+        /// Gets he current fixed network time. This is the time value of the last network tick. Similar to <see cref="Time.fixedUnscaledTime"/>.
         /// </summary>
         public double FixedTime => m_CachedTick * m_TickInterval;
 
         /// <summary>
         /// Gets the fixed delta time. This value is based on the <see cref="TickRate"/> and stays constant.
-        /// Similar to <see cref="Time.fixedDeltaTime"/> There is no equivalent to <see cref="Time.deltaTime"/>
+        /// Similar to <see cref="Time.fixedUnscaledTime"/> There is no equivalent to <see cref="Time.deltaTime"/>.
         /// </summary>
         public float FixedDeltaTime => (float)m_TickInterval;
 

com.unity.netcode.gameobjects/Runtime/Timing/NetworkTimeSystem.cs

@@ -76,7 +76,7 @@ public static NetworkTimeSystem ServerTimeSystem()
         }
 
         /// <summary>
-        /// Advances the time system by a certain amount of time. Should be called once per frame with Time.deltaTime or similar.
+        /// Advances the time system by a certain amount of time. Should be called once per frame with Time.unscaledDeltaTime or similar.
         /// </summary>
         /// <param name="deltaTimeSec">The amount of time to advance. The delta time which passed since Advance was last called.</param>
         /// <returns></returns>

com.unity.netcode.gameobjects/TestHelpers/Runtime/NetcodeIntegrationTest.cs

@@ -23,7 +23,7 @@ public abstract class NetcodeIntegrationTest
         /// </summary>
         internal static bool IsRunning { get; private set; }
         protected static TimeoutHelper s_GlobalTimeoutHelper = new TimeoutHelper(8.0f);
-        protected static WaitForSeconds s_DefaultWaitForTick = new WaitForSeconds(1.0f / k_DefaultTickRate);
+        protected static WaitForSecondsRealtime s_DefaultWaitForTick = new WaitForSecondsRealtime(1.0f / k_DefaultTickRate);
 
         public NetcodeLogAssert NetcodeLogAssert;
 
@@ -339,7 +339,7 @@ protected void CreateServerAndClients(int numberOfClients)
 
             if (m_ServerNetworkManager != null)
             {
-                s_DefaultWaitForTick = new WaitForSeconds(1.0f / m_ServerNetworkManager.NetworkConfig.TickRate);
+                s_DefaultWaitForTick = new WaitForSecondsRealtime(1.0f / m_ServerNetworkManager.NetworkConfig.TickRate);
             }
 
             // Set the player prefab for the server and clients
@@ -574,7 +574,7 @@ protected void ShutdownAndCleanUp()
             UnloadRemainingScenes();
 
             // reset the m_ServerWaitForTick for the next test to initialize
-            s_DefaultWaitForTick = new WaitForSeconds(1.0f / k_DefaultTickRate);
+            s_DefaultWaitForTick = new WaitForSecondsRealtime(1.0f / k_DefaultTickRate);
             VerboseDebug($"Exiting {nameof(ShutdownAndCleanUp)}");
         }
 

com.unity.netcode.gameobjects/Tests/Runtime/AddNetworkPrefabTests.cs

@@ -22,17 +22,18 @@ protected override IEnumerator OnSetup()
             // Host is irrelevant, messages don't get sent to the host "client"
             m_UseHost = false;
 
+            yield return null;
+        }
+
+        protected override void OnServerAndClientsCreated()
+        {
             m_Prefab = new GameObject("Object");
             var networkObject = m_Prefab.AddComponent<NetworkObject>();
             m_Prefab.AddComponent<EmptyComponent>();
 
             // Make it a prefab
             NetcodeIntegrationTestHelpers.MakeNetworkObjectTestPrefab(networkObject);
-            yield return null;
-        }
 
-        protected override void OnServerAndClientsCreated()
-        {
             m_ServerNetworkManager.NetworkConfig.SpawnTimeout = 0;
             m_ServerNetworkManager.NetworkConfig.ForceSamePrefabs = false;
             foreach (var client in m_ClientNetworkManagers)

com.unity.netcode.gameobjects/Tests/Runtime/NetworkVariableTests.cs

@@ -536,6 +536,23 @@ public IEnumerator ClientWritePermissionTest([Values(true, false)] bool useHost)
             Assert.Throws<InvalidOperationException>(() => m_Player1OnClient1.TheScalar.Value = k_TestVal1);
         }
 
+        /// <summary>
+        /// Runs tests that network variables sync on client whatever the local value of <see cref="Time.timeScale"/>.
+        /// </summary>
+        [UnityTest]
+        public IEnumerator NetworkVariableSync_WithDifferentTimeScale([Values(true, false)] bool useHost, [Values(0.0f, 1.0f, 2.0f)] float timeScale)
+        {
+            Time.timeScale = timeScale;
+
+            yield return InitializeServerAndClients(useHost);
+
+            m_Player1OnServer.TheScalar.Value = k_TestVal1;
+
+            // Now wait for the client side version to be updated to k_TestVal1
+            yield return WaitForConditionOrTimeOut(() => m_Player1OnClient1.TheScalar.Value == k_TestVal1);
+            Assert.IsFalse(s_GlobalTimeoutHelper.TimedOut, "Timed out waiting for client-side NetworkVariable to update!");
+        }
+
         [UnityTest]
         public IEnumerator FixedString32Test([Values(true, false)] bool useHost)
         {
@@ -758,9 +775,18 @@ public IEnumerator NetworkListIEnumerator([Values(true, false)] bool useHost)
         }
         #endregion
 
+        private float m_OriginalTimeScale = 1.0f;
+
+        protected override IEnumerator OnSetup()
+        {
+            m_OriginalTimeScale = Time.timeScale;
+            yield return null;
+        }
 
         protected override IEnumerator OnTearDown()
         {
+            Time.timeScale = m_OriginalTimeScale;
+
             m_NetworkListPredicateHandler = null;
             yield return base.OnTearDown();
         }

com.unity.netcode.gameobjects/Tests/Runtime/Timing/NetworkTimeSystemTests.cs

@@ -1,6 +1,7 @@
 using System.Collections;
 using NUnit.Framework;
 using UnityEngine;
+using UnityEngine.Assertions.Comparers;
 using UnityEngine.TestTools;
 using Unity.Netcode.TestHelpers.Runtime;
 
@@ -11,25 +12,45 @@ namespace Unity.Netcode.RuntimeTests
     /// </summary>
     public class NetworkTimeSystemTests
     {
-        private MonoBehaviourTest<PlayerLoopTimeTestComponent> m_MonoBehaviourTest; // cache for teardown
+        private MonoBehaviourTest<PlayerLoopFixedTimeTestComponent> m_PlayerLoopFixedTimeTestComponent; // cache for teardown
+        private MonoBehaviourTest<PlayerLoopTimeTestComponent> m_PlayerLoopTimeTestComponent; // cache for teardown
+
+        private float m_OriginalTimeScale = 1.0f;
 
         [SetUp]
         public void Setup()
         {
+            m_OriginalTimeScale = Time.timeScale;
+
             // Create, instantiate, and host
             Assert.IsTrue(NetworkManagerHelper.StartNetworkManager(out _));
         }
 
         /// <summary>
         /// Tests whether time is accessible and has correct values inside Update/FixedUpdate.
+        /// This test applies only when <see cref="Time.timeScale"> is 1.
+        /// </summary>
+        /// <returns></returns>
+        [UnityTest]
+        public IEnumerator PlayerLoopFixedTimeTest()
+        {
+            m_PlayerLoopFixedTimeTestComponent = new MonoBehaviourTest<PlayerLoopFixedTimeTestComponent>();
+
+            yield return m_PlayerLoopFixedTimeTestComponent;
+        }
+
+        /// <summary>
+        /// Tests whether time is accessible and has correct values inside Update, for multiples <see cref="Time.timeScale"/> values.
         /// </summary>
         /// <returns></returns>
         [UnityTest]
-        public IEnumerator PlayerLoopTimeTest()
+        public IEnumerator PlayerLoopTimeTest_WithDifferentTimeScale([Values(0.0f, 0.1f, 0.5f, 1.0f, 2.0f, 5.0f)] float timeScale)
         {
-            m_MonoBehaviourTest = new MonoBehaviourTest<PlayerLoopTimeTestComponent>();
+            Time.timeScale = timeScale;
+
+            m_PlayerLoopTimeTestComponent = new MonoBehaviourTest<PlayerLoopTimeTestComponent>();
 
-            yield return m_MonoBehaviourTest;
+            yield return m_PlayerLoopTimeTestComponent;
         }
 
         /// <summary>
@@ -40,10 +61,10 @@ public IEnumerator PlayerLoopTimeTest()
         [UnityTest]
         public IEnumerator CorrectAmountTicksTest()
         {
-            var tickSystem = NetworkManager.Singleton.NetworkTickSystem;
-            var delta = tickSystem.LocalTime.FixedDeltaTime;
-            var previous_localTickCalculated = 0;
-            var previous_serverTickCalculated = 0;
+            NetworkTickSystem tickSystem = NetworkManager.Singleton.NetworkTickSystem;
+            float delta = tickSystem.LocalTime.FixedDeltaTime;
+            int previous_localTickCalculated = 0;
+            int previous_serverTickCalculated = 0;
 
             while (tickSystem.LocalTime.Time < 3f)
             {
@@ -70,7 +91,7 @@ public IEnumerator CorrectAmountTicksTest()
 
                 Assert.AreEqual(previous_localTickCalculated, NetworkManager.Singleton.LocalTime.Tick, $"Calculated local tick {previous_localTickCalculated} does not match local tick {NetworkManager.Singleton.LocalTime.Tick}!");
                 Assert.AreEqual(previous_serverTickCalculated, NetworkManager.Singleton.ServerTime.Tick, $"Calculated server tick {previous_serverTickCalculated} does not match server tick {NetworkManager.Singleton.ServerTime.Tick}!");
-                Assert.True(Mathf.Approximately((float)NetworkManager.Singleton.LocalTime.Time, (float)NetworkManager.Singleton.ServerTime.Time), $"Local time {(float)NetworkManager.Singleton.LocalTime.Time} is not approximately server time {(float)NetworkManager.Singleton.ServerTime.Time}!");
+                Assert.AreEqual((float)NetworkManager.Singleton.LocalTime.Time, (float)NetworkManager.Singleton.ServerTime.Time, $"Local time {(float)NetworkManager.Singleton.LocalTime.Time} is not approximately server time {(float)NetworkManager.Singleton.ServerTime.Time}!", FloatComparer.s_ComparerWithDefaultTolerance);
             }
         }
 
@@ -80,15 +101,23 @@ public void TearDown()
             // Stop, shutdown, and destroy
             NetworkManagerHelper.ShutdownNetworkManager();
 
-            if (m_MonoBehaviourTest != null)
+            Time.timeScale = m_OriginalTimeScale;
+
+            if (m_PlayerLoopFixedTimeTestComponent != null)
             {
-                Object.DestroyImmediate(m_MonoBehaviourTest.gameObject);
+                Object.DestroyImmediate(m_PlayerLoopFixedTimeTestComponent.gameObject);
+                m_PlayerLoopFixedTimeTestComponent = null;
             }
-        }
 
+            if (m_PlayerLoopTimeTestComponent != null)
+            {
+                Object.DestroyImmediate(m_PlayerLoopTimeTestComponent.gameObject);
+                m_PlayerLoopTimeTestComponent = null;
+            }
+        }
     }
 
-    public class PlayerLoopTimeTestComponent : MonoBehaviour, IMonoBehaviourTest
+    public class PlayerLoopFixedTimeTestComponent : MonoBehaviour, IMonoBehaviourTest
     {
         public const int Passes = 100;
 
@@ -101,7 +130,7 @@ public class PlayerLoopTimeTestComponent : MonoBehaviour, IMonoBehaviourTest
         private NetworkTime m_ServerTimePreviousUpdate;
         private NetworkTime m_LocalTimePreviousFixedUpdate;
 
-        public void Start()
+        private void Start()
         {
             // Run fixed update at same rate as network tick
             Time.fixedDeltaTime = NetworkManager.Singleton.LocalTime.FixedDeltaTime;
@@ -110,23 +139,23 @@ public void Start()
             Time.maximumDeltaTime = float.MaxValue;
         }
 
-        public void Update()
+        private void Update()
         {
             // This must run first else it wont run if there is an exception
             m_UpdatePasses++;
 
-            var localTime = NetworkManager.Singleton.LocalTime;
-            var serverTime = NetworkManager.Singleton.ServerTime;
+            NetworkTime localTime = NetworkManager.Singleton.LocalTime;
+            NetworkTime serverTime = NetworkManager.Singleton.ServerTime;
 
             // time should have advanced on the host/server
-            Assert.True(m_LocalTimePreviousUpdate.Time < localTime.Time);
-            Assert.True(m_ServerTimePreviousUpdate.Time < serverTime.Time);
+            Assert.Less(m_LocalTimePreviousUpdate.Time, localTime.Time);
+            Assert.Less(m_ServerTimePreviousUpdate.Time, serverTime.Time);
 
             // time should be further then last fixed step in update
-            Assert.True(m_LocalTimePreviousFixedUpdate.FixedTime < localTime.Time);
+            Assert.Less(m_LocalTimePreviousFixedUpdate.FixedTime, localTime.Time);
 
             // we should be in same or further tick then fixed update
-            Assert.True(m_LocalTimePreviousFixedUpdate.Tick <= localTime.Tick);
+            Assert.LessOrEqual(m_LocalTimePreviousFixedUpdate.Tick, localTime.Tick);
 
             // fixed update should result in same amounts of tick as network time
             if (m_TickOffset == -1)
@@ -135,23 +164,61 @@ public void Update()
             }
             else
             {
-                // offset of  1 is ok, this happens due to different tick duration offsets
-                Assert.True(Mathf.Abs(serverTime.Tick - m_TickOffset - m_LastFixedUpdateTick) <= 1);
+                // offset of 1 is ok, this happens due to different tick duration offsets
+                Assert.LessOrEqual(Mathf.Abs(serverTime.Tick - m_TickOffset - m_LastFixedUpdateTick), 1);
             }
 
             m_LocalTimePreviousUpdate = localTime;
+            m_ServerTimePreviousUpdate = serverTime;
         }
 
-        public void FixedUpdate()
+        private void FixedUpdate()
         {
-            var time = NetworkManager.Singleton.LocalTime;
+            m_LocalTimePreviousFixedUpdate = NetworkManager.Singleton.LocalTime;
 
-            m_LocalTimePreviousFixedUpdate = time;
+            Assert.AreEqual(Time.fixedDeltaTime, m_LocalTimePreviousFixedUpdate.FixedDeltaTime);
+            Assert.AreEqual((float)NetworkManager.Singleton.LocalTime.Time, (float)NetworkManager.Singleton.ServerTime.Time, null, FloatComparer.s_ComparerWithDefaultTolerance);
+            m_LastFixedUpdateTick++;
+        }
 
-            Assert.AreEqual(Time.fixedDeltaTime, time.FixedDeltaTime);
-            Assert.True(Mathf.Approximately((float)NetworkManager.Singleton.LocalTime.Time, (float)NetworkManager.Singleton.ServerTime.Time));
+        public bool IsTestFinished => m_UpdatePasses >= Passes;
+    }
 
-            m_LastFixedUpdateTick++;
+    public class PlayerLoopTimeTestComponent : MonoBehaviour, IMonoBehaviourTest
+    {
+        public const int Passes = 100;
+
+        private int m_UpdatePasses = 0;
+
+        private NetworkTime m_LocalTimePreviousUpdate;
+        private NetworkTime m_ServerTimePreviousUpdate;
+        private NetworkTime m_LocalTimePreviousFixedUpdate;
+
+        private void Update()
+        {
+            // This must run first else it wont run if there is an exception
+            m_UpdatePasses++;
+
+            NetworkTime localTime = NetworkManager.Singleton.LocalTime;
+            NetworkTime serverTime = NetworkManager.Singleton.ServerTime;
+
+            // time should have advanced on the host/server
+            Assert.Less(m_LocalTimePreviousUpdate.Time, localTime.Time);
+            Assert.Less(m_ServerTimePreviousUpdate.Time, serverTime.Time);
+
+            // time should be further then last fixed step in update
+            Assert.Less(m_LocalTimePreviousFixedUpdate.FixedTime, localTime.Time);
+
+            // we should be in same or further tick then fixed update
+            Assert.LessOrEqual(m_LocalTimePreviousFixedUpdate.Tick, localTime.Tick);
+
+            m_LocalTimePreviousUpdate = localTime;
+            m_ServerTimePreviousUpdate = serverTime;
+        }
+
+        private void FixedUpdate()
+        {
+            m_LocalTimePreviousFixedUpdate = NetworkManager.Singleton.LocalTime;
         }
 
         public bool IsTestFinished => m_UpdatePasses >= Passes;