Пример #1
0
        public void OnSuspiciousObjectCollides_Updates_SendsDetectionMessageToDetectorForCorrectObject()
        {
            _vision.IsSuspiciousResult = true;
            var detectedObject = new GameObject();
            var laterObject    = new GameObject();

            var messageSpy = new UnityTestMessageHandleResponseObject <SuspiciousObjectDetectedMessage>();
            var handle     =
                UnityMessageEventFunctions.RegisterActionWithDispatcher <SuspiciousObjectDetectedMessage>(_detector,
                                                                                                          messageSpy.OnResponse);

            _vision.TestCollide(detectedObject);

            _vision.TestUpdate(_vision.TimeUntilDetection - 0.1f);

            _vision.TestCollide(laterObject);

            _vision.TestUpdate(0.2f);

            Assert.IsTrue(messageSpy.ActionCalled);
            Assert.AreSame(detectedObject, messageSpy.MessagePayload.SuspiciousGameObject);

            _vision.TestUpdate(_vision.TimeUntilDetection + 0.1f);

            Assert.AreSame(laterObject, messageSpy.MessagePayload.SuspiciousGameObject);

            UnityMessageEventFunctions.UnregisterActionWithDispatcher(_detector, handle);
        }
Пример #2
0
        public void ReadData_SetsExpectedCompanions()
        {
            var messageSpy      = new UnityTestMessageHandleResponseObject <CompanionSlotsUpdatedMessage>();
            var initialUseCount = _companion.GetCompanionDataResult.PowerUseCount;

            var handle =
                UnityMessageEventFunctions.RegisterActionWithDispatcher <CompanionSlotsUpdatedMessage>(_set.gameObject,
                                                                                                       messageSpy.OnResponse);

            _set.SetCompanion(_companion, ECompanionSlot.Primary);

            var stream = new MemoryStream();

            _set.WriteData(stream);

            _set.ClearCompanion(ECompanionSlot.Primary);

            var readStream = new MemoryStream(stream.ToArray());

            _companion.GetCompanionDataResult.PowerUseCount++;

            _set.ReadData(readStream);

            _set.TestUpdate();

            Assert.IsTrue(messageSpy.ActionCalled);
            Assert.IsNotNull(messageSpy.MessagePayload.Updates[ECompanionSlot.Primary].PriorCompanion);
            Assert.AreEqual(initialUseCount, messageSpy.MessagePayload.Updates[ECompanionSlot.Primary].PriorCompanion.GetCompanionData().PowerUseCount);

            UnityMessageEventFunctions.UnregisterActionWithDispatcher(_set.gameObject, handle);
        }
Пример #3
0
        public void ReadData_Collisions_CannotSave()
        {
            _trigger.TestCollide(_character.gameObject);

            var stream = new MemoryStream();

            _trigger.WriteData(stream);

            var readStream = new MemoryStream(stream.ToArray());

            _trigger.ReadData(readStream);

            var messageSpy =
                new UnityTestMessageHandleResponseObject <SaveGameTriggerActivatedMessage>();

            var handle =
                UnityMessageEventFunctions.RegisterActionWithDispatcher <SaveGameTriggerActivatedMessage>(_character.gameObject,
                                                                                                          messageSpy.OnResponse);

            _trigger.TestCollide(_character.gameObject);

            Assert.IsFalse(messageSpy.ActionCalled);

            UnityMessageEventFunctions.UnregisterActionWithDispatcher(_character.gameObject, handle);
        }
Пример #4
0
        public void OnSuspiciousObjectCollides_UpdateTogglesSuspicions_SendsExpectedMessages()
        {
            _vision.IsSuspiciousResult = false;
            var detectedObject = new GameObject();

            _vision.TestCollide(detectedObject);

            _vision.IsSuspiciousResult = true;

            _vision.TestUpdate(_vision.TimeUntilDetection + 0.1f);
            _vision.TestUpdate(_vision.TimeUntilDetection + 0.1f);

            var messageSpy = new UnityTestMessageHandleResponseObject <SuspiciousObjectDetectedMessage>();
            var handle     =
                UnityMessageEventFunctions.RegisterActionWithDispatcher <SuspiciousObjectDetectedMessage>(_detector,
                                                                                                          messageSpy.OnResponse);

            _vision.IsSuspiciousResult = false;

            _vision.TestUpdate(_vision.TimeUntilDetection + 0.1f);

            Assert.IsFalse(messageSpy.ActionCalled);

            UnityMessageEventFunctions.UnregisterActionWithDispatcher(_detector, handle);
        }
