BGC.StateMachine.StateMachine< TBoolEnum, TTriggerEnum > Class Template Reference

Implements a state machine that can be constructed programatically that is similar to the Unity animation state machine but not frame capped. More...

Inheritance diagram for BGC.StateMachine.StateMachine< TBoolEnum, TTriggerEnum >:

Collaboration diagram for BGC.StateMachine.StateMachine< TBoolEnum, TTriggerEnum >:

Public Member Functions
	StateMachine (bool verbose=false)
	Construct a StateMachine. Verbose dumps state transition information to UnityEngine.Log More...
void	AddState (State state)
	Add a state to the state machine More...
void	AddState (TriggeringState< TTriggerEnum > state)
void	AddState (CoordinatingState< TBoolEnum, TTriggerEnum > state)
	Add a coordinating state to the state machine More...
void	AddEntryState (State state)
	Add a state to the StateMachine and sets it as the initial State More...
void	AddEntryState (CoordinatingState< TBoolEnum, TTriggerEnum > state)
	Add a coordinate state to the state machine that is the initial state More...
void	AddTransition (State fromState, State targetState, params TransitionCondition< TBoolEnum, TTriggerEnum >[] conditions)
	Add a Standard Transition between two States More...
void	AddAnyStateTransition (State targetState, params TransitionCondition< TBoolEnum, TTriggerEnum >[] conditions)
	Add a Transition that can occur from any state More...
void	AddBool (TBoolEnum key, bool initialValue)
	Add a boolean that can affect transitions More...
void	ActivateTriggerImmediate (TTriggerEnum key)
	Activate a trigger to move the state machine forward. Initiate a transition check if transitions aren't blocked. More...
void	ActivateTriggerDeferred (TTriggerEnum key)
	Activate a trigger to move the state machine forward. Relies upon the eventual calling of either an Update or an Immediate call. More...
void	SetBoolImmediate (TBoolEnum key, bool value)
	Set a boolean that can affect transitions. Initiate a transition check if transitions aren't blocked. More...
void	SetBoolDeferred (TBoolEnum key, bool value)
	Set a boolean that can affect transitions. Relies upon the eventual calling of either an Update or an Immediate call. More...
void	Update ()
	Call update function on the currently active state. More...
void	Start ()
	Run the first state of the state machine More...
void	Reset (bool restartStateMachine=false)
	Reset the state machine by exiting the current state and setting the state to the entry state. If restartStateMachine is set to true then entry state will be entered and the StateMachine will have effectively restarted More...
TriggerCondition< TBoolEnum, TTriggerEnum >	CreateTriggerCondition (TTriggerEnum key)
BoolCondition< TBoolEnum, TTriggerEnum >	CreateBoolCondition (TBoolEnum key, bool value)
OrConjunction< TBoolEnum, TTriggerEnum >	CreateOrConjunction (params TransitionCondition< TBoolEnum, TTriggerEnum >[] conditions)

Properties
State	CurrentState [get, private set]
	Get the name of the current State that the StateMachine is in More...

Private Member Functions
Transition< TBoolEnum, TTriggerEnum >	CheckTransitions ()
	Test to see if there is a valid transitions and return it, or null. Clears the dirtyTransitionState flag. More...
void	ExecuteTransitions ()
	Run transitions as long as we have a valid one to perform next. Blocks immediate transitions from occuring. More...
void IStateTrigger< TTriggerEnum >.	ActivateTrigger (TTriggerEnum key)
bool IStateTrigger< TTriggerEnum >.	GetTrigger (TTriggerEnum key)
void IStateDataBool< TBoolEnum >.	SetBool (TBoolEnum key, bool value)
bool IStateDataBool< TBoolEnum >.	GetBool (TBoolEnum key)
bool ITransitionDataRetriever< TBoolEnum, TTriggerEnum >.	GetBool (TBoolEnum key)
bool ITransitionDataRetriever< TBoolEnum, TTriggerEnum >.	GetTrigger (TTriggerEnum key)
void ITransitionDataRetriever< TBoolEnum, TTriggerEnum >.	ConsumeTrigger (TTriggerEnum key)
void	Log (string str)
	Log the string if verbose More...

