board.cpp

Go to the documentation of this file.

/*---------------------------------------------------------------------+
 * File: board.cpp
 * Project: part of belofte - A Promising Chess Program
 * Author: yves
 * SPDX-License-Identifier: GPL-2.0-only
+----------------------------------------------------------------------*/
 
#include "belofte.h"
 
//-----------------------------------------------------------------------
 
bBasicBoard::bBasicBoard(bBasicBoard const& bb)
  : u_positionFlags{bb.u_positionFlags}
  , m_hash{bb.m_hash}
  , m_fields{bb.m_fields}
{
}
 
bBasicBoard::bBasicBoard(bBasicBoard&& bb)
  : u_positionFlags{std::move(bb.u_positionFlags)}
  , m_hash{std::move(bb.m_hash)}
  , m_fields{std::move(bb.m_fields)}
{
}
 
bBasicBoard::~bBasicBoard()
{
}
 
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Weffc++"
#endif
 
bBasicBoard::bBasicBoard(bFen const& fen)
{
  u_positionFlags = 0ULL;
  for (case_t iCase = 0; iCase < 64; iCase++) m_fields[iCase] = tPiece::P_EMPTY;
 
  // parse
  std::string sFen = belofte::alltrim(fen); // remove leading and trailing space
  belofte::stringList const fenParts = belofte::stringSplit(sFen, " ");
  belofte::stringList const rowParts = belofte::stringSplit(fenParts[0], "/");
 
  // part 1, board filler
  for (rank_t iRank = 0; iRank < 8; iRank++) {
    auto initRank = [this](rank_t iR, std::string const& rankdata) -> void {
      column_t iCol = 0;
      unsigned int i = 0;
      while (iCol < 8) {
        unsigned char c = static_cast<unsigned char>(rankdata[i++]);
        if (c == 0) {
          break;
        } else if ((c >= '1') && (c <= '8')) {
          iCol += (c - '0');
        } else {
          setPieceKU(bCase::coordToCase(iCol, iR), bPiece::getPiece(static_cast<cpiece_t>(c)));
          iCol++;
        }
      }
    };
    initRank(7 - iRank, rowParts[static_cast<unsigned long>(iRank)]);
  }
 
  if (fenParts.size() > 2) {
    // part 3, castling rights
    setCastle(tCFlags::WCASTLE_S, fenParts[2].find('K') != std::string::npos);
    setCastle(tCFlags::WCASTLE_L, fenParts[2].find('Q') != std::string::npos);
    setCastle(tCFlags::BCASTLE_S, fenParts[2].find('k') != std::string::npos);
    setCastle(tCFlags::BCASTLE_L, fenParts[2].find('q') != std::string::npos);
  }
 
  if (fenParts.size() > 3) {
    // part 4, ep case
    if (fenParts[3] == "-") {
      clearEp();
    } else {
      setEp(bCase(fenParts[3]).getCaseT());
    }
  }
 
  if (fenParts.size() > 4) {
    // part 5, 50 move number (half-move / ply)
    setPly50Moves(static_cast<movenum50_t>(atoi(fenParts[4].c_str())));
  }
 
  if (fenParts.size() > 5) {
    // part 6, move number, starting from 1
    setPly(static_cast<plynum_t>((atoi(fenParts[5].c_str()) - 1) * 2));
  }
 
  if (fenParts.size() > 1) {
    // part 2, side to move
    if (fenParts[1] == "b") incPly();
  }
 
  /**
   @todo check legality of position: Max number of pieces
   of each type e.g. K=1, Q=(9 - # pawns), N=(10 - # pawns)
   colour of bishops, double in-check, in case of ep, adjacent pawn
   movenumber if not initial position, location of pawns,
   position of king and rooks in case of castle allowed (att. 960)
   for each promoted piece, an opponent piece must have been taken
  */
  calcHash();
}
 
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
 
//-----------------------------------------------------------------------
 
bFen bBasicBoard::getFEN() const
{
  std::string strfen;
  piece_t nPiece;
  std::string castl;
 
  // part 1, board filler
  for (rank_t iRank = 0; iRank < 8; iRank++) {
    int iBlanks = 0;
    for (column_t iCol = 0; iCol < 8; iCol++) {
      nPiece = getPiece(iCol, 7 - iRank);
      if (nPiece) {
        if (iBlanks) strfen += static_cast<char>(iBlanks + '0');
        iBlanks = 0;
        strfen += static_cast<char>(bPiece::getPieceChar(nPiece));
      } else {
        iBlanks++;
      }
    }
    if (iBlanks) strfen += static_cast<char>(iBlanks + '0');
    if (iRank < 7) strfen += "/";
  }
 
  strfen += getColourToMove() == tSide::SIDE_BLACK ? " b " : " w ";
 
  castl += canCastle(tCFlags::WCASTLE_S) ? "K" : "";
  castl += canCastle(tCFlags::WCASTLE_L) ? "Q" : "";
  castl += canCastle(tCFlags::BCASTLE_S) ? "k" : "";
  castl += canCastle(tCFlags::BCASTLE_L) ? "q" : "";
  strfen += castl.size() ? castl : "-";
 
  if (getEp()) {
    strfen += " " + std::string(bCase(getEp())) + " ";
  } else {
    strfen += " - ";
  }
  strfen += belofte::to_string(getPly50Moves()) + " " + belofte::to_string(getMoveNumber());
 
  return bFen(strfen);
}
 
