piece.h

Go to the documentation of this file.

/*---------------------------------------------------------------------+
 * File: piece.h
 * Project: part of belofte - A Promising Chess Program
 * Author: yves
 * SPDX-License-Identifier: GPL-2.0-only
+----------------------------------------------------------------------*/
 
#if !defined(PIECE_H)
#define PIECE_H
 
#define S_P_BISHOP  "B"
#define S_P_KING    "K"
#define S_P_KNIGHT  "N"
#define S_P_PAWN    "P"
#define S_P_QUEEN   "Q"
#define S_P_ROOK    "R"
#define S_P_EMPTY   ""
 
enum tCPiece : unsigned char {
  C_EMPTY = ' ',
  C_W_BISHOP = 'B',
  C_W_KING = 'K',
  C_W_KNIGHT = 'N',
  C_W_PAWN = 'P',
  C_W_QUEEN = 'Q',
  C_W_ROOK = 'R',
  C_B_BISHOP = 'b',
  C_B_KING = 'k',
  C_B_KNIGHT = 'n',
  C_B_PAWN = 'p',
  C_B_QUEEN = 'q',
  C_B_ROOK = 'r'
};
 
typedef enum tCPiece cpiece_t;
 
enum tPiece : uint8_t {
  P_EMPTY = 0,
  W_KING = 1, W_PAWN, W_KNIGHT, W_BISHOP, W_ROOK, W_QUEEN,
  B_KING = 7, B_PAWN, B_KNIGHT, B_BISHOP, B_ROOK, B_QUEEN,
  P_SIZE
};
 
typedef enum tPiece piece_t;
 
enum tPPiece : uint8_t {
  N_P_EMPTY = 0,
  N_P_KNIGHT, N_P_BISHOP, N_P_ROOK, N_P_QUEEN,
  N_P_SIZE
};
 
typedef enum tPPiece ppiece_t;
 
enum tStatPiece : uint8_t {
  STAT_KNIGHT = 0, STAT_BISHOP, STAT_ROOK, STAT_QUEEN,
  STAT_SIZE
};
 
enum class tSide : uint8_t {
  SIDE_UNDEFINED = 0,
  SIDE_WHITE = 1,
  SIDE_BLACK = 2
};
 
typedef enum tSide side_t;
 
//-----------------------------------------------------------------------
 
void bPiece_ctor();
void bPiece_dtor();
 
//-----------------------------------------------------------------------
 
class bBasicBoard;
class bBoard;
class bCase;
class bMoveList;
 
//-----------------------------------------------------------------------
 
/** piece representation */
class bPiece {
public:
  explicit bPiece()
    {}
  explicit bPiece(bPiece&& bp)
    : m_piece{std::move(bp.m_piece)}
    {}
  explicit bPiece(piece_t piece)
    : m_piece(piece)
    {}
  virtual ~bPiece()
    {}
 
  // no copy or move ctor nor assignment defined
  bPiece(bPiece const&) = delete;
  bPiece& operator=(bPiece const&) = delete;
  bPiece& operator=(bPiece&&) = delete;
 
  // get piece letter
  constexpr piece_t getPiece() const
    { return m_piece; }
 
  virtual bool hasValidMovePreflightCheck(bBasicBoard& b,
          case_t const& cf) = 0;
  virtual movenum_t GenerateMoves(bBasicBoard const& b,
          case_t const& cf, bMoveList& ml) = 0;
 
  side_t toMove() const;
 
public:
  static piece_t getPiece(cpiece_t const piece);
  static cpiece_t getPieceChar(piece_t const piece);
  static bPiece* getPieceClass(piece_t const piece);
  static const std::string getPieceStrUpper(piece_t const piece);
  static bool isOpponent(side_t const s, piece_t const piece);
  static bool isOwnColour(side_t const s, piece_t const piece);
  static bool isWhitePiece(piece_t const p);
  static bool isBlackPiece(piece_t const p);
 
private:
  friend std::ostream& operator<<(std::ostream& os, bPiece const& bp)
    { if (bp.m_piece) os << bp.m_piece;
      return os;
    }
 
private:
  piece_t m_piece = tPiece::P_EMPTY;
};
 
//-----------------------------------------------------------------------
 
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
#endif
 
class bPieceColour {
public:
  explicit bPieceColour(side_t s)
    : m_side{s}
    {}
  virtual ~bPieceColour()
    {}
 
  // no copy or move ctor nor assignment defined
  bPieceColour(bPieceColour const&) = delete;
  bPieceColour(bPieceColour&&) = delete;
  bPieceColour& operator=(bPieceColour const&) = delete;
  bPieceColour& operator=(bPieceColour&&) = delete;
 
