#include "san.h"
#include "ucioption.h"
+using std::string;
+
////
//// Variables
copy(pos);
}
-Position::Position(const std::string& fen) {
+Position::Position(const string& fen) {
from_fen(fen);
}
/// string. This function is not very robust - make sure that input FENs are
/// correct (this is assumed to be the responsibility of the GUI).
-void Position::from_fen(const std::string& fen) {
+void Position::from_fen(const string& fen) {
- static const std::string pieceLetters = "KQRBNPkqrbnp";
+ static const string pieceLetters = "KQRBNPkqrbnp";
static const Piece pieces[] = { WK, WQ, WR, WB, WN, WP, BK, BQ, BR, BB, BN, BP };
clear();
continue;
}
size_t idx = pieceLetters.find(fen[i]);
- if (idx == std::string::npos)
+ if (idx == string::npos)
{
std::cout << "Error in FEN at character " << i << std::endl;
return;
st->materialKey = compute_material_key();
st->mgValue = compute_value<MidGame>();
st->egValue = compute_value<EndGame>();
- npMaterial[WHITE] = compute_non_pawn_material(WHITE);
- npMaterial[BLACK] = compute_non_pawn_material(BLACK);
+ st->npMaterial[WHITE] = compute_non_pawn_material(WHITE);
+ st->npMaterial[BLACK] = compute_non_pawn_material(BLACK);
}
/// Position::to_fen() converts the position object to a FEN string. This is
/// probably only useful for debugging.
-const std::string Position::to_fen() const {
+const string Position::to_fen() const {
- static const std::string pieceLetters = " PNBRQK pnbrqk";
- std::string fen;
+ static const string pieceLetters = " PNBRQK pnbrqk";
+ string fen;
int skip;
for (Rank rank = RANK_8; rank >= RANK_1; rank--)
void Position::print(Move m) const {
- static const std::string pieceLetters = " PNBRQK PNBRQK .";
+ static const string pieceLetters = " PNBRQK PNBRQK .";
// Check for reentrancy, as example when called from inside
// MovePicker that is used also here in move_to_san()
std::cout << std::endl;
if (m != MOVE_NONE)
{
- std::string col = (color_of_piece_on(move_from(m)) == BLACK ? ".." : "");
+ string col = (color_of_piece_on(move_from(m)) == BLACK ? ".." : "");
std::cout << "Move is: " << col << move_to_san(*this, m) << std::endl;
}
for (Rank rank = RANK_8; rank >= RANK_1; rank--)
}
/// Position::attacks_to() computes a bitboard containing all pieces which
-/// attacks a given square. There are two versions of this function: One
-/// which finds attackers of both colors, and one which only finds the
-/// attackers for one side.
+/// attacks a given square.
Bitboard Position::attacks_to(Square s) const {
const bool Rook = (Piece == QUEEN || Piece == ROOK);
const bool Slider = Bishop || Rook;
+ // Direct checks
if ( ( (Bishop && bit_is_set(BishopPseudoAttacks[ksq], to))
|| (Rook && bit_is_set(RookPseudoAttacks[ksq], to)))
&& bit_is_set(piece_attacks<Piece>(ksq), to)) // slow, try to early skip
&& bit_is_set(piece_attacks<Piece>(ksq), to))
set_bit(pCheckersBB, to);
+ // Discovery checks
if (Piece != QUEEN && bit_is_set(dcCandidates, from))
{
if (Piece != ROOK)
int castleRights, rule50;
Square epSquare;
Value mgValue, egValue;
+ Value npMaterial[2];
};
memcpy(&newSt, st, sizeof(ReducedStateInfo));
// Update material
if (capture != PAWN)
- npMaterial[them] -= piece_value_midgame(capture);
+ st->npMaterial[them] -= piece_value_midgame(capture);
// Update material hash key
st->materialKey ^= zobMaterial[them][capture][pieceCount[them][capture]];
st->capture = type_of_piece_on(to);
if (st->capture)
- do_capture_move(st->capture, them, to);
+ do_capture_move(st->capture, them, to);
// Remove pawn
clear_bit(&(byColorBB[us]), from);
st->egValue += pst<EndGame>(us, promotion, to);
// Update material
- npMaterial[us] += piece_value_midgame(promotion);
+ st->npMaterial[us] += piece_value_midgame(promotion);
// Clear the en passant square
if (st->epSquare != SQ_NONE)
set_bit(&(byTypeBB[0]), to);
board[to] = piece_of_color_and_type(them, st->capture);
- // Update material
- if (st->capture != PAWN)
- npMaterial[them] += piece_value_midgame(st->capture);
-
// Update piece list
pieceList[them][st->capture][pieceCount[them][st->capture]] = to;
index[to] = pieceCount[them][st->capture];
set_bit(&(byTypeBB[0]), from); // HACK: byTypeBB[0] == occupied squares
board[from] = piece_of_color_and_type(us, PAWN);
- // Update material
- npMaterial[us] -= piece_value_midgame(promotion);
-
// Update piece list
pieceList[us][PAWN][pieceCount[us][PAWN]] = from;
index[from] = pieceCount[us][PAWN];
set_bit(&(byTypeBB[0]), to); // HACK: byTypeBB[0] == occupied squares
board[to] = piece_of_color_and_type(them, st->capture);
- // Update material. Because the move is a promotion move, we know
- // that the captured piece cannot be a pawn.
- assert(st->capture != PAWN);
- npMaterial[them] += piece_value_midgame(st->capture);
-
// Update piece list
pieceList[them][st->capture][pieceCount[them][st->capture]] = to;
index[to] = pieceCount[them][st->capture];
set_bit(&(byTypeBB[0]), from);
board[from] = piece_of_color_and_type(us, PAWN);
- // Update piece list:
+ // Update piece list
pieceList[us][PAWN][index[to]] = from;
index[from] = index[to];
pieceList[them][PAWN][pieceCount[them][PAWN]] = capsq;
index[capsq] = pieceCount[them][PAWN];
- // Update piece count:
+ // Update piece count
pieceCount[them][PAWN]++;
}
// Back up the information necessary to undo the null move to the supplied
// StateInfo object. In the case of a null move, the only thing we need to
- // remember is the last move made and the en passant square.
+ // remember is the en passant square.
// Note that differently from normal case here backupSt is actually used as
// a backup storage not as a new state to be used.
- backupSt.lastMove = st->lastMove;
backupSt.epSquare = st->epSquare;
backupSt.previous = st->previous;
st->previous = &backupSt;
assert(!is_check());
// Restore information from the our backup StateInfo object
- st->lastMove = st->previous->lastMove;
st->epSquare = st->previous->epSquare;
st->previous = st->previous->previous;
st->egValue = compute_value<EndGame>();
// Material
- npMaterial[WHITE] = compute_non_pawn_material(WHITE);
- npMaterial[BLACK] = compute_non_pawn_material(BLACK);
+ st->npMaterial[WHITE] = compute_non_pawn_material(WHITE);
+ st->npMaterial[BLACK] = compute_non_pawn_material(BLACK);
assert(is_ok());
}
if (failedStep) (*failedStep)++;
if (debugNonPawnMaterial)
{
- if (npMaterial[WHITE] != compute_non_pawn_material(WHITE))
+ if (st->npMaterial[WHITE] != compute_non_pawn_material(WHITE))
return false;
- if (npMaterial[BLACK] != compute_non_pawn_material(BLACK))
+ if (st->npMaterial[BLACK] != compute_non_pawn_material(BLACK))
return false;
}