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