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] = {};
  static case_t kingarray[64][9] = {};
  static case_t knightarray[64][9] = {};
}
 
/**
 * we declare a separate namespace just for code purity
 * below declarations are globals, not static
 */
namespace belofte {
  extern bWhiteKing const* cWhiteKingClass;
  extern bBlackKing const* cBlackKingClass;
}
 
namespace belofte {
  bWhiteKing const* cWhiteKingClass = nullptr;
  bBlackKing const* cBlackKingClass = nullptr;
}
 
//-----------------------------------------------------------------------
 
boardbitmap_t static destinationbits(case_t const iCase, int8_t const ri, int8_t const ci);
boardbitmap_t static destinationbits_king(case_t const iCase);
boardbitmap_t static destinationbits_knight(case_t const iCase);
 
//-----------------------------------------------------------------------
 
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::cWhiteKingClass = new bWhiteKing();
  belofte::cBlackKingClass = new bBlackKing();
 
  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);
    // initialise array with destination squares
    belofte::kingarray[iCase][0] = 0;
    for (case_t bit = 0; bit < 64; ++bit) {
      if (belofte::kingmoves[iCase][bit]) {
        belofte::kingarray[iCase][0] += 1;
        belofte::kingarray[iCase][belofte::kingarray[iCase][0]] = bit;
      }
    }
    belofte::knightarray[iCase][0] = 0;
    for (case_t bit = 0; bit < 64; ++bit) {
      if (belofte::knightmoves[iCase][bit]) {
        belofte::knightarray[iCase][0] += 1;
        belofte::knightarray[iCase][belofte::knightarray[iCase][0]] = bit;
      }
    }
  }
}
 
boardbitmap_t static 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 static 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 static 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];
}
 
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wswitch-enum"
#endif
 
/**
 * static class member function
 */
std::string 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;
}
 
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
 
//-----------------------------------------------------------------------
 
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);
}
 
//-----------------------------------------------------------------------
 
/**
 * Check if piece on position is attacked, start with piece always on board
 * and then with pieces with greatest mobility, goal is to break out asap
 * @param b board
 * @param cf piece position
 * @return true if attacked, false if not
*/
bool bWhitePiece::isAttacked(bBasicBoard const& b, case_t const& cf) const
{
  // see if from square can be reached by king
  if (belofte::kingmoves[b.getBlackKingPos()][cf]) return true;
 
  // knight
  for (int_fast8_t iMove = 1; iMove <= belofte::knightarray[cf][0]; ++iMove) {
    if (b.getPiece(belofte::knightarray[cf][iMove]) == tPiece::B_KNIGHT) return true;
  }
 
  column_t fromcol = bCase::column(cf);
  rank_t fromrank = bCase::rank(cf);
 
  // pawn
  if (fromrank < 6) {
    if (fromcol && (b.getPiece(cf + 7) == tPiece::B_PAWN)) return true;
    if ((fromcol < 7) && (b.getPiece(cf + 9) == tPiece::B_PAWN)) return true;
  }
 
  // bishop, queen
  if (isAttackedBySlider(b, cf, fromcol, fromrank, -1, -1, tPiece::B_BISHOP, tPiece::B_QUEEN)) return true;
  if (isAttackedBySlider(b, cf, fromcol, fromrank, -1,  1, tPiece::B_BISHOP, tPiece::B_QUEEN)) return true;
  if (isAttackedBySlider(b, cf, fromcol, fromrank,  1, -1, tPiece::B_BISHOP, tPiece::B_QUEEN)) return true;
  if (isAttackedBySlider(b, cf, fromcol, fromrank,  1,  1, tPiece::B_BISHOP, tPiece::B_QUEEN)) return true;
 
  // rook, queen
  if (isAttackedBySlider(b, cf, fromcol, fromrank, -1,  0, tPiece::B_ROOK, tPiece::B_QUEEN)) return true;
  if (isAttackedBySlider(b, cf, fromcol, fromrank,  1,  0, tPiece::B_ROOK, tPiece::B_QUEEN)) return true;
  if (isAttackedBySlider(b, cf, fromcol, fromrank,  0, -1, tPiece::B_ROOK, tPiece::B_QUEEN)) return true;
  if (isAttackedBySlider(b, cf, fromcol, fromrank,  0,  1, tPiece::B_ROOK, tPiece::B_QUEEN)) return true;
 
  return false;
}
 
