piece.cpp

Go to the documentation of this file.

/*---------------------------------------------------------------------+
 * File: piece.cpp
 * Project: part of belofte - A Promising Chess Program
 * Author: yves
 * SPDX-License-Identifier: GPL-2.0-only
 +---------------------------------------------------------------------*/
 
#include "belofte.h"
 
/** Allow index mapper for char values of piece into int in 1-12 range
 *  to reduce space and easy initialisation
 */
namespace belofte {
  static piece_t  bPieceIndex[128] = {};
  static cpiece_t bPieceMapper[tPiece::P_SIZE] = {};
  static bPiece*  pieceinstances[tPiece::P_SIZE];
}
 
bPiece::bPiece()
{
}
 
bPiece::bPiece(piece_t p)
  : m_piece(p)
{
}
 
bPiece::~bPiece()
{
}
 
void bPiece_ctor()
{
  belofte::bPieceIndex[tCPiece::C_EMPTY] = tPiece::P_EMPTY;
  belofte::bPieceIndex[tCPiece::C_W_KING] = tPiece::W_KING;
  belofte::bPieceIndex[tCPiece::C_W_PAWN] = tPiece::W_PAWN;
  belofte::bPieceIndex[tCPiece::C_W_KNIGHT] = tPiece::W_KNIGHT;
  belofte::bPieceIndex[tCPiece::C_W_BISHOP] = tPiece::W_BISHOP;
  belofte::bPieceIndex[tCPiece::C_W_ROOK] = tPiece::W_ROOK;
  belofte::bPieceIndex[tCPiece::C_W_QUEEN] = tPiece::W_QUEEN;
  belofte::bPieceIndex[tCPiece::C_B_KING] = tPiece::B_KING;
  belofte::bPieceIndex[tCPiece::C_B_PAWN] = tPiece::B_PAWN;
  belofte::bPieceIndex[tCPiece::C_B_KNIGHT] = tPiece::B_KNIGHT;
  belofte::bPieceIndex[tCPiece::C_B_BISHOP] = tPiece::B_BISHOP;
  belofte::bPieceIndex[tCPiece::C_B_ROOK] = tPiece::B_ROOK;
  belofte::bPieceIndex[tCPiece::C_B_QUEEN] = tPiece::B_QUEEN;
 
  belofte::bPieceMapper[tPiece::P_EMPTY] = tCPiece::C_EMPTY;
  belofte::bPieceMapper[tPiece::W_KING] = tCPiece::C_W_KING;
  belofte::bPieceMapper[tPiece::W_PAWN] = tCPiece::C_W_PAWN;
  belofte::bPieceMapper[tPiece::W_KNIGHT] = tCPiece::C_W_KNIGHT;
  belofte::bPieceMapper[tPiece::W_BISHOP] = tCPiece::C_W_BISHOP;
  belofte::bPieceMapper[tPiece::W_ROOK] = tCPiece::C_W_ROOK;
  belofte::bPieceMapper[tPiece::W_QUEEN] = tCPiece::C_W_QUEEN;
  belofte::bPieceMapper[tPiece::B_KING] = tCPiece::C_B_KING;
  belofte::bPieceMapper[tPiece::B_PAWN] = tCPiece::C_B_PAWN;
  belofte::bPieceMapper[tPiece::B_KNIGHT] = tCPiece::C_B_KNIGHT;
  belofte::bPieceMapper[tPiece::B_BISHOP] = tCPiece::C_B_BISHOP;
  belofte::bPieceMapper[tPiece::B_ROOK] = tCPiece::C_B_ROOK;
  belofte::bPieceMapper[tPiece::B_QUEEN] = tCPiece::C_B_QUEEN;
 
  belofte::pieceinstances[tPiece::P_EMPTY] = new bEmptyPiece();
  belofte::pieceinstances[tPiece::W_KING] = new bWhiteKing();
  belofte::pieceinstances[tPiece::W_PAWN] = new bWhitePawn();
  belofte::pieceinstances[tPiece::W_KNIGHT] = new bWhiteKnight();
  belofte::pieceinstances[tPiece::W_BISHOP] = new bWhiteBishop();
  belofte::pieceinstances[tPiece::W_ROOK] = new bWhiteRook();
  belofte::pieceinstances[tPiece::W_QUEEN] = new bWhiteQueen();
  belofte::pieceinstances[tPiece::B_KING] = new bBlackKing();
  belofte::pieceinstances[tPiece::B_PAWN] = new bBlackPawn();
  belofte::pieceinstances[tPiece::B_KNIGHT] = new bBlackKnight();
  belofte::pieceinstances[tPiece::B_BISHOP] = new bBlackBishop();
  belofte::pieceinstances[tPiece::B_ROOK] = new bBlackRook();
  belofte::pieceinstances[tPiece::B_QUEEN] = new bBlackQueen();
}
 
