basicboard.h

Go to the documentation of this file.

/*---------------------------------------------------------------------+
 * File: basicboard.h
 * Project: part of belofte - A Promising Chess Program
 * Author: yves
 * SPDX-License-Identifier: GPL-2.0-only
+----------------------------------------------------------------------*/
 
#if !defined(BASICBOARD_H)
#define BASICBOARD_H
 
#define KingStartPosW 4
#define KingStartPosB 60
 
enum tCFlags { WCASTLE_S = 1, WCASTLE_L = 2, BCASTLE_S = 4, BCASTLE_L = 8 };
 
typedef
  union boardInfo {
    // ctor initialisation
    boardInfo(uint64_t uiValue): u_boardInfo(uiValue) {}
    uint64_t u_boardInfo;
    // easier through function than inline
    void setCapturedPiece(piece_t p)
      { s_boardInfo.capturedpiece = (s_boardInfo.capturedpiece & 0xF0) | p; }
    piece_t getCapturedPiece() const
      { return static_cast<piece_t>(s_boardInfo.capturedpiece & 0x0F); }
    struct {
      case_t whiteKing;
      case_t blackKing;
      plynum_t ply; // counting from zero for white to move at start position
      movenum50_t ply50moves;
      int8_t pieceCnt; // number of pieces on board (2-32)
      uint8_t flags; /// 4 castling bits, plus incheck flag and capture move
      /// 0b00001111
      ///   ^         position is non silent     (0x80 - 128)
      ///    ^        black has castled          (0x40 - 64)
      ///     ^       white has castled          (0x20 - 32)
      ///      ^      in check                   (0x10 - 16)
      ///       ^     black castle long allowed  (0x08 - 8)
      ///        ^    black castle short allowed (0x04 - 4)
      ///         ^   white castle long allowed  (0x02 - 2)
      ///          ^  white castle short allowed (0x01 - 1)
      uint8_t capturedpiece; // piece captured during executing move, not part
      // of oldflags but of move being executed (optimising return flags)
      /// 0b00001111
      ///   ^         ep column is set           (0x80 - 128)
      ///    ^^^      ep column (0 to 7)         (0x70 - 16 to 127)
      ///       ^^^^  captured piece             (0x0F - 0 to 15)
    } s_boardInfo;
  } boardInfo_t;
 
//-----------------------------------------------------------------------
 
class bBasicBoard {
protected:
  bBasicBoard();
  explicit bBasicBoard(bBasicBoard&& bb)
    : m_boardInfo{std::move(bb.m_boardInfo.u_boardInfo)}
    , m_hash{std::move(bb.m_hash)}
    { memcpy(m_fields, bb.m_fields, sizeof(bb.m_fields)); }
  explicit bBasicBoard(bFen const& fen);
 
  bBasicBoard& operator=(bBasicBoard const& bb)
    { m_boardInfo = bb.m_boardInfo.u_boardInfo;
      m_hash = bb.m_hash;
      memcpy(m_fields, bb.m_fields, sizeof(bb.m_fields));
      return *this;
    }
 
  // no move ctor defined
  bBasicBoard& operator=(bBasicBoard&&) = delete;
 
public:
  explicit bBasicBoard(bBasicBoard const& bb)
    : m_boardInfo{bb.m_boardInfo.u_boardInfo}
    , m_hash{bb.m_hash}
    { memcpy(m_fields, bb.m_fields, sizeof(bb.m_fields)); }
  virtual ~bBasicBoard()
    {}
 
  // move ply
  constexpr plynum_t getPly() const
    { return m_boardInfo.s_boardInfo.ply; }
  /// @todo, does hash need to be updated?
  inline void setPly(plynum_t const p)
    { m_boardInfo.s_boardInfo.ply = p; }
  inline void incPly()
    { ++m_boardInfo.s_boardInfo.ply; }
  inline void decPly()
    { --m_boardInfo.s_boardInfo.ply; }
 
  // ep field is blended into column and flag
  // getting it transforms from column to real case
  // ply must be set beforehand as it indicates where
  // real ep case is on the board
  constexpr bool isEpSet() const
    { return m_boardInfo.s_boardInfo.capturedpiece & 0x80; }
  constexpr case_t getEp() const
    { return bCase::coordToCase(getEpColumn(), blackToMove() ? 2 : 5); }
  constexpr column_t getEpColumn() const
    { // get column for ep, will be 0 to 7
      return ((m_boardInfo.s_boardInfo.capturedpiece >> 4) & 0x07);
    }
 
