fix: late-joining client cross-fades when not on the originating state

A late-joining client starts in its default state, so requiring the originating state left it stuck there. Adds a runtime test that joins mid-transition from a non-default state.

Author: NoelStephensUnity

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

@@ -1572,8 +1572,9 @@ private void UpdateAnimationState(AnimationState animationState)
                 {
                     if (TryGetTransitionInfo(animationState.Layer, animationState.DestinationStateHash, animationState.StateHash, out var transitionInfo))
                     {
-                        // Make sure we are on the originating/starting state we are going to cross-fade into
-                        if (currentState.shortNameHash == animationState.StateHash)
+                        // A late-joining client starts in its default state, which may not be the originating state,
+                        // so it cross-fades from whatever state it is in unless it is already mid-transition
+                        if (currentState.shortNameHash == animationState.StateHash || !m_Animator.IsInTransition(animationState.Layer))
                         {
                             // Cross-fade from the current to the destination state for the transitions duration while starting at the server's current normalized time of the transition
                             m_Animator.CrossFade(transitionInfo.DestinationState, transitionInfo.TransitionDuration, transitionInfo.Layer, 0.0f, animationState.NormalizedTime);

com.unity.netcode.gameobjects/Tests/Runtime/Components/NetworkAnimatorLateJoinTransitionTests.cs

@@ -0,0 +1,116 @@
+#if COM_UNITY_MODULES_ANIMATION && UNITY_EDITOR
+using System.Collections;
+using System.Text;
+using Unity.Netcode.Components;
+using Unity.Netcode.TestHelpers.Runtime;
+using UnityEditor;
+using UnityEditor.Animations;
+using UnityEngine;
+using UnityEngine.TestTools;
+
+namespace Unity.Netcode.RuntimeTests
+{
+    /// <summary>
+    /// Verifies a client that joins while the authority is mid-transition from a state other than
+    /// the controller's default state still cross-fades into the transition's destination state.
+    /// </summary>
+    internal class NetworkAnimatorLateJoinTransitionTests : NetcodeIntegrationTest
+    {
+        private const string k_ControllerPath = "Assets/NetworkAnimatorLateJoinTransitionTest.controller";
+        private const string k_TriggerName = "ToB";
+
+        protected override int NumberOfClients => 1;
+
+        private AnimatorController m_Controller;
+        private AnimatorState m_DefaultState;
+        private AnimatorState m_SourceState;
+        private AnimatorState m_DestinationState;
+        private GameObject m_Prefab;
+
+        protected override void OnServerAndClientsCreated()
+        {
+            m_Controller = AnimatorController.CreateAnimatorControllerAtPath(k_ControllerPath);
+            m_Controller.AddParameter(k_TriggerName, AnimatorControllerParameterType.Trigger);
+
+            var rootStateMachine = m_Controller.layers[0].stateMachine;
+            m_DefaultState = rootStateMachine.AddState("State A");
+            m_SourceState = rootStateMachine.AddState("State C");
+            m_DestinationState = rootStateMachine.AddState("State B");
+            rootStateMachine.defaultState = m_DefaultState;
+
+            // Both states transition into the same destination, and the transitions are long enough to still be running when the client joins
+            foreach (var state in new[] { m_DefaultState, m_SourceState })
+            {
+                var transition = state.AddTransition(m_DestinationState);
+                transition.hasExitTime = false;
+                transition.duration = 10.0f;
+                transition.AddCondition(AnimatorConditionMode.If, 0.0f, k_TriggerName);
+            }
+            AssetDatabase.SaveAssets();
+
+            m_Prefab = CreateNetworkObjectPrefab("Animated");
+            var animator = m_Prefab.AddComponent<Animator>();
+            animator.runtimeAnimatorController = m_Controller;
+            var networkAnimator = m_Prefab.AddComponent<TestNetworkAnimator>();
+            networkAnimator.Animator = animator;
+            networkAnimator.AnimatorParameterEntries = new NetworkAnimator.AnimatorParametersListContainer();
+            networkAnimator.InvokeOnValidate();
+            networkAnimator.OnAfterDeserialize();
+
+            base.OnServerAndClientsCreated();
+        }
+
+        protected override IEnumerator OnTearDown()
+        {
+            AssetDatabase.DeleteAsset(k_ControllerPath);
+            yield return base.OnTearDown();
+        }
+
+        [UnityTest]
+        public IEnumerator LateJoinFromNonDefaultStateCrossFadesToDestination()
+        {
+            var authority = GetAuthorityNetworkManager();
+            var authorityInstance = SpawnObject(m_Prefab, authority).GetComponent<NetworkObject>();
+            var authorityAnimator = authorityInstance.GetComponent<Animator>();
+
+            authorityAnimator.Play(m_SourceState.nameHash, 0);
+            yield return WaitForConditionOrTimeOut(_ => authorityAnimator.GetCurrentAnimatorStateInfo(0).shortNameHash == m_SourceState.nameHash);
+            AssertOnTimeout($"Authority did not enter {m_SourceState.name}!");
+
+            authorityAnimator.SetTrigger(k_TriggerName);
+            yield return WaitForConditionOrTimeOut(_ => authorityAnimator.IsInTransition(0) &&
+                authorityAnimator.GetNextAnimatorStateInfo(0).shortNameHash == m_DestinationState.nameHash);
+            AssertOnTimeout($"Authority did not start transitioning from {m_SourceState.name} to {m_DestinationState.name}!");
+
+            yield return CreateAndStartNewClient();
+            var lateJoinClient = m_ClientNetworkManagers[m_ClientNetworkManagers.Length - 1];
+
+            yield return WaitForConditionOrTimeOut(_ => lateJoinClient.SpawnManager.SpawnedObjects.ContainsKey(authorityInstance.NetworkObjectId));
+            AssertOnTimeout($"Late-joining client did not spawn {authorityInstance.name}!");
+            var clientAnimator = lateJoinClient.SpawnManager.SpawnedObjects[authorityInstance.NetworkObjectId].GetComponent<Animator>();
+
+            yield return WaitForConditionOrTimeOut(errorLog => ReachingDestination(clientAnimator, errorLog));
+            AssertOnTimeout($"Late-joining client did not cross-fade to {m_DestinationState.name}!");
+        }
+
+        private bool ReachingDestination(Animator animator, StringBuilder errorLog)
+        {
+            var current = animator.GetCurrentAnimatorStateInfo(0).shortNameHash;
+            if (current == m_DestinationState.nameHash || (animator.IsInTransition(0) && animator.GetNextAnimatorStateInfo(0).shortNameHash == m_DestinationState.nameHash))
+            {
+                return true;
+            }
+            errorLog.Append($"Client current state hash {current}, in transition: {animator.IsInTransition(0)}");
+            return false;
+        }
+
+        private class TestNetworkAnimator : NetworkAnimator
+        {
+            public void InvokeOnValidate()
+            {
+                base.OnValidate();
+            }
+        }
+    }
+}
+#endif

com.unity.netcode.gameobjects/Tests/Runtime/Components/NetworkAnimatorLateJoinTransitionTests.cs.meta

@@ -45,6 +45,11 @@
             "expression": "1.0.0-pre.7",
             "define": "MULTIPLAYER_TOOLS_1_0_0_PRE_7"
         },
+        {
+            "name": "com.unity.modules.animation",
+            "expression": "",
+            "define": "COM_UNITY_MODULES_ANIMATION"
+        },
         {
             "name": "com.unity.modules.physics",
             "expression": "",