X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fendgame.cpp;h=c55013f3ac141f531c3bee0192a63ee4da85eb17;hp=c8c491fdd60aaf304b023f26f12170ffb614161b;hb=48e39c5c8e671a37f09732d4a55d93d5e2d38550;hpb=fe8f5b3497036859f00ed23dbb8abfccc311ab8e

diff --git a/src/endgame.cpp b/src/endgame.cpp
index c8c491fd..c55013f3 100644
--- a/src/endgame.cpp
+++ b/src/endgame.cpp
@@ -87,7 +87,7 @@ namespace {
     do fen += char(tolower(keyCode[i])); while (++i < keyCode.length());
 
     // Add file padding and remaining empty ranks
-    fen += string(1, '0' + int(8 - keyCode.length())) + "/8/8/8/8/8/8/8 w - -";
+    fen += string(1, '0' + int(8 - keyCode.length())) + "/8/8/8/8/8/8/8 w - - 0 10";
 
     // Build a Position out of the fen string and get its material key
     return Position(fen, false, 0).get_material_key();
@@ -101,57 +101,59 @@ 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; }
+template<> const Endgames::EFMap& Endgames::map<EF>() const { return maps.first; }
+template<> const Endgames::SFMap& Endgames::map<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");
+  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");
 }
 
 Endgames::~Endgames() {
 
-  for (EFMap::const_iterator it = get<EF>().begin(); it != get<EF>().end(); ++it)
+  for (EFMap::const_iterator it = map<EF>().begin(); it != map<EF>().end(); ++it)
       delete it->second;
 
-  for (SFMap::const_iterator it = get<SF>().begin(); it != get<SF>().end(); ++it)
+  for (SFMap::const_iterator it = map<SF>().begin(); it != map<SF>().end(); ++it)
       delete it->second;
 }
 
-template<class T>
+template<typename T, EndgameType E>
 void Endgames::add(const string& keyCode) {
 
-  typedef typename T::Base F;
-  typedef std::map<Key, F*> M;
+  typedef Endgame<T, E> EG;
+  typedef typename EG::Base B;
+  typedef std::map<Key, B*> M;
 
-  const_cast<M&>(get<F>()).insert(std::pair<Key, F*>(mat_key(keyCode), new T(WHITE)));
-  const_cast<M&>(get<F>()).insert(std::pair<Key, F*>(mat_key(swap_colors(keyCode)), new T(BLACK)));
+  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)));
 }
 
