Subversion Repositories Games.Chess Giants

#include "chess.h"

#include "data.h"

/* last modified 05/16/14 */

/*

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

 *                                                                             *

 *   SEE() 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 SEE(TREE * RESTRICT tree, int wtm, int move) {

  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, see_list[32];

  int source = From(move), 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>.                                   *

 *                                                          *

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

 */

  wtm = Flip(wtm);

  see_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 see 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(wtm, piece) & attacks))

        break;

    if (piece > king)

      break;

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

    if (piece & 1)

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

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

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

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

    attacked_piece = pcval[piece];

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

      break;

    wtm = Flip(wtm);

  }

/*

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

 *                                                          *

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

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

 *  will stop.                                              *

 *                                                          *

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

 */

  while (--nc)

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

  return see_list[0];

}

/* last modified 05/16/14 */

/*

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

 *                                                                             *

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

 *   safe.  It is similar to SEE() 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 SEEO(TREE * RESTRICT tree, int wtm, int move) {

  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, see_list[32], 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.                *

 *                                                          *

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

 */

  wtm = Flip(wtm);

  see_list[0] = attacked_piece;

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

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

      break;

  if (piece > king)

    return 0;

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

  if (piece & 1)

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

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

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

  attacked_piece = pcval[piece];

  wtm = Flip(wtm);

/*

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

 *                                                          *

 *  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 see 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(wtm, piece) & attacks))

        break;

    if (piece > king)

      break;

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

    if (piece & 1)

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

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

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

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

    attacked_piece = pcval[piece];

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

      break;

    wtm = Flip(wtm);

  }

/*

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

 *                                                          *

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

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

 *  will stop.                                              *

 *                                                          *

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

 */

  while (--nc)

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

  return see_list[0];

}