Пример #5
0
        public void OnEventOfInterest_SendsMatchingUIEvent()
        {
            _chatter.TestStart();

            var messageSpy = new UnityTestMessageHandleResponseObject <RequestDialogueUIMessage>();

            var handle = GameInstance.CurrentInstance.GetUIMessageDispatcher()
                         .RegisterForMessageEvent <RequestDialogueUIMessage>(messageSpy.OnResponse);

            var responseEvent    = _events.ListenedEvents.Last();
            var matchingDialogue =
                _data.DialogueEntries.Find((entry) => entry.DialogueEntryKey.Equals(responseEvent.EventKey));

            responseEvent.Response(responseEvent.EventKey);

            Assert.AreEqual(matchingDialogue.Priority, messageSpy.MessagePayload.Priority);
            foreach (var line in matchingDialogue.Lines)
            {
                Assert.IsTrue(messageSpy.MessagePayload.Lines.Contains(line));
            }

            GameInstance.CurrentInstance.GetUIMessageDispatcher().UnregisterForMessageEvent(handle);

            _chatter.TestDestroy();
        }
Пример #6
0
        public void CycleActiveGadget_ActiveSlotDoesNotChange_DoesNotSendMessage()
        {
            _set.InitialCapacities.Add(new GadgetSlotCapcity {
                Capacity = 2, Slot = EGadgetSlot.Mine
            });
            _set.InitialCapacities.Add(new GadgetSlotCapcity {
                Capacity = 2, Slot = EGadgetSlot.NoiseMaker
            });

            _gadget.GetGadgetSlotResult      = EGadgetSlot.Mine;
            _otherGadget.GetGadgetSlotResult = EGadgetSlot.NoiseMaker;

            _set.TestAwake();

            _set.AddGadget(_gadget);
            _set.AddGadget(_otherGadget);

            var messageSpy = new UnityTestMessageHandleResponseObject <GadgetUpdatedMessage>();

            var handle = UnityMessageEventFunctions.RegisterActionWithDispatcher
                         <GadgetUpdatedMessage>(_set.gameObject, messageSpy.OnResponse);

            _set.CycleActiveGadget(200);

            Assert.IsFalse(messageSpy.ActionCalled);

            UnityMessageEventFunctions.UnregisterActionWithDispatcher(_set.gameObject, handle);
        }
Пример #7
0
        public void CycleActiveGadget_Negative_WrapsAround()
        {
            _set.InitialCapacities.Add(new GadgetSlotCapcity {
                Capacity = 2, Slot = EGadgetSlot.Mine
            });
            _set.InitialCapacities.Add(new GadgetSlotCapcity {
                Capacity = 2, Slot = EGadgetSlot.NoiseMaker
            });

            _gadget.GetGadgetSlotResult      = EGadgetSlot.Mine;
            _otherGadget.GetGadgetSlotResult = EGadgetSlot.NoiseMaker;

            _set.TestAwake();

            _set.AddGadget(_gadget);
            _set.AddGadget(_otherGadget);

            var messageSpy = new UnityTestMessageHandleResponseObject <GadgetUpdatedMessage>();

            var handle = UnityMessageEventFunctions.RegisterActionWithDispatcher
                         <GadgetUpdatedMessage>(_set.gameObject, messageSpy.OnResponse);

            _set.CycleActiveGadget(-1);

            Assert.IsTrue(messageSpy.ActionCalled);
            Assert.AreSame(_otherGadget, messageSpy.MessagePayload.NewGadget);
            Assert.AreEqual(1, messageSpy.MessagePayload.SlotCount);

            UnityMessageEventFunctions.UnregisterActionWithDispatcher(_set.gameObject, handle);
        }