  constexpr bool isWhite() const
    { return m_side == tSide::SIDE_WHITE; }
  constexpr bool isBlack() const
    { return m_side == tSide::SIDE_BLACK; }
  constexpr bool isEmpty() const
    { return m_side == tSide::SIDE_UNDEFINED; }
  constexpr side_t opponent() const
    { return isWhite() ? tSide::SIDE_BLACK : tSide::SIDE_WHITE; }
  constexpr side_t toMove() const
    { return isBlack() ? tSide::SIDE_WHITE : tSide::SIDE_BLACK; }
 
  virtual bool isAttacked(bBasicBoard const& b, case_t const& cf) const
    { return false; }
  side_t invert()
    { m_side = isWhite() ? tSide::SIDE_BLACK : tSide::SIDE_WHITE;
      return m_side;
    }
 
  virtual bool canMovePreflightCheck(bBasicBoard& b,
          case_t const& cf, case_t const& ct) const = 0;
  virtual bool canMovePreflightCheck(bBasicBoard& b, case_t const& cf,
          int8_t const ri, int8_t const ci,
          uint_fast8_t nMax) const = 0;
  virtual bool canPawnMovePreflightCheck(bBasicBoard& b, case_t const& cf,
          int8_t const ri, int8_t const ci) const = 0;
  virtual movenum_t addMove(bBasicBoard const& b, case_t const& cf,
          case_t const& ct, bMoveList& ml) const = 0;
  virtual movenum_t addMoves(bBasicBoard const& b, case_t const& cf,
          int8_t const ri, int8_t const ci,
          bMoveList& ml) const = 0;
 
protected:
  bool isAttackedBySlider(bBasicBoard const& b,
          case_t cf, column_t fromcol, rank_t fromrank,
          int8_t const ci, int8_t const ri,
          piece_t const cPiece, piece_t const cPiece2) const;
 
  side_t m_side = tSide::SIDE_UNDEFINED;
};
 
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
 
//-----------------------------------------------------------------------
 
class bWhitePiece : public bPieceColour {
public:
  bWhitePiece()
    : bPieceColour(tSide::SIDE_WHITE)
    {}
  ~bWhitePiece() override
    {}
 
  bool canMovePreflightCheck(bBasicBoard& b,
          case_t const& cf, case_t const& ct) const override;
  bool canMovePreflightCheck(bBasicBoard& b, case_t const& cf,
          int8_t const ri, int8_t const ci,
          uint_fast8_t nMax = 1) const override;
  bool canPawnMovePreflightCheck(bBasicBoard& b, case_t const& cf,
          int8_t const ri, int8_t const ci) const override;
  bool isAttacked(bBasicBoard const& b, case_t const& cf) const override;
  movenum_t addMove(bBasicBoard const& b, case_t const& cf,
          case_t const& ct, bMoveList& ml) const override;
  movenum_t addMoves(bBasicBoard const& b, case_t const& cf,
          int8_t const ri, int8_t const ci,
          bMoveList& ml) const override;
};
 
class bBlackPiece : public bPieceColour {
public:
  bBlackPiece()
    : bPieceColour(tSide::SIDE_BLACK)
    {}
  ~bBlackPiece() override
    {}
 
  bool canMovePreflightCheck(bBasicBoard& b,
          case_t const& cf, case_t const& ct) const override;
  bool canMovePreflightCheck(bBasicBoard& b, case_t const& cf,
          int8_t const ri, int8_t const ci,
          uint_fast8_t nMax = 1) const override;
  bool canPawnMovePreflightCheck(bBasicBoard& b, case_t const& cf,
          int8_t const ri, int8_t const ci) const override;
  bool isAttacked(bBasicBoard const& b, case_t const& cf) const override;
  movenum_t addMove(bBasicBoard const& b, case_t const& cf,
          case_t const& ct, bMoveList& ml) const override;
  movenum_t addMoves(bBasicBoard const& b, case_t const& cf,
          int8_t const ri, int8_t const ci,
          bMoveList& ml) const override;
};
 
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
#endif
 
/// @todo Candidate for template implementation
 
class bEmptyPiece : public bPiece, public bPieceColour {
public:
  bEmptyPiece()
    : bPieceColour(tSide::SIDE_UNDEFINED)
    {}
  ~bEmptyPiece() override
    {}
 