void bPiece_dtor()
{
  for (int i = 0; i < tPiece::P_SIZE; i++) {
    delete belofte::pieceinstances[i];
  }
}
 
//-----------------------------------------------------------------------
 
/** static class member function */
bPiece* bPiece::getPieceClass(piece_t const piece)
{
   return belofte::pieceinstances[piece];
}
 
/** static class member function */
std::string const bPiece::getPieceStrUpper(piece_t const piece)
{
  switch (piece) {
    case tPiece::W_PAWN:
    case tPiece::B_PAWN:
      return S_P_PAWN;
    case tPiece::W_ROOK:
    case tPiece::B_ROOK:
      return S_P_ROOK;
    case tPiece::W_KNIGHT:
    case tPiece::B_KNIGHT:
      return S_P_KNIGHT;
    case tPiece::W_BISHOP:
    case tPiece::B_BISHOP:
      return S_P_BISHOP;
    case tPiece::W_KING:
    case tPiece::B_KING:
      return S_P_KING;
    case tPiece::W_QUEEN:
    case tPiece::B_QUEEN:
      return S_P_QUEEN;
    case tPiece::P_EMPTY:
    case tPiece::P_SIZE:
      break;
  }
  return S_P_EMPTY;
}
 
//-----------------------------------------------------------------------
 
side_t bPiece::toMove() const
{
  if (!m_piece) return tSide::SIDE_UNDEFINED;
  if (m_piece <= tPiece::W_QUEEN) return tSide::SIDE_WHITE;
  return tSide::SIDE_BLACK;
}
 
//-----------------------------------------------------------------------
 
/** static class member function */
cpiece_t bPiece::getPieceChar(piece_t const p)
{
  return belofte::bPieceMapper[p];
}
 
/** static class member function */
piece_t bPiece::getPiece(cpiece_t const p)
{
  return belofte::bPieceIndex[p];
}
 
/** static class member function */
bool bPiece::isOpponent(side_t const s, piece_t const p)
{
  if (!p) return false;
  if (p <= tPiece::W_QUEEN) return s == tSide::SIDE_BLACK ;
  return s == tSide::SIDE_WHITE;
}
 
/** static class member function */
bool bPiece::isOwnColour(side_t const s, piece_t const p)
{
  if (!p) return false;
  if (p <= tPiece::W_QUEEN) return s == tSide::SIDE_WHITE;
  return s == tSide::SIDE_BLACK;
}
 
//-----------------------------------------------------------------------
 
bPieceColour::bPieceColour(side_t s)
  : m_side{s}
{
}
 
bPieceColour::~bPieceColour()
{
}
 