Private Attributes
readonly Dictionary< State, List< Transition< TBoolEnum, TTriggerEnum > > >	stateTransitions
readonly List< Transition< TBoolEnum, TTriggerEnum > >	anyStateTransitions
readonly StateData< TBoolEnum, TTriggerEnum >	stateData
readonly bool	verbose
State	entryState = null
bool	running = false
bool	dirtyTransitionState = false
bool	blockTransitions = false

Detailed Description

Implements a state machine that can be constructed programatically that is similar to the Unity animation state machine but not frame capped.

To use the update function, put the Update call in a MonoBehavior class Update call.

Type Constraints

TBoolEnum	:	Enum
TTriggerEnum	:	Enum

Definition at line 14 of file StateMachine.cs.

Constructor & Destructor Documentation

StateMachine()

BGC.StateMachine.StateMachine< TBoolEnum, TTriggerEnum >.StateMachine ( bool  verbose = false )

inline

Construct a StateMachine. Verbose dumps state transition information to UnityEngine.Log

Definition at line 42 of file StateMachine.cs.

        {
            this.verbose = verbose;
            stateData = new StateData<TBoolEnum, TTriggerEnum>();
            stateTransitions = new Dictionary<State, List<Transition<TBoolEnum, TTriggerEnum>>>();
            anyStateTransitions = new List<Transition<TBoolEnum, TTriggerEnum>>();
        }

Member Function Documentation

ActivateTrigger()

void IStateTrigger<TTriggerEnum>. BGC.StateMachine.StateMachine< TBoolEnum, TTriggerEnum >.ActivateTrigger ( TTriggerEnum  key )

private

Implements BGC.StateMachine.IStateTrigger< TTriggerEnum >.

ActivateTriggerDeferred()

void BGC.StateMachine.StateMachine< TBoolEnum, TTriggerEnum >.ActivateTriggerDeferred ( TTriggerEnum  key )

inline

Activate a trigger to move the state machine forward. Relies upon the eventual calling of either an Update or an Immediate call.

Definition at line 186 of file StateMachine.cs.

        {
            Debug.Assert(running,
                "Activating Triggers when the StateMachine is not running will accomplish nothing");

            stateData.ActivateTrigger(key);
            dirtyTransitionState = true;
        }

ActivateTriggerImmediate()

void BGC.StateMachine.StateMachine< TBoolEnum, TTriggerEnum >.ActivateTriggerImmediate ( TTriggerEnum  key )

inline

Activate a trigger to move the state machine forward. Initiate a transition check if transitions aren't blocked.

Definition at line 165 of file StateMachine.cs.

        {
            Debug.Assert(running,
                "Activating Triggers when the StateMachine is not running will accomplish nothing");

            stateData.ActivateTrigger(key);

            if (!blockTransitions)
            {
                ExecuteTransitions();
            }
            else
            {
                dirtyTransitionState = true;
            }
        }

AddAnyStateTransition()

void BGC.StateMachine.StateMachine< TBoolEnum, TTriggerEnum >.AddAnyStateTransition ( State  targetState, params TransitionCondition< TBoolEnum, TTriggerEnum > []  conditions  )

inline

Add a Transition that can occur from any state

Definition at line 145 of file StateMachine.cs.

References BGC.StateMachine.Transition< TBoolEnum, TTriggerEnum >.SetStateDataRetrievers().

        {
            Transition<TBoolEnum, TTriggerEnum> transition = new Transition<TBoolEnum, TTriggerEnum>(targetState, conditions);
            transition.SetStateDataRetrievers(this);
            anyStateTransitions.Add(transition);
        }

