bitboard-attacks.h

Go to the documentation of this file.

// Hoover Chess Utilities / PGN reader
// Copyright (C) 2023-2025  Sami Kiminki
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
#ifndef HOOVER_CHESS_UTILS__PGN_READER__BITBOARD_ATTACKS_H_INCLUDED
#define HOOVER_CHESS_UTILS__PGN_READER__BITBOARD_ATTACKS_H_INCLUDED
 
#include "pgnreader-config.h"
 
#include "chessboard-types.h"
#include "chessboard-types-squareset.h"
 
// the baseline
#include "bitboard-tables.h"
#include "bitboard-attacks-portable.h"
 
#if BITBOARD_TABLES_HAVE_ELEMENTARY
#include "bitboard-attacks-elementary.h"
#endif
 
#if BITBOARD_TABLES_HAVE_BLACK_MAGIC
#include "bitboard-attacks-black-magic.h"
#endif
 
#if BITBOARD_TABLES_HAVE_AARCH64_SVE2_BITPERM
#include "bitboard-attacks-aarch64-sve2-bitperm.h"
#endif
 
#if BITBOARD_TABLES_HAVE_X86_BMI2
#include "bitboard-attacks-x86-bmi2.h"
#endif
 
#if HAVE_X86_AVX512F
#include "bitboard-attacks-x86-avx512f.h"
#endif
 
#include <array>
#include <cinttypes>
 
namespace hoover_chess_utils::pgn_reader
{
 
class Attacks
{
public:
    static inline SquareSet getPawnAttackMask(Square sq, Color pawnColor) noexcept
    {
        static_assert(static_cast<std::uint64_t>(Color::WHITE) == 0U);
        static_assert(static_cast<std::uint64_t>(Color::BLACK) == 8U);
 
        return Attacks_Portable::getPawnAttackMask(sq, pawnColor);
    }
 
    static inline SquareSet getPawnAttackerMask(Square sq, Color pawnColor) noexcept
    {
        static_assert(static_cast<std::uint64_t>(Color::WHITE) == 0U);
        static_assert(static_cast<std::uint64_t>(Color::BLACK) == 8U);
 
        return Attacks_Portable::getPawnAttackerMask(sq, pawnColor);
    }
 
    template <Color pawnColor, bool captureToRight>
    static constexpr inline SquareSet getPawnAttackersMask(SquareSet capturable) noexcept
    {
        return Attacks_Portable::getPawnAttackersMask<pawnColor, captureToRight>(capturable);
    }
 
    static inline SquareSet getKnightAttackMask(Square sq) noexcept
    {
        return Attacks_Portable::getKnightAttackMask(sq);
    }
 
    static inline SquareSet getBishopAttackMask(Square sq, SquareSet occupancyMask) noexcept
    {
#if BITBOARD_TABLES_HAVE_X86_BMI2
        return
            Attacks_BMI2::getBishopAttackMask(sq, occupancyMask);
#elif BITBOARD_TABLES_HAVE_AARCH64_SVE2_BITPERM
        return
            Attacks_AArch64_SVE2_BitPerm::getBishopAttackMask(sq, occupancyMask);
#elif BITBOARD_TABLES_HAVE_BLACK_MAGIC
        return
            Attacks_BlackMagic::getBishopAttackMask(sq, occupancyMask);
#elif BITBOARD_TABLES_HAVE_ELEMENTARY
        return
            Attacks_Elementary_Bitboards::getBishopAttackMask(sq, occupancyMask);
#else
        return
            Attacks_Portable::getBishopAttackMask(sq, occupancyMask);
#endif
    }
 
    static inline SquareSet getRookAttackMask(Square sq, SquareSet occupancyMask) noexcept
    {
#if BITBOARD_TABLES_HAVE_X86_BMI2
        return
            Attacks_BMI2::getRookAttackMask(sq, occupancyMask);
#elif BITBOARD_TABLES_HAVE_AARCH64_SVE2_BITPERM
        return
            Attacks_AArch64_SVE2_BitPerm::getRookAttackMask(sq, occupancyMask);
#elif BITBOARD_TABLES_HAVE_BLACK_MAGIC
        return
            Attacks_BlackMagic::getRookAttackMask(sq, occupancyMask);
#elif BITBOARD_TABLES_HAVE_ELEMENTARY
        return
            Attacks_Elementary_Bitboards::getRookAttackMask(sq, occupancyMask);
#else
        return
            Attacks_Portable::getRookAttackMask(sq, occupancyMask);
#endif
    }
 
