move_predicates.h

Go to the documentation of this file.

 
#pragma once
 
#include "scid/core/board.h"
 
#include <cassert>
#include <utility>
 
// These functions use the following move classification:
// - a VALID move is a move that respects the basic rules for moving the pieces,
//   for example a bishop should move diagonally. Validating this type of moves
//   do not require any info about the current position.
// - an ATTACK move is a valid move that can capture an enemy piece at the
//   destination square. It takes into account the special rule for pawns that
//   can capture only diagonally and the board position for obstacles, for
//   example a valid diagonal bishop move is an attack move only if the
//   in-between squares are empty. To validate this type of moves it is
//   necessary to know the location of empty squares in the current position.
// - a PSEUDO-LEGAL move is an attack move, or a non-capture pawn move, or a
//   castle move.
// - a LEGAL move is a pseudo-legal move where the destination square is not
//   occupied by a friendly piece and that do not leave the king in check.
//   To validate this type of moves it is necessary to know the type and
//   position of every piece.
 
namespace scid::core {
 
namespace move_predicates {
 
constexpr int NSQUARES = 8;
constexpr int kWPHomeRank = 1;
constexpr int kBPHomeRank = NSQUARES - 2;
 
inline bool valid_king(squareT sqFrom, squareT sqTo) {
    unsigned distRank = 1 + (sqTo / NSQUARES) - (sqFrom / NSQUARES);
    unsigned distFyle = 1 + (sqTo % NSQUARES) - (sqFrom % NSQUARES);
    return distRank <= 2 && distFyle <= 2;
}
 
inline bool valid_knight(squareT sqFrom, squareT sqTo) {
    int distRank = (sqTo / NSQUARES) - (sqFrom / NSQUARES);
    int distFyle = (sqTo % NSQUARES) - (sqFrom % NSQUARES);
    int distProduct = distRank * distFyle;
    return (distProduct == 2 || distProduct == -2);
}
 
inline int valid_slider(squareT sqFrom, squareT sqTo, pieceT pieceType) {
    assert(pieceType == QUEEN || pieceType == ROOK || pieceType == BISHOP);
 
    int distRank = (sqTo / NSQUARES) - (sqFrom / NSQUARES);
    int distFyle = (sqTo % NSQUARES) - (sqFrom % NSQUARES);
 
    // Make sure the direction is valid:
    int sqStep;
    bool isDiagonal = false;
    if (distRank == 0) {
        sqStep = 1; // horizontal
    } else if (distFyle == 0) {
        sqStep = NSQUARES; // vertical
    } else if (distFyle == distRank) {
        sqStep = NSQUARES + 1;
        isDiagonal = true;
    } else if (distFyle == -distRank) {
        sqStep = NSQUARES - 1;
        isDiagonal = true;
    } else {
        return 0;
    }
    if (pieceType == ROOK && isDiagonal)
        return 0;
    if (pieceType == BISHOP && !isDiagonal)
        return 0;
 
    return sqStep;
}
 
inline bool attack_pawn(squareT sqFrom, squareT sqTo, colorT pieceCol) {
    int distRank = (sqTo / NSQUARES) - (sqFrom / NSQUARES);
    int distFyle = (sqTo % NSQUARES) - (sqFrom % NSQUARES);
    if (pieceCol == WHITE && distRank != 1)
        return false;
    if (pieceCol == BLACK && distRank != -1)
        return false;
 
    return (distFyle == 1 || distFyle == -1);
}
 
template <typename TFunc>
bool attack_slider(squareT sqFrom, squareT sqTo, pieceT pieceType,
                   TFunc isOccupied) {
    int sqStep = valid_slider(sqFrom, sqTo, pieceType);
    if (sqStep == 0)
        return false;
 
    // Make sure all the in-between squares are empty:
    if (sqFrom > sqTo)
        sqStep = -sqStep;
 
    for (int sq = sqFrom + sqStep; sq != sqTo; sq += sqStep) {
        if (isOccupied(sq))
            return false;
    }
 
    return true;
}
 
template <typename TFunc>
bool attack(squareT sqFrom, squareT sqTo, pieceT pieceCol, pieceT pieceType,
            TFunc isOccupied) {
    switch (pieceType) {
    case KING:
        return valid_king(sqFrom, sqTo);
    case KNIGHT:
        return valid_knight(sqFrom, sqTo);
    case PAWN:
        return attack_pawn(sqFrom, sqTo, pieceCol);
    default:
        break;
    }
    return attack_slider(sqFrom, sqTo, pieceType, isOccupied);
}
 
template <typename TFunc>
inline bool pseudo_advance_pawn(squareT sqFrom, squareT sqTo, colorT pieceCol,
                                TFunc isOccupied) {
    if ((sqTo % NSQUARES) != (sqFrom % NSQUARES) // Different file
        || isOccupied(sqTo)) // Pawns can only capture diagonally
        return false;
 
    int fromRank = sqFrom / NSQUARES;
    int distRank = (sqTo / NSQUARES) - fromRank;
    if (pieceCol == WHITE)
        return distRank == 1 || (distRank == 2 && fromRank == kWPHomeRank &&
                                 !isOccupied(sqFrom + NSQUARES));
 
    return distRank == -1 || (distRank == -2 && fromRank == kBPHomeRank &&
                              !isOccupied(sqFrom - NSQUARES));
}
 
template <typename TFunc>
bool pseudo(squareT sqFrom, squareT sqTo, colorT pieceCol, pieceT pieceType,
            TFunc isOccupied) {
    // TODO: castle moves
    if (pieceType == PAWN &&
        pseudo_advance_pawn(sqFrom, sqTo, pieceCol, isOccupied))
        return true;
 
    return attack(sqFrom, sqTo, pieceCol, pieceType, isOccupied);
}
 
template <typename TFunc>
inline std::pair<pieceT, squareT> opens_ray(squareT sqFrom, squareT sqTo,
                                            squareT sqRay, TFunc isOccupied) {
    assert(sqRay != sqFrom);
 
    int fyleFrom = sqFrom % NSQUARES;
    int distFyle = (sqRay % NSQUARES) - fyleFrom;
    int distRank = (sqRay / NSQUARES) - (sqFrom / NSQUARES);
 
    // Make sure the direction is valid:
    int fyleEdge;
    int sqStep;
    pieceT pt;
    if (distFyle == 0) {
        sqStep = NSQUARES; // vertical
        fyleEdge = -1;
        pt = ROOK;
    } else {
        if (fyleFrom == 0 || fyleFrom == (NSQUARES - 1))
            return {INVALID_PIECE, 0};
 
        if (distRank == 0) {
            sqStep = 1; // horizontal
            fyleEdge = 0;
            pt = ROOK;
        } else if (distFyle == distRank) {
            sqStep = NSQUARES + 1;
            fyleEdge = 0;
            pt = BISHOP;
        } else if (distFyle == -distRank) {
            sqStep = NSQUARES - 1;
            fyleEdge = NSQUARES - 1;
            pt = BISHOP;
        } else {
            return {INVALID_PIECE, 0};
        }
    }
    if (sqFrom > sqRay) {
        sqStep = -sqStep;
        fyleEdge = NSQUARES - 1 - fyleEdge;
    }
 
    for (int sq = sqFrom + sqStep; sq != sqRay; sq += sqStep) {
        if (sq == sqTo || isOccupied(sq))
            return {INVALID_PIECE, 0};
    }
 
    for (int sq = sqFrom - sqStep; sq < NSQUARES * NSQUARES; sq -= sqStep) {
        if (sq < 0 || sq == sqTo)
            break;
 
        if (isOccupied(sq))
            return {pt, static_cast<squareT>(sq)};
 
        if ((sq % NSQUARES) == fyleEdge)
            break;
    }
    return {INVALID_PIECE, 0};
}
 
inline bool blocks_ray(squareT sqFrom, squareT sqTo, squareT sqBlock) {
    return !move_predicates::attack_slider(sqFrom, sqTo, QUEEN,
                                   [&](auto sq) { return sq == sqBlock; });
}
 
} // namespace move_predicates
 
} // namespace scid::core