Subversion Repositories Games.Chess Giants

Rev

Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. /*
  2.   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
  3.   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
  4.   Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
  5.   Copyright (C) 2015-2016 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
  6.  
  7.   Stockfish is free software: you can redistribute it and/or modify
  8.   it under the terms of the GNU General Public License as published by
  9.   the Free Software Foundation, either version 3 of the License, or
  10.   (at your option) any later version.
  11.  
  12.   Stockfish is distributed in the hope that it will be useful,
  13.   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.   GNU General Public License for more details.
  16.  
  17.   You should have received a copy of the GNU General Public License
  18.   along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19. */
  20.  
  21. #ifndef ENDGAME_H_INCLUDED
  22. #define ENDGAME_H_INCLUDED
  23.  
  24. #include <map>
  25. #include <memory>
  26. #include <string>
  27. #include <type_traits>
  28. #include <utility>
  29.  
  30. #include "position.h"
  31. #include "types.h"
  32.  
  33.  
  34. /// EndgameType lists all supported endgames
  35.  
  36. enum EndgameType {
  37.  
  38.   // Evaluation functions
  39.  
  40.   KNNK,  // KNN vs K
  41.   KXK,   // Generic "mate lone king" eval
  42.   KBNK,  // KBN vs K
  43.   KPK,   // KP vs K
  44.   KRKP,  // KR vs KP
  45.   KRKB,  // KR vs KB
  46.   KRKN,  // KR vs KN
  47.   KQKP,  // KQ vs KP
  48.   KQKR,  // KQ vs KR
  49.  
  50.  
  51.   // Scaling functions
  52.   SCALING_FUNCTIONS,
  53.  
  54.   KBPsK,   // KB and pawns vs K
  55.   KQKRPs,  // KQ vs KR and pawns
  56.   KRPKR,   // KRP vs KR
  57.   KRPKB,   // KRP vs KB
  58.   KRPPKRP, // KRPP vs KRP
  59.   KPsK,    // K and pawns vs K
  60.   KBPKB,   // KBP vs KB
  61.   KBPPKB,  // KBPP vs KB
  62.   KBPKN,   // KBP vs KN
  63.   KNPK,    // KNP vs K
  64.   KNPKB,   // KNP vs KB
  65.   KPKP     // KP vs KP
  66. };
  67.  
  68.  
  69. /// Endgame functions can be of two types depending on whether they return a
  70. /// Value or a ScaleFactor.
  71. template<EndgameType E> using
  72. eg_type = typename std::conditional<(E < SCALING_FUNCTIONS), Value, ScaleFactor>::type;
  73.  
  74.  
  75. /// Base and derived templates for endgame evaluation and scaling functions
  76.  
  77. template<typename T>
  78. struct EndgameBase {
  79.  
  80.   virtual ~EndgameBase() = default;
  81.   virtual Color strong_side() const = 0;
  82.   virtual T operator()(const Position&) const = 0;
  83. };
  84.  
  85.  
  86. template<EndgameType E, typename T = eg_type<E>>
  87. struct Endgame : public EndgameBase<T> {
  88.  
  89.   explicit Endgame(Color c) : strongSide(c), weakSide(~c) {}
  90.   Color strong_side() const { return strongSide; }
  91.   T operator()(const Position&) const;
  92.  
  93. private:
  94.   Color strongSide, weakSide;
  95. };
  96.  
  97.  
  98. /// The Endgames class stores the pointers to endgame evaluation and scaling
  99. /// base objects in two std::map. We use polymorphism to invoke the actual
  100. /// endgame function by calling its virtual operator().
  101.  
  102. class Endgames {
  103.  
  104.   template<typename T> using Map = std::map<Key, std::unique_ptr<EndgameBase<T>>>;
  105.  
  106.   template<EndgameType E, typename T = eg_type<E>>
  107.   void add(const std::string& code);
  108.  
  109.   template<typename T>
  110.   Map<T>& map() {
  111.     return std::get<std::is_same<T, ScaleFactor>::value>(maps);
  112.   }
  113.  
  114.   std::pair<Map<Value>, Map<ScaleFactor>> maps;
  115.  
  116. public:
  117.   Endgames();
  118.  
  119.   template<typename T>
  120.   EndgameBase<T>* probe(Key key) {
  121.     return map<T>().count(key) ? map<T>()[key].get() : nullptr;
  122.   }
  123. };
  124.  
  125. #endif // #ifndef ENDGAME_H_INCLUDED
  126.