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"
 
//-----------------------------------------------------------------------
 
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Weffc++"
#endif
 
/**
 * Copy board with limited board data, no board history
 */
bBoard::bBoard(bBoard const& b)
    : bBasicBoard(b)
    , m_boardData{b.m_boardData.u_boardData}
{
}
 
/**
 * Create copy of board with limited board data and history
 * @param b existing board
 * @param m move to be added to history
 */
bBoard::bBoard(bBoard const& b, bMove& m)
  : bBasicBoard{b}
  , m_boardData{b.m_boardData.u_boardData}
  , m_previousmoves{b.getPreviousMoves()}
{
  m_previousmoves.emplace_back(m);
}
 
/**
 * used by setFENInitialPos
 */
bBoard::bBoard(bFen const& fen)
  : bBasicBoard(fen)
  , m_boardData{0ULL}
{
  calcMinorPieces(true);
  calcGameStage();
}
 
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
 
//-----------------------------------------------------------------------
 
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wswitch-enum"
#endif
 
/**
 * Recalculate minor pieces, used for evaluation and end of game
 * condition in case of less than 5 pieces
 * @param bForceRecalc force to recalculate
 */
void bBoard::calcMinorPieces(bool const bForceRecalc)
{
  if (!bForceRecalc && noNeedCalcMinorPieces()) return; // no extra calculation cost
 
  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) {
      switch (piece) {
        case tPiece::W_ROOK:
          m_whitePieces[tStatPiece::STAT_ROOK].push_back(iCase);
          break;
        case tPiece::W_KNIGHT:
          m_whitePieces[tStatPiece::STAT_KNIGHT].push_back(iCase);
          break;
        case tPiece::W_BISHOP:
          m_whitePieces[tStatPiece::STAT_BISHOP].push_back(iCase);
          break;
        case tPiece::W_QUEEN:
          m_whitePieces[tStatPiece::STAT_QUEEN].push_back(iCase);
          break;
        case tPiece::B_ROOK:
          m_blackPieces[tStatPiece::STAT_ROOK].push_back(iCase);
          break;
        case tPiece::B_KNIGHT:
          m_blackPieces[tStatPiece::STAT_KNIGHT].push_back(iCase);
          break;
        case tPiece::B_BISHOP:
          m_blackPieces[tStatPiece::STAT_BISHOP].push_back(iCase);
          break;
        case tPiece::B_QUEEN:
          m_blackPieces[tStatPiece::STAT_QUEEN].push_back(iCase);
          break;
        //case tPiece::W_PAWN:
        //case tPiece::B_PAWN:
        //  break;
        //case tPiece::W_KING:
        //case tPiece::B_KING:
        //  break;
        //case tPiece::P_EMPTY:
        //case tPiece::P_SIZE:
        //  break;
        default:
          break;
      }
    }
  }
 
  m_boardData.s_boardData.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_boardData.s_boardData.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());
 
  clearNeedCalcMinorPieces();
}
 
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
 
/**
 * calculate stage of game to assist in evaluation
 */
void bBoard::calcGameStage()
{
  // pre-calculate stage
  if (pieceCount() > 28) {
    /// @todo take into account actual moves
    setGameStage(bGameStage::ST_OPENING);
  } else if (pieceCount() < 14) {
    if (noNeedCalcMinorPieces()) {
      if (m_boardData.s_boardData.whiteminor && m_boardData.s_boardData.blackminor) {
        // both have at least a minor piece
        if ((m_boardData.s_boardData.whiteminor + m_boardData.s_boardData.blackminor) < 4)
          setGameStage(bGameStage::ST_PAWNENDING);
        else
          setGameStage(bGameStage::ST_ENDGAME);
      } else if (m_boardData.s_boardData.whiteminor || m_boardData.s_boardData.blackminor) {
        // one has minor piece
        setGameStage(bGameStage::ST_MATING);
      } else {
        setGameStage(bGameStage::ST_PAWNENDING);
      }
    } else {
      setGameStage(bGameStage::ST_ENDGAME);
    }
  } else {
    setGameStage(bGameStage::ST_UNSPECIFIED);
  }
}
 
std::string bBoard::getGameStageName() const
{
  std::string sStage;
  if (getGameStage() == bGameStage::ST_OPENING) sStage = "Opening";
  else if (getGameStage() == bGameStage::ST_ENDGAME) sStage = "Endgame";
  else if (getGameStage() == bGameStage::ST_MATING) sStage = "Mating";
  else if (getGameStage() == bGameStage::ST_PAWNENDING) sStage = "Pawnending";
  return sStage;
}
 
/**
 * invert colours
 * update kingpos, update colour to move, castle rights, ...
 * @todo castledone, capturedcase, capturedpiece, bmove, 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 = hasCastleRights(tCFlags::WCASTLE_S);
  setCastleRights(tCFlags::WCASTLE_S, hasCastleRights(tCFlags::BCASTLE_S));
  setCastleRights(tCFlags::BCASTLE_S, c);
  c = hasCastleRights(tCFlags::WCASTLE_L);
  setCastleRights(tCFlags::WCASTLE_L, hasCastleRights(tCFlags::BCASTLE_L));
  setCastleRights(tCFlags::BCASTLE_L, c);
  // invert column
  if (whiteToMove()) incPly();
  else decPly();
  // recalculate board data
  calcHash();
  calcMinorPieces(true);
}
 
/**
 * modification of board
 * move is kept on previous board
 * newboard does not have move stored and has flag to recalculate minor pieces
 * @todo check usage in case of failure, why not return exception?
 */
boardInfo_t bBoard::applyMove(bMove const& m)
{
  setMove(m.getFromTo());
  boardInfo_t oldBoardInfo = bBasicBoard::applyMove(m);
  setNeedCalcMinorPieces();
  return oldBoardInfo;
}
 
//-----------------------------------------------------------------------
 
void bBoard::setVariation(bBoard const& chldbrd)
{
  m_variation = chldbrd.getVariation();
  if (chldbrd.getPreviousMoves().back() != "")
    m_variation.insert(m_variation.begin(), chldbrd.getPreviousMoves().back());
}
 
//-----------------------------------------------------------------------
 
/**
 * print board
 * @todo add mate condition
 */
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 << (hasCastleRights(static_cast<uint8_t>(1 << i)) ? "1" : "-");
  if (isEpSet()) ss << " E.p. " << bCase(getEp());
  if (isNonSilent() || isInCheck())
     ss << " QS:" << (isInCheck() ? " Check" : "")
          << (getCapturedPiece() ? " Capture" : "");
 
  if (getGameStageName() != "") ss << " - " << getGameStageName();
 
  return ss.str();
}
 
/**
 * print board
 */
std::ostream& operator<<(std::ostream& os, bBoard const& bd)
{
  os << bd.operator std::string() << "\n";
  return os;
}
 
// eof