Subversion Repositories Games.Chess Giants

#if defined(DEBUG)

#  include "chess.h"

#  include "data.h"

/* last modified 02/26/14 */

/*

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

 *                                                                             *

 *   ValidatePosition() is a debugging tool that is enabled by using the       *

 *   -DDEBUG compilation flag.  This procedure tests the various data          *

 *   structures used in Crafty related to the chess board and incrementally    *

 *   updated values like hash signatures and so forth.  It simply looks for    *

 *   consistency between the various bitboards, and recomputes the hash        *

 *   signatures to determine if they are correct.  If anything fails to pass   *

 *   the validation test, we print out a dump of the moves made in this path   *

 *   through the tree, and then exit since things are corrupted.               *

 *                                                                             *

 *   This greatly slows the program down, because ValidatePosition() is called *

 *   after each Make()/Unmake() (these are the functions that modify the       *

 *   primary data structures).  In general, this will not be used by users     *

 *   unless they are modifying the source code themselves.                     *

 *                                                                             *

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

 */

void ValidatePosition(TREE * RESTRICT tree, int ply, int move, char *caller) {

  uint64_t temp, temp1, temp_occ;

  uint64_t temp_occx;

  int i, square, error;

  int side, piece, temp_score;

/*

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

 *                                                          *

 *  First, test occupied[side] which should match the OR    *

 *  result of all pieces[side].                             *

 *                                                          *

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

 */

  error = 0;

  for (side = black; side <= white; side++) {

    temp_occ =

        Pawns(side) | Knights(side) | Bishops(side) | Rooks(side) |

        Queens(side)

        | Kings(side);

    if (Occupied(side) ^ temp_occ) {

      Print(128, "ERROR %s occupied squares is bad!\n",

          (side) ? "white" : "black");

      Display2BitBoards(temp_occ, Occupied(white));

      error = 1;

    }

  }

/*

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

 *                                                          *

 *  Now we do some sanity tests on the actual chess board   *

 *  information.  The first test is to make sure that no    *

 *  bitmap square is set in more than one bitmap, which     *

 *  would imply two different pieces on the same square.    *

 *                                                          *

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

 */

  temp_occ =

      Pawns(white) ^ Knights(white) ^ Bishops(white) ^ Rooks(white) ^

      Queens(white) ^ Pawns(black) ^ Knights(black) ^ Bishops(black) ^

      Rooks(black) ^ Queens(black) ^ Kings(white) ^ Kings(black);

  temp_occx =

      Pawns(white) | Knights(white) | Bishops(white) | Rooks(white) |

      Queens(white) | Pawns(black) | Knights(black) | Bishops(black) |

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

  if (temp_occ ^ temp_occx) {

    Print(128, "ERROR two pieces on same square\n");

    error = 1;

  }

/*

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

 *                                                          *

 *  Add up all the pieces (material values) to see if this  *

 *  matches the incrementally updated value.                *

 *                                                          *

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

 */

  temp_score = 0;

  for (side = black; side <= white; side++)

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

      temp_score += PopCnt(Pieces(side, piece)) * PieceValues(side, piece);

  if (temp_score != Material) {

    Print(128, "ERROR  material evaluation is wrong, good=%d, bad=%d\n",

        temp_score, Material);

    error = 1;

  }

/*

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

 *                                                          *

 *  Next, check the incrementally updated piece counts for  *

 *  both sides.  ditto for pawn counts.                     *

 *                                                          *

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

 */

  for (side = black; side <= white; side++) {

    temp_score = 0;

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

      temp_score += PopCnt(Pieces(side, piece)) * p_vals[piece];

    if (temp_score != TotalPieces(side, occupied)) {

      Print(128, "ERROR  %s pieces is wrong, good=%d, bad=%d\n",

          (side) ? "white" : "black", temp_score, TotalPieces(side,

              occupied));

      error = 1;

    }

  }

  for (side = black; side <= white; side++) {

    temp_score = PopCnt(Pawns(side));

    if (temp_score != TotalPieces(side, pawn)) {

      Print(128, "ERROR  %s pawns is wrong, good=%d, bad=%d\n",

          (side) ? "white" : "black", temp_score, TotalPieces(side, pawn));

      error = 1;

    }

  }

  i = PopCnt(OccupiedSquares);

  if (i != TotalAllPieces) {

    Print(128, "ERROR!  TotalAllPieces is wrong, correct=%d  bad=%d\n", i,

        TotalAllPieces);

    error = 1;

  }

/*

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

 *                                                          *

 *  Now we cycle through each different chessboard bitmap   *

 *  and verify that each piece in a bitmap matches the same *

 *  piece type in the board[64] array.                      *

 *                                                          *

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

 */

  for (side = black; side <= white; side++)

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

      temp = Pieces(side, piece);

      while (temp) {

        square = LSB(temp);

        if (PcOnSq(square) != pieces[side][piece]) {

          Print(128, "ERROR!  board[%d]=%d, should be %d\n", square,

              PcOnSq(square), pieces[side][piece]);

          error = 1;

        }

        temp &= temp - 1;

      }

    }

