Пример #1
0
        public void RookPosition4()
        {
            var coords = Square.H1;

            string otherFiguresBoard =
                "00100001" +
                "10001001" +
                "00000001" +
                "00001010" +
                "00000000" +
                "10000000" +
                "00010000" +
                "10100000";

            string resultBoard =
                "00000000" +
                "00000000" +
                "00000001" +
                "00000001" +
                "00000001" +
                "00000001" +
                "00000001" +
                "00111110";

            ulong otherFigures = BitBoardHelper.FromString(otherFiguresBoard);
            ulong result       = BitBoardHelper.FromString(resultBoard);

            Assert.AreEqual(result,
                            provider.GetAttacks(coords, otherFigures));
        }
Пример #2
0
        public void FromStringComplexTest()
        {
            int count = 100;
            var rand  = new Random(DateTime.Now.Millisecond);

            while ((count--) > 0)
            {
                var board = new BitBoard();
                var str   = new StringBuilder(64);
                str.Append('0', 64);

                var indices = GetRandomBits(rand.Next(64));
                foreach (var point in indices)
                {
                    board.SetBit((Square)(point.Item1 * 8 + point.Item2));

                    int index = (7 - point.Item1) * 8 + point.Item2;
                    str[index] = '1';
                }

                Assert.AreEqual(
                    board.GetInnerValue(),
                    BitBoardHelper.FromString(str.ToString()));
            }
        }
Пример #3
0
        public void TestDoubleUpPush()
        {
            string boardString =
                "00000000" +
                "00000000" +
                "00000000" +
                "00000000" +
                "00000000" +
                "10000010" +
                "00101000" +
                "00000000";

            var board = new PawnBitBoard(BitBoardHelper.FromString(boardString));

            string moves =
                "00000000" +
                "00000000" +
                "00000000" +
                "00000000" +
                "00101000" +
                "00000000" +
                "00000000" +
                "00000000";

            ulong movesBoard   = BitBoardHelper.FromString(moves);
            ulong emptySquares = 0;

            emptySquares = ~emptySquares;

            var attacks = board.DoubleUpPushTargets(emptySquares);

            Assert.AreEqual(movesBoard, attacks);
        }
Пример #4
0
        public void TestUpRightAttacks()
        {
            string boardString =
                "00000000" +
                "00000000" +
                "00000000" +
                "00000000" +
                "00000000" +
                "10000010" +
                "00101000" +
                "00000000";

            var board = new PawnBitBoard(BitBoardHelper.FromString(boardString));

            string moves =
                "00000000" +
                "00000000" +
                "00000000" +
                "00000000" +
                "01000001" +
                "00010100" +
                "00000000" +
                "00000000";

            ulong movesBoard   = BitBoardHelper.FromString(moves);
            ulong emptySquares = 0;

            emptySquares = ~emptySquares;

            var attacks = board.NorthEastAttacks();

            Assert.AreEqual(movesBoard, attacks);
        }
Пример #5
0
        public void AttacksTest3()
        {
            string boardString =
                "00000000" +
                "00000000" +
                "00000000" +
                "00000000" +
                "00000000" +
                "00000000" +
                "00000000" +
                "00000000";

            ulong board  = BitBoardHelper.FromString(boardString);
            var   coords = Square.C4;

            string moves =
                "00100010" +
                "00100100" +
                "10101000" +
                "01110000" +
                "11011111" +
                "01110000" +
                "10101000" +
                "00100100";

            ulong movesBoard = BitBoardHelper.FromString(moves);
            var   attacks    = provider.GetAttacks(coords, board);

            Assert.AreEqual(movesBoard, attacks);
        }
Пример #6
0
        public void TestDoubleUpPushes()
        {
            string boardString =
                "00000000" +
                "00000000" +
                "00000000" +
                "00000000" +
                "01011100" +
                "00000000" +
                "00000000" +
                "00000000";
            //	 abcdefgh
            int   rankIndex = 3;
            ulong board     = BitBoardHelper.FromString(boardString);
            byte  rank      = (byte)(board >> (rankIndex * 8) & 0xff);
            var   realMoves = new Move[] {
                new Move(Square.B2, Square.B4),
                new Move(Square.D2, Square.D4),
                new Move(Square.E2, Square.E4),
                new Move(Square.F2, Square.F4)
            };

            var moves = PawnBitBoardHelper.DoublePushes[0][rankIndex][rank];

            Assert.IsTrue(this.AreMovesEqual(realMoves, moves));
        }
