Score Position::PieceSquareTable[16][64];
// Material values arrays, indexed by Piece
-const Value Position::PieceValueMidgame[17] = {
+const Value PieceValueMidgame[17] = {
VALUE_ZERO,
PawnValueMidgame, KnightValueMidgame, BishopValueMidgame,
RookValueMidgame, QueenValueMidgame, VALUE_ZERO,
RookValueMidgame, QueenValueMidgame
};
-const Value Position::PieceValueEndgame[17] = {
+const Value PieceValueEndgame[17] = {
VALUE_ZERO,
PawnValueEndgame, KnightValueEndgame, BishopValueEndgame,
RookValueEndgame, QueenValueEndgame, VALUE_ZERO,
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 {
// If the moving piece is a king, check whether the destination
// square is attacked by the opponent. Castling moves are checked
// for legality during move generation.
- if (type_of_piece_on(from) == KING)
+ if (type_of_piece(piece_on(from)) == KING)
return move_is_castle(m) || !(attackers_to(move_to(m)) & pieces_of_color(opposite_color(us)));
// A non-king move is legal if and only if it is not pinned or it
{
// In case of king moves under check we have to remove king so to catch
// as invalid moves like b1a1 when opposite queen is on c1.
- if (type_of_piece_on(from) == KING)
+ if (type_of_piece(piece_on(from)) == KING)
{
Bitboard b = occupied_squares();
clear_bit(&b, from);
Square from = move_from(m);
Square to = move_to(m);
- PieceType pt = type_of_piece_on(from);
+ PieceType pt = type_of_piece(piece_on(from));
// Direct check ?
if (bit_is_set(ci.checkSq[pt], to))
Piece piece = piece_on(from);
PieceType pt = type_of_piece(piece);
- PieceType capture = ep ? PAWN : type_of_piece_on(to);
+ PieceType capture = ep ? PAWN : type_of_piece(piece_on(to));
assert(color_of_piece_on(from) == us);
assert(color_of_piece_on(to) == them || square_is_empty(to));
bool ep = move_is_ep(m);
bool pm = move_is_promotion(m);
- PieceType pt = type_of_piece_on(to);
+ PieceType pt = type_of_piece(piece_on(to));
assert(square_is_empty(from));
assert(color_of_piece_on(to) == us);
// 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 (midgame_value_of_piece_on(to) >= midgame_value_of_piece_on(from))
+ if (piece_value_midgame(piece_on(to)) >= piece_value_midgame(piece_on(from)))
return 1;
return see(m);
from = move_from(m);
to = move_to(m);
- capturedType = type_of_piece_on(to);
+ capturedType = type_of_piece(piece_on(to));
occupied = occupied_squares();
// Handle en passant moves
- if (st->epSquare == to && type_of_piece_on(from) == PAWN)
+ if (st->epSquare == to && type_of_piece(piece_on(from)) == PAWN)
{
Square capQq = (side_to_move() == WHITE ? to - DELTA_N : to - DELTA_S);
assert(capturedType == PIECE_TYPE_NONE);
- assert(type_of_piece_on(capQq) == PAWN);
+ assert(type_of_piece(piece_on(capQq)) == PAWN);
// Remove the captured pawn
clear_bit(&occupied, capQq);
stm = opposite_color(color_of_piece_on(from));
stmAttackers = attackers & pieces_of_color(stm);
if (!stmAttackers)
- return seeValues[capturedType];
+ return PieceValueMidgame[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.
- swapList[0] = seeValues[capturedType];
- capturedType = type_of_piece_on(from);
+ swapList[0] = PieceValueMidgame[capturedType];
+ capturedType = type_of_piece(piece_on(from));
do {
// Locate the least valuable attacker for the side to move. The loop
// Add the new entry to the swap list
assert(slIndex < 32);
- swapList[slIndex] = -swapList[slIndex - 1] + seeValues[capturedType];
+ swapList[slIndex] = -swapList[slIndex - 1] + PieceValueMidgame[capturedType];
slIndex++;
// Remember the value of the capturing piece, and change the side to
for (Square s = SQ_A1; s <= SQ_H8; s++)
if (square_is_occupied(s))
- result ^= zobrist[color_of_piece_on(s)][type_of_piece_on(s)][s];
+ result ^= zobrist[color_of_piece_on(s)][type_of_piece(piece_on(s))][s];
if (ep_square() != SQ_NONE)
result ^= zobEp[ep_square()];
{
int kingCount[2] = {0, 0};
for (Square s = SQ_A1; s <= SQ_H8; s++)
- if (type_of_piece_on(s) == KING)
+ if (type_of_piece(piece_on(s)) == KING)
kingCount[color_of_piece_on(s)]++;
if (kingCount[0] != 1 || kingCount[1] != 1)