Exemple #1
0
 private void OrganizePieces()
 {
     Board.AddPiece(PawnBuilder.New().WithGameplay(this).WithPosition(new Position(EColumn.A, ELine.Two)).WithColor(EColor.White).WithBoard(Board).Build());
     Board.AddPiece(PawnBuilder.New().WithGameplay(this).WithPosition(new Position(EColumn.B, ELine.Two)).WithColor(EColor.White).WithBoard(Board).Build());
     Board.AddPiece(PawnBuilder.New().WithGameplay(this).WithPosition(new Position(EColumn.C, ELine.Two)).WithColor(EColor.White).WithBoard(Board).Build());
     Board.AddPiece(PawnBuilder.New().WithGameplay(this).WithPosition(new Position(EColumn.D, ELine.Two)).WithColor(EColor.White).WithBoard(Board).Build());
     Board.AddPiece(PawnBuilder.New().WithGameplay(this).WithPosition(new Position(EColumn.E, ELine.Two)).WithColor(EColor.White).WithBoard(Board).Build());
     Board.AddPiece(PawnBuilder.New().WithGameplay(this).WithPosition(new Position(EColumn.F, ELine.Two)).WithColor(EColor.White).WithBoard(Board).Build());
     Board.AddPiece(PawnBuilder.New().WithGameplay(this).WithPosition(new Position(EColumn.G, ELine.Two)).WithColor(EColor.White).WithBoard(Board).Build());
     Board.AddPiece(PawnBuilder.New().WithGameplay(this).WithPosition(new Position(EColumn.H, ELine.Two)).WithColor(EColor.White).WithBoard(Board).Build());
     Board.AddPiece(RookBuilder.New().WithPosition(new Position(EColumn.A, ELine.One)).WithColor(EColor.White).WithBoard(Board).Build());
     Board.AddPiece(KnightBuilder.New().WithPosition(new Position(EColumn.B, ELine.One)).WithColor(EColor.White).WithBoard(Board).Build());
     Board.AddPiece(BishopBuilder.New().WithPosition(new Position(EColumn.C, ELine.One)).WithColor(EColor.White).WithBoard(Board).Build());
     Board.AddPiece(QueenBuilder.New().WithPosition(new Position(EColumn.D, ELine.One)).WithColor(EColor.White).WithBoard(Board).Build());
     Board.AddPiece(KingBuilder.New().WithPosition(new Position(EColumn.E, ELine.One)).WithColor(EColor.White).WithBoard(Board).Build());
     Board.AddPiece(BishopBuilder.New().WithPosition(new Position(EColumn.F, ELine.One)).WithColor(EColor.White).WithBoard(Board).Build());
     Board.AddPiece(KnightBuilder.New().WithPosition(new Position(EColumn.G, ELine.One)).WithColor(EColor.White).WithBoard(Board).Build());
     Board.AddPiece(RookBuilder.New().WithPosition(new Position(EColumn.H, ELine.One)).WithColor(EColor.White).WithBoard(Board).Build());
     Board.AddPiece(PawnBuilder.New().WithGameplay(this).WithPosition(new Position(EColumn.A, ELine.Seven)).WithColor(EColor.Black).WithBoard(Board).Build());
     Board.AddPiece(PawnBuilder.New().WithGameplay(this).WithPosition(new Position(EColumn.B, ELine.Seven)).WithColor(EColor.Black).WithBoard(Board).Build());
     Board.AddPiece(PawnBuilder.New().WithGameplay(this).WithPosition(new Position(EColumn.C, ELine.Seven)).WithColor(EColor.Black).WithBoard(Board).Build());
     Board.AddPiece(PawnBuilder.New().WithGameplay(this).WithPosition(new Position(EColumn.D, ELine.Seven)).WithColor(EColor.Black).WithBoard(Board).Build());
     Board.AddPiece(PawnBuilder.New().WithGameplay(this).WithPosition(new Position(EColumn.E, ELine.Seven)).WithColor(EColor.Black).WithBoard(Board).Build());
     Board.AddPiece(PawnBuilder.New().WithGameplay(this).WithPosition(new Position(EColumn.F, ELine.Seven)).WithColor(EColor.Black).WithBoard(Board).Build());
     Board.AddPiece(PawnBuilder.New().WithGameplay(this).WithPosition(new Position(EColumn.G, ELine.Seven)).WithColor(EColor.Black).WithBoard(Board).Build());
     Board.AddPiece(PawnBuilder.New().WithGameplay(this).WithPosition(new Position(EColumn.H, ELine.Seven)).WithColor(EColor.Black).WithBoard(Board).Build());
     Board.AddPiece(RookBuilder.New().WithPosition(new Position(EColumn.A, ELine.Eight)).WithColor(EColor.Black).WithBoard(Board).Build());
     Board.AddPiece(KnightBuilder.New().WithPosition(new Position(EColumn.B, ELine.Eight)).WithColor(EColor.Black).WithBoard(Board).Build());
     Board.AddPiece(BishopBuilder.New().WithPosition(new Position(EColumn.C, ELine.Eight)).WithColor(EColor.Black).WithBoard(Board).Build());
     Board.AddPiece(QueenBuilder.New().WithPosition(new Position(EColumn.D, ELine.Eight)).WithColor(EColor.Black).WithBoard(Board).Build());
     Board.AddPiece(KingBuilder.New().WithPosition(new Position(EColumn.E, ELine.Eight)).WithColor(EColor.Black).WithBoard(Board).Build());
     Board.AddPiece(BishopBuilder.New().WithPosition(new Position(EColumn.F, ELine.Eight)).WithColor(EColor.Black).WithBoard(Board).Build());
     Board.AddPiece(KnightBuilder.New().WithPosition(new Position(EColumn.G, ELine.Eight)).WithColor(EColor.Black).WithBoard(Board).Build());
     Board.AddPiece(RookBuilder.New().WithPosition(new Position(EColumn.H, ELine.Eight)).WithColor(EColor.Black).WithBoard(Board).Build());
 }
