for (File f = FILE_A; f <= FILE_H; ++f)
Zobrist::enpassant[f] = rk.rand<Key>();
- for (int cr = CASTLES_NONE; cr <= ALL_CASTLES; cr++)
+ for (int cr = CASTLES_NONE; cr <= ALL_CASTLES; ++cr)
{
Bitboard b = cr;
while (b)
{
Square sq = file | rank;
- if (is_empty(sq))
+ if (empty(sq))
{
int emptyCnt = 1;
- for ( ; file < FILE_H && is_empty(++sq); ++file)
- emptyCnt++;
+ for ( ; file < FILE_H && empty(++sq); ++file)
+ ++emptyCnt;
ss << emptyCnt;
}
}
-/// Position::pl_move_is_legal() tests whether a pseudo-legal move is legal
+/// Position::legal() tests whether a pseudo-legal move is legal
-bool Position::pl_move_is_legal(Move m, Bitboard pinned) const {
+bool Position::legal(Move m, Bitboard pinned) const {
assert(is_ok(m));
assert(pinned == pinned_pieces());
Color us = sideToMove;
Square from = from_sq(m);
- assert(color_of(piece_moved(m)) == us);
+ assert(color_of(moved_piece(m)) == us);
assert(piece_on(king_square(us)) == make_piece(us, KING));
// En passant captures are a tricky special case. Because they are rather
Bitboard b = (pieces() ^ from ^ capsq) | to;
assert(to == ep_square());
- assert(piece_moved(m) == make_piece(us, PAWN));
+ assert(moved_piece(m) == make_piece(us, PAWN));
assert(piece_on(capsq) == make_piece(them, PAWN));
assert(piece_on(to) == NO_PIECE);
}
-/// Position::is_pseudo_legal() takes a random move and tests whether the move
-/// is pseudo legal. It is used to validate moves from TT that can be corrupted
+/// Position::pseudo_legal() takes a random move and tests whether the move is
+/// pseudo legal. It is used to validate moves from TT that can be corrupted
/// due to SMP concurrent access or hash position key aliasing.
-bool Position::is_pseudo_legal(const Move m) const {
+bool Position::pseudo_legal(const Move m) const {
Color us = sideToMove;
Square from = from_sq(m);
Square to = to_sq(m);
- Piece pc = piece_moved(m);
+ Piece pc = moved_piece(m);
// Use a slower but simpler function for uncommon cases
if (type_of(m) != NORMAL)
case DELTA_N:
case DELTA_S:
// Pawn push. The destination square must be empty.
- if (!is_empty(to))
+ if (!empty(to))
return false;
break;
// rank, and both the destination square and the square between the
// source and destination squares must be empty.
if ( rank_of(to) != RANK_4
- || !is_empty(to)
- || !is_empty(from + DELTA_N))
+ || !empty(to)
+ || !empty(from + DELTA_N))
return false;
break;
// rank, and both the destination square and the square between the
// source and destination squares must be empty.
if ( rank_of(to) != RANK_5
- || !is_empty(to)
- || !is_empty(from + DELTA_S))
+ || !empty(to)
+ || !empty(from + DELTA_S))
return false;
break;
/// Position::move_gives_check() tests whether a pseudo-legal move gives a check
-bool Position::move_gives_check(Move m, const CheckInfo& ci) const {
+bool Position::gives_check(Move m, const CheckInfo& ci) const {
assert(is_ok(m));
assert(ci.dcCandidates == discovered_check_candidates());
- assert(color_of(piece_moved(m)) == sideToMove);
+ assert(color_of(moved_piece(m)) == sideToMove);
Square from = from_sq(m);
Square to = to_sq(m);
void Position::do_move(Move m, StateInfo& newSt) {
CheckInfo ci(*this);
- do_move(m, newSt, ci, move_gives_check(m, ci));
+ do_move(m, newSt, ci, gives_check(m, ci));
}
void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveIsCheck) {
assert(is_ok(m));
assert(&newSt != st);
- nodes++;
+ ++nodes;
Key k = st->key;
// Copy some fields of old state to our new StateInfo object except the ones
// Increment ply counters.In particular rule50 will be later reset it to zero
// in case of a capture or a pawn move.
- gamePly++;
- st->rule50++;
- st->pliesFromNull++;
+ ++gamePly;
+ ++st->rule50;
+ ++st->pliesFromNull;
Color us = sideToMove;
Color them = ~us;
Square to = to_sq(m);
Piece pc = piece_on(from);
PieceType pt = type_of(pc);
- PieceType capture = type_of(m) == ENPASSANT ? PAWN : type_of(piece_on(to));
+ PieceType captured = type_of(m) == ENPASSANT ? PAWN : type_of(piece_on(to));
assert(color_of(pc) == us);
assert(piece_on(to) == NO_PIECE || color_of(piece_on(to)) == them || type_of(m) == CASTLE);
- assert(capture != KING);
+ assert(captured != KING);
if (type_of(m) == CASTLE)
{
Square rfrom = to; // Castle is encoded as "king captures friendly rook"
Square rto = relative_square(us, kingSide ? SQ_F1 : SQ_D1);
to = relative_square(us, kingSide ? SQ_G1 : SQ_C1);
- capture = NO_PIECE_TYPE;
+ captured = NO_PIECE_TYPE;
do_castle(from, to, rfrom, rto);
k ^= Zobrist::psq[us][ROOK][rfrom] ^ Zobrist::psq[us][ROOK][rto];
}
- if (capture)
+ if (captured)
{
Square capsq = to;
// If the captured piece is a pawn, update pawn hash key, otherwise
// update non-pawn material.
- if (capture == PAWN)
+ if (captured == PAWN)
{
if (type_of(m) == ENPASSANT)
{
st->pawnKey ^= Zobrist::psq[them][PAWN][capsq];
}
else
- st->npMaterial[them] -= PieceValue[MG][capture];
+ st->npMaterial[them] -= PieceValue[MG][captured];
// Update board and piece lists
- remove_piece(capsq, them, capture);
+ remove_piece(capsq, them, captured);
// Update material hash key and prefetch access to materialTable
- k ^= Zobrist::psq[them][capture][capsq];
- st->materialKey ^= Zobrist::psq[them][capture][pieceCount[them][capture]];
+ k ^= Zobrist::psq[them][captured][capsq];
+ st->materialKey ^= Zobrist::psq[them][captured][pieceCount[them][captured]];
prefetch((char*)thisThread->materialTable[st->materialKey]);
// Update incremental scores
- st->psq -= psq[them][capture][capsq];
+ st->psq -= psq[them][captured][capsq];
// Reset rule 50 counter
st->rule50 = 0;
st->psq += psq[us][pt][to] - psq[us][pt][from];
// Set capture piece
- st->capturedType = capture;
+ st->capturedType = captured;
// Update the key with the final value
st->key = k;
Square from = from_sq(m);
Square to = to_sq(m);
PieceType pt = type_of(piece_on(to));
- PieceType capture = st->capturedType;
+ PieceType captured = st->capturedType;
- assert(is_empty(from) || type_of(m) == CASTLE);
- assert(capture != KING);
+ assert(empty(from) || type_of(m) == CASTLE);
+ assert(captured != KING);
if (type_of(m) == PROMOTION)
{
Square rfrom = to; // Castle is encoded as "king captures friendly rook"
Square rto = relative_square(us, kingSide ? SQ_F1 : SQ_D1);
to = relative_square(us, kingSide ? SQ_G1 : SQ_C1);
- capture = NO_PIECE_TYPE;
+ captured = NO_PIECE_TYPE;
pt = KING;
do_castle(to, from, rto, rfrom);
}
else
move_piece(to, from, us, pt); // Put the piece back at the source square
- if (capture)
+ if (captured)
{
Square capsq = to;
assert(piece_on(capsq) == NO_PIECE);
}
- put_piece(capsq, them, capture); // Restore the captured piece
+ put_piece(capsq, them, captured); // Restore the captured piece
}
// Finally point our state pointer back to the previous state
st = st->previous;
- gamePly--;
+ --gamePly;
assert(pos_is_ok());
}
st->key ^= Zobrist::side;
prefetch((char*)TT.first_entry(st->key));
- st->rule50++;
+ ++st->rule50;
st->pliesFromNull = 0;
sideToMove = ~sideToMove;
// Early return if SEE cannot be negative because captured piece value
// is not less then capturing one. Note that king moves always return
// here because king midgame value is set to 0.
- if (PieceValue[MG][piece_moved(m)] <= PieceValue[MG][piece_on(to_sq(m))])
+ if (PieceValue[MG][moved_piece(m)] <= PieceValue[MG][piece_on(to_sq(m))])
return 1;
return see(m);
from = from_sq(m);
to = to_sq(m);
- swapList[0] = PieceValue[MG][type_of(piece_on(to))];
+ swapList[0] = PieceValue[MG][piece_on(to)];
stm = color_of(piece_on(from));
occupied = pieces() ^ from;
// Add the new entry to the swap list
swapList[slIndex] = -swapList[slIndex - 1] + PieceValue[MG][captured];
- slIndex++;
+ ++slIndex;
// Locate and remove the next least valuable attacker
captured = min_attacker<PAWN>(byTypeBB, to, stmAttackers, occupied, attackers);
// 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 (--slIndex)
- swapList[slIndex-1] = std::min(-swapList[slIndex], swapList[slIndex-1]);
+ swapList[slIndex - 1] = std::min(-swapList[slIndex], swapList[slIndex - 1]);
return swapList[0];
}
startState.epSquare = SQ_NONE;
st = &startState;
- for (int i = 0; i < PIECE_TYPE_NB; i++)
- for (int j = 0; j < 16; j++)
+ for (int i = 0; i < PIECE_TYPE_NB; ++i)
+ for (int j = 0; j < 16; ++j)
pieceList[WHITE][i][j] = pieceList[BLACK][i][j] = SQ_NONE;
}
for (Square s = SQ_A1; s <= SQ_H8; ++s)
if (type_of(piece_on(s)) == KING)
- kingCount[color_of(piece_on(s))]++;
+ ++kingCount[color_of(piece_on(s))];
if (kingCount[0] != 1 || kingCount[1] != 1)
return false;
if ((*step)++, debugPieceList)
for (Color c = WHITE; c <= BLACK; ++c)
for (PieceType pt = PAWN; pt <= KING; ++pt)
- for (int i = 0; i < pieceCount[c][pt]; i++)
+ for (int i = 0; i < pieceCount[c][pt]; ++i)
if ( board[pieceList[c][pt][i]] != make_piece(c, pt)
|| index[pieceList[c][pt][i]] != i)
return false;