Пример #7
0
        public void TestSingleDownPushes1()
        {
            string boardString =
                "00000000" +
                "00000000" +
                "00000000" +
                "00000000" +
                "00000000" +
                "01011100" +
                "00000000" +
                "00000000";
            //	 abcdefgh
            int   rankIndex = 2;
            ulong board     = BitBoardHelper.FromString(boardString);
            byte  rank      = (byte)(board >> (rankIndex * 8) & 0xff);
            var   realMoves = new Move[] {
                new Move(Square.B4, Square.B3),
                new Move(Square.D4, Square.D3),
                new Move(Square.E4, Square.E3),
                new Move(Square.F4, Square.F3)
            };

            var moves = PawnBitBoardHelper.QuietMoves[1][rankIndex][rank];

            Assert.IsTrue(this.AreMovesEqual(realMoves, moves));
        }
Пример #8
0
        public void TestDiagonalMoves4()
        {
            string boardString =
                "00000000" +
                "00001000" +
                "00000001" +
                "00010010" +
                "10100100" +
                "00000001" +
                "00011000" +
                "10100011";

            ulong board  = BitBoardHelper.FromString(boardString);
            var   coords = Square.E3;

            string moves =
                "00000000" +
                "00000000" +
                "00000000" +
                "00000000" +
                "00000100" +
                "00000000" +
                "00010000" +
                "00000000";
            ulong movesBoard      = BitBoardHelper.FromString(moves);
            var   diagonalAttacks = provider.DiagonalAttacks(coords, board);

            Assert.AreEqual(movesBoard, diagonalAttacks);
        }
Пример #9
0
        public void TestAntiDiagonalMoves3()
        {
            string boardString =
                "00000000" +
                "00000000" +
                "00000000" +
                "00000000" +
                "00000000" +
                "00000000" +
                "00000000" +
                "00000000";

            ulong board  = BitBoardHelper.FromString(boardString);
            var   coords = Square.H8;

            string moves =
                "00000000" +
                "00000000" +
                "00000000" +
                "00000000" +
                "00000000" +
                "00000000" +
                "00000000" +
                "00000000";

            ulong movesBoard          = BitBoardHelper.FromString(moves);
            var   antiDiagonalAttacks = provider.AntiDiagonalAttacks(coords, board);

            Assert.AreEqual(movesBoard, antiDiagonalAttacks);
        }
Пример #10
0
        public void TestSingleUpLeftAttacks1()
        {
            string boardString =
                "00000000" +
                "00000000" +
                "00000000" +
                "00000000" +
                "00000000" +
                "01011100" +
                "00000000" +
                "00000000";
            //	 abcdefgh
            int   rankIndex = 2;
            ulong board     = BitBoardHelper.FromString(boardString);
            byte  rank      = (byte)(board >> (rankIndex * 8) & 0xff);
            var   realMoves = new Move[] {
                new Move(Square.C2, Square.B3),
                new Move(Square.E2, Square.D3),
                new Move(Square.F2, Square.E3),
                new Move(Square.G2, Square.F3)
            };

            var moves = PawnBitBoardHelper.AttacksLeftMoves[0][rankIndex][rank];

            Assert.IsTrue(this.AreMovesEqual(realMoves, moves));
        }
Пример #11
0
        public void TestReverseUlong()
        {
            int count = 10000;

            while ((count--) > 0)
            {
                string str        = Get64CharsString();
                ulong  board      = BitBoardHelper.FromString(str);
                ulong  reversed   = Int64Helper.GetReversedUlong(board);
                ulong  rereversed = Int64Helper.GetReversedUlong(reversed);

                Assert.AreEqual(str.MyReverse(), BitBoardHelper.ToString(reversed, string.Empty).LJust(64, '0'));
                Assert.AreEqual(board, rereversed);
            }
        }
Пример #12
0
        public void KnightTest5()
        {
            string knightAttacksBoard =
                "00000000" +
                "00000101" +
                "00001000" +
                "00000000" +
                "00001000" +
                "00000101" +
                "00000000" +
                "00000000";
            ulong attacks = BitBoardHelper.FromString(knightAttacksBoard);

            Assert.AreEqual(attacks, provider.GetAttacks(Square.G5, 0));
        }