Пример #8
0
        public void UseActiveGadget_GadgetsLeftInSameSlot_SendsMessageWithRemainingGadget()
        {
            _set.InitialCapacities.Add(new GadgetSlotCapcity {
                Capacity = 2, Slot = EGadgetSlot.Mine
            });

            _gadget.GetGadgetSlotResult      = EGadgetSlot.Mine;
            _otherGadget.GetGadgetSlotResult = EGadgetSlot.Mine;

            _set.TestAwake();

            _set.AddGadget(_gadget);
            _set.AddGadget(_otherGadget);

            var messageSpy = new UnityTestMessageHandleResponseObject <GadgetUpdatedMessage>();

            var handle = UnityMessageEventFunctions.RegisterActionWithDispatcher
                         <GadgetUpdatedMessage>(_set.gameObject, messageSpy.OnResponse);

            _set.UseActiveGadget();

            Assert.IsTrue(messageSpy.ActionCalled);
            Assert.AreSame(_gadget, messageSpy.MessagePayload.NewGadget);
            Assert.AreEqual(1, messageSpy.MessagePayload.SlotCount);

            UnityMessageEventFunctions.UnregisterActionWithDispatcher(_set.gameObject, handle);
        }
        public void PushableStopsColliding_NotColliding_NoCancelTriggerMessage()
        {
            var messageSpy = new UnityTestMessageHandleResponseObject <CancelTriggerMessage>();

            var handle = UnityMessageEventFunctions.RegisterActionWithDispatcher <CancelTriggerMessage>
                             (_pushTrigger.gameObject, messageSpy.OnResponse);

            _pushTrigger.TestStopColliding(_pushable.gameObject);

            Assert.IsFalse(messageSpy.ActionCalled);

            UnityMessageEventFunctions.UnregisterActionWithDispatcher(_pushTrigger.gameObject, handle);
        }
        public void NullCollides_NoTriggerMessage()
        {
            var messageSpy = new UnityTestMessageHandleResponseObject <TriggerMessage>();

            var handle = UnityMessageEventFunctions.RegisterActionWithDispatcher <TriggerMessage>
                             (_pushTrigger.gameObject, messageSpy.OnResponse);

            _pushTrigger.TestCollide(null);

            Assert.IsFalse(messageSpy.ActionCalled);

            UnityMessageEventFunctions.UnregisterActionWithDispatcher(_pushTrigger.gameObject, handle);
        }
        public void Start_SendsEnterCinematicActionStateMessage()
        {
            var messageSpy = new UnityTestMessageHandleResponseObject <EnterCinematicCameraActionStateMessage>();

            var handle = UnityMessageEventFunctions.RegisterActionWithDispatcher <EnterCinematicCameraActionStateMessage>(
                _character.gameObject, messageSpy.OnResponse);

            _actionState.Start();

            Assert.IsTrue(messageSpy.ActionCalled);

            UnityMessageEventFunctions.UnregisterActionWithDispatcher(_character.gameObject, handle);
        }
Пример #12
0
        public void Start_FiresActivationEvent()
        {
            var eventSpy = new UnityTestMessageHandleResponseObject <RequestInGameMenuActivationMessage>();

            var dispatcher = GameInstance.CurrentInstance.GetUIMessageDispatcher();
            var handle     = dispatcher.RegisterForMessageEvent <RequestInGameMenuActivationMessage>(eventSpy.OnResponse);

            _actionState.Start();

            Assert.IsTrue(eventSpy.ActionCalled);

            dispatcher.UnregisterForMessageEvent(handle);
        }
