#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;
}