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

 #if defined(UNIX)
 #  include <unistd.h>
 #  include <signal.h>
 #endif
 #include "epdglue.h"
+#include "tbprobe.h"
-/* last modified 01/16/15 */
+/* last modified 08/03/16 */
 /*
  *******************************************************************************
  *                                                                             *
  *   Option() is used to handle user input necessary to control/customize the  *
  *   program.  It performs all functions excepting chess move input which is   *
     if (nargs != 6) {
       printf("usage:  adaptive NPS hmin hmax pmin pmax\n");
       return 1;
+    }
     if (nargs > 1) {
-      adaptive_hash = (int) atoiKMB(args[1]); // Pierre-Marie Baty -- added type cast
+      adaptive_hash = atoiKMB(args[1]);
-      adaptive_hash_min = (size_t) atoiKMB(args[2]); // Pierre-Marie Baty -- added type cast
+      adaptive_hash_min = atoiKMB(args[2]);
-      adaptive_hash_max = (size_t) atoiKMB(args[3]); // Pierre-Marie Baty -- added type cast
+      adaptive_hash_max = atoiKMB(args[3]);
-      adaptive_hashp_min = (size_t) atoiKMB(args[4]); // Pierre-Marie Baty -- added type cast
+      adaptive_hashp_min = atoiKMB(args[4]);
-      adaptive_hashp_max = (size_t) atoiKMB(args[5]); // Pierre-Marie Baty -- added type cast
+      adaptive_hashp_max = atoiKMB(args[5]);
+    }
     Print(32, "adaptive estimated NPS =  %s\n", DisplayKMB(adaptive_hash, 1));
     Print(32, "adaptive minimum hsize =  %s\n", DisplayKMB(adaptive_hash_min,
 ));
     Print(32, "adaptive maximum hsize =  %s\n", DisplayKMB(adaptive_hash_max,
  *  it up.                                                  *
  *                                                          *
  ************************************************************
  */
   else if (OptionMatch("bench", *args)) {
-    int mod = 0, time;
+    int mod = 0;
     if (nargs > 1)
       mod = atoi(args[1]);
-    time = Bench(mod, 0);
+    (void) Bench(mod, 0);
-    Print(32, "time used = %s\n", DisplayTime(time));
-  }
-/*
- ***************************************************************
- *                                                             *
- *  "pgo" runs an internal performance benchmark used for PGO. *
- *  An optional second argument can increase or decrease       *
- *  the time it takes.  "pgo 1" increases the default          *
- *  by one ply, and "pgo -1" reduces the depth to speed        *
- *  it up.                                                     *
- *                                                             *
- ************************************************************
-         */
-  else if (OptionMatch("pgo", *args)) {
-    int mod = 0, time;
-    if (nargs > 1)
-      mod = atoi(args[1]);
-    time = Bench_PGO(mod, 0);
-    Print(32, "time used = %s\n", DisplayTime(time));
+  }
 /*
  ************************************************************
  *                                                          *
  *  "bk"  book command from xboard sends the suggested book *
  ************************************************************
  */
   else if (OptionMatch("bookw", *args)) {
     if (nargs > 1) {
       if (OptionMatch("frequency", args[1]))
-        book_weight_freq = (float) atof(args[2]); // Pierre-Marie Baty -- added type cast
+        book_weight_freq = atof(args[2]);
       else if (OptionMatch("evaluation", args[1]))
-        book_weight_eval = (float) atof(args[2]); // Pierre-Marie Baty -- added type cast
+        book_weight_eval = atof(args[2]);
       else if (OptionMatch("learning", args[1]))
-        book_weight_learn = (float) atof(args[2]); // Pierre-Marie Baty -- added type cast
+        book_weight_learn = atof(args[2]);
     } else {
       Print(32, "frequency (freq)..............%4.2f\n", book_weight_freq);
       Print(32, "static evaluation (eval)......%4.2f\n", book_weight_eval);
       Print(32, "learning (learn)..............%4.2f\n", book_weight_learn);
+    }
+  }
-/*
- ************************************************************
- *                                                          *
- *  "cache" is used to set the EGTB cache size.  As always  *
- *  bigger is better.  The default is 1mb.  Sizes can be    *
- *  specified in bytes, Kbytes or Mbytes as with the hash   *
- *  commands.                                               *
- *                                                          *
- ************************************************************
- */
-#if !defined(NOEGTB)
-  else if (OptionMatch("cache", *args)) {
-    EGTB_cache_size = (size_t) atoiKMB(args[1]); // Pierre-Marie Baty -- added type cast
-    if (EGTB_cache)
-      free(EGTB_cache);
-    EGTB_cache = malloc(EGTB_cache_size);
-    if (!EGTB_cache) {
-      Print(2095,
-          "ERROR:  unable to malloc specified cache size, using default\n");
-      EGTB_cache = malloc(4096 * 4096);
-    }
-    Print(32, "EGTB cache memory = %s bytes.\n", DisplayKMB(EGTB_cache_size,
-));
-    FTbSetCacheSize(EGTB_cache, EGTB_cache_size);
-  }
-#endif
 /*
  ************************************************************
  *                                                          *
  *  "clock" command displays chess clock.                   *
  *                                                          *
     Option(tree);
+  }
 /*
  ************************************************************
  *                                                          *
- *  "egtb" command enables/disables tablebases and sets     *
+ *  "egtb" command enables syzygy endgame database tables.  *
- *  the number of pieces available for probing.             *
  *                                                          *
  ************************************************************
  */