//-----------------------------------------------------------------------
 
piece_t bBasicBoard::getPiece(case_t const bc) const
{
  return m_fields[bc];
}
 
piece_t bBasicBoard::getPiece(column_t const iColumn,
        rank_t const iRank) const
{
  return m_fields[bCase::coordToCase(iColumn, iRank)];
}
 
/** retrieve piece with bounds checking, return field empty in case
 * of out of bounds
 */
piece_t bBasicBoard::getPieceCtl(column_t const iColumn, rank_t const iRank) const
{
  if ((iColumn < 0) || (iColumn > 7)) return tPiece::P_EMPTY;
  if ((iRank < 0) || (iRank > 7)) return tPiece::P_EMPTY;
  return m_fields[bCase::coordToCase(iColumn, iRank)];
}
 
bool bBasicBoard::isFieldEmpty(case_t const bc) const
{
  return !m_fields[bc];
}
 
bool bBasicBoard::isFieldEmpty(column_t const iColumn,
        rank_t const iRank) const
{
  return !m_fields[bCase::coordToCase(iColumn, iRank)];
}
 
/** used for promotion move generation */
void bBasicBoard::setPiece(case_t const bc, piece_t const piece)
{
  m_fields[bc] = piece;
}
 
/** used for unMakeBoardMove */
void bBasicBoard::setPiece(case_t const bc, uint8_t const piece)
{
  m_fields[bc] = static_cast<piece_t>(piece);
}
 
/** used for makeBoardMove */
piece_t bBasicBoard::setGetPiece(column_t const newcol, rank_t const newrank,
                                 piece_t const piece)
{
  case_t bc = bCase::coordToCase(newcol, newrank);
  piece_t oldPiece = m_fields[bc];
  m_fields[bc] = piece;
  return oldPiece;
}
 
/** used for makeBoardMove */
piece_t bBasicBoard::removePiece(column_t const newcol, rank_t const newrank)
{
  case_t bc = bCase::coordToCase(newcol, newrank);
  piece_t oldPiece = m_fields[bc];
  m_fields[bc] = tPiece::P_EMPTY;
  return oldPiece;
}
 
/** used for setboard only */
void bBasicBoard::setPieceKU(case_t const bc, piece_t const piece)
{
  m_fields[bc] = piece;
  if (piece == tPiece::W_KING) m_whiteKing = bc;
  else if (piece == tPiece::B_KING) m_blackKing = bc;
}
 
void bBasicBoard::clearPiece(case_t const bc)
{
  m_fields[bc] = tPiece::P_EMPTY;
}
 
void bBasicBoard::setEp(case_t const e)
{
  if (m_ep != e) {
    // clear old and set new
    m_hash ^= hashmultiplexer[tPiece::P_EMPTY][m_ep]
           ^ hashmultiplexer[tPiece::P_EMPTY][e];
    m_ep = e;
  }
}
 
bool bBasicBoard::canCastle() const
{
  if (m_castling & 0x0F) return !isInCheck();
  return false;
}
 
bool bBasicBoard::canCastle(uint8_t const f) const
{
  return m_castling & f;
}
 
void bBasicBoard::setCastle(uint8_t const f, bool const c)
{
  if (c) setCastle(f);
  else clearCastle(f);
}
 
void bBasicBoard::setCastle(uint8_t const f)
{
  if (!(m_castling & f)) {
    m_castling |= f;
    // there can be (is) a difference in the offsets in the hash table and the castle flags
    m_hash ^= hashmultiplexer[tPiece::P_EMPTY][f];
  }
}
 
void bBasicBoard::clearCastle(uint8_t const f)
{
  if (m_castling & f) {
    m_castling &= 0x0F & ~f; // make sure to align to 4 bits only
    // there can be (is) a difference in the offsets in the hash table and the castle flags
    m_hash ^= hashmultiplexer[tPiece::P_EMPTY][f];
  }
}
 
bool bBasicBoard::isInCheck() const
{
  return m_castling & 0x10;
}
 
