side = rk.rand<Key>();
exclusion = rk.rand<Key>();
- for (PieceType pt = PAWN; pt <= KING; pt++)
+ for (Piece pc = W_PAWN; pc <= W_KING; pc++)
{
- PieceValue[MG][make_piece(BLACK, pt)] = PieceValue[MG][pt];
- PieceValue[EG][make_piece(BLACK, pt)] = PieceValue[EG][pt];
+ PieceValue[MG][~pc] = PieceValue[MG][pc];
+ PieceValue[EG][~pc] = PieceValue[EG][pc];
- Score v = make_score(PieceValue[MG][pt], PieceValue[EG][pt]);
+ Score v = make_score(PieceValue[MG][pc], PieceValue[EG][pc]);
for (Square s = SQ_A1; s <= SQ_H8; s++)
{
- pieceSquareTable[make_piece(WHITE, pt)][ s] = (v + PSQT[pt][s]);
- pieceSquareTable[make_piece(BLACK, pt)][~s] = -(v + PSQT[pt][s]);
+ pieceSquareTable[ pc][ s] = (v + PSQT[pc][s]);
+ pieceSquareTable[~pc][~s] = -(v + PSQT[pc][s]);
}
}
}
namespace {
-/// next_attacker() is an helper function used by see() to locate the least
-/// valuable attacker for the side to move, remove the attacker we just found
-/// from the 'occupied' bitboard and scan for new X-ray attacks behind it.
+// next_attacker() is an helper function used by see() to locate the least
+// valuable attacker for the side to move, remove the attacker we just found
+// from the 'occupied' bitboard and scan for new X-ray attacks behind it.
template<int Pt> FORCE_INLINE
PieceType next_attacker(const Bitboard* bb, const Square& to, const Bitboard& stmAttackers,
ss << square_to_string(pop_lsb(&b)) << " ";
ss << "\nLegal moves: ";
- for (MoveList<LEGAL> ml(*this); !ml.end(); ++ml)
- ss << move_to_san(*const_cast<Position*>(this), ml.move()) << " ";
+ for (MoveList<LEGAL> it(*this); *it; ++it)
+ ss << move_to_san(*const_cast<Position*>(this), *it) << " ";
return ss.str();
}
do_castle(from, to, rfrom, rto);
- st->psqScore += psq_delta(make_piece(us, ROOK), rfrom, rto);
k ^= Zobrist::psq[us][ROOK][rfrom] ^ Zobrist::psq[us][ROOK][rto];
+ st->psqScore += pieceSquareTable[make_piece(us, ROOK)][rto]
+ - pieceSquareTable[make_piece(us, ROOK)][rfrom];
}
if (capture)
}
// Update incremental scores
- st->psqScore += psq_delta(piece, from, to);
+ st->psqScore += pieceSquareTable[piece][to] - pieceSquareTable[piece][from];
// Set capture piece
st->capturedType = capture;
/// Position::see() is a static exchange evaluator: It tries to estimate the
-/// material gain or loss resulting from a move. There are three versions of
-/// this function: One which takes a destination square as input, one takes a
-/// move, and one which takes a 'from' and a 'to' square. The function does
-/// not yet understand promotions captures.
+/// material gain or loss resulting from a move. Parameter 'asymmThreshold' takes
+/// tempi into account. If the side who initiated the capturing sequence does the
+/// last capture, he loses a tempo and if the result is below 'asymmThreshold'
+/// the capturing sequence is considered bad.
int Position::see_sign(Move m) const {
return see(m);
}
-int Position::see(Move m) const {
- return do_see<false>(m, 0);
-}
-
-/// Position::see_asymm() takes tempi into account.
-/// If the side who initiated the capturing sequence does the last capture,
-/// he loses a tempo. In this case if the result is below asymmThreshold
-/// the capturing sequence is considered bad.
-
-int Position::see_asymm(Move m, int asymmThreshold) const
-{
- return do_see<true>(m, asymmThreshold);
-}
-
-template <bool Asymmetric>
-int Position::do_see(Move m, int asymmThreshold) const {
+int Position::see(Move m, int asymmThreshold) const {
Square from, to;
Bitboard occupied, attackers, stmAttackers;
} while (stmAttackers);
// If we are doing asymmetric SEE evaluation and the same side does the first
- // and the last capture, he loses a tempo and gain must be at least worth "asymmThreshold".
- // If not, we replace the score with a very low value, before negamaxing.
- if (Asymmetric)
- {
- for (int i = 0; i < slIndex ; i += 2)
- {
+ // and the last capture, he loses a tempo and gain must be at least worth
+ // 'asymmThreshold', otherwise we replace the score with a very low value,
+ // before negamaxing.
+ if (asymmThreshold)
+ for (int i = 0; i < slIndex; i += 2)
if (swapList[i] < asymmThreshold)
- swapList[i] = - QueenValueMg * 16;
- }
- }
+ swapList[i] = - QueenValueMg * 16;
// 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.
/// Position::is_draw() tests whether the position is drawn by material,
/// repetition, or the 50 moves rule. It does not detect stalemates, this
/// must be done by the search.
-template<bool SkipRepetition>
bool Position::is_draw() const {
// Draw by material?
return true;
// Draw by repetition?
- if (!SkipRepetition)
- {
- int i = 4, e = std::min(st->rule50, st->pliesFromNull);
+ int i = 4, e = std::min(st->rule50, st->pliesFromNull);
- if (i <= e)
- {
- StateInfo* stp = st->previous->previous;
+ if (i <= e)
+ {
+ StateInfo* stp = st->previous->previous;
- do {
- stp = stp->previous->previous;
+ do {
+ stp = stp->previous->previous;
- if (stp->key == st->key)
- return true;
+ if (stp->key == st->key)
+ return true;
- i += 2;
+ i += 2;
- } while (i <= e);
- }
+ } while (i <= e);
}
return false;
}
-// Explicit template instantiations
-template bool Position::is_draw<false>() const;
-template bool Position::is_draw<true>() const;
-
/// Position::flip() flips position with the white and black sides reversed. This
/// is only useful for debugging especially for finding evaluation symmetry bugs.