a2ee64f81cc603e6e4a03dbbfbbc00afeb863aa6
[stockfish] / src / position.cpp
1 /*
2   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
3   Copyright (C) 2004-2021 The Stockfish developers (see AUTHORS file)
4
5   Stockfish is free software: you can redistribute it and/or modify
6   it under the terms of the GNU General Public License as published by
7   the Free Software Foundation, either version 3 of the License, or
8   (at your option) any later version.
9
10   Stockfish is distributed in the hope that it will be useful,
11   but WITHOUT ANY WARRANTY; without even the implied warranty of
12   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13   GNU General Public License for more details.
14
15   You should have received a copy of the GNU General Public License
16   along with this program.  If not, see <http://www.gnu.org/licenses/>.
17 */
18
19 #include <algorithm>
20 #include <cassert>
21 #include <cstddef> // For offsetof()
22 #include <cstring> // For std::memset, std::memcmp
23 #include <iomanip>
24 #include <sstream>
25
26 #include "bitboard.h"
27 #include "misc.h"
28 #include "movegen.h"
29 #include "position.h"
30 #include "thread.h"
31 #include "tt.h"
32 #include "uci.h"
33 #include "syzygy/tbprobe.h"
34
35 using std::string;
36
37 namespace Stockfish {
38
39 namespace Zobrist {
40
41   Key psq[PIECE_NB][SQUARE_NB];
42   Key enpassant[FILE_NB];
43   Key castling[CASTLING_RIGHT_NB];
44   Key side, noPawns;
45 }
46
47 namespace {
48
49 const string PieceToChar(" PNBRQK  pnbrqk");
50
51 constexpr Piece Pieces[] = { W_PAWN, W_KNIGHT, W_BISHOP, W_ROOK, W_QUEEN, W_KING,
52                              B_PAWN, B_KNIGHT, B_BISHOP, B_ROOK, B_QUEEN, B_KING };
53 } // namespace
54
55
56 /// operator<<(Position) returns an ASCII representation of the position
57
58 std::ostream& operator<<(std::ostream& os, const Position& pos) {
59
60   os << "\n +---+---+---+---+---+---+---+---+\n";
61
62   for (Rank r = RANK_8; r >= RANK_1; --r)
63   {
64       for (File f = FILE_A; f <= FILE_H; ++f)
65           os << " | " << PieceToChar[pos.piece_on(make_square(f, r))];
66
67       os << " | " << (1 + r) << "\n +---+---+---+---+---+---+---+---+\n";
68   }
69
70   os << "   a   b   c   d   e   f   g   h\n"
71      << "\nFen: " << pos.fen() << "\nKey: " << std::hex << std::uppercase
72      << std::setfill('0') << std::setw(16) << pos.key()
73      << std::setfill(' ') << std::dec << "\nCheckers: ";
74
75   for (Bitboard b = pos.checkers(); b; )
76       os << UCI::square(pop_lsb(&b)) << " ";
77
78   if (    int(Tablebases::MaxCardinality) >= popcount(pos.pieces())
79       && !pos.can_castle(ANY_CASTLING))
80   {
81       StateInfo st;
82       ASSERT_ALIGNED(&st, Eval::NNUE::kCacheLineSize);
83
84       Position p;
85       p.set(pos.fen(), pos.is_chess960(), &st, pos.this_thread());
86       Tablebases::ProbeState s1, s2;
87       Tablebases::WDLScore wdl = Tablebases::probe_wdl(p, &s1);
88       int dtz = Tablebases::probe_dtz(p, &s2);
89       os << "\nTablebases WDL: " << std::setw(4) << wdl << " (" << s1 << ")"
90          << "\nTablebases DTZ: " << std::setw(4) << dtz << " (" << s2 << ")";
91   }
92
93   return os;
94 }
95
96
97 // Marcel van Kervinck's cuckoo algorithm for fast detection of "upcoming repetition"
98 // situations. Description of the algorithm in the following paper:
99 // https://marcelk.net/2013-04-06/paper/upcoming-rep-v2.pdf
100
101 // First and second hash functions for indexing the cuckoo tables
102 inline int H1(Key h) { return h & 0x1fff; }
103 inline int H2(Key h) { return (h >> 16) & 0x1fff; }
104
105 // Cuckoo tables with Zobrist hashes of valid reversible moves, and the moves themselves
106 Key cuckoo[8192];
107 Move cuckooMove[8192];
108
109
110 /// Position::init() initializes at startup the various arrays used to compute hash keys
111
112 void Position::init() {
113
114   PRNG rng(1070372);
115
116   for (Piece pc : Pieces)
117       for (Square s = SQ_A1; s <= SQ_H8; ++s)
118           Zobrist::psq[pc][s] = rng.rand<Key>();
119
120   for (File f = FILE_A; f <= FILE_H; ++f)
121       Zobrist::enpassant[f] = rng.rand<Key>();
122
123   for (int cr = NO_CASTLING; cr <= ANY_CASTLING; ++cr)
124       Zobrist::castling[cr] = rng.rand<Key>();
125
126   Zobrist::side = rng.rand<Key>();
127   Zobrist::noPawns = rng.rand<Key>();
128
129   // Prepare the cuckoo tables
130   std::memset(cuckoo, 0, sizeof(cuckoo));
131   std::memset(cuckooMove, 0, sizeof(cuckooMove));
132   int count = 0;
133   for (Piece pc : Pieces)
134       for (Square s1 = SQ_A1; s1 <= SQ_H8; ++s1)
135           for (Square s2 = Square(s1 + 1); s2 <= SQ_H8; ++s2)
136               if ((type_of(pc) != PAWN) && (attacks_bb(type_of(pc), s1, 0) & s2))
137               {
138                   Move move = make_move(s1, s2);
139                   Key key = Zobrist::psq[pc][s1] ^ Zobrist::psq[pc][s2] ^ Zobrist::side;
140                   int i = H1(key);
141                   while (true)
142                   {
143                       std::swap(cuckoo[i], key);
144                       std::swap(cuckooMove[i], move);
145                       if (move == MOVE_NONE) // Arrived at empty slot?
146                           break;
147                       i = (i == H1(key)) ? H2(key) : H1(key); // Push victim to alternative slot
148                   }
149                   count++;
150              }
151   assert(count == 3668);
152 }
153
154
155 /// Position::set() initializes the position object with the given FEN string.
156 /// This function is not very robust - make sure that input FENs are correct,
157 /// this is assumed to be the responsibility of the GUI.
158
159 Position& Position::set(const string& fenStr, bool isChess960, StateInfo* si, Thread* th) {
160 /*
161    A FEN string defines a particular position using only the ASCII character set.
162
163    A FEN string contains six fields separated by a space. The fields are:
164
165    1) Piece placement (from white's perspective). Each rank is described, starting
166       with rank 8 and ending with rank 1. Within each rank, the contents of each
167       square are described from file A through file H. Following the Standard
168       Algebraic Notation (SAN), each piece is identified by a single letter taken
169       from the standard English names. White pieces are designated using upper-case
170       letters ("PNBRQK") whilst Black uses lowercase ("pnbrqk"). Blank squares are
171       noted using digits 1 through 8 (the number of blank squares), and "/"
172       separates ranks.
173
174    2) Active color. "w" means white moves next, "b" means black.
175
176    3) Castling availability. If neither side can castle, this is "-". Otherwise,
177       this has one or more letters: "K" (White can castle kingside), "Q" (White
178       can castle queenside), "k" (Black can castle kingside), and/or "q" (Black
179       can castle queenside).
180
181    4) En passant target square (in algebraic notation). If there's no en passant
182       target square, this is "-". If a pawn has just made a 2-square move, this
183       is the position "behind" the pawn. Following X-FEN standard, this is recorded only
184       if there is a pawn in position to make an en passant capture, and if there really
185       is a pawn that might have advanced two squares.
186
187    5) Halfmove clock. This is the number of halfmoves since the last pawn advance
188       or capture. This is used to determine if a draw can be claimed under the
189       fifty-move rule.
190
191    6) Fullmove number. The number of the full move. It starts at 1, and is
192       incremented after Black's move.
193 */
194
195   unsigned char col, row, token;
196   size_t idx;
197   Square sq = SQ_A8;
198   std::istringstream ss(fenStr);
199
200   std::memset(this, 0, sizeof(Position));
201   std::memset(si, 0, sizeof(StateInfo));
202   st = si;
203
204   ss >> std::noskipws;
205
206   // 1. Piece placement
207   while ((ss >> token) && !isspace(token))
208   {
209       if (isdigit(token))
210           sq += (token - '0') * EAST; // Advance the given number of files
211
212       else if (token == '/')
213           sq += 2 * SOUTH;
214
215       else if ((idx = PieceToChar.find(token)) != string::npos) {
216           put_piece(Piece(idx), sq);
217           ++sq;
218       }
219   }
220
221   // 2. Active color
222   ss >> token;
223   sideToMove = (token == 'w' ? WHITE : BLACK);
224   ss >> token;
225
226   // 3. Castling availability. Compatible with 3 standards: Normal FEN standard,
227   // Shredder-FEN that uses the letters of the columns on which the rooks began
228   // the game instead of KQkq and also X-FEN standard that, in case of Chess960,
229   // if an inner rook is associated with the castling right, the castling tag is
230   // replaced by the file letter of the involved rook, as for the Shredder-FEN.
231   while ((ss >> token) && !isspace(token))
232   {
233       Square rsq;
234       Color c = islower(token) ? BLACK : WHITE;
235       Piece rook = make_piece(c, ROOK);
236
237       token = char(toupper(token));
238
239       if (token == 'K')
240           for (rsq = relative_square(c, SQ_H1); piece_on(rsq) != rook; --rsq) {}
241
242       else if (token == 'Q')
243           for (rsq = relative_square(c, SQ_A1); piece_on(rsq) != rook; ++rsq) {}
244
245       else if (token >= 'A' && token <= 'H')
246           rsq = make_square(File(token - 'A'), relative_rank(c, RANK_1));
247
248       else
249           continue;
250
251       set_castling_right(c, rsq);
252   }
253
254   set_state(st);
255
256   // 4. En passant square.
257   // Ignore if square is invalid or not on side to move relative rank 6.
258   bool enpassant = false;
259
260   if (   ((ss >> col) && (col >= 'a' && col <= 'h'))
261       && ((ss >> row) && (row == (sideToMove == WHITE ? '6' : '3'))))
262   {
263       st->epSquare = make_square(File(col - 'a'), Rank(row - '1'));
264
265       // En passant square will be considered only if
266       // a) side to move have a pawn threatening epSquare
267       // b) there is an enemy pawn in front of epSquare
268       // c) there is no piece on epSquare or behind epSquare
269       // d) enemy pawn didn't block a check of its own color by moving forward
270       enpassant = pawn_attacks_bb(~sideToMove, st->epSquare) & pieces(sideToMove, PAWN)
271                && (pieces(~sideToMove, PAWN) & (st->epSquare + pawn_push(~sideToMove)))
272                && !(pieces() & (st->epSquare | (st->epSquare + pawn_push(sideToMove))))
273                && (   file_of(square<KING>(sideToMove)) == file_of(st->epSquare)
274                    || !(blockers_for_king(sideToMove) & (st->epSquare + pawn_push(~sideToMove))));
275   }
276
277   // It's necessary for st->previous to be intialized in this way because legality check relies on its existence
278   if (enpassant) {
279       st->previous = new StateInfo();
280       remove_piece(st->epSquare - pawn_push(sideToMove));
281       st->previous->checkersBB = attackers_to(square<KING>(~sideToMove)) & pieces(sideToMove);
282       st->previous->blockersForKing[WHITE] = slider_blockers(pieces(BLACK), square<KING>(WHITE), st->previous->pinners[BLACK]);
283       st->previous->blockersForKing[BLACK] = slider_blockers(pieces(WHITE), square<KING>(BLACK), st->previous->pinners[WHITE]);
284       put_piece(make_piece(~sideToMove, PAWN), st->epSquare - pawn_push(sideToMove));
285   }
286   else
287       st->epSquare = SQ_NONE;
288
289   // 5-6. Halfmove clock and fullmove number
290   ss >> std::skipws >> st->rule50 >> gamePly;
291
292   // Convert from fullmove starting from 1 to gamePly starting from 0,
293   // handle also common incorrect FEN with fullmove = 0.
294   gamePly = std::max(2 * (gamePly - 1), 0) + (sideToMove == BLACK);
295
296   chess960 = isChess960;
297   thisThread = th;
298   st->accumulator.state[WHITE] = Eval::NNUE::INIT;
299   st->accumulator.state[BLACK] = Eval::NNUE::INIT;
300
301   return *this;
302 }
303
304
305 /// Position::set_castling_right() is a helper function used to set castling
306 /// rights given the corresponding color and the rook starting square.
307
308 void Position::set_castling_right(Color c, Square rfrom) {
309
310   Square kfrom = square<KING>(c);
311   CastlingRights cr = c & (kfrom < rfrom ? KING_SIDE: QUEEN_SIDE);
312
313   st->castlingRights |= cr;
314   castlingRightsMask[kfrom] |= cr;
315   castlingRightsMask[rfrom] |= cr;
316   castlingRookSquare[cr] = rfrom;
317
318   Square kto = relative_square(c, cr & KING_SIDE ? SQ_G1 : SQ_C1);
319   Square rto = relative_square(c, cr & KING_SIDE ? SQ_F1 : SQ_D1);
320
321   castlingPath[cr] =   (between_bb(rfrom, rto) | between_bb(kfrom, kto) | rto | kto)
322                     & ~(kfrom | rfrom);
323 }
324
325
326 /// Position::set_check_info() sets king attacks to detect if a move gives check
327
328 void Position::set_check_info(StateInfo* si) const {
329
330   si->blockersForKing[WHITE] = slider_blockers(pieces(BLACK), square<KING>(WHITE), si->pinners[BLACK]);
331   si->blockersForKing[BLACK] = slider_blockers(pieces(WHITE), square<KING>(BLACK), si->pinners[WHITE]);
332
333   Square ksq = square<KING>(~sideToMove);
334
335   si->checkSquares[PAWN]   = pawn_attacks_bb(~sideToMove, ksq);
336   si->checkSquares[KNIGHT] = attacks_bb<KNIGHT>(ksq);
337   si->checkSquares[BISHOP] = attacks_bb<BISHOP>(ksq, pieces());
338   si->checkSquares[ROOK]   = attacks_bb<ROOK>(ksq, pieces());
339   si->checkSquares[QUEEN]  = si->checkSquares[BISHOP] | si->checkSquares[ROOK];
340   si->checkSquares[KING]   = 0;
341 }
342
343
344 /// Position::set_state() computes the hash keys of the position, and other
345 /// data that once computed is updated incrementally as moves are made.
346 /// The function is only used when a new position is set up, and to verify
347 /// the correctness of the StateInfo data when running in debug mode.
348
349 void Position::set_state(StateInfo* si) const {
350
351   si->key = si->materialKey = 0;
352   si->pawnKey = Zobrist::noPawns;
353   si->nonPawnMaterial[WHITE] = si->nonPawnMaterial[BLACK] = VALUE_ZERO;
354   si->checkersBB = attackers_to(square<KING>(sideToMove)) & pieces(~sideToMove);
355
356   set_check_info(si);
357
358   for (Bitboard b = pieces(); b; )
359   {
360       Square s = pop_lsb(&b);
361       Piece pc = piece_on(s);
362       si->key ^= Zobrist::psq[pc][s];
363
364       if (type_of(pc) == PAWN)
365           si->pawnKey ^= Zobrist::psq[pc][s];
366
367       else if (type_of(pc) != KING)
368           si->nonPawnMaterial[color_of(pc)] += PieceValue[MG][pc];
369   }
370
371   if (si->epSquare != SQ_NONE)
372       si->key ^= Zobrist::enpassant[file_of(si->epSquare)];
373
374   if (sideToMove == BLACK)
375       si->key ^= Zobrist::side;
376
377   si->key ^= Zobrist::castling[si->castlingRights];
378
379   for (Piece pc : Pieces)
380       for (int cnt = 0; cnt < pieceCount[pc]; ++cnt)
381           si->materialKey ^= Zobrist::psq[pc][cnt];
382 }
383
384
385 /// Position::set() is an overload to initialize the position object with
386 /// the given endgame code string like "KBPKN". It is mainly a helper to
387 /// get the material key out of an endgame code.
388
389 Position& Position::set(const string& code, Color c, StateInfo* si) {
390
391   assert(code[0] == 'K');
392
393   string sides[] = { code.substr(code.find('K', 1)),      // Weak
394                      code.substr(0, std::min(code.find('v'), code.find('K', 1))) }; // Strong
395
396   assert(sides[0].length() > 0 && sides[0].length() < 8);
397   assert(sides[1].length() > 0 && sides[1].length() < 8);
398
399   std::transform(sides[c].begin(), sides[c].end(), sides[c].begin(), tolower);
400
401   string fenStr = "8/" + sides[0] + char(8 - sides[0].length() + '0') + "/8/8/8/8/"
402                        + sides[1] + char(8 - sides[1].length() + '0') + "/8 w - - 0 10";
403
404   return set(fenStr, false, si, nullptr);
405 }
406
407
408 /// Position::fen() returns a FEN representation of the position. In case of
409 /// Chess960 the Shredder-FEN notation is used. This is mainly a debugging function.
410
411 string Position::fen() const {
412
413   int emptyCnt;
414   std::ostringstream ss;
415
416   for (Rank r = RANK_8; r >= RANK_1; --r)
417   {
418       for (File f = FILE_A; f <= FILE_H; ++f)
419       {
420           for (emptyCnt = 0; f <= FILE_H && empty(make_square(f, r)); ++f)
421               ++emptyCnt;
422
423           if (emptyCnt)
424               ss << emptyCnt;
425
426           if (f <= FILE_H)
427               ss << PieceToChar[piece_on(make_square(f, r))];
428       }
429
430       if (r > RANK_1)
431           ss << '/';
432   }
433
434   ss << (sideToMove == WHITE ? " w " : " b ");
435
436   if (can_castle(WHITE_OO))
437       ss << (chess960 ? char('A' + file_of(castling_rook_square(WHITE_OO ))) : 'K');
438
439   if (can_castle(WHITE_OOO))
440       ss << (chess960 ? char('A' + file_of(castling_rook_square(WHITE_OOO))) : 'Q');
441
442   if (can_castle(BLACK_OO))
443       ss << (chess960 ? char('a' + file_of(castling_rook_square(BLACK_OO ))) : 'k');
444
445   if (can_castle(BLACK_OOO))
446       ss << (chess960 ? char('a' + file_of(castling_rook_square(BLACK_OOO))) : 'q');
447
448   if (!can_castle(ANY_CASTLING))
449       ss << '-';
450
451   ss << (ep_square() == SQ_NONE ? " - " : " " + UCI::square(ep_square()) + " ")
452      << st->rule50 << " " << 1 + (gamePly - (sideToMove == BLACK)) / 2;
453
454   return ss.str();
455 }
456
457
458 /// Position::slider_blockers() returns a bitboard of all the pieces (both colors)
459 /// that are blocking attacks on the square 's' from 'sliders'. A piece blocks a
460 /// slider if removing that piece from the board would result in a position where
461 /// square 's' is attacked. For example, a king-attack blocking piece can be either
462 /// a pinned or a discovered check piece, according if its color is the opposite
463 /// or the same of the color of the slider.
464
465 Bitboard Position::slider_blockers(Bitboard sliders, Square s, Bitboard& pinners) const {
466
467   Bitboard blockers = 0;
468   pinners = 0;
469
470   // Snipers are sliders that attack 's' when a piece and other snipers are removed
471   Bitboard snipers = (  (attacks_bb<  ROOK>(s) & pieces(QUEEN, ROOK))
472                       | (attacks_bb<BISHOP>(s) & pieces(QUEEN, BISHOP))) & sliders;
473   Bitboard occupancy = pieces() ^ snipers;
474
475   while (snipers)
476   {
477     Square sniperSq = pop_lsb(&snipers);
478     Bitboard b = between_bb(s, sniperSq) & occupancy;
479
480     if (b && !more_than_one(b))
481     {
482         blockers |= b;
483         if (b & pieces(color_of(piece_on(s))))
484             pinners |= sniperSq;
485     }
486   }
487   return blockers;
488 }
489
490
491 /// Position::attackers_to() computes a bitboard of all pieces which attack a
492 /// given square. Slider attacks use the occupied bitboard to indicate occupancy.
493
494 Bitboard Position::attackers_to(Square s, Bitboard occupied) const {
495
496   return  (pawn_attacks_bb(BLACK, s)       & pieces(WHITE, PAWN))
497         | (pawn_attacks_bb(WHITE, s)       & pieces(BLACK, PAWN))
498         | (attacks_bb<KNIGHT>(s)           & pieces(KNIGHT))
499         | (attacks_bb<  ROOK>(s, occupied) & pieces(  ROOK, QUEEN))
500         | (attacks_bb<BISHOP>(s, occupied) & pieces(BISHOP, QUEEN))
501         | (attacks_bb<KING>(s)             & pieces(KING));
502 }
503
504
505 /// Position::legal() tests whether a pseudo-legal move is legal
506
507 bool Position::legal(Move m) const {
508
509   assert(is_ok(m));
510
511   Color us = sideToMove;
512   Square from = from_sq(m);
513   Square to = to_sq(m);
514
515   assert(color_of(moved_piece(m)) == us);
516   assert(piece_on(square<KING>(us)) == make_piece(us, KING));
517
518   // st->previous->blockersForKing consider capsq as empty.
519   // If pinned, it has to move along the king ray.
520   if (type_of(m) == EN_PASSANT)
521       return   !(st->previous->blockersForKing[sideToMove] & from)
522             || aligned(from, to, square<KING>(us));
523
524   // Castling moves generation does not check if the castling path is clear of
525   // enemy attacks, it is delayed at a later time: now!
526   if (type_of(m) == CASTLING)
527   {
528       // After castling, the rook and king final positions are the same in
529       // Chess960 as they would be in standard chess.
530       to = relative_square(us, to > from ? SQ_G1 : SQ_C1);
531       Direction step = to > from ? WEST : EAST;
532
533       for (Square s = to; s != from; s += step)
534           if (attackers_to(s) & pieces(~us))
535               return false;
536
537       // In case of Chess960, verify if the Rook blocks some checks
538       // For instance an enemy queen in SQ_A1 when castling rook is in SQ_B1.
539       return !chess960 || !(blockers_for_king(us) & to_sq(m));
540   }
541
542   // If the moving piece is a king, check whether the destination square is
543   // attacked by the opponent.
544   if (type_of(piece_on(from)) == KING)
545       return !(attackers_to(to) & pieces(~us));
546
547   // A non-king move is legal if and only if it is not pinned or it
548   // is moving along the ray towards or away from the king.
549   return !(blockers_for_king(us) & from)
550       || aligned(from, to, square<KING>(us));
551 }
552
553
554 /// Position::pseudo_legal() takes a random move and tests whether the move is
555 /// pseudo legal. It is used to validate moves from TT that can be corrupted
556 /// due to SMP concurrent access or hash position key aliasing.
557
558 bool Position::pseudo_legal(const Move m) const {
559
560   Color us = sideToMove;
561   Square from = from_sq(m);
562   Square to = to_sq(m);
563   Piece pc = moved_piece(m);
564
565   // Use a slower but simpler function for uncommon cases
566   // yet we skip the legality check of MoveList<LEGAL>().
567   if (type_of(m) != NORMAL)
568       return checkers() ? MoveList<    EVASIONS>(*this).contains(m)
569                         : MoveList<NON_EVASIONS>(*this).contains(m);
570
571   // Is not a promotion, so promotion piece must be empty
572   if (promotion_type(m) - KNIGHT != NO_PIECE_TYPE)
573       return false;
574
575   // If the 'from' square is not occupied by a piece belonging to the side to
576   // move, the move is obviously not legal.
577   if (pc == NO_PIECE || color_of(pc) != us)
578       return false;
579
580   // The destination square cannot be occupied by a friendly piece
581   if (pieces(us) & to)
582       return false;
583
584   // Handle the special case of a pawn move
585   if (type_of(pc) == PAWN)
586   {
587       // We have already handled promotion moves, so destination
588       // cannot be on the 8th/1st rank.
589       if ((Rank8BB | Rank1BB) & to)
590           return false;
591
592       if (   !(pawn_attacks_bb(us, from) & pieces(~us) & to) // Not a capture
593           && !((from + pawn_push(us) == to) && empty(to))       // Not a single push
594           && !(   (from + 2 * pawn_push(us) == to)              // Not a double push
595                && (relative_rank(us, from) == RANK_2)
596                && empty(to)
597                && empty(to - pawn_push(us))))
598           return false;
599   }
600   else if (!(attacks_bb(type_of(pc), from, pieces()) & to))
601       return false;
602
603   // Evasions generator already takes care to avoid some kind of illegal moves
604   // and legal() relies on this. We therefore have to take care that the same
605   // kind of moves are filtered out here.
606   if (checkers())
607   {
608       if (type_of(pc) != KING)
609       {
610           // Double check? In this case a king move is required
611           if (more_than_one(checkers()))
612               return false;
613
614           // Our move must be a blocking evasion or a capture of the checking piece
615           if (!((between_bb(lsb(checkers()), square<KING>(us)) | checkers()) & to))
616               return false;
617       }
618       // In case of king moves under check we have to remove king so as to catch
619       // invalid moves like b1a1 when opposite queen is on c1.
620       else if (attackers_to(to, pieces() ^ from) & pieces(~us))
621           return false;
622   }
623
624   return true;
625 }
626
627
628 /// Position::gives_check() tests whether a pseudo-legal move gives a check
629
630 bool Position::gives_check(Move m) const {
631
632   assert(is_ok(m));
633   assert(color_of(moved_piece(m)) == sideToMove);
634
635   Square from = from_sq(m);
636   Square to = to_sq(m);
637
638   // Is there a direct check?
639   if (check_squares(type_of(piece_on(from))) & to)
640       return true;
641
642   // Is there a discovered check?
643   if (   (blockers_for_king(~sideToMove) & from)
644       && !aligned(from, to, square<KING>(~sideToMove)))
645       return true;
646
647   switch (type_of(m))
648   {
649   case NORMAL:
650       return false;
651
652   case PROMOTION:
653       return attacks_bb(promotion_type(m), to, pieces() ^ from) & square<KING>(~sideToMove);
654
655   // The double-pushed pawn blocked a check? En Passant will remove the blocker.
656   // The only discovery check that wasn't handle is through capsq and fromsq
657   // So the King must be in the same rank as fromsq to consider this possibility.
658   // st->previous->blockersForKing consider capsq as empty.
659   case EN_PASSANT:
660       return st->previous->checkersBB
661           || (   rank_of(square<KING>(~sideToMove)) == rank_of(from)
662               && st->previous->blockersForKing[~sideToMove] & from);
663
664   default: //CASTLING
665   {
666       // Castling is encoded as 'king captures the rook'
667       Square ksq = square<KING>(~sideToMove);
668       Square rto = relative_square(sideToMove, to > from ? SQ_F1 : SQ_D1);
669
670       return   (attacks_bb<ROOK>(rto) & ksq)
671             && (attacks_bb<ROOK>(rto, pieces() ^ from ^ to) & ksq);
672   }
673   }
674 }
675
676
677 /// Position::do_move() makes a move, and saves all information necessary
678 /// to a StateInfo object. The move is assumed to be legal. Pseudo-legal
679 /// moves should be filtered out before this function is called.
680
681 void Position::do_move(Move m, StateInfo& newSt, bool givesCheck) {
682
683   assert(is_ok(m));
684   assert(&newSt != st);
685
686   thisThread->nodes.fetch_add(1, std::memory_order_relaxed);
687   Key k = st->key ^ Zobrist::side;
688
689   // Copy some fields of the old state to our new StateInfo object except the
690   // ones which are going to be recalculated from scratch anyway and then switch
691   // our state pointer to point to the new (ready to be updated) state.
692   std::memcpy(&newSt, st, offsetof(StateInfo, key));
693   newSt.previous = st;
694   st = &newSt;
695
696   // Increment ply counters. In particular, rule50 will be reset to zero later on
697   // in case of a capture or a pawn move.
698   ++gamePly;
699   ++st->rule50;
700   ++st->pliesFromNull;
701
702   // Used by NNUE
703   st->accumulator.state[WHITE] = Eval::NNUE::EMPTY;
704   st->accumulator.state[BLACK] = Eval::NNUE::EMPTY;
705   auto& dp = st->dirtyPiece;
706   dp.dirty_num = 1;
707
708   Color us = sideToMove;
709   Color them = ~us;
710   Square from = from_sq(m);
711   Square to = to_sq(m);
712   Piece pc = piece_on(from);
713   Piece captured = type_of(m) == EN_PASSANT ? make_piece(them, PAWN) : piece_on(to);
714
715   assert(color_of(pc) == us);
716   assert(captured == NO_PIECE || color_of(captured) == (type_of(m) != CASTLING ? them : us));
717   assert(type_of(captured) != KING);
718
719   if (type_of(m) == CASTLING)
720   {
721       assert(pc == make_piece(us, KING));
722       assert(captured == make_piece(us, ROOK));
723
724       Square rfrom, rto;
725       do_castling<true>(us, from, to, rfrom, rto);
726
727       k ^= Zobrist::psq[captured][rfrom] ^ Zobrist::psq[captured][rto];
728       captured = NO_PIECE;
729   }
730
731   if (captured)
732   {
733       Square capsq = to;
734
735       // If the captured piece is a pawn, update pawn hash key, otherwise
736       // update non-pawn material.
737       if (type_of(captured) == PAWN)
738       {
739           if (type_of(m) == EN_PASSANT)
740           {
741               capsq -= pawn_push(us);
742
743               assert(pc == make_piece(us, PAWN));
744               assert(to == st->epSquare);
745               assert(relative_rank(us, to) == RANK_6);
746               assert(piece_on(to) == NO_PIECE);
747               assert(piece_on(capsq) == make_piece(them, PAWN));
748           }
749
750           st->pawnKey ^= Zobrist::psq[captured][capsq];
751       }
752       else
753           st->nonPawnMaterial[them] -= PieceValue[MG][captured];
754
755       if (Eval::useNNUE)
756       {
757           dp.dirty_num = 2;  // 1 piece moved, 1 piece captured
758           dp.piece[1] = captured;
759           dp.from[1] = capsq;
760           dp.to[1] = SQ_NONE;
761       }
762
763       // Update board and piece lists
764       remove_piece(capsq);
765
766       if (type_of(m) == EN_PASSANT)
767           board[capsq] = NO_PIECE;
768
769       // Update material hash key and prefetch access to materialTable
770       k ^= Zobrist::psq[captured][capsq];
771       st->materialKey ^= Zobrist::psq[captured][pieceCount[captured]];
772       prefetch(thisThread->materialTable[st->materialKey]);
773
774       // Reset rule 50 counter
775       st->rule50 = 0;
776   }
777
778   // Update hash key
779   k ^= Zobrist::psq[pc][from] ^ Zobrist::psq[pc][to];
780
781   // Reset en passant square
782   if (st->epSquare != SQ_NONE)
783   {
784       k ^= Zobrist::enpassant[file_of(st->epSquare)];
785       st->epSquare = SQ_NONE;
786   }
787
788   // Update castling rights if needed
789   if (st->castlingRights && (castlingRightsMask[from] | castlingRightsMask[to]))
790   {
791       k ^= Zobrist::castling[st->castlingRights];
792       st->castlingRights &= ~(castlingRightsMask[from] | castlingRightsMask[to]);
793       k ^= Zobrist::castling[st->castlingRights];
794   }
795
796   // Move the piece. The tricky Chess960 castling is handled earlier
797   if (type_of(m) != CASTLING)
798   {
799       if (Eval::useNNUE)
800       {
801           dp.piece[0] = pc;
802           dp.from[0] = from;
803           dp.to[0] = to;
804       }
805
806       move_piece(from, to);
807   }
808
809   // If the moving piece is a pawn do some special extra work
810   if (type_of(pc) == PAWN)
811   {
812       // Set en passant square if the moved pawn can be captured
813       if (   (int(to) ^ int(from)) == 16
814           && (pawn_attacks_bb(us, to - pawn_push(us)) & pieces(them, PAWN)))
815       {
816           st->epSquare = to - pawn_push(us);
817           k ^= Zobrist::enpassant[file_of(st->epSquare)];
818       }
819
820       else if (type_of(m) == PROMOTION)
821       {
822           Piece promotion = make_piece(us, promotion_type(m));
823
824           assert(relative_rank(us, to) == RANK_8);
825           assert(type_of(promotion) >= KNIGHT && type_of(promotion) <= QUEEN);
826
827           remove_piece(to);
828           put_piece(promotion, to);
829
830           if (Eval::useNNUE)
831           {
832               // Promoting pawn to SQ_NONE, promoted piece from SQ_NONE
833               dp.to[0] = SQ_NONE;
834               dp.piece[dp.dirty_num] = promotion;
835               dp.from[dp.dirty_num] = SQ_NONE;
836               dp.to[dp.dirty_num] = to;
837               dp.dirty_num++;
838           }
839
840           // Update hash keys
841           k ^= Zobrist::psq[pc][to] ^ Zobrist::psq[promotion][to];
842           st->pawnKey ^= Zobrist::psq[pc][to];
843           st->materialKey ^=  Zobrist::psq[promotion][pieceCount[promotion]-1]
844                             ^ Zobrist::psq[pc][pieceCount[pc]];
845
846           // Update material
847           st->nonPawnMaterial[us] += PieceValue[MG][promotion];
848       }
849
850       // Update pawn hash key
851       st->pawnKey ^= Zobrist::psq[pc][from] ^ Zobrist::psq[pc][to];
852
853       // Reset rule 50 draw counter
854       st->rule50 = 0;
855   }
856
857   // Set capture piece
858   st->capturedPiece = captured;
859
860   // Update the key with the final value
861   st->key = k;
862
863   // Calculate checkers bitboard (if move gives check)
864   st->checkersBB = givesCheck ? attackers_to(square<KING>(them)) & pieces(us) : 0;
865
866   sideToMove = ~sideToMove;
867
868   // Update king attacks used for fast check detection
869   set_check_info(st);
870
871   // Calculate the repetition info. It is the ply distance from the previous
872   // occurrence of the same position, negative in the 3-fold case, or zero
873   // if the position was not repeated.
874   st->repetition = 0;
875   int end = std::min(st->rule50, st->pliesFromNull);
876   if (end >= 4)
877   {
878       StateInfo* stp = st->previous->previous;
879       for (int i = 4; i <= end; i += 2)
880       {
881           stp = stp->previous->previous;
882           if (stp->key == st->key)
883           {
884               st->repetition = stp->repetition ? -i : i;
885               break;
886           }
887       }
888   }
889
890   assert(pos_is_ok());
891 }
892
893
894 /// Position::undo_move() unmakes a move. When it returns, the position should
895 /// be restored to exactly the same state as before the move was made.
896
897 void Position::undo_move(Move m) {
898
899   assert(is_ok(m));
900
901   sideToMove = ~sideToMove;
902
903   Color us = sideToMove;
904   Square from = from_sq(m);
905   Square to = to_sq(m);
906   Piece pc = piece_on(to);
907
908   assert(empty(from) || type_of(m) == CASTLING);
909   assert(type_of(st->capturedPiece) != KING);
910
911   if (type_of(m) == PROMOTION)
912   {
913       assert(relative_rank(us, to) == RANK_8);
914       assert(type_of(pc) == promotion_type(m));
915       assert(type_of(pc) >= KNIGHT && type_of(pc) <= QUEEN);
916
917       remove_piece(to);
918       pc = make_piece(us, PAWN);
919       put_piece(pc, to);
920   }
921
922   if (type_of(m) == CASTLING)
923   {
924       Square rfrom, rto;
925       do_castling<false>(us, from, to, rfrom, rto);
926   }
927   else
928   {
929       move_piece(to, from); // Put the piece back at the source square
930
931       if (st->capturedPiece)
932       {
933           Square capsq = to;
934
935           if (type_of(m) == EN_PASSANT)
936           {
937               capsq -= pawn_push(us);
938
939               assert(type_of(pc) == PAWN);
940               assert(to == st->previous->epSquare);
941               assert(relative_rank(us, to) == RANK_6);
942               assert(piece_on(capsq) == NO_PIECE);
943               assert(st->capturedPiece == make_piece(~us, PAWN));
944           }
945
946           put_piece(st->capturedPiece, capsq); // Restore the captured piece
947       }
948   }
949
950   // Finally point our state pointer back to the previous state
951   st = st->previous;
952   --gamePly;
953
954   assert(pos_is_ok());
955 }
956
957
958 /// Position::do_castling() is a helper used to do/undo a castling move. This
959 /// is a bit tricky in Chess960 where from/to squares can overlap.
960 template<bool Do>
961 void Position::do_castling(Color us, Square from, Square& to, Square& rfrom, Square& rto) {
962
963   bool kingSide = to > from;
964   rfrom = to; // Castling is encoded as "king captures friendly rook"
965   rto = relative_square(us, kingSide ? SQ_F1 : SQ_D1);
966   to = relative_square(us, kingSide ? SQ_G1 : SQ_C1);
967
968   if (Do && Eval::useNNUE)
969   {
970       auto& dp = st->dirtyPiece;
971       dp.piece[0] = make_piece(us, KING);
972       dp.from[0] = from;
973       dp.to[0] = to;
974       dp.piece[1] = make_piece(us, ROOK);
975       dp.from[1] = rfrom;
976       dp.to[1] = rto;
977       dp.dirty_num = 2;
978   }
979
980   // Remove both pieces first since squares could overlap in Chess960
981   remove_piece(Do ? from : to);
982   remove_piece(Do ? rfrom : rto);
983   board[Do ? from : to] = board[Do ? rfrom : rto] = NO_PIECE; // Since remove_piece doesn't do this for us
984   put_piece(make_piece(us, KING), Do ? to : from);
985   put_piece(make_piece(us, ROOK), Do ? rto : rfrom);
986 }
987
988
989 /// Position::do(undo)_null_move() is used to do(undo) a "null move": it flips
990 /// the side to move without executing any move on the board.
991
992 void Position::do_null_move(StateInfo& newSt) {
993
994   assert(!checkers());
995   assert(&newSt != st);
996
997   std::memcpy(&newSt, st, offsetof(StateInfo, accumulator));
998
999   newSt.previous = st;
1000   st = &newSt;
1001
1002   st->dirtyPiece.dirty_num = 0;
1003   st->dirtyPiece.piece[0] = NO_PIECE; // Avoid checks in UpdateAccumulator()
1004   st->accumulator.state[WHITE] = Eval::NNUE::EMPTY;
1005   st->accumulator.state[BLACK] = Eval::NNUE::EMPTY;
1006
1007   if (st->epSquare != SQ_NONE)
1008   {
1009       st->key ^= Zobrist::enpassant[file_of(st->epSquare)];
1010       st->epSquare = SQ_NONE;
1011   }
1012
1013   st->key ^= Zobrist::side;
1014   prefetch(TT.first_entry(key()));
1015
1016   ++st->rule50;
1017   st->pliesFromNull = 0;
1018
1019   sideToMove = ~sideToMove;
1020
1021   set_check_info(st);
1022
1023   st->repetition = 0;
1024
1025   assert(pos_is_ok());
1026 }
1027
1028 void Position::undo_null_move() {
1029
1030   assert(!checkers());
1031
1032   st = st->previous;
1033   sideToMove = ~sideToMove;
1034 }
1035
1036
1037 /// Position::key_after() computes the new hash key after the given move. Needed
1038 /// for speculative prefetch. It doesn't recognize special moves like castling,
1039 /// en passant and promotions.
1040
1041 Key Position::key_after(Move m) const {
1042
1043   Square from = from_sq(m);
1044   Square to = to_sq(m);
1045   Piece pc = piece_on(from);
1046   Piece captured = piece_on(to);
1047   Key k = st->key ^ Zobrist::side;
1048
1049   if (captured)
1050       k ^= Zobrist::psq[captured][to];
1051
1052   return k ^ Zobrist::psq[pc][to] ^ Zobrist::psq[pc][from];
1053 }
1054
1055
1056 /// Position::see_ge (Static Exchange Evaluation Greater or Equal) tests if the
1057 /// SEE value of move is greater or equal to the given threshold. We'll use an
1058 /// algorithm similar to alpha-beta pruning with a null window.
1059
1060 bool Position::see_ge(Move m, Value threshold) const {
1061
1062   assert(is_ok(m));
1063
1064   // Only deal with normal moves, assume others pass a simple SEE
1065   if (type_of(m) != NORMAL)
1066       return VALUE_ZERO >= threshold;
1067
1068   Square from = from_sq(m), to = to_sq(m);
1069
1070   int swap = PieceValue[MG][piece_on(to)] - threshold;
1071   if (swap < 0)
1072       return false;
1073
1074   swap = PieceValue[MG][piece_on(from)] - swap;
1075   if (swap <= 0)
1076       return true;
1077
1078   Bitboard occupied = pieces() ^ from ^ to;
1079   Color stm = color_of(piece_on(from));
1080   Bitboard attackers = attackers_to(to, occupied);
1081   Bitboard stmAttackers, bb;
1082   int res = 1;
1083
1084   while (true)
1085   {
1086       stm = ~stm;
1087       attackers &= occupied;
1088
1089       // If stm has no more attackers then give up: stm loses
1090       if (!(stmAttackers = attackers & pieces(stm)))
1091           break;
1092
1093       // Don't allow pinned pieces to attack (except the king) as long as
1094       // there are pinners on their original square.
1095       if (pinners(~stm) & occupied)
1096           stmAttackers &= ~blockers_for_king(stm);
1097
1098       if (!stmAttackers)
1099           break;
1100
1101       res ^= 1;
1102
1103       // Locate and remove the next least valuable attacker, and add to
1104       // the bitboard 'attackers' any X-ray attackers behind it.
1105       if ((bb = stmAttackers & pieces(PAWN)))
1106       {
1107           if ((swap = PawnValueMg - swap) < res)
1108               break;
1109
1110           occupied ^= lsb(bb);
1111           attackers |= attacks_bb<BISHOP>(to, occupied) & pieces(BISHOP, QUEEN);
1112       }
1113
1114       else if ((bb = stmAttackers & pieces(KNIGHT)))
1115       {
1116           if ((swap = KnightValueMg - swap) < res)
1117               break;
1118
1119           occupied ^= lsb(bb);
1120       }
1121
1122       else if ((bb = stmAttackers & pieces(BISHOP)))
1123       {
1124           if ((swap = BishopValueMg - swap) < res)
1125               break;
1126
1127           occupied ^= lsb(bb);
1128           attackers |= attacks_bb<BISHOP>(to, occupied) & pieces(BISHOP, QUEEN);
1129       }
1130
1131       else if ((bb = stmAttackers & pieces(ROOK)))
1132       {
1133           if ((swap = RookValueMg - swap) < res)
1134               break;
1135
1136           occupied ^= lsb(bb);
1137           attackers |= attacks_bb<ROOK>(to, occupied) & pieces(ROOK, QUEEN);
1138       }
1139
1140       else if ((bb = stmAttackers & pieces(QUEEN)))
1141       {
1142           if ((swap = QueenValueMg - swap) < res)
1143               break;
1144
1145           occupied ^= lsb(bb);
1146           attackers |=  (attacks_bb<BISHOP>(to, occupied) & pieces(BISHOP, QUEEN))
1147                       | (attacks_bb<ROOK  >(to, occupied) & pieces(ROOK  , QUEEN));
1148       }
1149
1150       else // KING
1151            // If we "capture" with the king but opponent still has attackers,
1152            // reverse the result.
1153           return (attackers & ~pieces(stm)) ? res ^ 1 : res;
1154   }
1155
1156   return bool(res);
1157 }
1158
1159
1160 /// Position::is_draw() tests whether the position is drawn by 50-move rule
1161 /// or by repetition. It does not detect stalemates.
1162
1163 bool Position::is_draw(int ply) const {
1164
1165   if (st->rule50 > 99 && (!checkers() || MoveList<LEGAL>(*this).size()))
1166       return true;
1167
1168   // Return a draw score if a position repeats once earlier but strictly
1169   // after the root, or repeats twice before or at the root.
1170   return st->repetition && st->repetition < ply;
1171 }
1172
1173
1174 // Position::has_repeated() tests whether there has been at least one repetition
1175 // of positions since the last capture or pawn move.
1176
1177 bool Position::has_repeated() const {
1178
1179     StateInfo* stc = st;
1180     int end = std::min(st->rule50, st->pliesFromNull);
1181     while (end-- >= 4)
1182     {
1183         if (stc->repetition)
1184             return true;
1185
1186         stc = stc->previous;
1187     }
1188     return false;
1189 }
1190
1191
1192 /// Position::has_game_cycle() tests if the position has a move which draws by repetition,
1193 /// or an earlier position has a move that directly reaches the current position.
1194
1195 bool Position::has_game_cycle(int ply) const {
1196
1197   int j;
1198
1199   int end = std::min(st->rule50, st->pliesFromNull);
1200
1201   if (end < 3)
1202     return false;
1203
1204   Key originalKey = st->key;
1205   StateInfo* stp = st->previous;
1206
1207   for (int i = 3; i <= end; i += 2)
1208   {
1209       stp = stp->previous->previous;
1210
1211       Key moveKey = originalKey ^ stp->key;
1212       if (   (j = H1(moveKey), cuckoo[j] == moveKey)
1213           || (j = H2(moveKey), cuckoo[j] == moveKey))
1214       {
1215           Move move = cuckooMove[j];
1216           Square s1 = from_sq(move);
1217           Square s2 = to_sq(move);
1218
1219           if (!(between_bb(s1, s2) & pieces()))
1220           {
1221               if (ply > i)
1222                   return true;
1223
1224               // For nodes before or at the root, check that the move is a
1225               // repetition rather than a move to the current position.
1226               // In the cuckoo table, both moves Rc1c5 and Rc5c1 are stored in
1227               // the same location, so we have to select which square to check.
1228               if (color_of(piece_on(empty(s1) ? s2 : s1)) != side_to_move())
1229                   continue;
1230
1231               // For repetitions before or at the root, require one more
1232               if (stp->repetition)
1233                   return true;
1234           }
1235       }
1236   }
1237   return false;
1238 }
1239
1240
1241 /// Position::flip() flips position with the white and black sides reversed. This
1242 /// is only useful for debugging e.g. for finding evaluation symmetry bugs.
1243
1244 void Position::flip() {
1245
1246   string f, token;
1247   std::stringstream ss(fen());
1248
1249   for (Rank r = RANK_8; r >= RANK_1; --r) // Piece placement
1250   {
1251       std::getline(ss, token, r > RANK_1 ? '/' : ' ');
1252       f.insert(0, token + (f.empty() ? " " : "/"));
1253   }
1254
1255   ss >> token; // Active color
1256   f += (token == "w" ? "B " : "W "); // Will be lowercased later
1257
1258   ss >> token; // Castling availability
1259   f += token + " ";
1260
1261   std::transform(f.begin(), f.end(), f.begin(),
1262                  [](char c) { return char(islower(c) ? toupper(c) : tolower(c)); });
1263
1264   ss >> token; // En passant square
1265   f += (token == "-" ? token : token.replace(1, 1, token[1] == '3' ? "6" : "3"));
1266
1267   std::getline(ss, token); // Half and full moves
1268   f += token;
1269
1270   set(f, is_chess960(), st, this_thread());
1271
1272   assert(pos_is_ok());
1273 }
1274
1275
1276 /// Position::pos_is_ok() performs some consistency checks for the
1277 /// position object and raises an asserts if something wrong is detected.
1278 /// This is meant to be helpful when debugging.
1279
1280 bool Position::pos_is_ok() const {
1281
1282   constexpr bool Fast = true; // Quick (default) or full check?
1283
1284   if (   (sideToMove != WHITE && sideToMove != BLACK)
1285       || piece_on(square<KING>(WHITE)) != W_KING
1286       || piece_on(square<KING>(BLACK)) != B_KING
1287       || (   ep_square() != SQ_NONE
1288           && relative_rank(sideToMove, ep_square()) != RANK_6))
1289       assert(0 && "pos_is_ok: Default");
1290
1291   if (Fast)
1292       return true;
1293
1294   if (   pieceCount[W_KING] != 1
1295       || pieceCount[B_KING] != 1
1296       || attackers_to(square<KING>(~sideToMove)) & pieces(sideToMove))
1297       assert(0 && "pos_is_ok: Kings");
1298
1299   if (   (pieces(PAWN) & (Rank1BB | Rank8BB))
1300       || pieceCount[W_PAWN] > 8
1301       || pieceCount[B_PAWN] > 8)
1302       assert(0 && "pos_is_ok: Pawns");
1303
1304   if (   (pieces(WHITE) & pieces(BLACK))
1305       || (pieces(WHITE) | pieces(BLACK)) != pieces()
1306       || popcount(pieces(WHITE)) > 16
1307       || popcount(pieces(BLACK)) > 16)
1308       assert(0 && "pos_is_ok: Bitboards");
1309
1310   for (PieceType p1 = PAWN; p1 <= KING; ++p1)
1311       for (PieceType p2 = PAWN; p2 <= KING; ++p2)
1312           if (p1 != p2 && (pieces(p1) & pieces(p2)))
1313               assert(0 && "pos_is_ok: Bitboards");
1314
1315   StateInfo si = *st;
1316   ASSERT_ALIGNED(&si, Eval::NNUE::kCacheLineSize);
1317
1318   set_state(&si);
1319   if (std::memcmp(&si, st, sizeof(StateInfo)))
1320       assert(0 && "pos_is_ok: State");
1321
1322   for (Piece pc : Pieces)
1323       if (   pieceCount[pc] != popcount(pieces(color_of(pc), type_of(pc)))
1324           || pieceCount[pc] != std::count(board, board + SQUARE_NB, pc))
1325           assert(0 && "pos_is_ok: Pieces");
1326
1327   for (Color c : { WHITE, BLACK })
1328       for (CastlingRights cr : {c & KING_SIDE, c & QUEEN_SIDE})
1329       {
1330           if (!can_castle(cr))
1331               continue;
1332
1333           if (   piece_on(castlingRookSquare[cr]) != make_piece(c, ROOK)
1334               || castlingRightsMask[castlingRookSquare[cr]] != cr
1335               || (castlingRightsMask[square<KING>(c)] & cr) != cr)
1336               assert(0 && "pos_is_ok: Castling");
1337       }
1338
1339   return true;
1340 }
1341
1342 } // namespace Stockfish