void bBasicBoard::setInCheck()
{
  m_castling |= 0x10;
}
 
void bBasicBoard::clearInCheck()
{
  m_castling &= ~(0x10);
}
 
/**
 * Clear castle flag if rook captured
 * update piece counter, update hash, clear field
 */
void bBasicBoard::setCapture(piece_t const p, case_t const c)
{
  clearPly50Moves();
  m_fields[c] = tPiece::P_EMPTY;
  m_hash ^= hashmultiplexer[p][c] ^ HASH_ODDMATERIAL;
  if (p == tPiece::W_ROOK) {
    if (c == bCase::coordToCase(7, 0)) {
      clearCastle(tCFlags::WCASTLE_S);
    } else if (c == bCase::coordToCase(0, 0)) {
      clearCastle(tCFlags::WCASTLE_L);
    }
  } else if (p == tPiece::B_ROOK) {
    if (c == bCase::coordToCase(7, 7)) {
      clearCastle(tCFlags::BCASTLE_S);
    } else if (c == bCase::coordToCase(0, 7)) {
      clearCastle(tCFlags::BCASTLE_L);
    }
  }
}
 
void bBasicBoard::movePiece(case_t const f, case_t const t, piece_t const p)
{
  m_fields[f] = tPiece::P_EMPTY;
  m_fields[t] = p;
  m_hash ^= hashmultiplexer[p][f] ^ hashmultiplexer[p][t];
}
 
void bBasicBoard::swapPiece(case_t const t, piece_t const op, piece_t const np)
{
  m_fields[t] = np;
  m_hash ^= hashmultiplexer[op][t] ^ hashmultiplexer[np][t];
}
 
void bBasicBoard::moveWhiteKing(case_t const f, case_t const t)
{
  m_fields[f] = tPiece::P_EMPTY;
  m_fields[t] = tPiece::W_KING;
  m_hash ^= hashmultiplexer[tPiece::W_KING][f] ^ hashmultiplexer[tPiece::W_KING][t];
  m_whiteKing = t;
}
 
void bBasicBoard::moveBlackKing(case_t const f, case_t const t)
{
  m_fields[f] = tPiece::P_EMPTY;
  m_fields[t] = tPiece::B_KING;
  m_hash ^= hashmultiplexer[tPiece::B_KING][f] ^ hashmultiplexer[tPiece::B_KING][t];
  m_blackKing = t;
}
 
//-----------------------------------------------------------------------
 
/**
 * Set hash based on board position, also calc pieces
 * Byte 0: bits 4-6 capture count (masked)
 *         bit 7 player to move
 * We are using 64 bits for hash
 * @todo TOCHECK: increase to 64 bits, is there added value
 */
void bBasicBoard::calcHash()
{
  hashkey_t hash = HASH_INIT;
  uint8_t piecesonboard = 0;
  for (case_t iCase = 0; iCase < 64; iCase++) {
    int piece = getPiece(iCase);
    if (piece) {
      hash ^= hashmultiplexer[piece][iCase];
      piecesonboard++;
    }
  }
 
  if (canCastle(tCFlags::WCASTLE_S))
    hash ^= hashmultiplexer[tPiece::P_EMPTY][(uint8_t)tHSpecial::HP_CASTLE_FL + (uint8_t)tCFlags::WCASTLE_S];
  if (canCastle(tCFlags::WCASTLE_L))
    hash ^= hashmultiplexer[tPiece::P_EMPTY][(uint8_t)tHSpecial::HP_CASTLE_FL + (uint8_t)tCFlags::WCASTLE_L];
  if (canCastle(tCFlags::BCASTLE_S))
    hash ^= hashmultiplexer[tPiece::P_EMPTY][(uint8_t)tHSpecial::HP_CASTLE_FL + (uint8_t)tCFlags::BCASTLE_S];
  if (canCastle(tCFlags::BCASTLE_L))
    hash ^= hashmultiplexer[tPiece::P_EMPTY][(uint8_t)tHSpecial::HP_CASTLE_FL + (uint8_t)tCFlags::BCASTLE_L];
 
  // use hash of field 0 or any of the ep fields
  hash ^= hashmultiplexer[tPiece::P_EMPTY][getEp()];
 
  // set bit 63 (odd material)
  if (piecesonboard & 0x01) hash |= HASH_ODDMATERIAL;
 
  // set bit 64 (black to move)
  if (getColourToMove() == tSide::SIDE_BLACK) hash |= HASH_BLACKTOMOVE;
 
  m_hash = hash;
}
 
//-----------------------------------------------------------------------
 
/** apply move to check if in check only, board to be discarded
 * as it will be in incomplete state, no hash update
 * no check flag set, etc.
 * @param oldcol column from
 * @param oldrank rank from
 * @param newcol column to
 * @param newrank rank to
 * @param promotion piece
 * @return captured piece
 */
