Example #1
0
        public void BlackBishopMoved2SW_Undo_Test()
        {
            ChessBoard testBoard = new ChessBoard();

            testBoard.InitializeGame();
            PawnBitBoard movePawn      = new PawnBitBoard(ChessPieceColors.Black);
            PawnBitBoard moveWhitePawn = new PawnBitBoard(ChessPieceColors.White);

            movePawn.Bits = (testBoard.BlackPawn.Bits ^ BoardSquare.B7) | BoardSquare.B6;
            ulong expectedHash = testBoard.BoardHash.Key;

            testBoard.Update(movePawn);
            testBoard.Undo();
            ulong actualHash = testBoard.BoardHash.Key;

            Assert.Equal(expectedHash, actualHash);
            testBoard.Update(movePawn);

            moveWhitePawn.Bits = (testBoard.WhitePawn.Bits ^ BoardSquare.H2) | BoardSquare.H3;
            expectedHash       = testBoard.BoardHash.Key;
            testBoard.Update(moveWhitePawn);
            testBoard.Undo();
            actualHash = testBoard.BoardHash.Key;
            Assert.Equal(expectedHash, actualHash);
            testBoard.Update(moveWhitePawn);

            BishopBitBoard moveBishop = new BishopBitBoard(ChessPieceColors.Black);

            moveBishop.Bits = (testBoard.BlackBishop.Bits ^ BoardSquare.C8) | BoardSquare.A6;
            expectedHash    = testBoard.BoardHash.Key;
            testBoard.Update(moveBishop);
            testBoard.Undo();
            actualHash = testBoard.BoardHash.Key;
            Assert.Equal(expectedHash, actualHash);
        }
Example #2
0
        private static BishopBitBoard ComputeBlackBishop(BishopBitBoard inputBishopBB, BitBoard blackPieces, BitBoard allPieces)
        {
            BishopBitBoard result = new BishopBitBoard(ChessPieceColors.Black);

            result.Bits  = Magic.getMagicMoves(inputBishopBB.Bits, allPieces.Bits, false);
            result.Bits &= ~blackPieces.Bits;
            return(result);
        }
        public void Initialize_IsBlackCorrectPlaced_Equal()
        {
            ulong          correctPlacement = 0x2400000000000000;
            BishopBitBoard board            = new BishopBitBoard(ChessPieceColors.Black);

            board.Initialize(null);

            Assert.Equal(correctPlacement, (ulong)board.Bits);
        }
Example #4
0
        public void WhiteBishopMoved2SE_Undo_Test()
        {
            ChessBoard testBoard = new ChessBoard();

            testBoard.InitializeGame();
            PawnBitBoard movePawn = new PawnBitBoard(ChessPieceColors.White);

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

            ulong expectedHash = testBoard.BoardHash.Key;

            testBoard.Update(movePawn);
            testBoard.Undo();
            ulong actualHash = testBoard.BoardHash.Key;

            Assert.Equal(expectedHash, actualHash);
            testBoard.Update(movePawn);

            moveBlackPawn1.Bits = (testBoard.BlackPawn.Bits ^ BoardSquare.H7) | BoardSquare.H6;
            expectedHash        = testBoard.BoardHash.Key;
            testBoard.Update(moveBlackPawn1);
            testBoard.Undo();
            actualHash = testBoard.BoardHash.Key;
            Assert.Equal(expectedHash, actualHash);
            testBoard.Update(moveBlackPawn1);

            BishopBitBoard moveBishop1 = new BishopBitBoard(ChessPieceColors.White);

            moveBishop1.Bits = (testBoard.WhiteBishop.Bits ^ BoardSquare.C1) | BoardSquare.A3;
            expectedHash     = testBoard.BoardHash.Key;
            testBoard.Update(moveBishop1);
            testBoard.Undo();
            actualHash = testBoard.BoardHash.Key;
            Assert.Equal(expectedHash, actualHash);
            testBoard.Update(moveBishop1);

            moveBlackPawn1.Bits = (testBoard.BlackPawn.Bits ^ BoardSquare.H6) | BoardSquare.H5;
            expectedHash        = testBoard.BoardHash.Key;
            testBoard.Update(moveBlackPawn1);
            testBoard.Undo();
            actualHash = testBoard.BoardHash.Key;
            Assert.Equal(expectedHash, actualHash);
            testBoard.Update(moveBlackPawn1);

            BishopBitBoard moveBishop2 = new BishopBitBoard(ChessPieceColors.White);

            moveBishop2.Bits = (moveBishop1.Bits ^ BoardSquare.A3) | BoardSquare.C1;
            expectedHash     = testBoard.BoardHash.Key;
            testBoard.Update(moveBishop2);
            testBoard.Undo();
            actualHash = testBoard.BoardHash.Key;
            Assert.Equal(expectedHash, actualHash);
        }
Example #5
0
        public static List <BishopBitBoard> BishopBitBoardResults(ChessBoard inputChessBoard, ChessPieceColors color, BitBoard blackPieces, BitBoard whitePieces, BitBoard allPieces)
        {
            List <BishopBitBoard> result = new List <BishopBitBoard>();
            List <Tuple <BishopBitBoard, BishopBitBoard> > legalBishopMoves = new List <Tuple <BishopBitBoard, BishopBitBoard> >();
            List <BishopBitBoard> sepBishopsInput  = new List <BishopBitBoard>();
            List <BishopBitBoard> sepBishopsOutput = new List <BishopBitBoard>();

            if (color == ChessPieceColors.White)
            {
                sepBishopsInput = ColoredBitBoard.SplitBitBoard(inputChessBoard.WhiteBishop).ToList();
                foreach (BishopBitBoard sepBishopBB in sepBishopsInput)
                {
                    legalBishopMoves.Add(new Tuple <BishopBitBoard, BishopBitBoard>(sepBishopBB, ComputeWhiteBishop(sepBishopBB, whitePieces, allPieces)));
                }
                for (int i = 0; i < legalBishopMoves.Count; i++)
                {
                    sepBishopsOutput = ColoredBitBoard.SplitBitBoard(legalBishopMoves[i].Item2).ToList();
                    foreach (BishopBitBoard sepBishopOutBB in sepBishopsOutput)
                    {
                        BishopBitBoard boardResult = new BishopBitBoard(color);
                        boardResult.Bits = (inputChessBoard.WhiteBishop.Bits ^ legalBishopMoves[i].Item1.Bits) | sepBishopOutBB.Bits;
                        result.Add(boardResult);
                    }
                }
            }
            else
            {
                sepBishopsInput = ColoredBitBoard.SplitBitBoard(inputChessBoard.BlackBishop).ToList();
                foreach (BishopBitBoard sepBishopBB in sepBishopsInput)
                {
                    legalBishopMoves.Add(new Tuple <BishopBitBoard, BishopBitBoard>(sepBishopBB, ComputeBlackBishop(sepBishopBB, blackPieces, allPieces)));
                }
                for (int i = 0; i < legalBishopMoves.Count; i++)
                {
                    sepBishopsOutput = ColoredBitBoard.SplitBitBoard(legalBishopMoves[i].Item2).ToList();
                    foreach (BishopBitBoard sepBishopOutBB in sepBishopsOutput)
                    {
                        BishopBitBoard boardResult = new BishopBitBoard(color);
                        boardResult.Bits = (inputChessBoard.BlackBishop.Bits ^ legalBishopMoves[i].Item1.Bits) | sepBishopOutBB.Bits;
                        result.Add(boardResult);
                    }
                }
            }
            return(result);
        }
Example #6
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);
        }
Example #7
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);
        }
Example #8
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);
        }
Example #9
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());
        }
Example #10
0
 public static BishopBitBoard ComputeBlackBishop_Test(BishopBitBoard inputBishopBB, ChessBoard inputChessBoard, BitBoard blackPieces, BitBoard whitePieces, BitBoard allPieces)
 {
     return(ComputeBlackBishop(inputBishopBB, blackPieces, allPieces));
 }
