basicboard.cpp

Go to the documentation of this file.

/*---------------------------------------------------------------------+
 * File: basicboard.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
 
bBasicBoard::bBasicBoard(bFen const& fen)
  : m_boardInfo{0ULL}
{
  memset(m_fields, 0, sizeof(m_fields));
 
  // 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
    setCastleRights(tCFlags::WCASTLE_S, fenParts[2].find('K') != std::string::npos);
    setCastleRights(tCFlags::WCASTLE_L, fenParts[2].find('Q') != std::string::npos);
    setCastleRights(tCFlags::BCASTLE_S, fenParts[2].find('k') != std::string::npos);
    setCastleRights(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 += hasCastleRights(tCFlags::WCASTLE_S) ? "K" : "";
  castl += hasCastleRights(tCFlags::WCASTLE_L) ? "Q" : "";
  castl += hasCastleRights(tCFlags::BCASTLE_S) ? "k" : "";
  castl += hasCastleRights(tCFlags::BCASTLE_L) ? "q" : "";
  strfen += castl.size() ? castl : "-";
 
  if (isEpSet()) {
    strfen += " " + std::string(bCase(getEp())) + " ";
  } else {
    strfen += " - ";
  }
  strfen += belofte::to_string(getPly50Moves()) + " " + belofte::to_string(getMoveNumber());
 
  return bFen(strfen);
}
 
//-----------------------------------------------------------------------
 
/**
 * set ep case, it will actually be stored as column only
 * rank will be calculated based on side to move
 * function is never called to clear ep case or when ep is not set
 */
void bBasicBoard::setEp(case_t const e)
{
  if (isEpSet()) {
    // ep case was already set, change it
    // flag does not need to be changed
    // clear hash of old ep field
    m_hash ^= hashmultiplexer[tPiece::P_EMPTY][getEp()];
    m_boardInfo.s_boardInfo.capturedpiece &= 0x8F;
  } else {
    // set flag
    m_boardInfo.s_boardInfo.capturedpiece |= 0x80;
  }
 
  m_boardInfo.s_boardInfo.capturedpiece |= bCase::column(e) << 4;
 
  // update hash
  m_hash ^= hashmultiplexer[tPiece::P_EMPTY][getEp()];
}
 
void bBasicBoard::clearEp()
{
  if (isEpSet()) {
    m_hash ^= hashmultiplexer[tPiece::P_EMPTY][getEp()];
    // clear flag and ep column
    m_boardInfo.s_boardInfo.capturedpiece &= 0x0F;
  }
}
 
//-----------------------------------------------------------------------
 
void bBasicBoard::setCastleRights(uint8_t const f, bool const c)
{
  if (c) setCastleRights(f);
  else clearCastleRights(f);
}
 
void bBasicBoard::setCastleRights(uint8_t const f)
{
  if (!(m_boardInfo.s_boardInfo.flags & f)) {
    m_boardInfo.s_boardInfo.flags |= f;
    /// there can be (is) a difference in the offsets in the hash table and the castle flags
    /// @todo what happens if 2 rights are set together or one by one
    m_hash ^= hashmultiplexer[tPiece::P_EMPTY][f];
  }
}
 
void bBasicBoard::clearCastleRights(uint8_t const f)
{
  if (m_boardInfo.s_boardInfo.flags & f) {
    m_boardInfo.s_boardInfo.flags &= 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
    /// @todo what happens if 2 rights are cleared together or one by one
    m_hash ^= hashmultiplexer[tPiece::P_EMPTY][f];
  }
}
 
/**
 * Clear castle flag if rook captured
 * update piece counter, update hash, clear field
 */
void bBasicBoard::capturePieceOn(piece_t const capturedPiece, case_t const ct)
{
  setNonSilent();
  setCapturedPiece(capturedPiece);
  decPieceCount();
  clearPly50Moves();
  if (capturedPiece == tPiece::W_ROOK) {
    if (ct == 7) {
      clearCastleRights(tCFlags::WCASTLE_S);
    } else if (ct == 0) {
      clearCastleRights(tCFlags::WCASTLE_L);
    }
  } else if (capturedPiece == tPiece::B_ROOK) {
    if (ct == 63) {
      clearCastleRights(tCFlags::BCASTLE_S);
    } else if (ct == 56) {
      clearCastleRights(tCFlags::BCASTLE_L);
    }
  }
}
 
