kate/BadFish
1
0
Fork 0
mirror of https://github.com/sockspls/badfish synced 2025-04-30 00:33:09 +00:00
Code Issues Releases Wiki Activity

Use template for endgame scaling functions

Browse source 
Also integrate scaling and evaluation in a
single base class.

Nice use of templates here :-)

No functional change.

Signed-off-by: Marco Costalba <mcostalba@gmail.com>
This commit is contained in:
Marco Costalba 2009-02-12 14:59:46 +01:00
parent 039badfda8
commit 67375f4693
4 changed files with 84 additions and 207 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

101
src/endgame.cpp
View file

@ -51,41 +51,15 @@ EvaluationFunction<KBBKN> EvaluateKBBKN(WHITE), EvaluateKNKBB(BLACK); // KBB vs
/// Scaling functions /// Scaling functions
// KBP vs K ScalingFunction<KBPK> ScaleKBPK(WHITE), ScaleKKBP(BLACK); // KBP vs K
KBPKScalingFunction ScaleKBPK = KBPKScalingFunction(WHITE); ScalingFunction<KQKRP> ScaleKQKRP(WHITE), ScaleKRPKQ(BLACK); // KQ vs KRP
KBPKScalingFunction ScaleKKBP = KBPKScalingFunction(BLACK); ScalingFunction<KRPKR> ScaleKRPKR(WHITE), ScaleKRKRP(BLACK); // KRP vs KR
ScalingFunction<KRPPKRP> ScaleKRPPKRP(WHITE), ScaleKRPKRPP(BLACK); // KRPP vs KRP
// KQ vs KRP ScalingFunction<KPsK> ScaleKPsK(WHITE), ScaleKKPs(BLACK); // King and pawns vs king
KQKRPScalingFunction ScaleKQKRP = KQKRPScalingFunction(WHITE); ScalingFunction<KBPKB> ScaleKBPKB(WHITE), ScaleKBKBP(BLACK); // KBP vs KB
KQKRPScalingFunction ScaleKRPKQ = KQKRPScalingFunction(BLACK); ScalingFunction<KBPKN> ScaleKBPKN(WHITE), ScaleKNKBP(BLACK); // KBP vs KN
ScalingFunction<KNPK> ScaleKNPK(WHITE), ScaleKKNP(BLACK); // KNP vs K
// KRP vs KR ScalingFunction<KPKP> ScaleKPKPw(WHITE), ScaleKPKPb(BLACK); // KPKP
KRPKRScalingFunction ScaleKRPKR = KRPKRScalingFunction(WHITE);
KRPKRScalingFunction ScaleKRKRP = KRPKRScalingFunction(BLACK);
// KRPP vs KRP
KRPPKRPScalingFunction ScaleKRPPKRP = KRPPKRPScalingFunction(WHITE);
KRPPKRPScalingFunction ScaleKRPKRPP = KRPPKRPScalingFunction(BLACK);
// King and pawns vs king
KPsKScalingFunction ScaleKPsK = KPsKScalingFunction(WHITE);
KPsKScalingFunction ScaleKKPs = KPsKScalingFunction(BLACK);
// KBP vs KB
KBPKBScalingFunction ScaleKBPKB = KBPKBScalingFunction(WHITE);
KBPKBScalingFunction ScaleKBKBP = KBPKBScalingFunction(BLACK);
// KBP vs KN
KBPKNScalingFunction ScaleKBPKN = KBPKNScalingFunction(WHITE);
KBPKNScalingFunction ScaleKNKBP = KBPKNScalingFunction(BLACK);
// KNP vs K
KNPKScalingFunction ScaleKNPK = KNPKScalingFunction(WHITE);
KNPKScalingFunction ScaleKKNP = KNPKScalingFunction(BLACK);
// KPKP
KPKPScalingFunction ScaleKPKPw = KPKPScalingFunction(WHITE);
KPKPScalingFunction ScaleKPKPb = KPKPScalingFunction(BLACK);
//// ////
@ -158,27 +132,6 @@ namespace {
//// Functions //// Functions
//// ////
/// Constructors
EndgameEvaluationFunction::EndgameEvaluationFunction(Color c) : strongerSide(c) {
weakerSide = opposite_color(strongerSide);
}
ScalingFunction::ScalingFunction(Color c) : strongerSide(c) {
weakerSide = opposite_color(c);
}
KBPKScalingFunction::KBPKScalingFunction(Color c) : ScalingFunction(c) {}
KQKRPScalingFunction::KQKRPScalingFunction(Color c) : ScalingFunction(c) {}
KRPKRScalingFunction::KRPKRScalingFunction(Color c) : ScalingFunction(c) {}
KRPPKRPScalingFunction::KRPPKRPScalingFunction(Color c) : ScalingFunction(c) {}
KPsKScalingFunction::KPsKScalingFunction(Color c) : ScalingFunction(c) {}
KBPKBScalingFunction::KBPKBScalingFunction(Color c) : ScalingFunction(c) {}
KBPKNScalingFunction::KBPKNScalingFunction(Color c) : ScalingFunction(c) {}
KNPKScalingFunction::KNPKScalingFunction(Color c) : ScalingFunction(c) {}
KPKPScalingFunction::KPKPScalingFunction(Color c) : ScalingFunction(c) {}
/// Mate with KX vs K. This function is used to evaluate positions with /// 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 /// 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 /// attacking side a bonus for driving the defending king towards the edge
@ -439,8 +392,8 @@ Value EvaluationFunction<KmmKm>::apply(const Position &pos) {
/// bishop of the wrong color. If such a draw is detected, ScaleFactor(0) is /// bishop of the wrong color. If such a draw is detected, ScaleFactor(0) is
/// returned. If not, the return value is SCALE_FACTOR_NONE, i.e. no scaling /// returned. If not, the return value is SCALE_FACTOR_NONE, i.e. no scaling
/// will be used. /// will be used.
template<>
ScaleFactor KBPKScalingFunction::apply(const Position& pos) { ScaleFactor ScalingFunction<KBPK>::apply(const Position& pos) {
assert(pos.non_pawn_material(strongerSide) == BishopValueMidgame); assert(pos.non_pawn_material(strongerSide) == BishopValueMidgame);
assert(pos.piece_count(strongerSide, BISHOP) == 1); assert(pos.piece_count(strongerSide, BISHOP) == 1);
@ -494,8 +447,8 @@ ScaleFactor KBPKScalingFunction::apply(const Position& pos) {
/// king and queen, while the weaker side has at least a rook and a pawn. /// king and queen, while the weaker side has at least a rook and a pawn.
/// It tests for fortress draws with a rook on the third rank defended by /// It tests for fortress draws with a rook on the third rank defended by
/// a pawn. /// a pawn.
template<>
ScaleFactor KQKRPScalingFunction::apply(const Position& pos) { ScaleFactor ScalingFunction<KQKRP>::apply(const Position& pos) {
assert(pos.non_pawn_material(strongerSide) == QueenValueMidgame); assert(pos.non_pawn_material(strongerSide) == QueenValueMidgame);
assert(pos.piece_count(strongerSide, QUEEN) == 1); assert(pos.piece_count(strongerSide, QUEEN) == 1);
@ -525,8 +478,8 @@ ScaleFactor KQKRPScalingFunction::apply(const Position& pos) {
/// ///
/// It would also be nice to rewrite the actual code for this function, /// 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. /// which is mostly copied from Glaurung 1.x, and not very pretty.
template<>
ScaleFactor KRPKRScalingFunction::apply(const Position &pos) { ScaleFactor ScalingFunction<KRPKR>::apply(const Position &pos) {
assert(pos.non_pawn_material(strongerSide) == RookValueMidgame); assert(pos.non_pawn_material(strongerSide) == RookValueMidgame);
assert(pos.piece_count(strongerSide, PAWN) == 1); assert(pos.piece_count(strongerSide, PAWN) == 1);
@ -643,8 +596,8 @@ ScaleFactor KRPKRScalingFunction::apply(const Position &pos) {
/// KRPPKRPScalingFunction scales KRPP vs KRP endgames. There is only a /// KRPPKRPScalingFunction scales KRPP vs KRP endgames. There is only a
/// single pattern: If the stronger side has no pawns and the defending king /// single pattern: If the stronger side has no pawns and the defending king
/// is actively placed, the position is drawish. /// is actively placed, the position is drawish.
template<>
ScaleFactor KRPPKRPScalingFunction::apply(const Position &pos) { ScaleFactor ScalingFunction<KRPPKRP>::apply(const Position &pos) {
assert(pos.non_pawn_material(strongerSide) == RookValueMidgame); assert(pos.non_pawn_material(strongerSide) == RookValueMidgame);
assert(pos.piece_count(strongerSide, PAWN) == 2); assert(pos.piece_count(strongerSide, PAWN) == 2);
@ -682,8 +635,8 @@ ScaleFactor KRPPKRPScalingFunction::apply(const Position &pos) {
/// KPsKScalingFunction scales endgames with king and two or more pawns /// KPsKScalingFunction scales endgames with king and two or more pawns
/// against king. There is just a single rule here: If all pawns are on /// 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. /// the same rook file and are blocked by the defending king, it's a draw.
template<>
ScaleFactor KPsKScalingFunction::apply(const Position &pos) { ScaleFactor ScalingFunction<KPsK>::apply(const Position &pos) {
assert(pos.non_pawn_material(strongerSide) == Value(0)); assert(pos.non_pawn_material(strongerSide) == Value(0));
assert(pos.piece_count(strongerSide, PAWN) >= 2); assert(pos.piece_count(strongerSide, PAWN) >= 2);
@ -728,8 +681,8 @@ ScaleFactor KPsKScalingFunction::apply(const Position &pos) {
/// square of the king is not of the same color as the stronger side's bishop, /// square of the king is not of the same color as the stronger side's bishop,
/// it's a draw. If the two bishops have opposite color, it's almost always /// it's a draw. If the two bishops have opposite color, it's almost always
/// a draw. /// a draw.
template<>
ScaleFactor KBPKBScalingFunction::apply(const Position &pos) { ScaleFactor ScalingFunction<KBPKB>::apply(const Position &pos) {
assert(pos.non_pawn_material(strongerSide) == BishopValueMidgame); assert(pos.non_pawn_material(strongerSide) == BishopValueMidgame);
assert(pos.piece_count(strongerSide, BISHOP) == 1); assert(pos.piece_count(strongerSide, BISHOP) == 1);
@ -783,8 +736,8 @@ ScaleFactor KBPKBScalingFunction::apply(const Position &pos) {
/// If the defending king is somewhere along the path of the pawn, and the /// If the defending king is somewhere along the path of the pawn, and the
/// square of the king is not of the same color as the stronger side's bishop, /// square of the king is not of the same color as the stronger side's bishop,
/// it's a draw. /// it's a draw.
template<>
ScaleFactor KBPKNScalingFunction::apply(const Position &pos) { ScaleFactor ScalingFunction<KBPKN>::apply(const Position &pos) {
assert(pos.non_pawn_material(strongerSide) == BishopValueMidgame); assert(pos.non_pawn_material(strongerSide) == BishopValueMidgame);
assert(pos.piece_count(strongerSide, BISHOP) == 1); assert(pos.piece_count(strongerSide, BISHOP) == 1);
@ -810,8 +763,8 @@ ScaleFactor KBPKNScalingFunction::apply(const Position &pos) {
/// KNPKScalingFunction scales KNP vs K endgames. There is a single rule: /// KNPKScalingFunction scales KNP vs K endgames. There is a single rule:
/// If the pawn is a rook pawn on the 7th rank and the defending king prevents /// If the pawn is a rook pawn on the 7th rank and the defending king prevents
/// the pawn from advancing, the position is drawn. /// the pawn from advancing, the position is drawn.
template<>
ScaleFactor KNPKScalingFunction::apply(const Position &pos) { ScaleFactor ScalingFunction<KNPK>::apply(const Position &pos) {
assert(pos.non_pawn_material(strongerSide) == KnightValueMidgame); assert(pos.non_pawn_material(strongerSide) == KnightValueMidgame);
assert(pos.piece_count(strongerSide, KNIGHT) == 1); assert(pos.piece_count(strongerSide, KNIGHT) == 1);
@ -840,8 +793,8 @@ ScaleFactor KNPKScalingFunction::apply(const Position &pos) {
/// the pawn as well. The exception is when the stronger side's pawn is far /// the pawn as well. The exception is when the stronger side's pawn is far
/// advanced and not on a rook file; in this case it is often possible to win /// 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). /// (e.g. 8/4k3/3p4/3P4/6K1/8/8/8 w - - 0 1).
template<>
ScaleFactor KPKPScalingFunction::apply(const Position &pos) { ScaleFactor ScalingFunction<KPKP>::apply(const Position &pos) {
assert(pos.non_pawn_material(strongerSide) == Value(0)); assert(pos.non_pawn_material(strongerSide) == Value(0));
assert(pos.non_pawn_material(weakerSide) == Value(0)); assert(pos.non_pawn_material(weakerSide) == Value(0));

160
src/endgame.h
View file

@ -34,23 +34,9 @@
//// Types //// Types
//// ////
/// Abstract base class for all special endgame evaluation functions
class EndgameEvaluationFunction {
public:
EndgameEvaluationFunction(Color c);
virtual ~EndgameEvaluationFunction() { }
virtual Value apply(const Position &pos) = 0;
protected:
Color strongerSide, weakerSide;
};
/// Template subclass for various concrete endgames
enum EndgameType { enum EndgameType {
// Evaluation functions
KXK, // Generic "mate lone king" eval KXK, // Generic "mate lone king" eval
KBNK, // KBN vs K KBNK, // KBN vs K
KPK, // KP vs K KPK, // KP vs K
@ -59,93 +45,49 @@ enum EndgameType {
KRKN, // KR vs KN KRKN, // KR vs KN
KQKR, // KQ vs KR KQKR, // KQ vs KR
KBBKN, // KBB vs KN KBBKN, // KBB vs KN
KmmKm // K and two minors vs K and one or two minors KmmKm, // K and two minors vs K and one or two minors
// Scaling functions
KBPK, // KBP vs K
KQKRP, // KQ vs KRP
KRPKR, // KRP vs KR
KRPPKRP, // KRPP vs KRP
KPsK, // King and pawns vs king
KBPKB, // KBP vs KB
KBPKN, // KBP vs KN
KNPK, // KNP vs K
KPKP // KP vs KP
}; };
template<EndgameType> /// Template abstract base class for all special endgame functions
class EvaluationFunction : public EndgameEvaluationFunction {
template<typename T>
class EndgameFunctionBase {
public: public:
explicit EvaluationFunction(Color c): EndgameEvaluationFunction(c) {} EndgameFunctionBase(Color c) : strongerSide(c) { weakerSide = opposite_color(strongerSide); }
Value apply(const Position& pos); virtual ~EndgameFunctionBase() {}
}; virtual T apply(const Position&) = 0;
/// Abstract base class for all evaluation scaling functions:
class ScalingFunction {
public:
ScalingFunction(Color c);
virtual ~ScalingFunction() { }
virtual ScaleFactor apply(const Position &pos) =0;
protected: protected:
Color strongerSide, weakerSide; Color strongerSide, weakerSide;
}; };
typedef EndgameFunctionBase<Value> EndgameEvaluationFunctionBase;
typedef EndgameFunctionBase<ScaleFactor> EndgameScalingFunctionBase;
/// Subclasses for various concrete endgames:
// KBP vs K: /// Templates subclass for various concrete endgames
class KBPKScalingFunction : public ScalingFunction {
public: template<EndgameType>
KBPKScalingFunction(Color c); struct EvaluationFunction : public EndgameEvaluationFunctionBase {
ScaleFactor apply(const Position &pos); explicit EvaluationFunction(Color c): EndgameEvaluationFunctionBase(c) {}
Value apply(const Position&);
}; };
// KQ vs KRP: template<EndgameType>
class KQKRPScalingFunction: public ScalingFunction { struct ScalingFunction : public EndgameScalingFunctionBase {
public: explicit ScalingFunction(Color c) : EndgameScalingFunctionBase(c) {}
KQKRPScalingFunction(Color c); ScaleFactor apply(const Position&);
ScaleFactor apply(const Position &pos);
};
// KRP vs KR:
class KRPKRScalingFunction : public ScalingFunction {
public:
KRPKRScalingFunction(Color c);
ScaleFactor apply(const Position &pos);
};
// KRPP vs KRP:
class KRPPKRPScalingFunction : public ScalingFunction {
public:
KRPPKRPScalingFunction(Color c);
ScaleFactor apply(const Position &pos);
};
// King and pawns vs king:
class KPsKScalingFunction : public ScalingFunction {
public:
KPsKScalingFunction(Color c);
ScaleFactor apply(const Position &pos);
};
// KBP vs KB:
class KBPKBScalingFunction : public ScalingFunction {
public:
KBPKBScalingFunction(Color c);
ScaleFactor apply(const Position &pos);
};
// KBP vs KN:
class KBPKNScalingFunction : public ScalingFunction {
public:
KBPKNScalingFunction(Color c);
ScaleFactor apply(const Position &pos);
};
// KNP vs K:
class KNPKScalingFunction : public ScalingFunction {
public:
KNPKScalingFunction(Color c);
ScaleFactor apply(const Position &pos);
};
// KP vs KP:
class KPKPScalingFunction : public ScalingFunction {
public:
KPKPScalingFunction(Color c);
ScaleFactor apply(const Position &pos);
}; };
@ -163,33 +105,15 @@ extern EvaluationFunction<KQKR> EvaluateKQKR, EvaluateKRKQ; // KQ vs KR
extern EvaluationFunction<KBBKN> EvaluateKBBKN, EvaluateKNKBB; // KBB vs KN extern EvaluationFunction<KBBKN> EvaluateKBBKN, EvaluateKNKBB; // KBB vs KN
extern EvaluationFunction<KmmKm> EvaluateKmmKm; // K and two minors vs K and one or two minors: extern EvaluationFunction<KmmKm> EvaluateKmmKm; // K and two minors vs K and one or two minors:
// KBP vs K: extern ScalingFunction<KBPK> ScaleKBPK, ScaleKKBP; // KBP vs K
extern KBPKScalingFunction ScaleKBPK, ScaleKKBP; extern ScalingFunction<KQKRP> ScaleKQKRP, ScaleKRPKQ; // KQ vs KRP
extern ScalingFunction<KRPKR> ScaleKRPKR, ScaleKRKRP; // KRP vs KR
// KQ vs KRP: extern ScalingFunction<KRPPKRP> ScaleKRPPKRP, ScaleKRPKRPP; // KRPP vs KRP
extern KQKRPScalingFunction ScaleKQKRP, ScaleKRPKQ; extern ScalingFunction<KPsK> ScaleKPsK, ScaleKKPs; // King and pawns vs king
extern ScalingFunction<KBPKB> ScaleKBPKB, ScaleKBKBP; // KBP vs KB
// KRP vs KR: extern ScalingFunction<KBPKN> ScaleKBPKN, ScaleKNKBP; // KBP vs KN
extern KRPKRScalingFunction ScaleKRPKR, ScaleKRKRP; extern ScalingFunction<KNPK> ScaleKNPK, ScaleKKNP; // KNP vs K
extern ScalingFunction<KPKP> ScaleKPKPw, ScaleKPKPb; // KP vs KP
// KRPP vs KRP:
extern KRPPKRPScalingFunction ScaleKRPPKRP, ScaleKRPKRPP;
// King and pawns vs king:
extern KPsKScalingFunction ScaleKPsK, ScaleKKPs;
// KBP vs KB:
extern KBPKBScalingFunction ScaleKBPKB, ScaleKBKBP;
// KBP vs KN:
extern KBPKNScalingFunction ScaleKBPKN, ScaleKNKBP;
// KNP vs K:
extern KNPKScalingFunction ScaleKNPK, ScaleKKNP;
// KP vs KP:
extern KPKPScalingFunction ScaleKPKPw, ScaleKPKPb;
//// ////
//// Prototypes //// Prototypes

26
src/material.cpp
View file

@ -54,20 +54,20 @@ class EndgameFunctions {
public: public:
EndgameFunctions(); EndgameFunctions();
EndgameEvaluationFunction* getEEF(Key key) const; EndgameEvaluationFunctionBase* getEEF(Key key) const;
ScalingFunction* getESF(Key key, Color* c) const; EndgameScalingFunctionBase* getESF(Key key, Color* c) const;
private: private:
void add(Key k, EndgameEvaluationFunction* f); void add(Key k, EndgameEvaluationFunctionBase* f);
void add(Key k, Color c, ScalingFunction* f); void add(Key k, Color c, EndgameScalingFunctionBase* f);
struct ScalingInfo struct ScalingInfo
{ {
Color col; Color col;
ScalingFunction* fun; EndgameScalingFunctionBase* fun;
}; };
std::map<Key, EndgameEvaluationFunction*> EEFmap; std::map<Key, EndgameEvaluationFunctionBase*> EEFmap;
std::map<Key, ScalingInfo> ESFmap; std::map<Key, ScalingInfo> ESFmap;
}; };
@ -187,7 +187,7 @@ MaterialInfo* MaterialInfoTable::get_material_info(const Position& pos) {
// are several conflicting applicable scaling functions and we need to // are several conflicting applicable scaling functions and we need to
// decide which one to use. // decide which one to use.
Color c; Color c;
ScalingFunction* sf; EndgameScalingFunctionBase* sf;
if ((sf = funcs->getESF(key, &c)) != NULL) if ((sf = funcs->getESF(key, &c)) != NULL)
{ {
@ -355,24 +355,24 @@ EndgameFunctions::EndgameFunctions() {
add(z[W][ROOK][1] ^ z[W][PAWN][1] ^ z[B][ROOK][1] ^ z[B][PAWN][1] ^ z[B][PAWN][2], B, &ScaleKRPKRPP); add(z[W][ROOK][1] ^ z[W][PAWN][1] ^ z[B][ROOK][1] ^ z[B][PAWN][1] ^ z[B][PAWN][2], B, &ScaleKRPKRPP);
} }
void EndgameFunctions::add(Key k, EndgameEvaluationFunction* f) { void EndgameFunctions::add(Key k, EndgameEvaluationFunctionBase* f) {
EEFmap.insert(std::pair<Key, EndgameEvaluationFunction*>(k, f)); EEFmap.insert(std::pair<Key, EndgameEvaluationFunctionBase*>(k, f));
} }
void EndgameFunctions::add(Key k, Color c, ScalingFunction* f) { void EndgameFunctions::add(Key k, Color c, EndgameScalingFunctionBase* f) {
ScalingInfo s = {c, f}; ScalingInfo s = {c, f};
ESFmap.insert(std::pair<Key, ScalingInfo>(k, s)); ESFmap.insert(std::pair<Key, ScalingInfo>(k, s));
} }
EndgameEvaluationFunction* EndgameFunctions::getEEF(Key key) const { EndgameEvaluationFunctionBase* EndgameFunctions::getEEF(Key key) const {
std::map<Key, EndgameEvaluationFunction*>::const_iterator it(EEFmap.find(key)); std::map<Key, EndgameEvaluationFunctionBase*>::const_iterator it(EEFmap.find(key));
return (it != EEFmap.end() ? it->second : NULL); return (it != EEFmap.end() ? it->second : NULL);
} }
ScalingFunction* EndgameFunctions::getESF(Key key, Color* c) const { EndgameScalingFunctionBase* EndgameFunctions::getESF(Key key, Color* c) const {
std::map<Key, ScalingInfo>::const_iterator it(ESFmap.find(key)); std::map<Key, ScalingInfo>::const_iterator it(ESFmap.find(key));
if (it == ESFmap.end()) if (it == ESFmap.end())

4
src/material.h
View file

@ -63,8 +63,8 @@ private:
int16_t mgValue; int16_t mgValue;
int16_t egValue; int16_t egValue;
uint8_t factor[2]; uint8_t factor[2];
EndgameEvaluationFunction* evaluationFunction; EndgameEvaluationFunctionBase* evaluationFunction;
ScalingFunction* scalingFunction[2]; EndgameScalingFunctionBase* scalingFunction[2];
uint8_t spaceWeight; uint8_t spaceWeight;
}; };