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 void IsCheck_BlackTeam_Check_Bishop_ShouldReturnTrue()
{
// arrange
var board = new OrdinaryChessBoard();
var pawnDeletePosition = new Position(6, 3);
var bishopStartPosition = new Position(0, 5);
var bishopEndPosition = new Position(3, 0);
board.RemoveFigure(pawnDeletePosition);
var bishop = board.RemoveFigure(bishopStartPosition);
bishop.Move(bishopEndPosition);
board.SetFigure(bishop, bishopEndPosition);
var moveValidator = new OrdinaryBoardMoveValidator(board);
var verifier = new OrdinaryBoardCheckVerifier(board, moveValidator);
TeamColor teamColor = TeamColor.Black;
// act
var result = verifier.IsCheck(teamColor);
// assert
Assert.True(result);
}
public void VerifyMoveCauseCheck_BlackKingChecked_MoveToSavePosition_ShouldReturnFalse()
{
// arrange
var board = new OrdinaryChessBoard();
var blackPawnRemove1Postion = new Position(1, 3);
var blackPawnRemove2Postion = new Position(1, 4);
var startWhiteQueenPosition = new Position(7, 3);
var endWhiteQueenPosition = new Position(4, 0);
var blackKingStartPosition = new Position(0, 4);
var blackKingEndPosition = new Position(1, 4);
board.RemoveFigure(blackPawnRemove1Postion);
board.RemoveFigure(blackPawnRemove2Postion);
var whiteQueen = board.RemoveFigure(startWhiteQueenPosition);
whiteQueen.Move(endWhiteQueenPosition);
board.SetFigure(whiteQueen, endWhiteQueenPosition);
var moveValidator = new OrdinaryBoardMoveValidator(board);
var verifier = new OrdinaryBoardCheckVerifier(board, moveValidator);
// act
var result = verifier.VerifyMoveCauseCheck(blackKingStartPosition, blackKingEndPosition);
// assert
Assert.False(result);
}
public void IsLastMoveSmash_NotSmash_ShouldReturnFalse()
{
// arrange
var board = new OrdinaryChessBoard();
var startBlackPawnPosition = new Position(1, 5);
var oneHopBlackPawnPosition = new Position(3, 5);
var startWhitePawnPosition = new Position(6, 4);
var oneHopWhitePawnPosition = new Position(4, 4);
var blackPawn = board.RemoveFigure(startBlackPawnPosition);
blackPawn.Move(oneHopBlackPawnPosition);
board.SetFigure(blackPawn, oneHopBlackPawnPosition);
var whitePawn = board.RemoveFigure(startWhitePawnPosition);
whitePawn.Move(oneHopWhitePawnPosition);
board.SetFigure(whitePawn, oneHopWhitePawnPosition);
var validator = new OrdinaryBoardMoveValidator(board);
var verifier = new OrdinaryBoardCheckVerifier(board, validator);
var lastMoveVm = new LastMoveViewModel(whitePawn, startWhitePawnPosition, oneHopWhitePawnPosition, null);
var moveResult = new ValidMoveResult(board, verifier, null, lastMoveVm, null);
// act
var result = moveResult.IsLastMoveSmash();
// assert
Assert.False(result);
}
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 IsCheckMate_NotCheck_ShouldReturnFalse()
{
// arrange
var board = new OrdinaryChessBoard();
var pawnStartPosition = new Position(1, 0);
var pawnEndPosition = new Position(2, 0);
var pawn = board.RemoveFigure(pawnStartPosition);
pawn.Move(pawnEndPosition);
board.SetFigure(pawn, pawnEndPosition);
var validator = new OrdinaryBoardMoveValidator(board);
var verifier = new OrdinaryBoardCheckVerifier(board, validator);
var lastMoveVm = new LastMoveViewModel(pawn, pawnStartPosition, pawnEndPosition, null);
var moveResult =
new ValidMoveResult(board, verifier, validator, lastMoveVm, null);
var team1 = TeamColor.Black;
var team2 = TeamColor.White;
// act
var result1 = moveResult.IsCheck(team1);
var result2 = moveResult.IsCheck(team2);
var result3 = moveResult.IsCheckMate(team1);
var result4 = moveResult.IsCheckMate(team2);
// assert
Assert.False(result1);
Assert.False(result2);
Assert.False(result3);
Assert.False(result4);
}
public void GetScore_AfterMovementBlack_BottomLeftPawnTwoFieldUp_WhiteTeam_ShouldBe_Minus1()
{
// arrange
var startingBoard = new OrdinaryChessBoard();
TeamColor team = TeamColor.White;
var startPawnPosition = new Position(1, 0);
var endPawnPosition = new Position(3, 0);
var pawn = startingBoard.RemoveFigure(startPawnPosition);
startingBoard.SetFigure(pawn, endPawnPosition);
pawn.Move(endPawnPosition);
var validator = new OrdinaryBoardMoveValidator(startingBoard);
var verifier = new OrdinaryBoardCheckVerifier(startingBoard, validator);
var lastMoveVm = new LastMoveViewModel(pawn, startPawnPosition, endPawnPosition, null);
var moveResult =
new ValidMoveResult(startingBoard, verifier, null, lastMoveVm, null);
int expectedScore = -1;
// act
var result = moveResult.GetScore(team);
// assert
Assert.AreEqual(expectedScore, result);
}
public void IsCheck_BlackTeam_BlackChecked_Bishop_ShouldReturnFalse()
{
// arrange
var board = new OrdinaryChessBoard();
var blackPawnDeletePosition = new Position(1, 3);
var whiteBishopStartPosition = new Position(7, 5);
var whiteBishopEndPosition = new Position(4, 0);
board.RemoveFigure(blackPawnDeletePosition);
var bishop = board.RemoveFigure(whiteBishopStartPosition);
bishop.Move(whiteBishopEndPosition);
board.SetFigure(bishop, whiteBishopEndPosition);
var moveValidator = new OrdinaryBoardMoveValidator(board);
var verifier = new OrdinaryBoardCheckVerifier(board, moveValidator);
TeamColor teamColor = TeamColor.Black;
// act
var result = verifier.IsCheck(teamColor);
// assert
Assert.False(result);
}
public void IsCheckMate_OnlyCheck_CulpritMayBeKilled_ShouldReturnFalse()
{
// arrange
var board = new OrdinaryChessBoard();
var blackPawnStartPosition = new Position(1, 7);
var blackPawnMiddlePosition = new Position(2, 7);
var blackPawnEndPosition = new Position(3, 7);
var whiteKnightStartPosition = new Position(7, 1);
var whiteKnightFirstHopPosition = new Position(5, 2);
var whiteKnightSecondHopPosition = new Position(3, 3);
var whiteKnightEndPosition = new Position(2, 5);
var blackPawn = board.RemoveFigure(blackPawnStartPosition);
blackPawn.Move(blackPawnMiddlePosition);
board.SetFigure(blackPawn, blackPawnMiddlePosition);
board.RemoveFigure(blackPawnMiddlePosition);
blackPawn.Move(blackPawnEndPosition);
board.SetFigure(blackPawn, blackPawnEndPosition);
var whiteKnight = board.RemoveFigure(whiteKnightStartPosition);
whiteKnight.Move(whiteKnightFirstHopPosition);
board.SetFigure(whiteKnight, whiteKnightFirstHopPosition);
board.RemoveFigure(whiteKnightFirstHopPosition);
whiteKnight.Move(whiteKnightSecondHopPosition);
board.SetFigure(whiteKnight, whiteKnightSecondHopPosition);
board.RemoveFigure(whiteKnightSecondHopPosition);
whiteKnight.Move(whiteKnightEndPosition);
board.SetFigure(whiteKnight, whiteKnightEndPosition);
var validator = new OrdinaryBoardMoveValidator(board);
var verifier = new OrdinaryBoardCheckVerifier(board, validator);
var lastMoveVm =
new LastMoveViewModel(whiteKnight, whiteKnightSecondHopPosition, whiteKnightEndPosition, null);
var moveResult =
new ValidMoveResult(board, verifier, validator, lastMoveVm, null);
var team1 = TeamColor.White;
var team2 = TeamColor.Black;
// act
var result1 = moveResult.IsCheck(team1);
var result2 = moveResult.IsCheck(team2);
var result3 = moveResult.IsCheckMate(team1);
var result4 = moveResult.IsCheckMate(team2);
// assert
Assert.True(result1);
Assert.False(result2);
Assert.False(result3);
Assert.False(result4);
}
public void IsCheckMate_CheckMateWhiteTeam()
{
// arrange
var board = new OrdinaryChessBoard();
var whitePawn1StartPosition = new Position(6, 5);
var whitePawn1EndPosition = new Position(5, 5);
var whitePawn2StartPosition = new Position(6, 6);
var whitePawn2EndPosition = new Position(4, 6);
var blackPawnStartPosition = new Position(1, 4);
var blackPawnEndPosition = new Position(3, 4);
var blackQueenStartPosition = new Position(0, 3);
var blackQueenEndPosition = new Position(4, 7);
var whitePawn1 = board.RemoveFigure(whitePawn1StartPosition);
whitePawn1.Move(whitePawn1EndPosition);
board.SetFigure(whitePawn1, whitePawn1EndPosition);
var blackPawn = board.RemoveFigure(blackPawnStartPosition);
blackPawn.Move(blackPawnEndPosition);
board.SetFigure(blackPawn, blackPawnEndPosition);
var whitePawn2 = board.RemoveFigure(whitePawn2StartPosition);
whitePawn2.Move(whitePawn2EndPosition);
board.SetFigure(whitePawn2, whitePawn2EndPosition);
var blackQueen = board.RemoveFigure(blackQueenStartPosition);
blackQueen.Move(blackQueenEndPosition);
board.SetFigure(blackQueen, blackQueenEndPosition);
var validator = new OrdinaryBoardMoveValidator(board);
var verifier = new OrdinaryBoardCheckVerifier(board, validator);
var lastMoveVm = new LastMoveViewModel(blackQueen, blackQueenStartPosition, blackPawnEndPosition, null);
var moveResult =
new ValidMoveResult(board, verifier, validator, lastMoveVm, null);
var team1 = TeamColor.White;
var team2 = TeamColor.Black;
// act
var result1 = moveResult.IsCheck(team1);
var result2 = moveResult.IsCheck(team2);
var result3 = moveResult.IsCheckMate(team1);
var result4 = moveResult.IsCheckMate(team2);
// assert
Assert.False(result1);
Assert.True(result2);
Assert.False(result3);
Assert.True(result4);
}
public void VerifyMoveCauseCheck_MoveNotCauseCheck_ShouldReturnFalse()
{
// arrange
var board = new OrdinaryChessBoard();
var pawnStartPosition = new Position(1, 0);
var pawnEndPosition = new Position(2, 0);
var moveValidator = new OrdinaryBoardMoveValidator(board);
var verifier = new OrdinaryBoardCheckVerifier(board, moveValidator);
// act
var result = verifier.VerifyMoveCauseCheck(pawnStartPosition, pawnEndPosition);
// assert
Assert.False(result);
}
public void VerifyMoveCauseCheck_CannotMove_InvalidMoveForFigure_ShouldThrowException()
{
// arrange
var board = new OrdinaryChessBoard();
var knightStartPosition = new Position(0, 1);
var knightEndPosition = new Position(5, 1);
var moveValidator = new OrdinaryBoardMoveValidator(board);
var verifier = new OrdinaryBoardCheckVerifier(board, moveValidator);
// act
// assert
Assert.Throws <InvalidMoveException>(() =>
verifier.VerifyMoveCauseCheck(knightStartPosition, knightEndPosition));
}
public void VerifyMoveCauseCheck_CannotMove_Rook_OtherFigureBlock_ShouldThrowException()
{
// arrange
var board = new OrdinaryChessBoard();
var rookStartPosition = new Position(0, 0);
var rookEndPosition = new Position(2, 0);
var moveValidator = new OrdinaryBoardMoveValidator(board);
var verifier = new OrdinaryBoardCheckVerifier(board, moveValidator);
// act
// assert
Assert.Throws <InvalidMoveException>(() =>
verifier.VerifyMoveCauseCheck(rookStartPosition, rookEndPosition));
}
public void VerifyMoveCauseCheck_Knight_OtherFigureBlock_OK_ShouldReturnFalse()
{
// arrange
var board = new OrdinaryChessBoard();
var knightStartPosition = new Position(0, 1);
var knightEndPosition = new Position(2, 0);
var moveValidator = new OrdinaryBoardMoveValidator(board);
var verifier = new OrdinaryBoardCheckVerifier(board, moveValidator);
// act
var result = verifier.VerifyMoveCauseCheck(knightStartPosition, knightEndPosition);
// assert
Assert.False(result);
}
public void VerifyMoveCauseCheck_NoFigureAtPosition_ShouldThrowException()
{
// arrange
var board = new OrdinaryChessBoard();
var pawnStartPosition = new Position(2, 0);
var pawnEndPosition = new Position(3, 0);
var moveValidator = new OrdinaryBoardMoveValidator(board);
var verifier = new OrdinaryBoardCheckVerifier(board, moveValidator);
// act
// assert
Assert.Throws <RemoveFromBoardEmptyFieldException>(() =>
verifier.VerifyMoveCauseCheck(pawnStartPosition, pawnEndPosition));
}
public void IsCheckMate_OnlyCheck_PathMayBeBlocked_ShouldReturnFalse()
{
// arrange
var board = new OrdinaryChessBoard();
var blackPawnStartPosition = new Position(1, 3);
var blackPawnEndPosition = new Position(2, 3);
var whitePawnStartPosition = new Position(6, 2);
var whitePawnEndPosition = new Position(5, 2);
var whiteQueenStartPosition = new Position(7, 3);
var whiteQueenEndPosition = new Position(4, 0);
var blackPawn1 = board.RemoveFigure(blackPawnStartPosition);
blackPawn1.Move(blackPawnEndPosition);
board.SetFigure(blackPawn1, blackPawnEndPosition);
var whitePawn = board.RemoveFigure(whitePawnStartPosition);
whitePawn.Move(whitePawnEndPosition);
board.SetFigure(whitePawn, whitePawnEndPosition);
var whiteQueen = board.RemoveFigure(whiteQueenStartPosition);
whiteQueen.Move(whiteQueenEndPosition);
board.SetFigure(whiteQueen, whiteQueenEndPosition);
var validator = new OrdinaryBoardMoveValidator(board);
var verifier = new OrdinaryBoardCheckVerifier(board, validator);
var lastMoveVm = new LastMoveViewModel(whiteQueen, whiteQueenStartPosition, whitePawnEndPosition, null);
var moveResult =
new ValidMoveResult(board, verifier, validator, lastMoveVm, null);
var team1 = TeamColor.White;
var team2 = TeamColor.Black;
// act
var result1 = moveResult.IsCheck(team1);
var result2 = moveResult.IsCheck(team2);
var result3 = moveResult.IsCheckMate(team1);
var result4 = moveResult.IsCheckMate(team2);
// assert
Assert.True(result1);
Assert.False(result2);
Assert.False(result3);
Assert.False(result4);
}
public void LastMoveFigureAndPositionFromAndDest_Smash()
{
// arrange
var board = new OrdinaryChessBoard();
var startBlackPawnPosition = new Position(1, 5);
var oneHopBlackPawnPosition = new Position(3, 5);
var startWhitePawnPosition = new Position(6, 4);
var oneHopWhitePawnPosition = new Position(4, 4);
var blackPawn = board.RemoveFigure(startBlackPawnPosition);
blackPawn.Move(oneHopBlackPawnPosition);
board.SetFigure(blackPawn, oneHopBlackPawnPosition);
var whitePawn = board.RemoveFigure(startWhitePawnPosition);
whitePawn.Move(oneHopWhitePawnPosition);
board.SetFigure(whitePawn, oneHopWhitePawnPosition);
board.RemoveFigure(oneHopWhitePawnPosition);
blackPawn = board.RemoveFigure(oneHopBlackPawnPosition);
blackPawn.Move(oneHopWhitePawnPosition);
board.SetFigure(blackPawn, oneHopWhitePawnPosition);
var validator = new OrdinaryBoardMoveValidator(board);
var verifier = new OrdinaryBoardCheckVerifier(board, validator);
var lastMoveVm =
new LastMoveViewModel(blackPawn, oneHopBlackPawnPosition, oneHopWhitePawnPosition, whitePawn);
var moveResult = new ValidMoveResult(board, verifier, null, lastMoveVm, null);
var expectedLastMoveFigure = blackPawn;
var expectedLastMovePositionFrom = oneHopBlackPawnPosition;
var expectedLastMovePositionDest = oneHopWhitePawnPosition;
// act
var result = moveResult.LastMoveFigureAndPositionFromAndDest();
// assert
Assert.AreEqual(expectedLastMoveFigure, result.Item1);
Assert.AreEqual(expectedLastMovePositionFrom, result.Item2);
Assert.AreEqual(expectedLastMovePositionDest, result.Item3);
}
/// <summary>
/// Helper function to IsCheckMate
/// Verify if Any of king possible move is not Check
/// </summary>
/// <param name="king"></param>
/// <param name="teamColor"></param>
/// <returns></returns>
private bool VerifyIfKingMayEscape(Figure king, TeamColor teamColor)
{
IBoard copyBoard = _board.Copy();
var validator = new OrdinaryBoardMoveValidator(copyBoard);
var verifier = new OrdinaryBoardCheckVerifier(copyBoard, validator);
foreach (var possibleKingMove in GetPossibleKingMoves(king))
{
King newKing = new King(possibleKingMove, king.TeamColor);
copyBoard.RemoveFigure(king.Position);
var figureAtKingMove = copyBoard.RemoveFigure(possibleKingMove);
copyBoard.SetFigure(newKing, possibleKingMove);
if (!verifier.IsCheck(teamColor))
{
return(true);
}
copyBoard.SetFigure(figureAtKingMove, possibleKingMove);
copyBoard.SetFigure(king, king.Position);
}
return(false);
}
public void VerifyMoveCauseCheck_MoveBlackBishop_CheckWhiteKing_ShouldReturnTrue()
{
// arrange
var board = new OrdinaryChessBoard();
var whiteRemovePawnPosition = new Position(6, 3);
var blackRemovePawnPosition = new Position(1, 4);
var blackBishopStartPosition = new Position(0, 5);
var blackBishopEndPosition = new Position(4, 1);
board.RemoveFigure(whiteRemovePawnPosition);
board.RemoveFigure(blackRemovePawnPosition);
var moveValidator = new OrdinaryBoardMoveValidator(board);
var verifier = new OrdinaryBoardCheckVerifier(board, moveValidator);
// act
var result = verifier.VerifyMoveCauseCheck(blackBishopStartPosition, blackBishopEndPosition);
// assert
Assert.True(result);
}
public void SmashedFigure_SmashedWhitePawn_ShouldThisFigure()
{
// arrange
var board = new OrdinaryChessBoard();
var startBlackPawnPosition = new Position(1, 5);
var oneHopBlackPawnPosition = new Position(3, 5);
var startWhitePawnPosition = new Position(6, 4);
var oneHopWhitePawnPosition = new Position(4, 4);
var blackPawn = board.RemoveFigure(startBlackPawnPosition);
blackPawn.Move(oneHopBlackPawnPosition);
board.SetFigure(blackPawn, oneHopBlackPawnPosition);
var whitePawn = board.RemoveFigure(startWhitePawnPosition);
whitePawn.Move(oneHopWhitePawnPosition);
board.SetFigure(whitePawn, oneHopWhitePawnPosition);
board.RemoveFigure(oneHopWhitePawnPosition);
blackPawn = board.RemoveFigure(oneHopBlackPawnPosition);
blackPawn.Move(oneHopWhitePawnPosition);
board.SetFigure(blackPawn, oneHopWhitePawnPosition);
var validator = new OrdinaryBoardMoveValidator(board);
var verifier = new OrdinaryBoardCheckVerifier(board, validator);
var lastMoveVm =
new LastMoveViewModel(blackPawn, oneHopBlackPawnPosition, oneHopWhitePawnPosition, whitePawn);
var moveResult = new ValidMoveResult(board, verifier, null, lastMoveVm, null);
var expected = whitePawn;
// act
var isSmash = moveResult.IsLastMoveSmash();
var result = moveResult.SmashedFigure();
// assert
Assert.True(isSmash);
Assert.AreEqual(expected, result);
}
public void GetScore_AfterKilledWhite_BlackTeam_ShouldBe_Minus19()
{
// arrange
var board = new OrdinaryChessBoard();
TeamColor team = TeamColor.Black;
var startBlackPawnPosition = new Position(1, 5);
var oneHopBlackPawnPosition = new Position(3, 5);
var startWhitePawnPosition = new Position(6, 4);
var oneHopWhitePawnPosition = new Position(4, 4);
var blackPawn = board.RemoveFigure(startBlackPawnPosition);
blackPawn.Move(oneHopBlackPawnPosition);
board.SetFigure(blackPawn, oneHopBlackPawnPosition);
var whitePawn = board.RemoveFigure(startWhitePawnPosition);
whitePawn.Move(oneHopWhitePawnPosition);
board.SetFigure(whitePawn, oneHopWhitePawnPosition);
board.RemoveFigure(oneHopWhitePawnPosition);
blackPawn = board.RemoveFigure(oneHopBlackPawnPosition);
blackPawn.Move(oneHopWhitePawnPosition);
board.SetFigure(blackPawn, oneHopWhitePawnPosition);
var validator = new OrdinaryBoardMoveValidator(board);
var verifier = new OrdinaryBoardCheckVerifier(board, validator);
var lastMoveVm =
new LastMoveViewModel(blackPawn, oneHopBlackPawnPosition, oneHopWhitePawnPosition, whitePawn);
var moveResult = new ValidMoveResult(board, verifier, null, lastMoveVm, null);
int expectedScore = -19;
// act
var result = moveResult.GetScore(team);
// assert
Assert.AreEqual(expectedScore, result);
}
public void IsCheck_WhiteTeam_NotCheck_ShouldReturnFalse()
{
// arrange
var board = new OrdinaryChessBoard();
var startBlackPawnPosition = new Position(1, 5);
var endBlackPawnPosition = new Position(3, 5);
var blackPawn = board.RemoveFigure(startBlackPawnPosition);
blackPawn.Move(endBlackPawnPosition);
board.SetFigure(blackPawn, endBlackPawnPosition);
var moveValidator = new OrdinaryBoardMoveValidator(board);
var checkVerifier = new OrdinaryBoardCheckVerifier(board, moveValidator);
TeamColor teamColor = TeamColor.White;
// act
var result = checkVerifier.IsCheck(teamColor);
// assert
Assert.False(result);
}
public void VerifyMoveCauseCheck_MoveWhiteKnight_CheckBlackKing_ShouldReturnTrue()
{
// arrange
var board = new OrdinaryChessBoard();
var whiteKnightStartPosition = new Position(7, 1);
var whiteKnightMiddlePosition = new Position(4, 2);
var whiteKnightEndPosition = new Position(2, 3);
var knight = board.RemoveFigure(whiteKnightStartPosition);
knight.Move(whiteKnightMiddlePosition);
board.SetFigure(knight, whiteKnightMiddlePosition);
var moveValidator = new OrdinaryBoardMoveValidator(board);
var verifier = new OrdinaryBoardCheckVerifier(board, moveValidator);
// act
var result = verifier.VerifyMoveCauseCheck(whiteKnightMiddlePosition, whiteKnightEndPosition);
// assert
Assert.True(result);
}
[Test] public void IsCheck_WhiteTeam_WhiteChecked_Knight_ShouldReturnFalse()
{
// arrange
var board = new OrdinaryChessBoard();
var knightStartPosition = new Position(0, 1);
var knightEndPosition = new Position(5, 3);
var knight = board.RemoveFigure(knightStartPosition);
knight.Move(knightEndPosition);
board.SetFigure(knight, knightEndPosition);
var moveValidator = new OrdinaryBoardMoveValidator(board);
var verifier = new OrdinaryBoardCheckVerifier(board, moveValidator);
TeamColor teamColor = TeamColor.White;
// act
var result = verifier.IsCheck(teamColor);
// assert
Assert.False(result);
}
/// <summary>
/// Helper function to IsCheckMate
/// Verify if after killing there is not Check
/// </summary>
/// <param name="aimPosition">Position of figure which cause Check</param>
/// <param name="teamColor">Color of checked Team</param>
/// <returns></returns>
private bool VerifyIfAfterKillKingWillBeFree(Position aimPosition, TeamColor teamColor)
{
IBoard copyBoard = _board.Copy();
var validator = new OrdinaryBoardMoveValidator(copyBoard);
var verifier = new OrdinaryBoardCheckVerifier(copyBoard, validator);
copyBoard.RemoveFigure(aimPosition);
foreach (var possibleKiller in FindPossibleKillers(aimPosition, teamColor))
{
var startPosition = possibleKiller.Position;
var killer = copyBoard.RemoveFigure(startPosition);
killer.Move(aimPosition);
copyBoard.SetFigure(killer, aimPosition);
if (!verifier.IsCheck(teamColor))
{
killer.Move(startPosition);
return(true);
}
killer.Move(startPosition);
copyBoard.SetFigure(killer, startPosition);
}
return(false);
}
private bool VerifyIfOtherFigureMayBlock(Figure culprit, Position kingPosition, TeamColor teamColor)
{
IBoard copyBoard = _board.Copy();
var validator = new OrdinaryBoardMoveValidator(copyBoard);
var verifier = new OrdinaryBoardCheckVerifier(copyBoard, validator);
foreach (var figureAndPos in FindPossibleBlockers(culprit, kingPosition, teamColor))
{
var startPosition = figureAndPos.Item1.Position;
var blocker = copyBoard.RemoveFigure(startPosition);
var figureAtEndPos = copyBoard.RemoveFigure(figureAndPos.Item2);
blocker.Move(figureAndPos.Item2);
copyBoard.SetFigure(blocker, figureAndPos.Item2);
if (!verifier.IsCheck(teamColor))
{
blocker.Move(startPosition);
return(true);
}
blocker.Move(startPosition);
copyBoard.SetFigure(blocker, startPosition);
copyBoard.SetFigure(figureAtEndPos, figureAndPos.Item2);
}
return(false);
}
public void VerifyMoveCauseCheck_BlackPawn_RevealsTheBlackKing_ShouldReturnTrue()
{
// arrange
var board = new OrdinaryChessBoard();
var blackPawnStartPosition = new Position(1, 3);
var blackPawnEndPosition = new Position(2, 3);
var startWhiteQueenPosition = new Position(7, 3);
var endWhiteQueenPosition = new Position(4, 0);
var whiteQueen = board.RemoveFigure(startWhiteQueenPosition);
whiteQueen.Move(endWhiteQueenPosition);
board.SetFigure(whiteQueen, endWhiteQueenPosition);
var moveValidator = new OrdinaryBoardMoveValidator(board);
var verifier = new OrdinaryBoardCheckVerifier(board, moveValidator);
// act
var result = verifier.VerifyMoveCauseCheck(blackPawnStartPosition, blackPawnEndPosition);
// assert
Assert.True(result);
}
