static bool is_solution(int move, const board_t * board, const char bm[], const char am[]) {
char move_string[256];
bool correct;
ASSERT(move!=MoveNone);
ASSERT(bm!=NULL);
ASSERT(am!=NULL);
if (!move_is_legal(move,board)) {
board_disp(board);
move_disp(move,board);
printf("\n\n");
}
ASSERT(move_is_legal(move,board));
if (!move_to_san(move,board,move_string,256)) ASSERT(false);
correct = false;
if (!my_string_empty(bm)) {
correct = string_contain(bm,move_string);
} else if (!my_string_empty(am)) {
correct = !string_contain(am,move_string);
} else {
ASSERT(false);
}
return correct;
}
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);
}
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
}
}
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_);
}
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 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;
}
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;
}
static void epd_test_file(const char file_name[]) {
FILE * file;
int hit, tot;
char epd[StringSize];
char am[StringSize], bm[StringSize], id[StringSize];
board_t board[1];
char string[StringSize];
int move;
char pv_string[StringSize];
bool correct;
double depth_tot, time_tot, node_tot;
ASSERT(file_name!=NULL);
// init
file = fopen(file_name,"r");
if (file == NULL) my_fatal("epd_test_file(): can't open file \"%s\": %s\n",file_name,strerror(errno));
hit = 0;
tot = 0;
depth_tot = 0.0;
time_tot = 0.0;
node_tot = 0.0;
// loop
while (my_file_read_line(file,epd,StringSize)) {
if (UseTrace) printf("%s\n",epd);
if (!epd_get_op(epd,"am",am,StringSize)) strcpy(am,"");
if (!epd_get_op(epd,"bm",bm,StringSize)) strcpy(bm,"");
if (!epd_get_op(epd,"id",id,StringSize)) strcpy(id,"");
if (my_string_empty(am) && my_string_empty(bm)) {
my_fatal("epd_test(): no am or bm field in EPD\n");
}
// init
uci_send_ucinewgame(Uci);
uci_send_isready_sync(Uci);
ASSERT(!Uci->searching);
// position
if (!board_from_fen(board,epd)) ASSERT(false);
if (!board_to_fen(board,string,StringSize)) ASSERT(false);
engine_send(Engine,"position fen %s",string);
// search
engine_send(Engine,"go movetime %.0f depth %d",MaxTime*1000.0,MaxDepth);
// engine_send(Engine,"go infinite");
// engine data
board_copy(Uci->board,board);
uci_clear(Uci);
Uci->searching = true;
Uci->pending_nb++;
FirstMove = MoveNone;
FirstDepth = 0;
FirstSelDepth = 0;
FirstScore = 0;
FirstTime = 0.0;
FirstNodeNb = 0;
line_clear(FirstPV);
LastMove = MoveNone;
LastDepth = 0;
LastSelDepth = 0;
LastScore = 0;
LastTime = 0.0;
LastNodeNb = 0;
line_clear(LastPV);
// parse engine output
while (engine_step()) {
// stop search?
if (Uci->depth > MaxDepth
|| Uci->time >= MaxTime
|| (Uci->depth - FirstDepth >= DepthDelta
&& Uci->depth > MinDepth
&& Uci->time >= MinTime
&& is_solution(FirstMove,board,bm,am))) {
engine_send(Engine,"stop");
}
}
move = FirstMove;
correct = is_solution(move,board,bm,am);
if (correct) hit++;
tot++;
if (correct) {
depth_tot += double(FirstDepth);
time_tot += FirstTime;
node_tot += double(FirstNodeNb);
}
printf("%s %d %4d %4d",id,correct,hit,tot);
if (!line_to_san(LastPV,Uci->board,pv_string,StringSize)) ASSERT(false);
printf(" - %2d %6.2f %9lld %+6.2f %s\n",FirstDepth,FirstTime,FirstNodeNb,double(LastScore)/100.0,pv_string);
}
printf("%d/%d",hit,tot);
if (hit != 0) {
depth_tot /= double(hit);
time_tot /= double(hit);
node_tot /= double(hit);
printf(" - %.1f %.2f %.0f",depth_tot,time_tot,node_tot);
}
printf("\n");
fclose(file);
}