Subversion Repositories Games.Chess Giants

Rev

Rev 96 | 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-2018 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. /// EndgameCode lists all supported endgame functions by corresponding codes
  35.  
  36. enum EndgameCode {
  37.  
  38.   EVALUATION_FUNCTIONS,
  39.   KNNK,  // KNN vs K
  40.   KXK,   // Generic "mate lone king" eval
  41.   KBNK,  // KBN vs K
  42.   KPK,   // KP vs K
  43.   KRKP,  // KR vs KP
  44.   KRKB,  // KR vs KB
  45.   KRKN,  // KR vs KN
  46.   KQKP,  // KQ vs KP
  47.   KQKR,  // KQ vs KR
  48.  
  49.   SCALING_FUNCTIONS,
  50.   KBPsK,   // KB and pawns vs K
  51.   KQKRPs,  // KQ vs KR and pawns
  52.   KRPKR,   // KRP vs KR
  53.   KRPKB,   // KRP vs KB
  54.   KRPPKRP, // KRPP vs KRP
  55.   KPsK,    // K and pawns vs K
  56.   KBPKB,   // KBP vs KB
  57.   KBPPKB,  // KBPP vs KB
  58.   KBPKN,   // KBP vs KN
  59.   KNPK,    // KNP vs K
  60.   KNPKB,   // KNP vs KB
  61.   KPKP     // KP vs KP
  62. };
  63.  
  64.  
  65. /// Endgame functions can be of two types depending on whether they return a
  66. /// Value or a ScaleFactor.
  67. template<EndgameCode E> using
  68. eg_type = typename std::conditional<(E < SCALING_FUNCTIONS), Value, ScaleFactor>::type;
  69.  
  70.  
  71. /// Base and derived functors for endgame evaluation and scaling functions
  72.  
  73. template<typename T>
  74. struct EndgameBase {
  75.  
  76.   explicit EndgameBase(Color c) : strongSide(c), weakSide(~c) {}
  77.   virtual ~EndgameBase() = default;
  78.   virtual T operator()(const Position&) const = 0;
  79.  
  80.   const Color strongSide, weakSide;
  81. };
  82.  
  83.  
  84. template<EndgameCode E, typename T = eg_type<E>>
  85. struct Endgame : public EndgameBase<T> {
  86.  
  87.   explicit Endgame(Color c) : EndgameBase<T>(c) {}
  88.   T operator()(const Position&) const override;
  89. };
  90.  
  91.  
  92. /// The Endgames class stores the pointers to endgame evaluation and scaling
  93. /// base objects in two std::map. We use polymorphism to invoke the actual
  94. /// endgame function by calling its virtual operator().
  95.  
  96. class Endgames {
  97.  
  98.   template<typename T> using Ptr = std::unique_ptr<EndgameBase<T>>;
  99.   template<typename T> using Map = std::map<Key, Ptr<T>>;
  100.  
  101.   template<typename T>
  102.   Map<T>& map() {
  103.     return std::get<std::is_same<T, ScaleFactor>::value>(maps);
  104.   }
  105.  
  106.   template<EndgameCode E, typename T = eg_type<E>, typename P = Ptr<T>>
  107.   void add(const std::string& code) {
  108.  
  109.     StateInfo st;
  110.     map<T>()[Position().set(code, WHITE, &st).material_key()] = P(new Endgame<E>(WHITE));
  111.     map<T>()[Position().set(code, BLACK, &st).material_key()] = P(new Endgame<E>(BLACK));
  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.