Merge branch 'master' of https://github.com/UnterrainerInformatik/FiniteStateMachine into feature/builder

Conflicts:
	StateMachine/Fluent/Api/FluentImplementation.cs
	StateMachine/Transition.cs
	StateMachine/TransitionModel.cs

Author: Olard

MonoGameStateMachine/Api/BuilderFluent.cs

@@ -0,0 +1,66 @@
+// *************************************************************************** 
+// This is free and unencumbered software released into the public domain.
+// 
+// Anyone is free to copy, modify, publish, use, compile, sell, or
+// distribute this software, either in source code form or as a compiled
+// binary, for any purpose, commercial or non-commercial, and by any
+// means.
+// 
+// In jurisdictions that recognize copyright laws, the author or authors
+// of this software dedicate any and all copyright interest in the
+// software to the public domain. We make this dedication for the benefit
+// of the public at large and to the detriment of our heirs and
+// successors. We intend this dedication to be an overt act of
+// relinquishment in perpetuity of all present and future rights to this
+// software under copyright law.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+// IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+// OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+// 
+// For more information, please refer to <http://unlicense.org>
+// ***************************************************************************
+
+using JetBrains.Annotations;
+
+namespace MonoGameStateMachine.Api
+{
+    [PublicAPI]
+    public interface BuilderFluent<TS, TT, TD>
+    {
+        /// <summary>
+        ///     Enables the stack and turns this Finite-State-Machine (FSM) into a Stack-Based-FSM (SBFSM).<br />
+        ///     Beware that you will have to specify "ClearsStack()" on some of the states, as otherwise the stack will grow and
+        ///     never be cleared.
+        /// </summary>
+        BuilderFluent<TS, TT, TD> EnableStack();
+
+        /// <summary>
+        ///     Sets a global transition to a state.<br />
+        ///     This will generate a transision that will be triggered regardless of the current state's position in the graph and
+        ///     regardless of the transitions connected to that state.<p />
+        ///     Think of it as a 'catch all' transition.<br />
+        ///     Usually you would use such global transitions to reset a graph when ESC is pressed or something like that.
+        /// </summary>
+        /// <param name="state">The state the global transition should lead to.</param>
+        GlobalTransitionFluent<TS, TT, TD> GlobalTransitionTo(TS state);
+
+        /// <summary>
+        ///     Generates a new state.<br />
+        ///     An FSM can have multiple states connected via transitions.<br />
+        ///     Only a single transition is active at any given time and that transition will receive 'Update(TData)' calls and
+        ///     will be checked for transitions that may be triggered by an input, which, in turn, would activate the next state.
+        /// </summary>
+        /// <param name="state">The state.</param>
+        StateFluent<TS, TT, TD> State(TS state);
+
+        /// <summary>
+        ///     Builds this instance of an FSM (or SBFSM).
+        /// </summary>
+        Fsm<TS, TT> Build();
+    }
+}

MonoGameStateMachine/Api/FluentImplementation.cs