/**
 * Check if piece on position is attacked, start with piece always on board
 * and then with pieces with greatest mobility, goal is to break ou asap
 * @param b board
 * @param cf piece position
 * @return true if attacked, false if not
*/
bool bWhitePiece::isAttacked(bBoard const& b, case_t const& cf) const
{
  // king
  if (isAttackedByPiece(b, cf, tPiece::B_KING, 1, -1)) return true;
  if (isAttackedByPiece(b, cf, tPiece::B_KING, 1, 0)) return true;
  if (isAttackedByPiece(b, cf, tPiece::B_KING, 1, 1)) return true;
  if (isAttackedByPiece(b, cf, tPiece::B_KING, 0, 1)) return true;
  if (isAttackedByPiece(b, cf, tPiece::B_KING, 0, -1)) return true;
  if (isAttackedByPiece(b, cf, tPiece::B_KING, -1, -1)) return true;
  if (isAttackedByPiece(b, cf, tPiece::B_KING, -1, 0)) return true;
  if (isAttackedByPiece(b, cf, tPiece::B_KING, -1, 1)) return true;
 
  // rook, queen
  if (isAttackedBySlider(b, cf, tPiece::B_ROOK, tPiece::B_QUEEN, -1, 0)) return true;
  if (isAttackedBySlider(b, cf, tPiece::B_ROOK, tPiece::B_QUEEN, 1, 0)) return true;
  if (isAttackedBySlider(b, cf, tPiece::B_ROOK, tPiece::B_QUEEN, 0, -1)) return true;
  if (isAttackedBySlider(b, cf, tPiece::B_ROOK, tPiece::B_QUEEN, 0, 1)) return true;
 
  // bishop, queen
  if (isAttackedBySlider(b, cf, tPiece::B_BISHOP, tPiece::B_QUEEN, -1, -1)) return true;
  if (isAttackedBySlider(b, cf, tPiece::B_BISHOP, tPiece::B_QUEEN, 1, -1)) return true;
  if (isAttackedBySlider(b, cf, tPiece::B_BISHOP, tPiece::B_QUEEN, -1, 1)) return true;
  if (isAttackedBySlider(b, cf, tPiece::B_BISHOP, tPiece::B_QUEEN, 1, 1)) return true;
 
  // knight
  if (isAttackedByPiece(b, cf, tPiece::B_KNIGHT, 1, -2)) return true;
  if (isAttackedByPiece(b, cf, tPiece::B_KNIGHT, 1, 2)) return true;
  if (isAttackedByPiece(b, cf, tPiece::B_KNIGHT, 2, -1)) return true;
  if (isAttackedByPiece(b, cf, tPiece::B_KNIGHT, 2, 1)) return true;
  if (isAttackedByPiece(b, cf, tPiece::B_KNIGHT, -1, -2)) return true;
  if (isAttackedByPiece(b, cf, tPiece::B_KNIGHT, -1, 2)) return true;
  if (isAttackedByPiece(b, cf, tPiece::B_KNIGHT, -2, -1)) return true;
  if (isAttackedByPiece(b, cf, tPiece::B_KNIGHT, -2, 1)) return true;
 
  if (bCase::rank(cf) < 6) {
    if (isAttackedByPiece(b, cf, tPiece::B_PAWN, 1, -1)) return true;
    if (isAttackedByPiece(b, cf, tPiece::B_PAWN, 1, 1)) return true;
    /// @todo TOCHECK how about ep
  }
 
  return false;
}
 
