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); }
public TurnStateMachine(IStateMachineState initialState) : base(initialState) { }
internal StateTransition(IStateMachine stateMachine, IStateMachineState initialState) : base(stateMachine) { TargetState = initialState; }