Here is the call graph for this function:

AddBool()

void BGC.StateMachine.StateMachine< TBoolEnum, TTriggerEnum >.AddBool	(	TBoolEnum	key,
		bool	initialValue
	)

Add a boolean that can affect transitions

AddEntryState() [1/2]

void BGC.StateMachine.StateMachine< TBoolEnum, TTriggerEnum >.AddEntryState ( State  state )

inline

Add a state to the StateMachine and sets it as the initial State

Definition at line 91 of file StateMachine.cs.

        {
            if (entryState != null)
            {
                throw new ArgumentException(
                    message: $"{state.Name} cannot be made the entry state because " +
                        $"{entryState} was already defined as the entry state.",
                    paramName: nameof(entryState));
            }

            AddState(state);
            entryState = state;
        }

AddEntryState() [2/2]

void BGC.StateMachine.StateMachine< TBoolEnum, TTriggerEnum >.AddEntryState ( CoordinatingState< TBoolEnum, TTriggerEnum >  state )

inline

Add a coordinate state to the state machine that is the initial state

Parameters

state

Definition at line 109 of file StateMachine.cs.

        {
            if (entryState != null)
            {
                throw new ArgumentException(
                    message: $"{state.Name} cannot be made the entry state because " +
                        $"{entryState} was already defined as the entry state.",
                    paramName: nameof(entryState));
            }

            AddState(state);
            entryState = state;
        }

AddState() [1/3]

void BGC.StateMachine.StateMachine< TBoolEnum, TTriggerEnum >.AddState ( State  state )

inline

Add a state to the state machine

Definition at line 53 of file StateMachine.cs.

References BGC.StateMachine.State.SetVerbose().

        {
            if (state is CoordinatingState<TBoolEnum, TTriggerEnum> coordinatingState)
            {
                AddState(coordinatingState);
            }
            else if (state is TriggeringState<TTriggerEnum> triggeringState)
            {
                AddState(triggeringState);
            }
            else
            {
                state.SetVerbose(verbose);
                stateTransitions.Add(state, new List<Transition<TBoolEnum, TTriggerEnum>>());
            }
        }

Here is the call graph for this function:

AddState() [2/3]

void BGC.StateMachine.StateMachine< TBoolEnum, TTriggerEnum >.AddState ( TriggeringState< TTriggerEnum >  state )

inline

Definition at line 70 of file StateMachine.cs.

References BGC.StateMachine.TriggeringState< TTriggerEnum >.SetStateMachineFunctions(), and BGC.StateMachine.State.SetVerbose().

        {
            state.SetStateMachineFunctions(this);
            state.SetVerbose(verbose);
            stateTransitions.Add(state, new List<Transition<TBoolEnum, TTriggerEnum>>());
        }

Here is the call graph for this function:

AddState() [3/3]

void BGC.StateMachine.StateMachine< TBoolEnum, TTriggerEnum >.AddState ( CoordinatingState< TBoolEnum, TTriggerEnum >  state )

inline

Add a coordinating state to the state machine

Parameters

state

Definition at line 81 of file StateMachine.cs.

References BGC.StateMachine.CoordinatingState< TBoolEnum, TTriggerEnum >.SetStateMachineFunctions(), and BGC.StateMachine.State.SetVerbose().

        {
            state.SetStateMachineFunctions(this, this);
            state.SetVerbose(verbose);
            stateTransitions.Add(state, new List<Transition<TBoolEnum, TTriggerEnum>>());
        }

Here is the call graph for this function:

AddTransition()

void BGC.StateMachine.StateMachine< TBoolEnum, TTriggerEnum >.AddTransition ( State  fromState, State  targetState, params TransitionCondition< TBoolEnum, TTriggerEnum > []  conditions  )

inline

Add a Standard Transition between two States

Definition at line 126 of file StateMachine.cs.

