public IEnumerator ActivateOnlyAfterOnePass()
{
// Given a behaviors sequence,
EndlessBehavior endlessBehavior = new EndlessBehavior();
BehaviorSequence sequence = new BehaviorSequence(true, new List <IBehavior> {
endlessBehavior
});
// When we activate it,
sequence.LifeCycle.Activate();
yield return(null);
sequence.Update();
// Then it is activated only after one pass.
endlessBehavior.LifeCycle.MarkToFastForward();
yield return(null);
sequence.Update();
yield return(null);
sequence.Update();
Assert.AreEqual(Stage.Active, sequence.LifeCycle.Stage);
// Cleanup.
sequence.LifeCycle.Deactivate();
}
public IEnumerator BehaviorSequence()
{
// Given a training with a behaviors sequence
BehaviorSequence sequence = new BehaviorSequence(true, new List <IBehavior>
{
new DelayBehavior(0f),
new EmptyBehaviorMock()
});
ICourse course = new LinearTrainingBuilder("Training")
.AddChapter(new LinearChapterBuilder("Chapter")
.AddStep(new BasicStepBuilder("Step")
.AddBehavior(sequence)))
.Build();
// When we serialize and deserialize it
ICourse deserializedCourse = Serializer.CourseFromByteArray(Serializer.CourseToByteArray(course));
BehaviorSequence deserializedSequence = deserializedCourse.Data.FirstChapter.Data.FirstStep.Data.Behaviors.Data.Behaviors.First() as BehaviorSequence;
// Then the values stay the same.
Assert.IsNotNull(deserializedSequence);
Assert.AreEqual(sequence.Data.PlaysOnRepeat, deserializedSequence.Data.PlaysOnRepeat);
List <IBehavior> behaviors = sequence.Data.Behaviors;
List <IBehavior> deserializedBehaviors = deserializedSequence.Data.Behaviors;
Assert.AreEqual(behaviors.First().GetType(), deserializedBehaviors.First().GetType());
Assert.AreEqual(behaviors.Last().GetType(), deserializedBehaviors.Last().GetType());
Assert.AreEqual(behaviors.Count, deserializedBehaviors.Count);
yield break;
}
public IEnumerator FastForwardInactiveBehavior()
{
// Given a sequence with two behaviors,
BehaviorSequence sequence = new BehaviorSequence(false, new List <IBehavior>
{
new DelayBehavior(shortDelay),
new DelayBehavior(shortDelay)
});
// When we mark it to fast-forward,
sequence.LifeCycle.MarkToFastForward();
// Then it doesn't autocomplete because it hasn't been activated yet.
Assert.AreEqual(Stage.Inactive, sequence.LifeCycle.Stage);
yield break;
}
public IEnumerator UnskipChild()
{
// Given an activating repeating behavior sequence of one not optional and one skipped optional behavior,
OptionalEndlessBehavior optional = new OptionalEndlessBehavior();
EndlessBehavior notOptional = new EndlessBehavior();
BehaviorSequence sequence = new BehaviorSequence(true, new List <IBehavior>
{
notOptional,
optional,
});
sequence.Configure(RuntimeConfigurator.Configuration.GetCurrentMode());
sequence.LifeCycle.Activate();
yield return(null);
sequence.Update();
notOptional.LifeCycle.MarkToFastForwardStage(Stage.Activating);
notOptional.LifeCycle.MarkToFastForwardStage(Stage.Deactivating);
sequence.Configure(new Mode("Test", new WhitelistTypeRule <IOptional>().Add <OptionalEndlessBehavior>()));
yield return(null);
sequence.Update();
//When you re-enable it,
sequence.Configure(RuntimeConfigurator.Configuration.GetCurrentMode());
notOptional.LifeCycle.MarkToFastForwardStage(Stage.Activating);
notOptional.LifeCycle.MarkToFastForwardStage(Stage.Deactivating);
while (optional.LifeCycle.Stage != Stage.Activating)
{
yield return(null);
sequence.Update();
}
// Then it is not skipped when it's its turn.
Assert.AreEqual(Stage.Activating, optional.LifeCycle.Stage);
}
public IEnumerator SkipChildNotWhenItIsExecuted()
{
// Given an activating behavior sequence of one not optional and one optional behavior,
OptionalEndlessBehavior optional = new OptionalEndlessBehavior();
EndlessBehavior notOptional = new EndlessBehavior();
BehaviorSequence sequence = new BehaviorSequence(false, new List <IBehavior>
{
notOptional,
optional,
});
sequence.Configure(RuntimeConfigurator.Configuration.GetCurrentMode());
sequence.LifeCycle.Activate();
yield return(null);
sequence.Update();
// When the optional behavior is marked to be skipped before it was its turn,
sequence.Configure(new Mode("Test", new WhitelistTypeRule <IOptional>().Add <OptionalEndlessBehavior>()));
notOptional.LifeCycle.MarkToFastForwardStage(Stage.Activating);
notOptional.LifeCycle.MarkToFastForwardStage(Stage.Deactivating);
while (notOptional.LifeCycle.Stage != Stage.Inactive)
{
yield return(null);
sequence.Update();
}
while (sequence.LifeCycle.Stage != Stage.Active)
{
Assert.AreEqual(Stage.Inactive, optional.LifeCycle.Stage);
yield return(null);
sequence.Update();
}
// Then it is skipped.
Assert.AreEqual(Stage.Active, sequence.LifeCycle.Stage);
yield break;
}
public IEnumerator FastForwardInactiveRepeatingBehaviorAndActivateIt()
{
// Given a sequence with two behaviors,
BehaviorSequence sequence = new BehaviorSequence(true, new List <IBehavior>
{
new DelayBehavior(shortDelay),
new DelayBehavior(shortDelay)
});
// When we mark it to fast-forward and activate it,
sequence.LifeCycle.MarkToFastForward();
sequence.LifeCycle.Activate();
// Then the behavior should be activated immediately.
Assert.AreEqual(Stage.Active, sequence.LifeCycle.Stage);
// Cleanup.
sequence.LifeCycle.Deactivate();
yield break;
}
/// <inheritdoc />
public override IBehavior GetNewItem()
{
DelayBehavior delayBehavior = new DelayBehavior(5f);
delayBehavior.Data.Name = "Wait for";
PlayAudioBehavior audioBehavior = new PlayAudioBehavior(new TextToSpeechAudio(new LocalizedString()), BehaviorExecutionStages.Activation);
audioBehavior.Data.Name = "Play Audio";
BehaviorSequence behaviorSequence = new BehaviorSequence(true, new List <IBehavior>
{
delayBehavior,
audioBehavior
});
behaviorSequence.Data.Name = "Audio Hint";
behaviorSequence.Data.IsBlocking = false;
return(behaviorSequence);
}
public IEnumerator DoNotRepeat()
{
// Given a behaviors sequence with RepeatsMode = Once,
DelayBehavior childBehavior = new DelayBehavior(shortDelay);
BehaviorSequence sequence = new BehaviorSequence(false, new List <IBehavior> {
childBehavior
});
// When we activate it,
sequence.LifeCycle.Activate();
yield return(null);
sequence.Update();
// Then it completes its activation only after every child behavior was activated once.
Assert.AreEqual(Stage.Activating, sequence.LifeCycle.Stage);
Assert.AreEqual(Stage.Activating, childBehavior.LifeCycle.Stage);
while (childBehavior.LifeCycle.Stage != Stage.Active)
{
yield return(null);
sequence.Update();
}
while (sequence.LifeCycle.Stage != Stage.Active)
{
yield return(null);
sequence.Update();
Assert.AreNotEqual(Stage.Activating, childBehavior.LifeCycle.Stage);
}
Assert.AreEqual(Stage.Active, sequence.LifeCycle.Stage);
// Cleanup.
sequence.LifeCycle.Deactivate();
}
public IEnumerator BehaviorsActivatedInSuccession()
{
// Given a sequence with two behaviors,
BehaviorSequence sequence = new BehaviorSequence(true, new List <IBehavior>
{
new DelayBehavior(shortDelay),
new DelayBehavior(shortDelay)
});
// When we activate it,
sequence.LifeCycle.Activate();
// One is activated only after the previous one is deactivated.
yield return(null);
sequence.Update();
List <IBehavior> behaviors = sequence.Data.Behaviors;
Assert.AreEqual(Stage.Activating, behaviors[0].LifeCycle.Stage);
while (behaviors[0].LifeCycle.Stage != Stage.Inactive)
{
Assert.AreEqual(Stage.Inactive, behaviors[1].LifeCycle.Stage);
yield return(null);
sequence.Update();
}
yield return(null);
sequence.Update();
Assert.AreEqual(Stage.Activating, behaviors[1].LifeCycle.Stage);
// Cleanup.
sequence.LifeCycle.Deactivate();
}
private void BehaviorSequenceHandler(object sender, RoutedEventArgs e)
{
if(TrialSequence.Count > 0) {
currentSequence = TrialSequence.Last();
TrialSequence.RemoveAt(TrialSequence.Count -1);
SequenceButton.Content = "Next Trial (" + TrialSequence.Count + ")";
SequenceButton.IsEnabled = false;
RunBehaviorSequence();
}
else
MessageBox.Show("All Trials Completed!!.",
"Trials Completed");
}
