public void WhenDispatchGuessResultSignal_UpdateGallowVisibilityViewModel()
{
SignalDelegate callback = null;
_eventDispatcherService
.When(service => service.Subscribe <GuessResultSignal>(Arg.Any <SignalDelegate>()))
.Do(info => callback = info.Arg <SignalDelegate>());
var isEnabledObserver1 = Substitute.For <IObserver <bool> >();
_inGameViewModel.IsGallowPartVisible.Clear();
var gallowImageProperty1 = _inGameViewModel.SubscribeGallowImage();
gallowImageProperty1.Subscribe(isEnabledObserver1);
isEnabledObserver1.ClearReceivedCalls();
var isEnabledObserver2 = Substitute.For <IObserver <bool> >();
var gallowImageProperty2 = _inGameViewModel.SubscribeGallowImage();
gallowImageProperty2.Subscribe(isEnabledObserver2);
isEnabledObserver2.ClearReceivedCalls();
var inGamePresenter = new InGamePresenter(_inGameViewModel, _eventDispatcherService);
callback(new GuessResultSignal(_letterToGuess, "word", true));
callback(new GuessResultSignal(_letterToGuess, "word", false));
callback(new GuessResultSignal(_letterToGuess, "word", true));
callback(new GuessResultSignal(_letterToGuess, "word", false));
callback(new GuessResultSignal(_letterToGuess, "word", true));
Received.InOrder(() =>
{
isEnabledObserver1.Received().OnNext(true);
isEnabledObserver2.Received().OnNext(true);
});
}
public void WhenCallToDispose_UnsubscribeFromEventDispatch()
{
var inGamePresenter = new InGamePresenter(_inGameViewModel, _eventDispatcherService);
_eventDispatcherService.ClearReceivedCalls();
inGamePresenter.Dispose();
_eventDispatcherService.Received(1).Unsubscribe <NewWordSignal>(Arg.Any <SignalDelegate>());
_eventDispatcherService.Received(1).Unsubscribe <GuessResultSignal>(Arg.Any <SignalDelegate>());
_eventDispatcherService.Received(1).Unsubscribe <WordCompletedSignal>(Arg.Any <SignalDelegate>());
_eventDispatcherService.Received(1).Unsubscribe <RestartGameSignal>(Arg.Any <SignalDelegate>());
_eventDispatcherService.Received(1).Unsubscribe <GameOverSignal>(Arg.Any <SignalDelegate>());
Assert.AreEqual(5, _eventDispatcherService.ReceivedCalls().Count());
}
public void WhenDispatchGuessResultSignal_UpdateKeyButtonViewModel(bool isCorrect)
{
SignalDelegate callback = null;
_eventDispatcherService
.When(service => service.Subscribe <GuessResultSignal>(Arg.Any <SignalDelegate>()))
.Do(info => callback = info.Arg <SignalDelegate>());
var inGamePresenter = new InGamePresenter(_inGameViewModel, _eventDispatcherService);
callback(new GuessResultSignal(_letterToGuess, "word", isCorrect));
_colorObserver.Received().OnNext(isCorrect ? InGameViewModel.CorrectColor : InGameViewModel.IncorrectColor);
_isKetEnabledObserver.Received().OnNext(false);
}
public void WhenDispatchNewWordSignal_UpdateTheVisibilityInViewModel()
{
SignalDelegate callback = null;
_eventDispatcherService
.When(service => service.Subscribe <NewWordSignal>(Arg.Any <SignalDelegate>()))
.Do(info => callback = info.Arg <SignalDelegate>());
var observer = Substitute.For <IObserver <bool> >();
_inGameViewModel.IsVisible.Subscribe(observer);
var inGamePresenter = new InGamePresenter(_inGameViewModel, _eventDispatcherService);
callback(new NewWordSignal("word"));
observer.Received().OnNext(true);
}
public void WhenDispatchNewWordSignal_UpdateTheWordInViewModel()
{
SignalDelegate callback = null;
_eventDispatcherService
.When(service => service.Subscribe <NewWordSignal>(Arg.Any <SignalDelegate>()))
.Do(info => callback = info.Arg <SignalDelegate>());
var wordObserver = Substitute.For <IObserver <string> >();
_inGameViewModel.CurrentWord.Subscribe(wordObserver);
var inGamePresenter = new InGamePresenter(_inGameViewModel, _eventDispatcherService);
callback(new NewWordSignal("word"));
wordObserver.Received().OnNext("w o r d");
}
private void Start()
{
var mainMenuViewModel = new MainMenuViewModel();
var inGameViewModel = new InGameViewModel();
var loadingViewModel = new LoadingViewModel();
InstantiateViews(mainMenuViewModel, inGameViewModel, loadingViewModel);
// TODO: these services should be unique, instantiate it in a previous step
var gameRepository = new GameRepository();
var gameServerService = new GameServerService
(
new RestRestClientAdapter(new JsonUtilityAdapter()),
gameRepository
);
var eventDispatcherService = new EventDispatcherService();
var startGameUseCase =
new StartGameUseCase(gameServerService, gameRepository, new ConfigurationGameRepository(),
eventDispatcherService);
var startGameController = new StartGameController(mainMenuViewModel,
startGameUseCase
);
var keyboardController = new KeyboardController(inGameViewModel,
new GuessLetterUseCase(
new CheckSolutionUseCase(
gameServerService,
gameRepository,
eventDispatcherService
),
gameRepository,
gameServerService,
eventDispatcherService
)
);
var restartGameController =
new RestartGameController(inGameViewModel,
new RestartGameUseCase(startGameUseCase, eventDispatcherService));
var updateWordPresenter = new InGamePresenter(inGameViewModel, eventDispatcherService);
var mainMenuPresenter = new MainMenuPresenter(mainMenuViewModel, eventDispatcherService);
var loadingPresenter = new LoadingPresenter(loadingViewModel, eventDispatcherService);
}
public void WhenDispatchRestartGameSignal_RestartKeyboard()
{
SignalDelegate callback = null;
_eventDispatcherService
.When(service => service.Subscribe <RestartGameSignal>(Arg.Any <SignalDelegate>()))
.Do(info => callback = info.Arg <SignalDelegate>());
var inGamePresenter = new InGamePresenter(_inGameViewModel, _eventDispatcherService);
_keyButtonViewModel.Color.Value = "";
_keyButtonViewModel.IsEnabled.Value = false;
_colorObserver.ClearReceivedCalls();
_isKetEnabledObserver.ClearReceivedCalls();
Assert.AreNotEqual(InGameViewModel.DefaultColor, _keyButtonViewModel.Color.Value);
Assert.AreNotEqual(true, _keyButtonViewModel.IsEnabled.Value);
callback(new RestartGameSignal());
_colorObserver.Received().OnNext(InGameViewModel.DefaultColor);
_isKetEnabledObserver.Received().OnNext(true);
}
private void InitializeModifyMode()
{
Loading = true;
using (new TimedLogEvent("Initialize game (in modify mode)"))
{
// Switch mode
CurrentState = GameState.Modify;
// Clean previous presenter
CleanupPresenter();
// Load game scene
CurrentPresenter = new InGamePresenter(Engine, CurrentSession.Universe);
CurrentPresenter.Initialize();
// Activate new view
AddInputReceiver((InteractivePresenter)CurrentPresenter);
CurrentPresenter.HookIn();
if (Settings.Current.Graphics.Fading)
{
Engine.FadeIn();
}
// Show game GUI
GuiManager.Reset();
LoadDialog("InGame/HUD_Modify");
}
using (new TimedLogEvent("Clean caches"))
{
Engine.Cache.Clean();
GC.Collect();
}
Loading = false;
}
public void WhenDispatchRestartGameSignal_RestartEndGameVisibilityInViewModel()
{
SignalDelegate callback = null;
_eventDispatcherService
.When(service => service.Subscribe <RestartGameSignal>(Arg.Any <SignalDelegate>()))
.Do(info => callback = info.Arg <SignalDelegate>());
var isEndGameVisibleObserver = Substitute.For <IObserver <bool> >();
_inGameViewModel.IsEndGameVisible.Subscribe(isEndGameVisibleObserver);
var isGameOverVisibleObserver = Substitute.For <IObserver <bool> >();
_inGameViewModel.IsGameOverVisible.Subscribe(isGameOverVisibleObserver);
var isVictoryVisibleObserver = Substitute.For <IObserver <bool> >();
_inGameViewModel.IsVictoryVisible.Subscribe(isVictoryVisibleObserver);
var inGamePresenter = new InGamePresenter(_inGameViewModel, _eventDispatcherService);
callback(new RestartGameSignal());
isEndGameVisibleObserver.Received().OnNext(false);
isGameOverVisibleObserver.Received().OnNext(false);
isVictoryVisibleObserver.Received().OnNext(false);
}
public void WhenDispatchRestartGameSignal_RestartGallow()
{
SignalDelegate callback = null;
_eventDispatcherService
.When(service => service.Subscribe <RestartGameSignal>(Arg.Any <SignalDelegate>()))
.Do(info => callback = info.Arg <SignalDelegate>());
var isEnabledObserver = Substitute.For <IObserver <bool> >();
_inGameViewModel.IsGallowPartVisible.Clear();
var gallowImageProperty = _inGameViewModel.SubscribeGallowImage();
var inGamePresenter = new InGamePresenter(_inGameViewModel, _eventDispatcherService);
gallowImageProperty.Subscribe(isEnabledObserver);
gallowImageProperty.Value = true;
_inGameViewModel.NextGallowPartToShow = 2;
Assert.AreNotEqual(0, _inGameViewModel.NextGallowPartToShow);
Assert.IsTrue(gallowImageProperty.Value);
callback(new RestartGameSignal());
Assert.AreEqual(0, _inGameViewModel.NextGallowPartToShow);
isEnabledObserver.Received().OnNext(false);
}
