advanceAndApply() never settles after hitting max iterations (60 fps with nothing changing) #664

--- a/runtime/src/animation/state_machine_instance.cpp
+++ b/runtime/src/animation/state_machine_instance.cpp
@@ -230,6 +230,8 @@ public:
         }
         m_currentState->advance(seconds, m_stateMachineInstance);
         updateMix(seconds);
+        m_settledInCycle = false;
+        m_cycleIsOpaque = false;
 
         if (m_stateFrom != nullptr && m_mix < 1.0f && !m_holdAnimationFrom)
         {
@@ -249,6 +251,13 @@ public:
 
             if (i == maxIterations)
             {
+                // The layer is cycling through zero-duration transitions whose
+                // conditions stay true. When the cycle has no side effect the
+                // host can observe (no event, no listener action, no random
+                // pick, no spilled time, no scripted condition), re-running it
+                // next frame yields the same result: let the layer settle until
+                // an input, a view model property or a pointer wakes it.
+                m_settledInCycle = !m_cycleIsOpaque;
                 auto stateMachineName =
                     m_stateMachineInstance->stateMachine() == nullptr
                         ? "[SM Not found]"
@@ -323,6 +332,10 @@ public:
 
     bool updateState()
     {
+        if (m_settledInCycle)
+        {
+            return false;
+        }
         // Don't allow changing state while a transition is taking place
         // (we're mixing one state onto another) if enableEarlyExit is not true.
         if (isTransitioning() && !m_transition->enableEarlyExit())
@@ -347,6 +360,7 @@ public:
         {
             if (event->occurs() == occurs)
             {
+                m_cycleIsOpaque = true;
                 event->perform(m_stateMachineInstance);
             }
         }
@@ -360,6 +374,7 @@ public:
         {
             if (action->matchesScheduledOccurrence(occurs))
             {
+                m_cycleIsOpaque = true;
                 action->perform(m_stateMachineInstance,
                                 ListenerInvocation::none());
             }
@@ -409,6 +424,19 @@ public:
         return;
     }
 
+    // A scripted condition can change its answer without any input changing,
+    // so a cycle that evaluates one is never treated as settled.
+    void markOpaqueConditions(const StateTransition* transition)
+    {
+        for (size_t c = 0; c < transition->conditionCount(); c++)
+        {
+            if (transition->condition(c)->is<ScriptedTransitionCondition>())
+            {
+                m_cycleIsOpaque = true;
+            }
+        }
+    }
+
     StateTransition* findRandomTransition(StateInstance* stateFromInstance)
     {
         uint32_t totalWeight = 0;
@@ -420,6 +448,7 @@ public:
             if (canChangeState(transition->stateTo()))
             {
 
+                markOpaqueConditions(transition);
                 auto allowed = transition->allowed(stateFromInstance,
                                                    m_stateMachineInstance,
                                                    this);
@@ -456,6 +485,7 @@ public:
                     (double)transition->evaluatedRandomWeight();
                 if (currentWeight + transitionWeight > randomWeight)
                 {
+                    m_cycleIsOpaque = true;
                     transition->useLayerInConditions(m_stateMachineInstance,
                                                      this);
                     return transition;
@@ -484,6 +514,7 @@ public:
             if (canChangeState(transition->stateTo()))
             {
 
+                markOpaqueConditions(transition);
                 auto allowed = transition->allowed(stateFromInstance,
                                                    m_stateMachineInstance,
                                                    this);
@@ -619,6 +650,10 @@ public:
                         advanceTime = instance->spilledTime();
                     }
                 }
+                if (advanceTime != 0.0f)
+                {
+                    m_cycleIsOpaque = true;
+                }
                 m_currentState->advance(advanceTime, m_stateMachineInstance);
             }
             m_mix = 0.0f;
@@ -705,6 +740,10 @@ private:
     bool m_stateMachineChangedOnAdvance = false;
 
     bool m_waitingForExit = false;
+    /// The layer hit maxIterations this frame on a cycle without observable
+    /// side effects; updateState() stops re-entering it until next advance.
+    bool m_settledInCycle = false;
+    bool m_cycleIsOpaque = false;
     /// Used to ensure a specific animation is applied on the next apply.
     const LinearAnimation* m_holdAnimation = nullptr;
     float m_holdTime = 0.0f;