u_positionFlags_t bBasicBoard::makeBoardMove(column_t const oldcol,
                                   rank_t const oldrank, column_t const newcol,
                                   rank_t const newrank, piece_t const promotion) {
  // keep old flags
  u_positionFlags_t oldFlags;
  oldFlags.u_positionFlags = u_positionFlags;
 
  piece_t piece = removePiece(oldcol, oldrank); // clear from square
 
  // in case of capture, we return captured piece
  oldFlags.capturedpiece = setGetPiece(newcol, newrank, piece);
 
  if (getColourToMove() == tSide::SIDE_WHITE) {
    if (piece == tPiece::W_PAWN) {
      if (newcol != oldcol) {
        // this is a column change, so a capture move
        // check if we need to clear ep case
        if (getPiece(newcol, newrank) == tPiece::P_EMPTY) {
          // ep move, clear pawn
          clearPiece(bCase::coordToCase(newcol, newrank-1));
          oldFlags.capturedpiece = tPiece::P_SIZE; // this is a special hack to allow
          // unmake move to restore ep move
        }
      }
      if (newrank == 7) {
        // override new piece with promotion piece
        setPiece(bCase::coordToCase(newcol, newrank), promotion);
      }
    } else if (piece == tPiece::W_KING) {
      m_whiteKing = bCase::coordToCase(newcol, newrank);
      if ((newcol - oldcol) == 2) {
        // short castle
        clearPiece(bCase::coordToCase(7, 0));
        setPiece(bCase::coordToCase(5, 0), tPiece::W_ROOK);
      } else if ((newcol - oldcol) == -2) {
        // long castle
        clearPiece(bCase::coordToCase(0, 0));
        setPiece(bCase::coordToCase(3, 0), tPiece::W_ROOK);
      }
    }
  } else {
    // tSide::SIDE_BLACK
    if (piece == tPiece::B_PAWN) {
      if (newcol != oldcol) {
        // this is a column change, so a capture move
        // check if we need to clear ep case
        if (getPiece(newcol, newrank) == tPiece::P_EMPTY) {
          // ep move, clear pawn
          clearPiece(bCase::coordToCase(newcol, newrank+1));
          oldFlags.capturedpiece = tPiece::P_SIZE; // this is a special hack to allow
          // unmake move to restore ep move
        }
      }
      if (newrank == 0) {
        // override new piece with promotion piece
        setPiece(bCase::coordToCase(newcol, newrank), promotion);
      }
    } else if (piece == tPiece::B_KING) {
      m_blackKing = bCase::coordToCase(newcol, newrank);
      if ((newcol - oldcol) == 2) {
        // short castle
        clearPiece(bCase::coordToCase(7, 7));
        setPiece(bCase::coordToCase(5, 7), tPiece::B_ROOK);
      } else if ((newcol - oldcol) == -2) {
        // long castle
        clearPiece(bCase::coordToCase(0, 7));
        setPiece(bCase::coordToCase(3, 7), tPiece::B_ROOK);
      }
    }
  }
  incPly();
  return oldFlags;
}
 
/** undo makeBoardMove, restoring previous situation
 * @param cf case from
 * @param newcol column to
 * @param newrank rank to
 * @param oldFlags the positionFlags of the old position
 * @param promotion move signals return to pawn
 */
void bBasicBoard::unMakeBoardMove(case_t const& cf, column_t const newcol,
                                  rank_t const newrank,
                                  u_positionFlags_t const oldFlags,
                                  piece_t const promotion)
{
  case_t ct = bCase::coordToCase(newcol, newrank);
  piece_t piece = getPiece(ct);
 
  setPiece(cf, piece);
  if (oldFlags.capturedpiece == tPiece::P_SIZE) {
    // see remark on e.p move, we flag old piece as P_SIZE
    // to be able to restore board on before ep move
    clearPiece(ct);
    if (getColourToMove() == tSide::SIDE_WHITE) {
      setPiece(bCase::coordToCase(newcol, newrank-1), tPiece::W_PAWN);
    } else {
      // tSide::SIDE_BLACK
      setPiece(bCase::coordToCase(newcol, newrank+1), tPiece::B_PAWN);
    }
  } else {
    setPiece(ct, oldFlags.capturedpiece); // can be tPiece::P_EMPTY as well
    if (getColourToMove() == tSide::SIDE_WHITE) {
      if (piece == tPiece::W_KING) {
        m_whiteKing = cf;
        column_t oldcol = bCase::column(cf);
        if ((newcol - oldcol) == 2) {
          // short un-castle
          setPiece(bCase::coordToCase(7, 0), tPiece::W_ROOK);
          clearPiece(bCase::coordToCase(5, 0));
        } else if ((newcol - oldcol) == -2) {
          // long un-castle
          setPiece(bCase::coordToCase(0, 0), tPiece::W_ROOK);
          clearPiece(bCase::coordToCase(3, 0));
        }
      } else if (promotion != tPiece::P_EMPTY) {
        setPiece(cf, tPiece::W_PAWN);
      }
    } else {
      // tSide::SIDE_BLACK
      if (piece == tPiece::B_KING) {
        m_blackKing = cf;
        column_t oldcol = bCase::column(cf);
        if ((newcol - oldcol) == 2) {
          // short un-castle
          setPiece(bCase::coordToCase(7, 7), tPiece::B_ROOK);
          clearPiece(bCase::coordToCase(5, 7));
        } else if ((newcol - oldcol) == -2) {
          // long un-castle
          setPiece(bCase::coordToCase(0, 7), tPiece::B_ROOK);
          clearPiece(bCase::coordToCase(3, 7));
        }
      } else if (promotion != tPiece::P_EMPTY) {
        setPiece(cf, tPiece::B_PAWN);
      }
    }
  }
  u_positionFlags = oldFlags.u_positionFlags;
}
 
