CACHE_LINE_ALIGNMENT
-Score pieceSquareTable[COLOR_NB][PIECE_TYPE_NB][SQUARE_NB];
+Score psq[COLOR_NB][PIECE_TYPE_NB][SQUARE_NB];
Value PieceValue[PHASE_NB][PIECE_NB] = {
{ VALUE_ZERO, PawnValueMg, KnightValueMg, BishopValueMg, RookValueMg, QueenValueMg },
{ VALUE_ZERO, PawnValueEg, KnightValueEg, BishopValueEg, RookValueEg, QueenValueEg } };
-namespace Zobrist {
-
-Key psq[COLOR_NB][PIECE_TYPE_NB][SQUARE_NB];
-Key enpassant[FILE_NB];
-Key castle[CASTLE_RIGHT_NB];
-Key side;
-Key exclusion;
-
-/// init() initializes at startup the various arrays used to compute hash keys
-/// and the piece square tables. The latter is a two-step operation: First, the
-/// white halves of the tables are copied from PSQT[] tables. Second, the black
-/// halves of the tables are initialized by flipping and changing the sign of
-/// the white scores.
-
-void init() {
-
- RKISS rk;
-
- for (Color c = WHITE; c <= BLACK; c++)
- for (PieceType pt = PAWN; pt <= KING; pt++)
- for (Square s = SQ_A1; s <= SQ_H8; s++)
- psq[c][pt][s] = rk.rand<Key>();
-
- for (File f = FILE_A; f <= FILE_H; f++)
- enpassant[f] = rk.rand<Key>();
-
- for (int cr = CASTLES_NONE; cr <= ALL_CASTLES; cr++)
- {
- Bitboard b = cr;
- while (b)
- {
- Key k = castle[1ULL << pop_lsb(&b)];
- castle[cr] ^= k ? k : rk.rand<Key>();
- }
- }
-
- side = rk.rand<Key>();
- exclusion = rk.rand<Key>();
-
- for (PieceType pt = PAWN; pt <= KING; pt++)
- {
- PieceValue[MG][make_piece(BLACK, pt)] = PieceValue[MG][pt];
- PieceValue[EG][make_piece(BLACK, pt)] = PieceValue[EG][pt];
-
- Score v = make_score(PieceValue[MG][pt], PieceValue[EG][pt]);
-
- for (Square s = SQ_A1; s <= SQ_H8; s++)
- {
- pieceSquareTable[WHITE][pt][ s] = (v + PSQT[pt][s]);
- pieceSquareTable[BLACK][pt][~s] = -(v + PSQT[pt][s]);
- }
- }
-}
-
-} // namespace Zobrist
-
+Key Zobrist::psq[COLOR_NB][PIECE_TYPE_NB][SQUARE_NB];
+Key Zobrist::enpassant[FILE_NB];
+Key Zobrist::castle[CASTLE_RIGHT_NB];
+Key Zobrist::side;
+Key Zobrist::exclusion;
namespace {
}
+/// Position::init() initializes at startup the various arrays used to compute
+/// hash keys and the piece square tables. The latter is a two-step operation:
+/// First, the white halves of the tables are copied from PSQT[] tables. Second,
+/// the black halves of the tables are initialized by flipping and changing the
+/// sign of the white scores.
+
+void Position::init() {
+
+ RKISS rk;
+
+ for (Color c = WHITE; c <= BLACK; c++)
+ for (PieceType pt = PAWN; pt <= KING; pt++)
+ for (Square s = SQ_A1; s <= SQ_H8; s++)
+ Zobrist::psq[c][pt][s] = rk.rand<Key>();
+
+ for (File f = FILE_A; f <= FILE_H; f++)
+ Zobrist::enpassant[f] = rk.rand<Key>();
+
+ for (int cr = CASTLES_NONE; cr <= ALL_CASTLES; cr++)
+ {
+ Bitboard b = cr;
+ while (b)
+ {
+ Key k = Zobrist::castle[1ULL << pop_lsb(&b)];
+ Zobrist::castle[cr] ^= k ? k : rk.rand<Key>();
+ }
+ }
+
+ Zobrist::side = rk.rand<Key>();
+ Zobrist::exclusion = rk.rand<Key>();
+
+ for (PieceType pt = PAWN; pt <= KING; pt++)
+ {
+ PieceValue[MG][make_piece(BLACK, pt)] = PieceValue[MG][pt];
+ PieceValue[EG][make_piece(BLACK, pt)] = PieceValue[EG][pt];
+
+ Score v = make_score(PieceValue[MG][pt], PieceValue[EG][pt]);
+
+ for (Square s = SQ_A1; s <= SQ_H8; s++)
+ {
+ psq[WHITE][pt][ s] = (v + PSQT[pt][s]);
+ psq[BLACK][pt][~s] = -(v + PSQT[pt][s]);
+ }
+ }
+}
+
+
/// Position::operator=() creates a copy of 'pos'. We want the new born Position
/// object do not depend on any external data so we detach state pointer from
/// the source one.
st->key = compute_key();
st->pawnKey = compute_pawn_key();
st->materialKey = compute_material_key();
- st->psqScore = compute_psq_score();
+ st->psq = compute_psq_score();
st->npMaterial[WHITE] = compute_non_pawn_material(WHITE);
st->npMaterial[BLACK] = compute_non_pawn_material(BLACK);
st->checkersBB = attackers_to(king_square(sideToMove)) & pieces(~sideToMove);
do_castle(from, to, rfrom, rto);
- st->psqScore += pieceSquareTable[us][ROOK][rto] - pieceSquareTable[us][ROOK][rfrom];
+ st->psq += psq[us][ROOK][rto] - psq[us][ROOK][rfrom];
k ^= Zobrist::psq[us][ROOK][rfrom] ^ Zobrist::psq[us][ROOK][rto];
}
prefetch((char*)thisThread->materialTable[st->materialKey]);
// Update incremental scores
- st->psqScore -= pieceSquareTable[them][capture][capsq];
+ st->psq -= psq[them][capture][capsq];
// Reset rule 50 counter
st->rule50 = 0;
^ Zobrist::psq[us][PAWN][pieceCount[us][PAWN]];
// Update incremental score
- st->psqScore += pieceSquareTable[us][promotion][to] - pieceSquareTable[us][PAWN][to];
+ st->psq += psq[us][promotion][to] - psq[us][PAWN][to];
// Update material
st->npMaterial[us] += PieceValue[MG][promotion];
}
// Update incremental scores
- st->psqScore += pieceSquareTable[us][pt][to] - pieceSquareTable[us][pt][from];
+ st->psq += psq[us][pt][to] - psq[us][pt][from];
// Set capture piece
st->capturedType = capture;
{
Square s = pop_lsb(&b);
Piece pc = piece_on(s);
- score += pieceSquareTable[color_of(pc)][type_of(pc)][s];
+ score += psq[color_of(pc)][type_of(pc)][s];
}
return score;
st->key = compute_key();
st->pawnKey = compute_pawn_key();
st->materialKey = compute_material_key();
- st->psqScore = compute_psq_score();
+ st->psq = compute_psq_score();
st->npMaterial[WHITE] = compute_non_pawn_material(WHITE);
st->npMaterial[BLACK] = compute_non_pawn_material(BLACK);
if ((*step)++, debugMaterialKey && st->materialKey != compute_material_key())
return false;
- if ((*step)++, debugIncrementalEval && st->psqScore != compute_psq_score())
+ if ((*step)++, debugIncrementalEval && st->psq != compute_psq_score())
return false;
if ((*step)++, debugNonPawnMaterial)