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 3 - 16 : 0 < 0x371F real score
 
constexpr bScore SCORE_THEORETIC_DRAW   = 0x3EEF; // 161.11
constexpr bScore SCORE_PRACTICAL_DRAW   = -SCORE_THEORETIC_DRAW; // negative draw score
 
constexpr bScore SCORE_MATE             = 0x3E80; // 160.00
constexpr bScore SCORE_INFINITE         = 0x3A98; // 150.00
constexpr bScore SCORE_UNDEFINED        = 0x3A00; // 148.48
constexpr bScore SCORE_ALMOST_NORMAL    = 0x371F; // 141.11
constexpr bScore SCORE_RESIGN           = 0x1000; //  40.96 (5 queens)
constexpr bScore SCORE_ALMOST_DRAW      = 0x000B; //   0.11
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&& 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, gameResult_t gr) 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, gameResult_t gr) const override;
};
 
//-----------------------------------------------------------------------
 
class PosEvalStaticBoard : public bPositionEvaluation {
public:
  explicit PosEvalStaticBoard()
    : bPositionEvaluation{"StaticBoard"}
    {}
  explicit PosEvalStaticBoard(std::string&& s)
    : bPositionEvaluation{std::move(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, gameResult_t gr) const override;
 
protected:
  static bScore getRelativeBoardEval(bBoard const& b);
  static bScore getEndgameEvaluation(bBoard const &b);
  static bScore getPawnEndingEvaluation(bBoard const &b);
  static bScore getMatingEvaluation(bBoard const &b);
};
 
//-----------------------------------------------------------------------
 
class PosEvalPositionalBoard : public PosEvalStaticBoard {
public:
  PosEvalPositionalBoard()
    : PosEvalStaticBoard("PositionalBoard")
    {}
  ~PosEvalPositionalBoard() override
    {}
 
  bScore getEvaluation(bBoard const& b, gameResult_t gr) const override;
 
private:
  static bScore getKingEvaluation(bBoard const& b);
 
  static bScore getPawnEvaluation(bBoard const& b);
  static bool whitePassed(bBoard const& b, column_t const iCol);
  static bool blackPassed(bBoard const& b, column_t const iCol);
 
  static bScore getRookEvaluation(bBoard const& b);
  static bool seesHorVer(bBoard const& b, column_t const iCol,
          rank_t const iRank, piece_t const matchPiece);
  static bool sameRank(bBoard const& b, column_t const iCol, rank_t const iRank,
          piece_t const matchPiece);
  static bool sameCol(bBoard const& b, column_t const iCol, rank_t const iRank,
          piece_t const matchPiece);
  static bool whiteKingSameRankCol(bBoard const& b, column_t const iCol,
          rank_t const iRank);
  static bool blackKingSameRankCol(bBoard const& b, column_t const iCol,
          rank_t const iRank);
  static bScore openLineValWhite(bBoard const& b, column_t const iCol,
          rank_t iRank);
  static bScore openLineValBlack(bBoard const& b, column_t const iCol,
          rank_t iRank);
  static bScore rookRankValWhite(bBoard const& b, rank_t const iRank);
  static bScore rookRankValBlack(bBoard const& b, rank_t const iRank);
 
  static bScore getBishopEvaluation(bBoard const& b);
  static bool sameDiagonal(bBoard const& b, column_t const iCol,
          rank_t const iRank, piece_t const matchPiece);
  static bool sameColour(bBoard const& b, case_t const c,
          piece_t const matchPiece);
  static bool sameColourWhiteKing(bBoard const& b, case_t const iCol);
  static bool sameColourBlackKing(bBoard const& b, case_t const iCol);
 
  static bScore getQueenEvaluation(bBoard const& b);
};
 
#endif // defined EVAL_H
 
// eof