bool bBlackPiece::isAttacked(bBoard const& b, case_t const& cf) const
{
  // king
  if (isAttackedByPiece(b, cf, tPiece::W_KING, 1, -1)) return true;
  if (isAttackedByPiece(b, cf, tPiece::W_KING, 1, 0)) return true;
  if (isAttackedByPiece(b, cf, tPiece::W_KING, 1, 1)) return true;
  if (isAttackedByPiece(b, cf, tPiece::W_KING, 0, 1)) return true;
  if (isAttackedByPiece(b, cf, tPiece::W_KING, 0, -1)) return true;
  if (isAttackedByPiece(b, cf, tPiece::W_KING, -1, -1)) return true;
  if (isAttackedByPiece(b, cf, tPiece::W_KING, -1, 0)) return true;
  if (isAttackedByPiece(b, cf, tPiece::W_KING, -1, 1)) return true;
 
  // rook, queen
  if (isAttackedBySlider(b, cf, tPiece::W_ROOK, tPiece::W_QUEEN, -1, 0)) return true;
  if (isAttackedBySlider(b, cf, tPiece::W_ROOK, tPiece::W_QUEEN, 1, 0)) return true;
  if (isAttackedBySlider(b, cf, tPiece::W_ROOK, tPiece::W_QUEEN, 0, -1)) return true;
  if (isAttackedBySlider(b, cf, tPiece::W_ROOK, tPiece::W_QUEEN, 0, 1)) return true;
 
  // bishop, queen
  if (isAttackedBySlider(b, cf, tPiece::W_BISHOP, tPiece::W_QUEEN, -1, -1)) return true;
  if (isAttackedBySlider(b, cf, tPiece::W_BISHOP, tPiece::W_QUEEN, 1, -1)) return true;
  if (isAttackedBySlider(b, cf, tPiece::W_BISHOP, tPiece::W_QUEEN, -1, 1)) return true;
  if (isAttackedBySlider(b, cf, tPiece::W_BISHOP, tPiece::W_QUEEN, 1, 1)) return true;
 
  // knight
  if (isAttackedByPiece(b, cf, tPiece::W_KNIGHT, 1, -2)) return true;
  if (isAttackedByPiece(b, cf, tPiece::W_KNIGHT, 1, 2)) return true;
  if (isAttackedByPiece(b, cf, tPiece::W_KNIGHT, 2, -1)) return true;
  if (isAttackedByPiece(b, cf, tPiece::W_KNIGHT, 2, 1)) return true;
  if (isAttackedByPiece(b, cf, tPiece::W_KNIGHT, -1, -2)) return true;
  if (isAttackedByPiece(b, cf, tPiece::W_KNIGHT, -1, 2)) return true;
  if (isAttackedByPiece(b, cf, tPiece::W_KNIGHT, -2, -1)) return true;
  if (isAttackedByPiece(b, cf, tPiece::W_KNIGHT, -2, 1)) return true;
 
  if (bCase::rank(cf) > 1) {
    if (isAttackedByPiece(b, cf, tPiece::W_PAWN, -1, -1)) return true;
    if (isAttackedByPiece(b, cf, tPiece::W_PAWN, -1, 1)) return true;
    /// @todo TOCHECK how about ep
  }
 
  return false;
}
 
bWhitePiece::bWhitePiece()
  : bPieceColour(tSide::SIDE_WHITE)
{
}
 
bWhitePiece::~bWhitePiece()
{
}
 
bBlackPiece::bBlackPiece()
  : bPieceColour(tSide::SIDE_BLACK)
{
}
 
bBlackPiece::~bBlackPiece()
{
}
 
/**
 * Return true if position is attacked by opponent respecting move offsets
 * @param b board
 * @param cf field from
 * @param cPiece attacking piece
 * @param ri row increment
 * @param ci col increment
 * @return true/false
 */
bool bPieceColour::isAttackedByPiece(bBoard const& b, case_t const& cf,
        piece_t const cPiece, int8_t const ri, int8_t const ci) const
{
  return (b.getPieceCtl(bCase::column(cf) + ci, bCase::rank(cf) + ri) == cPiece);
}
 
/**
 * Return true if position is attacked by opponent respecting move offsets
 * @param b board
 * @param cf field from
 * @param cPiece first possible piece (rook/bishop)
 * @param cPiece2 second possible piece (queen)
 * @param ri row increment
 * @param ci col increment
 * @return true/false
 */
bool bPieceColour::isAttackedBySlider(bBoard const& b, case_t const& cf,
        piece_t const cPiece, piece_t const cPiece2,
        int8_t const ri, int8_t const ci) const
{
  rank_t newrank = bCase::rank(cf) + ri;
  column_t newcol = bCase::column(cf) + ci;
 
  // slider move (queen, rook, bishop)
  for (int8_t i = 0; i < 7; i++) {
    // touch border?
    if (newrank < 0 || newrank > 7) return false;
    if (newcol < 0 || newcol > 7) return false;
 
    piece_t piece = b.getPiece(newcol, newrank);
    if (piece) {
      if (piece == cPiece) return true;
      if (piece == cPiece2) return true;
      // not empty, not opponent piece, so protected
      return false;
    }
    newrank += ri; newcol += ci;
  }
  return false;
}
 