Exemple #2
0
        public void ShouldRegisterQuantityMove()
        {
            var pawn = PawnBuilder.New().Build();

            pawn.Move(new Position(EColumn.B, ELine.Three));
            pawn.Move(new Position(EColumn.B, ELine.Four));
            Assert.True(pawn.QuantityMove == 2);
        }
Exemple #3
0
        public void ShouldNotKillNonExistentPiece(Position positionPieceToAddOnBoard, EColor colorPieceToAddOnBoard)
        {
            var board             = BoardBuilder.New().Build();
            var pieceToAddOnBoard = PawnBuilder.New().WithPosition(positionPieceToAddOnBoard).WithColor(colorPieceToAddOnBoard).Build();

            board.KillPiece(pieceToAddOnBoard);
            var pieceIsNotDead = !board.DeadPieces.Any(p => p.Equals(pieceToAddOnBoard));

            Assert.True(pieceIsNotDead);
        }
Exemple #4
0
        public void ShouldMove(Position actualPosition, Position newPosition, EColor color)
        {
            var board = BoardBuilder.New().Build();

            board.ClearBoard();
            var pawn = PawnBuilder.New().WithColor(color).WithPosition(actualPosition).WithBoard(board).Build();

            board.AddPiece(pawn);
            var moved = pawn.Move(newPosition);

            Assert.True(moved && pawn.Position.Equals(newPosition) && pawn.QuantityMove == 1);
        }
Exemple #5
0
        public void ShouldAddPiece()
        {
            var board = BoardBuilder.New().Build();

            board.ClearBoard();
            var pawn = PawnBuilder.New().Build();

            board.AddPiece(pawn);
            var existisPieceOnBoard = board.Pieces.Any(p => p.Equals(pawn));

            Assert.True(existisPieceOnBoard);
        }
Exemple #6
0
        public void ShouldMoveWithPiecesOnBoard(Position positionPieceToAddBoard, EColor colorPieceToAddBoard, Position newPosition)
        {
            var board = BoardBuilder.New().Build();

            board.ClearBoard();
            var pieceToAddBoard = PawnBuilder.New().WithPosition(positionPieceToAddBoard).WithColor(colorPieceToAddBoard).WithBoard(board).Build();

            board.AddPiece(pieceToAddBoard);
            var rook  = RookBuilder.New().WithColor(EColor.White).WithPosition(new Position(EColumn.D, ELine.Four)).WithBoard(board).Build();
            var moved = rook.Move(newPosition);

            Assert.True(moved && rook.Position.Equals(newPosition) && rook.QuantityMove > 0);
        }