  // update hash
  void setEp(case_t const e);
  void clearEp();
 
  // 50 moves counter
  constexpr movenum50_t getPly50Moves() const
    { return m_boardInfo.s_boardInfo.ply50moves; }
  inline void setPly50Moves(movenum50_t const p)
    { m_boardInfo.s_boardInfo.ply50moves = p; }
  inline void incPly50Moves()
    { ++m_boardInfo.s_boardInfo.ply50moves; }
  inline void clearPly50Moves()
    { m_boardInfo.s_boardInfo.ply50moves = 0; }
 
  // castle
  constexpr bool hasCastleRights(uint8_t const f) const
    { return m_boardInfo.s_boardInfo.flags & f; }
  inline void setWhiteHasCastled()
    { m_boardInfo.s_boardInfo.flags |= 0x20; }
  inline void setBlackHasCastled()
    { m_boardInfo.s_boardInfo.flags |= 0x40; }
  inline void clearWhiteHasCastled()
    { m_boardInfo.s_boardInfo.flags &= ~(0x20); }
  inline void clearBlackHasCastled()
    { m_boardInfo.s_boardInfo.flags &= ~(0x40); }
  constexpr bool whiteHasCastled() const
    { return m_boardInfo.s_boardInfo.flags & 0x20; }
  constexpr bool blackHasCastled() const
    { return m_boardInfo.s_boardInfo.flags & 0x40; }
  // update hash
  void setCastleRights(uint8_t const f);
  void setCastleRights(uint8_t const f, bool const c);
  void clearCastleRights(uint8_t const f);
 
  constexpr bool isInCheck() const
    { return m_boardInfo.s_boardInfo.flags & 0x10; }
  inline void setInCheck()
    { m_boardInfo.s_boardInfo.flags |= 0x10; }
  inline void clearInCheck()
    { m_boardInfo.s_boardInfo.flags &= ~(0x10); }
 
  constexpr bool isNonSilent() const
    { return m_boardInfo.s_boardInfo.flags & 0x80; }
  inline void setNonSilent()
    { m_boardInfo.s_boardInfo.flags |= 0x80; }
  inline void clearNonSilent()
    { m_boardInfo.s_boardInfo.flags &= ~(0x80); }
 
  constexpr piece_t getCapturedPiece() const
    { return static_cast<piece_t>(m_boardInfo.s_boardInfo.capturedpiece & 0x0F); }
  inline void setCapturedPiece(piece_t p)
    { m_boardInfo.s_boardInfo.capturedpiece &= 0xF0;
      m_boardInfo.s_boardInfo.capturedpiece |= static_cast<uint8_t>(p);
    }
  inline void clearCapturedPiece()
    { m_boardInfo.s_boardInfo.capturedpiece &= 0xF0; }
 
  // board information methods
  constexpr bool whiteToMove() const
    { return ((m_boardInfo.s_boardInfo.ply & 0x0001) == 0); }
  constexpr bool blackToMove() const
    { return (m_boardInfo.s_boardInfo.ply & 0x0001); }
  constexpr int16_t getMoveNumber() const
    { return (m_boardInfo.s_boardInfo.ply >> 1) + 1; }
  constexpr side_t getColourToMove() const
    { // 1 for white, 2 for black
      return static_cast<side_t>((m_boardInfo.s_boardInfo.ply & 0x0001) + 1);
    }
  constexpr bScore minimizing() const
    { // -1 black to move, 1 white to move, this function is used only in bBoard
      return whiteToMove() ? 1 : -1;
    }
 
