Subversion Repositories Games.Chess Giants

#include "chess.h"

#include "data.h"

/* last modified 05/16/14 */

/*

 *******************************************************************************

 *                                                                             *

 *   Swap() is used to analyze capture moves to see whether or not they appear *

 *   to be profitable.  The basic algorithm is extremely fast since it uses the*

 *   bitmaps to determine which squares are attacking the [target] square.     *

 *                                                                             *

 *   The algorithm is quite simple.  Using the attack bitmaps, we enumerate all*

 *   the pieces that are attacking [target] for either side.  Then we simply   *

 *   use the lowest piece (value) for the correct side to capture on [target]. *

 *   we continually "flip" sides taking the lowest piece each time.            *

 *                                                                             *

 *   As a piece is used, if it is a sliding piece (pawn, bishop, rook or queen)*

 *   we remove the piece, then generate moves of bishop/queen or rook/queen    *

 *   and then add those in to the attackers, removing any attacks that have    *

 *   already been used.                                                        *

 *                                                                             *

 *******************************************************************************

 */

int Swap(TREE * RESTRICT tree, int move, int side) {

  uint64_t attacks, temp = 0, toccupied = OccupiedSquares;

  uint64_t bsliders =

      Bishops(white) | Bishops(black) | Queens(white) | Queens(black);

  uint64_t rsliders =

      Rooks(white) | Rooks(black) | Queens(white) | Queens(black);

  int attacked_piece, piece, nc = 1, swap_list[32];

  int source = From(move);

  int target = To(move);

/*

 ************************************************************

 *                                                          *

 *  Determine which squares attack <target> for each side.  *

 *  initialize by placing the piece on <target> first in    *

 *  the list as it is being captured to start things off.   *

 *                                                          *

 ************************************************************

 */

  attacks = AttacksTo(tree, target);

  attacked_piece = pcval[Captured(move)];

/*

 ************************************************************

 *                                                          *

 *  The first piece to capture on <target> is the piece     *

 *  standing on <source>.                                   *

 *                                                          *

 ************************************************************

 */

  side = Flip(side);

  swap_list[0] = attacked_piece;

  piece = Piece(move);

  attacked_piece = pcval[piece];

  Clear(source, toccupied);

  if (piece & 1)

    attacks |= BishopAttacks(target, toccupied) & bsliders;

  if (piece != king && (piece == pawn || piece & 4))

    attacks |= RookAttacks(target, toccupied) & rsliders;

/*

 ************************************************************

 *                                                          *

 *  Now pick out the least valuable piece for the correct   *

 *  side that is bearing on <target>.  As we find one, we   *

 *  update the attacks (if this is a sliding piece) to get  *

 *  the attacks for any sliding piece that is lined up      *

 *  behind the attacker we are removing.                    *

 *                                                          *

 *  Once we know there is a piece attacking the last        *

 *  capturing piece, add it to the swap list and repeat     *

 *  until one side has no more captures.                    *

 *                                                          *

 ************************************************************

 */

  for (attacks &= toccupied; attacks; attacks &= toccupied) {

    for (piece = pawn; piece <= king; piece++)

      if ((temp = Pieces(side, piece) & attacks))

        break;

    if (piece > king)

      break;

    toccupied ^= (temp & (0-temp)); // Pierre-Marie Baty -- fixed signedness warning

    if (piece & 1)

      attacks |= BishopAttacks(target, toccupied) & bsliders;

    if (piece != king && piece & 4)

      attacks |= RookAttacks(target, toccupied) & rsliders;

    swap_list[nc] = -swap_list[nc - 1] + attacked_piece;

    attacked_piece = pcval[piece];

    if (swap_list[nc++] - attacked_piece > 0)

      break;

    side = Flip(side);

  }

/*

 ************************************************************

 *                                                          *

 *  Starting at the end of the sequence of values, use a    *

 *  "minimax" like procedure to decide where the captures   *

 *  will stop.                                              *

 *                                                          *

 ************************************************************

 */

  while (--nc)

    swap_list[nc - 1] = -Max(-swap_list[nc - 1], swap_list[nc]);

  return swap_list[0];

}

