WebSVN – Games.Chess Giants – Diff – //engine-crafty/ponder.c

  *   a suggested move from the transposition table.  Then, make this move and  *
  *   do a search from the resulting position.  While pondering, one of three   *
  *   things can happen:  (1) A move is entered, and it matches the predicted   *
  *   move.  We then switch from pondering to thinking and search as normal;    *
  *   (2) A move is entered, but it does not match the predicted move.  We then *
- *   abort the search, unmake the pondered move, and then restart with the move*
+ *   abort the search, unmake the pondered move, and then restart with the     *
- *   entered.  (3) A command is entered.  If it is a simple command, it can be *
+ *   move entered.  (3) A command is entered.  If it is a simple command, it   *
- *   done without aborting the search or losing time.  If not, we abort the    *
+ *   can be done without aborting the search or losing time.  If not, we abort *
- *   search, execute the command, and then attempt to restart pondering if the *
+ *   the search, execute the command, and then attempt to restart pondering if *
- *   command didn't make that impossible.                                      *
+ *   the command didn't make that impossible.                                  *
  *                                                                             *
  *******************************************************************************
  */
 int Ponder(int wtm) {
-  int dalpha = -999999, dbeta = 999999, i, *n_ponder_moves, *mv;
-  int save_move_number, tlom, value;
   TREE *const tree = block[0];
+  int dalpha = -999999, dbeta = 999999, i;
+  unsigned *n_ponder_moves, *mv;
+  int save_move_number, tlom, value;
 /*
  ************************************************************
  *                                                          *
  *  First, let's check to see if pondering is allowed, or   *
  *  legal move, we have to take action to find something to *
  *  ponder.                                                 *
  *                                                          *
  ************************************************************
  */
-  strcpy_s(hint, sizeof (hint), "none"); // Pierre-Marie Baty -- use safe version
+  strcpy(ponder_text, "none");
   if (ponder_move) {
     if (!VerifyMove(tree, 1, wtm, ponder_move)) {
       ponder_move = 0;
       Print(4095, "ERROR.  ponder_move is illegal (1).\n");
       Print(4095, "ERROR.  PV pathl=%d\n", last_pv.pathl);
  *  legal.                                                  *
  *                                                          *
  ************************************************************
  */
   if (!ponder_move) {
-    (void) HashProbe(tree, 0, 0, wtm, dalpha, dbeta, &value);
+    HashProbe(tree, 0, 0, wtm, dalpha, dbeta, &value);
     if (tree->hash_move[0])
       ponder_move = tree->hash_move[0];
     if (ponder_move) {
       if (!VerifyMove(tree, 1, wtm, ponder_move)) {
         Print(4095, "ERROR.  ponder_move is illegal (2).\n");
     TimeSet(puzzle);
     if (time_limit < 20)
       return 0;
     puzzling = 1;
     tree->status[1] = tree->status[0];
-    Print(128, "              puzzling over a move to ponder.\n");
+    Print(32, "              puzzling over a move to ponder.\n");
     last_pv.pathl = 0;
     last_pv.pathd = 0;
     for (i = 0; i < MAXPLY; i++) {
       tree->killers[i].move1 = 0;
       tree->killers[i].move2 = 0;
+    }
-    (void) Iterate(wtm, puzzle, 0);
+    Iterate(wtm, puzzle, 0);
     for (i = 0; i < MAXPLY; i++) {
       tree->killers[i].move1 = 0;
       tree->killers[i].move2 = 0;
+    }
     puzzling = 0;
  *  Display the move we are going to "ponder".              *
  *                                                          *
  ************************************************************
  */
   if (wtm)
-    Print(128, "White(%d): %s [pondering]\n", move_number, OutputMove(tree,
+    Print(32, "White(%d): %s [pondering]\n", move_number, OutputMove(tree, 0,
-            ponder_move, 0, wtm));
+            wtm, ponder_move));
   else
-    Print(128, "Black(%d): %s [pondering]\n", move_number, OutputMove(tree,
+    Print(32, "Black(%d): %s [pondering]\n", move_number, OutputMove(tree, 0,
-            ponder_move, 0, wtm));
+            wtm, ponder_move));
-  sprintf_s(hint, sizeof (hint), "%s", OutputMove(tree, ponder_move, 0, wtm)); // Pierre-Marie Baty -- use safe version
+  sprintf(ponder_text, "%s", OutputMove(tree, 0, wtm, ponder_move));
   if (post)
-    printf("Hint: %s\n", hint);
+    printf("Hint: %s\n", ponder_text);
 /*
  ************************************************************
  *                                                          *
  *  Set the ponder move list and eliminate illegal moves.   *
  *  This list is used to test the move entered while we are *
  */
   n_ponder_moves = GenerateCaptures(tree, 0, wtm, ponder_moves);
   num_ponder_moves =
       GenerateNoncaptures(tree, 0, wtm, n_ponder_moves) - ponder_moves;
   for (mv = ponder_moves; mv < ponder_moves + num_ponder_moves; mv++) {
-    MakeMove(tree, 0, *mv, wtm);
+    MakeMove(tree, 0, wtm, *mv);
     if (Check(wtm)) {
-      UnmakeMove(tree, 0, *mv, wtm);
+      UnmakeMove(tree, 0, wtm, *mv);
       *mv = 0;
     } else
-      UnmakeMove(tree, 0, *mv, wtm);
+      UnmakeMove(tree, 0, wtm, *mv);
+  }
 /*
  ************************************************************
  *                                                          *
  *  Now, perform an iterated search, but with the special   *
  *  since there is no need to stop searching until the      *
  *  opponent makes a move.                                  *
  *                                                          *
  ************************************************************
  */
-  MakeMove(tree, 0, ponder_move, wtm);
+  MakeMove(tree, 0, wtm, ponder_move);
+  tree->curmv[0] = ponder_move;
-  tree->rep_list[++(tree->rep_index)] = HashKey;
+  tree->rep_list[++rep_index] = HashKey;
   tlom = last_opponent_move;
   last_opponent_move = ponder_move;
   if (kibitz)
-    strcpy_s(kibitz_text, sizeof (kibitz_text), "n/a"); // Pierre-Marie Baty -- use safe version
+    strcpy(kibitz_text, "n/a");
   thinking = 0;
   pondering = 1;
   if (!wtm)
     move_number++;
   ponder_value = Iterate(Flip(wtm), think, 0);
-  tree->rep_index--;
+  rep_index--;
   move_number = save_move_number;
   pondering = 0;
   thinking = 0;
   last_opponent_move = tlom;
-  UnmakeMove(tree, 0, ponder_move, wtm);
+  UnmakeMove(tree, 0, wtm, ponder_move);
 /*
  ************************************************************
  *                                                          *
  *  Search completed. the possible return values are:       *
  *                                                          *
  *      terminated due to either finding a mate, or the     *
  *      maximum search depth was reached.  The result of    *
  *      this ponder search are valid, but only if the       *
  *      opponent makes the correct (predicted) move.        *
  *                                                          *
- *  (3) Pondering was done, but the opponent either made    *
+ *  (3) Pondering was done, but the opponent either made a  *
- *      a different move, or entered a command that has to  *
+ *      different move, or entered a command that has to    *
  *      interrupt the pondering search before the command   *
  *      (or move) can be processed.  This forces Main() to  *
  *      avoid reading in a move/command since one has been  *
  *      read into the command buffer already.               *
  *                                                          *

Subversion Repositories Games.Chess Giants

Games.Chess Giants//engine-crafty/ponder.c – Rev 33 → 108