Пример #13
0
        public void TestFileToRank3()
        {
            string boardString =
                "10000000" +
                "00000000" +
                "00000000" +
                "00000000" +
                "00000000" +
                "00000000" +
                "00000000" +
                "00000000";
            byte  b     = Convert.ToByte("00000001", 2);
            ulong board = BitBoardHelper.FromString(boardString);

            Assert.AreEqual(b, BitBoardHelper.GetRankFromAFile(board));
        }
Пример #14
0
        public void FromStringTest()
        {
            string boardString =
                "00000000" +
                "00101110" +
                "00001000" +
                "00010000" +
                "00010000" +
                "01000000" +
                "00100010" +
                "00100010";

            var board     = BitBoardHelper.FromString(boardString);
            var newString = BitBoardHelper.ToString(board, string.Empty);

            Assert.AreEqual(boardString, newString);
        }
Пример #15
0
        public void TestSingleDownPushes2()
        {
            string boardString =
                "01000001" +
                "00000000" +
                "00000000" +
                "00000000" +
                "00000000" +
                "00000000" +
                "00000000" +
                "00000000";
            //	 abcdefgh
            int   rankIndex = 7;
            ulong board     = BitBoardHelper.FromString(boardString);
            byte  rank      = (byte)(board >> (rankIndex * 8) & 0xff);

            var moves = PawnBitBoardHelper.QuietMoves[1][rankIndex][rank];

            Assert.IsTrue(moves.Length == 0);
        }
Пример #16
0
        public void TestSingleUpRightAttacks2()
        {
            string boardString =
                "00000000" +
                "00000000" +
                "00000000" +
                "00000000" +
                "00000000" +
                "00000000" +
                "00000000" +
                "10000000";
            //	 abcdefgh
            int   rankIndex = 0;
            ulong board     = BitBoardHelper.FromString(boardString);
            byte  rank      = (byte)(board >> (rankIndex * 8) & 0xff);

            var moves = PawnBitBoardHelper.AttacksRightMoves[0][rankIndex][rank];

            Assert.IsTrue(moves.Length == 0);
        }
Пример #17
0
        public void TestDiagonalMoves1()
        {
            var   boardString = BitBoardHelper.GetEmptyBoardString();
            ulong board       = BitBoardHelper.FromString(boardString);
            var   coords      = Square.A1;

            string moves =
                "00000001" +
                "00000010" +
                "00000100" +
                "00001000" +
                "00010000" +
                "00100000" +
                "01000000" +
                "00000000";
            ulong movesBoard      = BitBoardHelper.FromString(moves);
            var   diagonalAttacks = provider.DiagonalAttacks(coords, board);

            Assert.AreEqual(movesBoard, diagonalAttacks);
        }
Пример #18
0
        public void ClearPosition3()
        {
            var coords = Square.H3;

            string otherFiguresBoard = BitBoardHelper.GetEmptyBoardString();

            string resultBoard =
                "00000001" +
                "00000001" +
                "00000001" +
                "00000001" +
                "00000001" +
                "11111110" +
                "00000001" +
                "00000001";

            ulong otherFigures = BitBoardHelper.FromString(otherFiguresBoard);
            ulong result       = BitBoardHelper.FromString(resultBoard);

            Assert.AreEqual(result,
                            provider.GetAttacks(coords, otherFigures));
        }
Пример #19
0
        public void TestSingleUpPushes2()
        {
            string boardString =
                "01000001" +
                "00000000" +
                "00000000" +
                "00000000" +
                "00000000" +
                "00000000" +
                "00000000" +
                "00000000";
            //	 abcdefgh
            int   rankIndex = 7;
            ulong board     = BitBoardHelper.FromString(boardString);
            byte  rank      = (byte)(board >> (rankIndex * 8) & 0xff);
            var   realMoves = new Move[] {
                new Move(Square.B7, Square.B8),
                new Move(Square.H7, Square.H8)
            };

            var moves = PawnBitBoardHelper.QuietMoves[0][rankIndex][rank];

            Assert.IsTrue(this.AreMovesEqual(realMoves, moves));
        }