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;
 
typedef uint16_t ppiece_t;
 
namespace tPPiece {
  constexpr uint16_t N_P_CLEAR   = 0xF0FF;
  constexpr uint16_t N_PROMOTION = 0x0F00;
  constexpr ppiece_t N_P_EMPTY   = 0x0000;
  constexpr ppiece_t N_P_QUEEN   = 0x0800;
  constexpr ppiece_t N_P_ROOK    = 0x0400;
  constexpr ppiece_t N_P_BISHOP  = 0x0200;
  constexpr ppiece_t N_P_KNIGHT  = 0x0100;
}
 
enum tStatPiece : uint8_t {
  STAT_PAWN = 0,
  STAT_KNIGHT, 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 bBoard;
class bCase;
class bMoveList;
 
//-----------------------------------------------------------------------
 
/** piece representation */
class bPiece {
public:
  bPiece();
  explicit bPiece(piece_t p);
  virtual ~bPiece();
 
  bPiece(bPiece&&) = default;
 
  // no copy or move ctor nor assignment defined
  bPiece(bPiece const&) = delete;
  bPiece& operator=(bPiece const&) = delete;
  bPiece& operator=(bPiece&&) = delete;
 
  // get piece letter
  piece_t getPiece() const { return m_piece; }
 
  virtual int GenerateMoves(bBoard const& b UNUSED,
          case_t const& cf UNUSED, bMoveList& ml UNUSED,
          side_t const side UNUSED) = 0;
 
  int addMove(bBoard const& b, case_t const& cf,
          side_t const side, int8_t const ri, int8_t const ci,
          bMoveList& ml) const;
  int addMoves(bBoard const& b, case_t const& cf,
          side_t const side, int nMax, int8_t const ri, int8_t const ci,
          bMoveList& ml) const;
 
  side_t toMove() const;
 
public:
  static piece_t getPiece(cpiece_t const p);
  static cpiece_t getPieceChar(piece_t const p);
  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 p);
  static bool isOwnColour(side_t const s, piece_t const p);
 
private:
  friend std::ostream& operator<<(std::ostream& os, bPiece const& p) {
    if (p.m_piece) os << p.m_piece;
    return os;
  }
 
private:
  piece_t m_piece = tPiece::P_EMPTY;
};
 
//-----------------------------------------------------------------------
 
class bPieceColour {
public:
  bPieceColour(side_t 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;
 
  bool isWhite() const { return m_side == tSide::SIDE_WHITE; }
  bool isBlack() const { return m_side == tSide::SIDE_BLACK; }
  bool isEmpty() const { return m_side == tSide::SIDE_UNDEFINED; }
 
  side_t invert() {
    m_side = isWhite() ? tSide::SIDE_BLACK : tSide::SIDE_WHITE;
    return m_side;
  }
  side_t opponent() const {
    return isWhite() ? tSide::SIDE_BLACK : tSide::SIDE_WHITE;
  }
  side_t toMove() const {
    return isBlack() ? tSide::SIDE_WHITE : tSide::SIDE_BLACK;
  }
 
  virtual bool isAttacked(bBoard const& b, case_t const& cf) const = 0;
 
protected:
  bool isAttackedByPiece(bBoard const& b, case_t const& cf,
          piece_t const cPiece, int8_t const ri, int8_t const ci) const;
  bool isAttackedBySlider(bBoard const& b, case_t const& cf,
          piece_t const cPiece, piece_t const cPiece2,
          int8_t const ri, int8_t const ci) const;
 
  side_t m_side = tSide::SIDE_UNDEFINED;
};
 
//-----------------------------------------------------------------------
 
class bWhitePiece : public bPieceColour {
public:
  bWhitePiece();
  ~bWhitePiece() override;
 
  bool isAttacked(bBoard const& b, case_t const& cf) const override;
};
 
class bBlackPiece : public bPieceColour {
public:
  bBlackPiece();
  ~bBlackPiece() override;
 
  bool isAttacked(bBoard const& b, case_t const& cf) const override;
};
 
// TODO: Candidate for template implementation
 
class bEmptyPiece final : public bPiece, public bPieceColour {
public:
  bEmptyPiece() : bPieceColour(tSide::SIDE_UNDEFINED) {}
  ~bEmptyPiece() final {}
 