  bool canMovePreflightCheck(bBasicBoard& b,
          case_t const& cf, case_t const& ct) const override
    { return false; }
  bool canMovePreflightCheck(bBasicBoard& b,
          case_t const& cf,
          int8_t const ri, int8_t const ci,
          uint_fast8_t nMax = 0) const override
    { return false; }
  bool canPawnMovePreflightCheck(bBasicBoard& b,
          case_t const& cf,
          int8_t const ri, int8_t const ci) const override
    { return false; }
  bool isAttacked(bBasicBoard const& b, case_t const& cf) const override
    { return false; }
  movenum_t addMove(bBasicBoard const& b, case_t const& cf,
          case_t const& ct, bMoveList& ml) const override
    { return 0; }
  movenum_t addMoves(bBasicBoard const& b, case_t const& cf,
          int8_t const ri, int8_t const ci,
          bMoveList& ml) const override
    { return 0; }
  bool hasValidMovePreflightCheck(bBasicBoard& b,
          case_t const& cf) override
    { return false; }
  movenum_t GenerateMoves(bBasicBoard const& b,
          case_t const& cf, bMoveList& ml) override
    { return 0; }
};
 
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
 
class bPawn : public bPiece {
public:
  explicit bPawn(piece_t p)
    : bPiece(p)
    {}
  ~bPawn() override
    {}
};
 
class bWhitePawn : public bPawn, public bWhitePiece {
public:
  explicit bWhitePawn()
    : bPawn(tPiece::W_PAWN)
    {}
  ~bWhitePawn() override
    {}
 
  bool hasValidMovePreflightCheck(bBasicBoard& b,
          case_t const& cf) override;
  movenum_t GenerateMoves(bBasicBoard const& b, case_t const& cf,
          bMoveList& ml) override;
 
protected:
  movenum_t addNonCapturePawnMove(bBasicBoard const& b, case_t const& cf,
          bMoveList& ml) const;
  movenum_t addEPMove(bBasicBoard const& b, case_t const& cf,
          int8_t const ci, bMoveList& ml) const;
  movenum_t addCapturePawnMove(bBasicBoard const& b, case_t const& cf,
          int8_t const ci, bMoveList& ml) const;
  movenum_t addNonCapturePromotionMove(bBasicBoard const& b, case_t const& cf,
          bMoveList& ml) const;
  movenum_t addCapturePromotionMove(bBasicBoard const& b, case_t const& cf,
          int8_t const ci, bMoveList& ml) const;
 
private:
  bool canPawnMove(bBasicBoard& b, case_t const& cf) const;
  bool canPawnCapture(bBasicBoard& b, case_t const& cf,
          int8_t const ci) const;
  bool canPawnEPMove(bBasicBoard& b, case_t const& cf,
          int8_t const ci) const;
};
 
class bBlackPawn : public bPawn, public bBlackPiece {
public:
  explicit bBlackPawn()
    : bPawn(tPiece::B_PAWN)
    {}
  ~bBlackPawn() override
    {}
 
  bool hasValidMovePreflightCheck(bBasicBoard& b,
          case_t const& cf) override;
  movenum_t GenerateMoves(bBasicBoard const& b, case_t const& cf,
          bMoveList& ml) override;
 
protected:
  movenum_t addNonCapturePawnMove(bBasicBoard const& b, case_t const& cf,
          bMoveList& ml) const;
  movenum_t addEPMove(bBasicBoard const& b, case_t const& cf,
          int8_t const ci, bMoveList& ml) const;
  movenum_t addCapturePawnMove(bBasicBoard const& b, case_t const& cf,
          int8_t const ci, bMoveList& ml) const;
  movenum_t addNonCapturePromotionMove(bBasicBoard const& b, case_t const& cf,
          bMoveList& ml) const;
  movenum_t addCapturePromotionMove(bBasicBoard const& b, case_t const& cf,
          int8_t const ci, bMoveList& ml) const;
 
private:
  bool canPawnMove(bBasicBoard& b, case_t const& cf) const;
  bool canPawnCapture(bBasicBoard& b, case_t const& cf,
          int8_t const ci) const;
  bool canPawnEPMove(bBasicBoard& b, case_t const& cf,
          int8_t const ci) const;
};
 
class bKnight : public bPiece {
public:
  explicit bKnight(piece_t p)
    : bPiece(p)
    {}
  ~bKnight() override
    {}
};
 
class bWhiteKnight : public bKnight, public bWhitePiece {
public:
  bWhiteKnight()
    : bKnight(tPiece::W_KNIGHT)
    {}
  ~bWhiteKnight() override
    {}
 
  bool hasValidMovePreflightCheck(bBasicBoard& b,
          case_t const& cf) override;
  movenum_t GenerateMoves(bBasicBoard const& b, case_t const& cf,
          bMoveList& ml) override;
};
 
