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 class bGameStage { ST_UNKNOWN = 0, ST_OPENING, ST_ENDGAME, ST_PAWNENDING, ST_MATING };
enum tCFlags { WCASTLE_S = 0, WCASTLE_L, BCASTLE_S, BCASTLE_L, CASTLE_SIZE };
 
//-----------------------------------------------------------------------
 
/** FEN string */
class bFen final {
public:
  explicit bFen(std::string const& fs);
  bFen(bFen&& f);
  ~bFen();
 
  // no copy or move ctor nor assignment defined
  bFen(bFen const&) = delete;
  bFen& operator=(bFen const&) = delete;
  bFen& operator=(bFen&&) = delete;
 
  operator std::string() const;
 
private:
  friend std::ostream& operator<<(std::ostream& os, bFen const& f);
 
private:
  std::string m_fen;
};
 
//-----------------------------------------------------------------------
 
class bBasicBoard {
protected:
  bBasicBoard();
  explicit bBasicBoard(bFen const& fen);
  virtual ~bBasicBoard();
 
  bBasicBoard(bBasicBoard const&) = default;
  bBasicBoard(bBasicBoard&&) = default;
 
  // no move ctor nor assignment defined
  bBasicBoard& operator=(bBasicBoard const&) = delete;
  bBasicBoard& operator=(bBasicBoard&&) = delete;
 
public:
  // access methods
  int16_t getPly() const { return m_ply; }
  void setPly(int16_t const p) { m_ply = p; }
 
  case_t getEp() const { return m_ep; }
  void setEp(case_t const e);
  int16_t getPly50Moves() const { return m_ply50moves; }
  void setPly50Moves(int16_t const p) { m_ply50moves = p; }
 
  bool canCastle(uint8_t const f) const;
  void setCastle(uint8_t const f, bool const c);
  void clearCastle(uint8_t const f);
 
  // 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 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 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);
 
  bFen getFEN() const;
  std::string getHashStr() const;
 
protected:
  void setPieceKU(case_t const bc, piece_t const piece); // and update king position
  case_t getWhiteKingPos() const { return m_whiteKing; }
  case_t getBlackKingPos() const { return m_blackKing; }
  void calcHash(); /// calculate and set hash
  hashkey_t getHash() const { return m_hash; }
 
  hashkey_t m_hash;
  piece_t m_capturedpiece = tPiece::P_EMPTY;
 
private:
  uint8_t m_castling = 0; // white king, queen, black king, queen castle rights
  case_t m_whiteKing;
  case_t m_blackKing;
  std::array<piece_t, 64> m_fields;
  int16_t m_ply = 0; // counting from zero for white to move at start position
  case_t m_ep = tHSpecial::HP_NOEP; // en passant field
  int16_t m_ply50moves = 0;
};
 
//-----------------------------------------------------------------------
 
/** board */
class bBoard final : public bBasicBoard {
public:
  bBoard(bBoard&& b) noexcept;
  explicit bBoard(bBoard const& b, bMove const& m, move_t const& mt);
  explicit bBoard(bBoard const& b, bMove const& m);
  explicit bBoard(bFen const& fen);
  ~bBoard() override;
 
  // no move ctor nor assignment defined
  bBoard(bBoard const&) = delete;
  bBoard& operator=(bBoard const&) = delete;
  bBoard& operator=(bBoard&&) = delete;
 
  /// do full initialisation
  void delayed_ctor(bool const& needMaterialUpdate = true);
 
  operator std::string() const;
 
  bMoveList& getMoves();
  movenum_t getNumberOfMoves() const;
  movenum_t generateMoves();
  movenum_t generateAtLeastOneMove();
  movenum_t generateAtLeastOneQSMove();
 
  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;
  bool isInCheck() const { return m_bInCheck; }
  void setInCheck() { m_bInCheck = true; m_bNonSilent = true; }
  bool isMate() const { return m_bIsMate; }
  void setMate() { m_bIsMate = true; }
 
  void invert();
  bGameStage getStage() const { return m_gamestage; }
  bScore getBoardEvaluation() const { return m_boardeval; }
  void setBoardEvaluation(bScore const s) { m_boardeval = s; }
  bScore getMaterialEvaluation() const { return m_materialeval; }
  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 getPreviousMoves() const { return m_previousmoves; }
  void clearPreviousMoves() { m_previousmoves = {}; }
  move_t getMovePlayed() const { return m_moveplayed; }
  movesequence_t getVariation() const { return m_variation; }
  void clearVariation();
  void setVariation(bBoard const& chldbrd);
  uint8_t getPiecesOnBoard() const { return m_piecesonboard; }
 
protected:
  friend class bGame;
  friend class bMoveList;
  friend class bPositionEvaluation;
  friend class PosEvalPositionalBoard;
 
protected:
  bMoveList* m_moves = nullptr; // moves possible in position
 
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);
 
  void calcPieces(); /// calculate pieces
  void calcMaterial(); /// calculate material score
  void calcGameStage(); /// calculate gamestage
 
  bool m_fullyinitialised = false;
  move_t m_moveplayed = 0;
  uint8_t m_piecesonboard = 0;
 
  // postbox representation of board
  std::array<caselist_t ,tStatPiece::STAT_SIZE> m_whitePieces;
  std::array<caselist_t ,tStatPiece::STAT_SIZE> m_blackPieces;
 
  bGameStage m_gamestage = bGameStage::ST_UNKNOWN;
  uint8_t m_whiteminor = 0;
  uint8_t m_blackminor = 0;
 
  case_t m_capturedcase = 0;
  bool m_bNonSilent = false; /// used for promotion, capture and in-check
  bool m_bInCheck = false;
  bool m_bIsMate = false;
 
  bool m_castledoneWhite;
  bool m_castledoneBlack;
 
  bScore m_boardeval = SCORE_UNDEFINED; /// result of board evaluation
  bScore m_materialeval = SCORE_UNDEFINED; /// materialevaluation
  movesequence_t m_variation; /// variation leading to score
  movesequence_t m_previousmoves; /// movesequence to get here
};
 
// --------------------------------------------------------------------
 
#endif // defined BOARD_H
 
// eof