  bool isAttacked(bBoard const& b UNUSED, case_t const& cf UNUSED)
          const final { return false; }
  int GenerateMoves(bBoard const& b UNUSED, case_t const& cf UNUSED,
          bMoveList& ml UNUSED, side_t const side UNUSED) final { return 0; }
};
 
class bPawn : public bPiece {
public:
  explicit bPawn(piece_t p) : bPiece(p) {}
 
protected:
  int addNonCapturePawnMove(bBoard const& b, case_t const& cf,
          side_t const side, int8_t const ri,
          bMoveList& ml) const;
  int addNonCaptureDoublePawnMove(bBoard const& b, case_t const& cf,
          side_t const side, int8_t const ri,
          bMoveList& ml) const;
  int addCapturePawnMove(bBoard const& b, case_t const& cf,
          side_t const side, int8_t const ri,
          int8_t const ci, bMoveList& ml) const;
  int addNonCapturePromotionMove(bBoard const& b, case_t const& cf,
          side_t const side, int8_t const ri,
          bMoveList& ml) const;
  int addCapturePromotionMove(bBoard const& b, case_t const& cf,
          side_t const side, int8_t const ri,
          int8_t const ci, bMoveList& ml) const;
  int addEPMove(bBoard const& b, case_t const& cf,
        side_t const side,
        int8_t const ri, int8_t const ci, bMoveList& ml) const;
};
 
class bWhitePawn final : public bPawn, public bWhitePiece {
public:
  bWhitePawn() : bPawn(tPiece::W_PAWN) {}
 
  int GenerateMoves(bBoard const& b, case_t const& cf, bMoveList& ml,
          side_t const side) final;
};
 
class bBlackPawn final : public bPawn, public bBlackPiece {
public:
  bBlackPawn() : bPawn(tPiece::B_PAWN) {}
 
  int GenerateMoves(bBoard const& b, case_t const& cf, bMoveList& ml,
          side_t const side) final;
};
 
class bKnight : public bPiece {
public:
  explicit bKnight(piece_t p) : bPiece(p) {}
 
  int GenerateMoves(bBoard const& b, case_t const& cf, bMoveList& ml,
          side_t const side) final;
};
 
class bWhiteKnight final : public bKnight, public bWhitePiece {
public:
  bWhiteKnight() : bKnight(tPiece::W_KNIGHT) {}
};
 
class bBlackKnight final : public bKnight, public bBlackPiece {
public:
  bBlackKnight() : bKnight(tPiece::B_KNIGHT) {}
};
 
class bBishop : public bPiece {
public:
  explicit bBishop(piece_t p) : bPiece(p) {}
 
  int GenerateMoves(bBoard const& b, case_t const& cf, bMoveList& ml,
          side_t const side) final;
};
 
class bWhiteBishop final : public bBishop, public bWhitePiece {
public:
  bWhiteBishop() : bBishop(tPiece::W_BISHOP) {}
};
 
class bBlackBishop final : public bBishop, public bBlackPiece {
public:
  bBlackBishop() : bBishop(tPiece::B_BISHOP) {}
};
 
class bRook : public bPiece {
public:
  explicit bRook(piece_t p) : bPiece(p) {}
 
  int GenerateMoves(bBoard const& b, case_t const& cf, bMoveList& ml,
          side_t const side) final;
};
 
class bWhiteRook final : public bRook, public bWhitePiece {
public:
  bWhiteRook() : bRook(tPiece::W_ROOK) {}
};
 
class bBlackRook final : public bRook, public bBlackPiece {
public:
  bBlackRook() : bRook(tPiece::B_ROOK) {}
};
 
class bQueen : public bPiece {
public:
  explicit bQueen(piece_t p) : bPiece(p) {}
 
  int GenerateMoves(bBoard const& b, case_t const& cf, bMoveList& ml,
          side_t const side) final;
};
 
class bWhiteQueen final : public bQueen, public bWhitePiece {
public:
  bWhiteQueen() : bQueen(tPiece::W_QUEEN) {}
};
 
class bBlackQueen final : public bQueen, public bBlackPiece {
public:
  bBlackQueen() : bQueen(tPiece::B_QUEEN) {}
};
 
class bKing : public bPiece {
public:
  explicit bKing(piece_t p) : bPiece(p) {}
 
  int GenerateMoves(bBoard const& b, case_t const& cf, bMoveList& ml,
          side_t const side) override;
 
protected:
  bool kingSeesRook(bBoard const& b, case_t const& cf,
          piece_t const cPiece, int8_t const ci) const;
};
 
class bWhiteKing final : public bKing, public bWhitePiece {
public:
  bWhiteKing() : bKing(tPiece::W_KING) {}
 
  int GenerateMoves(bBoard const& b, case_t const& cf, bMoveList& ml,
          side_t const side) final;
};
 
class bBlackKing final : public bKing, public bBlackPiece {
public:
  bBlackKing() : bKing(tPiece::B_KING) {}
 
  int GenerateMoves(bBoard const& b, case_t const& cf, bMoveList& ml,
          side_t const side) final;
};
 
// --------------------------------------------------------------------
 
#endif // defined PIECE_H
 
// eof