void bBasicBoard::movePiece(case_t const cf, case_t const ct, piece_t const np)
{
  m_fields[cf] = tPiece::P_EMPTY;
  m_fields[ct] = np;
  m_hash ^= hashmultiplexer[np][cf] ^ hashmultiplexer[np][ct];
}
 
void bBasicBoard::swapPiece(case_t const cf, piece_t const op, piece_t const np)
{
  m_fields[cf] = np;
  m_hash ^= hashmultiplexer[op][cf] ^ hashmultiplexer[np][cf];
}
 
void bBasicBoard::clearPiece(case_t const cf, piece_t const op)
{
  m_fields[cf] = tPiece::P_EMPTY;
  m_hash ^= hashmultiplexer[op][cf];
}
 
void bBasicBoard::restorePiece(case_t const cf, piece_t const op)
{
  m_fields[cf] = op;
  m_hash ^= hashmultiplexer[op][cf];
}
 
void bBasicBoard::moveWhiteKing(case_t const cf, case_t const ct)
{
  m_fields[cf] = tPiece::P_EMPTY;
  m_fields[ct] = tPiece::W_KING;
  m_hash ^= hashmultiplexer[tPiece::W_KING][cf] ^ hashmultiplexer[tPiece::W_KING][ct];
  m_boardInfo.s_boardInfo.whiteKing = ct;
}
 
void bBasicBoard::moveBlackKing(case_t const cf, case_t const ct)
{
  m_fields[cf] = tPiece::P_EMPTY;
  m_fields[ct] = tPiece::B_KING;
  m_hash ^= hashmultiplexer[tPiece::B_KING][cf] ^ hashmultiplexer[tPiece::B_KING][ct];
  m_boardInfo.s_boardInfo.blackKing = ct;
}
 
//-----------------------------------------------------------------------
 
/**
 * 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 check increase to 64 bits, is there added value
 */
void bBasicBoard::calcHash()
{
  hashkey_t hash = HASH_INIT;
  setPieceCount(0);
  for (case_t iCase = 0; iCase < 64; ++iCase) {
    int piece = getPiece(iCase);
    if (piece) {
      hash ^= hashmultiplexer[piece][iCase];
      incPieceCount();
    }
  }
 
  if (hasCastleRights(tCFlags::WCASTLE_S))
    hash ^= hashmultiplexer[tPiece::P_EMPTY][static_cast<uint8_t>(tHSpecial::HP_CASTLE_FL) + static_cast<uint8_t>(tCFlags::WCASTLE_S)];
  if (hasCastleRights(tCFlags::WCASTLE_L))
    hash ^= hashmultiplexer[tPiece::P_EMPTY][static_cast<uint8_t>(tHSpecial::HP_CASTLE_FL) + static_cast<uint8_t>(tCFlags::WCASTLE_L)];
  if (hasCastleRights(tCFlags::BCASTLE_S))
    hash ^= hashmultiplexer[tPiece::P_EMPTY][static_cast<uint8_t>(tHSpecial::HP_CASTLE_FL) + static_cast<uint8_t>(tCFlags::BCASTLE_S)];
  if (hasCastleRights(tCFlags::BCASTLE_L))
    hash ^= hashmultiplexer[tPiece::P_EMPTY][static_cast<uint8_t>(tHSpecial::HP_CASTLE_FL) + static_cast<uint8_t>(tCFlags::BCASTLE_L)];
 
  // use hash of field 0 or any of the ep fields
  if (isEpSet()) hash ^= hashmultiplexer[tPiece::P_EMPTY][getEp()];
 
  // set bit 63 (odd material)
  if (pieceCount() & 0x01) hash |= HASH_ODDMATERIAL;
 
  // set bit 64 (black to move)
  if (getColourToMove() == tSide::SIDE_BLACK) hash |= HASH_BLACKTOMOVE;
 
  m_hash = hash;
}
 
//-----------------------------------------------------------------------
 
/**
 * play game move on board
 * @return boardinfo - of basicboard
 */
