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::map<EF>() const { return maps.first; }
-template<> const Endgames::SFMap& Endgames::map<SF>() const { return maps.second; }
+template<> const Endgames::M1& Endgames::map<Endgames::M1>() const { return m1; }
+template<> const Endgames::M2& Endgames::map<Endgames::M2>() const { return m2; }
Endgames::Endgames() {
- add<Value, KPK>("KPK");
- add<Value, KNNK>("KNNK");
- add<Value, KBNK>("KBNK");
- add<Value, KRKP>("KRKP");
- add<Value, KRKB>("KRKB");
- add<Value, KRKN>("KRKN");
- add<Value, KQKR>("KQKR");
- add<Value, KBBKN>("KBBKN");
-
- add<ScaleFactor, KNPK>("KNPK");
- add<ScaleFactor, KRPKR>("KRPKR");
- add<ScaleFactor, KBPKB>("KBPKB");
- add<ScaleFactor, KBPKN>("KBPKN");
- add<ScaleFactor, KBPPKB>("KBPPKB");
- add<ScaleFactor, KRPPKRP>("KRPPKRP");
+ add<KPK>("KPK");
+ add<KNNK>("KNNK");
+ add<KBNK>("KBNK");
+ add<KRKP>("KRKP");
+ add<KRKB>("KRKB");
+ add<KRKN>("KRKN");
+ add<KQKR>("KQKR");
+ add<KBBKN>("KBBKN");
+
+ add<KNPK>("KNPK");
+ add<KRPKR>("KRPKR");
+ add<KBPKB>("KBPKB");
+ add<KBPKN>("KBPKN");
+ add<KBPPKB>("KBPPKB");
+ add<KRPPKRP>("KRPPKRP");
}
Endgames::~Endgames() {
- for (EFMap::const_iterator it = map<EF>().begin(); it != map<EF>().end(); ++it)
+ for (M1::const_iterator it = m1.begin(); it != m1.end(); ++it)
delete it->second;
- for (SFMap::const_iterator it = map<SF>().begin(); it != map<SF>().end(); ++it)
+ for (M2::const_iterator it = m2.begin(); it != m2.end(); ++it)
delete it->second;
}
-template<typename T, EndgameType E>
+template<EndgameType E>
void Endgames::add(const string& keyCode) {
- typedef Endgame<T, E> EG;
- typedef typename EG::Base B;
- typedef std::map<Key, B*> M;
+ typedef typename eg_family<E>::type T;
+ typedef typename Map<T>::type M;
- const_cast<M&>(map<B>()).insert(std::pair<Key, B*>(mat_key(keyCode), new EG(WHITE)));
- const_cast<M&>(map<B>()).insert(std::pair<Key, B*>(mat_key(swap_colors(keyCode)), new EG(BLACK)));
+ const_cast<M&>(map<M>()).insert(std::make_pair(mat_key(keyCode), new Endgame<E>(WHITE)));
+ const_cast<M&>(map<M>()).insert(std::make_pair(mat_key(swap_colors(keyCode)), new Endgame<E>(BLACK)));
}
-template<typename T>
-EndgameBase<T>* Endgames::get(Key key) const {
-
- typedef EndgameBase<T> E;
- typename std::map<Key, E*>::const_iterator it = map<E>().find(key);
- return it != map<E>().end() ? it->second : NULL;
-}
-
-// Explicit template instantiations
-template EF* Endgames::get<Value>(Key key) const;
-template SF* Endgames::get<ScaleFactor>(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 Endgame<Value, KXK>::apply(const Position& pos) const {
+Value Endgame<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 Endgame<Value, KBNK>::apply(const Position& pos) const {
+Value Endgame<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 Endgame<Value, KPK>::apply(const Position& pos) const {
+Value Endgame<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 Endgame<Value, KRKP>::apply(const Position& pos) const {
+Value Endgame<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 Endgame<Value, KRKB>::apply(const Position& pos) const {
+Value Endgame<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 Endgame<Value, KRKN>::apply(const Position& pos) const {
+Value Endgame<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 Endgame<Value, KQKR>::apply(const Position& pos) const {
+Value Endgame<KQKR>::apply(const Position& pos) const {
assert(pos.non_pawn_material(strongerSide) == QueenValueMidgame);
assert(pos.piece_count(strongerSide, PAWN) == 0);
}
template<>
-Value Endgame<Value, KBBKN>::apply(const Position& pos) const {
+Value Endgame<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 Endgame<Value, KmmKm>::apply(const Position&) const {
+Value Endgame<KmmKm>::apply(const Position&) const {
return VALUE_DRAW;
}
template<>
-Value Endgame<Value, KNNK>::apply(const Position&) const {
+Value Endgame<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 Endgame<ScaleFactor, KBPsK>::apply(const Position& pos) const {
+ScaleFactor Endgame<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 Endgame<ScaleFactor, KQKRPs>::apply(const Position& pos) const {
+ScaleFactor Endgame<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 Endgame<ScaleFactor, KRPKR>::apply(const Position& pos) const {
+ScaleFactor Endgame<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 Endgame<ScaleFactor, KRPPKRP>::apply(const Position& pos) const {
+ScaleFactor Endgame<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 Endgame<ScaleFactor, KPsK>::apply(const Position& pos) const {
+ScaleFactor Endgame<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 Endgame<ScaleFactor, KBPKB>::apply(const Position& pos) const {
+ScaleFactor Endgame<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 Endgame<ScaleFactor, KBPPKB>::apply(const Position& pos) const {
+ScaleFactor Endgame<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 Endgame<ScaleFactor, KBPKN>::apply(const Position& pos) const {
+ScaleFactor Endgame<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 Endgame<ScaleFactor, KNPK>::apply(const Position& pos) const {
+ScaleFactor Endgame<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 Endgame<ScaleFactor, KPKP>::apply(const Position& pos) const {
+ScaleFactor Endgame<KPKP>::apply(const Position& pos) const {
assert(pos.non_pawn_material(strongerSide) == VALUE_ZERO);
assert(pos.non_pawn_material(weakerSide) == VALUE_ZERO);
projects / stockfish / blobdiff