References BGC.StateMachine.Transition< TBoolEnum, TTriggerEnum >.SetStateDataRetrievers().

        {
            if (fromState == null)
            {
                throw new ArgumentNullException(nameof(fromState),
                    message: "Cannot add a transition that has an empty state");
            }

            Transition<TBoolEnum, TTriggerEnum> transition = new Transition<TBoolEnum, TTriggerEnum>(targetState, conditions);
            stateTransitions[fromState].Add(transition);
            transition.SetStateDataRetrievers(this);
        }

Here is the call graph for this function:

CheckTransitions()

Transition<TBoolEnum, TTriggerEnum> BGC.StateMachine.StateMachine< TBoolEnum, TTriggerEnum >.CheckTransitions ( )

inlineprivate

Test to see if there is a valid transitions and return it, or null. Clears the dirtyTransitionState flag.

Definition at line 319 of file StateMachine.cs.

        {
            dirtyTransitionState = false;

            //Check AnyState Transitions First
            for (int i = 0; i < anyStateTransitions.Count; ++i)
            {
                if (anyStateTransitions[i].ShouldTransition())
                {
                    return anyStateTransitions[i];
                }
            }

            //Check State Transitions Next
            for (int i = 0; i < stateTransitions[CurrentState].Count; ++i)
            {
                if (stateTransitions[CurrentState][i].ShouldTransition())
                {
                    return stateTransitions[CurrentState][i];
                }
            }

            //No valid Transition found
            return null;
        }

ConsumeTrigger()

void ITransitionDataRetriever<TBoolEnum, TTriggerEnum>. BGC.StateMachine.StateMachine< TBoolEnum, TTriggerEnum >.ConsumeTrigger ( TTriggerEnum  key )

private

Implements BGC.StateMachine.ITransitionDataRetriever< TBoolEnum, TTriggerEnum >.

CreateBoolCondition()

BoolCondition<TBoolEnum, TTriggerEnum> BGC.StateMachine.StateMachine< TBoolEnum, TTriggerEnum >.CreateBoolCondition ( TBoolEnum  key, bool  value  )

inline

Definition at line 389 of file StateMachine.cs.

        {
            return new BoolCondition<TBoolEnum, TTriggerEnum>(key, value);
        }

CreateOrConjunction()

OrConjunction<TBoolEnum, TTriggerEnum> BGC.StateMachine.StateMachine< TBoolEnum, TTriggerEnum >.CreateOrConjunction ( params TransitionCondition< TBoolEnum, TTriggerEnum > []  conditions )

inline

Definition at line 394 of file StateMachine.cs.

        {
            return new OrConjunction<TBoolEnum, TTriggerEnum>(conditions);
        }

CreateTriggerCondition()

TriggerCondition<TBoolEnum, TTriggerEnum> BGC.StateMachine.StateMachine< TBoolEnum, TTriggerEnum >.CreateTriggerCondition ( TTriggerEnum  key )

inline

Definition at line 384 of file StateMachine.cs.

        {
            return new TriggerCondition<TBoolEnum, TTriggerEnum>(key);
        }

ExecuteTransitions()

void BGC.StateMachine.StateMachine< TBoolEnum, TTriggerEnum >.ExecuteTransitions ( )

inlineprivate

Run transitions as long as we have a valid one to perform next. Blocks immediate transitions from occuring.

Definition at line 349 of file StateMachine.cs.

