Key Position::zobMaterial[2][8][16];
Key Position::zobSideToMove;
-Value Position::MgPieceSquareTable[16][64];
-Value Position::EgPieceSquareTable[16][64];
+Score Position::PieceSquareTable[16][64];
static bool RequestPending = false;
st->key = compute_key();
st->pawnKey = compute_pawn_key();
st->materialKey = compute_material_key();
- st->mgValue = compute_value<MidGame>();
- st->egValue = compute_value<EndGame>();
+ st->value = compute_value();
st->npMaterial[WHITE] = compute_non_pawn_material(WHITE);
st->npMaterial[BLACK] = compute_non_pawn_material(BLACK);
}
Bitboard Position::attackers_to(Square s) const {
- return (pawn_attacks_from(s, BLACK) & pieces(PAWN, WHITE))
- | (pawn_attacks_from(s, WHITE) & pieces(PAWN, BLACK))
- | (piece_attacks_from<KNIGHT>(s) & pieces(KNIGHT))
- | (piece_attacks_from<ROOK>(s) & pieces(ROOK, QUEEN))
- | (piece_attacks_from<BISHOP>(s) & pieces(BISHOP, QUEEN))
- | (piece_attacks_from<KING>(s) & pieces(KING));
+ return (attacks_from<PAWN>(s, BLACK) & pieces(PAWN, WHITE))
+ | (attacks_from<PAWN>(s, WHITE) & pieces(PAWN, BLACK))
+ | (attacks_from<KNIGHT>(s) & pieces(KNIGHT))
+ | (attacks_from<ROOK>(s) & pieces(ROOK, QUEEN))
+ | (attacks_from<BISHOP>(s) & pieces(BISHOP, QUEEN))
+ | (attacks_from<KING>(s) & pieces(KING));
}
-/// Position::piece_attacks_from() computes a bitboard of all attacks
+/// Position::attacks_from() computes a bitboard of all attacks
/// of a given piece put in a given square.
-Bitboard Position::piece_attacks_from(Piece p, Square s) const {
+Bitboard Position::attacks_from(Piece p, Square s) const {
assert(square_is_ok(s));
switch (p)
{
- case WP: return pawn_attacks_from(s, WHITE);
- case BP: return pawn_attacks_from(s, BLACK);
- case WN: case BN: return piece_attacks_from<KNIGHT>(s);
- case WB: case BB: return piece_attacks_from<BISHOP>(s);
- case WR: case BR: return piece_attacks_from<ROOK>(s);
- case WQ: case BQ: return piece_attacks_from<QUEEN>(s);
- case WK: case BK: return piece_attacks_from<KING>(s);
+ 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;
}
return false;
assert(square_is_occupied(f));
- if (bit_is_set(piece_attacks_from(piece_on(f), t), s))
+ if (bit_is_set(attacks_from(piece_on(f), t), s))
return true;
// Move the piece and scan for X-ray attacks behind it
// If we have attacks we need to verify that are caused by our move
// and are not already existent ones.
- return xray && (xray ^ (xray & piece_attacks_from<QUEEN>(s)));
+ return xray && (xray ^ (xray & attacks_from<QUEEN>(s)));
}
/// Position::pl_move_is_legal() tests whether a pseudo-legal move is legal
-bool Position::pl_move_is_legal(Move m) const {
-
- // If we're in check, all pseudo-legal moves are legal, because our
- // check evasion generator only generates true legal moves.
- return is_check() || pl_move_is_legal(m, pinned_pieces(side_to_move()));
-}
-
bool Position::pl_move_is_legal(Move m, Bitboard pinned) const {
assert(is_ok());
assert(move_is_ok(m));
assert(pinned == pinned_pieces(side_to_move()));
- assert(!is_check());
// Castling moves are checked for legality during move generation.
if (move_is_castle(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
+ // 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))
}
+/// Position::pl_move_is_evasion() tests whether a pseudo-legal move is a legal evasion
+
+bool Position::pl_move_is_evasion(Move m, Bitboard pinned) const
+{
+ assert(is_check());
+
+ Color us = side_to_move();
+ Square from = move_from(m);
+ Square to = move_to(m);
+
+ // King moves and en-passant captures are verified in pl_move_is_legal()
+ if (type_of_piece_on(from) == KING || move_is_ep(m))
+ return pl_move_is_legal(m, pinned);
+
+ Bitboard target = checkers();
+ Square checksq = pop_1st_bit(&target);
+
+ if (target) // double check ?
+ return false;
+
+ // Our move must be a blocking evasion or a capture of the checking piece
+ target = squares_between(checksq, king_square(us)) | checkers();
+ return bit_is_set(target, to) && pl_move_is_legal(m, pinned);
+}
+
+
/// Position::move_is_check() tests whether a pseudo-legal move is a check
bool Position::move_is_check(Move m) const {
{
case PAWN:
- if (bit_is_set(pawn_attacks_from(ksq, them), to)) // Normal check?
+ if (bit_is_set(attacks_from<PAWN>(ksq, them), to)) // Normal check?
return true;
if ( dcCandidates // Discovered check?
switch (move_promotion_piece(m))
{
case KNIGHT:
- return bit_is_set(piece_attacks_from<KNIGHT>(to), ksq);
+ return bit_is_set(attacks_from<KNIGHT>(to), ksq);
case BISHOP:
return bit_is_set(bishop_attacks_bb(to, b), ksq);
case ROOK:
// Test discovered check and normal check according to piece type
case KNIGHT:
return (dcCandidates && bit_is_set(dcCandidates, from))
- || bit_is_set(piece_attacks_from<KNIGHT>(ksq), to);
+ || bit_is_set(attacks_from<KNIGHT>(ksq), to);
case BISHOP:
return (dcCandidates && bit_is_set(dcCandidates, from))
- || (direction_is_diagonal(ksq, to) && bit_is_set(piece_attacks_from<BISHOP>(ksq), to));
+ || (direction_is_diagonal(ksq, to) && bit_is_set(attacks_from<BISHOP>(ksq), to));
case ROOK:
return (dcCandidates && bit_is_set(dcCandidates, from))
- || (direction_is_straight(ksq, to) && bit_is_set(piece_attacks_from<ROOK>(ksq), to));
+ || (direction_is_straight(ksq, to) && bit_is_set(attacks_from<ROOK>(ksq), to));
case QUEEN:
// Discovered checks are impossible!
assert(!bit_is_set(dcCandidates, from));
- return ( (direction_is_straight(ksq, to) && bit_is_set(piece_attacks_from<ROOK>(ksq), to))
- || (direction_is_diagonal(ksq, to) && bit_is_set(piece_attacks_from<BISHOP>(ksq), to)));
+ return ( (direction_is_straight(ksq, to) && bit_is_set(attacks_from<ROOK>(ksq), to))
+ || (direction_is_diagonal(ksq, to) && bit_is_set(attacks_from<BISHOP>(ksq), to)));
case KING:
// Discovered check?
// Direct checks
if ( ( (Bishop && bit_is_set(BishopPseudoAttacks[ksq], to))
|| (Rook && bit_is_set(RookPseudoAttacks[ksq], to)))
- && bit_is_set(piece_attacks_from<Piece>(ksq), to)) // slow, try to early skip
+ && bit_is_set(attacks_from<Piece>(ksq), to)) // slow, try to early skip
set_bit(pCheckersBB, to);
else if ( Piece != KING
&& !Slider
- && bit_is_set(Piece == PAWN ? pawn_attacks_from(ksq, opposite_color(sideToMove))
- : piece_attacks_from<Piece>(ksq), to))
+ && bit_is_set(Piece == PAWN ? attacks_from<PAWN>(ksq, opposite_color(sideToMove))
+ : attacks_from<Piece>(ksq), to))
set_bit(pCheckersBB, to);
// Discovery checks
if (Piece != QUEEN && bit_is_set(dcCandidates, from))
{
if (Piece != ROOK)
- (*pCheckersBB) |= (piece_attacks_from<ROOK>(ksq) & pieces(ROOK, QUEEN, side_to_move()));
+ (*pCheckersBB) |= (attacks_from<ROOK>(ksq) & pieces(ROOK, QUEEN, side_to_move()));
if (Piece != BISHOP)
- (*pCheckersBB) |= (piece_attacks_from<BISHOP>(ksq) & pieces(BISHOP, QUEEN, side_to_move()));
+ (*pCheckersBB) |= (attacks_from<BISHOP>(ksq) & pieces(BISHOP, QUEEN, side_to_move()));
}
}
// pointer to point to the new, ready to be updated, state.
struct ReducedStateInfo {
Key key, pawnKey, materialKey;
- int castleRights, rule50;
- Square kingSquare[2], epSquare;
- Value mgValue, egValue;
+ int castleRights, rule50, pliesFromNull;
+ Square epSquare;
+ Value value;
Value npMaterial[2];
};
// Increment the 50 moves rule draw counter. Resetting it to zero in the
// case of non-reversible moves is taken care of later.
st->rule50++;
+ st->pliesFromNull++;
if (move_is_castle(m))
{
board[to] = board[from];
board[from] = EMPTY;
- // If the moving piece was a king, update the king square
- if (pt == KING)
- st->kingSquare[us] = to;
-
// Update piece lists, note that index[from] is not updated and
// becomes stale. This works as long as index[] is accessed just
// by known occupied squares.
// Set en passant square, only if moved pawn can be captured
if (abs(int(to) - int(from)) == 16)
{
- if (pawn_attacks_from(from + (us == WHITE ? DELTA_N : DELTA_S), us) & pieces(PAWN, them))
+ if (attacks_from<PAWN>(from + (us == WHITE ? DELTA_N : DELTA_S), us) & pieces(PAWN, them))
{
st->epSquare = Square((int(from) + int(to)) / 2);
key ^= zobEp[st->epSquare];
}
// Update incremental scores
- st->mgValue += pst_delta<MidGame>(piece, from, to);
- st->egValue += pst_delta<EndGame>(piece, from, to);
+ st->value += pst_delta(piece, from, to);
if (pm) // promotion ?
{
Square lastPawnSquare = pieceList[us][PAWN][pieceCount[us][PAWN]];
index[lastPawnSquare] = index[to];
pieceList[us][PAWN][index[lastPawnSquare]] = lastPawnSquare;
+ pieceList[us][PAWN][pieceCount[us][PAWN]] = SQ_NONE;
index[to] = pieceCount[us][promotion] - 1;
pieceList[us][promotion][index[to]] = to;
st->pawnKey ^= zobrist[us][PAWN][to];
// Partially revert and update incremental scores
- st->mgValue -= pst<MidGame>(us, PAWN, to);
- st->mgValue += pst<MidGame>(us, promotion, to);
- st->egValue -= pst<EndGame>(us, PAWN, to);
- st->egValue += pst<EndGame>(us, promotion, to);
+ st->value -= pst(us, PAWN, to);
+ st->value += pst(us, promotion, to);
// Update material
st->npMaterial[us] += piece_value_midgame(promotion);
// Finish
sideToMove = opposite_color(sideToMove);
-
- st->mgValue += (sideToMove == WHITE)? TempoValueMidgame : -TempoValueMidgame;
- st->egValue += (sideToMove == WHITE)? TempoValueEndgame : -TempoValueEndgame;
+ st->value += (sideToMove == WHITE ? TempoValue : -TempoValue);
assert(is_ok());
}
key ^= zobrist[them][capture][capsq];
// Update incremental scores
- st->mgValue -= pst<MidGame>(them, capture, capsq);
- st->egValue -= pst<EndGame>(them, capture, capsq);
+ st->value -= pst(them, capture, capsq);
// If the captured piece was a pawn, update pawn hash key,
// otherwise update non-pawn material.
Square lastPieceSquare = pieceList[them][capture][pieceCount[them][capture]];
index[lastPieceSquare] = index[capsq];
pieceList[them][capture][index[lastPieceSquare]] = lastPieceSquare;
+ pieceList[them][capture][pieceCount[them][capture]] = SQ_NONE;
// Reset rule 50 counter
st->rule50 = 0;
rto = relative_square(us, SQ_D1);
}
- // Move the pieces
- Bitboard kmove_bb = make_move_bb(kfrom, kto);
- do_move_bb(&(byColorBB[us]), kmove_bb);
- do_move_bb(&(byTypeBB[KING]), kmove_bb);
- do_move_bb(&(byTypeBB[0]), kmove_bb); // HACK: byTypeBB[0] == occupied squares
-
- Bitboard rmove_bb = make_move_bb(rfrom, rto);
- do_move_bb(&(byColorBB[us]), rmove_bb);
- do_move_bb(&(byTypeBB[ROOK]), rmove_bb);
- do_move_bb(&(byTypeBB[0]), rmove_bb); // HACK: byTypeBB[0] == occupied squares
-
+ // Remove pieces from source squares:
+ clear_bit(&(byColorBB[us]), kfrom);
+ clear_bit(&(byTypeBB[KING]), kfrom);
+ clear_bit(&(byTypeBB[0]), kfrom); // HACK: byTypeBB[0] == occupied squares
+ clear_bit(&(byColorBB[us]), rfrom);
+ clear_bit(&(byTypeBB[ROOK]), rfrom);
+ clear_bit(&(byTypeBB[0]), rfrom); // HACK: byTypeBB[0] == occupied squares
+
+ // Put pieces on destination squares:
+ set_bit(&(byColorBB[us]), kto);
+ set_bit(&(byTypeBB[KING]), kto);
+ set_bit(&(byTypeBB[0]), kto); // HACK: byTypeBB[0] == occupied squares
+ set_bit(&(byColorBB[us]), rto);
+ set_bit(&(byTypeBB[ROOK]), rto);
+ set_bit(&(byTypeBB[0]), rto); // HACK: byTypeBB[0] == occupied squares
+
// Update board array
Piece king = piece_of_color_and_type(us, KING);
Piece rook = piece_of_color_and_type(us, ROOK);
board[kto] = king;
board[rto] = rook;
- // Update king square
- st->kingSquare[us] = kto;
-
// Update piece lists
pieceList[us][KING][index[kfrom]] = kto;
pieceList[us][ROOK][index[rfrom]] = rto;
index[rto] = tmp;
// Update incremental scores
- st->mgValue += pst_delta<MidGame>(king, kfrom, kto);
- st->egValue += pst_delta<EndGame>(king, kfrom, kto);
- st->mgValue += pst_delta<MidGame>(rook, rfrom, rto);
- st->egValue += pst_delta<EndGame>(rook, rfrom, rto);
+ st->value += pst_delta(king, kfrom, kto);
+ st->value += pst_delta(rook, rfrom, rto);
// Update hash key
st->key ^= zobrist[us][KING][kfrom] ^ zobrist[us][KING][kto];
// Finish
sideToMove = opposite_color(sideToMove);
-
- st->mgValue += (sideToMove == WHITE)? TempoValueMidgame : -TempoValueMidgame;
- st->egValue += (sideToMove == WHITE)? TempoValueEndgame : -TempoValueEndgame;
+ st->value += (sideToMove == WHITE ? TempoValue : -TempoValue);
assert(is_ok());
}
Square lastPromotionSquare = pieceList[us][promotion][pieceCount[us][promotion]];
index[lastPromotionSquare] = index[to];
pieceList[us][promotion][index[lastPromotionSquare]] = lastPromotionSquare;
+ pieceList[us][promotion][pieceCount[us][promotion]] = SQ_NONE;
index[to] = pieceCount[us][PAWN] - 1;
pieceList[us][PAWN][index[to]] = to;
}
+
// Put the piece back at the source square
Bitboard move_bb = make_move_bb(to, from);
do_move_bb(&(byColorBB[us]), move_bb);
assert(piece_on(kto) == piece_of_color_and_type(us, KING));
assert(piece_on(rto) == piece_of_color_and_type(us, ROOK));
-
- // Put the pieces back at the source square
- Bitboard kmove_bb = make_move_bb(kto, kfrom);
- do_move_bb(&(byColorBB[us]), kmove_bb);
- do_move_bb(&(byTypeBB[KING]), kmove_bb);
- do_move_bb(&(byTypeBB[0]), kmove_bb); // HACK: byTypeBB[0] == occupied squares
-
- Bitboard rmove_bb = make_move_bb(rto, rfrom);
- do_move_bb(&(byColorBB[us]), rmove_bb);
- do_move_bb(&(byTypeBB[ROOK]), rmove_bb);
- do_move_bb(&(byTypeBB[0]), rmove_bb); // HACK: byTypeBB[0] == occupied squares
+
+ // Remove pieces from destination squares:
+ clear_bit(&(byColorBB[us]), kto);
+ clear_bit(&(byTypeBB[KING]), kto);
+ clear_bit(&(byTypeBB[0]), kto); // HACK: byTypeBB[0] == occupied squares
+ clear_bit(&(byColorBB[us]), rto);
+ clear_bit(&(byTypeBB[ROOK]), rto);
+ clear_bit(&(byTypeBB[0]), rto); // HACK: byTypeBB[0] == occupied squares
+
+ // Put pieces on source squares:
+ set_bit(&(byColorBB[us]), kfrom);
+ set_bit(&(byTypeBB[KING]), kfrom);
+ set_bit(&(byTypeBB[0]), kfrom); // HACK: byTypeBB[0] == occupied squares
+ set_bit(&(byColorBB[us]), rfrom);
+ set_bit(&(byTypeBB[ROOK]), rfrom);
+ set_bit(&(byTypeBB[0]), rfrom); // HACK: byTypeBB[0] == occupied squares
// Update board
board[rto] = board[kto] = EMPTY;
// a backup storage not as a new state to be used.
backupSt.key = st->key;
backupSt.epSquare = st->epSquare;
- backupSt.mgValue = st->mgValue;
- backupSt.egValue = st->egValue;
+ backupSt.value = st->value;
backupSt.previous = st->previous;
+ backupSt.pliesFromNull = st->pliesFromNull;
st->previous = &backupSt;
// Save the current key to the history[] array, in order to be able to
sideToMove = opposite_color(sideToMove);
st->epSquare = SQ_NONE;
st->rule50++;
+ st->pliesFromNull = 0;
+ st->value += (sideToMove == WHITE) ? TempoValue : -TempoValue;
gamePly++;
-
- st->mgValue += (sideToMove == WHITE)? TempoValueMidgame : -TempoValueMidgame;
- st->egValue += (sideToMove == WHITE)? TempoValueEndgame : -TempoValueEndgame;
}
StateInfo* backupSt = st->previous;
st->key = backupSt->key;
st->epSquare = backupSt->epSquare;
- st->mgValue = backupSt->mgValue;
- st->egValue = backupSt->egValue;
+ st->value = backupSt->value;
st->previous = backupSt->previous;
+ st->pliesFromNull = backupSt->pliesFromNull;
// Update the necessary information
sideToMove = opposite_color(sideToMove);
0, 0
};
- Bitboard attackers, stmAttackers, occ, b;
+ Bitboard attackers, stmAttackers, b;
assert(square_is_ok(from) || from == SQ_NONE);
assert(square_is_ok(to));
// Initialize pieces
Piece piece = piece_on(from);
Piece capture = piece_on(to);
+ Bitboard occ = occupied_squares();
- // Find all attackers to the destination square, with the moving piece
- // removed, but possibly an X-ray attacker added behind it.
- occ = occupied_squares();
+ // King cannot be recaptured
+ if (type_of_piece(piece) == KING)
+ return seeValues[capture];
// Handle en passant moves
if (st->epSquare == to && type_of_piece_on(from) == 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))
- | (piece_attacks_from<KNIGHT>(to) & pieces(KNIGHT))
- | (piece_attacks_from<KING>(to) & pieces(KING))
- | (pawn_attacks_from(to, WHITE) & pieces(PAWN, BLACK))
- | (pawn_attacks_from(to, BLACK) & pieces(PAWN, WHITE));
+ 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;
for (int i = 0; i < 64; i++)
board[i] = EMPTY;
- for (int i = 0; i < 7; i++)
- for (int j = 0; j < 8; j++)
+ for (int i = 0; i < 8; i++)
+ for (int j = 0; j < 16; j++)
pieceList[0][i][j] = pieceList[1][i][j] = SQ_NONE;
sideToMove = WHITE;
set_bit(&byTypeBB[0], s); // HACK: byTypeBB[0] contains all occupied squares.
pieceCount[c][pt]++;
-
- if (pt == KING)
- st->kingSquare[c] = s;
}
/// game and the endgame. These functions are used to initialize the incremental
/// scores when a new position is set up, and to verify that the scores are correctly
/// updated by do_move and undo_move when the program is running in debug mode.
-template<Position::GamePhase Phase>
-Value Position::compute_value() const {
+Score Position::compute_value() const {
- Value result = Value(0);
+ Score result = make_score(0, 0);
Bitboard b;
Square s;
{
s = pop_1st_bit(&b);
assert(piece_on(s) == piece_of_color_and_type(c, pt));
- result += pst<Phase>(c, pt, s);
+ result += pst(c, pt, s);
}
}
- const Value TempoValue = (Phase == MidGame ? TempoValueMidgame : TempoValueEndgame);
- result += (side_to_move() == WHITE)? TempoValue / 2 : -TempoValue / 2;
+ result += (side_to_move() == WHITE ? TempoValue / 2 : -TempoValue / 2);
return result;
}
return true;
// Draw by repetition?
- for (int i = 2; i < Min(gamePly, st->rule50); i += 2)
+ for (int i = 2; i < Min(Min(gamePly, st->rule50), st->pliesFromNull); i += 2)
if (history[gamePly - i] == st->key)
return true;
bool Position::is_mate() const {
MoveStack moves[256];
-
- return is_check() && (generate_evasions(*this, moves, pinned_pieces(sideToMove)) == moves);
+ return is_check() && (generate_moves(*this, moves, false) == moves);
}
MoveStack mlist[120];
bool result = false;
- Bitboard dc = discovered_check_candidates(sideToMove);
Bitboard pinned = pinned_pieces(sideToMove);
// Generate pseudo-legal non-capture and capture check moves
- MoveStack* last = generate_non_capture_checks(*this, mlist, dc);
+ MoveStack* 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 (Piece p = WP; p <= WK; p++)
{
i = (r == 0)? 0 : (genrand_int32() % (r*2) - r);
- MgPieceSquareTable[p][s] = Value(MgPST[p][s] + i);
- EgPieceSquareTable[p][s] = Value(EgPST[p][s] + i);
+ PieceSquareTable[p][s] = make_score(MgPST[p][s] + i, EgPST[p][s] + i);
}
for (Square s = SQ_A1; s <= SQ_H8; s++)
for (Piece p = BP; p <= BK; p++)
- {
- MgPieceSquareTable[p][s] = -MgPieceSquareTable[p-8][flip_square(s)];
- EgPieceSquareTable[p][s] = -EgPieceSquareTable[p-8][flip_square(s)];
- }
+ PieceSquareTable[p][s] = -PieceSquareTable[p-8][flip_square(s)];
}
st->materialKey = compute_material_key();
// Incremental scores
- st->mgValue = compute_value<MidGame>();
- st->egValue = compute_value<EndGame>();
+ st->value = compute_value();
// Material
st->npMaterial[WHITE] = compute_non_pawn_material(WHITE);
// Incremental eval OK?
if (failedStep) (*failedStep)++;
- if (debugIncrementalEval)
- {
- if (st->mgValue != compute_value<MidGame>())
- return false;
-
- if (st->egValue != compute_value<EndGame>())
- return false;
- }
+ if (debugIncrementalEval && st->value != compute_value())
+ return false;
// Non-pawn material OK?
if (failedStep) (*failedStep)++;
for(PieceType pt = PAWN; pt <= KING; pt++)
for(int i = 0; i < pieceCount[c][pt]; i++)
{
- if (piece_on(piece_list(c, pt, i)) != (pieces(pt, c)))
+ if (piece_on(piece_list(c, pt, i)) != piece_of_color_and_type(c, pt))
return false;
if (index[piece_list(c, pt, i)] != i)