Ejemplo n.º 1
0
        public void GeneratesCorrectBishopMasksForSquares(Square square, ulong expectedMask)
        {
            // Act
            Bitboard mask = MagicGenerator.BishopMask(square);

            // Assert
            Assert.Equal <Bitboard>(expectedMask, mask);
        }
Ejemplo n.º 2
0
        public void CanLoadMagicsFromEmbeddedResource()
        {
            // Act
            var magics = MagicGenerator.LoadMagics();

            // Assert
            magics.Should().HaveCount(128);
        }
Ejemplo n.º 3
0
        public void CanFindAMagicNumberForASquare()
        {
            // Act
            (Bitboard magic, int bitCount) = MagicGenerator.FindMagic(Square.a1, 100_000_000, Piece.Rook);

            // Assert
            Assert.NotEqual <Bitboard>(0, magic);
            Assert.NotEqual(0, bitCount);
        }
Ejemplo n.º 4
0
        private Storage.MagicBitboard[] GetMagicBitboards()
        {
            var generator = new MagicGenerator();
            var rv        = new Storage.MagicBitboard[64];

            for (var index = 0; index < 64; index++)
            {
                var obstructionBoard = MoveObstructionBoards[index];
                rv[index] = generator.GenerateMagicKey(obstructionBoard);
            }

            return(rv);
        }
Ejemplo n.º 5
0
        static void Main(string[] args)
        {
            if (args.Contains("--generateMagics"))
            {
                string targetFile = Path.Combine(Environment.CurrentDirectory, "magics.txt");
                MagicGenerator.GenerateMagicsToFile(targetFile);
                return;
            }

            var listener = new UciListener();

            listener.Run();
        }
Ejemplo n.º 6
0
        public void GetAllOccupanciesReturnsCorrectBitboards()
        {
            // Assemble
            Bitboard mask = 0x00_00_40_20_10_08_04_00; // Bishop on b1

            // Act
            Bitboard[] occupancies = MagicGenerator.GetAllPossibleOccupanciesForMask(mask);

            // Assert
            Bitboard[] expectedOccs = new Bitboard[]
            {
                0x00_00_00_00_00_00_00_00,
                0x00_00_00_00_00_00_04_00,
                0x00_00_00_00_00_08_00_00,
                0x00_00_00_00_00_08_04_00,
                0x00_00_00_00_10_00_00_00,
                0x00_00_00_00_10_00_04_00,
                0x00_00_00_00_10_08_00_00,
                0x00_00_00_00_10_08_04_00,
                0x00_00_00_20_00_00_00_00,
                0x00_00_00_20_00_00_04_00,
                0x00_00_00_20_00_08_00_00,
                0x00_00_00_20_00_08_04_00,
                0x00_00_00_20_10_00_00_00,
                0x00_00_00_20_10_00_04_00,
                0x00_00_00_20_10_08_00_00,
                0x00_00_00_20_10_08_04_00,
                0x00_00_40_00_00_00_00_00,
                0x00_00_40_00_00_00_04_00,
                0x00_00_40_00_00_08_00_00,
                0x00_00_40_00_00_08_04_00,
                0x00_00_40_00_10_00_00_00,
                0x00_00_40_00_10_00_04_00,
                0x00_00_40_00_10_08_00_00,
                0x00_00_40_00_10_08_04_00,
                0x00_00_40_20_00_00_00_00,
                0x00_00_40_20_00_00_04_00,
                0x00_00_40_20_00_08_00_00,
                0x00_00_40_20_00_08_04_00,
                0x00_00_40_20_10_00_00_00,
                0x00_00_40_20_10_00_04_00,
                0x00_00_40_20_10_08_00_00,
                0x00_00_40_20_10_08_04_00,
            };

            occupancies.Should().BeEquivalentTo(expectedOccs);
        }
Ejemplo n.º 7
0
        static SlidingPieceMoves()
        {
            var magics = MagicGenerator.LoadMagics();

            foreach (var magicDetail in magics)
            {
                if (magicDetail.Piece == Piece.Bishop)
                {
                    _bishopMagics[(int)magicDetail.Square]  = magicDetail;
                    _bishopAttacks[(int)magicDetail.Square] = MagicGenerator.CreateAttacksMapForMagic(magicDetail);
                }
                else if (magicDetail.Piece == Piece.Rook)
                {
                    _rookMagics[(int)magicDetail.Square]  = magicDetail;
                    _rookAttacks[(int)magicDetail.Square] = MagicGenerator.CreateAttacksMapForMagic(magicDetail);
                }
            }

            for (int s = 0; s < 64; s++)
            {
                _bishopMasks[s] = MagicGenerator.BishopMask((Square)s);
                _rookMasks[s]   = MagicGenerator.RookMask((Square)s);
            }
        }