References BGC.StateMachine.IStateTrigger< TTriggerEnum >.ActivateTrigger(), BGC.StateMachine.ITransitionDataRetriever< TBoolEnum, TTriggerEnum >.ConsumeTrigger(), BGC.StateMachine.IStateDataBool< TBoolEnum >.GetBool(), BGC.StateMachine.ITransitionDataRetriever< TBoolEnum, TTriggerEnum >.GetBool(), BGC.StateMachine.IStateTrigger< TTriggerEnum >.GetTrigger(), BGC.StateMachine.ITransitionDataRetriever< TBoolEnum, TTriggerEnum >.GetTrigger(), BGC.StateMachine.State.OnEnter(), BGC.StateMachine.Transition< TBoolEnum, TTriggerEnum >.OnTransition(), BGC.StateMachine.IStateDataBool< TBoolEnum >.SetBool(), and BGC.StateMachine.Transition< TBoolEnum, TTriggerEnum >.TargetState.

        {
            blockTransitions = true;

            Transition<TBoolEnum, TTriggerEnum> transition;

            while ((transition = CheckTransitions()) != null)
            {
                transition.OnTransition();
                CurrentState.OnExit();
                CurrentState = transition.TargetState;
                CurrentState.OnEnter();
            }

            blockTransitions = false;
        }

Here is the call graph for this function:

GetBool() [1/2]

bool IStateDataBool<TBoolEnum>. BGC.StateMachine.StateMachine< TBoolEnum, TTriggerEnum >.GetBool ( TBoolEnum  key )

private

Implements BGC.StateMachine.IStateDataBool< TBoolEnum >.

GetBool() [2/2]

bool ITransitionDataRetriever<TBoolEnum, TTriggerEnum>. BGC.StateMachine.StateMachine< TBoolEnum, TTriggerEnum >.GetBool ( TBoolEnum  key )

private

Implements BGC.StateMachine.IStateDataBool< TBoolEnum >.

GetTrigger() [1/2]

bool IStateTrigger<TTriggerEnum>. BGC.StateMachine.StateMachine< TBoolEnum, TTriggerEnum >.GetTrigger ( TTriggerEnum  key )

private

Implements BGC.StateMachine.IStateTrigger< TTriggerEnum >.

GetTrigger() [2/2]

bool ITransitionDataRetriever<TBoolEnum, TTriggerEnum>. BGC.StateMachine.StateMachine< TBoolEnum, TTriggerEnum >.GetTrigger ( TTriggerEnum  key )

private

Implements BGC.StateMachine.IStateTrigger< TTriggerEnum >.

Log()

void BGC.StateMachine.StateMachine< TBoolEnum, TTriggerEnum >.Log ( string  str )

inlineprivate

Log the string if verbose

Definition at line 403 of file StateMachine.cs.

        {
            if (verbose)
            {
                Debug.Log(str);
            }
        }

Reset()

void BGC.StateMachine.StateMachine< TBoolEnum, TTriggerEnum >.Reset ( bool  restartStateMachine = false )

inline

Reset the state machine by exiting the current state and setting the state to the entry state. If restartStateMachine is set to true then entry state will be entered and the StateMachine will have effectively restarted

Definition at line 294 of file StateMachine.cs.

        {
            if (running)
            {
                //Prevent escape of current state
                blockTransitions = true;
                CurrentState.OnExit();
                blockTransitions = false;
            }

            CurrentState = null;
            running = false;
            dirtyTransitionState = false;
            stateData.Clear();

            if (restartStateMachine)
            {
                Start();
            }
        }

SetBool()

void IStateDataBool<TBoolEnum>. BGC.StateMachine.StateMachine< TBoolEnum, TTriggerEnum >.SetBool ( TBoolEnum  key, bool  value  )

private

Implements BGC.StateMachine.IStateDataBool< TBoolEnum >.

SetBoolDeferred()

void BGC.StateMachine.StateMachine< TBoolEnum, TTriggerEnum >.SetBoolDeferred ( TBoolEnum  key, bool  value  )

inline

Set a boolean that can affect transitions. Relies upon the eventual calling of either an Update or an Immediate call.

Definition at line 220 of file StateMachine.cs.

        {
            Debug.Assert(running,
                "Setting boolean values when the StateMachine is not running will accomplish nothing");

            stateData.SetBoolean(key, value);
            dirtyTransitionState = true;
        }

SetBoolImmediate()