//-----------------------------------------------------------------------
 
std::string bBasicBoard::getHashStr() const
{
  std::stringstream ss;
  ss << std::uppercase << std::setfill('0')
          << std::setw(16) << std::hex << m_hash;
  return ss.str();
}
 
//-----------------------------------------------------------------------
 
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Weffc++"
#endif
 
/**
 * Used by bPgnMove ctor, popuplateMoveList, atLeastOneMovePossible
 * movesinpgnformat
 * @todo make function obsolete to avoid confusion
 */
bBoard::bBoard(bBoard const& b)
  : bBasicBoard{std::move(b)}
  , u_boardFlags1{std::move(b.u_boardFlags1)}
{
}
 
/**
 * Used when Push board on gamestack (playGameMove)
 */
bBoard::bBoard(bBoard&& b) noexcept
  : bBasicBoard{std::move(b)}
  , u_boardFlags1{std::move(b.u_boardFlags1)}
  , m_castledoneWhite{std::move(b.m_castledoneWhite)}
  , m_castledoneBlack{std::move(b.m_castledoneBlack)}
  , m_boardeval{std::move(b.m_boardeval)}
  , m_moves{}
#if !defined(INCOMPLETE_C11)
  , m_whitePieces{std::move(b.m_whitePieces)}
  , m_blackPieces{std::move(b.m_blackPieces)}
#endif
  , m_previousmoves{std::move(b.m_previousmoves)}
{
#if defined(INCOMPLETE_C11)
  for (unsigned int i = 0; i < tStatPiece::STAT_SIZE; i++) {
    m_whitePieces[i] = std::move(b.m_whitePieces[i]);
    m_blackPieces[i] = std::move(b.m_blackPieces[i]);
  }
#endif
}
 
/**
 * Create copy of board with move applied on it, clear fields that reflect
 * state before move is played
 * used by CalcBestMove
 * @param b existing board, moves may not have been generated yet
 * @param moveid to be applied
 */
bBoard::bBoard(bBoard const& b, movenum_t const moveid)
  : bBasicBoard{std::move(b)}
  , m_moves{}
  , m_variation{}
{
  bMove m(b.getMove(moveid));
  m_previousmoves = b.getPreviousMoves();
  m_previousmoves.emplace_back(m);
  applyMove(m);
  calcPieces();
  calcGameStage();
  getMoveListRef().generateMoves(*this);
  m_boardeval = Game()->EvalForPlayer(*this);
}
 
/**
 * Create copy of board with move applied on it, clear fields that reflect
 * state before move is played, used for playGameMove and applyMove
 * Signature difference in const only!!
 * @param b existing board
 * @param m move to be applied
 */
bBoard::bBoard(bBoard const& b, bMove& m)
  : bBasicBoard{std::move(b)}
  , m_previousmoves{b.getPreviousMoves()}
{
  m_previousmoves.emplace_back(std::move(m));
  applyMove(m);
  calcPieces();
  calcGameStage();
}
 
/**
 * Create copy of board with move applied on it, clear fields that reflect
 * state before move is played, used for SearchPerft::CalcBestMove, add..MoveIfValid
 * @param b existing board
 * @param m move to be applied
 */
bBoard::bBoard(bBoard const& b, bMove const& m)
  : bBasicBoard{std::move(b)}
{
  applyMove(m);
}
 
/** used by setFENInitialPos
 */