Пример #13
0
        public void Start_FiresSetMaxEventWithMaxStamina()
        {
            var messageSpy = new UnityTestMessageHandleResponseObject <MaxStaminaChangedMessage>();

            var handle =
                UnityMessageEventFunctions.RegisterActionWithDispatcher <MaxStaminaChangedMessage>(_stamina.gameObject, messageSpy.OnResponse);

            _stamina.TestStart();

            Assert.AreEqual(_stamina.InitialStamina, messageSpy.MessagePayload.NewMaxStamina);

            UnityMessageEventFunctions.UnregisterActionWithDispatcher(_stamina.gameObject, handle);
        }
        public void ReceiveLeftDeadActionStateMessage_ForwardsTextNotificationClearedToUIDispatcher()
        {
            var eventSpy = new UnityTestMessageHandleResponseObject <TextNotificationClearedUIMessage>();

            var dispatcher = GameInstance.CurrentInstance.GetUIMessageDispatcher();
            var handle     = dispatcher
                             .RegisterForMessageEvent <TextNotificationClearedUIMessage>(eventSpy.OnResponse);

            UnityMessageEventFunctions.InvokeMessageEventWithDispatcher(_playerUi.gameObject, new LeftDeadActionStateMessage());

            Assert.IsTrue(eventSpy.ActionCalled);

            dispatcher.UnregisterForMessageEvent(handle);
        }
Пример #15
0
        public void AddActiveInteractable_DoesNotSendInteractableUpdatedMessage()
        {
            var messageSpy = new UnityTestMessageHandleResponseObject <ActiveInteractableUpdatedMessage>();

            var handler =
                UnityMessageEventFunctions.RegisterActionWithDispatcher <ActiveInteractableUpdatedMessage>(
                    _interaction.gameObject, messageSpy.OnResponse);

            _interaction.AddActiveInteractable(_interactable);

            Assert.IsFalse(messageSpy.ActionCalled);

            UnityMessageEventFunctions.UnregisterActionWithDispatcher(_interaction.gameObject, handler);
        }
Пример #16
0
        public void SetCompanion_NoUpdateMessage()
        {
            var messageSpy = new UnityTestMessageHandleResponseObject <CompanionSlotsUpdatedMessage>();

            var handle =
                UnityMessageEventFunctions.RegisterActionWithDispatcher <CompanionSlotsUpdatedMessage>(_set.gameObject,
                                                                                                       messageSpy.OnResponse);

            _set.SetCompanion(_companion, ECompanionSlot.Primary);

            Assert.IsFalse(messageSpy.ActionCalled);

            UnityMessageEventFunctions.UnregisterActionWithDispatcher(_set.gameObject, handle);
        }
Пример #17
0
        public void Start_SendsEnterEventToOwner()
        {
            _deadActionState = new DeadActionState(new ActionStateInfo(_playerBinder.gameObject), _params);

            var eventSpy = new UnityTestMessageHandleResponseObject <EnterDeadActionStateMessage>();
            var handle   =
                UnityMessageEventFunctions.RegisterActionWithDispatcher <EnterDeadActionStateMessage>(_playerBinder.gameObject, eventSpy.OnResponse);

            _deadActionState.Start();

            Assert.IsTrue(eventSpy.ActionCalled);

            UnityMessageEventFunctions.UnregisterActionWithDispatcher(_playerBinder.gameObject, handle);
        }
Пример #18
0
        public void SetEmoteState_NotChanged_DoesNotSendMessageWithNewState()
        {
            var messageSpy = new UnityTestMessageHandleResponseObject <EmoteStatusChangedMessage>();

            var handle =
                UnityMessageEventFunctions.RegisterActionWithDispatcher <EmoteStatusChangedMessage>(_emote.gameObject,
                                                                                                    messageSpy.OnResponse);

            _emote.SetEmoteState(_emote.GetEmoteState());

            Assert.IsFalse(messageSpy.ActionCalled);

            UnityMessageEventFunctions.UnregisterActionWithDispatcher(_emote.gameObject, handle);
        }
