public IEnumerator EnableGameObjectBehavior() { // Given EnableGameObjectBehavior, TrainingSceneObject trainingSceneObject = TestingUtils.CreateSceneObject("TestObject"); ICourse training1 = new LinearTrainingBuilder("Training") .AddChapter(new LinearChapterBuilder("Chapter") .AddStep(new BasicStepBuilder("Step") .DisableAutomaticAudioHandling() .Enable("TestObject"))) .Build(); // When we serialize and deserialize a training course with it ICourse training2 = JsonTrainingSerializer.Deserialize(JsonTrainingSerializer.Serialize(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 = JsonTrainingSerializer.Deserialize(JsonTrainingSerializer.Serialize(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 TextToSpeechAudio() { // Given we have TextToSpeechAudio instance, TextToSpeechAudio audio = new TextToSpeechAudio(new LocalizedString("TestPath")); ICourse course = new LinearTrainingBuilder("Training") .AddChapter(new LinearChapterBuilder("Chapter") .AddStep(new BasicStepBuilder("Step") .DisableAutomaticAudioHandling() .AddBehavior(new PlayAudioBehavior(audio, BehaviorExecutionStages.Activation)))) .Build(); // When we serialize and deserialize a training with it, ICourse testCourse = JsonTrainingSerializer.Deserialize(JsonTrainingSerializer.Serialize(course)); // Then the text to generate sound from should be the same. IAudioData data1 = ((PlayAudioBehavior)course.Data.FirstChapter.Data.FirstStep.Data.Behaviors.Data.Behaviors.First()).Data.AudioData; IAudioData data2 = ((PlayAudioBehavior)testCourse.Data.FirstChapter.Data.FirstStep.Data.Behaviors.Data.Behaviors.First()).Data.AudioData; string audioPath1 = TestingUtils.GetField <LocalizedString>(data1, "text").Key; string audioPath2 = TestingUtils.GetField <LocalizedString>(data2, "text").Key; Assert.AreEqual(data1.GetType(), data2.GetType()); Assert.AreEqual(audioPath1, "TestPath"); Assert.AreEqual(audioPath1, audioPath2); return(null); }
public IEnumerator BaseTraining() { // Given base training ICourse training1 = new LinearTrainingBuilder("Training") .AddChapter(new LinearChapterBuilder("Chapter") .AddStep(new BasicStepBuilder("Step"))) .Build(); JsonTrainingSerializer.Serialize(training1); // When we serialize and deserialize it ICourse training2 = JsonTrainingSerializer.Deserialize(JsonTrainingSerializer.Serialize(training1)); // Then it should still be base training, have the same name and the first chapter with the same name. Assert.AreEqual(typeof(Course), training1.GetType()); Assert.AreEqual(training1.GetType(), training2.GetType()); Assert.AreEqual(training1.Data.Name, "Training"); Assert.AreEqual(training1.Data.Name, training2.Data.Name); Assert.AreEqual(training1.Data.FirstChapter.Data.Name, "Chapter"); Assert.AreEqual(training1.Data.FirstChapter.Data.Name, training2.Data.FirstChapter.Data.Name); return(null); }
public IEnumerator BehaviorSequence() { // Given a training with a behaviors sequence BehaviorSequence sequence = new BehaviorSequence(true, new List <IBehavior> { new DelayBehavior(0f), new EmptyBehavior() }); ICourse course = new LinearTrainingBuilder("Training") .AddChapter(new LinearChapterBuilder("Chapter") .AddStep(new BasicStepBuilder("Step") .DisableAutomaticAudioHandling() .AddBehavior(sequence))) .Build(); // When we serialize and deserialize it ICourse deserializedCourse = JsonTrainingSerializer.Deserialize(JsonTrainingSerializer.Serialize(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 UnlockObjectBehavior() { // Given a training with UnlockObjectBehavior TrainingSceneObject trainingSceneObject = TestingUtils.CreateSceneObject("TestObject"); ICourse training1 = new LinearTrainingBuilder("Training") .AddChapter(new LinearChapterBuilder("Chapter") .AddStep(new BasicStepBuilder("Step") .DisableAutomaticAudioHandling() .AddBehavior(new UnlockObjectBehavior(trainingSceneObject)))) .Build(); // When we serialize and deserialize it ICourse training2 = JsonTrainingSerializer.Deserialize(JsonTrainingSerializer.Serialize(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); }
/// <summary> /// Save the training to given path. /// </summary> public static bool SaveTrainingCourseToFile(ICourse course) { try { if (course == null) { throw new NullReferenceException("The training course is not saved because it doesn't exist."); } string path = GetTrainingPath(course); string directory = Path.GetDirectoryName(path); if (string.IsNullOrEmpty(directory) == false && Directory.Exists(directory) == false) { Directory.CreateDirectory(directory); } string serialized = JsonTrainingSerializer.Serialize(course); File.WriteAllText(path, serialized); // Check if saved as asset. If true, import it. TryReloadAssetByFullPath(path); return(true); } catch (Exception e) { TestableEditorElements.DisplayDialog("Error while saving the training course!", e.ToString(), "Close"); logger.Error(e); return(false); } }
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") .DisableAutomaticAudioHandling() .AddBehavior(new MoveObjectBehavior(moved, positionProvider, 24.7f)))) .Build(); // When that training is serialized and deserialzied ICourse training2 = JsonTrainingSerializer.Deserialize(JsonTrainingSerializer.Serialize(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 void MakeTemporarySave() { if (activeCourse == null) { return; } temporarySerializedTraining = JsonTrainingSerializer.Serialize(activeCourse); }
public IEnumerator Step() { // Given we have a training with a step ICourse training1 = new LinearTrainingBuilder("Training") .AddChapter(new LinearChapterBuilder("Chapter") .AddStep(new BasicStepBuilder("Step") .AddCondition(new TimeoutCondition(2.5f)))) .Build(); // When we serialize and deserialize it ICourse training2 = JsonTrainingSerializer.Deserialize((JsonTrainingSerializer.Serialize(training1))); // Then that step's name should still be the same. Assert.AreEqual(training1.Data.FirstChapter.Data.FirstStep.Data.Name, training2.Data.FirstChapter.Data.FirstStep.Data.Name); return(null); }
/// <inheritdoc /> public virtual ICourse LoadCourse() { if (string.IsNullOrEmpty(RuntimeConfigurator.GetSelectedTrainingCourse())) { throw new ArgumentException("A training course is not selected in the [TRAINING_CONFIGURATION] game object."); } string pathToFile = Path.Combine(Application.streamingAssetsPath, RuntimeConfigurator.GetSelectedTrainingCourse()).Replace('/', Path.DirectorySeparatorChar); if (File.Exists(pathToFile) == false) { throw new ArgumentException("The file or the path to the file could not be found.", pathToFile); } string serialized = File.ReadAllText(pathToFile); return(JsonTrainingSerializer.Deserialize(serialized)); }
private void OnEnable() { wantsMouseMove = true; if (chapterMenu == null) { chapterMenu = CreateInstance <TrainingMenuView>(); } if (chapterRepresentation == null) { chapterRepresentation = new ChapterRepresentation(); chapterRepresentation.Graphics.Canvas.PointerDrag += (o, eventArgs) => currentScrollPosition -= eventArgs.PointerDelta; } if (titleIcon == null) { titleIcon = new EditorIcon("icon_training_editor"); } if (window != null && window != this) { window.Close(); } window = this; if (string.IsNullOrEmpty(temporarySerializedTraining) == false) { try { bool wasDirty = IsDirty; chapterMenu = CreateInstance <TrainingMenuView>(); SetTrainingCourse(JsonTrainingSerializer.Deserialize(temporarySerializedTraining)); IsDirty = wasDirty; temporarySerializedTraining = null; } catch (Exception e) { logger.Error("Couldn't restore the training course state.", e); } } }
public IEnumerator Condition() { // Given a training which has a step with a condition ICourse training1 = new LinearTrainingBuilder("Training") .AddChapter(new LinearChapterBuilder("Chapter") .AddStep(new BasicStepBuilder("Step") .AddCondition(new TimeoutCondition(2.5f)))) .Build(); // When we serialize and deserialize it ICourse training2 = JsonTrainingSerializer.Deserialize((JsonTrainingSerializer.Serialize(training1))); // Then that condition's name should not change. ICondition condition1 = training1.Data.FirstChapter.Data.FirstStep.Data.Transitions.Data.Transitions.First().Data.Conditions.First(); ICondition condition2 = training2.Data.FirstChapter.Data.FirstStep.Data.Transitions.Data.Transitions.First().Data.Conditions.First(); Assert.AreEqual(condition1.GetType(), condition2.GetType()); return(null); }
public IEnumerator Transition() { // Given a training with more than one step ICourse training1 = new LinearTrainingBuilder("Training") .AddChapter(new LinearChapterBuilder("Chapter") .AddStep(new BasicStepBuilder("FirstStep") .DisableAutomaticAudioHandling()) .AddStep(new BasicStepBuilder("SecondStep") .DisableAutomaticAudioHandling())) .Build(); // When we serialize and deserialize it string serialized = JsonTrainingSerializer.Serialize(training1); ICourse training2 = JsonTrainingSerializer.Deserialize(serialized); // Then transition from the first step should lead to the same step as before. Assert.AreEqual(training1.Data.FirstChapter.Data.FirstStep.Data.Transitions.Data.Transitions.First().Data.TargetStep.Data.Name, training2.Data.FirstChapter.Data.FirstStep.Data.Transitions.Data.Transitions.First().Data.TargetStep.Data.Name); return(null); }
public IEnumerator DelayBehavior() { // Given we have a training with a delayed activation behavior, ICourse training1 = new LinearTrainingBuilder("Training") .AddChapter(new LinearChapterBuilder("Chapter") .AddStep(new BasicStepBuilder("Step") .DisableAutomaticAudioHandling() .AddBehavior(new DelayBehavior(7f)))) .Build(); // When we serialize and deserialize it, string serialized = JsonTrainingSerializer.Serialize(training1); ICourse training2 = JsonTrainingSerializer.Deserialize(serialized); // Then that delayed behaviors should have the same target behaviors and delay time. DelayBehavior behavior1 = training1.Data.FirstChapter.Data.FirstStep.Data.Behaviors.Data.Behaviors.First() as DelayBehavior; DelayBehavior behavior2 = training2.Data.FirstChapter.Data.FirstStep.Data.Behaviors.Data.Behaviors.First() as DelayBehavior; Assert.AreEqual(behavior1.Data.DelayTime, behavior2.Data.DelayTime); return(null); }
public IEnumerator Chapter() { // Given we have a training with a chapter ICourse training1 = new LinearTrainingBuilder("Training") .AddChapter(new LinearChapterBuilder("Chapter") .AddStep(new BasicStepBuilder("Step"))) .Build(); // When we serialize and deserialize it ICourse training2 = JsonTrainingSerializer.Deserialize((JsonTrainingSerializer.Serialize(training1))); // Then chapter's type, name, first step and next chapter should not change. IChapter chapter1 = training1.Data.FirstChapter; IChapter chapter2 = training2.Data.FirstChapter; Assert.AreEqual(chapter1.GetType(), chapter2.GetType()); Assert.AreEqual(chapter1.Data.Name, chapter2.Data.Name); Assert.AreEqual(chapter1.Data.FirstStep.Data.Name, chapter2.Data.FirstStep.Data.Name); Assert.AreEqual(training1.Data.Chapters.Count, training2.Data.Chapters.Count); return(null); }
public IEnumerator TimeoutCondition() { // Given a training with a timeout condition ICourse training1 = new LinearTrainingBuilder("Training") .AddChapter(new LinearChapterBuilder("Chapter") .AddStep(new BasicStepBuilder("Step") .AddCondition(new TimeoutCondition(2.5f)))) .Build(); // When we serialize and deserialize it ICourse training2 = JsonTrainingSerializer.Deserialize((JsonTrainingSerializer.Serialize(training1))); // Then that condition's timeout value should stay unchanged. TimeoutCondition condition1 = training1.Data.FirstChapter.Data.FirstStep.Data.Transitions.Data.Transitions.First().Data.Conditions.First() as TimeoutCondition; TimeoutCondition condition2 = training2.Data.FirstChapter.Data.FirstStep.Data.Transitions.Data.Transitions.First().Data.Conditions.First() as TimeoutCondition; Assert.IsNotNull(condition1); Assert.IsNotNull(condition2); Assert.AreEqual(condition1.Data.Timeout, condition2.Data.Timeout); return(null); }
public IEnumerator ResourceAudio() { // Given we have a ResourceAudio instance, ResourceAudio audio = new ResourceAudio(new LocalizedString("TestPath")); ICourse course = new LinearTrainingBuilder("Training") .AddChapter(new LinearChapterBuilder("Chapter") .AddStep(new BasicStepBuilder("Step") .DisableAutomaticAudioHandling() .AddBehavior(new PlayAudioBehavior(audio, BehaviorExecutionStages.Activation)))) .Build(); // When we serialize and deserialize a training with it ICourse testCourse = JsonTrainingSerializer.Deserialize(JsonTrainingSerializer.Serialize(course)); // Then the path to audio resource should be the same. string audioPath1 = TestingUtils.GetField <LocalizedString>(((PlayAudioBehavior)course.Data.FirstChapter.Data.FirstStep.Data.Behaviors.Data.Behaviors.First()).Data.AudioData, "path").Key; string audioPath2 = TestingUtils.GetField <LocalizedString>(((PlayAudioBehavior)testCourse.Data.FirstChapter.Data.FirstStep.Data.Behaviors.Data.Behaviors.First()).Data.AudioData, "path").Key; Assert.AreEqual(audioPath1, audioPath2); return(null); }
public IEnumerator PlayAudioOnDectivationBehavior() { // Given a training with PlayAudioOnDeactivationBehavior and some ResourceData, ICourse training1 = new LinearTrainingBuilder("Training") .AddChapter(new LinearChapterBuilder("Chapter") .AddStep(new BasicStepBuilder("Step") .DisableAutomaticAudioHandling() .AddBehavior(new PlayAudioBehavior(new ResourceAudio(new LocalizedString("TestPath")), BehaviorExecutionStages.Activation)))) .Build(); // When we serialize and deserialize it, ICourse training2 = JsonTrainingSerializer.Deserialize(JsonTrainingSerializer.Serialize(training1)); PlayAudioBehavior behavior1 = training1.Data.FirstChapter.Data.FirstStep.Data.Behaviors.Data.Behaviors.First() as PlayAudioBehavior; PlayAudioBehavior behavior2 = training2.Data.FirstChapter.Data.FirstStep.Data.Behaviors.Data.Behaviors.First() as PlayAudioBehavior; // Then path to audio file should not change. Assert.IsNotNull(behavior1); Assert.IsNotNull(behavior2); Assert.AreEqual(TestingUtils.GetField <LocalizedString>(behavior1.Data.AudioData, "path").Key, TestingUtils.GetField <LocalizedString>(behavior2.Data.AudioData, "path").Key); return(null); }
public IEnumerator NonblockingWrapperBehaviorIsConverted() { // Given a training with the obsolete NonblockingWapperBehavior where isBlocking is true, which wraps a non-blocking behavior, #pragma warning disable 618 NonblockingWrapperBehavior behavior = new NonblockingWrapperBehavior(new EndlessBehavior(false), true); #pragma warning restore 618 ICourse course = new LinearTrainingBuilder("Training") .AddChapter(new LinearChapterBuilder("Chapter") .AddStep(new BasicStepBuilder("Step") .DisableAutomaticAudioHandling() .AddBehavior(behavior))) .Build(); // When we serialize and deserialize it, ICourse deserializedCourse = JsonTrainingSerializer.Deserialize(JsonTrainingSerializer.Serialize(course)); EndlessBehavior deserializedBehavior = deserializedCourse.Data.FirstChapter.Data.FirstStep.Data.Behaviors.Data.Behaviors.First() as EndlessBehavior; // Then the NonblockingWrapperBehavior is converted to the actual wrapped behavior and the "IsBlocking" property returns true. Assert.IsNotNull(deserializedBehavior); Assert.IsTrue(deserializedBehavior.Data.IsBlocking); yield break; }
public IEnumerator LocalizedString() { // Given a LocalizedString LocalizedString original = new LocalizedString("Test1{0}{1}", "Test2", "Test3", "Test4"); Step step = new Step(""); step.Data.Behaviors.Data.Behaviors.Add(new PlayAudioBehavior(new ResourceAudio(original), BehaviorExecutionStages.Activation)); ICourse course = new Course("", new Chapter("", step)); // When we serialize and deserialize a training with it ICourse deserializedCourse = JsonTrainingSerializer.Deserialize(JsonTrainingSerializer.Serialize(course)); PlayAudioBehavior deserializedBehavior = deserializedCourse.Data.FirstChapter.Data.FirstStep.Data.Behaviors.Data.Behaviors.First() as PlayAudioBehavior; // ReSharper disable once PossibleNullReferenceException LocalizedString deserialized = ((ResourceAudio)deserializedBehavior.Data.AudioData).Path; // Then deserialized training should has different instance of LocalizedString but with the same values. Assert.IsFalse(ReferenceEquals(original, deserialized)); Assert.AreEqual(original.Key, deserialized.Key); Assert.AreEqual(original.DefaultText, deserialized.DefaultText); Assert.IsTrue(original.FormatParams.SequenceEqual(deserialized.FormatParams)); yield return(null); }
public static ICourse LoadTrainingCourseFromFile(string path) { string trainingData = File.ReadAllText(path); return(JsonTrainingSerializer.Deserialize(trainingData)); }