    static inline SquareSet getQueenAttackMask(Square sq, SquareSet occupancyMask) noexcept
    {
#if BITBOARD_TABLES_HAVE_X86_BMI2
        return
            Attacks_BMI2::getBishopAttackMask(sq, occupancyMask) |
            Attacks_BMI2::getRookAttackMask(sq, occupancyMask);
#elif BITBOARD_TABLES_HAVE_AARCH64_SVE2_BITPERM
        return
            Attacks_AArch64_SVE2_BitPerm::getQueenAttackMask(sq, occupancyMask);
#elif BITBOARD_TABLES_HAVE_BLACK_MAGIC
        return
            Attacks_BlackMagic::getBishopAttackMask(sq, occupancyMask) |
            Attacks_BlackMagic::getRookAttackMask(sq, occupancyMask);
#elif BITBOARD_TABLES_HAVE_ELEMENTARY
        return
            Attacks_Elementary_Bitboards::getBishopAttackMask(sq, occupancyMask) |
            Attacks_Elementary_Bitboards::getRookAttackMask(sq, occupancyMask);
#else
        return
            Attacks_Portable::getBishopAttackMask(sq, occupancyMask) |
            Attacks_Portable::getRookAttackMask(sq, occupancyMask);
#endif
    }
 
    static inline SquareSet getKingAttackMask(Square sq) noexcept
    {
        return Attacks_Portable::getKingAttackMask(sq);
    }
 
    static inline bool pinCheck(Square src, SquareSet dstBit, Square kingSq, SquareSet pinnedPieces) noexcept
    {
        return ((pinnedPieces & SquareSet { src }) == SquareSet { } ||
                (Intercepts::getPinRestiction<true>(kingSq, src) & dstBit) != SquareSet { });
    }
 
    static inline SquareSet determineAttackers(
        const SquareSet occupancyMask,
        const SquareSet turnColorMask,
        const SquareSet pawns,
        const SquareSet knights,
        const SquareSet bishops,
        const SquareSet rooks,
        const SquareSet kings,
        const Square sq,
        const Color turn) noexcept
    {
        SquareSet attackers { };
 
#if BITBOARD_TABLES_HAVE_AARCH64_SVE2_BITPERM
 
        const auto [ diagHits, horizVertHits ] = Attacks_AArch64_SVE2_BitPerm::getBishopAndRookAttackMasks(
            sq,
            occupancyMask);
 
#else
        // rooks and queens
        const SquareSet horizVertHits { Attacks::getRookAttackMask(sq, occupancyMask) };
 
        // bishops and queens
        const SquareSet diagHits { Attacks::getBishopAttackMask(sq, occupancyMask) };
#endif
        const SquareSet attackers1 { horizVertHits & rooks };
        const SquareSet attackers2 { diagHits & bishops };
 
        // pawn attackers
        const SquareSet attackers3 { Attacks::getPawnAttackMask(sq, turn) & pawns };
 
        // king
        const SquareSet attackers4 { Attacks::getKingAttackMask(sq) & kings };
 
        // knights
        const SquareSet attackers5 { Attacks::getKnightAttackMask(sq) & knights };
 
        attackers = (attackers1 | attackers2 | attackers3 | attackers4 | attackers5) & ~turnColorMask;
 
        return attackers;
    }
 
