#include "bitcount.h"
#include "movegen.h"
+#include "notation.h"
#include "position.h"
#include "psqtab.h"
#include "rkiss.h"
/// object do not depend on any external data so we detach state pointer from
/// the source one.
-void Position::operator=(const Position& pos) {
+Position& Position::operator=(const Position& pos) {
memcpy(this, &pos, sizeof(Position));
startState = *st;
nodes = 0;
assert(pos_is_ok());
+
+ return *this;
}
for (rsq = relative_square(c, SQ_A1); type_of(piece_on(rsq)) != ROOK; rsq++) {}
else if (token >= 'A' && token <= 'H')
- rsq = make_square(File(token - 'A'), relative_rank(c, RANK_1));
+ rsq = File(token - 'A') | relative_rank(c, RANK_1);
else
continue;
if ( ((fen >> col) && (col >= 'a' && col <= 'h'))
&& ((fen >> row) && (row == '3' || row == '6')))
{
- st->epSquare = make_square(File(col - 'a'), Rank(row - '1'));
+ st->epSquare = File(col - 'a') | Rank(row - '1');
if (!(attackers_to(st->epSquare) & pieces(sideToMove, PAWN)))
st->epSquare = SQ_NONE;
for (File file = FILE_A; file <= FILE_H; file++)
{
- sq = make_square(file, rank);
+ sq = file | rank;
if (is_empty(sq))
emptyCnt++;
while (pinners)
{
- b = between_bb(ksq, pop_1st_bit(&pinners)) & pieces();
+ b = between_bb(ksq, pop_lsb(&pinners)) & pieces();
if (b && !more_than_one(b) && (b & pieces(sideToMove)))
result |= b;
// 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 (is_enpassant(m))
+ if (type_of(m) == ENPASSANT)
{
Color them = ~us;
Square to = to_sq(m);
// square is attacked by the opponent. Castling moves are checked
// for legality during move generation.
if (type_of(piece_on(from)) == KING)
- return is_castle(m) || !(attackers_to(to_sq(m)) & pieces(~us));
+ return type_of(m) == CASTLE || !(attackers_to(to_sq(m)) & pieces(~us));
// A non-king move is legal if and only if it is not pinned or it
// is moving along the ray towards or away from the king.
bool Position::move_is_legal(const Move m) const {
- for (MoveList<MV_LEGAL> ml(*this); !ml.end(); ++ml)
+ for (MoveList<LEGAL> ml(*this); !ml.end(); ++ml)
if (ml.move() == m)
return true;
Piece pc = piece_moved(m);
// Use a slower but simpler function for uncommon cases
- if (is_special(m))
+ if (type_of(m) != NORMAL)
return move_is_legal(m);
// Is not a promotion, so promotion piece must be empty
if (type_of(pc) != KING)
{
Bitboard b = checkers();
- Square checksq = pop_1st_bit(&b);
+ Square checksq = pop_lsb(&b);
if (b) // double check ? In this case a king move is required
return false;
}
// Can we skip the ugly special cases ?
- if (!is_special(m))
+ if (type_of(m) == NORMAL)
return false;
Color us = sideToMove;
Square ksq = king_square(~us);
// Promotion with check ?
- if (is_promotion(m))
+ if (type_of(m) == PROMOTION)
return attacks_from(Piece(promotion_type(m)), to, pieces() ^ from) & ksq;
// En passant capture with check ? We have already handled the case
// of direct checks and ordinary discovered check, the only case we
// need to handle is the unusual case of a discovered check through
// the captured pawn.
- if (is_enpassant(m))
+ if (type_of(m) == ENPASSANT)
{
- Square capsq = make_square(file_of(to), rank_of(from));
+ Square capsq = file_of(to) | rank_of(from);
Bitboard b = (pieces() ^ from ^ capsq) | to;
return (attacks_bb< ROOK>(ksq, b) & pieces(us, QUEEN, ROOK))
}
// Castling with check ?
- if (is_castle(m))
+ if (type_of(m) == CASTLE)
{
Square kfrom = from;
Square rfrom = to; // 'King captures the rook' notation
st->rule50++;
st->pliesFromNull++;
- if (is_castle(m))
+ if (type_of(m) == CASTLE)
{
st->key = k;
do_castle_move<true>(m);
Square to = to_sq(m);
Piece piece = piece_on(from);
PieceType pt = type_of(piece);
- PieceType capture = is_enpassant(m) ? PAWN : type_of(piece_on(to));
+ PieceType capture = type_of(m) == ENPASSANT ? PAWN : type_of(piece_on(to));
assert(color_of(piece) == us);
assert(color_of(piece_on(to)) != us);
// update non-pawn material.
if (capture == PAWN)
{
- if (is_enpassant(m))
+ if (type_of(m) == ENPASSANT)
{
capsq += pawn_push(them);
k ^= zobEp[file_of(st->epSquare)];
}
- if (is_promotion(m))
+ if (type_of(m) == PROMOTION)
{
PieceType promotion = promotion_type(m);
if (moveIsCheck)
{
- if (is_special(m))
+ if (type_of(m) != NORMAL)
st->checkersBB = attackers_to(king_square(them)) & pieces(us);
else
{
sideToMove = ~sideToMove;
- if (is_castle(m))
+ if (type_of(m) == CASTLE)
{
do_castle_move<false>(m);
return;
assert(color_of(piece) == us);
assert(capture != KING);
- if (is_promotion(m))
+ if (type_of(m) == PROMOTION)
{
PieceType promotion = promotion_type(m);
{
Square capsq = to;
- if (is_enpassant(m))
+ if (type_of(m) == ENPASSANT)
{
capsq -= pawn_push(us);
void Position::do_castle_move(Move m) {
assert(is_ok(m));
- assert(is_castle(m));
+ assert(type_of(m) == CASTLE);
Square kto, kfrom, rfrom, rto, kAfter, rAfter;
// As castle moves are implemented as capturing the rook, they have
// SEE == RookValueMidgame most of the times (unless the rook is under
// attack).
- if (is_castle(m))
+ if (type_of(m) == CASTLE)
return 0;
from = from_sq(m);
occ = pieces();
// Handle en passant moves
- if (is_enpassant(m))
+ if (type_of(m) == ENPASSANT)
{
Square capQq = to - pawn_push(sideToMove);
for (Bitboard b = pieces(); b; )
{
- Square s = pop_1st_bit(&b);
+ Square s = pop_lsb(&b);
k ^= zobrist[color_of(piece_on(s))][type_of(piece_on(s))][s];
}
for (Bitboard b = pieces(PAWN); b; )
{
- Square s = pop_1st_bit(&b);
+ Square s = pop_lsb(&b);
k ^= zobrist[color_of(piece_on(s))][PAWN][s];
}
for (Bitboard b = pieces(); b; )
{
- Square s = pop_1st_bit(&b);
+ Square s = pop_lsb(&b);
score += pieceSquareTable[piece_on(s)][s];
}
return true;
// Draw by the 50 moves rule?
- if (st->rule50 > 99 && (!in_check() || MoveList<MV_LEGAL>(*this).size()))
+ if (st->rule50 > 99 && (!in_check() || MoveList<LEGAL>(*this).size()))
return true;
// Draw by repetition?
Bitboard b = cr;
while (b)
{
- Key k = zobCastle[1ULL << pop_1st_bit(&b)];
+ Key k = zobCastle[1ULL << pop_lsb(&b)];
zobCastle[cr] ^= k ? k : rk.rand<Key>();
}
}
projects / stockfish / blobdiff