bBoard::bBoard(bFen const& fen)
  : bBasicBoard(fen)
  , u_boardFlags1{0ULL}
  , m_castledoneWhite{false}
  , m_castledoneBlack{false}
  , m_moves{}
  , m_variation{}
  , m_previousmoves{}
{
  calcPieces();
  calcGameStage();
}
 
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
 
bBoard::~bBoard()
{
  for (auto& v : m_whitePieces) v.clear();
  for (auto& v : m_blackPieces) v.clear();
  m_variation.clear();
  m_previousmoves.clear();
}
 
//-----------------------------------------------------------------------
 
void bBoard::calcPieces()
{
  if (m_piecesonboard) return; // void extra calculation cost
 
  m_piecesonboard = 0;
  for (auto& v : m_whitePieces) v.clear();
  for (auto& v : m_blackPieces) v.clear();
 
  for (case_t iCase = 0; iCase < 64; iCase++) {
    piece_t piece = getPiece(iCase);
    if (piece) {
      m_piecesonboard++;
      switch (piece) {
        case tPiece::W_PAWN:
          m_whitePieces[tStatPiece::STAT_PAWN].emplace_back(iCase);
          break;
        case tPiece::W_ROOK:
          m_whitePieces[tStatPiece::STAT_ROOK].emplace_back(iCase);
          break;
        case tPiece::W_KNIGHT:
          m_whitePieces[tStatPiece::STAT_KNIGHT].emplace_back(iCase);
          break;
        case tPiece::W_BISHOP:
          m_whitePieces[tStatPiece::STAT_BISHOP].emplace_back(iCase);
          break;
        case tPiece::W_QUEEN:
          m_whitePieces[tStatPiece::STAT_QUEEN].emplace_back(iCase);
          break;
        case tPiece::B_PAWN:
          m_blackPieces[tStatPiece::STAT_PAWN].emplace_back(iCase);
          break;
        case tPiece::B_ROOK:
          m_blackPieces[tStatPiece::STAT_ROOK].emplace_back(iCase);
          break;
        case tPiece::B_KNIGHT:
          m_blackPieces[tStatPiece::STAT_KNIGHT].emplace_back(iCase);
          break;
        case tPiece::B_BISHOP:
          m_blackPieces[tStatPiece::STAT_BISHOP].emplace_back(iCase);
          break;
        case tPiece::B_QUEEN:
          m_blackPieces[tStatPiece::STAT_QUEEN].emplace_back(iCase);
          break;
        //case tPiece::W_KING:
        //case tPiece::B_KING:
        //  break;
        //case tPiece::P_EMPTY:
        //case tPiece::P_SIZE:
        //  break;
        default:
          break;
      }
    }
  }
 
  m_whiteminor = static_cast<uint8_t>(m_whitePieces[tStatPiece::STAT_ROOK].size()
          + m_whitePieces[tStatPiece::STAT_KNIGHT].size()
          + m_whitePieces[tStatPiece::STAT_BISHOP].size()
          + m_whitePieces[tStatPiece::STAT_QUEEN].size());
  m_blackminor = static_cast<uint8_t>(m_blackPieces[tStatPiece::STAT_ROOK].size()
          + m_blackPieces[tStatPiece::STAT_KNIGHT].size()
          + m_blackPieces[tStatPiece::STAT_BISHOP].size()
          + m_blackPieces[tStatPiece::STAT_QUEEN].size());
}
 
void bBoard::calcGameStage()
{
  // pre-calculate stage
  if (m_piecesonboard > 28) {
    // TODO: take into account actual moves
    m_gamestage = bGameStage::ST_OPENING;
  } else if (m_piecesonboard < 14) {
    if (m_whiteminor && m_blackminor) {
      if ((m_whiteminor + m_blackminor) < 4)
        m_gamestage = bGameStage::ST_PAWNENDING;
      else
        m_gamestage = bGameStage::ST_ENDGAME;
    } else if (m_whiteminor + m_blackminor) {
      m_gamestage = bGameStage::ST_MATING;
    } else {
      m_gamestage = bGameStage::ST_PAWNENDING;
    }
  } else {
    m_gamestage = bGameStage::ST_UNKNOWN;
  }
}
 
/** invert colours
 *  update kingpos, update colour to move, castle rights, ...
 *  @todo castledone, capturedcase, capturedpiece, moveplayed, eval
 *  @todo epcase
 */