boardInfo_t bBasicBoard::applyMove(bMove const& m)
{
  if (getColourToMove() == tSide::SIDE_WHITE) {
    return applyWhiteMove(m);
  }
  return applyBlackMove(m);
}
 
//-----------------------------------------------------------------------
 
boardInfo_t bBasicBoard::applyWhiteMove(bMove const& m)
{
  // keep old flags
  boardInfo_t oldBoardInfo(m_boardInfo.u_boardInfo);
 
  case_t cf = m.from();
  case_t ct = m.to();
  piece_t piece = getPiece(cf);
  piece_t capturedPiece = tPiece::P_EMPTY;
 
  if (piece == tPiece::W_PAWN) {
    if (m.isEPMove()) {
      capturedPiece = tPiece::B_PAWN;
      clearPiece(bCase::coordToCase(m.tocolumn(), m.fromrank()), capturedPiece);
    } else if (m.isCapture()) {
      capturedPiece = getPiece(ct);
      clearPiece(ct, capturedPiece);
    } else {
      clearPly50Moves();
    }
    movePiece(cf, ct, tPiece::W_PAWN);
    if (m.isPromotion()) {
      swapPiece(ct, tPiece::W_PAWN, m.getWhitePromotionPiece());
      clearEp(); // clear ep flag
    } else {
      if (m.isEPPossible()) {
        /// @todo add functions such as nextrank
        setEp(bCase::coordToCase(m.tocolumn(), m.fromrank() + 1));
      } else {
        clearEp(); // clear ep flag
      }
    }
  } else {
    // other pieces: King, Queen, Rook, Knight, Bishop
    clearEp(); // clear ep flag
    if (m.isCapture()) {
      capturedPiece = getPiece(ct);
      clearPiece(ct, capturedPiece);
    } else {
      incPly50Moves();
    }
    if (piece == tPiece::W_KING) {
      moveWhiteKing(cf, ct);
      if (m.isCastleMove()) {
        if (m.isLongCastleMove()) {
          movePiece(0, 3, tPiece::W_ROOK);
        } else {
          movePiece(7, 5, tPiece::W_ROOK);
        }
        setWhiteHasCastled();
      }
      clearCastleRights(tCFlags::WCASTLE_S);
      clearCastleRights(tCFlags::WCASTLE_L);
    } else {
      movePiece(cf, ct, piece);
      if (piece == tPiece::W_ROOK) {
        if (cf == 0) {
          clearCastleRights(tCFlags::WCASTLE_L);
        } else if (cf == 7) {
          clearCastleRights(tCFlags::WCASTLE_S);
        }
      }
    }
  }
 
  /// @todo flag mate/stalemate move, special move, ...
  if (m.isCheck()) {
    setInCheck(); /// @todo check do we need to look for mate here ?
  } else {
    clearInCheck();
  }
  m_hash |= HASH_BLACKTOMOVE;
 
  if (capturedPiece) {
    capturePieceOn(capturedPiece, ct);
  } else {
    clearCapturedPiece();
  }
  incPly();
 
  return oldBoardInfo;
}
 
