Subversion Repositories Games.Chess Giants

#include "chess.h"

#include "data.h"

/* last modified 04/29/15 */

/*

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

 *                                                                             *

 *   Repeat() is used to detect a draw by repetition.  The repetition list is  *

 *   a simple 1d array that contains the Zobrist signatures for each position  *

 *   reached in the game since the last irreversable moves at the root.  New   *

 *   positions are only added to this list here in Repeat().                   *

 *                                                                             *

 *   Repeat() scans the list to determine if this position has occurred at     *

 *   once previously (two-fold repetition.)  If so, this will be treated as a  *

 *   draw by Search()/Quiesce().                                               *

 *                                                                             *

 *   Repeat() also handles 50-move draws.  The position[] structure contains   *

 *   the count of moves since the last capture or pawn push.  When this value  *

 *   reaches 100 (plies, which is 50 moves) the score is set to DRAW.          *

 *                                                                             *

 *   Repeat() has one tricky issue.  MakeMoveRoot() has to insert moves into   *

 *   the repetition list so that things will work well.  We end up with the    *

 *   list having entries from 0 through "rep_index" where the last entry is    *

 *   the entry stored after the last actual move in the game.  Search() will   *

 *   call Repeat() at ply=1, which stores the SAME position at position        *

 *   rep_index + 1.  That gets the list out of sync.  To solve this, Iterate() *

 *   decrements rep_index immediately prior to calling Search(), and it then   *

 *   increments it immediately after Search() returns.  This causes Search()   *

 *   to overwrite the entry with the same value for ply=1, but now the list is *

 *   in a sane state for the rest of the search.  Do NOT remove those to lines *

 *   in Iterate() or repetition detection will be broken.                      *

 *                                                                             *

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

 */

int Repeat(TREE * RESTRICT tree, int ply) {

  int where, count;

/*

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

 *                                                          *

 *  If the 50-move rule has been reached, then adjust the   *

 *  score to reflect the impending draw.  If we have not    *

 *  made 2 moves for each side (or more) since the last     *

 *  irreversible move, there is no way to repeat a prior    *

 *  position.                                               *

 *                                                          *

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

 */

  tree->rep_list[rep_index + ply] = HashKey;

  if (Reversible(ply) < 4)

    return 0;

  if (Reversible(ply) > 99)

    return 2;

/*

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

 *                                                          *

 *  Now we scan the right part of the repetition list,      *

 *  which is to search backward from the entry for 2 plies  *

 *  back (no point in checking current position, we KNOW    *

 *  that is a match but it is not a repetition, it is just  *

 *  the current position's entry which we don't want to     *

 *  check).  We can use the reversible move counter as a    *

 *  limit since there is no point in scanning the list back *

 *  beyond the last capture/pawn move since there can not   *

 *  possibly be a repeat beyond that point.                 *

 *                                                          *

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

 */

  count = Reversible(ply) / 2 - 1;

  for (where = rep_index + ply - 4; count; where -= 2, count--) {

    if (HashKey == tree->rep_list[where])

      return 1;

  }

  return 0;

}

/* last modified 05/08/14 */

/*

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

 *                                                                             *

 *   Repeat3x() is used to detect a real draw by repetition.  This routine is  *

 *   only called from Main() and simply scans the complete list searching for  *

 *   exactly three repetitions (two additional repetitions of the current      *

 *   position.)  This is used to actually claim a draw by repetition or by the *

 *   50 move rule.                                                             *

 *                                                                             *

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

 */

int Repeat3x(TREE * RESTRICT tree) {

  int reps = 0, where;

/*

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

 *                                                          *

 *  If the 50-move rule has been reached, then return an    *

 *  indicator that a draw can be claimed if wanted.         *

 *                                                          *

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

 */

  if (Reversible(0) > 99)

    return 2;

/*

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

 *                                                          *

 *  Scan the repetition list to determine if this position  *

 *  has occurred two times previously, making this an       *

 *  actual 3-fold repetition.  Note we only check every     *

 *  other entry since the position has to be repeated 3x    *

 *  with the SAME side on move.                             *

 *                                                          *

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

 */

  for (where = rep_index % 2; where < rep_index; where += 2)

    if (HashKey == tree->rep_list[where])

      reps++;

  return reps == 2;

}