/* last modified 05/16/14 */

/*

 *******************************************************************************

 *                                                                             *

 *   SwapO() is used to analyze a move already made to see if it appears to be *

 *   safe.  It is similar to Swap() except that the move has already been made *

 *   and we are checking to see whether the opponent can gain material by      *

 *   capturing the piece just moved.                                           *

 *                                                                             *

 *******************************************************************************

 */

int SwapO(TREE * RESTRICT tree, int move, int side) {

  uint64_t attacks, temp = 0, toccupied = OccupiedSquares;

  uint64_t bsliders =

      Bishops(white) | Bishops(black) | Queens(white) | Queens(black);

  uint64_t rsliders =

      Rooks(white) | Rooks(black) | Queens(white) | Queens(black);

  int attacked_piece, piece, nc = 1, swap_list[32];

  int target = To(move);

/*

 ************************************************************

 *                                                          *

 *  Determine which squares attack <target> for each side.  *

 *  initialize by placing the piece on <target> first in    *

 *  the list as it is being captured to start things off.   *

 *                                                          *

 ************************************************************

 */

  attacks = AttacksTo(tree, target);

  attacked_piece = pcval[Piece(move)];

/*

 ************************************************************

 *                                                          *

 *  The first piece to capture on <target> is the piece     *

 *  standing on that square.  We have to find out the least *

 *  valuable attacker for that square first.                *

 *                                                          *

 ************************************************************

 */

  side = Flip(side);

  swap_list[0] = attacked_piece;

  for (piece = pawn; piece <= king; piece++)

    if ((temp = Pieces(side, piece) & attacks))

      break;

  if (piece > king)

    return 0;

  toccupied ^= (temp & (0-temp)); // Pierre-Marie Baty -- fixed signedness warning

  if (piece & 1)

    attacks |= BishopAttacks(target, toccupied) & bsliders;

  if (piece != king && piece & 4)

    attacks |= RookAttacks(target, toccupied) & rsliders;

  attacked_piece = pcval[piece];

  side = Flip(side);

/*

 ************************************************************

 *                                                          *

 *  Now pick out the least valuable piece for the correct   *

 *  side that is bearing on <target>.  As we find one, we   *

 *  update the attacks (if this is a sliding piece) to get  *

 *  the attacks for any sliding piece that is lined up      *

 *  behind the attacker we are removing.                    *

 *                                                          *

 *  Once we know there is a piece attacking the last        *

 *  capturing piece, add it to the swap list and repeat     *

 *  until one side has no more captures.                    *

 *                                                          *

 ************************************************************

 */

  for (attacks &= toccupied; attacks; attacks &= toccupied) {

    for (piece = pawn; piece <= king; piece++)

      if ((temp = Pieces(side, piece) & attacks))

        break;

    if (piece > king)

      break;

    toccupied ^= (temp & (0-temp)); // Pierre-Marie Baty -- fixed signedness warning

    if (piece & 1)

      attacks |= BishopAttacks(target, toccupied) & bsliders;

    if (piece != king && piece & 4)

      attacks |= RookAttacks(target, toccupied) & rsliders;

    swap_list[nc] = -swap_list[nc - 1] + attacked_piece;

    attacked_piece = pcval[piece];

    if (swap_list[nc++] - attacked_piece > 0)

      break;

    side = Flip(side);

  }

/*

 ************************************************************

 *                                                          *

 *  Starting at the end of the sequence of values, use a    *

 *  "minimax" like procedure to decide where the captures   *

 *  will stop.                                              *

 *                                                          *

 ************************************************************

 */

  while (--nc)

    swap_list[nc - 1] = -Max(-swap_list[nc - 1], swap_list[nc]);

  return swap_list[0];

}