engine.h

   1 /***************************************************************************
   2                           engine.h  -  description
   3                              -------------------
   4     begin                : mer ott 23 2002
   5     copyright            : (C) 2002-2005 by Maurizio Monge
   6     email                : monge@linuz.sns.it
   7  ***************************************************************************/
   8
   9 /***************************************************************************
  10  *                                                                         *
  11  *   This program is free software; you can redistribute it and/or modify  *
  12  *   it under the terms of the GNU General Public License as published by  *
  13  *   the Free Software Foundation; either version 2 of the License, or     *
  14  *   (at your option) any later version.                                   *
  15  *                                                                         *
  16  ***************************************************************************/
  17
  18 #ifndef __ENGINE_H__
  19 #define __ENGINE_H__
  20
  21
  22 #define PLAYING   1
  23 #define _10       2
  24 #define _01       3
  25 #define _12       4
  26
  27 //#define PLAYING   1
  28 #define ANALYZING 2
  29 #define FORCING   3
  30
  31 #define TIME_LIMIT  1
  32 #define DEPTH_LIMIT 2
  33 #define NODES_LIMIT 3
  34
  35
  36 #include <map>
  37 #include <string>
  38 #include <setjmp.h>
  39 #include "board.h"
  40
  41 class SearchGui;
  42 class SearchRoot;
  43
  44 class Engine
  45 {
  46 public:
  47     class Cmd;
  48     class Variable;
  49
  50     typedef std::map<std::string, Cmd> CmdSet;
  51     typedef std::map<std::string, Variable> VariableSet;
  52
  53     Board   board;
  54
  55     SearchGui* search_gui;
  56
  57     SearchRoot* current_root;
  58
  59     Move*   mv_done;
  60     int     mv_done_num;
  61
  62     SaveBuf *save_buf;
  63     int     save_buf_num;
  64
  65     /* the max depth of the engine */
  66     int     st_depth;
  67     int     st_nodes;
  68
  69     /* the color of the engine */
  70     uint8_t st_computer_color;
  71
  72     /* the time the engine will use to think */
  73     int     time_best_csec;
  74
  75     /* if there is a fixed time for a move, or else 0 */
  76     int     time_fixed;
  77
  78     /* time move per section, time per section and inc... */
  79     int     time_mps;
  80     int     time_base;
  81     int     time_inc;
  82
  83     /* clok and other clock in sec/100 */
  84     int     time_clock_csec;
  85     int     time_oth_clock_csec;
  86
  87     /* flags for options of the engine */
  88     int     analysis_limit;
  89
  90     bool     ponder;
  91     bool     post;
  92     //uint8_t  eng_color;
  93     uint64_t processed_nodes;
  94     int      max_think_time;
  95
  96     /* flag for output behaviour */
  97     bool    io_xboard;
  98     bool    io_san;
  99     bool    io_colors;
 100
 101     /* engine status */
 102     int         status;
 103     int         eng_status;
 104     const char *status_string;
 105     bool        thinking;
 106     int         start_think_time;
 107     uint8_t     analysis_color;
 108
 109     FILE    *log;
 110     CmdSet   commands;
 111     VariableSet   variables;
 112     jmp_buf  back;
 113
 114     HashEntry  *hash_table;
 115     void       *book_mmap;
 116     uint32_t    book_size;
 117
 118     typedef std::map<HashKey, std::map<Move, int> > Lines;
 119     Lines lines;
 120
 121     class OpeningInfo {
 122     public:
 123         const char *eco;
 124         const char *name;
 125         void set(const char* e, const char* n) {
 126             if(eco) free((void*)eco); if(name) free((void*)name);
 127             eco = e ? strdup(e) : NULL; name = n ? strdup(n) : NULL; }
 128         OpeningInfo(const OpeningInfo& o)
 129             : eco(o.eco ? strdup(o.eco) : NULL), name(o.name ? strdup(o.name) : NULL) {}
 130         OpeningInfo() : eco(NULL), name(NULL) {}
 131         ~OpeningInfo(){ if(eco) free((void*)eco); if(name) free((void*)name); }
 132     };
 133     typedef std::map<HashKey, OpeningInfo> Openings;
 134     Openings openings;
 135
 136     char     opponent[256];
 137     int      w_rating;
 138     int      b_rating;
 139
 140     static Engine* instance;
 141
 142     /* variables */
 143     int v_book_creation_max_depth;
 144     int v_book_creation_max_alternatives;
 145     int v_book_creation_min_games;
 146     int v_book_creation_min_probability;
 147     int v_book_creation_weigh_win;
 148     int v_book_creation_weigh_draw;
 149     int v_book_creation_weigh_lose;
 150
 151     int v_search_null_reduction;
 152     int v_search_threat_extension;
 153     int v_search_threat_threshold;
 154
 155     int v_eval_draw;
 156
 157     void cmd__check(int argc, char *argv[]);
 158     void cmd__attacks(int argc, char *argv[]);
 159     void cmd__see(int argc, char *argv[]);
 160     void cmd__shat(int argc, char *argv[]);
 161     void cmd__find_moves(int argc, char *argv[]);
 162     void cmd__gen_hash(int argc, char *argv[]);
 163     void cmd__gon(int argc, char *argv[]);
 164     void cmd__goff(int argc, char *argv[]);
 165     void cmd_quit(int argc, char *argv[]);
 166     void cmd_ping(int argc, char *argv[]);
 167     void cmd_bench(int argc, char *argv[]);
 168     void cmd_perft(int argc, char *argv[]);
 169     void cmd_perftall(int argc, char *argv[]);
 170     void cmd_sd(int argc, char *argv[]);
 171     void cmd_st(int argc, char *argv[]);
 172     void cmd_sn(int argc, char *argv[]);
 173     void cmd_otim(int argc, char *argv[]);
 174     void cmd_time(int argc, char *argv[]);
 175     void cmd_level(int argc, char *argv[]);
 176     void cmd_help(int argc, char *argv[]);
 177     void cmd_force(int argc, char *argv[]);
 178     void cmd_undo(int argc, char *argv[]);
 179     void cmd_remove(int argc, char *argv[]);
 180     void cmd_new(int argc, char *argv[]);
 181     void cmd_white(int argc, char *argv[]);
 182     void cmd_black(int argc, char *argv[]);
 183     void cmd_go(int argc, char *argv[]);
 184     void cmd_setboard(int argc, char *argv[]);
 185     void cmd_edit(int argc, char *argv[]);
 186     void cmd_load(int argc, char *argv[]);
 187     void cmd_save(int argc, char *argv[]);
 188     void cmd_load_pgn(int argc, char *argv[]);
 189     void cmd_epdtest(int argc, char *argv[]);
 190     void cmd_challenge(int argc, char *argv[]);
 191     void cmd_create_book(int argc, char *argv[]);
 192     void cmd_open_book(int argc, char *argv[]);
 193     void cmd_close_book(int argc, char *argv[]);
 194     void cmd_open_lines(int argc, char *argv[]);
 195     void cmd_close_lines(int argc, char *argv[]);
 196     void cmd_open_eco(int argc, char *argv[]);
 197     void cmd_close_eco(int argc, char *argv[]);
 198     void cmd_test(int argc, char *argv[]);
 199     void cmd_protover(int argc, char *argv[]);
 200     void cmd_accepted(int argc, char *argv[]);
 201     void cmd_rejected(int argc, char *argv[]);
 202     void cmd_xboard(int argc, char *argv[]);
 203     void cmd_analyze(int argc, char *argv[]);
 204     void cmd_exit(int argc, char *argv[]);
 205     void cmd_easy(int argc, char *argv[]);
 206     void cmd_hard(int argc, char *argv[]);
 207     void cmd_post(int argc, char *argv[]);
 208     void cmd_nopost(int argc, char *argv[]);
 209     void cmd_result(int argc, char *argv[]);
 210     void cmd_DOT(int argc, char *argv[]);
 211     void cmd_QUESTION(int argc, char *argv[]);
 212     void cmd_name(int argc, char *argv[]);
 213     void cmd_rating(int argc, char *argv[]);
 214     void cmd_var(int argc, char *argv[]);
 215     void cmd_varhelp(int argc, char *argv[]);
 216     void cmd_set(int argc, char *argv[]);
 217
 218     void create_hash();
 219     void reset_hash();
 220     void make_old_hash();
 221
 222     HashEntry* probe_hash(const HashKey& hk);
 223     void prefetch_hash(const HashKey& hk);
 224     void write_hash(const HashKey& hk, int16_t lo, int16_t up, int depth, int best_cont, bool no_good_moves);
 225
 226     bool check_time();
 227     bool check_draw();
 228     bool check_repetition(int nfold);
 229
 230     void print_stat();
 231     void move_now();
 232     static void sort_moves(Move* m,int num);
 233     static void incremental_sort_moves(Move* m,int num);
 234
 235     void calc_best_time();
 236
 237
 238     friend class Board;
 239
 240 public:
 241     Engine();
 242     static Engine *eng();
 243
 244     void run_command(int argc, char** argv);
 245     void load_ini();
 246
 247     uint8_t color_to_move();
 248     uint8_t computer_color();
 249     int  get_status();
 250     int  move_number();
 251
 252     void register_commands();
 253     void register_variables();
 254
 255     void process_input();
 256     void output(const char* fmt, ...) PRINTF(2, 3);
 257
 258     Move find_best_move();
 259
 260     void move(Move mv);
 261     void retract_move();
 262     void undo();
 263     void start();
 264     void start(unsigned char color);
 265     void force();
 266     void analyze();
 267     void do_ponder();
 268     void new_game();
 269     uint64_t perft(int lev);
 270     void set_depth(int depth);
 271     void set_max_nodes(int nodes);
 272     void set_time_control(int mps, int basesec, int inc);
 273     void set_time_fixed(int time);
 274     void set_my_clock(int time);
 275     void set_other_clock(int time);
 276
 277     /* io functions */
 278     void save_pgn(FILE *f, const char *result1, const char *result);
 279     void print_moves(Move* m, int num, bool nums=true, bool walk_ht=false);
 280     void print_board();        //prints colored board to stdout
 281     void read_board(char* brd, char* color, char* castle,
 282                     char* passing, int moves_to_draw, int num_moves);
 283     void read_board(char* str);//reads from f a Forsythe-Edwards notation board
 284     void read_board(FILE* f);  //reads from f a Forsythe-Edwards notation board
 285     void write_board(FILE* f); //writes to f a Forsythe-Edwards notation board
 286     int  load_pgn(FILE *f);
 287     int  run_epd_prog(const char* prog, int time, const char* file, bool quiet = true);
 288     void challenge(const char* prog, int time, const char* file);
 289
 290     void create_book(int argc, char *argv[]);
 291     bool open_book(const char *f);
 292     void close_book();
 293     Move probe_book(Board *b);
 294
 295     bool open_lines(const char *f);
 296     void close_lines();
 297     Move probe_lines(Board *b);
 298
 299     bool open_openings(const char *f);
 300     void close_openings();
 301     OpeningInfo* probe_openings(Board *b);
 302
 303     bool parse_command(char *str);
 304
 305     void autotune();
 306 };
 307
 308 #endif //__ENGINE_H__