public void Save_FileAlreadySaved_ShouldOverwrite() { // arrange const string repoDirectory = "Test2/"; Assert.False(Directory.Exists(repoDirectory)); const string repoPath = "Save_FileAlreadySaved_ShouldOverwrite.bin"; const string entryPath = "Test_Save_FileAlreadySaved_ShouldOverwrite.bin"; var gameStateOld = new ChessGameState(null, false, null, TeamColor.None, PlayerMode.SinglePlayer, 0); var gameStateNew = new ChessGameState(null, true, null, TeamColor.None, PlayerMode.SinglePlayer, 0); var repo = new SaveRepository(repoDirectory, repoPath); repo.Save(entryPath, gameStateOld); // act bool isInRepoBefore = repo.Contains(entryPath); repo.Save(entryPath, gameStateNew); bool isInRepoAfter = repo.Contains(entryPath); var fromRepo = repo.Read(entryPath); // assert Assert.True(isInRepoBefore); Assert.True(isInRepoAfter); Assert.NotNull(fromRepo); Assert.AreEqual(fromRepo.IsEnded, gameStateNew.IsEnded); Assert.AreEqual(fromRepo.PlayerMode, gameStateNew.PlayerMode); // clear Directory.Delete(repoDirectory, true); }
public void Delete_EntryInRepo_ShouldDelete_ShouldReturnTrue() { // arrange const string repoDirectory = "Test6/"; Assert.False(Directory.Exists(repoDirectory)); const string repoPath = "Delete_EntryInRepo_ShouldDelete_ShouldReturnTrue.bin"; const string entryPath = "Test_Delete_EntryInRepo_ShouldDelete_ShouldReturnTrue.bin"; var gameState = new ChessGameState(null, true, null, TeamColor.None, PlayerMode.SinglePlayer, 0); var repoSaver = new SaveRepository(repoDirectory, repoPath); repoSaver.Save(entryPath, gameState); var repoDeleter = new SaveRepository(repoDirectory, repoPath); // act bool isInRepo = repoDeleter.Contains(entryPath); bool result = repoDeleter.Delete(entryPath); // assert Assert.True(isInRepo); Assert.True(result); // clear Directory.Delete(repoDirectory, true); }
public void Serialize_NextDeserialize_NullObject() { // arrange var board = new OrdinaryChessBoard(); var validator = new OrdinaryBoardMoveValidator(board); var verifier = new OrdinaryBoardCheckVerifier(board, validator); var moveResult = new ValidMoveResult(board, verifier, validator, null, null); const bool isGameEnded = false; TeamColor currentTeam = TeamColor.Black; const string filePath = "Test_Serialize_NextDeserialize_NullObject.bin"; ChessGameState gameState = new ChessGameState(moveResult, isGameEnded, null, currentTeam, PlayerMode.TwoPlayers, 0); // act ChessGameSerializer.SaveInFile(filePath, gameState); ChessGameState fromFile = ChessGameSerializer.ReadFromFile <ChessGameState>(filePath); // assert Assert.AreEqual(fromFile.IsEnded, isGameEnded); Assert.AreEqual(fromFile.CurrentMovingTeam, currentTeam); // clear Assert.True(ChessGameSerializer.ClearFile(filePath)); }
public void Serialize_NextDeserialize_AlreadyWrittenFile() { // arrange var board = new OrdinaryChessBoard(); var validator = new OrdinaryBoardMoveValidator(board); var verifier = new OrdinaryBoardCheckVerifier(board, validator); LastMoveViewModel lastMoveVm = new LastMoveViewModel(new King(new Position(1, 2), TeamColor.Black), new Position(1, 2), new Position(2, 3), null); var moveResult = new ValidMoveResult(board, verifier, validator, lastMoveVm, null); const bool isGameEnded = false; TeamColor currentTeam = TeamColor.Black; const string filePath = "Serialize_NextDeserialize_AlreadyWrittenFile.bin"; ChessGameState gameState = new ChessGameState(moveResult, isGameEnded, null, currentTeam, PlayerMode.TwoPlayers, 0); // act ChessGameSerializer.SaveInFile(filePath, gameState); ChessGameSerializer.SaveInFile(filePath, gameState); ChessGameState fromFile = ChessGameSerializer.ReadFromFile <ChessGameState>(filePath); // assert Assert.AreEqual(fromFile.IsEnded, isGameEnded); Assert.AreEqual(fromFile.CurrentMovingTeam, currentTeam); Assert.AreEqual(fromFile.LastGameMoveResult.LastMoveFigureAndPositionFromAndDest().Item2, moveResult.LastMoveFigureAndPositionFromAndDest().Item2); // clear Assert.True(ChessGameSerializer.ClearFile(filePath)); }
public GameConductor(ChessGameState state) { _currentMovingTeam = state.CurrentMovingTeam; _isCheckMate = state.IsEnded; _smashed = state.LastGameMoveResult.AllSmashedFigures().ToList(); _moveManager = new MoveManager.MoveManager(state.LastGameMoveResult.GetBoard().GetCopy()); }
public void Read_ValidPath_ShouldReturnSavedValue() { // arrange const string repoDirectory = "Test4/"; Assert.False(Directory.Exists(repoDirectory)); const string repoPath = "Read_ValidPath_ShouldReturnSavedValue.bin"; const string entryPath = "Test_Read_ValidPath_ShouldReturnSavedValue.bin"; var gameState = new ChessGameState(null, true, null, TeamColor.None, PlayerMode.SinglePlayer, 0); var repoSaver = new SaveRepository(repoDirectory, repoPath); repoSaver.Save(entryPath, gameState); var repoReader = new SaveRepository(repoDirectory, repoPath); // act bool isInRepo = repoReader.Contains(entryPath); var fromRepo = repoReader.Read(entryPath); // assert Assert.True(isInRepo); Assert.AreEqual(fromRepo.IsEnded, gameState.IsEnded); Assert.AreEqual(fromRepo.PlayerMode, gameState.PlayerMode); // clear Directory.Delete(repoDirectory, true); }
public async Task PieceMovedAsync(string playerName, string from, string to, ChessGameState gameState) { await gameHubContext.Clients.User(gameState.GameInfo.White.Name == playerName?gameState.GameInfo.Black.Name : gameState.GameInfo.White.Name) .SendAsync("OnPieceMoved", from, to, gameState); await gameHubContext.Clients.Group(ChessFabrickUtils.GameGroupName(gameState.GameInfo.GameId)).SendAsync("OnBoardChanged", gameState); }
public async Task <ChessGameState> MovePieceAsync(string gameId, string playerName, string from, string to) { var dictActiveGames = await GetActiveGameDict(); var dictCompletedGames = await GetCompletedGameDict(); ChessGameState newGameState; var board = new Board(); using (var tx = StateManager.CreateTransaction()) { var game = await GetActiveGameAsync(tx, gameId); if (playerName != game.White.Name && playerName != game.Black.Name) { throw new ArgumentException("Player not in the game."); } board.PerformMoves(game.MoveHistory); var fromField = ChessGameUtils.FieldFromString(from); var toField = ChessGameUtils.FieldFromString(to); var piece = board[fromField.Item1, fromField.Item2]; if (!piece.MoveTo(toField.Item1, toField.Item2)) { throw new ArgumentException("Illegal move."); } var newGameInfo = new ChessGameInfo(game.GameId, game.White, game.Black, board.ToMovesString()); if (board.IsCheckmate || board.IsDraw) { await dictActiveGames.TryRemoveAsync(tx, gameId); await dictCompletedGames.TryAddAsync(tx, gameId, newGameInfo); } else { await dictActiveGames.TryUpdateAsync(tx, gameId, newGameInfo, game); } await tx.CommitAsync(); newGameState = new ChessGameState(newGameInfo); } var chessSignalRClient = proxyFactory.CreateServiceProxy <IChessFabrickSignalRService>(chessSignalRUri /*, ChessFabrickUtils.GuidPartitionKey(gameId)*/); chessSignalRClient.PieceMovedAsync(playerName, from, to, newGameState); if (newGameState.GetCurrentPlayer().IsBot() && !board.IsCheckmate && !board.IsDraw) { var actor = ActorProxy.Create <IChessFabrickActor>(new ActorId(gameId), chessActorUri); actor.PerformMove(); } return(newGameState); }
public SinglePlayerModeConsoleGame(ChessGameState state) { _player = state.Players[0]; _difficulty = state.DifficultyLevel; _gameConductor = new GameConductor(state); _startMoveResult = state.LastGameMoveResult; TeamColor computerColor = _player.TeamColor == TeamColor.Black ? TeamColor.White : TeamColor.Black; _computer = new ComputerPlayer(computerColor, _difficulty + 1, _difficulty); }
private void OnBoardChanged(ChessGameState board) { Console.WriteLine($"OnBoardChanged: {JsonConvert.SerializeObject(board)}"); if (board?.GameInfo?.GameId != gameId) { return; } gameState = board; selectedField = null; possibleMoves = null; showLastMove = true; UpdateBoard(); }
public static ChessGameState LookForCheckMateOrDraw(ChessBoard board, ChessPieceColor turn, List <ChessMove> chessMoves) { ChessGameState newGameState = ChessGameState.Active; List <ChessMove> possibleMoves = GetPossibleMoves(board, turn); if (possibleMoves.Count == 0) { if (IsInCheck(board, turn)) { newGameState = ChessGameState.CheckMate; } else { newGameState = ChessGameState.StaleMate; } } if (newGameState == ChessGameState.Active) { if (chessMoves != null && chessMoves.Count > 8) { int index = chessMoves.Count - 1; if (CompareMoves(index - 7, index - 3, chessMoves) && CompareMoves(index - 6, index - 2, chessMoves) && CompareMoves(index - 5, index - 1, chessMoves) && CompareMoves(index - 4, index, chessMoves)) { newGameState = ChessGameState.DrawByRepetition; } } } if (newGameState == ChessGameState.Active) { if (board.count50MoveRule > 99) { newGameState = ChessGameState.DrawBy50MoveRule; } } if (newGameState == ChessGameState.Active) { if (board.CheckDrawByMaterial()) { newGameState = ChessGameState.DrawByMaterial; } } return(newGameState); }
private IMoveResult SaveGame(IMoveResult moveResult) { Console.WriteLine("Under what name save the game?"); string file = UserInteraction.ReadNotEmptyStringFromUser(); var saveRepository = SaveRepository.GetDefaultRepository(); bool isEnded = moveResult.IsCheckMate(TeamColor.Black) || moveResult.IsCheckMate(TeamColor.White); var state = new ChessGameState(moveResult, isEnded, new [] { _player }, _computer.MyTeamColor, PlayerMode.SinglePlayer, _difficulty); saveRepository.Save(file + ".bin", state); Console.WriteLine("Game saved."); return(new StoppedMoveResult()); }
private IMoveResult SaveGame(IMoveResult moveResult, int currentPlayer) { Console.WriteLine("Under what name save the game?"); string file = UserInteraction.ReadNotEmptyStringFromUser(); var saveRepository = SaveRepository.GetDefaultRepository(); bool isEnded = moveResult.IsCheckMate(TeamColor.Black) || moveResult.IsCheckMate(TeamColor.White); var state = new ChessGameState(moveResult, isEnded, _players, _players[currentPlayer].TeamColor, PlayerMode.TwoPlayers, 0); saveRepository.Save(file + ".bin", state); Console.WriteLine("Game saved."); return(new StoppedMoveResult()); }
private async void btnAddBot_Click(object sender, EventArgs e) { try { var game = await PostAddBot(); gameState = new ChessGameState(game); UpdateBoard(); } catch (Exception ex) { txbMessage.Text = ex.Message; Console.Error.WriteLine(ex); } }
public void StartMove(string gameName, int x, int y) { SingleGame game; if (gameName != null && Games.ActualGames.TryGetValue(gameName, out game)) { if (PlayersTurn(game)) { ChessGameState state = game.ActualGameState; if (state != null) { Clients.Group(gameName).highLightFields(state.GetPossibleMoves(x, y)); } } } }
private async Task StartHubConnection() { try { await connection.StartAsync(); } catch (Exception ex) { Console.Error.WriteLine(ex); var result = MessageBox.Show(this, ex.Message, "Unable to connect to the server. Retry?", MessageBoxButtons.YesNo, MessageBoxIcon.Error); switch (result) { case DialogResult.Yes: await StartHubConnection(); return; case DialogResult.No: Close(); return; } } try { if (playerColor == null) { gameState = await connection.InvokeAsync <ChessGameState>("SpectateGame", gameId); Console.WriteLine($"SpectateGame: {JsonConvert.SerializeObject(gameState)}"); } else if (gameState != null) { gameState = await connection.InvokeAsync <ChessGameState>("JoinGame", gameId); Console.WriteLine($"JoinGame: {JsonConvert.SerializeObject(gameState)}"); } } catch (HubException ex) { Console.Error.WriteLine(ex); txbMessage.Text = ex.Message; } UpdateBoard(); }
public ChessOnlineForm(UserModel user, Uri host, ChessGameInfo gameInfo) { this.user = user; this.host = host; this.gameId = gameInfo.GameId; if (gameInfo.White?.Name == user.Player.Name) { playerColor = PieceColor.White; } else if (gameInfo.Black?.Name == user.Player.Name) { playerColor = PieceColor.Black; } if (gameInfo.White != null && gameInfo.Black != null) { gameState = new ChessGameState(gameInfo); } InitializeComponent(); InitializeBoard(); InitHttpClient(); InitHubConnection(); Icon = Icon.FromHandle(Properties.Resources.knight_white.GetHicon()); Text = $"Chess - {user.Player.Name}"; if (playerColor == null) { grbPlayerColor.Text = "Spectating"; cfbPlayerColor.Image = Properties.Resources.eye; } else { grbPlayerColor.Text = "Your color"; cfbPlayerColor.Image = PieceImageUtils.Pawn(playerColor.Value); } }
public void Contains_TrueAndFalse() { // arrange const string repoDirectory = "Test3/"; Assert.False(Directory.Exists(repoDirectory)); const string repoPath = "Contains_Contains_ShouldReturnTrue.bin"; const string entryPath = "Test_Contains_Contains_ShouldReturnTrue.bin"; var gameState = new ChessGameState(null, true, null, TeamColor.None, PlayerMode.SinglePlayer, 0); var repo = new SaveRepository(repoDirectory, repoPath); repo.Save(entryPath, gameState); // act bool isInValid = repo.Contains(entryPath); bool isInInvalid = repo.Contains(entryPath + "!"); // assert Assert.True(isInValid); Assert.False(isInInvalid); // clear Directory.Delete(repoDirectory, true); }
private async void FieldBox_Click(object sender, EventArgs e) { var fieldBox = sender as ChessFieldBox; var field = fieldBox.Tag as Tuple <int, int>; showLastMove = false; if (selectedField == null) { selectedField = field; var selectedPiece = board[selectedField.Item1, selectedField.Item2]; if (selectedPiece?.Color != playerColor || selectedPiece?.Color != gameState.OnTurn) { selectedField = null; } if (selectedField != null) { fieldBox.Style = ChessFieldBox.BoxStyle.Selected; fieldBox.Invalidate(); try { possibleMoves = new List <Tuple <int, int> >(); var newPossibleMoves = new List <Tuple <int, int> >(); var moves = await connection.InvokeAsync <List <string> >("GetPieceMoves", gameId, ChessGameUtils.FieldToString(selectedField.Item1, selectedField.Item2) ); foreach (var move in moves) { newPossibleMoves.Add(ChessGameUtils.FieldFromString(move)); } possibleMoves = newPossibleMoves; } catch (HubException ex) { selectedField = null; possibleMoves = null; Console.Error.WriteLine(ex); txbMessage.Text = ex.Message; } } } else { if (possibleMoves.Contains(field)) { try { gameState = await connection.InvokeAsync <ChessGameState>("MovePiece", gameId, ChessGameUtils.FieldToString(selectedField.Item1, selectedField.Item2), ChessGameUtils.FieldToString(field.Item1, field.Item2) ); } catch (HubException ex) { Console.Error.WriteLine(ex); txbMessage.Text = ex.Message; } } selectedField = null; possibleMoves = null; } UpdateBoard(); }
public SingleGame() { ActualGameState = new ChessGameState(); IsOver = false; }
public void MoveTo(string gameName, int x1, int y1, int x2, int y2) { SingleGame game; if (gameName != null && Games.ActualGames.TryGetValue(gameName, out game)) { if (PlayersTurn(game)) { lock (game) { if (!game.IsOver) { ChessGameState state = game.ActualGameState; ChessGameState nextState = state.GetNextMove(x1, y1, x2, y2); if (nextState != null) { AddToChat( gameName, "" + state.PieceSymbolAtPosition(x1, y1) + (char)('A' + x1) + (1 + y1) + " to " + nextState.PieceSymbolAtPosition(x2, y2) + (char)('A' + x2) + (1 + y2), ""); game.ActualGameState = nextState; state = nextState; Games.ShudeleGameRemoval( gameName, game.UpdateTime, game.TourTime, "Timeout: " + (state.Tour == ChessGameState.Color.White ? "balck player won" : "white player won")); } updateGameState(Clients.Group(gameName), game); if (game.IsOver) { string status = "draw"; if (game.ActualGameState.WhiteChecked.Value) { status = "balck player won"; } if (game.ActualGameState.BlackChecked.Value) { status = "white player won"; } AddToChat( gameName, "Game over: " + status, ""); } } } } else { updateGameState(Clients.Caller, game); } } }
public TwoPlayersModeConsoleGame(ChessGameState state) { _players = state.Players; _gameConductor = new GameConductor(state); _moveResult = state.LastGameMoveResult; }
public ChessOnlineForm(UserModel user, Uri host, ChessGameState gameState) : this(user, host, gameState.GameInfo) { }