Esempio n. 1
0
        public void TestFindFirstSquareIndexAndFindFirstSquareIndexInternal(long value, int expectedResult)
        {
            var bitboard = new Bitboard(value);

            var firstSquareIndex = bitboard.FindFirstSquareIndex();

            Assert.That(firstSquareIndex, Is.EqualTo(expectedResult));

            var firstSquareIndexInternal = Bitboard.FindFirstSquareIndexInternal((ulong)value);

            Assert.That(firstSquareIndexInternal, Is.EqualTo(expectedResult));
        }
Esempio n. 2
0
        public void TestFindFirstSquareIndexAndFindFirstSquareIndexInternalWhenSingleBitIsSet()
        {
            for (var index = 0; index < ChessConstants.SquareCount; index++)
            {
                var value    = 1L << index;
                var bitboard = new Bitboard(value);

                var firstSquareIndex = bitboard.FindFirstSquareIndex();
                Assert.That(firstSquareIndex, Is.EqualTo(index), "Failed for the bit {0}.", index);

                var firstSquareIndexInternal = Bitboard.FindFirstSquareIndexInternal((ulong)value);
                Assert.That(firstSquareIndexInternal, Is.EqualTo(index), "Failed for the bit {0}.", index);
            }
        }
Esempio n. 3
0
        public void TestFindFirstSquareIndexAndFindFirstSquareIndexInternalWhenNoBitsAreSet()
        {
            Assert.That(Bitboard.NoSquareIndex, Is.LessThan(0));

            const long Value    = 0L;
            var        bitboard = new Bitboard(Value);

            var firstSquareIndex = bitboard.FindFirstSquareIndex();

            Assert.That(firstSquareIndex, Is.EqualTo(Bitboard.NoSquareIndex));

            var firstSquareIndexInternal = Bitboard.FindFirstSquareIndexInternal(Value);

            Assert.That(firstSquareIndexInternal, Is.EqualTo(Bitboard.NoSquareIndex));
        }
        private static Bitboard GetSlidingAttackers(
            int targetSquareIndex,
            Bitboard opponentSlidingPieces,
            Bitboard[] slidingAttacks,
            Bitboard emptySquareBitboard,
            bool findFirstAttackOnly)
        {
            if (!opponentSlidingPieces.IsAny)
            {
                return(Bitboard.None);
            }

            var result = Bitboard.None;

            var slidingAttack          = slidingAttacks[targetSquareIndex];
            var attackingSlidingPieces = slidingAttack & opponentSlidingPieces;

            var currentValue = attackingSlidingPieces.InternalValue;

            while (currentValue != Bitboard.NoneValue)
            {
                var attackerBitboard    = Bitboard.PopFirstSquareBitboardInternal(ref currentValue);
                var attackerSquareIndex = Bitboard.FindFirstSquareIndexInternal(attackerBitboard);
                var connection          = GetConnection(targetSquareIndex, attackerSquareIndex);
                if ((emptySquareBitboard & connection) != connection)
                {
                    continue;
                }

                result |= new Bitboard(attackerBitboard);
                if (findFirstAttackOnly)
                {
                    return(result);
                }
            }

            return(result);
        }