boardInfo_t bBasicBoard::applyBlackMove(bMove const& m)
{
  // keep old flags
  boardInfo_t oldBoardInfo(m_boardInfo.u_boardInfo);
 
  case_t cf = m.from();
  case_t ct = m.to();
  piece_t piece = getPiece(cf);
  piece_t capturedPiece = tPiece::P_EMPTY;
 
  if (piece == tPiece::B_PAWN) {
    if (m.isEPMove()) {
      capturedPiece = tPiece::W_PAWN;
      clearPiece(bCase::coordToCase(m.tocolumn(), m.fromrank()), capturedPiece);
    } else if (m.isCapture()) {
      capturedPiece = getPiece(ct);
      clearPiece(ct, capturedPiece);
    } else {
      clearPly50Moves();
    }
    movePiece(cf, ct, tPiece::B_PAWN);
    if (m.isPromotion()) {
      swapPiece(ct, tPiece::B_PAWN, m.getBlackPromotionPiece());
      clearEp(); // clear ep flag
    } else {
      if (m.isEPPossible()) {
        /// @todo add functions such as nextrank
        setEp(bCase::coordToCase(m.tocolumn(), m.fromrank() - 1));
      } else {
        clearEp(); // clear ep flag
      }
    }
  } else {
    // other pieces: King, Queen, Rook, Knight, Bishop
    clearEp(); // clear ep flag
    if (m.isCapture()) {
      capturedPiece = getPiece(ct);
      clearPiece(ct, capturedPiece);
    } else {
      incPly50Moves();
    }
    if (piece == tPiece::B_KING) {
      moveBlackKing(cf, ct);
      if (m.isCastleMove()) {
        if (m.isLongCastleMove()) {
          movePiece(56, 59, tPiece::B_ROOK);
        } else {
          movePiece(63, 61, tPiece::B_ROOK);
        }
        setBlackHasCastled();
      }
      clearCastleRights(tCFlags::BCASTLE_S);
      clearCastleRights(tCFlags::BCASTLE_L);
    } else {
      movePiece(cf, ct, piece);
      if (piece == tPiece::B_ROOK) {
        if (cf == 56) {
          clearCastleRights(tCFlags::BCASTLE_L);
        } else if (cf == 63) {
          clearCastleRights(tCFlags::BCASTLE_S);
        }
      }
    }
  }
 
  /// @todo flag mate/stalemate move, special move, ...
  if (m.isCheck()) {
    setInCheck(); /// @todo check do we need to look for mate here ?
  } else {
    clearInCheck();
  }
  m_hash &= ~HASH_BLACKTOMOVE;
 
  if (capturedPiece) {
    capturePieceOn(capturedPiece, ct);
  } else {
    clearCapturedPiece();
  }
  incPly();
 
  return oldBoardInfo;
}
 
/**
 * exact restoration of basic board using move details
 */
void bBasicBoard::unApplyMove(bMove const& m, boardInfo_t const oldBoardInfo)
{
  case_t ct = m.to();
  case_t cf = m.from();
 
  if (getColourToMove() == tSide::SIDE_BLACK) {
    // when undoing move, we have not decreased ply yet, so
    // colour to move is inverted
    // tSide::SIDE_WHITE
    if (m.isEPMove()) {
      movePiece(ct, cf, tPiece::W_PAWN);
      restorePiece(bCase::coordToCase(m.tocolumn(), 4), tPiece::B_PAWN);
    } else {
      piece_t piece = getPiece(ct);
      clearPiece(ct, piece);
      if (getCapturedPiece()) {
        restorePiece(ct, getCapturedPiece());
      }
      if (m.isPromotion()) {
        restorePiece(cf, tPiece::W_PAWN);
      } else {
        restorePiece(cf, piece);
        if (m.isCastleMove()) {
          if (m.isLongCastleMove()) {
            movePiece(3, 0, tPiece::W_ROOK);
          } else {
            // short un-castle
            movePiece(5, 7, tPiece::W_ROOK);
          }
        }
      }
    }
    m_hash &= ~HASH_BLACKTOMOVE;
  } else {
    // tSide::SIDE_BLACK
    if (m.isEPMove()) {
      movePiece(ct, cf, tPiece::B_PAWN);
      restorePiece(bCase::coordToCase(m.tocolumn(), 3), tPiece::W_PAWN);
    } else {
      piece_t piece = getPiece(ct);
      clearPiece(ct, piece);
      if (getCapturedPiece()) {
        restorePiece(ct, getCapturedPiece());
      }
      if (m.isPromotion()) {
        restorePiece(cf, tPiece::B_PAWN);
      } else {
        restorePiece(cf, piece);
        if (m.isCastleMove()) {
          if (m.isLongCastleMove()) {
            movePiece(59, 56, tPiece::B_ROOK);
          } else {
            // short un-castle
            movePiece(61, 63, tPiece::B_ROOK);
          }
        }
      }
    }
    m_hash |= HASH_BLACKTOMOVE;
  }
  // set ply, kingpos, captured piece, castle flags, ...
  m_boardInfo.u_boardInfo = oldBoardInfo.u_boardInfo;
}
 
