board.h

Go to the documentation of this file.

/*---------------------------------------------------------------------+
 * File: board.h
 * Project: part of belofte - A Promising Chess Program
 * Author: yves
 * SPDX-License-Identifier: GPL-2.0-only
+----------------------------------------------------------------------*/
 
#if !defined(BOARD_H)
#define BOARD_H
 
enum tCFlags { WCASTLE_S = 1, WCASTLE_L = 2, BCASTLE_S = 4, BCASTLE_L = 8 };
 
typedef
  union {
    uint64_t u_positionFlags;
    struct {
      case_t whiteKing;
      case_t blackKing;
      plynum_t ply; // counting from zero for white to move at start position
      case_t ep; // en passant field
      movenum50_t ply50moves;
      uint8_t castling; /// 4 castling bits, plus incheck flag and capture move
      /// 0b00001111
      ///    ^        latest was capture move    (0x40 - 64)
      ///     ^       latest was castle move     (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)
    };
  } u_positionFlags_t;
 
//-----------------------------------------------------------------------
 
class bBasicBoard {
protected:
  bBasicBoard();
  explicit bBasicBoard(bBasicBoard const& bb);
  explicit bBasicBoard(bBasicBoard&& bb);
  explicit bBasicBoard(bFen const& fen);
  virtual ~bBasicBoard();
 
  // no move ctor nor assignment defined
  bBasicBoard& operator=(bBasicBoard const&) = delete;
  bBasicBoard& operator=(bBasicBoard&&) = delete;
 
public:
  // move ply
  plynum_t getPly() const { return m_ply; }
  void setPly(plynum_t const p) { m_ply = p; }
  void incPly() { ++m_ply; }
  void decPly() { --m_ply; }
 
  // e.p. case
  case_t getEp() const { return m_ep; }
  void setEp(case_t const e);
  void clearEp() { m_ep = tHSpecial::HP_NOEP; }
 
  // 50 moves counter
  movenum50_t getPly50Moves() const { return m_ply50moves; }
  void setPly50Moves(movenum50_t const p) { m_ply50moves = p; }
  movenum50_t incPly50Moves() { return ++m_ply50moves; }
  void clearPly50Moves() { m_ply50moves = 0; }
 
  // castle
  bool canCastle() const;
  bool canCastle(uint8_t const f) const;
  void setCastle(uint8_t const f);
  void setCastle(uint8_t const f, bool const c);
  void clearCastle(uint8_t const f);
 
  bool isInCheck() const;
  virtual void setInCheck();
  void clearInCheck();
 
  // board information methods
  bool whiteToMove() const { return ((m_ply & 0x0001) == 0); }
  int16_t getMoveNumber() const { return (m_ply >> 1) + 1; }
  side_t getColourToMove() const {
    return static_cast<side_t>((m_ply & 0x0001) + 1); } /// 1 for white, 2 for black
 
  // field and piece access methods
  piece_t getPiece(case_t const bc) const;
  piece_t getPiece(column_t const iColumn, rank_t const iRank) const;
  piece_t getPieceCtl(column_t const iColumn, rank_t const iRank) const;
  void setPiece(case_t const bc, piece_t const piece);
  void setPiece(case_t const bc, uint8_t const piece);
  piece_t setGetPiece(column_t const newcol, rank_t const newrank,
                      piece_t const piece);
  piece_t removePiece(column_t const newcol, rank_t const newrank);
  void movePiece(case_t const f, case_t const t, piece_t const p);
  void swapPiece(case_t const t, piece_t const op, piece_t const np);
  void clearPiece(case_t const bc);
  void moveWhiteKing(case_t const f, case_t const t);
  void moveBlackKing(case_t const f, case_t const t);
  bool isFieldEmpty(case_t const bc) const;
  bool isFieldEmpty(column_t const iColumn, rank_t const iRank) const;
  virtual void setCapture(piece_t const p, case_t const c);
  case_t getWhiteKingPos() const { return m_whiteKing; }
  case_t getBlackKingPos() const { return m_blackKing; }
  bFen getFEN() const;
  std::string getHashStr() const;
  hashkey_t getHash() const { return m_hash; }
  void setHash(hashkey_t const newHash) { m_hash = newHash; }
 
  // make and unmake move on board
  u_positionFlags_t makeBoardMove(column_t const oldcol,
                        rank_t const oldrank, column_t const newcol,
                        rank_t const newrank, piece_t const promotion);
  void unMakeBoardMove(case_t const& cf, column_t const newcol,
                       rank_t const newrank, u_positionFlags_t const oldFlags,
                       piece_t const promotion);
 
protected:
  void calcHash(); /// calculate and set hash
  void setPieceKU(case_t const bc, piece_t const piece); // and update king position
 
