Beispiel #1
0
        public void Rook_CanMove_TheSamePosition_ShouldReturnFalse()
        {
            // arrange
            Models.Position.Position startingPosition    = new Models.Position.Position(0, 0);
            Models.Position.Position destinationPosition = new Models.Position.Position(0, 0);
            var rook = new Rook(startingPosition, TeamColor.Black);

            // act
            bool result = rook.CanMove(destinationPosition);

            // assert
            Assert.False(result);
        }
Beispiel #2
0
        public void Queen_CanMove_InvalidMove_ShouldReturnFalse()
        {
            // arrange
            Models.Position.Position startingPosition    = new Models.Position.Position(0, 0);
            Models.Position.Position destinationPosition = new Models.Position.Position(3, 2);
            var queen = new Queen(startingPosition, TeamColor.Black);

            // act
            bool result = queen.CanMove(destinationPosition);

            // assert
            Assert.False(result);
        }
Beispiel #3
0
        public void King_CanMove_HorizontalMoveValid_ShouldReturnTrue()
        {
            // arrange
            Models.Position.Position startingPosition = new Models.Position.Position(0, 0);
            var king = new King(startingPosition, TeamColor.Black);

            Models.Position.Position destinationPosition = new Models.Position.Position(1, 0);

            // act
            bool result = king.CanMove(destinationPosition);

            // assert
            Assert.True(result);
        }
Beispiel #4
0
        public override bool CanMove(Models.Position.Position newPosition)
        {
            if (Position == newPosition)
            {
                return(false);
            }
            var vector = new Vector(Position, newPosition);

            if (vector.IsHorizontal || vector.IsVertical)
            {
                return(true);
            }
            return(false);
        }
        public void GetPath_Point_ShouldReturn_EmptyCollection()
        {
            // arrange
            var startPostion = new Models.Position.Position(1, 1);
            var endPostion   = new Models.Position.Position(1, 1);
            var vector       = new Vector(startPostion, endPostion);
            IEnumerable <Models.Position.Position> expected = new List <Models.Position.Position>();

            // act
            var result = vector.GetPath();

            // assert
            Assert.True(expected.SequenceEqual(result));
        }
Beispiel #6
0
        public void King_CanMove_DiagonalMoveInvalid_ShouldReturnFalse()
        {
            // arrange
            Models.Position.Position startingPosition = new Models.Position.Position(0, 0);
            var king = new King(startingPosition, TeamColor.Black);

            Models.Position.Position destinationPosition = new Models.Position.Position(2, 2);

            // act
            bool result = king.CanMove(destinationPosition);

            // assert
            Assert.False(result);
        }
        public void GetPositionWeight_King_White_TopLeftCorner_ShouldReturn_Minus6()
        {
            // arrange
            var postion  = new Models.Position.Position(7, 0);
            var team     = TeamColor.White;
            var figure   = new King(postion, team);
            int expected = -6;
            var weights  = new OrdinaryChessBoardFigurePositionWeight();

            // act
            var result = weights.GetPositionWeight(figure);

            // assert
            Assert.AreEqual(expected, result);
        }