void bBoard::invertColours()
{
  // invert pieces
  for (column_t iCol = 0; iCol < 8; iCol++) {
    for (rank_t iRank = 0; iRank < 4; iRank++) {
      piece_t c0 = getPiece(iCol, iRank);
      piece_t c1 = getPiece(iCol, 7 - iRank);
      if (c0) { c0 = static_cast<piece_t>((c0 > W_QUEEN) ? c0 - W_QUEEN : c0 + W_QUEEN); }
      if (c1) { c1 = static_cast<piece_t>((c1 > W_QUEEN) ? c1 - W_QUEEN : c1 + W_QUEEN); }
      setPieceKU(bCase::coordToCase(iCol, iRank), c1);
      setPieceKU(bCase::coordToCase(iCol, 7 - iRank), c0);
    }
  }
  // invert castle rights
  bool c = canCastle(tCFlags::WCASTLE_S);
  setCastle(tCFlags::WCASTLE_S, canCastle(tCFlags::BCASTLE_S));
  setCastle(tCFlags::BCASTLE_S, c);
  c = canCastle(tCFlags::WCASTLE_L);
  setCastle(tCFlags::WCASTLE_L, canCastle(tCFlags::BCASTLE_L));
  setCastle(tCFlags::BCASTLE_L, c);
  // invert column
  if (whiteToMove()) incPly();
  else decPly();
  // recalculate board data
  calcHash();
  m_piecesonboard = 0; /// force recalculation of pieces
  calcPieces();
}
 
/** set non-silent flag, store captured piece and case (for undo)
 */
void bBoard::setCapture(piece_t const p, case_t const c)
{
  bBasicBoard::setCapture(p, c);
  m_bNonSilent = true;
  m_capturedpiece = p;
  m_capturedcase = c;
}
 
void bBoard::setInCheck()
{
  bBasicBoard::setInCheck();
  m_bNonSilent = true;
}
 
 
/** modification of board
 *  TOCHECK: check usage in case of failure, why not return exception?
 */
void bBoard::applyMove(bMove const& m)
{
  if (getColourToMove() == tSide::SIDE_WHITE) {
    applyWhiteMove(m);
    m_hash &= ~HASH_BLACKTOMOVE;
  } else {
    applyBlackMove(m);
    m_hash |= HASH_BLACKTOMOVE;
  }
 
  // TODO: flag mate/stalemate move, special move, ...
  if (m.isCheck()) {
    setInCheck(); // TOCHECK: do we need to look for mate here ?
  }
  m_moveplayed = m.getBasicMoveT();
  incPly();
}
 
void bBoard::applyWhiteMove(bMove const& m)
{
  piece_t piece = getPiece(m.from());
 
  if (piece == tPiece::W_PAWN) {
    rank_t iFromRank = m.fromrank();
    if (m.isEPMove()) {
      setCapture(tPiece::B_PAWN, bCase::coordToCase(m.tocolumn(), iFromRank));
    } else if (m.isCapture()) {
      setCapture(getPiece(m.to()), m.to());
    } else {
      clearPly50Moves();
      m_capturedpiece = tPiece::P_EMPTY;
    }
    movePiece(m.from(), m.to(), tPiece::W_PAWN);
    if (m.isPromotion()) {
      swapPiece(m.to(), tPiece::W_PAWN, m.getWhitePromotionPiece());
      if (m.isMajorPromotion()) setNonSilent();
    }
    if (m.isEPPossible()) {
      // TODO: add functions such as nextrank
      setEp(bCase::coordToCase(m.tocolumn(), iFromRank + 1));
    } else {
      clearEp(); // clear ep flag
    }
  } else {
    // other pieces: King, Queen, Rook, Knight, Bishop
    clearEp(); // clear ep flag
    if (m.isCapture()) {
      setCapture(getPiece(m.to()), m.to());
    } else {
      incPly50Moves();
      m_capturedpiece = tPiece::P_EMPTY;
    }
    if (piece == tPiece::W_KING) {
      moveWhiteKing(m.from(), m.to());
      if (m.isCastleMove()) {
        if (m.isLongCastleMove()) {
          movePiece(bCase::coordToCase(0, 0), bCase::coordToCase(3, 0), tPiece::W_ROOK);
        } else {
          movePiece(bCase::coordToCase(7, 0), bCase::coordToCase(5, 0), tPiece::W_ROOK);
        }
        setCastleDoneWhite(true);
      }
      clearCastle(tCFlags::WCASTLE_S);
      clearCastle(tCFlags::WCASTLE_L);
    } else {
      movePiece(m.from(), m.to(), piece);
      if (piece == tPiece::W_ROOK) {
        if (m.from() == bCase::coordToCase(0, 0)) {
          clearCastle(tCFlags::WCASTLE_L);
        } else if (m.from() == bCase::coordToCase(7, 0)) {
          clearCastle(tCFlags::WCASTLE_S);
        }
      }
    }
  }
}
 