void BGC.StateMachine.StateMachine< TBoolEnum, TTriggerEnum >.SetBoolImmediate ( TBoolEnum  key, bool  value  )

inline

Set a boolean that can affect transitions. Initiate a transition check if transitions aren't blocked.

Definition at line 199 of file StateMachine.cs.

        {
            Debug.Assert(running, 
                "Setting boolean values when the StateMachine is not running will accomplish nothing");

            stateData.SetBoolean(key, value);

            if (!blockTransitions)
            {
                ExecuteTransitions();
            }
            else
            {
                dirtyTransitionState = true;
            }
        }

Start()

void BGC.StateMachine.StateMachine< TBoolEnum, TTriggerEnum >.Start ( )

inline

Run the first state of the state machine

Definition at line 265 of file StateMachine.cs.

        {
            if (entryState == null)
            {
                throw new InvalidOperationException("State machine must have an entry state defined to start.");
            }

            CurrentState = entryState;
            running = true;
            dirtyTransitionState = false;
            stateData.Initialize();

            //Block transitions during OnEnter
            {
                blockTransitions = true;
                entryState.OnEnter();
                blockTransitions = false;
            }

            //Execute any transitions
            ExecuteTransitions();
        }

Update()

void BGC.StateMachine.StateMachine< TBoolEnum, TTriggerEnum >.Update ( )

inline

Call update function on the currently active state.

Definition at line 232 of file StateMachine.cs.

References BGC.StateMachine.State.OnEnter().

        {
            if (!running)
            {
                return;
            }

            //Pre-Update check for Transitions
            if (dirtyTransitionState)
            {
                ExecuteTransitions();
            }

            //Block mid-update transitions
            {
                blockTransitions = true;
                //Update current state
                CurrentState.Update();
                blockTransitions = false;
            }

            //Post-Update check for Transitions
            if (dirtyTransitionState)
            {
                ExecuteTransitions();
            }
        }

Here is the call graph for this function:

Field Documentation

anyStateTransitions

readonly List<Transition<TBoolEnum, TTriggerEnum> > BGC.StateMachine.StateMachine< TBoolEnum, TTriggerEnum >.anyStateTransitions

private

Definition at line 22 of file StateMachine.cs.

blockTransitions

bool BGC.StateMachine.StateMachine< TBoolEnum, TTriggerEnum >.blockTransitions = false

private

Definition at line 30 of file StateMachine.cs.

dirtyTransitionState

bool BGC.StateMachine.StateMachine< TBoolEnum, TTriggerEnum >.dirtyTransitionState = false

private

Definition at line 29 of file StateMachine.cs.

entryState

State BGC.StateMachine.StateMachine< TBoolEnum, TTriggerEnum >.entryState = null

private

Definition at line 26 of file StateMachine.cs.

running

bool BGC.StateMachine.StateMachine< TBoolEnum, TTriggerEnum >.running = false

private

Definition at line 28 of file StateMachine.cs.

stateData

readonly StateData<TBoolEnum, TTriggerEnum> BGC.StateMachine.StateMachine< TBoolEnum, TTriggerEnum >.stateData

private

Definition at line 23 of file StateMachine.cs.

stateTransitions

readonly Dictionary<State, List<Transition<TBoolEnum, TTriggerEnum> > > BGC.StateMachine.StateMachine< TBoolEnum, TTriggerEnum >.stateTransitions

private

Definition at line 21 of file StateMachine.cs.

verbose

readonly bool BGC.StateMachine.StateMachine< TBoolEnum, TTriggerEnum >.verbose

private

Definition at line 24 of file StateMachine.cs.

Property Documentation

CurrentState

State BGC.StateMachine.StateMachine< TBoolEnum, TTriggerEnum >.CurrentState

getprivate set

Get the name of the current State that the StateMachine is in

Definition at line 35 of file StateMachine.cs.

---

The documentation for this class was generated from the following file:

• StateMachine/StateMachine.cs