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

  *                                                                             *
  *   64 bits:  hash key for this position.                                     *
  *                                                                             *
  *    8 bits:  flag bits defined as  follows:                                  *
  *                                                                             *
- *      0000 0001  ?? flagged move                       (0x01)                *
+ *        0000 0001  ?? flagged move                         (0x01)            *
- *      0000 0010   ? flagged move                       (0x02)                *
+ *        0000 0010   ? flagged move                         (0x02)            *
- *      0000 0100   = flagged move                       (0x04)                *
+ *        0000 0100   = flagged move                         (0x04)            *
- *      0000 1000   ! flagged move                       (0x08)                *
+ *        0000 1000   ! flagged move                         (0x08)            *
- *      0001 0000  !! flagged move                       (0x10)                *
+ *        0001 0000  !! flagged move                         (0x10)            *
- *      0010 0000     black won at least 1 game          (0x20)                *
+ *        0010 0000     black won at least 1 game            (0x20)            *
- *      0100 0000     at least one game was drawn        (0x40)                *
+ *        0100 0000     at least one game was drawn          (0x40)            *
- *      1000 0000     white won at least 1 game          (0x80)                *
+ *        1000 0000     white won at least 1 game            (0x80)            *
  *                                                                             *
  *   24 bits:  number of games this move was played.                           *
  *                                                                             *
  *   32 bits:  learned value (floating point).                                 *
  *                                                                             *
  *                                                                             *
  *******************************************************************************
  */
 #define BAD_MOVE  0x02
 #define GOOD_MOVE 0x08