bool bBlackPiece::isAttacked(bBasicBoard const& b, case_t const& cf) const
{
  // see if from square can be reached by king
  if (belofte::kingmoves[b.getWhiteKingPos()][cf]) return true;
 
  // knight
  for (int_fast8_t iMove = 1; iMove <= belofte::knightarray[cf][0]; ++iMove) {
    if (b.getPiece(belofte::knightarray[cf][iMove]) == tPiece::W_KNIGHT) return true;
  }
 
  column_t fromcol = bCase::column(cf);
  rank_t fromrank = bCase::rank(cf);
 
  // pawn
  if (fromrank > 1) {
    if ((fromcol < 7) && (b.getPiece(cf - 7) == tPiece::W_PAWN)) return true;
    if (fromcol && (b.getPiece(cf - 9) == tPiece::W_PAWN)) return true;
  }
 
  // bishop, queen
  if (isAttackedBySlider(b, cf, fromcol, fromrank, -1, -1, tPiece::W_BISHOP, tPiece::W_QUEEN)) return true;
  if (isAttackedBySlider(b, cf, fromcol, fromrank, -1,  1, tPiece::W_BISHOP, tPiece::W_QUEEN)) return true;
  if (isAttackedBySlider(b, cf, fromcol, fromrank,  1, -1, tPiece::W_BISHOP, tPiece::W_QUEEN)) return true;
  if (isAttackedBySlider(b, cf, fromcol, fromrank,  1,  1, tPiece::W_BISHOP, tPiece::W_QUEEN)) return true;
 
  // rook, queen
  if (isAttackedBySlider(b, cf, fromcol, fromrank, -1,  0, tPiece::W_ROOK, tPiece::W_QUEEN)) return true;
  if (isAttackedBySlider(b, cf, fromcol, fromrank,  1,  0, tPiece::W_ROOK, tPiece::W_QUEEN)) return true;
  if (isAttackedBySlider(b, cf, fromcol, fromrank,  0, -1, tPiece::W_ROOK, tPiece::W_QUEEN)) return true;
  if (isAttackedBySlider(b, cf, fromcol, fromrank,  0,  1, tPiece::W_ROOK, tPiece::W_QUEEN)) return true;
 
  return false;
}
 
/**
 * @static Class static function
 * Return true if position is attacked by opponent respecting move offsets
 * @param b board
 * @param cf from field
 * @param fromcol field from
 * @param fromrank field from
 * @param ci col increment
 * @param ri row increment
 * @param cPiece first possible piece (rook/bishop)
 * @param cPiece2 second possible piece (queen)
 * @return true/false
 */
bool bPieceColour::isAttackedBySlider(bBasicBoard const& b,
        case_t cf, column_t fromcol, rank_t fromrank,
        int8_t const ci, int8_t const ri,
        piece_t const cPiece, piece_t const cPiece2)
{
  int8_t offset = (8 * ri) + ci;
 
  // slider move (queen, rook, bishop)
  for (;;) {
    // touch border?
    fromcol += ci;
    if (fromcol < 0 || fromcol > 7) break;
    fromrank += ri;
    if (fromrank < 0 || fromrank > 7) break;
 
    cf += offset;
    piece_t piece = b.getPiece(cf);
 
    if (piece) {
      if (piece == cPiece) return true;
      if (piece == cPiece2) return true;
      // not empty, not opponent piece, so protected
      break;
    }
  }
  return false;
}
 
/**
 * Check if any could be added by just checking there
 * @return true if move seems valid, false if in check after move
 */