Exemple #7
0
        public void ShouldNotMoveWithPiecesOnBoard(Position positionPieceToAddBoard, EColor colorPieceToAddBoard, Position actualPosition, EColor color, Position newPosition)
        {
            var board = BoardBuilder.New().Build();

            board.ClearBoard();
            var pieceToAddBoard = PawnBuilder.New().WithPosition(positionPieceToAddBoard).WithColor(colorPieceToAddBoard).WithBoard(board).Build();

            board.AddPiece(pieceToAddBoard);
            var pawn     = PawnBuilder.New().WithColor(color).WithPosition(actualPosition).WithBoard(board).Build();
            var notMoved = !pawn.Move(newPosition);

            Assert.True(notMoved && pawn.Position.Equals(actualPosition) && pawn.QuantityMove == 0);
        }
Exemple #8
0
        public void ShouldUndoMove()
        {
            var board = BoardBuilder.New().Build();

            board.ClearBoard();
            var firstPosition = new Position(EColumn.B, ELine.Two);
            var pawn          = PawnBuilder.New().WithPosition(firstPosition).WithBoard(board).Build();

            board.AddPiece(pawn);
            var moved = pawn.Move(new Position(EColumn.B, ELine.Four));

            pawn.UndoMove();
            Assert.True(moved && pawn.Position.Equals(firstPosition) && pawn.QuantityMove == 0);
        }
Exemple #9
0
        public void ShouldKillPiece()
        {
            var board = BoardBuilder.New().Build();

            board.ClearBoard();
            var pawn = PawnBuilder.New().WithBoard(board).Build();

            board.AddPiece(pawn);
            board.KillPiece(pawn);
            var removedPiecefromBoard = !board.Pieces.Any(p => p.Equals(pawn));
            var pieceIsDead           = board.DeadPieces.Any(p => p.Equals(pawn));

            Assert.True(removedPiecefromBoard && pieceIsDead);
        }
Exemple #10
0
        public void ShouldNotAddSamePiece(Position positionPieceToAddOnBoard, EColor colorPieceToAddOnBoard)
        {
            var board = BoardBuilder.New().Build();

            board.ClearBoard();
            var pieceToAddOnBoard = PawnBuilder.New().WithPosition(positionPieceToAddOnBoard).WithColor(colorPieceToAddOnBoard).Build();

            board.AddPiece(pieceToAddOnBoard);
            var newPiece = PawnBuilder.New().WithPosition(positionPieceToAddOnBoard).WithColor(colorPieceToAddOnBoard).Build();;

            board.AddPiece(newPiece);
            var notExistisPieceOnBoard = !board.Pieces.Any(p => p.Equals(newPiece));

            Assert.True(notExistisPieceOnBoard);
        }
Exemple #11
0
        public void ShouldExchangePieceForAnother()
        {
            var board    = BoardBuilder.New().Build();
            var pawn     = PawnBuilder.New().WithColor(EColor.White).WithBoard(board).Build();
            var position = pawn.Position;

            board.AddPiece(pawn);
            var knight = KnightBuilder.New().WithColor(EColor.White).WithBoard(board).Build();

            board.AddPiece(knight);
            board.KillPiece(knight);
            board.ExchangePieceForAnother(pawn, knight);
            var newKnight = board.GetPieceFromPosition(position);

            Assert.True(newKnight != null && newKnight.Position.Equals(position) && !board.Pieces.Any(p => p == knight) && !board.DeadPieces.Any(p => p == knight) && board.DeadPieces.Any(p => p == pawn));
        }
Exemple #12
0
        public void ShouldClearBoard()
        {
            var board = BoardBuilder.New().Build();
            var pawn1 = PawnBuilder.New().WithPosition(new Position(EColumn.A, ELine.Two)).WithBoard(board).Build();

            board.AddPiece(pawn1);
            var pawn2 = PawnBuilder.New().WithPosition(new Position(EColumn.B, ELine.Two)).WithBoard(board).Build();

            board.AddPiece(pawn2);
            var pawn3 = PawnBuilder.New().WithPosition(new Position(EColumn.C, ELine.Two)).WithBoard(board).Build();

            board.AddPiece(pawn3);
            board.KillPiece(pawn3);

            board.ClearBoard();

            var boardWasClean = board.Pieces.Count == 0 && board.DeadPieces.Count == 0;

            Assert.True(boardWasClean);
        }