Exemplo n.º 1
0
        public static List <KingBitBoard> KingBitBoardResults(ChessBoard inputChessBoard, ChessPieceColors color, BitBoard blackPieces, BitBoard whitePieces, BitBoard allPieces)
        {
            List <KingBitBoard> result = new List <KingBitBoard>();
            KingBitBoard        legalWhiteKingMoves = new KingBitBoard(ChessPieceColors.White);
            KingBitBoard        legalBlackKingMoves = new KingBitBoard(ChessPieceColors.Black);
            List <KingBitBoard> sepKingsOutput      = new List <KingBitBoard>();

            if (color == ChessPieceColors.White)
            {
                legalWhiteKingMoves = ComputeWhiteKing(inputChessBoard.WhiteKing, inputChessBoard, blackPieces, whitePieces, allPieces);
                sepKingsOutput      = ColoredBitBoard.SplitBitBoard(legalWhiteKingMoves).ToList();
                foreach (KingBitBoard sepKBB in sepKingsOutput)
                {
                    result.Add(sepKBB);
                }
                _numberOfWhiteKingMoves = result.Count;
            }
            else
            {
                legalBlackKingMoves = ComputeBlackKing(inputChessBoard.BlackKing, inputChessBoard, blackPieces, whitePieces, allPieces);
                sepKingsOutput      = ColoredBitBoard.SplitBitBoard(legalBlackKingMoves).ToList();
                foreach (KingBitBoard sepKBB in sepKingsOutput)
                {
                    result.Add(sepKBB);
                }
                _numberOfBlackKingMoves = result.Count;
            }

            return(result);
        }
Exemplo n.º 2
0
        public void HasMoved_IsBlackKingMoved_False()
        {
            KingBitBoard Board = new KingBitBoard(ChessPieceColors.Black);

            Board.Initialize(null);

            Assert.False(Board.HasMoved);
        }
Exemplo n.º 3
0
        public void Initialize_IsBlackCorrectPlaced_Equal()
        {
            ulong        correctPlacement = 0x0800000000000000;
            KingBitBoard board            = new KingBitBoard(ChessPieceColors.Black);

            board.Initialize(null);

            Assert.Equal(correctPlacement, (ulong)board.Bits);
        }
Exemplo n.º 4
0
        public static List <ColoredBitBoard> GenerateStaticMoves_Black_Depth1(ChessBoard board, ChessPieceColors color)
        {
            List <ColoredBitBoard> legalMoves = new List <ColoredBitBoard>();
            //Black king moves
            KingBitBoard move1 = new KingBitBoard(ChessPieceColors.Black);
            KingBitBoard move2 = new KingBitBoard(ChessPieceColors.Black);
            KingBitBoard move3 = new KingBitBoard(ChessPieceColors.Black);
            KingBitBoard move4 = new KingBitBoard(ChessPieceColors.Black);
            KingBitBoard move5 = new KingBitBoard(ChessPieceColors.Black);
            KingBitBoard move6 = new KingBitBoard(ChessPieceColors.Black);
            KingBitBoard move7 = new KingBitBoard(ChessPieceColors.Black);

            move1.Bits = BoardSquare.A3;
            move2.Bits = BoardSquare.C3;
            move3.Bits = BoardSquare.A4;
            move4.Bits = BoardSquare.C4;
            move5.Bits = BoardSquare.A5;
            move6.Bits = BoardSquare.B5;
            move7.Bits = BoardSquare.C5;

            //Black Pawn moves, pawn at B3
            PawnBitBoard pawnEnd11 = new PawnBitBoard(ChessPieceColors.Black);
            PawnBitBoard pawnEnd12 = new PawnBitBoard(ChessPieceColors.Black);
            PawnBitBoard move8     = new PawnBitBoard(ChessPieceColors.Black);
            PawnBitBoard move9     = new PawnBitBoard(ChessPieceColors.Black);

            pawnEnd11.Bits = BoardSquare.B2;
            pawnEnd12.Bits = BoardSquare.C2;

            move8.Bits = (board.BlackPawn.Bits ^ BoardSquare.B3) | pawnEnd11.Bits;
            move9.Bits = (board.BlackPawn.Bits ^ BoardSquare.B3) | pawnEnd12.Bits;

            //Pawn at D3
            PawnBitBoard pawnEnd21 = new PawnBitBoard(ChessPieceColors.Black);
            PawnBitBoard pawnEnd22 = new PawnBitBoard(ChessPieceColors.Black);
            PawnBitBoard move10    = new PawnBitBoard(ChessPieceColors.Black);
            PawnBitBoard move11    = new PawnBitBoard(ChessPieceColors.Black);

            pawnEnd21.Bits = BoardSquare.C2;
            pawnEnd22.Bits = BoardSquare.D2;

            move10.Bits = (board.BlackPawn.Bits ^ BoardSquare.D3) | pawnEnd21.Bits;
            move11.Bits = (board.BlackPawn.Bits ^ BoardSquare.D3) | pawnEnd22.Bits;

            legalMoves.Add(move1);
            legalMoves.Add(move2);
            legalMoves.Add(move3);
            legalMoves.Add(move4);
            legalMoves.Add(move5);
            legalMoves.Add(move6);
            legalMoves.Add(move7);
            legalMoves.Add(move8);
            legalMoves.Add(move9);
            legalMoves.Add(move10);
            legalMoves.Add(move11);
            return(legalMoves);
        }
Exemplo n.º 5
0
        public void HasMoved_IsBlackKingMoved_True()
        {
            KingBitBoard Board = new KingBitBoard(ChessPieceColors.Black);

            Board.Initialize(null);
            Board.Bits = BoardSquare.F8;

            Assert.True(Board.HasMoved);
        }
Exemplo n.º 6
0
        public void Equals_BitBoardNotEqual_True()
        {
            KingBitBoard king = new KingBitBoard(ChessPieceColors.White);

            king.Bits = BoardSquare.E5;
            PawnBitBoard pawn = new PawnBitBoard(ChessPieceColors.White);

            pawn.Bits = BoardSquare.E5;

            Assert.False(king.Equals(pawn));
        }
Exemplo n.º 7
0
        public void Undo_WhiteKingRankBackward_Equal()
        {
            ChessBoard testBoard = new ChessBoard();

            testBoard.InitializeGame();

            PawnBitBoard move1 = new PawnBitBoard(ChessPieceColors.White);

            move1.Bits = (testBoard.WhitePawn.Bits ^ BoardSquare.E2) | BoardSquare.E3;
            PawnBitBoard move2 = new PawnBitBoard(ChessPieceColors.Black);

            move2.Bits = (testBoard.BlackPawn.Bits ^ BoardSquare.A7) | BoardSquare.A6;
            KingBitBoard move3 = new KingBitBoard(ChessPieceColors.White);

            move3.Bits = (testBoard.WhiteKing.Bits ^ BoardSquare.E1) | BoardSquare.E2;
            PawnBitBoard move4 = new PawnBitBoard(ChessPieceColors.Black);

            move4.Bits = (move2.Bits ^ BoardSquare.A6) | BoardSquare.A5;
            KingBitBoard move5 = new KingBitBoard(ChessPieceColors.White);

            move5.Bits = (move3.Bits ^ BoardSquare.E2) | BoardSquare.E1;

            ulong expectedHash = testBoard.BoardHash.Key;

            testBoard.Update(move1);
            testBoard.Undo();
            Assert.Equal(expectedHash, testBoard.BoardHash.Key);
            testBoard.Update(move1);
            expectedHash = testBoard.BoardHash.Key;

            testBoard.Update(move2);
            testBoard.Undo();
            Assert.Equal(expectedHash, testBoard.BoardHash.Key);
            testBoard.Update(move2);
            expectedHash = testBoard.BoardHash.Key;

            testBoard.Update(move3);
            testBoard.Undo();
            Assert.Equal(expectedHash, testBoard.BoardHash.Key);
            testBoard.Update(move3);
            expectedHash = testBoard.BoardHash.Key;

            testBoard.Update(move4);
            testBoard.Undo();
            Assert.Equal(expectedHash, testBoard.BoardHash.Key);
            testBoard.Update(move4);

            expectedHash = testBoard.BoardHash.Key;
            testBoard.Update(move5);
            testBoard.Undo();
            ulong testHash = testBoard.BoardHash.Key;

            Assert.Equal(expectedHash, testHash);
        }
