eval.h

Go to the documentation of this file.

/*---------------------------------------------------------------------+
 * File: eval.h
 * Project: part of belofte - A Promising Chess Program
 * Author: yves
 * SPDX-License-Identifier: GPL-2.0-only
+----------------------------------------------------------------------*/
 
#if !defined(EVAL_H)
#define EVAL_H
 
typedef int16_t bScore;
 
// bit 1 - 0x8000 negative
// bit 2 - 0x4000 draw
// bit 3 - 16 : 0x2FFF real score
 
constexpr bScore SCORE_THEORETIC_DRAW   = 0x4000; // 163.84
constexpr bScore SCORE_PRACTICAL_DRAW   = -SCORE_THEORETIC_DRAW; // negative draw score
constexpr bScore SCORE_INFINITE         = 0x3FFF; // 163.83 (or 0xBFFF for negative)
constexpr bScore SCORE_PUNDEFINED       = 0x3FF0; // 163.68 (or 0xBFF0 for negative)
constexpr bScore SCORE_UNDEFINED        = -SCORE_PUNDEFINED;
 
constexpr bScore SCORE_ALMOST_NORMAL    = 0x2FFF; // 122.87
constexpr bScore SCORE_MATE             = 0x2F4F; // 121.11
constexpr bScore SCORE_WINNING          = 0x27FF; // 102.39 centipawns is maximum score
constexpr bScore SCORE_RESIGN           = 0x0578; //  14.00
constexpr bScore SCORE_ALMOST_DRAW      = 0x000A; //   0.10
constexpr bScore SCORE_DRAW             = 0x0000; //   0
 
constexpr bScore SCORE_CONVERGE_BYDEPTH =      1; //   0.01
constexpr bScore SCORE_BETAMARGIN       =     80; //   0.80
 
// attention, ordering is used in std::string bGame::getResult
enum gameResult {
  GR_UNSET = 0,
  GR_UNKNOWN = 1,
  GR_DRAW_STALEMATE = 10, GR_DRAW_LACKMATERIAL, GR_DRAW_THREEFOLD, GR_DRAW_50,
  GR_DRAW_ADJ, GR_DRAW_FLAG, GR_DRAW_OTHER,
  GR_WHITEMATES = 20, GR_BLACKRESIGNS, GR_WHITEWINS_ADJ, GR_WHITEWINS_FLAG,
  GR_BLACKMATES = 30, GR_WHITERESIGNS, GR_BLACKWINS_ADJ, GR_BLACKWINS_FLAG
};
 
typedef enum gameResult gameResult_t;
 
//-----------------------------------------------------------------------
 
class bPositionEvaluation {
public:
  explicit bPositionEvaluation()
    : m_name{"None"}
    {}
  explicit bPositionEvaluation(std::string const& s);
  virtual ~bPositionEvaluation()
    {}
 
  // no copy or move ctor nor assignment defined
  bPositionEvaluation(bPositionEvaluation const&) = delete;
  bPositionEvaluation(bPositionEvaluation&&) = delete;
  bPositionEvaluation& operator=(bPositionEvaluation const&) = delete;
  bPositionEvaluation& operator=(bPositionEvaluation&&) = delete;
 
  virtual bScore getEvaluation(bBoard const& b) const;
 
  operator std::string() const&
    { return const_cast<std::string const&>(m_name); }
 
public:
  static gameResult_t gameEndedResult(bBoard const& b);
  static bScore resultToScoreFlag(gameResult_t const gr);
  static inline bool isDrawResult(gameResult_t const gr)
    { return (gr >= GR_DRAW_STALEMATE) && (gr <= GR_DRAW_OTHER); }
 
private:
  static int8_t nFoldRepetition(bBoard const& b);
  static bool twoFoldRepetition(bBoard const& b);
  static bool threeFoldRepetition(bBoard const& b);
  static bool insufficientMaterial(bBoard const& b);
 
  std::string m_name;
};
 
//-----------------------------------------------------------------------
 
