//////////////////////////////////////////////////////////////////////
//
// FILE: recog.cpp
// Endgame knowledge recognition methods
//
// Part of: Scid (Shane's Chess Information Database)
// Version: 3.5
//
// Notice: Copyright (c) 2002-2003 Shane Hudson. All rights reserved.
//
// Author: Shane Hudson (sgh@users.sourceforge.net)
//
//////////////////////////////////////////////////////////////////////
#include "engine.h"
#include "recog.h"
#include "sqmove.h"
// The Recognizer class provides score bound information for chess
// endgames.
namespace Recognizer {
static int KPK(Position* pos);
static int KBBK(Position* pos);
static int KBNK(Position* pos);
static int KBPK(Position* pos);
static int KRKB(Position* pos);
static int KRKN(Position* pos);
static int KMKP(Position* pos);
static int KQKP(Position* pos);
static int KRKP(Position* pos);
static int KRPKR(Position* pos);
} // namespace Recognizer
static const int DRAW = recogValue (SCORE_EXACT, 0);
static const int UNKNOWN = recogValue (SCORE_NONE, 0);
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Recognizer::Recognize
// Checks the current position for a recognized endgame.
// Returns a recognition value, which contains a regular score
// for the position and a score flag indicating if the score
// is exact, an upper bound, a lower bound, or useless.
int
Recognizer::Recognize (Position * pos)
{
uint npieces = pos->TotalMaterial();
const byte* material = pos->GetMaterial();
if (npieces > 6) { return UNKNOWN; }
// TODO: Speed up this code which selects the appropriate recognizer.
// TODO: We should maintain a material signature (or hash code) in
// TODO: the position and then we could use a small lookup table here
// TODO: find the appropriate recognizer quickly.
if (npieces == 3) {
if (material[WB] == 1 || material[BB] == 1) { return DRAW; }
if (material[WN] == 1 || material[BN] == 1) { return DRAW; }
if (material[WP] == 1 || material[BP] == 1) { return KPK(pos); }
return UNKNOWN;
}
if (npieces == 5) {
// KRP-KR:
if (material[WR] == 1 && material[WP] == 1 && material[BR] == 1) {
return KRPKR(pos);
}
if (material[BR] == 1 && material[BP] == 1 && material[WR] == 1) {
return KRPKR(pos);
}
// Bishop and 2 pawns on same rook file with bishop of wrong color:
if (material[WB] == 1 && material[WP] == 2) { return KBPK(pos); }
if (material[BB] == 1 && material[BP] == 2) { return KBPK(pos); }
return UNKNOWN;
}
if (npieces == 6) {
// Bishop and 3 pawns on same rook file with bishop of wrong color:
if (material[WB] == 1 && material[WP] == 3) { return KBPK(pos); }
if (material[BB] == 1 && material[BP] == 3) { return KBPK(pos); }
return UNKNOWN;
}
if (npieces <= 2) { return DRAW; } // Lone kings.
// If we get here, there are four pieces (including kings and pawns)
ASSERT (npieces == 4);
// Positions with pawns:
if (material[WP] == 1) {
if (material[BQ] == 1) { return KQKP(pos); }
if (material[BR] == 1) { return KRKP(pos); }
if (material[BB] == 1 || material[BN] == 1) { return KMKP(pos); }
if (material[WB] == 1) { return KBPK(pos); }
return UNKNOWN;
}
if (material[BP] == 1) {
if (material[WQ] == 1) { return KQKP(pos); }
if (material[WR] == 1) { return KRKP(pos); }
if (material[WB] == 1 || material[WN] == 1) { return KMKP(pos); }
if (material[BB] == 1) { return KBPK(pos); }
return UNKNOWN;
}
if (material[WB] == 2 || material[BB] == 2) { return KBBK(pos); }
if (material[WB] == 1 && material[WN] == 1) { return KBNK(pos); }
if (material[BB] == 1 && material[BN] == 1) { return KBNK(pos); }
if (material[WR] == 1 && material[BB] == 1) { return KRKB(pos); }
if (material[BR] == 1 && material[WB] == 1) { return KRKB(pos); }
if (material[WR] == 1 && material[BN] == 1) { return KRKN(pos); }
if (material[BR] == 1 && material[WN] == 1) { return KRKN(pos); }
// KBKB, KBKN, KNKN and KNNK are all draws, but may have a
// trivial mate-in-one if the non-side-to-move king is in a corner:
if (material[WN] == 2 || material[BN] == 2
|| (material[WB] == 1 && material[BB] == 1)
|| (material[WB] == 1 && material[BN] == 1)
|| (material[WN] == 1 && material[BB] == 1)
|| (material[WN] == 1 && material[BN] == 1)) {
squareT wk = pos->GetKingSquare(WHITE);
squareT bk = pos->GetKingSquare(BLACK);
colorT stm = pos->GetToMove();
if (stm == WHITE && square_IsCornerSquare(bk)) { return UNKNOWN; }
if (stm == BLACK && square_IsCornerSquare(wk)) { return UNKNOWN; }
return DRAW;
}
return UNKNOWN;
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Recognizer::KPK
// Returns a recognition score for King and one Pawn vs King.
int
Recognizer::KPK (Position * pos)
{
const byte* material = pos->GetMaterial();
squareT wk, bk, wp;
colorT stm = pos->GetToMove();
// Find piece squares with White having the pawn:
if (material[WP] == 1) {
wk = pos->GetKingSquare(WHITE);
bk = pos->GetKingSquare(BLACK);
squareT * sqlist = pos->GetList(WHITE);
wp = sqlist[1];
} else {
ASSERT (material[BP] == 1);
wk = square_FlipRank(pos->GetKingSquare(BLACK));
bk = square_FlipRank(pos->GetKingSquare(WHITE));
squareT * sqlist = pos->GetList(BLACK);
wp = square_FlipRank(sqlist[1]);
stm = color_Flip(stm);
}
// Find pawn, king and enemy king rank and file values:
rankT wpRank = square_Rank(wp); fyleT wpFyle = square_Fyle(wp);
rankT wkRank = square_Rank(wk); rankT wkFyle = square_Fyle(wk);
rankT bkRank = square_Rank(bk); rankT bkFyle = square_Fyle(bk);
// Find value to use if it is a win:
int winScore = 500 + 5 * wpRank;
int winValue = recogValue (SCORE_LOWER, winScore);
int lossValue = recogValue (SCORE_UPPER, -winScore);
// If the enemy king is behind or equal to the pawn rank: win or unknown
if (bkRank <= wpRank) {
if ((stm == WHITE && wpRank > bkRank)
|| (stm == BLACK && wpRank > bkRank + 1)) {
// Runaway pawn wins:
return (stm == WHITE) ? winValue : lossValue;
}
// Cannot easily determine the result of this position:
return UNKNOWN;
}
// Black king is clearly the closest king to the pawn: draw
uint wdist = square_Distance (wk, wp);
uint bdist = square_Distance (bk, wp);
if (stm == WHITE) { bdist++; }
if (bdist + 1 < wdist && bdist + wpRank <= RANK_8 + 1) { return DRAW; }
// Black king in front of a rook pawn: safe draw.
if ((wpFyle == A_FYLE || wpFyle == H_FYLE) && wpFyle == bkFyle) {
return DRAW;
}
// King the two squares in front of any pawn before the 6th rank: draw
if (wpRank < RANK_6 && wpFyle == bkFyle
&& (wpRank + 1 == bkRank || wpRank + 2 == bkRank)) {
return DRAW;
}
// Pawn on 6th rank, enemy king blocking it on 7th: draw
if (wpRank == RANK_6 && wpFyle == bkFyle && wpRank + 1 == bkRank) {
return DRAW;
}
// White king two ranks in front of the pawn, on the same file or an
// adjacent file: win
if (wpRank + 2 == wkRank && wpFyle != A_FYLE && wpFyle != H_FYLE && wdist < bdist) {
int fileDiff = (int)wpFyle - (int)wkFyle;
if (fileDiff >= -1 && fileDiff <= 1) {
return (stm == WHITE) ? winValue : lossValue;
}
}
// Pawn-King-space-EnemyKing formation, draw if pawn is before 5th rank
// and side with the pawn is to move; otherwise a win.
if (wpFyle == wkFyle && wpFyle == bkFyle
&& wpRank+1 == wkRank && wpRank+3 == bkRank) {
if (wpRank < RANK_5 && stm == WHITE) {
return DRAW;
}
return (stm == WHITE) ? winValue : lossValue;
}
// No key KPK position was found:
return UNKNOWN;
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Recognizer::KBBK
// Returns a recognition score for King and two Bishops vs King.
int
Recognizer::KBBK (Position * pos)
{
const byte* material = pos->GetMaterial();
squareT wk, bk, wb1, wb2;
colorT stm = pos->GetToMove();
// Set up piece squares so that White has the bishops:
if (material[WB] == 2) {
wk = pos->GetKingSquare(WHITE);
bk = pos->GetKingSquare(BLACK);
squareT * sqlist = pos->GetList(WHITE);
wb1 = sqlist[1];
wb2 = sqlist[2];
} else {
ASSERT (material[BB] == 2);
wk = square_FlipRank(pos->GetKingSquare(BLACK));
bk = square_FlipRank(pos->GetKingSquare(WHITE));
squareT * sqlist = pos->GetList(BLACK);
wb1 = square_FlipRank(sqlist[1]);
wb2 = square_FlipRank(sqlist[2]);
stm = color_Flip(stm);
}
// If the bishops are of the same square color, it is a draw:
if (square_Color(wb1) == square_Color(wb2)) { return DRAW; }
// If the lone king is to move and is next to a bishop, or on the
// edge of the board with the enemy king nearby, it may be a draw
// by capturing a bishop or by stalemate:
if (stm == BLACK) {
if (square_Adjacent (bk, wb1)) { return UNKNOWN; }
if (square_Adjacent (bk, wb2)) { return UNKNOWN; }
if (square_IsEdgeSquare(bk) && square_Distance(wk, bk) == 2) {
return UNKNOWN;
}
}
// Compute the lone king distances used for scoring:
int bkCorner = square_Distance (bk, square_NearestCorner (bk));
int kingDist = square_Distance (bk, wk);
// Return a suitable winning score:
int score = 900 + (25 * bkCorner) - (10 * kingDist);
int winValue = recogValue (SCORE_LOWER, score);
int lossValue = recogValue (SCORE_UPPER, -score);
return (stm == WHITE) ? winValue : lossValue;
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Recognizer::KBNK
// Returns a recognition score for King, Bishop and Knight vs King.
int
Recognizer::KBNK (Position * pos)
{
const byte* material = pos->GetMaterial();
const pieceT* board = pos->GetBoard();
squareT wk, bk, wb, wn;
colorT stm = pos->GetToMove();
// Set up piece squares so that White has the bishop and knight:
if (material[WB] == 1) {
wk = pos->GetKingSquare(WHITE);
bk = pos->GetKingSquare(BLACK);
squareT * sqlist = pos->GetList(WHITE);
wb = sqlist[1];
wn = sqlist[2];
if (board[wb] != WB) { squareT temp = wb; wb = wn; wn = temp; }
} else {
ASSERT (material[BB] == 1 && material[BN] == 1);
wk = square_FlipRank(pos->GetKingSquare(BLACK));
bk = square_FlipRank(pos->GetKingSquare(WHITE));
squareT * sqlist = pos->GetList(BLACK);
wb = sqlist[1];
wn = sqlist[2];
if (board[wb] != BB) { squareT temp = wb; wb = wn; wn = temp; }
wb = square_FlipRank(wb);
wn = square_FlipRank(wn);
stm = color_Flip(stm);
}
// If the lone king attacks a piece, the result is unclear:
if (square_Adjacent (wb, bk) || square_Adjacent (wn, bk)) {
return UNKNOWN;
}
// If the lone king is to move and possible stalemate, unclear result:
if (stm == BLACK && square_IsEdgeSquare(bk)) {
return UNKNOWN;
}
// If the knight is near a corner, it could be trapped, unclear result:
if ((square_Distance (wn, A1) < 2 || square_Distance (wn, A8) < 2 ||
square_Distance (wn, H1) < 2 || square_Distance (wn, H8) < 2)
&& square_Distance (bk, wn) < 4) {
return UNKNOWN;
}
// If the lone king can fork the bishop and knight, unclear result:
if (stm == BLACK && square_Distance(wb, wn) < 3
&& square_Distance (bk, wb) < 3 && square_Distance (bk, wn) < 3
&& square_Distance (wk, wb) > 1 && square_Distance (wk, wn) > 1 ) {
return UNKNOWN;
}
// Find lone king distance from the appropriate corner
squareT corner1 = A1; squareT corner2 = H8;
if (square_Color(wb) == WHITE) { corner1 = H1; corner2 = A8; }
int cornerDist = square_Distance (bk, corner1);
int cornerDist2 = square_Distance (bk, corner2);
if (cornerDist2 < cornerDist) { cornerDist = cornerDist2; }
int kingDist = square_Distance (wk, bk);
// Return an appropriate winning or losing score:
int winScore = 700 - 25 * cornerDist - 10 * kingDist;
int winValue = recogValue (SCORE_LOWER, winScore);
int lossValue = recogValue (SCORE_UPPER, -winScore);
return (stm == WHITE) ? winValue : lossValue;
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Recognizer::KBPK
// Returns a recognition score for King, Bishop and Pawn(s) vs King.
// Recognizes draws with wrong-color bishop for rook pawn(s).
int
Recognizer::KBPK (Position * pos)
{
const byte* material = pos->GetMaterial();
squareT /* wk, */ bk;
fyleT wrongFile = A_FYLE; // Wrong-color bishop rook-pawn file.
// Set up piece squares so that White has the bishop and pawn(s),
// and make sure all pawns are on the wrong rook-pawn file:
if (material[WB] == 1) {
// wk = pos->GetKingSquare(WHITE);
bk = pos->GetKingSquare(BLACK);
if (pos->SquareColorCount(WB,WHITE) == 1) { wrongFile = H_FYLE; }
if (pos->FyleCount(WP, wrongFile) != material[WP]) { return UNKNOWN; }
} else {
ASSERT (material[BB] == 1);
// wk = square_FlipRank(pos->GetKingSquare(BLACK));
bk = square_FlipRank(pos->GetKingSquare(WHITE));
if (pos->SquareColorCount(BB,BLACK) == 1) { wrongFile = H_FYLE; }
if (pos->FyleCount(BP, wrongFile) != material[BP]) { return UNKNOWN; }
}
// OK, we have it set up so white has the bishop and pawns, and we
// know all pawns are on the wrong rook-pawn file. So recognise a
// draw if the black king controls the queening square:
squareT promoSq = square_Make (wrongFile, RANK_8);
if (bk == promoSq || square_Adjacent (bk, promoSq)) { return DRAW; }
// The black king does not control the queening square, so no draw yet:
return UNKNOWN;
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Recognizer::KRKB
// Returns a recognition score for King and Rook vs King and Bishop.
// Contains simple rules covering many drawn positions, which were
// checked using tablebases.
int
Recognizer::KRKB (Position * pos)
{
const byte* material = pos->GetMaterial();
squareT wk, bk, wr, bb;
colorT stm = pos->GetToMove();
// Find piece squares with White having the rook:
wk = pos->GetKingSquare(WHITE);
bk = pos->GetKingSquare(BLACK);
squareT * sqlist = pos->GetList(WHITE);
wr = sqlist[1];
sqlist = pos->GetList(BLACK);
bb = sqlist[1];
if (material[WB] == 1) {
squareT t = wk; wk = square_FlipRank(bk); bk = square_FlipRank(t);
t = wr; wr = square_FlipRank(bb); bb = square_FlipRank(t);
stm = color_Flip(stm);
}
// Flip board so the black king is in the 10-square a1-d1-d4 triangle:
if (square_Rank(bk) >= RANK_5) {
wk = square_FlipRank(wk); wr = square_FlipRank(wr);
bk = square_FlipRank(bk); bb = square_FlipRank(bb);
}
if (square_Fyle(bk) >= E_FYLE) {
wk = square_FlipFyle(wk); wr = square_FlipFyle(wr);
bk = square_FlipFyle(bk); bb = square_FlipFyle(bb);
}
if (bk == A2 || bk == A3 || bk == A4 || bk == B3 || bk == B4 || bk == C4) {
wk = square_FlipDiag(wk); wr = square_FlipDiag(wr);
bk = square_FlipDiag(bk); bb = square_FlipDiag(bb);
}
int kingsDist = square_Distance(wk, bk);
if (stm == WHITE) {
// Black king on c2/c3/d3/d4, black bishop adjacent,
// white king more than 2 squares away: draw.
if (kingsDist > 2 && square_Adjacent(bk,bb)
&& (bk == C2 || bk == C3 || bk == D3 || bk == D4)) {
return DRAW;
}
} else {
// Black king anywhere but a1 or b1, black bishop adjacent,
// white king more than 2 squares away: draw.
if (kingsDist > 2 && square_Adjacent(bk,bb)
&& bk != A1 && bk != B1) {
return DRAW;
}
// Black king not on edge or b2, not sharing a rank or file with
// the white rook; white king more than 2 squares away: draw.
if (kingsDist > 2 && !square_IsEdgeSquare(bk) && bk != B2
&& square_Rank(bk) != square_Rank(wr)
&& square_Fyle(bk) != square_Fyle(wr)) {
return DRAW;
}
}
return UNKNOWN;
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Recognizer::KRKN
// Returns a recognition score for King and Rook vs King and Knight.
// Contains simple rules covering many drawn positions, which were
// checked using tablebases.
int
Recognizer::KRKN (Position * pos)
{
const byte* material = pos->GetMaterial();
squareT wk, bk, wr, bn;
colorT stm = pos->GetToMove();
// Find piece squares with White having the rook:
wk = pos->GetKingSquare(WHITE);
bk = pos->GetKingSquare(BLACK);
squareT * sqlist = pos->GetList(WHITE);
wr = sqlist[1];
sqlist = pos->GetList(BLACK);
bn = sqlist[1];
if (material[WN] == 1) {
squareT t = wk; wk = square_FlipRank(bk); bk = square_FlipRank(t);
t = wr; wr = square_FlipRank(bn); bn = square_FlipRank(t);
stm = color_Flip(stm);
}
// Flip board so the black king is in the 10-square a1-d1-d4 triangle:
if (square_Rank(bk) >= RANK_5) {
wk = square_FlipRank(wk); wr = square_FlipRank(wr);
bk = square_FlipRank(bk); bn = square_FlipRank(bn);
}
if (square_Fyle(bk) >= E_FYLE) {
wk = square_FlipFyle(wk); wr = square_FlipFyle(wr);
bk = square_FlipFyle(bk); bn = square_FlipFyle(bn);
}
if (bk == A2 || bk == A3 || bk == A4 || bk == B3 || bk == B4 || bk == C4) {
wk = square_FlipDiag(wk); wr = square_FlipDiag(wr);
bk = square_FlipDiag(bk); bn = square_FlipDiag(bn);
}
int kingsDist = square_Distance(wk, bk);
if (stm == WHITE) {
// Black king not on edge or b2, adjacent to black knight,
// not sharing a rank or file with the white rook; white king
// more than 2 squares away: draw.
if (kingsDist > 2 && !square_IsEdgeSquare(bk) && bk != B2
&& square_Adjacent (bk, bn)
&& square_Rank(bk) != square_Rank(wr)
&& square_Fyle(bk) != square_Fyle(wr)) {
return DRAW;
}
} else {
// Black king anywhere but a1 or b1, adjacent to the knight,
// white king more than 2 squares away: draw.
if (bk != A1 && bk != B1 && kingsDist > 2
&& square_Adjacent (bk, bn)) {
return DRAW;
}
// Black king not on edge or b2, adjacent to black knight,
// not sharing a rank/file with the white rook: draw.
if (!square_IsEdgeSquare(bk) && bk != B2
&& square_Adjacent (bk, bn)
&& square_Rank(bk) != square_Rank(wr)
&& square_Fyle(bk) != square_Fyle(wr)) {
return DRAW;
}
// Black king anywhere but a1/b1/c1/b2, adjacent to the black
// knight, not sharing a rank/file with the rook; white king
// not adjacent to the knight: draw.
if (bk != A1 && bk != B1 && bk != C1 && bk != B2
&& !square_Adjacent(wk,bn) && square_Adjacent(bk,bn)
&& square_Rank(bk) != square_Rank(wr)
&& square_Fyle(bk) != square_Fyle(wr)) {
return DRAW;
}
}
return UNKNOWN;
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Recognizer::KMKP
// Returns a recognition score for King and Minor Piece vs King and Pawn.
int
Recognizer::KMKP (Position * pos)
{
const byte* material = pos->GetMaterial();
squareT wk, bk, wm, bp;
colorT stm = pos->GetToMove();
// Find piece squares with White having the minor piece:
wk = pos->GetKingSquare(WHITE);
bk = pos->GetKingSquare(BLACK);
squareT * sqlist = pos->GetList(WHITE);
wm = sqlist[1];
sqlist = pos->GetList(BLACK);
bp = sqlist[1];
if (material[WP] == 1) {
squareT t = wk; wk = square_FlipRank(bk); bk = square_FlipRank(t);
t = wm; wm = square_FlipRank(bp); bp = square_FlipRank(t);
stm = color_Flip(stm);
}
// Black (the side with the pawn) can only lose to trivial mates
// in a corner trapped by the pawn:
if (stm == WHITE && square_IsCornerSquare(bk)
&& square_Adjacent(bk, bp) && square_Distance(bk, wk) == 2) {
return UNKNOWN;
}
// Black has at least a draw:
return recogValue ((stm == BLACK) ? SCORE_LOWER : SCORE_UPPER, 0);
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Recognizer::KQKP
// Returns a recognition score for King and Queen vs King and Pawn.
// Contains rules for many draws with Queen vs a2 or c2 pawn,
// checked using tablebases.
int
Recognizer::KQKP (Position * pos)
{
const byte* material = pos->GetMaterial();
squareT wk, bk, wq, bp;
colorT stm = pos->GetToMove();
// Find piece squares with White having the queen:
wk = pos->GetKingSquare(WHITE);
bk = pos->GetKingSquare(BLACK);
squareT * sqlist = pos->GetList(WHITE);
wq = sqlist[1];
sqlist = pos->GetList(BLACK);
bp = sqlist[1];
if (material[WQ] != 1) {
squareT t = wk; wk = square_FlipRank(bk); bk = square_FlipRank(t);
t = wq; wq = square_FlipRank(bp); bp = square_FlipRank(t);
stm = color_Flip(stm);
}
// There are only recognizable draws with a pawn on its 7th rank,
// defended by its king:
if (square_Rank(bp) != RANK_2 || ! square_Adjacent (bk, bp)) {
return UNKNOWN;
}
// Make sure the pawn is on the queenside:
if (square_Fyle(bp) >= E_FYLE) {
wk = square_FlipFyle(wk); wq = square_FlipFyle(wq);
bk = square_FlipFyle(bk); bp = square_FlipFyle(bp);
}
// Lists of squares for each (black king, black pawn) pair listing
// the white king squares for which white to move only draws
// regardless of where the white queen is:
static const squareT drawSquares_None [] = { NULL_SQUARE };
static const squareT drawSquares_BPa2_BKb1 [] = {
G1,H1,F2,G2,H2,G3,H3,F4,G4,H4,E5,F5,G5,H5,
A6,C6,D6,E6,F6,G6,H6,A7,B7,C7,D7,E7,F7,G7,H7,
A8,B8,C8,D8,E8,F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPa2_BKb2 [] = {
F1,G1,H1,G2,H2,F3,G3,H3,F4,G4,H4,F5,G5,H5,
A6,C6,D6,E6,F6,G6,H6,A7,B7,C7,D7,E7,F7,G7,H7,
A8,B8,C8,D8,E8,F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPc2_BKc1 [] = {
H6,A7,B7,C7,D7,E7,F7,G7,H7,
A8,B8,C8,D8,E8,F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPc2_BKd1 [] = {
F6,G6,H6,A7,B7,C7,D7,E7,F7,G7,H7,
A8,B8,C8,D8,E8,F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPc2_BKd2 [] = {
F6,G6,H6,A7,B7,C7,D7,E7,F7,G7,H7,
A8,B8,C8,D8,E8,F8,G8,H8, NULL_SQUARE
};
const squareT * drawSquares = drawSquares_None;
if (bp == A2) {
if (bk == B1) { drawSquares = drawSquares_BPa2_BKb1; }
if (bk == B2) { drawSquares = drawSquares_BPa2_BKb2; }
} else if (bp == C2) {
if (bk == C1) { drawSquares = drawSquares_BPc2_BKc1; }
if (bk == D1) { drawSquares = drawSquares_BPc2_BKd1; }
if (bk == D2) { drawSquares = drawSquares_BPc2_BKd2; }
}
// Scan the list of drawn squares for the white king square:
while (*drawSquares != NULL_SQUARE) {
if (wk == *drawSquares) { return DRAW; }
drawSquares++;
}
return UNKNOWN;
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Recognizer::KRKP
// Returns a recognition score for King and Rook vs King and Pawn.
// Contains rules for many draws, checked using tablebases.
int
Recognizer::KRKP (Position * pos)
{
const byte* material = pos->GetMaterial();
squareT wk, bk, wr, bp;
colorT stm = pos->GetToMove();
// Find piece squares with White having the rook:
wk = pos->GetKingSquare(WHITE);
bk = pos->GetKingSquare(BLACK);
squareT * sqlist = pos->GetList(WHITE);
wr = sqlist[1];
sqlist = pos->GetList(BLACK);
bp = sqlist[1];
if (material[WR] != 1) {
squareT t = wk; wk = square_FlipRank(bk); bk = square_FlipRank(t);
t = wr; wr = square_FlipRank(bp); bp = square_FlipRank(t);
stm = color_Flip(stm);
}
// There are only recognized draws when the pawn is defended by its king:
if (! square_Adjacent (bk, bp)) {
return UNKNOWN;
}
// Make sure the pawn is on the queenside:
if (square_Fyle(bp) >= E_FYLE) {
wk = square_FlipFyle(wk); wr = square_FlipFyle(wr);
bk = square_FlipFyle(bk); bp = square_FlipFyle(bp);
}
// Lists of squares for each (black king, black pawn) pair listing
// the white king squares for which white to move only draws
// regardless of where the white rook is:
static const squareT drawSquares_None [] = { NULL_SQUARE };
static const squareT drawSquares_BPa2_BKb2 [] = {
D1,D2,D3,C4, NULL_SQUARE
};
static const squareT drawSquares_BPa2_BKb3 [] = {
E1,F1,G1,H1,D4,E4,F4,G4,H4,A5,B5,C5,D5,E5,F5,G5,H5,A6,B6,C6,
D6,E6,F6,G6,H6,A7,B7, NULL_SQUARE
};
static const squareT drawSquares_BPa3_BKb2 [] = {
E1,F1,G1,H1,E2,F2,G2,H2,D3,E3,F3,G3,H3,D4,E4,F4,G4,H4,D5,E5,
F5,G5,H5,A6,B6,C6,D6,E6,F6,G6,H6,A7,B7,C7,D7,E7,F7,G7,H7,A8,
B8,C8,D8,E8,F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPa3_BKb3 [] = {
F1,G1,H1,F2,G2,H2,F3,G3,H3,D4,E4,F4,G4,H4,D5,E5,F5,G5,H5,A6,
B6,C6,D6,E6,F6,G6,H6,A7,B7,C7,D7,E7,F7,G7,H7,A8,B8,C8,D8,E8,
F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPa3_BKb4 [] = {
G1,H1,G2,H2,G3,H3,G4,H4,D5,E5,F5,G5,H5,A6,B6,C6,D6,E6,F6,G6,
H6,A7,B7,C7,D7,E7,F7,G7,H7,A8,B8,C8,D8,E8,F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPa4_BKa3 [] = {
H1,H2,H3,H4,H5,H6,H7,H8, NULL_SQUARE
};
static const squareT drawSquares_BPa4_BKa5 [] = {
A7,A8,B8,C8,D8,E8,F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPa4_BKb3 [] = {
G1,H1,G2,H2,G3,H3,G4,H4,E5,F5,G5,H5,E6,F6,G6,H6,A7,B7,C7,D7,
E7,F7,G7,H7,A8,B8,C8,D8,E8,F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPa4_BKb4 [] = {
H1,H2,H3,H4,H5,D6,E6,F6,G6,H6,A7,B7,C7,D7,E7,F7,G7,H7,A8,B8,
C8,D8,E8,F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPa4_BKb5 [] = {
A7,B7,C7,D7,E7,F7,G7,H7,A8,B8,C8,D8,E8,F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPa5_BKb4 [] = {
E7,F7,G7,H7,A8,B8,C8,D8,E8,F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPa5_BKb5 [] = {
A8,B8,C8,D8,E8,F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPb2_BKa2 [] = {
E1,F1,G1,H1,E2,F2,G2,H2,E3,F3,G3,H3,D4,E4,F4,G4,H4,B5,C5,D5,
E5,F5,G5,H5,A6,B6,C6,D6,E6,F6,G6,H6,A7,B7,C7,D7,E7,F7,G7,H7,
A8,B8,C8,D8,E8,F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPb2_BKa3 [] = {
F2,G2,H2,F3,G3,H3,F4,G4,H4,A5,E5,G5,H5,A6,B6,C6,D6,E6,F6,H6,
A7,B7,C7,D7,E7,F7,G7,A8,B8,C8,D8,E8,F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPb2_BKb3 [] = {
F2,G2,H2,F3,G3,H3,F4,G4,H4,A5,B5,C5,D5,E5,G5,H5,A6,B6,C6,D6,
E6,F6,H6,A7,B7,C7,D7,E7,F7,G7,A8,B8,C8,D8,E8,F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPb2_BKc1 [] = {
F1,G1,H1,F2,G2,H2,E3,F3,G3,H3,A4,D4,E4,F4,G4,H4,A5,C5,D5,E5,
F5,G5,H5,A6,C6,D6,E6,F6,G6,H6,A7,C7,D7,E7,F7,G7,H7,A8,C8,D8,
E8,F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPb2_BKc2 [] = {
E1,E2,E3,C4,D4, NULL_SQUARE
};
static const squareT drawSquares_BPb2_BKc3 [] = {
E3,A5,B5,C5,D5,E5,A6,B6,C6,D6,A7,B7,C7,A8,B8,C8, NULL_SQUARE
};
static const squareT drawSquares_BPb3_BKa2 [] = {
F1,G1,H1,F2,G2,H2,F3,G3,H3,F4,G4,H4,E5,F5,G5,H5,B6,C6,D6,E6,
F6,G6,H6,A7,B7,C7,D7,E7,F7,G7,H7,A8,B8,C8,D8,E8,F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPb3_BKa3 [] = {
G1,H1,G2,H2,G3,H3,G4,H4,G5,H5,F6,G6,H6,A7,B7,C7,D7,E7,F7,G7,
H7,A8,B8,C8,D8,E8,F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPb3_BKa4 [] = {
H1,H2,H3,H4,H5,H6,G7,H7,A8,B8,C8,D8,E8,F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPb3_BKb2 [] = {
G1,H1,G2,H2,G3,H3,G4,H4,F5,G5,H5,F6,G6,H6,A7,B7,C7,D7,E7,F7,
G7,H7,A8,B8,C8,D8,E8,F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPb3_BKb4 [] = {
G1,H1,G2,H2,G3,H3,G4,H4,F5,G5,H5,A6,B6,C6,D6,E6,F6,G6,H6,A7,
B7,C7,D7,E7,F7,G7,H7,A8,B8,C8,D8,E8,F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPb3_BKc2 [] = {
F1,G1,H1,G2,H2,E3,F3,G3,H3,E4,F4,G4,H4,A5,B5,D5,E5,F5,G5,H5,
A6,B6,C6,D6,E6,F6,G6,H6,A7,B7,C7,D7,E7,F7,G7,H7,A8,B8,C8,D8,
E8,F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPb3_BKc3 [] = {
G1,H1,G2,H2,G3,H3,E4,F4,G4,H4,C5,D5,E5,F5,G5,H5,A6,B6,C6,D6,
E6,F6,G6,H6,A7,B7,C7,D7,E7,F7,G7,H7,A8,B8,C8,D8,E8,F8,G8,H8,
NULL_SQUARE
};
static const squareT drawSquares_BPb3_BKc4 [] = {
H1,H2,H3,H4,E5,F5,G5,H5,C6,D6,E6,F6,G6,H6,A7,B7,C7,D7,E7,F7,
G7,H7,A8,B8,C8,D8,E8,F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPb4_BKa3 [] = {
H1,H2,H3,H4,H5,H6,G7,H7,A8,B8,C8,D8,E8,F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPb4_BKa4 [] = {
G7,H7,F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPb4_BKa5 [] = {
H8, NULL_SQUARE
};
static const squareT drawSquares_BPb4_BKb3 [] = {
H6,G7,H7,A8,B8,C8,D8,E8,F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPb4_BKc3 [] = {
H1,H2,H3,H4,E5,F5,G5,H5,D6,E6,F6,G6,H6,A7,B7,C7,D7,E7,F7,G7,
H7,A8,B8,C8,D8,E8,F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPb4_BKc4 [] = {
D6,E6,F6,G6,H6,D7,E7,F7,G7,H7,A8,B8,C8,D8,E8,F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPb4_BKc5 [] = {
E7,F7,G7,H7,E8,F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPb5_BKc4 [] = {
E7,F7,G7,H7,E8,F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPb5_BKc5 [] = {
F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPc2_BKb2 [] = {
A4,B4,B5,B6,B7,B8, NULL_SQUARE
};
static const squareT drawSquares_BPc2_BKb3 [] = {
A5,B5,C5,D5,A6,B6,C6,D6,B7,C7,D7,E7,B8,C8,D8,E8, NULL_SQUARE
};
static const squareT drawSquares_BPc2_BKd1 [] = {
G1,H1,G2,H2,F3,G3,H3,A4,B4,E4,F4,G4,H4,A5,B5,D5,E5,F5,G5,H5,
A6,B6,D6,E6,F6,G6,H6,A7,B7,D7,E7,F7,G7,H7,A8,B8,D8,E8,F8,G8,
H8, NULL_SQUARE
};
static const squareT drawSquares_BPc2_BKd3 [] = {
F3,B5,C5,D5,E5,F5,A6,B6,C6,D6,E6,A7,B7,C7,D7,A8,B8,C8,D8, NULL_SQUARE
};
static const squareT drawSquares_BPc3_BKb2 [] = {
G1,H1,G2,H2,G3,H3,G4,H4,A5,C5,D5,E5,F5,G5,H5,A6,B6,C6,D6,E6,
F6,G6,H6,A7,B7,C7,D7,E7,F7,G7,H7,A8,B8,C8,D8,E8,F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPc3_BKb3 [] = {
H1,H2,H3,H4,A5,B5,H5,A6,B6,C6,D6,E6,F6,G6,H6,A7,B7,C7,D7,E7,
F7,G7,H7,A8,B8,C8,D8,E8,F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPc3_BKb4 [] = {
A6,B6,A7,B7,C7,D7,E7,F7,G7,H7,A8,B8,C8,D8,E8,F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPc3_BKc2 [] = {
H1,H2,H3,H4,G5,H5,A6,B6,C6,D6,E6,F6,G6,H6,A7,B7,C7,D7,E7,F7,
G7,H7,A8,B8,C8,D8,E8,F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPc3_BKc4 [] = {
H1,H2,H3,H4,G5,H5,A6,B6,C6,D6,E6,F6,G6,H6,A7,B7,C7,D7,E7,F7,
G7,H7,A8,B8,C8,D8,E8,F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPc3_BKd2 [] = {
G1,H1,H2,F3,G3,H3,F4,G4,H4,A5,B5,C5,E5,F5,G5,H5,A6,B6,C6,D6,
E6,F6,G6,H6,A7,B7,C7,D7,E7,F7,G7,H7,A8,B8,C8,D8,E8,F8,G8,H8,
NULL_SQUARE
};
static const squareT drawSquares_BPc3_BKd3 [] = {
H1,H2,H3,F4,G4,H4,D5,E5,F5,G5,H5,A6,B6,C6,D6,E6,F6,G6,H6,A7,
B7,C7,D7,E7,F7,G7,H7,A8,B8,C8,D8,E8,F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPc3_BKd4 [] = {
F5,G5,H5,D6,E6,F6,G6,H6,A7,B7,C7,D7,E7,F7,G7,H7,A8,B8,C8,D8,
E8,F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPc4_BKb3 [] = {
A6,A7,B7,C7,D7,E7,F7,G7,H7,A8,B8,C8,D8,E8,F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPc4_BKb4 [] = {
A6,A7,H7,A8,B8,C8,D8,E8,F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPc4_BKc3 [] = {
F7,G7,H7,A8,B8,C8,D8,E8,F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPc4_BKd3 [] = {
F5,G5,H5,E6,F6,G6,H6,A7,B7,C7,D7,E7,F7,G7,H7,A8,B8,C8,D8,E8,
F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPc4_BKd4 [] = {
E6,F6,G6,H6,E7,F7,G7,H7,A8,B8,C8,D8,E8,F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPc4_BKd5 [] = {
F7,G7,H7,F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPd2_BKc1 [] = {
G1,H1,G2,H2,A3,G3,H3,A4,B4,E4,F4,G4,H4,A5,B5,E5,F5,G5,H5,A6,
B6,E6,F6,G6,H6,A7,B7,E7,F7,G7,H7,A8,B8,E8,F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPd2_BKc3 [] = {
A3,A5,B5,C5,D5,E5,B6,C6,D6,E6,C7,D7,E7,F7,C8,D8,E8,F8, NULL_SQUARE
};
static const squareT drawSquares_BPd2_BKd1 [] = {
H1,H2,H3,A4,G4,H4,A5,B5,C5,D5,E5,F5,G5,H5,A6,B6,C6,D6,E6,F6,
G6,H6,A7,B7,C7,D7,E7,F7,G7,H7,A8,B8,C8,D8,E8,F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPd2_BKd3 [] = {
H2,H3,H4,A5,B5,C5,D5,E5,F5,G5,A6,B6,C6,D6,E6,F6,G6,H6,A7,B7,
C7,D7,E7,F7,G7,H7,A8,B8,C8,D8,E8,F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPd2_BKe1 [] = {
A1,H1,A2,H2,A3,G3,H3,A4,B4,C4,F4,G4,H4,A5,B5,C5,E5,F5,G5,H5,
A6,B6,C6,E6,F6,G6,H6,A7,B7,C7,E7,F7,G7,H7,A8,B8,C8,E8,F8,G8,
H8, NULL_SQUARE
};
static const squareT drawSquares_BPd2_BKe3 [] = {
G3,C5,D5,E5,F5,G5,C6,D6,E6,F6,B7,C7,D7,E7,B8,C8,D8,E8, NULL_SQUARE
};
static const squareT drawSquares_BPd3_BKc2 [] = {
H1,H2,A3,H3,A4,H4,A5,B5,D5,E5,F5,G5,H5,A6,B6,C6,D6,E6,F6,G6,
H6,A7,B7,C7,D7,E7,F7,G7,H7,A8,B8,C8,D8,E8,F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPd3_BKc3 [] = {
A4,A5,B5,C5,A6,B6,C6,D6,E6,F6,G6,H6,A7,B7,C7,D7,E7,F7,G7,H7,
A8,B8,C8,D8,E8,F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPd3_BKc4 [] = {
A5,A6,B6,C6,A7,B7,C7,D7,E7,F7,G7,H7,A8,B8,C8,D8,E8,F8,G8,H8,
NULL_SQUARE
};
static const squareT drawSquares_BPd3_BKd2 [] = {
H5,A6,B6,C6,D6,E6,F6,G6,H6,A7,B7,C7,D7,E7,F7,G7,H7,A8,B8,C8,
D8,E8,F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPd3_BKd4 [] = {
H5,A6,B6,C6,D6,E6,F6,G6,H6,A7,B7,C7,D7,E7,F7,G7,H7,A8,B8,C8,
D8,E8,F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPd3_BKe2 [] = {
H1,H2,G3,H3,G4,H4,A5,B5,C5,D5,F5,G5,H5,A6,B6,C6,D6,E6,F6,G6,
H6,A7,B7,C7,D7,E7,F7,G7,H7,A8,B8,C8,D8,E8,F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPd3_BKe3 [] = {
G4,H4,E5,F5,G5,H5,A6,B6,C6,D6,E6,F6,G6,H6,A7,B7,C7,D7,E7,F7,
G7,H7,A8,B8,C8,D8,E8,F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPd3_BKe4 [] = {
G5,H5,E6,F6,G6,H6,A7,B7,C7,D7,E7,F7,G7,H7,A8,B8,C8,D8,E8,F8,
G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPd4_BKc3 [] = {
A5,A6,B6,A7,B7,C7,D7,E7,F7,G7,H7,A8,B8,C8,D8,E8,F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPd4_BKc4 [] = {
A6,B6,A7,B7,A8,B8,C8,D8,E8,F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPd4_BKc5 [] = {
A7,A8, NULL_SQUARE
};
static const squareT drawSquares_BPd4_BKd3 [] = {
A7,G7,H7,A8,B8,C8,D8,E8,F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPd4_BKd5 [] = {
A8,B8,F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPd4_BKe3 [] = {
G5,H5,F6,G6,H6,A7,B7,C7,D7,E7,F7,G7,H7,A8,B8,C8,D8,E8,F8,G8,
H8, NULL_SQUARE
};
static const squareT drawSquares_BPd4_BKe4 [] = {
F6,G6,H6,F7,G7,H7,A8,B8,C8,D8,E8,F8,G8,H8, NULL_SQUARE
};
static const squareT drawSquares_BPd4_BKe5 [] = {
G7,H7,G8,H8, NULL_SQUARE
};
const squareT * drawSquares = drawSquares_None;
if (bp == A2) {
if (bk == B2) { drawSquares = drawSquares_BPa2_BKb2; }
else if (bk == B3) { drawSquares = drawSquares_BPa2_BKb3; }
} else if (bp == A3) {
if (bk == B2) { drawSquares = drawSquares_BPa3_BKb2; }
else if (bk == B3) { drawSquares = drawSquares_BPa3_BKb3; }
else if (bk == B4) { drawSquares = drawSquares_BPa3_BKb4; }
} else if (bp == A4) {
if (bk == A3) { drawSquares = drawSquares_BPa4_BKa3; }
else if (bk == A5) { drawSquares = drawSquares_BPa4_BKa5; }
else if (bk == B3) { drawSquares = drawSquares_BPa4_BKb3; }
else if (bk == B4) { drawSquares = drawSquares_BPa4_BKb4; }
else if (bk == B5) { drawSquares = drawSquares_BPa4_BKb5; }
} else if (bp == A5) {
if (bk == B4) { drawSquares = drawSquares_BPa5_BKb4; }
else if (bk == B5) { drawSquares = drawSquares_BPa5_BKb5; }
} else if (bp == B2) {
if (bk == A2) { drawSquares = drawSquares_BPb2_BKa2; }
else if (bk == A3) { drawSquares = drawSquares_BPb2_BKa3; }
else if (bk == B3) { drawSquares = drawSquares_BPb2_BKb3; }
else if (bk == C1) { drawSquares = drawSquares_BPb2_BKc1; }
else if (bk == C2) { drawSquares = drawSquares_BPb2_BKc2; }
else if (bk == C3) { drawSquares = drawSquares_BPb2_BKc3; }
} else if (bp == B3) {
if (bk == A2) { drawSquares = drawSquares_BPb3_BKa2; }
else if (bk == A3) { drawSquares = drawSquares_BPb3_BKa3; }
else if (bk == A4) { drawSquares = drawSquares_BPb3_BKa4; }
else if (bk == B2) { drawSquares = drawSquares_BPb3_BKb2; }
else if (bk == B4) { drawSquares = drawSquares_BPb3_BKb4; }
else if (bk == C2) { drawSquares = drawSquares_BPb3_BKc2; }
else if (bk == C3) { drawSquares = drawSquares_BPb3_BKc3; }
else if (bk == C4) { drawSquares = drawSquares_BPb3_BKc4; }
} else if (bp == B4) {
if (bk == A3) { drawSquares = drawSquares_BPb4_BKa3; }
else if (bk == A4) { drawSquares = drawSquares_BPb4_BKa4; }
else if (bk == A5) { drawSquares = drawSquares_BPb4_BKa5; }
else if (bk == B3) { drawSquares = drawSquares_BPb4_BKb3; }
else if (bk == C3) { drawSquares = drawSquares_BPb4_BKc3; }
else if (bk == C4) { drawSquares = drawSquares_BPb4_BKc4; }
else if (bk == C5) { drawSquares = drawSquares_BPb4_BKc5; }
} else if (bp == B5) {
if (bk == C4) { drawSquares = drawSquares_BPb5_BKc4; }
else if (bk == C5) { drawSquares = drawSquares_BPb5_BKc5; }
} else if (bp == C2) {
if (bk == B2) { drawSquares = drawSquares_BPc2_BKb2; }
else if (bk == B3) { drawSquares = drawSquares_BPc2_BKb3; }
else if (bk == D1) { drawSquares = drawSquares_BPc2_BKd1; }
else if (bk == D3) { drawSquares = drawSquares_BPc2_BKd3; }
} else if (bp == C3) {
if (bk == B2) { drawSquares = drawSquares_BPc3_BKb2; }
else if (bk == B3) { drawSquares = drawSquares_BPc3_BKb3; }
else if (bk == B4) { drawSquares = drawSquares_BPc3_BKb4; }
else if (bk == C2) { drawSquares = drawSquares_BPc3_BKc2; }
else if (bk == C4) { drawSquares = drawSquares_BPc3_BKc4; }
else if (bk == D2) { drawSquares = drawSquares_BPc3_BKd2; }
else if (bk == D3) { drawSquares = drawSquares_BPc3_BKd3; }
else if (bk == D4) { drawSquares = drawSquares_BPc3_BKd4; }
} else if (bp == C4) {
if (bk == B3) { drawSquares = drawSquares_BPc4_BKb3; }
else if (bk == B4) { drawSquares = drawSquares_BPc4_BKb4; }
else if (bk == C3) { drawSquares = drawSquares_BPc4_BKc3; }
else if (bk == D3) { drawSquares = drawSquares_BPc4_BKd3; }
else if (bk == D4) { drawSquares = drawSquares_BPc4_BKd4; }
else if (bk == D5) { drawSquares = drawSquares_BPc4_BKd5; }
} else if (bp == D2) {
if (bk == C1) { drawSquares = drawSquares_BPd2_BKc1; }
else if (bk == C3) { drawSquares = drawSquares_BPd2_BKc3; }
else if (bk == D1) { drawSquares = drawSquares_BPd2_BKd1; }
else if (bk == D3) { drawSquares = drawSquares_BPd2_BKd3; }
else if (bk == E1) { drawSquares = drawSquares_BPd2_BKe1; }
else if (bk == E3) { drawSquares = drawSquares_BPd2_BKe3; }
} else if (bp == D3) {
if (bk == C2) { drawSquares = drawSquares_BPd3_BKc2; }
else if (bk == C3) { drawSquares = drawSquares_BPd3_BKc3; }
else if (bk == C4) { drawSquares = drawSquares_BPd3_BKc4; }
else if (bk == D2) { drawSquares = drawSquares_BPd3_BKd2; }
else if (bk == D4) { drawSquares = drawSquares_BPd3_BKd4; }
else if (bk == E2) { drawSquares = drawSquares_BPd3_BKe2; }
else if (bk == E3) { drawSquares = drawSquares_BPd3_BKe3; }
else if (bk == E4) { drawSquares = drawSquares_BPd3_BKe4; }
} else if (bp == D4) {
if (bk == C3) { drawSquares = drawSquares_BPd4_BKc3; }
else if (bk == C4) { drawSquares = drawSquares_BPd4_BKc4; }
else if (bk == C5) { drawSquares = drawSquares_BPd4_BKc5; }
else if (bk == D3) { drawSquares = drawSquares_BPd4_BKd3; }
else if (bk == D5) { drawSquares = drawSquares_BPd4_BKd5; }
else if (bk == E3) { drawSquares = drawSquares_BPd4_BKe3; }
else if (bk == E4) { drawSquares = drawSquares_BPd4_BKe4; }
else if (bk == E5) { drawSquares = drawSquares_BPd4_BKe5; }
}
// Scan the list of drawn squares for the white king square:
while (*drawSquares != NULL_SQUARE) {
if (wk == *drawSquares) { return DRAW; }
drawSquares++;
}
return UNKNOWN;
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Recognizer::KRPKR
// Returns a recognition score for King, Rook and Pawn vs King and Rook.
// Contains rules for some draws, checked using tablebases.
int
Recognizer::KRPKR (Position * pos)
{
// Incomplete but correct
const byte* material = pos->GetMaterial();
const pieceT* board = pos->GetBoard();
squareT wk, bk, wr, wp, br;
colorT stm = pos->GetToMove();
// Set up piece squares so that White has the pawn:
if (material[WP] == 1) {
wk = pos->GetKingSquare(WHITE);
bk = pos->GetKingSquare(BLACK);
squareT * sqlist = pos->GetList(WHITE);
wr = sqlist[1];
wp = sqlist[2];
if (board[wr] != WR) { squareT temp = wr; wr = wp; wp = temp; }
sqlist = pos->GetList(BLACK);
br = sqlist[1];
} else {
wk = square_FlipRank(pos->GetKingSquare(BLACK));
bk = square_FlipRank(pos->GetKingSquare(WHITE));
squareT * sqlist = pos->GetList(BLACK);
wr = sqlist[1];
wp = sqlist[2];
if (board[wr] != BR) { squareT temp = wr; wr = wp; wp = temp; }
wr = square_FlipRank(wr);
wp = square_FlipRank(wp);
sqlist = pos->GetList(WHITE);
br = square_FlipRank(sqlist[1]);
stm = color_Flip(stm);
}
// Make sure the pawn is on the queenside:
if (square_Fyle(wp) >= E_FYLE) {
wk = square_FlipFyle(wk); wr = square_FlipFyle(wr);
wp = square_FlipFyle(wp);
bk = square_FlipFyle(bk); br = square_FlipFyle(br);
}
// Get ranks and files of piece squares:
int wkRank = square_Rank(wk); int wkFyle = square_Fyle(wk);
int wrRank = square_Rank(wr); int wrFyle = square_Fyle(wr);
int wpRank = square_Rank(wp); int wpFyle = square_Fyle(wp);
int bkRank = square_Rank(bk); int bkFyle = square_Fyle(bk);
int brRank = square_Rank(br); int brFyle = square_Fyle(br);
// No draws recognized if the black king is behind the pawn:
if (bkRank < wpRank) { return UNKNOWN; }
// We cannot recognize draws if the rooks share a rank or file:
if (wrRank == brRank || wrFyle == brFyle) { return UNKNOWN; }
// Designate side-to-move king,rook as sk and sr, enemy as ek and er
squareT /* sk, sr, er, */ ek;
int /* skRank, srRank, */ ekRank, erRank;
int /* skFyle, srFyle, */ ekFyle, erFyle;
if (stm == WHITE) {
ek = bk; // sk = wk; sr = wr; er = br;
// skRank = wkRank; skFyle = wkFyle; srRank = wrRank; srFyle = wrFyle;
ekRank = bkRank; ekFyle = bkFyle; erRank = brRank; erFyle = brFyle;
} else {
ek = wk; /// sk = bk; sr = br; er = wr;
// skRank = bkRank; skFyle = bkFyle; srRank = brRank; srFyle = brFyle;
ekRank = wkRank; ekFyle = wkFyle; erRank = wrRank; erFyle = wrFyle;
}
uint kingDist = square_Distance (wk, bk);
// No recognition if the king and rook of the side NOT to move share
// a rank or file, since there may be a pin or skewer.
if (ekRank == erRank || ekFyle == erFyle) { return UNKNOWN; }
// No draws if the side NOT to move king and rook nearly share a
// rank or file (that is, are on adjacent ranks or files) and the
// king is on an edge, or the enemy king is only 2 squares away.
// This can lead to loss of a rook, e.g. WK=d1 WR=a2 and ...Rh1+
// or BK=d6 BR=h7 WK=d4 and Ra6+ wins the rook.
if (square_IsEdgeSquare(ek) || kingDist == 2) {
int rankDiff = (int)ekRank - (int)erRank;
if (rankDiff >= -1 && rankDiff <= 1) { return UNKNOWN; }
int fyleDiff = (int)ekFyle - (int)erFyle;
if (fyleDiff >= -1 && fyleDiff <= 1) { return UNKNOWN; }
}
// No recognition if either king attacks the enemy rook:
if (square_Adjacent (wk, br)) { return UNKNOWN; }
if (square_Adjacent (bk, wr)) { return UNKNOWN; }
// No recognition if the white pawn attacks the black rook:
if (square_Move (wp, UP_LEFT) == br) { return UNKNOWN; }
if (square_Move (wp, UP_RIGHT) == br) { return UNKNOWN; }
// Philidor and more:
// white pawn and king are on 5th rank or lower, on any file;
// black rook has higher rank than white king and pawn, up to rank 6;
// black king is on pawn file or adjacent, ranked higher than black rook;
// Drawn for white or black to move.
if (wpRank <= RANK_5 && wkRank <= RANK_5
&& brRank <= RANK_6 && brRank > wpRank && brRank > wkRank
&& bkRank > brRank && bkRank > RANK_4) {
// Only exception: WK=a1, WP=b2, WR=b1; White may be checkmated.
if (wk == A1 && wp == B2 && wr == B1) { return UNKNOWN; }
// black king on the pawn file
if (bkFyle == wpFyle && (brRank == RANK_6 || wrFyle != bkFyle)) {
return DRAW;
}
// black king on adjacent file
if ((bkFyle == wpFyle + 1 || bkFyle == wpFyle - 1)
&& brFyle != wpFyle && wrFyle != bkFyle) {
return DRAW;
}
}
// Sixth-rank pawn draws:
// white pawn on 6th rank; black king on pawn file on 7th/8th rank;
// black rook anywhere on 1st rank; white king on 6th rank or less;
// white rook and black king are not on same rank.
if (wpRank == RANK_6 && bkFyle == wpFyle && bkRank >= RANK_7
&& brRank == RANK_1 && wkRank <= RANK_6 && wrRank != bkRank) {
// Black to move: draw
if (stm == BLACK) { return DRAW; }
// White to move: draw if the kings are > 2 squares apart, and
// the white king and black rook do not share a rank or file.
if (wkRank != brRank && wkFyle != brFyle
&& square_Distance(wk,bk) > 2) {
return DRAW;
}
}
// TODO: Common a-pawn draws.
if (wpFyle == A_FYLE) {
// ....
}
return UNKNOWN;
}
//////////////////////////////////////////////////////////////////////
// EOF: recog.cpp
//////////////////////////////////////////////////////////////////////
