X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fmaterial.cpp;h=11fd3c9b235cfe5ba8baaa542694186f69a6aa9a;hp=10daaeb53ae6df5d3507eda190ca6bb6d99b691a;hb=f178f0a2912082e2e9d07d9b0926031322d78f67;hpb=899b9455d6a5ae64f867ce8f78a02c17858e94e9 diff --git a/src/material.cpp b/src/material.cpp index 10daaeb5..11fd3c9b 100644 --- a/src/material.cpp +++ b/src/material.cpp @@ -23,6 +23,7 @@ //// #include +#include #include #include "material.h" @@ -39,29 +40,33 @@ namespace { Key KNNKMaterialKey, KKNNMaterialKey; - struct ScalingInfo - { - Color col; - ScalingFunction* fun; - }; - } //// //// Classes //// + +/// See header for a class description. It is declared here to avoid +/// to include in the header file. + class EndgameFunctions { public: EndgameFunctions(); - EndgameEvaluationFunction* getEEF(Key key); - ScalingInfo getESF(Key key); + EndgameEvaluationFunction* getEEF(Key key) const; + ScalingFunction* getESF(Key key, Color* c) const; private: void add(Key k, EndgameEvaluationFunction* f); void add(Key k, Color c, ScalingFunction* f); + struct ScalingInfo + { + Color col; + ScalingFunction* fun; + }; + std::map EEFmap; std::map ESFmap; }; @@ -71,19 +76,6 @@ private: //// Functions //// -/// MaterialInfo::init() is called during program initialization. It -/// precomputes material hash keys for a few basic endgames, in order -/// to make it easy to recognize such endgames when they occur. - -void MaterialInfo::init() { - - typedef Key ZM[2][8][16]; - const ZM& z = Position::zobMaterial; - - KNNKMaterialKey = z[WHITE][KNIGHT][1] ^ z[WHITE][KNIGHT][2]; - KKNNMaterialKey = z[BLACK][KNIGHT][1] ^ z[BLACK][KNIGHT][2]; -} - /// Constructor for the MaterialInfoTable class @@ -126,7 +118,7 @@ void MaterialInfoTable::clear() { /// is stored there, so we don't have to recompute everything when the /// same material configuration occurs again. -MaterialInfo *MaterialInfoTable::get_material_info(const Position& pos) { +MaterialInfo* MaterialInfoTable::get_material_info(const Position& pos) { Key key = pos.get_material_key(); int index = key & (size - 1); @@ -136,7 +128,7 @@ MaterialInfo *MaterialInfoTable::get_material_info(const Position& pos) { // have analysed this material configuration before, and we can simply // return the information we found the last time instead of recomputing it. if (mi->key == key) - return mi; + return mi; // Clear the MaterialInfo object, and set its key mi->clear(); @@ -146,8 +138,8 @@ MaterialInfo *MaterialInfoTable::get_material_info(const Position& pos) { // KNN vs K is a draw. if (key == KNNKMaterialKey || key == KKNNMaterialKey) { - mi->factor[WHITE] = mi->factor[BLACK] = 0; - return mi; + mi->factor[WHITE] = mi->factor[BLACK] = 0; + return mi; } // Let's look if we have a specialized evaluation function for this @@ -169,6 +161,22 @@ MaterialInfo *MaterialInfoTable::get_material_info(const Position& pos) { mi->evaluationFunction = &EvaluateKKX; return mi; } + else if ( pos.pawns() == EmptyBoardBB + && pos.rooks() == EmptyBoardBB + && pos.queens() == EmptyBoardBB) + { + // Minor piece endgame with at least one minor piece per side, + // and no pawns. + assert(pos.knights(WHITE) | pos.bishops(WHITE)); + assert(pos.knights(BLACK) | pos.bishops(BLACK)); + + if ( pos.piece_count(WHITE, BISHOP) + pos.piece_count(WHITE, KNIGHT) <= 2 + && pos.piece_count(BLACK, BISHOP) + pos.piece_count(BLACK, KNIGHT) <= 2) + { + mi->evaluationFunction = &EvaluateKmmKm; + return mi; + } + } // OK, we didn't find any special evaluation function for the current // material configuration. Is there a suitable scaling function? @@ -177,10 +185,12 @@ MaterialInfo *MaterialInfoTable::get_material_info(const Position& pos) { // if we decide to add more special cases. We face problems when there // are several conflicting applicable scaling functions and we need to // decide which one to use. - ScalingInfo si = funcs->getESF(key); - if (si.fun != NULL) + Color c; + ScalingFunction* sf; + + if ((sf = funcs->getESF(key, &c)) != NULL) { - mi->scalingFunction[si.col] = si.fun; + mi->scalingFunction[c] = sf; return mi; } @@ -229,7 +239,6 @@ MaterialInfo *MaterialInfoTable::get_material_info(const Position& pos) { // Evaluate the material balance - Color c; int sign; Value egValue = Value(0); Value mgValue = Value(0); @@ -281,17 +290,16 @@ MaterialInfo *MaterialInfoTable::get_material_info(const Position& pos) { egValue -= sign * v; } } - mi->mgValue = int16_t(mgValue); mi->egValue = int16_t(egValue); return mi; } -/// EndgameFunctions members definition. This helper class is used to -/// store the maps of end game and scaling functions that MaterialInfoTable -/// will query for each key. The maps are constant, and are populated only -/// at construction. Being per thread avoids to use locks to access them. +/// EndgameFunctions member definitions. This class is used to store the maps +/// of end game and scaling functions that MaterialInfoTable will query for +/// each key. The maps are constant and are populated only at construction, +/// but are per-thread instead of globals to avoid expensive locks. EndgameFunctions::EndgameFunctions() { @@ -317,6 +325,8 @@ EndgameFunctions::EndgameFunctions() { add(z[W][KNIGHT][1] ^ z[B][ROOK][1], &EvaluateKNKR); add(z[W][QUEEN][1] ^ z[B][ROOK][1], &EvaluateKQKR); add(z[W][ROOK][1] ^ z[B][QUEEN][1], &EvaluateKRKQ); + add(z[W][BISHOP][2] ^ z[B][KNIGHT][1], &EvaluateKBBKN); + add(z[W][KNIGHT][1] ^ z[B][BISHOP][2], &EvaluateKNKBB); add(z[W][KNIGHT][1] ^ z[W][PAWN][1], W, &ScaleKNPK); add(z[B][KNIGHT][1] ^ z[B][PAWN][1], B, &ScaleKKNP); @@ -343,22 +353,18 @@ void EndgameFunctions::add(Key k, Color c, ScalingFunction* f) { ESFmap.insert(std::pair(k, s)); } -EndgameEvaluationFunction* EndgameFunctions::getEEF(Key key) { - - EndgameEvaluationFunction* f = NULL; - std::map::iterator it(EEFmap.find(key)); - if (it != EEFmap.end()) - f = it->second; +EndgameEvaluationFunction* EndgameFunctions::getEEF(Key key) const { - return f; + std::map::const_iterator it(EEFmap.find(key)); + return (it != EEFmap.end() ? it->second : NULL); } -ScalingInfo EndgameFunctions::getESF(Key key) { +ScalingFunction* EndgameFunctions::getESF(Key key, Color* c) const { - ScalingInfo si = {WHITE, NULL}; - std::map::iterator it(ESFmap.find(key)); - if (it != ESFmap.end()) - si = it->second; + std::map::const_iterator it(ESFmap.find(key)); + if (it == ESFmap.end()) + return NULL; - return si; + *c = it->second.col; + return it->second.fun; }