    static inline void determineCheckersAndPins(
        SquareSet occupancyMask,
        SquareSet turnColorMask,
        SquareSet pawns,
        SquareSet knights,
        SquareSet bishops,
        SquareSet rooks,
        Square epSquare,
        SquareSet epCapturable,
        Square kingSq,
        Color turn,
        SquareSet &out_checkers,
        SquareSet &out_pinnedPieces) noexcept
    {
 
#if 0 && HAVE_X86_AVX512F // quite a lot slower than the PDEP/PEXT implementation on Zen4, so disable for now
        Attacks_AVX512F::determineSliderCheckersAndPins(
            occupancyMask,
            turnColorMask,
            bishops,
            rooks,
            epCapturable,
            kingSq,
            out_checkers,
            out_pinnedPieces);
 
        const SquareSet opponentPieces { occupancyMask &~ turnColorMask };
 
        // pawn checkers
        out_checkers |= Attacks::getPawnAttackMask(kingSq, turn) & pawns;
 
        // knights
        out_checkers |= Attacks::getKnightAttackMask(kingSq) & knights;
 
        out_checkers &= opponentPieces;
 
#else
        const SquareSet opponentPieces { occupancyMask ^ turnColorMask };
        SquareSet pinners { };
 
#if HAVE_AARCH64_SVE2_BITPERM && 0 // Somewhat slower on Neoverse V2, so disable for now
        if constexpr (false)
        {
            Attacks_AArch64_SVE2_BitPerm::determineSliderCheckersAndPinners(
                kingSq,
                occupancyMask,
                rooks,
                bishops,
                opponentPieces,
                epCapturable,
                out_checkers,
                pinners);
 
            // pawn checkers
            out_checkers |= Attacks::getPawnAttackMask(kingSq, turn) & pawns;
 
            // knights
            out_checkers |= Attacks::getKnightAttackMask(kingSq) & knights;
 
            out_checkers &= opponentPieces;
        }
        else
        {
            // rooks and queens
            const auto [ firstDiagHits, firstHVHits ] =
                Attacks_AArch64_SVE2_BitPerm::getBishopAndRookAttackMasks(
                    kingSq,
                    occupancyMask);
 
            // pawn checkers
            out_checkers = Attacks::getPawnAttackMask(kingSq, turn) & pawns;
 
            // bishops and queens
            out_checkers |= firstDiagHits & bishops;
 
            // rooks and queens
            out_checkers |= firstHVHits & rooks;
 
            // Resolve pinned pieces. Notes:
            // - We'll remove only pinnable pieces from the first hits. The idea is to avoid
            //   x-rays over non-pinnable pieces in order to minimize the number of pinners
            // - In the second hit check, we'll remove pieces that are already determined to be checkers.
            //   The reason is the same as the above.
 
            const auto [ secondDiagHits, secondHVHits ] =
                Attacks_AArch64_SVE2_BitPerm::getBishopAndRookAttackMasks(
                    kingSq,
                    (occupancyMask &~ firstDiagHits) | (opponentPieces &~ epCapturable),
                    (occupancyMask &~ firstHVHits) | opponentPieces);
 
            // knights
            out_checkers |= Attacks::getKnightAttackMask(kingSq) & knights;
 
            out_checkers &= opponentPieces;
 
            pinners = ((rooks & secondHVHits) | (bishops & secondDiagHits)) & opponentPieces &~ out_checkers;
        }
#else
        {
            // pawn checkers
            out_checkers = Attacks::getPawnAttackMask(kingSq, turn) & pawns;
 
            // knights
            out_checkers |= Attacks::getKnightAttackMask(kingSq) & knights;
 
            // rooks and queens
            const SquareSet firstHVHits { Attacks::getRookAttackMask(kingSq, occupancyMask) };
            out_checkers |= firstHVHits & rooks;
 
            // bishops and queens
            const SquareSet firstDiagHits { Attacks::getBishopAttackMask(kingSq, occupancyMask) };
            out_checkers |= firstDiagHits & bishops;
 
            out_checkers &= opponentPieces;
 
            // Resolve pinned pieces. Notes:
            // - We'll remove only pinnable pieces from the first hits. The idea is to avoid
            //   x-rays over non-pinnable pieces in order to minimize the number of pinners
            // - In the second hit check, we'll remove pieces that are already determined to be checkers.
            //   The reason is the same as the above.
            const SquareSet secondHVHits {
                Attacks::getRookAttackMask(kingSq, (occupancyMask &~ firstHVHits) | opponentPieces) };
            const SquareSet secondDiagHits {
                Attacks::getBishopAttackMask(kingSq, (occupancyMask &~ firstDiagHits) | (opponentPieces &~ epCapturable)) };
 
            pinners = ((rooks & secondHVHits) | (bishops & secondDiagHits)) & opponentPieces &~ out_checkers;
        }
#endif
        out_pinnedPieces = SquareSet { };
        SQUARESET_ENUMERATE(
            pinner,
            pinners,
            {
                SquareSet inBetween { Intercepts::getInterceptSquares(kingSq, pinner) };
                out_pinnedPieces |= inBetween & (turnColorMask | epCapturable);
            });
#endif
        // The rest of this function is EP capture legality checking. Short-circuit if there's no EP to capture
        if (epCapturable == SquareSet { })
            return;
 
        // If we're in check and the only checker is not the EP pawn, EP capture
        // is not legal
        if ((out_checkers &~ epCapturable) != SquareSet { })
            out_pinnedPieces |= epCapturable;
 
        // If not marked illegal yet, check whether the EP capture is legal.
        if ((epCapturable &~ out_pinnedPieces) != SquareSet { })
        {
            // Adjacent pawns. This leaves one pawn in case there's
            // adjacent pawns both sides.
            const SquareSet adjacentPawns {
                ((((epCapturable & ~SquareSet::column(0U)) >> 1U) |
                  ((epCapturable & ~SquareSet::column(7U)) << 1U))
 
                 & pawns & turnColorMask)
            };
 
            // If all (usually 1) adjacent pawns are pinned and can't capture
            // along the pin direction, mark the EP pawn pinned, too. Capture is
            // not legal.
            SquareSet epCaptureLegalMask { };
            SQUARESET_ENUMERATE(
                epCapturer,
                adjacentPawns,
                {
                    if (pinCheck(epCapturer, SquareSet { epSquare }, kingSq, out_pinnedPieces))
                        epCaptureLegalMask = SquareSet::all();
                });
 
            // add EP capturable to pinned if neither capture is legal
            out_pinnedPieces |= epCapturable &~ epCaptureLegalMask;
 
            // Check whether the EP capturable pawn is horizontally pinned. This can only happen
            // when the king is on the same row
            if ((epCapturable & (SquareSet::row(0U) << (static_cast<std::uint64_t>(kingSq) & 56U)))
                != SquareSet { })
            {
                const SquareSet adjacentPawnsMinus1 { adjacentPawns.removeFirstSquare() };
 
                const SquareSet exposedHorizLine {
                    Attacks_Portable::getHorizRookAttackMask(
                        epCapturable.firstSquare(),
                        occupancyMask &~ (adjacentPawns &~ adjacentPawnsMinus1)) };
 
                const SquareSet kingBit { kingSq };
                const SquareSet oppRooks { rooks & ~turnColorMask };
 
                const SquareSet pinnedEp { epCapturable &
                    (kingBit & exposedHorizLine).allIfAny() &
                    (oppRooks & exposedHorizLine).allIfAny() };
 
                // add the EP pawn in pinned pieces if capturing it would
                // horizontally expose the king to a rook
                out_pinnedPieces |= pinnedEp;
            }
        }
    }
 