bool bWhitePiece::canMovePreflightCheck(bBasicBoard& b,
        case_t const& cf, case_t const& ct) const
{
  bool canMove = false;
 
  if (bPiece::isWhitePiece(b.getPiece(ct))) return false;
 
  bMove m(cf, ct);
  if (bPiece::isBlackPiece(b.getPiece(ct))) m.setCapture();
 
  boardInfo_t oldBoardInfo = b.applyWhiteMove(m);
  if (!belofte::cWhiteKingClass->isAttacked(b, b.getWhiteKingPos())) canMove = true;
  b.unApplyMove(m, oldBoardInfo);
 
  return canMove;
}
 
/**
 * Check if any could be added by just checking there
 * is not check, break on first
 * @return true if move seems valid, false if in check after move
 */
bool bWhitePiece::canMovePreflightCheck(bBasicBoard& 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;
 
  rank_t oldrank = bCase::rank(cf);
  rank_t newrank = oldrank + ri;
 
  bool canMove = false;
 
  for (;;) {
    if (newcol < 0 || newcol > 7) return false;
    if (newrank < 0 || newrank > 7) return false;
 
    if (bPiece::isWhitePiece(b.getPiece(newcol, newrank))) return false;
 
    boardInfo_t oldBoardInfo = b.makeBoardMove(oldcol, oldrank, newcol, newrank);
    if (!belofte::cWhiteKingClass->isAttacked(b, b.getWhiteKingPos())) canMove = true;
    b.unMakeBoardMove(cf, newcol, newrank, oldBoardInfo);
 
    if (canMove) break;
 
    newcol += ci;
    newrank += ri;
  }
 
  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 bWhitePawn::canMovePreflightCheck(bBasicBoard& 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;
 
  boardInfo_t oldBoardInfo = b.makeBoardMove(oldcol, oldrank, newcol, newrank);
  if (belofte::cWhiteKingClass->isAttacked(b, b.getWhiteKingPos())) canMove = false;
  b.unMakeBoardMove(cf, newcol, newrank, oldBoardInfo);
 
  return canMove;
}
 
/**
 * Check if any could be added by just checking there
 * @return true if move seems valid, false if in check after move
 */
bool bBlackPiece::canMovePreflightCheck(bBasicBoard& b,
        case_t const& cf, case_t const& ct) const
{
  bool canMove = false;
 
  if (bPiece::isBlackPiece(b.getPiece(ct))) return false;
 
  bMove m(cf, ct);
  if (bPiece::isWhitePiece(b.getPiece(ct))) m.setCapture();
 
  boardInfo_t oldBoardInfo = b.applyBlackMove(m);
  if (!belofte::cBlackKingClass->isAttacked(b, b.getBlackKingPos())) canMove = true;
  b.unApplyMove(m, oldBoardInfo);
 
  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(bBasicBoard& 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;
 
  rank_t oldrank = bCase::rank(cf);
  rank_t newrank = oldrank + ri;
 
  bool canMove = false;
 
  for (;;) {
    if (newcol < 0 || newcol > 7) return false;
    if (newrank < 0 || newrank > 7) return false;
 
    if (bPiece::isBlackPiece(b.getPiece(newcol, newrank))) return false;
 
    boardInfo_t oldBoardInfo = b.makeBoardMove(oldcol, oldrank, newcol, newrank);
    if (!belofte::cBlackKingClass->isAttacked(b, b.getBlackKingPos())) canMove = true;
    b.unMakeBoardMove(cf, newcol, newrank, oldBoardInfo);
 
    if (canMove) break;
 
    newcol += ci;
    newrank += ri;
  }
 
  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 bBlackPawn::canMovePreflightCheck(bBasicBoard& 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;
 
  boardInfo_t oldBoardInfo = b.makeBoardMove(oldcol, oldrank, newcol, newrank);
  if (belofte::cBlackKingClass->isAttacked(b, b.getBlackKingPos())) canMove = false;
  b.unMakeBoardMove(cf, newcol, newrank, oldBoardInfo);
 
  return canMove;
}
 
/**
 * Check for in-check position, used for King and Knight
 */
movenum_t bWhitePiece::addMove(bBasicBoard const& b,
        case_t const& cf, case_t const& ct,
        bMoveList& ml) const
{
  if (b.isFieldEmpty(ct)) {
    bMove m(cf, ct);
    return ml.addWhiteMoveIfValid(b, m);
  } else if (bPiece::isBlackPiece(b.getPiece(ct))) {
    bMove m(cf, ct);
    m.setCapture();
    return ml.addWhiteMoveIfValid(b, m);
  }
  return 0;
}
 
movenum_t bBlackPiece::addMove(bBasicBoard const& b,
        case_t const& cf, case_t const& ct,
        bMoveList& ml) const
{
  if (b.isFieldEmpty(ct)) {
    bMove m(cf, ct);
    return ml.addBlackMoveIfValid(b, m);
  } else if (bPiece::isWhitePiece(b.getPiece(ct))) {
    bMove m(cf, ct);
    m.setCapture();
    return ml.addBlackMoveIfValid(b, m);
  }
  return 0;
}
 
/**
 * Add moves for Queen, Rook and Bishop
 * @return number of moves generated
 */
movenum_t bWhitePiece::addMoves(bBasicBoard 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)) {
      bMove m(cf, to);
      nMoves += ml.addWhiteMoveIfValid(b, m);
    } else if (bPiece::isBlackPiece(b.getPiece(to))) {
      bMove m(cf, to);
      m.setCapture();
      nMoves += ml.addWhiteMoveIfValid(b, m);
      break;
    } else {
      // own colour, cannot jump
      break;
    }
    newcol += ci;
    newrank += ri;
  }
  return nMoves;
}
 