  union {
    uint64_t u_positionFlags = 0ULL; // initialise all subsequent fields to 0
    struct {
      case_t m_whiteKing;
      case_t m_blackKing;
      plynum_t m_ply; // counting from zero for white to move at start position
      case_t m_ep; // en passant field
      movenum50_t m_ply50moves;
      uint8_t m_castling; /// 4 castling bits as uints as copy ctor stumbles on bool array
      piece_t m_capturedpiece; /// @todo move to bBoard
    };
  };
  hashkey_t m_hash;
 
private:
  std::array<piece_t, 64> m_fields;
};
 
//-----------------------------------------------------------------------
 
typedef std::vector<std::string> movesequence_t;
enum class bGameStage { ST_UNKNOWN = 0, ST_OPENING, ST_ENDGAME, ST_PAWNENDING, ST_MATING };
 
//-----------------------------------------------------------------------
 
/** board */
class bBoard final : public bBasicBoard {
public:
  explicit bBoard(bBoard&& b) noexcept;
  explicit bBoard(bBoard const& b);
  explicit bBoard(bBoard const& b, movenum_t const moveid);
  explicit bBoard(bBoard const& b, bMove const& m);
  explicit bBoard(bBoard const& b, bMove& m);
  explicit bBoard(bFen const& fen);
  ~bBoard() override;
 
  // no move ctor nor assignment defined
  bBoard& operator=(bBoard const&) = delete;
  bBoard& operator=(bBoard&&) = delete;
 
  operator std::string() const;
 
  bool atLeastOneMovePossible() const;
  bMoveList& getMoveListRef();
  bMove const& getMove(movenum_t const moveid) const;
 
  void calcPieces(); /// calculate pieces
  void calcGameStage(); /// calculate gamestage
 
  bool isNonSilent() const { return m_bNonSilent; }
  void setNonSilent() { m_bNonSilent = true; }
  bool isCapture() const { return m_capturedpiece; }
  void setCapture(piece_t const p, case_t const c) override;
  void setInCheck() final;
 
  void invertColours();
  bGameStage getStage() const { return m_gamestage; }
  bScore getBoardEvaluation() const { return m_boardeval; }
  void setBoardEvaluation(bScore const s) { m_boardeval = s; }
  bScore minimizing() const { return whiteToMove() ? 1 : -1; } /// -1 black to move, 1 white to move
  bool castleDoneWhite() const { return m_castledoneWhite; }
  bool castleDoneBlack() const { return m_castledoneBlack; }
  void setCastleDoneWhite(bool const c) { m_castledoneWhite = c; }
  void setCastleDoneBlack(bool const c) { m_castledoneBlack = c; }
 
  movesequence_t const& getPreviousMoves() const { return m_previousmoves; }
  void setPreviousMoves(movesequence_t const& v) { m_previousmoves = v; }
  basicmove_t const& getMovePlayed() const { return m_moveplayed; }
  movesequence_t const& getVariation() const { return m_variation; }
  void clearVariation();
  void setVariation(bBoard const& chldbrd);
 
protected:
  friend class bPositionEvaluation;
  friend class PosEvalPositionalBoard;
  friend class bWhitePiece;
  friend class bBlackPiece;
 
private:
  friend std::ostream& operator<<(std::ostream& os, bBoard const& dt);
 
private:
  void applyMove(bMove const& m);
  void applyWhiteMove(bMove const& m);
  void applyBlackMove(bMove const& m);
 
  union {
    uint64_t u_boardFlags1 = 0ULL; // initialise all subsequent fields to 0
    struct {
      basicmove_t m_moveplayed; // = 0;
      uint8_t m_bNonSilent; // = false; /// used for promotion, capture and in-check
      uint8_t m_piecesonboard; // = 0;
      uint8_t m_whiteminor;
      uint8_t m_blackminor;
      bGameStage m_gamestage; // = bGameStage::ST_UNKNOWN;
      case_t m_capturedcase; // = 0;
    };
  };
 
  union {
    uint32_t u_boardFlags2; // initialise all subsequent fields to 0
    struct {
      uint8_t m_castledoneWhite;
      uint8_t m_castledoneBlack;
      bScore m_boardeval = SCORE_UNDEFINED; /// result of board evaluation
    };
  };
 
  bMoveList m_moves; // moves possible in position
 
  // postbox representation of board
  std::array<caselist_t ,tStatPiece::STAT_SIZE> m_whitePieces;
  std::array<caselist_t ,tStatPiece::STAT_SIZE> m_blackPieces;
 
  movesequence_t m_variation; /// variation leading to score
  movesequence_t m_previousmoves; /// movesequence to get here
};
 
// --------------------------------------------------------------------
 
#endif // defined BOARD_H
 
// eof