2008-08-31 23:59:13 -06:00
|
|
|
/*
|
2008-10-19 10:56:28 -06:00
|
|
|
Stockfish, a UCI chess playing engine derived from Glaurung 2.1
|
2021-01-08 09:04:23 -07:00
|
|
|
Copyright (C) 2004-2021 The Stockfish developers (see AUTHORS file)
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2008-10-19 10:56:28 -06:00
|
|
|
Stockfish is free software: you can redistribute it and/or modify
|
2008-08-31 23:59:13 -06:00
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
|
|
(at your option) any later version.
|
2009-01-07 06:26:58 -07:00
|
|
|
|
2008-10-19 10:56:28 -06:00
|
|
|
Stockfish is distributed in the hope that it will be useful,
|
2008-08-31 23:59:13 -06:00
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
GNU General Public License for more details.
|
2009-01-07 06:26:58 -07:00
|
|
|
|
2008-08-31 23:59:13 -06:00
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
|
2011-12-28 16:13:49 -07:00
|
|
|
#include <cassert>
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2012-08-18 06:04:43 -06:00
|
|
|
#include "bitboard.h"
|
2008-08-31 23:59:13 -06:00
|
|
|
#include "endgame.h"
|
2012-02-05 12:52:01 -07:00
|
|
|
#include "movegen.h"
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2021-02-26 02:02:13 -07:00
|
|
|
namespace Stockfish {
|
|
|
|
|
2008-08-31 23:59:13 -06:00
|
|
|
namespace {
|
|
|
|
|
Equations for edges and corners.
This is a functional simplification that removes the large arrays in endgames.cpp.
It also fixes a recently introduced bug (960d59d54143d84aab26deae65279a611fc989f4) in KNBvK,
now using flip_file() instead of ~.
One fen added to bench to increase endgame coverage.
STC
LLR: 2.94 (-2.94,2.94) {-1.50,0.50}
Total: 174724 W: 33325 L: 33404 D: 107995
Ptnml(0-2): 2503, 19607, 43181, 19608, 2463
http://tests.stockfishchess.org/tests/view/5e6448ffe42a5c3b3ca2e287
LTC
LLR: 2.95 (-2.94,2.94) {-1.50,0.50}
Total: 35640 W: 4679 L: 4621 D: 26340
Ptnml(0-2): 189, 2991, 11424, 3005, 211
http://tests.stockfishchess.org/tests/view/5e650b24e42a5c3b3ca2e2d8
closes https://github.com/official-stockfish/Stockfish/pull/2577
Bench: 5527957
2020-03-09 15:11:08 -06:00
|
|
|
// Used to drive the king towards the edge of the board
|
2009-01-08 07:46:57 -07:00
|
|
|
// in KX vs K and KQ vs KR endgames.
|
2020-06-17 15:15:54 -06:00
|
|
|
// Values range from 27 (center squares) to 90 (in the corners)
|
Equations for edges and corners.
This is a functional simplification that removes the large arrays in endgames.cpp.
It also fixes a recently introduced bug (960d59d54143d84aab26deae65279a611fc989f4) in KNBvK,
now using flip_file() instead of ~.
One fen added to bench to increase endgame coverage.
STC
LLR: 2.94 (-2.94,2.94) {-1.50,0.50}
Total: 174724 W: 33325 L: 33404 D: 107995
Ptnml(0-2): 2503, 19607, 43181, 19608, 2463
http://tests.stockfishchess.org/tests/view/5e6448ffe42a5c3b3ca2e287
LTC
LLR: 2.95 (-2.94,2.94) {-1.50,0.50}
Total: 35640 W: 4679 L: 4621 D: 26340
Ptnml(0-2): 189, 2991, 11424, 3005, 211
http://tests.stockfishchess.org/tests/view/5e650b24e42a5c3b3ca2e2d8
closes https://github.com/official-stockfish/Stockfish/pull/2577
Bench: 5527957
2020-03-09 15:11:08 -06:00
|
|
|
inline int push_to_edge(Square s) {
|
|
|
|
int rd = edge_distance(rank_of(s)), fd = edge_distance(file_of(s));
|
|
|
|
return 90 - (7 * fd * fd / 2 + 7 * rd * rd / 2);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Used to drive the king towards A1H8 corners in KBN vs K endgames.
|
2020-06-17 15:15:54 -06:00
|
|
|
// Values range from 0 on A8H1 diagonal to 7 in A1H8 corners
|
Equations for edges and corners.
This is a functional simplification that removes the large arrays in endgames.cpp.
It also fixes a recently introduced bug (960d59d54143d84aab26deae65279a611fc989f4) in KNBvK,
now using flip_file() instead of ~.
One fen added to bench to increase endgame coverage.
STC
LLR: 2.94 (-2.94,2.94) {-1.50,0.50}
Total: 174724 W: 33325 L: 33404 D: 107995
Ptnml(0-2): 2503, 19607, 43181, 19608, 2463
http://tests.stockfishchess.org/tests/view/5e6448ffe42a5c3b3ca2e287
LTC
LLR: 2.95 (-2.94,2.94) {-1.50,0.50}
Total: 35640 W: 4679 L: 4621 D: 26340
Ptnml(0-2): 189, 2991, 11424, 3005, 211
http://tests.stockfishchess.org/tests/view/5e650b24e42a5c3b3ca2e2d8
closes https://github.com/official-stockfish/Stockfish/pull/2577
Bench: 5527957
2020-03-09 15:11:08 -06:00
|
|
|
inline int push_to_corner(Square s) {
|
|
|
|
return abs(7 - rank_of(s) - file_of(s));
|
|
|
|
}
|
2008-08-31 23:59:13 -06:00
|
|
|
|
Use equations for PushAway and PushClose
A functional simplification replacing the corresponding arrays. Tested in two variants,
also the simpler one performs well, even though differences to master should be minimal.
STC
LLR: 2.95 (-2.94,2.94) {-1.50,0.50}
Total: 57864 W: 11092 L: 11001 D: 35771
Ptnml(0-2): 826, 6458, 14320, 6455, 873
http://tests.stockfishchess.org/tests/view/5e5da5b6e42a5c3b3ca2e05c
LTC
LLR: 2.95 (-2.94,2.94) {-1.50,0.50}
Total: 7198 W: 982 L: 883 D: 5333
Ptnml(0-2): 33, 575, 2296, 650, 45
http://tests.stockfishchess.org/tests/view/5e5df13ae42a5c3b3ca2e077
LTC (This exact version. . . more simplified)
LLR: 2.95 (-2.94,2.94) {-1.50,0.50}
Total: 5392 W: 729 L: 631 D: 4032
Ptnml(0-2): 23, 405, 1751, 485, 32
http://tests.stockfishchess.org/tests/view/5e5ead99e42a5c3b3ca2e0e4
closes https://github.com/official-stockfish/Stockfish/pull/2570
Bench 5123316
2020-03-02 17:32:02 -07:00
|
|
|
// Drive a piece close to or away from another piece
|
|
|
|
inline int push_close(Square s1, Square s2) { return 140 - 20 * distance(s1, s2); }
|
|
|
|
inline int push_away(Square s1, Square s2) { return 120 - push_close(s1, s2); }
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2013-10-14 06:57:08 -06:00
|
|
|
#ifndef NDEBUG
|
2014-12-07 16:53:33 -07:00
|
|
|
bool verify_material(const Position& pos, Color c, Value npm, int pawnsCnt) {
|
|
|
|
return pos.non_pawn_material(c) == npm && pos.count<PAWN>(c) == pawnsCnt;
|
2013-10-14 06:57:08 -06:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2013-10-23 07:50:20 -06:00
|
|
|
// Map the square as if strongSide is white and strongSide's only pawn
|
|
|
|
// is on the left half of the board.
|
|
|
|
Square normalize(const Position& pos, Color strongSide, Square sq) {
|
|
|
|
|
|
|
|
assert(pos.count<PAWN>(strongSide) == 1);
|
|
|
|
|
2015-08-04 01:00:52 -06:00
|
|
|
if (file_of(pos.square<PAWN>(strongSide)) >= FILE_E)
|
2020-03-01 02:03:36 -07:00
|
|
|
sq = flip_file(sq);
|
2013-10-23 07:50:20 -06:00
|
|
|
|
2020-03-01 02:03:36 -07:00
|
|
|
return strongSide == WHITE ? sq : flip_rank(sq);
|
2013-10-23 07:50:20 -06:00
|
|
|
}
|
|
|
|
|
2011-04-11 10:12:41 -06:00
|
|
|
} // namespace
|
|
|
|
|
|
|
|
|
2019-05-15 02:41:58 -06:00
|
|
|
namespace Endgames {
|
|
|
|
|
|
|
|
std::pair<Map<Value>, Map<ScaleFactor>> maps;
|
|
|
|
|
|
|
|
void init() {
|
|
|
|
|
2019-05-02 11:36:25 -06:00
|
|
|
add<KPK>("KPK");
|
|
|
|
add<KNNK>("KNNK");
|
|
|
|
add<KBNK>("KBNK");
|
|
|
|
add<KRKP>("KRKP");
|
|
|
|
add<KRKB>("KRKB");
|
|
|
|
add<KRKN>("KRKN");
|
|
|
|
add<KQKP>("KQKP");
|
|
|
|
add<KQKR>("KQKR");
|
|
|
|
add<KNNKP>("KNNKP");
|
|
|
|
|
|
|
|
add<KRPKR>("KRPKR");
|
|
|
|
add<KRPKB>("KRPKB");
|
|
|
|
add<KBPKB>("KBPKB");
|
|
|
|
add<KBPKN>("KBPKN");
|
|
|
|
add<KBPPKB>("KBPPKB");
|
|
|
|
add<KRPPKRP>("KRPPKRP");
|
2019-05-15 02:41:58 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-05-02 11:36:25 -06:00
|
|
|
|
2009-01-08 07:46:57 -07:00
|
|
|
/// Mate with KX vs K. This function is used to evaluate positions with
|
2013-12-02 11:04:09 -07:00
|
|
|
/// king and plenty of material vs a lone king. It simply gives the
|
2008-08-31 23:59:13 -06:00
|
|
|
/// 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.
|
2009-02-12 05:20:22 -07:00
|
|
|
template<>
|
2011-12-05 12:58:23 -07:00
|
|
|
Value Endgame<KXK>::operator()(const Position& pos) const {
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2013-10-14 11:34:12 -06:00
|
|
|
assert(verify_material(pos, weakSide, VALUE_ZERO, 0));
|
2013-08-19 00:54:10 -06:00
|
|
|
assert(!pos.checkers()); // Eval is never called when in check
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2012-04-01 08:12:39 -06:00
|
|
|
// Stalemate detection with lone king
|
2013-10-14 11:34:12 -06:00
|
|
|
if (pos.side_to_move() == weakSide && !MoveList<LEGAL>(pos).size())
|
2013-08-19 00:54:10 -06:00
|
|
|
return VALUE_DRAW;
|
2012-04-01 08:12:39 -06:00
|
|
|
|
2020-06-17 15:15:54 -06:00
|
|
|
Square strongKing = pos.square<KING>(strongSide);
|
|
|
|
Square weakKing = pos.square<KING>(weakSide);
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2013-10-14 11:34:12 -06:00
|
|
|
Value result = pos.non_pawn_material(strongSide)
|
|
|
|
+ pos.count<PAWN>(strongSide) * PawnValueEg
|
2020-06-17 15:15:54 -06:00
|
|
|
+ push_to_edge(weakKing)
|
|
|
|
+ push_close(strongKing, weakKing);
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2013-10-14 11:34:12 -06:00
|
|
|
if ( pos.count<QUEEN>(strongSide)
|
|
|
|
|| pos.count<ROOK>(strongSide)
|
2014-05-03 13:37:24 -06:00
|
|
|
||(pos.count<BISHOP>(strongSide) && pos.count<KNIGHT>(strongSide))
|
2017-08-12 02:50:38 -06:00
|
|
|
|| ( (pos.pieces(strongSide, BISHOP) & ~DarkSquares)
|
|
|
|
&& (pos.pieces(strongSide, BISHOP) & DarkSquares)))
|
Fix for incorrect VALUE_MATE_IN_MAX_PLY usage.
Fixes #2533, fixes #2543, fixes #2423.
the code that prevents false mate announcements depending on the TT
state (GHI), incorrectly used VALUE_MATE_IN_MAX_PLY. The latter
constant, however, also includes, counterintuitively, the TB win range.
This patch fixes that, by restoring the behavior for TB win scores,
while retaining the false mate correctness, and improving the mate
finding ability. In particular
no alse mates are announced with the poisened hash testcase
```
position fen 8/8/8/3k4/8/8/6K1/7R w - - 0 1
go depth 40
position fen 8/8/8/3k4/8/8/6K1/7R w - - 76 1
go depth 20
ucinewgame
```
mates are found with the testcases reported in #2543
```
position fen 4k3/3pp3/8/8/8/8/2PPP3/4K3 w - - 0 1
setoption name Hash value 1024
go depth 55
ucinewgame
```
and
```
position fen 4k3/4p3/8/8/8/8/3PP3/4K3 w - - 0 1
setoption name Hash value 1024
go depth 45
ucinewgame
```
furthermore, on the mate finding benchmark (ChestUCI_23102018.epd),
performance improves over master, roughly reaching performance with the
false mate protection reverted
```
Analyzing 6566 mate positions for best and found mates:
----------------best ---------------found
nodes master revert fixed master revert fixed
16000000 4233 4236 4235 5200 5201 5199
32000000 4583 4585 4585 5417 5424 5418
64000000 4852 4853 4855 5575 5584 5579
128000000 5071 5068 5066 5710 5720 5716
256000000 5280 5282 5279 5819 5827 5826
512000000 5471 5468 5468 5919 5935 5932
```
On a testcase with TB enabled, progress is made consistently, contrary
to master
```
setoption name SyzygyPath value ../../../syzygy/3-4-5/
setoption name Hash value 2048
position fen 1R6/3k4/8/K2p4/4n3/2P5/8/8 w - - 0 1
go depth 58
ucinewgame
```
The PR (prior to a rewrite for clarity)
passed STC:
LLR: 2.94 (-2.94,2.94) {-1.50,0.50}
Total: 65405 W: 12454 L: 12384 D: 40567
Ptnml(0-2): 920, 7256, 16285, 7286, 944
http://tests.stockfishchess.org/tests/view/5e441a3be70d848499f63d15
passed LTC:
LLR: 2.94 (-2.94,2.94) {-1.50,0.50}
Total: 27096 W: 3477 L: 3413 D: 20206
Ptnml(0-2): 128, 2215, 8776, 2292, 122
http://tests.stockfishchess.org/tests/view/5e44e277e70d848499f63d63
The incorrectly named VALUE_MATE_IN_MAX_PLY and VALUE_MATED_IN_MAX_PLY
were renamed into VALUE_TB_WIN_IN_MAX_PLY and VALUE_TB_LOSS_IN_MAX_PLY,
and correclty defined VALUE_MATE_IN_MAX_PLY and VALUE_MATED_IN_MAX_PLY
were introduced.
One further (corner case) mistake using these constants was fixed (go
mate X), which could lead to a premature return if X > MAX_PLY / 2,
but TB were present.
Thanks to @svivanov72 for one of the reports and help fixing the issue.
closes https://github.com/official-stockfish/Stockfish/pull/2552
Bench: 4932981
2020-02-11 12:42:32 -07:00
|
|
|
result = std::min(result + VALUE_KNOWN_WIN, VALUE_TB_WIN_IN_MAX_PLY - 1);
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2013-10-14 11:34:12 -06:00
|
|
|
return strongSide == pos.side_to_move() ? result : -result;
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-01-08 07:46:57 -07:00
|
|
|
/// Mate with KBN vs K. This is similar to KX vs K, but we have to drive the
|
2018-12-08 10:08:59 -07:00
|
|
|
/// defending king towards a corner square that our bishop attacks.
|
2009-02-12 05:20:22 -07:00
|
|
|
template<>
|
2011-12-05 12:58:23 -07:00
|
|
|
Value Endgame<KBNK>::operator()(const Position& pos) const {
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2013-10-14 11:34:12 -06:00
|
|
|
assert(verify_material(pos, strongSide, KnightValueMg + BishopValueMg, 0));
|
|
|
|
assert(verify_material(pos, weakSide, VALUE_ZERO, 0));
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2020-06-17 15:15:54 -06:00
|
|
|
Square strongKing = pos.square<KING>(strongSide);
|
|
|
|
Square strongBishop = pos.square<BISHOP>(strongSide);
|
|
|
|
Square weakKing = pos.square<KING>(weakSide);
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2020-01-09 12:49:13 -07:00
|
|
|
// If our bishop does not attack A1/H8, we flip the enemy king square
|
2018-12-08 10:08:59 -07:00
|
|
|
// to drive to opposite corners (A8/H1).
|
2008-08-31 23:59:13 -06:00
|
|
|
|
Equations for edges and corners.
This is a functional simplification that removes the large arrays in endgames.cpp.
It also fixes a recently introduced bug (960d59d54143d84aab26deae65279a611fc989f4) in KNBvK,
now using flip_file() instead of ~.
One fen added to bench to increase endgame coverage.
STC
LLR: 2.94 (-2.94,2.94) {-1.50,0.50}
Total: 174724 W: 33325 L: 33404 D: 107995
Ptnml(0-2): 2503, 19607, 43181, 19608, 2463
http://tests.stockfishchess.org/tests/view/5e6448ffe42a5c3b3ca2e287
LTC
LLR: 2.95 (-2.94,2.94) {-1.50,0.50}
Total: 35640 W: 4679 L: 4621 D: 26340
Ptnml(0-2): 189, 2991, 11424, 3005, 211
http://tests.stockfishchess.org/tests/view/5e650b24e42a5c3b3ca2e2d8
closes https://github.com/official-stockfish/Stockfish/pull/2577
Bench: 5527957
2020-03-09 15:11:08 -06:00
|
|
|
Value result = (VALUE_KNOWN_WIN + 3520)
|
2020-06-17 15:15:54 -06:00
|
|
|
+ push_close(strongKing, weakKing)
|
|
|
|
+ 420 * push_to_corner(opposite_colors(strongBishop, SQ_A1) ? flip_file(weakKing) : weakKing);
|
2008-08-31 23:59:13 -06:00
|
|
|
|
Fix for incorrect VALUE_MATE_IN_MAX_PLY usage.
Fixes #2533, fixes #2543, fixes #2423.
the code that prevents false mate announcements depending on the TT
state (GHI), incorrectly used VALUE_MATE_IN_MAX_PLY. The latter
constant, however, also includes, counterintuitively, the TB win range.
This patch fixes that, by restoring the behavior for TB win scores,
while retaining the false mate correctness, and improving the mate
finding ability. In particular
no alse mates are announced with the poisened hash testcase
```
position fen 8/8/8/3k4/8/8/6K1/7R w - - 0 1
go depth 40
position fen 8/8/8/3k4/8/8/6K1/7R w - - 76 1
go depth 20
ucinewgame
```
mates are found with the testcases reported in #2543
```
position fen 4k3/3pp3/8/8/8/8/2PPP3/4K3 w - - 0 1
setoption name Hash value 1024
go depth 55
ucinewgame
```
and
```
position fen 4k3/4p3/8/8/8/8/3PP3/4K3 w - - 0 1
setoption name Hash value 1024
go depth 45
ucinewgame
```
furthermore, on the mate finding benchmark (ChestUCI_23102018.epd),
performance improves over master, roughly reaching performance with the
false mate protection reverted
```
Analyzing 6566 mate positions for best and found mates:
----------------best ---------------found
nodes master revert fixed master revert fixed
16000000 4233 4236 4235 5200 5201 5199
32000000 4583 4585 4585 5417 5424 5418
64000000 4852 4853 4855 5575 5584 5579
128000000 5071 5068 5066 5710 5720 5716
256000000 5280 5282 5279 5819 5827 5826
512000000 5471 5468 5468 5919 5935 5932
```
On a testcase with TB enabled, progress is made consistently, contrary
to master
```
setoption name SyzygyPath value ../../../syzygy/3-4-5/
setoption name Hash value 2048
position fen 1R6/3k4/8/K2p4/4n3/2P5/8/8 w - - 0 1
go depth 58
ucinewgame
```
The PR (prior to a rewrite for clarity)
passed STC:
LLR: 2.94 (-2.94,2.94) {-1.50,0.50}
Total: 65405 W: 12454 L: 12384 D: 40567
Ptnml(0-2): 920, 7256, 16285, 7286, 944
http://tests.stockfishchess.org/tests/view/5e441a3be70d848499f63d15
passed LTC:
LLR: 2.94 (-2.94,2.94) {-1.50,0.50}
Total: 27096 W: 3477 L: 3413 D: 20206
Ptnml(0-2): 128, 2215, 8776, 2292, 122
http://tests.stockfishchess.org/tests/view/5e44e277e70d848499f63d63
The incorrectly named VALUE_MATE_IN_MAX_PLY and VALUE_MATED_IN_MAX_PLY
were renamed into VALUE_TB_WIN_IN_MAX_PLY and VALUE_TB_LOSS_IN_MAX_PLY,
and correclty defined VALUE_MATE_IN_MAX_PLY and VALUE_MATED_IN_MAX_PLY
were introduced.
One further (corner case) mistake using these constants was fixed (go
mate X), which could lead to a premature return if X > MAX_PLY / 2,
but TB were present.
Thanks to @svivanov72 for one of the reports and help fixing the issue.
closes https://github.com/official-stockfish/Stockfish/pull/2552
Bench: 4932981
2020-02-11 12:42:32 -07:00
|
|
|
assert(abs(result) < VALUE_TB_WIN_IN_MAX_PLY);
|
2013-10-14 11:34:12 -06:00
|
|
|
return strongSide == pos.side_to_move() ? result : -result;
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-01-09 12:49:13 -07:00
|
|
|
/// KP vs K. This endgame is evaluated with the help of a bitbase
|
2009-02-12 05:20:22 -07:00
|
|
|
template<>
|
2011-12-05 12:58:23 -07:00
|
|
|
Value Endgame<KPK>::operator()(const Position& pos) const {
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2013-10-14 11:34:12 -06:00
|
|
|
assert(verify_material(pos, strongSide, VALUE_ZERO, 1));
|
|
|
|
assert(verify_material(pos, weakSide, VALUE_ZERO, 0));
|
2009-01-07 06:26:58 -07:00
|
|
|
|
2013-10-22 16:03:45 -06:00
|
|
|
// Assume strongSide is white and the pawn is on files A-D
|
2020-06-17 15:15:54 -06:00
|
|
|
Square strongKing = normalize(pos, strongSide, pos.square<KING>(strongSide));
|
|
|
|
Square strongPawn = normalize(pos, strongSide, pos.square<PAWN>(strongSide));
|
|
|
|
Square weakKing = normalize(pos, strongSide, pos.square<KING>(weakSide));
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2013-10-22 16:03:45 -06:00
|
|
|
Color us = strongSide == pos.side_to_move() ? WHITE : BLACK;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2020-06-17 15:15:54 -06:00
|
|
|
if (!Bitbases::probe(strongKing, strongPawn, weakKing, us))
|
2009-01-08 07:46:57 -07:00
|
|
|
return VALUE_DRAW;
|
|
|
|
|
2020-06-17 15:15:54 -06:00
|
|
|
Value result = VALUE_KNOWN_WIN + PawnValueEg + Value(rank_of(strongPawn));
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2013-10-14 11:34:12 -06:00
|
|
|
return strongSide == pos.side_to_move() ? result : -result;
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-01-08 07:46:57 -07:00
|
|
|
/// KR vs KP. This is a somewhat tricky endgame to evaluate precisely without
|
|
|
|
/// a bitbase. The function below returns drawish scores when the pawn is
|
2008-08-31 23:59:13 -06:00
|
|
|
/// far advanced with support of the king, while the attacking king is far
|
|
|
|
/// away.
|
2009-02-12 05:20:22 -07:00
|
|
|
template<>
|
2011-12-05 12:58:23 -07:00
|
|
|
Value Endgame<KRKP>::operator()(const Position& pos) const {
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2013-10-14 11:34:12 -06:00
|
|
|
assert(verify_material(pos, strongSide, RookValueMg, 0));
|
|
|
|
assert(verify_material(pos, weakSide, VALUE_ZERO, 1));
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2020-06-30 10:17:50 -06:00
|
|
|
Square strongKing = pos.square<KING>(strongSide);
|
|
|
|
Square weakKing = pos.square<KING>(weakSide);
|
|
|
|
Square strongRook = pos.square<ROOK>(strongSide);
|
|
|
|
Square weakPawn = pos.square<PAWN>(weakSide);
|
|
|
|
Square queeningSquare = make_square(file_of(weakPawn), relative_rank(weakSide, RANK_8));
|
2008-08-31 23:59:13 -06:00
|
|
|
Value result;
|
|
|
|
|
2009-01-08 07:46:57 -07:00
|
|
|
// If the stronger side's king is in front of the pawn, it's a win
|
2020-06-30 10:17:50 -06:00
|
|
|
if (forward_file_bb(strongSide, strongKing) & weakPawn)
|
2020-06-17 15:15:54 -06:00
|
|
|
result = RookValueEg - distance(strongKing, weakPawn);
|
2008-08-31 23:59:13 -06:00
|
|
|
|
|
|
|
// If the weaker side's king is too far from the pawn and the rook,
|
2013-09-01 07:58:58 -06:00
|
|
|
// it's a win.
|
2020-06-17 15:15:54 -06:00
|
|
|
else if ( distance(weakKing, weakPawn) >= 3 + (pos.side_to_move() == weakSide)
|
|
|
|
&& distance(weakKing, strongRook) >= 3)
|
|
|
|
result = RookValueEg - distance(strongKing, weakPawn);
|
2008-08-31 23:59:13 -06:00
|
|
|
|
|
|
|
// If the pawn is far advanced and supported by the defending king,
|
2009-01-08 07:46:57 -07:00
|
|
|
// the position is drawish
|
2020-06-30 10:17:50 -06:00
|
|
|
else if ( relative_rank(strongSide, weakKing) <= RANK_3
|
2020-06-17 15:15:54 -06:00
|
|
|
&& distance(weakKing, weakPawn) == 1
|
2020-06-30 10:17:50 -06:00
|
|
|
&& relative_rank(strongSide, strongKing) >= RANK_4
|
2020-06-17 15:15:54 -06:00
|
|
|
&& distance(strongKing, weakPawn) > 2 + (pos.side_to_move() == strongSide))
|
|
|
|
result = Value(80) - 8 * distance(strongKing, weakPawn);
|
2008-08-31 23:59:13 -06:00
|
|
|
|
|
|
|
else
|
2020-06-30 10:17:50 -06:00
|
|
|
result = Value(200) - 8 * ( distance(strongKing, weakPawn + pawn_push(weakSide))
|
|
|
|
- distance(weakKing, weakPawn + pawn_push(weakSide))
|
2020-06-17 15:15:54 -06:00
|
|
|
- distance(weakPawn, queeningSquare));
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2013-10-14 11:34:12 -06:00
|
|
|
return strongSide == pos.side_to_move() ? result : -result;
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-09-21 15:18:46 -06:00
|
|
|
/// KR vs KB. This is very simple, and always returns drawish scores. The
|
2008-08-31 23:59:13 -06:00
|
|
|
/// score is slightly bigger when the defending king is close to the edge.
|
2009-02-12 05:20:22 -07:00
|
|
|
template<>
|
2011-12-05 12:58:23 -07:00
|
|
|
Value Endgame<KRKB>::operator()(const Position& pos) const {
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2013-10-14 11:34:12 -06:00
|
|
|
assert(verify_material(pos, strongSide, RookValueMg, 0));
|
|
|
|
assert(verify_material(pos, weakSide, BishopValueMg, 0));
|
2008-08-31 23:59:13 -06:00
|
|
|
|
Equations for edges and corners.
This is a functional simplification that removes the large arrays in endgames.cpp.
It also fixes a recently introduced bug (960d59d54143d84aab26deae65279a611fc989f4) in KNBvK,
now using flip_file() instead of ~.
One fen added to bench to increase endgame coverage.
STC
LLR: 2.94 (-2.94,2.94) {-1.50,0.50}
Total: 174724 W: 33325 L: 33404 D: 107995
Ptnml(0-2): 2503, 19607, 43181, 19608, 2463
http://tests.stockfishchess.org/tests/view/5e6448ffe42a5c3b3ca2e287
LTC
LLR: 2.95 (-2.94,2.94) {-1.50,0.50}
Total: 35640 W: 4679 L: 4621 D: 26340
Ptnml(0-2): 189, 2991, 11424, 3005, 211
http://tests.stockfishchess.org/tests/view/5e650b24e42a5c3b3ca2e2d8
closes https://github.com/official-stockfish/Stockfish/pull/2577
Bench: 5527957
2020-03-09 15:11:08 -06:00
|
|
|
Value result = Value(push_to_edge(pos.square<KING>(weakSide)));
|
2013-10-14 11:34:12 -06:00
|
|
|
return strongSide == pos.side_to_move() ? result : -result;
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-12-04 23:18:12 -07:00
|
|
|
/// KR vs KN. The attacking side has slightly better winning chances than
|
2008-08-31 23:59:13 -06:00
|
|
|
/// in KR vs KB, particularly if the king and the knight are far apart.
|
2009-02-12 05:20:22 -07:00
|
|
|
template<>
|
2011-12-05 12:58:23 -07:00
|
|
|
Value Endgame<KRKN>::operator()(const Position& pos) const {
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2013-10-14 11:34:12 -06:00
|
|
|
assert(verify_material(pos, strongSide, RookValueMg, 0));
|
|
|
|
assert(verify_material(pos, weakSide, KnightValueMg, 0));
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2020-06-17 15:15:54 -06:00
|
|
|
Square weakKing = pos.square<KING>(weakSide);
|
|
|
|
Square weakKnight = pos.square<KNIGHT>(weakSide);
|
|
|
|
Value result = Value(push_to_edge(weakKing) + push_away(weakKing, weakKnight));
|
2013-10-14 11:34:12 -06:00
|
|
|
return strongSide == pos.side_to_move() ? result : -result;
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-12-02 11:04:09 -07:00
|
|
|
/// KQ vs KP. In general, this is a win for the stronger side, but there are a
|
|
|
|
/// few important exceptions. A pawn on 7th rank and on the A,C,F or H files
|
|
|
|
/// with a king positioned next to it can be a draw, so in that case, we only
|
|
|
|
/// use the distance between the kings.
|
2012-10-27 20:27:19 -06:00
|
|
|
template<>
|
|
|
|
Value Endgame<KQKP>::operator()(const Position& pos) const {
|
|
|
|
|
2013-10-14 11:34:12 -06:00
|
|
|
assert(verify_material(pos, strongSide, QueenValueMg, 0));
|
|
|
|
assert(verify_material(pos, weakSide, VALUE_ZERO, 1));
|
2012-10-27 20:27:19 -06:00
|
|
|
|
2020-06-17 15:15:54 -06:00
|
|
|
Square strongKing = pos.square<KING>(strongSide);
|
|
|
|
Square weakKing = pos.square<KING>(weakSide);
|
|
|
|
Square weakPawn = pos.square<PAWN>(weakSide);
|
2012-10-27 20:27:19 -06:00
|
|
|
|
2020-06-17 15:15:54 -06:00
|
|
|
Value result = Value(push_close(strongKing, weakKing));
|
2012-10-27 20:27:19 -06:00
|
|
|
|
2020-06-17 15:15:54 -06:00
|
|
|
if ( relative_rank(weakSide, weakPawn) != RANK_7
|
|
|
|
|| distance(weakKing, weakPawn) != 1
|
|
|
|
|| ((FileBBB | FileDBB | FileEBB | FileGBB) & weakPawn))
|
2013-09-01 07:58:58 -06:00
|
|
|
result += QueenValueEg - PawnValueEg;
|
2012-10-27 20:27:19 -06:00
|
|
|
|
2013-10-14 11:34:12 -06:00
|
|
|
return strongSide == pos.side_to_move() ? result : -result;
|
2012-10-27 20:27:19 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-06-24 14:19:58 -06:00
|
|
|
/// KQ vs KR. This is almost identical to KX vs K: we give the attacking
|
2008-08-31 23:59:13 -06:00
|
|
|
/// king a bonus for having the kings close together, and for forcing the
|
2013-12-04 23:18:12 -07:00
|
|
|
/// defending king towards the edge. If we also take care to avoid null move for
|
|
|
|
/// the defending side in the search, this is usually sufficient to win KQ vs KR.
|
2009-02-12 05:20:22 -07:00
|
|
|
template<>
|
2011-12-05 12:58:23 -07:00
|
|
|
Value Endgame<KQKR>::operator()(const Position& pos) const {
|
2009-01-08 07:46:57 -07:00
|
|
|
|
2013-10-14 11:34:12 -06:00
|
|
|
assert(verify_material(pos, strongSide, QueenValueMg, 0));
|
|
|
|
assert(verify_material(pos, weakSide, RookValueMg, 0));
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2020-06-17 15:15:54 -06:00
|
|
|
Square strongKing = pos.square<KING>(strongSide);
|
|
|
|
Square weakKing = pos.square<KING>(weakSide);
|
2009-01-07 06:26:58 -07:00
|
|
|
|
2012-08-20 11:41:28 -06:00
|
|
|
Value result = QueenValueEg
|
|
|
|
- RookValueEg
|
2020-06-17 15:15:54 -06:00
|
|
|
+ push_to_edge(weakKing)
|
|
|
|
+ push_close(strongKing, weakKing);
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2013-10-14 11:34:12 -06:00
|
|
|
return strongSide == pos.side_to_move() ? result : -result;
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
2013-09-02 03:03:01 -06:00
|
|
|
|
Updated KNNKP endgame.
This is a patch that significantly improves playing KNNKP endgames:
```
Score of 2553 vs master: 132 - 38 - 830 [0.547] 1000
Elo difference: 32.8 +/- 8.7, LOS: 100.0 %, DrawRatio: 83.0 %
```
At the same time it reduces the evaluation of this mostly draw engame
from ~7.5 to ~1.5
This patch does not regress against master in normal games:
STC
LLR: 2.94 (-2.94,2.94) {-1.50,0.50}
Total: 96616 W: 18459 L: 18424 D: 59733
Ptnml(0-2): 1409, 10812, 23802, 10905, 1380
http://tests.stockfishchess.org/tests/view/5e49dfe6f8d1d52b40cd31bc
LTC
LLR: 2.95 (-2.94,2.94) {-1.50,0.50}
Total: 49726 W: 6340 L: 6304 D: 37082
Ptnml(0-2): 239, 4227, 15906, 4241, 250
http://tests.stockfishchess.org/tests/view/5e4ab9ee16fb3df8c4cc01d0
Theory: KNNK is a dead draw, however the presence of the additional weakSide pawn opens up some mate opportunities. The idea is to block the pawn (preferably behind the Troitsky line) with one of the knights and press the weakSide king into a corner. If we can stalemate the king, we release the pawn with the knight (to avoid actual stalemate), and use the knight to complete the mate before the pawn promotes. This is also why there is an additional penalty for advancement of the pawn.
closes https://github.com/official-stockfish/Stockfish/pull/2553
Bench: 4981770
2020-02-18 09:10:58 -07:00
|
|
|
/// KNN vs KP. Very drawish, but there are some mate opportunities if we can
|
2020-06-24 14:19:58 -06:00
|
|
|
/// press the weakSide King to a corner before the pawn advances too much.
|
2019-01-04 16:27:14 -07:00
|
|
|
template<>
|
|
|
|
Value Endgame<KNNKP>::operator()(const Position& pos) const {
|
|
|
|
|
2019-03-31 03:47:36 -06:00
|
|
|
assert(verify_material(pos, strongSide, 2 * KnightValueMg, 0));
|
|
|
|
assert(verify_material(pos, weakSide, VALUE_ZERO, 1));
|
2019-01-04 16:27:14 -07:00
|
|
|
|
2020-06-17 15:15:54 -06:00
|
|
|
Square weakKing = pos.square<KING>(weakSide);
|
|
|
|
Square weakPawn = pos.square<PAWN>(weakSide);
|
|
|
|
|
Updated KNNKP endgame.
This is a patch that significantly improves playing KNNKP endgames:
```
Score of 2553 vs master: 132 - 38 - 830 [0.547] 1000
Elo difference: 32.8 +/- 8.7, LOS: 100.0 %, DrawRatio: 83.0 %
```
At the same time it reduces the evaluation of this mostly draw engame
from ~7.5 to ~1.5
This patch does not regress against master in normal games:
STC
LLR: 2.94 (-2.94,2.94) {-1.50,0.50}
Total: 96616 W: 18459 L: 18424 D: 59733
Ptnml(0-2): 1409, 10812, 23802, 10905, 1380
http://tests.stockfishchess.org/tests/view/5e49dfe6f8d1d52b40cd31bc
LTC
LLR: 2.95 (-2.94,2.94) {-1.50,0.50}
Total: 49726 W: 6340 L: 6304 D: 37082
Ptnml(0-2): 239, 4227, 15906, 4241, 250
http://tests.stockfishchess.org/tests/view/5e4ab9ee16fb3df8c4cc01d0
Theory: KNNK is a dead draw, however the presence of the additional weakSide pawn opens up some mate opportunities. The idea is to block the pawn (preferably behind the Troitsky line) with one of the knights and press the weakSide king into a corner. If we can stalemate the king, we release the pawn with the knight (to avoid actual stalemate), and use the knight to complete the mate before the pawn promotes. This is also why there is an additional penalty for advancement of the pawn.
closes https://github.com/official-stockfish/Stockfish/pull/2553
Bench: 4981770
2020-02-18 09:10:58 -07:00
|
|
|
Value result = PawnValueEg
|
2020-06-17 15:15:54 -06:00
|
|
|
+ 2 * push_to_edge(weakKing)
|
|
|
|
- 10 * relative_rank(weakSide, weakPawn);
|
2019-01-04 16:27:14 -07:00
|
|
|
|
2019-03-31 03:47:36 -06:00
|
|
|
return strongSide == pos.side_to_move() ? result : -result;
|
2019-01-04 16:27:14 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-07-27 00:22:12 -06:00
|
|
|
/// Some cases of trivial draws
|
|
|
|
template<> Value Endgame<KNNK>::operator()(const Position&) const { return VALUE_DRAW; }
|
2008-12-21 07:38:10 -07:00
|
|
|
|
|
|
|
|
2013-12-04 23:18:12 -07:00
|
|
|
/// KB and one or more pawns vs K. It checks for draws with rook pawns and
|
2011-12-10 02:14:25 -07:00
|
|
|
/// a bishop of the wrong color. If such a draw is detected, SCALE_FACTOR_DRAW
|
|
|
|
/// is returned. If not, the return value is SCALE_FACTOR_NONE, i.e. no scaling
|
2008-08-31 23:59:13 -06:00
|
|
|
/// will be used.
|
2009-02-12 06:59:46 -07:00
|
|
|
template<>
|
2011-12-05 12:58:23 -07:00
|
|
|
ScaleFactor Endgame<KBPsK>::operator()(const Position& pos) const {
|
2009-01-08 07:46:57 -07:00
|
|
|
|
2013-10-14 11:34:12 -06:00
|
|
|
assert(pos.non_pawn_material(strongSide) == BishopValueMg);
|
|
|
|
assert(pos.count<PAWN>(strongSide) >= 1);
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2013-10-14 11:34:12 -06:00
|
|
|
// No assertions about the material of weakSide, because we want draws to
|
2008-08-31 23:59:13 -06:00
|
|
|
// be detected even when the weaker side has some pawns.
|
|
|
|
|
2020-03-14 10:04:50 -06:00
|
|
|
Bitboard strongPawns = pos.pieces(strongSide, PAWN);
|
|
|
|
Bitboard allPawns = pos.pieces(PAWN);
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2020-06-17 15:15:54 -06:00
|
|
|
Square strongBishop = pos.square<BISHOP>(strongSide);
|
|
|
|
Square weakKing = pos.square<KING>(weakSide);
|
|
|
|
Square strongKing = pos.square<KING>(strongSide);
|
|
|
|
|
2020-03-05 12:07:48 -07:00
|
|
|
// All strongSide pawns are on a single rook file?
|
2020-03-14 10:04:50 -06:00
|
|
|
if (!(strongPawns & ~FileABB) || !(strongPawns & ~FileHBB))
|
2009-01-08 07:46:57 -07:00
|
|
|
{
|
2020-06-17 15:15:54 -06:00
|
|
|
Square queeningSquare = relative_square(strongSide, make_square(file_of(lsb(strongPawns)), RANK_8));
|
2009-01-08 07:46:57 -07:00
|
|
|
|
2020-06-17 15:15:54 -06:00
|
|
|
if ( opposite_colors(queeningSquare, strongBishop)
|
|
|
|
&& distance(queeningSquare, weakKing) <= 1)
|
2014-05-04 01:31:25 -06:00
|
|
|
return SCALE_FACTOR_DRAW;
|
|
|
|
}
|
|
|
|
|
|
|
|
// If all the pawns are on the same B or G file, then it's potentially a draw
|
2020-03-14 10:04:50 -06:00
|
|
|
if ((!(allPawns & ~FileBBB) || !(allPawns & ~FileGBB))
|
2014-05-04 01:31:25 -06:00
|
|
|
&& pos.non_pawn_material(weakSide) == 0
|
|
|
|
&& pos.count<PAWN>(weakSide) >= 1)
|
|
|
|
{
|
2020-03-05 12:07:48 -07:00
|
|
|
// Get the least advanced weakSide pawn
|
2020-06-17 15:15:54 -06:00
|
|
|
Square weakPawn = frontmost_sq(strongSide, pos.pieces(weakSide, PAWN));
|
2014-05-04 01:31:25 -06:00
|
|
|
|
|
|
|
// There's potential for a draw if our pawn is blocked on the 7th rank,
|
2020-06-24 14:19:58 -06:00
|
|
|
// the bishop cannot attack it or they only have one pawn left.
|
2020-06-17 15:15:54 -06:00
|
|
|
if ( relative_rank(strongSide, weakPawn) == RANK_7
|
|
|
|
&& (strongPawns & (weakPawn + pawn_push(weakSide)))
|
|
|
|
&& (opposite_colors(strongBishop, weakPawn) || !more_than_one(strongPawns)))
|
2014-05-04 01:31:25 -06:00
|
|
|
{
|
2020-06-17 15:15:54 -06:00
|
|
|
int strongKingDist = distance(weakPawn, strongKing);
|
|
|
|
int weakKingDist = distance(weakPawn, weakKing);
|
2014-05-04 01:31:25 -06:00
|
|
|
|
|
|
|
// It's a draw if the weak king is on its back two ranks, within 2
|
|
|
|
// squares of the blocking pawn and the strong king is not
|
|
|
|
// closer. (I think this rule only fails in practically
|
|
|
|
// unreachable positions such as 5k1K/6p1/6P1/8/8/3B4/8/8 w
|
|
|
|
// and positions where qsearch will immediately correct the
|
2020-06-24 14:19:58 -06:00
|
|
|
// problem such as 8/4k1p1/6P1/1K6/3B4/8/8/8 w).
|
2020-06-17 15:15:54 -06:00
|
|
|
if ( relative_rank(strongSide, weakKing) >= RANK_7
|
2014-05-04 01:31:25 -06:00
|
|
|
&& weakKingDist <= 2
|
|
|
|
&& weakKingDist <= strongKingDist)
|
2013-10-13 09:44:51 -06:00
|
|
|
return SCALE_FACTOR_DRAW;
|
|
|
|
}
|
2013-02-03 13:42:51 -07:00
|
|
|
}
|
|
|
|
|
2008-08-31 23:59:13 -06:00
|
|
|
return SCALE_FACTOR_NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-12-04 23:18:12 -07:00
|
|
|
/// KQ vs KR and one or more pawns. It tests for fortress draws with a rook on
|
|
|
|
/// the third rank defended by a pawn.
|
2009-02-12 06:59:46 -07:00
|
|
|
template<>
|
2011-12-05 12:58:23 -07:00
|
|
|
ScaleFactor Endgame<KQKRPs>::operator()(const Position& pos) const {
|
2009-01-08 07:46:57 -07:00
|
|
|
|
2013-10-14 11:34:12 -06:00
|
|
|
assert(verify_material(pos, strongSide, QueenValueMg, 0));
|
|
|
|
assert(pos.count<ROOK>(weakSide) == 1);
|
|
|
|
assert(pos.count<PAWN>(weakSide) >= 1);
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2020-06-17 15:15:54 -06:00
|
|
|
Square strongKing = pos.square<KING>(strongSide);
|
|
|
|
Square weakKing = pos.square<KING>(weakSide);
|
|
|
|
Square weakRook = pos.square<ROOK>(weakSide);
|
2013-09-01 07:58:58 -06:00
|
|
|
|
2020-06-17 15:15:54 -06:00
|
|
|
if ( relative_rank(weakSide, weakKing) <= RANK_2
|
|
|
|
&& relative_rank(weakSide, strongKing) >= RANK_4
|
|
|
|
&& relative_rank(weakSide, weakRook) == RANK_3
|
2013-10-14 17:09:05 -06:00
|
|
|
&& ( pos.pieces(weakSide, PAWN)
|
2020-06-17 15:15:54 -06:00
|
|
|
& attacks_bb<KING>(weakKing)
|
|
|
|
& pawn_attacks_bb(strongSide, weakRook)))
|
2011-12-10 02:14:25 -07:00
|
|
|
return SCALE_FACTOR_DRAW;
|
2013-09-01 07:58:58 -06:00
|
|
|
|
2008-08-31 23:59:13 -06:00
|
|
|
return SCALE_FACTOR_NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-12-04 23:18:12 -07:00
|
|
|
/// KRP vs KR. This function knows a handful of the most important classes of
|
|
|
|
/// drawn positions, but is far from perfect. It would probably be a good idea
|
|
|
|
/// to add more knowledge in the future.
|
2008-08-31 23:59:13 -06:00
|
|
|
///
|
|
|
|
/// It would also be nice to rewrite the actual code for this function,
|
2013-12-02 11:04:09 -07:00
|
|
|
/// which is mostly copied from Glaurung 1.x, and isn't very pretty.
|
2009-02-12 06:59:46 -07:00
|
|
|
template<>
|
2011-12-05 12:58:23 -07:00
|
|
|
ScaleFactor Endgame<KRPKR>::operator()(const Position& pos) const {
|
2009-02-03 08:08:41 -07:00
|
|
|
|
2013-10-14 11:34:12 -06:00
|
|
|
assert(verify_material(pos, strongSide, RookValueMg, 1));
|
|
|
|
assert(verify_material(pos, weakSide, RookValueMg, 0));
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2013-10-22 16:03:45 -06:00
|
|
|
// Assume strongSide is white and the pawn is on files A-D
|
2020-06-17 15:15:54 -06:00
|
|
|
Square strongKing = normalize(pos, strongSide, pos.square<KING>(strongSide));
|
|
|
|
Square strongRook = normalize(pos, strongSide, pos.square<ROOK>(strongSide));
|
|
|
|
Square strongPawn = normalize(pos, strongSide, pos.square<PAWN>(strongSide));
|
|
|
|
Square weakKing = normalize(pos, strongSide, pos.square<KING>(weakSide));
|
|
|
|
Square weakRook = normalize(pos, strongSide, pos.square<ROOK>(weakSide));
|
|
|
|
|
|
|
|
File pawnFile = file_of(strongPawn);
|
|
|
|
Rank pawnRank = rank_of(strongPawn);
|
|
|
|
Square queeningSquare = make_square(pawnFile, RANK_8);
|
2013-10-14 11:34:12 -06:00
|
|
|
int tempo = (pos.side_to_move() == strongSide);
|
2008-08-31 23:59:13 -06:00
|
|
|
|
|
|
|
// If the pawn is not too far advanced and the defending king defends the
|
2009-02-03 08:08:41 -07:00
|
|
|
// queening square, use the third-rank defence.
|
2020-06-17 15:15:54 -06:00
|
|
|
if ( pawnRank <= RANK_5
|
|
|
|
&& distance(weakKing, queeningSquare) <= 1
|
|
|
|
&& strongKing <= SQ_H5
|
|
|
|
&& (rank_of(weakRook) == RANK_6 || (pawnRank <= RANK_3 && rank_of(strongRook) != RANK_6)))
|
2011-12-10 02:14:25 -07:00
|
|
|
return SCALE_FACTOR_DRAW;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
|
|
|
// The defending side saves a draw by checking from behind in case the pawn
|
|
|
|
// has advanced to the 6th rank with the king behind.
|
2020-06-17 15:15:54 -06:00
|
|
|
if ( pawnRank == RANK_6
|
|
|
|
&& distance(weakKing, queeningSquare) <= 1
|
|
|
|
&& rank_of(strongKing) + tempo <= RANK_6
|
|
|
|
&& (rank_of(weakRook) == RANK_1 || (!tempo && distance<File>(weakRook, strongPawn) >= 3)))
|
2011-12-10 02:14:25 -07:00
|
|
|
return SCALE_FACTOR_DRAW;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2020-06-17 15:15:54 -06:00
|
|
|
if ( pawnRank >= RANK_6
|
|
|
|
&& weakKing == queeningSquare
|
|
|
|
&& rank_of(weakRook) == RANK_1
|
|
|
|
&& (!tempo || distance(strongKing, strongPawn) >= 2))
|
2011-12-10 02:14:25 -07:00
|
|
|
return SCALE_FACTOR_DRAW;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
|
|
|
// White pawn on a7 and rook on a8 is a draw if black's king is on g7 or h7
|
|
|
|
// and the black rook is behind the pawn.
|
2020-06-17 15:15:54 -06:00
|
|
|
if ( strongPawn == SQ_A7
|
|
|
|
&& strongRook == SQ_A8
|
|
|
|
&& (weakKing == SQ_H7 || weakKing == SQ_G7)
|
|
|
|
&& file_of(weakRook) == FILE_A
|
|
|
|
&& (rank_of(weakRook) <= RANK_3 || file_of(strongKing) >= FILE_D || rank_of(strongKing) <= RANK_5))
|
2011-12-10 02:14:25 -07:00
|
|
|
return SCALE_FACTOR_DRAW;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
|
|
|
// If the defending king blocks the pawn and the attacking king is too far
|
|
|
|
// away, it's a draw.
|
2020-06-17 15:15:54 -06:00
|
|
|
if ( pawnRank <= RANK_5
|
|
|
|
&& weakKing == strongPawn + NORTH
|
|
|
|
&& distance(strongKing, strongPawn) - tempo >= 2
|
|
|
|
&& distance(strongKing, weakRook) - tempo >= 2)
|
2011-12-10 02:14:25 -07:00
|
|
|
return SCALE_FACTOR_DRAW;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
|
|
|
// Pawn on the 7th rank supported by the rook from behind usually wins if the
|
|
|
|
// attacking king is closer to the queening square than the defending king,
|
2009-02-03 08:08:41 -07:00
|
|
|
// and the defending king cannot gain tempi by threatening the attacking rook.
|
2020-06-17 15:15:54 -06:00
|
|
|
if ( pawnRank == RANK_7
|
|
|
|
&& pawnFile != FILE_A
|
|
|
|
&& file_of(strongRook) == pawnFile
|
|
|
|
&& strongRook != queeningSquare
|
|
|
|
&& (distance(strongKing, queeningSquare) < distance(weakKing, queeningSquare) - 2 + tempo)
|
|
|
|
&& (distance(strongKing, queeningSquare) < distance(weakKing, strongRook) + tempo))
|
|
|
|
return ScaleFactor(SCALE_FACTOR_MAX - 2 * distance(strongKing, queeningSquare));
|
2009-02-03 08:08:41 -07:00
|
|
|
|
|
|
|
// Similar to the above, but with the pawn further back
|
2020-06-17 15:15:54 -06:00
|
|
|
if ( pawnFile != FILE_A
|
|
|
|
&& file_of(strongRook) == pawnFile
|
|
|
|
&& strongRook < strongPawn
|
|
|
|
&& (distance(strongKing, queeningSquare) < distance(weakKing, queeningSquare) - 2 + tempo)
|
|
|
|
&& (distance(strongKing, strongPawn + NORTH) < distance(weakKing, strongPawn + NORTH) - 2 + tempo)
|
|
|
|
&& ( distance(weakKing, strongRook) + tempo >= 3
|
|
|
|
|| ( distance(strongKing, queeningSquare) < distance(weakKing, strongRook) + tempo
|
|
|
|
&& (distance(strongKing, strongPawn + NORTH) < distance(weakKing, strongPawn) + tempo))))
|
2009-02-03 08:08:41 -07:00
|
|
|
return ScaleFactor( SCALE_FACTOR_MAX
|
2020-06-17 15:15:54 -06:00
|
|
|
- 8 * distance(strongPawn, queeningSquare)
|
|
|
|
- 2 * distance(strongKing, queeningSquare));
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2013-12-04 23:18:12 -07:00
|
|
|
// If the pawn is not far advanced and the defending king is somewhere in
|
2009-02-03 08:08:41 -07:00
|
|
|
// the pawn's path, it's probably a draw.
|
2020-06-17 15:15:54 -06:00
|
|
|
if (pawnRank <= RANK_4 && weakKing > strongPawn)
|
2009-02-03 08:08:41 -07:00
|
|
|
{
|
2020-06-17 15:15:54 -06:00
|
|
|
if (file_of(weakKing) == file_of(strongPawn))
|
2009-02-03 08:08:41 -07:00
|
|
|
return ScaleFactor(10);
|
2020-06-17 15:15:54 -06:00
|
|
|
if ( distance<File>(weakKing, strongPawn) == 1
|
|
|
|
&& distance(strongKing, weakKing) > 2)
|
|
|
|
return ScaleFactor(24 - 2 * distance(strongKing, weakKing));
|
2008-12-21 07:38:10 -07:00
|
|
|
}
|
2008-08-31 23:59:13 -06:00
|
|
|
return SCALE_FACTOR_NONE;
|
|
|
|
}
|
|
|
|
|
2013-10-13 14:50:45 -06:00
|
|
|
template<>
|
|
|
|
ScaleFactor Endgame<KRPKB>::operator()(const Position& pos) const {
|
|
|
|
|
2013-10-14 11:34:12 -06:00
|
|
|
assert(verify_material(pos, strongSide, RookValueMg, 1));
|
|
|
|
assert(verify_material(pos, weakSide, BishopValueMg, 0));
|
2013-10-13 14:50:45 -06:00
|
|
|
|
|
|
|
// Test for a rook pawn
|
|
|
|
if (pos.pieces(PAWN) & (FileABB | FileHBB))
|
|
|
|
{
|
2020-06-17 15:15:54 -06:00
|
|
|
Square weakKing = pos.square<KING>(weakSide);
|
|
|
|
Square weakBishop = pos.square<BISHOP>(weakSide);
|
|
|
|
Square strongKing = pos.square<KING>(strongSide);
|
|
|
|
Square strongPawn = pos.square<PAWN>(strongSide);
|
|
|
|
Rank pawnRank = relative_rank(strongSide, strongPawn);
|
2017-12-04 09:52:31 -07:00
|
|
|
Direction push = pawn_push(strongSide);
|
2013-10-13 14:50:45 -06:00
|
|
|
|
|
|
|
// If the pawn is on the 5th rank and the pawn (currently) is on
|
|
|
|
// the same color square as the bishop then there is a chance of
|
|
|
|
// a fortress. Depending on the king position give a moderate
|
|
|
|
// reduction or a stronger one if the defending king is near the
|
|
|
|
// corner but not trapped there.
|
2020-06-17 15:15:54 -06:00
|
|
|
if (pawnRank == RANK_5 && !opposite_colors(weakBishop, strongPawn))
|
2013-10-13 14:50:45 -06:00
|
|
|
{
|
2020-06-17 15:15:54 -06:00
|
|
|
int d = distance(strongPawn + 3 * push, weakKing);
|
2013-10-13 14:50:45 -06:00
|
|
|
|
2020-06-17 15:15:54 -06:00
|
|
|
if (d <= 2 && !(d == 0 && weakKing == strongKing + 2 * push))
|
2013-10-13 14:50:45 -06:00
|
|
|
return ScaleFactor(24);
|
|
|
|
else
|
|
|
|
return ScaleFactor(48);
|
|
|
|
}
|
|
|
|
|
|
|
|
// When the pawn has moved to the 6th rank we can be fairly sure
|
|
|
|
// it's drawn if the bishop attacks the square in front of the
|
|
|
|
// pawn from a reasonable distance and the defending king is near
|
|
|
|
// the corner
|
2020-06-17 15:15:54 -06:00
|
|
|
if ( pawnRank == RANK_6
|
|
|
|
&& distance(strongPawn + 2 * push, weakKing) <= 1
|
|
|
|
&& (attacks_bb<BISHOP>(weakBishop) & (strongPawn + push))
|
|
|
|
&& distance<File>(weakBishop, strongPawn) >= 2)
|
2013-10-13 14:50:45 -06:00
|
|
|
return ScaleFactor(8);
|
|
|
|
}
|
|
|
|
|
|
|
|
return SCALE_FACTOR_NONE;
|
|
|
|
}
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2013-12-04 23:18:12 -07:00
|
|
|
/// KRPP vs KRP. There is just a single rule: if the stronger side has no passed
|
|
|
|
/// pawns and the defending king is actively placed, the position is drawish.
|
2009-02-12 06:59:46 -07:00
|
|
|
template<>
|
2011-12-05 12:58:23 -07:00
|
|
|
ScaleFactor Endgame<KRPPKRP>::operator()(const Position& pos) const {
|
2009-02-03 08:08:41 -07:00
|
|
|
|
2013-10-14 11:34:12 -06:00
|
|
|
assert(verify_material(pos, strongSide, RookValueMg, 2));
|
|
|
|
assert(verify_material(pos, weakSide, RookValueMg, 1));
|
2008-08-31 23:59:13 -06:00
|
|
|
|
Remove piece lists
This patch removes the incrementally updated piece lists from the Position object.
This has been tried before but always failed. My reasons for trying again are:
* 32-bit systems (including phones) are now much less important than they were some years ago (and are absent from fishtest);
* NNUE may have made SF less finely tuned to the order in which moves were generated.
STC:
LLR: 2.94 (-2.94,2.94) {-1.25,0.25}
Total: 55272 W: 5260 L: 5216 D: 44796
Ptnml(0-2): 208, 4147, 18898, 4159, 224
https://tests.stockfishchess.org/tests/view/5fc2986a42a050a89f02c926
LTC:
LLR: 2.96 (-2.94,2.94) {-0.75,0.25}
Total: 16600 W: 673 L: 608 D: 15319
Ptnml(0-2): 14, 533, 7138, 604, 11
https://tests.stockfishchess.org/tests/view/5fc2f98342a050a89f02c95c
closes https://github.com/official-stockfish/Stockfish/pull/3247
Bench: 3940967
2020-11-29 04:05:26 -07:00
|
|
|
Square strongPawn1 = lsb(pos.pieces(strongSide, PAWN));
|
|
|
|
Square strongPawn2 = msb(pos.pieces(strongSide, PAWN));
|
2020-06-17 15:15:54 -06:00
|
|
|
Square weakKing = pos.square<KING>(weakSide);
|
2008-08-31 23:59:13 -06:00
|
|
|
|
|
|
|
// Does the stronger side have a passed pawn?
|
2020-06-17 15:15:54 -06:00
|
|
|
if (pos.pawn_passed(strongSide, strongPawn1) || pos.pawn_passed(strongSide, strongPawn2))
|
2009-02-03 08:08:41 -07:00
|
|
|
return SCALE_FACTOR_NONE;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2020-06-17 15:15:54 -06:00
|
|
|
Rank pawnRank = std::max(relative_rank(strongSide, strongPawn1), relative_rank(strongSide, strongPawn2));
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2020-06-17 15:15:54 -06:00
|
|
|
if ( distance<File>(weakKing, strongPawn1) <= 1
|
|
|
|
&& distance<File>(weakKing, strongPawn2) <= 1
|
|
|
|
&& relative_rank(strongSide, weakKing) > pawnRank)
|
2009-02-03 08:08:41 -07:00
|
|
|
{
|
2020-06-17 15:15:54 -06:00
|
|
|
assert(pawnRank > RANK_1 && pawnRank < RANK_7);
|
|
|
|
return ScaleFactor(7 * pawnRank);
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
return SCALE_FACTOR_NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-06-24 14:19:58 -06:00
|
|
|
/// K and two or more pawns vs K. There is just a single rule here: if all pawns
|
2011-12-10 02:14:25 -07:00
|
|
|
/// are on the same rook file and are blocked by the defending king, it's a draw.
|
2009-02-12 06:59:46 -07:00
|
|
|
template<>
|
2011-12-05 12:58:23 -07:00
|
|
|
ScaleFactor Endgame<KPsK>::operator()(const Position& pos) const {
|
2009-02-03 08:08:41 -07:00
|
|
|
|
2013-10-14 11:34:12 -06:00
|
|
|
assert(pos.non_pawn_material(strongSide) == VALUE_ZERO);
|
|
|
|
assert(pos.count<PAWN>(strongSide) >= 2);
|
|
|
|
assert(verify_material(pos, weakSide, VALUE_ZERO, 0));
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2020-06-17 15:15:54 -06:00
|
|
|
Square weakKing = pos.square<KING>(weakSide);
|
|
|
|
Bitboard strongPawns = pos.pieces(strongSide, PAWN);
|
2013-10-14 17:20:34 -06:00
|
|
|
|
2020-03-14 10:04:50 -06:00
|
|
|
// If all pawns are ahead of the king on a single rook file, it's a draw.
|
2020-07-11 08:25:34 -06:00
|
|
|
if ( !(strongPawns & ~(FileABB | FileHBB))
|
|
|
|
&& !(strongPawns & ~passed_pawn_span(weakSide, weakKing)))
|
2013-10-14 17:20:34 -06:00
|
|
|
return SCALE_FACTOR_DRAW;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2010-07-17 07:00:25 -06:00
|
|
|
return SCALE_FACTOR_NONE;
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-12-04 23:18:12 -07:00
|
|
|
/// KBP vs KB. There are two rules: 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, it's a draw. If the two bishops have opposite color,
|
|
|
|
/// it's almost always a draw.
|
2009-02-12 06:59:46 -07:00
|
|
|
template<>
|
2011-12-05 12:58:23 -07:00
|
|
|
ScaleFactor Endgame<KBPKB>::operator()(const Position& pos) const {
|
2009-02-03 08:08:41 -07:00
|
|
|
|
2013-10-14 11:34:12 -06:00
|
|
|
assert(verify_material(pos, strongSide, BishopValueMg, 1));
|
|
|
|
assert(verify_material(pos, weakSide, BishopValueMg, 0));
|
2013-06-16 03:59:40 -06:00
|
|
|
|
2020-06-17 15:15:54 -06:00
|
|
|
Square strongPawn = pos.square<PAWN>(strongSide);
|
|
|
|
Square strongBishop = pos.square<BISHOP>(strongSide);
|
|
|
|
Square weakBishop = pos.square<BISHOP>(weakSide);
|
|
|
|
Square weakKing = pos.square<KING>(weakSide);
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2009-02-03 08:08:41 -07:00
|
|
|
// Case 1: Defending king blocks the pawn, and cannot be driven away
|
2020-06-17 15:15:54 -06:00
|
|
|
if ( (forward_file_bb(strongSide, strongPawn) & weakKing)
|
|
|
|
&& ( opposite_colors(weakKing, strongBishop)
|
|
|
|
|| relative_rank(strongSide, weakKing) <= RANK_6))
|
2011-12-10 02:14:25 -07:00
|
|
|
return SCALE_FACTOR_DRAW;
|
2009-02-03 08:08:41 -07:00
|
|
|
|
|
|
|
// Case 2: Opposite colored bishops
|
2020-06-17 15:15:54 -06:00
|
|
|
if (opposite_colors(strongBishop, weakBishop))
|
2018-03-31 18:00:57 -06:00
|
|
|
return SCALE_FACTOR_DRAW;
|
2010-07-17 07:00:25 -06:00
|
|
|
|
2008-08-31 23:59:13 -06:00
|
|
|
return SCALE_FACTOR_NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-12-04 23:18:12 -07:00
|
|
|
/// KBPP vs KB. It detects a few basic draws with opposite-colored bishops
|
2009-03-22 06:06:29 -06:00
|
|
|
template<>
|
2011-12-05 12:58:23 -07:00
|
|
|
ScaleFactor Endgame<KBPPKB>::operator()(const Position& pos) const {
|
2009-03-22 06:06:29 -06:00
|
|
|
|
2013-10-14 11:34:12 -06:00
|
|
|
assert(verify_material(pos, strongSide, BishopValueMg, 2));
|
|
|
|
assert(verify_material(pos, weakSide, BishopValueMg, 0));
|
2009-03-22 06:06:29 -06:00
|
|
|
|
2020-06-17 15:15:54 -06:00
|
|
|
Square strongBishop = pos.square<BISHOP>(strongSide);
|
|
|
|
Square weakBishop = pos.square<BISHOP>(weakSide);
|
2009-03-22 06:06:29 -06:00
|
|
|
|
2020-06-17 15:15:54 -06:00
|
|
|
if (!opposite_colors(strongBishop, weakBishop))
|
2009-03-22 06:06:29 -06:00
|
|
|
return SCALE_FACTOR_NONE;
|
|
|
|
|
2020-06-17 15:15:54 -06:00
|
|
|
Square weakKing = pos.square<KING>(weakSide);
|
Remove piece lists
This patch removes the incrementally updated piece lists from the Position object.
This has been tried before but always failed. My reasons for trying again are:
* 32-bit systems (including phones) are now much less important than they were some years ago (and are absent from fishtest);
* NNUE may have made SF less finely tuned to the order in which moves were generated.
STC:
LLR: 2.94 (-2.94,2.94) {-1.25,0.25}
Total: 55272 W: 5260 L: 5216 D: 44796
Ptnml(0-2): 208, 4147, 18898, 4159, 224
https://tests.stockfishchess.org/tests/view/5fc2986a42a050a89f02c926
LTC:
LLR: 2.96 (-2.94,2.94) {-0.75,0.25}
Total: 16600 W: 673 L: 608 D: 15319
Ptnml(0-2): 14, 533, 7138, 604, 11
https://tests.stockfishchess.org/tests/view/5fc2f98342a050a89f02c95c
closes https://github.com/official-stockfish/Stockfish/pull/3247
Bench: 3940967
2020-11-29 04:05:26 -07:00
|
|
|
Square strongPawn1 = lsb(pos.pieces(strongSide, PAWN));
|
|
|
|
Square strongPawn2 = msb(pos.pieces(strongSide, PAWN));
|
2009-03-22 06:06:29 -06:00
|
|
|
Square blockSq1, blockSq2;
|
|
|
|
|
2020-06-17 15:15:54 -06:00
|
|
|
if (relative_rank(strongSide, strongPawn1) > relative_rank(strongSide, strongPawn2))
|
2009-03-22 06:06:29 -06:00
|
|
|
{
|
2020-06-17 15:15:54 -06:00
|
|
|
blockSq1 = strongPawn1 + pawn_push(strongSide);
|
|
|
|
blockSq2 = make_square(file_of(strongPawn2), rank_of(strongPawn1));
|
2009-03-22 06:06:29 -06:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2020-06-17 15:15:54 -06:00
|
|
|
blockSq1 = strongPawn2 + pawn_push(strongSide);
|
|
|
|
blockSq2 = make_square(file_of(strongPawn1), rank_of(strongPawn2));
|
2009-03-22 06:06:29 -06:00
|
|
|
}
|
|
|
|
|
2020-06-17 15:15:54 -06:00
|
|
|
switch (distance<File>(strongPawn1, strongPawn2))
|
2009-03-22 06:06:29 -06:00
|
|
|
{
|
|
|
|
case 0:
|
2013-12-02 11:04:09 -07:00
|
|
|
// Both pawns are on the same file. It's an easy draw if the defender firmly
|
|
|
|
// controls some square in the frontmost pawn's path.
|
2020-06-17 15:15:54 -06:00
|
|
|
if ( file_of(weakKing) == file_of(blockSq1)
|
|
|
|
&& relative_rank(strongSide, weakKing) >= relative_rank(strongSide, blockSq1)
|
|
|
|
&& opposite_colors(weakKing, strongBishop))
|
2011-12-10 02:14:25 -07:00
|
|
|
return SCALE_FACTOR_DRAW;
|
2009-03-22 06:06:29 -06:00
|
|
|
else
|
|
|
|
return SCALE_FACTOR_NONE;
|
|
|
|
|
|
|
|
case 1:
|
2013-12-02 11:04:09 -07:00
|
|
|
// Pawns on adjacent files. It's a draw if the defender firmly controls the
|
|
|
|
// square in front of the frontmost pawn's path, and the square diagonally
|
|
|
|
// behind this square on the file of the other pawn.
|
2020-06-17 15:15:54 -06:00
|
|
|
if ( weakKing == blockSq1
|
|
|
|
&& opposite_colors(weakKing, strongBishop)
|
|
|
|
&& ( weakBishop == blockSq2
|
2020-05-28 09:48:31 -06:00
|
|
|
|| (attacks_bb<BISHOP>(blockSq2, pos.pieces()) & pos.pieces(weakSide, BISHOP))
|
2020-06-17 15:15:54 -06:00
|
|
|
|| distance<Rank>(strongPawn1, strongPawn2) >= 2))
|
2011-12-10 02:14:25 -07:00
|
|
|
return SCALE_FACTOR_DRAW;
|
2010-07-17 07:00:25 -06:00
|
|
|
|
2020-06-17 15:15:54 -06:00
|
|
|
else if ( weakKing == blockSq2
|
|
|
|
&& opposite_colors(weakKing, strongBishop)
|
|
|
|
&& ( weakBishop == blockSq1
|
2020-05-28 09:48:31 -06:00
|
|
|
|| (attacks_bb<BISHOP>(blockSq1, pos.pieces()) & pos.pieces(weakSide, BISHOP))))
|
2011-12-10 02:14:25 -07:00
|
|
|
return SCALE_FACTOR_DRAW;
|
2009-03-22 06:06:29 -06:00
|
|
|
else
|
|
|
|
return SCALE_FACTOR_NONE;
|
|
|
|
|
|
|
|
default:
|
|
|
|
// The pawns are not on the same file or adjacent files. No scaling.
|
|
|
|
return SCALE_FACTOR_NONE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-06-24 14:19:58 -06:00
|
|
|
/// KBP vs KN. There is a single rule: if the defending king is somewhere along
|
2013-12-04 23:18:12 -07:00
|
|
|
/// the path of the pawn, and the square of the king is not of the same color as
|
|
|
|
/// the stronger side's bishop, it's a draw.
|
2009-02-12 06:59:46 -07:00
|
|
|
template<>
|
2011-12-05 12:58:23 -07:00
|
|
|
ScaleFactor Endgame<KBPKN>::operator()(const Position& pos) const {
|
2009-02-03 08:08:41 -07:00
|
|
|
|
2013-10-14 11:34:12 -06:00
|
|
|
assert(verify_material(pos, strongSide, BishopValueMg, 1));
|
|
|
|
assert(verify_material(pos, weakSide, KnightValueMg, 0));
|
2013-06-16 03:59:40 -06:00
|
|
|
|
2020-06-17 15:15:54 -06:00
|
|
|
Square strongPawn = pos.square<PAWN>(strongSide);
|
|
|
|
Square strongBishop = pos.square<BISHOP>(strongSide);
|
|
|
|
Square weakKing = pos.square<KING>(weakSide);
|
2009-01-07 06:26:58 -07:00
|
|
|
|
2020-06-17 15:15:54 -06:00
|
|
|
if ( file_of(weakKing) == file_of(strongPawn)
|
|
|
|
&& relative_rank(strongSide, strongPawn) < relative_rank(strongSide, weakKing)
|
|
|
|
&& ( opposite_colors(weakKing, strongBishop)
|
|
|
|
|| relative_rank(strongSide, weakKing) <= RANK_6))
|
2011-12-10 02:14:25 -07:00
|
|
|
return SCALE_FACTOR_DRAW;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
|
|
|
return SCALE_FACTOR_NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-12-04 23:18:12 -07:00
|
|
|
/// KP vs KP. This is done by removing the weakest side's pawn and probing the
|
2020-06-24 14:19:58 -06:00
|
|
|
/// KP vs K bitbase: if the weakest side has a draw without the pawn, it probably
|
2013-12-04 23:18:12 -07:00
|
|
|
/// has at least a draw with 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 (e.g. 8/4k3/3p4/3P4/6K1/8/8/8 w - - 0 1).
|
2009-02-12 06:59:46 -07:00
|
|
|
template<>
|
2011-12-05 12:58:23 -07:00
|
|
|
ScaleFactor Endgame<KPKP>::operator()(const Position& pos) const {
|
2009-02-03 08:08:41 -07:00
|
|
|
|
2013-10-14 11:34:12 -06:00
|
|
|
assert(verify_material(pos, strongSide, VALUE_ZERO, 1));
|
|
|
|
assert(verify_material(pos, weakSide, VALUE_ZERO, 1));
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2013-10-22 16:03:45 -06:00
|
|
|
// Assume strongSide is white and the pawn is on files A-D
|
2020-06-17 15:15:54 -06:00
|
|
|
Square strongKing = normalize(pos, strongSide, pos.square<KING>(strongSide));
|
|
|
|
Square weakKing = normalize(pos, strongSide, pos.square<KING>(weakSide));
|
|
|
|
Square strongPawn = normalize(pos, strongSide, pos.square<PAWN>(strongSide));
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2013-10-22 16:03:45 -06:00
|
|
|
Color us = strongSide == pos.side_to_move() ? WHITE : BLACK;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
|
|
|
// If the pawn has advanced to the fifth rank or further, and is not a
|
|
|
|
// rook pawn, it's too dangerous to assume that it's at least a draw.
|
2020-06-17 15:15:54 -06:00
|
|
|
if (rank_of(strongPawn) >= RANK_5 && file_of(strongPawn) != FILE_A)
|
2009-02-03 08:08:41 -07:00
|
|
|
return SCALE_FACTOR_NONE;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2011-12-10 02:14:25 -07:00
|
|
|
// Probe the KPK bitbase with the weakest side's pawn removed. If it's a draw,
|
|
|
|
// it's probably at least a draw even with the pawn.
|
2020-06-17 15:15:54 -06:00
|
|
|
return Bitbases::probe(strongKing, strongPawn, weakKing, us) ? SCALE_FACTOR_NONE : SCALE_FACTOR_DRAW;
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
2021-02-26 02:02:13 -07:00
|
|
|
|
|
|
|
} // namespace Stockfish
|