public ForwardState(GameObject player,
IStateTransition stateTransition,
Behaviour behaviour,
float speed) : base(player, stateTransition, behaviour)
{
this.speed = speed;
}
/// <summary>
/// Creates a new edge based on the background logic transition.
/// </summary>
/// <param name="sourceState">The source state.</param>
/// <param name="targetState">The target state.</param>
/// <param name="transition">The background logic transition.</param>
public Edge(State sourceState, State targetState, IStateTransition transition)
: base(sourceState, targetState, ConnectionToGraph.Connected)
{
LogicTransition = transition ?? throw new ArgumentNullException(nameof(transition), "The logic transition can not be null!");
LabelText = LogicTransition.Label;
}
/// <summary>
/// Does a specified step in the simulation for ambiguous state.
/// </summary>
/// <param name="transition">The specific transition to handle.</param>
/// <returns>The result of the step.</returns>
public SimulationStepResult SpecificStep(IStateTransition transition)
{
if (transition == null)
{
throw new ArgumentNullException(nameof(transition), "The transition can not be null!");
}
var canStep = CanStep();
if (canStep != SimulationStepResult.Ambiguous && canStep != SimulationStepResult.AmbiguousNoResolver)
{
return(SimulationStepResult.Invalid);
}
var applicableTransitions = GetApplicableTransitions();
if (!applicableTransitions.Contains(transition))
{
return(SimulationStepResult.Invalid);
}
StepInternal(transition);
return(SimulationStepResult.Success);
}
/// <summary>
/// Create the event args
/// </summary>
/// <param name="nextState">The state to transition to</param>
/// <param name="transition">The transition to use to get to the next state</param>
public StateBeginExitEventArgs(
IState nextState,
IStateTransition transition
)
{
NextState = nextState;
Transition = transition;
}
virtual public void AddTransition(IStateTransition transition)
{
if (typeof(AFObject) == transition.GetType())
{
((AFObject)transition).gameObject.transform.parent = gameObject.transform;
}
m_transition = transition;
m_transition.Initialize(this);
}
public TransitionPolicyControllerContext(IStateMachine stateMachine, IStateTransition currentTransition, ICredential credentialToApprov)
{
stateMachine.TestForArgumentNull();
ControledMachine = stateMachine;
currentTransition.TestForArgumentNull();
_currentTransition = currentTransition;
credentialToApprov.TestForArgumentNull();
_credentialToApprov = credentialToApprov;
}
public void Setup()
{
_transitions = new IStateTransition<BugState, TransitionActionStatus>[]
{
new BugTransition.Assign(new BugTransitionAction.Assign()),
};
_stateMachine = new StateMachine<BugState, TransitionActionStatus>("example",
_transitions,
initialState: new BugState.Open());
}
/// <summary>
/// Called when [transition].
/// </summary>
/// <param name="TO"> The TO. </param>
/// <param name="FROM"> The FROM. </param>
/// <param name="transition"> The transition. </param>
// ReSharper disable InconsistentNaming
private void OnTransition(List <IState> TO, IState FROM, IStateTransition transition) // ReSharper restore InconsistentNaming
{
try
{
if (FROM.Leave != null)
{
foreach (IState toState in ActiveStates)
{
if (_logging.IsDebugEnabled)
{
_logging.DebugFormat("StateMachine Transition Activated From {0} to {1}", FROM.Name, toState.Name);
}
}
FROM.Leave.CallOnEach(x => x.Execute(StateContainer, _stateMap));
}
}
catch (Exception ex)
{
throw new StateMachineException(ex.Message);
}
try
{
if (TO != null)
{
ActiveStates.AddRange(TO);
foreach (IState toState in ActiveStates)
{
if (toState.Enter != null)
{
toState.Enter.CallOnEach(x => x.Execute(StateContainer, _stateMap));
}
if (_logging.IsDebugEnabled)
{
_logging.DebugFormat("StateMachine Transition Completed From {0} to {1}", FROM.Name, toState.Name);
}
}
}
else
{
if (_logging.IsDebugEnabled)
{
_logging.DebugFormat("StateMachine has Transitioned To A Final State From {0}", FROM.Name);
}
}
}
catch (Exception ex)
{
throw new StateMachineException(ex.Message);
}
}
/// <summary>
/// Handles the select button's click event.
/// </summary>
/// <param name="sender">The triggerer object.</param>
/// <param name="e">The event arguments.</param>
private void SelectTransitionButton_Click(object sender, EventArgs e)
{
if (_comboBoxSelectionList.Count <= TransitionComboBox.SelectedIndex)
{
return;
}
SelectedTransition = _comboBoxSelectionList[TransitionComboBox.SelectedIndex];
DialogResult = DialogResult.OK;
Close();
}
protected virtual void CompleteStateMachine(IStateTransition transition)
{
List <IStateTransitionAction> actions =
this.GetMatchingTransitionActions(StateTransitionPhase.StateMachineComplete);
if (actions != null)
{
actions.ForEach(action => ExecuteAction(action, transition, StateTransitionPhase.StateMachineComplete));
}
OnStateMachineComplete(transition);
}
public void Setup()
{
var homePanelTransitions = new IStateTransition <LucidState>[]
{
new HomePanelTransition.Hide(),
new HomePanelTransition.Show(),
};
_homePanelStateMachine = new StateMachine <LucidState>("HomePanel",
homePanelTransitions,
initialState: new HomePanelState.Visible());
}
protected virtual void InitializeState(IStateTransition transition, IStateMachineState prevState)
{
List <IStateTransitionAction> actions =
this.GetMatchingTransitionActions(StateTransitionPhase.StateInitialization);
if (actions != null)
{
actions.ForEach(action => ExecuteAction(action, transition, StateTransitionPhase.StateInitialization));
}
OnStateInitialized(transition, prevState);
}
/// <summary>
/// Removes a transition from the automata.
/// </summary>
/// <param name="transition">The transition that is removed.</param>
public void RemoveTrasition(IStateTransition transition)
{
if (transition == null)
{
throw new ArgumentNullException(nameof(transition), "The transition can not be null!");
}
if (Transitions.Remove(transition))
{
OnTransitionRemove?.Invoke(this, new TransitionEventArgs(transition));
}
}
protected void ExecuteAction(IStateMachineAction action, IStateTransition transition,
StateTransitionPhase phase)
{
var context = new StateMachineActionContext
{
WorkflowContext = this,
Action = action,
CurrentTransition = transition,
CurrentPhase = phase
};
action.Execute(context);
}
/// <summary>
/// Execute the initial state and any subsequent states and transitions until there are no more
/// states to execute.
/// </summary>
public IEnumerable Execute()
{
while (true)
{
// Execute the current state until it transitions or stops executing
for (
var e = state.Execute().GetEnumerator();
transition == null && e.MoveNext();
)
{
yield return(e.Current);
}
// Wait until the current state transitions
while (transition == null)
{
yield return(null);
}
// Stop listening for the current state to transition
// This prevents accidentally transitioning twice
state.OnBeginExit -= HandleStateBeginExit;
// There is no next state to transition to
// This means the state machine is finished executing
if (nextState == null)
{
break;
}
// Run the transition's exit process
foreach (var e in transition.Exit())
{
yield return(e);
}
state.EndExit();
// Switch state
State = nextState;
nextState = null;
// Run the transition's enter process
foreach (var e in transition.Enter())
{
yield return(e);
}
transition = null;
state.EndEnter();
}
}
private BoxCollider2D bx; //The box collider
public SlipState(GameObject player, IStateTransition stateTransition,
Vector2 standSize, Vector2 standCenter,
Vector2 slipSize, Vector2 slipCenter)
{
Player = player;
StateTransition = stateTransition;
StandSize = standSize;
StandCenter = standCenter;
SlipSize = slipSize;
SlipCenter = slipCenter;
bx = Player.GetComponent <BoxCollider2D> ();
}
/// <summary>
/// Handles the transition's update after a property of it was modified.
/// </summary>
/// <param name="transition">The trainsition that was updated.</param>
public void UpdateTransition(IStateTransition transition)
{
if (transition == null)
{
throw new ArgumentNullException(nameof(transition), "The transition can not be null!");
}
foreach (var existing in Transitions)
{
if (existing == transition)
{
OnTransitionUpdate?.Invoke(this, new TransitionEventArgs(transition));
}
}
}
public void Setup()
{
var bugTransitions = new IStateTransition<BugState>[]
{
new BugTransition.Open(),
new BugTransition.Assign(BugTransitionAction.Assign),
new BugTransition.Defer(BugTransitionAction.Defer),
new BugTransition.Resolve(BugTransitionAction.Resolve),
new BugTransition.Close(BugTransitionAction.Close),
};
_stateMachine = new StateMachine<BugState>("Bug",
bugTransitions,
initialState: new BugState.Open());
}
public void Setup()
{
var bugTransitions = new IStateTransition <BugState>[]
{
new BugTransition.Open(),
new BugTransition.Assign(BugTransitionAction.Assign),
new BugTransition.Defer(BugTransitionAction.Defer),
new BugTransition.Resolve(BugTransitionAction.Resolve),
new BugTransition.Close(BugTransitionAction.Close),
};
_stateMachine = new StateMachine <BugState>("Bug",
bugTransitions,
initialState: new BugState.Open());
}
protected virtual void FireEventActions(IStateTransition transition)
{
//State Machine initialization
if (transition.TriggerEvent == null)
{
return;
}
List <IStateMachineEventAction> actions =
this.GetMatchingEventActions(transition.TriggerEvent.EventIdentifier);
if (actions != null)
{
actions.ForEach(action => ExecuteAction(action, transition, StateTransitionPhase.All));
}
}
protected virtual void OnStateMachineComplete(IStateTransition finalTransition)
{
var transitionArgs = new StateTransitionEventArgs
{
StateMachineContext = this,
StartingState = null,
Transition = finalTransition,
TransitionPhase = StateTransitionPhase.All
};
EventHandler <StateTransitionEventArgs> evt = StateMachineComplete;
if (evt != null)
{
evt(this, transitionArgs);
}
}
protected virtual void OnStateInitialized(IStateTransition transition, IStateMachineState prevState)
{
var transitionArgs = new StateTransitionEventArgs
{
StateMachineContext = this,
StartingState = prevState,
Transition = transition,
TransitionPhase = StateTransitionPhase.StateInitialization
};
EventHandler <StateTransitionEventArgs> stateInitializedHandler = StateInitialized;
if (stateInitializedHandler != null)
{
stateInitializedHandler(this, transitionArgs);
}
}
public void Setup()
{
_stateMachineRoot = new StateMachine <LucidState>("Root",
new IStateTransition <LucidState> [0],
initialState: new UIRootState.Enabled());
_transitions = new IStateTransition <LucidState>[]
{
new SmTransition.Hide(),
new SmTransition.Show(),
};
_stateMachine1 = new StateMachine <LucidState>("SM1",
_transitions,
initialState: new SmState.Visible(),
parentStateMachine: _stateMachineRoot);
}
/// <summary>
/// Returns false if the consumer of the event cancelled the process,
/// true otherwise.
/// </summary>
/// <param name="transition"></param>
/// <returns></returns>
protected virtual bool OnBeforeStateChanged(IStateTransition transition)
{
var args = new StateChangingEventArgs
{
StateMachineContext = this,
NewState = transition.TargetState,
Cancel = false
};
EventHandler <StateChangingEventArgs> evt = BeforeStateChanged;
if (evt != null)
{
evt(this, args);
}
return(!args.Cancel);
}
/// <summary>
/// Takes an event from the outside world and performs
/// a state transition if necessary.
/// </summary>
/// <param name="transitionEvent"></param>
/// <returns></returns>
public EventResponse HandleEvent(object transitionEvent)
{
EnsureStateMachineStarted();
if (transitionEvent == null)
{
return(EventResponse.EventNotRegistered);
}
IStateMachineEvent evt;
if (transitionEvent is IStateMachineEvent)
{
evt = (IStateMachineEvent)transitionEvent;
}
else
{
evt = StateMachine.FindEvent(transitionEvent);
if (evt == null)
{
return(EventResponse.EventNotRegistered);
}
}
IStateTransition transition = this.FindFirstMatchingTransition(evt);
this.FindMatchingTransitions();
if (transition == null)
{
return(EventResponse.EventNotInScope);
}
if (IsTransactional)
{
using (var scope = new TransactionScope(TransactionScopeOption.Required))
{
EventResponse result = PerformTransition(transition);
scope.Complete();
return(result);
}
}
return(PerformTransition(transition));
}
private void Update( )
{
if (isExecuting) // is the engine state machine running
{
Assert.IsFalse(state == null, "[StateMachine][Update] State Machine has no state!");
if (exitStateTransition == null && state.IsStateExecuting) // RTC the current state, return until done
{
state.ExecuteState( );
return;
}
state.RaiseStateChangeEvent -= HandleOnStateTransition;
if (nextState == null) // check if a nextState was passed, if not -- app was terminated
{
isExecuting = false;
}
if (exitStateTransition != null) // if the transition variable has a transition, run 'transition exit current state' coroutine
{
if (exitStateTransition.HasTriggered == false)
{
StartCoroutine(exitStateTransition.BeginTransition( ).GetEnumerator( ));
}
if (exitStateTransition.HasCompleted == false)
{
return;
}
}
// TODO: consider adding a state.EndExit()
newState = nextState; // this fires the property, and the new state will run its 'enter' method
nextState = null;
// TODO: add a 'transition enter next state'
exitStateTransition = null;
// TODO: add a state.EndEnter();
}
}
// 実行可能なIEnumerableを返す
public IEnumerable Execute()
{
// ずっとぶん回す
while (true)
{
for (var e = state.Execute().GetEnumerator(); transition == null && e.MoveNext();)
{
yield return(e.Current);
}
while (transition == null)
{
yield return(null);
}
state.OnBeginExit -= HandleStateBeginExit;
if (nextState == null)
{
break;
}
// いまのステートが終わる時の演出
foreach (var e in transition.Exit())
{
yield return(e);
}
state.EndExit();
// ステートの切り替え
// BeginEnter()呼び出し
State = nextState;
nextState = null;
// 新しいステートが始まるときの演出
foreach (var e in transition.Enter())
{
yield return(e);
}
state.EndEnter();
transition = null;
}
}
/// <summary>
/// Adds a new transition to the graph representation.
/// </summary>
/// <param name="transition">The transition instance.</param>
private void AddTransition(IStateTransition transition)
{
if (transition == null)
{
throw new ArgumentNullException(nameof(transition), "The logic transition can not be null!");
}
if (transition.SourceState == null)
{
throw new ArgumentNullException(nameof(transition), "The logic transition's source state can not be null!");
}
if (transition.TargetState == null)
{
throw new ArgumentNullException(nameof(transition), "The logic transition's target state can not be null!");
}
if (_logicToDrawingTransitionMap.ContainsKey(transition))
{
throw new ArgumentException("The graph already contains this transition!", nameof(transition));
}
var sourceState = NodeMap[transition.SourceState.Id] as State;
var targetState = NodeMap[transition.TargetState.Id] as State;
if (sourceState == null || targetState == null)
{
throw new Exception("You can not add a transition to a non-existant state!");
}
var edge = new Edge(sourceState, targetState, transition);
SetupEdge(edge);
_logicToDrawingTransitionMap.Add(transition, edge);
AddPrecalculatedEdge(edge);
IsSaved = false;
Redraw();
}
/// <summary>
/// Removes a transition from the graph representation.
/// </summary>
/// <param name="transition">The transition instance.</param>
private void RemoveTransition(IStateTransition transition)
{
if (transition == null)
{
throw new ArgumentNullException(nameof(transition), "The logic transition can not be null!");
}
if (!_logicToDrawingTransitionMap.ContainsKey(transition))
{
throw new ArgumentException("The graph doesn't contain this transition!", nameof(transition));
}
RemoveEdge(_logicToDrawingTransitionMap[transition]);
_logicToDrawingTransitionMap.Remove(transition);
IsSaved = false;
Redraw();
}
public IEnumerable Execute()
{
while (true)
{
for (var e = state.Execute().GetEnumerator(); transition == null && e.MoveNext();)
{
yield return(e.Current);
}
while (transition == null)
{
yield return(null);
}
state.OnBeginExit -= HandleStateBeginExit;
if (nextState == null)
{
break;
}
foreach (var e in transition.Exit())
{
yield return(e);
}
state.EndExit();
State = nextState;
nextState = null;
foreach (var e in transition.Enter())
{
yield return(e);
}
transition = null;
state.EndEnter();
}
}
protected virtual EventResponse PerformTransition(IStateTransition transition)
{
IStateMachineState prevState = CurrentState;
if (prevState != null)
{
if (OnBeforeStateChanged(transition) == false)
{
return(EventResponse.TransitionCancelled);
}
FinalizeState(transition);
}
else
{
StartStateMachine(transition);
}
FireEventActions(transition);
CurrentState = transition.TargetState;
InitializeState(transition, prevState);
OnAfterStateChanged(prevState);
if (IsComplete)
{
CompleteStateMachine(transition);
}
if (PersistenceService != null)
{
PersistenceService.Save(this);
}
return(EventResponse.TransitionComplete);
}
/// <summary>
/// Handles the internal process of stepping.
/// </summary>
/// <param name="transition">The selected transition to handle.</param>
private void StepInternal(IStateTransition transition)
{
if (transition == null)
{
throw new ArgumentNullException(nameof(transition), "The transition can not be null!");
}
if (transition.SourceState != CurrentState)
{
throw new ArgumentException("The transition's source isn't the current state!", nameof(transition));
}
if (!transition.HandlesSymbol(CurrentInputSymbol))
{
throw new ArgumentException("The transition can't handle the current input symbol!", nameof(transition));
}
CurrentState = transition.TargetState;
++CurrentInputIndex;
OnStep?.Invoke();
}
/// <summary>
/// Creates a new instance with the given transition.
/// </summary>
/// <param name="state"></param>
public TransitionEventArgs(IStateTransition transition)
{
Transition = transition;
}
public void PerformTransition(IStateTransition transition)
{
if (transition.Parent.Specification.IsValidForMoveForward())
SetState(transition.Target);
}
public void Setup()
{
_transitions = new IStateTransition<BugState, TransitionActionStatus>[]
{
new BugTransition.Open(),
new BugTransition.Assign(new BugTransitionAction.Assign()),
new BugTransition.Defer(new BugTransitionAction.Defer()),
new BugTransition.Resolve(new BugTransitionAction.Resolve()),
new BugTransition.Close(new BugTransitionAction.Close()),
};
_stateMachine = new StateMachine<BugState, TransitionActionStatus>("state machine name",
_transitions,
initialState: new BugState.Open());
_bug = new Bug("bug1");
}
public bool Search(
IStateTransition transition,
IState initialState,
IState goalState,
HeuristicDelegate heuristic,
out Node result, double initialCost=0)
{
result = null;
var fringe = new BinaryHeap<SearchNode>((x, y) => y.Value > x.Value);
fringe.Insert(new SearchNode()
{
f = heuristic(initialState, goalState),
g = initialCost,
State = initialState
});
var visitedNodes = new Dictionary<IState, SearchNode>();
visitedNodes.Add(initialState, new SearchNode()
{
f = heuristic(initialState,
goalState),
g = initialCost,
State = initialState
});
var history = new Dictionary<IState, Node>();
history.Add(initialState, new Node() { State = initialState });
while (true)
{
if (fringe.Count == 0)
{
return false;
}
var node = fringe.Remove();
if (transition.IsGoal(node.State, goalState))
{
result = history[goalState];
return true;
}
foreach (var x in transition.Expand(node.State))
{
var state = x.Item1;
var _g = x.Item3 + node.g;
var _f = _g + heuristic(state, goalState);
if (transition.IsGoal(state, goalState))
_f = _g;
var action = x.Item2;
SearchNode visitedNode;
Node hnode;
if (visitedNodes.TryGetValue(state, out visitedNode))
{
if (visitedNode.g < _g)
hnode = history[state];
else
continue;
}
else
{
visitedNode = new SearchNode();
visitedNodes.Add(state, visitedNode);
hnode = new Node();
history.Add(state, hnode);
}
visitedNode.f = _f;
visitedNode.g = _g;
visitedNode.State = state;
fringe.Insert(visitedNode);
hnode.Previous = history[node.State];
hnode.Cost = _g;
hnode.PreviousAction = action;
hnode.State = state;
}
}
}
public StateTransitionPending(IStateMachine stateMachine, IStateTransition transitionPending)
{
StateMachine = stateMachine;
TransitionPending = transitionPending;
}
