public StateTransition(IStateMachineState parent, IStateMachineEvent triggerEvent,
IStateMachineState targetState) : base(parent.StateMachine)
{
ParentState = parent;
TriggerEvent = triggerEvent;
TargetState = targetState;
}
public void SwitchState(string nextStateName)
{
if (CurrentStateName.Equals(nextStateName))
{
return;
}
IStateMachineState nextState = States.Get(nextStateName);
if (nextState == null)
{
Debug.Log(string.Format("StateMachine on {0} could not switch to {1}.", gameObject.name, nextStateName));
return;
}
if (CurrentState != null && CurrentState.GetEndFn() != null)
{
CurrentState.GetEndFn()();
}
CurrentState = nextState;
if (CurrentState.GetStartFn() != null)
{
CurrentState.GetStartFn()();
}
}
public virtual IStateTransition AddNewTransition(IStateMachineEvent trigger, IStateMachineState destination)
{
var transition = new StateTransition(this, trigger, destination);
TransitionList.Add(transition);
return(transition);
}
public virtual IStateTransition AddNewTransition(IStateMachineEvent trigger, IStateMachineState destination, List <string> rolesRequired)
{
var transition = new StateTransition(this, trigger, destination, rolesRequired);
TransitionList.Add(transition);
return(transition);
}
public StateTransition(IStateMachineState parent, IStateMachineEvent triggerEvent,
IStateMachineState targetState, List <string> rolesRequired)
: base(parent.StateMachine)
{
ParentState = parent;
TriggerEvent = triggerEvent;
TargetState = targetState;
RolesRequired = rolesRequired;
}
public void AddState(IStateMachineState state)
{
if (state == null) throw new ArgumentNullException(nameof(state));
if (SupportsState(state.Id))
{
throw new InvalidOperationException($"State '{state.Id}' already added.");
}
_states.Add(state);
}
public void AcceptNewState(IStateMachineState state)
{
object value = state.StateIdentifier;
if (StateProperty.PropertyType.IsEnum)
{
value = ConvertEnum(StateProperty.PropertyType, state.StateIdentifier);
}
StateProperty.SetValue(DomainContext, value, new object[] {});
}
public LaundryMachineStateTransition([NotNull] IStateMachineState <LaundryMachineStateCode, StateMachineStateType> owner, int priority, [NotNull] string name,
[NotNull] string predicateText, [NotNull] LTransPredicateEvaluator transitionPredicate,
[NotNull] LTransProcedure transitionProcedure, [NotNull] LTransAdditionalProcedure additionalProcedure1,
ImmutableArray <LaundryMachineStateCode> destinations) : base(owner, priority, name, predicateText,
destinations)
{
_transitionPredicate = transitionPredicate ?? throw new ArgumentNullException(nameof(transitionPredicate));
_transitionProcedure = transitionProcedure ?? throw new ArgumentNullException(nameof(transitionProcedure));
_additionalProcedure =
additionalProcedure1 ?? throw new ArgumentNullException(nameof(additionalProcedure1));
}
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);
}
public void RegisterState(IStateMachineState state)
{
if (state == null)
{
throw new ArgumentNullException(nameof(state));
}
lock (_syncRoot)
{
ThrowIfStateAlreadySupported(state.Id);
_states.Add(state);
}
}
public void AddState(IStateMachineState state)
{
if (state == null)
{
throw new ArgumentNullException(nameof(state));
}
if (GetSupportsState(state.Id))
{
throw new InvalidOperationException($"State '{state.Id}' already added.");
}
_states.Add(state);
}
protected virtual void OnAfterStateChanged(IStateMachineState prevState)
{
var stateChangedArgs = new StateChangedEventArgs
{
StateMachineContext = this,
PreviousState = prevState
};
EventHandler <StateChangedEventArgs> evt = AfterStateChanged;
if (evt != null)
{
evt(this, stateChangedArgs);
}
}
private void AssignNewState <TState>(TState newState) where TState : IStateMachineState
{
if (newState.Equals(this.CurrentState) || !this.IsAllowedTransition(this.CurrentState, newState))
{
throw new InvalidOperationException($"That transition is not allowed. {CurrentState.GetType().Name} -> {newState.GetType().Name}");
}
var oldState = this.CurrentState;
oldState.OnLeavingState(newState);
newState.OnEnteringState(oldState);
this.CurrentState = newState;
this.RaiseStateChanged(oldState, newState);
}
private IStateMachineState GetState(IComponentState id)
{
IStateMachineState state = _states.FirstOrDefault(s => s.Id.Equals(id));
if (state == null && _stateAlias.TryGetValue(id, out id))
{
state = _states.FirstOrDefault(s => s.Id.Equals(id));
}
if (state == null)
{
throw new InvalidOperationException("State machine state is unknown.");
}
return(state);
}
public void ChangeState(string key)
{
if (!states.ContainsKey(key))
{
Debug.LogError("Invalid state machine key");
return;
}
if (currentState != null)
{
currentState.OnExit();
}
currentState = states[key];
CurrentStateName = key;
currentState.OnEnter();
}
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);
}
}
private void SetState(string id, params IHardwareParameter[] parameters)
{
ThrowIfNoStatesAvailable();
ThrowIfStateNotSupported(id);
var oldState = GetState();
if (AlternativeStateId != null && id == _activeState?.Id)
{
id = AlternativeStateId;
}
_activeState?.Deactivate(parameters);
_activeState = _states.First(s => s.Id.Equals(id));
_activeState.Activate(parameters);
OnStateChanged(oldState);
}
public static void SetState(this IStateMachineContext context, object stateIdentifier)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
if (stateIdentifier == null)
{
throw new ArgumentNullException("stateIdentifier");
}
IStateMachineState target = FindState(context.StateMachine, stateIdentifier);
if (target != null)
{
context.SetState(target);
}
}
public void SetState(IStateMachineState targetState)
{
EnsureStateMachineStarted();
if (targetState.StateMachine != StateMachine)
{
throw new ArgumentException(
"The target state provided does not belong to the same StateMachine as this StateMachineContext.");
}
if (targetState == null)
{
throw new ArgumentNullException("targetState");
}
var transition = new StateTransition(CurrentState, null, targetState);
PerformTransition(transition);
}
public IComponentState GetNextState(IComponentState stateId)
{
if (stateId == null)
{
throw new ArgumentNullException(nameof(stateId));
}
ThrowIfStateNotSupported(stateId);
IStateMachineState startState = GetState(stateId);
int indexOfStartState = _states.IndexOf(startState);
if (indexOfStartState == _states.Count - 1)
{
return(_states.First().Id);
}
return(_states[indexOfStartState + 1].Id);
}
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);
}
public override void SetState(IComponentState id, params IHardwareParameter[] parameters)
{
if (id == null)
{
throw new ArgumentNullException(nameof(id));
}
ThrowIfNoStatesAvailable();
IStateMachineState oldState = _activeState;
IStateMachineState newState = GetState(id);
if (newState.Id.Equals(_activeState?.Id))
{
if (_turnOffIfStateIsAppliedTwice && GetSupportsState(BinaryStateId.Off) && !GetState().Equals(BinaryStateId.Off))
{
SetState(BinaryStateId.Off, parameters);
return;
}
if (!parameters.Any(p => p is ForceUpdateStateParameter))
{
return;
}
}
oldState?.Deactivate(parameters);
newState.Activate(parameters);
if (parameters.Any(p => p is IsPartOfPartialUpdateParameter))
{
return;
}
_activeState = newState;
OnActiveStateChanged(oldState, newState);
}
protected override bool IsAllowedTransition <TState>(IStateMachineState currentState, TState newState)
{
if (currentState is WaitingForTurnState wft)
{
return(newState is RestoringResourcesState);
}
if (currentState is RestoringResourcesState rrs)
{
return(newState is PlayingCardsPhase);
}
if (currentState is PlayingCardsPhase pcp)
{
return(newState is ResolvingBattleState);
}
if (currentState is ResolvingBattleState rbs)
{
return(newState is WaitingForTurnState);
}
throw new NotImplementedException();
}
protected void CommitPendingTransitions()
{
foreach (TransitionDef transition in PendingTransitions)
{
IStateMachineEvent triggerEvent = StateMachine.FindEventByName(transition.TriggerEvent);
IStateMachineState targetState = StateMachine.FindStateByName(transition.TargetState);
if (triggerEvent == null)
{
throw new Exception("A non-existent event was specified in a transition for " +
transition.ParentState.StateName + " : " +
transition.TriggerEvent);
}
if (targetState == null)
{
throw new Exception(
"A non-existent target state was specified in a transition for " +
transition.ParentState.StateName + " : " + transition.TargetState);
}
((StateMachineState)transition.ParentState).AddNewTransition(triggerEvent, targetState, transition.RolesRequired);
}
}
private void SetState(IStateMachineState targetState)
{
targetState.TestForArgumentNull();
this.CurrentState = targetState;
}
public StateTransition(IStateMachineState parent, IStateMachineState target)
{
this.Parent = parent;
this.Target = target;
}
protected StateMachineBase(IStateMachineState initialState)
{
CodeGuard.ArgumentNotNull(initialState, nameof(initialState));
this.CurrentState = initialState;
}
protected virtual void RaiseStateChanged(IStateMachineState oldState, IStateMachineState newState)
{
StateChanged?.Invoke(this, new StateMachineStateChanged(oldState, newState));
}
protected virtual bool IsAllowedTransition <TState>(IStateMachineState currentState, TState newState)
where TState : IStateMachineState
{
return(true);
}
public override void SetState(ComponentState id, params IHardwareParameter[] parameters)
{
if (id == null) throw new ArgumentNullException(nameof(id));
ThrowIfNoStatesAvailable();
IStateMachineState oldState = _activeState;
IStateMachineState newState = GetState(id);
if (newState.Id.Equals(_activeState?.Id))
{
if (_turnOffIfStateIsAppliedTwice && SupportsState(BinaryStateId.Off) && !GetState().Equals(BinaryStateId.Off))
{
SetState(BinaryStateId.Off, parameters);
return;
}
if (!parameters.Any(p => p is ForceUpdateStateParameter))
{
return;
}
}
oldState?.Deactivate(parameters);
newState.Activate(parameters);
if (parameters.Any(p => p is IsPartOfPartialUpdateParameter))
{
return;
}
_activeState = newState;
OnActiveStateChanged(oldState, newState);
}
public StateMachineStateChanged(IStateMachineState oldState, IStateMachineState newState)
{
OldState = oldState;
NewState = newState;
}
protected virtual void OnActiveStateChanged(IStateMachineState oldState, IStateMachineState newState)
{
OnActiveStateChanged(oldState?.Id, newState.Id);
}
protected virtual void OnActiveStateChanged(IStateMachineState oldState, IStateMachineState newState)
{
OnActiveStateChanged(oldState?.Id, newState.Id);
}
public TurnStateMachine(IStateMachineState initialState) : base(initialState)
{
}
internal StateTransition(IStateMachine stateMachine, IStateMachineState initialState) : base(stateMachine)
{
TargetState = initialState;
}