  // field and piece access methods, no hash update
  constexpr piece_t getPiece(case_t const cf) const
    { return m_fields[cf]; }
  constexpr piece_t getPiece(column_t const iColumn, rank_t const iRank) const
    { return m_fields[bCase::coordToCase(iColumn, iRank)]; }
  inline piece_t getPieceCtl(column_t const iColumn, rank_t const iRank) const
    { // retrieve piece with bounds checking, return field empty in case of out of bounds
      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)];
    }
  inline void setPiece(case_t const cf, piece_t const piece)
    { m_fields[cf] = piece; }
  inline void setPiece(case_t const cf, uint8_t const piece)
    { m_fields[cf] = static_cast<piece_t>(piece); }
  inline piece_t setGetPiece(column_t const newcol, rank_t const newrank,
          piece_t const piece)
    { case_t ct = bCase::coordToCase(newcol, newrank);
      piece_t oldPiece = m_fields[ct];
      m_fields[ct] = piece;
      return oldPiece;
    }
  inline piece_t removePiece(column_t const newcol, rank_t const newrank)
    { case_t ct = bCase::coordToCase(newcol, newrank);
      piece_t oldPiece = m_fields[ct];
      m_fields[ct] = tPiece::P_EMPTY;
      return oldPiece;
    }
  inline void clearPiece(case_t const cf)
    { m_fields[cf] = tPiece::P_EMPTY; }
  constexpr bool isFieldEmpty(case_t const cf) const
    { return !m_fields[cf]; }
  constexpr bool isFieldEmpty(column_t const iColumn, rank_t const iRank) const
    { return !m_fields[bCase::coordToCase(iColumn, iRank)]; }
 
  constexpr case_t getWhiteKingPos() const
    { return m_boardInfo.s_boardInfo.whiteKing; }
  constexpr case_t getBlackKingPos() const
    { return m_boardInfo.s_boardInfo.blackKing; }
 
  // update hash
  void movePiece(case_t const cf, case_t const ct, piece_t const np);
  void swapPiece(case_t const cf, piece_t const op, piece_t const np);
  void clearPiece(case_t const cf, piece_t const op);
  void restorePiece(case_t const cf, piece_t const op);
  void moveWhiteKing(case_t const cf, case_t const ct);
  void moveBlackKing(case_t const cf, case_t const ct);
 
  bFen getFEN() const;
 
  constexpr int8_t pieceCount() const
    { return m_boardInfo.s_boardInfo.pieceCnt; }
 
  std::string getHashStr() const;
  constexpr hashkey_t getHash() const
    { return m_hash; }
  inline void setHash(hashkey_t const newHash)
    { m_hash = newHash; }
 
  // functions used in conjunction with make/unmake
  inline boardInfo_t getBoardInfo() const
    { return m_boardInfo; }
  inline void setBoardInfo(boardInfo_t boardInfo)
    { m_boardInfo = boardInfo; }
 
  virtual boardInfo_t applyMove(bMove const& m);
  boardInfo_t applyWhiteMove(bMove const& m);
  boardInfo_t applyBlackMove(bMove const& m);
  void unApplyMove(bMove const& m, boardInfo_t const oldBoardInfo);
 
  // make and unmake move on board
  // simplified make and unmake move on board, does not cater for
  // keeping all board flags ok
  boardInfo_t makeBoardMove(column_t const oldcol, rank_t const oldrank,
          column_t const newcol, rank_t const newrank);
  void unMakeBoardMove(case_t const& cf, column_t const newcol,
          rank_t const newrank, boardInfo_t const oldBoardInfo);
 
protected:
  // update hash
  void calcHash();
  void capturePieceOn(piece_t const capturedPiece, case_t const ct);
  inline void setPieceKU(case_t const cf, piece_t const piece)
    { // and update king position
      m_fields[cf] = piece;
      if (piece == tPiece::W_KING) m_boardInfo.s_boardInfo.whiteKing = cf;
      else if (piece == tPiece::B_KING) m_boardInfo.s_boardInfo.blackKing = cf;
    }
 
  // piececount
  inline void setPieceCount(int8_t const n)
    { m_boardInfo.s_boardInfo.pieceCnt = n; }
  inline void incPieceCount()
    { ++m_boardInfo.s_boardInfo.pieceCnt; }
  inline void decPieceCount()
    { --m_boardInfo.s_boardInfo.pieceCnt; }
 
private:
  boardInfo_t m_boardInfo;
  hashkey_t m_hash;
 
  piece_t m_fields[64];
};
 
//-----------------------------------------------------------------------
 
#endif // defined BASICBOARD_H
 
// eof