update

Time systems related updates

Author: NoelStephensUnity

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

@@ -45,11 +45,19 @@ public struct NetworkTime
         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.fixedUnscaledTime"/> There is no equivalent to <see cref="Time.deltaTime"/>.
+        /// Gets the fixed delta time. This value is calculated by dividing 1.0 by the <see cref="TickRate"/> and stays constant.
         /// </summary>
+        /// <remarks>
+        /// This could result in a potential floating point precision variance on different systems. <br />
+        /// See <see href="FixedDeltaTime"></see> for a more precise value.
+        /// </remarks>
         public float FixedDeltaTime => (float)m_TickInterval;
 
+        /// <summary>
+        /// Gets the fixed delta time as a double. This value is calculated by dividing 1.0 by the <see cref="TickRate"/> and stays constant.
+        /// </summary>
+        public double FixedDeltaTimeAsDouble => m_TickInterval;
+
         /// <summary>
         /// Gets the amount of network ticks which have passed until reaching the current time value.
         /// </summary>
@@ -70,7 +78,7 @@ public NetworkTime(uint tickRate)
             Assert.IsTrue(tickRate > 0, "Tickrate must be a positive value.");
 
             m_TickRate = tickRate;
-            m_TickInterval = 1f / m_TickRate; // potential floating point precision issue, could result in different interval on different machines
+            m_TickInterval = 1.0 / m_TickRate;
             m_CachedTickOffset = 0;
             m_CachedTick = 0;
             m_TimeSec = 0;

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

@@ -1,5 +1,6 @@
 using System;
 using Unity.Profiling;
+using UnityEngine;
 
 namespace Unity.Netcode
 {
@@ -35,7 +36,7 @@ public class NetworkTimeSystem
 #if DEVELOPMENT_BUILD || UNITY_EDITOR
         private static ProfilerMarker s_SyncTime = new ProfilerMarker($"{nameof(NetworkManager)}.SyncTime");
 #endif
-
+        private double m_PreviousTimeSec;
         private double m_TimeSec;
         private double m_CurrentLocalTimeOffset;
         private double m_DesiredLocalTimeOffset;
@@ -75,8 +76,20 @@ public class NetworkTimeSystem
         /// </summary>
         public double ServerTime => m_TimeSec + m_CurrentServerTimeOffset;
 
+        private float m_TickLatencyAverage = 2.0f;
+
+        /// <summary>
+        /// The averaged latency in network ticks between a client and server.
+        /// </summary>
+        /// <remarks>
+        /// For a distributed authority network topology, this latency is between
+        /// the client and the distributed authority service instance.
+        /// </remarks>
+        public int TickLatency = 2;
+
         internal double LastSyncedServerTimeSec { get; private set; }
         internal double LastSyncedRttSec { get; private set; }
+        internal double LastSyncedHalfRttSec { get; private set; }
 
         private NetworkConnectionManager m_ConnectionManager;
         private NetworkTransport m_NetworkTransport;
@@ -101,6 +114,7 @@ public NetworkTimeSystem(double localBufferSec, double serverBufferSec = k_Defau
             ServerBufferSec = serverBufferSec;
             HardResetThresholdSec = hardResetThresholdSec;
             AdjustmentRatio = adjustmentRatio;
+            m_TickLatencyAverage = 2;
         }
 
         /// <summary>
@@ -203,7 +217,14 @@ public static NetworkTimeSystem ServerTimeSystem()
         /// <returns>True if a hard reset of the time system occurred due to large time offset differences. False if normal time advancement occurred</returns>
         public bool Advance(double deltaTimeSec)
         {
+            m_PreviousTimeSec = m_TimeSec;
             m_TimeSec += deltaTimeSec;
+            // TODO: For client-server, we need a latency message sent by clients to tell us their tick latency
+            if (LastSyncedRttSec > 0.0f)
+            {
+                m_TickLatencyAverage = Mathf.Lerp(m_TickLatencyAverage, (float)((LastSyncedRttSec + deltaTimeSec) / m_NetworkTickSystem.ServerTime.FixedDeltaTimeAsDouble), (float)deltaTimeSec);
+                TickLatency = (int)Mathf.Max(1.0f, Mathf.Round(m_TickLatencyAverage)) + 1;
+            }
 
             if (Math.Abs(m_DesiredLocalTimeOffset - m_CurrentLocalTimeOffset) > HardResetThresholdSec || Math.Abs(m_DesiredServerTimeOffset - m_CurrentServerTimeOffset) > HardResetThresholdSec)
             {
@@ -243,19 +264,18 @@ public void Reset(double serverTimeSec, double rttSec)
         public void Sync(double serverTimeSec, double rttSec)
         {
             LastSyncedRttSec = rttSec;
+            LastSyncedHalfRttSec = (rttSec * 0.5d);
             LastSyncedServerTimeSec = serverTimeSec;
 
             var timeDif = serverTimeSec - m_TimeSec;
 
             m_DesiredServerTimeOffset = timeDif - ServerBufferSec;
             // We adjust our desired local time offset to be half RTT since the delivery of
             // the TimeSyncMessage should only take half of the RTT time (legacy was using 1 full RTT)
-            m_DesiredLocalTimeOffset = timeDif + (rttSec * 0.5d) + LocalBufferSec;
+            m_DesiredLocalTimeOffset = timeDif + LastSyncedHalfRttSec + LocalBufferSec;
         }
 
         internal double ServerTimeOffset => m_DesiredServerTimeOffset;
         internal double LocalTimeOffset => m_DesiredLocalTimeOffset;
-
-        internal double RawTime => m_TimeSec;
     }
 }