-template<class T>
-T* Endgames::get(Key key) const {
+template<typename T>
+EndgameBase<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;
+  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<EF>(Key key) const;
-template SF* Endgames::get<SF>(Key key) const;
+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
@@ -196,7 +198,7 @@ Value Endgame<Value, KBNK>::apply(const Position& pos) const {
 
   Square winnerKSq = pos.king_square(strongerSide);
   Square loserKSq = pos.king_square(weakerSide);
-  Square bishopSquare = pos.piece_list(strongerSide, BISHOP, 0);
+  Square bishopSquare = pos.piece_list(strongerSide, BISHOP)[0];
 
   // kbnk_mate_table() tries to drive toward corners A1 or H8,
   // if we have a bishop that cannot reach the above squares we
@@ -231,14 +233,14 @@ Value Endgame<Value, KPK>::apply(const Position& pos) const {
   {
       wksq = pos.king_square(WHITE);
       bksq = pos.king_square(BLACK);
-      wpsq = pos.piece_list(WHITE, PAWN, 0);
+      wpsq = pos.piece_list(WHITE, PAWN)[0];
       stm = pos.side_to_move();
   }
   else
   {
       wksq = flip_square(pos.king_square(BLACK));
       bksq = flip_square(pos.king_square(WHITE));
-      wpsq = flip_square(pos.piece_list(BLACK, PAWN, 0));
+      wpsq = flip_square(pos.piece_list(BLACK, PAWN)[0]);
       stm = opposite_color(pos.side_to_move());
   }
 
@@ -276,9 +278,9 @@ Value Endgame<Value, KRKP>::apply(const Position& pos) const {
   int tempo = (pos.side_to_move() == strongerSide);
 
   wksq = pos.king_square(strongerSide);
-  wrsq = pos.piece_list(strongerSide, ROOK, 0);
+  wrsq = pos.piece_list(strongerSide, ROOK)[0];
   bksq = pos.king_square(weakerSide);
-  bpsq = pos.piece_list(weakerSide, PAWN, 0);
+  bpsq = pos.piece_list(weakerSide, PAWN)[0];
 
   if (strongerSide == BLACK)
   {
@@ -347,7 +349,7 @@ Value Endgame<Value, KRKN>::apply(const Position& pos) const {
   assert(pos.piece_count(weakerSide, KNIGHT) == 1);
 
   Square defendingKSq = pos.king_square(weakerSide);
-  Square nSq = pos.piece_list(weakerSide, KNIGHT, 0);
+  Square nSq = pos.piece_list(weakerSide, KNIGHT)[0];
 
   int d = square_distance(defendingKSq, nSq);
   Value result =   Value(10)
@@ -394,7 +396,7 @@ Value Endgame<Value, KBBKN>::apply(const Position& pos) const {
   Value result = BishopValueEndgame;
   Square wksq = pos.king_square(strongerSide);
   Square bksq = pos.king_square(weakerSide);
-  Square nsq = pos.piece_list(weakerSide, KNIGHT, 0);
+  Square nsq = pos.piece_list(weakerSide, KNIGHT)[0];
 
   // Bonus for attacking king close to defending king
   result += Value(DistanceBonus[square_distance(wksq, bksq)]);
@@ -437,13 +439,13 @@ ScaleFactor Endgame<ScaleFactor, KBPsK>::apply(const Position& pos) const {
   // be detected even when the weaker side has some pawns.
 
   Bitboard pawns = pos.pieces(PAWN, strongerSide);
-  File pawnFile = square_file(pos.piece_list(strongerSide, PAWN, 0));
+  File pawnFile = square_file(pos.piece_list(strongerSide, PAWN)[0]);
 
   // All pawns are on a single rook file ?
   if (   (pawnFile == FILE_A || pawnFile == FILE_H)
       && (pawns & ~file_bb(pawnFile)) == EmptyBoardBB)
   {
-      Square bishopSq = pos.piece_list(strongerSide, BISHOP, 0);
+      Square bishopSq = pos.piece_list(strongerSide, BISHOP)[0];
       Square queeningSq = relative_square(strongerSide, make_square(pawnFile, RANK_8));
       Square kingSq = pos.king_square(weakerSide);
 
@@ -496,7 +498,7 @@ ScaleFactor Endgame<ScaleFactor, KQKRPs>::apply(const Position& pos) const {
       && (pos.pieces(PAWN, weakerSide) & rank_bb(relative_rank(weakerSide, RANK_2)))
       && (pos.attacks_from<KING>(kingSq) & pos.pieces(PAWN, weakerSide)))
   {
-      Square rsq = pos.piece_list(weakerSide, ROOK, 0);
+      Square rsq = pos.piece_list(weakerSide, ROOK)[0];
       if (pos.attacks_from<PAWN>(rsq, strongerSide) & pos.pieces(PAWN, weakerSide))
           return SCALE_FACTOR_ZERO;
   }
@@ -520,10 +522,10 @@ ScaleFactor Endgame<ScaleFactor, KRPKR>::apply(const Position& pos) const {
   assert(pos.piece_count(weakerSide, PAWN) == 0);
 
   Square wksq = pos.king_square(strongerSide);
-  Square wrsq = pos.piece_list(strongerSide, ROOK, 0);
-  Square wpsq = pos.piece_list(strongerSide, PAWN, 0);
+  Square wrsq = pos.piece_list(strongerSide, ROOK)[0];
+  Square wpsq = pos.piece_list(strongerSide, PAWN)[0];
   Square bksq = pos.king_square(weakerSide);
-  Square brsq = pos.piece_list(weakerSide, ROOK, 0);
+  Square brsq = pos.piece_list(weakerSide, ROOK)[0];
 
   // Orient the board in such a way that the stronger side is white, and the
   // pawn is on the left half of the board.
@@ -637,8 +639,8 @@ ScaleFactor Endgame<ScaleFactor, KRPPKRP>::apply(const Position& pos) const {
   assert(pos.non_pawn_material(weakerSide) == RookValueMidgame);
   assert(pos.piece_count(weakerSide, PAWN) == 1);
 
-  Square wpsq1 = pos.piece_list(strongerSide, PAWN, 0);
-  Square wpsq2 = pos.piece_list(strongerSide, PAWN, 1);
+  Square wpsq1 = pos.piece_list(strongerSide, PAWN)[0];
+  Square wpsq2 = pos.piece_list(strongerSide, PAWN)[1];
   Square bksq = pos.king_square(weakerSide);
 
   // Does the stronger side have a passed pawn?
@@ -716,9 +718,9 @@ ScaleFactor Endgame<ScaleFactor, KBPKB>::apply(const Position& pos) const {
   assert(pos.piece_count(weakerSide, BISHOP) == 1);
   assert(pos.piece_count(weakerSide, PAWN) == 0);
 
-  Square pawnSq = pos.piece_list(strongerSide, PAWN, 0);
-  Square strongerBishopSq = pos.piece_list(strongerSide, BISHOP, 0);
-  Square weakerBishopSq = pos.piece_list(weakerSide, BISHOP, 0);
+  Square pawnSq = pos.piece_list(strongerSide, PAWN)[0];
+  Square strongerBishopSq = pos.piece_list(strongerSide, BISHOP)[0];
+  Square weakerBishopSq = pos.piece_list(weakerSide, BISHOP)[0];
   Square weakerKingSq = pos.king_square(weakerSide);
 
   // Case 1: Defending king blocks the pawn, and cannot be driven away
@@ -771,15 +773,15 @@ ScaleFactor Endgame<ScaleFactor, KBPPKB>::apply(const Position& pos) const {
   assert(pos.piece_count(weakerSide, BISHOP) == 1);
   assert(pos.piece_count(weakerSide, PAWN) == 0);
 
-  Square wbsq = pos.piece_list(strongerSide, BISHOP, 0);
-  Square bbsq = pos.piece_list(weakerSide, BISHOP, 0);
+  Square wbsq = pos.piece_list(strongerSide, BISHOP)[0];
+  Square bbsq = pos.piece_list(weakerSide, BISHOP)[0];
 
   if (!opposite_color_squares(wbsq, bbsq))
       return SCALE_FACTOR_NONE;
 
   Square ksq = pos.king_square(weakerSide);
-  Square psq1 = pos.piece_list(strongerSide, PAWN, 0);
-  Square psq2 = pos.piece_list(strongerSide, PAWN, 1);
+  Square psq1 = pos.piece_list(strongerSide, PAWN)[0];
+  Square psq2 = pos.piece_list(strongerSide, PAWN)[1];
   Rank r1 = square_rank(psq1);
   Rank r2 = square_rank(psq2);
   Square blockSq1, blockSq2;
@@ -847,8 +849,8 @@ ScaleFactor Endgame<ScaleFactor, KBPKN>::apply(const Position& pos) const {
   assert(pos.piece_count(weakerSide, KNIGHT) == 1);
   assert(pos.piece_count(weakerSide, PAWN) == 0);
 
-  Square pawnSq = pos.piece_list(strongerSide, PAWN, 0);
-  Square strongerBishopSq = pos.piece_list(strongerSide, BISHOP, 0);
+  Square pawnSq = pos.piece_list(strongerSide, PAWN)[0];
+  Square strongerBishopSq = pos.piece_list(strongerSide, BISHOP)[0];
   Square weakerKingSq = pos.king_square(weakerSide);
 
   if (   square_file(weakerKingSq) == square_file(pawnSq)
@@ -873,7 +875,7 @@ ScaleFactor Endgame<ScaleFactor, KNPK>::apply(const Position& pos) const {
   assert(pos.non_pawn_material(weakerSide) == VALUE_ZERO);
   assert(pos.piece_count(weakerSide, PAWN) == 0);
 
-  Square pawnSq = pos.piece_list(strongerSide, PAWN, 0);
+  Square pawnSq = pos.piece_list(strongerSide, PAWN)[0];
   Square weakerKingSq = pos.king_square(weakerSide);
 
   if (   pawnSq == relative_square(strongerSide, SQ_A7)
@@ -909,14 +911,14 @@ ScaleFactor Endgame<ScaleFactor, KPKP>::apply(const Position& pos) const {
   {
       wksq = pos.king_square(WHITE);
       bksq = pos.king_square(BLACK);
-      wpsq = pos.piece_list(WHITE, PAWN, 0);
+      wpsq = pos.piece_list(WHITE, PAWN)[0];
       stm = pos.side_to_move();
   }
   else
   {
       wksq = flip_square(pos.king_square(BLACK));
       bksq = flip_square(pos.king_square(WHITE));
-      wpsq = flip_square(pos.piece_list(BLACK, PAWN, 0));
+      wpsq = flip_square(pos.piece_list(BLACK, PAWN)[0]);
       stm = opposite_color(pos.side_to_move());
   }