public ProcessState GetNext(Command command) { StateTransition transition = new StateTransition(CurrentState, command); ProcessState nextState; if (!transitions.TryGetValue(transition, out nextState)) { //Halt process throwing execption //throw new Exception("Invalid transition: " + CurrentState + " -> " + command); Console.WriteLine("Invalid transition: " + CurrentState + " -> " + command); } else { switch (nextState) { case ProcessState.Inactive: Console.WriteLine("Do stuff for " + nextState); break; case ProcessState.Active: Console.WriteLine("Do stuff for " + nextState); break; case ProcessState.Paused: Console.WriteLine("Do stuff for " + nextState); break; case ProcessState.Terminated: Console.WriteLine("Do stuff for " + nextState); break; default: break; } } return nextState; }
public FiniteAutomaton(int initialState, int statesNumber, int eventsNumber) { InitialState = initialState; StatesNumber = statesNumber; EventsNumber = eventsNumber; Transitions = new StateTransition[statesNumber, eventsNumber]; }
public override void SetTransitions() { StateTransition cancellingBackMenu = new StateTransition(TransitionID.Previous, StateID.SelectUnit); AddTransition(cancellingBackMenu); StateTransition endingTurn = new StateTransition(TransitionID.Next, StateID.ChangeTurns); AddTransition(endingTurn); }
public void TestStateTransitionEquals() { var s1 = new StateTransition<SystemState, SystemStateEvent>(SystemState.WaitingForEvaluator, SystemStateEvent.AllContextsAreReady); var s2 = new StateTransition<SystemState, SystemStateEvent>(SystemState.WaitingForEvaluator, SystemStateEvent.AllContextsAreReady); Assert.True(s1.Equals(s2), "The two transitions should be equal"); }
public EnemyEntityState GetNext(EnemyCommand command) { StateTransition transition = new StateTransition(CurrentState, command); EnemyEntityState nextState; if (!transitions.TryGetValue(transition, out nextState)) throw new Exception("Invalid transition: " + CurrentState + " -> " + command); return nextState; }
public ProcessState GetNext(Command command) { StateTransition transition = new StateTransition(CurrentState, command); ProcessState nextState; if (!transitions.TryGetValue(transition, out nextState)) { throw new Exception("Invalid transition: " + CurrentState + " -> " + command); } return nextState; }
/// <summary> /// Based on the event and current state to determine the next state /// </summary> /// <param name="systemEvent"></param> /// <returns></returns> internal SystemState GetNext(SystemStateEvent systemEvent) { var transition = new StateTransition<SystemState, SystemStateEvent>(_currentState, systemEvent); SystemState nextState; if (!Transitions.TryGetValue(transition, out nextState)) { throw new SystemStateTransitionException(_currentState, systemEvent); } return nextState; }
/// <summary> /// Initialise the fade transition, specifying how long the fade should last, in ms. /// </summary> /// <param name="transition">The transition this fade is part of.</param> /// <param name="manager">The window this fade is to be drawn on.</param> /// <param name="lengthMS">The length of time, in ms, the fade should last.</param> public FeatureFrameTransition(StateTransition transition, FrameOverlayManager manager, IFeatureTransition transitionEffect) : base(transition, manager) { mTransition = transitionEffect; mTransition.Start = From; mTransition.Finish = To; mTransition.Finished += new Action(transitionEffect_Finished); AddFeature(mTransition); }
public void AddTransition(S init, S end, Callback c) { StateTransition <S> tr = new StateTransition <S>(init, end); if (mTransitions.ContainsKey(tr)) { return; } mTransitions.Add(tr, c); }
public void AddTransition(S initial_state, S end_state, StateHandler call) { StateTransition <S> temp_transition = new StateTransition <S>(initial_state, end_state); if (TransitionTable.ContainsKey(temp_transition)) { return; } TransitionTable.Add(temp_transition, call); }
public void Tick() { // Transition to a new State if any of our current State's transition conditions are met StateTransition transition = CheckForTransition(); if (transition != null) { SetState(transition.To); } _currentState.Tick(); }
public void DefineTransition( TState fromState, TState toState, Func <TEvent, bool> condition, Action <TEvent> action ) { var t = new StateTransition(fromState, toState, condition, action); _transitions.Add(t); }
public override bool Equals(object obj) { bool result = false; StateTransition newObj = obj as StateTransition; if (newObj != null && _currentState == newObj._currentState && _transition == newObj._transition) { result = true; } return(result); }
public ProcessState GetNext(Command command) { StateTransition transition = new StateTransition(CurrentState, command); ProcessState nextState; if (!transitions.TryGetValue(transition, out nextState)) { return(nextState); } return(nextState); }
public ProcessState GetNext(Command command) { StateTransition transition = new StateTransition(CurrentState, command); ProcessState nextState; if (!transitions.TryGetValue(transition, out nextState)) { throw new Exception("Invalid transition: " + CurrentState + " -> " + command); } return(nextState); }
public State GetNext(Event currentEvent) { StateTransition transition = new StateTransition(CurrentState, currentEvent); State nextState; if (!m_transitions.TryGetValue(transition, out nextState)) { throw new Exception("Invalid transition: " + CurrentState + " -> " + currentEvent); } return(nextState); }
//Return a list of values associated with the action values from each model for the given state public List <double[]> modelActionValues(StateTransition <stateType, actionType> StaTran, Dictionary <int, ActionValue <stateType, actionType> > models) { List <double[]> returnValues = null; foreach (int key in models.Keys) { returnValues.Add(models[key].value(StaTran.oldState, models[key].availableActions)); } return(returnValues); }
public void Tick() { StateTransition transition = CheckForTransition(); if (transition != null) { SetState(transition.To); } CurrentState.Tick(); }
public void AddTransition(IState from, IState to, Func <bool> condition) { if (_stateTransitions.ContainsKey(from) == false) { _stateTransitions[from] = new List <StateTransition>(); } StateTransition stateTransition = new StateTransition(from, to, condition); _stateTransitions[from].Add(stateTransition); }
public void GetPossibleTransitionsFromState2and5returns4Transitions() { GameState fromState = new GameState(2, 5); int bucket1Max = 3; int bucket2Max = 5; IList <StateTransition> actual = StateTransition.GetPossibleTransitions(fromState, bucket1Max, bucket2Max); //dump 1, dump 2, fill 1, tranfer 2 to 1 Assert.AreEqual(actual.Count, 4); }
public void GetPossibleTransitionsFromState0and0returns2Transitions() { GameState fromState = new GameState(0, 0); int bucket1Max = 3; int bucket2Max = 5; IList <StateTransition> actual = StateTransition.GetPossibleTransitions(fromState, bucket1Max, bucket2Max); //fill 1, fill 2 Assert.AreEqual(actual.Count, 2); }
protected TState GetNext(TState state) { StateTransition transition = new StateTransition(CurrentState, state); TState nextState; if (!transitions.TryGetValue(transition, out nextState)) { throw new System.Exception($"Invalid transition: {CurrentState} -> {state}"); } return(nextState); }
/// <summary> /// /// </summary> /// <param name="transition"></param> /// <param name="window"></param> /// <exception cref="InvalidArgumentException">Thrown if there is no window state for the To or From state.</exception> public FrameTransition(StateTransition transition, FrameOverlayManager manager) : base(manager.Name) { mManager = manager; mTransition = transition; mFrom = transition.From[manager.Name]; mTo = transition.To[manager.Name]; Finished += trans => mSelected = false; }
private IEnumerator ChangeToNewStateRoutine(StateMapping newState, StateTransition transtiion) { _destinationState = newState; if (_currentState != null) { if (_currentState.hasExitRoutine) { _exitRoutine = _currentState.ExitRoutine(); if (_exitRoutine != null && transtiion != StateTransition.Overwrite) { yield return(_engine.StartCoroutine(_exitRoutine)); } _exitRoutine = null; } else { _currentState.ExitCall(); } _currentState.Finally(); } _lastState = _currentState; _currentState = _destinationState; if (_currentState != null) { if (_currentState.hasEnterRoutine) { _enterRoutine = _currentState.EnterRoutine(); if (_enterRoutine != null) { yield return(_engine.StartCoroutine(_enterRoutine)); } _enterRoutine = null; } else { _currentState.EnterCall(); } if (Changed != null) { Changed(_currentState.State); } } _isInTransition = false; }
//Transistions between step public ProcessState GetNext(Command command) { StateTransition transition = new StateTransition(CurrentState, command); ProcessState nextState; if (!transitions.TryGetValue(transition, out nextState)) // Handles the case where the transition to the next step is invalid in which case throws and exceptions to get the values from the next step. { throw new Exception("Invalid transition: " + CurrentState + " -> " + command); } return(nextState); }
public StrategySettings(StrategySettings other) { AllowedTransitions = other.AllowedTransitions; Run = other.Run; Reset = other.Reset; PreferredSpeed = other.PreferredSpeed; PreferredManeuverSecondDistance = other.PreferredManeuverSecondDistance; PartialUpdate = other.PartialUpdate; VersionNumber = other.VersionNumber; CustomTransitionQueue = new List <StateTransition>(other.CustomTransitionQueue); }
public void GetHashCode_ReturnsExpectedInt() { // Arrange var stateTransition = new StateTransition(new State(OrderStatus.Initialized), new Trigger(OrderEvent.Accepted)); // Act var result = stateTransition.GetHashCode(); // Assert Assert.Equal(typeof(int), result.GetType()); }
public void ToString_ReturnsExpectedString() { // Arrange var stateTransition = new StateTransition(new State(OrderStatus.Initialized), new Trigger(OrderEvent.Accepted)); // Act var result = stateTransition.ToString(); // Assert Assert.Equal("StateTransition: Initialized -> Accepted", result); }
/// <summary> /// /// </summary> /// <param name="command"></param> /// <returns></returns> public Status GetNext(SendCommand command) { var transition = new StateTransition(CurrentState, command); Status nextState; if (!_transitions.TryGetValue(transition, out nextState)) { throw new CommunicationStateException("Incorrect State"); } return(nextState); }
public void TestTransitionConstructor() { var firstState = new State(); var secondState = new State(); var testTransition = new StateTransition(firstState, secondState, "TransitionTrigger"); Assert.NotNull(testTransition); Assert.True(testTransition.SourceState == firstState); Assert.True(testTransition.TargetState == secondState); Assert.True(testTransition.TransitionTrigger == "TransitionTrigger"); }
protected override void ReadInternal(Reader reader) { transitions = new StateTransition[length]; for (int i = 0; i < transitions.Length; i++) { transitions[i] = new StateTransition(); transitions[i].targetState = new Reference <State>(reader, true); transitions[i].stateToGo = new Reference <State>(reader, true); transitions[i].linkingType = reader.ReadUInt16(); } }
public void ToString_ReturnsExpectedString() { // Arrange var stateTransition = new StateTransition <OrderState>(OrderState.Initialized, Trigger.Event(typeof(OrderAccepted))); // Act var result = stateTransition.ToString(); // Assert Assert.Equal("StateTransition(Initialized -> OrderAccepted)", result); }
public MyRegistrationState GetNext(RegisterCommands command) { StateTransition transition = new StateTransition(CurrentState, command); MyRegistrationState nextState; if (!transitions.TryGetValue(transition, out nextState)) { throw new Exception("Invalid transition: " + CurrentState + " -> " + command); } return(nextState); }
private void GenerateStructure() { foreach (State toState in sm.States) { string stateName = toState.Name; if (stateName == FromState) { continue; } MetaObject mo = StateMachineManager.GetState(ClassName, stateName); HtmlTableRow tr = new HtmlTableRow(); tr.Style.Add(HtmlTextWriterStyle.Height, "25px"); HtmlTableCell td1 = new HtmlTableCell(); HtmlTableCell td2 = new HtmlTableCell(); td1.NoWrap = true; CheckBox cb = new CheckBox(); cb.ID = String.Format("chk{0}", stateName); TextBox txt = new TextBox(); txt.ID = String.Format("txt{0}", stateName); txt.Width = Unit.Percentage(100); if (!IsPostBack) { cb.Text = CHelper.GetResFileString(mo.Properties["FriendlyName"].Value.ToString()); StateTransition st = sm.FindTransition(FromState, stateName); if (st != null) { cb.Checked = true; txt.Text = st.Name; } else { txt.Text = mo.Properties["FriendlyName"].Value.ToString(); txt.Style.Add(HtmlTextWriterStyle.Display, "none"); } } td1.Controls.Add(cb); td2.Controls.Add(txt); tr.Cells.Add(td1); tr.Cells.Add(td2); tblMain.Rows.Add(tr); cb.Attributes.Add("onclick", String.Format("ShowHide('{0}', '{1}')", cb.ClientID, txt.ClientID)); } }
public void AddTransition(SimpleState toState) { if (_transitions.ContainsKey(toState)) { StateTransition transition = _transitions[toState]; } else { _transitions.Add(toState, new StateTransition(this, toState)); } }
public void TestTransitionEquals() { var firstState = new State(); var secondState = new State(); var testTransition1 = new StateTransition(firstState, secondState, "TransitionTrigger"); var testTransition2 = new StateTransition(firstState, secondState, "TransitionTrigger"); var testTransition3 = new StateTransition(secondState, firstState, "TransitionTrigger"); Assert.True(testTransition1.Equals(testTransition2)); Assert.True(!testTransition1.Equals(testTransition3)); }
public override SceneBase GetNext(SceneCommand command) { StateTransition transition = new StateTransition(Current, command); SceneBase nextState; if (!transitions.TryGetValue(transition, out nextState)) { throw new System.Exception("Invalid transition: " + Current + " -> " + command); } return(nextState); }
public static void addStateTransition(CompanionSettings settings, string stateName, string transitionName, FFXICompanion.Settings.Button button, Settings.Key key) { StateTransition stateTransition = new StateTransition(); stateTransition.stateName = stateName; stateTransition.transitionName = transitionName; stateTransition.key = key; ControllerButton controllerButton = new ControllerButton(button, Settings.Action.PRESSED); stateTransition.transitionButtons.Add(controllerButton); settings.stateTransitions.Add(stateTransition); }
void Start() { target = GameController.instance.player; characterData = this.GetComponent<CharacterData>(); animator = this.GetComponent<Animator>(); attack = new Attack(this); idle = new Idle(this); toIdle = new StateTransition(this, idle); toAttack= new StateTransition(this, attack); currentState = idle; }
public void FromState() { var machine = new FiniteStateMachine<UpdateState, string>(); var transition = new StateTransition<UpdateState, string> { FromState = UpdateState.Ready, ToState = UpdateState.DownloadingUpdate, InputValidator = s => s.Equals("Start") }; machine.Transitions.Add( transition ); Assert.AreEqual(UpdateState.Ready, machine.CurrentState); var transitions = machine.Transitions.FromState(machine.CurrentState); Assert.AreEqual(1, transitions.Count()); Assert.AreEqual(transition, transitions.First()); }
public IWindowTransition Create(StateTransition transition, FrameOverlayManager manager) { return new OpacityFadeWindowTransition(transition, manager, mLengthMS, !mFadeOut); }
public void IsValid_throws_InvalidOperationException_if_InputValidator_is_null() { var transition = new StateTransition<string, string>(); transition.IsValid("test"); }
public static void SwitchState(Type state, StateTransition startTransition, StateTransition endTransition) { Core.SwitchState(state, startTransition, endTransition); }
private void TransitState(StateTransition stateTransition) { TimerBar.localScale = Vector3.one; if (Type == CellType.Interactive) { CurrentInteractiveCellStateID = stateTransition.TransitionToID; } else { DoorCellState = stateTransition.TransitionToDoorState; } UpdateCellType(); }
public void SwitchState(Type state, StateTransition startTransition, StateTransition endTransition) { this.CurrentState = null; this.CurrentState = (State)Activator.CreateInstance(state); }
/// <summary> /// Start the transition transition one state to another. /// </summary> /// <param name="transition">The transition to begin.</param> public void BeginTransition(StateTransition transition) { if (Transitioning) throw new InvalidOperationException("Unable to start transition transition " + transition.From.Name + " to " + transition.To.Name + ". There is already a transition in progress."); lock (this) { mCurrentState = null; mCurrentTransition = transition; transition.Finished += mTransitionCompleteListener; } if (TransitionStarting != null) TransitionStarting(transition); transition.Begin(); }
/// <summary> /// Called by ITransitionCommand's when the transitional condition is met, triggers state change /// </summary> public void OnTransition(ITransitionCommand transition) { StateTransition st = new StateTransition(CurrentState,transition); ChangeState(StateTransitions[st]); }
public IWindowTransition Create(StateTransition transition, FrameOverlayManager manager) { return new FeatureFrameTransition(transition, manager, mFactory.Create(mLengthMS)); }
/// <summary> /// Add a new transition to another state. /// </summary> /// <param name="stateTransition">The new transition to add.</param> public void AddTransition(StateTransition stateTransition) { if (stateTransition.From != this) throw new ArgumentException("Error. " + stateTransition.Name + " does not start at " + Name + " so cannot be added as a transition from it."); //TODO - this is a hack and will break things. Need to decide on how to handle multiple triggers. //What happens if new transition needs to be drawn? if (mTransitions.ContainsKey(stateTransition.To.Name)) { mTransitions[stateTransition.To.Name].AddTriggers(stateTransition.Triggers); } else { mTransitions.Add(stateTransition.To.Name, stateTransition); if (stateTransition is IFeature) AddFeature(stateTransition as IFeature); } }
/// <summary> /// Binds the transition buttons. /// </summary> /// <param name="nextTransitions">The next transitions.</param> /// <param name="prevTransitions">The prev transitions.</param> private void BindTransitions(StateTransition[] nextTransitions, StateTransition[] prevTransitions) { if (TransitionList.Items.Count > 0) TransitionList.Items.Clear(); ListItem li; for (int i = 0; i < prevTransitions.Length; i++) { li = new ListItem(CHelper.GetResFileString(prevTransitions[i].Name), prevTransitions[i].Uid.ToString()); TransitionList.Items.Add(li); } for (int i = 0; i < nextTransitions.Length; i++) { li = new ListItem(CHelper.GetResFileString(nextTransitions[i].Name), nextTransitions[i].Uid.ToString()); TransitionList.Items.Add(li); if (i == 0) li.Selected = true; } if (TransitionList.Items.Count > 0 && TransitionList.SelectedItem == null) TransitionList.Items[0].Selected = true; }
/// <summary> /// Initialise the fade transition, specifying how long the fade should last, in ms. /// </summary> /// <param name="transition">The transition this fade is part of.</param> /// <param name="manager">The window this fade is to be drawn on.</param> /// <param name="lengthMS">The length of time, in ms, the fade should last.</param> public OpacityFadeWindowTransition(StateTransition transition, FrameOverlayManager manager, double lengthMS, bool fadeIn) : base(transition, manager) { mLengthMS = lengthMS; mFadeIn = fadeIn; mTickListener = new Action(Coordinator_Tick); Finished += new Action<IWindowTransition>(OpacityFadeWindowTransition_Finished); #if DEBUG StatisticsCollection.AddStatistics(mStatistics, transition.Name + " " + manager.Name); #endif }
public override void SetTransitions() { StateTransition cancellingUnitAction = new StateTransition(TransitionID.Previous, StateID.SelectUnitAction); AddTransition(cancellingUnitAction); StateTransition executingUnitAction = new StateTransition(TransitionID.Next, StateID.ExecuteUnitAction); AddTransition(executingUnitAction); }
/// <summary> /// Map the transitiom from 'fromState' to 'toState'. /// </summary> /// <returns> /// false if there is a transition from 'fromState' matching 'transition', else true; /// </returns> bool MapTransition(FiniteState fromState, ITransitionCommand transition,FiniteState toState,bool cache) { StateTransition st = new StateTransition(fromState,transition); if(StateTransitions.ContainsKey(st)){ return false; } AddState(fromState,cache); AddState(toState,cache); StateTransitions.Add(st,toState); TransitionMap[fromState].Add(transition); if(cache){ StateTransitionState sts = new StateTransitionState();//ScriptableObject.CreateInstance<StateTransitionState>() as StateTransitionState; sts.StartState = fromState; sts.EndState = toState; sts.Transition = transition; StateCache.Add(sts); } return true; }
private void transition_Finished(StateTransition transition) { if (TransitionFinished != null) TransitionFinished(transition); lock (this) { transition.Finished -= mTransitionCompleteListener; CurrentState = transition.To; mCurrentTransition = null; } }
/// <summary> /// Called by 'awake()' to rebuild dictionaries, which Unity doesn't serialize /// </summary> void RebuildStateTransitionMap() { TransitionMap.Clear(); StateTransitions.Clear(); StartState = null; CurrentState = null; //Debug.Log("Rebuilding transition map"); //Unity serialization doesn't work w/ Generic.Dictionary, rebuild from state list foreach(StateTransitionState sts in StateCache){ AddState(sts.StartState,false); AddState(sts.EndState,false); if(sts.StartState!=null && sts.Transition!=null) { StateTransition st = new StateTransition(sts.StartState,sts.Transition); StateTransitions.Add(st,sts.EndState); TransitionMap[sts.StartState].Add(sts.Transition); if(sts.StartState.Start == true){ SetStart(sts.StartState,false); } } if(sts.Valid()){ //Debug.Log("Rebuilding transition from " + sts.StartState.StateName + " to " + sts.EndState.StateName); } else if(sts.StartState!=null && sts.EndState==null){ //Debug.Log("Rebuilding start state w/ no end state <" + sts.StartState.StateName + ">"); } else if(sts.StartState==null && sts.EndState!=null){ //Debug.Log("Rebuilding end state w/ no start state <" + sts.EndState.StateName + ">"); } else if(sts.StartState==null && sts.EndState==null && sts.Transition==null){ //Debug.Log("Warning, disconnected transition <" + sts.Transition.Name + ">"); } } //StateTransition st1 = new StateTransition(StateCache[0].StartState,StateCache[0].Transition); //StateTransition st2 = new StateTransition(StartState,StateCache[0].Transition); //Debug.Log("Comparison Hash. " + st1.GetHashCode() + "==" + st2.GetHashCode()); //Debug.Log("Comparison Equl. " + (st1 == st2).ToString()); }
/// <summary> /// Add a new transition from 1 state to another /// </summary> /// <returns> public ITransitionCommand AddTransition(FiniteState fromState, ITransitionCommand component, FiniteState toState) { component.enabled = false; component.FSM = this; StateTransition st = new StateTransition(fromState,component); //Debug.Log("Adding new transition type " + component.GetType() + " from state " + fromState.StateName + " to state " + toState.StateName); if(!MapTransition(fromState,component,toState)){ Destroy(component); //always delete duplicate transition components //Debug.Log("fromState " + fromState.StateName + " already contains a transition type " + component.GetType().ToString()); return null; } return component; }
public override void SetTransitions() { StateTransition selectingUnit = new StateTransition(TransitionID.Previous, StateID.SelectUnit); AddTransition(selectingUnit); StateTransition changingTurns = new StateTransition(TransitionID.Next, StateID.ChangeTurns); AddTransition(changingTurns); }
private bool CheckStateTransition(StateTransition stateTransition) { for (int i = 0; i < stateTransition.Conditions.Count; i++) { if (stateTransition.Conditions[i].Cell.CurrentInteractiveCellStateID != stateTransition.Conditions[i].CellStateID) { return false; } } return true; }
public override void SetTransitions() { StateTransition deselectingUnit = new StateTransition(TransitionID.Previous, StateID.SelectUnit); AddTransition(deselectingUnit); StateTransition confirmingUnitMove = new StateTransition(TransitionID.Next, StateID.SelectUnitAction); AddTransition(confirmingUnitMove); }