Beispiel #8
0
        public void GetScoreForTeam_AfterDeleteWhite_BottomLeftPawn_BlackTeam_ShouldBe_21()
        {
            // arrange
            var       board         = new OrdinaryChessBoard();
            TeamColor team          = TeamColor.Black;
            int       expectedScore = 21;
            var       pawnPosition  = new Models.Position.Position(1, 0);

            // act
            board.RemoveFigure(pawnPosition);
            var result = board.GetScoreForTeam(team);

            // assert
            Assert.AreEqual(expectedScore, result);
        }
        public void GetPositionWeight_King_White_SomewhereInTheMiddle_ShouldReturn_Minus4()
        {
            // arrange
            var postion  = new Models.Position.Position(2, 3);
            var team     = TeamColor.White;
            var figure   = new King(postion, team);
            int expected = -4;
            var weights  = new OrdinaryChessBoardFigurePositionWeight();

            // act
            var result = weights.GetPositionWeight(figure);

            // assert
            Assert.AreEqual(expected, result);
        }
        public void GetPositionWeight_King_Black_AlmostTopRightCorner_ShouldReturn_6()
        {
            // arrange
            var postion  = new Models.Position.Position(7, 6);
            var team     = TeamColor.Black;
            var figure   = new King(postion, team);
            int expected = 6;
            var weights  = new OrdinaryChessBoardFigurePositionWeight();

            // act
            var result = weights.GetPositionWeight(figure);

            // assert
            Assert.AreEqual(expected, result);
        }
        public void CanMove_Rook_OutOfBoundaries_ShouldReturnFalse()
        {
            // arrange
            var board             = new OrdinaryChessBoard();
            var startRookPosition = new Models.Position.Position(0, 0);
            var destRookPosition  = new Models.Position.Position(-1, 0);
            var queen             = board.FigureAt(startRookPosition);
            var validator         = new OrdinaryBoardMoveValidator(board);

            // act
            var result = validator.CanMove(queen, destRookPosition);

            // assert
            Assert.False(result.Item1);
        }
        public void CanMove_King_PositionAlreadyTakenByAlly_ShouldReturnFalse()
        {
            // arrange
            var board        = new OrdinaryChessBoard();
            var destPosition = new Models.Position.Position(1, 4);
            var kingPosition = new Models.Position.Position(0, 4);
            var king         = board.FigureAt(kingPosition);
            var validator    = new OrdinaryBoardMoveValidator(board);

            // act
            var result = validator.CanMove(king, destPosition);

            // assert
            Assert.False(result.Item1);
        }
        public void CanMove_Queen_PositionAlreadyTakenByAlly_ShouldReturnFalse()
        {
            // arrange
            var board = new OrdinaryChessBoard();
            var startQueenPosition = new Models.Position.Position(0, 3);
            var destQueenPosition  = new Models.Position.Position(1, 4);
            var queen     = board.FigureAt(startQueenPosition);
            var validator = new OrdinaryBoardMoveValidator(board);

            // act
            var result = validator.CanMove(queen, destQueenPosition);

            // assert
            Assert.False(result.Item1);
        }
        public void CanMove_Knight_OutOfBoundaries_ShouldReturnFalse()
        {
            // arrange
            var board = new OrdinaryChessBoard();
            var startKnightPosition = new Models.Position.Position(0, 1);
            var destKnightPosition  = new Models.Position.Position(-1, 3);

            var bishop    = board.FigureAt(startKnightPosition);
            var validator = new OrdinaryBoardMoveValidator(board);

            // act
            var result = validator.CanMove(bishop, destKnightPosition);

            // assert
            Assert.False(result.Item1);
        }
        public void CanMove_Knight_AllyBlockPath_CanMove_ShouldReturnTrue()
        {
            // arrange
            var board = new OrdinaryChessBoard();
            var startKnightPosition = new Models.Position.Position(0, 1);
            var destKnightPosition  = new Models.Position.Position(2, 2);

            var bishop    = board.FigureAt(startKnightPosition);
            var validator = new OrdinaryBoardMoveValidator(board);

            // act
            var result = validator.CanMove(bishop, destKnightPosition);

            // assert
            Assert.True(result.Item1);
        }
        public void CanMove_Bishop_AllyBlockPath_ShouldReturnFalse()
        {
            // arrange
            var board = new OrdinaryChessBoard();
            var startBishopPosition = new Models.Position.Position(0, 2);
            var destBishopPosition  = new Models.Position.Position(5, 7);

            var bishop    = board.FigureAt(startBishopPosition);
            var validator = new OrdinaryBoardMoveValidator(board);

            // act
            var result = validator.CanMove(bishop, destBishopPosition);

            // assert
            Assert.False(result.Item1);
        }
