movgen.c

#include "chess.h"
#include "data.h"
/* modified 12/31/15 */
/*
 *******************************************************************************
 *                                                                             *
 *   GenerateCaptures() is used to generate capture and pawn promotion moves   *
 *   from the current position.                                                *
 *                                                                             *
 *   The destination square set is the set of squares occupied by opponent     *
 *   pieces, plus the set of squares on the 8th rank that pawns can advance to *
 *   and promote.                                                              *
 *                                                                             *
 *******************************************************************************
 */
unsigned *GenerateCaptures(TREE * RESTRICT tree, int ply, int side,
    unsigned *move) {
  uint64_t target, piecebd, moves, promotions, pcapturesl, pcapturesr;
  int from, to, temp, common, enemy = Flip(side);

/*
 ************************************************************
 *                                                          *
 *  We produce knight moves by locating the most advanced   *
 *  knight and then using that <from> square as an index    *
 *  into the precomputed knight_attacks data.  We repeat    *
 *  for each knight.                                        *
 *                                                          *
 ************************************************************
 */
  for (piecebd = Knights(side); piecebd; Clear(from, piecebd)) {
    from = MostAdvanced(side, piecebd);
    moves = knight_attacks[from] & Occupied(enemy);
    temp = from + (knight << 12);
    Extract(side, move, moves, temp);
  }
/*
 ************************************************************
 *                                                          *
 *  We produce sliding piece moves by locating each piece   *
 *  type in turn.  We then start with the most advanced     *
 *  piece and generate moves from that square.  This uses   *
 *  "magic move generation" to produce the destination      *
 *  squares.                                                *
 *                                                          *
 ************************************************************
 */
  for (piecebd = Bishops(side); piecebd; Clear(from, piecebd)) {
    from = MostAdvanced(side, piecebd);
    moves = BishopAttacks(from, OccupiedSquares) & Occupied(enemy);
    temp = from + (bishop << 12);
    Extract(side, move, moves, temp);
  }
  for (piecebd = Rooks(side); piecebd; Clear(from, piecebd)) {
    from = MostAdvanced(side, piecebd);
    moves = RookAttacks(from, OccupiedSquares) & Occupied(enemy);
    temp = from + (rook << 12);
    Extract(side, move, moves, temp);
  }
  for (piecebd = Queens(side); piecebd; Clear(from, piecebd)) {
    from = MostAdvanced(side, piecebd);
    moves = QueenAttacks(from, OccupiedSquares) & Occupied(enemy);
    temp = from + (queen << 12);
    Extract(side, move, moves, temp);
  }
/*
 ************************************************************
 *                                                          *
 *  We produce king moves by locating the only king and     *
 *  then using that <from> square as an index into the      *
 *  precomputed king_attacks data.                          *
 *                                                          *
 ************************************************************
 */
  from = KingSQ(side);
  moves = king_attacks[from] & Occupied(enemy);
  temp = from + (king << 12);
  Extract(side, move, moves, temp);
/*
 ************************************************************
 *                                                          *
 *  Now, produce pawn moves.  This is done differently due  *
 *  to inconsistencies in the way a pawn moves when it      *
 *  captures as opposed to normal non-capturing moves.      *
 *  Another exception is capturing enpassant.  The first    *
 *  step is to generate all possible pawn promotions.  We   *
 *  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) ? 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 = 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 = 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 12/31/15 */
/*
 *******************************************************************************
 *                                                                             *
 *   GenerateChecks() is used to generate non-capture moves from the current   *
 *   position.                                                                 *
 *                                                                             *
 *   The first pass produces a bitmap that contains the squares a particular   *
 *   piece type would attack if sitting on the square the enemy king sits on.  *
 *   We then use each of these squares as a source and check to see if the     *
 *   same piece type attacks one of these common targets.  If so, we can move  *
 *   that piece to that square and it will directly attack the king.  We do    *
 *   this for pawns, knights, bishops, rooks and queens to produce the set of  *
 *   "direct checking moves."                                                  *
 *                                                                             *
 *   Then we generate discovered checks in two passes, once for diagonal       *
 *   attacks and once for rank/file attacks (we do it in two passes since a    *
 *   rook can't produce a discovered check along a rank or file since it moves *
 *   in that direction as well.  For diagonals, we first generate the bishop   *
 *   attacks from the enemy king square and mask them with the friendly piece  *
 *   occupied squares bitmap.  This gives us a set of up to 4 "blocking        *
 *   pieces" that could be preventing a check.  We then remove them via the    *
 *   "magic move generation" tricks, and see if we now reach friendly bishops  *
 *   or queens on those diagonals.  If we have a friendly blocker, and a       *
 *   friendly diagonal mover behind that blocker, then moving the blocker is   *
 *   a discovered check (and there could be double-checks included but we do   *
 *   not check for that since a single check is good enough).  We repeat this  *
 *   for the ranks/files and we are done.                                      *
 *                                                                             *
 *   For the present, this code does not produce discovered checks by the      *
 *   king since all king moves are not discovered checks because the king can  *
 *   move in the same direction as the piece it blocks and not uncover the     *
 *   attack.  This might be fixed at some point, but it is rare enough to not  *
 *   be an issue except in far endgames.                                       *
 *                                                                             *
 *******************************************************************************
 */
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 pretend that a piece of that type stands on    *
 *  the square of the king and we generate attacks from     *
 *  that square for that piece.  Now, if we can find any    *
 *  piece of that type that attacks one of those squares,   *
 *  then that piece move would deliver a direct check to    *
 *  the enemy king.  Easy, wasn't it?                       *
 *                                                          *
 ************************************************************
 */
  target = ~OccupiedSquares;
/*
 ************************************************************
 *                                                          *
 *  Knight direct checks.                                   *
 *                                                          *
 ************************************************************
 */
  temp_target = target & knight_attacks[KingSQ(enemy)];
  for (piecebd = Knights(side); piecebd; Clear(from, piecebd)) {
    from = MostAdvanced(side, piecebd);
    moves = knight_attacks[from] & temp_target;
    temp = from + (knight << 12);
    Extract(side, move, moves, temp);
  }
/*
 ************************************************************
 *                                                          *
 *  Sliding piece direct checks.                            *
 *                                                          *
 ************************************************************
 */
  temp_target = target & BishopAttacks(KingSQ(enemy), OccupiedSquares);
  for (piecebd = Bishops(side); piecebd; Clear(from, piecebd)) {
    from = MostAdvanced(side, piecebd);
    moves = BishopAttacks(from, OccupiedSquares) & temp_target;
    temp = from + (bishop << 12);
    Extract(side, move, moves, temp);
  }
  temp_target = target & RookAttacks(KingSQ(enemy), OccupiedSquares);
  for (piecebd = Rooks(side); piecebd; Clear(from, piecebd)) {
    from = MostAdvanced(side, piecebd);
    moves = RookAttacks(from, OccupiedSquares) & temp_target;
    temp = from + (rook << 12);
    Extract(side, move, moves, temp);
  }
  temp_target = target & QueenAttacks(KingSQ(enemy), OccupiedSquares);
  for (piecebd = Queens(side); piecebd; Clear(from, piecebd)) {
    from = MostAdvanced(side, piecebd);
    moves = QueenAttacks(from, OccupiedSquares) & temp_target;
    temp = from + (queen << 12);
    Extract(side, move, moves, temp);
  }
/*
 ************************************************************
 *                                                          *
 *   Pawn direct checks.                                    *
 *                                                          *
 ************************************************************
 */
  temp_target = target & pawn_attacks[enemy][KingSQ(enemy)];
  padvances1 = ((side) ? Pawns(white) << 8 : Pawns(black) >> 8) & temp_target;
  for (; padvances1; Clear(to, 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.       *
 *                                                          *
 *  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.                               *
 *                                                          *
 ************************************************************
 */
  blockers =
      BishopAttacks(KingSQ(enemy),
      OccupiedSquares) & (Rooks(side) | Knights(side) | Pawns(side));
  if (blockers) {
    checkers =
        BishopAttacks(KingSQ(enemy),
        OccupiedSquares & ~blockers) & (Bishops(side) | Queens(side));
    if (checkers) {
      if (plus7dir[KingSQ(enemy)] & blockers &&
          !(plus7dir[KingSQ(enemy)] & checkers))
        blockers &= ~plus7dir[KingSQ(enemy)];
      if (plus9dir[KingSQ(enemy)] & blockers &&
          !(plus9dir[KingSQ(enemy)] & checkers))
        blockers &= ~plus9dir[KingSQ(enemy)];
      if (minus7dir[KingSQ(enemy)] & blockers &&
          !(minus7dir[KingSQ(enemy)] & checkers))
        blockers &= ~minus7dir[KingSQ(enemy)];
      if (minus9dir[KingSQ(enemy)] & blockers &&
          !(minus9dir[KingSQ(enemy)] & checkers))
        blockers &= ~minus9dir[KingSQ(enemy)];
      target = ~OccupiedSquares;
/*
 ************************************************************
 *                                                          *
 *  Knight discovered checks.                               *
 *                                                          *
 ************************************************************
 */
      temp_target = target & ~knight_attacks[KingSQ(enemy)];
      for (piecebd = Knights(side) & blockers; piecebd; Clear(from, piecebd)) {
        from = MostAdvanced(side, piecebd);
        moves = knight_attacks[from] & temp_target;
        temp = from + (knight << 12);
        Extract(side, move, moves, temp);
      }
/*
 ************************************************************
 *                                                          *
 *  Rook discovered checks.                                 *
 *                                                          *
 ************************************************************
 */
      target = ~OccupiedSquares;
      temp_target = target & ~RookAttacks(KingSQ(enemy), OccupiedSquares);
      for (piecebd = Rooks(side) & blockers; piecebd; Clear(from, piecebd)) {
        from = MostAdvanced(side, piecebd);
        moves = RookAttacks(from, OccupiedSquares) & temp_target;
        temp = from + (rook << 12);
        Extract(side, move, moves, temp);
      }
/*
 ************************************************************
 *                                                          *
 *  Pawn discovered checks.                                 *
 *                                                          *
 ************************************************************
 */
      piecebd =
          Pawns(side) & blockers & ((side) ? ~OccupiedSquares >> 8 :
          ~OccupiedSquares << 8);
      for (; piecebd; Clear(from, piecebd)) {
        from = MostAdvanced(side, piecebd);
        to = from + pawnadv1[enemy];
        if ((side) ? to > 55 : to < 8)
          promote = queen;
        else
          promote = 0;
        *move++ = from | (to << 6) | (pawn << 12) | (promote << 18);
      }
    }
  }
/*
 ************************************************************
 *                                                          *
 *  Next, we look for rank/file discovered attacks.  Once   *
 *  we know which squares hold pieces that create a         *
 *  discovered check when they move, we generate them       *
 *  piece type by piece type.                               *
 *                                                          *
 ************************************************************
 */
  blockers =
      RookAttacks(KingSQ(enemy),
      OccupiedSquares) & (Bishops(side) | Knights(side) | (Pawns(side) &
          rank_mask[Rank(KingSQ(enemy))]));
  if (blockers) {
    checkers =
        RookAttacks(KingSQ(enemy),
        OccupiedSquares & ~blockers) & (Rooks(side) | Queens(side));
    if (checkers) {
      if (plus1dir[KingSQ(enemy)] & blockers &&
          !(plus1dir[KingSQ(enemy)] & checkers))
        blockers &= ~plus1dir[KingSQ(enemy)];
      if (plus8dir[KingSQ(enemy)] & blockers &&
          !(plus8dir[KingSQ(enemy)] & checkers))
        blockers &= ~plus8dir[KingSQ(enemy)];
      if (minus1dir[KingSQ(enemy)] & blockers &&
          !(minus1dir[KingSQ(enemy)] & checkers))
        blockers &= ~minus1dir[KingSQ(enemy)];
      if (minus8dir[KingSQ(enemy)] & blockers &&
          !(minus8dir[KingSQ(enemy)] & checkers))
        blockers &= ~minus8dir[KingSQ(enemy)];
      target = ~OccupiedSquares;
/*
 ************************************************************
 *                                                          *
 *  Knight discovered checks.                               *
 *                                                          *
 ************************************************************
 */
      temp_target = target & ~knight_attacks[KingSQ(enemy)];
      for (piecebd = Knights(side) & blockers; piecebd; Clear(from, piecebd)) {
        from = MostAdvanced(side, piecebd);
        moves = knight_attacks[from] & temp_target;
        temp = from + (knight << 12);
        Extract(side, move, moves, temp);
      }
/*
 ************************************************************
 *                                                          *
 *  Bishop discovered checks.                               *
 *                                                          *
 ************************************************************
 */
      target = ~OccupiedSquares;
      temp_target = target & ~BishopAttacks(KingSQ(enemy), OccupiedSquares);
      for (piecebd = Bishops(side) & blockers; piecebd; Clear(from, piecebd)) {
        from = MostAdvanced(side, piecebd);
        moves = BishopAttacks(from, OccupiedSquares) & temp_target;
        temp = from + (bishop << 12);
        Extract(side, move, moves, temp);
      }
/*
 ************************************************************
 *                                                          *
 *  Pawn discovered checks.                                 *
 *                                                          *
 ************************************************************
 */
      piecebd =
          Pawns(side) & blockers & ((side) ? ~OccupiedSquares >> 8 :
          ~OccupiedSquares << 8);
      for (; piecebd; Clear(from, piecebd)) {
        from = MostAdvanced(side, piecebd);
        to = from + pawnadv1[enemy];
        if ((side) ? to > 55 : to < 8)
          promote = queen;
        else
          promote = 0;
        *move++ = from | (to << 6) | (pawn << 12) | (promote << 18);
      }
    }
  }
  return move;
}

/* modified 12/31/15 */
/*
 *******************************************************************************
 *                                                                             *
 *   GenerateCheckEvasions() is used to generate moves when the king is in     *
 *   check.                                                                    *
 *                                                                             *
 *   Three types of check-evasion moves are generated:                         *
 *                                                                             *
 *   (1) Generate king moves to squares that are not attacked by the           *
 *   opponent's pieces.  This includes capture and non-capture moves.          *
 *                                                                             *
 *   (2) Generate interpositions along the rank/file that the checking attack  *
 *   is coming along (assuming (a) only one piece is checking the king, and    *
 *   (b) the checking piece is a sliding piece [bishop, rook, queen]).         *
 *                                                                             *
 *   (3) Generate capture moves, but only to the square(s) that are giving     *
 *   check.  Captures are a special case.  If there is one checking piece,     *
 *   then capturing it by any piece is tried.  If there are two pieces         *
 *   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.       *
 *                                                                             *
 *******************************************************************************
 */
unsigned *GenerateCheckEvasions(TREE * RESTRICT tree, int ply, int side,
    unsigned *move) {
  uint64_t target, targetc, targetp, piecebd, moves, empty, checksqs;
  uint64_t padvances1, padvances2, pcapturesl, pcapturesr, padvances1_all;
  int from, to, temp, common, enemy = Flip(side), king_square, checkers;
  int checking_square, check_direction1 = 0, check_direction2 = 0;

/*
 ************************************************************
 *                                                          *
 *  First, determine how many pieces are attacking the king *
 *  and where they are, so we can figure out how to legally *
 *  get out of check.                                       *
 *                                                          *
 ************************************************************
 */
  king_square = KingSQ(side);
  checksqs = AttacksTo(tree, king_square) & Occupied(enemy);
  checkers = PopCnt(checksqs);
  if (checkers == 1) {
    checking_square = LSB(checksqs);
    if (PcOnSq(checking_square) != pieces[enemy][pawn])
      check_direction1 = directions[checking_square][king_square];
    target = InterposeSquares(king_square, checking_square);
    target |= checksqs;
    target |= Kings(enemy);
  } else {
    target = Kings(enemy);
    checking_square = LSB(checksqs);
    if (PcOnSq(checking_square) != pieces[enemy][pawn])
      check_direction1 = directions[checking_square][king_square];
    checking_square = MSB(checksqs);
    if (PcOnSq(checking_square) != pieces[enemy][pawn])
      check_direction2 = directions[checking_square][king_square];
  }
/*
 ************************************************************
 *                                                          *
 *  The next step is to produce the set of valid            *
 *  destination squares.  For king moves, this is simply    *
 *  the set of squares that are not attacked by enemy       *
 *  pieces (if there are any such squares.)                 *
 *                                                          *
 *  Then, if the checking piece is not a knight, we need    *
 *  to know the checking direction so that we can either    *
 *  move the king off of that ray, or else block that ray.  *
 *                                                          *
 *  We produce king moves by locating the only king and     *
 *  then using that <from> square as an index into the      *
 *  precomputed king_attacks data.                          *
 *                                                          *
 ************************************************************
 */
  from = king_square;
  temp = from + (king << 12);
  for (moves = king_attacks[from] & ~Occupied(side); moves; Clear(to, 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);
  }
/*
 ************************************************************
 *                                                          *
 *  We produce knight moves by locating the most advanced   *
 *  knight and then using that <from> square as an index    *
 *  into the precomputed knight_attacks data.  We repeat    *
 *  for each knight.                                        *
 *                                                          *
 ************************************************************
 */
  if (checkers == 1) {
    for (piecebd = Knights(side); piecebd; Clear(from, 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 sliding piece moves by locating each piece   *
 *  type in turn.  We then start with the most advanced     *
 *  piece and generate moves from that square.  This uses   *
 *  "magic move generation" to produce the destination      *
 *  squares.                                                *
 *                                                          *
 ************************************************************
 */
    for (piecebd = Bishops(side); piecebd; Clear(from, piecebd)) {
      from = MostAdvanced(side, piecebd);
      if (!PinnedOnKing(tree, side, from)) {
        moves = BishopAttacks(from, OccupiedSquares) & target;
        temp = from + (bishop << 12);
        Extract(side, move, moves, temp);
      }
    }
    for (piecebd = Rooks(side); piecebd; Clear(from, piecebd)) {
      from = MostAdvanced(side, piecebd);
      if (!PinnedOnKing(tree, side, from)) {
        moves = RookAttacks(from, OccupiedSquares) & target;
        temp = from + (rook << 12);
        Extract(side, move, moves, temp);
      }
    }
    for (piecebd = Queens(side); piecebd; Clear(from, piecebd)) {
      from = MostAdvanced(side, piecebd);
      if (!PinnedOnKing(tree, side, from)) {
        moves = QueenAttacks(from, OccupiedSquares) & target;
        temp = from + (queen << 12);
        Extract(side, move, moves, temp);
      }
    }
/*
 ************************************************************
 *                                                          *
 *  Now, produce pawn moves.  This is done differently due  *
 *  to inconsistencies in the way a pawn moves when it      *
 *  captures as opposed to normal non-capturing moves.      *
 *  Another exception is capturing enpassant.  The first    *
 *  step is to generate all possible pawn moves.  We do     *
 *  this in 2 operations:  (1) shift the pawns forward one  *
 *  rank then AND with empty squares;  (2) shift the pawns  *
 *  forward two ranks and then AND with empty squares.      *
 *                                                          *
 ************************************************************
 */
    empty = ~OccupiedSquares;
    targetp = target & empty;
    if (side) {
      padvances1 = Pawns(white) << 8 & targetp;
      padvances1_all = Pawns(white) << 8 & empty;
      padvances2 = ((padvances1_all & ((uint64_t) 255 << 16)) << 8) & targetp;
    } else {
      padvances1 = Pawns(black) >> 8 & targetp;
      padvances1_all = Pawns(black) >> 8 & empty;
      padvances2 = ((padvances1_all & ((uint64_t) 255 << 40)) >> 8) & targetp;
    }
/*
 ************************************************************
 *                                                          *
 *  Now that we got 'em, we simply enumerate the to squares *
 *  as before, but in four steps since we have four sets of *
 *  potential moves.                                        *
 *                                                          *
 ************************************************************
 */
    for (; padvances2; Clear(to, 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 = 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);
    if (side) {
      pcapturesl = (Pawns(white) & mask_left_edge) << 7 & targetc;
      pcapturesr = (Pawns(white) & mask_right_edge) << 9 & targetc;
    } else {
      pcapturesl = (Pawns(black) & mask_left_edge) >> 9 & targetc;
      pcapturesr = (Pawns(black) & mask_right_edge) >> 7 & targetc;
    }
    for (; pcapturesl; Clear(to, 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 | queen << 18;
          *move++ = common | Abs(PcOnSq(to)) << 15 | knight << 18;
        }
      }
    }
    for (; pcapturesr; Clear(to, 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 {
          *move++ = common | Abs(PcOnSq(to)) << 15 | queen << 18;
          *move++ = common | Abs(PcOnSq(to)) << 15 | knight << 18;
        }
      }
    }
  }
  return move;
}

/* 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 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        *
 *   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 three moves, promoting the pawn to      *
 *   knight, bishop and rook (queen promotions were generated earlier by       *
 *   GenerateCaptures()).                                                      *
 *                                                                             *
 *******************************************************************************
 */
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 when they are legal.      *
 *                                                          *
 ************************************************************
 */
  if (Castle(ply, side) > 0) {
    if (Castle(ply, side) & 1 && !(OccupiedSquares & OO[side])
        && !Attacks(tree, enemy, OOsqs[side][0])
        && !Attacks(tree, enemy, OOsqs[side][1])
        && !Attacks(tree, enemy, OOsqs[side][2])) {
      *move++ = (king << 12) + (OOto[side] << 6) + OOfrom[side];
    }
    if (Castle(ply, side) & 2 && !(OccupiedSquares & OOO[side])
        && !Attacks(tree, enemy, OOOsqs[side][0])
        && !Attacks(tree, enemy, OOOsqs[side][1])
        && !Attacks(tree, enemy, OOOsqs[side][2])) {
      *move++ = (king << 12) + (OOOto[side] << 6) + OOfrom[side];
    }
  }
  target = ~OccupiedSquares;
/*
 ************************************************************
 *                                                          *
 *  We produce knight moves by locating the most advanced   *
 *  knight and then using that <from> square as an index    *
 *  into the precomputed knight_attacks data.  We repeat    *
 *  for each knight.                                        *
 *                                                          *
 ************************************************************
 */
  for (piecebd = Knights(side); piecebd; Clear(from, piecebd)) {
    from = MostAdvanced(side, piecebd);
    moves = knight_attacks[from] & target;
    temp = from + (knight << 12);
    Extract(side, move, moves, temp);
  }
/*
 ************************************************************
 *                                                          *
 *  We produce sliding piece moves by locating each piece   *
 *  type in turn.  We then start with the most advanced     *
 *  piece and generate moves from that square.  This uses   *
 *  "magic move generation" to produce the destination      *
 *  squares.                                                *
 *                                                          *
 ************************************************************
 */
  for (piecebd = Bishops(side); piecebd; Clear(from, piecebd)) {
    from = MostAdvanced(side, piecebd);
    moves = BishopAttacks(from, OccupiedSquares) & target;
    temp = from + (bishop << 12);
    Extract(side, move, moves, temp);
  }
  for (piecebd = Rooks(side); piecebd; Clear(from, piecebd)) {
    from = MostAdvanced(side, piecebd);
    moves = RookAttacks(from, OccupiedSquares) & target;
    temp = from + (rook << 12);
    Extract(side, move, moves, temp);
  }
  for (piecebd = Queens(side); piecebd; Clear(from, piecebd)) {
    from = MostAdvanced(side, piecebd);
    moves = QueenAttacks(from, OccupiedSquares) & target;
    temp = from + (queen << 12);
    Extract(side, move, moves, temp);
  }
/*
 ************************************************************
 *                                                          *
 *  We produce king moves by locating the only king and     *
 *  then using that <from> square as an index into the      *
 *  precomputed king_attacks data.                          *
 *                                                          *
 ************************************************************
 */
  from = KingSQ(side);
  moves = king_attacks[from] & target;
  temp = from + (king << 12);
  Extract(side, move, moves, temp);
/*
 ************************************************************
 *                                                          *
 *  Now, produce pawn moves.  This is done differently due  *
 *  to inconsistencies in the way a pawn moves when it      *
 *  captures as opposed to normal non-capturing moves.      *
 *  First we generate all possible pawn moves.  We do this  *
 *  in 4 operations:  (1) shift the pawns forward one rank  *
 *  then and with empty squares;  (2) shift the pawns       *
 *  forward two ranks and then and with empty squares;      *
 *  (3) remove the a-pawn(s) then shift the pawns           *
 *  diagonally left then and with enemy occupied squares;   *
 *  (4) remove the h-pawn(s) then shift the pawns           *
 *  diagonally right then and with enemy occupied squares.  *
 *  note that the only captures produced are under-         *
 *  promotions, because the rest were done in GenCap.       *
 *                                                          *
 ************************************************************
 */
  padvances1 = ((side) ? Pawns(side) << 8 : Pawns(side) >> 8) & target;
  padvances2 =
      ((side) ? (padvances1 & mask_advance_2_w) << 8 : (padvances1 &
          mask_advance_2_b) >> 8) & target;
/*
 ************************************************************
 *                                                          *
 *  Now that we got 'em, we simply enumerate the to         *
 *  squares as before, but in four steps since we have      *
 *  four sets of potential moves.                           *
 *                                                          *
 ************************************************************
 */
  for (; padvances2; Clear(to, padvances2)) {
    to = MostAdvanced(side, padvances2);
    *move++ = (to + pawnadv2[side]) | (to << 6) | (pawn << 12);
  }
  for (; padvances1; Clear(to, 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);
      *move++ = common | (bishop << 18);
      *move++ = common | (knight << 18);
    }
  }
/*
 ************************************************************
 *                                                          *
 *  Generate the rest of the promotions here since          *
 *  GenerateCaptures() only generated captures or           *
 *  promotions to a queen.                                  *
 *                                                          *
 ************************************************************
 */
  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 = 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 = 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 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  *
 *   potential moves by GenerateCheckEvasions() so that illegal moves are not  *
 *   produced.                                                                 *
 *                                                                             *
 *******************************************************************************
 */
int PinnedOnKing(TREE * RESTRICT tree, int side, int square) {
  int ray, enemy = Flip(side);

/*
 ************************************************************
 *                                                          *
 *  First, determine if the piece being moved is on the     *
 *  same diagonal, rank or file as the king.  If not, then  *
 *  it can't be pinned and we return (0).                   *
 *                                                          *
 ************************************************************
 */
  ray = directions[square][KingSQ(side)];
  if (!ray)
    return 0;
/*
 ************************************************************
 *                                                          *
 *  If they are on the same ray, then determine if the king *
 *  blocks a bishop attack in one direction from this       *
 *  square and a bishop or queen blocks a bishop attack on  *
 *  the same diagonal in the opposite direction (or the     *
 *  same rank/file for rook/queen.)                         *
 *                                                          *
 ************************************************************
 */
  switch (Abs(ray)) {
    case 1:
      if (RankAttacks(square) & Kings(side))
        return (RankAttacks(square) & (Rooks(enemy) | Queens(enemy))) != 0;
      else
        return 0;
    case 7:
      if (Diagh1Attacks(square) & Kings(side))
        return (Diagh1Attacks(square) & (Bishops(enemy) | Queens(enemy))) !=
            0;
      else
        return 0;
    case 8:
      if (FileAttacks(square) & Kings(side))
        return (FileAttacks(square) & (Rooks(enemy) | Queens(enemy))) != 0;
      else
        return 0;
    case 9:
      if (Diaga1Attacks(square) & Kings(side))
        return (Diaga1Attacks(square) & (Bishops(enemy) | Queens(enemy))) !=
            0;
      else
        return 0;
  }
  return 0;
}