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