/**
 * Return true if king sees rook of own colour
 * @param b board
 * @param cf field from
 * @param cPiece rook
 * @param ci col increment
 * @return true/false
 */
bool bKing::kingSeesRook(bBoard const& b, case_t const& cf,
        piece_t const cPiece, int8_t const ci) const
{
  column_t newcol = bCase::column(cf) + ci;
 
  for (int8_t i = 0; i < 5; i++) {
    // touch border?
    if (newcol < 0 || newcol > 7) return false;
 
    piece_t p = b.getPiece(newcol, bCase::rank(cf));
    if (p) {
      if (p == cPiece) return true;
      // not empty, other piece
      return false;
    }
    newcol += ci;
  }
  return false;
}
 
/** Check for in-check position, single step move
 *  used for King and Knight
 */
int bPiece::addMove(bBoard const& b, case_t const& cf,
        side_t const side,
        int8_t const ri, int8_t const ci, bMoveList& ml) const
{
  column_t newcol = bCase::column(cf) + ci;
  rank_t newrank = bCase::rank(cf) + ri;
 
  if (newcol < 0 || newcol > 7) return 0;
  if (newrank < 0 || newrank > 7) return 0;
 
  case_t to = bCase::coordToCase(newcol, newrank);
  if (b.isFieldEmpty(to)) {
    return ml.addMoveIfValid(b, bMove(cf, to), side);
  } else if (bPiece::isOpponent(side, b.getPiece(to))) {
    bMove m(cf, to);
    m.setCapture();
    return ml.addMoveIfValid(b, m, side);
  }
  return 0;
}
 
/**
 * Add moves for Queen, Rook and Bishop
 * @return number of moves generated
 */
int bPiece::addMoves(bBoard const& b, case_t const& cf,
        side_t const side, int nMax,
        int8_t const ri, int8_t const ci, bMoveList& ml) const
{
  int nMoves = 0;
  column_t newcol = bCase::column(cf) + ci;
  rank_t newrank = bCase::rank(cf) + ri;
 
  while (--nMax >= 0) {
    if (newcol < 0 || newcol > 7) return nMoves;
    if (newrank < 0 || newrank > 7) return nMoves;
 
    case_t to = bCase::coordToCase(newcol, newrank);
    if (b.isFieldEmpty(to)) {
      nMoves += ml.addMoveIfValid(b, bMove(cf, to), side);
    } else if (bPiece::isOpponent(side, b.getPiece(to))) {
      bMove m(cf, to);
      m.setCapture();
      nMoves += ml.addMoveIfValid(b, m, side);
      break;
    } else {
      // own  colour, cannot jump
      break;
    }
    newcol += ci;
    newrank += ri;
  }
  return nMoves;
}
 
/** Test move is possible, single step move
 * non capture move
 */
int bPawn::addNonCapturePawnMove(bBoard const& b, case_t const& cf,
        side_t const side,
        int8_t const ri, bMoveList& ml) const
{
  // no test on rank, as we remain on board
  case_t to = bCase::coordToCase(bCase::column(cf), bCase::rank(cf) + ri);
  if (b.isFieldEmpty(to)) {
    bMove m(cf, to);
    return ml.addMoveIfValid(b, m, side);
  }
  return 0;
}
 
int bPawn::addNonCaptureDoublePawnMove(bBoard const& b, case_t const& cf,
        side_t const side,
        int8_t const ri, bMoveList& ml) const
{
  // no test on rank, as we remain on board
  case_t to = bCase::coordToCase(bCase::column(cf), bCase::rank(cf) + ri);
  if (b.isFieldEmpty(to)) {
    bMove m(cf, to);
    m.setEPPossible();
    return ml.addMoveIfValid(b, m, side);
  }
  return 0;
}
 
