And cleanup code while there.
No functional change.
Signed-off-by: Marco Costalba <mcostalba@gmail.com>
#include "endgame.h"
#include "pawns.h"
+using std::string;
+
extern uint32_t probe_kpk_bitbase(Square wksq, Square wpsq, Square bksq, Color stm);
namespace {
return Value(KRKNKingKnightDistancePenalty[d]);
}
+ // Build corresponding key for the opposite color: "KBPKN" -> "KNKBP"
+ const string swapColors(const string& keyCode) {
+
+ size_t idx = keyCode.find('K', 1);
+ return keyCode.substr(idx) + keyCode.substr(0, idx);
+ }
+
+ // Build up a fen string with the given pieces, note that the fen string
+ // could be of an illegal position.
+ Key buildKey(const string& keyCode) {
+
+ assert(keyCode.length() > 0 && keyCode.length() < 8);
+ assert(keyCode[0] == 'K');
+
+ string fen;
+ bool upcase = false;
+
+ for (size_t i = 0; i < keyCode.length(); i++)
+ {
+ if (keyCode[i] == 'K')
+ upcase = !upcase;
+
+ fen += char(upcase ? toupper(keyCode[i]) : tolower(keyCode[i]));
+ }
+ fen += char(8 - keyCode.length() + '0');
+ fen += "/8/8/8/8/8/8/8 w - -";
+ return Position(fen, false, 0).get_material_key();
+ }
+
+ typedef EndgameBase<Value> EF;
+ typedef EndgameBase<ScaleFactor> SF;
+
+} // namespace
+
+
+/// Endgames member definitions
+
+template<> const Endgames::EFMap& Endgames::get<EF>() const { return maps.first; }
+template<> const Endgames::SFMap& Endgames::get<SF>() const { return maps.second; }
+
+Endgames::Endgames() {
+
+ add<Endgame<Value, KNNK> >("KNNK");
+ add<Endgame<Value, KPK> >("KPK");
+ add<Endgame<Value, KBNK> >("KBNK");
+ add<Endgame<Value, KRKP> >("KRKP");
+ add<Endgame<Value, KRKB> >("KRKB");
+ add<Endgame<Value, KRKN> >("KRKN");
+ add<Endgame<Value, KQKR> >("KQKR");
+ add<Endgame<Value, KBBKN> >("KBBKN");
+
+ add<Endgame<ScaleFactor, KNPK> >("KNPK");
+ add<Endgame<ScaleFactor, KRPKR> >("KRPKR");
+ add<Endgame<ScaleFactor, KBPKB> >("KBPKB");
+ add<Endgame<ScaleFactor, KBPPKB> >("KBPPKB");
+ add<Endgame<ScaleFactor, KBPKN> >("KBPKN");
+ add<Endgame<ScaleFactor, KRPPKRP> >("KRPPKRP");
+}
+
+Endgames::~Endgames() {
+
+ for (EFMap::const_iterator it = get<EF>().begin(); it != get<EF>().end(); ++it)
+ delete it->second;
+
+ for (SFMap::const_iterator it = get<SF>().begin(); it != get<SF>().end(); ++it)
+ delete it->second;
+}
+
+template<class T>
+void Endgames::add(const string& keyCode) {
+
+ typedef typename T::Base F;
+ typedef std::map<Key, F*> M;
+
+ const_cast<M&>(get<F>()).insert(std::pair<Key, F*>(buildKey(keyCode), new T(WHITE)));
+ const_cast<M&>(get<F>()).insert(std::pair<Key, F*>(buildKey(swapColors(keyCode)), new T(BLACK)));
}
+template<class T>
+T* Endgames::get(Key key) const {
+
+ typename std::map<Key, T*>::const_iterator it = get<T>().find(key);
+ return it != get<T>().end() ? it->second : NULL;
+}
+
+// Explicit template instantiations
+template EF* Endgames::get<EF>(Key key) const;
+template SF* Endgames::get<SF>(Key key) const;
+
/// Mate with KX vs K. This function is used to evaluate positions with
/// King and plenty of material vs a lone king. It simply gives the
/// attacking side a bonus for driving the defending king towards the edge
/// of the board, and for keeping the distance between the two kings small.
template<>
-Value EvaluationFunction<KXK>::apply(const Position& pos) const {
+Value Endgame<Value, KXK>::apply(const Position& pos) const {
assert(pos.non_pawn_material(weakerSide) == VALUE_ZERO);
assert(pos.piece_count(weakerSide, PAWN) == VALUE_ZERO);
/// Mate with KBN vs K. This is similar to KX vs K, but we have to drive the
/// defending king towards a corner square of the right color.
template<>
-Value EvaluationFunction<KBNK>::apply(const Position& pos) const {
+Value Endgame<Value, KBNK>::apply(const Position& pos) const {
assert(pos.non_pawn_material(weakerSide) == VALUE_ZERO);
assert(pos.piece_count(weakerSide, PAWN) == VALUE_ZERO);
/// KP vs K. This endgame is evaluated with the help of a bitbase.
template<>
-Value EvaluationFunction<KPK>::apply(const Position& pos) const {
+Value Endgame<Value, KPK>::apply(const Position& pos) const {
assert(pos.non_pawn_material(strongerSide) == VALUE_ZERO);
assert(pos.non_pawn_material(weakerSide) == VALUE_ZERO);
/// far advanced with support of the king, while the attacking king is far
/// away.
template<>
-Value EvaluationFunction<KRKP>::apply(const Position& pos) const {
+Value Endgame<Value, KRKP>::apply(const Position& pos) const {
assert(pos.non_pawn_material(strongerSide) == RookValueMidgame);
assert(pos.piece_count(strongerSide, PAWN) == 0);
/// KR vs KB. This is very simple, and always returns drawish scores. The
/// score is slightly bigger when the defending king is close to the edge.
template<>
-Value EvaluationFunction<KRKB>::apply(const Position& pos) const {
+Value Endgame<Value, KRKB>::apply(const Position& pos) const {
assert(pos.non_pawn_material(strongerSide) == RookValueMidgame);
assert(pos.piece_count(strongerSide, PAWN) == 0);
/// KR vs KN. The attacking side has slightly better winning chances than
/// in KR vs KB, particularly if the king and the knight are far apart.
template<>
-Value EvaluationFunction<KRKN>::apply(const Position& pos) const {
+Value Endgame<Value, KRKN>::apply(const Position& pos) const {
assert(pos.non_pawn_material(strongerSide) == RookValueMidgame);
assert(pos.piece_count(strongerSide, PAWN) == 0);
/// for the defending side in the search, this is usually sufficient to be
/// able to win KQ vs KR.
template<>
-Value EvaluationFunction<KQKR>::apply(const Position& pos) const {
+Value Endgame<Value, KQKR>::apply(const Position& pos) const {
assert(pos.non_pawn_material(strongerSide) == QueenValueMidgame);
assert(pos.piece_count(strongerSide, PAWN) == 0);
}
template<>
-Value EvaluationFunction<KBBKN>::apply(const Position& pos) const {
+Value Endgame<Value, KBBKN>::apply(const Position& pos) const {
assert(pos.piece_count(strongerSide, BISHOP) == 2);
assert(pos.non_pawn_material(strongerSide) == 2*BishopValueMidgame);
/// K and two minors vs K and one or two minors or K and two knights against
/// king alone are always draw.
template<>
-Value EvaluationFunction<KmmKm>::apply(const Position&) const {
+Value Endgame<Value, KmmKm>::apply(const Position&) const {
return VALUE_DRAW;
}
template<>
-Value EvaluationFunction<KNNK>::apply(const Position&) const {
+Value Endgame<Value, KNNK>::apply(const Position&) const {
return VALUE_DRAW;
}
/// returned. If not, the return value is SCALE_FACTOR_NONE, i.e. no scaling
/// will be used.
template<>
-ScaleFactor ScalingFunction<KBPsK>::apply(const Position& pos) const {
+ScaleFactor Endgame<ScaleFactor, KBPsK>::apply(const Position& pos) const {
assert(pos.non_pawn_material(strongerSide) == BishopValueMidgame);
assert(pos.piece_count(strongerSide, BISHOP) == 1);
/// It tests for fortress draws with a rook on the third rank defended by
/// a pawn.
template<>
-ScaleFactor ScalingFunction<KQKRPs>::apply(const Position& pos) const {
+ScaleFactor Endgame<ScaleFactor, KQKRPs>::apply(const Position& pos) const {
assert(pos.non_pawn_material(strongerSide) == QueenValueMidgame);
assert(pos.piece_count(strongerSide, QUEEN) == 1);
/// It would also be nice to rewrite the actual code for this function,
/// which is mostly copied from Glaurung 1.x, and not very pretty.
template<>
-ScaleFactor ScalingFunction<KRPKR>::apply(const Position& pos) const {
+ScaleFactor Endgame<ScaleFactor, KRPKR>::apply(const Position& pos) const {
assert(pos.non_pawn_material(strongerSide) == RookValueMidgame);
assert(pos.piece_count(strongerSide, PAWN) == 1);
/// single pattern: If the stronger side has no pawns and the defending king
/// is actively placed, the position is drawish.
template<>
-ScaleFactor ScalingFunction<KRPPKRP>::apply(const Position& pos) const {
+ScaleFactor Endgame<ScaleFactor, KRPPKRP>::apply(const Position& pos) const {
assert(pos.non_pawn_material(strongerSide) == RookValueMidgame);
assert(pos.piece_count(strongerSide, PAWN) == 2);
/// against king. There is just a single rule here: If all pawns are on
/// the same rook file and are blocked by the defending king, it's a draw.
template<>
-ScaleFactor ScalingFunction<KPsK>::apply(const Position& pos) const {
+ScaleFactor Endgame<ScaleFactor, KPsK>::apply(const Position& pos) const {
assert(pos.non_pawn_material(strongerSide) == VALUE_ZERO);
assert(pos.piece_count(strongerSide, PAWN) >= 2);
/// it's a draw. If the two bishops have opposite color, it's almost always
/// a draw.
template<>
-ScaleFactor ScalingFunction<KBPKB>::apply(const Position& pos) const {
+ScaleFactor Endgame<ScaleFactor, KBPKB>::apply(const Position& pos) const {
assert(pos.non_pawn_material(strongerSide) == BishopValueMidgame);
assert(pos.piece_count(strongerSide, BISHOP) == 1);
/// KBPPKBScalingFunction scales KBPP vs KB endgames. It detects a few basic
/// draws with opposite-colored bishops.
template<>
-ScaleFactor ScalingFunction<KBPPKB>::apply(const Position& pos) const {
+ScaleFactor Endgame<ScaleFactor, KBPPKB>::apply(const Position& pos) const {
assert(pos.non_pawn_material(strongerSide) == BishopValueMidgame);
assert(pos.piece_count(strongerSide, BISHOP) == 1);
/// square of the king is not of the same color as the stronger side's bishop,
/// it's a draw.
template<>
-ScaleFactor ScalingFunction<KBPKN>::apply(const Position& pos) const {
+ScaleFactor Endgame<ScaleFactor, KBPKN>::apply(const Position& pos) const {
assert(pos.non_pawn_material(strongerSide) == BishopValueMidgame);
assert(pos.piece_count(strongerSide, BISHOP) == 1);
/// If the pawn is a rook pawn on the 7th rank and the defending king prevents
/// the pawn from advancing, the position is drawn.
template<>
-ScaleFactor ScalingFunction<KNPK>::apply(const Position& pos) const {
+ScaleFactor Endgame<ScaleFactor, KNPK>::apply(const Position& pos) const {
assert(pos.non_pawn_material(strongerSide) == KnightValueMidgame);
assert(pos.piece_count(strongerSide, KNIGHT) == 1);
/// advanced and not on a rook file; in this case it is often possible to win
/// (e.g. 8/4k3/3p4/3P4/6K1/8/8/8 w - - 0 1).
template<>
-ScaleFactor ScalingFunction<KPKP>::apply(const Position& pos) const {
+ScaleFactor Endgame<ScaleFactor, KPKP>::apply(const Position& pos) const {
assert(pos.non_pawn_material(strongerSide) == VALUE_ZERO);
assert(pos.non_pawn_material(weakerSide) == VALUE_ZERO);
#if !defined(ENDGAME_H_INCLUDED)
#define ENDGAME_H_INCLUDED
+#include <string>
+#include <map>
+
#include "position.h"
#include "types.h"
+
+/// EndgameType lists all supported endgames
+
enum EndgameType {
- // Evaluation functions
- KXK, // Generic "mate lone king" eval
- KBNK, // KBN vs K
- KPK, // KP vs K
- KRKP, // KR vs KP
- KRKB, // KR vs KB
- KRKN, // KR vs KN
- KQKR, // KQ vs KR
- KBBKN, // KBB vs KN
- KNNK, // KNN vs K
- KmmKm, // K and two minors vs K and one or two minors
-
- // Scaling functions
- KBPsK, // KB+pawns vs K
- KQKRPs, // KQ vs KR+pawns
- KRPKR, // KRP vs KR
- KRPPKRP, // KRPP vs KRP
- KPsK, // King and pawns vs king
- KBPKB, // KBP vs KB
- KBPPKB, // KBPP vs KB
- KBPKN, // KBP vs KN
- KNPK, // KNP vs K
- KPKP // KP vs KP
+ // Evaluation functions
+ KXK, // Generic "mate lone king" eval
+ KBNK, // KBN vs K
+ KPK, // KP vs K
+ KRKP, // KR vs KP
+ KRKB, // KR vs KB
+ KRKN, // KR vs KN
+ KQKR, // KQ vs KR
+ KBBKN, // KBB vs KN
+ KNNK, // KNN vs K
+ KmmKm, // K and two minors vs K and one or two minors
+
+ // Scaling functions
+ KBPsK, // KB+pawns vs K
+ KQKRPs, // KQ vs KR+pawns
+ KRPKR, // KRP vs KR
+ KRPPKRP, // KRPP vs KRP
+ KPsK, // King and pawns vs king
+ KBPKB, // KBP vs KB
+ KBPPKB, // KBPP vs KB
+ KBPKN, // KBP vs KN
+ KNPK, // KNP vs K
+ KPKP // KP vs KP
};
-/// Template abstract base class for all special endgame functions
+
+/// Base and derived template class for endgame evaluation and scaling functions
template<typename T>
-class EndgameFunctionBase {
-public:
- EndgameFunctionBase(Color c) : strongerSide(c), weakerSide(opposite_color(c)) {}
- virtual ~EndgameFunctionBase() {}
+struct EndgameBase {
+
+ typedef EndgameBase<T> Base;
+
+ EndgameBase(Color c) : strongerSide(c), weakerSide(opposite_color(c)) {}
+ virtual ~EndgameBase() {}
virtual T apply(const Position&) const = 0;
Color color() const { return strongerSide; }
Color strongerSide, weakerSide;
};
-typedef EndgameFunctionBase<Value> EndgameEvaluationFunctionBase;
-typedef EndgameFunctionBase<ScaleFactor> EndgameScalingFunctionBase;
-
-/// Templates subclass for various concrete endgames
+template<typename T, EndgameType>
+struct Endgame : public EndgameBase<T> {
-template<EndgameType>
-struct EvaluationFunction : public EndgameEvaluationFunctionBase {
- typedef EndgameEvaluationFunctionBase Base;
- explicit EvaluationFunction(Color c): EndgameEvaluationFunctionBase(c) {}
- Value apply(const Position&) const;
+ explicit Endgame(Color c): EndgameBase<T>(c) {}
+ T apply(const Position&) const;
};
-template<EndgameType>
-struct ScalingFunction : public EndgameScalingFunctionBase {
- typedef EndgameScalingFunctionBase Base;
- explicit ScalingFunction(Color c) : EndgameScalingFunctionBase(c) {}
- ScaleFactor apply(const Position&) const;
+
+/// Endgames class stores in two std::map the pointers to endgame evaluation
+/// and scaling base objects. Then we use polymorphism to invoke the actual
+/// endgame function calling its apply() method that is virtual.
+
+class Endgames {
+
+ typedef std::map<Key, EndgameBase<Value>*> EFMap;
+ typedef std::map<Key, EndgameBase<ScaleFactor>*> SFMap;
+
+public:
+ Endgames();
+ ~Endgames();
+ template<class T> T* get(Key key) const;
+
+private:
+ template<class T> void add(const std::string& keyCode);
+
+ // Here we store two maps, for evaluate and scaling functions...
+ std::pair<EFMap, SFMap> maps;
+
+ // ...and here is the accessing template function
+ template<typename T> const std::map<Key, T*>& get() const;
};
#endif // !defined(ENDGAME_H_INCLUDED)
#include <cassert>
#include <cstring>
-#include <map>
#include "material.h"
{ 41, 41, 41, 41, 41, 41 }, { 37, 41, 41, 41, 41, 41 }, { 10, 62, 41, 41, 41, 41 },
{ 57, 64, 39, 41, 41, 41 }, { 50, 40, 23, -22, 41, 41 }, { 106, 101, 3, 151, 171, 41 } };
- typedef EndgameEvaluationFunctionBase EF;
- typedef EndgameScalingFunctionBase SF;
- typedef map<Key, EF*> EFMap;
- typedef map<Key, SF*> SFMap;
-
// Endgame evaluation and scaling functions accessed direcly and not through
// the function maps because correspond to more then one material hash key.
- EvaluationFunction<KmmKm> EvaluateKmmKm[] = { EvaluationFunction<KmmKm>(WHITE), EvaluationFunction<KmmKm>(BLACK) };
- EvaluationFunction<KXK> EvaluateKXK[] = { EvaluationFunction<KXK>(WHITE), EvaluationFunction<KXK>(BLACK) };
- ScalingFunction<KBPsK> ScaleKBPsK[] = { ScalingFunction<KBPsK>(WHITE), ScalingFunction<KBPsK>(BLACK) };
- ScalingFunction<KQKRPs> ScaleKQKRPs[] = { ScalingFunction<KQKRPs>(WHITE), ScalingFunction<KQKRPs>(BLACK) };
- ScalingFunction<KPsK> ScaleKPsK[] = { ScalingFunction<KPsK>(WHITE), ScalingFunction<KPsK>(BLACK) };
- ScalingFunction<KPKP> ScaleKPKP[] = { ScalingFunction<KPKP>(WHITE), ScalingFunction<KPKP>(BLACK) };
+ Endgame<Value, KmmKm> EvaluateKmmKm[] = { Endgame<Value, KmmKm>(WHITE), Endgame<Value, KmmKm>(BLACK) };
+ Endgame<Value, KXK> EvaluateKXK[] = { Endgame<Value, KXK>(WHITE), Endgame<Value, KXK>(BLACK) };
+
+ Endgame<ScaleFactor, KBPsK> ScaleKBPsK[] = { Endgame<ScaleFactor, KBPsK>(WHITE), Endgame<ScaleFactor, KBPsK>(BLACK) };
+ Endgame<ScaleFactor, KQKRPs> ScaleKQKRPs[] = { Endgame<ScaleFactor, KQKRPs>(WHITE), Endgame<ScaleFactor, KQKRPs>(BLACK) };
+ Endgame<ScaleFactor, KPsK> ScaleKPsK[] = { Endgame<ScaleFactor, KPsK>(WHITE), Endgame<ScaleFactor, KPsK>(BLACK) };
+ Endgame<ScaleFactor, KPKP> ScaleKPKP[] = { Endgame<ScaleFactor, KPKP>(WHITE), Endgame<ScaleFactor, KPKP>(BLACK) };
// Helper templates used to detect a given material distribution
template<Color Us> bool is_KXK(const Position& pos) {
&& pos.piece_count(Them, ROOK) == 1
&& pos.piece_count(Them, PAWN) >= 1;
}
-}
-
-
-/// EndgameFunctions class stores endgame evaluation and scaling functions
-/// in two std::map. Because STL library is not guaranteed to be thread
-/// safe even for read access, the maps, although with identical content,
-/// are replicated for each thread. This is faster then using locks.
-
-class EndgameFunctions {
-public:
- EndgameFunctions();
- ~EndgameFunctions();
- template<class T> T* get(Key key) const;
-
-private:
- template<class T> void add(const string& keyCode);
-
- static Key buildKey(const string& keyCode);
- static const string swapColors(const string& keyCode);
-
- // Here we store two maps, for evaluate and scaling functions...
- pair<EFMap, SFMap> maps;
-
- // ...and here is the accessing template function
- template<typename T> const map<Key, T*>& get() const;
-};
-// Explicit specializations of a member function shall be declared in
-// the namespace of which the class template is a member.
-template<> const EFMap& EndgameFunctions::get<EF>() const { return maps.first; }
-template<> const SFMap& EndgameFunctions::get<SF>() const { return maps.second; }
+} // namespace
-/// MaterialInfoTable c'tor and d'tor allocate and free the space for EndgameFunctions
+/// MaterialInfoTable c'tor and d'tor allocate and free the space for Endgames
-MaterialInfoTable::MaterialInfoTable() { funcs = new EndgameFunctions(); }
+MaterialInfoTable::MaterialInfoTable() { funcs = new Endgames(); }
MaterialInfoTable::~MaterialInfoTable() { delete funcs; }
// Let's look if we have a specialized evaluation function for this
// particular material configuration. First we look for a fixed
// configuration one, then a generic one if previous search failed.
- if ((mi->evaluationFunction = funcs->get<EF>(key)) != NULL)
+ if ((mi->evaluationFunction = funcs->get<EndgameBase<Value> >(key)) != NULL)
return mi;
if (is_KXK<WHITE>(pos))
//
// We face problems when there are several conflicting applicable
// scaling functions and we need to decide which one to use.
- SF* sf;
+ EndgameBase<ScaleFactor>* sf;
- if ((sf = funcs->get<SF>(key)) != NULL)
+ if ((sf = funcs->get<EndgameBase<ScaleFactor> >(key)) != NULL)
{
mi->scalingFunction[sf->color()] = sf;
return mi;
const Color Them = (Us == WHITE ? BLACK : WHITE);
- int pt1, pt2, pc, vv;
+ int pt1, pt2, pc, v;
int value = 0;
// Redundancy of major pieces, formula based on Kaufman's paper
if (!pc)
continue;
- vv = LinearCoefficients[pt1];
+ v = LinearCoefficients[pt1];
for (pt2 = PIECE_TYPE_NONE; pt2 <= pt1; pt2++)
- vv += QuadraticCoefficientsSameColor[pt1][pt2] * pieceCount[Us][pt2]
- + QuadraticCoefficientsOppositeColor[pt1][pt2] * pieceCount[Them][pt2];
+ v += QuadraticCoefficientsSameColor[pt1][pt2] * pieceCount[Us][pt2]
+ + QuadraticCoefficientsOppositeColor[pt1][pt2] * pieceCount[Them][pt2];
- value += pc * vv;
+ value += pc * v;
}
return value;
}
Value npm = pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK);
- if (npm >= MidgameLimit)
- return PHASE_MIDGAME;
-
- if (npm <= EndgameLimit)
- return PHASE_ENDGAME;
-
- return Phase(((npm - EndgameLimit) * 128) / (MidgameLimit - EndgameLimit));
-}
-
-
-/// EndgameFunctions member definitions
-
-EndgameFunctions::EndgameFunctions() {
-
- add<EvaluationFunction<KNNK> >("KNNK");
- add<EvaluationFunction<KPK> >("KPK");
- add<EvaluationFunction<KBNK> >("KBNK");
- add<EvaluationFunction<KRKP> >("KRKP");
- add<EvaluationFunction<KRKB> >("KRKB");
- add<EvaluationFunction<KRKN> >("KRKN");
- add<EvaluationFunction<KQKR> >("KQKR");
- add<EvaluationFunction<KBBKN> >("KBBKN");
-
- add<ScalingFunction<KNPK> >("KNPK");
- add<ScalingFunction<KRPKR> >("KRPKR");
- add<ScalingFunction<KBPKB> >("KBPKB");
- add<ScalingFunction<KBPPKB> >("KBPPKB");
- add<ScalingFunction<KBPKN> >("KBPKN");
- add<ScalingFunction<KRPPKRP> >("KRPPKRP");
-}
-
-EndgameFunctions::~EndgameFunctions() {
-
- for (EFMap::const_iterator it = maps.first.begin(); it != maps.first.end(); ++it)
- delete it->second;
-
- for (SFMap::const_iterator it = maps.second.begin(); it != maps.second.end(); ++it)
- delete it->second;
-}
-
-Key EndgameFunctions::buildKey(const string& keyCode) {
-
- assert(keyCode.length() > 0 && keyCode.length() < 8);
- assert(keyCode[0] == 'K');
-
- string fen;
- bool upcase = false;
-
- // Build up a fen string with the given pieces, note that
- // the fen string could be of an illegal position.
- for (size_t i = 0; i < keyCode.length(); i++)
- {
- if (keyCode[i] == 'K')
- upcase = !upcase;
-
- fen += char(upcase ? toupper(keyCode[i]) : tolower(keyCode[i]));
- }
- fen += char(8 - keyCode.length() + '0');
- fen += "/8/8/8/8/8/8/8 w - -";
- return Position(fen, false, 0).get_material_key();
-}
-
-const string EndgameFunctions::swapColors(const string& keyCode) {
-
- // Build corresponding key for the opposite color: "KBPKN" -> "KNKBP"
- size_t idx = keyCode.find('K', 1);
- return keyCode.substr(idx) + keyCode.substr(0, idx);
-}
-
-template<class T>
-void EndgameFunctions::add(const string& keyCode) {
-
- typedef typename T::Base F;
- typedef map<Key, F*> M;
-
- const_cast<M&>(get<F>()).insert(pair<Key, F*>(buildKey(keyCode), new T(WHITE)));
- const_cast<M&>(get<F>()).insert(pair<Key, F*>(buildKey(swapColors(keyCode)), new T(BLACK)));
-}
-
-template<class T>
-T* EndgameFunctions::get(Key key) const {
-
- typename map<Key, T*>::const_iterator it = get<T>().find(key);
- return it != get<T>().end() ? it->second : NULL;
+ return npm >= MidgameLimit ? PHASE_MIDGAME
+ : npm <= EndgameLimit ? PHASE_ENDGAME
+ : Phase(((npm - EndgameLimit) * 128) / (MidgameLimit - EndgameLimit));
}
Key key;
int16_t value;
uint8_t factor[2];
- EndgameEvaluationFunctionBase* evaluationFunction;
- EndgameScalingFunctionBase* scalingFunction[2];
+ EndgameBase<Value>* evaluationFunction;
+ EndgameBase<ScaleFactor>* scalingFunction[2];
int spaceWeight;
Phase gamePhase;
};
/// The MaterialInfoTable class represents a pawn hash table. The most important
/// method is get_material_info, which returns a pointer to a MaterialInfo object.
-class EndgameFunctions;
class MaterialInfoTable : public SimpleHash<MaterialInfo, MaterialTableSize> {
public:
template<Color Us>
static int imbalance(const int pieceCount[][8]);
- EndgameFunctions* funcs;
+ Endgames* funcs;
};
return sf == SCALE_FACTOR_NONE ? ScaleFactor(factor[c]) : sf;
}
+inline Value MaterialInfo::evaluate(const Position& pos) const {
+ return evaluationFunction->apply(pos);
+}
+
inline Score MaterialInfo::material_value() const {
return make_score(value, value);
}
return evaluationFunction != NULL;
}
-inline Value MaterialInfo::evaluate(const Position& pos) const {
- return evaluationFunction->apply(pos);
-}
-
#endif // !defined(MATERIAL_H_INCLUDED)
class Position {
- friend class MaterialInfo;
- friend class EndgameFunctions;
-
Position(); // No default or copy c'tor allowed
Position(const Position& pos);