-int Book(TREE * RESTRICT tree, int wtm, int root_list_done) {
+int Book(TREE * RESTRICT tree, int wtm) {
   static int book_moves[200];
   static BOOK_POSITION start_moves[200];
   static uint64_t selected_key[200];
   static int selected[200];
-  static int selected_order_played[200];
+  static int selected_order_played[200], selected_value[200];
-  static float selected_value[200]; // Pierre-Marie Baty -- fixed type
   static int selected_status[200], selected_percent[200],
       book_development[200];
   static int bs_played[200], bs_percent[200];
   static int book_status[200], evaluations[200], bs_learn[200];
   static float bs_value[200], total_value;
   int m1_status, forced = 0, total_percent, play_percentage = 0;
   float tempr;
   int done, i, j, last_move, temp, which, minlv = 999999, maxlv = -999999;
   int maxp = -999999, minev = 999999, maxev = -999999;
   int nflagged, im, value, np, book_ponder_move;
-  int cluster, scluster, test;
+  int cluster, scluster, test, v;
   unsigned char buf32[4];
   uint64_t temp_hash_key, common, tempk;
   int key, nmoves, num_selected, st;
   int percent_played, total_played, total_moves, smoves;
   int distribution;
  *  each move found.  These will be used later to augment   *
  *  the flags in the normal book to offer better control.   *
  *                                                          *
  ************************************************************
  */
-  if (!root_list_done)
-    RootMoveList(wtm);
   test = HashKey >> 49;
   smoves = 0;
   if (books_file) {
     fseek(books_file, test * sizeof(int), SEEK_SET);
-    fread(buf32, 4, 1, books_file);
+    v = fread(buf32, 4, 1, books_file);
+    if (v <= 0)
+      perror("Book() fread error: ");
     key = BookIn32(buf32);
     if (key > 0) {
       fseek(books_file, key, SEEK_SET);
-      fread(buf32, 4, 1, books_file);
+      v = fread(buf32, 4, 1, books_file);
+      if (v <= 0)
+        perror("Book() fread error: ");
       scluster = BookIn32(buf32);
+      if (scluster)
-      BookClusterIn(books_file, scluster, book_buffer);
+        BookClusterIn(books_file, scluster, book_buffer);
       for (im = 0; im < n_root_moves; im++) {
         common = HashKey & ((uint64_t) 65535 << 48);
-        MakeMove(tree, 1, root_moves[im].move, wtm);
+        MakeMove(tree, 1, wtm, root_moves[im].move);
         if (Repeat(tree, 2)) {
-          UnmakeMove(tree, 1, root_moves[im].move, wtm);
+          UnmakeMove(tree, 1, wtm, root_moves[im].move);
           return 0;
+        }
         temp_hash_key = (wtm) ? HashKey : ~HashKey;
         temp_hash_key = (temp_hash_key & ~((uint64_t) 65535 << 48)) | common;
         for (i = 0; i < scluster; i++)
           if (!(temp_hash_key ^ book_buffer[i].position)) {
             start_moves[smoves++] = book_buffer[i];
             break;
+          }
-        UnmakeMove(tree, 1, root_moves[im].move, wtm);
+        UnmakeMove(tree, 1, wtm, root_moves[im].move);
+      }
+    }
+  }
 /*
  ************************************************************
  ************************************************************
  */
   test = HashKey >> 49;
   if (book_file) {
     fseek(book_file, test * sizeof(int), SEEK_SET);
-    fread(buf32, 4, 1, book_file);
+    v = fread(buf32, 4, 1, book_file);
+    if (v <= 0)
+      perror("Book() fread error: ");
     key = BookIn32(buf32);
     if (key > 0) {
       book_learn_seekto = key;
       fseek(book_file, key, SEEK_SET);
-      fread(buf32, 4, 1, book_file);
+      v = fread(buf32, 4, 1, book_file);
+      if (v <= 0)
+        perror("Book() fread error: ");
       cluster = BookIn32(buf32);
+      if (cluster)
-      BookClusterIn(book_file, cluster, book_buffer);
+        BookClusterIn(book_file, cluster, book_buffer);
     } else
       cluster = 0;
     if (!cluster && !smoves)
       return 0;
 /*
  *  database.                                               *
  *                                                          *
  ************************************************************
  */
     initial_development = tree->score_mg;
-    EvaluateDevelopment(tree, 1, wtm);
+    EvaluateCastling(tree, 1, wtm);
     initial_development = tree->score_mg - initial_development;
     total_moves = 0;
     nmoves = 0;
     for (im = 0; im < n_root_moves; im++) {
       common = HashKey & ((uint64_t) 65535 << 48);
-      MakeMove(tree, 1, root_moves[im].move, wtm);
+      MakeMove(tree, 1, wtm, root_moves[im].move);
       if (Repeat(tree, 2)) {
-        UnmakeMove(tree, 1, root_moves[im].move, wtm);
+        UnmakeMove(tree, 1, wtm, root_moves[im].move);
         return 0;
+      }
       temp_hash_key = (wtm) ? HashKey : ~HashKey;
       temp_hash_key = (temp_hash_key & ~((uint64_t) 65535 << 48)) | common;
       for (i = 0; i < cluster; i++) {
           if (puzzling)
             bs_played[nmoves] += 1;
           tree->curmv[1] = root_moves[im].move;
           if (!Captured(root_moves[im].move)) {
             book_development[nmoves] = tree->score_mg;
-            EvaluateDevelopment(tree, 2, wtm);
+            EvaluateCastling(tree, 2, wtm);
             book_development[nmoves] =
                 tree->score_mg - book_development[nmoves];
           } else
             book_development[nmoves] = 0;
           total_moves += bs_played[nmoves];
           book_key[nmoves] = temp_hash_key;
           nmoves++;
           break;
+        }
+      }
-      UnmakeMove(tree, 1, root_moves[im].move, wtm);
+      UnmakeMove(tree, 1, wtm, root_moves[im].move);
+    }
     if (!nmoves)
       return 0;
     book_learn_nmoves = nmoves;
 /*
+      }
+    }
     maxp++;
     for (i = 0; i < nmoves; i++) {
       bs_value[i] = 1;
-      bs_value[i] += bs_played[i] / (float) maxp * 1000.0f * book_weight_freq; // Pierre-Marie Baty -- added float suffix
+      bs_value[i] += bs_played[i] / (float) maxp *1000.0f * book_weight_freq; // Pierre-Marie Baty -- added type cast
       if (minlv < maxlv)
         bs_value[i] +=
             (bs_learn[i] - minlv) / (float) (maxlv -
-            minlv) * 1000.0f * book_weight_learn; // Pierre-Marie Baty -- added float suffix
+            minlv) * 1000.0f * book_weight_learn; // Pierre-Marie Baty -- added type cast
       if (minev < maxev)
         bs_value[i] +=
             (evaluations[i] - minev) / (float) (Max(maxev - minev,
-)) * 1000.0f * book_weight_eval; // Pierre-Marie Baty -- added float suffix
+)) * 1000.0f * book_weight_eval; // Pierre-Marie Baty -- added type cast
+    }
     total_played = total_moves;
 /*
  ************************************************************
  *                                                          *
         done = 1;
         for (i = 0; i < nmoves - 1; i++) {
           if (bs_percent[i] < bs_percent[i + 1]
               || (bs_percent[i] == bs_percent[i + 1]
                   && bs_value[i] < bs_value[i + 1])) {
-            temp = bs_played[i]; // Pierre-Marie Baty -- the wrong variable type was used
+            tempr = (float) bs_played[i]; // Pierre-Marie Baty -- added type cast (FIXME: ugly!)
             bs_played[i] = bs_played[i + 1];
-            bs_played[i + 1] = temp;
+            bs_played[i + 1] = (int) tempr; // Pierre-Marie Baty -- added type cast (FIXME: ugly!)
             tempr = bs_value[i];
             bs_value[i] = bs_value[i + 1];
             bs_value[i + 1] = tempr;
             temp = evaluations[i];
             evaluations[i] = evaluations[i + 1];
  *  operator has requested it.                              *
  *                                                          *
  ************************************************************
  */
     if (show_book) {
-      Print(128, "  after screening, the following moves can be played\n");
+      Print(32, "  after screening, the following moves can be played\n");
-      Print(128,
+      Print(32,
           "  move     played    %%  score    learn    " "sortv   P%%  P\n");
       for (i = 0; i < nmoves; i++) {
-        Print(128, "%6s", OutputMove(tree, book_moves[i], 1, wtm));
+        Print(32, "%6s", OutputMove(tree, 1, wtm, book_moves[i]));
         st = book_status[i];
         if (st & 0x1f) {
           if (st & 0x01)
-            Print(128, "??");
+            Print(32, "??");
           else if (st & 0x02)
-            Print(128, "? ");
+            Print(32, "? ");
           else if (st & 0x04)
-            Print(128, "= ");
+            Print(32, "= ");
           else if (st & 0x08)
-            Print(128, "! ");
+            Print(32, "! ");
           else if (st & 0x10)
-            Print(128, "!!");
+            Print(32, "!!");
         } else
-          Print(128, "  ");
+          Print(32, "  ");
-        Print(128, "   %6d", bs_played[i]);
+        Print(32, "   %6d", bs_played[i]);
-        Print(128, "  %3d", 100 * bs_played[i] / Max(total_moves, 1));
+        Print(32, "  %3d", 100 * bs_played[i] / Max(total_moves, 1));
-        Print(128, "%s", DisplayEvaluation(evaluations[i], wtm));
+        Print(32, "%s", DisplayEvaluation(evaluations[i], wtm));
-        Print(128, "%9.2f", (float) bs_learn[i] / 100.0);
+        Print(32, "%9.2f", (float) bs_learn[i] / 100.0);
-        Print(128, " %9.1f", bs_value[i]);
+        Print(32, " %9.1f", bs_value[i]);
-        Print(128, " %3d", bs_percent[i]);
+        Print(32, " %3d", bs_percent[i]);
         if ((book_status[i] & book_accept_mask &&
                 !(book_status[i] & book_reject_mask))
             || (!(book_status[i] & book_reject_mask) && (bs_percent[i]
                     || book_status[i] & 0x18 || (wtm && book_status[i] & 0x80)
                     || (!wtm && book_status[i] & 0x20))))
-          Print(128, "  Y");
+          Print(32, "  Y");
         else
-          Print(128, "  N");
+          Print(32, "  N");
-        Print(128, "\n");
+        Print(32, "\n");
+      }
+    }
 /*
  ************************************************************
  *                                                          *
     if (!play_percentage) {
       for (i = 0; i < nmoves; i++)
         if (!(book_status[i] & 0x03) || bs_percent[i]) {
           selected_status[num_selected] = book_status[i];
           selected_order_played[num_selected] = bs_played[i];
-          selected_value[num_selected] = bs_value[i];
+          selected_value[num_selected] = (int) bs_value[i]; // Pierre-Marie Baty -- added type cast
           selected_percent[num_selected] = bs_percent[i];
           selected_key[num_selected] = book_key[i];
           selected[num_selected++] = book_moves[i];
+        }
     } else {
       for (i = 0; i < nmoves; i++)
         if (bs_percent[i]) {
           selected_status[num_selected] = book_status[i];
           selected_order_played[num_selected] = bs_played[i];
-          selected_value[num_selected] = bs_value[i];
+          selected_value[num_selected] = (int) bs_value[i]; // Pierre-Marie Baty -- added type cast
           selected_percent[num_selected] = bs_percent[i];
           selected_key[num_selected] = book_key[i];
           selected[num_selected++] = book_moves[i];
+        }
+    }
     for (i = 0; i < num_selected; i++) {
       book_status[i] = selected_status[i];
       bs_played[i] = selected_order_played[i];
-      bs_value[i] = selected_value[i];
+      bs_value[i] = (float) selected_value[i]; // Pierre-Marie Baty -- added type cast
       bs_percent[i] = selected_percent[i];
       book_moves[i] = selected[i];
+    }
     nmoves = num_selected;
 /*
         if (!nmoves)
           break;
         sprintf(kibitz_text, "book moves (");
         kibitz_p = kibitz_text + strlen(kibitz_text);
         for (i = 0; i < nmoves; i++) {
-          sprintf(kibitz_p, "%s %d%%", OutputMove(tree, book_moves[i], 1,
+          sprintf(kibitz_p, "%s %d%%", OutputMove(tree, 1, wtm,
-                  wtm), 100 * bs_played[i] / Max(total_played, 1));
+                  book_moves[i]), 100 * bs_played[i] / Max(total_played, 1));
           kibitz_p = kibitz_text + strlen(kibitz_text);
           if (i < nmoves - 1) {
             sprintf(kibitz_p, ", ");
             kibitz_p = kibitz_text + strlen(kibitz_text);
+          }
         for (i = 0; i < nmoves; i++)
           if (book_status[i] & 16) {
             forced = 1;
             selected_status[num_selected] = book_status[i];
             selected_order_played[num_selected] = bs_played[i];
-            selected_value[num_selected] = bs_value[i];
+            selected_value[num_selected] = (int) bs_value[i]; // Pierre-Marie Baty -- added type cast
             selected_key[num_selected] = book_key[i];
             selected[num_selected++] = book_moves[i];
+          }
     if (!num_selected && !puzzling)
       if (book_accept_mask & 8)
         for (i = 0; i < nmoves; i++)
           if (book_status[i] & 8) {
             forced = 1;
             selected_status[num_selected] = book_status[i];
             selected_order_played[num_selected] = bs_played[i];
-            selected_value[num_selected] = bs_value[i];
+            selected_value[num_selected] = (int) bs_value[i]; // Pierre-Marie Baty -- added type cast
             selected_key[num_selected] = book_key[i];
             selected[num_selected++] = book_moves[i];
+          }
     if (!num_selected && !puzzling)
       if (book_accept_mask & 4)
         for (i = 0; i < nmoves; i++)
           if (book_status[i] & 4) {
             selected_status[num_selected] = book_status[i];
             selected_order_played[num_selected] = bs_played[i];
-            selected_value[num_selected] = bs_value[i];
+            selected_value[num_selected] = (int) bs_value[i]; // Pierre-Marie Baty -- added type cast
             selected_key[num_selected] = book_key[i];
             selected[num_selected++] = book_moves[i];
+          }
     if (!num_selected && !puzzling)
       for (i = 0; i < nmoves; i++)
         if (book_status[i] & book_accept_mask) {
           selected_status[num_selected] = book_status[i];
           selected_order_played[num_selected] = bs_played[i];
-          selected_value[num_selected] = bs_value[i];
+          selected_value[num_selected] = (int) bs_value[i]; // Pierre-Marie Baty -- added type cast
           selected_key[num_selected] = book_key[i];
           selected[num_selected++] = book_moves[i];
+        }
     if (!num_selected)
       for (i = 0; i < nmoves; i++) {
         selected_status[num_selected] = book_status[i];
         selected_order_played[num_selected] = bs_played[i];
-        selected_value[num_selected] = bs_value[i];
+        selected_value[num_selected] = (int) bs_value[i]; // Pierre-Marie Baty -- added type cast
         selected_key[num_selected] = book_key[i];
         selected[num_selected++] = book_moves[i];
+      }
     if (!num_selected)
       return 0;
     for (i = 0; i < num_selected; i++) {
       book_status[i] = selected_status[i];
       book_moves[i] = selected[i];
       bs_played[i] = selected_order_played[i];
-      bs_value[i] = selected_value[i];
+      bs_value[i] = (float) selected_value[i]; // Pierre-Marie Baty -- added type cast
       bs_key[i] = selected_key[i];
+    }
     nmoves = num_selected;
     if (nmoves == 0)
       return 0;
-    Print(128, "               book moves {");
+    Print(32, "               book moves {");
     for (i = 0; i < nmoves; i++) {
-      Print(128, "%s", OutputMove(tree, book_moves[i], 1, wtm));
+      Print(32, "%s", OutputMove(tree, 1, wtm, book_moves[i]));
       if (i < nmoves - 1)
-        Print(128, ", ");
+        Print(32, ", ");
+    }
-    Print(128, "}\n");
+    Print(32, "}\n");
     nflagged = 0;
     for (i = 0; i < nmoves; i++)
       if (book_status[i] & 8)
         nflagged++;
     nmoves = Max(Min(nmoves, book_selection_width), nflagged);
     if (show_book) {
-      Print(128, "               moves considered {");
+      Print(32, "               moves considered {");
       for (i = 0; i < nmoves; i++) {
-        Print(128, "%s", OutputMove(tree, book_moves[i], 1, wtm));
+        Print(32, "%s", OutputMove(tree, 1, wtm, book_moves[i]));
         if (i < nmoves - 1)
-          Print(128, ", ");
+          Print(32, ", ");
+      }
-      Print(128, "}\n");
+      Print(32, "}\n");
+    }
 /*
  ************************************************************
  *                                                          *
  *  We have the book moves, if any have specified percents  *
       total_value = 1000.0;
     total_percent = (total_percent > 99) ? 99 : total_percent;
     for (i = 0; i < nmoves; i++)
       if (bs_percent[i])
         bs_value[i] =
-            total_value / (1.0f -
+            total_value / (1.0f - // Pierre-Marie Baty -- added type cast
-            (float) total_percent / 100.0f) * (float) bs_percent[i] / 100.0f; // Pierre-Marie Baty -- added float suffixes
+            (float) total_percent / 100.0f) * (float) bs_percent[i] / 100.0f; // Pierre-Marie Baty -- added type casts
 /*
  ************************************************************
  *                                                          *
  *  Display the book moves, and total counts, etc. if the   *
  *  operator has requested it.                              *
  *                                                          *
  ************************************************************
  */
     if (show_book) {
-      Print(128, "  move     played    %%  score     sortv  P%%  P\n");
+      Print(32, "  move     played    %%  score     sortv  P%%  P\n");
       for (i = 0; i < nmoves; i++) {
-        Print(128, "%6s", OutputMove(tree, book_moves[i], 1, wtm));
+        Print(32, "%6s", OutputMove(tree, 1, wtm, book_moves[i]));
         st = book_status[i];
         if (st & 0x1f) {
           if (st & 0x01)
-            Print(128, "??");
+            Print(32, "??");
           else if (st & 0x02)
-            Print(128, "? ");
+            Print(32, "? ");
           else if (st & 0x04)
-            Print(128, "= ");
+            Print(32, "= ");
           else if (st & 0x08)
-            Print(128, "! ");
+            Print(32, "! ");
           else if (st & 0x10)
-            Print(128, "!!");
+            Print(32, "!!");
         } else
-          Print(128, "  ");
+          Print(32, "  ");
-        Print(128, "   %6d", bs_played[i]);
+        Print(32, "   %6d", bs_played[i]);
-        Print(128, "  %3d", 100 * bs_played[i] / Max(total_moves, 1));
+        Print(32, "  %3d", 100 * bs_played[i] / Max(total_moves, 1));
-        Print(128, "%s", DisplayEvaluation(evaluations[i], wtm));
+        Print(32, "%s", DisplayEvaluation(evaluations[i], wtm));
-        Print(128, " %9.1f", bs_value[i]);
+        Print(32, " %9.1f", bs_value[i]);
-        Print(128, " %3d", bs_percent[i]);
+        Print(32, " %3d", bs_percent[i]);
         if ((book_status[i] & book_accept_mask &&
                 !(book_status[i] & book_reject_mask))
             || (!(book_status[i] & book_reject_mask) && ((wtm &&
                         book_status[i] & 0x80) || (!wtm &&
                         book_status[i] & 0x20))))
-          Print(128, "  Y");
+          Print(32, "  Y");
         else
-          Print(128, "  N");
+          Print(32, "  N");
-        Print(128, "\n");
+        Print(32, "\n");
+      }
+    }
 /*
  ************************************************************
  *                                                          *
           if (value < -50) {
             last_pv.pathd = 0;
             return 0;
+          }
         } else {
-          tree->pv[1].path[1] = book_moves[0];
+          tree->pv[0].path[1] = book_moves[0];
-          tree->pv[1].pathl = 2;
+          tree->pv[0].pathl = 2;
-          tree->pv[1].pathd = 0;
+          tree->pv[0].pathd = 0;
+        }
         return 1;
+      }
+    }
 /*
             root_moves[i].move = 0;
       for (i = 0, j = 0; i < n_root_moves; i++)
         if (root_moves[i].move != 0)
           root_moves[j++] = root_moves[i];
       n_root_moves = j;
-      Print(128, "               moves considered {only non-book moves}\n");
+      Print(32, "               moves considered {only non-book moves}\n");
       nmoves = j;
       if (nmoves > 1) {
         last_pv.pathd = 0;
         booking = 1;
-        (void) Iterate(wtm, booking, 1);
+        Iterate(wtm, booking, 1);
         booking = 0;
       } else {
-        tree->pv[1].path[1] = book_moves[0];
+        tree->pv[0].path[1] = book_moves[0];
-        tree->pv[1].pathl = 2;
+        tree->pv[0].pathl = 2;
-        tree->pv[1].pathd = 0;
+        tree->pv[0].pathd = 0;
+      }
       return 1;
+    }
     last_move = nmoves;
 /*
         distribution -= (int) (bs_value[which] * bs_value[which]); // Pierre-Marie Baty -- added type cast
       if (distribution < 0)
         break;
+    }
     which = Min(which, last_move - 1);
-    tree->pv[1].path[1] = book_moves[which];
+    tree->pv[0].path[1] = book_moves[which];
     percent_played = 100 * bs_played[which] / Max(total_played, 1);
     total_played = bs_played[which];
     m1_status = book_status[which];
-    tree->pv[1].pathl = 2;
+    tree->pv[0].pathl = 2;
-    tree->pv[1].pathd = 0;
+    tree->pv[0].pathd = 0;
     if (mode != tournament_mode) {
-      MakeMove(tree, 1, book_moves[which], wtm);
+      MakeMove(tree, 1, wtm, book_moves[which]);
       if ((book_ponder_move = BookPonderMove(tree, Flip(wtm)))) {
-        tree->pv[1].path[2] = book_ponder_move;
+        tree->pv[0].path[2] = book_ponder_move;
-        tree->pv[1].pathl = 3;
+        tree->pv[0].pathl = 3;
+      }
-      UnmakeMove(tree, 1, book_moves[which], wtm);
+      UnmakeMove(tree, 1, wtm, book_moves[which]);
+    }
     book_learn_key = bs_key[which];
-    Print(128, "               book   0.0s    %3d%%   ", percent_played);
+    Print(32, "               book   0.0s    %3d%%   ", percent_played);
-    Print(128, " %s", OutputMove(tree, tree->pv[1].path[1], 1, wtm));
+    Print(32, " %s", OutputMove(tree, 1, wtm, tree->pv[0].path[1]));
     st = m1_status & book_accept_mask & (~224);
     if (st) {
       if (st & 1)
-        Print(128, "??");
+        Print(32, "??");
       else if (st & 2)
-        Print(128, "?");
+        Print(32, "?");
       else if (st & 4)
-        Print(128, "=");
+        Print(32, "=");
       else if (st & 8)
-        Print(128, "!");
+        Print(32, "!");
       else if (st & 16)
-        Print(128, "!!");
+        Print(32, "!!");
+    }
-    MakeMove(tree, 1, tree->pv[1].path[1], wtm);
+    MakeMove(tree, 1, wtm, tree->pv[0].path[1]);
-    if (tree->pv[1].pathl > 2)
+    if (tree->pv[0].pathl > 2)
-      Print(128, " %s", OutputMove(tree, tree->pv[1].path[2], 2, Flip(wtm)));
+      Print(32, " %s", OutputMove(tree, 2, Flip(wtm), tree->pv[0].path[2]));
-    UnmakeMove(tree, 1, tree->pv[1].path[1], wtm);
+    UnmakeMove(tree, 1, wtm, tree->pv[0].path[1]);
-    Print(128, "\n");
+    Print(32, "\n");
     return 1;
+  }
   return 0;
+}
  *                                                                             *
  *******************************************************************************
  */
 int BookPonderMove(TREE * RESTRICT tree, int wtm) {
   uint64_t temp_hash_key, common;
-  static int book_moves[200];
+  static unsigned book_moves[200];
-  int i, key, *lastm, cluster, n_moves, im, played, tplayed;
+  int i, v, key, cluster, n_moves, im, played, tplayed;
+  unsigned *lastm;
   int book_ponder_move = 0, test;
   unsigned char buf32[4];
 /*
  ************************************************************
  ************************************************************
  */
   if (book_file) {
     test = HashKey >> 49;
     fseek(book_file, test * sizeof(int), SEEK_SET);
-    fread(buf32, 4, 1, book_file);
+    v = fread(buf32, 4, 1, book_file);
+    if (v <= 0)
+      perror("Book() fread error: ");
     key = BookIn32(buf32);
     if (key > 0) {
       fseek(book_file, key, SEEK_SET);
-      fread(buf32, 4, 1, book_file);
+      v = fread(buf32, 4, 1, book_file);
+      if (v <= 0)
+        perror("Book() fread error: ");
       cluster = BookIn32(buf32);
+      if (cluster)
-      BookClusterIn(book_file, cluster, book_buffer);
+        BookClusterIn(book_file, cluster, book_buffer);
     } else
       cluster = 0;
     if (!cluster)
       return 0;
     lastm = GenerateCaptures(tree, 2, wtm, book_moves);
  ************************************************************
  */
     played = -1;
     for (im = 0; im < n_moves; im++) {
       common = HashKey & ((uint64_t) 65535 << 48);
-      MakeMove(tree, 2, book_moves[im], wtm);
+      MakeMove(tree, 2, wtm, book_moves[im]);
       temp_hash_key = (wtm) ? HashKey : ~HashKey;
       temp_hash_key = (temp_hash_key & ~((uint64_t) 65535 << 48)) | common;
       for (i = 0; i < cluster; i++) {
         if (!(temp_hash_key ^ book_buffer[i].position)) {
           tplayed = book_buffer[i].status_played & 077777777;
             book_ponder_move = book_moves[im];
+          }
           break;
+        }
+      }
-      UnmakeMove(tree, 2, book_moves[im], wtm);
+      UnmakeMove(tree, 2, wtm, book_moves[im]);
+    }
+  }
   return book_ponder_move;
+}
 /* last modified 05/08/14 */
 /*
  *******************************************************************************
  *                                                                             *
- *   BookUp() is used to create/add to the opening book file.  typing "<file>  *
+ *   Bookup() is used to create/add to the opening book file.  typing "<file>  *
  *   create" will erase the old book file and start from scratch,              *
  *                                                                             *
- *   The format of the input data is a left bracket ("[") followed by any title*
+ *   The format of the input data is a left bracket ("[") followed by any      *
- *   information desired, followed by a right bracket ("]") followed by a      *
+ *   title information desired, followed by a right bracket ("]") followed by  *
- *   sequence of moves.  The sequence of moves is assumed to start at ply=1,   *
+ *   a sequence of moves.  The sequence of moves is assumed to start at ply=1, *
- *   with white-to-move (normal opening position) and can contain as many moves*
+ *   with white-to-move (normal opening position) and can contain as many      *
- *   as desired (no limit on the depth of each variation.)  The file *must* be *
+ *   moves as desired (no limit on the depth of each variation.)  The file     *
- *   terminated with a line that begins with "end", since handling the EOF     *
+ *   *must* be terminated with a line that begins with "end", since handling   *
- *   condition makes portable code difficult.                                  *
+ *   the EOF condition makes portable code difficult.                          *
  *                                                                             *
  *   Book moves can either be typed in by hand, directly into book_add(), by   *
  *   using the "book create/add" command.  Using the command "book add/create  *
  *   filename" will cause book_add() to read its opening text moves from       *
  *   filename rather than from the keyboard                                    *
  *                                                                             *
  *   In addition to the normal text for a move (reduced or full algebraic is   *
  *   accepted, ie, e4, ed, exd4, e3d4, etc. are all acceptable) some special   *
  *   characters can be appended to a move.                                     *
  *                                                                             *
- *      ?? ->  Never play this move.  since the same book is used for both     *
+ *        ?? ->  Never play this move.  since the same book is used for both   *
- *             black and white, you can enter moves in that white might play,  *
+ *               black and white, you can enter moves in that white might      *
- *             but prevent the program from choosing them on its own.          *
+ *               play, but prevent the program from choosing them on its own.  *
- *      ?  ->  Avoid this move except for non-important games.  These openings *
+ *        ?  ->  Avoid this move except for non-important games.  These        *
- *             are historically those that the program doesn't play very well, *
+ *               openings are historically those that the program doesn't play *
- *             but which aren't outright losing.                               *
+ *               very well, but which aren't outright losing.                  *
- *      =  ->  Drawish move, only play this move if drawish moves are allowed  *
+ *        =  ->  Drawish move, only play this move if drawish moves are        *
- *             by the operator.  This is used to encourage the program to play *
+ *               allowed by the operator.  This is used to encourage the       *
- *             drawish openings (Petrov's comes to mind) when the program needs*
+ *               program to play drawish openings (Petrov's comes to mind)     *
- *             to draw or is facing a formidable opponent (deep thought comes  *
+ *               when the program needs to draw or is facing a formidable      *
- *             to mind.)                                                       *
+ *               opponent (deep thought comes to mind.)                        *
- *      !  ->  Always play this move, if there isn't a move with the !! flag   *
+ *        !  ->  Always play this move, if there isn't a move with the !! flag *
- *             set also.  This is a strong move, but not as strong as a !!     *
+ *               set also.  This is a strong move, but not as strong as a !!   *
- *             move.                                                           *
+ *               move.                                                         *
- *      !! ->  Always play this move.  This can be used to make the program    *
+ *        !! ->  Always play this move.  This can be used to make the program  *
- *             favor particular lines, or to mark a strong move for certain    *
+ *               favor particular lines, or to mark a strong move for certain  *
- *             opening traps.                                                  *
+ *               opening traps.                                                *
  *                                                                             *
- *  {Play nn%} is used to force this specific book move to be played a specific*
+ *  {Play nn%} is used to force this specific book move to be played a         *
- *             percentage of the time, and override the frequency of play that *
+ *  specific percentage of the time, and override the frequency of play that   *
- *             comes from the large pgn database.                              *
+ *               comes from the large pgn database.                            *
  *                                                                             *
  *******************************************************************************
  */
-void BookUp(TREE * RESTRICT tree, int nargs, char **args) {
+void Bookup(TREE * RESTRICT tree, int nargs, char **args) {
   BB_POSITION *bbuffer;
   uint64_t temp_hash_key, common;
   FILE *book_input;
   char fname[128], start, *ch, output_filename[128];
   static char schar[2] = { "." };
               if (move) {
                 ply++;
                 max_search_depth = Max(max_search_depth, ply);
                 total_moves++;
                 common = HashKey & ((uint64_t) 65535 << 48);
-                MakeMove(tree, 2, move, wtm);
+                MakeMove(tree, 2, wtm, move);
                 tree->status[2] = tree->status[3];
                 if (ply <= max_ply) {
                   temp_hash_key = (wtm) ? HashKey : ~HashKey;
                   temp_hash_key =
                       (temp_hash_key & ~((uint64_t) 65535 << 48)) | common;
                   if (Castle(0, black) < 0)
                     Castle(0, black) = 0;
                   strcpy(buffer, "savepos *");
                   twtm = game_wtm;
                   game_wtm = wtm;
-                  (void) Option(tree);
+                  Option(tree);
                   game_wtm = twtm;
                   fprintf(pout, "%s\n", initial_position);
                   strcpy(initial_position, t_initial_position);
                   tree->status[0] = temp_pos;
+                }
       Print(4095, "Unable to malloc() index block, aborting\n");
       CraftyExit(1);
+    }
     for (i = 0; i < 32768; i++)
       index[i] = -1;
-    temp = BookUpNextPosition(files, 1);
+    temp = BookupNextPosition(files, 1);
     memcpy((char *) &current.position, temp.position, 8);
     current.status_played = temp.status << 24;
     if (start)
       current.status_played += temp.percent_play & 127;
     current.learn = 0.0;
     if (temp.status & 32 && !(temp.percent_play & 128))
       wins++;
     if (temp.status & 32 && temp.percent_play & 128)
       losses++;
     while (1) {
-      temp = BookUpNextPosition(files, 0);
+      temp = BookupNextPosition(files, 0);
       memcpy((char *) &next.position, temp.position, 8);
       next.status_played = temp.status << 24;
       if (start)
         next.status_played += temp.percent_play & 127;
       next.learn = 0.0;
               (void *) BookOut64(current.position), 8);
           memcpy((void *) &book_buffer_char[0].status_played,
               (void *) BookOut32(current.status_played), 4);
           memcpy((void *) &book_buffer_char[0].learn,
               (void *) BookOut32((int) current.learn), 4); // Pierre-Marie Baty -- added type cast
+          stat =
-          stat = fwrite(book_buffer_char, BOOK_POSITION_SIZE, 1, book_file);
+              fwrite(book_buffer_char, sizeof(BOOK_POSITION), 1, book_file);
           if (stat != 1)
             Print(4095, "ERROR!  write failed, disk probably full.\n");
         } else if (played < min_played)
           discarded_mp++;
         else
 void BookSort(BB_POSITION * buffer, int number, int fileno) {
   char fname[16];
   FILE *output_file;
   int stat;
-  qsort((char *) buffer, number, sizeof(BB_POSITION), BookUpCompare);
+  qsort((char *) buffer, number, sizeof(BB_POSITION), BookupCompare);
   sprintf(fname, "sort.%d", fileno);
   if (!(output_file = fopen(fname, "wb+")))
     printf("ERROR.  unable to open sort output file\n");
   stat = fwrite(buffer, sizeof(BB_POSITION), number, output_file);
   if (stat != number)
 /* last modified 02/23/14 */
 /*
  *******************************************************************************
  *                                                                             *
- *   BookUpNextPosition() is the heart of the "merge" operation that is done   *
+ *   BookupNextPosition() is the heart of the "merge" operation that is done   *
  *   after the chunks of the parsed/hashed move file are sorted.  This code    *
  *   opens the sort.n files, and returns the least (lexically) position key to *
  *   counted/merged into the main book database.                               *
  *                                                                             *
  *******************************************************************************
  */
-BB_POSITION BookUpNextPosition(int files, int init) {
+BB_POSITION BookupNextPosition(int files, int init) {
   char fname[20];
   static FILE *input_file[100];
   static BB_POSITION *buffer[100];
   static int data_read[100], next[100];
   int i, used;
   } else
     next[used]++;
   return least;
+}
-int BookUpCompare(const void *pos1, const void *pos2) {
+int BookupCompare(const void *pos1, const void *pos2) {
   static uint64_t p1, p2;
   memcpy((char *) &p1, ((BB_POSITION *) pos1)->position, 8);
   memcpy((char *) &p2, ((BB_POSITION *) pos2)->position, 8);
   if (p1 < p2)

Subversion Repositories Games.Chess Giants

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