along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
+#include <algorithm>
#include <cassert>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <sstream>
-#include <algorithm>
#include "bitcount.h"
#include "movegen.h"
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++)
+ 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++)
+ for (File f = FILE_A; f <= FILE_H; ++f)
Zobrist::enpassant[f] = rk.rand<Key>();
for (int cr = CASTLES_NONE; cr <= ALL_CASTLES; cr++)
Zobrist::side = rk.rand<Key>();
Zobrist::exclusion = rk.rand<Key>();
- for (PieceType pt = PAWN; pt <= KING; pt++)
+ 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++)
+ 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]);
else if ((p = PieceToChar.find(token)) != string::npos)
{
put_piece(sq, color_of(Piece(p)), type_of(Piece(p)));
- sq++;
+ ++sq;
}
}
token = char(toupper(token));
if (token == 'K')
- for (rsq = relative_square(c, SQ_H1); type_of(piece_on(rsq)) != ROOK; rsq--) {}
+ for (rsq = relative_square(c, SQ_H1); type_of(piece_on(rsq)) != ROOK; --rsq) {}
else if (token == 'Q')
- for (rsq = relative_square(c, SQ_A1); type_of(piece_on(rsq)) != ROOK; rsq++) {}
+ for (rsq = relative_square(c, SQ_A1); type_of(piece_on(rsq)) != ROOK; ++rsq) {}
else if (token >= 'A' && token <= 'H')
rsq = File(token - 'A') | relative_rank(c, RANK_1);
Square kto = relative_square(c, cs == KING_SIDE ? SQ_G1 : SQ_C1);
Square rto = relative_square(c, cs == KING_SIDE ? SQ_F1 : SQ_D1);
- for (Square s = std::min(rfrom, rto); s <= std::max(rfrom, rto); s++)
+ for (Square s = std::min(rfrom, rto); s <= std::max(rfrom, rto); ++s)
if (s != kfrom && s != rfrom)
castlePath[c][cs] |= s;
- for (Square s = std::min(kfrom, kto); s <= std::max(kfrom, kto); s++)
+ for (Square s = std::min(kfrom, kto); s <= std::max(kfrom, kto); ++s)
if (s != kfrom && s != rfrom)
castlePath[c][cs] |= s;
}
std::ostringstream ss;
- for (Rank rank = RANK_8; rank >= RANK_1; rank--)
+ for (Rank rank = RANK_8; rank >= RANK_1; --rank)
{
- for (File file = FILE_A; file <= FILE_H; file++)
+ for (File file = FILE_A; file <= FILE_H; ++file)
{
Square sq = file | rank;
{
int emptyCnt = 1;
- for ( ; file < FILE_H && is_empty(sq++); file++)
+ for ( ; file < FILE_H && is_empty(++sq); ++file)
emptyCnt++;
ss << emptyCnt;
void Position::do_castle(Square kfrom, Square kto, Square rfrom, Square rto) {
- Color us = sideToMove;
- Bitboard k_from_to_bb = SquareBB[kfrom] ^ SquareBB[kto];
- Bitboard r_from_to_bb = SquareBB[rfrom] ^ SquareBB[rto];
- byTypeBB[KING] ^= k_from_to_bb;
- byTypeBB[ROOK] ^= r_from_to_bb;
- byTypeBB[ALL_PIECES] ^= k_from_to_bb ^ r_from_to_bb;
- byColorBB[us] ^= k_from_to_bb ^ r_from_to_bb;
-
- // Could be from == to, so first set NO_PIECE then KING and ROOK
- board[kfrom] = board[rfrom] = NO_PIECE;
- board[kto] = make_piece(us, KING);
- board[rto] = make_piece(us, ROOK);
-
- // Could be kfrom == rto, so use a 'tmp' variable
- int tmp = index[kfrom];
- index[rto] = index[rfrom];
- index[kto] = tmp;
- pieceList[us][KING][index[kto]] = kto;
- pieceList[us][ROOK][index[rto]] = rto;
+ // Remove both pieces first since squares could overlap in Chess960
+ remove_piece(kfrom, sideToMove, KING);
+ remove_piece(rfrom, sideToMove, ROOK);
+ board[kfrom] = board[rfrom] = NO_PIECE; // Since remove_piece doesn't do it for us
+ put_piece(kto, sideToMove, KING);
+ put_piece(rto, sideToMove, ROOK);
}
startState.epSquare = SQ_NONE;
st = &startState;
- for (int i = 0; i < 8; i++)
+ for (int i = 0; i < PIECE_TYPE_NB; i++)
for (int j = 0; j < 16; j++)
- pieceList[0][i][j] = pieceList[1][i][j] = SQ_NONE;
+ pieceList[WHITE][i][j] = pieceList[BLACK][i][j] = SQ_NONE;
}
Key k = 0;
- for (Color c = WHITE; c <= BLACK; c++)
- for (PieceType pt = PAWN; pt <= QUEEN; pt++)
- for (int cnt = 0; cnt < pieceCount[c][pt]; cnt++)
+ for (Color c = WHITE; c <= BLACK; ++c)
+ for (PieceType pt = PAWN; pt <= QUEEN; ++pt)
+ for (int cnt = 0; cnt < pieceCount[c][pt]; ++cnt)
k ^= Zobrist::psq[c][pt][cnt];
return k;
/// game and the endgame. These functions are used to initialize the incremental
/// scores when a new position is set up, and to verify that the scores are correctly
/// updated by do_move and undo_move when the program is running in debug mode.
+
Score Position::compute_psq_score() const {
Score score = SCORE_ZERO;
Value value = VALUE_ZERO;
- for (PieceType pt = KNIGHT; pt <= QUEEN; pt++)
+ for (PieceType pt = KNIGHT; pt <= QUEEN; ++pt)
value += pieceCount[c][pt] * PieceValue[MG][pt];
return value;
if (st->rule50 > 99 && (!checkers() || MoveList<LEGAL>(*this).size()))
return true;
- // Draw by repetition?
int i = 4, e = std::min(st->rule50, st->pliesFromNull);
if (i <= e)
stp = stp->previous->previous;
if (stp->key == st->key)
- return true;
+ return true; // Draw after first repetition
i += 2;
/// Position::flip() flips position with the white and black sides reversed. This
/// is only useful for debugging especially for finding evaluation symmetry bugs.
+static char toggle_case(char c) {
+ return char(islower(c) ? toupper(c) : tolower(c));
+}
+
void Position::flip() {
- const Position pos(*this);
+ string f, token;
+ std::stringstream ss(fen());
- clear();
+ for (Rank rank = RANK_8; rank >= RANK_1; --rank) // Piece placement
+ {
+ std::getline(ss, token, rank > RANK_1 ? '/' : ' ');
+ f.insert(0, token + (f.empty() ? " " : "/"));
+ }
- sideToMove = ~pos.side_to_move();
- thisThread = pos.this_thread();
- nodes = pos.nodes_searched();
- chess960 = pos.is_chess960();
- gamePly = pos.game_ply();
+ ss >> token; // Active color
+ f += (token == "w" ? "B " : "W "); // Will be lowercased later
- for (Square s = SQ_A1; s <= SQ_H8; s++)
- if (!pos.is_empty(s))
- {
- Piece p = Piece(pos.piece_on(s) ^ 8);
- put_piece(~s, color_of(p), type_of(p));
- }
+ ss >> token; // Castling availability
+ f += token + " ";
- if (pos.can_castle(WHITE_OO))
- set_castle_right(BLACK, ~pos.castle_rook_square(WHITE, KING_SIDE));
- if (pos.can_castle(WHITE_OOO))
- set_castle_right(BLACK, ~pos.castle_rook_square(WHITE, QUEEN_SIDE));
- if (pos.can_castle(BLACK_OO))
- set_castle_right(WHITE, ~pos.castle_rook_square(BLACK, KING_SIDE));
- if (pos.can_castle(BLACK_OOO))
- set_castle_right(WHITE, ~pos.castle_rook_square(BLACK, QUEEN_SIDE));
+ std::transform(f.begin(), f.end(), f.begin(), toggle_case);
- if (pos.st->epSquare != SQ_NONE)
- st->epSquare = ~pos.st->epSquare;
+ ss >> token; // En passant square
+ f += (token == "-" ? token : token.replace(1, 1, token[1] == '3' ? "6" : "3"));
- st->checkersBB = attackers_to(king_square(sideToMove)) & pieces(~sideToMove);
+ std::getline(ss, token); // Half and full moves
+ f += token;
- st->key = compute_key();
- st->pawnKey = compute_pawn_key();
- st->materialKey = compute_material_key();
- st->psq = compute_psq_score();
- st->npMaterial[WHITE] = compute_non_pawn_material(WHITE);
- st->npMaterial[BLACK] = compute_non_pawn_material(BLACK);
+ set(f, is_chess960(), this_thread());
assert(pos_is_ok());
}
{
int kingCount[COLOR_NB] = {};
- for (Square s = SQ_A1; s <= SQ_H8; s++)
+ for (Square s = SQ_A1; s <= SQ_H8; ++s)
if (type_of(piece_on(s)) == KING)
kingCount[color_of(piece_on(s))]++;
return false;
// Separate piece type bitboards must have empty intersections
- for (PieceType p1 = PAWN; p1 <= KING; p1++)
- for (PieceType p2 = PAWN; p2 <= KING; p2++)
+ for (PieceType p1 = PAWN; p1 <= KING; ++p1)
+ for (PieceType p2 = PAWN; p2 <= KING; ++p2)
if (p1 != p2 && (pieces(p1) & pieces(p2)))
return false;
}
return false;
if ((*step)++, debugPieceCounts)
- for (Color c = WHITE; c <= BLACK; c++)
- for (PieceType pt = PAWN; pt <= KING; pt++)
+ for (Color c = WHITE; c <= BLACK; ++c)
+ for (PieceType pt = PAWN; pt <= KING; ++pt)
if (pieceCount[c][pt] != popcount<Full>(pieces(c, pt)))
return false;
if ((*step)++, debugPieceList)
- for (Color c = WHITE; c <= BLACK; c++)
- for (PieceType pt = PAWN; pt <= KING; pt++)
+ for (Color c = WHITE; c <= BLACK; ++c)
+ for (PieceType pt = PAWN; pt <= KING; ++pt)
for (int i = 0; i < pieceCount[c][pt]; i++)
if ( board[pieceList[c][pt][i]] != make_piece(c, pt)
|| index[pieceList[c][pt][i]] != i)
return false;
if ((*step)++, debugCastleSquares)
- for (Color c = WHITE; c <= BLACK; c++)
+ for (Color c = WHITE; c <= BLACK; ++c)
for (CastlingSide s = KING_SIDE; s <= QUEEN_SIDE; s = CastlingSide(s + 1))
{
CastleRight cr = make_castle_right(c, s);
projects / stockfish / blobdiff