Introduce and use struct MoveList

[stockfish] / src / movegen.cpp

diff --git a/src/movegen.cpp b/src/movegen.cpp
index 3d736b255952537f26515f97b5118116b9b1fce9..e6c52ce5aceeed80c4603e4df362fba03210772c 100644 (file)
--- a/src/movegen.cpp
+++ b/src/movegen.cpp
@@ -64,9 +64,9 @@ namespace {
 
     Bitboard checkSqs, b;
     Square from;
-    const Square* ptr = pos.piece_list_begin(us, Pt);
+    const Square* pl = pos.piece_list(us, Pt);
 
-    if ((from = *ptr++) == SQ_NONE)
+    if ((from = *pl++) == SQ_NONE)
         return mlist;
 
     checkSqs = pos.attacks_from<Pt>(ksq) & pos.empty_squares();
@@ -84,7 +84,7 @@ namespace {
         b = pos.attacks_from<Pt>(from) & checkSqs;
         SERIALIZE_MOVES(b);
 
-    } while ((from = *ptr++) != SQ_NONE);
+    } while ((from = *pl++) != SQ_NONE);
 
     return mlist;
   }
@@ -111,15 +111,15 @@ namespace {
 
     Bitboard b;
     Square from;
-    const Square* ptr = pos.piece_list_begin(us, Pt);
+    const Square* pl = pos.piece_list(us, Pt);
 
-    if (*ptr != SQ_NONE)
+    if (*pl != SQ_NONE)
     {
         do {
-            from = *ptr;
+            from = *pl;
             b = pos.attacks_from<Pt>(from) & target;
             SERIALIZE_MOVES(b);
-        } while (*++ptr != SQ_NONE);
+        } while (*++pl != SQ_NONE);
     }
     return mlist;
   }
@@ -157,7 +157,7 @@ MoveStack* generate(const Position& pos, MoveStack* mlist) {
   Bitboard target;
 
   if (Type == MV_CAPTURE || Type == MV_NON_EVASION)
-      target = pos.pieces_of_color(opposite_color(us));
+      target = pos.pieces(opposite_color(us));
   else if (Type == MV_NON_CAPTURE)
       target = pos.empty_squares();
   else
@@ -289,7 +289,7 @@ MoveStack* generate<MV_EVASION>(const Position& pos, MoveStack* mlist) {
   } while (b);
 
   // Generate evasions for king, capture and non capture moves
-  b = pos.attacks_from<KING>(ksq) & ~pos.pieces_of_color(us) & ~sliderAttacks;
+  b = pos.attacks_from<KING>(ksq) & ~pos.pieces(us) & ~sliderAttacks;
   from = ksq;
   SERIALIZE_MOVES(b);
 
@@ -411,7 +411,7 @@ namespace {
     Bitboard b1, b2, dc1, dc2, pawnPushes, emptySquares;
     Bitboard pawns = pos.pieces(PAWN, Us);
     Bitboard pawnsOn7 = pawns & TRank7BB;
-    Bitboard enemyPieces = (Type == MV_CAPTURE ? target : pos.pieces_of_color(Them));
+    Bitboard enemyPieces = (Type == MV_CAPTURE ? target : pos.pieces(Them));
 
     // Pre-calculate pawn pushes before changing emptySquares definition
     if (Type != MV_CAPTURE)
@@ -501,38 +501,45 @@ namespace {
   template<CastlingSide Side>
   MoveStack* generate_castle_moves(const Position& pos, MoveStack* mlist, Color us) {
 
-    Color them = opposite_color(us);
-    Square ksq = pos.king_square(us);
     CastleRight f = CastleRight((Side == KING_SIDE ? WHITE_OO : WHITE_OOO) << us);
+    Color them = opposite_color(us);
 
-    assert(pos.piece_on(ksq) == make_piece(us, KING));
-
-    Square rsq = pos.castle_rook_square(f);
-    Square s1 = relative_square(us, Side == KING_SIDE ? SQ_G1 : SQ_C1);
-    Square s2 = relative_square(us, Side == KING_SIDE ? SQ_F1 : SQ_D1);
-    Square s;
-    bool illegal = false;
-
-    assert(pos.piece_on(rsq) == make_piece(us, ROOK));
-
-    // It is a bit complicated to correctly handle Chess960
-    for (s = Min(ksq, s1); s <= Max(ksq, s1); s++)
-        if (  (s != ksq && s != rsq && pos.square_is_occupied(s))
-            ||(pos.attackers_to(s) & pos.pieces_of_color(them)))
-            illegal = true;
+    // After castling, the rook and king's final positions are exactly the same
+    // in Chess960 as they would be in standard chess.
+    Square kfrom = pos.king_square(us);
+    Square rfrom = pos.castle_rook_square(f);
+    Square kto = relative_square(us, Side == KING_SIDE ? SQ_G1 : SQ_C1);
+    Square rto = relative_square(us, Side == KING_SIDE ? SQ_F1 : SQ_D1);
+
+    assert(!pos.in_check());
+    assert(pos.piece_on(kfrom) == make_piece(us, KING));
+    assert(pos.piece_on(rfrom) == make_piece(us, ROOK));
+
+    // Unimpeded rule: All the squares between the king's initial and final squares
+    // (including the final square), and all the squares between the rook's initial
+    // and final squares (including the final square), must be vacant except for
+    // the king and castling rook.
+    for (Square s = Min(kfrom, kto); s <= Max(kfrom, kto); s++)
+        if (  (s != kfrom && s != rfrom && !pos.square_is_empty(s))
+            ||(pos.attackers_to(s) & pos.pieces(them)))
+            return mlist;
 
-    for (s = Min(rsq, s2); s <= Max(rsq, s2); s++)
-        if (s != ksq && s != rsq && pos.square_is_occupied(s))
-            illegal = true;
+    for (Square s = Min(rfrom, rto); s <= Max(rfrom, rto); s++)
+        if (s != kfrom && s != rfrom && !pos.square_is_empty(s))
+            return mlist;
 
-    if (   Side == QUEEN_SIDE
-        && square_file(rsq) == FILE_B
-        && (   pos.piece_on(relative_square(us, SQ_A1)) == make_piece(them, ROOK)
-            || pos.piece_on(relative_square(us, SQ_A1)) == make_piece(them, QUEEN)))
-        illegal = true;
+    // Because we generate only legal castling moves we need to verify that
+    // when moving the castling rook we do not discover some hidden checker.
+    // For instance an enemy queen in SQ_A1 when castling rook is in SQ_B1.
+    if (pos.is_chess960())
+    {
+        Bitboard occ = pos.occupied_squares();
+        clear_bit(&occ, rfrom);
+        if (pos.attackers_to(kto, occ) & pos.pieces(them))
+            return mlist;
+    }
 
-    if (!illegal)
-        (*mlist++).move = make_castle_move(ksq, rsq);
+    (*mlist++).move = make_castle_move(kfrom, rfrom);
 
     return mlist;
   }