Exemplo n.º 8
0
        public static List <ColoredBitBoard> GenerateStaticMoves_Depth12(ChessBoard board, ChessPieceColors color)
        {
            List <ColoredBitBoard> legalMoves = new List <ColoredBitBoard>();

            if (color == ChessPieceColors.Black)
            {
                if (board.WhitePawn.Bits == BoardSquare.B3)
                {
                    PawnBitBoard move1 = new PawnBitBoard(ChessPieceColors.Black);
                    move1.Bits = (board.BlackPawn.Bits ^ BoardSquare.D3) | BoardSquare.D2;

                    KingBitBoard move2 = new KingBitBoard(ChessPieceColors.Black);
                    move2.Bits = BoardSquare.B3;
                    legalMoves.Add(move1);
                    legalMoves.Add(move2);
                }
                else if (board.WhitePawn.Bits == BoardSquare.D3)
                {
                    PawnBitBoard move3 = new PawnBitBoard(ChessPieceColors.Black);
                    move3.Bits = (board.BlackPawn.Bits ^ BoardSquare.B3) | BoardSquare.B2;

                    KingBitBoard move4 = new KingBitBoard(ChessPieceColors.Black);
                    move4.Bits = BoardSquare.A3;
                    legalMoves.Add(move3);
                    legalMoves.Add(move4);
                }
                else if (board.WhitePawn.Bits == BoardSquare.C3)
                {
                    KingBitBoard move8 = new KingBitBoard(ChessPieceColors.Black);
                    move8.Bits = BoardSquare.C3;
                    KingBitBoard move9 = new KingBitBoard(ChessPieceColors.Black);
                    move9.Bits = BoardSquare.C4;

                    legalMoves.Add(move8);
                    legalMoves.Add(move9);
                }
            }
            else if (color == ChessPieceColors.White)
            {
                PawnBitBoard move5 = new PawnBitBoard(ChessPieceColors.White);
                move5.Bits = (board.WhitePawn.Bits ^ BoardSquare.C2) | BoardSquare.B3;
                PawnBitBoard move6 = new PawnBitBoard(ChessPieceColors.White);
                move6.Bits = (board.WhitePawn.Bits ^ BoardSquare.C2) | BoardSquare.D3;
                PawnBitBoard move7 = new PawnBitBoard(ChessPieceColors.White);
                move7.Bits = (board.WhitePawn.Bits ^ BoardSquare.C2) | BoardSquare.C3;
                legalMoves.Add(move5);
                legalMoves.Add(move6);
                legalMoves.Add(move7);
            }
            return(legalMoves);
        }
Exemplo n.º 9
0
        private static KingBitBoard ComputeBlackKing(KingBitBoard inputKingBB, ChessBoard inputChessBoard, BitBoard blackPieces, BitBoard whitePieces, BitBoard allPieces)
        {
            KingBitBoard  result         = new KingBitBoard(ChessPieceColors.Black);
            EmptyBitBoard kingClipFILE_H = new EmptyBitBoard();
            EmptyBitBoard kingClipFILE_A = new EmptyBitBoard();

            EmptyBitBoard spot1    = new EmptyBitBoard();
            EmptyBitBoard spot2    = new EmptyBitBoard();
            EmptyBitBoard spot3    = new EmptyBitBoard();
            EmptyBitBoard spot4    = new EmptyBitBoard();
            EmptyBitBoard spot5    = new EmptyBitBoard();
            EmptyBitBoard spot6    = new EmptyBitBoard();
            EmptyBitBoard spot7    = new EmptyBitBoard();
            EmptyBitBoard spot8    = new EmptyBitBoard();
            EmptyBitBoard castling = new EmptyBitBoard();

            kingClipFILE_A.Bits = (BoardSquare)((ulong)inputKingBB.Bits & ~MoveGenUtils.FILE_A);
            kingClipFILE_H.Bits = (BoardSquare)((ulong)inputKingBB.Bits & ~MoveGenUtils.FILE_H);

            spot1.Bits = (BoardSquare)((ulong)kingClipFILE_A.Bits << 9);
            spot2.Bits = (BoardSquare)((ulong)inputKingBB.Bits << 8);
            spot3.Bits = (BoardSquare)((ulong)kingClipFILE_H.Bits << 7);
            spot4.Bits = (BoardSquare)((ulong)kingClipFILE_H.Bits >> 1);
            spot5.Bits = (BoardSquare)((ulong)kingClipFILE_H.Bits >> 9);
            spot6.Bits = (BoardSquare)((ulong)inputKingBB.Bits >> 8);
            spot7.Bits = (BoardSquare)((ulong)kingClipFILE_A.Bits >> 7);
            spot8.Bits = (BoardSquare)((ulong)kingClipFILE_A.Bits << 1);

            if (!inputKingBB.HasMoved)
            {
                if (!inputChessBoard.BlackRook.HasMovedKingSide && ((ulong)(BoardSquare.F8 | BoardSquare.G8) & (ulong)blackPieces.Bits) == 0)
                {
                    castling.Bits = (BoardSquare)((ulong)inputKingBB.Bits >> 2);
                }
                else if (!inputChessBoard.BlackRook.HasMovedQueenSide && ((ulong)(BoardSquare.D8 | BoardSquare.C8 | BoardSquare.B8) & (ulong)blackPieces.Bits) == 0)
                {
                    castling.Bits = (BoardSquare)((ulong)inputKingBB.Bits << 2);
                }
            }

            result.Bits = spot1.Bits | spot2.Bits | spot3.Bits | spot4.Bits | spot5.Bits | spot6.Bits | spot7.Bits | spot8.Bits | castling.Bits;
            result.Bits = result.Bits & ~blackPieces.Bits;

            return(result);
        }
