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