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');
}
