fix: NetworkTransform fails to sync multiple state updates (#3614)

## Purpose of this PR
This PR resolves an issue where a client, under above average latency
and packet loss conditions, could receive multiple `NetworkTransform`
state updates in one frame and when processing the state updates only
the last state update would be applied to the transform.

fix: #3571

### Jira ticket

[MTTB-1530](https://jira.unity3d.com/browse/MTTB-1530)

### Changelog
[//]: # (updated with all public facing changes - API changes, UI/UX
changes, behaviour changes, bug fixes. Remove if not relevant.)

- Fixed: Issue where a client, under above average latency and packet
loss conditions, could receive multiple `NetworkTransform` state updates
in one frame and when processing the state updates only the last state
update would be applied to the transform if interpolation was disabled.


<!-- Uncomment and mark items off with a * if this PR deprecates any
API:
### Deprecated API
- [ ] An `[Obsolete]` attribute was added along with a `(RemovedAfter
yyyy-mm-dd)` entry.
- [ ] An [api
updater](https://confluence.unity3d.com/display/DEV/Obsolete+API+updaters)
was added.
- [ ] Deprecation of the API is explained in the CHANGELOG.
- [ ] The users can understand why this API was removed and what they
should use instead.
-->

## Documentation
[//]: # (
This section is REQUIRED and should mention what documentation changes
were following the changes in this PR.
We should always evaluate if the changes in this PR require any
documentation changes.
)

- No documentation changes or additions were necessary.


## Testing & QA
[//]: #  (
This section is REQUIRED and should describe how the changes were tested
and how should they be tested when Playtesting for the release.
It can range from "edge case covered by unit tests" to "manual testing
required and new sample was added".
Expectation is that PR creator does some manual testing and provides a
summary of it here.)

### Functional Testing
[//]: # (If checked, List manual tests that have been performed.)
_Manual testing :_
- [X] `Manual testing done`
-
[PR-46](https://github.cds.internal.unity3d.com/unity/Asteroids-CMB-NGO-Sample/pull/46)
manual test.

_Automated tests:_
- [ ] `Covered by existing automated tests`
- [X] `Covered by new automated tests`

_Does the change require QA team to:_

- [ ] `Review automated tests`?
- [ ] `Execute manual tests`?

If any boxes above are checked, please add QA as a PR reviewer.

## Backport
This is an NGO v2.x only issue.

Author: NoelStephensUnity

com.unity.netcode.gameobjects/CHANGELOG.md

@@ -22,6 +22,8 @@ Additional documentation and release notes are available at [Multiplayer Documen
 
 ### Fixed
 
+- Fixed issue where a client, under above average latency and packet loss conditions, could receive multiple NetworkTransform state updates in one frame and when processing the state updates only the last state update would be applied to the transform if interpolation was disabled. (#3614)
+
 
 ### Security
 

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

@@ -3003,7 +3003,7 @@ private void ApplyTeleportingState(NetworkTransformState newState)
         /// <remarks>
         /// Only non-authoritative instances should invoke this
         /// </remarks>
-        private void ApplyUpdatedState(NetworkTransformState newState)
+        internal void ApplyUpdatedState(NetworkTransformState newState)
         {
             // Set the transforms's synchronization modes
             InLocalSpace = newState.InLocalSpace;
@@ -3052,6 +3052,7 @@ private void ApplyUpdatedState(NetworkTransformState newState)
 
             if (!Interpolate)
             {
+                ApplyAuthoritativeState();
                 return;
             }
 

com.unity.netcode.gameobjects/Tests/Runtime/NetworkTransform/NetworkTransformGeneral.cs

@@ -37,6 +37,72 @@ protected override void OnOneTimeTearDown()
             base.OnOneTimeTearDown();
         }
 
+        /// <summary>
+        /// This validates an issue where if multiple state updates are received in a single frame
+        /// and interpolation is disabled, only the last state udpate processed gets applied.
+        /// </summary>
+        [Test]
+        public void TestMultipleStateSynchronization([Values] bool isLocal, [Values] bool timeTravelBetweenStateUpdates)
+        {
+            // Assure no new state updates are pushed.
+            TimeTravel(0.5f, 60);
+
+            // Disable interpolation and set world or local space
+            m_NonAuthoritativeTransform.Interpolate = false;
+            m_NonAuthoritativeTransform.InLocalSpace = isLocal;
+
+            // Get the non-authority's state
+            var localState = m_NonAuthoritativeTransform.LocalAuthoritativeNetworkState;
+
+            // Assure this is not set to avoid a false positive result with teleporting
+            localState.IsTeleportingNextFrame = false;
+
+            // Simulate a state update
+            localState.UseInterpolation = false;
+            localState.CurrentPosition = new Vector3(5.0f, 0.0f, 0.0f);
+            localState.HasPositionX = true;
+            localState.PositionX = 5.0f;
+            localState.NetworkTick++;
+
+            var lastStateTick = localState.NetworkTick;
+            // Apply the simualted state update to the non-authority instance
+            m_NonAuthoritativeTransform.ApplyUpdatedState(localState);
+            // Simulate both having time between state updates and having state updates delivered back to back on the same frame
+            if (timeTravelBetweenStateUpdates)
+            {
+                TimeTravelAdvanceTick();
+            }
+
+            // Validate the state update was applied
+            var xValue = isLocal ? m_NonAuthoritativeTransform.transform.localPosition.x : m_NonAuthoritativeTransform.transform.position.x;
+            Assert.IsTrue(xValue == 5.0f, $"[Test1][IsLocal: {isLocal}] X axis ({xValue}) does not equal 5.0f!");
+
+
+            // Get the non-authority state
+            localState = m_NonAuthoritativeTransform.LocalAuthoritativeNetworkState;
+
+            //Assure we have not received any state updates from the authority that could skew the test
+            Assert.IsTrue(localState.NetworkTick == lastStateTick, $"Previous Non-authority state tick was {lastStateTick} but is now {localState.NetworkTick}. Authority pushed a state update.");
+
+            // Simualate a 2nd state update on a different position axis
+            localState.HasPositionX = false;
+            localState.HasPositionZ = true;
+            localState.PositionZ = -5.0f;
+            localState.NetworkTick++;
+            m_NonAuthoritativeTransform.ApplyUpdatedState(localState);
+            // Simulate both having time between state updates and having state updates delivered back to back on the same frame
+            if (timeTravelBetweenStateUpdates)
+            {
+                TimeTravelAdvanceTick();
+            }
+            var zValue = isLocal ? m_NonAuthoritativeTransform.transform.localPosition.z : m_NonAuthoritativeTransform.transform.position.z;
+            xValue = isLocal ? m_NonAuthoritativeTransform.transform.localPosition.x : m_NonAuthoritativeTransform.transform.position.x;
+
+            // Verify the previous state update's position and current state update's position
+            Assert.IsTrue(xValue == 5.0f, $"[Test2][IsLocal: {isLocal}] X axis ({xValue}) does not equal 5.0f!");
+            Assert.IsTrue(zValue == -5.0f, $"[Test2][IsLocal: {isLocal}] Z axis ({zValue}) does not equal -5.0f!");
+        }
+
         /// <summary>
         /// Test to verify nonAuthority cannot change the transform directly
         /// </summary>