int bPawn::addCapturePawnMove(bBoard const& b, case_t const& cf,
        side_t const side,
        int8_t const ri, int8_t const ci, bMoveList& ml) const
{
  column_t newcol = bCase::column(cf) + ci;
 
  if (newcol < 0 || newcol > 7) return 0;
  // no test on rank, as we remain on board
 
  rank_t newrank = bCase::rank(cf) + ri;
 
  if (bPiece::isOpponent(side, b.getPiece(newcol, newrank))) {
    bMove m(cf, bCase::coordToCase(newcol, newrank));
    m.setCapture();
    return ml.addMoveIfValid(b, m, side);
  }
  return 0;
}
 
/** Test move is possible, single step move
 * non capture move
 */
int bPawn::addNonCapturePromotionMove(bBoard const& b, case_t const& cf,
        side_t const side,
        int8_t const ri, bMoveList& ml) const
{
  // no test on new rank, as promotion is always in good rank
  case_t to = bCase::coordToCase(bCase::column(cf), bCase::rank(cf) + ri);
  if (b.isFieldEmpty(to)) {
    return ml.addPromotionIfValid(b, bMove(cf, to), side);
  }
  return 0;
}
 
/** Test move is possible, single step move
 *  capture only move
 */
int bPawn::addCapturePromotionMove(bBoard const& b, case_t const& cf,
        side_t const side,
        int8_t const ri, int8_t const ci, bMoveList& ml) const
{
  column_t newcol = bCase::column(cf) + ci;
 
  if (newcol < 0 || newcol > 7) return 0;
  // no test on new rank, as capture promotion is always in good rank
 
  rank_t newrank = bCase::rank(cf) + ri;
 
  if (bPiece::isOpponent(side, b.getPiece(newcol, newrank))) {
    bMove m(cf, bCase::coordToCase(newcol, newrank));
    m.setCapture();
    return ml.addPromotionIfValid(b, m, side);
  }
  return 0;
}
 
/** Test move is possible, e.p. move
 *  capture only move, no test if pawn is present
 *  only board e.p. flag is used in calling function
 */
int bPawn::addEPMove(bBoard const& b, case_t const& cf,
        side_t const side,
        int8_t const ri, int8_t const ci, bMoveList& ml) const
{
  // no test on column, as e.p. move is pre-calculated
  // no test on new rank, as e.p. is always in good rank
  case_t to = bCase::coordToCase(bCase::column(cf) + ci, bCase::rank(cf) + ri);
  bMove m(cf, to);
  m.setCapture();
  m.setEPMove();
  return ml.addMoveIfValid(b, m, side);
}
 
int bWhitePawn::GenerateMoves(bBoard const& b, case_t const& cf, bMoveList& ml,
        side_t const side)
{
  int nMoves = 0;
 
  if (bCase::rank(cf) == 6) {
    nMoves += addNonCapturePromotionMove(b, cf, side, 1, ml);
    nMoves += addCapturePromotionMove(b, cf, side, 1, -1, ml);
    nMoves += addCapturePromotionMove(b, cf, side, 1, 1, ml);
  } else {
    nMoves += addNonCapturePawnMove(b, cf, side, 1, ml);
    if ((bCase::rank(cf) == 1) && b.isFieldEmpty(bCase::column(cf),2))
      nMoves += addNonCaptureDoublePawnMove(b, cf, side, 2, ml);
    nMoves += addCapturePawnMove(b, cf, side, 1, -1, ml);
    nMoves += addCapturePawnMove(b, cf, side, 1, 1, ml);
    if (bCase::rank(cf) == 4 && b.getEp()) {
      if (bCase::column(cf) == bCase::column(b.getEp()) + 1) {
        nMoves += addEPMove(b, cf, side, 1, -1, ml);
      } else if (bCase::column(cf) == bCase::column(b.getEp()) - 1) {
        nMoves += addEPMove(b, cf, side, 1, 1, ml);
      }
    }
  }
  return nMoves;
}
 