Exemplo n.º 10
0
        public void Undo_BlackKingRankBackward_Equal()
        {
            ChessBoard testBoard = new ChessBoard();

            testBoard.InitializeGame();

            PawnBitBoard move1 = new PawnBitBoard(ChessPieceColors.White);

            move1.Bits = (testBoard.WhitePawn.Bits ^ BoardSquare.H2) | BoardSquare.H3;
            PawnBitBoard move2 = new PawnBitBoard(ChessPieceColors.Black);

            move2.Bits = (testBoard.BlackPawn.Bits ^ BoardSquare.E7) | BoardSquare.E6;
            PawnBitBoard move3 = new PawnBitBoard(ChessPieceColors.White);

            move3.Bits = (move1.Bits ^ BoardSquare.H3) | BoardSquare.H4;
            KingBitBoard move4 = new KingBitBoard(ChessPieceColors.Black);

            move4.Bits = (testBoard.BlackKing.Bits ^ BoardSquare.E8) | BoardSquare.E7;

            ulong expectedHash = testBoard.BoardHash.Key;

            testBoard.Update(move1);
            testBoard.Undo();
            Assert.Equal(expectedHash, testBoard.BoardHash.Key);
            testBoard.Update(move1);
            expectedHash = testBoard.BoardHash.Key;

            testBoard.Update(move2);
            testBoard.Undo();
            Assert.Equal(expectedHash, testBoard.BoardHash.Key);
            testBoard.Update(move2);
            expectedHash = testBoard.BoardHash.Key;

            testBoard.Update(move3);
            testBoard.Undo();
            Assert.Equal(expectedHash, testBoard.BoardHash.Key);
            testBoard.Update(move3);
            expectedHash = testBoard.BoardHash.Key;

            testBoard.Update(move4);
            testBoard.Undo();
            Assert.Equal(expectedHash, testBoard.BoardHash.Key);
        }
Exemplo n.º 11
0
        public static List <ColoredBitBoard> GenerateStaticMoves_White_Depth1(ChessBoard board, ChessPieceColors color)
        {
            List <ColoredBitBoard> legalMoves = new List <ColoredBitBoard>();
            //White king moves
            KingBitBoard move1 = new KingBitBoard(ChessPieceColors.White);
            KingBitBoard move2 = new KingBitBoard(ChessPieceColors.White);
            KingBitBoard move3 = new KingBitBoard(ChessPieceColors.White);

            move1.Bits = BoardSquare.H2;
            move2.Bits = BoardSquare.G1;
            move3.Bits = BoardSquare.G2;



            //White pawn moves
            PawnBitBoard pawnEnd1 = new PawnBitBoard(ChessPieceColors.White);
            PawnBitBoard pawnEnd2 = new PawnBitBoard(ChessPieceColors.White);
            PawnBitBoard pawnEnd3 = new PawnBitBoard(ChessPieceColors.White);

            pawnEnd1.Bits = BoardSquare.C3;
            pawnEnd2.Bits = BoardSquare.D3;
            pawnEnd3.Bits = BoardSquare.B3;

            PawnBitBoard move4 = new PawnBitBoard(ChessPieceColors.White);
            PawnBitBoard move5 = new PawnBitBoard(ChessPieceColors.White);
            PawnBitBoard move6 = new PawnBitBoard(ChessPieceColors.White);

            move4.Bits = (board.WhitePawn.Bits ^ BoardSquare.C2) | pawnEnd1.Bits;
            move5.Bits = (board.WhitePawn.Bits ^ BoardSquare.C2) | pawnEnd2.Bits;
            move6.Bits = (board.WhitePawn.Bits ^ BoardSquare.C2) | pawnEnd3.Bits;

            legalMoves.Add(move1);
            legalMoves.Add(move2);
            legalMoves.Add(move3);
            legalMoves.Add(move4);
            legalMoves.Add(move5);
            legalMoves.Add(move6);

            return(legalMoves);
        }
Exemplo n.º 12
0
        private static void f3d5failmove()
        {
            //Winboard winboard = new Winboard();
            ChessBoard lolBoard = new ChessBoard();

            lolBoard.InitializeGame();

            //White
            PawnBitBoard pawnWhite = new PawnBitBoard(ChessPieceColors.White);

            pawnWhite.Bits = BoardSquare.A3 | BoardSquare.B3 | BoardSquare.C3 | BoardSquare.D3 | BoardSquare.H4;

            BishopBitBoard bishopWhite = new BishopBitBoard(ChessPieceColors.White);

            bishopWhite.Bits = BoardSquare.C1;

            KingBitBoard kingWhite = new KingBitBoard(ChessPieceColors.White);

            kingWhite.Bits = BoardSquare.F2;

            RookBitBoard rookWhite = new RookBitBoard(ChessPieceColors.White);

            rookWhite.Bits = BoardSquare.A1 | BoardSquare.H1;

            KnightBitBoard knightWhite = new KnightBitBoard(ChessPieceColors.White);

            knightWhite.Bits = BoardSquare.B1 | BoardSquare.G1;

            QueenBitBoard queenWhite = new QueenBitBoard(ChessPieceColors.White);

            queenWhite.Bits = BoardSquare.F3;

            //Black
            PawnBitBoard pawnBlack = new PawnBitBoard(ChessPieceColors.Black);

            pawnBlack.Bits = BoardSquare.A7 | BoardSquare.B7 | BoardSquare.C5 | BoardSquare.D7 | BoardSquare.G7 | BoardSquare.G4 | BoardSquare.H7;

            RookBitBoard rookBlack = new RookBitBoard(ChessPieceColors.Black);

            rookBlack.Bits = BoardSquare.A8 | BoardSquare.F8;

            BishopBitBoard bishopBlack = new BishopBitBoard(ChessPieceColors.Black);

            bishopBlack.Bits = BoardSquare.C8 | BoardSquare.D6;

            QueenBitBoard queenBlack = new QueenBitBoard(ChessPieceColors.Black);

            queenBlack.Bits = BoardSquare.G6;

            KingBitBoard kingBlack = new KingBitBoard(ChessPieceColors.Black);

            kingBlack.Bits = BoardSquare.G8;

            KnightBitBoard knightBlack = new KnightBitBoard(ChessPieceColors.Black);

            knightBlack.Bits = BoardSquare.D5;


            //RookBitBoard badMove = new RookBitBoard( ChessPieceColors.Black );
            //badMove.Bits = BoardSquare.B8;
            lolBoard.Update(pawnWhite);
            lolBoard.Update(knightWhite);
            lolBoard.Update(queenWhite);
            lolBoard.Update(rookWhite);
            lolBoard.Update(bishopWhite);
            lolBoard.Update(kingWhite);
            lolBoard.Update(pawnBlack);
            lolBoard.Update(rookBlack);
            lolBoard.Update(bishopBlack);
            lolBoard.Update(queenBlack);
            lolBoard.Update(kingBlack);
            lolBoard.Update(knightBlack);


            ColoredBitBoard bestMove = NegaMax.GetBestMove(lolBoard, 3, ChessPieceColors.White, MoveGen.GenerateLegalMoves, Eval.EvaluateState);
        }
Exemplo n.º 13
0
 public KingMovesGenerator(BitBoard bitboard, AttacksGenerator attacksgenerator)
     : base(bitboard, attacksgenerator)
 {
     this.kingBoard = (KingBitBoard)bitboard;
 }
Exemplo n.º 14
0
 public static KingBitBoard Test_ComputeBlackKing(KingBitBoard inputKingBB, ChessBoard inputChessBoard, BitBoard blackPieces, BitBoard whitePieces, BitBoard allPieces)
 {
     return(ComputeBlackKing(inputKingBB, inputChessBoard, blackPieces, whitePieces, allPieces));
 }