class PosEvalPiecesOnly : public bPositionEvaluation {
public:
  explicit PosEvalPiecesOnly()
    : bPositionEvaluation("PiecesOnly")
    {}
  ~PosEvalPiecesOnly() override
    {}
 
  // no copy or move ctor nor assignment defined
  PosEvalPiecesOnly(PosEvalPiecesOnly const&) = delete;
  PosEvalPiecesOnly(PosEvalPiecesOnly&&) = delete;
  PosEvalPiecesOnly& operator=(PosEvalPiecesOnly const&) = delete;
  PosEvalPiecesOnly& operator=(PosEvalPiecesOnly&&) = delete;
 
  bScore getEvaluation(bBoard const& b) const override;
};
 
//-----------------------------------------------------------------------
 
class PosEvalStaticBoard : public bPositionEvaluation {
public:
  explicit PosEvalStaticBoard()
    : bPositionEvaluation("StaticBoard")
    {}
  explicit PosEvalStaticBoard(std::string const& s)
    : bPositionEvaluation(s)
    {}
  ~PosEvalStaticBoard() override
    {}
 
  // no copy or move ctor nor assignment defined
  PosEvalStaticBoard(PosEvalStaticBoard const&) = delete;
  PosEvalStaticBoard(PosEvalStaticBoard&&) = delete;
  PosEvalStaticBoard& operator=(PosEvalStaticBoard const&) = delete;
  PosEvalStaticBoard& operator=(PosEvalStaticBoard&&) = delete;
 
  bScore getEvaluation(bBoard const& b) const override;
 
protected:
  bScore getRelativeBoardEval(bBoard const& b) const;
  bScore getEndgameEvaluation(bBoard const &b) const;
  bScore getPawnEndingEvaluation(bBoard const &b) const;
  bScore getMatingEvaluation(bBoard const &b) const;
};
 
//-----------------------------------------------------------------------
 
class PosEvalPositionalBoard : public PosEvalStaticBoard {
public:
  PosEvalPositionalBoard()
    : PosEvalStaticBoard("PositionalBoard")
    {}
  ~PosEvalPositionalBoard() override
    {}
 
  bScore getEvaluation(bBoard const& b) const override;
 
private:
  bScore getKingEvaluation(bBoard const& b) const;
 
  bScore getPawnEvaluation(bBoard const& b) const;
  bool whitePassed(bBoard const& b, column_t const iCol) const;
  bool blackPassed(bBoard const& b, column_t const iCol) const;
 
  bScore getRookEvaluation(bBoard const& b) const;
  bool seesHorVer(bBoard const& b, column_t const iCol,
          rank_t const iRank, piece_t const matchPiece) const;
  bool sameRank(bBoard const& b, column_t const iCol, rank_t const iRank,
          piece_t const matchPiece) const;
  bool sameCol(bBoard const& b, column_t const iCol, rank_t const iRank,
          piece_t const matchPiece) const;
  bool whiteKingSameRankCol(bBoard const& b, column_t const iCol,
          rank_t const iRank) const;
  bool blackKingSameRankCol(bBoard const& b, column_t const iCol,
          rank_t const iRank) const;
  bScore openLineValWhite(bBoard const& b, column_t const iCol,
          rank_t iRank) const;
  bScore openLineValBlack(bBoard const& b, column_t const iCol,
          rank_t iRank) const;
  bScore rookRankValWhite(bBoard const& b, rank_t const iRank) const;
  bScore rookRankValBlack(bBoard const& b, rank_t const iRank) const;
 
  bScore getBishopEvaluation(bBoard const& b) const;
  bool sameDiagonal(bBoard const& b, column_t const iCol,
          rank_t const iRank, piece_t const matchPiece) const;
  bool sameColour(bBoard const& b, case_t const c,
          piece_t const matchPiece) const;
  bool sameColourWhiteKing(bBoard const& b, case_t const iCol) const;
  bool sameColourBlackKing(bBoard const& b, case_t const iCol) const;
 
  bScore getQueenEvaluation(bBoard const& b) const;
};
 
#endif // defined EVAL_H
 
// eof