movenum_t bBlackPiece::addMoves(bBasicBoard 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)) {
      bMove m(cf, to);
      nMoves += ml.addBlackMoveIfValid(b, m);
    } else if (bPiece::isWhitePiece(b.getPiece(to))) {
      bMove m(cf, to);
      m.setCapture();
      nMoves += ml.addBlackMoveIfValid(b, m);
      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(bBasicBoard& b, case_t const& cf) const
{
  // no test on rank, as we remain on board
  if (!b.isFieldEmpty(cf + 8)) return false;
 
  return canMovePreflightCheck(b, cf, 1, 0);
}
 
/**
 * Test move is possible, pawn capture move
 * could be promotion as well
 * @todo only look left and right when required
 */
bool bWhitePawn::canPawnCapture(bBasicBoard& 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);
}
 
/**
 * Test if e.p. move is possible
 */
bool bWhitePawn::canPawnEPMove(bBasicBoard& 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) != b.getEpColumn() + ci) return false;
 
  return canMovePreflightCheck(b, cf, 1, ci);
}
 
/**
 * @static Class static function
 * Test move is possible, single step move
 * non capture move
 */
movenum_t bWhitePawn::addNonCapturePawnMove(bBasicBoard const& b,
        case_t const& cf, bMoveList& ml)
{
  // no test on rank, as we remain on board
  case_t to = cf + 8;
  if (b.isFieldEmpty(to)) {
    bMove m(cf, to);
    m.setPawnMove();
    movenum_t nMoves = ml.addWhiteMoveIfValid(b, m);
    to = cf + 16;
    if ((bCase::rank(cf) == 1) && b.isFieldEmpty(to)) {
      bMove m2(cf, to);
      m2.setEPPossible();
      nMoves += ml.addWhiteMoveIfValid(b, m2);
    }
    return nMoves;
  }
  return 0;
}
 
/**
 * Test move is possible, single step non capture move
 * could be promotion as well
 */
bool bBlackPawn::canPawnMove(bBasicBoard& b, case_t const& cf) const
{
  // no test on rank, as we remain on board
  if (!b.isFieldEmpty(cf - 8)) return false;
 
  return canMovePreflightCheck(b, cf, -1, 0);
}
 