Exemplo n.º 15
0
        public void Undo_WhiteKingQueenSideCastling_Equal()
        {
            ChessBoard testBoard = new ChessBoard();

            testBoard.InitializeGame();

            KnightBitBoard move1 = new KnightBitBoard(ChessPieceColors.White);

            move1.Bits = (testBoard.WhiteKnight.Bits ^ BoardSquare.B1) | BoardSquare.C3;
            PawnBitBoard move2 = new PawnBitBoard(ChessPieceColors.Black);

            move2.Bits = (testBoard.BlackPawn.Bits ^ BoardSquare.H7) | BoardSquare.H6;
            PawnBitBoard move3 = new PawnBitBoard(ChessPieceColors.White);

            move3.Bits = (testBoard.WhitePawn.Bits ^ BoardSquare.B2) | BoardSquare.B3;
            PawnBitBoard move4 = new PawnBitBoard(ChessPieceColors.Black);

            move4.Bits = (move2.Bits ^ BoardSquare.H6) | BoardSquare.H5;
            BishopBitBoard move5 = new BishopBitBoard(ChessPieceColors.White);

            move5.Bits = (testBoard.WhiteBishop.Bits ^ BoardSquare.C1) | BoardSquare.A3;
            PawnBitBoard move6 = new PawnBitBoard(ChessPieceColors.Black);

            move6.Bits = (move4.Bits ^ BoardSquare.H5) | BoardSquare.H4;
            QueenBitBoard move7 = new QueenBitBoard(ChessPieceColors.White);

            move7.Bits = (testBoard.WhiteQueen.Bits ^ BoardSquare.D1) | BoardSquare.B1;
            PawnBitBoard move8 = new PawnBitBoard(ChessPieceColors.Black);

            move8.Bits = (move6.Bits ^ BoardSquare.H4) | BoardSquare.H3;
            QueenBitBoard move9 = new QueenBitBoard(ChessPieceColors.White);

            move9.Bits = (move7.Bits ^ BoardSquare.B1) | BoardSquare.B2;
            PawnBitBoard move10 = new PawnBitBoard(ChessPieceColors.Black);

            move10.Bits = (move8.Bits ^ BoardSquare.G7) | BoardSquare.G5;
            KingBitBoard move11 = new KingBitBoard(ChessPieceColors.White);

            move11.Bits = (testBoard.WhiteKing.Bits ^ BoardSquare.E1) | BoardSquare.C1;

            ulong expectedHash = testBoard.BoardHash.Key;

            testBoard.Update(move1);
            testBoard.Undo();
            Assert.Equal(expectedHash, testBoard.BoardHash.Key);
            testBoard.Update(move1);
            expectedHash = testBoard.BoardHash.Key;

            testBoard.Update(move2);
            testBoard.Undo();
            Assert.Equal(expectedHash, testBoard.BoardHash.Key);
            testBoard.Update(move2);
            expectedHash = testBoard.BoardHash.Key;

            testBoard.Update(move3);
            testBoard.Undo();
            Assert.Equal(expectedHash, testBoard.BoardHash.Key);
            testBoard.Update(move3);
            expectedHash = testBoard.BoardHash.Key;

            testBoard.Update(move4);
            testBoard.Undo();
            Assert.Equal(expectedHash, testBoard.BoardHash.Key);
            testBoard.Update(move4);
            expectedHash = testBoard.BoardHash.Key;

            testBoard.Update(move5);
            testBoard.Undo();
            Assert.Equal(expectedHash, testBoard.BoardHash.Key);
            testBoard.Update(move5);
            expectedHash = testBoard.BoardHash.Key;

            testBoard.Update(move6);
            testBoard.Undo();
            Assert.Equal(expectedHash, testBoard.BoardHash.Key);
            testBoard.Update(move6);
            expectedHash = testBoard.BoardHash.Key;

            testBoard.Update(move7);
            testBoard.Undo();
            Assert.Equal(expectedHash, testBoard.BoardHash.Key);
            testBoard.Update(move7);
            expectedHash = testBoard.BoardHash.Key;

            testBoard.Update(move8);
            testBoard.Undo();
            Assert.Equal(expectedHash, testBoard.BoardHash.Key);
            testBoard.Update(move8);
            expectedHash = testBoard.BoardHash.Key;

            testBoard.Update(move9);
            testBoard.Undo();
            Assert.Equal(expectedHash, testBoard.BoardHash.Key);
            testBoard.Update(move9);
            expectedHash = testBoard.BoardHash.Key;

            testBoard.Update(move10);
            testBoard.Undo();
            Assert.Equal(expectedHash, testBoard.BoardHash.Key);
            testBoard.Update(move10);
            expectedHash = testBoard.BoardHash.Key;

            expectedHash = testBoard.BoardHash.Key;
            testBoard.Update(move11);
            testBoard.Undo();
            ulong testHash = testBoard.BoardHash.Key;

            Assert.Equal(expectedHash, testHash);
        }
Exemplo n.º 16
0
        private static void sacrificeQueenDebugStuffSomethingTestMethod()
        {
            //Winboard winboard = new Winboard();
            ChessBoard lolBoard = new ChessBoard();

            lolBoard.InitializeGame();

            //White
            PawnBitBoard pawnWhite = new PawnBitBoard(ChessPieceColors.White);

            pawnWhite.Bits = BoardSquare.A4 | BoardSquare.C2 | BoardSquare.D3 | BoardSquare.E4 | BoardSquare.F2 | BoardSquare.G2;

            BishopBitBoard bishopWhite = new BishopBitBoard(ChessPieceColors.White);

            bishopWhite.Bits = BoardSquare.E2 | BoardSquare.H4;

            KingBitBoard kingWhite = new KingBitBoard(ChessPieceColors.White);

            kingWhite.Bits = BoardSquare.E1;

            RookBitBoard rookWhite = new RookBitBoard(ChessPieceColors.White);

            rookWhite.Bits = BoardSquare.B1 | BoardSquare.H1;

            KnightBitBoard knightWhite = new KnightBitBoard(ChessPieceColors.White);

            knightWhite.Bits = BoardSquare.D2;

            QueenBitBoard queenWhite = new QueenBitBoard(ChessPieceColors.White);

            queenWhite.Bits = BoardSquare.D1;

            //Black
            PawnBitBoard pawnBlack = new PawnBitBoard(ChessPieceColors.Black);

            pawnBlack.Bits = BoardSquare.A7 | BoardSquare.B7 | BoardSquare.C5 | BoardSquare.E5 | BoardSquare.H5;
            RookBitBoard rookBlack = new RookBitBoard(ChessPieceColors.Black);

            rookBlack.Bits = BoardSquare.A8 | BoardSquare.H7;

            BishopBitBoard bishopBlack = new BishopBitBoard(ChessPieceColors.Black);

            bishopBlack.Bits = BoardSquare.C8 | BoardSquare.F8;

            QueenBitBoard queenBlack = new QueenBitBoard(ChessPieceColors.Black);

            queenBlack.Bits = BoardSquare.B4;

            KingBitBoard kingBlack = new KingBitBoard(ChessPieceColors.Black);

            kingBlack.Bits = BoardSquare.F7;

            KnightBitBoard knightBlack = new KnightBitBoard(ChessPieceColors.Black);

            knightBlack.Bits = BoardSquare.B8;


            //RookBitBoard badMove = new RookBitBoard( ChessPieceColors.Black );
            //badMove.Bits = BoardSquare.B8;
            lolBoard.Update(pawnWhite);
            lolBoard.Update(knightWhite);
            lolBoard.Update(queenWhite);
            lolBoard.Update(rookWhite);
            lolBoard.Update(bishopWhite);
            lolBoard.Update(kingWhite);
            lolBoard.Update(pawnBlack);
            lolBoard.Update(rookBlack);
            lolBoard.Update(bishopBlack);
            lolBoard.Update(queenBlack);
            lolBoard.Update(kingBlack);
            lolBoard.Update(knightBlack);

            List <ColoredBitBoard> legalMoves = new List <ColoredBitBoard>();

            legalMoves = MoveGen.GenerateLegalMoves(lolBoard, ChessPieceColors.Black);
            ColoredBitBoard bestMove = NegaMax.GetBestMove(lolBoard, 3, ChessPieceColors.Black, MoveGen.GenerateLegalMoves, Eval.EvaluateState);

            Console.Write(legalMoves.ToString() + bestMove.ToString());
        }
