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];
  static boardbitmap_t kingmoves[64] = {};
  static boardbitmap_t knightmoves[64] = {};
}
 
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();
 
  for (case_t iCase = 0; iCase < 64; ++iCase) {
    belofte::kingmoves[iCase] = destinationbits_king(iCase);
    belofte::knightmoves[iCase] = destinationbits_knight(iCase);
  }
}
 
boardbitmap_t destinationbits_king(case_t const iCase) {
  boardbitmap_t dbits = 0L;
  dbits |= destinationbits(iCase, -1, -1);
  dbits |= destinationbits(iCase, -1,  0);
  dbits |= destinationbits(iCase, -1,  1);
  dbits |= destinationbits(iCase,  0, -1);
  dbits |= destinationbits(iCase,  0,  1);
  dbits |= destinationbits(iCase,  1, -1);
  dbits |= destinationbits(iCase,  1,  0);
  dbits |= destinationbits(iCase,  1,  1);
  return dbits;
}
 
boardbitmap_t destinationbits_knight(case_t const iCase) {
  boardbitmap_t dbits = 0L;
  dbits |= destinationbits(iCase, -2, -1);
  dbits |= destinationbits(iCase, -2,  1);
  dbits |= destinationbits(iCase, -1, -2);
  dbits |= destinationbits(iCase, -1,  2);
  dbits |= destinationbits(iCase,  1, -2);
  dbits |= destinationbits(iCase,  1,  2);
  dbits |= destinationbits(iCase,  2, -1);
  dbits |= destinationbits(iCase,  2,  1);
  return dbits;
}
 
boardbitmap_t destinationbits(case_t const iCase, int8_t const ri, int8_t const ci) {
  column_t newcol = bCase::column(iCase) + ci;
  rank_t newrank = bCase::rank(iCase) + ri;
 
  if (newcol < 0 || newcol > 7) return 0;
  if (newrank < 0 || newrank > 7) return 0;
 
  return bCase::caseToBit(bCase::coordToCase(newcol, newrank));
}
 
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;
    default:
      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;
}
 
/** static class member function */
bool bPiece::isWhitePiece(piece_t const p)
{
  if (!p) return false;
  return (p <= tPiece::W_QUEEN);
}
 
/** static class member function */
bool bPiece::isBlackPiece(piece_t const p)
{
  if (!p) return false;
  return (p > tPiece::W_QUEEN);
}
 
