public static TriggerConfigurer FromMessage <TStateMachine, TMessage, TMessageContext>( this TriggerConfigurer configurer, Func <TMessage, TMessageContext, Guid> correlationFunc, Func <TStateMachine, TMessage, TMessageContext, Task> machineFunc, Action <IConsumerConfigurationBuilder> consumeConfig = null ) { Func <object[], Task <Acknowledgement> > genericHandler = args => machineFunc((TStateMachine)args[0], (TMessage)args[1], (TMessageContext)args[2]) .ContinueWith <Acknowledgement>(t => new Ack()); Func <object, object, Guid> genericCorrFunc = (msg, ctx) => correlationFunc((TMessage)msg, (TMessageContext)ctx); return(configurer.From(SubscribePipe, context => { var stateMachineContext = new StateMachineContext(context); stateMachineContext.Properties.Add(StateMachineKey.Type, typeof(TStateMachine)); stateMachineContext.AddMessageContextType <TMessageContext>(); stateMachineContext.Properties.Add(StateMachineKey.CorrelationFunc, genericCorrFunc); stateMachineContext.UseLazyCorrelationArgs(ctx => new[] { ctx.GetMessage(), ctx.GetMessageContext() }); stateMachineContext.Properties.Add(PipeKey.MessageType, typeof(TMessage)); stateMachineContext.Properties.Add(PipeKey.ConfigurationAction, consumeConfig); stateMachineContext.Properties.Add(PipeKey.MessageHandler, genericHandler); stateMachineContext.UseLazyHandlerArgs(ctx => new[] { ctx.GetStateMachine(), ctx.GetMessage(), ctx.GetMessageContext() }); })); }
private static async Task <JToken> EnterState(State state, StateMachineContext context) { Debug.Assert(state != null); Debug.Assert(context != null); await context.RecordObservableActionAsync(ObservableAction.EnterState, () => new Dictionary <string, object> { { "stateName", state.Name } }); var data = state.InputFilter?.EvalExpr(context.Data, context) ?? context.Data; Debug.Assert(data != null); if (state.EnterAction != null) { var result = await state.EnterAction.ExecuteAsync(context, data); Debug.Assert(result != null); result.Merge(context.Data, state.EnterResultHandler, context); } return(data); }
public void setControlsEnabled(bool enabled) { EventDispatcher eventDispatcher = Service.Get <EventDispatcher>(); if (enabled) { eventDispatcher.DispatchEvent(new UIDisablerEvents.EnableUIElement("ControlsButton2")); eventDispatcher.DispatchEvent(new UIDisablerEvents.EnableUIElement("ActionButton")); eventDispatcher.DispatchEvent(new UIDisablerEvents.EnableUIElement("ChatButtons")); eventDispatcher.DispatchEvent(new UIDisablerEvents.EnableUIElementGroup("MainNavButtons")); eventDispatcher.DispatchEvent(new UIDisablerEvents.EnableUIElement("CellphoneButton")); return; } eventDispatcher.DispatchEvent(new UIDisablerEvents.DisableUIElement("ControlsButton2")); eventDispatcher.DispatchEvent(new UIDisablerEvents.DisableUIElement("ActionButton")); eventDispatcher.DispatchEvent(new UIDisablerEvents.DisableUIElement("ChatButtons")); eventDispatcher.DispatchEvent(new UIDisablerEvents.DisableUIElementGroup("MainNavButtons")); eventDispatcher.DispatchEvent(new UIDisablerEvents.DisableUIElement("CellphoneButton")); StateMachineContext component = GameObject.FindWithTag(UIConstants.Tags.UI_Tray_Root).GetComponent <StateMachineContext>(); if (component != null) { component.SendEvent(new ExternalEvent("Root", "mainnav_locomotion")); } }
public void StateTransitionedToSameStateTest() { var stateMachine = new StateMachine(); IStateMachineEvent e1 = stateMachine.AddNewEvent("Event1"); IStateMachineEvent e2 = stateMachine.AddNewEvent("Event2"); var initial = stateMachine.AddNewState("Initial") as StateMachineState; var first = stateMachine.AddNewState("First") as StateMachineState; initial.AddNewTransition(e1, first); first.AddNewTransition(e1, initial); first.AddNewTransition(e2, first); var context = new StateMachineContext(stateMachine, initial, null); context.Start(); context.HandleEvent(e2); Assert.That(context.CurrentState, Is.SameAs(initial)); context.HandleEvent(e1); Assert.That(context.CurrentState, Is.SameAs(first)); context.HandleEvent(e2); Assert.That(context.CurrentState, Is.SameAs(first)); }
private void Start() { string startEvent = GetComponentInParent <SEDFSMStartEventSource>().StartEvent; StateMachineContext component = GetComponent <StateMachineContext>(); component.SendEvent(new ExternalEvent(FSMName, startEvent)); }
private IEnumerator Start() { if (!string.IsNullOrEmpty(StateMachineToCheck)) { StateMachineContext stateMachineContext = GetComponentInParent <StateMachineContext>(); while (!stateMachineContext.ContainsStateMachine(StateMachineToCheck)) { yield return(null); } string state = stateMachineContext.GetStateMachineState(StateMachineToCheck); int num = 0; while (true) { if (num < StatesToEvents.Length) { if (StatesToEvents[num].State == state) { break; } num++; continue; } yield break; } stateMachineContext.SendEvent(new ExternalEvent(Target, StatesToEvents[num].Event)); } else { Log.LogError(this, "StateMachineToCheck was null or empty"); } }
private static bool TryHandleError(this ModelAction action, JToken error, StateMachineContext context, out RetryPolicy?retry) { Debug.Assert(action != null); Debug.Assert(context != null); retry = null; if (action.ErrorHandlers != null) { foreach (var handler in action.ErrorHandlers) { if (handler.Condition?.EvalPredicateExpr(error, context) ?? true) { error.Merge(context.Data, handler.ResultHandler, context); retry = context.Workflow.Retries?.SingleOrDefault(r => r.Name.IsEqualTo(handler.RetryPolicy ?? string.Empty)); return(true); } } } return(false); }
protected override void OnEnable() { if (!Owner.CompareTag("Player")) { return; } EventDispatcher eventDispatcher = Service.Get <EventDispatcher>(); MascotController componentInParent = ClubPenguin.SceneRefs.ActionSequencer.GetTrigger(Owner).GetComponentInParent <MascotController>(); Mascot mascot = componentInParent.Mascot; if (mascot.InteractionBehaviours.ZoomIn && Controller != null) { CinematographyEvents.CameraLogicChangeEvent evt = default(CinematographyEvents.CameraLogicChangeEvent); evt.Controller = Controller; eventDispatcher.DispatchEvent(evt); } if (mascot.InteractionBehaviours.LowerTray && TrayClosed) { GameObject gameObject = GameObject.FindWithTag(UIConstants.Tags.UI_Tray_Root); if (gameObject != null) { StateMachineContext component = gameObject.GetComponent <StateMachineContext>(); component.SendEvent(new ExternalEvent("Root", "minnpc")); } } if (MainNavDisabled) { eventDispatcher.DispatchEvent(new PlayerCardEvents.SetEnablePlayerCard(enable: false)); eventDispatcher.DispatchEvent(new UIDisablerEvents.DisableUIElementGroup("MainNavButtons")); } if (mascot.InteractionBehaviours.SuppressQuestNotifier) { eventDispatcher.DispatchEvent(new HudEvents.SuppressQuestNotifier(suppress: true, autoShow: true)); } if (mascot.InteractionBehaviours.MoveToTalkSpot) { LocomoteToAction component2 = Owner.GetComponent <LocomoteToAction>(); if (component2 != null) { component2.IsEnabled = true; if (mascot.InteractionBehaviours.OverrideInteracteeTxform) { component2.Waypoints = new List <Transform>(1); component2.IsEnabled = true; Transform transform = new GameObject().transform; transform.position = mascot.InteractionBehaviours.DesiredInteracteeTxform.position; transform.rotation = mascot.InteractionBehaviours.DesiredInteracteeTxform.rotation; component2.Waypoints.Add(transform); } } } else { LocomoteToAction component2 = Owner.GetComponent <LocomoteToAction>(); if (component2 != null) { component2.IsEnabled = false; } } }
public static async Task <bool> ShouldRetryAsync(this RetryPolicy retryPolicy, StateMachineContext context, int attempts, TimeSpan elapsedDelay) { context.CheckArgNull(nameof(context)); if (retryPolicy == null) { return(false); } else if (attempts >= retryPolicy.MaxAttempts) { return(false); } else if (retryPolicy.Delay != null) { var delay = attempts == 1 ? retryPolicy.Delay.Value : elapsedDelay; if (retryPolicy.Increment != null) { delay += retryPolicy.Increment.Value; } else if (retryPolicy.Multiplier != null) { delay *= retryPolicy.Multiplier.Value; }
public static async Task <JToken> ExecuteAsync(this SequenceAction action, StateMachineContext context, JToken input) { action.CheckArgNull(nameof(action)); context.CheckArgNull(nameof(context)); input.CheckArgNull(nameof(input)); var output = new JObject(); for (var idx = 0; idx < action.Actions.Count; idx++) { var childAction = action.Actions.ElementAt(idx); Debug.Assert(childAction != null); var id = string.IsNullOrWhiteSpace(childAction.Name) ? idx.ToString() : childAction.Name; Debug.Assert(!string.IsNullOrWhiteSpace(id)); output[id] = await childAction.ExecuteAsync(context, input); } return(output); }
internal StateMachineContext Build() { var machine = new ControllerStateMachine(actions, deviceControllerOptions, new SystemDateTimeUtcClock(), logger); machine.ShutterStepPosition = shutterStepPosition; machine.ShutterLimitSwitches = shutterSensorState; var context = new StateMachineContext { Actions = actions, Machine = machine }; if (initializeRotatorStateMachine) { var rotatorState = Activator.CreateInstance(rotatorStartType, machine) as IRotatorState; machine.Initialize(rotatorState); } if (initializeShuttterStateMachine) { var shutterState = Activator.CreateInstance(shutterStartType, machine) as IShutterState; machine.Initialize(shutterState); } if (rotatorIsRotating) { machine.AzimuthMotorActive = true; machine.AtHome = false; machine.AzimuthDirection = RotationDirection.Clockwise; // Arbitrary choice machine.AzimuthEncoderPosition = 100; // Arbitrary choice } return(context); }
private void onPromptButtonPressed(DPrompt.ButtonFlags pressed) { if (pressed != DPrompt.ButtonFlags.YES) { return; } LocomotionController currentController = LocomotionHelper.GetCurrentController(base.gameObject); if (currentController is SitController) { LocomotionHelper.SetCurrentController <SwimController>(base.gameObject); } bubbleState = BubbleState.TransitionToHidden; playAudioEvent(mutableData.AirCriticalAudioEvent, EventAction.StopSound); GameObject gameObject = GameObject.FindWithTag(UIConstants.Tags.UI_Tray_Root); if (gameObject != null) { StateMachineContext component = gameObject.GetComponent <StateMachineContext>(); if (component != null) { component.SendEvent(new ExternalEvent("Root", "noUI")); } } Invoke("startBubbleScreenWipe", 0.7f); swimController.ResurfaceAccepted(); dispatcher.DispatchEvent(default(DivingEvents.PlayerResurfaced)); }
public void ShouldExecuteEventActionsWhenLoadedFromDSL() { var stateMachine = new StateMachine(); var builder = _factory.Create <StateMachineBuilder>("EventActionTestMachine.boo"); builder.BuildStateMachine(stateMachine); var context = new StateMachineContext(stateMachine, null, null); context.Start(); TestStateMachineTask.Clear(); context.HandleEvent(1); Assert.That(TestStateMachineTask.EventHistory.Count, Is.EqualTo(1)); context.HandleEvent(2); Assert.That(TestStateMachineTask.EventHistory.Count, Is.EqualTo(2)); context.HandleEvent(1); Assert.That(TestStateMachineTask.EventHistory.Count, Is.EqualTo(3)); }
private void OnDestroy() { if (!string.IsNullOrEmpty(Target)) { StateMachineContext stateMachineContext = GetComponentInParent <StateMachineContext>(); if (stateMachineContext == null) { GameObject gameObject = GameObject.FindGameObjectWithTag(UIConstants.Tags.UI_Tray_Root); if (!gameObject.IsDestroyed()) { stateMachineContext = gameObject.GetComponent <StateMachineContext>(); } } if (stateMachineContext != null) { stateMachineContext.SendEvent(new ExternalEvent(Target, Event)); } else if (!AllowMissingStateMachine) { Log.LogError(this, "Could not find a StateMachineContext"); } } else { StateMachine component = GetComponent <StateMachine>(); if (component != null) { component.SendEvent(Event); } else { Log.LogError(this, "Could not find a StateMachine"); } } }
public static async Task <JToken> ExecuteAsync(this SendEventAction action, StateMachineContext context, JToken input) { action.CheckArgNull(nameof(action)); context.CheckArgNull(nameof(context)); input.CheckArgNull(nameof(input)); var eventDefinition = context.Workflow.Events.SingleOrDefault(ev => ev.Name.IsEqualTo(action.Event)); if (eventDefinition == null) { throw new InvalidOperationException("Unable to resolve event definition: " + action.Event); } JToken payload = action.Expression?.EvalExpr(input, context) ?? new JObject(); var evt = context.Host.CreateEventInstance(eventDefinition.Name, eventDefinition.Type, eventDefinition.Source, payload, action.ContextAttributes); Debug.Assert(evt != null); await context.Host.SendEventsAsync(new[] { evt }, context.CancelToken); return(JValue.CreateNull()); }
private IEnumerator AutoTransition() { yield return(new WaitForSeconds(4.15f)); StateMachineContext smc = GetComponentInParent <StateMachineContext>(); smc.SendEvent(new ExternalEvent("AccountRootFSM", "closepopup")); }
private void Start() { settingsTweener = GetComponentInChildren <SettingsTweener>(); smContext = GetComponentInParent <StateMachineContext>(); Service.Get <ICPSwrveService>().Action("view.settings", "start"); Service.Get <EventDispatcher>().AddListener <AccessibilityEvents.AccessibilityScaleUpdated>(onTextScaleChanged); Service.Get <EventDispatcher>().DispatchEvent(default(CellPhoneEvents.HideLoadingScreen)); }
/// <summary> /// Starts the specified state machine name. /// </summary> /// <param name="stateMachineName">Name of the state machine.</param> /// <param name="domainContext">The domain context.</param> /// <returns>The workflow</returns> public IStateMachineContext Start(string stateMachineName, object domainContext) { IStateMachine stateMachine = _stateMachineService.CreateStateMachine(stateMachineName); var machineContext = new StateMachineContext(stateMachine, domainContext, this); machineContext.Start(); return(machineContext); }
protected override void onHandle(NavBarSecondaryInputMap.Result inputResult) { if (inputResult.Close.WasJustReleased || inputResult.Locomotion.Direction.sqrMagnitude > float.Epsilon) { StateMachineContext componentInParent = GetComponentInParent <StateMachineContext>(); componentInParent.SendEvent(new ExternalEvent(target, targetEvent)); } }
public static async Task <JToken> ExecuteAsync(this ParallelAction action, StateMachineContext context, JToken input) { action.CheckArgNull(nameof(action)); context.CheckArgNull(nameof(context)); input.CheckArgNull(nameof(input)); var output = new JObject(); var tasks = action.Actions.Select(async(a, idx) => { var item = await a.ExecuteAsync(context, input.DeepClone()); Debug.Assert(item != null); var id = string.IsNullOrWhiteSpace(a.Name) ? idx.ToString() : a.Name; return(id, item); }).ToList(); if (action.CompletionType == ParallelCompletionType.And) { var results = await Task.WhenAll(tasks); Array.ForEach(results, tuple => output[tuple.id] = tuple.item); } else if (action.CompletionType == ParallelCompletionType.Xor) { var resultTask = await Task.WhenAny(tasks); var tuple = await resultTask; output[tuple.id] = tuple.item; } else { Debug.Assert(action.CompletionType == ParallelCompletionType.N_of_M); Debug.Assert(action.N > 0); var resultCount = 0; while (resultCount < action.N && resultCount < tasks.Count) { var resultTask = await Task.WhenAny(tasks); tasks.Remove(resultTask); var tuple = await resultTask; output[tuple.id] = tuple.item; resultCount++; } } return(output); }
public async Task TestNextState() { var context = StateMachineContext.Create <BasicEnum, TestTransitionEnum, object>(null, new StateMachineState <BasicEnum, TestTransitionEnum, object>(BasicEnum.Start, null, null, null), null); await Task.Delay(100); context.SetState(new StateMachineState <BasicEnum, TestTransitionEnum, object>(BasicEnum.Stop, null, null, null)); Assert.IsTrue(context.TotalElapsedTime > context.StateElapsedTime); Assert.AreEqual(BasicEnum.Stop, context.CurrentState.State); }
private bool onMainNavBarBackButtonClicked(MainNavBarBackButton.MainNavBarBackButtonClicked evt) { if (base.enabled) { StateMachineContext componentInChildren = GameObject.FindWithTag(UIConstants.Tags.UI_Tray_Root).GetComponentInChildren <StateMachineContext>(); componentInChildren.SendEvent(new ExternalEvent(Target, Event)); } return(false); }
public void OnOpenButtonPressed() { GetComponentInParent <QuestsScreenController>().CurrentChapterData = chapterData; GameObject gameObject = GameObject.FindWithTag(UIConstants.Tags.UI_Tray_Root); StateMachineContext component = gameObject.GetComponent <StateMachineContext>(); component.SendEvent(new ExternalEvent("ScreenQuestsAdventures", "logQuests")); removeBreadcrumb(); }
private void findWorldTrayFSMContext() { GameObject gameObject = GameObject.FindWithTag(UIConstants.Tags.UI_Tray_Root); if (gameObject != null) { trayFSMContext = gameObject.GetComponent <StateMachineContext>(); } }
public void MarketplaceScreenOutroComplete() { if (hasOpened) { Object.Destroy(base.gameObject); GameObject gameObject = GameObject.FindWithTag(UIConstants.Tags.UI_Tray_Root); StateMachineContext component = gameObject.GetComponent <StateMachineContext>(); component.SendEvent(new ExternalEvent("Root", "mainnav_locomotion")); } }
/// <summary> /// Starts the specified state machine name. /// </summary> /// <param name="stateMachineName">Name of the state machine.</param> /// <param name="domainContext">The domain context.</param> /// <param name="domainContextStateProperty">The domain context state property.</param> /// <returns>The workflow</returns> public IStateMachineContext Start(string stateMachineName, object domainContext, string domainContextStateProperty) { IStateMachine stateMachine = _stateMachineService.CreateStateMachine(stateMachineName); var machineContext = new StateMachineContext(stateMachine, new ReflectiveDomainContextWrapper(domainContext, domainContextStateProperty), this); machineContext.Start(); return(machineContext); }
public static Task <JToken> ExecuteAsync(this InjectDataAction action, StateMachineContext context, JToken input) { action.CheckArgNull(nameof(action)); context.CheckArgNull(nameof(context)); input.CheckArgNull(nameof(input)); return(Task.FromResult(action.Expression.EvalExpr(input, context) ?? JValue.CreateNull())); }
protected override void onHandle(NavBarTitleInputMap.Result inputResult) { back.HandleMappedInput(inputResult.Back); exit.HandleMappedInput(inputResult.Exit); if (inputResult.Locomotion.Direction.sqrMagnitude > float.Epsilon) { StateMachineContext componentInParent = GetComponentInParent <StateMachineContext>(); componentInParent.SendEvent(new ExternalEvent(target, targetEvent)); } }
private void onCellPhonePrefabLoaded(string path, GameObject cellPhonePrefab) { GameObject popup = Object.Instantiate(cellPhonePrefab); PopupEvents.ShowCameraSpacePopup evt = new PopupEvents.ShowCameraSpacePopup(popup, destroyPopupOnBackPressed: false, scaleToFit: true, "Accessibility.Popup.Title.CellPhone", "MainCamera", 1f, 0); Service.Get <EventDispatcher>().DispatchEvent(evt); StateMachineContext componentInParent = GetComponentInParent <StateMachineContext>(); componentInParent.SendEvent(new ExternalEvent("Root", "noui")); }
private IEnumerator sendLoadedEvent() { while (smContext == null) { yield return(null); smContext = GetComponentInParent <StateMachineContext>(); } smContext.SendEvent(new ExternalEvent(fsmTarget, "loaded")); }
public void When_Trigger_Does_Not_Exist() { var stateMachine = new StateMachineBuilder().CreateStateMachine<char, int, StateMachineContext<char>>( sm => sm.DefineState('a') .WithTrigger(1, 'b') ); var originalContext = new StateMachineContext<char>('a'); Assert.Throws<InvalidTriggerException<char, int>>(() => stateMachine.Fire(originalContext, 2)); }
public void When_Predicate_Triggering_With_Non_Matching_Value() { var stateMachine = new StateMachineBuilder().CreateStateMachine<char, int, StateMachineContext<char>>( sm => sm.DefineState('a') .WithTrigger(1, (string x) => x == "yes", 'x') .WithTrigger(1, (string x) => x == "no", 'y') ); var originalContext = new StateMachineContext<char>('a'); Assert.Throws<InvalidTriggerException<char, int>>(() => stateMachine.Fire(originalContext, 1, "maybe")); }
public void When_Predicate_Triggering_With_Matching_Value() { var stateMachine = new StateMachineBuilder().CreateStateMachine<char, int, StateMachineContext<char>>( sm => sm.DefineState('a') .WithTrigger(1, (string x) => x == "yes", 'x') .WithTrigger(1, (string x) => x == "no", 'y') ); var originalContext = new StateMachineContext<char>('a'); Assert.Equal('x', stateMachine.Fire(originalContext, 1, "yes").GetState()); Assert.Equal('y', stateMachine.Fire(originalContext, 1, "no").GetState()); }
public void When_Trigger_Exists() { var stateMachine = new StateMachineBuilder().CreateStateMachine<char, int, StateMachineContext<char>>( sm => sm.DefineState('a') .WithTrigger(1, 'b') ); var originalContext = new StateMachineContext<char>('a'); var newContext = stateMachine.Fire(originalContext, 1); Assert.Equal(newContext.GetState(), 'b'); }