move.h

Go to the documentation of this file.

/*---------------------------------------------------------------------+
 * File: move.h
 * Project: part of belofte - A Promising Chess Program
 * Author: yves
 * SPDX-License-Identifier: GPL-2.0-only
+----------------------------------------------------------------------*/
 
#if !defined(MOVE_H)
#define MOVE_H
 
/** move */
class bBasicMove {
public:
  explicit bBasicMove(bBasicMove const& bm);
  explicit bBasicMove(bBasicMove&& bm);
  explicit bBasicMove(basicmove_t const bmt);
  explicit bBasicMove(case_t cf, case_t ct);
  virtual ~bBasicMove();
 
  bBasicMove& operator=(bBasicMove&& bm);
  bBasicMove& operator=(bBasicMove const& bm);
 
  operator std::string() const;
 
  MEMBER_CONSTEXPR case_t from() const {
    return static_cast<case_t>(m_bmove ? (m_bmove & 0x00FF) : 0xFF);
  }
 
  MEMBER_CONSTEXPR case_t to() const {
    return static_cast<case_t>(m_bmove ? ((m_bmove >> 8) & 0x00FF) : 0xFF);
  }
 
  rank_t fromrank() const { return bCase::rank(from()); }
  column_t fromcolumn() const { return bCase::column(from()); }
  rank_t torank() const { return bCase::rank(to()); }
  column_t tocolumn() const { return bCase::column(to()); }
 
  basicmove_t getBasicMoveT() const { return m_bmove; }
  ppiece_t getPromotion() const { return m_promotion; }
 
protected:
  union {
    uint32_t u_bmove = 0UL; // initialise all subsequent fields to 0
    struct {
      basicmove_t m_bmove;
      uint8_t m_flag;
      // 0b00000000 some flags are not set in basicmove
      //   ^        capture move     - 0x80 - 128
      //    ^       pawn move        - 0x40 - 64
      //     ^      ep move          - 0x20 - 32
      //      ^     double pawn move - 0x10 - 16
      //       ^    long castle move - 0x08 - 8
      //        ^   short castle     - 0x04 - 4
      //         ^  check move       - 0x02 - 2
      //          ^ game end         - 0x01 - 1
      ppiece_t m_promotion; // 0 for no promotion
    };
  };
 
private:
  std::string const getPromotionDecorationStr() const;
 
private:
  friend std::ostream& operator<<(std::ostream& os, bBasicMove const& m);
};
 
//-----------------------------------------------------------------------
 
class bMove : public bBasicMove {
public:
  bMove(bMove const& m);
  explicit bMove(bMove&& m);
  explicit bMove(case_t cf, case_t ct);
  ~bMove() override;
 
  bMove& operator=(bMove&& m);
  bool operator>(bMove const& r) const;
 
  bMove& operator=(bMove const&) = delete;
 
  piece_t getWhitePromotionPiece() const;
  piece_t getBlackPromotionPiece() const;
  bool isPromotion() const { return m_promotion; }
  bool isMajorPromotion() const;
  void setPromotion(const ppiece_t p) { m_promotion = p; }
 
  bool isCapture() const { return m_flag & 0x80; }
  void setCapture() { m_flag |= 0x80; }
  bool isPawnMove() const { return m_flag & 0x40; }
  void setPawnMove() { m_flag |= 0x40; }
  bool isCastleMove() const { return m_flag & (0x08 | 0x04); }
  void setShortCastleMove() { m_flag |= 0x04; }
  void setLongCastleMove() { m_flag |= 0x08; }
  bool isLongCastleMove() const { return m_flag & 0x08; }
  bool isCheck() const { return m_flag & 0x02; }
  void setCheck() { m_flag |= 0x02; }
  void setGameEnd() { m_flag |= 0x01; }
  bool getGameEnd() const { return m_flag & 0x01; }
  bool isEndOfGame() const;
  bool isEPPossible() const { return m_flag & 0x10; }
  void setEPPossible() { m_flag |= 0x10; }
  bool isEPMove() const { return m_flag & 0x20; }
  void setEPMove() { m_flag |= 0x20; }
  bool isNonSilent() const { return isCapture() || isMajorPromotion() || isEPMove(); }
 
  void setScore(bScore const s) { m_score = s; }
  bScore getScore() const { return m_score; }
  std::string getMoveEvalStr() const;
 
private:
  bScore m_score = SCORE_UNDEFINED;
};
 
#endif // defined MOVE_H
 
// eof