/**
 * 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.
 * promotion is not executed, pawn is kept at promotion place
 * @param oldcol column from
 * @param oldrank rank from
 * @param newcol column to
 * @param newrank rank to
 * @return boardinfo and captured piece
 */
boardInfo_t bBasicBoard::makeBoardMove(column_t const oldcol, rank_t const oldrank,
        column_t const newcol, rank_t const newrank)
{
  // keep old flags
  boardInfo_t oldBoardInfo(m_boardInfo.u_boardInfo);
 
  piece_t piece = removePiece(oldcol, oldrank); // clear from square
 
  // in case of capture, we return captured piece
  oldBoardInfo.setCapturedPiece(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));
          oldBoardInfo.setCapturedPiece(tPiece::P_SIZE); // this is a special hack to allow
          // unmake move to restore ep move
        }
      }
    } else if (piece == tPiece::W_KING) {
      m_boardInfo.s_boardInfo.whiteKing = bCase::coordToCase(newcol, newrank);
      if ((newcol - oldcol) == 2) {
        // short castle
        clearPiece(7);
        setPiece(5, tPiece::W_ROOK);
      } else if ((newcol - oldcol) == -2) {
        // long castle
        clearPiece(0);
        setPiece(3, 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));
          oldBoardInfo.setCapturedPiece(tPiece::P_SIZE); // this is a special hack to allow
          // unmake move to restore ep move
        }
      }
    } else if (piece == tPiece::B_KING) {
      m_boardInfo.s_boardInfo.blackKing = bCase::coordToCase(newcol, newrank);
      if ((newcol - oldcol) == 2) {
        // short castle
        clearPiece(63);
        setPiece(61, tPiece::B_ROOK);
      } else if ((newcol - oldcol) == -2) {
        // long castle
        clearPiece(56);
        setPiece(59, tPiece::B_ROOK);
      }
    }
  }
  incPly();
  return oldBoardInfo;
}
 
/**
 * undo makeBoardMove, restoring previous situation
 * @param cf case from
 * @param newcol column to
 * @param newrank rank to
 * @param oldBoardInfo the boardInfo of the old position
 * Note: does not undo promotion properly
 */
void bBasicBoard::unMakeBoardMove(case_t const& cf,
        column_t const newcol, rank_t const newrank,
        boardInfo_t const oldBoardInfo)
{
  case_t ct = bCase::coordToCase(newcol, newrank);
  piece_t piece = getPiece(ct);
 
  setPiece(cf, piece);
  if ((oldBoardInfo.s_boardInfo.capturedpiece & 0x0F) == 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, (oldBoardInfo.s_boardInfo.capturedpiece & 0x0F)); // can be tPiece::P_EMPTY as well
    if (getColourToMove() == tSide::SIDE_WHITE) {
      if (piece == tPiece::W_KING) {
        m_boardInfo.s_boardInfo.whiteKing = cf;
        column_t oldcol = bCase::column(cf);
        if ((newcol - oldcol) == 2) {
          // short un-castle
          setPiece(7, tPiece::W_ROOK);
          clearPiece(5);
        } else if ((newcol - oldcol) == -2) {
          // long un-castle
          setPiece(0, tPiece::W_ROOK);
          clearPiece(3);
        }
      }
    } else {
      // tSide::SIDE_BLACK
      if (piece == tPiece::B_KING) {
        m_boardInfo.s_boardInfo.blackKing = cf;
        column_t oldcol = bCase::column(cf);
        if ((newcol - oldcol) == 2) {
          // short un-castle
          setPiece(63, tPiece::B_ROOK);
          clearPiece(61);
        } else if ((newcol - oldcol) == -2) {
          // long un-castle
          setPiece(56, tPiece::B_ROOK);
          clearPiece(59);
        }
      }
    }
  }
  // set ply, kingpos, captured piece, castle flags, ...
  m_boardInfo.u_boardInfo = oldBoardInfo.u_boardInfo;
}
 
//-----------------------------------------------------------------------
 
std::string bBasicBoard::getHashStr() const
{
  std::stringstream ss;
  ss << std::nouppercase << std::setfill('0')
          << std::setw(16) << std::hex << m_hash;
  return ss.str();
}
 
//-----------------------------------------------------------------------
 
// eof