Resets local timers when entering a state.

Author: guFalcon

MonoGameStateMachine/Fsm.cs

@@ -61,6 +61,29 @@ public Fsm(State<TS, TT, GameTime> current, bool stackEnabled = false) : base(cu
             return new FluentImplementation<TS, TT>(startState);
         }
 
+        private void ResetCurrentAfterEntries()
+        {
+            foreach (var k in Current.Model.Transitions.Keys)
+            {
+                List<Timer<TS>> currentAfterEntries;
+                if (AfterEntries.TryGetValue(new Tuple<TS, TS>(Current.Identifier, k), out currentAfterEntries))
+                {
+                    for (int i = 0; i < currentAfterEntries.Count; i++)
+                    {
+                        Timer<TS> e = currentAfterEntries[i];
+                        e.Reset();
+                        currentAfterEntries[i] = e;
+                    }
+                }
+            }
+        }
+
+        protected override void Entered(StateChangeArgs<TS, TT, GameTime> args)
+        {
+            ResetCurrentAfterEntries();
+            base.Entered(args);
+        }
+
         public new void Update(GameTime gameTime)
         {
             // After-entries on transitions.
@@ -84,7 +107,7 @@ public Fsm(State<TS, TT, GameTime> current, bool stackEnabled = false) : base(cu
 
             Model.Current.RaiseUpdated(new UpdateArgs<TS, TT, GameTime>(this, Current, gameTime));
         }
-
+        
         private bool CheckAfterEntries(List<Timer<TS>> afterEntries,
             Dictionary<TS, Transition<TS, TT, GameTime>> transitions, GameTime g)
         {

MonoGameStateMachine/NUnitTests/FluentTests.cs

@@ -181,5 +181,28 @@ public void WhenMultipleAfterConditionsFireOnASingleUpdateOnEnterAndOnExitShoudF
             Assert.That(enterCount, Is.EqualTo(4));
             Assert.That(exitCount, Is.EqualTo(4));
         }
+
+        [Test]
+        [Category("MonoGameStateMachine.FluentTests")]
+        public void WhenAnAfterConditionDoesNotFiresAndATransitionHappensTheTimerIsResetOnReentry()
+        {
+            var m = Fsm<State, Trigger>.Builder(State.IDLE)
+                .State(State.IDLE)
+                    .TransitionTo(State.OVER).After(10, TimeUnit.MILLISECONDS)
+                    .TransitionTo(State.OVER).On(Trigger.MOUSE_CLICKED)
+                .State(State.OVER)
+                    .TransitionTo(State.IDLE).On(Trigger.MOUSE_CLICKED)
+                .Build();
+
+            Assert.That(m.Current.Identifier, Is.EqualTo(State.IDLE));
+            m.Update(new GameTime(TimeSpan.FromDays(1), TimeSpan.FromMilliseconds(5)));
+            Assert.That(m.Current.Identifier, Is.EqualTo(State.IDLE));
+            m.Trigger(Trigger.MOUSE_CLICKED);
+            Assert.That(m.Current.Identifier, Is.EqualTo(State.OVER));
+            m.Trigger(Trigger.MOUSE_CLICKED);
+            Assert.That(m.Current.Identifier, Is.EqualTo(State.IDLE));
+            m.Update(new GameTime(TimeSpan.FromDays(1), TimeSpan.FromMilliseconds(5)));
+            Assert.That(m.Current.Identifier, Is.EqualTo(State.IDLE));
+        }
     }
 }

MonoGameStateMachine/Timer.cs

@@ -46,7 +46,7 @@ public Timer(TS target, double value, TimeUnit unit)
             Reset();
         }
 
-        private void Reset()
+        public void Reset()
         {
             Time = Value * (long) Unit;
         }

StateMachine/Fsm.cs

@@ -153,12 +153,27 @@ protected void DoTransition(TS state, TT input, bool isPop)
             {
                 StateChangeArgs<TS, TT, TD> args =
                     new StateChangeArgs<TS, TT, TD>(this, old, Model.Current, input);
-                old.RaiseExited(args);
-                Model.Current.RaiseEntered(args);
-                Model.RaiseStateChanged(args);
+                Exited(old, args);
+                Entered(args);
+                StateChanged(args);
             }
         }
 
+        protected virtual void Entered(StateChangeArgs<TS, TT, TD> args)
+        {
+            Model.Current.RaiseEntered(args);
+        }
+
+        protected virtual void Exited(State<TS, TT, TD> old, StateChangeArgs<TS, TT, TD> args)
+        {
+            old.RaiseExited(args);
+        }
+
+        protected virtual void StateChanged(StateChangeArgs<TS, TT, TD> args)
+        {
+            Model.RaiseStateChanged(args);
+        }
+
         public void Trigger(TT input)
         {
             if (input == null) return;