class bBlackKnight : public bKnight, public bBlackPiece {
public:
  bBlackKnight()
    : bKnight(tPiece::B_KNIGHT)
    {}
  ~bBlackKnight() override
    {}
 
  bool hasValidMovePreflightCheck(bBasicBoard& b,
          case_t const& cf) override;
  movenum_t GenerateMoves(bBasicBoard const& b, case_t const& cf,
          bMoveList& ml) override;
};
 
class bBishop : public bPiece {
public:
  explicit bBishop(piece_t p)
    : bPiece(p)
    {}
  ~bBishop() override
    {}
};
 
class bWhiteBishop : public bBishop, public bWhitePiece {
public:
  bWhiteBishop()
    : bBishop(tPiece::W_BISHOP)
    {}
  ~bWhiteBishop() override
    {}
 
  bool hasValidMovePreflightCheck(bBasicBoard& b,
          case_t const& cf) override;
  movenum_t GenerateMoves(bBasicBoard const& b, case_t const& cf,
          bMoveList& ml) override;
};
 
class bBlackBishop : public bBishop, public bBlackPiece {
public:
  bBlackBishop()
    : bBishop(tPiece::B_BISHOP)
    {}
  ~bBlackBishop() override
    {}
 
  bool hasValidMovePreflightCheck(bBasicBoard& b,
          case_t const& cf) override;
  movenum_t GenerateMoves(bBasicBoard const& b, case_t const& cf,
          bMoveList& ml) override;
};
 
class bRook : public bPiece {
public:
  explicit bRook(piece_t p)
    : bPiece(p)
    {}
  ~bRook() override
    {}
};
 
class bWhiteRook : public bRook, public bWhitePiece {
public:
  bWhiteRook()
    : bRook(tPiece::W_ROOK)
    {}
  ~bWhiteRook() override
    {}
 
  bool hasValidMovePreflightCheck(bBasicBoard& b,
          case_t const& cf) override;
  movenum_t GenerateMoves(bBasicBoard const& b, case_t const& cf,
          bMoveList& ml) override;
};
 
class bBlackRook : public bRook, public bBlackPiece {
public:
  bBlackRook()
    : bRook(tPiece::B_ROOK)
    {}
  ~bBlackRook() override
    {}
 
  bool hasValidMovePreflightCheck(bBasicBoard& b,
          case_t const& cf) override;
  movenum_t GenerateMoves(bBasicBoard const& b, case_t const& cf,
          bMoveList& ml) override;
};
 
class bQueen : public bPiece {
public:
  explicit bQueen(piece_t p)
    : bPiece(p)
    {}
  ~bQueen() override
    {}
};
 
class bWhiteQueen : public bQueen, public bWhitePiece {
public:
  bWhiteQueen()
    : bQueen(tPiece::W_QUEEN)
    {}
  ~bWhiteQueen() override
    {}
 
  bool hasValidMovePreflightCheck(bBasicBoard& b,
          case_t const& cf) override;
  movenum_t GenerateMoves(bBasicBoard const& b, case_t const& cf,
          bMoveList& ml) override;
};
 
class bBlackQueen : public bQueen, public bBlackPiece {
public:
  bBlackQueen()
    : bQueen(tPiece::B_QUEEN)
    {}
  ~bBlackQueen() override
    {}
 
  bool hasValidMovePreflightCheck(bBasicBoard& b,
          case_t const& cf) override;
  movenum_t GenerateMoves(bBasicBoard const& b, case_t const& cf,
          bMoveList& ml) override;
};
 
class bKing : public bPiece {
public:
  explicit bKing(piece_t p)
    : bPiece(p)
    {}
  ~bKing() override
    {}
};
 
class bWhiteKing : public bKing, public bWhitePiece {
public:
  bWhiteKing()
    : bKing(tPiece::W_KING)
    {}
  ~bWhiteKing() override
    {}
 
  bool hasValidMovePreflightCheck(bBasicBoard& b,
          case_t const& cf) override;
  movenum_t GenerateMoves(bBasicBoard const& b, case_t const& cf,
          bMoveList& ml) override;
};
 
class bBlackKing : public bKing, public bBlackPiece {
public:
  bBlackKing()
    : bKing(tPiece::B_KING)
    {}
  ~bBlackKing() override
    {}
 
  bool hasValidMovePreflightCheck(bBasicBoard& b,
          case_t const& cf) override;
  movenum_t GenerateMoves(bBasicBoard const& b, case_t const& cf,
          bMoveList& ml) override;
};
 
// --------------------------------------------------------------------
 
#endif // defined PIECE_H
 
// eof