@@ -0,0 +1,155 @@
+// *************************************************************************** 
+// This is free and unencumbered software released into the public domain.
+// 
+// Anyone is free to copy, modify, publish, use, compile, sell, or
+// distribute this software, either in source code form or as a compiled
+// binary, for any purpose, commercial or non-commercial, and by any
+// means.
+// 
+// In jurisdictions that recognize copyright laws, the author or authors
+// of this software dedicate any and all copyright interest in the
+// software to the public domain. We make this dedication for the benefit
+// of the public at large and to the detriment of our heirs and
+// successors. We intend this dedication to be an overt act of
+// relinquishment in perpetuity of all present and future rights to this
+// software under copyright law.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+// IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+// OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+// 
+// For more information, please refer to <http://unlicense.org>
+// ***************************************************************************
+
+using System;
+using System.Collections.Generic;
+using Microsoft.Xna.Framework;
+using StateMachine.Events;
+
+namespace MonoGameStateMachine.Api
+{
+    public class FluentImplementation<TS, TT> : StateMachine.Fluent.Api.FluentImplementation<TS, TT, GameTime>,
+        TransitionStateFluent<TS, TT, GameTime>, GlobalTransitionBuilderFluent<TS, TT, GameTime>
+    {
+        public Dictionary<Tuple<TS, TS>, List<Timer<TS>>> AfterEntries { get; set; } = new Dictionary<Tuple<TS, TS>, List<Timer<TS>>>();
+        public List<Timer<TS>> GlobalAfterEntries { get; set; } = new List<Timer<TS>>();
+
+        public FluentImplementation(TS startState) : base(startState)
+        {
+        }
+
+        public new Fsm<TS, TT> Build()
+        {
+            base.Build();
+            var m = new Fsm<TS, TT>(FsmModel);
+            m.AfterEntries = AfterEntries;
+            m.GlobalAfterEntries = GlobalAfterEntries;
+            return m;
+        }
+
+        public TransitionStateFluent<TS, TT, GameTime> After(float amount, TimeUnit timeUnit)
+        {
+            List<Timer<TS>> l;
+            var key = currentTransition;
+            if (!AfterEntries.TryGetValue(key, out l))
+            {
+                l = new List<Timer<TS>>();
+                AfterEntries.Add(key, l);
+            }
+            l.Add(new Timer<TS>(key.Item2, amount, timeUnit));
+            return this;
+        }
+
+        public TransitionStateFluent<TS, TT, GameTime> AfterGlobal(float amount, TimeUnit timeUnit)
+        {
+            var key = currentGlobalTransition;
+            GlobalAfterEntries.Add(new Timer<TS>(key.Item1, amount, timeUnit));
+            return this;
+        }
+
+        public new StateFluent<TS, TT, GameTime> State(TS state)
+        {
+            base.State(state);
+            return this;
+        }
+
+        public new TransitionFluent<TS, TT, GameTime> TransitionTo(TS state)
+        {
+            base.TransitionTo(state);
+            return this;
+        }
+
+        public new TransitionFluent<TS, TT, GameTime> PopTransition()
+        {
+            base.PopTransition();
+            return this;
+        }
+
+        public new TransitionStateFluent<TS, TT, GameTime> On(TT trigger)
+        {
+            base.On(trigger);
+            return this;
+        }
+
+        public new TransitionStateFluent<TS, TT, GameTime> If(Func<IfArgs<TS>, bool> condition)
+        {
+            base.If(condition);
+            return this;
+        }
+
+        public new StateFluent<TS, TT, GameTime> OnEnter(
+            Action<StateChangeArgs<TS, TT, GameTime>> stateChangeArgs)
+        {
+            base.OnEnter(stateChangeArgs);
+            return this;
+        }
+
+        public new StateFluent<TS, TT, GameTime> OnExit(
+            Action<StateChangeArgs<TS, TT, GameTime>> stateChangeArgs)
+        {
+            base.OnExit(stateChangeArgs);
+            return this;
+        }
+
+        public new StateFluent<TS, TT, GameTime> Update(Action<UpdateArgs<TS, TT, GameTime>> updateArgs)
+        {
+            base.Update(updateArgs);
+            return this;
+        }
+
+        public new StateFluent<TS, TT, GameTime> ClearsStack()
+        {
+            base.ClearsStack();
+            return this;
+        }
+
+        public new BuilderFluent<TS, TT, GameTime> EnableStack()
+        {
+            base.EnableStack();
+            return this;
+        }
+
+        public new GlobalTransitionFluent<TS, TT, GameTime> GlobalTransitionTo(TS state)
+        {
+            base.GlobalTransitionTo(state);
+            return this;
+        }
+
+        public new GlobalTransitionBuilderFluent<TS, TT, GameTime> OnGlobal(TT trigger)
+        {
+            base.OnGlobal(trigger);
+            return this;
+        }
+
+        public new GlobalTransitionBuilderFluent<TS, TT, GameTime> IfGlobal(
+            Func<IfArgs<TS>, bool> condition)
+        {
+            base.IfGlobal(condition);
+            return this;
+        }
+    }
+}

MonoGameStateMachine/Api/GlobalTransitionBuilderFluent.cs

@@ -0,0 +1,37 @@
+// *************************************************************************** 
+// This is free and unencumbered software released into the public domain.
+// 
+// Anyone is free to copy, modify, publish, use, compile, sell, or
+// distribute this software, either in source code form or as a compiled
+// binary, for any purpose, commercial or non-commercial, and by any
+// means.
+// 
+// In jurisdictions that recognize copyright laws, the author or authors
+// of this software dedicate any and all copyright interest in the
+// software to the public domain. We make this dedication for the benefit
+// of the public at large and to the detriment of our heirs and
+// successors. We intend this dedication to be an overt act of
+// relinquishment in perpetuity of all present and future rights to this
+// software under copyright law.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+// IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+// OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+// 
+// For more information, please refer to <http://unlicense.org>
+// ***************************************************************************
+
+using JetBrains.Annotations;
+
+namespace MonoGameStateMachine.Api
+{
+    [PublicAPI]
+    public interface GlobalTransitionBuilderFluent<TS, TT, TD> :
+        GlobalTransitionFluent<TS, TT, TD>, BuilderFluent<TS, TT, TD>
+    {
+    }
+}

MonoGameStateMachine/Api/GlobalTransitionFluent.cs