Пример #19
0
        public void RequestDialogue_SendsRequestEventCorrespondingToDefaultMessage()
        {
            var messageSpy = new UnityTestMessageHandleResponseObject <RequestDialogueUIMessage>();

            var handle =
                GameInstance.CurrentInstance.GetUIMessageDispatcher().RegisterForMessageEvent <RequestDialogueUIMessage>(messageSpy.OnResponse);

            _companion.RequestDialogue();

            Assert.IsTrue(messageSpy.ActionCalled);
            Assert.AreSame(_companion.DialogueEntries.DialogueEntries[0].Lines, messageSpy.MessagePayload.Lines);

            GameInstance.CurrentInstance.GetUIMessageDispatcher().UnregisterForMessageEvent(handle);
        }
        public void PushableCollides_TriggerMessage()
        {
            var messageSpy = new UnityTestMessageHandleResponseObject <TriggerMessage>();

            var handle = UnityMessageEventFunctions.RegisterActionWithDispatcher <TriggerMessage>
                             (_pushTrigger.gameObject, messageSpy.OnResponse);

            _pushTrigger.TestCollide(_pushable.gameObject);

            Assert.IsTrue(messageSpy.ActionCalled);
            Assert.AreSame(_pushable.gameObject, messageSpy.MessagePayload.TriggeringObject);

            UnityMessageEventFunctions.UnregisterActionWithDispatcher(_pushTrigger.gameObject, handle);
        }
Пример #21
0
        public void Start_SendsInteractionUpdatedMessage()
        {
            var messageSpy = new UnityTestMessageHandleResponseObject <InteractionStatusUpdatedMessage>();

            var handler =
                UnityMessageEventFunctions.RegisterActionWithDispatcher <InteractionStatusUpdatedMessage>(
                    _interaction.gameObject, messageSpy.OnResponse);

            _interaction.TestStart();

            Assert.IsTrue(messageSpy.ActionCalled);
            Assert.IsFalse(messageSpy.MessagePayload.Interactable);

            UnityMessageEventFunctions.UnregisterActionWithDispatcher(_interaction.gameObject, handler);
        }
Пример #22
0
        public void AlterStamina_DoesNotSendUIEventIfUnaltered()
        {
            _stamina.TestStart();

            var messageSpy = new UnityTestMessageHandleResponseObject <StaminaChangedMessage>();

            var handle =
                UnityMessageEventFunctions.RegisterActionWithDispatcher <StaminaChangedMessage>(_stamina.gameObject, messageSpy.OnResponse);

            _stamina.AlterStamina(0);

            Assert.IsFalse(messageSpy.ActionCalled);

            UnityMessageEventFunctions.UnregisterActionWithDispatcher(_stamina.gameObject, handle);
        }
Пример #23
0
        public void Update_ConditionsNotComplete_DoesNotFireRequestRespawnEventToGameMode()
        {
            _deadActionState = new DeadActionState(new ActionStateInfo(_playerBinder.gameObject), _params);

            var eventSpy = new UnityTestMessageHandleResponseObject <RequestRespawnMessage>();
            var handle   =
                UnityMessageEventFunctions.RegisterActionWithDispatcher <RequestRespawnMessage>(GameModeComponent.RegisteredGameMode.gameObject, eventSpy.OnResponse);

            _deadActionState.Start();
            _deadActionState.Update(1.0f);

            Assert.IsFalse(eventSpy.ActionCalled);

            UnityMessageEventFunctions.UnregisterActionWithDispatcher(GameModeComponent.RegisteredGameMode.gameObject, handle);
        }
Пример #24
0
        public void UseActiveGadget_NoGadgets_NoEffect()
        {
            _set.TestAwake();

            var messageSpy = new UnityTestMessageHandleResponseObject <GadgetUpdatedMessage>();

            var handle = UnityMessageEventFunctions.RegisterActionWithDispatcher
                         <GadgetUpdatedMessage>(_set.gameObject, messageSpy.OnResponse);

            _set.UseActiveGadget();

            Assert.IsFalse(messageSpy.ActionCalled);

            UnityMessageEventFunctions.UnregisterActionWithDispatcher(_set.gameObject, handle);
        }
        public void ReceiveExitCinematicCameraActionStateMessage_ForwardsUpdateUIEnabledMessage()
        {
            var eventSpy = new UnityTestMessageHandleResponseObject <UpdateUIEnabledMessage>();

            var dispatcher = GameInstance.CurrentInstance.GetUIMessageDispatcher();
            var handle     = dispatcher
                             .RegisterForMessageEvent <UpdateUIEnabledMessage>(eventSpy.OnResponse);

            UnityMessageEventFunctions.InvokeMessageEventWithDispatcher(_playerUi.gameObject, new ExitCinematicCameraActionStateMessage());

            Assert.IsTrue(eventSpy.ActionCalled);
            Assert.IsTrue(eventSpy.MessagePayload.IsEnabled);

            dispatcher.UnregisterForMessageEvent(handle);
        }
