Move EndgameFunctions to endgame.cpp
[stockfish] / src / endgame.cpp
index 167a9ed4f5df1f8b479c6b5064de0cba2630bc44..44a34d607fb69676fd12b662f2b56f2c18e26003 100644 (file)
@@ -23,6 +23,8 @@
 #include "endgame.h"
 #include "pawns.h"
 
+using std::string;
+
 extern uint32_t probe_kpk_bitbase(Square wksq, Square wpsq, Square bksq, Color stm);
 
 namespace {
@@ -78,15 +80,102 @@ 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);
@@ -112,7 +201,7 @@ Value EvaluationFunction<KXK>::apply(const Position& pos) const {
 /// 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);
@@ -144,7 +233,7 @@ Value EvaluationFunction<KBNK>::apply(const Position& pos) const {
 
 /// 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);
@@ -192,7 +281,7 @@ Value EvaluationFunction<KPK>::apply(const Position& pos) const {
 /// 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);
@@ -249,7 +338,7 @@ Value EvaluationFunction<KRKP>::apply(const Position& pos) const {
 /// 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);
@@ -265,7 +354,7 @@ Value EvaluationFunction<KRKB>::apply(const Position& pos) const {
 /// 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);
@@ -291,7 +380,7 @@ Value EvaluationFunction<KRKN>::apply(const Position& pos) const {
 /// 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);
@@ -310,7 +399,7 @@ Value EvaluationFunction<KQKR>::apply(const Position& pos) const {
 }
 
 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);
@@ -339,12 +428,12 @@ Value EvaluationFunction<KBBKN>::apply(const Position& pos) const {
 /// 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;
 }
 
@@ -354,7 +443,7 @@ Value EvaluationFunction<KNNK>::apply(const Position&) const {
 /// 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);
@@ -408,7 +497,7 @@ ScaleFactor ScalingFunction<KBPsK>::apply(const Position& pos) const {
 /// 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);
@@ -439,7 +528,7 @@ ScaleFactor ScalingFunction<KQKRPs>::apply(const Position& pos) const {
 /// 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);
@@ -557,7 +646,7 @@ ScaleFactor ScalingFunction<KRPKR>::apply(const Position& pos) const {
 /// 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);
@@ -596,7 +685,7 @@ ScaleFactor ScalingFunction<KRPPKRP>::apply(const Position& pos) const {
 /// 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);
@@ -634,7 +723,7 @@ ScaleFactor ScalingFunction<KPsK>::apply(const Position& pos) const {
 /// 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);
@@ -689,7 +778,7 @@ ScaleFactor ScalingFunction<KBPKB>::apply(const Position& pos) const {
 /// 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);
@@ -765,7 +854,7 @@ ScaleFactor ScalingFunction<KBPPKB>::apply(const Position& pos) const {
 /// 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);
@@ -792,7 +881,7 @@ ScaleFactor ScalingFunction<KBPKN>::apply(const Position& pos) const {
 /// 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);
@@ -822,7 +911,7 @@ ScaleFactor ScalingFunction<KNPK>::apply(const Position& pos) const {
 /// 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);