Beispiel #17
0
        public void Queen_CanMove_DiagonalMove_ShouldReturnTrue()
        {
            // arrange
            Models.Position.Position startingPosition     = new Models.Position.Position(0, 0);
            Models.Position.Position destinationPosition1 = new Models.Position.Position(3, 3);
            Models.Position.Position destinationPosition2 = new Models.Position.Position(-2, 2);
            var queen = new Queen(startingPosition, TeamColor.Black);

            // act
            bool result1 = queen.CanMove(destinationPosition1);
            bool result2 = queen.CanMove(destinationPosition2);

            // assert
            Assert.True(result1);
            Assert.True(result2);
        }
        public void CanMove_Pawn_CanMove_ShouldReturnTrue()
        {
            // arrange
            var board             = new OrdinaryChessBoard();
            var startPawnPosition = new Models.Position.Position(1, 0);
            var destPawnPosition  = new Models.Position.Position(2, 0);

            var pawn      = board.FigureAt(startPawnPosition);
            var validator = new OrdinaryBoardMoveValidator(board);

            // act
            var result = validator.CanMove(pawn, destPawnPosition);

            // assert
            Assert.True(result.Item1);
        }
        public void CanMove_King_CanMove_ShouldReturnTrue()
        {
            // arrange
            var board        = new OrdinaryChessBoard();
            var destPosition = new Models.Position.Position(1, 4);
            var kingPosition = new Models.Position.Position(0, 4);

            board.RemoveFigure(destPosition);
            var king      = board.FigureAt(kingPosition);
            var validator = new OrdinaryBoardMoveValidator(board);

            // act
            var result = validator.CanMove(king, destPosition);

            // assert
            Assert.True(result.Item1);
        }
        public void CanMove_Bishop_OutOfBoundaries_ShouldReturnFalse()
        {
            // arrange
            var board = new OrdinaryChessBoard();
            var startBishopPosition = new Models.Position.Position(0, 2);
            var destBishopPosition  = new Models.Position.Position(5, 8);
            var pawnPosition        = new Models.Position.Position(1, 3);

            board.RemoveFigure(pawnPosition);
            var bishop    = board.FigureAt(startBishopPosition);
            var validator = new OrdinaryBoardMoveValidator(board);

            // act
            var result = validator.CanMove(bishop, destBishopPosition);

            // assert
            Assert.False(result.Item1);
        }
Beispiel #21
0
        public void Pawn_CanMove_FirstMoveTwoFieldsForward_SecondMove_ShouldReturnFalse()
        {
            // arrange
            Models.Position.Position startingPosition     = new Models.Position.Position(0, 0);
            Models.Position.Position intermediatePosition = new Models.Position.Position(1, 0);
            Models.Position.Position destinationPosition  = new Models.Position.Position(3, 0);
            var pawn = new Pawn(startingPosition, TeamColor.White);

            // act
            bool result1 = pawn.CanMove(intermediatePosition);

            pawn.Move(intermediatePosition);
            bool result2 = pawn.CanMove(destinationPosition);

            // assert
            Assert.True(result1);
            Assert.False(result2);
        }
Beispiel #22
0
        public override bool CanMove(Models.Position.Position newPosition)
        {
            if (Position == newPosition)
            {
                return(false);
            }

            var vector = new Vector(Position, newPosition);
            var diffX  = Math.Abs(vector.DiffX);
            var diffY  = Math.Abs(vector.DiffY);

            if (diffX == 2 && diffY == 1 ||
                diffX == 1 && diffY == 2)
            {
                return(true);
            }
            return(false);
        }
        public void CanMove_Queen_CanMove_ShouldReturnTrue()
        {
            // arrange
            var board = new OrdinaryChessBoard();
            var startQueenPosition = new Models.Position.Position(0, 3);
            var destQueenPosition  = new Models.Position.Position(4, 7);
            var pawnPosition       = new Models.Position.Position(1, 4);

            board.RemoveFigure(pawnPosition);
            var queen     = board.FigureAt(startQueenPosition);
            var validator = new OrdinaryBoardMoveValidator(board);

            // act
            var result = validator.CanMove(queen, destQueenPosition);

            // assert
            Assert.True(result.Item1);
        }
        public void CanMove_Rook_EnemyBlockPath_ShouldReturnFalse()
        {
            // arrange
            var board             = new OrdinaryChessBoard();
            var startRookPosition = new Models.Position.Position(0, 0);
            var destRookPosition  = new Models.Position.Position(7, 0);
            var pawnPosition      = new Models.Position.Position(1, 0);

            board.RemoveFigure(pawnPosition);

            var queen     = board.FigureAt(startRookPosition);
            var validator = new OrdinaryBoardMoveValidator(board);

            // act
            var result = validator.CanMove(queen, destRookPosition);

            // assert
            Assert.False(result.Item1);
        }