void bBoard::applyBlackMove(bMove const& m)
{
  piece_t piece = getPiece(m.from());
 
  if (piece == tPiece::B_PAWN) {
    rank_t iFromRank = m.fromrank();
    if (m.isEPMove()) {
      setCapture(tPiece::W_PAWN, bCase::coordToCase(m.tocolumn(), iFromRank));
    } else if (m.isCapture()) {
      setCapture(getPiece(m.to()), m.to());
    } else {
      clearPly50Moves();
      m_capturedpiece = tPiece::P_EMPTY;
    }
    movePiece(m.from(), m.to(), tPiece::B_PAWN);
    if (m.isPromotion()) {
      swapPiece(m.to(), tPiece::B_PAWN, m.getBlackPromotionPiece());
      if (m.isMajorPromotion()) setNonSilent();
    }
    if (m.isEPPossible()) {
      // TODO: add functions such as nextrank
      setEp(bCase::coordToCase(m.tocolumn(), iFromRank - 1));
    } else {
      clearEp(); // clear ep flag
    }
  } else {
    // other pieces: King, Queen, Rook, Knight, Bishop
    clearEp(); // clear ep flag
    if (m.isCapture()) {
      setCapture(getPiece(m.to()), m.to());
    } else {
      incPly50Moves();
      m_capturedpiece = tPiece::P_EMPTY;
    }
    if (piece == tPiece::B_KING) {
      moveBlackKing(m.from(), m.to());
      if (m.isCastleMove()) {
        if (m.isLongCastleMove()) {
          movePiece(bCase::coordToCase(0, 7), bCase::coordToCase(3, 7), tPiece::B_ROOK);
        } else {
          movePiece(bCase::coordToCase(7, 7), bCase::coordToCase(5, 7), tPiece::B_ROOK);
        }
        setCastleDoneBlack(true);
      }
      clearCastle(tCFlags::BCASTLE_S);
      clearCastle(tCFlags::BCASTLE_L);
    } else {
      movePiece(m.from(), m.to(), piece);
      if (piece == tPiece::B_ROOK) {
        if (m.from() == bCase::coordToCase(0, 7)) {
          clearCastle(tCFlags::BCASTLE_L);
        } else if (m.from() == bCase::coordToCase(7, 7)) {
          clearCastle(tCFlags::BCASTLE_S);
        }
      }
    }
  }
}
 
//-----------------------------------------------------------------------
 
/**
 * return reference to movelist
 */
bMoveList& bBoard::getMoveListRef()
{
  return m_moves;
}
 
/**
 * see if at least one move can be played e.g. (stale-)mate eval
 */
bool bBoard::atLeastOneMovePossible() const
{
  return m_moves.atLeastOneMovePossible(*this);
}
 
bMove const& bBoard::getMove(movenum_t const moveid) const
{
  return m_moves[moveid];
}
 
//-----------------------------------------------------------------------
 
void bBoard::clearVariation()
{
  m_variation = {};
}
 
void bBoard::setVariation(bBoard const& chldbrd)
{
  m_variation = chldbrd.getVariation();
  if (chldbrd.getPreviousMoves().back() != "")
    m_variation.insert(m_variation.begin(), chldbrd.getPreviousMoves().back());
}
 
//-----------------------------------------------------------------------
 
bBoard::operator std::string() const
{
  std::stringstream ss;
 
  for (rank_t iRank = 0; iRank < 8; iRank++) {
    ss << "+---+---+---+---+---+---+---+---+\n";
    for (column_t iCol = 0; iCol < 8; iCol++) {
      ss << "| "
              << static_cast<char>(bPiece::getPieceChar(getPiece(iCol, 7 - iRank)))
              << " ";
    }
    ss << "|\n";
  }
  ss << "+---+---+---+---+---+---+---+---+\n";
 
  ss << "Move " << getMoveNumber() << " - "
          << (whiteToMove() ? "White" : "Black") << " to move"
          << "\n";
 
  ss << "Castling : ";
  for (uint8_t i = 0; i < 4; i++) ss << canCastle(static_cast<uint8_t>(1 << i));
  if (getEp()) ss << " E.p. " << bCase(getEp());
  if (isNonSilent() || isInCheck())
     ss << " QS:" << (isInCheck() ? " Check" : "")
          << (isCapture() ? " Capture" : "");
  if (getStage() == bGameStage::ST_OPENING) ss << " - Opening";
  else if (getStage() == bGameStage::ST_ENDGAME) ss << " - Endgame";
  else if (getStage() == bGameStage::ST_MATING) ss << " - Mating";
  else if (getStage() == bGameStage::ST_PAWNENDING) ss << " - Pawnending";
 
  return ss.str();
}
 
/** print board */
std::ostream& operator<<(std::ostream& os, bBoard const& bd)
{
  os << bd.operator std::string();
  os << std::endl;
  return os;
}
 
// eof