Revert "Revert "Revert "Shuffle detection #2064"""
[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   return *this;
322 }
323
324
325 /// Position::set_castling_right() is a helper function used to set castling
326 /// rights given the corresponding color and the rook starting square.
327
328 void Position::set_castling_right(Color c, Square rfrom) {
329
330   Square kfrom = square<KING>(c);
331   CastlingSide cs = kfrom < rfrom ? KING_SIDE : QUEEN_SIDE;
332   CastlingRight cr = (c | cs);
333
334   st->castlingRights |= cr;
335   castlingRightsMask[kfrom] |= cr;
336   castlingRightsMask[rfrom] |= cr;
337   castlingRookSquare[cr] = rfrom;
338
339   Square kto = relative_square(c, cs == KING_SIDE ? SQ_G1 : SQ_C1);
340   Square rto = relative_square(c, cs == KING_SIDE ? SQ_F1 : SQ_D1);
341
342   castlingPath[cr] =   (between_bb(rfrom, rto) | between_bb(kfrom, kto) | rto | kto)
343                     & ~(square_bb(kfrom) | rfrom);
344 }
345
346
347 /// Position::set_check_info() sets king attacks to detect if a move gives check
348
349 void Position::set_check_info(StateInfo* si) const {
350
351   si->blockersForKing[WHITE] = slider_blockers(pieces(BLACK), square<KING>(WHITE), si->pinners[BLACK]);
352   si->blockersForKing[BLACK] = slider_blockers(pieces(WHITE), square<KING>(BLACK), si->pinners[WHITE]);
353
354   Square ksq = square<KING>(~sideToMove);
355
356   si->checkSquares[PAWN]   = attacks_from<PAWN>(ksq, ~sideToMove);
357   si->checkSquares[KNIGHT] = attacks_from<KNIGHT>(ksq);
358   si->checkSquares[BISHOP] = attacks_from<BISHOP>(ksq);
359   si->checkSquares[ROOK]   = attacks_from<ROOK>(ksq);
360   si->checkSquares[QUEEN]  = si->checkSquares[BISHOP] | si->checkSquares[ROOK];
361   si->checkSquares[KING]   = 0;
362 }
363
364
365 /// Position::set_state() computes the hash keys of the position, and other
366 /// data that once computed is updated incrementally as moves are made.
367 /// The function is only used when a new position is set up, and to verify
368 /// the correctness of the StateInfo data when running in debug mode.
369
370 void Position::set_state(StateInfo* si) const {
371
372   si->key = si->materialKey = 0;
373   si->pawnKey = Zobrist::noPawns;
374   si->nonPawnMaterial[WHITE] = si->nonPawnMaterial[BLACK] = VALUE_ZERO;
375   si->checkersBB = attackers_to(square<KING>(sideToMove)) & pieces(~sideToMove);
376
377   set_check_info(si);
378
379   for (Bitboard b = pieces(); b; )
380   {
381       Square s = pop_lsb(&b);
382       Piece pc = piece_on(s);
383       si->key ^= Zobrist::psq[pc][s];
384
385       if (type_of(pc) == PAWN)
386           si->pawnKey ^= Zobrist::psq[pc][s];
387
388       else if (type_of(pc) != KING)
389           si->nonPawnMaterial[color_of(pc)] += PieceValue[MG][pc];
390   }
391
392   if (si->epSquare != SQ_NONE)
393       si->key ^= Zobrist::enpassant[file_of(si->epSquare)];
394
395   if (sideToMove == BLACK)
396       si->key ^= Zobrist::side;
397
398   si->key ^= Zobrist::castling[si->castlingRights];
399
400   for (Piece pc : Pieces)
401       for (int cnt = 0; cnt < pieceCount[pc]; ++cnt)
402           si->materialKey ^= Zobrist::psq[pc][cnt];
403 }
404
405
406 /// Position::set() is an overload to initialize the position object with
407 /// the given endgame code string like "KBPKN". It is mainly a helper to
408 /// get the material key out of an endgame code.
409
410 Position& Position::set(const string& code, Color c, StateInfo* si) {
411
412   assert(code.length() > 0 && code.length() < 8);
413   assert(code[0] == 'K');
414
415   string sides[] = { code.substr(code.find('K', 1)),      // Weak
416                      code.substr(0, code.find('K', 1)) }; // Strong
417
418   std::transform(sides[c].begin(), sides[c].end(), sides[c].begin(), tolower);
419
420   string fenStr = "8/" + sides[0] + char(8 - sides[0].length() + '0') + "/8/8/8/8/"
421                        + sides[1] + char(8 - sides[1].length() + '0') + "/8 w - - 0 10";
422
423   return set(fenStr, false, si, nullptr);
424 }
425
426
427 /// Position::fen() returns a FEN representation of the position. In case of
428 /// Chess960 the Shredder-FEN notation is used. This is mainly a debugging function.
429
430 const string Position::fen() const {
431
432   int emptyCnt;
433   std::ostringstream ss;
434
435   for (Rank r = RANK_8; r >= RANK_1; --r)
436   {
437       for (File f = FILE_A; f <= FILE_H; ++f)
438       {
439           for (emptyCnt = 0; f <= FILE_H && empty(make_square(f, r)); ++f)
440               ++emptyCnt;
441
442           if (emptyCnt)
443               ss << emptyCnt;
444
445           if (f <= FILE_H)
446               ss << PieceToChar[piece_on(make_square(f, r))];
447       }
448
449       if (r > RANK_1)
450           ss << '/';
451   }
452
453   ss << (sideToMove == WHITE ? " w " : " b ");
454
455   if (can_castle(WHITE_OO))
456       ss << (chess960 ? char('A' + file_of(castling_rook_square(WHITE_OO ))) : 'K');
457
458   if (can_castle(WHITE_OOO))
459       ss << (chess960 ? char('A' + file_of(castling_rook_square(WHITE_OOO))) : 'Q');
460
461   if (can_castle(BLACK_OO))
462       ss << (chess960 ? char('a' + file_of(castling_rook_square(BLACK_OO ))) : 'k');
463
464   if (can_castle(BLACK_OOO))
465       ss << (chess960 ? char('a' + file_of(castling_rook_square(BLACK_OOO))) : 'q');
466
467   if (!can_castle(ANY_CASTLING))
468       ss << '-';
469
470   ss << (ep_square() == SQ_NONE ? " - " : " " + UCI::square(ep_square()) + " ")
471      << st->rule50 << " " << 1 + (gamePly - (sideToMove == BLACK)) / 2;
472
473   return ss.str();
474 }
475
476
477 /// Position::slider_blockers() returns a bitboard of all the pieces (both colors)
478 /// that are blocking attacks on the square 's' from 'sliders'. A piece blocks a
479 /// slider if removing that piece from the board would result in a position where
480 /// square 's' is attacked. For example, a king-attack blocking piece can be either
481 /// a pinned or a discovered check piece, according if its color is the opposite
482 /// or the same of the color of the slider.
483
484 Bitboard Position::slider_blockers(Bitboard sliders, Square s, Bitboard& pinners) const {
485
486   Bitboard blockers = 0;
487   pinners = 0;
488
489   // Snipers are sliders that attack 's' when a piece and other snipers are removed
490   Bitboard snipers = (  (PseudoAttacks[  ROOK][s] & pieces(QUEEN, ROOK))
491                       | (PseudoAttacks[BISHOP][s] & pieces(QUEEN, BISHOP))) & sliders;
492   Bitboard occupancy = pieces() ^ snipers;
493
494   while (snipers)
495   {
496     Square sniperSq = pop_lsb(&snipers);
497     Bitboard b = between_bb(s, sniperSq) & occupancy;
498
499     if (b && !more_than_one(b))
500     {
501         blockers |= b;
502         if (b & pieces(color_of(piece_on(s))))
503             pinners |= sniperSq;
504     }
505   }
506   return blockers;
507 }
508
509
510 /// Position::attackers_to() computes a bitboard of all pieces which attack a
511 /// given square. Slider attacks use the occupied bitboard to indicate occupancy.
512
513 Bitboard Position::attackers_to(Square s, Bitboard occupied) const {
514
515   return  (attacks_from<PAWN>(s, BLACK)    & pieces(WHITE, PAWN))
516         | (attacks_from<PAWN>(s, WHITE)    & pieces(BLACK, PAWN))
517         | (attacks_from<KNIGHT>(s)         & pieces(KNIGHT))
518         | (attacks_bb<  ROOK>(s, occupied) & pieces(  ROOK, QUEEN))
519         | (attacks_bb<BISHOP>(s, occupied) & pieces(BISHOP, QUEEN))
520         | (attacks_from<KING>(s)           & pieces(KING));
521 }
522
523
524 /// Position::legal() tests whether a pseudo-legal move is legal
525
526 bool Position::legal(Move m) const {
527
528   assert(is_ok(m));
529
530   Color us = sideToMove;
531   Square from = from_sq(m);
532   Square to = to_sq(m);
533
534   assert(color_of(moved_piece(m)) == us);
535   assert(piece_on(square<KING>(us)) == make_piece(us, KING));
536
537   // En passant captures are a tricky special case. Because they are rather
538   // uncommon, we do it simply by testing whether the king is attacked after
539   // the move is made.
540   if (type_of(m) == ENPASSANT)
541   {
542       Square ksq = square<KING>(us);
543       Square capsq = to - pawn_push(us);
544       Bitboard occupied = (pieces() ^ from ^ capsq) | to;
545
546       assert(to == ep_square());
547       assert(moved_piece(m) == make_piece(us, PAWN));
548       assert(piece_on(capsq) == make_piece(~us, PAWN));
549       assert(piece_on(to) == NO_PIECE);
550
551       return   !(attacks_bb<  ROOK>(ksq, occupied) & pieces(~us, QUEEN, ROOK))
552             && !(attacks_bb<BISHOP>(ksq, occupied) & pieces(~us, QUEEN, BISHOP));
553   }
554
555   // Castling moves generation does not check if the castling path is clear of
556   // enemy attacks, it is delayed at a later time: now!
557   if (type_of(m) == CASTLING)
558   {
559       // After castling, the rook and king final positions are the same in
560       // Chess960 as they would be in standard chess.
561       to = relative_square(us, to > from ? SQ_G1 : SQ_C1);
562       Direction step = to > from ? WEST : EAST;
563
564       for (Square s = to; s != from; s += step)
565           if (attackers_to(s) & pieces(~us))
566               return false;
567
568       // In case of Chess960, verify that when moving the castling rook we do
569       // not discover some hidden checker.
570       // For instance an enemy queen in SQ_A1 when castling rook is in SQ_B1.
571       return   !chess960
572             || !(attacks_bb<ROOK>(to, pieces() ^ to_sq(m)) & pieces(~us, ROOK, QUEEN));
573   }
574
575   // If the moving piece is a king, check whether the destination square is
576   // attacked by the opponent.
577   if (type_of(piece_on(from)) == KING)
578       return !(attackers_to(to) & pieces(~us));
579
580   // A non-king move is legal if and only if it is not pinned or it
581   // is moving along the ray towards or away from the king.
582   return   !(blockers_for_king(us) & from)
583         ||  aligned(from, to, square<KING>(us));
584 }
585
586
587 /// Position::pseudo_legal() takes a random move and tests whether the move is
588 /// pseudo legal. It is used to validate moves from TT that can be corrupted
589 /// due to SMP concurrent access or hash position key aliasing.
590
591 bool Position::pseudo_legal(const Move m) const {
592
593   Color us = sideToMove;
594   Square from = from_sq(m);
595   Square to = to_sq(m);
596   Piece pc = moved_piece(m);
597
598   // Use a slower but simpler function for uncommon cases
599   if (type_of(m) != NORMAL)
600       return MoveList<LEGAL>(*this).contains(m);
601
602   // Is not a promotion, so promotion piece must be empty
603   if (promotion_type(m) - KNIGHT != NO_PIECE_TYPE)
604       return false;
605
606   // If the 'from' square is not occupied by a piece belonging to the side to
607   // move, the move is obviously not legal.
608   if (pc == NO_PIECE || color_of(pc) != us)
609       return false;
610
611   // The destination square cannot be occupied by a friendly piece
612   if (pieces(us) & to)
613       return false;
614
615   // Handle the special case of a pawn move
616   if (type_of(pc) == PAWN)
617   {
618       // We have already handled promotion moves, so destination
619       // cannot be on the 8th/1st rank.
620       if ((Rank8BB | Rank1BB) & to)
621           return false;
622
623       if (   !(attacks_from<PAWN>(from, us) & pieces(~us) & to) // Not a capture
624           && !((from + pawn_push(us) == to) && empty(to))       // Not a single push
625           && !(   (from + 2 * pawn_push(us) == to)              // Not a double push
626                && (rank_of(from) == relative_rank(us, RANK_2))
627                && empty(to)
628                && empty(to - pawn_push(us))))
629           return false;
630   }
631   else if (!(attacks_from(type_of(pc), from) & to))
632       return false;
633
634   // Evasions generator already takes care to avoid some kind of illegal moves
635   // and legal() relies on this. We therefore have to take care that the same
636   // kind of moves are filtered out here.
637   if (checkers())
638   {
639       if (type_of(pc) != KING)
640       {
641           // Double check? In this case a king move is required
642           if (more_than_one(checkers()))
643               return false;
644
645           // Our move must be a blocking evasion or a capture of the checking piece
646           if (!((between_bb(lsb(checkers()), square<KING>(us)) | checkers()) & to))
647               return false;
648       }
649       // In case of king moves under check we have to remove king so as to catch
650       // invalid moves like b1a1 when opposite queen is on c1.
651       else if (attackers_to(to, pieces() ^ from) & pieces(~us))
652           return false;
653   }
654
655   return true;
656 }
657
658
659 /// Position::gives_check() tests whether a pseudo-legal move gives a check
660
661 bool Position::gives_check(Move m) const {
662
663   assert(is_ok(m));
664   assert(color_of(moved_piece(m)) == sideToMove);
665
666   Square from = from_sq(m);
667   Square to = to_sq(m);
668
669   // Is there a direct check?
670   if (st->checkSquares[type_of(piece_on(from))] & to)
671       return true;
672
673   // Is there a discovered check?
674   if (   (st->blockersForKing[~sideToMove] & from)
675       && !aligned(from, to, square<KING>(~sideToMove)))
676       return true;
677
678   switch (type_of(m))
679   {
680   case NORMAL:
681       return false;
682
683   case PROMOTION:
684       return attacks_bb(promotion_type(m), to, pieces() ^ from) & square<KING>(~sideToMove);
685
686   // En passant capture with check? We have already handled the case
687   // of direct checks and ordinary discovered check, so the only case we
688   // need to handle is the unusual case of a discovered check through
689   // the captured pawn.
690   case ENPASSANT:
691   {
692       Square capsq = make_square(file_of(to), rank_of(from));
693       Bitboard b = (pieces() ^ from ^ capsq) | to;
694
695       return  (attacks_bb<  ROOK>(square<KING>(~sideToMove), b) & pieces(sideToMove, QUEEN, ROOK))
696             | (attacks_bb<BISHOP>(square<KING>(~sideToMove), b) & pieces(sideToMove, QUEEN, BISHOP));
697   }
698   case CASTLING:
699   {
700       Square kfrom = from;
701       Square rfrom = to; // Castling is encoded as 'King captures the rook'
702       Square kto = relative_square(sideToMove, rfrom > kfrom ? SQ_G1 : SQ_C1);
703       Square rto = relative_square(sideToMove, rfrom > kfrom ? SQ_F1 : SQ_D1);
704
705       return   (PseudoAttacks[ROOK][rto] & square<KING>(~sideToMove))
706             && (attacks_bb<ROOK>(rto, (pieces() ^ kfrom ^ rfrom) | rto | kto) & square<KING>(~sideToMove));
707   }
708   default:
709       assert(false);
710       return false;
711   }
712 }
713
714
715 /// Position::do_move() makes a move, and saves all information necessary
716 /// to a StateInfo object. The move is assumed to be legal. Pseudo-legal
717 /// moves should be filtered out before this function is called.
718
719 void Position::do_move(Move m, StateInfo& newSt, bool givesCheck) {
720
721   assert(is_ok(m));
722   assert(&newSt != st);
723
724   thisThread->nodes.fetch_add(1, std::memory_order_relaxed);
725   Key k = st->key ^ Zobrist::side;
726
727   // Copy some fields of the old state to our new StateInfo object except the
728   // ones which are going to be recalculated from scratch anyway and then switch
729   // our state pointer to point to the new (ready to be updated) state.
730   std::memcpy(&newSt, st, offsetof(StateInfo, key));
731   newSt.previous = st;
732   st = &newSt;
733
734   // Increment ply counters. In particular, rule50 will be reset to zero later on
735   // in case of a capture or a pawn move.
736   ++gamePly;
737   ++st->rule50;
738   ++st->pliesFromNull;
739
740   Color us = sideToMove;
741   Color them = ~us;
742   Square from = from_sq(m);
743   Square to = to_sq(m);
744   Piece pc = piece_on(from);
745   Piece captured = type_of(m) == ENPASSANT ? make_piece(them, PAWN) : piece_on(to);
746
747   assert(color_of(pc) == us);
748   assert(captured == NO_PIECE || color_of(captured) == (type_of(m) != CASTLING ? them : us));
749   assert(type_of(captured) != KING);
750
751   if (type_of(m) == CASTLING)
752   {
753       assert(pc == make_piece(us, KING));
754       assert(captured == make_piece(us, ROOK));
755
756       Square rfrom, rto;
757       do_castling<true>(us, from, to, rfrom, rto);
758
759       k ^= Zobrist::psq[captured][rfrom] ^ Zobrist::psq[captured][rto];
760       captured = NO_PIECE;
761   }
762
763   if (captured)
764   {
765       Square capsq = to;
766
767       // If the captured piece is a pawn, update pawn hash key, otherwise
768       // update non-pawn material.
769       if (type_of(captured) == PAWN)
770       {
771           if (type_of(m) == ENPASSANT)
772           {
773               capsq -= pawn_push(us);
774
775               assert(pc == make_piece(us, PAWN));
776               assert(to == st->epSquare);
777               assert(relative_rank(us, to) == RANK_6);
778               assert(piece_on(to) == NO_PIECE);
779               assert(piece_on(capsq) == make_piece(them, PAWN));
780
781               board[capsq] = NO_PIECE; // Not done by remove_piece()
782           }
783
784           st->pawnKey ^= Zobrist::psq[captured][capsq];
785       }
786       else
787           st->nonPawnMaterial[them] -= PieceValue[MG][captured];
788
789       // Update board and piece lists
790       remove_piece(captured, capsq);
791
792       // Update material hash key and prefetch access to materialTable
793       k ^= Zobrist::psq[captured][capsq];
794       st->materialKey ^= Zobrist::psq[captured][pieceCount[captured]];
795       prefetch(thisThread->materialTable[st->materialKey]);
796
797       // Reset rule 50 counter
798       st->rule50 = 0;
799   }
800
801   // Update hash key
802   k ^= Zobrist::psq[pc][from] ^ Zobrist::psq[pc][to];
803
804   // Reset en passant square
805   if (st->epSquare != SQ_NONE)
806   {
807       k ^= Zobrist::enpassant[file_of(st->epSquare)];
808       st->epSquare = SQ_NONE;
809   }
810
811   // Update castling rights if needed
812   if (st->castlingRights && (castlingRightsMask[from] | castlingRightsMask[to]))
813   {
814       int cr = castlingRightsMask[from] | castlingRightsMask[to];
815       k ^= Zobrist::castling[st->castlingRights & cr];
816       st->castlingRights &= ~cr;
817   }
818
819   // Move the piece. The tricky Chess960 castling is handled earlier
820   if (type_of(m) != CASTLING)
821       move_piece(pc, from, to);
822
823   // If the moving piece is a pawn do some special extra work
824   if (type_of(pc) == PAWN)
825   {
826       // Set en-passant square if the moved pawn can be captured
827       if (   (int(to) ^ int(from)) == 16
828           && (attacks_from<PAWN>(to - pawn_push(us), us) & pieces(them, PAWN)))
829       {
830           st->epSquare = to - pawn_push(us);
831           k ^= Zobrist::enpassant[file_of(st->epSquare)];
832       }
833
834       else if (type_of(m) == PROMOTION)
835       {
836           Piece promotion = make_piece(us, promotion_type(m));
837
838           assert(relative_rank(us, to) == RANK_8);
839           assert(type_of(promotion) >= KNIGHT && type_of(promotion) <= QUEEN);
840
841           remove_piece(pc, to);
842           put_piece(promotion, to);
843
844           // Update hash keys
845           k ^= Zobrist::psq[pc][to] ^ Zobrist::psq[promotion][to];
846           st->pawnKey ^= Zobrist::psq[pc][to];
847           st->materialKey ^=  Zobrist::psq[promotion][pieceCount[promotion]-1]
848                             ^ Zobrist::psq[pc][pieceCount[pc]];
849
850           // Update material
851           st->nonPawnMaterial[us] += PieceValue[MG][promotion];
852       }
853
854       // Update pawn hash key and prefetch access to pawnsTable
855       st->pawnKey ^= Zobrist::psq[pc][from] ^ Zobrist::psq[pc][to];
856
857       // Reset rule 50 draw counter
858       st->rule50 = 0;
859   }
860
861   // Set capture piece
862   st->capturedPiece = captured;
863
864   // Update the key with the final value
865   st->key = k;
866
867   // Calculate checkers bitboard (if move gives check)
868   st->checkersBB = givesCheck ? attackers_to(square<KING>(them)) & pieces(us) : 0;
869
870   sideToMove = ~sideToMove;
871
872   // Update king attacks used for fast check detection
873   set_check_info(st);
874
875   // Calculate the repetition info. It is the ply distance from the previous
876   // occurrence of the same position, negative in the 3-fold case, or zero
877   // if the position was not repeated.
878   st->repetition = 0;
879   int end = std::min(st->rule50, st->pliesFromNull);
880   if (end >= 4)
881   {
882       StateInfo* stp = st->previous->previous;
883       for (int i=4; i <= end; i += 2)
884       {
885           stp = stp->previous->previous;
886           if (stp->key == st->key)
887           {
888               st->repetition = stp->repetition ? -i : i;
889               break;
890           }
891       }
892   }
893
894   assert(pos_is_ok());
895 }
896
897
898 /// Position::undo_move() unmakes a move. When it returns, the position should
899 /// be restored to exactly the same state as before the move was made.
900
901 void Position::undo_move(Move m) {
902
903   assert(is_ok(m));
904
905   sideToMove = ~sideToMove;
906
907   Color us = sideToMove;
908   Square from = from_sq(m);
909   Square to = to_sq(m);
910   Piece pc = piece_on(to);
911
912   assert(empty(from) || type_of(m) == CASTLING);
913   assert(type_of(st->capturedPiece) != KING);
914
915   if (type_of(m) == PROMOTION)
916   {
917       assert(relative_rank(us, to) == RANK_8);
918       assert(type_of(pc) == promotion_type(m));
919       assert(type_of(pc) >= KNIGHT && type_of(pc) <= QUEEN);
920
921       remove_piece(pc, to);
922       pc = make_piece(us, PAWN);
923       put_piece(pc, to);
924   }
925
926   if (type_of(m) == CASTLING)
927   {
928       Square rfrom, rto;
929       do_castling<false>(us, from, to, rfrom, rto);
930   }
931   else
932   {
933       move_piece(pc, to, from); // Put the piece back at the source square
934
935       if (st->capturedPiece)
936       {
937           Square capsq = to;
938
939           if (type_of(m) == ENPASSANT)
940           {
941               capsq -= pawn_push(us);
942
943               assert(type_of(pc) == PAWN);
944               assert(to == st->previous->epSquare);
945               assert(relative_rank(us, to) == RANK_6);
946               assert(piece_on(capsq) == NO_PIECE);
947               assert(st->capturedPiece == make_piece(~us, PAWN));
948           }
949
950           put_piece(st->capturedPiece, capsq); // Restore the captured piece
951       }
952   }
953
954   // Finally point our state pointer back to the previous state
955   st = st->previous;
956   --gamePly;
957
958   assert(pos_is_ok());
959 }
960
961
962 /// Position::do_castling() is a helper used to do/undo a castling move. This
963 /// is a bit tricky in Chess960 where from/to squares can overlap.
964 template<bool Do>
965 void Position::do_castling(Color us, Square from, Square& to, Square& rfrom, Square& rto) {
966
967   bool kingSide = to > from;
968   rfrom = to; // Castling is encoded as "king captures friendly rook"
969   rto = relative_square(us, kingSide ? SQ_F1 : SQ_D1);
970   to = relative_square(us, kingSide ? SQ_G1 : SQ_C1);
971
972   // Remove both pieces first since squares could overlap in Chess960
973   remove_piece(make_piece(us, KING), Do ? from : to);
974   remove_piece(make_piece(us, ROOK), Do ? rfrom : rto);
975   board[Do ? from : to] = board[Do ? rfrom : rto] = NO_PIECE; // Since remove_piece doesn't do it for us
976   put_piece(make_piece(us, KING), Do ? to : from);
977   put_piece(make_piece(us, ROOK), Do ? rto : rfrom);
978 }
979
980
981 /// Position::do(undo)_null_move() is used to do(undo) a "null move": It flips
982 /// the side to move without executing any move on the board.
983
984 void Position::do_null_move(StateInfo& newSt) {
985
986   assert(!checkers());
987   assert(&newSt != st);
988
989   std::memcpy(&newSt, st, sizeof(StateInfo));
990   newSt.previous = st;
991   st = &newSt;
992
993   if (st->epSquare != SQ_NONE)
994   {
995       st->key ^= Zobrist::enpassant[file_of(st->epSquare)];
996       st->epSquare = SQ_NONE;
997   }
998
999   st->key ^= Zobrist::side;
1000   prefetch(TT.first_entry(st->key));
1001
1002   ++st->rule50;
1003   st->pliesFromNull = 0;
1004
1005   sideToMove = ~sideToMove;
1006
1007   set_check_info(st);
1008
1009   st->repetition = 0;
1010
1011   assert(pos_is_ok());
1012 }
1013
1014 void Position::undo_null_move() {
1015
1016   assert(!checkers());
1017
1018   st = st->previous;
1019   sideToMove = ~sideToMove;
1020 }
1021
1022
1023 /// Position::key_after() computes the new hash key after the given move. Needed
1024 /// for speculative prefetch. It doesn't recognize special moves like castling,
1025 /// en-passant and promotions.
1026
1027 Key Position::key_after(Move m) const {
1028
1029   Square from = from_sq(m);
1030   Square to = to_sq(m);
1031   Piece pc = piece_on(from);
1032   Piece captured = piece_on(to);
1033   Key k = st->key ^ Zobrist::side;
1034
1035   if (captured)
1036       k ^= Zobrist::psq[captured][to];
1037
1038   return k ^ Zobrist::psq[pc][to] ^ Zobrist::psq[pc][from];
1039 }
1040
1041
1042 /// Position::see_ge (Static Exchange Evaluation Greater or Equal) tests if the
1043 /// SEE value of move is greater or equal to the given threshold. We'll use an
1044 /// algorithm similar to alpha-beta pruning with a null window.
1045
1046 bool Position::see_ge(Move m, Value threshold) const {
1047
1048   assert(is_ok(m));
1049
1050   // Only deal with normal moves, assume others pass a simple see
1051   if (type_of(m) != NORMAL)
1052       return VALUE_ZERO >= threshold;
1053
1054   Bitboard stmAttackers;
1055   Square from = from_sq(m), to = to_sq(m);
1056   PieceType nextVictim = type_of(piece_on(from));
1057   Color us = color_of(piece_on(from));
1058   Color stm = ~us; // First consider opponent's move
1059   Value balance;   // Values of the pieces taken by us minus opponent's ones
1060
1061   // The opponent may be able to recapture so this is the best result
1062   // we can hope for.
1063   balance = PieceValue[MG][piece_on(to)] - threshold;
1064
1065   if (balance < VALUE_ZERO)
1066       return false;
1067
1068   // Now assume the worst possible result: that the opponent can
1069   // capture our piece for free.
1070   balance -= PieceValue[MG][nextVictim];
1071
1072   // If it is enough (like in PxQ) then return immediately. Note that
1073   // in case nextVictim == KING we always return here, this is ok
1074   // if the given move is legal.
1075   if (balance >= VALUE_ZERO)
1076       return true;
1077
1078   // Find all attackers to the destination square, with the moving piece
1079   // removed, but possibly an X-ray attacker added behind it.
1080   Bitboard occupied = pieces() ^ from ^ to;
1081   Bitboard attackers = attackers_to(to, occupied) & occupied;
1082
1083   while (true)
1084   {
1085       stmAttackers = attackers & pieces(stm);
1086
1087       // Don't allow pinned pieces to attack (except the king) as long as
1088       // any pinners are on their original square.
1089       if (st->pinners[~stm] & occupied)
1090           stmAttackers &= ~st->blockersForKing[stm];
1091
1092       // If stm has no more attackers then give up: stm loses
1093       if (!stmAttackers)
1094           break;
1095
1096       // Locate and remove the next least valuable attacker, and add to
1097       // the bitboard 'attackers' the possibly X-ray attackers behind it.
1098       nextVictim = min_attacker<PAWN>(byTypeBB, to, stmAttackers, occupied, attackers);
1099
1100       stm = ~stm; // Switch side to move
1101
1102       // Negamax the balance with alpha = balance, beta = balance+1 and
1103       // add nextVictim's value.
1104       //
1105       //      (balance, balance+1) -> (-balance-1, -balance)
1106       //
1107       assert(balance < VALUE_ZERO);
1108
1109       balance = -balance - 1 - PieceValue[MG][nextVictim];
1110
1111       // If balance is still non-negative after giving away nextVictim then we
1112       // win. The only thing to be careful about it is that we should revert
1113       // stm if we captured with the king when the opponent still has attackers.
1114       if (balance >= VALUE_ZERO)
1115       {
1116           if (nextVictim == KING && (attackers & pieces(stm)))
1117               stm = ~stm;
1118           break;
1119       }
1120       assert(nextVictim != KING);
1121   }
1122   return us != stm; // We break the above loop when stm loses
1123 }
1124
1125
1126 /// Position::is_draw() tests whether the position is drawn by 50-move rule
1127 /// or by repetition. It does not detect stalemates.
1128
1129 bool Position::is_draw(int ply) const {
1130
1131   if (st->rule50 > 99 && (!checkers() || MoveList<LEGAL>(*this).size()))
1132       return true;
1133
1134   // Return a draw score if a position repeats once earlier but strictly
1135   // after the root, or repeats twice before or at the root.
1136   if (st->repetition && st->repetition < ply)
1137       return true;
1138
1139   return false;
1140 }
1141
1142
1143 // Position::has_repeated() tests whether there has been at least one repetition
1144 // of positions since the last capture or pawn move.
1145
1146 bool Position::has_repeated() const {
1147
1148     StateInfo* stc = st;
1149     int end = std::min(st->rule50, st->pliesFromNull);
1150     while (end-- >= 4)
1151     {
1152         if (stc->repetition)
1153             return true;
1154
1155         stc = stc->previous;
1156     }
1157     return false;
1158 }
1159
1160
1161 /// Position::has_game_cycle() tests if the position has a move which draws by repetition,
1162 /// or an earlier position has a move that directly reaches the current position.
1163
1164 bool Position::has_game_cycle(int ply) const {
1165
1166   int j;
1167
1168   int end = std::min(st->rule50, st->pliesFromNull);
1169
1170   if (end < 3)
1171     return false;
1172
1173   Key originalKey = st->key;
1174   StateInfo* stp = st->previous;
1175
1176   for (int i = 3; i <= end; i += 2)
1177   {
1178       stp = stp->previous->previous;
1179
1180       Key moveKey = originalKey ^ stp->key;
1181       if (   (j = H1(moveKey), cuckoo[j] == moveKey)
1182           || (j = H2(moveKey), cuckoo[j] == moveKey))
1183       {
1184           Move move = cuckooMove[j];
1185           Square s1 = from_sq(move);
1186           Square s2 = to_sq(move);
1187
1188           if (!(between_bb(s1, s2) & pieces()))
1189           {
1190               if (ply > i)
1191                   return true;
1192
1193               // For nodes before or at the root, check that the move is a
1194               // repetition rather than a move to the current position.
1195               // In the cuckoo table, both moves Rc1c5 and Rc5c1 are stored in
1196               // the same location, so we have to select which square to check.
1197               if (color_of(piece_on(empty(s1) ? s2 : s1)) != side_to_move())
1198                   continue;
1199
1200               // For repetitions before or at the root, require one more
1201               if (stp->repetition)
1202                   return true;
1203           }
1204       }
1205   }
1206   return false;
1207 }
1208
1209
1210 /// Position::flip() flips position with the white and black sides reversed. This
1211 /// is only useful for debugging e.g. for finding evaluation symmetry bugs.
1212
1213 void Position::flip() {
1214
1215   string f, token;
1216   std::stringstream ss(fen());
1217
1218   for (Rank r = RANK_8; r >= RANK_1; --r) // Piece placement
1219   {
1220       std::getline(ss, token, r > RANK_1 ? '/' : ' ');
1221       f.insert(0, token + (f.empty() ? " " : "/"));
1222   }
1223
1224   ss >> token; // Active color
1225   f += (token == "w" ? "B " : "W "); // Will be lowercased later
1226
1227   ss >> token; // Castling availability
1228   f += token + " ";
1229
1230   std::transform(f.begin(), f.end(), f.begin(),
1231                  [](char c) { return char(islower(c) ? toupper(c) : tolower(c)); });
1232
1233   ss >> token; // En passant square
1234   f += (token == "-" ? token : token.replace(1, 1, token[1] == '3' ? "6" : "3"));
1235
1236   std::getline(ss, token); // Half and full moves
1237   f += token;
1238
1239   set(f, is_chess960(), st, this_thread());
1240
1241   assert(pos_is_ok());
1242 }
1243
1244
1245 /// Position::pos_is_ok() performs some consistency checks for the
1246 /// position object and raises an asserts if something wrong is detected.
1247 /// This is meant to be helpful when debugging.
1248
1249 bool Position::pos_is_ok() const {
1250
1251   constexpr bool Fast = true; // Quick (default) or full check?
1252
1253   if (   (sideToMove != WHITE && sideToMove != BLACK)
1254       || piece_on(square<KING>(WHITE)) != W_KING
1255       || piece_on(square<KING>(BLACK)) != B_KING
1256       || (   ep_square() != SQ_NONE
1257           && relative_rank(sideToMove, ep_square()) != RANK_6))
1258       assert(0 && "pos_is_ok: Default");
1259
1260   if (Fast)
1261       return true;
1262
1263   if (   pieceCount[W_KING] != 1
1264       || pieceCount[B_KING] != 1
1265       || attackers_to(square<KING>(~sideToMove)) & pieces(sideToMove))
1266       assert(0 && "pos_is_ok: Kings");
1267
1268   if (   (pieces(PAWN) & (Rank1BB | Rank8BB))
1269       || pieceCount[W_PAWN] > 8
1270       || pieceCount[B_PAWN] > 8)
1271       assert(0 && "pos_is_ok: Pawns");
1272
1273   if (   (pieces(WHITE) & pieces(BLACK))
1274       || (pieces(WHITE) | pieces(BLACK)) != pieces()
1275       || popcount(pieces(WHITE)) > 16
1276       || popcount(pieces(BLACK)) > 16)
1277       assert(0 && "pos_is_ok: Bitboards");
1278
1279   for (PieceType p1 = PAWN; p1 <= KING; ++p1)
1280       for (PieceType p2 = PAWN; p2 <= KING; ++p2)
1281           if (p1 != p2 && (pieces(p1) & pieces(p2)))
1282               assert(0 && "pos_is_ok: Bitboards");
1283
1284   StateInfo si = *st;
1285   set_state(&si);
1286   if (std::memcmp(&si, st, sizeof(StateInfo)))
1287       assert(0 && "pos_is_ok: State");
1288
1289   for (Piece pc : Pieces)
1290   {
1291       if (   pieceCount[pc] != popcount(pieces(color_of(pc), type_of(pc)))
1292           || pieceCount[pc] != std::count(board, board + SQUARE_NB, pc))
1293           assert(0 && "pos_is_ok: Pieces");
1294
1295       for (int i = 0; i < pieceCount[pc]; ++i)
1296           if (board[pieceList[pc][i]] != pc || index[pieceList[pc][i]] != i)
1297               assert(0 && "pos_is_ok: Index");
1298   }
1299
1300   for (Color c : { WHITE, BLACK })
1301       for (CastlingSide s : {KING_SIDE, QUEEN_SIDE})
1302       {
1303           if (!can_castle(c | s))
1304               continue;
1305
1306           if (   piece_on(castlingRookSquare[c | s]) != make_piece(c, ROOK)
1307               || castlingRightsMask[castlingRookSquare[c | s]] != (c | s)
1308               || (castlingRightsMask[square<KING>(c)] & (c | s)) != (c | s))
1309               assert(0 && "pos_is_ok: Castling");
1310       }
1311
1312   return true;
1313 }