Exemplo n.º 17
0
        private static void blackqueensidecastle()
        {
            //Winboard winboard = new Winboard();
            ChessBoard lolBoard = new ChessBoard();

            lolBoard.InitializeGame();

            //White
            PawnBitBoard pawnWhite = new PawnBitBoard(ChessPieceColors.White);

            pawnWhite.Bits = BoardSquare.A2 | BoardSquare.B2 | BoardSquare.C2 | BoardSquare.D2 | BoardSquare.E4 | BoardSquare.H3;

            BishopBitBoard bishopWhite = new BishopBitBoard(ChessPieceColors.White);

            bishopWhite.Bits = BoardSquare.C1;

            KingBitBoard kingWhite = new KingBitBoard(ChessPieceColors.White);

            kingWhite.Bits = BoardSquare.D3;

            RookBitBoard rookWhite = new RookBitBoard(ChessPieceColors.White);

            rookWhite.Bits = BoardSquare.A1 | BoardSquare.H1;

            KnightBitBoard knightWhite = new KnightBitBoard(ChessPieceColors.White);

            knightWhite.Bits = BoardSquare.D2;

            QueenBitBoard queenWhite = new QueenBitBoard(ChessPieceColors.White);

            queenWhite.Bits = BoardSquare.D1;

            //Black
            PawnBitBoard pawnBlack = new PawnBitBoard(ChessPieceColors.Black);

            pawnBlack.Bits = BoardSquare.A7 | BoardSquare.B7 | BoardSquare.C7 | BoardSquare.C6 | BoardSquare.F7 | BoardSquare.G7 | BoardSquare.H7;

            RookBitBoard rookBlack = new RookBitBoard(ChessPieceColors.Black);

            rookBlack.Bits = BoardSquare.A8 | BoardSquare.H8;

            BishopBitBoard bishopBlack = new BishopBitBoard(ChessPieceColors.Black);

            bishopBlack.Bits = BoardSquare.F5 | BoardSquare.H4;

            QueenBitBoard queenBlack = new QueenBitBoard(ChessPieceColors.Black);

            queenBlack.Bits = BoardSquare.F2;

            KingBitBoard kingBlack = new KingBitBoard(ChessPieceColors.Black);

            kingBlack.Bits = BoardSquare.E8;

            KnightBitBoard knightBlack = new KnightBitBoard(ChessPieceColors.Black);

            knightBlack.Bits = BoardSquare.H6;


            //RookBitBoard badMove = new RookBitBoard( ChessPieceColors.Black );
            //badMove.Bits = BoardSquare.B8;
            lolBoard.Update(pawnWhite);
            lolBoard.Update(knightWhite);
            lolBoard.Update(queenWhite);
            lolBoard.Update(rookWhite);
            lolBoard.Update(bishopWhite);
            lolBoard.Update(kingWhite);
            lolBoard.Update(pawnBlack);
            lolBoard.Update(rookBlack);
            lolBoard.Update(bishopBlack);
            lolBoard.Update(queenBlack);
            lolBoard.Update(kingBlack);
            lolBoard.Update(knightBlack);
            KingBitBoard test = new KingBitBoard(ChessPieceColors.Black);

            test.Bits = BoardSquare.C8;
            lolBoard.Update(test);

            List <ColoredBitBoard> legalMoves = new List <ColoredBitBoard>();

            legalMoves = MoveGen.GenerateLegalMoves(lolBoard, ChessPieceColors.Black);
            ColoredBitBoard bestMove = NegaMax.GetBestMove(lolBoard, 3, ChessPieceColors.White, MoveGen.GenerateLegalMoves, Eval.EvaluateState);

            Console.Write(legalMoves.ToString() + bestMove.ToString());
        }
Exemplo n.º 18
0
        public void Undo_WhiteKingKingSideCastling_Equal()
        {
            ChessBoard testBoard = new ChessBoard();

            testBoard.InitializeGame();

            KnightBitBoard move1 = new KnightBitBoard(ChessPieceColors.White);

            move1.Bits = (testBoard.WhiteKnight.Bits ^ BoardSquare.G1) | BoardSquare.F3;
            PawnBitBoard move2 = new PawnBitBoard(ChessPieceColors.Black);

            move2.Bits = (testBoard.BlackPawn.Bits ^ BoardSquare.A7) | BoardSquare.A6;
            PawnBitBoard move3 = new PawnBitBoard(ChessPieceColors.White);

            move3.Bits = (testBoard.WhitePawn.Bits ^ BoardSquare.G2) | BoardSquare.G3;
            PawnBitBoard move4 = new PawnBitBoard(ChessPieceColors.Black);

            move4.Bits = (move2.Bits ^ BoardSquare.A6) | BoardSquare.A5;
            BishopBitBoard move5 = new BishopBitBoard(ChessPieceColors.White);

            move5.Bits = (testBoard.WhiteBishop.Bits ^ BoardSquare.F1) | BoardSquare.G2;
            PawnBitBoard move6 = new PawnBitBoard(ChessPieceColors.Black);

            move6.Bits = (move4.Bits ^ BoardSquare.A5) | BoardSquare.A4;
            KingBitBoard move7 = new KingBitBoard(ChessPieceColors.White);

            move7.Bits = (testBoard.WhiteKing.Bits ^ BoardSquare.E1) | BoardSquare.G1;

            ulong expectedHash = testBoard.BoardHash.Key;

            testBoard.Update(move1);
            testBoard.Undo();
            Assert.Equal(expectedHash, testBoard.BoardHash.Key);
            testBoard.Update(move1);
            expectedHash = testBoard.BoardHash.Key;

            testBoard.Update(move2);
            testBoard.Undo();
            Assert.Equal(expectedHash, testBoard.BoardHash.Key);
            testBoard.Update(move2);
            expectedHash = testBoard.BoardHash.Key;

            testBoard.Update(move3);
            testBoard.Undo();
            Assert.Equal(expectedHash, testBoard.BoardHash.Key);
            testBoard.Update(move3);
            expectedHash = testBoard.BoardHash.Key;

            testBoard.Update(move4);
            testBoard.Undo();
            Assert.Equal(expectedHash, testBoard.BoardHash.Key);
            testBoard.Update(move4);
            expectedHash = testBoard.BoardHash.Key;

            testBoard.Update(move5);
            testBoard.Undo();
            Assert.Equal(expectedHash, testBoard.BoardHash.Key);
            testBoard.Update(move5);
            expectedHash = testBoard.BoardHash.Key;

            testBoard.Update(move6);
            testBoard.Undo();
            Assert.Equal(expectedHash, testBoard.BoardHash.Key);
            testBoard.Update(move6);
            expectedHash = testBoard.BoardHash.Key;

            expectedHash = testBoard.BoardHash.Key;
            testBoard.Update(move7);
            testBoard.Undo();
            ulong testHash = testBoard.BoardHash.Key;

            Assert.Equal(expectedHash, testHash);
        }
