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
 
//-----------------------------------------------------------------------
 
typedef std::vector<std::string> movesequence_t;
enum class bGameStage { ST_NOTSET = 0, ST_UNSPECIFIED,
        ST_OPENING, ST_ENDGAME, ST_PAWNENDING, ST_MATING };
typedef std::array<caselist_t ,tStatPiece::STAT_SIZE> piecepostbox_t;
 
typedef
  union boardData {
    boardData(uint64_t uiValue): u_boardData(uiValue) {}
    uint64_t u_boardData = 0ULL; // initialise all subsequent fields to 0
    struct {
      uint8_t boardFlags; // = bGameStage::ST_NOTSET && needCalcMinorPieces = true
      /// 0b00001111
      ///   ^         0 = NeedCalcMinorPieces    (0x80 - 128)
      ///    ^        unused                     (0x40 - 64)
      ///     ^       unused                     (0x20 - 32)
      ///      ^      unused                     (0x10 - 16)
      ///       ^^^^  gameStage                  (0x0F - 0 to 15)
      case_t capturedcase; // = 0;
      uint8_t whiteminor; // = 0; // updated through calcMinorPieces
      uint8_t blackminor; // = 0; // updated through calcMinorPieces
      bmove_t moveplayed; // = 0;
    } s_boardData;
  } boardData_t;
 
//-----------------------------------------------------------------------
 
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Weffc++"
#endif
 
/** board */
class bBoard : public bBasicBoard {
public:
  explicit bBoard(bBoard const& b); // board with limited data
  explicit bBoard(bBoard const& b, bMove& m); // board with including move history
  explicit bBoard(bFen const& fen);
  ~bBoard() override
    {}
 
  bBoard& operator=(bBoard const& b)
    { bBasicBoard::operator=(b);
      m_boardData     = b.m_boardData.u_boardData;
      m_whitePieces   = b.m_whitePieces;
      m_blackPieces   = b.m_blackPieces;
      m_variation     = b.m_variation;
      m_previousmoves = b.m_previousmoves;
      return *this;
    }
 
  // no move ctor defined
  bBoard& operator=(bBoard&& b) = delete;
 
  void invertColours();
 
  constexpr bGameStage getGameStage() const
    { return static_cast<bGameStage>(m_boardData.s_boardData.boardFlags & 0x0F); }
  inline void clearGameStage()
    { setGameStage(bGameStage::ST_NOTSET); }
  std::string getGameStageName() const;
 
  void calcGameStage();
 
  constexpr bool needCalcMinorPieces() const
    { return m_boardData.s_boardData.boardFlags ^ 0x80; }
  constexpr bool noNeedCalcMinorPieces() const
    { return m_boardData.s_boardData.boardFlags & 0x80; }
  inline void setNeedCalcMinorPieces()
    { m_boardData.s_boardData.boardFlags &= ~(0x80); }
  inline void clearNeedCalcMinorPieces()
    { m_boardData.s_boardData.boardFlags |= 0x80; }
 
  void calcMinorPieces(bool const bForceRecalc);
 
  constexpr bmove_t getMove() const
    { return m_boardData.s_boardData.moveplayed; }
  inline void clearMove()
    { m_boardData.s_boardData.moveplayed = 0; }
  inline void setMove(bmove_t const bmt)
    { m_boardData.s_boardData.moveplayed = bmt; }
 
  inline movesequence_t const& getPreviousMoves() const
    { return m_previousmoves; }
  inline void setPreviousMoves(movesequence_t const& v)
    { m_previousmoves = v; }
  inline movesequence_t const& getVariation() const
    { return m_variation; }
  inline void clearVariation()
    { m_variation = {}; }
  void setVariation(bBoard const& chldbrd);
 
  boardInfo_t applyMove(bMove const& m) override;
 
  operator std::string() const;
 
protected:
  friend class bPositionEvaluation; // for accessing m_..Pieces
  friend class PosEvalPositionalBoard; // for accessing m_..Pieces
  friend class bWhitePiece; // for accessing m_..Pieces
  friend class bBlackPiece; // for accessing m_..Pieces
 
private:
  friend std::ostream& operator<<(std::ostream& os, bBoard const& bd);
 
  inline void setGameStage(bGameStage const stage)
    { m_boardData.s_boardData.boardFlags
              = static_cast<uint8_t>((m_boardData.s_boardData.boardFlags & 0xF0)
                | (static_cast<uint8_t>(stage) & 0x0F));
    }
 
  boardData_t m_boardData;
 
  // postbox representation of board
  piecepostbox_t m_whitePieces;
  piecepostbox_t m_blackPieces;
 
  movesequence_t m_variation; /// variation leading to score
  movesequence_t m_previousmoves; /// movesequence to get here
};
 
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
 
// --------------------------------------------------------------------
 
#endif // defined BOARD_H
 
// eof