Пример #26
0
        public void OnCollides_CharacterComponent_MessageSent()
        {
            var messageSpy =
                new UnityTestMessageHandleResponseObject <SaveGameTriggerActivatedMessage>();


            var handle =
                UnityMessageEventFunctions.RegisterActionWithDispatcher <SaveGameTriggerActivatedMessage>(_character.gameObject,
                                                                                                          messageSpy.OnResponse);

            _trigger.TestCollide(_character.gameObject);

            Assert.IsTrue(messageSpy.ActionCalled);

            UnityMessageEventFunctions.UnregisterActionWithDispatcher(_character.gameObject, handle);
        }
        public void ReceiveMaxStaminaChangedMessage_ForwardsToInstanceDispatcher()
        {
            var eventSpy   = new UnityTestMessageHandleResponseObject <MaxStaminaChangedUIMessage>();
            var dispatcher = GameInstance.CurrentInstance.GetUIMessageDispatcher();

            var handle = dispatcher
                         .RegisterForMessageEvent <MaxStaminaChangedUIMessage>(eventSpy.OnResponse);

            const int newStamina = 10;

            UnityMessageEventFunctions.InvokeMessageEventWithDispatcher(_playerUi.gameObject, new MaxStaminaChangedMessage(newStamina));

            Assert.AreEqual(newStamina, eventSpy.MessagePayload.NewMaxStamina);

            dispatcher.UnregisterForMessageEvent(handle);
        }
        public void IncorrectSpeciesCollides_NoTriggerMessage()
        {
            _pushTrigger.TriggeringSpeciesTypes.Add(ESpeciesType.Human);
            _species.GetCurrentSpeciesTypeResult = ESpeciesType.Rat;

            var messageSpy = new UnityTestMessageHandleResponseObject <TriggerMessage>();

            var handle = UnityMessageEventFunctions.RegisterActionWithDispatcher <TriggerMessage>
                             (_pushTrigger.gameObject, messageSpy.OnResponse);

            _pushTrigger.TestCollide(_species.gameObject);

            Assert.IsFalse(messageSpy.ActionCalled);

            UnityMessageEventFunctions.UnregisterActionWithDispatcher(_pushTrigger.gameObject, handle);
        }
Пример #29
0
        public void OnNonSuspiciousObjectCollides_DoesNotSendSightingMessageToDetector()
        {
            _vision.IsSuspiciousResult = false;
            var detectedObject = new GameObject();

            var messageSpy = new UnityTestMessageHandleResponseObject <SuspiciousObjectSightedMessage>();
            var handle     =
                UnityMessageEventFunctions.RegisterActionWithDispatcher <SuspiciousObjectSightedMessage>(_detector,
                                                                                                         messageSpy.OnResponse);

            _vision.TestCollide(detectedObject);

            Assert.IsFalse(messageSpy.ActionCalled);

            UnityMessageEventFunctions.UnregisterActionWithDispatcher(_detector, handle);
        }
Пример #30
0
        public void Start_SendsMaxHealthSetEvent()
        {
            var eventCapture = new UnityTestMessageHandleResponseObject <MaxHealthChangedMessage>();

            var handle = _dispatcherComponent.GetUnityMessageEventDispatcher().RegisterForMessageEvent <MaxHealthChangedMessage>
                         (
                eventCapture.OnResponse
                         );

            _healthComponent.TestStart();

            Assert.IsTrue(eventCapture.ActionCalled);
            Assert.AreEqual(_healthComponent.InitialHealth, eventCapture.MessagePayload.MaxHealth);

            _dispatcherComponent.GetUnityMessageEventDispatcher().UnregisterForMessageEvent(handle);
        }