//-----------------------------------------------------------------------
 
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
{
  boardbitmap_t caseBit = bCase::caseToBit(cf);
  column_t fromcol = bCase::column(cf);
  rank_t fromrank = bCase::rank(cf);
 
  // king
  if (caseBit & belofte::kingmoves[b.getBlackKingPos()]) return true;
 
  // rook, queen
  if (isAttackedBySlider(b, fromcol, fromrank, tPiece::B_ROOK, tPiece::B_QUEEN, -1, 0)) return true;
  if (isAttackedBySlider(b, fromcol, fromrank, tPiece::B_ROOK, tPiece::B_QUEEN, 1, 0)) return true;
  if (isAttackedBySlider(b, fromcol, fromrank, tPiece::B_ROOK, tPiece::B_QUEEN, 0, -1)) return true;
  if (isAttackedBySlider(b, fromcol, fromrank, tPiece::B_ROOK, tPiece::B_QUEEN, 0, 1)) return true;
 
  // bishop, queen
  if (isAttackedBySlider(b, fromcol, fromrank, tPiece::B_BISHOP, tPiece::B_QUEEN, -1, -1)) return true;
  if (isAttackedBySlider(b, fromcol, fromrank, tPiece::B_BISHOP, tPiece::B_QUEEN, 1, -1)) return true;
  if (isAttackedBySlider(b, fromcol, fromrank, tPiece::B_BISHOP, tPiece::B_QUEEN, -1, 1)) return true;
  if (isAttackedBySlider(b, fromcol, fromrank, tPiece::B_BISHOP, tPiece::B_QUEEN, 1, 1)) return true;
 
  // knight
  if (b.m_blackPieces[tStatPiece::STAT_KNIGHT].size()) {
    // piece statistics filled, so we can use bitmasks
    for (unsigned int i=0; i < b.m_blackPieces[STAT_KNIGHT].size(); i++) {
      if (caseBit & belofte::knightmoves[b.m_blackPieces[STAT_KNIGHT][i]]) return true;
    }
  } else {
    if (isAttackedByPiece(b, fromcol, fromrank, tPiece::B_KNIGHT, 1, -2)) return true;
    if (isAttackedByPiece(b, fromcol, fromrank, tPiece::B_KNIGHT, 1, 2)) return true;
    if (isAttackedByPiece(b, fromcol, fromrank, tPiece::B_KNIGHT, 2, -1)) return true;
    if (isAttackedByPiece(b, fromcol, fromrank, tPiece::B_KNIGHT, 2, 1)) return true;
    if (isAttackedByPiece(b, fromcol, fromrank, tPiece::B_KNIGHT, -1, -2)) return true;
    if (isAttackedByPiece(b, fromcol, fromrank, tPiece::B_KNIGHT, -1, 2)) return true;
    if (isAttackedByPiece(b, fromcol, fromrank, tPiece::B_KNIGHT, -2, -1)) return true;
    if (isAttackedByPiece(b, fromcol, fromrank, tPiece::B_KNIGHT, -2, 1)) return true;
  }
 
  if (bCase::rank(cf) < 6) {
    if (isAttackedByPiece(b, fromcol, fromrank, tPiece::B_PAWN, 1, -1)) return true;
    if (isAttackedByPiece(b, fromcol, fromrank, 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
{
  boardbitmap_t caseBit = bCase::caseToBit(cf);
  column_t fromcol = bCase::column(cf);
  rank_t fromrank = bCase::rank(cf);
 
  // king
  if (caseBit & belofte::kingmoves[b.getWhiteKingPos()]) return true;
 
  // rook, queen
  if (isAttackedBySlider(b, fromcol, fromrank, tPiece::W_ROOK, tPiece::W_QUEEN, -1, 0)) return true;
  if (isAttackedBySlider(b, fromcol, fromrank, tPiece::W_ROOK, tPiece::W_QUEEN, 1, 0)) return true;
  if (isAttackedBySlider(b, fromcol, fromrank, tPiece::W_ROOK, tPiece::W_QUEEN, 0, -1)) return true;
  if (isAttackedBySlider(b, fromcol, fromrank, tPiece::W_ROOK, tPiece::W_QUEEN, 0, 1)) return true;
 
  // bishop, queen
  if (isAttackedBySlider(b, fromcol, fromrank, tPiece::W_BISHOP, tPiece::W_QUEEN, -1, -1)) return true;
  if (isAttackedBySlider(b, fromcol, fromrank, tPiece::W_BISHOP, tPiece::W_QUEEN, 1, -1)) return true;
  if (isAttackedBySlider(b, fromcol, fromrank, tPiece::W_BISHOP, tPiece::W_QUEEN, -1, 1)) return true;
  if (isAttackedBySlider(b, fromcol, fromrank, tPiece::W_BISHOP, tPiece::W_QUEEN, 1, 1)) return true;
 
  // knight
  if (b.m_whitePieces[tStatPiece::STAT_KNIGHT].size()) {
    // piece statistics filled, so we can use bitmasks
    for (unsigned int i=0; i < b.m_whitePieces[STAT_KNIGHT].size(); i++) {
      if (caseBit & belofte::knightmoves[b.m_whitePieces[STAT_KNIGHT][i]]) return true;
    }
  } else {
    if (isAttackedByPiece(b, fromcol, fromrank, tPiece::W_KNIGHT, 1, -2)) return true;
    if (isAttackedByPiece(b, fromcol, fromrank, tPiece::W_KNIGHT, 1, 2)) return true;
    if (isAttackedByPiece(b, fromcol, fromrank, tPiece::W_KNIGHT, 2, -1)) return true;
    if (isAttackedByPiece(b, fromcol, fromrank, tPiece::W_KNIGHT, 2, 1)) return true;
    if (isAttackedByPiece(b, fromcol, fromrank, tPiece::W_KNIGHT, -1, -2)) return true;
    if (isAttackedByPiece(b, fromcol, fromrank, tPiece::W_KNIGHT, -1, 2)) return true;
    if (isAttackedByPiece(b, fromcol, fromrank, tPiece::W_KNIGHT, -2, -1)) return true;
    if (isAttackedByPiece(b, fromcol, fromrank, tPiece::W_KNIGHT, -2, 1)) return true;
  }
 
  if (bCase::rank(cf) > 1) {
    if (isAttackedByPiece(b, fromcol, fromrank, tPiece::W_PAWN, -1, -1)) return true;
    if (isAttackedByPiece(b, fromcol, fromrank, 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 fromcol field from
 * @param fromrank field from
 * @param cPiece attacking piece
 * @param ri row increment
 * @param ci col increment
 * @return true/false
 */
bool bPieceColour::isAttackedByPiece(bBoard const& b, column_t const fromcol,
        rank_t const fromrank,
        piece_t const cPiece, int8_t const ri, int8_t const ci) const
{
  return (b.getPieceCtl(fromcol + ci, fromrank + ri) == cPiece);
}
 
/**
 * Return true if position is attacked by opponent respecting move offsets
 * @param b board
 * @param fromcol field from
 * @param fromrank 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, column_t const fromcol,
        rank_t const fromrank,
        piece_t const cPiece, piece_t const cPiece2,
        int8_t const ri, int8_t const ci) const
{
  rank_t newrank = fromrank + ri;
  column_t newcol = fromcol + 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;
}
 
/**
 * Check if move could be added by just checking there
 * is not check
 * @return true if move seems valid, false if in check after move
 */
bool bWhitePiece::canMovePreflightCheck(bBoard& b, case_t const& cf,
        int8_t const ri, int8_t const ci) const
{
  column_t oldcol = bCase::column(cf);
 
  column_t newcol = oldcol + ci;
  if (newcol < 0 || newcol > 7) return false;
 
  rank_t oldrank = bCase::rank(cf);
 
  rank_t newrank = oldrank + ri;
  if (newrank < 0 || newrank > 7) return false;
 
  if (bPiece::isWhitePiece(b.getPiece(newcol, newrank))) return false;
 
  bool canMove = true;
 
  u_positionFlags_t oldFlags = b.makeBoardMove(oldcol, oldrank, newcol, newrank, tPiece::P_EMPTY);
 
  bWhiteKing const* wking = static_cast<bWhiteKing *>(bPiece::getPieceClass(tPiece::W_KING));
  if (wking->isAttacked(b, b.getWhiteKingPos())) canMove = false;
 
  b.unMakeBoardMove(cf, newcol, newrank, oldFlags, tPiece::P_EMPTY);
 
  return canMove;
}
 
/**
 * Check if pawn move could be added by just checking there
 * is not check, case of possible promotion
 * @return true if move seems valid, false if in check after move
 */
bool bWhitePiece::canMovePreflightCheck(bBoard& b, case_t const& cf,
        int8_t const ri, int8_t const ci,
        piece_t const cPromotion) const
{
  column_t oldcol = bCase::column(cf);
 
  column_t newcol = oldcol + ci;
  if (newcol < 0 || newcol > 7) return false;
 
  rank_t oldrank = bCase::rank(cf);
 
  rank_t newrank = oldrank + ri;
  if (newrank < 0 || newrank > 7) return false;
 
  if (bPiece::isWhitePiece(b.getPiece(newcol, newrank))) return false;
 
  bool canMove = true;
 
  u_positionFlags_t oldFlags = b.makeBoardMove(oldcol, oldrank, newcol, newrank, tPiece::P_EMPTY);
 
  bWhiteKing const* wking = static_cast<bWhiteKing *>(bPiece::getPieceClass(tPiece::W_KING));
  if (wking->isAttacked(b, b.getWhiteKingPos())) canMove = false;
 
  b.unMakeBoardMove(cf, newcol, newrank, oldFlags, cPromotion);
 
  return canMove;
}
 
/**
 * Check if move could be added by just checking there
 * is not check
 * @return true if move seems valid, false if in check after move
 */
bool bBlackPiece::canMovePreflightCheck(bBoard& b, case_t const& cf,
        int8_t const ri, int8_t const ci) const
{
  column_t oldcol = bCase::column(cf);
 
  column_t newcol = oldcol + ci;
  if (newcol < 0 || newcol > 7) return false;
 
  rank_t oldrank = bCase::rank(cf);
 
  rank_t newrank = oldrank + ri;
  if (newrank < 0 || newrank > 7) return false;
 
  if (bPiece::isBlackPiece(b.getPiece(newcol, newrank))) return false;
 
  bool canMove = true;
 
  u_positionFlags_t oldFlags = b.makeBoardMove(oldcol, oldrank, newcol, newrank, tPiece::P_EMPTY);
 
  bBlackKing const* bking = static_cast<bBlackKing *>(bPiece::getPieceClass(tPiece::B_KING));
  if (bking->isAttacked(b, b.getBlackKingPos())) canMove = false;
 
  b.unMakeBoardMove(cf, newcol, newrank, oldFlags, tPiece::P_EMPTY);
 
  return canMove;
}
 
/**
 * Check if pawn move could be added by just checking there
 * is not check, case of possible promotion
 * @return true if move seems valid, false if in check after move
 */
bool bBlackPiece::canMovePreflightCheck(bBoard& b, case_t const& cf,
        int8_t const ri, int8_t const ci,
        piece_t const cPromotion) const
{
  column_t oldcol = bCase::column(cf);
 
  column_t newcol = oldcol + ci;
  if (newcol < 0 || newcol > 7) return false;
 
  rank_t oldrank = bCase::rank(cf);
 
  rank_t newrank = oldrank + ri;
  if (newrank < 0 || newrank > 7) return false;
 
  if (bPiece::isBlackPiece(b.getPiece(newcol, newrank))) return false;
 
  bool canMove = true;
 
  u_positionFlags_t oldFlags = b.makeBoardMove(oldcol, oldrank, newcol, newrank, tPiece::P_EMPTY);
 
  bBlackKing const* bking = static_cast<bBlackKing *>(bPiece::getPieceClass(tPiece::B_KING));
  if (bking->isAttacked(b, b.getBlackKingPos())) canMove = false;
 
  b.unMakeBoardMove(cf, newcol, newrank, oldFlags, cPromotion);
 
  return canMove;
}
 
/** Check for in-check position, single step move
 *  used for King and Knight
 */
movenum_t bWhitePiece::addMove(bBoard const& b, case_t const& cf,
        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;
 
  rank_t newrank = bCase::rank(cf) + ri;
  if (newrank < 0 || newrank > 7) return 0;
 
  case_t to = bCase::coordToCase(newcol, newrank);
  if (b.isFieldEmpty(to)) {
    return ml.addWhiteMoveIfValid(b, bMove(cf, to));
  } else if (bPiece::isBlackPiece(b.getPiece(to))) {
    return ml.addWhiteCaptureIfValid(b, cf, to);
  }
  return 0;
}
 
movenum_t bBlackPiece::addMove(bBoard const& b, case_t const& cf,
        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;
 
  rank_t newrank = bCase::rank(cf) + ri;
  if (newrank < 0 || newrank > 7) return 0;
 
  case_t to = bCase::coordToCase(newcol, newrank);
  if (b.isFieldEmpty(to)) {
    return ml.addBlackMoveIfValid(b, bMove(cf, to));
  } else if (bPiece::isWhitePiece(b.getPiece(to))) {
    return ml.addBlackCaptureIfValid(b, cf, to);
  }
  return 0;
}
 
/**
 * Add moves for Queen, Rook and Bishop
 * @return number of moves generated
 */
movenum_t bWhitePiece::addMoves(bBoard const& b, case_t const& cf,
        int8_t const ri, int8_t const ci, bMoveList& ml) const
{
  int_fast8_t nMax = 7;
  movenum_t 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.addWhiteMoveIfValid(b, bMove(cf, to));
    } else if (bPiece::isBlackPiece(b.getPiece(to))) {
      nMoves += ml.addWhiteCaptureIfValid(b, cf, to);
      break;
    } else {
      // own  colour, cannot jump
      break;
    }
    newcol += ci;
    newrank += ri;
  }
  return nMoves;
}
 
movenum_t bBlackPiece::addMoves(bBoard const& b, case_t const& cf,
        int8_t const ri, int8_t const ci, bMoveList& ml) const
{
  int_fast8_t nMax = 7;
  movenum_t 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.addBlackMoveIfValid(b, bMove(cf, to));
    } else if (bPiece::isWhitePiece(b.getPiece(to))) {
      nMoves += ml.addBlackCaptureIfValid(b, cf, to);
      break;
    } else {
      // own  colour, cannot jump
      break;
    }
    newcol += ci;
    newrank += ri;
  }
  return nMoves;
}
 
/** Test move is possible, single step non capture move
 * could be promotion as well
 */
bool bWhitePawn::canPawnMove(bBoard& b, case_t const& cf) const
{
  column_t newcol = bCase::column(cf);
  rank_t newrank = bCase::rank(cf) + 1;
  // no test on rank, as we remain on board
 
  if (!b.isFieldEmpty(newcol, newrank)) return false;
 
  return canMovePreflightCheck(b, cf, 1, 0, tPiece::W_PAWN);
}
 
/** Test move is possible, pawn capture move
 * could be promotion as well
 */
bool bWhitePawn::canPawnCapture(bBoard& b, case_t const& cf,
                                int8_t const ci) const
{
  column_t newcol = bCase::column(cf) + ci;
  if (newcol < 0 || newcol > 7) return false;
 
  rank_t newrank = bCase::rank(cf) + 1;
  // no test on rank, as we remain on board
 
  if (!bPiece::isBlackPiece(b.getPiece(newcol, newrank))) return false;
 
  return canMovePreflightCheck(b, cf, 1, ci, tPiece::W_PAWN);
}
 
/** Test if e.p. move is possible
 */
bool bWhitePawn::canPawnEPMove(bBoard& b,
                               case_t const& cf, int8_t const ci) const
{
  column_t newcol = bCase::column(cf) + ci;
  if (newcol < 0 || newcol > 7) return false;
 
  // no test on rank, as we remain on board
 
  if (bCase::column(cf) != bCase::column(b.getEp()) + ci) return false;
 
  return canMovePreflightCheck(b, cf, 1, ci);
}
 
/** Test move is possible, single step move
 * non capture move
 */
movenum_t bWhitePawn::addNonCapturePawnMove(bBoard const& b, case_t const& cf,
        bMoveList& ml) const
{
  // no test on rank, as we remain on board
  case_t to = bCase::coordToCase(bCase::column(cf), bCase::rank(cf) + 1);
  if (b.isFieldEmpty(to)) {
    bMove m(cf, to);
    return ml.addWhiteMoveIfValid(b, m);
  }
  return 0;
}
 
/** Test move is possible, single step non capture move
 * could be promotion as well
 */
bool bBlackPawn::canPawnMove(bBoard& b, case_t const& cf) const
{
  column_t newcol = bCase::column(cf);
  rank_t newrank = bCase::rank(cf) - 1;
  // no test on rank, as we remain on board
 
  if (!b.isFieldEmpty(newcol, newrank)) return false;
 
  return canMovePreflightCheck(b, cf, -1, 0, tPiece::B_PAWN);
}
 
/** Test move is possible, pawn capture move
 * could be promotion as well
 */
bool bBlackPawn::canPawnCapture(bBoard& b, case_t const& cf,
                                int8_t const ci) const
{
  column_t newcol = bCase::column(cf) + ci;
  if (newcol < 0 || newcol > 7) return false;
 
  rank_t newrank = bCase::rank(cf) - 1;
  // no test on rank, as we remain on board
 
  if (!bPiece::isWhitePiece(b.getPiece(newcol, newrank))) return false;
 
  return canMovePreflightCheck(b, cf, -1, ci, tPiece::B_PAWN);
}
 
/** Test if e.p. move is possible
 */
bool bBlackPawn::canPawnEPMove(bBoard& b,
                               case_t const& cf, int8_t const ci) const
{
  column_t newcol = bCase::column(cf) + ci;
  if (newcol < 0 || newcol > 7) return false;
 
  // no test on rank, as we remain on board
 
  if (bCase::column(cf) != bCase::column(b.getEp()) + ci) return false;
 
  return canMovePreflightCheck(b, cf, -1, ci);
}
 
/** Test move is possible, single step move
 * non capture move
 */
movenum_t bBlackPawn::addNonCapturePawnMove(bBoard const& b, case_t const& cf,
        bMoveList& ml) const
{
  // no test on rank, as we remain on board
  case_t to = bCase::coordToCase(bCase::column(cf), bCase::rank(cf) - 1);
  if (b.isFieldEmpty(to)) {
    bMove m(cf, to);
    return ml.addBlackMoveIfValid(b, m);
  }
  return 0;
}
 
movenum_t bWhitePawn::addNonCaptureDoublePawnMove(bBoard const& b, case_t const& cf,
        bMoveList& ml) const
{
  // no test on rank, as we remain on board
  case_t to = bCase::coordToCase(bCase::column(cf), bCase::rank(cf) + 2);
  if (b.isFieldEmpty(to)) {
    bMove m(cf, to);
    m.setEPPossible();
    return ml.addWhiteMoveIfValid(b, m);
  }
  return 0;
}
 
movenum_t bBlackPawn::addNonCaptureDoublePawnMove(bBoard const& b, case_t const& cf,
        bMoveList& ml) const
{
  // no test on rank, as we remain on board
  case_t to = bCase::coordToCase(bCase::column(cf), bCase::rank(cf) - 2);
  if (b.isFieldEmpty(to)) {
    bMove m(cf, to);
    m.setEPPossible();
    return ml.addBlackMoveIfValid(b, m);
  }
  return 0;
}
 
movenum_t bWhitePawn::addCapturePawnMove(bBoard const& b, case_t const& cf,
        int8_t const ci, bMoveList& ml) const
{
  column_t newcol = bCase::column(cf) + ci;
  if (newcol < 0 || newcol > 7) return 0;
 
  rank_t newrank = bCase::rank(cf) + 1;
  // no test on rank, as we remain on board
 
  if (bPiece::isBlackPiece(b.getPiece(newcol, newrank))) {
    return ml.addWhiteCaptureIfValid(b, cf, bCase::coordToCase(newcol, newrank));
  }
  return 0;
}
 
movenum_t bBlackPawn::addCapturePawnMove(bBoard const& b, case_t const& cf,
        int8_t const ci, bMoveList& ml) const
{
  column_t newcol = bCase::column(cf) + ci;
  if (newcol < 0 || newcol > 7) return 0;
 
  rank_t newrank = bCase::rank(cf) - 1;
  // no test on rank, as we remain on board
 
  if (bPiece::isWhitePiece(b.getPiece(newcol, newrank))) {
    return ml.addBlackCaptureIfValid(b, cf, bCase::coordToCase(newcol, newrank));
  }
  return 0;
}
 
/** Test move is possible, single step move
 * non capture move
 */
movenum_t bWhitePawn::addNonCapturePromotionMove(bBoard const& b, case_t const& cf,
        bMoveList& ml) const
{
  // no test on new rank, as promotion is always in good rank
  case_t to = bCase::coordToCase(bCase::column(cf), 7);
  if (b.isFieldEmpty(to)) {
    return ml.addWhitePromotionIfValid(b, bMove(cf, to));
  }
  return 0;
}
 
movenum_t bBlackPawn::addNonCapturePromotionMove(bBoard const& b, case_t const& cf,
        bMoveList& ml) const
{
  // no test on new rank, as promotion is always in good rank
  case_t to = bCase::coordToCase(bCase::column(cf), 0);
  if (b.isFieldEmpty(to)) {
    return ml.addBlackPromotionIfValid(b, bMove(cf, to));
  }
  return 0;
}
 
/** Test move is possible, single step move
 *  capture only move
 */
movenum_t bWhitePawn::addCapturePromotionMove(bBoard const& b, case_t const& cf,
        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 = 7;
 
  if (bPiece::isBlackPiece(b.getPiece(newcol, newrank))) {
    bMove m(cf, bCase::coordToCase(newcol, newrank));
    m.setCapture();
    return ml.addWhitePromotionIfValid(b, m);
  }
  return 0;
}
 
movenum_t bBlackPawn::addCapturePromotionMove(bBoard const& b, case_t const& cf,
        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 = 0;
 
  if (bPiece::isWhitePiece(b.getPiece(newcol, newrank))) {
    bMove m(cf, bCase::coordToCase(newcol, newrank));
    m.setCapture();
    return ml.addBlackPromotionIfValid(b, m);
  }
  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
 */
movenum_t bWhitePawn::addEPMove(bBoard const& b, case_t const& cf,
        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) + 1);
  bMove m(cf, to);
  m.setCapture();
  m.setEPMove();
  return ml.addWhiteMoveIfValid(b, m);
}
 
/** 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
 */
movenum_t bBlackPawn::addEPMove(bBoard const& b, case_t const& cf,
        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) - 1);
  bMove m(cf, to);
  m.setCapture();
  m.setEPMove();
  return ml.addBlackMoveIfValid(b, m);
}
 
/** check if there is at least one move possible
 * currently, relies on full move generation for pawn
 * @todo full preflight implementation to speed-up
 */
bool bWhitePawn::hasValidMovePreflightCheck(bBoard& b, case_t const& cf)
{
  if (canPawnMove(b, cf)) return true;
  if (canPawnCapture(b, cf, -1)) return true;
  if (canPawnCapture(b, cf, 1)) return true;
  if (bCase::rank(cf) == 4 && b.getEp()) {
    if (canPawnEPMove(b, cf, -1)) return true;
    if (canPawnEPMove(b, cf, 1)) return true;
  }
  return false;
}
 
movenum_t bWhitePawn::GenerateMoves(bBoard const& b, case_t const& cf, bMoveList& ml)
{
  movenum_t nMoves = 0;
 
  if (bCase::rank(cf) == 6) {
    nMoves += addNonCapturePromotionMove(b, cf, ml);
    nMoves += addCapturePromotionMove(b, cf, -1, ml);
    nMoves += addCapturePromotionMove(b, cf, 1, ml);
  } else {
    nMoves += addNonCapturePawnMove(b, cf, ml);
    if ((bCase::rank(cf) == 1) && b.isFieldEmpty(bCase::column(cf),2))
      nMoves += addNonCaptureDoublePawnMove(b, cf, ml);
    nMoves += addCapturePawnMove(b, cf, -1, ml);
    nMoves += addCapturePawnMove(b, cf, 1, ml);
    if (bCase::rank(cf) == 4 && b.getEp()) {
      if (bCase::column(cf) == bCase::column(b.getEp()) + 1) {
        nMoves += addEPMove(b, cf, -1, ml);
      } else if (bCase::column(cf) == bCase::column(b.getEp()) - 1) {
        nMoves += addEPMove(b, cf, 1, ml);
      }
    }
  }
  return nMoves;
}
 
/** check if there is at least one move possible
 * currently, relies on full move generation for pawn
 */
bool bBlackPawn::hasValidMovePreflightCheck(bBoard& b, case_t const& cf)
{
  if (canPawnMove(b, cf)) return true;
  if (canPawnCapture(b, cf, -1)) return true;
  if (canPawnCapture(b, cf, 1)) return true;
  if (bCase::rank(cf) == 3 && b.getEp()) {
    if (canPawnEPMove(b, cf, -1)) return true;
    if (canPawnEPMove(b, cf, 1)) return true;
  }
  return false;
}
 
movenum_t bBlackPawn::GenerateMoves(bBoard const& b, case_t const& cf, bMoveList& ml)
{
  movenum_t nMoves = 0;
 
  if (bCase::rank(cf) == 1) {
    nMoves += addNonCapturePromotionMove(b, cf, ml);
    nMoves += addCapturePromotionMove(b, cf, -1, ml);
    nMoves += addCapturePromotionMove(b, cf, 1, ml);
  } else {
    nMoves += addNonCapturePawnMove(b, cf, ml);
    if ((bCase::rank(cf) == 6) && b.isFieldEmpty(bCase::column(cf), 5))
      nMoves += addNonCaptureDoublePawnMove(b, cf, ml);
    nMoves += addCapturePawnMove(b, cf, -1, ml);
    nMoves += addCapturePawnMove(b, cf, 1, ml);
    if (bCase::rank(cf) == 3 && b.getEp()) {
      if (bCase::column(cf) == bCase::column(b.getEp()) + 1) {
        nMoves += addEPMove(b, cf, -1, ml);
      } else if (bCase::column(cf) == bCase::column(b.getEp()) - 1) {
        nMoves += addEPMove(b, cf, 1, ml);
      }
    }
  }
  return nMoves;
}
 
bool bWhiteRook::hasValidMovePreflightCheck(bBoard& b, case_t const& cf)
{
  if (canMovePreflightCheck(b, cf, -1, 0)
     || canMovePreflightCheck(b, cf, 1, 0)
     || canMovePreflightCheck(b, cf, 0, 1)
     || canMovePreflightCheck(b, cf, 0, -1)) return true;
  return false;
}
 
bool bBlackRook::hasValidMovePreflightCheck(bBoard& b, case_t const& cf)
{
  if (canMovePreflightCheck(b, cf, -1, 0)
     || canMovePreflightCheck(b, cf, 1, 0)
     || canMovePreflightCheck(b, cf, 0, -1)
     || canMovePreflightCheck(b, cf, 0, 1)) return true;
  return false;
}
 
movenum_t bWhiteRook::GenerateMoves(bBoard const& b, case_t const& cf, bMoveList& ml)
{
  movenum_t nMoves = 0;
 
  nMoves += addMoves(b, cf, -1, 0, ml);
  nMoves += addMoves(b, cf, 1, 0, ml);
  nMoves += addMoves(b, cf, 0, -1, ml);
  nMoves += addMoves(b, cf, 0, 1, ml);
 
  return nMoves;
}
 
movenum_t bBlackRook::GenerateMoves(bBoard const& b, case_t const& cf, bMoveList& ml)
{
  movenum_t nMoves = 0;
 
  nMoves += addMoves(b, cf, -1, 0, ml);
  nMoves += addMoves(b, cf, 1, 0, ml);
  nMoves += addMoves(b, cf, 0, -1, ml);
  nMoves += addMoves(b, cf, 0, 1, ml);
 
  return nMoves;
}
 
bool bWhiteKnight::hasValidMovePreflightCheck(bBoard& b, case_t const& cf)
{
  if (canMovePreflightCheck(b, cf, 1, 2)
     || canMovePreflightCheck(b, cf, 1, -2)
     || canMovePreflightCheck(b, cf, 2, 1)
     || canMovePreflightCheck(b, cf, 2, -1)
     || canMovePreflightCheck(b, cf, -1, 2)
     || canMovePreflightCheck(b, cf, -1, -2)
     || canMovePreflightCheck(b, cf, -2, 1)
     || canMovePreflightCheck(b, cf, -2, -1)) return true;
  return false;
}
 
bool bBlackKnight::hasValidMovePreflightCheck(bBoard& b, case_t const& cf)
{
  if (canMovePreflightCheck(b, cf, -1, 2)
     || canMovePreflightCheck(b, cf, -1, -2)
     || canMovePreflightCheck(b, cf, 2, 1)
     || canMovePreflightCheck(b, cf, 2, -1)
     || canMovePreflightCheck(b, cf, 1, 2)
     || canMovePreflightCheck(b, cf, 1, -2)
     || canMovePreflightCheck(b, cf, -2, 1)
     || canMovePreflightCheck(b, cf, -2, -1)) return true;
  return false;
}
 
movenum_t bWhiteKnight::GenerateMoves(bBoard const& b, case_t const& cf, bMoveList& ml)
{
  movenum_t nMoves = 0;
 
  nMoves += addMove(b, cf, 1, 2, ml);
  nMoves += addMove(b, cf, 1, -2, ml);
  nMoves += addMove(b, cf, 2, 1, ml);
  nMoves += addMove(b, cf, -2, 1, ml);
  nMoves += addMove(b, cf, -1, 2, ml);
  nMoves += addMove(b, cf, -1, -2, ml);
  nMoves += addMove(b, cf, 2, -1, ml);
  nMoves += addMove(b, cf, -2, -1, ml);
 
  return nMoves;
}
 
movenum_t bBlackKnight::GenerateMoves(bBoard const& b, case_t const& cf, bMoveList& ml)
{
  movenum_t nMoves = 0;
 
  nMoves += addMove(b, cf, 1, 2, ml);
  nMoves += addMove(b, cf, 1, -2, ml);
  nMoves += addMove(b, cf, 2, 1, ml);
  nMoves += addMove(b, cf, -2, 1, ml);
  nMoves += addMove(b, cf, -1, 2, ml);
  nMoves += addMove(b, cf, -1, -2, ml);
  nMoves += addMove(b, cf, 2, -1, ml);
  nMoves += addMove(b, cf, -2, -1, ml);
 
  return nMoves;
}
 
bool bWhiteBishop::hasValidMovePreflightCheck(bBoard& b, case_t const& cf)
{
  if (canMovePreflightCheck(b, cf,  1, -1)
     || canMovePreflightCheck(b, cf, 1, 1)
     || canMovePreflightCheck(b, cf, -1, 1)
     || canMovePreflightCheck(b, cf, -1, -1)) return true;
  return false;
}
 
bool bBlackBishop::hasValidMovePreflightCheck(bBoard& b, case_t const& cf)
{
  if (canMovePreflightCheck(b, cf, -1, -1)
     || canMovePreflightCheck(b, cf, 1, -1)
     || canMovePreflightCheck(b, cf, -1, 1)
     || canMovePreflightCheck(b, cf, 1, 1)) return true;
  return false;
}
 
movenum_t bWhiteBishop::GenerateMoves(bBoard const& b, case_t const& cf, bMoveList& ml)
{
  movenum_t nMoves = 0;
 
  nMoves += addMoves(b, cf, -1, -1, ml);
  nMoves += addMoves(b, cf, 1, -1, ml);
  nMoves += addMoves(b, cf, -1, 1, ml);
  nMoves += addMoves(b, cf, 1, 1, ml);
 
  return nMoves;
}
 
movenum_t bBlackBishop::GenerateMoves(bBoard const& b, case_t const& cf, bMoveList& ml)
{
  movenum_t nMoves = 0;
 
  nMoves += addMoves(b, cf, -1, -1, ml);
  nMoves += addMoves(b, cf, 1, -1, ml);
  nMoves += addMoves(b, cf, -1, 1, ml);
  nMoves += addMoves(b, cf, 1, 1, ml);
 
  return nMoves;
}
 
bool bWhiteQueen::hasValidMovePreflightCheck(bBoard& b, case_t const& cf)
{
  if (canMovePreflightCheck(b, cf, 0, -1)
     || canMovePreflightCheck(b, cf, 0, 1)
     || canMovePreflightCheck(b, cf, 1, -1)
     || canMovePreflightCheck(b, cf, 1, 0)
     || canMovePreflightCheck(b, cf, 1, 1)
     || canMovePreflightCheck(b, cf, -1, -1)
     || canMovePreflightCheck(b, cf, -1, 0)
     || canMovePreflightCheck(b, cf, -1, 1)) return true;
  return false;
}
 
bool bBlackQueen::hasValidMovePreflightCheck(bBoard& b, case_t const& cf)
{
  if (canMovePreflightCheck(b, cf, 0, -1)
     || canMovePreflightCheck(b, cf, 0, 1)
     || canMovePreflightCheck(b, cf, 1, -1)
     || canMovePreflightCheck(b, cf, 1, 0)
     || canMovePreflightCheck(b, cf, 1, 1)
     || canMovePreflightCheck(b, cf, -1, -1)
     || canMovePreflightCheck(b, cf, -1, 0)
     || canMovePreflightCheck(b, cf, -1, 1)) return true;
  return false;
}
 
movenum_t bWhiteQueen::GenerateMoves(bBoard const& b, case_t const& cf, bMoveList& ml)
{
  movenum_t nMoves = 0;
 
  nMoves += addMoves(b, cf, 0, -1, ml);
  nMoves += addMoves(b, cf, 0, 1, ml);
  nMoves += addMoves(b, cf, 1, -1, ml);
  nMoves += addMoves(b, cf, 1, 0, ml);
  nMoves += addMoves(b, cf, 1, 1, ml);
  nMoves += addMoves(b, cf, -1, -1, ml);
  nMoves += addMoves(b, cf, -1, 0, ml);
  nMoves += addMoves(b, cf, -1, 1, ml);
 
  return nMoves;
}
 
movenum_t bBlackQueen::GenerateMoves(bBoard const& b, case_t const& cf, bMoveList& ml)
{
  movenum_t nMoves = 0;
 
  nMoves += addMoves(b, cf, 0, -1, ml);
  nMoves += addMoves(b, cf, 0, 1, ml);
  nMoves += addMoves(b, cf, 1, -1, ml);
  nMoves += addMoves(b, cf, 1, 0, ml);
  nMoves += addMoves(b, cf, 1, 1, ml);
  nMoves += addMoves(b, cf, -1, -1, ml);
  nMoves += addMoves(b, cf, -1, 0, ml);
  nMoves += addMoves(b, cf, -1, 1, ml);
 
  return nMoves;
}
 
bool bWhiteKing::hasValidMovePreflightCheck(bBoard& b, case_t const& cf)
{
  if (canMovePreflightCheck(b, cf, 0, -1)
     || canMovePreflightCheck(b, cf, 0, 1)
     || canMovePreflightCheck(b, cf, 1, -1)
     || canMovePreflightCheck(b, cf, 1, 0)
     || canMovePreflightCheck(b, cf, 1, 1)
     || canMovePreflightCheck(b, cf, -1, -1)
     || canMovePreflightCheck(b, cf, -1, 0)
     || canMovePreflightCheck(b, cf, -1, 1)) return true;
  return false;
}
 
bool bBlackKing::hasValidMovePreflightCheck(bBoard& b, case_t const& cf)
{
  if (canMovePreflightCheck(b, cf, 0, -1)
     || canMovePreflightCheck(b, cf, 0, 1)
     || canMovePreflightCheck(b, cf, -1, -1)
     || canMovePreflightCheck(b, cf, -1, 0)
     || canMovePreflightCheck(b, cf, -1, 1)
     || canMovePreflightCheck(b, cf, 1, -1)
     || canMovePreflightCheck(b, cf, 1, 0)
     || canMovePreflightCheck(b, cf, 1, 1)) return true;
  return false;
}
 
movenum_t bWhiteKing::GenerateMoves(bBoard const& b, case_t const& cf, bMoveList& ml)
{
  movenum_t nMoves = 0;
 
  nMoves += addMove(b, cf, 0, -1, ml);
  nMoves += addMove(b, cf, 0, 1, ml);
  nMoves += addMove(b, cf, 1, -1, ml);
  nMoves += addMove(b, cf, 1, 0, ml);
  nMoves += addMove(b, cf, 1, 1, ml);
  nMoves += addMove(b, cf, -1, -1, ml);
  nMoves += addMove(b, cf, -1, 0, ml);
  nMoves += addMove(b, cf, -1, 1, ml);
 
  // king not on original position, TODO: use absolute index
  if ((bCase::column(cf) != 4) || (bCase::rank(cf) != 0)) return nMoves;
 
  // king in check
  bWhiteKing const* wking = static_cast<bWhiteKing *>(bPiece::getPieceClass(tPiece::W_KING));
  if (wking->isAttacked(b, cf)) return nMoves;
 
  if (b.canCastle(tCFlags::WCASTLE_S)) {
    // short castle, test if row is empty
    if (b.isFieldEmpty(bCase::coordToCase(5, 0))
        && b.isFieldEmpty(bCase::coordToCase(6, 0))
        && !wking->isAttacked(b, bCase::coordToCase(5, 0))) {
      // king is not going over attacked field
      bMove m(cf, bCase::coordToCase(6, 0));
      m.setShortCastleMove();
      nMoves += ml.addWhiteMoveIfValid(b, m);
    }
  }
 
  if (b.canCastle(tCFlags::WCASTLE_L)) {
    // long castle, test if row is empty
    if (b.isFieldEmpty(bCase::coordToCase(3, 0))
        && b.isFieldEmpty(bCase::coordToCase(2, 0))
        && b.isFieldEmpty(bCase::coordToCase(1, 0))
        && !wking->isAttacked(b, bCase::coordToCase(3, 0))) {
      // king is not going over attacked field
      bMove m(cf, bCase::coordToCase(2, 0));
      m.setLongCastleMove();
      nMoves += ml.addWhiteMoveIfValid(b, m);
    }
  }
 
  return nMoves;
}
 
movenum_t bBlackKing::GenerateMoves(bBoard const& b, case_t const& cf, bMoveList& ml)
{
  movenum_t nMoves = 0;
 
  nMoves += addMove(b, cf, 0, -1, ml);
  nMoves += addMove(b, cf, 0, 1, ml);
  nMoves += addMove(b, cf, 1, -1, ml);
  nMoves += addMove(b, cf, 1, 0, ml);
  nMoves += addMove(b, cf, 1, 1, ml);
  nMoves += addMove(b, cf, -1, -1, ml);
  nMoves += addMove(b, cf, -1, 0, ml);
  nMoves += addMove(b, cf, -1, 1, ml);
 
  // king not on original position, TODO: use absolute index
  if ((bCase::column(cf) != 4) || (bCase::rank(cf) != 7)) return nMoves;
 
  // king in check
  bBlackKing const* bking = static_cast<bBlackKing *>(bPiece::getPieceClass(tPiece::B_KING));
  if (bking->isAttacked(b, cf)) return nMoves;
 
  if (b.canCastle(tCFlags::BCASTLE_S)) {
    // short castle, test if row is empty
    if (b.isFieldEmpty(bCase::coordToCase(5, 7))
        && b.isFieldEmpty(bCase::coordToCase(6, 7))
        && !bking->isAttacked(b, bCase::coordToCase(5, 7))) {
      // king is not going over attacked field
      bMove m(cf, bCase::coordToCase(6, 7));
      m.setShortCastleMove();
      nMoves += ml.addBlackMoveIfValid(b, m);
    }
  }
 
  if (b.canCastle(tCFlags::BCASTLE_L)) {
    // long castle, test if row is empty
    if (b.isFieldEmpty(bCase::coordToCase(3, 7))
        && b.isFieldEmpty(bCase::coordToCase(2, 7))
        && b.isFieldEmpty(bCase::coordToCase(1, 7))
        && !bking->isAttacked(b, bCase::coordToCase(3, 7))) {
      // king is not going over attacked field
      bMove m(cf, bCase::coordToCase(2, 7));
      m.setLongCastleMove();
      nMoves += ml.addBlackMoveIfValid(b, m);
    }
  }
 
  return nMoves;
}
 
//-----------------------------------------------------------------------
// eof