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