349 lines
8.4 KiB
C++
349 lines
8.4 KiB
C++
/*
|
|
Glaurung, a UCI chess playing engine.
|
|
Copyright (C) 2004-2008 Tord Romstad
|
|
|
|
Glaurung is free software: you can redistribute it and/or modify
|
|
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.
|
|
|
|
Glaurung is distributed in the hope that it will be useful,
|
|
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.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
|
|
////
|
|
//// Includes
|
|
////
|
|
|
|
#include <cassert>
|
|
|
|
#include "bitbase.h"
|
|
#include "bitboard.h"
|
|
#include "move.h"
|
|
#include "square.h"
|
|
|
|
|
|
////
|
|
//// Local definitions
|
|
////
|
|
|
|
namespace {
|
|
|
|
enum Result {
|
|
RESULT_UNKNOWN,
|
|
RESULT_INVALID,
|
|
RESULT_WIN,
|
|
RESULT_LOSS,
|
|
RESULT_DRAW
|
|
};
|
|
|
|
struct KPKPosition {
|
|
void from_index(int index);
|
|
int to_index() const;
|
|
bool is_legal() const;
|
|
bool is_immediate_draw() const;
|
|
bool is_immediate_win() const;
|
|
Bitboard wk_attacks() const;
|
|
Bitboard bk_attacks() const;
|
|
Bitboard pawn_attacks() const;
|
|
|
|
Square whiteKingSquare, blackKingSquare, pawnSquare;
|
|
Color sideToMove;
|
|
};
|
|
|
|
|
|
Result *Bitbase;
|
|
const int IndexMax = 2*24*64*64;
|
|
int UnknownCount = 0;
|
|
|
|
void initialize();
|
|
bool next_iteration();
|
|
Result classify_wtm(const KPKPosition &p);
|
|
Result classify_btm(const KPKPosition &p);
|
|
int compute_index(Square wksq, Square bksq, Square psq, Color stm);
|
|
int compress_result(Result r);
|
|
|
|
}
|
|
|
|
|
|
////
|
|
//// Functions
|
|
////
|
|
|
|
void generate_kpk_bitbase(uint8_t bitbase[]) {
|
|
// Allocate array and initialize:
|
|
Bitbase = new Result[IndexMax];
|
|
initialize();
|
|
|
|
// Iterate until all positions are classified:
|
|
while(next_iteration());
|
|
|
|
// Compress bitbase into the supplied parameter:
|
|
int i, j, b;
|
|
for(i = 0; i < 24576; i++) {
|
|
for(b = 0, j = 0; j < 8; b |= (compress_result(Bitbase[8*i+j]) << j), j++);
|
|
bitbase[i] = b;
|
|
}
|
|
|
|
// Release allocated memory:
|
|
delete [] Bitbase;
|
|
}
|
|
|
|
|
|
namespace {
|
|
|
|
void KPKPosition::from_index(int index) {
|
|
int s;
|
|
sideToMove = Color(index % 2);
|
|
blackKingSquare = Square((index / 2) % 64);
|
|
whiteKingSquare = Square((index / 128) % 64);
|
|
s = (index / 8192) % 24;
|
|
pawnSquare = make_square(File(s % 4), Rank(s / 4 + 1));
|
|
}
|
|
|
|
|
|
int KPKPosition::to_index() const {
|
|
return compute_index(whiteKingSquare, blackKingSquare, pawnSquare,
|
|
sideToMove);
|
|
}
|
|
|
|
|
|
bool KPKPosition::is_legal() const {
|
|
if(whiteKingSquare == pawnSquare || whiteKingSquare == blackKingSquare ||
|
|
pawnSquare == blackKingSquare)
|
|
return false;
|
|
if(sideToMove == WHITE) {
|
|
if(bit_is_set(this->wk_attacks(), blackKingSquare))
|
|
return false;
|
|
if(bit_is_set(this->pawn_attacks(), blackKingSquare))
|
|
return false;
|
|
}
|
|
else {
|
|
if(bit_is_set(this->bk_attacks(), whiteKingSquare))
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
bool KPKPosition::is_immediate_draw() const {
|
|
if(sideToMove == BLACK) {
|
|
Bitboard wka = this->wk_attacks();
|
|
Bitboard bka = this->bk_attacks();
|
|
|
|
// Case 1: Stalemate
|
|
if((bka & ~(wka | this->pawn_attacks())) == EmptyBoardBB)
|
|
return true;
|
|
|
|
// Case 2: King can capture pawn
|
|
if(bit_is_set(bka, pawnSquare) && !bit_is_set(wka, pawnSquare))
|
|
return true;
|
|
}
|
|
else {
|
|
// Case 1: Stalemate
|
|
if(whiteKingSquare == SQ_A8 && pawnSquare == SQ_A7 &&
|
|
(blackKingSquare == SQ_C7 || blackKingSquare == SQ_C8))
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
bool KPKPosition::is_immediate_win() const {
|
|
// The position is an immediate win if it is white to move and the white
|
|
// pawn can be promoted without getting captured:
|
|
return
|
|
sideToMove == WHITE &&
|
|
square_rank(pawnSquare) == RANK_7 &&
|
|
(square_distance(blackKingSquare, pawnSquare+DELTA_N) > 1 ||
|
|
bit_is_set(this->wk_attacks(), pawnSquare+DELTA_N));
|
|
}
|
|
|
|
|
|
Bitboard KPKPosition::wk_attacks() const {
|
|
return StepAttackBB[WK][whiteKingSquare];
|
|
}
|
|
|
|
|
|
Bitboard KPKPosition::bk_attacks() const {
|
|
return StepAttackBB[BK][blackKingSquare];
|
|
}
|
|
|
|
|
|
Bitboard KPKPosition::pawn_attacks() const {
|
|
return StepAttackBB[WP][pawnSquare];
|
|
}
|
|
|
|
|
|
void initialize() {
|
|
KPKPosition p;
|
|
for(int i = 0; i < IndexMax; i++) {
|
|
p.from_index(i);
|
|
if(!p.is_legal())
|
|
Bitbase[i] = RESULT_INVALID;
|
|
else if(p.is_immediate_draw())
|
|
Bitbase[i] = RESULT_DRAW;
|
|
else if(p.is_immediate_win())
|
|
Bitbase[i] = RESULT_WIN;
|
|
else {
|
|
Bitbase[i] = RESULT_UNKNOWN;
|
|
UnknownCount++;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
bool next_iteration() {
|
|
KPKPosition p;
|
|
int previousUnknownCount = UnknownCount;
|
|
|
|
for(int i = 0; i < IndexMax; i++)
|
|
if(Bitbase[i] == RESULT_UNKNOWN) {
|
|
p.from_index(i);
|
|
|
|
Bitbase[i] = (p.sideToMove == WHITE)? classify_wtm(p) : classify_btm(p);
|
|
|
|
if(Bitbase[i] == RESULT_WIN || Bitbase[i] == RESULT_LOSS ||
|
|
Bitbase[i] == RESULT_DRAW)
|
|
UnknownCount--;
|
|
}
|
|
|
|
return UnknownCount != previousUnknownCount;
|
|
}
|
|
|
|
|
|
Result classify_wtm(const KPKPosition &p) {
|
|
|
|
// If one move leads to a position classified as RESULT_LOSS, the result
|
|
// of the current position is RESULT_WIN. If all moves lead to positions
|
|
// classified as RESULT_DRAW, the current position is classified as
|
|
// RESULT_DRAW. Otherwise, the current position is classified as
|
|
// RESULT_UNKNOWN.
|
|
|
|
bool unknownFound = false;
|
|
Bitboard b;
|
|
Square s;
|
|
|
|
// King moves
|
|
b = p.wk_attacks();
|
|
while(b) {
|
|
s = pop_1st_bit(&b);
|
|
switch(Bitbase[compute_index(s, p.blackKingSquare, p.pawnSquare,
|
|
BLACK)]) {
|
|
case RESULT_LOSS:
|
|
return RESULT_WIN;
|
|
|
|
case RESULT_UNKNOWN:
|
|
unknownFound = true;
|
|
break;
|
|
|
|
case RESULT_DRAW: case RESULT_INVALID:
|
|
break;
|
|
|
|
default:
|
|
assert(false);
|
|
}
|
|
}
|
|
|
|
// Pawn moves
|
|
if(square_rank(p.pawnSquare) < RANK_7) {
|
|
s = p.pawnSquare + DELTA_N;
|
|
switch(Bitbase[compute_index(p.whiteKingSquare, p.blackKingSquare, s,
|
|
BLACK)]) {
|
|
case RESULT_LOSS:
|
|
return RESULT_WIN;
|
|
|
|
case RESULT_UNKNOWN:
|
|
unknownFound = true;
|
|
break;
|
|
|
|
case RESULT_DRAW: case RESULT_INVALID:
|
|
break;
|
|
|
|
default:
|
|
assert(false);
|
|
}
|
|
|
|
if(square_rank(s) == RANK_3 &&
|
|
s != p.whiteKingSquare && s != p.blackKingSquare) {
|
|
s += DELTA_N;
|
|
switch(Bitbase[compute_index(p.whiteKingSquare, p.blackKingSquare, s,
|
|
BLACK)]) {
|
|
case RESULT_LOSS:
|
|
return RESULT_WIN;
|
|
|
|
case RESULT_UNKNOWN:
|
|
unknownFound = true;
|
|
break;
|
|
|
|
case RESULT_DRAW: case RESULT_INVALID:
|
|
break;
|
|
|
|
default:
|
|
assert(false);
|
|
}
|
|
}
|
|
}
|
|
|
|
return unknownFound? RESULT_UNKNOWN : RESULT_DRAW;
|
|
}
|
|
|
|
|
|
Result classify_btm(const KPKPosition &p) {
|
|
|
|
// If one move leads to a position classified as RESULT_DRAW, the result
|
|
// of the current position is RESULT_DRAW. If all moves lead to positions
|
|
// classified as RESULT_WIN, the current position is classified as
|
|
// RESULT_LOSS. Otherwise, the current position is classified as
|
|
// RESULT_UNKNOWN.
|
|
|
|
bool unknownFound = false;
|
|
Bitboard b;
|
|
Square s;
|
|
|
|
// King moves
|
|
b = p.bk_attacks();
|
|
while(b) {
|
|
s = pop_1st_bit(&b);
|
|
switch(Bitbase[compute_index(p.whiteKingSquare, s, p.pawnSquare,
|
|
WHITE)]) {
|
|
case RESULT_DRAW:
|
|
return RESULT_DRAW;
|
|
|
|
case RESULT_UNKNOWN:
|
|
unknownFound = true;
|
|
break;
|
|
|
|
case RESULT_WIN: case RESULT_INVALID:
|
|
break;
|
|
|
|
default:
|
|
assert(false);
|
|
}
|
|
}
|
|
|
|
return unknownFound? RESULT_UNKNOWN : RESULT_LOSS;
|
|
}
|
|
|
|
|
|
int compute_index(Square wksq, Square bksq, Square psq, Color stm) {
|
|
int p = int(square_file(psq)) + (int(square_rank(psq)) - 1) * 4;
|
|
int result = int(stm) + 2*int(bksq) + 128*int(wksq) + 8192*p;
|
|
assert(result >= 0 && result < IndexMax);
|
|
return result;
|
|
}
|
|
|
|
|
|
int compress_result(Result r) {
|
|
return (r == RESULT_WIN || r == RESULT_LOSS)? 1 : 0;
|
|
}
|
|
|
|
}
|