Exemplo n.º 19
0
        private static void anotherBlackQueenSideCastleFail()
        {
            ChessBoard lolBoard = new ChessBoard();

            lolBoard.InitializeGame();

            //White
            PawnBitBoard pawnWhite = new PawnBitBoard(ChessPieceColors.White);

            pawnWhite.Bits = BoardSquare.A2 | BoardSquare.C3 | BoardSquare.E3 | BoardSquare.H3;

            BishopBitBoard bishopWhite = new BishopBitBoard(ChessPieceColors.White);

            bishopWhite.Bits = 0;

            RookBitBoard rookWhite = new RookBitBoard(ChessPieceColors.White);

            rookWhite.Bits = BoardSquare.A1;

            KnightBitBoard knightWhite = new KnightBitBoard(ChessPieceColors.White);

            knightWhite.Bits = BoardSquare.B1;

            QueenBitBoard queenWhite = new QueenBitBoard(ChessPieceColors.White);

            queenWhite.Bits = BoardSquare.E2;

            KingBitBoard kingWhite = new KingBitBoard(ChessPieceColors.White);

            kingWhite.Bits = BoardSquare.D2;

            //black
            PawnBitBoard pawnBlack = new PawnBitBoard(ChessPieceColors.Black);

            pawnBlack.Bits = BoardSquare.A7 | BoardSquare.B7 | BoardSquare.C5 | BoardSquare.F7 | BoardSquare.G7 | BoardSquare.H5;

            BishopBitBoard bishopBlack = new BishopBitBoard(ChessPieceColors.Black);

            bishopBlack.Bits = BoardSquare.E4 | BoardSquare.F8;

            RookBitBoard rookBlack = new RookBitBoard(ChessPieceColors.Black);

            rookBlack.Bits = BoardSquare.A8 | BoardSquare.H8;

            KnightBitBoard knightBlack = new KnightBitBoard(ChessPieceColors.Black);

            knightBlack.Bits = BoardSquare.F4;

            QueenBitBoard queenBlack = new QueenBitBoard(ChessPieceColors.Black);

            queenBlack.Bits = BoardSquare.H3;

            KingBitBoard kingBlack = new KingBitBoard(ChessPieceColors.Black);

            kingBlack.Bits = BoardSquare.C8;

            //Update

            lolBoard.Update(pawnWhite);
            lolBoard.Update(knightWhite);
            lolBoard.Update(queenWhite);
            lolBoard.Update(rookWhite);
            lolBoard.Update(bishopWhite);
            lolBoard.Update(kingWhite);
            lolBoard.Update(pawnBlack);
            lolBoard.Update(rookBlack);
            lolBoard.Update(bishopBlack);
            lolBoard.Update(queenBlack);
            lolBoard.Update(kingBlack);
            lolBoard.Update(knightBlack);

            ColoredBitBoard bestMove = NegaMax.GetBestMove(lolBoard, 3, ChessPieceColors.White, MoveGen.GenerateLegalMoves, Eval.EvaluateState);
        }
Exemplo n.º 20
0
 public KingMovesGenerator(BitBoard bitboard, AttacksGenerator attacksgenerator)
     : base(bitboard, attacksgenerator)
 {
     this.kingBoard = (KingBitBoard)bitboard;
 }
Exemplo n.º 21
0
        public void Undo_BlackKingKingSideCastling_Equal()
        {
            ChessBoard testBoard = new ChessBoard();

            testBoard.InitializeGame();

            PawnBitBoard move1 = new PawnBitBoard(ChessPieceColors.White);

            move1.Bits = (testBoard.WhitePawn.Bits ^ BoardSquare.A2) | BoardSquare.A3;
            KnightBitBoard move2 = new KnightBitBoard(ChessPieceColors.Black);

            move2.Bits = (testBoard.BlackKnight.Bits ^ BoardSquare.G8) | BoardSquare.F6;
            PawnBitBoard move3 = new PawnBitBoard(ChessPieceColors.White);

            move3.Bits = (move1.Bits ^ BoardSquare.A3) | BoardSquare.A4;
            PawnBitBoard move4 = new PawnBitBoard(ChessPieceColors.Black);

            move4.Bits = (testBoard.BlackPawn.Bits ^ BoardSquare.G7) | BoardSquare.G6;
            PawnBitBoard move5 = new PawnBitBoard(ChessPieceColors.White);

            move5.Bits = (move3.Bits ^ BoardSquare.A4) | BoardSquare.A5;
            BishopBitBoard move6 = new BishopBitBoard(ChessPieceColors.Black);

            move6.Bits = (testBoard.BlackBishop.Bits ^ BoardSquare.F8) | BoardSquare.G7;
            PawnBitBoard move7 = new PawnBitBoard(ChessPieceColors.White);

            move7.Bits = (move5.Bits ^ BoardSquare.A5) | BoardSquare.A6;
            KingBitBoard move8 = new KingBitBoard(ChessPieceColors.Black);

            move8.Bits = (testBoard.BlackKing.Bits ^ BoardSquare.E8) | BoardSquare.G8;

            ulong expectedHash = testBoard.BoardHash.Key;

            testBoard.Update(move1);
            testBoard.Undo();
            Assert.Equal(expectedHash, testBoard.BoardHash.Key);
            testBoard.Update(move1);
            expectedHash = testBoard.BoardHash.Key;

            testBoard.Update(move2);
            testBoard.Undo();
            Assert.Equal(expectedHash, testBoard.BoardHash.Key);
            testBoard.Update(move2);
            expectedHash = testBoard.BoardHash.Key;

            testBoard.Update(move3);
            testBoard.Undo();
            Assert.Equal(expectedHash, testBoard.BoardHash.Key);
            testBoard.Update(move3);
            expectedHash = testBoard.BoardHash.Key;

            testBoard.Update(move4);
            testBoard.Undo();
            Assert.Equal(expectedHash, testBoard.BoardHash.Key);
            testBoard.Update(move4);
            expectedHash = testBoard.BoardHash.Key;

            testBoard.Update(move5);
            testBoard.Undo();
            Assert.Equal(expectedHash, testBoard.BoardHash.Key);
            testBoard.Update(move5);
            expectedHash = testBoard.BoardHash.Key;

            testBoard.Update(move6);
            testBoard.Undo();
            Assert.Equal(expectedHash, testBoard.BoardHash.Key);
            testBoard.Update(move6);
            expectedHash = testBoard.BoardHash.Key;

            testBoard.Update(move7);
            testBoard.Undo();
            Assert.Equal(expectedHash, testBoard.BoardHash.Key);
            testBoard.Update(move7);
            expectedHash = testBoard.BoardHash.Key;

            testBoard.Update(move8);
            testBoard.Undo();
            Assert.Equal(expectedHash, testBoard.BoardHash.Key);
        }
