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
 
// bit 1 - 0x8000 negative
// bit 2 - 0x4000 draw
// bit 3 - 16 : 0x2FFF real score
 
constexpr bScore SCORE_INFINITE         = 0x3FFF; // (or 0xBFFF for negative)
constexpr bScore SCORE_POSITIVE         = 0x7FFF;
constexpr bScore SCORE_THEORETIC_DRAW   = 0x4000;
constexpr bScore SCORE_PRACTICAL_DRAW   = SCORE_THEORETIC_DRAW | ~SCORE_POSITIVE; // negative draw score
constexpr bScore SCORE_PUNDEFINED       = 0x3FFE; // draw bit unset, positive (0xBFFE for positive)
constexpr bScore SCORE_UNDEFINED        = SCORE_PUNDEFINED | ~SCORE_POSITIVE;
 
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_UNKNOWN = 0,
  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;
 
namespace belofte {
  bScore realScore(bScore const sc);
}
 
//-----------------------------------------------------------------------
 
class bPositionEvaluation {
public:
  explicit bPositionEvaluation(std::string const& n);
  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;
 
  operator std::string() const& { return const_cast<std::string const&>(m_name); }
 
  virtual bScore getEvaluation(bBoard const& b) const = 0;
 
  gameResult_t isGameEnded(bBoard const& b) const;
 
public:
  static bScore pieceValue(piece_t const p);
  static bScore mymove_pieceValue(piece_t const p);
  static bScore centerplay_pieceValue(case_t const p);
 
protected:
  bScore resultToScoreFlag(gameResult_t const sc) const;
 
private:
  std::string getPieceList(bBoard const& b) const;
  int8_t nFoldRepetition(bBoard const& b) const;
  bool twoFoldRepetition(bBoard const& b) const;
  bool threeFoldRepetition(bBoard const& b) const;
  bool insufficientMaterial(bBoard const& b) const;
  bool sameColorBishops(bBoard const& b) const;
 
  std::string m_name;
};
 
//-----------------------------------------------------------------------
 
class PosEvalPiecesOnly final : public bPositionEvaluation {
public:
  PosEvalPiecesOnly();
  ~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:
  PosEvalStaticBoard();
  explicit PosEvalStaticBoard(std::string const& n);
  ~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();
  ~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 const iRank) const;
  bScore openLineValBlack(bBoard const& b, column_t const iCol,
          rank_t const 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