2 Glaurung, a UCI chess playing engine.
3 Copyright (C) 2004-2008 Tord Romstad
5 Glaurung is free software: you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation, either version 3 of the License, or
8 (at your option) any later version.
10 Glaurung is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program. If not, see <http://www.gnu.org/licenses/>.
30 //// Local definitions
35 int generate_white_pawn_captures(const Position
&pos
, MoveStack
*mlist
);
36 int generate_black_pawn_captures(const Position
&pos
, MoveStack
*mlist
);
37 int generate_white_pawn_noncaptures(const Position
&pos
, MoveStack
*mlist
);
38 int generate_black_pawn_noncaptures(const Position
&pos
, MoveStack
*mlist
);
39 int generate_knight_moves(const Position
&pos
, MoveStack
*mlist
,
40 Color side
, Bitboard target
);
41 int generate_bishop_moves(const Position
&pos
, MoveStack
*mlist
,
42 Color side
, Bitboard target
);
43 int generate_rook_moves(const Position
&pos
, MoveStack
*mlist
,
44 Color side
, Bitboard target
);
45 int generate_queen_moves(const Position
&pos
, MoveStack
*mlist
,
46 Color side
, Bitboard target
);
47 int generate_king_moves(const Position
&pos
, MoveStack
*mlist
,
48 Square from
, Bitboard target
);
49 int generate_castle_moves(const Position
&pos
, MoveStack
*mlist
, Color us
);
59 /// generate_captures generates() all pseudo-legal captures and queen
60 /// promotions. The return value is the number of moves generated.
62 int generate_captures(const Position
&pos
, MoveStack
*mlist
) {
63 Color us
= pos
.side_to_move();
64 Bitboard target
= pos
.pieces_of_color(opposite_color(us
));
68 assert(!pos
.is_check());
71 n
+= generate_white_pawn_captures(pos
, mlist
);
73 n
+= generate_black_pawn_captures(pos
, mlist
);
74 n
+= generate_knight_moves(pos
, mlist
+n
, us
, target
);
75 n
+= generate_bishop_moves(pos
, mlist
+n
, us
, target
);
76 n
+= generate_rook_moves(pos
, mlist
+n
, us
, target
);
77 n
+= generate_queen_moves(pos
, mlist
+n
, us
, target
);
78 n
+= generate_king_moves(pos
, mlist
+n
, pos
.king_square(us
), target
);
84 /// generate_noncaptures() generates all pseudo-legal non-captures and
85 /// underpromotions. The return value is the number of moves generated.
87 int generate_noncaptures(const Position
&pos
, MoveStack
*mlist
) {
88 Color us
= pos
.side_to_move();
89 Bitboard target
= pos
.empty_squares();
93 assert(!pos
.is_check());
96 n
+= generate_white_pawn_noncaptures(pos
, mlist
);
98 n
+= generate_black_pawn_noncaptures(pos
, mlist
);
99 n
+= generate_knight_moves(pos
, mlist
+n
, us
, target
);
100 n
+= generate_bishop_moves(pos
, mlist
+n
, us
, target
);
101 n
+= generate_rook_moves(pos
, mlist
+n
, us
, target
);
102 n
+= generate_queen_moves(pos
, mlist
+n
, us
, target
);
103 n
+= generate_king_moves(pos
, mlist
+n
, pos
.king_square(us
), target
);
104 n
+= generate_castle_moves(pos
, mlist
+n
, us
);
110 /// generate_checks() generates all pseudo-legal non-capturing, non-promoting
111 /// checks, except castling moves (will add this later). It returns the
112 /// number of generated moves.
114 int generate_checks(const Position
&pos
, MoveStack
*mlist
, Bitboard dc
) {
116 Square ksq
, from
, to
;
117 Bitboard empty
, checkSqs
, b1
, b2
, b3
;
121 assert(!pos
.is_check());
123 us
= pos
.side_to_move();
124 them
= opposite_color(us
);
126 ksq
= pos
.king_square(them
);
127 assert(pos
.piece_on(ksq
) == king_of_color(them
));
129 dc
= pos
.discovered_check_candidates(us
);
130 empty
= pos
.empty_squares();
132 // Pawn moves. This is somewhat messy, and we use separate code for white
133 // and black, because we can't shift by negative numbers in C/C++. :-(
136 // Pawn moves which give discovered check. This is possible only if the
137 // pawn is not on the same file as the enemy king, because we don't
138 // generate captures.
140 // Find all friendly pawns not on the enemy king's file:
141 b1
= pos
.pawns(us
) & ~file_bb(ksq
);
143 // Discovered checks, single pawn pushes:
144 b2
= b3
= ((b1
& dc
) << 8) & ~Rank8BB
& empty
;
146 to
= pop_1st_bit(&b3
);
147 mlist
[n
++].move
= make_move(to
- DELTA_N
, to
);
150 // Discovered checks, double pawn pushes:
151 b3
= ((b2
& Rank3BB
) << 8) & empty
;
153 to
= pop_1st_bit(&b3
);
154 mlist
[n
++].move
= make_move(to
- DELTA_N
- DELTA_N
, to
);
157 // Direct checks. These are possible only for pawns on neighboring files
158 // of the enemy king:
160 b1
&= (~dc
& neighboring_files_bb(ksq
));
162 // Direct checks, single pawn pushes:
163 b2
= (b1
<< 8) & empty
;
164 b3
= b2
& pos
.black_pawn_attacks(ksq
);
166 to
= pop_1st_bit(&b3
);
167 mlist
[n
++].move
= make_move(to
- DELTA_N
, to
);
170 // Direct checks, double pawn pushes:
171 b3
= ((b2
& Rank3BB
) << 8) & empty
& pos
.black_pawn_attacks(ksq
);
173 to
= pop_1st_bit(&b3
);
174 mlist
[n
++].move
= make_move(to
- DELTA_N
- DELTA_N
, to
);
177 else { // (us == BLACK)
179 // Pawn moves which give discovered check. This is possible only if the
180 // pawn is not on the same file as the enemy king, because we don't
181 // generate captures.
183 // Find all friendly pawns not on the enemy king's file:
184 b1
= pos
.pawns(us
) & ~file_bb(ksq
);
186 // Discovered checks, single pawn pushes:
187 b2
= b3
= ((b1
& dc
) >> 8) & ~Rank1BB
& empty
;
189 to
= pop_1st_bit(&b3
);
190 mlist
[n
++].move
= make_move(to
- DELTA_S
, to
);
193 // Discovered checks, double pawn pushes:
194 b3
= ((b2
& Rank6BB
) >> 8) & empty
;
196 to
= pop_1st_bit(&b3
);
197 mlist
[n
++].move
= make_move(to
- DELTA_S
- DELTA_S
, to
);
200 // Direct checks. These are possible only for pawns on neighboring files
201 // of the enemy king:
203 b1
&= (~dc
& neighboring_files_bb(ksq
));
205 // Direct checks, single pawn pushes:
206 b2
= (b1
>> 8) & empty
;
207 b3
= b2
& pos
.white_pawn_attacks(ksq
);
209 to
= pop_1st_bit(&b3
);
210 mlist
[n
++].move
= make_move(to
- DELTA_S
, to
);
213 // Direct checks, double pawn pushes:
214 b3
= ((b2
& Rank6BB
) >> 8) & empty
& pos
.black_pawn_attacks(ksq
);
216 to
= pop_1st_bit(&b3
);
217 mlist
[n
++].move
= make_move(to
- DELTA_S
- DELTA_S
, to
);
222 b1
= pos
.knights(us
);
224 // Discovered knight checks:
227 from
= pop_1st_bit(&b2
);
228 b3
= pos
.knight_attacks(from
) & empty
;
230 to
= pop_1st_bit(&b3
);
231 mlist
[n
++].move
= make_move(from
, to
);
235 // Direct knight checks:
237 checkSqs
= pos
.knight_attacks(ksq
) & empty
;
239 from
= pop_1st_bit(&b2
);
240 b3
= pos
.knight_attacks(from
) & checkSqs
;
242 to
= pop_1st_bit(&b3
);
243 mlist
[n
++].move
= make_move(from
, to
);
249 b1
= pos
.bishops(us
);
251 // Discovered bishop checks:
254 from
= pop_1st_bit(&b2
);
255 b3
= pos
.bishop_attacks(from
) & empty
;
257 to
= pop_1st_bit(&b3
);
258 mlist
[n
++].move
= make_move(from
, to
);
262 // Direct bishop checks:
264 checkSqs
= pos
.bishop_attacks(ksq
) & empty
;
266 from
= pop_1st_bit(&b2
);
267 b3
= pos
.bishop_attacks(from
) & checkSqs
;
269 to
= pop_1st_bit(&b3
);
270 mlist
[n
++].move
= make_move(from
, to
);
278 // Discovered rook checks:
281 from
= pop_1st_bit(&b2
);
282 b3
= pos
.rook_attacks(from
) & empty
;
284 to
= pop_1st_bit(&b3
);
285 mlist
[n
++].move
= make_move(from
, to
);
289 // Direct rook checks:
291 checkSqs
= pos
.rook_attacks(ksq
) & empty
;
293 from
= pop_1st_bit(&b2
);
294 b3
= pos
.rook_attacks(from
) & checkSqs
;
296 to
= pop_1st_bit(&b3
);
297 mlist
[n
++].move
= make_move(from
, to
);
305 // Discovered queen checks are impossible!
307 // Direct queen checks:
308 checkSqs
= pos
.queen_attacks(ksq
) & empty
;
310 from
= pop_1st_bit(&b1
);
311 b2
= pos
.queen_attacks(from
) & checkSqs
;
313 to
= pop_1st_bit(&b2
);
314 mlist
[n
++].move
= make_move(from
, to
);
320 from
= pos
.king_square(us
);
321 if(bit_is_set(dc
, from
)) {
322 b1
= pos
.king_attacks(from
) & empty
& ~QueenPseudoAttacks
[ksq
];
324 to
= pop_1st_bit(&b1
);
325 mlist
[n
++].move
= make_move(from
, to
);
329 // TODO: Castling moves!
335 /// generate_evasions() generates all check evasions when the side to move is
336 /// in check. Unlike the other move generation functions, this one generates
337 /// only legal moves. It returns the number of generated moves. This
338 /// function is very ugly, and needs cleaning up some time later. FIXME
340 int generate_evasions(const Position
&pos
, MoveStack
*mlist
) {
342 Bitboard checkers
= pos
.checkers();
343 Bitboard pinned
, b1
, b2
;
344 Square ksq
, from
, to
;
348 assert(pos
.is_check());
350 us
= pos
.side_to_move();
351 them
= opposite_color(us
);
353 ksq
= pos
.king_square(us
);
354 assert(pos
.piece_on(ksq
) == king_of_color(us
));
356 // Generate evasions for king:
357 b1
= pos
.king_attacks(ksq
) & ~pos
.pieces_of_color(us
);
358 b2
= pos
.occupied_squares();
361 to
= pop_1st_bit(&b1
);
363 // Make sure to is not attacked by the other side. This is a bit ugly,
364 // because we can't use Position::square_is_attacked. Instead we use
365 // the low-level bishop_attacks_bb and rook_attacks_bb with the bitboard
366 // b2 (the occupied squares with the king removed) in order to test whether
367 // the king will remain in check on the destination square.
368 if(((pos
.pawn_attacks(us
, to
) & pos
.pawns(them
)) == EmptyBoardBB
) &&
369 ((pos
.knight_attacks(to
) & pos
.knights(them
)) == EmptyBoardBB
) &&
370 ((pos
.king_attacks(to
) & pos
.kings(them
)) == EmptyBoardBB
) &&
371 ((bishop_attacks_bb(to
, b2
) & pos
.bishops_and_queens(them
))
373 ((rook_attacks_bb(to
, b2
) & pos
.rooks_and_queens(them
)) == EmptyBoardBB
))
374 mlist
[n
++].move
= make_move(ksq
, to
);
378 // Generate evasions for other pieces only if not double check. We use a
379 // simple bit twiddling hack here rather than calling count_1s in order to
380 // save some time (we know that pos.checkers() has at most two nonzero bits).
381 if(!(checkers
& (checkers
- 1))) {
382 Square checksq
= first_1(checkers
);
383 assert(pos
.color_of_piece_on(checksq
) == them
);
385 // Find pinned pieces:
386 pinned
= pos
.pinned_pieces(us
);
388 // Generate captures of the checking piece:
391 b1
= pos
.pawn_attacks(them
, checksq
) & pos
.pawns(us
) & ~pinned
;
393 from
= pop_1st_bit(&b1
);
394 if(pawn_rank(us
, checksq
) == RANK_8
) {
395 mlist
[n
++].move
= make_promotion_move(from
, checksq
, QUEEN
);
396 mlist
[n
++].move
= make_promotion_move(from
, checksq
, ROOK
);
397 mlist
[n
++].move
= make_promotion_move(from
, checksq
, BISHOP
);
398 mlist
[n
++].move
= make_promotion_move(from
, checksq
, KNIGHT
);
401 mlist
[n
++].move
= make_move(from
, checksq
);
405 b1
= pos
.knight_attacks(checksq
) & pos
.knights(us
) & ~pinned
;
407 from
= pop_1st_bit(&b1
);
408 mlist
[n
++].move
= make_move(from
, checksq
);
411 // Bishop and queen captures:
412 b1
= pos
.bishop_attacks(checksq
) & pos
.bishops_and_queens(us
)
415 from
= pop_1st_bit(&b1
);
416 mlist
[n
++].move
= make_move(from
, checksq
);
419 // Rook and queen captures:
420 b1
= pos
.rook_attacks(checksq
) & pos
.rooks_and_queens(us
)
423 from
= pop_1st_bit(&b1
);
424 mlist
[n
++].move
= make_move(from
, checksq
);
427 // Blocking check evasions are possible only if the checking piece is
429 if(checkers
& pos
.sliders()) {
430 Bitboard blockSquares
= squares_between(checksq
, ksq
);
431 assert((pos
.occupied_squares() & blockSquares
) == EmptyBoardBB
);
433 // Pawn moves. Because a blocking evasion can never be a capture, we
434 // only generate pawn pushes. As so often, the code for pawns is a bit
435 // ugly, and uses separate clauses for white and black pawns. :-(
437 // Find non-pinned pawns:
438 b1
= pos
.pawns(WHITE
) & ~pinned
;
440 // Single pawn pushes. We don't have to AND with empty squares here,
441 // because the blocking squares will always be empty.
442 b2
= (b1
<< 8) & blockSquares
;
444 to
= pop_1st_bit(&b2
);
445 assert(pos
.piece_on(to
) == EMPTY
);
446 if(square_rank(to
) == RANK_8
) {
447 mlist
[n
++].move
= make_promotion_move(to
- DELTA_N
, to
, QUEEN
);
448 mlist
[n
++].move
= make_promotion_move(to
- DELTA_N
, to
, ROOK
);
449 mlist
[n
++].move
= make_promotion_move(to
- DELTA_N
, to
, BISHOP
);
450 mlist
[n
++].move
= make_promotion_move(to
- DELTA_N
, to
, KNIGHT
);
453 mlist
[n
++].move
= make_move(to
- DELTA_N
, to
);
455 // Double pawn pushes.
456 b2
= (((b1
<< 8) & pos
.empty_squares() & Rank3BB
) << 8) & blockSquares
;
458 to
= pop_1st_bit(&b2
);
459 assert(pos
.piece_on(to
) == EMPTY
);
460 assert(square_rank(to
) == RANK_4
);
461 mlist
[n
++].move
= make_move(to
- DELTA_N
- DELTA_N
, to
);
464 else { // (us == BLACK)
465 // Find non-pinned pawns:
466 b1
= pos
.pawns(BLACK
) & ~pinned
;
468 // Single pawn pushes. We don't have to AND with empty squares here,
469 // because the blocking squares will always be empty.
470 b2
= (b1
>> 8) & blockSquares
;
472 to
= pop_1st_bit(&b2
);
473 assert(pos
.piece_on(to
) == EMPTY
);
474 if(square_rank(to
) == RANK_1
) {
475 mlist
[n
++].move
= make_promotion_move(to
- DELTA_S
, to
, QUEEN
);
476 mlist
[n
++].move
= make_promotion_move(to
- DELTA_S
, to
, ROOK
);
477 mlist
[n
++].move
= make_promotion_move(to
- DELTA_S
, to
, BISHOP
);
478 mlist
[n
++].move
= make_promotion_move(to
- DELTA_S
, to
, KNIGHT
);
481 mlist
[n
++].move
= make_move(to
- DELTA_S
, to
);
483 // Double pawn pushes.
484 b2
= (((b1
>> 8) & pos
.empty_squares() & Rank6BB
) >> 8) & blockSquares
;
486 to
= pop_1st_bit(&b2
);
487 assert(pos
.piece_on(to
) == EMPTY
);
488 assert(square_rank(to
) == RANK_5
);
489 mlist
[n
++].move
= make_move(to
- DELTA_S
- DELTA_S
, to
);
494 b1
= pos
.knights(us
) & ~pinned
;
496 from
= pop_1st_bit(&b1
);
497 b2
= pos
.knight_attacks(from
) & blockSquares
;
499 to
= pop_1st_bit(&b2
);
500 mlist
[n
++].move
= make_move(from
, to
);
505 b1
= pos
.bishops(us
) & ~pinned
;
507 from
= pop_1st_bit(&b1
);
508 b2
= pos
.bishop_attacks(from
) & blockSquares
;
510 to
= pop_1st_bit(&b2
);
511 mlist
[n
++].move
= make_move(from
, to
);
516 b1
= pos
.rooks(us
) & ~pinned
;
518 from
= pop_1st_bit(&b1
);
519 b2
= pos
.rook_attacks(from
) & blockSquares
;
521 to
= pop_1st_bit(&b2
);
522 mlist
[n
++].move
= make_move(from
, to
);
527 b1
= pos
.queens(us
) & ~pinned
;
529 from
= pop_1st_bit(&b1
);
530 b2
= pos
.queen_attacks(from
) & blockSquares
;
532 to
= pop_1st_bit(&b2
);
533 mlist
[n
++].move
= make_move(from
, to
);
538 // Finally, the ugly special case of en passant captures. An en passant
539 // capture can only be a check evasion if the check is not a discovered
540 // check. If pos.ep_square() is set, the last move made must have been
541 // a double pawn push. If, furthermore, the checking piece is a pawn,
542 // an en passant check evasion may be possible.
543 if(pos
.ep_square() != SQ_NONE
&& (checkers
& pos
.pawns(them
))) {
544 to
= pos
.ep_square();
545 b1
= pos
.pawn_attacks(them
, to
) & pos
.pawns(us
);
546 assert(b1
!= EmptyBoardBB
);
549 from
= pop_1st_bit(&b1
);
551 // Before generating the move, we have to make sure it is legal.
552 // This is somewhat tricky, because the two disappearing pawns may
553 // cause new "discovered checks". We test this by removing the
554 // two relevant bits from the occupied squares bitboard, and using
555 // the low-level bitboard functions for bishop and rook attacks.
556 b2
= pos
.occupied_squares();
557 clear_bit(&b2
, from
);
558 clear_bit(&b2
, checksq
);
559 if(((bishop_attacks_bb(ksq
, b2
) & pos
.bishops_and_queens(them
))
561 ((rook_attacks_bb(ksq
, b2
) & pos
.rooks_and_queens(them
))
563 mlist
[n
++].move
= make_ep_move(from
, to
);
572 /// generate_legal_moves() computes a complete list of legal moves in the
573 /// current position. This function is not very fast, and should be used
574 /// only in situations where performance is unimportant. It wouldn't be
575 /// very hard to write an efficient legal move generator, but for the moment
576 /// we don't need it.
578 int generate_legal_moves(const Position
&pos
, MoveStack
*mlist
) {
582 return generate_evasions(pos
, mlist
);
585 Bitboard pinned
= pos
.pinned_pieces(pos
.side_to_move());
587 // Generate pseudo-legal moves:
588 n
= generate_captures(pos
, mlist
);
589 n
+= generate_noncaptures(pos
, mlist
+ n
);
591 // Remove illegal moves from the list:
592 for(i
= 0; i
< n
; i
++) {
593 if(!pos
.move_is_legal(mlist
[i
].move
, pinned
))
594 mlist
[i
--].move
= mlist
[--n
].move
;
602 /// generate_move_if_legal() takes a position and a (not necessarily
603 /// pseudo-legal) move and a pinned pieces bitboard as input, and tests
604 /// whether the move is legal. If the move is legal, the move itself is
605 /// returned. If not, the function returns MOVE_NONE. This function must
606 /// only be used when the side to move is not in check.
608 Move
generate_move_if_legal(const Position
&pos
, Move m
, Bitboard pinned
) {
614 assert(!pos
.is_check());
615 assert(move_is_ok(m
));
617 us
= pos
.side_to_move();
618 them
= opposite_color(us
);
620 pc
= pos
.piece_on(from
);
622 // If the from square is not occupied by a piece belonging to the side to
623 // move, the move is obviously not legal.
624 if(color_of_piece(pc
) != us
)
632 // The piece must be a pawn:
633 if(type_of_piece(pc
) != PAWN
)
636 // The destination square must be the en passant square:
637 if(to
!= pos
.ep_square())
640 assert(pos
.square_is_empty(to
));
641 assert(pos
.piece_on(to
- pawn_push(us
)) == pawn_of_color(them
));
643 // The move is pseudo-legal. If it is legal, return it.
644 if(pos
.move_is_legal(m
))
651 else if(move_is_short_castle(m
)) {
653 // The piece must be a king:
654 if(type_of_piece(pc
) != KING
)
657 // The side to move must still have the right to castle kingside:
658 if(!pos
.can_castle_kingside(us
))
661 assert(from
== pos
.king_square(us
));
662 assert(to
== pos
.initial_kr_square(us
));
663 assert(pos
.piece_on(to
) == rook_of_color(us
));
665 Square g1
= relative_square(us
, SQ_G1
);
666 Square f1
= relative_square(us
, SQ_F1
);
668 bool illegal
= false;
670 for(s
= Min(from
, g1
); s
<= Max(from
, g1
); s
++)
671 if((s
!= from
&& s
!= to
&& !pos
.square_is_empty(s
)) ||
672 pos
.square_is_attacked(s
, them
))
674 for(s
= Min(to
, f1
); s
<= Max(to
, f1
); s
++)
675 if(s
!= from
&& s
!= to
&& !pos
.square_is_empty(s
))
683 else if(move_is_long_castle(m
)) {
685 // The piece must be a king:
686 if(type_of_piece(pc
) != KING
)
689 // The side to move must still have the right to castle kingside:
690 if(!pos
.can_castle_queenside(us
))
693 assert(from
== pos
.king_square(us
));
694 assert(to
== pos
.initial_qr_square(us
));
695 assert(pos
.piece_on(to
) == rook_of_color(us
));
697 Square c1
= relative_square(us
, SQ_C1
);
698 Square d1
= relative_square(us
, SQ_D1
);
700 bool illegal
= false;
702 for(s
= Min(from
, c1
); s
<= Max(from
, c1
); s
++)
703 if((s
!= from
&& s
!= to
&& !pos
.square_is_empty(s
)) ||
704 pos
.square_is_attacked(s
, them
))
706 for(s
= Min(to
, d1
); s
<= Max(to
, d1
); s
++)
707 if(s
!= from
&& s
!= to
&& !pos
.square_is_empty(s
))
709 if(square_file(to
) == FILE_B
&&
710 (pos
.piece_on(to
+ DELTA_W
) == rook_of_color(them
) ||
711 pos
.piece_on(to
+ DELTA_W
) == queen_of_color(them
)))
723 // The destination square cannot be occupied by a friendly piece:
724 if(pos
.color_of_piece_on(to
) == us
)
727 // Proceed according to the type of the moving piece.
728 switch(type_of_piece(pc
)) {
731 // Pawn moves, as usual, are somewhat messy.
733 // If the destination square is on the 8th rank, the move must be a
735 if(square_rank(to
) == RANK_8
&& !move_promotion(m
))
738 // Proceed according to the square delta between the source and
739 // destionation squares.
742 case DELTA_NW
: case DELTA_NE
:
743 // Capture. The destination square must be occupied by an enemy piece
744 // (en passant captures was handled earlier).
745 if(pos
.color_of_piece_on(to
) != them
)
750 // Pawn push. The destination square must be empty.
751 if(!pos
.square_is_empty(to
))
756 // Double pawn push. The destination square must be on the fourth
757 // rank, and both the destination square and the square between the
758 // source and destination squares must be empty.
759 if(square_rank(to
) != RANK_4
|| !pos
.square_is_empty(to
) ||
760 !pos
.square_is_empty(from
+ DELTA_N
))
768 else { // (us == BLACK)
769 // If the destination square is on the 1st rank, the move must be a
771 if(square_rank(to
) == RANK_1
&& !move_promotion(m
))
774 // Proceed according to the square delta between the source and
775 // destionation squares.
778 case DELTA_SW
: case DELTA_SE
:
779 // Capture. The destination square must be occupied by an enemy piece
780 // (en passant captures was handled earlier).
781 if(pos
.color_of_piece_on(to
) != them
)
786 // Pawn push. The destination square must be empty.
787 if(!pos
.square_is_empty(to
))
792 // Double pawn push. The destination square must be on the fifth
793 // rank, and both the destination square and the square between the
794 // source and destination squares must be empty.
795 if(square_rank(to
) != RANK_5
|| !pos
.square_is_empty(to
) ||
796 !pos
.square_is_empty(from
+ DELTA_S
))
804 // The move is pseudo-legal. Return it if it is legal.
805 if(pos
.move_is_legal(m
))
812 if(pos
.knight_attacks_square(from
, to
) && pos
.move_is_legal(m
) &&
820 if(pos
.bishop_attacks_square(from
, to
) && pos
.move_is_legal(m
) &&
828 if(pos
.rook_attacks_square(from
, to
) && pos
.move_is_legal(m
) &&
836 if(pos
.queen_attacks_square(from
, to
) && pos
.move_is_legal(m
) &&
844 if(pos
.king_attacks_square(from
, to
) && pos
.move_is_legal(m
) &&
863 int generate_white_pawn_captures(const Position
&pos
, MoveStack
*mlist
) {
864 Bitboard pawns
= pos
.pawns(WHITE
);
865 Bitboard enemyPieces
= pos
.pieces_of_color(BLACK
);
870 // Captures in the a1-h8 direction:
871 b1
= (pawns
<< 9) & ~FileABB
& enemyPieces
;
876 sq
= pop_1st_bit(&b2
);
877 mlist
[n
++].move
= make_promotion_move(sq
- DELTA_NE
, sq
, QUEEN
);
883 sq
= pop_1st_bit(&b2
);
884 mlist
[n
++].move
= make_move(sq
- DELTA_NE
, sq
);
887 // Captures in the h1-a8 direction:
888 b1
= (pawns
<< 7) & ~FileHBB
& enemyPieces
;
893 sq
= pop_1st_bit(&b2
);
894 mlist
[n
++].move
= make_promotion_move(sq
- DELTA_NW
, sq
, QUEEN
);
900 sq
= pop_1st_bit(&b2
);
901 mlist
[n
++].move
= make_move(sq
- DELTA_NW
, sq
);
904 // Non-capturing promotions:
905 b1
= (pawns
<< 8) & pos
.empty_squares() & Rank8BB
;
907 sq
= pop_1st_bit(&b1
);
908 mlist
[n
++].move
= make_promotion_move(sq
- DELTA_N
, sq
, QUEEN
);
911 // En passant captures:
912 if(pos
.ep_square() != SQ_NONE
) {
913 assert(square_rank(pos
.ep_square()) == RANK_6
);
914 b1
= pawns
& pos
.black_pawn_attacks(pos
.ep_square());
915 assert(b1
!= EmptyBoardBB
);
917 sq
= pop_1st_bit(&b1
);
918 mlist
[n
++].move
= make_ep_move(sq
, pos
.ep_square());
926 int generate_black_pawn_captures(const Position
&pos
, MoveStack
*mlist
) {
927 Bitboard pawns
= pos
.pawns(BLACK
);
928 Bitboard enemyPieces
= pos
.pieces_of_color(WHITE
);
933 // Captures in the a8-h1 direction:
934 b1
= (pawns
>> 7) & ~FileABB
& enemyPieces
;
939 sq
= pop_1st_bit(&b2
);
940 mlist
[n
++].move
= make_promotion_move(sq
- DELTA_SE
, sq
, QUEEN
);
946 sq
= pop_1st_bit(&b2
);
947 mlist
[n
++].move
= make_move(sq
- DELTA_SE
, sq
);
950 // Captures in the h8-a1 direction:
951 b1
= (pawns
>> 9) & ~FileHBB
& enemyPieces
;
956 sq
= pop_1st_bit(&b2
);
957 mlist
[n
++].move
= make_promotion_move(sq
- DELTA_SW
, sq
, QUEEN
);
963 sq
= pop_1st_bit(&b2
);
964 mlist
[n
++].move
= make_move(sq
- DELTA_SW
, sq
);
967 // Non-capturing promotions:
968 b1
= (pawns
>> 8) & pos
.empty_squares() & Rank1BB
;
970 sq
= pop_1st_bit(&b1
);
971 mlist
[n
++].move
= make_promotion_move(sq
- DELTA_S
, sq
, QUEEN
);
974 // En passant captures:
975 if(pos
.ep_square() != SQ_NONE
) {
976 assert(square_rank(pos
.ep_square()) == RANK_3
);
977 b1
= pawns
& pos
.white_pawn_attacks(pos
.ep_square());
978 assert(b1
!= EmptyBoardBB
);
980 sq
= pop_1st_bit(&b1
);
981 mlist
[n
++].move
= make_ep_move(sq
, pos
.ep_square());
989 int generate_white_pawn_noncaptures(const Position
&pos
, MoveStack
*mlist
) {
990 Bitboard pawns
= pos
.pawns(WHITE
);
991 Bitboard enemyPieces
= pos
.pieces_of_color(BLACK
);
992 Bitboard emptySquares
= pos
.empty_squares();
997 // Underpromotion captures in the a1-h8 direction:
998 b1
= (pawns
<< 9) & ~FileABB
& enemyPieces
& Rank8BB
;
1000 sq
= pop_1st_bit(&b1
);
1001 mlist
[n
++].move
= make_promotion_move(sq
- DELTA_NE
, sq
, ROOK
);
1002 mlist
[n
++].move
= make_promotion_move(sq
- DELTA_NE
, sq
, BISHOP
);
1003 mlist
[n
++].move
= make_promotion_move(sq
- DELTA_NE
, sq
, KNIGHT
);
1006 // Underpromotion captures in the h1-a8 direction:
1007 b1
= (pawns
<< 7) & ~FileHBB
& enemyPieces
& Rank8BB
;
1009 sq
= pop_1st_bit(&b1
);
1010 mlist
[n
++].move
= make_promotion_move(sq
- DELTA_NW
, sq
, ROOK
);
1011 mlist
[n
++].move
= make_promotion_move(sq
- DELTA_NW
, sq
, BISHOP
);
1012 mlist
[n
++].move
= make_promotion_move(sq
- DELTA_NW
, sq
, KNIGHT
);
1015 // Single pawn pushes:
1016 b1
= (pawns
<< 8) & emptySquares
;
1019 sq
= pop_1st_bit(&b2
);
1020 mlist
[n
++].move
= make_promotion_move(sq
- DELTA_N
, sq
, ROOK
);
1021 mlist
[n
++].move
= make_promotion_move(sq
- DELTA_N
, sq
, BISHOP
);
1022 mlist
[n
++].move
= make_promotion_move(sq
- DELTA_N
, sq
, KNIGHT
);
1026 sq
= pop_1st_bit(&b2
);
1027 mlist
[n
++].move
= make_move(sq
- DELTA_N
, sq
);
1030 // Double pawn pushes:
1031 b2
= ((b1
& Rank3BB
) << 8) & emptySquares
;
1033 sq
= pop_1st_bit(&b2
);
1034 mlist
[n
++].move
= make_move(sq
- DELTA_N
- DELTA_N
, sq
);
1041 int generate_black_pawn_noncaptures(const Position
&pos
, MoveStack
*mlist
) {
1042 Bitboard pawns
= pos
.pawns(BLACK
);
1043 Bitboard enemyPieces
= pos
.pieces_of_color(WHITE
);
1044 Bitboard emptySquares
= pos
.empty_squares();
1049 // Underpromotion captures in the a8-h1 direction:
1050 b1
= (pawns
>> 7) & ~FileABB
& enemyPieces
& Rank1BB
;
1052 sq
= pop_1st_bit(&b1
);
1053 mlist
[n
++].move
= make_promotion_move(sq
- DELTA_SE
, sq
, ROOK
);
1054 mlist
[n
++].move
= make_promotion_move(sq
- DELTA_SE
, sq
, BISHOP
);
1055 mlist
[n
++].move
= make_promotion_move(sq
- DELTA_SE
, sq
, KNIGHT
);
1058 // Underpromotion captures in the h8-a1 direction:
1059 b1
= (pawns
>> 9) & ~FileHBB
& enemyPieces
& Rank1BB
;
1061 sq
= pop_1st_bit(&b1
);
1062 mlist
[n
++].move
= make_promotion_move(sq
- DELTA_SW
, sq
, ROOK
);
1063 mlist
[n
++].move
= make_promotion_move(sq
- DELTA_SW
, sq
, BISHOP
);
1064 mlist
[n
++].move
= make_promotion_move(sq
- DELTA_SW
, sq
, KNIGHT
);
1067 // Single pawn pushes:
1068 b1
= (pawns
>> 8) & emptySquares
;
1071 sq
= pop_1st_bit(&b2
);
1072 mlist
[n
++].move
= make_promotion_move(sq
- DELTA_S
, sq
, ROOK
);
1073 mlist
[n
++].move
= make_promotion_move(sq
- DELTA_S
, sq
, BISHOP
);
1074 mlist
[n
++].move
= make_promotion_move(sq
- DELTA_S
, sq
, KNIGHT
);
1078 sq
= pop_1st_bit(&b2
);
1079 mlist
[n
++].move
= make_move(sq
- DELTA_S
, sq
);
1082 // Double pawn pushes:
1083 b2
= ((b1
& Rank6BB
) >> 8) & emptySquares
;
1085 sq
= pop_1st_bit(&b2
);
1086 mlist
[n
++].move
= make_move(sq
- DELTA_S
- DELTA_S
, sq
);
1093 int generate_knight_moves(const Position
&pos
, MoveStack
*mlist
,
1094 Color side
, Bitboard target
) {
1099 for(i
= 0; i
< pos
.knight_count(side
); i
++) {
1100 from
= pos
.knight_list(side
, i
);
1101 b
= pos
.knight_attacks(from
) & target
;
1103 to
= pop_1st_bit(&b
);
1104 mlist
[n
++].move
= make_move(from
, to
);
1111 int generate_bishop_moves(const Position
&pos
, MoveStack
*mlist
,
1112 Color side
, Bitboard target
) {
1117 for(i
= 0; i
< pos
.bishop_count(side
); i
++) {
1118 from
= pos
.bishop_list(side
, i
);
1119 b
= pos
.bishop_attacks(from
) & target
;
1121 to
= pop_1st_bit(&b
);
1122 mlist
[n
++].move
= make_move(from
, to
);
1129 int generate_rook_moves(const Position
&pos
, MoveStack
*mlist
,
1130 Color side
, Bitboard target
) {
1135 for(i
= 0; i
< pos
.rook_count(side
); i
++) {
1136 from
= pos
.rook_list(side
, i
);
1137 b
= pos
.rook_attacks(from
) & target
;
1139 to
= pop_1st_bit(&b
);
1140 mlist
[n
++].move
= make_move(from
, to
);
1147 int generate_queen_moves(const Position
&pos
, MoveStack
*mlist
,
1148 Color side
, Bitboard target
) {
1153 for(i
= 0; i
< pos
.queen_count(side
); i
++) {
1154 from
= pos
.queen_list(side
, i
);
1155 b
= pos
.queen_attacks(from
) & target
;
1157 to
= pop_1st_bit(&b
);
1158 mlist
[n
++].move
= make_move(from
, to
);
1165 int generate_king_moves(const Position
&pos
, MoveStack
*mlist
,
1166 Square from
, Bitboard target
) {
1171 b
= pos
.king_attacks(from
) & target
;
1173 to
= pop_1st_bit(&b
);
1174 mlist
[n
++].move
= make_move(from
, to
);
1180 int generate_castle_moves(const Position
&pos
, MoveStack
*mlist
, Color us
) {
1183 if(pos
.can_castle(us
)) {
1184 Color them
= opposite_color(us
);
1185 Square ksq
= pos
.king_square(us
);
1186 assert(pos
.piece_on(ksq
) == king_of_color(us
));
1188 if(pos
.can_castle_kingside(us
)) {
1189 Square rsq
= pos
.initial_kr_square(us
);
1190 Square g1
= relative_square(us
, SQ_G1
);
1191 Square f1
= relative_square(us
, SQ_F1
);
1193 bool illegal
= false;
1195 assert(pos
.piece_on(rsq
) == rook_of_color(us
));
1197 for(s
= Min(ksq
, g1
); s
<= Max(ksq
, g1
); s
++)
1198 if((s
!= ksq
&& s
!= rsq
&& pos
.square_is_occupied(s
))
1199 || pos
.square_is_attacked(s
, them
))
1201 for(s
= Min(rsq
, f1
); s
<= Max(rsq
, f1
); s
++)
1202 if(s
!= ksq
&& s
!= rsq
&& pos
.square_is_occupied(s
))
1206 mlist
[n
++].move
= make_castle_move(ksq
, rsq
);
1209 if(pos
.can_castle_queenside(us
)) {
1210 Square rsq
= pos
.initial_qr_square(us
);
1211 Square c1
= relative_square(us
, SQ_C1
);
1212 Square d1
= relative_square(us
, SQ_D1
);
1214 bool illegal
= false;
1216 assert(pos
.piece_on(rsq
) == rook_of_color(us
));
1218 for(s
= Min(ksq
, c1
); s
<= Max(ksq
, c1
); s
++)
1219 if((s
!= ksq
&& s
!= rsq
&& pos
.square_is_occupied(s
))
1220 || pos
.square_is_attacked(s
, them
))
1222 for(s
= Min(rsq
, d1
); s
<= Max(rsq
, d1
); s
++)
1223 if(s
!= ksq
&& s
!= rsq
&& pos
.square_is_occupied(s
))
1225 if(square_file(rsq
) == FILE_B
&&
1226 (pos
.piece_on(relative_square(us
, SQ_A1
)) == rook_of_color(them
) ||
1227 pos
.piece_on(relative_square(us
, SQ_A1
)) == queen_of_color(them
)))
1231 mlist
[n
++].move
= make_castle_move(ksq
, rsq
);