int bBlackPawn::GenerateMoves(bBoard const& b, case_t const& cf, bMoveList& ml,
        side_t const side)
{
  int nMoves = 0;
 
  if (bCase::rank(cf) == 1) {
    nMoves += addNonCapturePromotionMove(b, cf, side, -1, ml);
    nMoves += addCapturePromotionMove(b, cf, side, -1, -1, ml);
    nMoves += addCapturePromotionMove(b, cf, side, -1, 1, ml);
  } else {
    nMoves += addNonCapturePawnMove(b, cf, side, -1, ml);
    if ((bCase::rank(cf) == 6) && b.isFieldEmpty(bCase::column(cf), 5))
      nMoves += addNonCaptureDoublePawnMove(b, cf, side, -2, ml);
    nMoves += addCapturePawnMove(b, cf, side, -1, -1, ml);
    nMoves += addCapturePawnMove(b, cf, side, -1, 1, ml);
    if (bCase::rank(cf) == 3 && b.getEp()) {
      if (bCase::column(cf) == bCase::column(b.getEp()) + 1) {
        nMoves += addEPMove(b, cf, side, -1, -1, ml);
      } else if (bCase::column(cf) == bCase::column(b.getEp()) - 1) {
        nMoves += addEPMove(b, cf, side, -1, 1, ml);
      }
    }
  }
  return nMoves;
}
 
int bRook::GenerateMoves(bBoard const& b, case_t const& cf, bMoveList& ml,
        side_t const side)
{
  int nMoves = 0;
 
  nMoves += addMoves(b, cf, side, 7, -1, 0, ml);
  nMoves += addMoves(b, cf, side, 7, 1, 0, ml);
  nMoves += addMoves(b, cf, side, 7, 0, -1, ml);
  nMoves += addMoves(b, cf, side, 7, 0, 1, ml);
 
  return nMoves;
}
 
int bKnight::GenerateMoves(bBoard const& b, case_t const& cf, bMoveList& ml,
        side_t const side)
{
  int nMoves = 0;
 
  nMoves += addMove(b, cf, side, 1, 2, ml);
  nMoves += addMove(b, cf, side, 1, -2, ml);
  nMoves += addMove(b, cf, side, 2, 1, ml);
  nMoves += addMove(b, cf, side, -2, 1, ml);
  nMoves += addMove(b, cf, side, -1, 2, ml);
  nMoves += addMove(b, cf, side, -1, -2, ml);
  nMoves += addMove(b, cf, side, 2, -1, ml);
  nMoves += addMove(b, cf, side, -2, -1, ml);
 
  return nMoves;
}
 
int bBishop::GenerateMoves(bBoard const& b, case_t const& cf, bMoveList& ml,
        side_t const side)
{
  int nMoves = 0;
 
  nMoves += addMoves(b, cf, side, 7, -1, -1, ml);
  nMoves += addMoves(b, cf, side, 7, 1, -1, ml);
  nMoves += addMoves(b, cf, side, 7, -1, 1, ml);
  nMoves += addMoves(b, cf, side, 7, 1, 1, ml);
 
  return nMoves;
}
 
int bQueen::GenerateMoves(bBoard const& b, case_t const& cf, bMoveList& ml,
        side_t const side)
{
  int nMoves = 0;
 
  nMoves += addMoves(b, cf, side, 7, 0, -1, ml);
  nMoves += addMoves(b, cf, side, 7, 0, 1, ml);
  nMoves += addMoves(b, cf, side, 7, 1, -1, ml);
  nMoves += addMoves(b, cf, side, 7, 1, 0, ml);
  nMoves += addMoves(b, cf, side, 7, 1, 1, ml);
  nMoves += addMoves(b, cf, side, 7, -1, -1, ml);
  nMoves += addMoves(b, cf, side, 7, -1, 0, ml);
  nMoves += addMoves(b, cf, side, 7, -1, 1, ml);
 
  return nMoves;
}
 
int bKing::GenerateMoves(bBoard const& b, case_t const& cf, bMoveList& ml,
        side_t const side)
{
  int nMoves = 0;
 
  nMoves += addMove(b, cf, side, 0, -1, ml);
  nMoves += addMove(b, cf, side, 0, 1, ml);
  nMoves += addMove(b, cf, side, 1, -1, ml);
  nMoves += addMove(b, cf, side, 1, 0, ml);
  nMoves += addMove(b, cf, side, 1, 1, ml);
  nMoves += addMove(b, cf, side, -1, -1, ml);
  nMoves += addMove(b, cf, side, -1, 0, ml);
  nMoves += addMove(b, cf, side, -1, 1, ml);
 
  return nMoves;
}
 
