INVALID = 0,

UNKNOWN = 1,

DRAW = 2,

WIN = 4

KPKPosition() = default;

explicit KPKPosition(unsigned idx);

operator Result() const { return result; }

Result classify(const std::vector<KPKPosition>& db)

{ return us == WHITE ? classify<WHITE>(db) : classify<BLACK>(db); }

template<Color Us> Result classify(const std::vector<KPKPosition>& db);

Color us;

Square ksq[COLOR_NB], psq;

Result result;

assert(file_of(wpsq) <= FILE_D);

unsigned idx = index(us, bksq, wksq, wpsq);

return KPKBitbase[idx / 32] & (1 << (idx & 0x1F));

std::vector<KPKPosition> db(MAX_INDEX);

unsigned idx, repeat = 1;

// Initialize db with known win / draw positions

for (idx = 0; idx < MAX_INDEX; ++idx)

db[idx] = KPKPosition(idx);

// Iterate through the positions until none of the unknown positions can be

// changed to either wins or draws (15 cycles needed).

while (repeat)

for (repeat = idx = 0; idx < MAX_INDEX; ++idx)

repeat |= (db[idx] == UNKNOWN && db[idx].classify(db) != UNKNOWN);

// Map 32 results into one KPKBitbase[] entry

for (idx = 0; idx < MAX_INDEX; ++idx)

if (db[idx] == WIN)

KPKBitbase[idx / 32] |= 1 << (idx & 0x1F);

ksq[WHITE] = Square((idx >> 0) & 0x3F);

ksq[BLACK] = Square((idx >> 6) & 0x3F);

us = Color ((idx >> 12) & 0x01);

psq = make_square(File((idx >> 13) & 0x3), Rank(RANK_7 - ((idx >> 15) & 0x7)));

// Check if two pieces are on the same square or if a king can be captured

if ( distance(ksq[WHITE], ksq[BLACK]) <= 1

|| ksq[WHITE] == psq

|| ksq[BLACK] == psq

|| (us == WHITE && (PawnAttacks[WHITE][psq] & ksq[BLACK])))

result = INVALID;

// Immediate win if a pawn can be promoted without getting captured

else if ( us == WHITE

&& rank_of(psq) == RANK_7

&& ksq[us] != psq + NORTH

&& ( distance(ksq[~us], psq + NORTH) > 1

|| (PseudoAttacks[KING][ksq[us]] & (psq + NORTH))))

result = WIN;

// Immediate draw if it is a stalemate or a king captures undefended pawn

else if ( us == BLACK

&& ( !(PseudoAttacks[KING][ksq[us]] & ~(PseudoAttacks[KING][ksq[~us]] | PawnAttacks[~us][psq]))

|| (PseudoAttacks[KING][ksq[us]] & psq & ~PseudoAttacks[KING][ksq[~us]])))

result = DRAW;

// Position will be classified later

else

result = UNKNOWN;

// White to move: If one move leads to a position classified as WIN, the result

// of the current position is WIN. If all moves lead to positions classified

// as DRAW, the current position is classified as DRAW, otherwise the current

// position is classified as UNKNOWN.

//

// Black to move: If one move leads to a position classified as DRAW, the result

// of the current position is DRAW. If all moves lead to positions classified

// as WIN, the position is classified as WIN, otherwise the current position is

// classified as UNKNOWN.

const Color Them = (Us == WHITE ? BLACK : WHITE);

const Result Good = (Us == WHITE ? WIN : DRAW);

const Result Bad = (Us == WHITE ? DRAW : WIN);

Result r = INVALID;

Bitboard b = PseudoAttacks[KING][ksq[Us]];

while (b)

r |= Us == WHITE ? db[index(Them, ksq[Them] , pop_lsb(&b), psq)]

: db[index(Them, pop_lsb(&b), ksq[Them] , psq)];

if (Us == WHITE)

{

if (rank_of(psq) < RANK_7) // Single push

r |= db[index(Them, ksq[Them], ksq[Us], psq + NORTH)];

if ( rank_of(psq) == RANK_2 // Double push

&& psq + NORTH != ksq[Us]

&& psq + NORTH != ksq[Them])

r |= db[index(Them, ksq[Them], ksq[Us], psq + NORTH + NORTH)];

}

return result = r & Good ? Good : r & UNKNOWN ? UNKNOWN : Bad;