/*

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

 *                                                          *

 *  And then we look at the board[64] array and make sure   *

 *  that any non-zero piece matches the proper bitmap for   *

 *  that particular piece type.                             *

 *                                                          *

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

 */

  for (i = 0; i < 64; i++) {

    if (!PcOnSq(i))

      continue;

    side = (PcOnSq(i) > 0) ? 1 : 0;

    if (SetMask(i) & Pieces(side, Abs(PcOnSq(i))))

      continue;

    Print(128, "ERROR!  bitboards/board[%d] don't agree!\n", i);

    error = 1;

    break;

  }

/*

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

 *                                                          *

 *  The last chess board test is to make sure that any      *

 *  square that is empty according to board[64] is also     *

 *  empty according to the occupied squares bitmap.         *

 *                                                          *

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

 */

  temp = ~(temp_occ | temp_occx);

  while (temp) {

    square = LSB(temp);

    if (PcOnSq(square)) {

      Print(128, "ERROR!  board[%d]=%d, should be 0\n", square,

          PcOnSq(square));

      error = 1;

    }

    temp &= temp - 1;

  }

/*

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

 *                                                          *

 *  Finally, we re-compute the pawn hash signature and the  *

 *  normal hash signature and verify that they match the    *

 *  incrementally updated values.                           *

 *                                                          *

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

 */

  temp = 0;

  temp1 = 0;

  for (i = 0; i < 64; i++) {

    side = (PcOnSq(i) > 0) ? 1 : 0;

    temp ^= randoms[side][Abs(PcOnSq(i))][i];

    if (Abs(PcOnSq(i)) == pawn)

      temp1 ^= randoms[side][Abs(PcOnSq(i))][i];

  }

  if (EnPassant(ply))

    temp ^= enpassant_random[EnPassant(ply)];

  for (side = black; side <= white; side++) {

    if (Castle(ply, side) < 0 || !(Castle(ply, side) & 1))

      temp ^= castle_random[0][side];

    if (Castle(ply, side) < 0 || !(Castle(ply, side) & 2))

      temp ^= castle_random[1][side];

  }

  if (temp ^ HashKey) {

    Print(128, "ERROR!  hash_key is bad.\n");

    error = 1;

  }

  if (temp1 ^ PawnHashKey) {

    Print(128, "ERROR!  pawn_hash_key is bad.\n");

    error = 1;

  }

/*

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

 *                                                          *

 *  If any inconsistencies/errors were found, we are going  *

 *  to dump as much debugging information as possible to    *

 *  help pinpoint the source of the problem.                *

 *                                                          *

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

 */

  if (error) {

    Print(4095, "processor id: cpu-%d\n", tree->thread_id);

    Print(4095, "current move:\n");

    DisplayChessMove("move=", move);

    DisplayChessBoard(stdout, tree->position);

    Print(4095, "called from %s, ply=%d\n", caller, ply);

    Print(4095, "node=%" PRIu64 "\n", tree->nodes_searched);

    Print(4095, "active path:\n");

    for (i = 1; i <= ply; i++)

      DisplayChessMove("move=", tree->curmv[i]);

    CraftyExit(1);

  }

}

#endif