Subversion Repositories Games.Chess Giants

#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)) {