mirror of
https://github.com/sockspls/badfish
synced 2025-04-30 08:43:09 +00:00
Move EndgameFunctions to endgame.cpp
And cleanup code while there. No functional change. Signed-off-by: Marco Costalba <mcostalba@gmail.com>
This commit is contained in:
Marco Costalba
parent
08c464c690
commit
b5d5646c84
5 changed files with 201 additions and 209 deletions
129
src/endgame.cpp
129
src/endgame.cpp
|
|
@ -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);
|
||||
|
|
|
|||
104
src/endgame.h
104
src/endgame.h
|
|
@ -20,43 +20,52 @@
|
|||
#if !defined(ENDGAME_H_INCLUDED)
|
||||
#define ENDGAME_H_INCLUDED
|
||||
|
||||
#include <string>
|
||||
#include <map>
|
||||
|
||||
#include "position.h"
|
||||
#include "types.h"
|
||||
|
||||
|
||||
/// EndgameType lists all supported endgames
|
||||
|
||||
enum EndgameType {
|
||||
|
||||
// Evaluation functions
|
||||
KXK, // Generic "mate lone king" eval
|
||||
KBNK, // KBN vs K
|
||||
KPK, // KP vs K
|
||||
KRKP, // KR vs KP
|
||||
KRKB, // KR vs KB
|
||||
KRKN, // KR vs KN
|
||||
KQKR, // KQ vs KR
|
||||
KBBKN, // KBB vs KN
|
||||
KNNK, // KNN vs K
|
||||
KmmKm, // K and two minors vs K and one or two minors
|
||||
// Evaluation functions
|
||||
KXK, // Generic "mate lone king" eval
|
||||
KBNK, // KBN vs K
|
||||
KPK, // KP vs K
|
||||
KRKP, // KR vs KP
|
||||
KRKB, // KR vs KB
|
||||
KRKN, // KR vs KN
|
||||
KQKR, // KQ vs KR
|
||||
KBBKN, // KBB vs KN
|
||||
KNNK, // KNN vs K
|
||||
KmmKm, // K and two minors vs K and one or two minors
|
||||
|
||||
// Scaling functions
|
||||
KBPsK, // KB+pawns vs K
|
||||
KQKRPs, // KQ vs KR+pawns
|
||||
KRPKR, // KRP vs KR
|
||||
KRPPKRP, // KRPP vs KRP
|
||||
KPsK, // King and pawns vs king
|
||||
KBPKB, // KBP vs KB
|
||||
KBPPKB, // KBPP vs KB
|
||||
KBPKN, // KBP vs KN
|
||||
KNPK, // KNP vs K
|
||||
KPKP // KP vs KP
|
||||
// Scaling functions
|
||||
KBPsK, // KB+pawns vs K
|
||||
KQKRPs, // KQ vs KR+pawns
|
||||
KRPKR, // KRP vs KR
|
||||
KRPPKRP, // KRPP vs KRP
|
||||
KPsK, // King and pawns vs king
|
||||
KBPKB, // KBP vs KB
|
||||
KBPPKB, // KBPP vs KB
|
||||
KBPKN, // KBP vs KN
|
||||
KNPK, // KNP vs K
|
||||
KPKP // KP vs KP
|
||||
};
|
||||
|
||||
/// Template abstract base class for all special endgame functions
|
||||
|
||||
/// Base and derived template class for endgame evaluation and scaling functions
|
||||
|
||||
template<typename T>
|
||||
class EndgameFunctionBase {
|
||||
public:
|
||||
EndgameFunctionBase(Color c) : strongerSide(c), weakerSide(opposite_color(c)) {}
|
||||
virtual ~EndgameFunctionBase() {}
|
||||
struct EndgameBase {
|
||||
|
||||
typedef EndgameBase<T> Base;
|
||||
|
||||
EndgameBase(Color c) : strongerSide(c), weakerSide(opposite_color(c)) {}
|
||||
virtual ~EndgameBase() {}
|
||||
virtual T apply(const Position&) const = 0;
|
||||
Color color() const { return strongerSide; }
|
||||
|
||||
|
|
@ -64,24 +73,37 @@ protected:
|
|||
Color strongerSide, weakerSide;
|
||||
};
|
||||
|
||||
typedef EndgameFunctionBase<Value> EndgameEvaluationFunctionBase;
|
||||
typedef EndgameFunctionBase<ScaleFactor> EndgameScalingFunctionBase;
|
||||
|
||||
template<typename T, EndgameType>
|
||||
struct Endgame : public EndgameBase<T> {
|
||||
|
||||
/// Templates subclass for various concrete endgames
|
||||
|
||||
template<EndgameType>
|
||||
struct EvaluationFunction : public EndgameEvaluationFunctionBase {
|
||||
typedef EndgameEvaluationFunctionBase Base;
|
||||
explicit EvaluationFunction(Color c): EndgameEvaluationFunctionBase(c) {}
|
||||
Value apply(const Position&) const;
|
||||
explicit Endgame(Color c): EndgameBase<T>(c) {}
|
||||
T apply(const Position&) const;
|
||||
};
|
||||
|
||||
template<EndgameType>
|
||||
struct ScalingFunction : public EndgameScalingFunctionBase {
|
||||
typedef EndgameScalingFunctionBase Base;
|
||||
explicit ScalingFunction(Color c) : EndgameScalingFunctionBase(c) {}
|
||||
ScaleFactor apply(const Position&) const;
|
||||
|
||||
/// Endgames class stores in two std::map the pointers to endgame evaluation
|
||||
/// and scaling base objects. Then we use polymorphism to invoke the actual
|
||||
/// endgame function calling its apply() method that is virtual.
|
||||
|
||||
class Endgames {
|
||||
|
||||
typedef std::map<Key, EndgameBase<Value>*> EFMap;
|
||||
typedef std::map<Key, EndgameBase<ScaleFactor>*> SFMap;
|
||||
|
||||
public:
|
||||
Endgames();
|
||||
~Endgames();
|
||||
template<class T> T* get(Key key) const;
|
||||
|
||||
private:
|
||||
template<class T> void add(const std::string& keyCode);
|
||||
|
||||
// Here we store two maps, for evaluate and scaling functions...
|
||||
std::pair<EFMap, SFMap> maps;
|
||||
|
||||
// ...and here is the accessing template function
|
||||
template<typename T> const std::map<Key, T*>& get() const;
|
||||
};
|
||||
|
||||
#endif // !defined(ENDGAME_H_INCLUDED)
|
||||
|
|
|
|||
159
src/material.cpp
159
src/material.cpp
|
|
@ -19,7 +19,6 @@
|
|||
|
||||
#include <cassert>
|
||||
#include <cstring>
|
||||
#include <map>
|
||||
|
||||
#include "material.h"
|
||||
|
||||
|
|
@ -48,19 +47,15 @@ namespace {
|
|||
{ 41, 41, 41, 41, 41, 41 }, { 37, 41, 41, 41, 41, 41 }, { 10, 62, 41, 41, 41, 41 },
|
||||
{ 57, 64, 39, 41, 41, 41 }, { 50, 40, 23, -22, 41, 41 }, { 106, 101, 3, 151, 171, 41 } };
|
||||
|
||||
typedef EndgameEvaluationFunctionBase EF;
|
||||
typedef EndgameScalingFunctionBase SF;
|
||||
typedef map<Key, EF*> EFMap;
|
||||
typedef map<Key, SF*> SFMap;
|
||||
|
||||
// Endgame evaluation and scaling functions accessed direcly and not through
|
||||
// the function maps because correspond to more then one material hash key.
|
||||
EvaluationFunction<KmmKm> EvaluateKmmKm[] = { EvaluationFunction<KmmKm>(WHITE), EvaluationFunction<KmmKm>(BLACK) };
|
||||
EvaluationFunction<KXK> EvaluateKXK[] = { EvaluationFunction<KXK>(WHITE), EvaluationFunction<KXK>(BLACK) };
|
||||
ScalingFunction<KBPsK> ScaleKBPsK[] = { ScalingFunction<KBPsK>(WHITE), ScalingFunction<KBPsK>(BLACK) };
|
||||
ScalingFunction<KQKRPs> ScaleKQKRPs[] = { ScalingFunction<KQKRPs>(WHITE), ScalingFunction<KQKRPs>(BLACK) };
|
||||
ScalingFunction<KPsK> ScaleKPsK[] = { ScalingFunction<KPsK>(WHITE), ScalingFunction<KPsK>(BLACK) };
|
||||
ScalingFunction<KPKP> ScaleKPKP[] = { ScalingFunction<KPKP>(WHITE), ScalingFunction<KPKP>(BLACK) };
|
||||
Endgame<Value, KmmKm> EvaluateKmmKm[] = { Endgame<Value, KmmKm>(WHITE), Endgame<Value, KmmKm>(BLACK) };
|
||||
Endgame<Value, KXK> EvaluateKXK[] = { Endgame<Value, KXK>(WHITE), Endgame<Value, KXK>(BLACK) };
|
||||
|
||||
Endgame<ScaleFactor, KBPsK> ScaleKBPsK[] = { Endgame<ScaleFactor, KBPsK>(WHITE), Endgame<ScaleFactor, KBPsK>(BLACK) };
|
||||
Endgame<ScaleFactor, KQKRPs> ScaleKQKRPs[] = { Endgame<ScaleFactor, KQKRPs>(WHITE), Endgame<ScaleFactor, KQKRPs>(BLACK) };
|
||||
Endgame<ScaleFactor, KPsK> ScaleKPsK[] = { Endgame<ScaleFactor, KPsK>(WHITE), Endgame<ScaleFactor, KPsK>(BLACK) };
|
||||
Endgame<ScaleFactor, KPKP> ScaleKPKP[] = { Endgame<ScaleFactor, KPKP>(WHITE), Endgame<ScaleFactor, KPKP>(BLACK) };
|
||||
|
||||
// Helper templates used to detect a given material distribution
|
||||
template<Color Us> bool is_KXK(const Position& pos) {
|
||||
|
|
@ -84,42 +79,13 @@ namespace {
|
|||
&& pos.piece_count(Them, ROOK) == 1
|
||||
&& pos.piece_count(Them, PAWN) >= 1;
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
|
||||
/// EndgameFunctions class stores endgame evaluation and scaling functions
|
||||
/// in two std::map. Because STL library is not guaranteed to be thread
|
||||
/// safe even for read access, the maps, although with identical content,
|
||||
/// are replicated for each thread. This is faster then using locks.
|
||||
/// MaterialInfoTable c'tor and d'tor allocate and free the space for Endgames
|
||||
|
||||
class EndgameFunctions {
|
||||
public:
|
||||
EndgameFunctions();
|
||||
~EndgameFunctions();
|
||||
template<class T> T* get(Key key) const;
|
||||
|
||||
private:
|
||||
template<class T> void add(const string& keyCode);
|
||||
|
||||
static Key buildKey(const string& keyCode);
|
||||
static const string swapColors(const string& keyCode);
|
||||
|
||||
// Here we store two maps, for evaluate and scaling functions...
|
||||
pair<EFMap, SFMap> maps;
|
||||
|
||||
// ...and here is the accessing template function
|
||||
template<typename T> const map<Key, T*>& get() const;
|
||||
};
|
||||
|
||||
// Explicit specializations of a member function shall be declared in
|
||||
// the namespace of which the class template is a member.
|
||||
template<> const EFMap& EndgameFunctions::get<EF>() const { return maps.first; }
|
||||
template<> const SFMap& EndgameFunctions::get<SF>() const { return maps.second; }
|
||||
|
||||
|
||||
/// MaterialInfoTable c'tor and d'tor allocate and free the space for EndgameFunctions
|
||||
|
||||
MaterialInfoTable::MaterialInfoTable() { funcs = new EndgameFunctions(); }
|
||||
MaterialInfoTable::MaterialInfoTable() { funcs = new Endgames(); }
|
||||
MaterialInfoTable::~MaterialInfoTable() { delete funcs; }
|
||||
|
||||
|
||||
|
|
@ -151,7 +117,7 @@ MaterialInfo* MaterialInfoTable::get_material_info(const Position& pos) const {
|
|||
// Let's look if we have a specialized evaluation function for this
|
||||
// particular material configuration. First we look for a fixed
|
||||
// configuration one, then a generic one if previous search failed.
|
||||
if ((mi->evaluationFunction = funcs->get<EF>(key)) != NULL)
|
||||
if ((mi->evaluationFunction = funcs->get<EndgameBase<Value> >(key)) != NULL)
|
||||
return mi;
|
||||
|
||||
if (is_KXK<WHITE>(pos))
|
||||
|
|
@ -186,9 +152,9 @@ MaterialInfo* MaterialInfoTable::get_material_info(const Position& pos) const {
|
|||
//
|
||||
// We face problems when there are several conflicting applicable
|
||||
// scaling functions and we need to decide which one to use.
|
||||
SF* sf;
|
||||
EndgameBase<ScaleFactor>* sf;
|
||||
|
||||
if ((sf = funcs->get<SF>(key)) != NULL)
|
||||
if ((sf = funcs->get<EndgameBase<ScaleFactor> >(key)) != NULL)
|
||||
{
|
||||
mi->scalingFunction[sf->color()] = sf;
|
||||
return mi;
|
||||
|
|
@ -277,7 +243,7 @@ int MaterialInfoTable::imbalance(const int pieceCount[][8]) {
|
|||
|
||||
const Color Them = (Us == WHITE ? BLACK : WHITE);
|
||||
|
||||
int pt1, pt2, pc, vv;
|
||||
int pt1, pt2, pc, v;
|
||||
int value = 0;
|
||||
|
||||
// Redundancy of major pieces, formula based on Kaufman's paper
|
||||
|
|
@ -293,13 +259,13 @@ int MaterialInfoTable::imbalance(const int pieceCount[][8]) {
|
|||
if (!pc)
|
||||
continue;
|
||||
|
||||
vv = LinearCoefficients[pt1];
|
||||
v = LinearCoefficients[pt1];
|
||||
|
||||
for (pt2 = PIECE_TYPE_NONE; pt2 <= pt1; pt2++)
|
||||
vv += QuadraticCoefficientsSameColor[pt1][pt2] * pieceCount[Us][pt2]
|
||||
+ QuadraticCoefficientsOppositeColor[pt1][pt2] * pieceCount[Them][pt2];
|
||||
v += QuadraticCoefficientsSameColor[pt1][pt2] * pieceCount[Us][pt2]
|
||||
+ QuadraticCoefficientsOppositeColor[pt1][pt2] * pieceCount[Them][pt2];
|
||||
|
||||
value += pc * vv;
|
||||
value += pc * v;
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
|
@ -313,88 +279,7 @@ Phase MaterialInfoTable::game_phase(const Position& pos) {
|
|||
|
||||
Value npm = pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK);
|
||||
|
||||
if (npm >= MidgameLimit)
|
||||
return PHASE_MIDGAME;
|
||||
|
||||
if (npm <= EndgameLimit)
|
||||
return PHASE_ENDGAME;
|
||||
|
||||
return Phase(((npm - EndgameLimit) * 128) / (MidgameLimit - EndgameLimit));
|
||||
}
|
||||
|
||||
|
||||
/// EndgameFunctions member definitions
|
||||
|
||||
EndgameFunctions::EndgameFunctions() {
|
||||
|
||||
add<EvaluationFunction<KNNK> >("KNNK");
|
||||
add<EvaluationFunction<KPK> >("KPK");
|
||||
add<EvaluationFunction<KBNK> >("KBNK");
|
||||
add<EvaluationFunction<KRKP> >("KRKP");
|
||||
add<EvaluationFunction<KRKB> >("KRKB");
|
||||
add<EvaluationFunction<KRKN> >("KRKN");
|
||||
add<EvaluationFunction<KQKR> >("KQKR");
|
||||
add<EvaluationFunction<KBBKN> >("KBBKN");
|
||||
|
||||
add<ScalingFunction<KNPK> >("KNPK");
|
||||
add<ScalingFunction<KRPKR> >("KRPKR");
|
||||
add<ScalingFunction<KBPKB> >("KBPKB");
|
||||
add<ScalingFunction<KBPPKB> >("KBPPKB");
|
||||
add<ScalingFunction<KBPKN> >("KBPKN");
|
||||
add<ScalingFunction<KRPPKRP> >("KRPPKRP");
|
||||
}
|
||||
|
||||
EndgameFunctions::~EndgameFunctions() {
|
||||
|
||||
for (EFMap::const_iterator it = maps.first.begin(); it != maps.first.end(); ++it)
|
||||
delete it->second;
|
||||
|
||||
for (SFMap::const_iterator it = maps.second.begin(); it != maps.second.end(); ++it)
|
||||
delete it->second;
|
||||
}
|
||||
|
||||
Key EndgameFunctions::buildKey(const string& keyCode) {
|
||||
|
||||
assert(keyCode.length() > 0 && keyCode.length() < 8);
|
||||
assert(keyCode[0] == 'K');
|
||||
|
||||
string fen;
|
||||
bool upcase = false;
|
||||
|
||||
// Build up a fen string with the given pieces, note that
|
||||
// the fen string could be of an illegal position.
|
||||
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();
|
||||
}
|
||||
|
||||
const string EndgameFunctions::swapColors(const string& keyCode) {
|
||||
|
||||
// Build corresponding key for the opposite color: "KBPKN" -> "KNKBP"
|
||||
size_t idx = keyCode.find('K', 1);
|
||||
return keyCode.substr(idx) + keyCode.substr(0, idx);
|
||||
}
|
||||
|
||||
template<class T>
|
||||
void EndgameFunctions::add(const string& keyCode) {
|
||||
|
||||
typedef typename T::Base F;
|
||||
typedef map<Key, F*> M;
|
||||
|
||||
const_cast<M&>(get<F>()).insert(pair<Key, F*>(buildKey(keyCode), new T(WHITE)));
|
||||
const_cast<M&>(get<F>()).insert(pair<Key, F*>(buildKey(swapColors(keyCode)), new T(BLACK)));
|
||||
}
|
||||
|
||||
template<class T>
|
||||
T* EndgameFunctions::get(Key key) const {
|
||||
|
||||
typename map<Key, T*>::const_iterator it = get<T>().find(key);
|
||||
return it != get<T>().end() ? it->second : NULL;
|
||||
return npm >= MidgameLimit ? PHASE_MIDGAME
|
||||
: npm <= EndgameLimit ? PHASE_ENDGAME
|
||||
: Phase(((npm - EndgameLimit) * 128) / (MidgameLimit - EndgameLimit));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -53,8 +53,8 @@ private:
|
|||
Key key;
|
||||
int16_t value;
|
||||
uint8_t factor[2];
|
||||
EndgameEvaluationFunctionBase* evaluationFunction;
|
||||
EndgameScalingFunctionBase* scalingFunction[2];
|
||||
EndgameBase<Value>* evaluationFunction;
|
||||
EndgameBase<ScaleFactor>* scalingFunction[2];
|
||||
int spaceWeight;
|
||||
Phase gamePhase;
|
||||
};
|
||||
|
|
@ -62,7 +62,6 @@ private:
|
|||
|
||||
/// The MaterialInfoTable class represents a pawn hash table. The most important
|
||||
/// method is get_material_info, which returns a pointer to a MaterialInfo object.
|
||||
class EndgameFunctions;
|
||||
|
||||
class MaterialInfoTable : public SimpleHash<MaterialInfo, MaterialTableSize> {
|
||||
public:
|
||||
|
|
@ -75,7 +74,7 @@ private:
|
|||
template<Color Us>
|
||||
static int imbalance(const int pieceCount[][8]);
|
||||
|
||||
EndgameFunctions* funcs;
|
||||
Endgames* funcs;
|
||||
};
|
||||
|
||||
|
||||
|
|
@ -95,6 +94,10 @@ inline ScaleFactor MaterialInfo::scale_factor(const Position& pos, Color c) cons
|
|||
return sf == SCALE_FACTOR_NONE ? ScaleFactor(factor[c]) : sf;
|
||||
}
|
||||
|
||||
inline Value MaterialInfo::evaluate(const Position& pos) const {
|
||||
return evaluationFunction->apply(pos);
|
||||
}
|
||||
|
||||
inline Score MaterialInfo::material_value() const {
|
||||
return make_score(value, value);
|
||||
}
|
||||
|
|
@ -111,8 +114,4 @@ inline bool MaterialInfo::specialized_eval_exists() const {
|
|||
return evaluationFunction != NULL;
|
||||
}
|
||||
|
||||
inline Value MaterialInfo::evaluate(const Position& pos) const {
|
||||
return evaluationFunction->apply(pos);
|
||||
}
|
||||
|
||||
#endif // !defined(MATERIAL_H_INCLUDED)
|
||||
|
|
|
|||
|
|
@ -104,9 +104,6 @@ struct StateInfo {
|
|||
|
||||
class Position {
|
||||
|
||||
friend class MaterialInfo;
|
||||
friend class EndgameFunctions;
|
||||
|
||||
Position(); // No default or copy c'tor allowed
|
||||
Position(const Position& pos);
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue