basicmove.h

Go to the documentation of this file.

/*---------------------------------------------------------------------+
 * File: basicmove.h
 * Project: part of belofte - A Promising Chess Program
 * Author: yves
 * SPDX-License-Identifier: GPL-2.0-only
+----------------------------------------------------------------------*/
 
#if !defined(BASICMOVE_H)
#define BASICMOVE_H
 
/** basicmove */
class bBasicMove {
public:
  explicit bBasicMove()
    {}
  explicit bBasicMove(bBasicMove const& bm)
    : u_bmove{bm.u_bmove}
    {}
  explicit bBasicMove(bBasicMove&& bm)
    : u_bmove{std::move(bm.u_bmove)}
    {}
  explicit bBasicMove(bmove_t const bmt)
    : u_bmove{bmt}
    {}
  explicit bBasicMove(case_t cf, case_t ct)
    : m_from{cf}
    , m_to{ct}
    , m_decoration{0}
    {}
  virtual ~bBasicMove()
    {}
 
  bBasicMove& operator=(bBasicMove const& bm)
    { u_bmove = bm.u_bmove;
      return *this;
    }
  bBasicMove& operator=(bBasicMove&& bm)
    { u_bmove = std::move(bm.u_bmove);
      return *this;
    }
 
  constexpr bool operator==(bBasicMove const& r) const
    { // flags can be different in case they are not set, it will still be the same move
      // so if flags are different, we only compare fromto case and promotion part
      return (u_bmove == r.u_bmove)
         || ((m_fromto == r.m_fromto) && (m_promotion == r.m_promotion));
    }
  bool operator==(bmove_t const& r) const
    { // flags can be different in case they are not set, it will still be the same move
      // so if flags are different, we only compare fromto case and promotion part
      bBasicMove rm(r);
      return (u_bmove == rm.u_bmove)
         || ((m_fromto == rm.m_fromto) && (m_promotion == rm.m_promotion));
    }
 
  constexpr case_t from() const
    { return m_from; }
  constexpr case_t to() const
    { return m_to; }
 
  constexpr rank_t fromrank() const
    { return bCase::rank(m_from); }
  constexpr column_t fromcolumn() const
    { return bCase::column(m_from); }
  constexpr rank_t torank() const
    { return bCase::rank(m_to); }
  constexpr column_t tocolumn() const
    { return bCase::column(m_to); }
 
  constexpr fromto_t getFromTo() const
    { return m_fromto; }
  constexpr bmove_t getBMoveT() const
    { return u_bmove; }
  constexpr ppiece_t getPromotion() const
    { return m_promotion; }
 
  constexpr bool isValid() const
    { return m_fromto != 0; }
  constexpr bool isNullMove() const
    { return m_fromto == 0; }
 
  constexpr bool isPromotion() const
    { return m_promotion; }
  constexpr bool isMajorPromotion() const
    { return m_promotion == tPPiece::N_P_QUEEN; }
  inline void setPromotion(const ppiece_t p)
    { m_promotion = p;
      m_flag |= 0x40;
    }
  piece_t getWhitePromotionPiece() const;
  piece_t getBlackPromotionPiece() const;
 
  constexpr bool isCapture() const
    { return m_flag & 0x80; }
  inline void setCapture()
    { m_flag |= 0x80; }
  constexpr bool isPawnMove() const
    { return m_flag & 0x40; }
  inline void setPawnMove()
    { m_flag |= 0x40; }
  constexpr bool isCastleMove() const
    { return m_flag & (0x08 | 0x04); }
  inline void setShortCastleMove()
    { m_flag |= 0x04; }
  inline void setLongCastleMove()
    { m_flag |= 0x08; }
  constexpr bool isLongCastleMove() const
    { return m_flag & 0x08; }
  constexpr bool isCheck() const
    { return m_flag & 0x02; }
  inline void setCheck()
    { m_flag |= 0x02; }
  inline void clearIsCheck()
    { m_flag &= ~(0x02); }
  constexpr bool getGameEnd() const
    { return m_flag & 0x01; }
  inline void setGameEnd()
    { m_flag |= 0x01; }
 
  constexpr bool isEPPossible() const
    { return m_flag & 0x10; }
  inline void setEPPossible()
    { // mix pawn move flag
      m_flag |= 0x10 | 0x40;
    }
  constexpr bool isEPMove() const
    { return m_flag & 0x20; }
  inline void setEPMove()
    { // mix pawn move flag
      m_flag |= 0x20 | 0x40;
    }
 
  constexpr bool isNonSilent() const
    { return isCapture() || isPromotion() || isEPMove(); }
 
  operator std::string() const;
 
private:
  union {
    bmove_t u_bmove = 0UL; // initialise all subsequent fields to 0
    struct {
      union {
        fromto_t m_fromto;
        struct {
          case_t m_from;
          case_t m_to;
        };
      };
      union {
        uint16_t m_decoration;
        struct {
          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);
};
 
#endif // defined BASICMOVE_H
 
// eof