/**
 * Test move is possible, pawn capture move
 * could be promotion as well
 * @todo only look left and right when required
 */
bool bBlackPawn::canPawnCapture(bBasicBoard& 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);
}
 
/**
 * Test if e.p. move is possible
 */
bool bBlackPawn::canPawnEPMove(bBasicBoard& 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) != b.getEpColumn() + ci) return false;
 
  return canMovePreflightCheck(b, cf, -1, ci);
}
 
/**
 * @static Class static function
 * Test move is possible, single step move
 * non capture move
 */
movenum_t bBlackPawn::addNonCapturePawnMove(bBasicBoard const& b,
        case_t const& cf, bMoveList& ml)
{
  // no test on rank, as we remain on board
  case_t to = cf - 8;
  if (b.isFieldEmpty(to)) {
    bMove m(cf, to);
    m.setPawnMove();
    movenum_t nMoves = ml.addBlackMoveIfValid(b, m);
    to = cf - 16;
    if ((bCase::rank(cf) == 6) && b.isFieldEmpty(to)) {
      bMove m2(cf, to);
      m2.setEPPossible();
      nMoves += ml.addBlackMoveIfValid(b, m2);
    }
    return nMoves;
  }
  return 0;
}
 
movenum_t bWhitePawn::addCapturePawnMove(bBasicBoard const& b,
        case_t const& cf, int8_t const ci, bMoveList& ml)
{
  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))) {
    bMove m(cf, bCase::coordToCase(newcol, newrank));
    m.setPawnMove();
    m.setCapture();
    return ml.addWhiteMoveIfValid(b, m);
  }
  return 0;
}
 
movenum_t bBlackPawn::addCapturePawnMove(bBasicBoard const& b,
        case_t const& cf, int8_t const ci, bMoveList& ml)
{
  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))) {
    bMove m(cf, bCase::coordToCase(newcol, newrank));
    m.setPawnMove();
    m.setCapture();
    return ml.addBlackMoveIfValid(b, m);
  }
  return 0;
}
 
/**
 * Test move is possible, single step move
 * non capture move
 */
movenum_t bWhitePawn::addNonCapturePromotionMove(bBasicBoard const& b,
        case_t const& cf, bMoveList& ml)
{
  // 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)) {
    bMove m(cf, to);
    return ml.addWhitePromotionIfValid(b, m);
  }
  return 0;
}
 
movenum_t bBlackPawn::addNonCapturePromotionMove(bBasicBoard const& b,
        case_t const& cf, bMoveList& ml)
{
  // 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)) {
    bMove m(cf, to);
    return ml.addBlackPromotionIfValid(b, m);
  }
  return 0;
}
 
/**
 * Test move is possible, single step move
 * capture only move
 */
