X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fmaterial.cpp;h=294744f4ed7de6da34ccdea53acca82d813d13f5;hp=7f760ee29b2cc3ab1359b7020deb242cf4d7f5f9;hb=b54bcfddaa2a5f6c5d4d5b54243a682a098f49a3;hpb=d8f683760c9eb6d2c4714ec83e717dd2143de55c diff --git a/src/material.cpp b/src/material.cpp index 7f760ee2..294744f4 100644 --- a/src/material.cpp +++ b/src/material.cpp @@ -2,7 +2,7 @@ Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad - Copyright (C) 2015-2017 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad + Copyright (C) 2015-2019 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Stockfish is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -31,18 +31,18 @@ namespace { // Polynomial material imbalance parameters - const int QuadraticOurs[][PIECE_TYPE_NB] = { + constexpr int QuadraticOurs[][PIECE_TYPE_NB] = { // OUR PIECES // pair pawn knight bishop rook queen - {1667 }, // Bishop pair - { 40, 2 }, // Pawn - { 32, 255, -3 }, // Knight OUR PIECES + {1438 }, // Bishop pair + { 40, 38 }, // Pawn + { 32, 255, -62 }, // Knight OUR PIECES { 0, 104, 4, 0 }, // Bishop - { -26, -2, 47, 105, -149 }, // Rook - {-185, 24, 122, 137, -134, 0 } // Queen + { -26, -2, 47, 105, -208 }, // Rook + {-189, 24, 117, 133, -134, -6 } // Queen }; - const int QuadraticTheirs[][PIECE_TYPE_NB] = { + constexpr int QuadraticTheirs[][PIECE_TYPE_NB] = { // THEIR PIECES // pair pawn knight bishop rook queen { 0 }, // Bishop pair @@ -50,7 +50,7 @@ namespace { { 9, 63, 0 }, // Knight OUR PIECES { 59, 65, 42, 0 }, // Bishop { 46, 39, 24, -24, 0 }, // Rook - { 101, 100, -37, 141, 268, 0 } // Queen + { 97, 100, -42, 137, 268, 0 } // Queen }; // Endgame evaluation and scaling functions are accessed directly and not through @@ -68,7 +68,7 @@ namespace { && pos.non_pawn_material(us) >= RookValueMg; } - bool is_KBPsKs(const Position& pos, Color us) { + bool is_KBPsK(const Position& pos, Color us) { return pos.non_pawn_material(us) == BishopValueMg && pos.count(us) == 1 && pos.count(us) >= 1; @@ -77,7 +77,7 @@ namespace { bool is_KQKRPs(const Position& pos, Color us) { return !pos.count(us) && pos.non_pawn_material(us) == QueenValueMg - && pos.count(us) == 1 + && pos.count(us) == 1 && pos.count(~us) == 1 && pos.count(~us) >= 1; } @@ -87,11 +87,11 @@ namespace { template int imbalance(const int pieceCount[][PIECE_TYPE_NB]) { - const Color Them = (Us == WHITE ? BLACK : WHITE); + constexpr Color Them = (Us == WHITE ? BLACK : WHITE); int bonus = 0; - // Second-degree polynomial material imbalance by Tord Romstad + // Second-degree polynomial material imbalance, by Tord Romstad for (int pt1 = NO_PIECE_TYPE; pt1 <= QUEEN; ++pt1) { if (!pieceCount[Us][pt1]) @@ -129,7 +129,13 @@ Entry* probe(const Position& pos) { std::memset(e, 0, sizeof(Entry)); e->key = key; e->factor[WHITE] = e->factor[BLACK] = (uint8_t)SCALE_FACTOR_NORMAL; - e->gamePhase = pos.game_phase(); + + Value npm_w = pos.non_pawn_material(WHITE); + Value npm_b = pos.non_pawn_material(BLACK); + Value npm = std::max(EndgameLimit, std::min(npm_w + npm_b, MidgameLimit)); + + // Map total non-pawn material into [PHASE_ENDGAME, PHASE_MIDGAME] + e->gamePhase = Phase(((npm - EndgameLimit) * PHASE_MIDGAME) / (MidgameLimit - EndgameLimit)); // Let's look if we have a specialized evaluation function for this particular // material configuration. Firstly we look for a fixed configuration one, then @@ -146,11 +152,11 @@ Entry* probe(const Position& pos) { // OK, we didn't find any special evaluation function for the current material // configuration. Is there a suitable specialized scaling function? - EndgameBase* sf; + const EndgameBase* sf; if ((sf = pos.this_thread()->endgames.probe(key)) != nullptr) { - e->scalingFunction[sf->strong_side()] = sf; // Only strong color assigned + e->scalingFunction[sf->strongSide] = sf; // Only strong color assigned return e; } @@ -159,16 +165,13 @@ Entry* probe(const Position& pos) { // case we don't return after setting the function. for (Color c = WHITE; c <= BLACK; ++c) { - if (is_KBPsKs(pos, c)) + if (is_KBPsK(pos, c)) e->scalingFunction[c] = &ScaleKBPsK[c]; else if (is_KQKRPs(pos, c)) e->scalingFunction[c] = &ScaleKQKRPs[c]; } - Value npm_w = pos.non_pawn_material(WHITE); - Value npm_b = pos.non_pawn_material(BLACK); - if (npm_w + npm_b == VALUE_ZERO && pos.pieces(PAWN)) // Only pawns on the board { if (!pos.count(BLACK)) @@ -203,22 +206,16 @@ Entry* probe(const Position& pos) { e->factor[BLACK] = uint8_t(npm_b < RookValueMg ? SCALE_FACTOR_DRAW : npm_w <= BishopValueMg ? 4 : 14); - if (pos.count(WHITE) == 1 && npm_w - npm_b <= BishopValueMg) - e->factor[WHITE] = (uint8_t) SCALE_FACTOR_ONEPAWN; - - if (pos.count(BLACK) == 1 && npm_b - npm_w <= BishopValueMg) - e->factor[BLACK] = (uint8_t) SCALE_FACTOR_ONEPAWN; - // Evaluate the material imbalance. We use PIECE_TYPE_NONE as a place holder // for the bishop pair "extended piece", which allows us to be more flexible // in defining bishop pair bonuses. - const int PieceCount[COLOR_NB][PIECE_TYPE_NB] = { + const int pieceCount[COLOR_NB][PIECE_TYPE_NB] = { { pos.count(WHITE) > 1, pos.count(WHITE), pos.count(WHITE), pos.count(WHITE) , pos.count(WHITE), pos.count(WHITE) }, { pos.count(BLACK) > 1, pos.count(BLACK), pos.count(BLACK), pos.count(BLACK) , pos.count(BLACK), pos.count(BLACK) } }; - e->value = int16_t((imbalance(PieceCount) - imbalance(PieceCount)) / 16); + e->value = int16_t((imbalance(pieceCount) - imbalance(pieceCount)) / 16); return e; }