Example #11
0
        /*  private static void WinBoardCastlingFAIL( ChessBoard chessBoard, ChessPieceColors winboardColor ) {
         *  _winboardConverter = new StringBitboardConverter( chessBoard, winboardColor );
         *  ColoredBitBoard bitBoardMoveRecived = _winboardConverter.ConvertStringMoveToBitBoard( "E8G8" );
         *  chessBoard.Update( bitBoardMoveRecived );
         * }*/
        private static void FAILFAILtest()
        {
            ChessBoard lolboard = new ChessBoard();

            lolboard.InitializeGame();

            PawnBitBoard pawnWhite = new PawnBitBoard(ChessPieceColors.White);

            pawnWhite.Bits = BoardSquare.E4 | BoardSquare.B2 | BoardSquare.C2 | BoardSquare.D2 | BoardSquare.H2 | BoardSquare.G2 | BoardSquare.F2 | BoardSquare.A2;
            lolboard.Update(pawnWhite);

            PawnBitBoard pawnBlack = new PawnBitBoard(ChessPieceColors.Black);

            pawnBlack.Bits = BoardSquare.A7 | BoardSquare.B7 | BoardSquare.C7 | BoardSquare.D7 | BoardSquare.E5 | BoardSquare.F7 | BoardSquare.G7 | BoardSquare.H7;
            lolboard.Update(pawnBlack);

            KnightBitBoard lilleKnejtWhite = new KnightBitBoard(ChessPieceColors.White);

            lilleKnejtWhite.Bits = BoardSquare.C3 | BoardSquare.G1;
            lolboard.Update(lilleKnejtWhite);

            KnightBitBoard lilleKnejtBlack = new KnightBitBoard(ChessPieceColors.Black);

            lilleKnejtBlack.Bits = BoardSquare.C6 | BoardSquare.G8;
            lolboard.Update(lilleKnejtBlack);

            KnightBitBoard lilleKnejtWhitenummer2 = new KnightBitBoard(ChessPieceColors.White);

            lilleKnejtWhitenummer2.Bits = BoardSquare.C3 | BoardSquare.F3;
            lolboard.Update(lilleKnejtWhitenummer2);

            PawnBitBoard pawnBlacknummerto = new PawnBitBoard(ChessPieceColors.Black);

            pawnBlacknummerto.Bits = BoardSquare.A7 | BoardSquare.B7 | BoardSquare.C7 | BoardSquare.D5 | BoardSquare.E5 | BoardSquare.F7 | BoardSquare.G7 | BoardSquare.H7;
            lolboard.Update(pawnBlacknummerto);
            //INGEN FEJL!
            PawnBitBoard pawnWhitenummerto = new PawnBitBoard(ChessPieceColors.White);

            pawnWhitenummerto.Bits = BoardSquare.A2 | BoardSquare.B2 | BoardSquare.C2 | BoardSquare.D2 | BoardSquare.D5 | BoardSquare.G2 | BoardSquare.F2 | BoardSquare.H2;
            lolboard.Update(pawnWhitenummerto);
            //MÃ¥ske fejl?
            KnightBitBoard lilleKnejtBlacknummerto = new KnightBitBoard(ChessPieceColors.Black);

            lilleKnejtBlacknummerto.Bits = BoardSquare.B4 | BoardSquare.G8;
            lolboard.Update(lilleKnejtBlacknummerto);

            KnightBitBoard lilleKnejtWhitenummer3 = new KnightBitBoard(ChessPieceColors.White);

            lilleKnejtWhitenummer3.Bits = BoardSquare.C3 | BoardSquare.E5;
            lolboard.Update(lilleKnejtWhitenummer3);

            KnightBitBoard lilleKnejtBlacknummertre = new KnightBitBoard(ChessPieceColors.Black);

            lilleKnejtBlacknummertre.Bits = BoardSquare.B4 | BoardSquare.F6;
            lolboard.Update(lilleKnejtBlacknummertre);

            BishopBitBoard lillebishopruner = new BishopBitBoard(ChessPieceColors.White);

            lillebishopruner.Bits = BoardSquare.C1 | BoardSquare.B5;
            lolboard.Update(lillebishopruner);



            ColoredBitBoard bestMove = NegaMax.GetBestMove(lolboard, 2, ChessPieceColors.Black, MoveGen.GenerateLegalMoves, Eval.EvaluateState);
        }
Example #12
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());
        }
Example #13
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);
        }
Example #14
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);
        }
Example #15
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);
        }
Example #16
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);
        }
Example #17
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);
        }