moveparse.cpp

   1 /***************************************************************************
   2                           moveparse.cpp  -  description
   3                              -------------------
   4     begin                : mer ott 30 2002
   5     copyright            : (C) 2002-2007 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 #include "engine.h"
  19 #include "utils.h"
  20 #include <string.h>
  21
  22 void Engine::print_moves(Move* m, int num, bool nums, bool walk_ht)
  23 {
  24     int i,j;
  25     if(board.color_to_move==BLACK &&nums)
  26         output("%d. ...",board.num_moves+1);
  27
  28     for(i=0;i<num;i++)
  29     {
  30         if(m[i].as_int == 0)
  31             break;
  32
  33         if(board.color_to_move==WHITE && nums)
  34             printf(" %d.",board.num_moves+1);
  35         output(" %s", board.move_to_alg(MoveStr().data(), m[i]) );
  36         board.do_move(m[i], save_buf[save_buf_num++]);
  37     }
  38
  39     if(walk_ht)
  40     {
  41         Move hash_mv[24];
  42         for(j=0;j<24-i;j++)
  43         {
  44             HashEntry *h = probe_hash( board.hash );
  45             if(!h || !h->best_mv || h->depth<0)
  46                 break;
  47
  48             /* don't follow the hash if there is draw for repetition :) */
  49             if( check_draw() )
  50             {
  51                 output( " <DRAW>" );
  52                 break;
  53             }
  54
  55             hash_mv[j] = board.uncompress_move( h->best_mv );
  56
  57             /* verify that the move in the hash is a legal move */
  58             Move tmp[255];
  59             int num_tmp = board.find_moves(tmp);
  60             bool ok = false;
  61             for(int q=0;q<num_tmp;q++)
  62             if(tmp[q] == hash_mv[j])
  63             {
  64                 ok = true;
  65                 break;
  66             }
  67
  68             if(!ok)
  69                 break;
  70
  71             if(j==0)
  72                 output(" |");
  73
  74             if(board.color_to_move==WHITE && nums)
  75                 output(" %d.",board.num_moves+1);
  76             output( " %s", board.move_to_alg(MoveStr().data(), hash_mv[j]) );
  77             board.do_move(hash_mv[j], save_buf[save_buf_num++]);
  78         }
  79
  80         while(j--)
  81             board.undo_move(hash_mv[j], save_buf[--save_buf_num]);
  82     }
  83
  84     while(i--)
  85         board.undo_move(m[i], save_buf[--save_buf_num]);
  86
  87     output("\n");
  88 }
  89
  90 /* TODO: load correctly the pgn that start with a fen */
  91 int Engine::load_pgn(FILE *f)
  92 {
  93     char buf[1024];
  94
  95     board.set_as_default();
  96     mv_done_num     = 0;
  97
  98     while(1)
  99     {
 100         if(!fgets(buf, 1024, f))
 101             return 0;
 102         if(buf[0]=='\n' || buf[0]=='\r' || buf[0]=='\t'
 103                 || buf[0]==' ' || buf[0]=='[' || buf[0]=='#')
 104             continue;
 105         break;
 106     }
 107
 108     while(1)
 109     {
 110         char *ptr = buf;
 111         ptr += strspn(ptr, ". \t\r\n");
 112
 113         for(int i=0;;i++)
 114         {
 115             if(!*ptr)
 116                 break;
 117             char *t = ptr;
 118             char *tmp = (ptr += strcspn(ptr, ". \t\r\n"));
 119             ptr += strspn(ptr, ". \t\r\n");
 120             *tmp = 0;
 121
 122             /* is this the result? */
 123             if(!strcmp(t, "1-0"))
 124             {
 125                 status = _10;
 126                 return 1;
 127             }
 128             else if(!strcmp(t, "0-1"))
 129             {
 130                 status = _01;
 131                 return 1;
 132             }
 133             else if(!strcmp(t, "1/2-1/2") || !strcmp(t, "*"))
 134             {
 135                 status = _12;
 136                 return 1;
 137             }
 138
 139             /* is this a move number? */
 140             char *e;
 141             strtol(t, &e, 10);
 142             if(e!=t)
 143                 continue;
 144
 145             Move mv = board.move_from_string(t);
 146             if(!mv.valid())
 147             {
 148                 board.print_board();
 149                 output("Error! \"%s\" %x\n", t, mv.as_int);
 150                 return 0;   /* error */
 151             }
 152
 153             mv_done[mv_done_num++] = mv;
 154             board.do_move(mv, save_buf[save_buf_num++]);
 155         }
 156
 157         if(!fgets(buf, 1024, f))
 158             return 1;
 159     }
 160 }
 161
 162 int Engine::run_epd_prog(const char* prog, int time, const char* file, bool quiet)
 163 {
 164     char buf[1024];
 165     bool failed[8000];
 166     FILE *in = NULL;
 167     FILE *out = NULL;
 168     FILE *f;
 169
 170     /* open the file with the tests */
 171     f = fopen(file, "r");
 172     if(!f)
 173     {
 174         output("Error, could not open %s for reading!\n", file);
 175         return 0;
 176     }
 177
 178     if(!strcmp(prog, "self"))
 179     {
 180         if(quiet)
 181             post = false;
 182         set_time_fixed(time);
 183     }
 184     else
 185         start_engine(prog, &in, &out);
 186
 187     /* reset passed flags */
 188     int done = 0;
 189     int passed = 0;
 190     for(int i=0;i<8000;i++)
 191         failed[i] = false;
 192
 193     while(fgets(buf, 1024, f))
 194     {
 195         char brd[81];
 196         char color[2],castle[5],passing[3];
 197         char best[256];
 198         char avoid[256];
 199         char name[64];// = "unknown";
 200         char *tmp;
 201         Move best_mv[10];
 202         Move avoid_mv[10];
 203         int num_best = 0;
 204         int num_avoid = 0;
 205         Move m;
 206
 207
 208         /* read the board */
 209         sscanf(buf,"%s%s%s%s",
 210                brd,color,castle,passing);
 211         read_board(brd,color,castle,passing,0,0);
 212         if(!quiet)
 213         {
 214             output("\n\n");
 215             board.print_board();
 216         }
 217
 218
 219         done++;
 220         //printf("%s\n", buf);
 221
 222         /* save the best moves in the best_mv array */
 223         tmp = strstr(buf, "bm");
 224         if(tmp)
 225         {
 226             int tok = 0;
 227             sscanf(tmp, "bm %63[^;];", best);
 228             tok += strspn(best + tok, " \t\r\n");
 229
 230             for(num_best=0;num_best<10;num_best++)
 231             {
 232                 if(!best[tok])
 233                     break;
 234
 235                 int start = tok;
 236                 int firstspace = (tok += strcspn(best + tok, " \t\r\n"));
 237                 tok += strspn(best + tok, " \t\r\n");
 238                 best[firstspace] = 0;
 239
 240                 best_mv[num_best] = board.move_from_string(best+start);
 241
 242                 if(!best_mv[num_best].valid())
 243                 {
 244                     output("Error, could not parse move %s in pos %d\n", best+start, done);
 245                     return 0;
 246                 }
 247             }
 248         }
 249
 250         /* save the avoid moves in the best_mv array */
 251         tmp = strstr(buf, "am");
 252         if(tmp)
 253         {
 254             int tok = 0;
 255             sscanf(tmp, "am %63[^;];", avoid);
 256             tok += strspn(avoid + tok, " \t\r\n");
 257
 258             for(num_avoid=0;num_avoid<10;num_avoid++)
 259             {
 260                 if(!avoid[tok])
 261                     break;
 262
 263                 int start = tok;
 264                 int firstspace = (tok += strcspn(avoid + tok, " \t\r\n"));
 265                 tok += strspn(avoid + tok, " \t\r\n");
 266                 avoid[firstspace] = 0;
 267
 268                 avoid_mv[num_avoid] = board.move_from_string(avoid+start);
 269
 270                 if(!avoid_mv[num_avoid].valid())
 271                 {
 272                     output("Error, could not parse move %s in pos %d\n", best+start, done);
 273                     return 0;
 274                 }
 275             }
 276         }
 277
 278         /* get the id */
 279         tmp = strstr(buf, "id");
 280         if(tmp)
 281             sscanf ( tmp, "id %63[^;];", name);
 282         else
 283             strcpy( name, "<unknown>" );
 284
 285         if(!quiet)
 286         {
 287             output(" %d - Thinking", done);
 288             if(num_best)
 289             {
 290                 output(", the best move%s\e[32;1m", num_best>1 ? "s are" : " is");
 291                 for(int i=0;i<num_best;i++)
 292                     output(" %s", board.move_to_alg(MoveStr().data(), best_mv[i]) );
 293                 output("\e[0m");
 294             }
 295             if(num_avoid)
 296             {
 297                 output(", the move%s to avoid\e[31;1m", num_avoid>1 ? "s are" : " is");
 298                 for(int i=0;i<num_avoid;i++)
 299                     output(" %s", board.move_to_alg(MoveStr().data(), avoid_mv[i]) );
 300                 output("\e[0m");
 301             }
 302             output("\n");
 303         }
 304
 305         if(!strcmp(prog, "self"))
 306         {
 307             st_computer_color = board.color_to_move;
 308             m = find_best_move();
 309         }
 310         else
 311         {
 312             fprintf(out, "force\n");
 313             fprintf(out, "setboard %s\n", board.to_fen(BigStr().data()) );
 314             fprintf(out, "st %d\n", time);
 315             //fprintf(out, "level 1 %d 0\n", time);
 316             fprintf(out, "time %d\n", time*200);
 317             fprintf(out, "otim %d\n", time*200);
 318             fprintf(out, "go\n");
 319
 320             while(fgets(buf, 1024, in))
 321             {
 322                 char mv[32];
 323                 if(!strncmp(buf, "move ", 5))
 324                 {
 325                     sscanf ( buf, "move %s", mv);
 326                     m = board.move_from_string(mv);
 327                     if(!m.valid())
 328                     {
 329                         output("Got illegal move %s\n", mv);
 330                         return 0;
 331                     }
 332                     break;
 333                 }
 334                 else
 335             output(buf);
 336             }
 337         }
 338
 339         bool fail = false;
 340         if(!quiet)
 341             output("Result: \e[36;1m%s\e[0m\n", board.move_to_alg(MoveStr().data(), m));
 342         for(int i=0;i<num_avoid;i++)
 343         if(m == avoid_mv[i])
 344         {
 345             fail = true;
 346             if(!quiet)
 347                 output("Test %d \e[31;1mFAILURE\e[0m, %s did not avoid the "
 348                         "wrong move \e[33;1m%s\e[0m (che pollo!)\n",done, prog,
 349                                    board.move_to_alg(MoveStr().data(), avoid_mv[i]));
 350         }
 351         if(num_avoid && !fail && !quiet)
 352             output("Test %d \e[32;1mSUCCESS\e[0m, %s avoided the "
 353                     "wrong move%s \e[33;1m%s\e[0m (teto figo!)\n",
 354                     done, prog, num_avoid>1?"s":"", avoid);
 355         if(!fail && num_best)
 356         {
 357             fail = true;
 358             for(int i=0;i<num_best;i++)
 359             if(m == best_mv[i])
 360             {
 361                 fail = false;
 362                 if(!quiet)
 363                     output("Test %d \e[32;1mSUCCESS\e[0m, %s found the "
 364                             "best move \e[33;1m%s\e[0m (o se figo!)\n",
 365                             done, prog,  board.move_to_alg(MoveStr().data(), best_mv[i]));
 366                 break;
 367             }
 368             if(fail && !quiet)
 369                 output("Test %d \e[31;1mFAILURE\e[0m, %s missed the best "
 370                         "move%s (\e[33;1m%s\e[0m) (che scarso!)\n",  done, prog,
 371                                 num_best>1?"s":"", best);
 372         }
 373         if(!fail)
 374             passed++;
 375         else
 376             failed[done] = true;
 377
 378         if(!quiet)
 379             output("Test %d %s %s!  (+%d, -%d, ~%d%%)\n", done, name, fail ?
 380                         "\e[31;1mFAILED\e[0m" : "\e[32;1mPASSED\e[0m",
 381                             passed, done-passed, passed*100/done);
 382         else {
 383             output("%s", fail ? "-" : "+");
 384             char str[80];
 385             snprintf(str, 40, "(%d/%d)", passed, done);
 386             int l = strlen(str);
 387             for(int i=0;i<l;i++)
 388                 str[l+i] = '\b';
 389             fwrite(str, 2*l, 1, stdout);
 390             fflush(stdout);
 391         }
 392     }
 393     if(quiet)
 394         output("\n");
 395     output("Passed %d tests out of %d (%d%%)\n", passed, done, passed*100/done);
 396     if(!quiet)
 397     {
 398         output("Failed are:\n");
 399         int numsh = 0;
 400         for(int i=1;i<done+1;i++)
 401             if(failed[i])
 402             {
 403                 output(" %d", i);
 404                 if(((++numsh) % 10) == 0)
 405                     output("\n");
 406             }
 407         output("\n");
 408     }
 409
 410     if(strcmp(prog, "self"))
 411     {
 412         fprintf(out, "quit\n");
 413         fclose(out);
 414         fclose(in);
 415     }
 416     fclose(f);
 417
 418     return passed;
 419 }
 420
 421 void Engine::save_pgn(FILE *f, const char *result1, const char *result)
 422 {
 423     for(int i=mv_done_num-1;i>=0;i--)
 424         board.undo_move(mv_done[i], save_buf[--save_buf_num]);
 425
 426     fprintf(f, "[White \"%s\"]\n", st_computer_color == WHITE ?
 427                                 "RattateChess" : opponent );
 428     fprintf(f, "[Black \"%s\"]\n", st_computer_color == BLACK ?
 429                                 "RattateChess" : opponent );
 430     fprintf(f, "[WhiteELO \"%d\"]\n", w_rating);
 431     fprintf(f, "[BlackELO \"%d\"]\n", b_rating);
 432
 433     time_t t = time(NULL);
 434     char tbuf[256];
 435     strftime(tbuf, 256, "%Y.%m.%d %H:%M", localtime(&t));
 436     fprintf(f, "[Date \"%s\"]\n", tbuf);
 437     fprintf(f, "[Result \"%s\"]\n", result1);
 438
 439     if(0)
 440         fprintf(f, "[FEN \"%s\"]\n", board.to_fen(BigStr().data()) );
 441
 442     if(board.color_to_move==BLACK)
 443         fprintf(f, "%d. ... ",board.num_moves+1);
 444     for(int i=0;i<mv_done_num;i++)
 445     {
 446         if(board.color_to_move==WHITE)
 447             fprintf(f, "%d. ",board.num_moves+1);
 448         fprintf(f, "%s ", board.move_to_alg(MoveStr().data(), mv_done[i]) );
 449         if((i+1)%14 == 0 && i!=mv_done_num-1)
 450             fprintf(f, "\n");
 451         board.do_move(mv_done[i], save_buf[save_buf_num++]);
 452     }
 453     fprintf(f, "\n%s\n\n", result);
 454 }
 455
 456 void Engine::challenge(const char* prog, int time, const char* file)
 457 {
 458     char buf[1024];
 459     FILE *in = NULL;
 460     FILE *out = NULL;
 461     FILE *f;
 462     FILE *log;
 463     int won=0, draw=0, lost=0;
 464
 465     /* open the file with the tests */
 466     f = fopen(file, "r");
 467     log = fopen("challenge.pgn", "w");
 468
 469     if(!f)
 470     {
 471         output("Error, could not open %s for reading!\n", file);
 472         return;
 473     }
 474
 475     start_engine(prog, &in, &out);
 476
 477     while(fgets(buf, 1024, f))
 478     {
 479         uint8_t cols[2] = {WHITE, BLACK};
 480
 481         for(int i=0;i<2;i++)
 482         {
 483             bool go_done = false;
 484             read_board(buf);
 485             //set_max_nodes(time);
 486             //set_time_fixed(time);
 487             set_time_control(40, time, 0);
 488             ponder = false;
 489
 490             fprintf(out, "new\n");
 491             //fprintf(out, "st %d\n", time);
 492             fprintf(out, "level 40 %d:%d 0\n", time/60, time%60);
 493             fprintf(out, "force\n");
 494             fprintf(out, "setboard %s\n", board.to_fen(BigStr().data()));
 495
 496
 497             status = PLAYING;
 498             st_computer_color = cols[i];
 499
 500             while(1)
 501             {
 502                 char buf[1024];
 503
 504                 /*output("\n\n");
 505                 board.print_board();*/
 506
 507                 /* print the pgn to the log file */
 508                 if(status != PLAYING)
 509                 {
 510                     const char *result = status==_01?"0-1":(status==_10?"1-0":"1/2-1/2");
 511                     const char *white = st_computer_color == WHITE ? "Rattatechess" : prog;
 512                     const char *black = st_computer_color == BLACK ? "Rattatechess" : prog;
 513
 514                     if(log)
 515                     {
 516                         for(int i=mv_done_num-1;i>=0;i--)
 517                             board.undo_move(mv_done[i], save_buf[--save_buf_num]);
 518
 519                         fprintf(log, "[White \"%s\"]\n", white);
 520                         fprintf(log, "[Black \"%s\"]\n", black);
 521                         fprintf(log, "[Result \"%s\"]\n", result);
 522                         fprintf(log, "[FEN \"%s\"]\n", board.to_fen(BigStr().data()) );
 523
 524                         if(board.color_to_move==BLACK)
 525                             fprintf(log, "%d. ... ",board.num_moves+1);
 526                         for(int i=0;i<mv_done_num;i++)
 527                         {
 528                             if(board.color_to_move==WHITE)
 529                                 fprintf(log, "%d. ",board.num_moves+1);
 530                             fprintf(log, "%s ", board.move_to_alg(MoveStr().data(), mv_done[i]) );
 531                             if((i+1)%14 == 0)
 532                                 fprintf(log, "\n");
 533                             board.do_move(mv_done[i], save_buf[save_buf_num++]);
 534                         }
 535                         fprintf(log, "%s\n\n", result);
 536                         fflush(log);
 537                     }
 538
 539                     if((status==_01 && st_computer_color==BLACK) ||
 540                             (status==_10 && st_computer_color==WHITE))
 541                     {
 542                         output("RATTA!!!\n");
 543                         won++;
 544                     }
 545                     else if(status==_12)
 546                     {
 547                         output("DRAW!\n");
 548                         draw++;
 549                     }
 550                     else
 551                     {
 552                         output("ARGH!!!\n");
 553                         lost++;
 554                     }
 555                     break;
 556                 }
 557
 558                 /* think or wait for a new move */
 559                 if(st_computer_color == board.color_to_move)
 560                 {
 561                     /* think and move */
 562                     Move mv = find_best_move();
 563                     output("%d. %s %s\n",board.num_moves+1,
 564                             board.color_to_move==BLACK ? "..." : "",
 565                             board.move_to_alg(MoveStr().data(), mv) );
 566                     fprintf( out, "%s\n", Board::move_to_coord(MoveStr().data(), mv));
 567                     move(mv);
 568                 }
 569                 else
 570                 {
 571                     if(!go_done)
 572                     {
 573                         fprintf( out, "go\n");
 574                         go_done = true;
 575                     }
 576
 577                     while(fgets(buf, 1024, in))
 578                     {
 579                         /* get a move from the other engine */
 580                         if(!strncmp(buf, "move ", 5))
 581                         {
 582                             Move mv;
 583                             char buf2[32];
 584                             sscanf( buf, "move %s", buf2);
 585                             mv = board.move_from_string(buf2);
 586                             if(!mv.valid())
 587                             {
 588                                 output("Got illegal move %s\n", buf2);
 589                                 return;
 590                             }
 591                             output("%d. %s %s\n",board.num_moves+1,
 592                                     board.color_to_move==BLACK ? "..." : "",
 593                                     board.move_to_alg(MoveStr().data(), mv) );
 594                             move(mv);
 595                             break;
 596                         }
 597                         else if(!strcmp(buf, "resign"))
 598                         {
 599                             status = board.color_to_move==WHITE?_01:_10;
 600                             break;
 601                         }
 602                         //else
 603                           //  output(buf);
 604                     }
 605                 }
 606             }
 607         }
 608     }
 609
 610     fprintf(out, "quit\n");
 611     fclose(out);
 612     fclose(in);
 613     if(log) fclose(log);
 614     fclose(f);
 615
 616     output("\n\n%d games played (+%d =%d -%d)\n", won+draw+lost, won, draw, lost);
 617 }