Beispiel #25
0
        public void GetScoreForTeam_AfterMovementWhite_BottomLeftPawnTwoFieldUp_BlackTeam_ShouldBe_1()
        {
            // arrange
            var       board             = new OrdinaryChessBoard();
            TeamColor team              = TeamColor.Black;
            int       expectedScore     = 1;
            var       startPawnPosition = new Models.Position.Position(1, 0);
            var       endPawnPosition   = new Models.Position.Position(3, 0);

            // act
            var pawn = board.RemoveFigure(startPawnPosition);

            pawn.Move(endPawnPosition);
            board.SetFigure(pawn, endPawnPosition);
            var result = board.GetScoreForTeam(team);

            // assert
            Assert.AreEqual(expectedScore, result);
        }
        public void CanMove_Rook_PositionAlreadyTakenByAlly_ShouldReturnFalse()
        {
            // arrange
            var board             = new OrdinaryChessBoard();
            var startRookPosition = new Models.Position.Position(0, 0);
            var destRookPosition  = new Models.Position.Position(4, 0);
            var pawnPosition      = new Models.Position.Position(1, 0);

            var pawn = board.RemoveFigure(pawnPosition);

            pawn.Move(destRookPosition);
            board.SetFigure(pawn, destRookPosition);

            var queen     = board.FigureAt(startRookPosition);
            var validator = new OrdinaryBoardMoveValidator(board);

            // act
            var result = validator.CanMove(queen, destRookPosition);

            // assert
            Assert.False(result.Item1);
        }
        public void CanMove_Pawn_PositionAlreadyTakenByEnemy_NotAttack_ShouldReturnFalse()
        {
            // arrange
            var board              = new OrdinaryChessBoard();
            var startPawnPosition  = new Models.Position.Position(1, 0);
            var destPawnPosition   = new Models.Position.Position(2, 0);
            var enemyStartPosition = new Models.Position.Position(6, 0);

            var enemy = board.RemoveFigure(enemyStartPosition);

            enemy.Move(destPawnPosition);
            board.SetFigure(enemy, destPawnPosition);

            var pawn      = board.FigureAt(startPawnPosition);
            var validator = new OrdinaryBoardMoveValidator(board);

            // act
            var result = validator.CanMove(pawn, destPawnPosition);

            // assert
            Assert.False(result.Item1);
        }
Beispiel #28
0
        public void CopyConstructor_InitializationTest()
        {
            // arrange
            var baseBoard                 = new OrdinaryChessBoard();
            var expectedFigureType        = FigureType.Knight;
            var destinationPosition       = new Models.Position.Position(2, 1);
            var secondDestinationPosition = new Models.Position.Position(3, 0);

            // act
            var knight = baseBoard.RemoveFigure(new Models.Position.Position(0, 1));

            knight.Move(destinationPosition);
            baseBoard.SetFigure(knight, destinationPosition);
            var copyBoard = new OrdinaryChessBoard(baseBoard);

            baseBoard.RemoveFigure(destinationPosition);
            knight.Move(secondDestinationPosition);
            baseBoard.SetFigure(knight, secondDestinationPosition);

            // assert
            Assert.AreEqual(expectedFigureType, copyBoard.FigureAt(destinationPosition).FigureType);
            Assert.AreEqual(null, copyBoard.FigureAt(secondDestinationPosition));
        }
        public void CanMove_King_PositionAlreadyTakenByEnemy_ShouldReturnTrue()
        {
            // arrange
            var board              = new OrdinaryChessBoard();
            var destPosition       = new Models.Position.Position(1, 4);
            var startEnemyPosition = new Models.Position.Position(6, 4);
            var kingPosition       = new Models.Position.Position(0, 4);

            board.RemoveFigure(destPosition);
            var enemyPawn = board.RemoveFigure(startEnemyPosition);

            enemyPawn.Move(destPosition);
            board.SetFigure(enemyPawn, destPosition);

            var king      = board.FigureAt(kingPosition);
            var validator = new OrdinaryBoardMoveValidator(board);

            // act
            var result = validator.CanMove(king, destPosition);

            // assert
            Assert.True(result.Item1);
        }
        public void CanMove_Knight_PositionAlreadyTakenByEnemy_ShouldReturnTrue()
        {
            // arrange
            var board = new OrdinaryChessBoard();
            var startKnightPosition    = new Models.Position.Position(0, 1);
            var destKnightPosition     = new Models.Position.Position(2, 2);
            var enemyPawnStartPosition = new Models.Position.Position(6, 2);
            var enemyPawnEndPosition   = new Models.Position.Position(2, 2);

            var enemy = board.RemoveFigure(enemyPawnStartPosition);

            enemy.Move(enemyPawnEndPosition);
            board.SetFigure(enemy, enemyPawnEndPosition);

            var bishop    = board.FigureAt(startKnightPosition);
            var validator = new OrdinaryBoardMoveValidator(board);

            // act
            var result = validator.CanMove(bishop, destKnightPosition);

            // assert
            Assert.True(result.Item1);
        }