public IEnumerator UnlockObjectBehavior()
{
// Given a training with UnlockObjectBehavior
TrainingSceneObject trainingSceneObject = TestingUtils.CreateSceneObject("TestObject");
ICourse training1 = new LinearTrainingBuilder("Training")
.AddChapter(new LinearChapterBuilder("Chapter")
.AddStep(new BasicStepBuilder("Step")
.AddBehavior(new UnlockObjectBehavior(trainingSceneObject))))
.Build();
// When we serialize and deserialize it
ICourse training2 = Serializer.CourseFromByteArray(Serializer.CourseToByteArray(training1));
UnlockObjectBehavior behavior1 = training1.Data.FirstChapter.Data.FirstStep.Data.Behaviors.Data.Behaviors.First() as UnlockObjectBehavior;
UnlockObjectBehavior behavior2 = training2.Data.FirstChapter.Data.FirstStep.Data.Behaviors.Data.Behaviors.First() as UnlockObjectBehavior;
// Then that behavior's target should not change.
Assert.IsNotNull(behavior1);
Assert.IsNotNull(behavior2);
Assert.AreEqual(behavior1.Data.Target.Value, behavior2.Data.Target.Value);
// Cleanup
TestingUtils.DestroySceneObject(trainingSceneObject);
return(null);
}
public IEnumerator GameObjectStaysDisabled()
{
// Given an active training scene object and a training course with disable game object behavior,
TrainingSceneObject toDisable = TestingUtils.CreateSceneObject("ToDisable");
EndlessConditionMock trigger = new EndlessConditionMock();
ICourse course = new LinearTrainingBuilder("Course")
.AddChapter(new LinearChapterBuilder("Chapter")
.AddStep(new BasicCourseStepBuilder("Step")
.Disable(toDisable))
.AddStep(new BasicCourseStepBuilder("Step")
.AddCondition(trigger)))
.Build();
course.Configure(RuntimeConfigurator.Configuration.Modes.CurrentMode);
// When the behavior is activated and after the step is completed
CourseRunner.Initialize(course);
CourseRunner.Run();
yield return(new WaitUntil(() => course.Data.FirstChapter.Data.Steps[1].LifeCycle.Stage == Stage.Active));
trigger.Autocomplete();
yield return(new WaitUntil(() => course.Data.FirstChapter.Data.Steps[1].LifeCycle.Stage == Stage.Inactive));
// Then the training scene object stays disabled.
Assert.False(toDisable.GameObject.activeSelf);
// Cleanup.
TestingUtils.DestroySceneObject(toDisable);
yield break;
}
public IEnumerator MoveObjectBehavior()
{
// Given training with MoveObjectBehavior
TrainingSceneObject moved = TestingUtils.CreateSceneObject("moved");
TrainingSceneObject positionProvider = TestingUtils.CreateSceneObject("positionprovider");
ICourse training1 = new LinearTrainingBuilder("Training")
.AddChapter(new LinearChapterBuilder("Chapter")
.AddStep(new BasicStepBuilder("Step")
.AddBehavior(new MoveObjectBehavior(moved, positionProvider, 24.7f))))
.Build();
// When that training is serialized and deserialzied
ICourse training2 = Serializer.CourseFromByteArray(Serializer.CourseToByteArray(training1));
// Then we should have two identical move object behaviors
MoveObjectBehavior behavior1 = training1.Data.FirstChapter.Data.FirstStep.Data.Behaviors.Data.Behaviors.First() as MoveObjectBehavior;
MoveObjectBehavior behavior2 = training2.Data.FirstChapter.Data.FirstStep.Data.Behaviors.Data.Behaviors.First() as MoveObjectBehavior;
Assert.IsNotNull(behavior1);
Assert.IsNotNull(behavior2);
Assert.IsFalse(ReferenceEquals(behavior1, behavior2));
Assert.AreEqual(behavior1.Data.Target.Value, behavior2.Data.Target.Value);
Assert.AreEqual(behavior1.Data.PositionProvider.Value, behavior2.Data.PositionProvider.Value);
Assert.AreEqual(behavior1.Data.Duration, behavior2.Data.Duration);
// Cleanup created game objects.
TestingUtils.DestroySceneObject(moved);
TestingUtils.DestroySceneObject(positionProvider);
return(null);
}
public IEnumerator EnableGameObjectBehavior()
{
// Given EnableGameObjectBehavior,
TrainingSceneObject trainingSceneObject = TestingUtils.CreateSceneObject("TestObject");
ICourse training1 = new LinearTrainingBuilder("Training")
.AddChapter(new LinearChapterBuilder("Chapter")
.AddStep(new BasicCourseStepBuilder("Step")
.Enable("TestObject")))
.Build();
// When we serialize and deserialize a training course with it
ICourse training2 = Serializer.CourseFromByteArray(Serializer.CourseToByteArray(training1));
EnableGameObjectBehavior behavior1 = training1.Data.FirstChapter.Data.FirstStep.Data.Behaviors.Data.Behaviors.First() as EnableGameObjectBehavior;
EnableGameObjectBehavior behavior2 = training2.Data.FirstChapter.Data.FirstStep.Data.Behaviors.Data.Behaviors.First() as EnableGameObjectBehavior;
// Then it's target training scene object is still the same.
Assert.IsNotNull(behavior1);
Assert.IsNotNull(behavior2);
Assert.AreEqual(behavior1.Data.Target.Value, behavior2.Data.Target.Value);
TestingUtils.DestroySceneObject(trainingSceneObject);
return(null);
}
public IEnumerator ObjectInRangeCondition()
{
// Given a training with ObjectInRangeCondition,
TrainingSceneObject testObjectToo = TestingUtils.CreateSceneObject("TestObjectToo");
TransformInRangeDetectorProperty detector = testObjectToo.gameObject.AddComponent <TransformInRangeDetectorProperty>();
TrainingSceneObject testObject = TestingUtils.CreateSceneObject("TestObject");
ICourse training1 = new LinearTrainingBuilder("Training")
.AddChapter(new LinearChapterBuilder("Chapter")
.AddStep(new BasicStepBuilder("Step")
.AddCondition(new ObjectInRangeCondition(testObject, detector, 1.5f))))
.Build();
// When we serialize and deserialize it
ICourse training2 = Serializer.CourseFromByteArray(Serializer.CourseToByteArray(training1));
// Then that condition's target, detector and range should stay unchanged.
ObjectInRangeCondition condition1 = training1.Data.FirstChapter.Data.FirstStep.Data.Transitions.Data.Transitions.First().Data.Conditions.First() as ObjectInRangeCondition;
ObjectInRangeCondition condition2 = training2.Data.FirstChapter.Data.FirstStep.Data.Transitions.Data.Transitions.First().Data.Conditions.First() as ObjectInRangeCondition;
Assert.IsNotNull(condition1);
Assert.IsNotNull(condition2);
Assert.AreEqual(condition1.Data.Range, condition2.Data.Range);
Assert.AreEqual(condition1.Data.Target.Value, condition2.Data.Target.Value);
Assert.AreEqual(condition1.Data.DistanceDetector.Value, condition2.Data.DistanceDetector.Value);
// Cleanup
TestingUtils.DestroySceneObject(testObjectToo);
TestingUtils.DestroySceneObject(testObject);
return(null);
}
public IEnumerator LockObjectBehavior()
{
// Given a training with LockObjectBehavior
TrainingSceneObject trainingSceneObject = TestingUtils.CreateSceneObject("TestObject");
ICourse training1 = new LinearTrainingBuilder("Training")
.AddChapter(new LinearChapterBuilder("Chapter")
.AddStep(new BasicStepBuilder("Step")
.DisableAutomaticAudioHandling()
.AddBehavior(new LockObjectBehavior(trainingSceneObject))))
.Build();
// When we serialize and deserialize it
ICourse training2 = JsonTrainingSerializer.Deserialize(JsonTrainingSerializer.Serialize(training1));
// Then that's behavior target is still the same.
LockObjectBehavior behavior1 = training1.Data.FirstChapter.Data.FirstStep.Data.Behaviors.Data.Behaviors.First() as LockObjectBehavior;
LockObjectBehavior behavior2 = training2.Data.FirstChapter.Data.FirstStep.Data.Behaviors.Data.Behaviors.First() as LockObjectBehavior;
Assert.IsNotNull(behavior1);
Assert.IsNotNull(behavior2);
Assert.AreEqual(behavior1.Data.Target.Value, behavior2.Data.Target.Value);
// Cleanup
TestingUtils.DestroySceneObject(trainingSceneObject);
return(null);
}
public IEnumerator DisableGameObjectBehavior()
{
// Given DisableGameObjectBehavior,
TrainingSceneObject trainingSceneObject = TestingUtils.CreateSceneObject("TestObject");
ICourse training1 = new LinearTrainingBuilder("Training")
.AddChapter(new LinearChapterBuilder("Chapter")
.AddStep(new BasicStepBuilder("Step")
.DisableAutomaticAudioHandling()
.Disable("TestObject")))
.Build();
// When we serialize and deserialize a training with it
string serialized = JsonTrainingSerializer.Serialize(training1);
ICourse training2 = JsonTrainingSerializer.Deserialize(serialized);
DisableGameObjectBehavior behavior1 = training1.Data.FirstChapter.Data.FirstStep.Data.Behaviors.Data.Behaviors.First() as DisableGameObjectBehavior;
DisableGameObjectBehavior behavior2 = training2.Data.FirstChapter.Data.FirstStep.Data.Behaviors.Data.Behaviors.First() as DisableGameObjectBehavior;
// Then it's target training scene object is still the same.
Assert.IsNotNull(behavior1);
Assert.IsNotNull(behavior2);
Assert.AreEqual(behavior1.Data.Target.Value, behavior2.Data.Target.Value);
TestingUtils.DestroySceneObject(trainingSceneObject);
return(null);
}
public IEnumerator GameObjectIsEnabledAfterActivation()
{
// Given an active training scene object and a training with enable game object behavior,
TrainingSceneObject toEnable = TestingUtils.CreateSceneObject("toEnable");
toEnable.GameObject.SetActive(false);
EndlessConditionMock trigger = new EndlessConditionMock();
ICourse course = new LinearTrainingBuilder("Training")
.AddChapter(new LinearChapterBuilder("Chapter")
.AddStep(new BasicCourseStepBuilder("Step")
.Enable(toEnable)
.AddCondition(trigger)))
.Build();
course.Configure(RuntimeConfigurator.Configuration.Modes.CurrentMode);
CourseRunner.Initialize(course);
CourseRunner.Run();
// When the behavior is activated
CourseRunner.Initialize(course);
CourseRunner.Run();
yield return(new WaitUntil(() => course.Data.FirstChapter.Data.Steps[0].LifeCycle.Stage == Stage.Active));
// Then the training scene object is enabled.
Assert.True(toEnable.GameObject.activeSelf);
// Cleanup
TestingUtils.DestroySceneObject(toEnable);
yield break;
}
public IEnumerator FastForwardInactiveBehavior()
{
// Given an active training scene object and a DisableGameObjectBehavior,
TrainingSceneObject toDisable = TestingUtils.CreateSceneObject("ToDisable");
DisableGameObjectBehavior behavior = new DisableGameObjectBehavior(toDisable);
// When we mark it to fast-forward,
behavior.LifeCycle.MarkToFastForward();
// Then it doesn't autocomplete because it weren't activated yet.
Assert.AreEqual(Stage.Inactive, behavior.LifeCycle.Stage);
// Cleanup.
TestingUtils.DestroySceneObject(toDisable);
yield break;
}
public IEnumerator FastForwardInactiveBehaviorAndActivateIt()
{
// Given an active training scene object and a DisableGameObjectBehavior,
TrainingSceneObject toDisable = TestingUtils.CreateSceneObject("ToDisable");
DisableGameObjectBehavior behavior = new DisableGameObjectBehavior(toDisable);
// When we mark it to fast-forward and activate it,
behavior.LifeCycle.MarkToFastForward();
behavior.LifeCycle.Activate();
// Then it should work without any differences because the behavior is done immediately anyways.
Assert.AreEqual(Stage.Active, behavior.LifeCycle.Stage);
Assert.IsFalse(toDisable.GameObject.activeSelf);
// Cleanup.
TestingUtils.DestroySceneObject(toDisable);
yield break;
}
public IEnumerator GameObjectStaysEnabled()
{
// Given an active training scene object and a training with enalbe game object condition,
TrainingSceneObject toEnable = TestingUtils.CreateSceneObject("toEnable");
toEnable.GameObject.SetActive(false);
EndlessCondition trigger = new EndlessCondition();
ICourse course = new LinearTrainingBuilder("Training")
.AddChapter(new LinearChapterBuilder("Chapter")
.AddStep(new BasicStepBuilder("Step")
.DisableAutomaticAudioHandling()
.Enable(toEnable))
.AddStep(new BasicStepBuilder("Step")
.DisableAutomaticAudioHandling()
.AddCondition(trigger)))
.Build();
course.Configure(RuntimeConfigurator.Configuration.GetCurrentMode());
// When the behavior is activated and after the step is completed
TrainingRunner.Initialize(course);
TrainingRunner.Run();
yield return(new WaitUntil(() => course.Data.FirstChapter.Data.Steps[0].LifeCycle.Stage == Stage.Active));
trigger.Autocomplete();
yield return(new WaitUntil(() => course.Data.FirstChapter.Data.Steps[0].LifeCycle.Stage == Stage.Inactive));
// Then the training scene object stays enabled.
Assert.True(toEnable.GameObject.activeSelf);
// Cleanup
TestingUtils.DestroySceneObject(toEnable);
}