movenum_t bWhitePawn::addCapturePromotionMove(bBasicBoard const& b,
        case_t const& cf, int8_t const ci, bMoveList& ml)
{
  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(bBasicBoard const& b,
        case_t const& cf, int8_t const ci, bMoveList& ml)
{
  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(bBasicBoard const& b,
        case_t const& cf, int8_t const ci, bMoveList& ml)
{
  // 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(bBasicBoard const& b,
        case_t const& cf, int8_t const ci, bMoveList& ml)
{
  // 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
 */
bool bWhitePawn::hasValidMovePreflightCheck(bBasicBoard& 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.isEpSet()) {
    if (canPawnEPMove(b, cf, -1)) return true;
    if (canPawnEPMove(b, cf, 1)) return true;
  }
  return false;
}
 
movenum_t bWhitePawn::GenerateMoves(bBasicBoard const& b,
        case_t const& cf, bMoveList& ml)
{
  movenum_t nMoves = 0;
 
  rank_t oldrank = bCase::rank(cf);
 
  if (oldrank == 6) {
    nMoves += addNonCapturePromotionMove(b, cf, ml);
    nMoves += addCapturePromotionMove(b, cf, -1, ml);
    nMoves += addCapturePromotionMove(b, cf, 1, ml);
  } else {
    nMoves += addNonCapturePawnMove(b, cf, ml);
    nMoves += addCapturePawnMove(b, cf, -1, ml);
    nMoves += addCapturePawnMove(b, cf, 1, ml);
    if (oldrank == 4 && b.isEpSet()) {
      if (bCase::column(cf) == b.getEpColumn() + 1) {
        nMoves += addEPMove(b, cf, -1, ml);
      } else if (bCase::column(cf) == b.getEpColumn() - 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(bBasicBoard& 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.isEpSet()) {
    if (canPawnEPMove(b, cf, -1)) return true;
    if (canPawnEPMove(b, cf, 1)) return true;
  }
  return false;
}
 
movenum_t bBlackPawn::GenerateMoves(bBasicBoard const& b,
        case_t const& cf, bMoveList& ml)
{
  movenum_t nMoves = 0;
 
  rank_t oldrank = bCase::rank(cf);
 
  if (oldrank == 1) {
    nMoves += addNonCapturePromotionMove(b, cf, ml);
    nMoves += addCapturePromotionMove(b, cf, -1, ml);
    nMoves += addCapturePromotionMove(b, cf, 1, ml);
  } else {
    nMoves += addNonCapturePawnMove(b, cf, ml);
    nMoves += addCapturePawnMove(b, cf, -1, ml);
    nMoves += addCapturePawnMove(b, cf, 1, ml);
    if (oldrank == 3 && b.isEpSet()) {
      if (bCase::column(cf) == b.getEpColumn() + 1) {
        nMoves += addEPMove(b, cf, -1, ml);
      } else if (bCase::column(cf) == b.getEpColumn() - 1) {
        nMoves += addEPMove(b, cf, 1, ml);
      }
    }
  }
  return nMoves;
}
 
bool bWhiteRook::hasValidMovePreflightCheck(bBasicBoard& 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(bBasicBoard& 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(bBasicBoard 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(bBasicBoard 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(bBasicBoard& b, case_t const& cf)
{
  for (int_fast8_t iMove = 1; iMove <= belofte::knightarray[cf][0]; ++iMove) {
    if (canMovePreflightCheck(b, cf, belofte::knightarray[cf][iMove])) return true;
  }
 
  return false;
}
 
bool bBlackKnight::hasValidMovePreflightCheck(bBasicBoard& b, case_t const& cf)
{
  for (int_fast8_t iMove = 1; iMove <= belofte::knightarray[cf][0]; ++iMove) {
    if (canMovePreflightCheck(b, cf, belofte::knightarray[cf][iMove])) return true;
  }
 
  return false;
}
 
movenum_t bWhiteKnight::GenerateMoves(bBasicBoard const& b,
        case_t const& cf, bMoveList& ml)
{
  movenum_t nMoves = 0;
 
  for (int_fast8_t iMove = 1; iMove <= belofte::knightarray[cf][0]; ++iMove) {
    nMoves += addMove(b, cf, belofte::knightarray[cf][iMove], ml);
  }
 
  return nMoves;
}
 
movenum_t bBlackKnight::GenerateMoves(bBasicBoard const& b,
        case_t const& cf, bMoveList& ml)
{
  movenum_t nMoves = 0;
 
  for (int_fast8_t iMove = 1; iMove <= belofte::knightarray[cf][0]; ++iMove) {
    nMoves += addMove(b, cf, belofte::knightarray[cf][iMove], ml);
  }
 
  return nMoves;
}
 
bool bWhiteBishop::hasValidMovePreflightCheck(bBasicBoard& 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(bBasicBoard& 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(bBasicBoard 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(bBasicBoard 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(bBasicBoard& 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(bBasicBoard& 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(bBasicBoard 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(bBasicBoard 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(bBasicBoard& b, case_t const& cf)
{
  /// we do not check castle moves, castle is possible only when normal move
  /// is possible
  for (int_fast8_t iMove = 1; iMove <= belofte::kingarray[cf][0]; ++iMove) {
    if (canMovePreflightCheck(b, cf, belofte::kingarray[cf][iMove])) return true;
  }
 
  return false;
}
 
bool bBlackKing::hasValidMovePreflightCheck(bBasicBoard& b, case_t const& cf)
{
  /// we do not check castle moves, castle is possible only when normal move
  /// is possible
  for (int_fast8_t iMove = 1; iMove <= belofte::kingarray[cf][0]; ++iMove) {
    if (canMovePreflightCheck(b, cf, belofte::kingarray[cf][iMove])) return true;
  }
 
  return false;
}
 
movenum_t bWhiteKing::GenerateMoves(bBasicBoard const& b,
        case_t const& cf, bMoveList& ml)
{
  movenum_t nMoves = 0;
 
  for (int_fast8_t iMove = 1; iMove <= belofte::kingarray[cf][0]; ++iMove) {
    nMoves += addMove(b, cf, belofte::kingarray[cf][iMove], ml);
  }
 
  /// king not on original position, so not looking for castle
  if (cf != KingStartPosW) return nMoves;
 
  // king in check on original position
  if (belofte::cWhiteKingClass->isAttacked(b, cf)) return nMoves;
 
  if (b.hasCastleRights(tCFlags::WCASTLE_S)) {
    // short castle, test if row is empty
    if (b.isFieldEmpty(5)
        && b.isFieldEmpty(6)
        && !belofte::cWhiteKingClass->isAttacked(b, 5)) {
      // king is not going over attacked field
      bMove m(KingStartPosW, 6);
      m.setShortCastleMove();
      nMoves += ml.addWhiteMoveIfValid(b, m);
    }
  }
 
  if (b.hasCastleRights(tCFlags::WCASTLE_L)) {
    // long castle, test if row is empty
    if (b.isFieldEmpty(3)
        && b.isFieldEmpty(2)
        && b.isFieldEmpty(1)
        && !belofte::cWhiteKingClass->isAttacked(b, 3)) {
      // king is not going over attacked field
      bMove m(KingStartPosW, 2);
      m.setLongCastleMove();
      nMoves += ml.addWhiteMoveIfValid(b, m);
    }
  }
 
  return nMoves;
}
 
movenum_t bBlackKing::GenerateMoves(bBasicBoard const& b,
        case_t const& cf, bMoveList& ml)
{
  movenum_t nMoves = 0;
 
  for (int_fast8_t iMove = 1; iMove <= belofte::kingarray[cf][0]; ++iMove) {
    nMoves += addMove(b, cf, belofte::kingarray[cf][iMove], ml);
  }
 
  /// king not on original position, so not looking for castle
  if (cf != KingStartPosB) return nMoves;
 
  // king in check on original position
  if (belofte::cBlackKingClass->isAttacked(b, cf)) return nMoves;
 
  if (b.hasCastleRights(tCFlags::BCASTLE_S)) {
    // short castle, test if row is empty
    if (b.isFieldEmpty(61)
        && b.isFieldEmpty(62)
        && !belofte::cBlackKingClass->isAttacked(b, 61)) {
      // king is not going over attacked field
      bMove m(KingStartPosB, 62);
      m.setShortCastleMove();
      nMoves += ml.addBlackMoveIfValid(b, m);
    }
  }
 
  if (b.hasCastleRights(tCFlags::BCASTLE_L)) {
    // long castle, test if row is empty
    if (b.isFieldEmpty(59)
        && b.isFieldEmpty(58)
        && b.isFieldEmpty(57)
        && !belofte::cBlackKingClass->isAttacked(b, 59)) {
      // king is not going over attacked field
      bMove m(KingStartPosB, 58);
      m.setLongCastleMove();
      nMoves += ml.addBlackMoveIfValid(b, m);
    }
  }
 
  return nMoves;
}
 
//-----------------------------------------------------------------------
// eof