WebSVN – Games.Chess Giants – Diff – //engine-crafty/movgen.c

 #include "chess.h"
 #include "data.h"
-/* modified 02/22/14 */
+/* modified 12/31/15 */
 /*
  *******************************************************************************
  *                                                                             *
  *   GenerateCaptures() is used to generate capture and pawn promotion moves   *
  *   from the current position.                                                *
  *   pieces, plus the set of squares on the 8th rank that pawns can advance to *
  *   and promote.                                                              *
  *                                                                             *
  *******************************************************************************
  */
-int *GenerateCaptures(TREE * RESTRICT tree, int ply, int side, int *move) {
+unsigned *GenerateCaptures(TREE * RESTRICT tree, int ply, int side,
-  uint64_t target, piecebd, moves;
+    unsigned *move) {
-  uint64_t promotions, pcapturesl, pcapturesr;
+  uint64_t target, piecebd, moves, promotions, pcapturesl, pcapturesr;
   int from, to, temp, common, enemy = Flip(side);
 /*
  ************************************************************
  *                                                          *
  *  for each knight.                                        *
  *                                                          *
  ************************************************************
  */
   for (piecebd = Knights(side); piecebd; Clear(from, piecebd)) {
-    from = Advanced(side, piecebd);
+    from = MostAdvanced(side, piecebd);
     moves = knight_attacks[from] & Occupied(enemy);
     temp = from + (knight << 12);
     Extract(side, move, moves, temp);
+  }
 /*
  ************************************************************
  *                                                          *
- *  We produce bishop moves by locating the most advanced   *
+ *  We produce sliding piece moves by locating each piece   *
+ *  type in turn.  We then start with the most advanced     *
- *  bishop and then using that square in a magic multiply   *
+ *  piece and generate moves from that square.  This uses   *
- *  move generation to quickly identify all the squares a   *
+ *  "magic move generation" to produce the destination      *
- *  bishop can reach.  We repeat for each bishop.           *
+ *  squares.                                                *
  *                                                          *
  ************************************************************
  */
   for (piecebd = Bishops(side); piecebd; Clear(from, piecebd)) {
-    from = Advanced(side, piecebd);
+    from = MostAdvanced(side, piecebd);
     moves = BishopAttacks(from, OccupiedSquares) & Occupied(enemy);
     temp = from + (bishop << 12);
     Extract(side, move, moves, temp);
+  }
-/*
- ************************************************************
- *                                                          *
- *  We produce rook moves by locating the most advanced     *
- *  rook and then using that square in a magic multiply     *
- *  move generation to quickly identify all the squares a   *
- *  rook can reach.  We repeat for each rook.               *
- *                                                          *
- ************************************************************
- */
   for (piecebd = Rooks(side); piecebd; Clear(from, piecebd)) {
-    from = Advanced(side, piecebd);
+    from = MostAdvanced(side, piecebd);
     moves = RookAttacks(from, OccupiedSquares) & Occupied(enemy);
     temp = from + (rook << 12);
     Extract(side, move, moves, temp);
+  }
-/*
- ************************************************************
- *                                                          *
- *  We produce queen moves by locating the most advanced    *
- *  queen and then using that square in a magic multiply    *
- *  move generation to quickly identify all the squares a   *
- *  queen can reach.  We repeat for each queen.             *
- *                                                          *
- ************************************************************
- */
   for (piecebd = Queens(side); piecebd; Clear(from, piecebd)) {
-    from = Advanced(side, piecebd);
+    from = MostAdvanced(side, piecebd);
     moves = QueenAttacks(from, OccupiedSquares) & Occupied(enemy);
     temp = from + (queen << 12);
     Extract(side, move, moves, temp);
+  }
 /*
  *  do this by removing all pawns but those on the 7th rank *
  *  and then advancing them if the square in front is empty.*
  *                                                          *
  ************************************************************
  */
+  promotions = Pawns(side) & rank_mask[rank7[side]];
   promotions =
-      ((side) ? (Pawns(white) & rank_mask[RANK7]) << 8 : (Pawns(black) &
-          rank_mask[RANK2]) >> 8) & ~OccupiedSquares;
+      ((side) ? promotions << 8 : promotions >> 8) & ~OccupiedSquares;
   for (; promotions; Clear(to, promotions)) {
     to = LSB(promotions);
     *move++ =
         (to + pawnadv1[side]) | (to << 6) | (pawn << 12) | (queen << 18);
+  }
   target = Occupied(enemy) | EnPassantTarget(ply);
   pcapturesl =
       ((side) ? (Pawns(white) & mask_left_edge) << 7 : (Pawns(black) &
           mask_left_edge) >> 9) & target;
   for (; pcapturesl; Clear(to, pcapturesl)) {
-    to = Advanced(side, pcapturesl);
+    to = MostAdvanced(side, pcapturesl);
     common = (to + capleft[side]) | (to << 6) | (pawn << 12);
     if ((side) ? to < 56 : to > 7)
       *move++ = common | (((PcOnSq(to)) ? Abs(PcOnSq(to)) : pawn) << 15);
     else
       *move++ = common | Abs(PcOnSq(to)) << 15 | queen << 18;
+  }
   pcapturesr =
       ((side) ? (Pawns(white) & mask_right_edge) << 9 : (Pawns(black) &
           mask_right_edge) >> 7) & target;
   for (; pcapturesr; Clear(to, pcapturesr)) {
-    to = Advanced(side, pcapturesr);
+    to = MostAdvanced(side, pcapturesr);
     common = (to + capright[side]) | (to << 6) | (pawn << 12);
     if ((side) ? to < 56 : to > 7)
       *move++ = common | (((PcOnSq(to)) ? Abs(PcOnSq(to)) : pawn) << 15);
     else
       *move++ = common | Abs(PcOnSq(to)) << 15 | queen << 18;
+  }
   return move;
+}
-/* modified 02/22/14 */
+/* modified 12/31/15 */
 /*
  *******************************************************************************
  *                                                                             *
  *   GenerateChecks() is used to generate non-capture moves from the current   *
  *   position.                                                                 *
  *   attack.  This might be fixed at some point, but it is rare enough to not  *
  *   be an issue except in far endgames.                                       *
  *                                                                             *
  *******************************************************************************
  */
-int *GenerateChecks(TREE * RESTRICT tree, int side, int *move) {
+unsigned *GenerateChecks(TREE * RESTRICT tree, int side, unsigned *move) {
   uint64_t temp_target, target, piecebd, moves;
   uint64_t padvances1, blockers, checkers;
   int from, to, promote, temp, enemy = Flip(side);
 /*
- *********************************************************************
+ ************************************************************
- *                                                                   *
+ *                                                          *
- *  First pass:  produce direct checks.  For each piece type, we     *
+ *  First pass:  produce direct checks.  For each piece     *
- *  pretend that a piece of that type stands on the square of the    *
+ *  type, we pretend that a piece of that type stands on    *
- *  king and we generate attacks from that square for that piece.    *
+ *  the square of the king and we generate attacks from     *
+ *  that square for that piece.  Now, if we can find any    *
- *  Now, if we can find any piece of that type that attacks one of   *
+ *  piece of that type that attacks one of those squares,   *
- *  those squares, then that piece move would deliver a direct       *
+ *  then that piece move would deliver a direct check to    *
- *  check to the enemy king.  Easy, wasn't it?                       *
+ *  the enemy king.  Easy, wasn't it?                       *
- *                                                                   *
+ *                                                          *
- *********************************************************************
+ ************************************************************
  */
   target = ~OccupiedSquares;
 /*
  ************************************************************
  *                                                          *
  *                                                          *
  ************************************************************
  */
   temp_target = target & knight_attacks[KingSQ(enemy)];
   for (piecebd = Knights(side); piecebd; Clear(from, piecebd)) {
-    from = Advanced(side, piecebd);
+    from = MostAdvanced(side, piecebd);
     moves = knight_attacks[from] & temp_target;
     temp = from + (knight << 12);
     Extract(side, move, moves, temp);
+  }
 /*
  ************************************************************
  *                                                          *
- *  Bishop direct checks.                                   *
+ *  Sliding piece direct checks.                            *
  *                                                          *
  ************************************************************
  */
   temp_target = target & BishopAttacks(KingSQ(enemy), OccupiedSquares);
   for (piecebd = Bishops(side); piecebd; Clear(from, piecebd)) {
-    from = Advanced(side, piecebd);
+    from = MostAdvanced(side, piecebd);
     moves = BishopAttacks(from, OccupiedSquares) & temp_target;
     temp = from + (bishop << 12);
     Extract(side, move, moves, temp);
+  }
-/*
- ************************************************************
- *                                                          *
- *  Rook direct checks.                                     *
- *                                                          *
- ************************************************************
- */
   temp_target = target & RookAttacks(KingSQ(enemy), OccupiedSquares);
   for (piecebd = Rooks(side); piecebd; Clear(from, piecebd)) {
-    from = Advanced(side, piecebd);
+    from = MostAdvanced(side, piecebd);
     moves = RookAttacks(from, OccupiedSquares) & temp_target;
     temp = from + (rook << 12);
     Extract(side, move, moves, temp);
+  }
-/*
- ************************************************************
- *                                                          *
- *  Queen direct checks.                                    *
- *                                                          *
- ************************************************************
- */
   temp_target = target & QueenAttacks(KingSQ(enemy), OccupiedSquares);
   for (piecebd = Queens(side); piecebd; Clear(from, piecebd)) {
-    from = Advanced(side, piecebd);
+    from = MostAdvanced(side, piecebd);
     moves = QueenAttacks(from, OccupiedSquares) & temp_target;
     temp = from + (queen << 12);
     Extract(side, move, moves, temp);
+  }
 /*
  ************************************************************
  */
   temp_target = target & pawn_attacks[enemy][KingSQ(enemy)];
   padvances1 = ((side) ? Pawns(white) << 8 : Pawns(black) >> 8) & temp_target;
   for (; padvances1; Clear(to, padvances1)) {
-    to = Advanced(side, padvances1);
+    to = MostAdvanced(side, padvances1);
     *move++ = (to + pawnadv1[side]) | (to << 6) | (pawn << 12);
+  }
-/*
- *********************************************************************
- *                                                                   *
- *  Second pass:  produce discovered checks.  Here we do things a    *
- *  bit differently.  We first take diagonal movers.  From the enemy *
- *  king's position, we generate diagonal moves to see if any of     *
- *  them end at one of our pieces that does not slide diagonally,    *
- *  such as a rook, knight or pawn.  If we find one, we look further *
- *  down that diagonal to see if we now find a diagonal moves (queen *
- *  or bishop).  If so, any legal move by the blocking piece (except *
- *  captures which have already been generated) will be a discovered *
- *  check that needs to be searched.  We do the same for vertical /  *
- *  horizontal rays that are blocked by bishops, knights or pawns    *
- *  that would hide a discovered check by a rook or queen.           *
- *                                                                   *
- *********************************************************************
- */
 /*
  ************************************************************
+ *                                                          *
+ *  Second pass:  produce discovered checks.  Here we do    *
+ *  things a bit differently.  We first take diagonal       *
+ *  movers.  From the enemy king's position, we generate    *
+ *  diagonal moves to see if any of them end at one of our  *
+ *  pieces that does not slide diagonally, such as a rook,  *
+ *  knight or pawn.  If we find one, we look further down   *
+ *  that diagonal to see if we now find a diagonal moves    *
+ *  (queen or bishop).  If so, any legal move by the        *
+ *  blocking piece (except captures which have already been *
+ *  generated) will be a discovered check that needs to be  *
+ *  searched.  We do the same for vertical / horizontal     *
+ *  rays that are blocked by bishops, knights or pawns that *
+ *  would hide a discovered check by a rook or queen.       *
  *                                                          *
  *  First we look for diagonal discovered attacks.  Once we *
  *  know which squares hold pieces that create a discovered *
  *  check when they move, we generate those piece moves     *
  *  piece type by piece type.                               *
  *                                                          *
  ************************************************************
  */
       temp_target = target & ~knight_attacks[KingSQ(enemy)];
       for (piecebd = Knights(side) & blockers; piecebd; Clear(from, piecebd)) {
-        from = Advanced(side, piecebd);
+        from = MostAdvanced(side, piecebd);
         moves = knight_attacks[from] & temp_target;
         temp = from + (knight << 12);
         Extract(side, move, moves, temp);
+      }
 /*
  ************************************************************
  */
       target = ~OccupiedSquares;
       temp_target = target & ~RookAttacks(KingSQ(enemy), OccupiedSquares);
       for (piecebd = Rooks(side) & blockers; piecebd; Clear(from, piecebd)) {
-        from = Advanced(side, piecebd);
+        from = MostAdvanced(side, piecebd);
         moves = RookAttacks(from, OccupiedSquares) & temp_target;
         temp = from + (rook << 12);
         Extract(side, move, moves, temp);
+      }
 /*
  */
       piecebd =
           Pawns(side) & blockers & ((side) ? ~OccupiedSquares >> 8 :
           ~OccupiedSquares << 8);
       for (; piecebd; Clear(from, piecebd)) {
-        from = Advanced(side, piecebd);
+        from = MostAdvanced(side, piecebd);
         to = from + pawnadv1[enemy];
         if ((side) ? to > 55 : to < 8)
           promote = queen;
         else
           promote = 0;
  *                                                          *
  ************************************************************
  */
       temp_target = target & ~knight_attacks[KingSQ(enemy)];
       for (piecebd = Knights(side) & blockers; piecebd; Clear(from, piecebd)) {
-        from = Advanced(side, piecebd);
+        from = MostAdvanced(side, piecebd);
         moves = knight_attacks[from] & temp_target;
         temp = from + (knight << 12);
         Extract(side, move, moves, temp);
+      }
 /*
  ************************************************************
  */
       target = ~OccupiedSquares;
       temp_target = target & ~BishopAttacks(KingSQ(enemy), OccupiedSquares);
       for (piecebd = Bishops(side) & blockers; piecebd; Clear(from, piecebd)) {
-        from = Advanced(side, piecebd);
+        from = MostAdvanced(side, piecebd);
         moves = BishopAttacks(from, OccupiedSquares) & temp_target;
         temp = from + (bishop << 12);
         Extract(side, move, moves, temp);
+      }
 /*
  */
       piecebd =
           Pawns(side) & blockers & ((side) ? ~OccupiedSquares >> 8 :
           ~OccupiedSquares << 8);
       for (; piecebd; Clear(from, piecebd)) {
-        from = Advanced(side, piecebd);
+        from = MostAdvanced(side, piecebd);
         to = from + pawnadv1[enemy];
         if ((side) ? to > 55 : to < 8)
           promote = queen;
         else
           promote = 0;
+    }
+  }
   return move;
+}
-/* modified 02/22/14 */
+/* modified 12/31/15 */
 /*
  *******************************************************************************
  *                                                                             *
  *   GenerateCheckEvasions() is used to generate moves when the king is in     *
  *   check.                                                                    *
  *   checking the king, then the only legal capture to try is for the king to  *
  *   capture one of the checking pieces that is on an unattacked square.       *
  *                                                                             *
  *******************************************************************************
  */
-int *GenerateCheckEvasions(TREE * RESTRICT tree, int ply, int side, int *move) {
+unsigned *GenerateCheckEvasions(TREE * RESTRICT tree, int ply, int side,
+    unsigned *move) {
-  uint64_t target, targetc, targetp, piecebd, moves;
+  uint64_t target, targetc, targetp, piecebd, moves, empty, checksqs;
-  uint64_t padvances1, padvances2, pcapturesl, pcapturesr;
+  uint64_t padvances1, padvances2, pcapturesl, pcapturesr, padvances1_all;
-  uint64_t padvances1_all, empty, checksqs;
-  int from, to, temp, common, enemy = Flip(side);
+  int from, to, temp, common, enemy = Flip(side), king_square, checkers;
-  int king_square, checkers, checking_square;
-  int check_direction1 = 0, check_direction2 = 0;
+  int checking_square, check_direction1 = 0, check_direction2 = 0;
 /*
  ************************************************************
  *                                                          *
  *  First, determine how many pieces are attacking the king *
  ************************************************************
  */
   from = king_square;
   temp = from + (king << 12);
   for (moves = king_attacks[from] & ~Occupied(side); moves; Clear(to, moves)) {
-    to = Advanced(side, moves);
+    to = MostAdvanced(side, moves);
     if (!Attacks(tree, enemy, to)
         && directions[from][to] != check_direction1 &&
         directions[from][to] != check_direction2)
       *move++ = temp | (to << 6) | (Abs(PcOnSq(to)) << 15);
+  }
  *                                                          *
  ************************************************************
  */
   if (checkers == 1) {
     for (piecebd = Knights(side); piecebd; Clear(from, piecebd)) {
-      from = Advanced(side, piecebd);
+      from = MostAdvanced(side, piecebd);
       if (!PinnedOnKing(tree, side, from)) {
         moves = knight_attacks[from] & target;
         temp = from + (knight << 12);
         Extract(side, move, moves, temp);
+      }
+    }
 /*
  ************************************************************
  *                                                          *
- *  We produce bishop moves by locating the most advanced   *
+ *  We produce sliding piece moves by locating each piece   *
+ *  type in turn.  We then start with the most advanced     *
- *  bishop and then using that square in a magic multiply   *
+ *  piece and generate moves from that square.  This uses   *
- *  move generation to quickly identify all the squares a   *
+ *  "magic move generation" to produce the destination      *
- *  bishop can reach.  We repeat for each bishop.           *
+ *  squares.                                                *
  *                                                          *
  ************************************************************
  */
     for (piecebd = Bishops(side); piecebd; Clear(from, piecebd)) {
-      from = Advanced(side, piecebd);
+      from = MostAdvanced(side, piecebd);
       if (!PinnedOnKing(tree, side, from)) {
         moves = BishopAttacks(from, OccupiedSquares) & target;
         temp = from + (bishop << 12);
         Extract(side, move, moves, temp);
+      }
+    }
-/*
- ************************************************************
- *                                                          *
- *  We produce rook moves by locating the most advanced     *
- *  rook and then using that square in a magic multiply     *
- *  move generation to quickly identify all the squares     *
- *  rook can reach.  We repeat for each rook.               *
- *                                                          *
- ************************************************************
- */
     for (piecebd = Rooks(side); piecebd; Clear(from, piecebd)) {
-      from = Advanced(side, piecebd);
+      from = MostAdvanced(side, piecebd);
       if (!PinnedOnKing(tree, side, from)) {
         moves = RookAttacks(from, OccupiedSquares) & target;
         temp = from + (rook << 12);
         Extract(side, move, moves, temp);
+      }
+    }
-/*
- ************************************************************
- *                                                          *
- *  We produce queen moves by locating the most advanced    *
- *  queen and then using that square in a magic multiply    *
- *  move generation to quickly identify all the squares a   *
- *  queen can reach.  We repeat for each queen.             *
- *                                                          *
- ************************************************************
- */
     for (piecebd = Queens(side); piecebd; Clear(from, piecebd)) {
-      from = Advanced(side, piecebd);
+      from = MostAdvanced(side, piecebd);
       if (!PinnedOnKing(tree, side, from)) {
         moves = QueenAttacks(from, OccupiedSquares) & target;
         temp = from + (queen << 12);
         Extract(side, move, moves, temp);
+      }
  *  potential moves.                                        *
  *                                                          *
  ************************************************************
  */
     for (; padvances2; Clear(to, padvances2)) {
-      to = Advanced(side, padvances2);
+      to = MostAdvanced(side, padvances2);
       if (!PinnedOnKing(tree, side, to + pawnadv2[side]))
         *move++ = (to + pawnadv2[side]) | (to << 6) | (pawn << 12);
+    }
     for (; padvances1; Clear(to, padvances1)) {
-      to = Advanced(side, padvances1);
+      to = MostAdvanced(side, padvances1);
       if (!PinnedOnKing(tree, side, to + pawnadv1[side])) {
         common = (to + pawnadv1[side]) | (to << 6) | (pawn << 12);
         if ((side) ? to < 56 : to > 7)
           *move++ = common;
         else {
           *move++ = common | (queen << 18);
           *move++ = common | (knight << 18);
+        }
+      }
+    }
+/*
+ ************************************************************
+ *                                                          *
+ *  And then we try to see if the checking piece can be     *
+ *  captured by a friendly pawn.                            *
+ *                                                          *
+ ************************************************************
+ */
     targetc = Occupied(enemy) | EnPassantTarget(ply);
     targetc = targetc & target;
     if (Pawns(enemy) & target & ((side) ? EnPassantTarget(ply) >> 8 :
             EnPassantTarget(ply) << 8))
       targetc = targetc | EnPassantTarget(ply);
     } else {
       pcapturesl = (Pawns(black) & mask_left_edge) >> 9 & targetc;
       pcapturesr = (Pawns(black) & mask_right_edge) >> 7 & targetc;
+    }
     for (; pcapturesl; Clear(to, pcapturesl)) {
-      to = Advanced(side, pcapturesl);
+      to = MostAdvanced(side, pcapturesl);
       if (!PinnedOnKing(tree, side, to + capleft[side])) {
         common = (to + capleft[side]) | (to << 6) | (pawn << 12);
         if ((side) ? to < 56 : to > 7)
           *move++ = common | (((PcOnSq(to)) ? Abs(PcOnSq(to)) : pawn) << 15);
         else {
           *move++ = common | Abs(PcOnSq(to)) << 15 | knight << 18;
+        }
+      }
+    }
     for (; pcapturesr; Clear(to, pcapturesr)) {
-      to = Advanced(side, pcapturesr);
+      to = MostAdvanced(side, pcapturesr);
       if (!PinnedOnKing(tree, side, to + capright[side])) {
         common = (to + capright[side]) | (to << 6) | (pawn << 12);
         if ((side) ? to < 56 : to > 7)
           *move++ = common | (((PcOnSq(to)) ? Abs(PcOnSq(to)) : pawn) << 15);
         else {
+    }
+  }
   return move;
+}
-/* modified 02/22/14 */
+/* modified 12/31/15 */
 /*
  *******************************************************************************
  *                                                                             *
  *   GenerateNoncaptures() is used to generate non-capture moves from the      *
  *   current position.                                                         *
  *                                                                             *
  *   Once the valid destination squares are known, we have to locate a         *
- *   friendly piece to get a attacks_to[] entry.  We then produce the moves    *
- *   for this piece by using the source square as [from] and enumerating each  *
- *   square it attacks into [to].                                              *
+ *   friendly piece to compute the squares it attacks.                         *
  *                                                                             *
  *   Pawns are handled differently.  Regular pawn moves are produced by        *
  *   shifting the pawn bitmap 8 bits "forward" and anding this with the        *
- *   complement of the occupied squares bitmap  double advances are then       *
+ *   complement of the occupied squares bitmap double advances are then        *
  *   produced by anding the pawn bitmap with a mask containing 1's on the      *
  *   second rank, shifting this 16 bits "forward" and then anding this with    *
  *   the complement of the occupied squares bitmap as before.  If [to] reaches *
- *   the 8th rank, we produce a set of four moves, promoting the pawn to       *
+ *   the 8th rank, we produce a set of three moves, promoting the pawn to      *
+ *   knight, bishop and rook (queen promotions were generated earlier by       *
- *   knight, bishop, rook and queen.                                           *
+ *   GenerateCaptures()).                                                      *
  *                                                                             *
  *******************************************************************************
  */
-int *GenerateNoncaptures(TREE * RESTRICT tree, int ply, int side, int *move) {
+unsigned *GenerateNoncaptures(TREE * RESTRICT tree, int ply, int side,
+    unsigned *move) {
   uint64_t target, piecebd, moves;
   uint64_t padvances1, padvances2, pcapturesl, pcapturesr;
   int from, to, temp, common, enemy = Flip(side);
 /*
  ************************************************************
  *                                                          *
- *  First, produce castling moves if it is legal.           *
+ *  First, produce castling moves when they are legal.      *
  *                                                          *
  ************************************************************
  */
   if (Castle(ply, side) > 0) {
     if (Castle(ply, side) & 1 && !(OccupiedSquares & OO[side])
  *  for each knight.                                        *
  *                                                          *
  ************************************************************
  */
   for (piecebd = Knights(side); piecebd; Clear(from, piecebd)) {
-    from = Advanced(side, piecebd);
+    from = MostAdvanced(side, piecebd);
     moves = knight_attacks[from] & target;
     temp = from + (knight << 12);
     Extract(side, move, moves, temp);
+  }
 /*
  ************************************************************
  *                                                          *
- *  We produce bishop moves by locating the most advanced   *
+ *  We produce sliding piece moves by locating each piece   *
+ *  type in turn.  We then start with the most advanced     *
- *  bishop and then using that square in a magic multiply   *
+ *  piece and generate moves from that square.  This uses   *
- *  move generation to quickly identify all the squares a   *
+ *  "magic move generation" to produce the destination      *
- *  bishop can reach.  We repeat for each bishop.           *
+ *  squares.                                                *
  *                                                          *
  ************************************************************
  */
   for (piecebd = Bishops(side); piecebd; Clear(from, piecebd)) {
-    from = Advanced(side, piecebd);
+    from = MostAdvanced(side, piecebd);
     moves = BishopAttacks(from, OccupiedSquares) & target;
     temp = from + (bishop << 12);
     Extract(side, move, moves, temp);
+  }
-/*
- ************************************************************
- *                                                          *
- *  We produce rook moves by locating the most advanced     *
- *  rook and then using that square in a magic multiply     *
- *  move generation to quickly identify all the squares     *
- *  rook can reach.  We repeat for each rook.               *
- *                                                          *
- ************************************************************
- */
   for (piecebd = Rooks(side); piecebd; Clear(from, piecebd)) {
-    from = Advanced(side, piecebd);
+    from = MostAdvanced(side, piecebd);
     moves = RookAttacks(from, OccupiedSquares) & target;
     temp = from + (rook << 12);
     Extract(side, move, moves, temp);
+  }
-/*
- ************************************************************
- *                                                          *
- *  We produce queen moves by locating the most advanced    *
- *  queen and then using that square in a magic multiply    *
- *  move generation to quickly identify all the squares a   *
- *  queen can reach.  We repeat for each queen.             *
- *                                                          *
- ************************************************************
- */
   for (piecebd = Queens(side); piecebd; Clear(from, piecebd)) {
-    from = Advanced(side, piecebd);
+    from = MostAdvanced(side, piecebd);
     moves = QueenAttacks(from, OccupiedSquares) & target;
     temp = from + (queen << 12);
     Extract(side, move, moves, temp);
+  }
 /*
  *  four sets of potential moves.                           *
  *                                                          *
  ************************************************************
  */
   for (; padvances2; Clear(to, padvances2)) {
-    to = Advanced(side, padvances2);
+    to = MostAdvanced(side, padvances2);
     *move++ = (to + pawnadv2[side]) | (to << 6) | (pawn << 12);
+  }
   for (; padvances1; Clear(to, padvances1)) {
-    to = Advanced(side, padvances1);
+    to = MostAdvanced(side, padvances1);
     common = (to + pawnadv1[side]) | (to << 6) | (pawn << 12);
     if ((side) ? to < 56 : to > 7)
       *move++ = common;
     else {
       *move++ = common | (rook << 18);
+    }
+  }
 /*
  ************************************************************
  *                                                          *
- *  Generate the rest of the capture/promotions here since  *
+ *  Generate the rest of the promotions here since          *
- *  GenerateCaptures() only generates captures that are     *
+ *  GenerateCaptures() only generated captures or           *
  *  promotions to a queen.                                  *
  *                                                          *
  ************************************************************
  */
-  target = Occupied(enemy) & rank_mask[RANK1 + side * 7];
+  target = Occupied(enemy) & rank_mask[rank8[side]];
   pcapturesl =
       ((side) ? (Pawns(white) & mask_left_edge) << 7 : (Pawns(black) &
           mask_left_edge) >> 9) & target;
   for (; pcapturesl; Clear(to, pcapturesl)) {
-    to = Advanced(side, pcapturesl);
+    to = MostAdvanced(side, pcapturesl);
     common = (to + capleft[side]) | (to << 6) | (pawn << 12);
     *move++ = common | (Abs(PcOnSq(to)) << 15) | (rook << 18);
     *move++ = common | (Abs(PcOnSq(to)) << 15) | (bishop << 18);
     *move++ = common | (Abs(PcOnSq(to)) << 15) | (knight << 18);
+  }
   pcapturesr =
       ((side) ? (Pawns(white) & mask_right_edge) << 9 : (Pawns(black) &
           mask_right_edge) >> 7) & target;
   for (; pcapturesr; Clear(to, pcapturesr)) {
-    to = Advanced(side, pcapturesr);
+    to = MostAdvanced(side, pcapturesr);
     common = (to + capright[side]) | (to << 6) | (pawn << 12);
     *move++ = common | (Abs(PcOnSq(to)) << 15) | (rook << 18);
     *move++ = common | (Abs(PcOnSq(to)) << 15) | (bishop << 18);
     *move++ = common | (Abs(PcOnSq(to)) << 15) | (knight << 18);
+  }
   return move;
+}
-/* modified 02/22/14 */
+/* modified 12/31/15 */
 /*
  *******************************************************************************
  *                                                                             *
  *   PinnedOnKing() is used to determine if the piece on <square> is pinned    *
  *   against the king, so that it's illegal to move it.  This is used to cull  *
  *   produced.                                                                 *
  *                                                                             *
  *******************************************************************************
  */
 int PinnedOnKing(TREE * RESTRICT tree, int side, int square) {
-  int ray;
-  int enemy = Flip(side);
+  int ray, enemy = Flip(side);
 /*
  ************************************************************
  *                                                          *
  *  First, determine if the piece being moved is on the     *

Subversion Repositories Games.Chess Giants

Games.Chess Giants//engine-crafty/movgen.c – Rev 33 → 108