test update

Added a form of tick synchronization prior to making changes to the authoritative transform state.

Author: NoelStephensUnity

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

@@ -148,6 +148,10 @@ public IEnumerator NetworkTransformParentingLocalSpaceOffsetTests([Values] Trans
             yield return null;
         }
 
+        /// <summary>
+        /// Moves and rotates the authority side with a single frame between
+        /// both actions in order to
+        /// </summary>
         private IEnumerator MoveAndRotateAuthority(Vector3 position, Vector3 rotation)
         {
             m_AuthoritativeTransform.transform.position = position;
@@ -179,30 +183,40 @@ private IEnumerator WaitForPositionAndRotationToMatch(int ticksToWait)
                 $"Authority ({m_AuthoritativeTransform.transform.rotation.eulerAngles}) Non-Authority ({m_NonAuthoritativeTransform.transform.rotation.eulerAngles})");
         }
 
-        [UnityTest]
-        public IEnumerator NetworkTransformMultipleChangesOverTime([Values] TransformSpace testLocalTransform, [Values] OverrideState overideState)
+        private IEnumerator WaitForNextTick()
         {
-            var overrideUpdate = overideState == OverrideState.CommitToTransform;
-            m_AuthoritativeTransform.InLocalSpace = testLocalTransform == TransformSpace.Local;
-
-            // Wait for tick to change (so we start close to the beginning the next tick)
             var currentTick = m_AuthoritativeTransform.NetworkManager.LocalTime.Tick;
             while (m_AuthoritativeTransform.NetworkManager.LocalTime.Tick == currentTick)
             {
                 yield return null;
             }
+        }
+
+        [UnityTest]
+        public IEnumerator NetworkTransformMultipleChangesOverTime([Values] TransformSpace testLocalTransform, [Values] OverrideState overideState)
+        {
+            var overrideUpdate = overideState == OverrideState.CommitToTransform;
+            m_AuthoritativeTransform.InLocalSpace = testLocalTransform == TransformSpace.Local;
 
             var positionStart = new Vector3(1.0f, 0.5f, 2.0f);
             var rotationStart = new Vector3(0.0f, 45.0f, 0.0f);
             var position = positionStart;
             var rotation = rotationStart;
+
             // Move and rotate within the same tick, validate the non-authoritative instance updates
             // to each set of changes.  Repeat several times.
             for (int i = 1; i < m_PositionRotationIterations + 1; i++)
             {
                 position = positionStart * i;
                 rotation = rotationStart * i;
+                // Wait for tick to change so we cam start close to the beginning the next tick in order
+                // to apply both deltas within the same tick period.
+                yield return WaitForNextTick();
+
+                // Apply deltas
                 MoveAndRotateAuthority(position, rotation);
+
+                // Wait for deltas to synchronize on non-authoritative side
                 yield return WaitForPositionAndRotationToMatch(4);
             }
 
@@ -211,23 +225,35 @@ public IEnumerator NetworkTransformMultipleChangesOverTime([Values] TransformSpa
             {
                 position = positionStart * i;
                 rotation = rotationStart * i;
+                // Wait for tick to change so we cam start close to the beginning the next tick in order
+                // to apply both deltas within the same tick period.
+                yield return WaitForNextTick();
+
                 MoveAndRotateAuthority(position, rotation);
                 yield return WaitForPositionAndRotationToMatch(4);
             }
 
+            // Wait for tick to change so we cam start close to the beginning the next tick in order
+            // to apply as many deltas within the same tick period as we can (if not all)
+            yield return WaitForNextTick();
+
             // Move and rotate within the same tick several times, then validate the non-authoritative
             // instance updates to the authoritative instance's final position and rotation.
             for (int i = 1; i < m_PositionRotationIterations + 1; i++)
             {
                 position = positionStart * i;
                 rotation = rotationStart * i;
-                MoveAndRotateAuthority(position, rotation);
 
+                MoveAndRotateAuthority(position, rotation);
             }
 
             yield return WaitForPositionAndRotationToMatch(1);
 
-            // Repeat this in the opposite direction
+            // Wait for tick to change so we cam start close to the beginning the next tick in order
+            // to apply as many deltas within the same tick period as we can (if not all)
+            yield return WaitForNextTick();
+
+            // Repeat this in the opposite direction and rotation
             for (int i = -1; i > -1 * (m_PositionRotationIterations + 1); i--)
             {
                 position = positionStart * i;
@@ -237,8 +263,6 @@ public IEnumerator NetworkTransformMultipleChangesOverTime([Values] TransformSpa
             yield return WaitForPositionAndRotationToMatch(1);
         }
 
-
-
         /// <summary>
         /// Tests changing all axial values one at a time.
         /// These tests are performed: