#include <sstream>
#include "bitcount.h"
-#include "mersenne.h"
#include "movegen.h"
#include "movepick.h"
#include "position.h"
#include "psqtab.h"
+#include "rkiss.h"
#include "san.h"
#include "tt.h"
#include "ucioption.h"
using std::cout;
using std::endl;
-static inline bool isZero(char c) { return c == '0'; }
-struct PieceLetters : std::map<char, Piece> {
+////
+//// Position's static data definitions
+////
+
+Key Position::zobrist[2][8][64];
+Key Position::zobEp[64];
+Key Position::zobCastle[16];
+Key Position::zobSideToMove;
+Key Position::zobExclusion;
+
+Score Position::PieceSquareTable[16][64];
+
+// Material values arrays, indexed by Piece
+const Value Position::PieceValueMidgame[17] = {
+ VALUE_ZERO,
+ PawnValueMidgame, KnightValueMidgame, BishopValueMidgame,
+ RookValueMidgame, QueenValueMidgame, VALUE_ZERO,
+ VALUE_ZERO, VALUE_ZERO,
+ PawnValueMidgame, KnightValueMidgame, BishopValueMidgame,
+ RookValueMidgame, QueenValueMidgame
+};
+
+const Value Position::PieceValueEndgame[17] = {
+ VALUE_ZERO,
+ PawnValueEndgame, KnightValueEndgame, BishopValueEndgame,
+ RookValueEndgame, QueenValueEndgame, VALUE_ZERO,
+ VALUE_ZERO, VALUE_ZERO,
+ PawnValueEndgame, KnightValueEndgame, BishopValueEndgame,
+ RookValueEndgame, QueenValueEndgame
+};
+
+// Material values array used by SEE, indexed by PieceType
+const Value Position::seeValues[] = {
+ VALUE_ZERO,
+ PawnValueMidgame, KnightValueMidgame, BishopValueMidgame,
+ RookValueMidgame, QueenValueMidgame, QueenValueMidgame*10
+};
+
+
+namespace {
+
+ // Bonus for having the side to move (modified by Joona Kiiski)
+ const Score TempoValue = make_score(48, 22);
+
+ bool isZero(char c) { return c == '0'; }
+
+ struct PieceLetters : public std::map<char, Piece> {
PieceLetters() {
operator[]('B') = WB; operator[]('b') = BB;
operator[]('N') = WN; operator[]('n') = BN;
operator[]('P') = WP; operator[]('p') = BP;
- operator[](' ') = NO_PIECE; operator[]('.') = NO_PIECE_DARK_SQ;
+ operator[](' ') = PIECE_NONE;
+ operator[]('.') = PIECE_NONE_DARK_SQ;
}
char from_piece(Piece p) const {
- std::map<char, Piece>::const_iterator it;
- for (it = begin(); it != end(); ++it)
- if (it->second == p)
- return it->first;
+ std::map<char, Piece>::const_iterator it;
+ for (it = begin(); it != end(); ++it)
+ if (it->second == p)
+ return it->first;
- assert(false);
- return 0;
+ assert(false);
+ return 0;
}
-};
-
-////
-//// Variables
-////
-
-Key Position::zobrist[2][8][64];
-Key Position::zobEp[64];
-Key Position::zobCastle[16];
-Key Position::zobSideToMove;
-Key Position::zobExclusion;
-
-Score Position::PieceSquareTable[16][64];
+ };
-static PieceLetters pieceLetters;
+ PieceLetters pieceLetters;
+}
-/// Constructors
+/// CheckInfo c'tor
CheckInfo::CheckInfo(const Position& pos) {
/// or the FEN string, we want the new born Position object do not depend
/// on any external data so we detach state pointer from the source one.
-Position::Position(int th) : threadID(th) {}
-
Position::Position(const Position& pos, int th) {
memcpy(this, &pos, sizeof(Position));
detach(); // Always detach() in copy c'tor to avoid surprises
threadID = th;
+ nodes = 0;
}
Position::Position(const string& fen, int th) {
{
if (isdigit(token))
{
- file += token - '0'; // Skip the given number of files
+ file += File(token - '0'); // Skip the given number of files
continue;
}
else if (token == '/')
castleRightsMask[make_square(initialQRFile, RANK_1)] ^= WHITE_OOO;
castleRightsMask[make_square(initialQRFile, RANK_8)] ^= BLACK_OOO;
+ isChess960 = initialKFile != FILE_E
+ || initialQRFile != FILE_A
+ || initialKRFile != FILE_H;
+
find_checkers();
st->key = compute_key();
for (Square sq = sqH; sq >= sqA; sq--)
if (piece_on(sq) == rook)
{
- allow_oo(c);
+ do_allow_oo(c);
initialKRFile = square_file(sq);
break;
}
for (Square sq = sqA; sq <= sqH; sq++)
if (piece_on(sq) == rook)
{
- allow_ooo(c);
+ do_allow_ooo(c);
initialQRFile = square_file(sq);
break;
}
File rookFile = File(token - 'A') + FILE_A;
if (rookFile < initialKFile)
{
- allow_ooo(c);
+ do_allow_ooo(c);
initialQRFile = rookFile;
}
else
{
- allow_oo(c);
+ do_allow_oo(c);
initialKRFile = rookFile;
}
}
fen.erase(--fen.end());
fen += (sideToMove == WHITE ? " w " : " b ");
- if (st->castleRights != NO_CASTLES)
+ if (st->castleRights != CASTLES_NONE)
{
- const bool Chess960 = initialKFile != FILE_E
- || initialQRFile != FILE_A
- || initialKRFile != FILE_H;
-
if (can_castle_kingside(WHITE))
- fen += Chess960 ? char(toupper(file_to_char(initialKRFile))) : 'K';
+ fen += isChess960 ? char(toupper(file_to_char(initialKRFile))) : 'K';
if (can_castle_queenside(WHITE))
- fen += Chess960 ? char(toupper(file_to_char(initialQRFile))) : 'Q';
+ fen += isChess960 ? char(toupper(file_to_char(initialQRFile))) : 'Q';
if (can_castle_kingside(BLACK))
- fen += Chess960 ? file_to_char(initialKRFile) : 'k';
+ fen += isChess960 ? file_to_char(initialKRFile) : 'k';
if (can_castle_queenside(BLACK))
- fen += Chess960 ? file_to_char(initialQRFile) : 'q';
+ fen += isChess960 ? file_to_char(initialQRFile) : 'q';
} else
fen += '-';
/// Position::print() prints an ASCII representation of the position to
-/// the standard output. If a move is given then also the san is print.
+/// the standard output. If a move is given then also the san is printed.
void Position::print(Move move) const {
char c = (color_of_piece_on(sq) == BLACK ? '=' : ' ');
Piece piece = piece_on(sq);
- if (piece == NO_PIECE && square_color(sq) == DARK)
- piece = NO_PIECE_DARK_SQ;
+ if (piece == PIECE_NONE && square_color(sq) == DARK)
+ piece = PIECE_NONE_DARK_SQ;
cout << c << pieceLetters.from_piece(piece) << c << '|';
}
switch (p)
{
- case WP: return attacks_from<PAWN>(s, WHITE);
- case BP: return attacks_from<PAWN>(s, BLACK);
- case WN: case BN: return attacks_from<KNIGHT>(s);
case WB: case BB: return attacks_from<BISHOP>(s);
case WR: case BR: return attacks_from<ROOK>(s);
case WQ: case BQ: return attacks_from<QUEEN>(s);
- case WK: case BK: return attacks_from<KING>(s);
- default: break;
+ default: return StepAttackBB[p][s];
+ }
+}
+
+Bitboard Position::attacks_from(Piece p, Square s, Bitboard occ) {
+
+ assert(square_is_ok(s));
+
+ switch (p)
+ {
+ case WB: case BB: return bishop_attacks_bb(s, occ);
+ case WR: case BR: return rook_attacks_bb(s, occ);
+ case WQ: case BQ: return bishop_attacks_bb(s, occ) | rook_attacks_bb(s, occ);
+ default: return StepAttackBB[p][s];
}
- return false;
}
assert(move_is_ok(m));
assert(square_is_ok(s));
+ Bitboard occ, xray;
Square f = move_from(m), t = move_to(m);
assert(square_is_occupied(f));
return true;
// Move the piece and scan for X-ray attacks behind it
- Bitboard occ = occupied_squares();
- Color us = color_of_piece_on(f);
- clear_bit(&occ, f);
- set_bit(&occ, t);
- Bitboard xray = ( (rook_attacks_bb(s, occ) & pieces(ROOK, QUEEN))
- |(bishop_attacks_bb(s, occ) & pieces(BISHOP, QUEEN))) & pieces_of_color(us);
+ occ = occupied_squares();
+ do_move_bb(&occ, make_move_bb(f, t));
+ xray = ( (rook_attacks_bb(s, occ) & pieces(ROOK, QUEEN))
+ |(bishop_attacks_bb(s, occ) & pieces(BISHOP, QUEEN)))
+ & pieces_of_color(color_of_piece_on(f));
// If we have attacks we need to verify that are caused by our move
// and are not already existent ones.
if (move_is_castle(m))
return true;
- Color us = side_to_move();
- Square from = move_from(m);
-
- assert(color_of_piece_on(from) == us);
- assert(piece_on(king_square(us)) == piece_of_color_and_type(us, KING));
-
// En passant captures are a tricky special case. Because they are
// rather uncommon, we do it simply by testing whether the king is attacked
// after the move is made
if (move_is_ep(m))
{
+ Color us = side_to_move();
Color them = opposite_color(us);
+ Square from = move_from(m);
Square to = move_to(m);
Square capsq = make_square(square_file(to), square_rank(from));
- Bitboard b = occupied_squares();
Square ksq = king_square(us);
+ Bitboard b = occupied_squares();
assert(to == ep_square());
assert(piece_on(from) == piece_of_color_and_type(us, PAWN));
assert(piece_on(capsq) == piece_of_color_and_type(them, PAWN));
- assert(piece_on(to) == NO_PIECE);
+ assert(piece_on(to) == PIECE_NONE);
clear_bit(&b, from);
clear_bit(&b, capsq);
&& !(bishop_attacks_bb(ksq, b) & pieces(BISHOP, QUEEN, them));
}
+ Color us = side_to_move();
+ Square from = move_from(m);
+
+ assert(color_of_piece_on(from) == us);
+ assert(piece_on(king_square(us)) == piece_of_color_and_type(us, KING));
+
// If the moving piece is a king, check whether the destination
// square is attacked by the opponent.
if (type_of_piece_on(from) == KING)
assert(is_ok());
assert(move_is_ok(m));
+ nodes++;
Key key = st->key;
// Copy some fields of old state to our new StateInfo object except the
Value npMaterial[2];
};
- memcpy(&newSt, st, sizeof(ReducedStateInfo));
+ if (&newSt != st)
+ memcpy(&newSt, st, sizeof(ReducedStateInfo));
+
newSt.previous = st;
st = &newSt;
do_move_bb(&(byTypeBB[0]), move_bb); // HACK: byTypeBB[0] == occupied squares
board[to] = board[from];
- board[from] = NO_PIECE;
+ board[from] = PIECE_NONE;
// Update piece lists, note that index[from] is not updated and
// becomes stale. This works as long as index[] is accessed just
// Reset rule 50 draw counter
st->rule50 = 0;
- // Update pawn hash key
+ // Update pawn hash key and prefetch in L1/L2 cache
st->pawnKey ^= zobrist[us][PAWN][from] ^ zobrist[us][PAWN][to];
+ prefetchPawn(st->pawnKey, threadID);
// Set en passant square, only if moved pawn can be captured
if ((to ^ from) == 16)
st->value += pst(us, promotion, to);
// Update material
- st->npMaterial[us] += piece_value_midgame(promotion);
+ st->npMaterial[us] += PieceValueMidgame[promotion];
}
}
st->value += pst_delta(piece, from, to);
// Set capture piece
- st->capture = capture;
+ st->capturedType = capture;
// Update the key with the final value
st->key = key;
assert(to == st->epSquare);
assert(relative_rank(opposite_color(them), to) == RANK_6);
- assert(piece_on(to) == NO_PIECE);
+ assert(piece_on(to) == PIECE_NONE);
assert(piece_on(capsq) == piece_of_color_and_type(them, PAWN));
- board[capsq] = NO_PIECE;
+ board[capsq] = PIECE_NONE;
}
st->pawnKey ^= zobrist[them][PAWN][capsq];
}
else
- st->npMaterial[them] -= piece_value_midgame(capture);
+ st->npMaterial[them] -= PieceValueMidgame[capture];
// Remove captured piece
clear_bit(&(byColorBB[them]), capsq);
Color them = opposite_color(us);
// Reset capture field
- st->capture = NO_PIECE_TYPE;
+ st->capturedType = PIECE_TYPE_NONE;
// Find source squares for king and rook
Square kfrom = move_from(m);
// Update board array
Piece king = piece_of_color_and_type(us, KING);
Piece rook = piece_of_color_and_type(us, ROOK);
- board[kfrom] = board[rfrom] = NO_PIECE;
+ board[kfrom] = board[rfrom] = PIECE_NONE;
board[kto] = king;
board[rto] = rook;
do_move_bb(&(byTypeBB[0]), move_bb); // HACK: byTypeBB[0] == occupied squares
board[from] = piece_of_color_and_type(us, pt);
- board[to] = NO_PIECE;
+ board[to] = PIECE_NONE;
// Update piece list
index[from] = index[to];
pieceList[us][pt][index[from]] = from;
- if (st->capture)
+ if (st->capturedType)
{
Square capsq = to;
if (ep)
capsq = (us == WHITE)? (to - DELTA_N) : (to - DELTA_S);
- assert(st->capture != KING);
+ assert(st->capturedType != KING);
assert(!ep || square_is_empty(capsq));
// Restore the captured piece
set_bit(&(byColorBB[them]), capsq);
- set_bit(&(byTypeBB[st->capture]), capsq);
+ set_bit(&(byTypeBB[st->capturedType]), capsq);
set_bit(&(byTypeBB[0]), capsq);
- board[capsq] = piece_of_color_and_type(them, st->capture);
+ board[capsq] = piece_of_color_and_type(them, st->capturedType);
// Update piece count
- pieceCount[them][st->capture]++;
+ pieceCount[them][st->capturedType]++;
// Update piece list, add a new captured piece in capsq square
- index[capsq] = pieceCount[them][st->capture] - 1;
- pieceList[them][st->capture][index[capsq]] = capsq;
+ index[capsq] = pieceCount[them][st->capturedType] - 1;
+ pieceList[them][st->capturedType][index[capsq]] = capsq;
}
// Finally point our state pointer back to the previous state
set_bit(&(byTypeBB[0]), rfrom); // HACK: byTypeBB[0] == occupied squares
// Update board
- board[rto] = board[kto] = NO_PIECE;
+ board[rto] = board[kto] = PIECE_NONE;
board[rfrom] = piece_of_color_and_type(us, ROOK);
board[kfrom] = piece_of_color_and_type(us, KING);
/// move, and one which takes a 'from' and a 'to' square. The function does
/// not yet understand promotions captures.
-int Position::see(Square to) const {
-
- assert(square_is_ok(to));
- return see(SQ_NONE, to);
-}
-
int Position::see(Move m) const {
assert(move_is_ok(m));
int Position::see(Square from, Square to) const {
- // Material values
- static const int seeValues[18] = {
- 0, PawnValueMidgame, KnightValueMidgame, BishopValueMidgame,
- RookValueMidgame, QueenValueMidgame, QueenValueMidgame*10, 0,
- 0, PawnValueMidgame, KnightValueMidgame, BishopValueMidgame,
- RookValueMidgame, QueenValueMidgame, QueenValueMidgame*10, 0,
- 0, 0
- };
-
- Bitboard attackers, stmAttackers, b;
+ Bitboard occupied, attackers, stmAttackers, b;
+ int swapList[32], slIndex = 1;
+ PieceType capturedType, pt;
+ Color stm;
- assert(square_is_ok(from) || from == SQ_NONE);
+ assert(square_is_ok(from));
assert(square_is_ok(to));
- // Initialize colors
- Color us = (from != SQ_NONE ? color_of_piece_on(from) : opposite_color(color_of_piece_on(to)));
- Color them = opposite_color(us);
-
- // Initialize pieces
- Piece piece = piece_on(from);
- Piece capture = piece_on(to);
- Bitboard occ = occupied_squares();
+ capturedType = type_of_piece_on(to);
// King cannot be recaptured
- if (type_of_piece(piece) == KING)
- return seeValues[capture];
+ if (capturedType == KING)
+ return seeValues[capturedType];
+
+ occupied = occupied_squares();
// Handle en passant moves
if (st->epSquare == to && type_of_piece_on(from) == PAWN)
{
- assert(capture == NO_PIECE);
+ Square capQq = (side_to_move() == WHITE ? to - DELTA_N : to - DELTA_S);
- Square capQq = (side_to_move() == WHITE)? (to - DELTA_N) : (to - DELTA_S);
- capture = piece_on(capQq);
+ assert(capturedType == PIECE_TYPE_NONE);
assert(type_of_piece_on(capQq) == PAWN);
// Remove the captured pawn
- clear_bit(&occ, capQq);
+ clear_bit(&occupied, capQq);
+ capturedType = PAWN;
}
- while (true)
- {
- // Find all attackers to the destination square, with the moving piece
- // removed, but possibly an X-ray attacker added behind it.
- clear_bit(&occ, from);
- attackers = (rook_attacks_bb(to, occ) & pieces(ROOK, QUEEN))
- | (bishop_attacks_bb(to, occ) & pieces(BISHOP, QUEEN))
- | (attacks_from<KNIGHT>(to) & pieces(KNIGHT))
- | (attacks_from<KING>(to) & pieces(KING))
- | (attacks_from<PAWN>(to, WHITE) & pieces(PAWN, BLACK))
- | (attacks_from<PAWN>(to, BLACK) & pieces(PAWN, WHITE));
-
- if (from != SQ_NONE)
- break;
-
- // If we don't have any attacker we are finished
- if ((attackers & pieces_of_color(us)) == EmptyBoardBB)
- return 0;
-
- // Locate the least valuable attacker to the destination square
- // and use it to initialize from square.
- stmAttackers = attackers & pieces_of_color(us);
- PieceType pt;
- for (pt = PAWN; !(stmAttackers & pieces(pt)); pt++)
- assert(pt < KING);
-
- from = first_1(stmAttackers & pieces(pt));
- piece = piece_on(from);
- }
+ // Find all attackers to the destination square, with the moving piece
+ // removed, but possibly an X-ray attacker added behind it.
+ clear_bit(&occupied, from);
+ attackers = (rook_attacks_bb(to, occupied) & pieces(ROOK, QUEEN))
+ | (bishop_attacks_bb(to, occupied)& pieces(BISHOP, QUEEN))
+ | (attacks_from<KNIGHT>(to) & pieces(KNIGHT))
+ | (attacks_from<KING>(to) & pieces(KING))
+ | (attacks_from<PAWN>(to, WHITE) & pieces(PAWN, BLACK))
+ | (attacks_from<PAWN>(to, BLACK) & pieces(PAWN, WHITE));
// If the opponent has no attackers we are finished
- stmAttackers = attackers & pieces_of_color(them);
+ stm = opposite_color(color_of_piece_on(from));
+ stmAttackers = attackers & pieces_of_color(stm);
if (!stmAttackers)
- return seeValues[capture];
-
- attackers &= occ; // Remove the moving piece
+ return seeValues[capturedType];
// The destination square is defended, which makes things rather more
// difficult to compute. We proceed by building up a "swap list" containing
// destination square, where the sides alternately capture, and always
// capture with the least valuable piece. After each capture, we look for
// new X-ray attacks from behind the capturing piece.
- int lastCapturingPieceValue = seeValues[piece];
- int swapList[32], n = 1;
- Color c = them;
- PieceType pt;
-
- swapList[0] = seeValues[capture];
+ swapList[0] = seeValues[capturedType];
+ capturedType = type_of_piece_on(from);
do {
// Locate the least valuable attacker for the side to move. The loop
for (pt = PAWN; !(stmAttackers & pieces(pt)); pt++)
assert(pt < KING);
- // Remove the attacker we just found from the 'attackers' bitboard,
+ // Remove the attacker we just found from the 'occupied' bitboard,
// and scan for new X-ray attacks behind the attacker.
b = stmAttackers & pieces(pt);
- occ ^= (b & (~b + 1));
- attackers |= (rook_attacks_bb(to, occ) & pieces(ROOK, QUEEN))
- | (bishop_attacks_bb(to, occ) & pieces(BISHOP, QUEEN));
+ occupied ^= (b & (~b + 1));
+ attackers |= (rook_attacks_bb(to, occupied) & pieces(ROOK, QUEEN))
+ | (bishop_attacks_bb(to, occupied) & pieces(BISHOP, QUEEN));
- attackers &= occ;
+ attackers &= occupied; // Cut out pieces we've already done
// Add the new entry to the swap list
- assert(n < 32);
- swapList[n] = -swapList[n - 1] + lastCapturingPieceValue;
- n++;
-
- // Remember the value of the capturing piece, and change the side to move
- // before beginning the next iteration
- lastCapturingPieceValue = seeValues[pt];
- c = opposite_color(c);
- stmAttackers = attackers & pieces_of_color(c);
-
- // Stop after a king capture
- if (pt == KING && stmAttackers)
+ assert(slIndex < 32);
+ swapList[slIndex] = -swapList[slIndex - 1] + seeValues[capturedType];
+ slIndex++;
+
+ // Remember the value of the capturing piece, and change the side to
+ // move before beginning the next iteration.
+ capturedType = pt;
+ stm = opposite_color(stm);
+ stmAttackers = attackers & pieces_of_color(stm);
+
+ // Stop before processing a king capture
+ if (capturedType == KING && stmAttackers)
{
- assert(n < 32);
- swapList[n++] = QueenValueMidgame*10;
+ assert(slIndex < 32);
+ swapList[slIndex++] = QueenValueMidgame*10;
break;
}
} while (stmAttackers);
// Having built the swap list, we negamax through it to find the best
- // achievable score from the point of view of the side to move
- while (--n)
- swapList[n-1] = Min(-swapList[n], swapList[n-1]);
+ // achievable score from the point of view of the side to move.
+ while (--slIndex)
+ swapList[slIndex-1] = Min(-swapList[slIndex], swapList[slIndex-1]);
return swapList[0];
}
memset(st, 0, sizeof(StateInfo));
st->epSquare = SQ_NONE;
startPosPlyCounter = 0;
+ nodes = 0;
memset(byColorBB, 0, sizeof(Bitboard) * 2);
memset(byTypeBB, 0, sizeof(Bitboard) * 8);
memset(index, 0, sizeof(int) * 64);
for (int i = 0; i < 64; i++)
- board[i] = NO_PIECE;
+ board[i] = PIECE_NONE;
for (int i = 0; i < 8; i++)
for (int j = 0; j < 16; j++)
}
/// Position::put_piece() puts a piece on the given square of the board,
-/// updating the board array, bitboards, and piece counts.
+/// updating the board array, pieces list, bitboards, and piece counts.
void Position::put_piece(Piece p, Square s) {
PieceType pt = type_of_piece(p);
board[s] = p;
- index[s] = pieceCount[c][pt];
+ index[s] = pieceCount[c][pt]++;
pieceList[c][pt][index[s]] = s;
set_bit(&(byTypeBB[pt]), s);
set_bit(&(byColorBB[c]), s);
- set_bit(&byTypeBB[0], s); // HACK: byTypeBB[0] contains all occupied squares.
-
- pieceCount[c][pt]++;
-}
-
-
-/// Position::allow_oo() gives the given side the right to castle kingside.
-/// Used when setting castling rights during parsing of FEN strings.
-
-void Position::allow_oo(Color c) {
-
- st->castleRights |= (1 + int(c));
-}
-
-
-/// Position::allow_ooo() gives the given side the right to castle queenside.
-/// Used when setting castling rights during parsing of FEN strings.
-
-void Position::allow_ooo(Color c) {
-
- st->castleRights |= (4 + 4*int(c));
+ set_bit(&(byTypeBB[0]), s); // HACK: byTypeBB[0] contains all occupied squares.
}
Key Position::compute_key() const {
- Key result = Key(0ULL);
+ Key result = zobCastle[st->castleRights];
for (Square s = SQ_A1; s <= SQ_H8; s++)
if (square_is_occupied(s))
if (ep_square() != SQ_NONE)
result ^= zobEp[ep_square()];
- result ^= zobCastle[st->castleRights];
if (side_to_move() == BLACK)
result ^= zobSideToMove;
Key Position::compute_pawn_key() const {
- Key result = Key(0ULL);
Bitboard b;
- Square s;
+ Key result = 0;
for (Color c = WHITE; c <= BLACK; c++)
{
b = pieces(PAWN, c);
while (b)
- {
- s = pop_1st_bit(&b);
- result ^= zobrist[c][PAWN][s];
- }
+ result ^= zobrist[c][PAWN][pop_1st_bit(&b)];
}
return result;
}
Key Position::compute_material_key() const {
- Key result = Key(0ULL);
+ int count;
+ Key result = 0;
+
for (Color c = WHITE; c <= BLACK; c++)
for (PieceType pt = PAWN; pt <= QUEEN; pt++)
{
- int count = piece_count(c, pt);
+ count = piece_count(c, pt);
for (int i = 0; i < count; i++)
result ^= zobrist[c][pt][i];
}
/// updated by do_move and undo_move when the program is running in debug mode.
Score Position::compute_value() const {
- Score result = make_score(0, 0);
Bitboard b;
- Square s;
+ Score result = SCORE_ZERO;
for (Color c = WHITE; c <= BLACK; c++)
for (PieceType pt = PAWN; pt <= KING; pt++)
{
b = pieces(pt, c);
while (b)
- {
- s = pop_1st_bit(&b);
- assert(piece_on(s) == piece_of_color_and_type(c, pt));
- result += pst(c, pt, s);
- }
+ result += pst(c, pt, pop_1st_bit(&b));
}
result += (side_to_move() == WHITE ? TempoValue / 2 : -TempoValue / 2);
/// Position::compute_non_pawn_material() computes the total non-pawn middle
-/// game material score for the given side. Material scores are updated
+/// game material value for the given side. Material values are updated
/// incrementally during the search, this function is only used while
/// initializing a new Position object.
Value Position::compute_non_pawn_material(Color c) const {
- Value result = Value(0);
+ Value result = VALUE_ZERO;
for (PieceType pt = KNIGHT; pt <= QUEEN; pt++)
- {
- Bitboard b = pieces(pt, c);
- while (b)
- {
- assert(piece_on(first_1(b)) == piece_of_color_and_type(c, pt));
- pop_1st_bit(&b);
- result += piece_value_midgame(pt);
- }
- }
+ result += piece_count(c, pt) * PieceValueMidgame[pt];
+
return result;
}
/// Position::is_draw() tests whether the position is drawn by material,
/// repetition, or the 50 moves rule. It does not detect stalemates, this
/// must be done by the search.
-// FIXME: Currently we are not handling 50 move rule correctly when in check
bool Position::is_draw() const {
return true;
// Draw by the 50 moves rule?
- if (st->rule50 > 100 || (st->rule50 == 100 && !is_check()))
+ if (st->rule50 > 99 && (st->rule50 > 100 || !is_mate()))
return true;
// Draw by repetition?
bool Position::is_mate() const {
- MoveStack moves[256];
- return is_check() && (generate_moves(*this, moves, false) == moves);
+ MoveStack moves[MOVES_MAX];
+ return is_check() && generate_moves(*this, moves) == moves;
}
-/// Position::has_mate_threat() tests whether a given color has a mate in one
-/// from the current position.
+/// Position::has_mate_threat() tests whether the side to move is under
+/// a threat of being mated in one from the current position.
-bool Position::has_mate_threat(Color c) {
+bool Position::has_mate_threat() {
+ MoveStack mlist[MOVES_MAX], *last, *cur;
StateInfo st1, st2;
- Color stm = side_to_move();
+ bool mateFound = false;
+ // If we are under check it's up to evasions to do the job
if (is_check())
return false;
- // If the input color is not equal to the side to move, do a null move
- if (c != stm)
- do_null_move(st1);
-
- MoveStack mlist[120];
- bool result = false;
- Bitboard pinned = pinned_pieces(sideToMove);
+ // First pass the move to our opponent doing a null move
+ do_null_move(st1);
- // Generate pseudo-legal non-capture and capture check moves
- MoveStack* last = generate_non_capture_checks(*this, mlist);
+ // Then generate pseudo-legal moves that could give check
+ last = generate_non_capture_checks(*this, mlist);
last = generate_captures(*this, last);
- // Loop through the moves, and see if one of them is mate
- for (MoveStack* cur = mlist; cur != last; cur++)
+ // Loop through the moves, and see if one of them gives mate
+ Bitboard pinned = pinned_pieces(sideToMove);
+ CheckInfo ci(*this);
+ for (cur = mlist; cur != last && !mateFound; cur++)
{
Move move = cur->move;
- if (!pl_move_is_legal(move, pinned))
+ if ( !pl_move_is_legal(move, pinned)
+ || !move_is_check(move, ci))
continue;
- do_move(move, st2);
+ do_move(move, st2, ci, true);
+
if (is_mate())
- result = true;
+ mateFound = true;
undo_move(move);
}
- // Undo null move, if necessary
- if (c != stm)
- undo_null_move();
-
- return result;
+ undo_null_move();
+ return mateFound;
}
-/// Position::init_zobrist() is a static member function which initializes the
-/// various arrays used to compute hash keys.
+/// Position::init_zobrist() is a static member function which initializes at
+/// startup the various arrays used to compute hash keys.
void Position::init_zobrist() {
- for (int i = 0; i < 2; i++)
- for (int j = 0; j < 8; j++)
- for (int k = 0; k < 64; k++)
- zobrist[i][j][k] = Key(genrand_int64());
+ int i,j, k;
+ RKISS rk;
- for (int i = 0; i < 64; i++)
- zobEp[i] = Key(genrand_int64());
+ for (i = 0; i < 2; i++) for (j = 0; j < 8; j++) for (k = 0; k < 64; k++)
+ zobrist[i][j][k] = rk.rand<Key>();
+
+ for (i = 0; i < 64; i++)
+ zobEp[i] = rk.rand<Key>();
- for (int i = 0; i < 16; i++)
- zobCastle[i] = genrand_int64();
+ for (i = 0; i < 16; i++)
+ zobCastle[i] = rk.rand<Key>();
- zobSideToMove = genrand_int64();
- zobExclusion = genrand_int64();
+ zobSideToMove = rk.rand<Key>();
+ zobExclusion = rk.rand<Key>();
}
/// Position::init_piece_square_tables() initializes the piece square tables.
-/// This is a two-step operation:
-/// First, the white halves of the tables are
-/// copied from the MgPST[][] and EgPST[][] arrays.
-/// Second, the black halves of the tables are initialized by mirroring
-/// and changing the sign of the corresponding white scores.
+/// This is a two-step operation: First, the white halves of the tables are
+/// copied from the MgPST[][] and EgPST[][] arrays. Second, the black halves
+/// of the tables are initialized by mirroring and changing the sign of the
+/// corresponding white scores.
void Position::init_piece_square_tables() {
// Board
for (Square s = SQ_A1; s <= SQ_H8; s++)
if (!pos.square_is_empty(s))
- put_piece(Piece(int(pos.piece_on(s)) ^ 8), flip_square(s));
+ put_piece(Piece(pos.piece_on(s) ^ 8), flip_square(s));
// Side to move
sideToMove = opposite_color(pos.side_to_move());
// Castling rights
- if (pos.can_castle_kingside(WHITE)) allow_oo(BLACK);
- if (pos.can_castle_queenside(WHITE)) allow_ooo(BLACK);
- if (pos.can_castle_kingside(BLACK)) allow_oo(WHITE);
- if (pos.can_castle_queenside(BLACK)) allow_ooo(WHITE);
+ if (pos.can_castle_kingside(WHITE)) do_allow_oo(BLACK);
+ if (pos.can_castle_queenside(WHITE)) do_allow_ooo(BLACK);
+ if (pos.can_castle_kingside(BLACK)) do_allow_oo(WHITE);
+ if (pos.can_castle_queenside(BLACK)) do_allow_ooo(WHITE);
initialKFile = pos.initialKFile;
initialKRFile = pos.initialKRFile;
bool Position::is_ok(int* failedStep) const {
// What features of the position should be verified?
- static const bool debugBitboards = false;
- static const bool debugKingCount = false;
- static const bool debugKingCapture = false;
- static const bool debugCheckerCount = false;
- static const bool debugKey = false;
- static const bool debugMaterialKey = false;
- static const bool debugPawnKey = false;
- static const bool debugIncrementalEval = false;
- static const bool debugNonPawnMaterial = false;
- static const bool debugPieceCounts = false;
- static const bool debugPieceList = false;
- static const bool debugCastleSquares = false;
+ const bool debugAll = false;
+
+ const bool debugBitboards = debugAll || false;
+ const bool debugKingCount = debugAll || false;
+ const bool debugKingCapture = debugAll || false;
+ const bool debugCheckerCount = debugAll || false;
+ const bool debugKey = debugAll || false;
+ const bool debugMaterialKey = debugAll || false;
+ const bool debugPawnKey = debugAll || false;
+ const bool debugIncrementalEval = debugAll || false;
+ const bool debugNonPawnMaterial = debugAll || false;
+ const bool debugPieceCounts = debugAll || false;
+ const bool debugPieceList = debugAll || false;
+ const bool debugCastleSquares = debugAll || false;
if (failedStep) *failedStep = 1;
// Is there more than 2 checkers?
if (failedStep) (*failedStep)++;
- if (debugCheckerCount && count_1s(st->checkersBB) > 2)
+ if (debugCheckerCount && count_1s<CNT32>(st->checkersBB) > 2)
return false;
// Bitboards OK?
if (debugPieceCounts)
for (Color c = WHITE; c <= BLACK; c++)
for (PieceType pt = PAWN; pt <= KING; pt++)
- if (pieceCount[c][pt] != count_1s(pieces(pt, c)))
+ if (pieceCount[c][pt] != count_1s<CNT32>(pieces(pt, c)))
return false;
if (failedStep) (*failedStep)++;