    static inline SquareSet determineAttackedSquares(
        SquareSet occupancyMask,
        SquareSet pawns,
        SquareSet knights,
        SquareSet bishops,
        SquareSet rooks,
        Square king,
        Color turn) noexcept
    {
#if HAVE_X86_AVX512F
        return Attacks_AVX512F::determineAttackedSquares(
            occupancyMask,
            pawns,
            knights,
            bishops,
            rooks,
            king,
            turn);
#else
        SquareSet attacks { };
 
        // pawn attacks
        static_assert(static_cast<std::int8_t>(Color::WHITE) == 0);
        static_assert(static_cast<std::int8_t>(Color::BLACK) == 8);
 
        // for rotl -- pawn color is opposite to turn
        std::int8_t pawnAdvanceShiftLeft = -9 + 2 * static_cast<std::int8_t>(turn);
 
        // captures to left
        attacks |= (pawns &~ SquareSet::column(0)).rotl(pawnAdvanceShiftLeft);
 
        // captures to right
        attacks |= (pawns &~ SquareSet::column(7)).rotl(pawnAdvanceShiftLeft + 2);
 
 
        SQUARESET_ENUMERATE(
            piece,
            knights,
            attacks |= getKnightAttackMask(piece));
 
        SQUARESET_ENUMERATE(
            piece,
            bishops,
            attacks |= getBishopAttackMask(piece, occupancyMask));
 
        SQUARESET_ENUMERATE(
            piece,
            rooks,
            attacks |= getRookAttackMask(piece, occupancyMask));
 
        attacks |= getKingAttackMask(king);
 
        return attacks;
#endif
    }
};
 
}
 
#endif