@@ -0,0 +1,59 @@
+// *************************************************************************** 
+// This is free and unencumbered software released into the public domain.
+// 
+// Anyone is free to copy, modify, publish, use, compile, sell, or
+// distribute this software, either in source code form or as a compiled
+// binary, for any purpose, commercial or non-commercial, and by any
+// means.
+// 
+// In jurisdictions that recognize copyright laws, the author or authors
+// of this software dedicate any and all copyright interest in the
+// software to the public domain. We make this dedication for the benefit
+// of the public at large and to the detriment of our heirs and
+// successors. We intend this dedication to be an overt act of
+// relinquishment in perpetuity of all present and future rights to this
+// software under copyright law.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+// IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+// OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+// 
+// For more information, please refer to <http://unlicense.org>
+// ***************************************************************************
+
+using System;
+using JetBrains.Annotations;
+using StateMachine.Events;
+
+namespace MonoGameStateMachine.Api
+{
+    [PublicAPI]
+    public interface GlobalTransitionFluent<TS, TT, TD>
+    {
+        /// <summary>
+        ///     Specifies the trigger, that has to be served as input in order to walk the global transition you're currently
+        ///     describing.
+        /// </summary>
+        /// <param name="trigger">The trigger.</param>
+        GlobalTransitionBuilderFluent<TS, TT, TD> OnGlobal(TT trigger);
+
+        /// <summary>
+        ///     Specifies the condition, that has to be met, in addition to the trigger, to walk the global transition you're
+        ///     currently describing.
+        /// </summary>
+        /// <param name="condition">The condition.</param>
+        GlobalTransitionBuilderFluent<TS, TT, TD> IfGlobal(Func<IfArgs<TS>, bool> condition);
+
+        /// <summary>
+        ///     Automatically walks the transition you're currently describing, if the specified amount of time has passed.
+        /// </summary>
+        /// <param name="amount">The amount.</param>
+        /// <param name="timeUnit">The time unit.</param>
+        /// <returns></returns>
+        TransitionStateFluent<TS, TT, TD> AfterGlobal(float amount, TimeUnit timeUnit);
+    }
+}

MonoGameStateMachine/Api/StateFluent.cs

@@ -0,0 +1,73 @@
+// *************************************************************************** 
+// This is free and unencumbered software released into the public domain.
+// 
+// Anyone is free to copy, modify, publish, use, compile, sell, or
+// distribute this software, either in source code form or as a compiled
+// binary, for any purpose, commercial or non-commercial, and by any
+// means.
+// 
+// In jurisdictions that recognize copyright laws, the author or authors
+// of this software dedicate any and all copyright interest in the
+// software to the public domain. We make this dedication for the benefit
+// of the public at large and to the detriment of our heirs and
+// successors. We intend this dedication to be an overt act of
+// relinquishment in perpetuity of all present and future rights to this
+// software under copyright law.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+// IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+// OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+// 
+// For more information, please refer to <http://unlicense.org>
+// ***************************************************************************
+
+using System;
+using JetBrains.Annotations;
+using StateMachine.Events;
+
+namespace MonoGameStateMachine.Api
+{
+    [PublicAPI]
+    public interface StateFluent<TS, TT, TD> : BuilderFluent<TS, TT, TD>
+    {
+        /// <summary>
+        ///     Adds a new transition to the state, you currently describe.
+        /// </summary>
+        /// <param name="state">The state the transition will lead to.</param>
+        TransitionFluent<TS, TT, TD> TransitionTo(TS state);
+
+        /// <summary>
+        ///     Adding a transition that, being triggered, will result in the last state on the stack being popped and set to be
+        ///     the current one.<br />
+        ///     For this to work 'EnableStack' has to be set (this machine has to be a Stack-Based-FSM (SBFSM)).
+        /// </summary>
+        TransitionFluent<TS, TT, TD> PopTransition();
+
+        /// <summary>
+        ///     Called when the state, you currently describe, is entered.
+        /// </summary>
+        /// <param name="stateChangeArgs">The state change arguments.</param>
+        StateFluent<TS, TT, TD> OnEnter(Action<StateChangeArgs<TS, TT, TD>> stateChangeArgs);
+
+        /// <summary>
+        ///     Called when the state, you currently describe, is exited.
+        /// </summary>
+        /// <param name="stateChangeArgs">The state change arguments.</param>
+        StateFluent<TS, TT, TD> OnExit(Action<StateChangeArgs<TS, TT, TD>> stateChangeArgs);
+
+        /// <summary>
+        ///     Called when the FSM's 'Update(TData)' method is called and the state, you currently describe, is active.
+        /// </summary>
+        /// <param name="updateArgs">The update arguments.</param>
+        StateFluent<TS, TT, TD> Update(Action<UpdateArgs<TS, TT, TD>> updateArgs);
+
+        /// <summary>
+        ///     Clears the stack when the state, you currently describe, is entered.
+        /// </summary>
+        StateFluent<TS, TT, TD> ClearsStack();
+    }
+}