bool pgn_next_game(pgn_t * pgn) {
char name[PGN_STRING_SIZE];
char value[PGN_STRING_SIZE];
ASSERT(pgn!=NULL);
// init
strcpy(pgn->result,"*");
strcpy(pgn->fen,"");
// loop
while (true) {
pgn_token_read(pgn);
if (pgn->token_type != '[') break;
// tag
pgn_token_read(pgn);
if (pgn->token_type != TOKEN_SYMBOL) {
my_fatal("pgn_next_game(): malformed tag at line %d, column %d\n",pgn->token_line,pgn->token_column);
}
strcpy(name,pgn->token_string);
pgn_token_read(pgn);
if (pgn->token_type != TOKEN_STRING) {
my_fatal("pgn_next_game(): malformed tag at line %d, column %d\n",pgn->token_line,pgn->token_column);
}
strcpy(value,pgn->token_string);
pgn_token_read(pgn);
if (pgn->token_type != ']') {
my_fatal("pgn_next_game(): malformed tag at line %d, column %d\n",pgn->token_line,pgn->token_column);
}
// special tag?
if (false) {
} else if (my_string_equal(name,"Result")) {
strcpy(pgn->result,value);
} else if (my_string_equal(name,"FEN")) {
strcpy(pgn->fen,value);
}
}
if (pgn->token_type == TOKEN_EOF) return false;
pgn_token_unread(pgn);
return true;
}
void uci_send_option(uci_t * uci, const char option[], const char format[], ...) {
va_list arg_list;
char value[StringSize];
int i;
option_t * opt;
ASSERT(uci_is_ok(uci));
ASSERT(option!=NULL);
ASSERT(format!=NULL);
// format
va_start(arg_list,format);
vsprintf(value,format,arg_list);
va_end(arg_list);
if (UseDebug) my_log("POLYGLOT OPTION %s VALUE %s\n",option,value);
// scan options
for (i = 0; i < uci->option_nb; i++) {
opt = &uci->option[i];
if (my_string_case_equal(opt->name,option) && !my_string_equal(opt->default_,value)) {
engine_send(uci->engine,"setoption name %s value %s",opt->name,value);
my_string_set(&opt->default_,value);
break;
}
}
}
void uci_set_option(uci_t * uci,
const char * name,
const char * default_,
const char * type,
const char * max,
const char * min,
int var_nb,
const char * var[]){
int i,j;
for(i=0;i<Uci->option_nb;i++){
if(my_string_equal(Uci->option[i].name,name)){
break;
}
}
if(i<OptionNb){
my_string_set(&(Uci->option[i].name),name);
my_string_set(&(Uci->option[i].default_),default_);
my_string_set(&(Uci->option[i].type),type);
my_string_set(&(Uci->option[i].min),min);
my_string_set(&(Uci->option[i].max),max);
Uci->option[i].var_nb=var_nb;
for(j=0;j<var_nb;j++){
my_string_set(&(Uci->option[i].var[j]),var[j]);
}
if(i==Uci->option_nb){
Uci->option_nb++;
}
}
}
static void parse_setoption(char string[]) {
const char * name;
char * value;
// init
name = strstr(string,"name ");
value = strstr(string,"value ");
if (name == NULL || value == NULL || name >= value) return; // ignore buttons
value[-1] = '\0'; // HACK
name += 5;
value += 6;
// update
option_set(name,value);
// update transposition-table size if needed
if (Init && my_string_equal(name,"Hash")) { // Init => already allocated
ASSERT(!Searching);
if (option_get_int("Hash") >= 4) {
trans_free(Trans);
trans_alloc(Trans);
}
}
}
bool option_get_bool(const char var[]) {
const char * val;
val = option_get(var);
if (false) {
} else if (my_string_case_equal(val,"true") || my_string_case_equal(val,"yes") || my_string_equal(val,"1")) {
return true;
} else if (my_string_case_equal(val,"false") || my_string_case_equal(val,"no") || my_string_equal(val,"0")) {
return false;
}
ASSERT(false);
return false;
}
static void parse_option() {
const char * file_name;
FILE * file;
char line[256];
char * name, * value;
file_name = option_get_string("OptionFile");
file = fopen(file_name,"r");
if (file == NULL) my_fatal("Can't open file \"%s\": %s\n",file_name,strerror(errno));
// PolyGlot options (assumed first)
while (true) {
if (!my_file_read_line(file,line,256)) {
my_fatal("parse_option(): missing [Engine] section\n");
}
if (my_string_case_equal(line,"[engine]")) break;
if (parse_line(line,&name,&value)) option_set(name,value);
}
if (option_get_bool("Log")) {
my_log_open(option_get_string("LogFile"));
}
my_log("POLYGLOT %s *** START ***\n",Version);
my_log("POLYGLOT INI file \"%s\"\n",file_name);
engine_open(Engine);
Init = true;
uci_open(Uci,Engine);
while (my_file_read_line(file,line,256)) {
if (line[0] == '[') my_fatal("parse_option(): unknown section %s\n",line);
if (parse_line(line,&name,&value)) {
uci_send_option(Uci,name,"%s",value);
//to get a decent display in winboard_x we need to now if an engine really is doing multipv analysis
// "multipv 1" in the pv is meaningless,f.i. toga sends that all the time
//therefore check if MultiPV is set to a decent value in the polyglot ini file
if(my_string_case_equal(name,"MultiPV") && atoi(value)>1) Uci->multipv_mode=true;
}
}
uci_send_isready(Uci);
fclose(file);
if (my_string_equal(option_get_string("EngineName"),"<empty>")) {
option_set("EngineName",Uci->name);
}
}
static void parse_id(uci_t * uci, const char string[]) {
parse_t parse[1];
char command[StringSize];
char option[StringSize];
char argument[StringSize];
ASSERT(uci!=NULL);
ASSERT(string!=NULL);
// init
strcpy(command,"id");
parse_open(parse,string);
parse_add_keyword(parse,"author");
parse_add_keyword(parse,"name");
// loop
while (parse_get_word(parse,option,StringSize)) {
parse_get_string(parse,argument,StringSize);
if (UseDebug) my_log("POLYGLOT COMMAND \"%s\" OPTION \"%s\" ARGUMENT \"%s\"\n",command,option,argument);
if (false) {
} else if (my_string_equal(option,"author")) {
ASSERT(!my_string_empty(argument));
my_string_set(&uci->author,argument);
} else if (my_string_equal(option,"name")) {
ASSERT(!my_string_empty(argument));
my_string_set(&uci->name,argument);
} else {
my_log("POLYGLOT unknown option \"%s\" for command \"%s\"\n",option,command);
}
}
parse_close(parse);
if (UseDebug) my_log("POLYGLOT engine name \"%s\" author \"%s\"\n",uci->name,uci->author);
}
static bool string_contain(const char string[], const char substring[]) {
char new_string[StringSize], *p;
strcpy(new_string,string); // HACK
for (p = strtok(new_string," "); p != NULL; p = strtok(NULL," ")) {
if (my_string_equal(p,substring)) return true;
}
return false;
}
static option_t * option_find(const char var[]) {
option_t * opt;
ASSERT(var!=NULL);
for (opt = &Option[0]; opt->var != NULL; opt++) {
if (my_string_equal(opt->var,var)) return opt;
}
return NULL;
}
void format_xboard_option_line(char * option_line, option_t *opt){
int j;
char option_string[StringSize];
char *tmp;
strcpy(option_line,"");
// buffer overflow alert
strcat(option_line,"feature option=\"");
if(opt->mode&PG){
strcat(option_line,"Polyglot ");
}
sprintf(option_string,"%s",opt->name);
strcat(option_line,option_string);
sprintf(option_string," -%s",opt->type);
strcat(option_line,option_string);
if(!IS_BUTTON(opt->type) && strcmp(opt->type,"combo")){
if(strcmp(opt->type,"check")){
sprintf(option_string," %s",opt->value);
}else{
sprintf(option_string," %d",
my_string_case_equal(opt->value,"true")||
my_string_equal(opt->value,"1")
?1:0);
}
strcat(option_line,option_string);
}
if(IS_SPIN(opt->type)){
sprintf(option_string," %s",opt->min);
strcat(option_line,option_string);
}
if(IS_SPIN(opt->type)){
sprintf(option_string," %s",opt->max);
strcat(option_line,option_string);
}
for(j=0;j<opt->var_nb;j++){
if(!strcmp(opt->var[j],opt->value)){
sprintf(option_string," *%s",opt->var[j]);
}else{
sprintf(option_string," %s",opt->var[j]);
}
strcat(option_line,option_string);
if(j!=opt->var_nb-1){
strcat(option_line," ///");
}
}
strcat(option_line,"\"");
if(option_get_bool(Option,"WbWorkArounds") &&
(tmp=strstr(option_line,"Draw"))){
*tmp='d';
my_log("POLYGLOT Decapitalizing \"Draw\" in option \"%s\"\n",
opt->name);
}
}
int move_from_san_debug(const char string[], const board_t * board) {
list_t list[1];
int i, move;
char move_string[256];
ASSERT(string!=NULL);
ASSERT(board_is_ok(board));
gen_legal_moves(list,board);
for (i = 0; i < list_size(list); i++) {
move = list_move(list,i);
if (!move_to_san(move,board,move_string,256)) ASSERT(false);
if (my_string_equal(move_string,string)) return move;
}
return MoveNone;
}
void egbb_path(const char path[]) {
char c;
ASSERT(path!=NULL);
// init
if (Egbb->init == 0) return;
// verify
if (!my_string_empty(path)) {
if (strlen(path) >= 256-2) {
my_fatal("egbb_path(): String to long\n");
}
if (my_string_equal(path,"<empty>")) return;
// set
strncpy(Egbb->path,path,256);
// verify
c = Egbb->path[strlen(path)-1];
if (c != '/' && c != '\\') {
if (strchr(Egbb->path, '\\') != NULL) {
strcat(Egbb->path, "\\");
} else {
strcat(Egbb->path, "/");
}
}
// load
load_egbb_ptr(Egbb->path,Egbb->size,LOAD_SMART);
Egbb->load = true;
Egbb->piece_nb = 5; // HACK: assume 5-piece table
}
}
bool option_set_default(option_list_t *option,
const char name[],
const char value[]) {
option_t * opt;
ASSERT(name!=NULL);
ASSERT(value!=NULL);
opt = option_find(option,name);
if (opt == NULL) return FALSE;
if(my_string_case_equal(opt->type,"check")){
value=(my_string_equal(value,"1")||
my_string_case_equal(value,"true"))?"true":"false";
}
my_string_set(&opt->default_,value);
if (UseDebug) my_log("POLYGLOT OPTION DEFAULT SET \"%s\" -> \"%s\"\n",opt->name,opt->default_);
return TRUE;
}
int main(int argc, char * argv[]) {
// board_t board[1];
// init
Init = false;
#ifdef _WIN32
signal(SIGINT,SIG_IGN);
signal(SIGTERM,SIG_IGN);
#ifdef SIGPIPE
signal(SIGPIPE,SIG_IGN);
#endif
#endif
util_init();
printf("PolyGlot %s by Fabien Letouzey\n",Version);
option_init();
uci_options_init();
square_init();
piece_init();
attack_init();
hash_init();
my_random_init();
// build book
if (argc >= 2 && my_string_equal(argv[1],"make-book")) {
book_make(argc,argv);
return EXIT_SUCCESS;
}
if (argc >= 2 && my_string_equal(argv[1],"merge-book")) {
book_merge(argc,argv);
return EXIT_SUCCESS;
}
// read options
if (argc == 2) option_set("OptionFile",argv[1]); // HACK for compatibility
parse_option(); // HACK: also launches the engine
// EPD test
if (argc >= 2 && my_string_equal(argv[1],"epd-test")) {
epd_test(argc,argv);
return EXIT_SUCCESS;
}
// opening book
book_clear();
if (option_get_bool("Book")){
if (book_open(option_get_string("BookFile")))
option_set("Book","false");//some error,set to false
}
//adapter_loop();
#ifdef _WIN32
Engine_ready_ok=CreateEvent(NULL,FALSE,FALSE,NULL);
Engine_sync_stop = CreateEvent(NULL,FALSE,FALSE,NULL);
// all set and done.lets open a thread for fun
DWORD dwThreadID;
HANDLE hThread;
hThread= CreateThread(
NULL, //default security attributes
0, //default stacksize
ThreadFunc, //The thread function!
&sCommand, //the commands for the thread function
0, //default creation flags
&dwThreadID); //the thread identifier
Idle500msecs();//
if(hThread==NULL){
my_log("CreateThread failed\n");
}
#endif
adapter_loop();
engine_send(Engine,"quit");
engine_close(Engine);
#ifdef _WIN32
CloseHandle(hThread); //close the thread;
#endif
return EXIT_SUCCESS;
}
static void parse_score(uci_t * uci, const char string[]) {
parse_t parse[1];
char command[StringSize];
char option[StringSize];
char argument[StringSize];
int n;
ASSERT(uci_is_ok(uci));
ASSERT(string!=NULL);
// init
strcpy(command,"score");
parse_open(parse,string);
parse_add_keyword(parse,"cp");
parse_add_keyword(parse,"lowerbound");
parse_add_keyword(parse,"mate");
parse_add_keyword(parse,"upperbound");
// loop
while (parse_get_word(parse,option,StringSize)) {
parse_get_string(parse,argument,StringSize);
if (UseDebug) my_log("POLYGLOT COMMAND \"%s\" OPTION \"%s\" ARGUMENT \"%s\"\n",command,option,argument);
if (false) {
} else if (my_string_equal(option,"cp")) {
ASSERT(!my_string_empty(argument));
n = atoi(argument);
uci->score = n;
} else if (my_string_equal(option,"lowerbound")) {
ASSERT(my_string_empty(argument));
} else if (my_string_equal(option,"mate")) {
ASSERT(!my_string_empty(argument));
n = atoi(argument);
ASSERT(n!=0);
uci->score = mate_score(n);
} else if (my_string_equal(option,"upperbound")) {
ASSERT(my_string_empty(argument));
} else {
my_log("POLYGLOT unknown option \"%s\" for command \"%s\"\n",option,command);
}
}
parse_close(parse);
}
static void parse_option(uci_t * uci, const char string[]) {
option_t * opt;
parse_t parse[1];
char command[StringSize];
char option[StringSize];
char argument[StringSize];
ASSERT(uci!=NULL);
ASSERT(string!=NULL);
// init
strcpy(command,"option");
if (uci->option_nb >= OptionNb) return;
opt = &uci->option[uci->option_nb];
uci->option_nb++;
opt->value=NULL;
my_string_set(&opt->value,"<empty>");
opt->mode=0;
opt->name = NULL;
my_string_set(&opt->name,"<empty>");
opt->default_ = NULL;
my_string_set(&opt->default_,"<empty>");
opt->max = NULL;
my_string_set(&opt->max,"<empty>");
opt->min = NULL;
my_string_set(&opt->min,"<empty>");
opt->type = NULL;
my_string_set(&opt->type,"<empty>");
opt->var_nb=0;
parse_open(parse,string);
parse_add_keyword(parse,"default");
parse_add_keyword(parse,"max");
parse_add_keyword(parse,"min");
parse_add_keyword(parse,"name");
parse_add_keyword(parse,"type");
parse_add_keyword(parse,"var");
// loop
while (parse_get_word(parse,option,StringSize)) {
parse_get_string(parse,argument,StringSize);
if (UseDebug) my_log("POLYGLOT COMMAND \"%s\" OPTION \"%s\" ARGUMENT \"%s\"\n",command,option,argument);
if (false) {
} else if (my_string_equal(option,"default")) {
// ASSERT(!my_string_empty(argument)); // HACK for Pepito
if (!my_string_empty(argument)) {
my_string_set(&opt->default_,argument);
my_string_set(&opt->value,argument);
}
} else if (my_string_equal(option,"max")) {
ASSERT(!my_string_empty(argument));
my_string_set(&opt->max,argument);
} else if (my_string_equal(option,"min")) {
ASSERT(!my_string_empty(argument));
my_string_set(&opt->min,argument);
} else if (my_string_equal(option,"name")) {
ASSERT(!my_string_empty(argument));
if (!my_string_empty(argument)) {
my_string_set(&opt->name,argument);
}
} else if (my_string_equal(option,"type")) {
ASSERT(!my_string_empty(argument));
my_string_set(&opt->type,argument);
} else if (my_string_equal(option,"var")) {
ASSERT(!my_string_empty(argument));
my_string_set(&opt->var[opt->var_nb++],argument);
if(opt->var_nb==VarNb) break;
} else {
my_log("POLYGLOT unknown option \"%s\" for command \"%s\"\n",option,command);
}
}
parse_close(parse);
if (UseDebug) my_log("POLYGLOT option name \"%s\" default \"%s\"\n",opt->name,opt->default_);
}
void search_full_init(list_t * list, board_t * board, int ThreadId) {
const char * string;
int trans_move, trans_depth, trans_flags, trans_value;
int i, j;
entry_t * found_entry;
ASSERT(list_is_ok(list));
ASSERT(board_is_ok(board));
// null-move options
string = option_get_string("NullMove Pruning");
if (false) {
} else if (my_string_equal(string,"Always")) {
UseNull = true;
UseNullEval = false;
} else if (my_string_equal(string,"Fail High")) {
UseNull = true;
UseNullEval = true;
} else if (my_string_equal(string,"Never")) {
UseNull = false;
UseNullEval = false;
} else {
ASSERT(false);
UseNull = true;
UseNullEval = true;
}
NullReduction = option_get_int("NullMove Reduction");
string = option_get_string("Verification Search");
if (false) {
} else if (my_string_equal(string,"Always")) {
UseVer = true;
UseVerEndgame = false;
} else if (my_string_equal(string,"Endgame")) {
UseVer = true;
UseVerEndgame = true;
} else if (my_string_equal(string,"Never")) {
UseVer = false;
UseVerEndgame = false;
} else {
ASSERT(false);
UseVer = true;
UseVerEndgame = true;
}
VerReduction = option_get_int("Verification Reduction");
// history-pruning options
UseHistory = option_get_bool("History Pruning");
HistoryValue = (option_get_int("History Threshold") * 16384 + 50) / 100;
// Stockfish Late Move Reductions
// about 20 elo better than previous Toga History Reductions
for (i = 0; i < 64; i++){
for (j = 0; j < 64; j++){
if (i == 0 || j == 0){
quietPvMoveReduction[i][j] = quietMoveReduction[i][j] = 0;
}
else{
double pvReduction =
log((double) (i)) * log((double) (j)) / 3.0;
double nonPvReduction =
(1.0 + log((double) (i))) * log((double) (j)) / 2.5; // JD
quietPvMoveReduction[i][j] =
(int) (pvReduction >= 1.0 ?
floor(pvReduction) : 0);
quietMoveReduction[i][j] =
(int) (nonPvReduction >= 1.0 ?
floor(nonPvReduction) : 0);
}
}
}
// futility-pruning options
UseFutility = option_get_bool("Futility Pruning");
FutilityMargin1 = option_get_int("Futility Margin");
FutilityMargin2 = option_get_int("Extended Futility Margin");
// delta-pruning options
UseDelta = option_get_bool("Delta Pruning");
DeltaMargin = option_get_int("Delta Margin");
// quiescence-search options
SearchCurrent[ThreadId]->CheckNb = option_get_int("Quiescence Check Plies");
SearchCurrent[ThreadId]->CheckDepth = 1 - SearchCurrent[ThreadId]->CheckNb;
// standard sort
list_note(list);
list_sort(list);
// misc
SearchCurrent[ThreadId]->last_move = MoveNone;
// basic sort
trans_move = MoveNone;
if (UseTrans) trans_retrieve(Trans,&found_entry,board->key,&trans_move,&trans_depth,&trans_flags,&trans_value);
note_moves(list,board,0,trans_move,ThreadId);
list_sort(list);
}
static int parse_info(uci_t * uci, const char string[]) {
int event;
parse_t parse[1];
char command[StringSize];
char option[StringSize];
char argument[StringSize];
int n;
int multipvline=0;
sint64 ln;
ASSERT(uci_is_ok(uci));
ASSERT(string!=NULL);
// init
event = EVENT_NONE;
strcpy(command,"info");
parse_open(parse,string);
parse_add_keyword(parse,"cpuload");
parse_add_keyword(parse,"currline");
parse_add_keyword(parse,"currmove");
parse_add_keyword(parse,"currmovenumber");
parse_add_keyword(parse,"depth");
parse_add_keyword(parse,"hashfull");
parse_add_keyword(parse,"multipv");
parse_add_keyword(parse,"nodes");
parse_add_keyword(parse,"nps");
parse_add_keyword(parse,"pv");
parse_add_keyword(parse,"refutation");
parse_add_keyword(parse,"score");
parse_add_keyword(parse,"seldepth");
parse_add_keyword(parse,"string");
parse_add_keyword(parse,"tbhits");
parse_add_keyword(parse,"time");
// loop
while (parse_get_word(parse,option,StringSize)) {
parse_get_string(parse,argument,StringSize);
if (UseDebug) my_log("POLYGLOT COMMAND \"%s\" OPTION \"%s\" ARGUMENT \"%s\"\n",command,option,argument);
if (false) {
} else if (my_string_equal(option,"cpuload")) {
ASSERT(!my_string_empty(argument));
n = atoi(argument);
ASSERT(n>=0);
if (n >= 0) uci->cpu = double(n) / 1000.0;
} else if (my_string_equal(option,"currline")) {
ASSERT(!my_string_empty(argument));
line_from_can(uci->current_line,uci->board,argument,LineSize);
} else if (my_string_equal(option,"currmove")) {
ASSERT(!my_string_empty(argument));
uci->root_move = move_from_can(argument,uci->board);
ASSERT(uci->root_move!=MoveNone);
} else if (my_string_equal(option,"currmovenumber")) {
ASSERT(!my_string_empty(argument));
n = atoi(argument);
ASSERT(n>=1&&n<=uci->root_move_nb);
if (n >= 1 && n <= uci->root_move_nb) {
uci->root_move_pos = n - 1;
ASSERT(uci->root_move_pos>=0&&uci->root_move_pos<uci->root_move_nb);
}
} else if (my_string_equal(option,"depth")) {
ASSERT(!my_string_empty(argument));
n = atoi(argument);
ASSERT(n>=1);
if (n >= 0) {
if (n > uci->depth) event |= EVENT_DEPTH;
uci->depth = n;
}
} else if (my_string_equal(option,"hashfull")) {
ASSERT(!my_string_empty(argument));
n = atoi(argument);
ASSERT(n>=0);
if (n >= 0) uci->hash = double(n) / 1000.0;
} else if (my_string_equal(option,"multipv")) {
ASSERT(!my_string_empty(argument));
n = atoi(argument);
if(Uci->multipv_mode) multipvline=n;
ASSERT(n>=1);
} else if (my_string_equal(option,"nodes")) {
ASSERT(!my_string_empty(argument));
ln = my_atoll(argument);
ASSERT(ln>=0);
if (ln >= 0) uci->node_nb = ln;
} else if (my_string_equal(option,"nps")) {
ASSERT(!my_string_empty(argument));
n = atoi(argument);
ASSERT(n>=0);
if (n >= 0) uci->speed = double(n);
} else if (my_string_equal(option,"pv")) {
ASSERT(!my_string_empty(argument));
line_from_can(uci->pv,uci->board,argument,LineSize);
event |= EVENT_PV;
} else if (my_string_equal(option,"refutation")) {
ASSERT(!my_string_empty(argument));
line_from_can(uci->pv,uci->board,argument,LineSize);
} else if (my_string_equal(option,"score")) {
ASSERT(!my_string_empty(argument));
parse_score(uci,argument);
} else if (my_string_equal(option,"seldepth")) {
ASSERT(!my_string_empty(argument));
n = atoi(argument);
ASSERT(n>=0);
if (n >= 0) uci->sel_depth = n;
} else if (my_string_equal(option,"string")) {
if(!strncmp(argument,"DrawOffer",9))
event |= EVENT_DRAW;
if(!strncmp(argument,"Resign",6))
event |= EVENT_RESIGN;
// TODO: argument to EOS
ASSERT(!my_string_empty(argument));
} else if (my_string_equal(option,"tbhits")) {
ASSERT(!my_string_empty(argument));
ln = my_atoll(argument);
ASSERT(ln>=0);
} else if (my_string_equal(option,"time")) {
ASSERT(!my_string_empty(argument));
n = atoi(argument);
ASSERT(n>=0);
if (n >= 0) uci->time = double(n) / 1000.0;
} else {
my_log("POLYGLOT unknown option \"%s\" for command \"%s\"\n",option,command);
}
}
parse_close(parse);
// update display
//lousy uci,filter out lower depth multipv lines that have been repeated from the engine
if(multipvline>1 && uci->depth<uci->best_depth) event &= ~EVENT_PV;
if ((event & EVENT_PV) != 0) {
uci->best_score = uci->score;
uci->best_depth = uci->depth;
if(multipvline==1)uci->depth=-1; //HACK ,clears the engine outpout window,see send_pv in adapter.cpp
uci->best_sel_depth = uci->sel_depth;
line_copy(uci->best_pv,uci->pv);
}
return event;
}
static void pgn_read_token(pgn_t * pgn) {
ASSERT(pgn!=NULL);
// skip white-space characters
pgn_skip_blanks(pgn);
// init
pgn->token_type = TOKEN_ERROR;
strcpy(pgn->token_string,"");
pgn->token_length = 0;
pgn->token_line = pgn->char_line;
pgn->token_column = pgn->char_column;
// determine token type
if (false) {
} else if (pgn->char_hack == CHAR_EOF) {
pgn->token_type = TOKEN_EOF;
} else if (strchr(".[]()<>",pgn->char_hack) != NULL) {
// single-character token
pgn->token_type = pgn->char_hack;
sprintf(pgn->token_string,"%c",pgn->char_hack);
pgn->token_length = 1;
} else if (pgn->char_hack == '*') {
pgn->token_type = TOKEN_RESULT;
sprintf(pgn->token_string,"%c",pgn->char_hack);
pgn->token_length = 1;
} else if (pgn->char_hack == '!') {
pgn_char_read(pgn);
if (false) {
} else if (pgn->char_hack == '!') { // "!!"
pgn->token_type = TOKEN_NAG;
strcpy(pgn->token_string,"3");
pgn->token_length = 1;
} else if (pgn->char_hack == '?') { // "!?"
pgn->token_type = TOKEN_NAG;
strcpy(pgn->token_string,"5");
pgn->token_length = 1;
} else { // "!"
pgn_char_unread(pgn);
pgn->token_type = TOKEN_NAG;
strcpy(pgn->token_string,"1");
pgn->token_length = 1;
}
} else if (pgn->char_hack == '?') {
pgn_char_read(pgn);
if (false) {
} else if (pgn->char_hack == '?') { // "??"
pgn->token_type = TOKEN_NAG;
strcpy(pgn->token_string,"4");
pgn->token_length = 1;
} else if (pgn->char_hack == '!') { // "?!"
pgn->token_type = TOKEN_NAG;
strcpy(pgn->token_string,"6");
pgn->token_length = 1;
} else { // "?"
pgn_char_unread(pgn);
pgn->token_type = TOKEN_NAG;
strcpy(pgn->token_string,"2");
pgn->token_length = 1;
}
} else if (is_symbol_start(pgn->char_hack)) {
// symbol, integer, or result
pgn->token_type = TOKEN_INTEGER;
pgn->token_length = 0;
do {
if (pgn->token_length >= PGN_STRING_SIZE-1) {
my_fatal("pgn_read_token(): symbol too long at line %d, column %d\n",pgn->char_line,pgn->char_column);
}
if (!isdigit(pgn->char_hack)) pgn->token_type = TOKEN_SYMBOL;
pgn->token_string[pgn->token_length++] = pgn->char_hack;
pgn_char_read(pgn);
} while (is_symbol_next(pgn->char_hack));
pgn_char_unread(pgn);
ASSERT(pgn->token_length>0&&pgn->token_length<PGN_STRING_SIZE);
pgn->token_string[pgn->token_length] = '\0';
if (my_string_equal(pgn->token_string,"1-0")
|| my_string_equal(pgn->token_string,"0-1")
|| my_string_equal(pgn->token_string,"1/2-1/2")) {
pgn->token_type = TOKEN_RESULT;
}
} else if (pgn->char_hack == '"') {
// string
pgn->token_type = TOKEN_STRING;
pgn->token_length = 0;
while (true) {
pgn_char_read(pgn);
if (pgn->char_hack == CHAR_EOF) {
my_fatal("pgn_read_token(): EOF in string at line %d, column %d\n",pgn->char_line,pgn->char_column);
}
if (pgn->char_hack == '"') break;
if (pgn->char_hack == '\\') {
pgn_char_read(pgn);
if (pgn->char_hack == CHAR_EOF) {
my_fatal("pgn_read_token(): EOF in string at line %d, column %d\n",pgn->char_line,pgn->char_column);
}
if (pgn->char_hack != '"' && pgn->char_hack != '\\') {
// bad escape, ignore
if (pgn->token_length >= PGN_STRING_SIZE-1) {
my_fatal("pgn_read_token(): string too long at line %d, column %d\n",pgn->char_line,pgn->char_column);
}
pgn->token_string[pgn->token_length++] = '\\';
}
}
if (pgn->token_length >= PGN_STRING_SIZE-1) {
my_fatal("pgn_read_token(): string too long at line %d, column %d\n",pgn->char_line,pgn->char_column);
}
pgn->token_string[pgn->token_length++] = pgn->char_hack;
}
ASSERT(pgn->token_length>=0&&pgn->token_length<PGN_STRING_SIZE);
pgn->token_string[pgn->token_length] = '\0';
} else if (pgn->char_hack == '$') {
// NAG
pgn->token_type = TOKEN_NAG;
pgn->token_length = 0;
while (true) {
pgn_char_read(pgn);
if (!isdigit(pgn->char_hack)) break;
if (pgn->token_length >= 3) {
my_fatal("pgn_read_token(): NAG too long at line %d, column %d\n",pgn->char_line,pgn->char_column);
}
pgn->token_string[pgn->token_length++] = pgn->char_hack;
}
pgn_char_unread(pgn);
if (pgn->token_length == 0) {
my_fatal("pgn_read_token(): malformed NAG at line %d, column %d\n",pgn->char_line,pgn->char_column);
}
ASSERT(pgn->token_length>0&&pgn->token_length<=3);
pgn->token_string[pgn->token_length] = '\0';
} else {
// unknown token
// my_fatal("lexical error at line %d, column %d\n",pgn->char_line,pgn->char_column);
}
}
static int parse_bestmove(uci_t * uci, const char string[]) {
parse_t parse[1];
char command[StringSize];
char option[StringSize];
char argument[StringSize];
board_t board[1];
ASSERT(uci_is_ok(uci));
ASSERT(string!=NULL);
// init
strcpy(command,"bestmove");
parse_open(parse,string);
parse_add_keyword(parse,"ponder");
// bestmove
if (!parse_get_string(parse,argument,StringSize)) {
my_fatal("parse_bestmove(): missing argument\n");
}
uci->best_move = move_from_can(argument,uci->board);
if (uci->best_move == MoveNone) my_fatal("parse_bestmove(): not a move \"%s\"\n",argument);
ASSERT(uci->best_move!=MoveNone);
ASSERT(move_is_legal(uci->best_move,uci->board));
// loop
while (parse_get_word(parse,option,StringSize)) {
parse_get_string(parse,argument,StringSize);
if (UseDebug) my_log("POLYGLOT COMMAND \"%s\" OPTION \"%s\" ARGUMENT \"%s\"\n",command,option,argument);
if (false) {
} else if (my_string_equal(option,"ponder")) {
ASSERT(!my_string_empty(argument));
board_copy(board,uci->board);
move_do(board,uci->best_move);
uci->ponder_move = move_from_can(argument,board);
// if (uci->ponder_move == MoveNone) my_fatal("parse_bestmove(): not a move \"%s\"\n",argument);
ASSERT(uci->ponder_move!=MoveNone);
ASSERT(move_is_legal(uci->ponder_move,board));
} else {
my_log("POLYGLOT unknown option \"%s\" for command \"%s\"\n",option,command);
}
}
parse_close(parse);
return EVENT_MOVE;
}
static void xboard_step() {
char string[StringSize];
int move;
char move_string[256];
board_t board[1];
xboard_get(XBoard,string,StringSize);
if (false) {
} else if (match(string,"accepted *")) {
// ignore
} else if (match(string,"analyze")) {
State->computer[White] = false;
State->computer[Black] = false;
XB->analyse = true;
XB->new_hack = false;
ASSERT(!XB->result);
XB->result = false;
mess();
} else if (match(string,"bk")) {
if (option_get_bool("Book")) {
game_get_board(Game,board);
book_disp(board);
}
} else if (match(string,"black")) {
if (colour_is_black(game_turn(Game))) {
State->computer[White] = true;
State->computer[Black] = false;
XB->new_hack = true;
XB->result = false;
mess();
}
} else if (match(string,"computer")) {
XB->computer = true;
} else if (match(string,"draw")) {
// ignore
} else if (match(string,"easy")) {
XB->ponder = false;
mess();
} else if (match(string,"edit")) {
// refuse
xboard_send(XBoard,"Error (unknown command): %s",string);
} else if (match(string,"exit")) {
State->computer[White] = false;
State->computer[Black] = false;
XB->analyse = false;
mess();
} else if (match(string,"force")) {
State->computer[White] = false;
State->computer[Black] = false;
mess();
} else if (match(string,"go")) {
State->computer[game_turn(Game)] = true;
State->computer[colour_opp(game_turn(Game))] = false;
XB->new_hack = false;
ASSERT(!XB->result);
XB->result = false;
mess();
} else if (match(string,"hard")) {
XB->ponder = true;
mess();
} else if (match(string,"hint")) {
if (option_get_bool("Book")) {
game_get_board(Game,board);
move = book_move(board,false);
if (move != MoveNone && move_is_legal(move,board)) {
move_to_san(move,board,move_string,256);
xboard_send(XBoard,"Hint: %s",move_string);
}
}
} else if (match(string,"ics *")) {
XB->ics = true;
} else if (match(string,"level * *:* *")) {
XB->mps = atoi(Star[0]);
XB->base = double(atoi(Star[1])) * 60.0 + double(atoi(Star[2]));
XB->inc = double(atoi(Star[3]));
} else if (match(string,"level * * *")) {
XB->mps = atoi(Star[0]);
XB->base = double(atoi(Star[1])) * 60.0;
XB->inc = double(atoi(Star[2]));
} else if (match(string,"name *")) {
my_string_set(&XB->name,Star[0]);
} else if (match(string,"new")) {
my_log("POLYGLOT NEW GAME\n");
option_set("Chess960","false");
game_clear(Game);
if (XB->analyse) {
State->computer[White] = false;
State->computer[Black] = false;
} else {
State->computer[White] = false;
State->computer[Black] = true;
}
XB->new_hack = true;
XB->result = false;
XB->depth_limit = false;
XB->computer = false;
my_string_set(&XB->name,"<empty>");
board_update();
mess();
uci_send_ucinewgame(Uci);
} else if (match(string,"nopost")) {
XB->post = false;
} else if (match(string,"otim *")) {
XB->opp_time = double(atoi(Star[0])) / 100.0;
if (XB->opp_time < 0.0) XB->opp_time = 0.0;
} else if (match(string,"pause")) {
// refuse
xboard_send(XBoard,"Error (unknown command): %s",string);
} else if (match(string,"ping *")) {
// HACK; TODO: answer only after an engine move
if (DelayPong) {
if (XB->ping >= 0) xboard_send(XBoard,"pong %d",XB->ping); // HACK: get rid of old ping
XB->ping = atoi(Star[0]);
uci_send_isready(Uci);
} else {
ASSERT(XB->ping==-1);
xboard_send(XBoard,"pong %s",Star[0]);
}
} else if (match(string,"playother")) {
State->computer[game_turn(Game)] = false;
State->computer[colour_opp(game_turn(Game))] = true;
XB->new_hack = false;
ASSERT(!XB->result);
XB->result = false;
mess();
} else if (match(string,"post")) {
XB->post = true;
} else if (match(string,"protover *")) {
XB->proto_ver = atoi(Star[0]);
ASSERT(XB->proto_ver>=2);
xboard_send(XBoard,"feature done=0");
xboard_send(XBoard,"feature analyze=1");
xboard_send(XBoard,"feature colors=0");
xboard_send(XBoard,"feature draw=1");
xboard_send(XBoard,"feature ics=1");
xboard_send(XBoard,"feature myname=\"%s\"",option_get_string("EngineName"));
xboard_send(XBoard,"feature name=1");
xboard_send(XBoard,"feature pause=0");
xboard_send(XBoard,"feature ping=1");
xboard_send(XBoard,"feature playother=1");
xboard_send(XBoard,"feature reuse=1");
xboard_send(XBoard,"feature san=0");
xboard_send(XBoard,"feature setboard=1");
xboard_send(XBoard,"feature sigint=0");
xboard_send(XBoard,"feature sigterm=0");
xboard_send(XBoard,"feature time=1");
xboard_send(XBoard,"feature usermove=1");
if (uci_option_exist(Uci,"UCI_Chess960")) {
xboard_send(XBoard,"feature variants=\"normal,fischerandom\"");
} else {
xboard_send(XBoard,"feature variants=\"normal\"");
}
if (Uci->ready) xboard_send(XBoard,"feature done=1");
// otherwise "feature done=1" will be sent when the engine is ready
} else if (match(string,"quit")) {
my_log("POLYGLOT *** \"quit\" from XBoard ***\n");
quit();
} else if (match(string,"random")) {
// ignore
} else if (match(string,"rating * *")) {
// ignore
} else if (match(string,"remove")) {
if (game_pos(Game) >= 2) {
game_goto(Game,game_pos(Game)-2);
ASSERT(!XB->new_hack);
XB->new_hack = false; // HACK?
XB->result = false;
board_update();
mess();
}
} else if (match(string,"rejected *")) {
// ignore
} else if (match(string,"reset")) { // protover 3?
// refuse
xboard_send(XBoard,"Error (unknown command): %s",string);
} else if (false
|| match(string,"result * {*}")
|| match(string,"result * {* }")
|| match(string,"result * { *}")
|| match(string,"result * { * }")) {
my_log("POLYGLOT GAME END\n");
XB->result = true;
mess();
// book learning
if (option_get_bool("Book") && option_get_bool("BookLearn")) {
if (false) {
} else if (my_string_equal(Star[0],"1-0")) {
learn(+1);
} else if (my_string_equal(Star[0],"0-1")) {
learn(-1);
} else if (my_string_equal(Star[0],"1/2-1/2")) {
learn(0);
}
}
} else if (match(string,"resume")) {
// refuse
xboard_send(XBoard,"Error (unknown command): %s",string);
} else if (match(string,"sd *")) {
XB->depth_limit = true;
XB->depth_max = atoi(Star[0]);
} else if (match(string,"setboard *")) {
my_log("POLYGLOT FEN %s\n",Star[0]);
if (!game_init(Game,Star[0])) my_fatal("xboard_step(): bad FEN \"%s\"\n",Star[0]);
State->computer[White] = false;
State->computer[Black] = false;
XB->new_hack = true; // HACK?
XB->result = false;
board_update();
mess();
} else if (match(string,"st *")) {
XB->time_limit = true;
XB->time_max = double(atoi(Star[0]));
} else if (match(string,"time *")) {
XB->my_time = double(atoi(Star[0])) / 100.0;
if (XB->my_time < 0.0) XB->my_time = 0.0;
} else if (match(string,"undo")) {
if (game_pos(Game) >= 1) {
game_goto(Game,game_pos(Game)-1);
ASSERT(!XB->new_hack);
XB->new_hack = false; // HACK?
XB->result = false;
board_update();
mess();
}
} else if (match(string,"usermove *")) {
game_get_board(Game,board);
move = move_from_san(Star[0],board);
if (move != MoveNone && move_is_legal(move,board)) {
XB->new_hack = false;
ASSERT(!XB->result);
XB->result = false;
move_step(move);
no_mess(move);
} else {
xboard_send(XBoard,"Illegal move: %s",Star[0]);
}
} else if (match(string,"variant *")) {
if (my_string_equal(Star[0],"fischerandom")) {
option_set("Chess960","true");
} else {
option_set("Chess960","false");
}
} else if (match(string,"white")) {
if (colour_is_white(game_turn(Game))) {
State->computer[White] = false;
State->computer[Black] = true;
XB->new_hack = true;
XB->result = false;
mess();
}
} else if (match(string,"xboard")) {
// ignore
} else if (match(string,".")) { // analyse info
if (State->state == ANALYSE) {
ASSERT(Uci->searching);
ASSERT(Uci->pending_nb>=1);
if (Uci->root_move != MoveNone && move_is_legal(Uci->root_move,Uci->board)) {
move_to_san(Uci->root_move,Uci->board,move_string,256);
xboard_send(XBoard,"stat01: %.0f %lld %d %d %d %s",Uci->time*100.0,Uci->node_nb,Uci->depth,Uci->root_move_nb-(Uci->root_move_pos+1),Uci->root_move_nb,move_string);
} else {
xboard_send(XBoard,"stat01: %.0f %lld %d %d %d",Uci->time*100.0,Uci->node_nb,Uci->depth,0,0); // HACK
}
}
} else if (match(string,"?")) { // move now
if (State->state == THINK) {
ASSERT(Uci->searching);
ASSERT(Uci->pending_nb>=1);
// HACK: just send "stop" to the engine
if (Uci->searching) {
my_log("POLYGLOT STOP SEARCH\n");
engine_send(Engine,"stop");
}
}
} else { // unknown command, maybe a move?
game_get_board(Game,board);
move = move_from_san(string,board);
if (move != MoveNone && move_is_legal(move,board)) {
XB->new_hack = false;
ASSERT(!XB->result);
XB->result = false;
move_step(move);
no_mess(move);
} else if (move != MoveNone) {
xboard_send(XBoard,"Illegal move: %s",string);
} else {
xboard_send(XBoard,"Error (unknown command): %s",string);
}
}
}
static void parse_option() {
const char * file_name;
FILE * file;
char line[256];
char * name, * value;
file_name = option_get_string("OptionFile");
file = fopen(file_name,"r");
if (file == NULL)
my_fatal("Can't open file \"%s\": %s\n",file_name,strerror(errno));
// PolyGlot options (assumed first)
//read the ini file,and store the name/value pairs
while (true) {
if (!my_file_read_line(file,line,sizeof(line))) {
my_fatal("parse_option(): missing [Engine] section\n");
}
if (my_string_case_equal(line,"[engine]")) break;
if (parse_line(line,&name,&value)) option_set(name,value);
}
if (option_get_bool("Log")) { my_log_open(option_get_string("LogFile"));}
while (my_file_read_line(file,line,sizeof(line))) {
if (line[0] == '[') my_fatal("parse_option(): unknown section %s\n",line);
if (parse_line(line,&name,&value)) {
uci_option_store(name,value);
}
}
fclose(file);
//read the optional global.ini file
if(!option_get_bool("NoGlobals")){
file=fopen("globals.ini","r");
//override settings,if any
if(file!=NULL){
while (true) {
if (!my_file_read_line(file,line,sizeof(line))) {
my_fatal("parse_option(): missing [Engine] section\n");
}
if (my_string_case_equal(line,"[engine]")) break;
if (parse_line(line,&name,&value)){
if(!my_string_case_equal(name,"LogFile"))
option_set(name,value);
}
}
if (option_get_bool("Log")) {
my_log_open(option_get_string("LogFile"));
}
else my_log_close(); //close it
while (my_file_read_line(file,line,sizeof(line))) {
if (line[0] == '[') my_fatal("parse_option(): unknown section %s\n",line);
if (parse_line(line,&name,&value)) {
uci_option_store(name,value);
}
}
fclose(file);
}
}
my_log("POLYGLOT %s *** START ***\n",Version);
my_log("POLYGLOT INI file \"%s\"\n",file_name);
//do the dump:
engine_open(Engine);
Init = true;
uci_open(Uci,Engine);
uci_option_t *next;
init_uci_list(&next);
while(next!=NULL){
if(next->var==NULL) break;
uci_send_option(Uci,next->var,"%s",next->val);
if(my_string_case_equal(next->var,"MultiPV") && atoi(next->val)>1) Uci->multipv_mode=true;
next=next->next;
}
uci_send_isready(Uci);
if (my_string_equal(option_get_string("EngineName"),"<empty>")) {
option_set("EngineName",Uci->name);
}
}
static void send_board(int extra_move) {
char fen[256];
int start, end;
board_t board[1];
int pos;
int move;
char string[256];
ASSERT(extra_move==MoveNone||move_is_ok(extra_move));
ASSERT(!Uci->searching);
// init
game_get_board(Game,Uci->board);
if (extra_move != MoveNone) move_do(Uci->board,extra_move);
board_to_fen(Uci->board,fen,256);
my_log("POLYGLOT FEN %s\n",fen);
ASSERT(board_can_play(Uci->board));
// more init
start = 0;
end = game_pos(Game);
ASSERT(end>=start);
// position
game_get_board(Game,board,start);
board_to_fen(board,string,256);
engine_send_queue(Engine,"position");
if (my_string_equal(string,StartFen)) {
engine_send_queue(Engine," startpos");
} else {
engine_send_queue(Engine," fen %s",string);
}
// move list
if (end > start || extra_move != MoveNone) engine_send_queue(Engine," moves");
for (pos = start; pos < end; pos++) { // game moves
move = game_move(Game,pos);
move_to_can(move,board,string,256);
engine_send_queue(Engine," %s",string);
move_do(board,move);
}
if (extra_move != MoveNone) { // move to ponder on
move_to_can(extra_move,board,string,256);
engine_send_queue(Engine," %s",string);
}
// end
engine_send(Engine,""); // newline
}
static void parse_setoption(char string[]) {
const char * name;
char * value;
// init
name = strstr(string,"name ");
value = strstr(string,"value ");
if (name == NULL || value == NULL || name >= value) return; // ignore buttons
value[-1] = '\0'; // HACK
name += 5;
value += 6;
// update
option_set(name,value);
// update transposition-table size if needed
if (Init && my_string_equal(name,"Hash")) { // Init => already allocated
ASSERT(!Searching);
if (option_get_int("Hash") >= 4) {
trans_free();
trans_alloc();
}
}
// update endgame tablebases if needed
if (my_string_equal(name,"NalimovPath")) {
ASSERT(!Searching);
tb_path(option_get_string("NalimovPath"));
}
if (my_string_equal(name,"NalimovCache")) {
ASSERT(!Searching);
tb_cache(option_get_int("NalimovCache"));
}
if (my_string_equal(name,"EgbbPath")) {
ASSERT(!Searching);
egbb_path(option_get_string("EgbbPath"));
}
if (my_string_equal(name,"EgbbCache")) {
ASSERT(!Searching);
egbb_cache(option_get_int("EgbbCache"));
}
// update pawn structure if needed
if (my_string_equal(name,"Pawn Structure")) {
ASSERT(!Searching);
pawn_structure_set_option(option_get_int("Pawn Structure"));
pst_init();
}
// update piece activity if needed
if (my_string_equal(name,"Piece Activity")) {
ASSERT(!Searching);
trans_clear();
pst_init();
}
// update king safty if needed
if (my_string_equal(name,"King Safety")) {
ASSERT(!Searching);
trans_clear();
pst_init();
}
// update pawn activity if needed
if (my_string_equal(name,"Pawn Activity")) {
ASSERT(!Searching);
trans_clear();
pst_init();
}
// update material if needed
if (my_string_equal(name,"Material")) {
ASSERT(!Searching);
material_set_option(option_get_int("Material"));
}
// update piece value if needed
if (my_string_equal(name,"Pawn")) {
ASSERT(!Searching);
piece_set_option(option_get_int("Pawn"),MAT_PAWN);
}
if (my_string_equal(name,"Knight")) {
ASSERT(!Searching);
piece_set_option(option_get_int("Knight"),MAT_KNIGHT);
}
if (my_string_equal(name,"Bishop")) {
ASSERT(!Searching);
piece_set_option(option_get_int("Bishop"),MAT_BISHOP);
}
if (my_string_equal(name,"Rook")) {
ASSERT(!Searching);
piece_set_option(option_get_int("Rook"),MAT_ROOK);
}
if (my_string_equal(name,"Queen")) {
ASSERT(!Searching);
piece_set_option(option_get_int("Queen"),MAT_QUEEN);
}
if (my_string_equal(name,"Bishop Pair")) {
ASSERT(!Searching);
piece_set_option(option_get_int("Bishop Pair"),MAT_BISHOP_PAIR);
}
}
void search_full_init(list_t * list, board_t * board) {
const char * string;
int trans_move, trans_min_depth, trans_max_depth, trans_min_value, trans_max_value;
ASSERT(list_is_ok(list));
ASSERT(board_is_ok(board));
// null-move options
string = option_get_string("NullMove Pruning");
if (false) {
} else if (my_string_equal(string,"Always")) {
UseNull = true;
UseNullEval = false;
} else if (my_string_equal(string,"Fail High")) {
UseNull = true;
UseNullEval = true;
} else if (my_string_equal(string,"Never")) {
UseNull = false;
UseNullEval = false;
} else {
ASSERT(false);
UseNull = true;
UseNullEval = true;
}
NullReduction = option_get_int("NullMove Reduction");
string = option_get_string("Verification Search");
if (false) {
} else if (my_string_equal(string,"Always")) {
UseVer = true;
UseVerEndgame = false;
} else if (my_string_equal(string,"Endgame")) {
UseVer = true;
UseVerEndgame = true;
} else if (my_string_equal(string,"Never")) {
UseVer = false;
UseVerEndgame = false;
} else {
ASSERT(false);
UseVer = true;
UseVerEndgame = true;
}
VerReduction = option_get_int("Verification Reduction");
// history-pruning options
UseHistory = option_get_bool("History Pruning");
HistoryValue = (option_get_int("History Threshold") * 16384 + 50) / 100;
UseExtendedHistory = option_get_bool("Toga Extended History Pruning");
HistoryBound = (option_get_int("Toga History Threshold") * 16384 + 50) / 100;
// futility-pruning options
UseFutility = option_get_bool("Futility Pruning");
FutilityMargin1 = option_get_int("Futility Margin");
FutilityMargin2 = option_get_int("Extended Futility Margin");
// delta-pruning options
UseDelta = option_get_bool("Delta Pruning");
DeltaMargin = option_get_int("Delta Margin");
// quiescence-search options
CheckNb = option_get_int("Quiescence Check Plies");
CheckDepth = 1 - CheckNb;
// standard sort
list_note(list);
list_sort(list);
// basic sort
trans_move = MoveNone;
if (UseTrans) trans_retrieve(Trans,board->key,&trans_move,&trans_min_depth,&trans_max_depth,&trans_min_value,&trans_max_value);
note_moves(list,board,0,trans_move);
list_sort(list);
}
void xboard2uci_gui_step(char string[]) {
int move;
char move_string[256];
board_t board[1];
if (FALSE) {
} else if (match(string,"accepted *")) {
// ignore
} else if (match(string,"analyze")) {
State->computer[White] = FALSE;
State->computer[Black] = FALSE;
XB->analyse = TRUE;
XB->new_hack = FALSE;
ASSERT(!XB->result);
XB->result = FALSE;
mess();
} else if (match(string,"bk")) {
if (option_get_bool(Option,"Book")) {
game_get_board(Game,board);
book_disp(board);
}
} else if (match(string,"black")) {
if (colour_is_black(game_turn(Game))) {
State->computer[White] = TRUE;
State->computer[Black] = FALSE;
XB->new_hack = TRUE;
XB->result = FALSE;
mess();
}
} else if (match(string,"computer")) {
XB->computer = TRUE;
} else if (match(string,"draw")) {
if(option_find(Uci->option,"UCI_DrawOffers")){
my_log("POLYGLOT draw from XB received");
uci_send_option(Uci,"DrawOffer","%s","draw");}
} else if (match(string,"easy")) {
XB->ponder = FALSE;
mess();
} else if (match(string,"edit")) {
// refuse
gui_send(GUI,"Error (unknown command): %s",string);
} else if (match(string,"exit")) {
State->computer[White] = FALSE;
State->computer[Black] = FALSE;
XB->analyse = FALSE;
mess();
} else if (match(string,"force")) {
State->computer[White] = FALSE;
State->computer[Black] = FALSE;
mess();
} else if (match(string,"go")) {
State->computer[game_turn(Game)] = TRUE;
State->computer[colour_opp(game_turn(Game))] = FALSE;
XB->new_hack = FALSE;
ASSERT(!XB->result);
XB->result = FALSE;
mess();
} else if (match(string,"hard")) {
XB->ponder = TRUE;
mess();
} else if (match(string,"hint")) {
move=MoveNone;
game_get_board(Game,board);
if (option_get_bool(Option,"Book")) {
move = book_move(board,FALSE);
}
if(move==MoveNone && State->hint_move!=MoveNone){
move=State->hint_move;
}
if (move != MoveNone && move_is_legal(move,board)) {
move_to_san(move,board,move_string,256);
gui_send(GUI,"Hint: %s",move_string);
}
} else if (match(string,"ics *")) {
XB->ics = TRUE;
} else if (match(string,"level * *:* *")) {
XB->mps = atoi(Star[0]);
XB->base = ((double)atoi(Star[1])) * 60.0 + ((double)atoi(Star[2]));
XB->inc = ((double)atoi(Star[3]));
} else if (match(string,"level * * *")) {
XB->mps = atoi(Star[0]);
XB->base = ((double)atoi(Star[1])) * 60.0;
XB->inc = ((double)atoi(Star[2]));
} else if (match(string,"name *")) {
my_string_set(&XB->name,Star[0]);
} else if (match(string,"new")) {
uci_send_isready_sync(Uci);
my_log("POLYGLOT NEW GAME\n");
option_set(Option,"3Check","false");
option_set(Option,"Chess960","false");
option_set(Option,"Atomic","false");
option_set(Option,"Horde","false");
game_clear(Game);
if (XB->analyse) {
State->computer[White] = FALSE;
State->computer[Black] = FALSE;
} else {
State->computer[White] = FALSE;
State->computer[Black] = TRUE;
}
XB->new_hack = TRUE;
XB->result = FALSE;
XB->depth_limit = FALSE;
XB->node_rate=-1;
XB->computer = FALSE;
my_string_set(&XB->name,"<empty>");
board_update();
mess();
uci_send_ucinewgame(Uci);
} else if (match(string,"nopost")) {
XB->post = FALSE;
} else if (match(string,"otim *")) {
XB->opp_time = ((double)atoi(Star[0])) / 100.0;
if (XB->opp_time < 0.0) XB->opp_time = 0.0;
} else if (match(string,"pause")) {
// refuse
gui_send(GUI,"Error (unknown command): %s",string);
} else if (match(string,"ping *")) {
// HACK; TODO: answer only after an engine move
if (DelayPong) {
if (XB->ping >= 0) gui_send(GUI,"pong %d",XB->ping); // HACK: get rid of old ping
XB->ping = atoi(Star[0]);
uci_send_isready_sync(Uci);
} else {
ASSERT(XB->ping==-1);
gui_send(GUI,"pong %s",Star[0]);
}
} else if (match(string,"nps *")) {
// fake WB play-by-nodes mode
XB->node_rate = atoi(Star[0]);
} else if (match(string,"playother")) {
State->computer[game_turn(Game)] = FALSE;
State->computer[colour_opp(game_turn(Game))] = TRUE;
XB->new_hack = FALSE;
ASSERT(!XB->result);
XB->result = FALSE;
mess();
} else if (match(string,"post")) {
XB->post = TRUE;
} else if (match(string,"protover *")) {
XB->proto_ver = atoi(Star[0]);
ASSERT(XB->proto_ver>=2);
send_xboard_options();
} else if (match(string,"quit")) {
my_log("POLYGLOT *** \"quit\" from GUI ***\n");
quit();
} else if (match(string,"random")) {
// ignore
} else if (match(string,"rating * *")) {
// ignore
} else if (match(string,"remove")) {
if (game_pos(Game) >= 2) {
game_goto(Game,game_pos(Game)-2);
ASSERT(!XB->new_hack);
XB->new_hack = FALSE; // HACK?
XB->result = FALSE;
board_update();
mess();
}
} else if (match(string,"rejected *")) {
// ignore
} else if (match(string,"reset")) { // protover 3?
// refuse
gui_send(GUI,"Error (unknown command): %s",string);
} else if (FALSE
|| match(string,"result * {*}")
|| match(string,"result * {* }")
|| match(string,"result * { *}")
|| match(string,"result * { * }")) {
my_log("POLYGLOT GAME END\n");
XB->result = TRUE;
mess();
// book learning
if (FALSE && option_get_bool(Option,"Book") &&
option_get_bool(Option,"BookLearn")) {
if (FALSE) {
} else if (my_string_equal(Star[0],"1-0")) {
learn(+1);
} else if (my_string_equal(Star[0],"0-1")) {
learn(-1);
} else if (my_string_equal(Star[0],"1/2-1/2")) {
learn(0);
}
}
} else if (match(string,"resume")) {
// refuse
gui_send(GUI,"Error (unknown command): %s",string);
} else if (match(string,"option *=*") ||
match(string,"option * =*") ||
match(string,"option *= *") ||
match(string,"option * = *")
){
char *name=Star[0];
char *value=Star[1];
if(match(name, "Polyglot *")){
char *pg_name=Star[0];
polyglot_set_option(pg_name,value);
}else{
option_t *opt=option_find(Uci->option,name);
if(opt){
if(my_string_case_equal(opt->type,"check")){
value=my_string_equal(value,"1")?"true":"false";
}
start_protected_command();
uci_send_option(Uci, name, "%s", value);
end_protected_command();
}else{
gui_send(GUI,"Error (unknown option): %s",name);
}
}
} else if (match(string,"option *")){
char *name=Star[0];
if(match(name, "Polyglot *")){
char *pg_name=Star[0];
polyglot_set_option(pg_name,"<empty>");
}else{
start_protected_command();
// value is ignored
if(!uci_send_option(Uci, name, "%s", "<empty>")){
gui_send(GUI,"Error (unknown option): %s",name);
};
end_protected_command();
}
} else if (XB->has_feature_smp && match(string,"cores *")){
int cores=atoi(Star[0]);
if(cores>=1){
// updating the number of cores
my_log("POLYGLOT setting the number of cores to %d\n",cores);
start_protected_command();
uci_set_threads(Uci,cores);
end_protected_command();
} else{
// refuse
gui_send(GUI,"Error (unknown command): %s",string);
}
} else if (match(string,"egtpath * *")){
char *type=Star[0];
char *path=Star[1];
if(my_string_empty(path)){
// refuse
gui_send(GUI,"Error (unknown command): %s",string);
}else{
if(my_string_case_equal(type,"nalimov") && XB->has_feature_egt_nalimov){
// updating NalimovPath
my_log("POLYGLOT setting the Nalimov path to %s\n",path);
start_protected_command();
uci_send_option(Uci,"NalimovPath","%s",path);
end_protected_command();
}else if(my_string_case_equal(type,"gaviota") && XB->has_feature_egt_gaviota){
// updating GaviotaPath
my_log("POLYGLOT setting the Gaviota path to %s\n",path);
start_protected_command();
uci_send_option(Uci,"GaviotaTbPath","%s",path);
end_protected_command();
}else{
// refuse
gui_send(GUI,"Error (unsupported table base format): %s",string);
}
}
} else if (XB->has_feature_memory && match(string,"memory *")){
int memory = atoi(Star[0]);
int egt_cache;
int real_memory;
if(memory>=1){
// updating the available memory
option_t *opt;
my_log("POLYGLOT setting the amount of memory to %dMb\n",memory);
if(XB->has_feature_egt_nalimov && (opt=option_find(Uci->option,"NalimovCache"))){
egt_cache=atoi(opt->value);
}else if(XB->has_feature_egt_gaviota &&
(opt=option_find(Uci->option,"GaviotaTbCache"))){
egt_cache=atoi(opt->value);
}else{
egt_cache=0;
}
my_log("POLYGLOT EGTB Cache is %dMb\n",egt_cache);
real_memory=memory-egt_cache;
if(real_memory>0){
start_protected_command();
uci_send_option(Uci,"Hash", "%d", real_memory);
end_protected_command();
}
}else{
// refuse
gui_send(GUI,"Error (unknown command): %s",string);
}
} else if (match(string,"sd *")) {
XB->depth_limit = TRUE;
XB->depth_max = atoi(Star[0]);
} else if (match(string,"setboard *")) {
my_log("POLYGLOT FEN %s\n",Star[0]);
if (!game_init(Game,Star[0])) my_fatal("xboard_step(): bad FEN \"%s\"\n",Star[0]);
State->computer[White] = FALSE;
State->computer[Black] = FALSE;
XB->new_hack = TRUE; // HACK?
XB->result = FALSE;
board_update();
mess();
} else if (match(string,"st *")) {
XB->time_limit = TRUE;
XB->time_max = ((double)atoi(Star[0]));
} else if (match(string,"time *")) {
XB->my_time = ((double)atoi(Star[0])) / 100.0;
if (XB->my_time < 0.0) XB->my_time = 0.0;
} else if (match(string,"undo")) {
if (game_pos(Game) >= 1) {
game_goto(Game,game_pos(Game)-1);
ASSERT(!XB->new_hack);
XB->new_hack = FALSE; // HACK?
XB->result = FALSE;
board_update();
mess();
}
} else if (match(string,"usermove *")) {
game_get_board(Game,board);
move = move_from_san(Star[0],board);
if (move != MoveNone && move_is_legal(move,board)) {
XB->new_hack = FALSE;
ASSERT(!XB->result);
XB->result = FALSE;
move_step(move);
no_mess(move);
} else {
gui_send(GUI,"Illegal move: %s",Star[0]);
}
} else if (match(string,"variant *")) {
if (my_string_equal(Star[0],"3check")) {
option_set(Option,"3Check","true");
} else {
option_set(Option,"3Check","false");
}
if (my_string_equal(Star[0],"fischerandom")) {
option_set(Option,"Chess960","true");
} else {
option_set(Option,"Chess960","false");
}
if (my_string_equal(Star[0],"atomic")) {
option_set(Option,"Atomic","true");
} else {
option_set(Option,"Atomic","false");
}
if (my_string_equal(Star[0],"horde")) {
option_set(Option,"Horde","true");
game_init(Game,StartFenHorde);
//gui_send(GUI,"setup %s",StartFenHorde);
} else {
option_set(Option,"Horde","false");
}
} else if (match(string,"white")) {
if (colour_is_white(game_turn(Game))) {
State->computer[White] = FALSE;
State->computer[Black] = TRUE;
XB->new_hack = TRUE;
XB->result = FALSE;
mess();
}
} else if (match(string,"xboard")) {
// ignore
} else if (match(string,".")) { // analyse info
if (State->state == ANALYSE) {
int depth=Uci->best_depth;//HACK: don't clear engine-output window...
ASSERT(Uci->searching);
ASSERT(Uci->pending_nb>=1);
if (Uci->root_move != MoveNone && move_is_legal(Uci->root_move,Uci->board)) {
move_to_san(Uci->root_move,Uci->board,move_string,256);
gui_send(GUI,"stat01: %.0f "S64_FORMAT" %d %d %d %s",Uci->time*100.0,Uci->node_nb,/*Uci->*/depth,Uci->root_move_nb-(Uci->root_move_pos+1),Uci->root_move_nb,move_string);
} else {
gui_send(GUI,"stat01: %.0f "S64_FORMAT" %d %d %d",Uci->time*100.0,Uci->node_nb,/*Uci->*/depth,0,0); // HACK
}
}
} else if (match(string,"?")) { // move now
if (State->state == THINK) {
ASSERT(Uci->searching);
ASSERT(Uci->pending_nb>=1);
// HACK: just send "stop" to the engine
if (Uci->searching) {
my_log("POLYGLOT STOP SEARCH\n");
engine_send(Engine,"stop");
}
}
} else { // unknown command, maybe a move?
game_get_board(Game,board);
move = move_from_san(string,board);
if (move != MoveNone && move_is_legal(move,board)) {
XB->new_hack = FALSE;
ASSERT(!XB->result);
XB->result = FALSE;
move_step(move);
no_mess(move);
} else if (move != MoveNone) {
gui_send(GUI,"Illegal move: %s",string);
} else {
gui_send(GUI,"Error (unknown command): %s",string);
}
}
return;
}
void epd_test(int argc, char * argv[]) {
int i;
const char * epd_file;
epd_file = NULL;
my_string_set(&epd_file,"wac.epd");
MinDepth = 8;
MaxDepth = 63;
MinTime = 1.0;
MaxTime = 5.0;
DepthDelta = 3;
for (i = 1; i < argc; i++) {
if (false) {
} else if (my_string_equal(argv[i],"epd-test")) {
// skip
} else if (my_string_equal(argv[i],"-epd")) {
i++;
if (argv[i] == NULL) my_fatal("epd_test(): missing argument\n");
my_string_set(&epd_file,argv[i]);
} else if (my_string_equal(argv[i],"-min-depth")) {
i++;
if (argv[i] == NULL) my_fatal("epd_test(): missing argument\n");
MinDepth = atoi(argv[i]);
} else if (my_string_equal(argv[i],"-max-depth")) {
i++;
if (argv[i] == NULL) my_fatal("epd_test(): missing argument\n");
MaxDepth = atoi(argv[i]);
} else if (my_string_equal(argv[i],"-min-time")) {
i++;
if (argv[i] == NULL) my_fatal("epd_test(): missing argument\n");
MinTime = atof(argv[i]);
} else if (my_string_equal(argv[i],"-max-time")) {
i++;
if (argv[i] == NULL) my_fatal("epd_test(): missing argument\n");
MaxTime = atof(argv[i]);
} else if (my_string_equal(argv[i],"-depth-delta")) {
i++;
if (argv[i] == NULL) my_fatal("epd_test(): missing argument\n");
DepthDelta = atoi(argv[i]);
} else {
my_fatal("epd_test(): unknown option \"%s\"\n",argv[i]);
}
}
epd_test_file(epd_file);
}
int uci_parse(uci_t * uci, const char string[]) {
int event;
parse_t parse[1];
char command[StringSize];
char argument[StringSize];
ASSERT(uci_is_ok(uci));
ASSERT(string!=NULL);
// init
event = EVENT_NONE;
// parse
parse_open(parse,string);
if (parse_get_word(parse,command,StringSize)) {
parse_get_string(parse,argument,StringSize);
if (UseDebug) my_log("POLYGLOT COMMAND \"%s\" ARGUMENT \"%s\"\n",command,argument);
if (false) {
} else if (my_string_equal(command,"bestmove")) {
// search end
ASSERT(uci->pending_nb>0);
if (uci->searching && uci->pending_nb == 1) {
// current search
uci->searching = false;
uci->pending_nb--;
event = parse_bestmove(uci,argument); // updates uci->best_move and uci->ponder_move
} else {
// obsolete search
if (uci->pending_nb > 0) {
uci->pending_nb--;
if (uci->pending_nb == 0) event = EVENT_STOP;
}
}
} else if (my_string_equal(command,"id")) {
parse_id(uci,argument);
} else if (my_string_equal(command,"info")) {
// search information
if (uci->searching && uci->pending_nb == 1) { // current search
event = parse_info(uci,argument);
}
} else if (my_string_equal(command,"option")) {
parse_option(uci,argument);
} else if (my_string_equal(command,"readyok")) {
// engine is ready
ASSERT(uci->ready_nb>0);
if (uci->ready_nb > 0) {
uci->ready_nb--;
if (uci->ready_nb == 0) event = EVENT_READY;
}
} else if (my_string_equal(command,"uciok")) {
event = EVENT_UCI;
} else {
if (UseDebug) my_log("POLYGLOT unknown command \"%s\"\n",command);
}
}
parse_close(parse);
return event;
}
bool option_get_bool(option_list_t *option, const char name[]) {
const char * value;
value = option_get(option,name);
if (FALSE) {
} else if (my_string_case_equal(value,"true") || my_string_case_equal(value,"yes") || my_string_equal(value,"1")) {
return TRUE;
} else if (my_string_case_equal(value,"false") || my_string_case_equal(value,"no") || my_string_equal(value,"0")) {
return FALSE;
}
ASSERT(FALSE);
return FALSE;
}