int bWhiteKing::GenerateMoves(bBoard const& b, case_t const& cf, bMoveList& ml,
        side_t const side)
{
  int nMoves = bKing::GenerateMoves(b, cf, ml, side);
 
  // king not on original position, TODO: use absolute index
  if ((bCase::column(cf) != 4) || (bCase::rank(cf) != 0)) return nMoves;
 
  // king in check
  bWhiteKing* wking = static_cast<bWhiteKing *>(bPiece::getPieceClass(tPiece::W_KING));
  if (wking->isAttacked(b, cf)) return nMoves;
 
  if (b.canCastle(tCFlags::WCASTLE_S)) {
    // short castle
    if (kingSeesRook(b, cf, tPiece::W_ROOK, 1)) {
      // king is attacked by own rook, so it means it can castle
      // TODO: use case constant instead of calculating
      if (!wking->isAttacked(b, bCase::coordToCase(5, 0))) {
        // king is not going over attacked field
        bMove m(cf, bCase::coordToCase(bCase::column(cf) + 2, 0));
        m.setCastleMove(tSpecialMoveFlag::SHORT_CASTLE);
        nMoves += ml.addMoveIfValid(b, m, side);
      }
    }
  }
 
  if (b.canCastle(tCFlags::WCASTLE_L)) {
    // long castle
    if (kingSeesRook(b, cf, tPiece::W_ROOK, -1)) {
      // king is attacked by own rook, so it means it can castle
      // TODO: use case constant instead of calculating
      if (!wking->isAttacked(b, bCase::coordToCase(3, 0))) {
        // king is not going over attacked field
        bMove m(cf, bCase::coordToCase(bCase::column(cf) - 2, 0));
        m.setCastleMove(tSpecialMoveFlag::LONG_CASTLE);
        nMoves += ml.addMoveIfValid(b, m, side);
      }
    }
  }
 
  return nMoves;
}
 
int bBlackKing::GenerateMoves(bBoard const& b, case_t const& cf, bMoveList& ml,
        side_t const side)
{
  int nMoves = bKing::GenerateMoves(b, cf, ml, side);
 
  // king not on original position, TODO: use absolute index
  if ((bCase::column(cf) != 4) || (bCase::rank(cf) != 7)) return nMoves;
 
  // king in check
  bBlackKing* bking = static_cast<bBlackKing *>(bPiece::getPieceClass(tPiece::B_KING));
  if (bking->isAttacked(b, cf)) return nMoves;
 
  if (b.canCastle(tCFlags::BCASTLE_S)) {
    // short castle
    if (kingSeesRook(b, cf, tPiece::B_ROOK, 1)) {
      // king is attacked by own rook, so it means it can castle
      // TODO: use case constant instead of calculating
      if (!bking->isAttacked(b, bCase::coordToCase(5, 7))) {
        // king is not going over attacked field
        bMove m(cf, bCase::coordToCase(bCase::column(cf) + 2, 7));
        m.setCastleMove(tSpecialMoveFlag::SHORT_CASTLE);
        nMoves += ml.addMoveIfValid(b, m, side);
      }
    }
  }
 
  if (b.canCastle(tCFlags::BCASTLE_L)) {
    // long castle
    if (kingSeesRook(b, cf, tPiece::B_ROOK, -1)) {
      // king is attacked by own rook, so it means it can castle
      // TODO: use case constant instead of calculating
      if (!bking->isAttacked(b, bCase::coordToCase(3, 7))) {
        // king is not going over attacked field
        bMove m(cf, bCase::coordToCase(bCase::column(cf) - 2, 7));
        m.setCastleMove(tSpecialMoveFlag::LONG_CASTLE);
        nMoves += ml.addMoveIfValid(b, m, side);
      }
    }
  }
 
  return nMoves;
}
 
//-----------------------------------------------------------------------
// eof