Rename CASTLE to CASTLING
[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-2013 Marco Costalba, Joona Kiiski, Tord Romstad
5
6   Stockfish is free software: you can redistribute it and/or modify
7   it under the terms of the GNU General Public License as published by
8   the Free Software Foundation, either version 3 of the License, or
9   (at your option) any later version.
10
11   Stockfish is distributed in the hope that it will be useful,
12   but WITHOUT ANY WARRANTY; without even the implied warranty of
13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14   GNU General Public License for more details.
15
16   You should have received a copy of the GNU General Public License
17   along with this program.  If not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include <algorithm>
21 #include <cassert>
22 #include <cstring>
23 #include <iomanip>
24 #include <sstream>
25
26 #include "bitcount.h"
27 #include "movegen.h"
28 #include "notation.h"
29 #include "position.h"
30 #include "psqtab.h"
31 #include "rkiss.h"
32 #include "thread.h"
33 #include "tt.h"
34
35 using std::string;
36
37 static const string PieceToChar(" PNBRQK  pnbrqk");
38
39 CACHE_LINE_ALIGNMENT
40
41 Score psq[COLOR_NB][PIECE_TYPE_NB][SQUARE_NB];
42 Value PieceValue[PHASE_NB][PIECE_NB] = {
43 { VALUE_ZERO, PawnValueMg, KnightValueMg, BishopValueMg, RookValueMg, QueenValueMg },
44 { VALUE_ZERO, PawnValueEg, KnightValueEg, BishopValueEg, RookValueEg, QueenValueEg } };
45
46 namespace Zobrist {
47
48   Key psq[COLOR_NB][PIECE_TYPE_NB][SQUARE_NB];
49   Key enpassant[FILE_NB];
50   Key castling[CASTLING_FLAG_NB];
51   Key side;
52   Key exclusion;
53 }
54
55 Key Position::exclusion_key() const { return st->key ^ Zobrist::exclusion;}
56
57 namespace {
58
59 // min_attacker() is an helper function used by see() to locate the least
60 // valuable attacker for the side to move, remove the attacker we just found
61 // from the bitboards and scan for new X-ray attacks behind it.
62
63 template<int Pt> FORCE_INLINE
64 PieceType min_attacker(const Bitboard* bb, const Square& to, const Bitboard& stmAttackers,
65                        Bitboard& occupied, Bitboard& attackers) {
66
67   Bitboard b = stmAttackers & bb[Pt];
68   if (!b)
69       return min_attacker<Pt+1>(bb, to, stmAttackers, occupied, attackers);
70
71   occupied ^= b & ~(b - 1);
72
73   if (Pt == PAWN || Pt == BISHOP || Pt == QUEEN)
74       attackers |= attacks_bb<BISHOP>(to, occupied) & (bb[BISHOP] | bb[QUEEN]);
75
76   if (Pt == ROOK || Pt == QUEEN)
77       attackers |= attacks_bb<ROOK>(to, occupied) & (bb[ROOK] | bb[QUEEN]);
78
79   attackers &= occupied; // After X-ray that may add already processed pieces
80   return (PieceType)Pt;
81 }
82
83 template<> FORCE_INLINE
84 PieceType min_attacker<KING>(const Bitboard*, const Square&, const Bitboard&, Bitboard&, Bitboard&) {
85   return KING; // No need to update bitboards, it is the last cycle
86 }
87
88 } // namespace
89
90
91 /// CheckInfo c'tor
92
93 CheckInfo::CheckInfo(const Position& pos) {
94
95   Color them = ~pos.side_to_move();
96   ksq = pos.king_square(them);
97
98   pinned = pos.pinned_pieces(pos.side_to_move());
99   dcCandidates = pos.discovered_check_candidates();
100
101   checkSq[PAWN]   = pos.attacks_from<PAWN>(ksq, them);
102   checkSq[KNIGHT] = pos.attacks_from<KNIGHT>(ksq);
103   checkSq[BISHOP] = pos.attacks_from<BISHOP>(ksq);
104   checkSq[ROOK]   = pos.attacks_from<ROOK>(ksq);
105   checkSq[QUEEN]  = checkSq[BISHOP] | checkSq[ROOK];
106   checkSq[KING]   = 0;
107 }
108
109
110 /// Position::init() initializes at startup the various arrays used to compute
111 /// hash keys and the piece square tables. The latter is a two-step operation:
112 /// First, the white halves of the tables are copied from PSQT[] tables. Second,
113 /// the black halves of the tables are initialized by flipping and changing the
114 /// sign of the white scores.
115
116 void Position::init() {
117
118   RKISS rk;
119
120   for (Color c = WHITE; c <= BLACK; ++c)
121       for (PieceType pt = PAWN; pt <= KING; ++pt)
122           for (Square s = SQ_A1; s <= SQ_H8; ++s)
123               Zobrist::psq[c][pt][s] = rk.rand<Key>();
124
125   for (File f = FILE_A; f <= FILE_H; ++f)
126       Zobrist::enpassant[f] = rk.rand<Key>();
127
128   for (int cf = NO_CASTLING; cf <= ANY_CASTLING; ++cf)
129   {
130       Bitboard b = cf;
131       while (b)
132       {
133           Key k = Zobrist::castling[1ULL << pop_lsb(&b)];
134           Zobrist::castling[cf] ^= k ? k : rk.rand<Key>();
135       }
136   }
137
138   Zobrist::side = rk.rand<Key>();
139   Zobrist::exclusion  = rk.rand<Key>();
140
141   for (PieceType pt = PAWN; pt <= KING; ++pt)
142   {
143       PieceValue[MG][make_piece(BLACK, pt)] = PieceValue[MG][pt];
144       PieceValue[EG][make_piece(BLACK, pt)] = PieceValue[EG][pt];
145
146       Score v = make_score(PieceValue[MG][pt], PieceValue[EG][pt]);
147
148       for (Square s = SQ_A1; s <= SQ_H8; ++s)
149       {
150          psq[WHITE][pt][ s] =  (v + PSQT[pt][s]);
151          psq[BLACK][pt][~s] = -(v + PSQT[pt][s]);
152       }
153   }
154 }
155
156
157 /// Position::operator=() creates a copy of 'pos'. We want the new born Position
158 /// object do not depend on any external data so we detach state pointer from
159 /// the source one.
160
161 Position& Position::operator=(const Position& pos) {
162
163   std::memcpy(this, &pos, sizeof(Position));
164   startState = *st;
165   st = &startState;
166   nodes = 0;
167
168   assert(pos_is_ok());
169
170   return *this;
171 }
172
173
174 /// Position::set() initializes the position object with the given FEN string.
175 /// This function is not very robust - make sure that input FENs are correct,
176 /// this is assumed to be the responsibility of the GUI.
177
178 void Position::set(const string& fenStr, bool isChess960, Thread* th) {
179 /*
180    A FEN string defines a particular position using only the ASCII character set.
181
182    A FEN string contains six fields separated by a space. The fields are:
183
184    1) Piece placement (from white's perspective). Each rank is described, starting
185       with rank 8 and ending with rank 1; within each rank, the contents of each
186       square are described from file A through file H. Following the Standard
187       Algebraic Notation (SAN), each piece is identified by a single letter taken
188       from the standard English names. White pieces are designated using upper-case
189       letters ("PNBRQK") while Black take lowercase ("pnbrqk"). Blank squares are
190       noted using digits 1 through 8 (the number of blank squares), and "/"
191       separates ranks.
192
193    2) Active color. "w" means white moves next, "b" means black.
194
195    3) Castling availability. If neither side can castle, this is "-". Otherwise,
196       this has one or more letters: "K" (White can castle kingside), "Q" (White
197       can castle queenside), "k" (Black can castle kingside), and/or "q" (Black
198       can castle queenside).
199
200    4) En passant target square (in algebraic notation). If there's no en passant
201       target square, this is "-". If a pawn has just made a 2-square move, this
202       is the position "behind" the pawn. This is recorded regardless of whether
203       there is a pawn in position to make an en passant capture.
204
205    5) Halfmove clock. This is the number of halfmoves since the last pawn advance
206       or capture. This is used to determine if a draw can be claimed under the
207       fifty-move rule.
208
209    6) Fullmove number. The number of the full move. It starts at 1, and is
210       incremented after Black's move.
211 */
212
213   char col, row, token;
214   size_t p;
215   Square sq = SQ_A8;
216   std::istringstream ss(fenStr);
217
218   clear();
219   ss >> std::noskipws;
220
221   // 1. Piece placement
222   while ((ss >> token) && !isspace(token))
223   {
224       if (isdigit(token))
225           sq += Square(token - '0'); // Advance the given number of files
226
227       else if (token == '/')
228           sq -= Square(16);
229
230       else if ((p = PieceToChar.find(token)) != string::npos)
231       {
232           put_piece(sq, color_of(Piece(p)), type_of(Piece(p)));
233           ++sq;
234       }
235   }
236
237   // 2. Active color
238   ss >> token;
239   sideToMove = (token == 'w' ? WHITE : BLACK);
240   ss >> token;
241
242   // 3. Castling availability. Compatible with 3 standards: Normal FEN standard,
243   // Shredder-FEN that uses the letters of the columns on which the rooks began
244   // the game instead of KQkq and also X-FEN standard that, in case of Chess960,
245   // if an inner rook is associated with the castling right, the castling tag is
246   // replaced by the file letter of the involved rook, as for the Shredder-FEN.
247   while ((ss >> token) && !isspace(token))
248   {
249       Square rsq;
250       Color c = islower(token) ? BLACK : WHITE;
251
252       token = char(toupper(token));
253
254       if (token == 'K')
255           for (rsq = relative_square(c, SQ_H1); type_of(piece_on(rsq)) != ROOK; --rsq) {}
256
257       else if (token == 'Q')
258           for (rsq = relative_square(c, SQ_A1); type_of(piece_on(rsq)) != ROOK; ++rsq) {}
259
260       else if (token >= 'A' && token <= 'H')
261           rsq = File(token - 'A') | relative_rank(c, RANK_1);
262
263       else
264           continue;
265
266       set_castling_flag(c, rsq);
267   }
268
269   // 4. En passant square. Ignore if no pawn capture is possible
270   if (   ((ss >> col) && (col >= 'a' && col <= 'h'))
271       && ((ss >> row) && (row == '3' || row == '6')))
272   {
273       st->epSquare = File(col - 'a') | Rank(row - '1');
274
275       if (!(attackers_to(st->epSquare) & pieces(sideToMove, PAWN)))
276           st->epSquare = SQ_NONE;
277   }
278
279   // 5-6. Halfmove clock and fullmove number
280   ss >> std::skipws >> st->rule50 >> gamePly;
281
282   // Convert from fullmove starting from 1 to ply starting from 0,
283   // handle also common incorrect FEN with fullmove = 0.
284   gamePly = std::max(2 * (gamePly - 1), 0) + int(sideToMove == BLACK);
285
286   st->key = compute_key();
287   st->pawnKey = compute_pawn_key();
288   st->materialKey = compute_material_key();
289   st->psq = compute_psq_score();
290   st->npMaterial[WHITE] = compute_non_pawn_material(WHITE);
291   st->npMaterial[BLACK] = compute_non_pawn_material(BLACK);
292   st->checkersBB = attackers_to(king_square(sideToMove)) & pieces(~sideToMove);
293   chess960 = isChess960;
294   thisThread = th;
295
296   assert(pos_is_ok());
297 }
298
299
300 /// Position::set_castling_flag() is an helper function used to set castling
301 /// flags given the corresponding color and the rook starting square.
302
303 void Position::set_castling_flag(Color c, Square rfrom) {
304
305   Square kfrom = king_square(c);
306   CastlingSide cs = kfrom < rfrom ? KING_SIDE : QUEEN_SIDE;
307   CastlingFlag cf = make_castling_flag(c, cs);
308
309   st->castlingFlags |= cf;
310   castlingFlagsMask[kfrom] |= cf;
311   castlingFlagsMask[rfrom] |= cf;
312   castlingRookSquare[c][cs] = rfrom;
313
314   Square kto = relative_square(c, cs == KING_SIDE ? SQ_G1 : SQ_C1);
315   Square rto = relative_square(c, cs == KING_SIDE ? SQ_F1 : SQ_D1);
316
317   for (Square s = std::min(rfrom, rto); s <= std::max(rfrom, rto); ++s)
318       if (s != kfrom && s != rfrom)
319           castlingPath[c][cs] |= s;
320
321   for (Square s = std::min(kfrom, kto); s <= std::max(kfrom, kto); ++s)
322       if (s != kfrom && s != rfrom)
323           castlingPath[c][cs] |= s;
324 }
325
326
327 /// Position::fen() returns a FEN representation of the position. In case
328 /// of Chess960 the Shredder-FEN notation is used. Mainly a debugging function.
329
330 const string Position::fen() const {
331
332   std::ostringstream ss;
333
334   for (Rank rank = RANK_8; rank >= RANK_1; --rank)
335   {
336       for (File file = FILE_A; file <= FILE_H; ++file)
337       {
338           Square sq = file | rank;
339
340           if (empty(sq))
341           {
342               int emptyCnt = 1;
343
344               for ( ; file < FILE_H && empty(++sq); ++file)
345                   ++emptyCnt;
346
347               ss << emptyCnt;
348           }
349           else
350               ss << PieceToChar[piece_on(sq)];
351       }
352
353       if (rank > RANK_1)
354           ss << '/';
355   }
356
357   ss << (sideToMove == WHITE ? " w " : " b ");
358
359   if (can_castle(WHITE_OO))
360       ss << (chess960 ? file_to_char(file_of(castling_rook_square(WHITE,  KING_SIDE)), false) : 'K');
361
362   if (can_castle(WHITE_OOO))
363       ss << (chess960 ? file_to_char(file_of(castling_rook_square(WHITE, QUEEN_SIDE)), false) : 'Q');
364
365   if (can_castle(BLACK_OO))
366       ss << (chess960 ? file_to_char(file_of(castling_rook_square(BLACK,  KING_SIDE)),  true) : 'k');
367
368   if (can_castle(BLACK_OOO))
369       ss << (chess960 ? file_to_char(file_of(castling_rook_square(BLACK, QUEEN_SIDE)),  true) : 'q');
370
371   if (st->castlingFlags == NO_CASTLING)
372       ss << '-';
373
374   ss << (ep_square() == SQ_NONE ? " - " : " " + square_to_string(ep_square()) + " ")
375       << st->rule50 << " " << 1 + (gamePly - int(sideToMove == BLACK)) / 2;
376
377   return ss.str();
378 }
379
380
381 /// Position::pretty() returns an ASCII representation of the position to be
382 /// printed to the standard output together with the move's san notation.
383
384 const string Position::pretty(Move move) const {
385
386   const string dottedLine =            "\n+---+---+---+---+---+---+---+---+";
387   const string twoRows =  dottedLine + "\n|   | . |   | . |   | . |   | . |"
388                         + dottedLine + "\n| . |   | . |   | . |   | . |   |";
389
390   string brd = twoRows + twoRows + twoRows + twoRows + dottedLine;
391
392   for (Bitboard b = pieces(); b; )
393   {
394       Square s = pop_lsb(&b);
395       brd[513 - 68 * rank_of(s) + 4 * file_of(s)] = PieceToChar[piece_on(s)];
396   }
397
398   std::ostringstream ss;
399
400   if (move)
401       ss << "\nMove: " << (sideToMove == BLACK ? ".." : "")
402          << move_to_san(*const_cast<Position*>(this), move);
403
404   ss << brd << "\nFen: " << fen() << "\nKey: " << std::hex << std::uppercase
405      << std::setfill('0') << std::setw(16) << st->key << "\nCheckers: ";
406
407   for (Bitboard b = checkers(); b; )
408       ss << square_to_string(pop_lsb(&b)) << " ";
409
410   ss << "\nLegal moves: ";
411   for (MoveList<LEGAL> it(*this); *it; ++it)
412       ss << move_to_san(*const_cast<Position*>(this), *it) << " ";
413
414   return ss.str();
415 }
416
417
418 /// Position:hidden_checkers() returns a bitboard of all pinned / discovery check
419 /// pieces, according to the call parameters. Pinned pieces protect our king,
420 /// discovery check pieces attack the enemy king.
421
422 Bitboard Position::hidden_checkers(Square ksq, Color c, Color toMove) const {
423
424   Bitboard b, pinners, result = 0;
425
426   // Pinners are sliders that give check when pinned piece is removed
427   pinners = (  (pieces(  ROOK, QUEEN) & PseudoAttacks[ROOK  ][ksq])
428              | (pieces(BISHOP, QUEEN) & PseudoAttacks[BISHOP][ksq])) & pieces(c);
429
430   while (pinners)
431   {
432       b = between_bb(ksq, pop_lsb(&pinners)) & pieces();
433
434       if (!more_than_one(b))
435           result |= b & pieces(toMove);
436   }
437   return result;
438 }
439
440
441 /// Position::attackers_to() computes a bitboard of all pieces which attack a
442 /// given square. Slider attacks use occ bitboard as occupancy.
443
444 Bitboard Position::attackers_to(Square s, Bitboard occ) const {
445
446   return  (attacks_from<PAWN>(s, BLACK) & pieces(WHITE, PAWN))
447         | (attacks_from<PAWN>(s, WHITE) & pieces(BLACK, PAWN))
448         | (attacks_from<KNIGHT>(s)      & pieces(KNIGHT))
449         | (attacks_bb<ROOK>(s, occ)     & pieces(ROOK, QUEEN))
450         | (attacks_bb<BISHOP>(s, occ)   & pieces(BISHOP, QUEEN))
451         | (attacks_from<KING>(s)        & pieces(KING));
452 }
453
454
455 /// Position::legal() tests whether a pseudo-legal move is legal
456
457 bool Position::legal(Move m, Bitboard pinned) const {
458
459   assert(is_ok(m));
460   assert(pinned == pinned_pieces(sideToMove));
461
462   Color us = sideToMove;
463   Square from = from_sq(m);
464
465   assert(color_of(moved_piece(m)) == us);
466   assert(piece_on(king_square(us)) == make_piece(us, KING));
467
468   // En passant captures are a tricky special case. Because they are rather
469   // uncommon, we do it simply by testing whether the king is attacked after
470   // the move is made.
471   if (type_of(m) == ENPASSANT)
472   {
473       Color them = ~us;
474       Square to = to_sq(m);
475       Square capsq = to + pawn_push(them);
476       Square ksq = king_square(us);
477       Bitboard b = (pieces() ^ from ^ capsq) | to;
478
479       assert(to == ep_square());
480       assert(moved_piece(m) == make_piece(us, PAWN));
481       assert(piece_on(capsq) == make_piece(them, PAWN));
482       assert(piece_on(to) == NO_PIECE);
483
484       return   !(attacks_bb<  ROOK>(ksq, b) & pieces(them, QUEEN, ROOK))
485             && !(attacks_bb<BISHOP>(ksq, b) & pieces(them, QUEEN, BISHOP));
486   }
487
488   // If the moving piece is a king, check whether the destination
489   // square is attacked by the opponent. Castling moves are checked
490   // for legality during move generation.
491   if (type_of(piece_on(from)) == KING)
492       return type_of(m) == CASTLING || !(attackers_to(to_sq(m)) & pieces(~us));
493
494   // A non-king move is legal if and only if it is not pinned or it
495   // is moving along the ray towards or away from the king.
496   return   !pinned
497         || !(pinned & from)
498         ||  aligned(from, to_sq(m), king_square(us));
499 }
500
501
502 /// Position::pseudo_legal() takes a random move and tests whether the move is
503 /// pseudo legal. It is used to validate moves from TT that can be corrupted
504 /// due to SMP concurrent access or hash position key aliasing.
505
506 bool Position::pseudo_legal(const Move m) const {
507
508   Color us = sideToMove;
509   Square from = from_sq(m);
510   Square to = to_sq(m);
511   Piece pc = moved_piece(m);
512
513   // Use a slower but simpler function for uncommon cases
514   if (type_of(m) != NORMAL)
515       return MoveList<LEGAL>(*this).contains(m);
516
517   // Is not a promotion, so promotion piece must be empty
518   if (promotion_type(m) - 2 != NO_PIECE_TYPE)
519       return false;
520
521   // If the from square is not occupied by a piece belonging to the side to
522   // move, the move is obviously not legal.
523   if (pc == NO_PIECE || color_of(pc) != us)
524       return false;
525
526   // The destination square cannot be occupied by a friendly piece
527   if (pieces(us) & to)
528       return false;
529
530   // Handle the special case of a pawn move
531   if (type_of(pc) == PAWN)
532   {
533       // Move direction must be compatible with pawn color
534       int direction = to - from;
535       if ((us == WHITE) != (direction > 0))
536           return false;
537
538       // We have already handled promotion moves, so destination
539       // cannot be on the 8/1th rank.
540       if (rank_of(to) == RANK_8 || rank_of(to) == RANK_1)
541           return false;
542
543       // Proceed according to the square delta between the origin and
544       // destination squares.
545       switch (direction)
546       {
547       case DELTA_NW:
548       case DELTA_NE:
549       case DELTA_SW:
550       case DELTA_SE:
551       // Capture. The destination square must be occupied by an enemy
552       // piece (en passant captures was handled earlier).
553       if (piece_on(to) == NO_PIECE || color_of(piece_on(to)) != ~us)
554           return false;
555
556       // From and to files must be one file apart, avoids a7h5
557       if (abs(file_of(from) - file_of(to)) != 1)
558           return false;
559       break;
560
561       case DELTA_N:
562       case DELTA_S:
563       // Pawn push. The destination square must be empty.
564       if (!empty(to))
565           return false;
566       break;
567
568       case DELTA_NN:
569       // Double white pawn push. The destination square must be on the fourth
570       // rank, and both the destination square and the square between the
571       // source and destination squares must be empty.
572       if (    rank_of(to) != RANK_4
573           || !empty(to)
574           || !empty(from + DELTA_N))
575           return false;
576       break;
577
578       case DELTA_SS:
579       // Double black pawn push. The destination square must be on the fifth
580       // rank, and both the destination square and the square between the
581       // source and destination squares must be empty.
582       if (    rank_of(to) != RANK_5
583           || !empty(to)
584           || !empty(from + DELTA_S))
585           return false;
586       break;
587
588       default:
589           return false;
590       }
591   }
592   else if (!(attacks_from(pc, from) & to))
593       return false;
594
595   // Evasions generator already takes care to avoid some kind of illegal moves
596   // and pl_move_is_legal() relies on this. So we have to take care that the
597   // same kind of moves are filtered out here.
598   if (checkers())
599   {
600       if (type_of(pc) != KING)
601       {
602           // Double check? In this case a king move is required
603           if (more_than_one(checkers()))
604               return false;
605
606           // Our move must be a blocking evasion or a capture of the checking piece
607           if (!((between_bb(lsb(checkers()), king_square(us)) | checkers()) & to))
608               return false;
609       }
610       // In case of king moves under check we have to remove king so to catch
611       // as invalid moves like b1a1 when opposite queen is on c1.
612       else if (attackers_to(to, pieces() ^ from) & pieces(~us))
613           return false;
614   }
615
616   return true;
617 }
618
619
620 /// Position::move_gives_check() tests whether a pseudo-legal move gives a check
621
622 bool Position::gives_check(Move m, const CheckInfo& ci) const {
623
624   assert(is_ok(m));
625   assert(ci.dcCandidates == discovered_check_candidates());
626   assert(color_of(moved_piece(m)) == sideToMove);
627
628   Square from = from_sq(m);
629   Square to = to_sq(m);
630   PieceType pt = type_of(piece_on(from));
631
632   // Direct check ?
633   if (ci.checkSq[pt] & to)
634       return true;
635
636   // Discovered check ?
637   if (   unlikely(ci.dcCandidates)
638       && (ci.dcCandidates & from)
639       && !aligned(from, to, king_square(~sideToMove)))
640       return true;
641
642   // Can we skip the ugly special cases ?
643   if (type_of(m) == NORMAL)
644       return false;
645
646   Color us = sideToMove;
647   Square ksq = king_square(~us);
648
649   switch (type_of(m))
650   {
651   case PROMOTION:
652       return attacks_bb(Piece(promotion_type(m)), to, pieces() ^ from) & ksq;
653
654   // En passant capture with check ? We have already handled the case
655   // of direct checks and ordinary discovered check, the only case we
656   // need to handle is the unusual case of a discovered check through
657   // the captured pawn.
658   case ENPASSANT:
659   {
660       Square capsq = file_of(to) | rank_of(from);
661       Bitboard b = (pieces() ^ from ^ capsq) | to;
662
663       return  (attacks_bb<  ROOK>(ksq, b) & pieces(us, QUEEN, ROOK))
664             | (attacks_bb<BISHOP>(ksq, b) & pieces(us, QUEEN, BISHOP));
665   }
666   case CASTLING:
667   {
668       Square kfrom = from;
669       Square rfrom = to; // Castling is encoded as 'King captures the rook'
670       Square kto = relative_square(us, rfrom > kfrom ? SQ_G1 : SQ_C1);
671       Square rto = relative_square(us, rfrom > kfrom ? SQ_F1 : SQ_D1);
672
673       return   (PseudoAttacks[ROOK][rto] & ksq)
674             && (attacks_bb<ROOK>(rto, (pieces() ^ kfrom ^ rfrom) | rto | kto) & ksq);
675   }
676   default:
677       assert(false);
678       return false;
679   }
680 }
681
682
683 /// Position::do_move() makes a move, and saves all information necessary
684 /// to a StateInfo object. The move is assumed to be legal. Pseudo-legal
685 /// moves should be filtered out before this function is called.
686
687 void Position::do_move(Move m, StateInfo& newSt) {
688
689   CheckInfo ci(*this);
690   do_move(m, newSt, ci, gives_check(m, ci));
691 }
692
693 void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveIsCheck) {
694
695   assert(is_ok(m));
696   assert(&newSt != st);
697
698   ++nodes;
699   Key k = st->key;
700
701   // Copy some fields of old state to our new StateInfo object except the ones
702   // which are going to be recalculated from scratch anyway, then switch our state
703   // pointer to point to the new, ready to be updated, state.
704   std::memcpy(&newSt, st, StateCopySize64 * sizeof(uint64_t));
705
706   newSt.previous = st;
707   st = &newSt;
708
709   // Update side to move
710   k ^= Zobrist::side;
711
712   // Increment ply counters.In particular rule50 will be later reset it to zero
713   // in case of a capture or a pawn move.
714   ++gamePly;
715   ++st->rule50;
716   ++st->pliesFromNull;
717
718   Color us = sideToMove;
719   Color them = ~us;
720   Square from = from_sq(m);
721   Square to = to_sq(m);
722   Piece pc = piece_on(from);
723   PieceType pt = type_of(pc);
724   PieceType captured = type_of(m) == ENPASSANT ? PAWN : type_of(piece_on(to));
725
726   assert(color_of(pc) == us);
727   assert(piece_on(to) == NO_PIECE || color_of(piece_on(to)) == them || type_of(m) == CASTLING);
728   assert(captured != KING);
729
730   if (type_of(m) == CASTLING)
731   {
732       assert(pc == make_piece(us, KING));
733
734       bool kingSide = to > from;
735       Square rfrom = to; // Castling is encoded as "king captures friendly rook"
736       Square rto = relative_square(us, kingSide ? SQ_F1 : SQ_D1);
737       to = relative_square(us, kingSide ? SQ_G1 : SQ_C1);
738       captured = NO_PIECE_TYPE;
739
740       do_castling(from, to, rfrom, rto);
741
742       st->psq += psq[us][ROOK][rto] - psq[us][ROOK][rfrom];
743       k ^= Zobrist::psq[us][ROOK][rfrom] ^ Zobrist::psq[us][ROOK][rto];
744   }
745
746   if (captured)
747   {
748       Square capsq = to;
749
750       // If the captured piece is a pawn, update pawn hash key, otherwise
751       // update non-pawn material.
752       if (captured == PAWN)
753       {
754           if (type_of(m) == ENPASSANT)
755           {
756               capsq += pawn_push(them);
757
758               assert(pt == PAWN);
759               assert(to == st->epSquare);
760               assert(relative_rank(us, to) == RANK_6);
761               assert(piece_on(to) == NO_PIECE);
762               assert(piece_on(capsq) == make_piece(them, PAWN));
763
764               board[capsq] = NO_PIECE;
765           }
766
767           st->pawnKey ^= Zobrist::psq[them][PAWN][capsq];
768       }
769       else
770           st->npMaterial[them] -= PieceValue[MG][captured];
771
772       // Update board and piece lists
773       remove_piece(capsq, them, captured);
774
775       // Update material hash key and prefetch access to materialTable
776       k ^= Zobrist::psq[them][captured][capsq];
777       st->materialKey ^= Zobrist::psq[them][captured][pieceCount[them][captured]];
778       prefetch((char*)thisThread->materialTable[st->materialKey]);
779
780       // Update incremental scores
781       st->psq -= psq[them][captured][capsq];
782
783       // Reset rule 50 counter
784       st->rule50 = 0;
785   }
786
787   // Update hash key
788   k ^= Zobrist::psq[us][pt][from] ^ Zobrist::psq[us][pt][to];
789
790   // Reset en passant square
791   if (st->epSquare != SQ_NONE)
792   {
793       k ^= Zobrist::enpassant[file_of(st->epSquare)];
794       st->epSquare = SQ_NONE;
795   }
796
797   // Update castling flags if needed
798   if (st->castlingFlags && (castlingFlagsMask[from] | castlingFlagsMask[to]))
799   {
800       int cf = castlingFlagsMask[from] | castlingFlagsMask[to];
801       k ^= Zobrist::castling[st->castlingFlags & cf];
802       st->castlingFlags &= ~cf;
803   }
804
805   // Prefetch TT access as soon as we know the new hash key
806   prefetch((char*)TT.first_entry(k));
807
808   // Move the piece. The tricky Chess960 castling is handled earlier
809   if (type_of(m) != CASTLING)
810       move_piece(from, to, us, pt);
811
812   // If the moving piece is a pawn do some special extra work
813   if (pt == PAWN)
814   {
815       // Set en-passant square, only if moved pawn can be captured
816       if (   (int(to) ^ int(from)) == 16
817           && (attacks_from<PAWN>(from + pawn_push(us), us) & pieces(them, PAWN)))
818       {
819           st->epSquare = Square((from + to) / 2);
820           k ^= Zobrist::enpassant[file_of(st->epSquare)];
821       }
822
823       if (type_of(m) == PROMOTION)
824       {
825           PieceType promotion = promotion_type(m);
826
827           assert(relative_rank(us, to) == RANK_8);
828           assert(promotion >= KNIGHT && promotion <= QUEEN);
829
830           remove_piece(to, us, PAWN);
831           put_piece(to, us, promotion);
832
833           // Update hash keys
834           k ^= Zobrist::psq[us][PAWN][to] ^ Zobrist::psq[us][promotion][to];
835           st->pawnKey ^= Zobrist::psq[us][PAWN][to];
836           st->materialKey ^=  Zobrist::psq[us][promotion][pieceCount[us][promotion]-1]
837                             ^ Zobrist::psq[us][PAWN][pieceCount[us][PAWN]];
838
839           // Update incremental score
840           st->psq += psq[us][promotion][to] - psq[us][PAWN][to];
841
842           // Update material
843           st->npMaterial[us] += PieceValue[MG][promotion];
844       }
845
846       // Update pawn hash key and prefetch access to pawnsTable
847       st->pawnKey ^= Zobrist::psq[us][PAWN][from] ^ Zobrist::psq[us][PAWN][to];
848       prefetch((char*)thisThread->pawnsTable[st->pawnKey]);
849
850       // Reset rule 50 draw counter
851       st->rule50 = 0;
852   }
853
854   // Update incremental scores
855   st->psq += psq[us][pt][to] - psq[us][pt][from];
856
857   // Set capture piece
858   st->capturedType = captured;
859
860   // Update the key with the final value
861   st->key = k;
862
863   // Update checkers bitboard, piece must be already moved
864   st->checkersBB = 0;
865
866   if (moveIsCheck)
867   {
868       if (type_of(m) != NORMAL)
869           st->checkersBB = attackers_to(king_square(them)) & pieces(us);
870       else
871       {
872           // Direct checks
873           if (ci.checkSq[pt] & to)
874               st->checkersBB |= to;
875
876           // Discovery checks
877           if (ci.dcCandidates && (ci.dcCandidates & from))
878           {
879               if (pt != ROOK)
880                   st->checkersBB |= attacks_from<ROOK>(king_square(them)) & pieces(us, QUEEN, ROOK);
881
882               if (pt != BISHOP)
883                   st->checkersBB |= attacks_from<BISHOP>(king_square(them)) & pieces(us, QUEEN, BISHOP);
884           }
885       }
886   }
887
888   sideToMove = ~sideToMove;
889
890   assert(pos_is_ok());
891 }
892
893
894 /// Position::undo_move() unmakes a move. When it returns, the position should
895 /// be restored to exactly the same state as before the move was made.
896
897 void Position::undo_move(Move m) {
898
899   assert(is_ok(m));
900
901   sideToMove = ~sideToMove;
902
903   Color us = sideToMove;
904   Color them = ~us;
905   Square from = from_sq(m);
906   Square to = to_sq(m);
907   PieceType pt = type_of(piece_on(to));
908   PieceType captured = st->capturedType;
909
910   assert(empty(from) || type_of(m) == CASTLING);
911   assert(captured != KING);
912
913   if (type_of(m) == PROMOTION)
914   {
915       PieceType promotion = promotion_type(m);
916
917       assert(promotion == pt);
918       assert(relative_rank(us, to) == RANK_8);
919       assert(promotion >= KNIGHT && promotion <= QUEEN);
920
921       remove_piece(to, us, promotion);
922       put_piece(to, us, PAWN);
923       pt = PAWN;
924   }
925
926   if (type_of(m) == CASTLING)
927   {
928       bool kingSide = to > from;
929       Square rfrom = to; // Castling is encoded as "king captures friendly rook"
930       Square rto = relative_square(us, kingSide ? SQ_F1 : SQ_D1);
931       to = relative_square(us, kingSide ? SQ_G1 : SQ_C1);
932       captured = NO_PIECE_TYPE;
933       pt = KING;
934       do_castling(to, from, rto, rfrom);
935   }
936   else
937       move_piece(to, from, us, pt); // Put the piece back at the source square
938
939   if (captured)
940   {
941       Square capsq = to;
942
943       if (type_of(m) == ENPASSANT)
944       {
945           capsq -= pawn_push(us);
946
947           assert(pt == PAWN);
948           assert(to == st->previous->epSquare);
949           assert(relative_rank(us, to) == RANK_6);
950           assert(piece_on(capsq) == NO_PIECE);
951       }
952
953       put_piece(capsq, them, captured); // Restore the captured piece
954   }
955
956   // Finally point our state pointer back to the previous state
957   st = st->previous;
958   --gamePly;
959
960   assert(pos_is_ok());
961 }
962
963
964 /// Position::do_castling() is a helper used to do/undo a castling move. This
965 /// is a bit tricky, especially in Chess960.
966
967 void Position::do_castling(Square kfrom, Square kto, Square rfrom, Square rto) {
968
969   // Remove both pieces first since squares could overlap in Chess960
970   remove_piece(kfrom, sideToMove, KING);
971   remove_piece(rfrom, sideToMove, ROOK);
972   board[kfrom] = board[rfrom] = NO_PIECE; // Since remove_piece doesn't do it for us
973   put_piece(kto, sideToMove, KING);
974   put_piece(rto, sideToMove, ROOK);
975 }
976
977
978 /// Position::do(undo)_null_move() is used to do(undo) a "null move": It flips
979 /// the side to move without executing any move on the board.
980
981 void Position::do_null_move(StateInfo& newSt) {
982
983   assert(!checkers());
984
985   std::memcpy(&newSt, st, sizeof(StateInfo)); // Fully copy here
986
987   newSt.previous = st;
988   st = &newSt;
989
990   if (st->epSquare != SQ_NONE)
991   {
992       st->key ^= Zobrist::enpassant[file_of(st->epSquare)];
993       st->epSquare = SQ_NONE;
994   }
995
996   st->key ^= Zobrist::side;
997   prefetch((char*)TT.first_entry(st->key));
998
999   ++st->rule50;
1000   st->pliesFromNull = 0;
1001
1002   sideToMove = ~sideToMove;
1003
1004   assert(pos_is_ok());
1005 }
1006
1007 void Position::undo_null_move() {
1008
1009   assert(!checkers());
1010
1011   st = st->previous;
1012   sideToMove = ~sideToMove;
1013 }
1014
1015
1016 /// Position::see() is a static exchange evaluator: It tries to estimate the
1017 /// material gain or loss resulting from a move. Parameter 'asymmThreshold' takes
1018 /// tempi into account. If the side who initiated the capturing sequence does the
1019 /// last capture, he loses a tempo and if the result is below 'asymmThreshold'
1020 /// the capturing sequence is considered bad.
1021
1022 int Position::see_sign(Move m) const {
1023
1024   assert(is_ok(m));
1025
1026   // Early return if SEE cannot be negative because captured piece value
1027   // is not less then capturing one. Note that king moves always return
1028   // here because king midgame value is set to 0.
1029   if (PieceValue[MG][moved_piece(m)] <= PieceValue[MG][piece_on(to_sq(m))])
1030       return 1;
1031
1032   return see(m);
1033 }
1034
1035 int Position::see(Move m, int asymmThreshold) const {
1036
1037   Square from, to;
1038   Bitboard occupied, attackers, stmAttackers;
1039   int swapList[32], slIndex = 1;
1040   PieceType captured;
1041   Color stm;
1042
1043   assert(is_ok(m));
1044
1045   from = from_sq(m);
1046   to = to_sq(m);
1047   swapList[0] = PieceValue[MG][piece_on(to)];
1048   stm = color_of(piece_on(from));
1049   occupied = pieces() ^ from;
1050
1051   // Castling moves are implemented as king capturing the rook so cannot be
1052   // handled correctly. Simply return 0 that is always the correct value
1053   // unless in the rare case the rook ends up under attack.
1054   if (type_of(m) == CASTLING)
1055       return 0;
1056
1057   if (type_of(m) == ENPASSANT)
1058   {
1059       occupied ^= to - pawn_push(stm); // Remove the captured pawn
1060       swapList[0] = PieceValue[MG][PAWN];
1061   }
1062
1063   // Find all attackers to the destination square, with the moving piece
1064   // removed, but possibly an X-ray attacker added behind it.
1065   attackers = attackers_to(to, occupied) & occupied;
1066
1067   // If the opponent has no attackers we are finished
1068   stm = ~stm;
1069   stmAttackers = attackers & pieces(stm);
1070   if (!stmAttackers)
1071       return swapList[0];
1072
1073   // The destination square is defended, which makes things rather more
1074   // difficult to compute. We proceed by building up a "swap list" containing
1075   // the material gain or loss at each stop in a sequence of captures to the
1076   // destination square, where the sides alternately capture, and always
1077   // capture with the least valuable piece. After each capture, we look for
1078   // new X-ray attacks from behind the capturing piece.
1079   captured = type_of(piece_on(from));
1080
1081   do {
1082       assert(slIndex < 32);
1083
1084       // Add the new entry to the swap list
1085       swapList[slIndex] = -swapList[slIndex - 1] + PieceValue[MG][captured];
1086       ++slIndex;
1087
1088       // Locate and remove the next least valuable attacker
1089       captured = min_attacker<PAWN>(byTypeBB, to, stmAttackers, occupied, attackers);
1090       stm = ~stm;
1091       stmAttackers = attackers & pieces(stm);
1092
1093       // Stop before processing a king capture
1094       if (captured == KING && stmAttackers)
1095       {
1096           swapList[slIndex++] = QueenValueMg * 16;
1097           break;
1098       }
1099
1100   } while (stmAttackers);
1101
1102   // If we are doing asymmetric SEE evaluation and the same side does the first
1103   // and the last capture, he loses a tempo and gain must be at least worth
1104   // 'asymmThreshold', otherwise we replace the score with a very low value,
1105   // before negamaxing.
1106   if (asymmThreshold)
1107       for (int i = 0; i < slIndex; i += 2)
1108           if (swapList[i] < asymmThreshold)
1109               swapList[i] = - QueenValueMg * 16;
1110
1111   // Having built the swap list, we negamax through it to find the best
1112   // achievable score from the point of view of the side to move.
1113   while (--slIndex)
1114       swapList[slIndex - 1] = std::min(-swapList[slIndex], swapList[slIndex - 1]);
1115
1116   return swapList[0];
1117 }
1118
1119
1120 /// Position::clear() erases the position object to a pristine state, with an
1121 /// empty board, white to move, and no castling rights.
1122
1123 void Position::clear() {
1124
1125   std::memset(this, 0, sizeof(Position));
1126   startState.epSquare = SQ_NONE;
1127   st = &startState;
1128
1129   for (int i = 0; i < PIECE_TYPE_NB; ++i)
1130       for (int j = 0; j < 16; ++j)
1131           pieceList[WHITE][i][j] = pieceList[BLACK][i][j] = SQ_NONE;
1132 }
1133
1134
1135 /// Position::compute_key() computes the hash key of the position. The hash
1136 /// key is usually updated incrementally as moves are made and unmade, the
1137 /// compute_key() function is only used when a new position is set up, and
1138 /// to verify the correctness of the hash key when running in debug mode.
1139
1140 Key Position::compute_key() const {
1141
1142   Key k = Zobrist::castling[st->castlingFlags];
1143
1144   for (Bitboard b = pieces(); b; )
1145   {
1146       Square s = pop_lsb(&b);
1147       k ^= Zobrist::psq[color_of(piece_on(s))][type_of(piece_on(s))][s];
1148   }
1149
1150   if (ep_square() != SQ_NONE)
1151       k ^= Zobrist::enpassant[file_of(ep_square())];
1152
1153   if (sideToMove == BLACK)
1154       k ^= Zobrist::side;
1155
1156   return k;
1157 }
1158
1159
1160 /// Position::compute_pawn_key() computes the hash key of the position. The
1161 /// hash key is usually updated incrementally as moves are made and unmade,
1162 /// the compute_pawn_key() function is only used when a new position is set
1163 /// up, and to verify the correctness of the pawn hash key when running in
1164 /// debug mode.
1165
1166 Key Position::compute_pawn_key() const {
1167
1168   Key k = 0;
1169
1170   for (Bitboard b = pieces(PAWN); b; )
1171   {
1172       Square s = pop_lsb(&b);
1173       k ^= Zobrist::psq[color_of(piece_on(s))][PAWN][s];
1174   }
1175
1176   return k;
1177 }
1178
1179
1180 /// Position::compute_material_key() computes the hash key of the position.
1181 /// The hash key is usually updated incrementally as moves are made and unmade,
1182 /// the compute_material_key() function is only used when a new position is set
1183 /// up, and to verify the correctness of the material hash key when running in
1184 /// debug mode.
1185
1186 Key Position::compute_material_key() const {
1187
1188   Key k = 0;
1189
1190   for (Color c = WHITE; c <= BLACK; ++c)
1191       for (PieceType pt = PAWN; pt <= QUEEN; ++pt)
1192           for (int cnt = 0; cnt < pieceCount[c][pt]; ++cnt)
1193               k ^= Zobrist::psq[c][pt][cnt];
1194
1195   return k;
1196 }
1197
1198
1199 /// Position::compute_psq_score() computes the incremental scores for the middle
1200 /// game and the endgame. These functions are used to initialize the incremental
1201 /// scores when a new position is set up, and to verify that the scores are correctly
1202 /// updated by do_move and undo_move when the program is running in debug mode.
1203
1204 Score Position::compute_psq_score() const {
1205
1206   Score score = SCORE_ZERO;
1207
1208   for (Bitboard b = pieces(); b; )
1209   {
1210       Square s = pop_lsb(&b);
1211       Piece pc = piece_on(s);
1212       score += psq[color_of(pc)][type_of(pc)][s];
1213   }
1214
1215   return score;
1216 }
1217
1218
1219 /// Position::compute_non_pawn_material() computes the total non-pawn middle
1220 /// game material value for the given side. Material values are updated
1221 /// incrementally during the search, this function is only used while
1222 /// initializing a new Position object.
1223
1224 Value Position::compute_non_pawn_material(Color c) const {
1225
1226   Value value = VALUE_ZERO;
1227
1228   for (PieceType pt = KNIGHT; pt <= QUEEN; ++pt)
1229       value += pieceCount[c][pt] * PieceValue[MG][pt];
1230
1231   return value;
1232 }
1233
1234
1235 /// Position::is_draw() tests whether the position is drawn by material,
1236 /// repetition, or the 50 moves rule. It does not detect stalemates, this
1237 /// must be done by the search.
1238 bool Position::is_draw() const {
1239
1240   // Draw by material?
1241   if (   !pieces(PAWN)
1242       && (non_pawn_material(WHITE) + non_pawn_material(BLACK) <= BishopValueMg))
1243       return true;
1244
1245   // Draw by the 50 moves rule?
1246   if (st->rule50 > 99 && (!checkers() || MoveList<LEGAL>(*this).size()))
1247       return true;
1248
1249   int i = 4, e = std::min(st->rule50, st->pliesFromNull);
1250
1251   if (i <= e)
1252   {
1253       StateInfo* stp = st->previous->previous;
1254
1255       do {
1256           stp = stp->previous->previous;
1257
1258           if (stp->key == st->key)
1259               return true; // Draw after first repetition
1260
1261           i += 2;
1262
1263       } while (i <= e);
1264   }
1265
1266   return false;
1267 }
1268
1269
1270 /// Position::flip() flips position with the white and black sides reversed. This
1271 /// is only useful for debugging especially for finding evaluation symmetry bugs.
1272
1273 static char toggle_case(char c) {
1274   return char(islower(c) ? toupper(c) : tolower(c));
1275 }
1276
1277 void Position::flip() {
1278
1279   string f, token;
1280   std::stringstream ss(fen());
1281
1282   for (Rank rank = RANK_8; rank >= RANK_1; --rank) // Piece placement
1283   {
1284       std::getline(ss, token, rank > RANK_1 ? '/' : ' ');
1285       f.insert(0, token + (f.empty() ? " " : "/"));
1286   }
1287
1288   ss >> token; // Active color
1289   f += (token == "w" ? "B " : "W "); // Will be lowercased later
1290
1291   ss >> token; // Castling availability
1292   f += token + " ";
1293
1294   std::transform(f.begin(), f.end(), f.begin(), toggle_case);
1295
1296   ss >> token; // En passant square
1297   f += (token == "-" ? token : token.replace(1, 1, token[1] == '3' ? "6" : "3"));
1298
1299   std::getline(ss, token); // Half and full moves
1300   f += token;
1301
1302   set(f, is_chess960(), this_thread());
1303
1304   assert(pos_is_ok());
1305 }
1306
1307
1308 /// Position::pos_is_ok() performs some consitency checks for the position object.
1309 /// This is meant to be helpful when debugging.
1310
1311 bool Position::pos_is_ok(int* failedStep) const {
1312
1313   int dummy, *step = failedStep ? failedStep : &dummy;
1314
1315   // What features of the position should be verified?
1316   const bool all = false;
1317
1318   const bool debugBitboards       = all || false;
1319   const bool debugKingCount       = all || false;
1320   const bool debugKingCapture     = all || false;
1321   const bool debugCheckerCount    = all || false;
1322   const bool debugKey             = all || false;
1323   const bool debugMaterialKey     = all || false;
1324   const bool debugPawnKey         = all || false;
1325   const bool debugIncrementalEval = all || false;
1326   const bool debugNonPawnMaterial = all || false;
1327   const bool debugPieceCounts     = all || false;
1328   const bool debugPieceList       = all || false;
1329   const bool debugCastlingSquares = all || false;
1330
1331   *step = 1;
1332
1333   if (sideToMove != WHITE && sideToMove != BLACK)
1334       return false;
1335
1336   if ((*step)++, piece_on(king_square(WHITE)) != W_KING)
1337       return false;
1338
1339   if ((*step)++, piece_on(king_square(BLACK)) != B_KING)
1340       return false;
1341
1342   if ((*step)++, debugKingCount)
1343   {
1344       int kingCount[COLOR_NB] = {};
1345
1346       for (Square s = SQ_A1; s <= SQ_H8; ++s)
1347           if (type_of(piece_on(s)) == KING)
1348               ++kingCount[color_of(piece_on(s))];
1349
1350       if (kingCount[0] != 1 || kingCount[1] != 1)
1351           return false;
1352   }
1353
1354   if ((*step)++, debugKingCapture)
1355       if (attackers_to(king_square(~sideToMove)) & pieces(sideToMove))
1356           return false;
1357
1358   if ((*step)++, debugCheckerCount && popcount<Full>(st->checkersBB) > 2)
1359       return false;
1360
1361   if ((*step)++, debugBitboards)
1362   {
1363       // The intersection of the white and black pieces must be empty
1364       if (pieces(WHITE) & pieces(BLACK))
1365           return false;
1366
1367       // The union of the white and black pieces must be equal to all
1368       // occupied squares
1369       if ((pieces(WHITE) | pieces(BLACK)) != pieces())
1370           return false;
1371
1372       // Separate piece type bitboards must have empty intersections
1373       for (PieceType p1 = PAWN; p1 <= KING; ++p1)
1374           for (PieceType p2 = PAWN; p2 <= KING; ++p2)
1375               if (p1 != p2 && (pieces(p1) & pieces(p2)))
1376                   return false;
1377   }
1378
1379   if ((*step)++, ep_square() != SQ_NONE && relative_rank(sideToMove, ep_square()) != RANK_6)
1380       return false;
1381
1382   if ((*step)++, debugKey && st->key != compute_key())
1383       return false;
1384
1385   if ((*step)++, debugPawnKey && st->pawnKey != compute_pawn_key())
1386       return false;
1387
1388   if ((*step)++, debugMaterialKey && st->materialKey != compute_material_key())
1389       return false;
1390
1391   if ((*step)++, debugIncrementalEval && st->psq != compute_psq_score())
1392       return false;
1393
1394   if ((*step)++, debugNonPawnMaterial)
1395       if (   st->npMaterial[WHITE] != compute_non_pawn_material(WHITE)
1396           || st->npMaterial[BLACK] != compute_non_pawn_material(BLACK))
1397           return false;
1398
1399   if ((*step)++, debugPieceCounts)
1400       for (Color c = WHITE; c <= BLACK; ++c)
1401           for (PieceType pt = PAWN; pt <= KING; ++pt)
1402               if (pieceCount[c][pt] != popcount<Full>(pieces(c, pt)))
1403                   return false;
1404
1405   if ((*step)++, debugPieceList)
1406       for (Color c = WHITE; c <= BLACK; ++c)
1407           for (PieceType pt = PAWN; pt <= KING; ++pt)
1408               for (int i = 0; i < pieceCount[c][pt];  ++i)
1409                   if (   board[pieceList[c][pt][i]] != make_piece(c, pt)
1410                       || index[pieceList[c][pt][i]] != i)
1411                       return false;
1412
1413   if ((*step)++, debugCastlingSquares)
1414       for (Color c = WHITE; c <= BLACK; ++c)
1415           for (CastlingSide s = KING_SIDE; s <= QUEEN_SIDE; s = CastlingSide(s + 1))
1416           {
1417               CastlingFlag cf = make_castling_flag(c, s);
1418
1419               if (!can_castle(cf))
1420                   continue;
1421
1422               if (  (castlingFlagsMask[king_square(c)] & cf) != cf
1423                   || piece_on(castlingRookSquare[c][s]) != make_piece(c, ROOK)
1424                   || castlingFlagsMask[castlingRookSquare[c][s]] != cf)
1425                   return false;
1426           }
1427
1428   *step = 0;
1429   return true;
1430 }