fix

This fixes the issue where an authority NetworkTransform instance could check for any changes to the transform more than once in a single frame if the frame time was greater than the tick frequency.

Author: NoelStephensUnity

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

@@ -935,6 +935,12 @@ public void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReade
 
         #region PROPERTIES AND GENERAL METHODS
 
+        /// <summary>
+        /// Used on the authority side only.
+        /// This is the current network tick and is set within <see cref="NetworkManager.NetworkUpdate(NetworkUpdateStage)"/>.
+        /// </summary>
+        internal static int CurrentTick;
+
         /// <summary>
         /// Pertains to Owner Authority and Interpolation<br />
         /// When enabled (default), 1 additional tick is added to the total number of ticks used to calculate the tick latency ("ticks ago") as a time.
@@ -1878,6 +1884,8 @@ private void TryCommitTransform(ref Transform transformToCommit, bool synchroniz
                 // If the state was explicitly set, then update the network tick to match the locally calculate tick
                 if (m_LocalAuthoritativeNetworkState.ExplicitSet)
                 {
+                    // For explicit set, we use the current ServerTime.Tick and not CurrentTick since this is a SetState specific flow
+                    // that is outside of the normal internal tick flow.
                     m_LocalAuthoritativeNetworkState.NetworkTick = m_CachedNetworkManager.NetworkTickSystem.ServerTime.Tick;
                 }
 
@@ -2011,7 +2019,7 @@ private bool CheckForStateChange(ref NetworkTransformState networkState, ref Tra
             // send a full frame synch.
             var isAxisSync = false;
             // We compare against the NetworkTickSystem version since ServerTime is set when updating ticks
-            if (UseUnreliableDeltas && !isSynchronization && m_DeltaSynch && m_NextTickSync <= m_CachedNetworkManager.NetworkTickSystem.ServerTime.Tick)
+            if (UseUnreliableDeltas && !isSynchronization && m_DeltaSynch && m_NextTickSync <= CurrentTick)
             {
                 // Increment to the next frame synch tick position for this instance
                 m_NextTickSync += (int)m_CachedNetworkManager.NetworkConfig.TickRate;
@@ -2179,7 +2187,7 @@ private bool CheckForStateChange(ref NetworkTransformState networkState, ref Tra
             {
                 // If we are teleporting then we can skip the delta threshold check
                 isPositionDirty = networkState.IsTeleportingNextFrame || isAxisSync || forceState;
-                if (m_HalfFloatTargetTickOwnership > m_CachedNetworkManager.ServerTime.Tick)
+                if (m_HalfFloatTargetTickOwnership > CurrentTick)
                 {
                     isPositionDirty = true;
                 }
@@ -2225,7 +2233,7 @@ private bool CheckForStateChange(ref NetworkTransformState networkState, ref Tra
                         networkState.NetworkDeltaPosition = m_HalfPositionState;
 
                         // If ownership offset is greater or we are doing an axial synchronization then synchronize the base position
-                        if ((m_HalfFloatTargetTickOwnership > m_CachedNetworkManager.ServerTime.Tick || isAxisSync) && !networkState.IsTeleportingNextFrame)
+                        if ((m_HalfFloatTargetTickOwnership > CurrentTick || isAxisSync) && !networkState.IsTeleportingNextFrame)
                         {
                             networkState.SynchronizeBaseHalfFloat = true;
                         }
@@ -2409,7 +2417,7 @@ private bool CheckForStateChange(ref NetworkTransformState networkState, ref Tra
                 if (enabled)
                 {
                     // We use the NetworkTickSystem version since ServerTime is set when updating ticks
-                    networkState.NetworkTick = m_CachedNetworkManager.NetworkTickSystem.ServerTime.Tick;
+                    networkState.NetworkTick = CurrentTick;
                 }
             }
 
@@ -2440,7 +2448,7 @@ private void OnNetworkTick(bool isCalledFromParent = false)
                 }
 
                 // If we are nested and have already sent a state update this tick, then exit early (otherwise check for any changes in state)
-                if (IsNested && m_LocalAuthoritativeNetworkState.NetworkTick == m_CachedNetworkManager.ServerTime.Tick)
+                if (IsNested && m_LocalAuthoritativeNetworkState.NetworkTick == CurrentTick)
                 {
                     return;
                 }
@@ -4500,6 +4508,15 @@ private void UpdateTransformState()
 
         #region NETWORK TICK REGISTRATOIN AND HANDLING
         private static Dictionary<NetworkManager, NetworkTransformTickRegistration> s_NetworkTickRegistration = new Dictionary<NetworkManager, NetworkTransformTickRegistration>();
+
+        internal static void UpdateNetworkTick(NetworkManager networkManager)
+        {
+            if (s_NetworkTickRegistration.ContainsKey(networkManager))
+            {
+                s_NetworkTickRegistration[networkManager].TickUpdate();
+            }
+        }
+
         /// <summary>
         /// Adjusts the over-all tick offset (i.e. how many ticks ago) and how wide of a maximum delta time will be used for the
         /// various <see cref="InterpolationTypes"/>.
@@ -4561,9 +4578,8 @@ private static void RemoveTickUpdate(NetworkManager networkManager)
         /// Having the tick update once and cycling through registered instances to update is evidently less processor
         /// intensive than having each instance subscribe and update individually.
         /// </summary>
-        private class NetworkTransformTickRegistration
+        internal class NetworkTransformTickRegistration
         {
-            private Action m_NetworkTickUpdate;
             private NetworkManager m_NetworkManager;
             public HashSet<NetworkTransform> NetworkTransforms = new HashSet<NetworkTransform>();
 
@@ -4575,8 +4591,6 @@ private void OnNetworkManagerStopped(bool value)
 
             public void Remove()
             {
-                m_NetworkManager.NetworkTickSystem.Tick -= m_NetworkTickUpdate;
-                m_NetworkTickUpdate = null;
                 NetworkTransforms.Clear();
                 RemoveTickUpdate(m_NetworkManager);
             }
@@ -4585,10 +4599,10 @@ public void Remove()
             /// Invoked once per network tick, this will update any registered
             /// authority instances.
             /// </summary>
-            private void TickUpdate()
+            internal void TickUpdate()
             {
                 // TODO FIX: The local NetworkTickSystem can invoke with the same network tick as before
-                if (m_NetworkManager.ServerTime.Tick <= m_LastTick)
+                if (CurrentTick <= m_LastTick)
                 {
                     return;
                 }
@@ -4599,13 +4613,11 @@ private void TickUpdate()
                         networkTransform.OnNetworkTick();
                     }
                 }
-                m_LastTick = m_NetworkManager.ServerTime.Tick;
+                m_LastTick = CurrentTick;
             }
             public NetworkTransformTickRegistration(NetworkManager networkManager)
             {
                 m_NetworkManager = networkManager;
-                m_NetworkTickUpdate = new Action(TickUpdate);
-                networkManager.NetworkTickSystem.Tick += m_NetworkTickUpdate;
                 if (networkManager.IsServer)
                 {
                     networkManager.OnServerStopped += OnNetworkManagerStopped;

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

@@ -9,6 +9,7 @@
 #endif
 using UnityEngine.SceneManagement;
 using Debug = UnityEngine.Debug;
+using Unity.Netcode.Components;
 
 namespace Unity.Netcode
 {
@@ -386,7 +387,19 @@ public void NetworkUpdate(NetworkUpdateStage updateStage)
 #endif
                 case NetworkUpdateStage.PreUpdate:
                     {
+                        var currentTick = ServerTime.Tick;
                         NetworkTimeSystem.UpdateTime();
+                        if (ServerTime.Tick != currentTick)
+                        {
+                            // If we have a lower than expected frame rate and our number of ticks that have passed since the last
+                            // frame is greater than 1, then use the first next tick as opposed to the last tick when checking for
+                            // changes in transform state.
+                            // Note: This is an adjustment from using the NetworkTick event as that can be invoked more than once in
+                            // a single frame under the above condition and since any changes to the transform are frame driven there
+                            // is no need to check for changes to the transform more than once per frame.
+                            NetworkTransform.CurrentTick = (ServerTime.Tick - currentTick) > 1 ? currentTick + 1 : ServerTime.Tick;
+                            NetworkTransform.UpdateNetworkTick(this);
+                        }
                         AnticipationSystem.Update();
                     }
                     break;