Align with PieceType naming convention and
make them more readable.
No functional change.
Signed-off-by: Marco Costalba <mcostalba@gmail.com>
void from_index(int index);
Result classify_white(const Result db[]);
Result classify_black(const Result db[]);
void from_index(int index);
Result classify_white(const Result db[]);
Result classify_black(const Result db[]);
- Bitboard wk_attacks() const { return StepAttacksBB[WK][whiteKingSquare]; }
- Bitboard bk_attacks() const { return StepAttacksBB[BK][blackKingSquare]; }
- Bitboard pawn_attacks() const { return StepAttacksBB[WP][pawnSquare]; }
+ Bitboard wk_attacks() const { return StepAttacksBB[W_KING][whiteKingSquare]; }
+ Bitboard bk_attacks() const { return StepAttacksBB[B_KING][blackKingSquare]; }
+ Bitboard pawn_attacks() const { return StepAttacksBB[W_PAWN][pawnSquare]; }
Square whiteKingSquare, blackKingSquare, pawnSquare;
Color sideToMove;
Square whiteKingSquare, blackKingSquare, pawnSquare;
Color sideToMove;
+ RedundantQueenPenalty * pieceCount[Us][QUEEN];
// Second-degree polynomial material imbalance by Tord Romstad
+ RedundantQueenPenalty * pieceCount[Us][QUEEN];
// Second-degree polynomial material imbalance by Tord Romstad
- for (pt1 = PIECE_TYPE_NONE; pt1 <= QUEEN; pt1++)
+ for (pt1 = NO_PIECE_TYPE; pt1 <= QUEEN; pt1++)
{
pc = pieceCount[Us][pt1];
if (!pc)
{
pc = pieceCount[Us][pt1];
if (!pc)
v = LinearCoefficients[pt1];
v = LinearCoefficients[pt1];
- for (pt2 = PIECE_TYPE_NONE; pt2 <= pt1; pt2++)
+ for (pt2 = NO_PIECE_TYPE; pt2 <= pt1; pt2++)
v += QuadraticCoefficientsSameColor[pt1][pt2] * pieceCount[Us][pt2]
+ QuadraticCoefficientsOppositeColor[pt1][pt2] * pieceCount[Them][pt2];
v += QuadraticCoefficientsSameColor[pt1][pt2] * pieceCount[Us][pt2]
+ QuadraticCoefficientsOppositeColor[pt1][pt2] * pieceCount[Them][pt2];
const Score TempoValue = make_score(48, 22);
// To convert a Piece to and from a FEN char
const Score TempoValue = make_score(48, 22);
// To convert a Piece to and from a FEN char
- const string PieceToChar(".PNBRQK pnbrqk ");
+ const string PieceToChar(" PNBRQK pnbrqk .");
Piece piece = piece_on(sq);
char c = (color_of(piece) == BLACK ? '=' : ' ');
Piece piece = piece_on(sq);
char c = (color_of(piece) == BLACK ? '=' : ' ');
- if (piece == PIECE_NONE && color_of(sq) == DARK)
- piece = PIECE_NONE_DARK_SQ;
+ if (piece == NO_PIECE && color_of(sq) == DARK)
+ piece++; // Index the dot
cout << c << PieceToChar[piece] << c << '|';
}
cout << c << PieceToChar[piece] << c << '|';
}
- 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 StepAttacksBB[p][s];
+ case BISHOP: return bishop_attacks_bb(s, occ);
+ case ROOK : return rook_attacks_bb(s, occ);
+ case QUEEN : return bishop_attacks_bb(s, occ) | rook_attacks_bb(s, occ);
+ default : return StepAttacksBB[p][s];
assert(to == ep_square());
assert(piece_on(from) == make_piece(us, PAWN));
assert(piece_on(capsq) == make_piece(them, PAWN));
assert(to == ep_square());
assert(piece_on(from) == make_piece(us, PAWN));
assert(piece_on(capsq) == make_piece(them, PAWN));
- assert(piece_on(to) == PIECE_NONE);
+ assert(piece_on(to) == NO_PIECE);
clear_bit(&b, from);
clear_bit(&b, capsq);
clear_bit(&b, from);
clear_bit(&b, capsq);
return move_is_legal(m);
// Is not a promotion, so promotion piece must be empty
return move_is_legal(m);
// Is not a promotion, so promotion piece must be empty
- if (promotion_piece_type(m) - 2 != PIECE_TYPE_NONE)
+ if (promotion_piece_type(m) - 2 != NO_PIECE_TYPE)
return false;
// If the from square is not occupied by a piece belonging to the side to
// move, the move is obviously not legal.
return false;
// If the from square is not occupied by a piece belonging to the side to
// move, the move is obviously not legal.
- if (pc == PIECE_NONE || color_of(pc) != us)
+ if (pc == NO_PIECE || color_of(pc) != us)
return false;
// The destination square cannot be occupied by a friendly piece
return false;
// The destination square cannot be occupied by a friendly piece
assert(pt == PAWN);
assert(to == st->epSquare);
assert(relative_rank(us, to) == RANK_6);
assert(pt == PAWN);
assert(to == st->epSquare);
assert(relative_rank(us, to) == RANK_6);
- assert(piece_on(to) == PIECE_NONE);
+ assert(piece_on(to) == NO_PIECE);
assert(piece_on(capsq) == make_piece(them, PAWN));
assert(piece_on(capsq) == make_piece(them, PAWN));
- board[capsq] = PIECE_NONE;
+ board[capsq] = NO_PIECE;
}
st->pawnKey ^= zobrist[them][PAWN][capsq];
}
st->pawnKey ^= zobrist[them][PAWN][capsq];
do_move_bb(&occupied, move_bb);
board[to] = board[from];
do_move_bb(&occupied, move_bb);
board[to] = board[from];
- board[from] = PIECE_NONE;
+ board[from] = NO_PIECE;
// Update piece lists, index[from] is not updated and becomes stale. This
// works as long as index[] is accessed just by known occupied squares.
// Update piece lists, index[from] is not updated and becomes stale. This
// works as long as index[] is accessed just by known occupied squares.
do_move_bb(&occupied, move_bb);
board[from] = board[to];
do_move_bb(&occupied, move_bb);
board[from] = board[to];
- board[to] = PIECE_NONE;
// Update piece lists, index[to] is not updated and becomes stale. This
// works as long as index[] is accessed just by known occupied squares.
// Update piece lists, index[to] is not updated and becomes stale. This
// works as long as index[] is accessed just by known occupied squares.
assert(pt == PAWN);
assert(to == st->previous->epSquare);
assert(relative_rank(us, to) == RANK_6);
assert(pt == PAWN);
assert(to == st->previous->epSquare);
assert(relative_rank(us, to) == RANK_6);
- assert(piece_on(capsq) == PIECE_NONE);
+ assert(piece_on(capsq) == NO_PIECE);
}
// Restore the captured piece
}
// Restore the captured piece
// Update board
Piece king = make_piece(us, KING);
Piece rook = make_piece(us, ROOK);
// Update board
Piece king = make_piece(us, KING);
Piece rook = make_piece(us, ROOK);
- board[kfrom] = board[rfrom] = PIECE_NONE;
+ board[kfrom] = board[rfrom] = NO_PIECE;
board[kto] = king;
board[rto] = rook;
board[kto] = king;
board[rto] = rook;
if (Do)
{
// Reset capture field
if (Do)
{
// Reset capture field
- st->capturedType = PIECE_TYPE_NONE;
+ st->capturedType = NO_PIECE_TYPE;
// Update incremental scores
st->value += pst_delta(king, kfrom, kto);
// Update incremental scores
st->value += pst_delta(king, kfrom, kto);
{
Square capQq = to - pawn_push(side_to_move());
{
Square capQq = to - pawn_push(side_to_move());
- assert(capturedType == PIECE_TYPE_NONE);
+ assert(capturedType == NO_PIECE_TYPE);
assert(type_of(piece_on(capQq)) == PAWN);
// Remove the captured pawn
assert(type_of(piece_on(capQq)) == PAWN);
// Remove the captured pawn
for (Square sq = SQ_A1; sq <= SQ_H8; sq++)
{
for (Square sq = SQ_A1; sq <= SQ_H8; sq++)
{
- board[sq] = PIECE_NONE;
castleRightsMask[sq] = ALL_CASTLES;
}
sideToMove = WHITE;
castleRightsMask[sq] = ALL_CASTLES;
}
sideToMove = WHITE;
zobSideToMove = rk.rand<Key>();
zobExclusion = rk.rand<Key>();
zobSideToMove = rk.rand<Key>();
zobExclusion = rk.rand<Key>();
- for (Piece p = WP; p <= WK; p++)
+ for (Piece p = W_PAWN; p <= W_KING; p++)
{
Score ps = make_score(PieceValueMidgame[p], PieceValueEndgame[p]);
{
Score ps = make_score(PieceValueMidgame[p], PieceValueEndgame[p]);
// Are the king squares in the position correct?
if (failedStep) (*failedStep)++;
// Are the king squares in the position correct?
if (failedStep) (*failedStep)++;
- if (piece_on(king_square(WHITE)) != WK)
+ if (piece_on(king_square(WHITE)) != W_KING)
return false;
if (failedStep) (*failedStep)++;
return false;
if (failedStep) (*failedStep)++;
- if (piece_on(king_square(BLACK)) != BK)
+ if (piece_on(king_square(BLACK)) != B_KING)
return false;
// Do both sides have exactly one king?
return false;
// Do both sides have exactly one king?
if (!can_castle(f))
continue;
if (!can_castle(f))
continue;
- Piece rook = (f & (WHITE_OO | WHITE_OOO) ? WR : BR);
+ Piece rook = (f & (WHITE_OO | WHITE_OOO) ? W_ROOK : B_ROOK);
if ( castleRightsMask[castleRookSquare[f]] != (ALL_CASTLES ^ f)
|| piece_on(castleRookSquare[f]) != rook)
if ( castleRightsMask[castleRookSquare[f]] != (ALL_CASTLES ^ f)
|| piece_on(castleRookSquare[f]) != rook)
}
inline bool Position::square_is_empty(Square s) const {
}
inline bool Position::square_is_empty(Square s) const {
- return board[s] == PIECE_NONE;
+ return board[s] == NO_PIECE;
}
inline Color Position::side_to_move() const {
}
inline Color Position::side_to_move() const {
if ( (move = (ss-1)->currentMove) != MOVE_NULL
&& (ss-1)->eval != VALUE_NONE
&& ss->eval != VALUE_NONE
if ( (move = (ss-1)->currentMove) != MOVE_NULL
&& (ss-1)->eval != VALUE_NONE
&& ss->eval != VALUE_NONE
- && pos.captured_piece_type() == PIECE_TYPE_NONE
+ && pos.captured_piece_type() == NO_PIECE_TYPE
&& !is_special(move))
{
Square to = move_to(move);
&& !is_special(move))
{
Square to = move_to(move);
PAWN = 1, KNIGHT = 2, BISHOP = 3, ROOK = 4, QUEEN = 5, KING = 6
};
enum Piece {
PAWN = 1, KNIGHT = 2, BISHOP = 3, ROOK = 4, QUEEN = 5, KING = 6
};
enum Piece {
- PIECE_NONE_DARK_SQ = 0, WP = 1, WN = 2, WB = 3, WR = 4, WQ = 5, WK = 6,
- BP = 9, BN = 10, BB = 11, BR = 12, BQ = 13, BK = 14, PIECE_NONE = 16
+ NO_PIECE = 16, // color_of(NO_PIECE) == NO_COLOR
+ W_PAWN = 1, W_KNIGHT = 2, W_BISHOP = 3, W_ROOK = 4, W_QUEEN = 5, W_KING = 6,
+ B_PAWN = 9, B_KNIGHT = 10, B_BISHOP = 11, B_ROOK = 12, B_QUEEN = 13, B_KING = 14
- WHITE, BLACK, COLOR_NONE