-#if !defined(NOEGTB)
   else if (OptionMatch("egtb", *args)) {
-    if (!EGTB_setup) {
+#if defined(SYZYGY)
-      Print(32, "EGTB access enabled\n");
-      Print(32, "using tbpath=%s\n", tb_path);
-      EGTBlimit = IInitializeTb(tb_path);
-      Print(32, "%d piece tablebase files found\n", EGTBlimit);
-      if (0 != cbEGTBCompBytes)
+    if (!strcmp(args[1], "off"))
-        Print(32,
+      EGTBlimit = 0;
-            "%dkb of RAM used for TB indices and decompression tables\n",
-            (cbEGTBCompBytes + 1023) / 1024);
-      if (EGTBlimit) {
+    else {
-        if (!EGTB_cache)
+      if (!EGTB_setup) {
-          EGTB_cache = malloc(EGTB_cache_size);
-        if (!EGTB_cache) {
+        tb_init(tb_path);
-          Print(32, "ERROR  EGTB cache malloc failed\n");
-          EGTB_cache = malloc(4096 * 4096);
-        } else
-          FTbSetCacheSize(EGTB_cache, EGTB_cache_size);
         EGTB_setup = 1;
+      }
-    } else {
-      if (nargs == 1)
-        EGTBPV(tree, game_wtm);
-      else if (nargs == 2)
-        EGTBlimit = Min(atoi(args[1]), 5);
+      EGTBlimit = TB_LARGEST;
+    }
+    if (EGTBlimit)
+      Print(32, "SYZYGY EGTB access enabled, %d piece TBs found\n",
+          TB_LARGEST);
+    else
+      Print(32, "SYZYGY EGTB access disabled.\n");
+#else
+    Print(32, "SYZYGY support not included (no -DSYZYGY)\n");
+#endif
+  }
 /*
  ************************************************************
  *                                                          *
  *  "egtbd" command sets the probe depth limit.  If the     *
  *  remaining depth is < this limit, probes are not done to *
  *  avoid slowing the search unnecessarily.                 *
  *                                                          *
  ************************************************************
  */
+#if defined(SYZYGY)
   else if (OptionMatch("egtbd", *args)) {
     if (nargs > 1)
       EGTB_depth = atoi(args[1]);
     Print(32, "EGTB probe depth set to %d\n", EGTB_depth);
+  }
       return 2;
     if (nargs > 1) {
       allow_memory = 0;
       if (xboard)
         Print(4095, "Warning--  xboard 'memory' option disabled\n");
-      new_hash_size = (size_t) atoiKMB(args[1]); // Pierre-Marie Baty -- added type cast
+      new_hash_size = atoiKMB(args[1]);
       if (new_hash_size < 64 * 1024) {
         printf("ERROR.  Minimum hash table size is 64K bytes.\n");
         return 1;
+      }
       hash_table_size = ((1ull) << MSB(new_hash_size)) / 16;
-      AlignedRemalloc((void *) ((void *) &hash_table), 64,
+      AlignedRemalloc((void *) &hash_table, 64,
           hash_table_size * sizeof(HASH_ENTRY));
       if (!hash_table) {
         printf("AlignedRemalloc() failed, not enough memory.\n");
         exit(1);
+      }
     size_t old_hash_size = hash_path_size, new_hash_size;
     if (thinking || pondering)
       return 2;
     if (nargs > 1) {
-      new_hash_size = (size_t) atoiKMB(args[1]); // Pierre-Marie Baty -- added type cast
+      new_hash_size = atoiKMB(args[1]);
       if (new_hash_size < 64 * 1024) {
         printf("ERROR.  Minimum phash table size is 64K bytes.\n");
         return 1;
+      }
       hash_path_size = ((1ull) << MSB(new_hash_size / sizeof(HPATH_ENTRY)));
-      AlignedRemalloc((void *) ((void *) &hash_path), 64,
+      AlignedRemalloc((void *) &hash_path, 64,
           sizeof(HPATH_ENTRY) * hash_path_size);
       if (!hash_path) {
         printf("AlignedRemalloc() failed, not enough memory.\n");
         hash_path_size = 0;
         hash_path = 0;
       return 2;
     if (nargs > 1) {
       allow_memory = 0;
       if (xboard)
         Print(4095, "Warning--  xboard 'memory' option disabled\n");
-      new_hash_size = (size_t) atoiKMB(args[1]); // Pierre-Marie Baty -- added type cast
+      new_hash_size = atoiKMB(args[1]);
       if (new_hash_size < 16 * 1024) {
         printf("ERROR.  Minimum pawn hash table size is 16K bytes.\n");
         return 1;
+      }
       pawn_hash_table_size =
 ull << MSB(new_hash_size / sizeof(PAWN_HASH_ENTRY));
-      AlignedRemalloc((void *) ((void *) &pawn_hash_table), 64,
+      AlignedRemalloc((void *) &pawn_hash_table, 64,
           sizeof(PAWN_HASH_ENTRY) * pawn_hash_table_size);
       if (!pawn_hash_table) {
         printf("AlignedRemalloc() failed, not enough memory.\n");
         exit(1);
+      }
+    }
     Print(32, "pawn hash table memory = %s bytes",
         DisplayKMB(pawn_hash_table_size * sizeof(PAWN_HASH_ENTRY), 1));
     Print(32, " (%s entries).\n", DisplayKMB(pawn_hash_table_size, 1));
     InitializeHashTables(old_hash_size != pawn_hash_table_size);
-  }
-/*
- ************************************************************
- *                                                          *
- *  "hashe" command controls the eval hash table size.      *
- *                                                          *
- ************************************************************
- */
-  else if (OptionMatch("hashe", *args)) {
-    size_t old_hash_size = eval_hash_table_size, new_hash_size;
-    if (thinking || pondering)
-      return 2;
-    if (nargs > 1) {
-      allow_memory = 0;
-      if (xboard)
-        Print(4095, "Warning--  xboard 'memory' option disabled\n");
-      new_hash_size = (size_t) atoiKMB(args[1]); // Pierre-Marie Baty -- added type cast
-      if (new_hash_size < 16 * 1024) {
-        printf("ERROR.  Minimum eval hash table size is 16K bytes.\n");
-        return 1;
-      }
-      eval_hash_table_size = 1ull << MSB(new_hash_size / sizeof(uint64_t));
-      AlignedRemalloc((void *) ((void *) &eval_hash_table), 64,
-          sizeof(uint64_t) * eval_hash_table_size);
-      if (!eval_hash_table) {
-        printf("AlignedRemalloc() failed, not enough memory.\n");
-        exit(1);
-      }
-      eval_hash_mask = eval_hash_table_size - 1;
-    }
-    Print(32, "eval hash table memory = %s bytes",
-        DisplayKMB(eval_hash_table_size * sizeof(uint64_t), 1));
-    Print(32, " (%s entries).\n", DisplayKMB(eval_hash_table_size, 1));
-    InitializeHashTables(old_hash_size != eval_hash_table_size);
+  }
 /*
  ************************************************************
  *                                                          *
  *  "help" command lists commands/options.                  *
     Print(32, "hash table memory = %s bytes", DisplayKMB(hash_table_size * 64,
 ));
     Print(32, " (%s entries).\n", DisplayKMB(hash_table_size * 5, 0));
     Print(32, "pawn hash table memory = %5s\n",
         DisplayKMB(pawn_hash_table_size * sizeof(PAWN_HASH_ENTRY), 1));
-#if !defined(NOEGTB)
-    Print(32, "EGTB cache memory =      %5s\n", DisplayKMB(EGTB_cache_size,
-));
-#endif
     if (!tc_sudden_death) {
       Print(32, "%d moves/%d minutes %d seconds primary time control\n",
           tc_moves, tc_time / 6000, (tc_time / 100) % 60);
       Print(32, "%d moves/%d minutes %d seconds secondary time control\n",
           tc_secondary_moves, tc_secondary_time / 6000,
       int optimal_hash_size;
       TimeSet(think);
       time_limit /= 100;
       positions_per_move = time_limit * adaptive_hash / 16;
-      optimal_hash_size = (int) positions_per_move * 16; // Pierre-Marie Baty -- added type cast
+      optimal_hash_size = positions_per_move * 16;
       printf("optimal=%d\n", optimal_hash_size);
-      optimal_hash_size = Max(optimal_hash_size, (int) adaptive_hash_min); // Pierre-Marie Baty -- added type cast
+      optimal_hash_size = Max(optimal_hash_size, adaptive_hash_min);
-      optimal_hash_size = Min(optimal_hash_size, (int) adaptive_hash_max); // Pierre-Marie Baty -- added type cast
+      optimal_hash_size = Min(optimal_hash_size, adaptive_hash_max);
       sprintf(buffer, "hash=%d\n", optimal_hash_size);
       Option(tree);
       percent =
           (float) (optimal_hash_size -
           adaptive_hash_min) / (float) (adaptive_hash_max -
           adaptive_hash_min);
-      optimal_hash_size = (int) // Pierre-Marie Baty -- added type cast
+      optimal_hash_size =
-          (adaptive_hashp_min + percent * (adaptive_hashp_max -
+          adaptive_hashp_min + percent * (adaptive_hashp_max -
-          adaptive_hashp_min));
+          adaptive_hashp_min);
-      optimal_hash_size = Max(optimal_hash_size, (int) adaptive_hashp_min); // Pierre-Marie Baty -- added type cast
+      optimal_hash_size = Max(optimal_hash_size, adaptive_hashp_min);
       sprintf(buffer, "hashp=%d\n", optimal_hash_size);
       Option(tree);
+    }
+  }
 /*
+          }
           Print(32, "\n");
+        }
+      }
+    }
+  }
+/*
+ ************************************************************
+ *                                                          *
+ *  "lmp" command sets the formla parameters that produce   *
+ *  LMP pruning bounds array.                               *
+ *                                                          *
+ *     lmp <maxdepth> <base> <scale>                        *
+ *                                                          *
+ *  <maxdepth> is the max depth at which LMP is done.       *
+ *                                                          *
+ *  <base> is the base pruning move count.  The function is *
+ *  an exponential of the form x = base + f(y).  The        *
+ *  default is currently 3.                                 *
+ *                                                          *
+ *  <scale> is the exponent of the exponential function.    *
+ *  larger numbers produce more conservative (larger) move  *
+ *  counts.  Smaller values are more aggressive.  The       *
+ *  default is currently 1.9.                               *
+ *                                                          *
+ ************************************************************
+ */
+  else if (OptionMatch("lmp", *args)) {
+    int i;
+    if ((nargs > 1 && nargs < 4) || nargs > 4) {
+      printf("usage:  lmp <maxdepth> <base> <scale>\n");
+      return 1;
+    }
+    if (nargs > 1) {
+      LMP_depth = atoi(args[1]);
+      LMP_base = atoi(args[2]);
+      LMP_scale = atof(args[3]);
+      InitializeLMP();
+    }
+    Print(32, "LMP depth=%d  base=%d  scale=%f\n", LMP_depth, LMP_base,
+        LMP_scale);
+    Print(32, "depth:  ");
+    for (i = 1; i < 16; i++)
+      Print(32, "%4d", i);
+    Print(32, "\n");
+    Print(32, "movcnt: ");
+    for (i = 1; i < 16; i++)
+      Print(32, "%4d", LMP[i]);
+    Print(32, "\n");
+  }
 /*
  ************************************************************
  *                                                          *
  *  "lmr" command sets the formla parameters that produce   *
       LMR_min = atoi(args[1]);
       LMR_max = Min(atoi(args[2]), 15);
       LMR_db = atof(args[3]);
       LMR_mb = atof(args[4]);
       LMR_s = atof(args[5]);
-      InitializeReductions();
+      InitializeLMR();
+    }
     if (nargs > 6) {
       char *axis = "|||||||||||depth left|||||||||||";
       Print(32,
         for (j = 0; j < 64; j += 1)
           Print(32, " %2d", LMR[i][j]);
         Print(32, "\n");
+      }
     } else {
       char *axis = "||depth left|||";
       Print(32,
           "LMR values:  %d(min) %d(max) %.2f(depth) %.2f(moves) %.2f(scale).\n",
           LMR_min, LMR_max, LMR_db, LMR_mb, LMR_s);
       Print(32, "\n                 LMR reductions[depth][moves]\n");
       Print(32, "  ----------------------moves searched------------------\n");
       if (!strcmp(args[0], "setboard")) {
         Option(tree);
         break;
+      }
+    }
+    fclose(prob_file);
+  }
 /*
  ************************************************************
  *                                                          *
  *   "log" command turns log on/off, and also lets you view *
  *   to this file instead.                                  *
  *                                                          *
  ************************************************************
  */
   else if (OptionMatch("log", *args)) {
-    FILE *output_file;
-    char filename[64], buffer[128];
+    char filename[64];
     if (nargs < 2) {
       printf("usage:  log on|off|n [filename]\n");
       return 1;
+    }
       log_file = 0;
       sprintf(filename, "%s/log.%03d", log_path, log_id - 1);
       remove(filename);
       sprintf(filename, "%s/game.%03d", log_path, log_id - 1);
       remove(filename);
-    } else if (args[1][0] >= '0' && args[1][0] <= '9') {
+    } else if (args[1][0] >= '0' && args[1][0] <= '9')
-      if (log_id == 0)
-        log_id = atoi(args[1]);
+      log_id = atoi(args[1]);
-    } else {
-      char *eof;
-      FILE *log;
-      int nrecs, trecs, lrecs;
-      nrecs = atoi(args[1]);
-      output_file = stdout;
-      if (nargs > 2)
-        output_file = fopen(args[2], "w");
-      log = fopen(log_filename, "r");
-      for (trecs = 1; trecs < 99999999; trecs++) {
-        eof = fgets(buffer, 128, log);
-        if (eof) {
-          char *delim;
-          delim = strchr(buffer, '\n');
-          if (delim)
-            *delim = 0;
-          delim = strchr(buffer, '\r');
-          if (delim)
-            *delim = ' ';
-        } else
-          break;
-      }
-      fseek(log, 0, SEEK_SET);
-      for (lrecs = 1; lrecs < trecs - nrecs; lrecs++) {
-        eof = fgets(buffer, 128, log);
-        if (eof) {
-          char *delim;
-          delim = strchr(buffer, '\n');
-          if (delim)
-            *delim = 0;
-          delim = strchr(buffer, '\r');
-          if (delim)
-            *delim = ' ';
-        } else
-          break;
-      }
-      for (; lrecs < trecs; lrecs++) {
-        eof = fgets(buffer, 128, log);
-        if (eof) {
-          char *delim;
-          delim = strchr(buffer, '\n');
-          if (delim)
-            *delim = 0;
-          delim = strchr(buffer, '\r');
-          if (delim)
-            *delim = ' ';
-        } else
-          break;
-        fprintf(output_file, "%s\n", buffer);
-      }
-      if (output_file != stdout)
-        fclose(output_file);
-    }
+  }
 /*
  ************************************************************
  *                                                          *
  *   "memory" command is used to set the max memory to use  *
         book_weight_freq = 1.0;
         book_weight_eval = 0.5;
       } else if (!strcmp(args[1], "match")) {
         mode = normal_mode;
         book_weight_learn = 1.0;
-        book_weight_freq = 0.2f; // Pierre-Marie Baty -- added type cast
+        book_weight_freq = 0.2;
-        book_weight_eval = 0.1f; // Pierre-Marie Baty -- added type cast
+        book_weight_eval = 0.1;
       } else {
         printf("usage:  mode normal|tournament|match\n");
         mode = normal_mode;
         book_weight_learn = 1.0;
         book_weight_freq = 1.0;
  *  "new" command initializes for a new game.               *
  *                                                          *
  ************************************************************
  */
   else if (OptionMatch("new", *args)) {
-    new_game = 1;
-    if (thinking || pondering)
-      return 3;
-    if (smp_max_threads) {
-      int proc;
-      Print(32, "parallel threads terminated.\n");
+    Print(4095, "NOTICE:  ""new"" command not implemented, please exit and\n");
-      for (proc = 1; proc < CPUS; proc++)
-        thread[proc].terminate = 1;
+    Print(4095, "restart crafty to re-initialize everything for a new game\n");
-    }
-    NewGame(0);
-    return 3;
+    return 1;
+  }
 /*
  ************************************************************
  *                                                          *
  *  "noise" command sets a minimum limit on time searched   *
   else if (OptionMatch("noise", *args)) {
     if (nargs < 2) {
       printf("usage:  noise <n>\n");
       return 1;
+    }
-    noise_level = (int) (atof(args[1]) * 100); // Pierre-Marie Baty -- added type cast
+    noise_level = atof(args[1]) * 100;
     Print(32, "noise level set to %.2f seconds.\n",
         (float) noise_level / 100.0);
+  }
 /*
  ************************************************************
     if (!strchr(args[1], '(')) {
       if (strstr(args[0], "bookpath"))
         strcpy(book_path, args[1]);
       else if (strstr(args[0], "logpath"))
         strcpy(log_path, args[1]);
-#if !defined(NOEGTB)
+#if defined(SYZYGY)
       else if (strstr(args[0], "tbpath"))
         strcpy(tb_path, args[1]);
 #endif
     } else {
       if (strchr(args[1], ')')) {
         *strchr(args[1], ')') = 0;
         if (strstr(args[0], "bookpath"))
           strcpy(book_path, args[1] + 1);
         else if (strstr(args[0], "logpath"))
           strcpy(log_path, args[1] + 1);
-#if !defined(NOEGTB)
+#if defined(SYZYGY)
         else if (strstr(args[0], "tbpath"))
           strcpy(tb_path, args[1] + 1);
 #endif
       } else
         Print(4095, "ERROR multiple paths must be enclosed in ( and )\n");
     int pversion = atoi(args[1]);
     if (pversion >= 1 && pversion <= 3) {
       if (pversion >= 2) {
         Print(-1, "feature ping=1 setboard=1 san=1 time=1 draw=1\n");
-        Print(-1, "feature sigint=0 sigterm=0 reuse=1 analyze=1\n");
+        Print(-1, "feature sigint=0 sigterm=0 reuse=0 analyze=1\n");
         Print(-1, "feature myname=\"Crafty-%s\" name=1\n", version);
         Print(-1, "feature playother=1 colors=0 memory=%d\n", allow_memory);
 #if (CPUS > 1)
         Print(-1, "feature smp=%d\n", allow_cores);
 #endif
     mgw = tree->score_mg - mgw;
     egw = tree->score_eg - egw;
     tb = (mgb * phase + egb * (62 - phase)) / 62;
     tw = (mgw * phase + egw * (62 - phase)) / 62;
     Print(32, "kings..........%s  |", DisplayEvaluation(tb + tw, 1));
-    Print(32, " %s", DisplayEvaluation(tw, 1));
-    Print(32, " %s", DisplayEvaluation(mgw, 1));
-    Print(32, " %s  |", DisplayEvaluation(egw, 1));
-    Print(32, " %s", DisplayEvaluation(tb, 1));
-    Print(32, " %s", DisplayEvaluation(mgb, 1));
-    Print(32, " %s  |\n", DisplayEvaluation(egb, 1));
-    mgb = tree->score_mg;
-    egb = tree->score_eg;
-    EvaluateCastling(tree, 1, black);
-    mgb = tree->score_mg - mgb;
-    egb = tree->score_eg - egb;
-    mgw = tree->score_mg;
-    egw = tree->score_eg;
-    EvaluateCastling(tree, 1, white);
-    mgw = tree->score_mg - mgw;
-    egw = tree->score_eg - egw;
-    tb = (mgb * phase + egb * (62 - phase)) / 62;
-    tw = (mgw * phase + egw * (62 - phase)) / 62;
-    Print(32, "castling.......%s  |", DisplayEvaluation(tb + tw, 1));
     Print(32, " %s", DisplayEvaluation(tw, 1));
     Print(32, " %s", DisplayEvaluation(mgw, 1));
     Print(32, " %s  |", DisplayEvaluation(egw, 1));
     Print(32, " %s", DisplayEvaluation(tb, 1));
     Print(32, " %s", DisplayEvaluation(mgb, 1));
 /*
  ************************************************************
  *                                                          *
  *  "skill" command sets a value from 1-100 that affects    *
  *  Crafty's playing skill level.  100 => max skill, 1 =>   *
- *  minimal skill.  This is used to reduce the chess        *
+ *  minimal skill.  This is used to slow the search speed   *
- *  knowledge usage, along with other things.               *
+ *  (and depth) significantly.                              *
  *                                                          *
  ************************************************************
  */
 #if defined(SKILL)
   else if (OptionMatch("skill", *args)) {
       if (skill < 1 || skill > 100) {
         printf("ERROR: skill range is 1-100 only\n");
         skill = 100;
+      }
       Print(32, "skill level set to %d%%\n", skill);
-      null_depth = (null_depth * skill + 50) / 100;
-      if (skill < 100)
-        null_divisor = null_divisor + 2 * (100 - skill) / 10;
-      check_depth = (check_depth * skill + 50) / 100;
-      LMR_min = (LMR_min * skill + 50) / 100;
-      LMR_max = (LMR_max * skill + 50) / 100;
-      InitializeReductions();
+    }
+  }
 #endif
 /*
  ************************************************************
       return 3;
     allow_cores = 0;
     if (xboard)
       Print(4095, "Warning--  xboard 'cores' option disabled\n");
     smp_max_threads = atoi(args[1]);
+    if (smp_max_threads > hardware_processors) {
+      Print(4095, "ERROR - machine has %d processors.\n",
+          hardware_processors);
+      Print(4095, "ERROR - max threads can not exceed this limit.\n");
+      smp_max_threads = hardware_processors;
+    }
     if (smp_max_threads > CPUS) {
       Print(4095, "ERROR - Crafty was compiled with CPUS=%d.", CPUS);
       Print(4095, "  mt can not exceed this value.\n");
       smp_max_threads = CPUS;
+    }
     if (smp_max_threads)
       Print(32, "max threads set to %d.\n", smp_max_threads);
     else
       Print(32, "parallel threads disabled.\n");
     for (proc = 1; proc < CPUS; proc++)
-      if (proc >= (int) smp_max_threads) // Pierre-Marie Baty -- added type cast
+      if (proc >= smp_max_threads)
         thread[proc].terminate = 1;
   } else if (OptionMatch("smpnice", *args)) {
     if (nargs < 2) {
       printf("usage:  smpnice 0|1\n");
       return 1;
   else if (OptionMatch("st", *args)) {
     if (nargs < 2) {
       printf("usage:  st <time>\n");
       return 1;
+    }
-    search_time_limit = (int) (atof(args[1]) * 100); // Pierre-Marie Baty -- added type cast
+    search_time_limit = atof(args[1]) * 100;
     Print(32, "search time set to %.2f.\n",
         (float) search_time_limit / 100.0);
+  }
 /*
  ************************************************************

Subversion Repositories Games.Chess Giants

Games.Chess Giants//engine-crafty/option.c – Rev 108 → 154