moveparse.cpp

   1 /***************************************************************************
   2                           moveparse.cpp  -  description
   3                              -------------------
   4     begin                : mer ott 30 2002
   5     copyright            : (C) 2002-2005 by Maurizio Monge
   6     email                : monge@linuz.sns.it
   7  ***************************************************************************/
   8
   9 /***************************************************************************
  10  *                                                                         *
  11  *   This program is free software; you can redistribute it and/or modify  *
  12  *   it under the terms of the GNU General Public License as published by  *
  13  *   the Free Software Foundation; either version 2 of the License, or     *
  14  *   (at your option) any later version.                                   *
  15  *                                                                         *
  16  ***************************************************************************/
  17
  18 #include "engine.h"
  19 #include "utils.h"
  20 #include <string.h>
  21
  22 //reads a string and if possible understand a move
  23 //in the current position
  24 //the board must be the board before the move is done
  25
  26 static int char_to_piece(char c)
  27 {
  28     switch(c)
  29     {
  30         case 'K': case 'k': return KING;
  31         case 'Q': case 'q': return QUEEN;
  32         case 'R': case 'r': return ROOK;
  33         case 'B': case 'b': return BISHOP;
  34         case 'N': case 'n': return KNIGHT;
  35         case 'P': case 'p': return PAWN;
  36     }
  37
  38     return -1;
  39 }
  40
  41 int Engine::parse_move(Move* mv,char* s)
  42 {
  43     int piece = -1;
  44     int from_x = -1;
  45     int from_y = -1;
  46     int to_x = -1;
  47     int to_y = -1;
  48     int promote = -1;
  49     int comment_1 = 0;
  50     int comment_2 = strlen(s);
  51     int pos = 0;
  52
  53     /* parse O-O-O */
  54     if(!strncmp(s, "0-0-0", 5) || !strncmp(s, "O-O-O", 5) || !strncmp(s, "o-o-o", 5) )
  55     {
  56         comment_1 = 5;
  57
  58         Move moves[250];
  59         int num_moves = board.find_moves(moves);
  60
  61         for(int i=0;i<num_moves;i++)
  62         if(moves[i].flags == CASTLEQUEENSIDE)
  63         {
  64             *mv = moves[i];
  65             goto do_return;
  66         }
  67
  68         output("Illegal move: %s\n", s);
  69         return 2;
  70     }
  71
  72     /* parse O-O. Note that O-O-O matches the expr for O-O, so it must be tested after */
  73     if(!strncmp(s, "0-0", 3) || !strncmp(s, "O-O", 3) || !strncmp(s, "o-o", 3) )
  74     {
  75         comment_1 = 3;
  76
  77         Move moves[250];
  78         int num_moves = board.find_moves(moves);
  79
  80         for(int i=0;i<num_moves;i++)
  81         if(moves[i].flags == CASTLEKINGSIDE)
  82         {
  83             *mv = moves[i];
  84             goto do_return;
  85         }
  86
  87         output("Illegal move: %s\n", s);
  88         return 2;
  89     }
  90
  91     /* parse a SAN */
  92     if(s[pos]>='A' && s[pos]<='Z' && (piece=char_to_piece(s[pos])) != -1)
  93         pos++;
  94     if(s[pos]>='a' && s[pos]<='h')
  95         to_x = s[pos++] - 'a';
  96     if(s[pos]>='1' && s[pos]<='8')
  97         to_y = s[pos++] - '1';
  98     if(s[pos]=='-' || s[pos]=='x')
  99         pos++;
 100     if(s[pos]>='A' && s[pos]<='Z' && char_to_piece(s[pos]) != -1)
 101         pos++;
 102     if(s[pos]>='a' && s[pos]<='h')
 103     {
 104         from_x = to_x;
 105         to_x = s[pos++] - 'a';
 106     }
 107     if(s[pos]>='1' && s[pos]<='8')
 108     {
 109         from_y = to_y;
 110         to_y = s[pos++] - '1';
 111     }
 112     if(s[pos]=='=')
 113         pos++;
 114     if((promote=char_to_piece(s[pos])) != -1)
 115         pos++;
 116
 117     if(to_x != -1 && to_y != -1)
 118     {
 119         if(piece==-1 && (from_x==-1 || from_y==-1))
 120             piece = PAWN;
 121
 122         comment_1 = pos;
 123
 124         /* find a unique matching move */
 125         Move moves[250];
 126         int num_moves = board.find_moves(moves);
 127         bool found = false;
 128
 129         for(int i=0;i<num_moves;i++)
 130         {
 131             if( (piece  == -1 || piece == PIECE_OF(board.data[moves[i].from])) &&
 132                 (from_x == -1 || from_x == X(moves[i].from)) &&
 133                 (from_y == -1 || from_y == Y(moves[i].from)) &&
 134                 (to_x == X(moves[i].to)) &&
 135                 (to_y == Y(moves[i].to)) &&
 136                 (moves[i].flags<=PROMOTE0 || moves[i].flags-PROMOTE0 == promote) )
 137             {
 138                 if(found)
 139                 {
 140                     output("Illegal move (ambiguous): %s\n", s);
 141                     return 3;
 142                 }
 143                 else
 144                 {
 145                     found = true;
 146                     *mv = moves[i];
 147                 }
 148             }
 149         }
 150
 151         if(!found)
 152         {
 153             output("Illegal move: %s\n", s);
 154             return 2;
 155         }
 156
 157         goto do_return;
 158     }
 159
 160     return 0;
 161
 162 do_return:
 163     mv->val = 0;
 164     for(int i=comment_1; i<comment_2; i++)
 165     if(s[i] == '!')
 166         mv->val++;
 167     else if(s[i] == '?')
 168         mv->val--;
 169
 170     return 1;
 171 }
 172
 173 //converts a move to the dummy notation (e2e4,g7h8q,...)
 174 char* Engine::move_to_coord(char* string,Move* mv)
 175 {
 176     char* str = string;
 177     *(str++) = 'a' + X(mv->from);
 178     *(str++) = '1' + Y(mv->from);
 179     *(str++) = 'a' + X(mv->to);
 180     *(str++) = '1' + Y(mv->to);
 181
 182     /* promotion */
 183     if(mv->flags > PROMOTE0)
 184         *(str++) = Board::piecename[ mv->flags-PROMOTE0 ]^0x20;
 185     *(str++)='\0';
 186     return string;
 187 }
 188
 189 /* converts a move into the standard algebraic notation
 190    the current board must be the board before the move is done.
 191    mv must be a valid move in the current position! */
 192 char* Engine::move_to_alg(char* string,Move* mv)
 193 {
 194     char* str=string;
 195
 196     if(mv->flags==CASTLEKINGSIDE)
 197     {
 198         *(str++)='O';
 199         *(str++)='-';
 200         *(str++)='O';
 201     }
 202     else if(mv->flags==CASTLEQUEENSIDE)
 203     {
 204         *(str++)='O';
 205         *(str++)='-';
 206         *(str++)='O';
 207         *(str++)='-';
 208         *(str++)='O';
 209     }
 210     else
 211     {
 212         Move moves[200];
 213         int num_moves = board.find_moves(moves);
 214         unsigned char piece=board.data[mv->from];
 215
 216         if(PIECE_OF(piece)!=PAWN)
 217         {
 218             /* mark here how the move could be ambiguous */
 219             bool ambig = false;
 220             bool samecol=false;
 221             bool samerow=false;
 222
 223             *(str++)=Board::piecename[PIECE_OF(piece)];
 224
 225             for(int i=0;i<num_moves;i++)
 226             {
 227                 //check for ambiguity
 228                 if(piece == board.data[moves[i].from]      //same piece?
 229                   && moves[i].to == mv->to                 //same target?
 230                   && moves[i].from != mv->from)            //but not same move?
 231                 {
 232                     ambig = true;
 233                     if(X(moves[i].from)==X(mv->from))
 234                         samecol=true;
 235                     if(Y(moves[i].from)==Y(mv->from))
 236                         samerow=true;
 237                 }
 238             }
 239
 240             if(ambig)
 241             {
 242                 if(!samecol || samerow)
 243                     *(str++)='a' + X(mv->from);
 244                 if(samecol)
 245                     *(str++)='1' + Y(mv->from);
 246             }
 247         }
 248         if((mv->capture) || mv->flags==ENPASSANT)
 249         {
 250             if(PIECE_OF(piece)==PAWN)
 251                 *(str++)='a' + X(mv->from);
 252             *(str++)='x';
 253         }
 254
 255         *(str++)='a' + X(mv->to);
 256         *(str++)='1' + Y(mv->to);
 257
 258         if(mv->flags > PROMOTE0)
 259         {
 260             *(str++) = '=';
 261             *(str++) = Board::piecename[ mv->flags-PROMOTE0 ];
 262         }
 263     }
 264     /* is this move a check(mate)? */
 265     board.do_move(*mv);
 266     if(board.under_attack( board.king_pos[IS_WHITE(board.color_to_move)],
 267                                                         board.other_color) )
 268     {
 269         Move mv_tmp[200];
 270         int n = board.find_moves(mv_tmp);
 271
 272         if(n==0)
 273             *(str++)='#';
 274         else
 275             *(str++)='+';
 276     }
 277     board.undo_move(*mv);
 278     *(str++)='\0';
 279     return string;
 280 }
 281
 282 void Engine::print_moves(Move* m,int num,bool nums)
 283 {
 284     int i,j;
 285     if(board.color_to_move==BLACK &&nums)
 286         output("%d. ...",board.num_moves+1);
 287
 288     for(i=0;i<num;i++)
 289     {
 290         char str[32];
 291         if(m[i].as_int == 0)
 292             break;
 293
 294         if(board.color_to_move==WHITE && nums)
 295             printf(" %d.",board.num_moves+1);
 296         output( " %s", move_to_alg(str,m+i) );
 297         board.do_move(m[i]);
 298     }
 299
 300     Move hash_mv[24];
 301     int prev_depth = 0;
 302     for(j=0;j<24-i;j++)
 303     {
 304         HashEntry *h = probe_hash( board.hash );
 305         if(!h || !h->best_mv)
 306             break;
 307
 308         /* don't follow the hash if there is draw for repetition :) */
 309         if(j==0)
 310             prev_depth = h->depth;
 311         //if(h->depth > prev_depth)
 312         if( check_draw() )
 313         {
 314             output( " <DRAW>" );
 315             break;
 316         }
 317
 318         hash_mv[j] = board.uncompress_move( h->best_mv );
 319
 320         /* rerity taht the move in the hash is a legal move */
 321         Move tmp[255];
 322         int num_tmp = board.find_moves(tmp);
 323         bool ok = false;
 324         for(int q=0;q<num_tmp;q++)
 325         if(tmp[q] == hash_mv[j])
 326         {
 327             ok = true;
 328             break;
 329         }
 330
 331         if(!ok)
 332             break;
 333         /*{
 334             printf("QUEEEEEEEEEEEEEEE2!!!!!!!!!!\n");
 335             board.print_board();
 336             exit(0);
 337         }*/
 338
 339         char str[32];
 340         if(board.color_to_move==WHITE && nums)
 341             output(" %d.",board.num_moves+1);
 342         output( " %s", move_to_alg(str,hash_mv+j) );
 343         board.do_move(hash_mv[j]);
 344     }
 345
 346     while(j--)
 347         board.undo_move(hash_mv[j]);
 348
 349     while(i--)
 350         board.undo_move(m[i]);
 351
 352     output("\n");
 353 }
 354
 355 /* TODO: load correctly the pgn that start with a fen */
 356 int Engine::load_pgn(FILE *f)
 357 {
 358     char buf[1024];
 359
 360     board.set_as_default();
 361     mv_done_num     = 0;
 362
 363     while(1)
 364     {
 365         if(!fgets(buf, 1024, f))
 366             return 0;
 367         if(buf[0]=='\n' || buf[0]=='\r' || buf[0]=='\t'
 368                 || buf[0]==' ' || buf[0]=='[' || buf[0]=='#')
 369             continue;
 370         break;
 371     }
 372
 373     while(1)
 374     {
 375         char *ptr = buf;
 376         ptr += strspn(ptr, ". \t\r\n");
 377
 378         for(int i=0;;i++)
 379         {
 380             if(!*ptr)
 381                 break;
 382             char *t = ptr;
 383             char *tmp = (ptr += strcspn(ptr, ". \t\r\n"));
 384             ptr += strspn(ptr, ". \t\r\n");
 385             *tmp = 0;
 386
 387             /* is this the result? */
 388             if(!strcmp(t, "1-0"))
 389             {
 390                 status = _10;
 391                 return 1;
 392             }
 393             else if(!strcmp(t, "0-1"))
 394             {
 395                 status = _01;
 396                 return 1;
 397             }
 398             else if(!strcmp(t, "1/2-1/2") || !strcmp(t, "*"))
 399             {
 400                 status = _12;
 401                 return 1;
 402             }
 403
 404             /* is this a move number? */
 405             char *e;
 406             strtol(t, &e, 10);
 407             if(e!=t)
 408                 continue;
 409
 410             Move mv;
 411             int retv = parse_move(&mv, t);
 412             if(retv != 1)
 413             {
 414                 board.print_board();
 415                 output("Error! \"%s\" %d\n", t, retv);
 416                 return 0;   /* error */
 417             }
 418
 419             mv_done[mv_done_num++] = mv;
 420             board.do_move(mv);
 421         }
 422
 423         if(!fgets(buf, 1024, f))
 424             return 1;
 425     }
 426 }
 427
 428 int Engine::run_epd_prog(const char* prog, int time, const char* file, bool quiet)
 429 {
 430     char buf[1024];
 431     bool failed[8000];
 432     FILE *in = NULL;
 433     FILE *out = NULL;
 434     FILE *f;
 435
 436     /* open the file with the tests */
 437     f = fopen(file, "r");
 438     if(!f)
 439     {
 440         output("Error, could not open %s for reading!\n", file);
 441         return 0;
 442     }
 443
 444     if(!strcmp(prog, "self"))
 445     {
 446         if(quiet)
 447             post = false;
 448         set_time_fixed(time);
 449     }
 450     else
 451         start_engine(prog, &in, &out);
 452
 453     /* reset passed flags */
 454     int done = 0;
 455     int passed = 0;
 456     for(int i=0;i<8000;i++)
 457         failed[i] = false;
 458
 459     while(fgets(buf, 1024, f))
 460     {
 461         char brd[81];
 462         char color[2],castle[5],passing[3];
 463         char best[256];
 464         char avoid[256];
 465         char name[64];// = "unknown";
 466         char *tmp;
 467         Move best_mv[10];
 468         Move avoid_mv[10];
 469         int num_best = 0;
 470         int num_avoid = 0;
 471         Move m;
 472
 473
 474         /* read the board */
 475         sscanf(buf,"%s%s%s%s",
 476                brd,color,castle,passing);
 477         read_board(brd,color,castle,passing,0,0);
 478         if(!quiet)
 479         {
 480             output("\n\n");
 481             board.print_board();
 482         }
 483
 484
 485         done++;
 486
 487         /* save the best moves in the best_mv array */
 488         tmp = strstr(buf, "bm");
 489         if(tmp)
 490         {
 491             int tok = 0;
 492             sscanf(tmp, "bm %63[^;];", best);
 493             tok += strspn(best + tok, " \t\r\n");
 494
 495             for(num_best=0;num_best<10;num_best++)
 496             {
 497                 if(!best[tok])
 498                     break;
 499
 500                 int start = tok;
 501                 int firstspace = (tok += strcspn(best + tok, " \t\r\n"));
 502                 tok += strspn(best + tok, " \t\r\n");
 503                 best[firstspace] = 0;
 504
 505                 if(parse_move(&best_mv[num_best], best+start) != 1)
 506                 {
 507                     output("Error, could not parse move %s in pos %d\n", best+start, done);
 508                     return 0;
 509                 }
 510             }
 511         }
 512
 513         /* save the avoid moves in the best_mv array */
 514         tmp = strstr(buf, "am");
 515         if(tmp)
 516         {
 517             int tok = 0;
 518             sscanf(tmp, "am %63[^;];", avoid);
 519             tok += strspn(avoid + tok, " \t\r\n");
 520
 521             for(num_avoid=0;num_avoid<10;num_avoid++)
 522             {
 523                 if(!avoid[tok])
 524                     break;
 525
 526                 int start = tok;
 527                 int firstspace = (tok += strcspn(avoid + tok, " \t\r\n"));
 528                 tok += strspn(avoid + tok, " \t\r\n");
 529                 avoid[firstspace] = 0;
 530
 531                 if(parse_move(&avoid_mv[num_avoid], best+start) != 1)
 532                 {
 533                     output("Error, could not parse move %s in pos %d\n", best+start, done);
 534                     return 0;
 535                 }
 536             }
 537         }
 538
 539         /* get the id */
 540         tmp = strstr(buf, "id");
 541         if(tmp)
 542             sscanf ( tmp, "id %63[^;];", name);
 543         else
 544             strcpy( name, "<unknown>" );
 545
 546         if(!quiet)
 547         {
 548             output(" %d - Thinking", done);
 549             if(num_best)
 550             {
 551                 output(", the best move%s\e[32;1m", num_best>1 ? "s are" : " is");
 552                 for(int i=0;i<num_best;i++)
 553                     output(" %s", move_to_alg(buf, &best_mv[i]) );
 554                 output("\e[0m");
 555             }
 556             if(num_avoid)
 557             {
 558                 output(", the move%s to avoid\e[31;1m", num_avoid>1 ? "s are" : " is");
 559                 for(int i=0;i<num_avoid;i++)
 560                     output(" %s", move_to_alg(buf, &avoid_mv[i]) );
 561                 output("\e[0m");
 562             }
 563             output("\n");
 564         }
 565
 566         if(!strcmp(prog, "self"))
 567         {
 568             st_computer_color = board.color_to_move;
 569             m = find_best_move();
 570         }
 571         else
 572         {
 573             fprintf(out, "force\n");
 574             board.write_board(buf);
 575             fprintf(out, "setboard %s\n", buf);
 576             fprintf(out, "st %d\n", time);
 577             //fprintf(out, "level 1 %d 0\n", time);
 578             fprintf(out, "time %d\n", time*200);
 579             fprintf(out, "otim %d\n", time*200);
 580             fprintf(out, "go\n");
 581
 582             while(fgets(buf, 1024, in))
 583             {
 584                 char mv[32];
 585                 if(!strncmp(buf, "move ", 5))
 586                 {
 587                     sscanf ( buf, "move %s", mv);
 588                     if(parse_move( &m, mv )!=1)
 589                     {
 590                         output("Got illegal move %s\n", mv);
 591                         return 0;
 592                     }
 593                     break;
 594                 }
 595                 else
 596             output(buf);
 597             }
 598         }
 599
 600         bool fail = false;
 601         if(!quiet)
 602             output("Result: \e[36;1m%s\e[0m\n", move_to_alg(buf, &m));
 603         for(int i=0;i<num_avoid;i++)
 604         if(m == avoid_mv[i])
 605         {
 606             fail = true;
 607             if(!quiet)
 608                 output("Test %d \e[31;1mFAILURE\e[0m, %s did not avoid the "
 609                         "wrong move \e[33;1m%s\e[0m (che pollo!)\n",done, prog,
 610                                    move_to_alg(buf, &avoid_mv[i]));
 611         }
 612         if(num_avoid && !fail && !quiet)
 613             output("Test %d \e[32;1mSUCCESS\e[0m, %s avoided the "
 614                     "wrong move%s \e[33;1m%s\e[0m (teto figo!)\n",
 615                     done, prog, num_avoid>1?"s":"", avoid);
 616         if(!fail && num_best)
 617         {
 618             fail = true;
 619             for(int i=0;i<num_best;i++)
 620             if(m == best_mv[i])
 621             {
 622                 fail = false;
 623                 if(!quiet)
 624                     output("Test %d \e[32;1mSUCCESS\e[0m, %s found the "
 625                             "best move \e[33;1m%s\e[0m (o se figo!)\n",
 626                             done, prog,  move_to_alg(buf, &best_mv[i]));
 627                 break;
 628             }
 629             if(fail && !quiet)
 630                 output("Test %d \e[31;1mFAILURE\e[0m, %s missed the best "
 631                         "move%s (\e[33;1m%s\e[0m) (che scarso!)\n",  done, prog,
 632                                 num_best>1?"s":"", best);
 633         }
 634         if(!fail)
 635             passed++;
 636         else
 637             failed[done] = true;
 638
 639         if(!quiet)
 640             output("Test %d %s %s!  (+%d, -%d, ~%d%%)\n", done, name, fail ?
 641                         "\e[31;1mFAILED\e[0m" : "\e[32;1mPASSED\e[0m",
 642                             passed, done-passed, passed*100/done);
 643         else
 644             output("%s", fail ? "-" : "+");
 645     }
 646     if(quiet)
 647         output("\n");
 648     output("Passed %d tests out of %d (%d%%)\n", passed, done, passed*100/done);
 649     if(!quiet)
 650     {
 651         output("Failed are:\n");
 652         int numsh = 0;
 653         for(int i=1;i<done+1;i++)
 654             if(failed[i])
 655             {
 656                 output(" %d", i);
 657                 if(((++numsh) % 10) == 0)
 658                     output("\n");
 659             }
 660         output("\n");
 661     }
 662
 663     if(strcmp(prog, "self"))
 664     {
 665         fprintf(out, "quit\n");
 666         fclose(out);
 667         fclose(in);
 668     }
 669     fclose(f);
 670
 671     return passed;
 672 }
 673
 674 void Engine::save_pgn(FILE *f, const char *result1, const char *result)
 675 {
 676     for(int i=mv_done_num-1;i>=0;i--)
 677         board.undo_move(mv_done[i]);
 678
 679     fprintf(f, "[White \"%s\"]\n", st_computer_color == WHITE ?
 680                                 "RattateChess" : opponent );
 681     fprintf(f, "[Black \"%s\"]\n", st_computer_color == BLACK ?
 682                                 "RattateChess" : opponent );
 683     fprintf(f, "[WhiteELO \"%d\"]\n", w_rating);
 684     fprintf(f, "[BlackELO \"%d\"]\n", b_rating);
 685
 686     time_t t = time(NULL);
 687     char tbuf[256];
 688     strftime(tbuf, 256, "%Y.%m.%d %H:%M", localtime(&t));
 689     fprintf(f, "[Date \"%s\"]\n", tbuf);
 690     fprintf(f, "[Result \"%s\"]\n", result1);
 691
 692     if(0)
 693     {
 694         char fen[256];
 695         board.write_board(fen);
 696         fprintf(f, "[FEN \"%s\"]\n", fen);
 697     }
 698
 699     if(board.color_to_move==BLACK)
 700         fprintf(f, "%d. ... ",board.num_moves+1);
 701     for(int i=0;i<mv_done_num;i++)
 702     {
 703         char buf[32];
 704         if(board.color_to_move==WHITE)
 705             fprintf(f, "%d. ",board.num_moves+1);
 706         fprintf(f, "%s ", move_to_alg(buf, &mv_done[i]) );
 707         if((i+1)%14 == 0 && i!=mv_done_num-1)
 708             fprintf(f, "\n");
 709         board.do_move(mv_done[i]);
 710     }
 711     fprintf(f, "\n%s\n\n", result);
 712 }
 713
 714 void Engine::challenge(const char* prog, int time, const char* file)
 715 {
 716     char buf[1024];
 717     FILE *in = NULL;
 718     FILE *out = NULL;
 719     FILE *f;
 720     FILE *log;
 721     int won=0, draw=0, lost=0;
 722
 723     /* open the file with the tests */
 724     f = fopen(file, "r");
 725     log = fopen("challenge.pgn", "w");
 726
 727     if(!f)
 728     {
 729         output("Error, could not open %s for reading!\n", file);
 730         return;
 731     }
 732
 733     start_engine(prog, &in, &out);
 734
 735     while(fgets(buf, 1024, f))
 736     {
 737         uint8_t cols[2] = {WHITE, BLACK};
 738
 739         for(int i=0;i<2;i++)
 740         {
 741             char fen[256];
 742             bool go_done = false;
 743             read_board(buf);
 744             //set_max_nodes(time);
 745             set_time_fixed(time);
 746         ponder = false;
 747             board.write_board(fen);
 748
 749             fprintf(out, "new\n");
 750             fprintf(out, "st %d\n", time);
 751             //fprintf(out, "level 1 %d 0\n", time);
 752             fprintf(out, "force\n");
 753             fprintf(out, "setboard %s\n", fen);
 754
 755
 756             status = PLAYING;
 757             st_computer_color = cols[i];
 758
 759             while(1)
 760             {
 761                 char buf[1024];
 762
 763                 /*output("\n\n");
 764                 board.print_board();*/
 765
 766                 /* print the pgn to the log file */
 767                 if(status != PLAYING)
 768                 {
 769                     const char *result = status==_01?"0-1":(status==_10?"1-0":"1/2-1/2");
 770                     const char *white = st_computer_color == WHITE ? "Rattatechess" : prog;
 771                     const char *black = st_computer_color == BLACK ? "Rattatechess" : prog;
 772
 773                     if(log)
 774                     {
 775                         for(int i=mv_done_num-1;i>=0;i--)
 776                             board.undo_move(mv_done[i]);
 777
 778                         fprintf(log, "[White \"%s\"]\n", white);
 779                         fprintf(log, "[Black \"%s\"]\n", black);
 780                         fprintf(log, "[Result \"%s\"]\n", result);
 781                         fprintf(log, "[FEN \"%s\"]\n", fen);
 782
 783                         if(board.color_to_move==BLACK)
 784                             fprintf(log, "%d. ... ",board.num_moves+1);
 785                         for(int i=0;i<mv_done_num;i++)
 786                         {
 787                             char buf[32];
 788                             if(board.color_to_move==WHITE)
 789                                 fprintf(log, "%d. ",board.num_moves+1);
 790                             fprintf(log, "%s ", move_to_alg(buf, &mv_done[i]) );
 791                             if((i+1)%14 == 0)
 792                                 fprintf(log, "\n");
 793                             board.do_move(mv_done[i]);
 794                         }
 795                         fprintf(log, "%s\n\n", result);
 796                         fflush(log);
 797                     }
 798
 799                     if((status==_01 && st_computer_color==BLACK) ||
 800                             (status==_10 && st_computer_color==WHITE))
 801                     {
 802                         output("RATTA!!!\n");
 803                         won++;
 804                     }
 805                     else if(status==_12)
 806                     {
 807                         output("DRAW!\n");
 808                         draw++;
 809                     }
 810                     else
 811                     {
 812                         output("ARGH!!!\n");
 813                         lost++;
 814                     }
 815                     break;
 816                 }
 817
 818                 /* think or wait for a new move */
 819                 if(st_computer_color == board.color_to_move)
 820                 {
 821                     char buf2[32];
 822
 823                     /* think and move */
 824                     Move mv = find_best_move();
 825                     output("%d. %s %s\n",board.num_moves+1,
 826                             board.color_to_move==BLACK ? "..." : "",
 827                             move_to_alg(buf2, &mv) );
 828                     fprintf( out, "%s\n", move_to_coord(buf2,&mv));
 829                     move(mv);
 830                 }
 831                 else
 832                 {
 833                     if(!go_done)
 834                     {
 835                         fprintf( out, "go\n");
 836                         go_done = true;
 837                     }
 838
 839                     while(fgets(buf, 1024, in))
 840                     {
 841                         /* get a move from the other engine */
 842                         if(!strncmp(buf, "move ", 5))
 843                         {
 844                             Move mv;
 845                             char buf2[32];
 846                             sscanf( buf, "move %s", buf2);
 847                             if(parse_move( &mv, buf2 )!=1)
 848                             {
 849                                 output("Got illegal move %s\n", buf2);
 850                                 return;
 851                             }
 852                             output("%d. %s %s\n",board.num_moves+1,
 853                                     board.color_to_move==BLACK ? "..." : "",
 854                                     move_to_alg(buf2, &mv) );
 855                             move(mv);
 856                             break;
 857                         }
 858                         else if(!strcmp(buf, "resign"))
 859                         {
 860                             status = board.color_to_move==WHITE?_01:_10;
 861                             break;
 862                         }
 863                         //else
 864                           //  output(buf);
 865                     }
 866                 }
 867             }
 868         }
 869     }
 870
 871     fprintf(out, "quit\n");
 872     fclose(out);
 873     fclose(in);
 874     if(log) fclose(log);
 875     fclose(f);
 876
 877     output("\n\n%d games played (+%d =%d -%d)\n", won+draw+lost, won, draw, lost);
 878 }