public void LoadGame(StreamReader stream)
{
var loadingResult = GameFactory.LoadGame(stream);
if (loadingResult.LoadingSuccesfull)
{
Game = loadingResult.Game;
if (Game.EndState == GameState.StillPlaying)
{
ProgramState.GameLoaded();
}
else
{
ProgramState.GameFinished();
}
OutputFacade.UpdateRecordState(Game.RecordOfGame);
OutputFacade.UpdateBoardState(RenderGameState());
OutputFacade.UpdateWhosPlaying(Game.PlayerOnMove);
}
else
{
OutputFacade.AddToTrackingLog(ProgramLocalization.GameLoadingFailed);
}
}
public void NewGame()
{
Game = GameFactory.NewGame();
ProgramState.GameLoaded();
OutputFacade.UpdateBoardState(RenderGameState());
OutputFacade.UpdateWhosPlaying(Game.PlayerOnMove);
}
/// <summary>
/// Update fps counter
/// </summary>
private void UpdateFps()
{
int?fps = FpsCounter.Update();
if (fps != null)
{
OutputFacade.UpdateFps(fps.Value);
}
}
public OutputFacadeTests()
{
_cursorHelperMock = new Mock <ICursorHelper>(MockBehavior.Strict);
_gridPainterMock = new Mock <IGridPainter>(MockBehavior.Strict);
_gridResultPainterMock = new Mock <IGridResultPainter>(MockBehavior.Strict);
_textResultDisplayerMock = new Mock <ITextResultDisplayer>(MockBehavior.Strict);
_soundPlayerMock = new Mock <ISoundPlayer>(MockBehavior.Strict);
_outputWriter = new Mock <IOutputWriter>(MockBehavior.Strict);
_sut = new OutputFacade(_cursorHelperMock.Object, _gridPainterMock.Object, _gridResultPainterMock.Object, _textResultDisplayerMock.Object, _soundPlayerMock.Object,
_outputWriter.Object);
}
public DispatcherIntegrationTests()
{
_gameLogicMock = new Mock <IGameLogic>(MockBehavior.Strict);
_inputReaderMock = new Mock <IInputReader>(MockBehavior.Strict);
_outputWriterMock = new Mock <IOutputWriter>(MockBehavior.Strict);
_soundPlayerMock = new Mock <ISoundPlayer>(MockBehavior.Strict);
var cursorHelper = new CursorHelper();
var gridPainter = new GridPainter(_outputWriterMock.Object);
var gridResultPainter = new GridResultPainter(cursorHelper, _outputWriterMock.Object);
var textResultDisplayer = new TextResultDisplayer(_outputWriterMock.Object, cursorHelper);
var outputFacade = new OutputFacade(cursorHelper, gridPainter, gridResultPainter, textResultDisplayer, _soundPlayerMock.Object, _outputWriterMock.Object);
_sut = new Dispatcher(_gameLogicMock.Object, _inputReaderMock.Object, outputFacade);
}
public void TryChangeChessboardState(TrackingState trackingState)
{
if (Game.EndState == GameState.StillPlaying)
{
var validationResult = GameValidator.ValidateAndPerform(Game.DeepClone(), trackingState); // get from validator
if (validationResult.IsValid)
{
Game = validationResult.NewGameState;
}
if (trackingState.IsEquivalentTo(Game.Chessboard.GetTrackingStates()))
{
OutputFacade.UpdateValidationState(true);
}
else
{
OutputFacade.UpdateValidationState(validationResult.IsValid);
}
if (Game.EndState != GameState.StillPlaying)
{
ProgramState.GameFinished();
// do some stopping of everything}
OutputFacade.AddToTrackingLog(ProgramLocalization.GameEnded);
if (Game.EndState == GameState.BlackWin)
{
OutputFacade.AddToTrackingLog(ProgramLocalization.BlackWon);
Game.RecordOfGame.Add(ProgramLocalization.BlackWonRecord);
}
if (Game.EndState == GameState.WhiteWin)
{
OutputFacade.AddToTrackingLog(ProgramLocalization.WhiteWon);
Game.RecordOfGame.Add(ProgramLocalization.WhiteWonRecord);
}
if (Game.EndState == GameState.Draw)
{
OutputFacade.AddToTrackingLog(ProgramLocalization.ItsDraw);
Game.RecordOfGame.Add(ProgramLocalization.ItsDrawRecord);
}
}
OutputFacade.UpdateRecordState(Game.RecordOfGame);
OutputFacade.UpdateBoardState(RenderGameState());
OutputFacade.UpdateWhosPlaying(Game.PlayerOnMove);
}
}
public int?InitiateWithTracingInput(TrackingState trackingState)
{
var figures = Game.Chessboard.GetTrackingStates().Figures;
var chessboardState = new TrackingState(figures);
for (int i = 0; i < 4; i++)
{
if (TrackingState.IsEquivalent(chessboardState, trackingState))
{
OutputFacade.UpdateValidationState(true);
return(i);
}
trackingState.RotateClockWise(1);
}
return(null);
}
/// <summary>
/// Processing of messages arriving from tracking thread
/// </summary>
public void ProcessQueue()
{
bool messageProcessed = false;
do
{
messageProcessed = ProcessingOutputQueue.TryTake(out var message);
if (message is ResultMessage resultMessage)
{
TrackingResultProcessing.ProcessResult(resultMessage);
}
if (message is TrackingStartSuccessfulMessage)
{
ProgramState.TrackingStartSuccessful();
}
if (message is TrackingError error)
{
ProgramState.ErrorInTracking(error.Message);
StopTracking();
}
if (message is SceneCalibrationSnapshotMessage snapshot)
{
OutputFacade.UpdateCalibrationSnapshot(snapshot.Snapshot);
}
if (messageProcessed && message == null)
{
throw new InvalidOperationException(string.Format(ProgramLocalization.UnexpectedIncomingMessage, nameof(TrackingManager)));
}
} while (messageProcessed);
}
/// <summary>
/// Process result message, update concrete components, average tracking state optionally notify game
/// </summary>
/// <param name="resultMessage"></param>
public void ProcessResult(ResultMessage resultMessage)
{
OutputFacade.HandDetected(resultMessage.HandDetected);
OutputFacade.DisplayVizuaization(resultMessage.BitmapToDisplay);
UpdateFps();
if (resultMessage.TrackingState == null)
{
return;
}
if (resultMessage.HandDetected)
{
return;
}
if (TimeOffset > DateTime.Now)
{
return;
}
var trackingState = resultMessage.TrackingState;
trackingState.HorizontalFlip();
var pointCounts = resultMessage.PointCountsOverFields;
pointCounts = pointCounts.FlipHorizontally();
if (TrackningInProgress)
{
trackingState.RotateClockWise(NumberOfCwRotations);
pointCounts = pointCounts.RotateArray90DegCcwNTimes(NumberOfCwRotations);
OutputFacade.UpdateImmediateBoard(GenerateImageForTrackingState(trackingState, pointCounts));
// averaging
var average = Averaging(trackingState);
if (average == null)
{
return;
}
// send averaging
OutputFacade.UpdateAveragedBoard(GenerateImageForTrackingState(average, null, GameController.GetTrackingState()));
// check so we aren't sending the same state again
if (LastSentState != null && !LastSentState.IsEquivalentTo(average))
{
// send it to the game
GameController.TryChangeChessboardState(average);
}
LastSentState = average;
}
else
{
OutputFacade.UpdateImmediateBoard(GenerateImageForTrackingState(trackingState, pointCounts));
// averaging
var average = Averaging(trackingState);
if (average == null)
{
return;
}
else
{
// send averaging
OutputFacade.UpdateAveragedBoard(GenerateImageForTrackingState(average, null));
// try to get rotation of tracking state
var rotation = GameController.InitiateWithTracingInput(average);
// if rotation is succesfull(figures got matched)
if (rotation.HasValue)
{
ProgramState.GameRecognized();
NumberOfCwRotations = rotation.Value;
RotatedSavedStates();
TrackningInProgress = true;
}
}
}
}
public void SaveGame(StreamWriter stream)
{
stream.Write(Game.ExportGameToAlgebraicNotation());
OutputFacade.AddToTrackingLog(ProgramLocalization.GameSaved);
}