Exemplo n.º 22
0
        public void Undo_BlackKingCapture_Equal()
        {
            ChessBoard testBoard = new ChessBoard();

            testBoard.InitializeGame();

            PawnBitBoard move1 = new PawnBitBoard(ChessPieceColors.White);

            move1.Bits = (testBoard.WhitePawn.Bits ^ BoardSquare.E2) | BoardSquare.E4;
            PawnBitBoard move2 = new PawnBitBoard(ChessPieceColors.Black);

            move2.Bits = (testBoard.BlackPawn.Bits ^ BoardSquare.F7) | BoardSquare.F6;
            PawnBitBoard move3 = new PawnBitBoard(ChessPieceColors.White);

            move3.Bits = (move1.Bits ^ BoardSquare.E4) | BoardSquare.E5;
            KingBitBoard move4 = new KingBitBoard(ChessPieceColors.Black);

            move4.Bits = (testBoard.BlackKing.Bits ^ BoardSquare.E8) | BoardSquare.F7;
            PawnBitBoard move5 = new PawnBitBoard(ChessPieceColors.White);

            move5.Bits = (move3.Bits ^ BoardSquare.E5) | BoardSquare.E6;
            KingBitBoard move6 = new KingBitBoard(ChessPieceColors.Black);

            move6.Bits = (move4.Bits ^ BoardSquare.F7) | BoardSquare.E6;

            ulong expectedHash = testBoard.BoardHash.Key;

            testBoard.Update(move1);
            testBoard.Undo();
            Assert.Equal(expectedHash, testBoard.BoardHash.Key);
            testBoard.Update(move1);
            expectedHash = testBoard.BoardHash.Key;

            testBoard.Update(move2);
            testBoard.Undo();
            Assert.Equal(expectedHash, testBoard.BoardHash.Key);
            testBoard.Update(move2);
            expectedHash = testBoard.BoardHash.Key;

            testBoard.Update(move3);
            testBoard.Undo();
            Assert.Equal(expectedHash, testBoard.BoardHash.Key);
            testBoard.Update(move3);
            expectedHash = testBoard.BoardHash.Key;

            testBoard.Update(move4);
            testBoard.Undo();
            Assert.Equal(expectedHash, testBoard.BoardHash.Key);
            testBoard.Update(move4);
            expectedHash = testBoard.BoardHash.Key;

            testBoard.Update(move5);
            testBoard.Undo();
            Assert.Equal(expectedHash, testBoard.BoardHash.Key);
            testBoard.Update(move5);
            expectedHash = testBoard.BoardHash.Key;

            testBoard.Update(move6);
            testBoard.Undo();
            Assert.Equal(expectedHash, testBoard.BoardHash.Key);
        }
Exemplo n.º 23
0
        public void Undo_BlackKingLeft_Equal()
        {
            ChessBoard testBoard = new ChessBoard();

            testBoard.InitializeGame();

            PawnBitBoard move1 = new PawnBitBoard(ChessPieceColors.White);

            move1.Bits = (testBoard.WhitePawn.Bits ^ BoardSquare.H2) | BoardSquare.H3;
            PawnBitBoard move2 = new PawnBitBoard(ChessPieceColors.Black);

            move2.Bits = (testBoard.BlackPawn.Bits ^ BoardSquare.C7) | BoardSquare.C6;
            PawnBitBoard move3 = new PawnBitBoard(ChessPieceColors.White);

            move3.Bits = (move1.Bits ^ BoardSquare.H3) | BoardSquare.H4;
            QueenBitBoard move4 = new QueenBitBoard(ChessPieceColors.Black);

            move4.Bits = (testBoard.BlackQueen.Bits ^ BoardSquare.D8) | BoardSquare.C7;
            PawnBitBoard move5 = new PawnBitBoard(ChessPieceColors.White);

            move5.Bits = (move3.Bits ^ BoardSquare.H4) | BoardSquare.H5;
            KingBitBoard move6 = new KingBitBoard(ChessPieceColors.Black);

            move6.Bits = (testBoard.BlackKing.Bits ^ BoardSquare.E8) | BoardSquare.D8;
            PawnBitBoard move7 = new PawnBitBoard(ChessPieceColors.White);

            move7.Bits = (move5.Bits ^ BoardSquare.H5) | BoardSquare.H6;
            PawnBitBoard move8 = new PawnBitBoard(ChessPieceColors.Black);

            move8.Bits = (move2.Bits ^ BoardSquare.B7) | BoardSquare.B6;
            PawnBitBoard move9 = new PawnBitBoard(ChessPieceColors.White);

            move9.Bits = (move7.Bits ^ BoardSquare.G2) | BoardSquare.G3;
            BishopBitBoard move10 = new BishopBitBoard(ChessPieceColors.Black);

            move10.Bits = (testBoard.BlackBishop.Bits ^ BoardSquare.C8) | BoardSquare.B7;
            PawnBitBoard move11 = new PawnBitBoard(ChessPieceColors.White);

            move11.Bits = (move9.Bits ^ BoardSquare.G3) | BoardSquare.G4;
            KingBitBoard move12 = new KingBitBoard(ChessPieceColors.Black);

            move12.Bits = (move6.Bits ^ BoardSquare.D8) | BoardSquare.C8;

            ulong expectedHash = testBoard.BoardHash.Key;

            testBoard.Update(move1);
            testBoard.Undo();
            Assert.Equal(expectedHash, testBoard.BoardHash.Key);
            testBoard.Update(move1);
            expectedHash = testBoard.BoardHash.Key;

            testBoard.Update(move2);
            testBoard.Undo();
            Assert.Equal(expectedHash, testBoard.BoardHash.Key);
            testBoard.Update(move2);
            expectedHash = testBoard.BoardHash.Key;

            testBoard.Update(move3);
            testBoard.Undo();
            Assert.Equal(expectedHash, testBoard.BoardHash.Key);
            testBoard.Update(move3);
            expectedHash = testBoard.BoardHash.Key;

            testBoard.Update(move4);
            testBoard.Undo();
            Assert.Equal(expectedHash, testBoard.BoardHash.Key);
            testBoard.Update(move4);
            expectedHash = testBoard.BoardHash.Key;

            testBoard.Update(move5);
            testBoard.Undo();
            Assert.Equal(expectedHash, testBoard.BoardHash.Key);
            testBoard.Update(move5);
            expectedHash = testBoard.BoardHash.Key;

            testBoard.Update(move6);
            testBoard.Undo();
            Assert.Equal(expectedHash, testBoard.BoardHash.Key);
            testBoard.Update(move6);
            expectedHash = testBoard.BoardHash.Key;

            testBoard.Update(move7);
            testBoard.Undo();
            Assert.Equal(expectedHash, testBoard.BoardHash.Key);
            testBoard.Update(move7);
            expectedHash = testBoard.BoardHash.Key;

            testBoard.Update(move8);
            testBoard.Undo();
            Assert.Equal(expectedHash, testBoard.BoardHash.Key);
            testBoard.Update(move8);
            expectedHash = testBoard.BoardHash.Key;

            testBoard.Update(move9);
            testBoard.Undo();
            Assert.Equal(expectedHash, testBoard.BoardHash.Key);
            testBoard.Update(move9);
            expectedHash = testBoard.BoardHash.Key;

            testBoard.Update(move10);
            testBoard.Undo();
            Assert.Equal(expectedHash, testBoard.BoardHash.Key);
            testBoard.Update(move10);
            expectedHash = testBoard.BoardHash.Key;

            testBoard.Update(move11);
            testBoard.Undo();
            Assert.Equal(expectedHash, testBoard.BoardHash.Key);
            testBoard.Update(move11);
            expectedHash = testBoard.BoardHash.Key;

            testBoard.Update(move12);
            testBoard.Undo();
            Assert.Equal(expectedHash, testBoard.BoardHash.Key);
        }
Exemplo n.º 24
0
        private static void KingSideCastlingFAIL()
        {
            ChessBoard lolBoard = new ChessBoard();

            lolBoard.InitializeGame();

            //White
            PawnBitBoard pawnWhite = new PawnBitBoard(ChessPieceColors.White);

            pawnWhite.Bits = BoardSquare.A4 | BoardSquare.B4 | BoardSquare.C2 | BoardSquare.F4 | BoardSquare.H5;

            BishopBitBoard bishopWhite = new BishopBitBoard(ChessPieceColors.White);

            bishopWhite.Bits = BoardSquare.E3;

            RookBitBoard rookWhite = new RookBitBoard(ChessPieceColors.White);

            rookWhite.Bits = BoardSquare.C1 | BoardSquare.H1;

            KnightBitBoard knightWhite = new KnightBitBoard(ChessPieceColors.White);

            knightWhite.Bits = BoardSquare.G1;

            QueenBitBoard queenWhite = new QueenBitBoard(ChessPieceColors.White);

            queenWhite.Bits = 0;

            KingBitBoard kingWhite = new KingBitBoard(ChessPieceColors.White);

            kingWhite.Bits = BoardSquare.F2;

            //black
            PawnBitBoard pawnBlack = new PawnBitBoard(ChessPieceColors.Black);

            pawnBlack.Bits = BoardSquare.A7 | BoardSquare.B7 | BoardSquare.E7 | BoardSquare.E4 | BoardSquare.G4 | BoardSquare.G5 | BoardSquare.H7;

            BishopBitBoard bishopBlack = new BishopBitBoard(ChessPieceColors.Black);

            bishopBlack.Bits = BoardSquare.C3 | BoardSquare.C4;

            RookBitBoard rookBlack = new RookBitBoard(ChessPieceColors.Black);

            rookBlack.Bits = BoardSquare.A8 | BoardSquare.H8;

            KnightBitBoard knightBlack = new KnightBitBoard(ChessPieceColors.Black);

            knightBlack.Bits = BoardSquare.D4;

            QueenBitBoard queenBlack = new QueenBitBoard(ChessPieceColors.Black);

            queenBlack.Bits = 0;

            KingBitBoard kingBlack = new KingBitBoard(ChessPieceColors.Black);

            kingBlack.Bits = BoardSquare.G8;

            //Update

            lolBoard.Update(pawnWhite);
            lolBoard.Update(knightWhite);
            lolBoard.Update(queenWhite);
            lolBoard.Update(rookWhite);
            lolBoard.Update(bishopWhite);
            lolBoard.Update(kingWhite);
            lolBoard.Update(pawnBlack);
            lolBoard.Update(bishopBlack);
            lolBoard.Update(queenBlack);
            lolBoard.Update(knightBlack);
            lolBoard.Update(kingBlack);

            List <ColoredBitBoard> legalMoves = new List <ColoredBitBoard>();

            legalMoves = MoveGen.GenerateLegalMoves(lolBoard, ChessPieceColors.White);
            ColoredBitBoard bestMove = NegaMax.GetBestMove(lolBoard, 3, ChessPieceColors.White, MoveGen.GenerateLegalMoves, Eval.EvaluateState);
        }
Exemplo n.º 25
0
        private static void anotherIllegalMoveFromMovegen()
        {
            //Winboard winboard = new Winboard();
            ChessBoard lolBoard = new ChessBoard();

            lolBoard.InitializeGame();

            //White
            PawnBitBoard pawnWhite = new PawnBitBoard(ChessPieceColors.White);

            pawnWhite.Bits = BoardSquare.A3 | BoardSquare.C3 | BoardSquare.C4 | BoardSquare.F4 | BoardSquare.G4 | BoardSquare.H3;

            BishopBitBoard bishopWhite = new BishopBitBoard(ChessPieceColors.White);

            bishopWhite.Bits = 0;

            KingBitBoard kingWhite = new KingBitBoard(ChessPieceColors.White);

            kingWhite.Bits = BoardSquare.C2;

            RookBitBoard rookWhite = new RookBitBoard(ChessPieceColors.White);

            rookWhite.Bits = BoardSquare.A1 | BoardSquare.E2;

            KnightBitBoard knightWhite = new KnightBitBoard(ChessPieceColors.White);

            knightWhite.Bits = BoardSquare.B1;

            QueenBitBoard queenWhite = new QueenBitBoard(ChessPieceColors.White);

            queenWhite.Bits = 0;

            //Black
            PawnBitBoard pawnBlack = new PawnBitBoard(ChessPieceColors.Black);

            pawnBlack.Bits = BoardSquare.A7 | BoardSquare.B7 | BoardSquare.C6 | BoardSquare.E7 | BoardSquare.F7 | BoardSquare.G7 | BoardSquare.H7;

            RookBitBoard rookBlack = new RookBitBoard(ChessPieceColors.Black);

            rookBlack.Bits = BoardSquare.D8 | BoardSquare.H8;

            BishopBitBoard bishopBlack = new BishopBitBoard(ChessPieceColors.Black);

            bishopBlack.Bits = BoardSquare.F8;

            QueenBitBoard queenBlack = new QueenBitBoard(ChessPieceColors.Black);

            queenBlack.Bits = BoardSquare.D1;

            KingBitBoard kingBlack = new KingBitBoard(ChessPieceColors.Black);

            kingBlack.Bits = BoardSquare.C8;

            KnightBitBoard knightBlack = new KnightBitBoard(ChessPieceColors.Black);

            knightBlack.Bits = 0;


            //RookBitBoard badMove = new RookBitBoard( ChessPieceColors.Black );
            //badMove.Bits = BoardSquare.B8;
            lolBoard.Update(pawnWhite);
            lolBoard.Update(knightWhite);
            lolBoard.Update(queenWhite);
            lolBoard.Update(rookWhite);
            lolBoard.Update(bishopWhite);
            lolBoard.Update(kingWhite);
            lolBoard.Update(pawnBlack);
            lolBoard.Update(rookBlack);
            lolBoard.Update(bishopBlack);
            lolBoard.Update(queenBlack);
            lolBoard.Update(kingBlack);
            lolBoard.Update(knightBlack);


            ColoredBitBoard bestMove = NegaMax.GetBestMove(lolBoard, 3, ChessPieceColors.White, MoveGen.GenerateLegalMoves, Eval.EvaluateState);
        }