lasker-2.2.3/src/matchproc.c

   1 /*
   2    This program is free software; you can redistribute it and/or modify
   3    it under the terms of the GNU General Public License as published by
   4    the Free Software Foundation; either version 2 of the License, or
   5    (at your option) any later version.
   6
   7    This program is distributed in the hope that it will be useful,
   8    but WITHOUT ANY WARRANTY; without even the implied warranty of
   9    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10    GNU General Public License for more details.
  11
  12    You should have received a copy of the GNU General Public License
  13    along with this program; if not, write to the Free Software
  14    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  15 */
  16
  17 /**
  18   matchproc.c
  19   Feb 9 1996 - rewritten - DAV
  20
  21 */
  22
  23 #include "includes.h"
  24
  25 const char *colorstr[] = {"", "[black] ", "[white] "};
  26 const char *adjustr[] = {"", " (adjourned)"};
  27
  28 static void prepare_match(int g,int wt,int bt,int winc,int binc,int wp, int bp,int rated)
  29 {
  30
  31   wt = wt * 60;                 /* To Seconds */
  32   bt = bt * 60;
  33   game_globals.garray[g].white = wp;
  34   game_globals.garray[g].black = bp;
  35   strcpy(game_globals.garray[g].white_name, player_globals.parray[wp].name);
  36   strcpy(game_globals.garray[g].black_name, player_globals.parray[bp].name);
  37   game_globals.garray[g].status = GAME_ACTIVE;
  38   if ((game_globals.garray[g].type == TYPE_UNTIMED) || (game_globals.garray[g].type == TYPE_NONSTANDARD))
  39     game_globals.garray[g].rated = 0;
  40   else
  41     game_globals.garray[g].rated = rated;
  42   game_globals.garray[g].private = BoolCheckPFlag(wp, PFLAG_PRIVATE)
  43                       || BoolCheckPFlag(bp, PFLAG_PRIVATE);
  44   game_globals.garray[g].white = wp;
  45   if (game_globals.garray[g].type == TYPE_BLITZ) {
  46     game_globals.garray[g].white_rating = player_globals.parray[wp].b_stats.rating;
  47     game_globals.garray[g].black_rating = player_globals.parray[bp].b_stats.rating;
  48   } else if (game_globals.garray[g].type == TYPE_WILD) {
  49     game_globals.garray[g].white_rating = player_globals.parray[wp].w_stats.rating;
  50     game_globals.garray[g].black_rating = player_globals.parray[bp].w_stats.rating;
  51   } else if (game_globals.garray[g].type == TYPE_LIGHT) {
  52     game_globals.garray[g].white_rating = player_globals.parray[wp].l_stats.rating;
  53     game_globals.garray[g].black_rating = player_globals.parray[bp].l_stats.rating;
  54   } else if (game_globals.garray[g].type == TYPE_BUGHOUSE) {
  55     game_globals.garray[g].white_rating = player_globals.parray[wp].bug_stats.rating;
  56     game_globals.garray[g].black_rating = player_globals.parray[bp].bug_stats.rating;
  57   } else {
  58     game_globals.garray[g].white_rating = player_globals.parray[wp].s_stats.rating;
  59     game_globals.garray[g].black_rating = player_globals.parray[bp].s_stats.rating;
  60   }
  61
  62   game_globals.garray[g].game_state.gameNum = g;
  63
  64   game_globals.garray[g].wTime = wt * 10;
  65   game_globals.garray[g].wInitTime = wt * 10;
  66   game_globals.garray[g].wIncrement = winc * 10;
  67   game_globals.garray[g].bTime = bt * 10;
  68
  69   if (game_globals.garray[g].type != TYPE_UNTIMED) {
  70     if (wt == 0)
  71         game_globals.garray[g].wTime = 100;
  72     if (bt == 0)
  73         game_globals.garray[g].bTime = 100;
  74   } /* 0 x games start with 10 seconds */
  75
  76   game_globals.garray[g].wRealTime = game_globals.garray[g].wTime * 100;
  77   game_globals.garray[g].bRealTime = game_globals.garray[g].bTime * 100;
  78   game_globals.garray[g].wTimeWhenReceivedMove = 0;
  79   game_globals.garray[g].bTimeWhenReceivedMove = 0;
  80
  81   game_globals.garray[g].bInitTime = bt * 10;
  82   game_globals.garray[g].bIncrement = binc * 10;
  83
  84   if (game_globals.garray[g].game_state.onMove == BLACK) {   /* Start with black */
  85     game_globals.garray[g].numHalfMoves = 1;
  86     game_globals.garray[g].moveListSize = 1;
  87     game_globals.garray[g].moveList = (struct move_t *) malloc(sizeof(struct move_t));
  88     game_globals.garray[g].moveList[0].fromFile = -1;
  89     game_globals.garray[g].moveList[0].fromRank = -1;
  90     game_globals.garray[g].moveList[0].toFile = -1;
  91     game_globals.garray[g].moveList[0].toRank = -1;
  92     game_globals.garray[g].moveList[0].color = WHITE;
  93     strcpy(game_globals.garray[g].moveList[0].moveString, "NONE");
  94     strcpy(game_globals.garray[g].moveList[0].algString, "NONE");
  95   } else {
  96     game_globals.garray[g].numHalfMoves = 0;
  97     game_globals.garray[g].moveListSize = 0;
  98     game_globals.garray[g].moveList = NULL;
  99   }
 100
 101   game_globals.garray[g].timeOfStart = tenth_secs();
 102   game_globals.garray[g].startTime = tenth_secs();
 103   game_globals.garray[g].lastMoveTime = game_globals.garray[g].startTime;
 104   game_globals.garray[g].lastDecTime = game_globals.garray[g].startTime;
 105   game_globals.garray[g].clockStopped = 0;
 106
 107 }
 108
 109 static void pick_colors(int* wp,int* bp,int white,int wt,int bt,int winc,
 110                                                                 int binc)
 111
 112 {
 113  int reverse = 0;
 114
 115   if (white == 0) {
 116     reverse = 1; /* did challenger ask for black? */
 117
 118   } else if (white == -1) { /* unknown */
 119
 120     if ((wt == bt) && (winc == binc)) { /* if diff times challenger is white */
 121
 122       if (CheckPFlag(*wp, PFLAG_LASTBLACK)==CheckPFlag(*bp, PFLAG_LASTBLACK)) {
 123         if ((player_globals.parray[*wp].num_white - player_globals.parray[*wp].num_black) >
 124           (player_globals.parray[*bp].num_white - player_globals.parray[*bp].num_black))
 125           reverse = 1; /* whose played the most extra whites gets black */
 126
 127       } else if (!CheckPFlag(*wp, PFLAG_LASTBLACK))
 128         reverse = 1;
 129
 130     } else
 131       reverse = 1;
 132   }
 133   if (reverse) {
 134     int tmp = *wp;
 135     *wp = *bp;
 136     *bp = tmp;
 137   }
 138 }
 139
 140 static void output_match_messages(int wp,int bp,int g, char* mess)
 141 {
 142
 143   int printed;
 144   int avail_printed = 0;
 145   char notavail_white[200];
 146   char notavail_black[200];
 147   int p;
 148   char *outStr;
 149
 150   notavail_white[0] = '\0';
 151   notavail_black[0] = '\0';
 152
 153   asprintf(&outStr,"\nCreating: %s (%d) %s (%d) %s %s %d %d\n",
 154            player_globals.parray[wp].name,
 155            game_globals.garray[g].white_rating,
 156            player_globals.parray[bp].name,
 157            game_globals.garray[g].black_rating,
 158            rstr[game_globals.garray[g].rated],
 159            //bstr[game_globals.garray[g].type],
 160            game_globals.garray[g].variant,
 161            game_globals.garray[g].wInitTime/600,
 162            game_globals.garray[g].wIncrement);
 163   pprintf(wp, "%s", outStr);
 164   pprintf(bp, "%s", outStr);
 165   free(outStr);
 166
 167   asprintf(&outStr, "\n{Game %d (%s vs. %s) %s %s %s match.}\n",
 168           g + 1, player_globals.parray[wp].name,
 169           player_globals.parray[bp].name,
 170           mess,
 171           rstr[game_globals.garray[g].rated],
 172           //bstr[game_globals.garray[g].type]);
 173           game_globals.garray[g].variant);
 174   pprintf(wp, "%s", outStr);
 175   pprintf(bp, "%s", outStr);
 176
 177   if (!(player_num_active_boards(wp)) && CheckPFlag(wp, PFLAG_OPEN))
 178 /* open may be 0 if a simul */
 179     getnotavailmess(wp,notavail_white);
 180   if (CheckPFlag(bp, PFLAG_OPEN))
 181     getnotavailmess(bp,notavail_black);
 182   for (p = 0; p < player_globals.p_num; p++) {
 183     struct player *pp = &player_globals.parray[p];
 184     int gnw, gnb;
 185     printed = 0;
 186
 187     if ((p == wp) || (p == bp))
 188       continue;
 189     if (pp->status != PLAYER_PROMPT)
 190       continue;
 191     if (CheckPFlag(p, PFLAG_GIN)) {
 192       pprintf(p, "%s", outStr);
 193       printed = 1;
 194     }
 195     gnw = in_list(p, L_GNOTIFY, player_globals.parray[wp].login);
 196     gnb = in_list(p, L_GNOTIFY, player_globals.parray[bp].login);
 197     if (gnw || gnb) {
 198       pprintf(p, "\nGame notification: ");
 199
 200       if (gnw)
 201         pprintf_highlight(p, player_globals.parray[wp].name);
 202       else
 203         pprintf(p, player_globals.parray[wp].name);
 204
 205       pprintf(p, " (%s) vs. ",
 206               ratstr(GetRating(&player_globals.parray[wp], game_globals.garray[g].type)));
 207
 208       if (gnb)
 209         pprintf_highlight(p, player_globals.parray[bp].name);
 210       else
 211         pprintf(p, player_globals.parray[bp].name);
 212       pprintf(p, " (%s) %s %s %d %d: Game %d\n",
 213                      ratstr(GetRating(&player_globals.parray[bp], game_globals.garray[g].type)),
 214                      rstr[game_globals.garray[g].rated], bstr[game_globals.garray[g].type],
 215                      game_globals.garray[g].wInitTime/600, game_globals.garray[g].wIncrement/10, g+1);
 216
 217       printed = 1;
 218     }
 219
 220     if (CheckPFlag(p, PFLAG_AVAIL) && CheckPFlag(p, PFLAG_OPEN) && (pp->game < 0) &&
 221        (CheckPFlag(wp, PFLAG_OPEN) || CheckPFlag(bp, PFLAG_OPEN))) {
 222
 223       if (((player_globals.parray[wp].b_stats.rating <= pp->availmax) &&
 224          (player_globals.parray[wp].b_stats.rating >= pp->availmin)) ||
 225          (!pp->availmax)) {
 226          pprintf (p,"\n%s",notavail_white);
 227          avail_printed = 1;
 228       }
 229
 230       if (((player_globals.parray[bp].b_stats.rating <= pp->availmax) &&
 231          (player_globals.parray[bp].b_stats.rating >= pp->availmin)) ||
 232          (!pp->availmax)) {
 233       pprintf (p,"\n%s",notavail_black);
 234       avail_printed = 1;
 235       }
 236
 237       if (avail_printed) {
 238         printed = 1;
 239         avail_printed = 0;
 240         pprintf (p,"\n");
 241       } /* was black or white open originally (for simuls) */
 242     }
 243
 244     if (printed)
 245       send_prompt (p);
 246   }
 247
 248   free(outStr);
 249 }
 250
 251 int create_new_match(int g, int white_player, int black_player,
 252                              int wt, int winc, int bt, int binc,
 253                              int rated, char *category, char *board,
 254                              int white, int simul)
 255 {
 256
 257   remove_request(white_player, black_player, -PEND_PARTNER);
 258
 259   pick_colors(&white_player,&black_player,white,wt,bt,winc,binc);
 260
 261   decline_withdraw_offers(white_player,-1, PEND_MATCH,DO_WITHDRAW | DO_DECLINE);
 262   decline_withdraw_offers(black_player,-1, PEND_MATCH,DO_WITHDRAW | DO_DECLINE);
 263   decline_withdraw_offers(black_player,-1, PEND_SIMUL,DO_WITHDRAW | DO_DECLINE);
 264   if (simul) {
 265     decline_withdraw_offers(white_player, -1, PEND_SIMUL, DO_WITHDRAW);
 266   } else {
 267     decline_withdraw_offers(white_player, -1, PEND_SIMUL,
 268                             DO_WITHDRAW | DO_DECLINE);
 269   }
 270   game_globals.garray[g].FENstartPos[0] = 0; // [HGM] new shuffle
 271   if (board_init(g,&game_globals.garray[g].game_state, category, board)) {
 272     pprintf(white_player, "PROBLEM LOADING BOARD. Game Aborted.\n");
 273     pprintf(black_player, "PROBLEM LOADING BOARD. Game Aborted.\n");
 274     d_printf( "CHESSD: PROBLEM LOADING BOARD %s %s. Game Aborted.\n",
 275             category, board);
 276     game_remove(g);
 277     return COM_FAILED;
 278   }
 279
 280   if (simul)
 281     game_globals.garray[g].type = TYPE_UNTIMED;
 282   else
 283     game_globals.garray[g].type = game_isblitz(wt, winc, bt, binc, category, board);
 284
 285   if(category && category[0]) { // [HGM] set variant string from directory for games loaded from file
 286     if(!strcmp(category, "wild") && board)
 287         sprintf(game_globals.garray[g].variant, "%s/%s", category, board);
 288     else
 289         strcpy(game_globals.garray[g].variant, category);
 290   }
 291   else
 292     strcpy(game_globals.garray[g].variant, bstr[game_globals.garray[g].type]);
 293
 294   prepare_match(g,wt,bt,winc,binc,white_player,black_player,rated);
 295
 296   output_match_messages(white_player,black_player,g, "Creating");
 297
 298   player_globals.parray[white_player].game = g;
 299   player_globals.parray[white_player].opponent = black_player;
 300   player_globals.parray[white_player].side = WHITE;
 301   player_globals.parray[white_player].promote = QUEEN;
 302   player_globals.parray[black_player].game = g;
 303   player_globals.parray[black_player].opponent = white_player;
 304   player_globals.parray[black_player].side = BLACK;
 305   player_globals.parray[black_player].promote = QUEEN;
 306   send_boards(g);
 307   gics_globals.userstat.games++;
 308
 309   /* obey any 'follow' lists */
 310   follow_start(white_player,black_player);
 311
 312   return COM_OK;
 313 }
 314
 315 int accept_match(struct pending *pend, int p, int p1)
 316 {
 317   struct player *pp = &player_globals.parray[p];
 318   int wt, winc, bt, binc, rated, white;
 319   char category[50], board[50];
 320   char tmp[100];
 321   int bh = 0, partner = 0, pp1 = 0, g1, g2;
 322
 323   unobserveAll(p);              /* stop observing when match starts */
 324   unobserveAll(p1);
 325
 326   wt = pend->wtime;
 327   winc = pend->winc;
 328   bt = pend->btime;
 329   binc = pend->binc;
 330   rated = pend->rated;
 331   strcpy (category, pend->category);
 332   strcpy (board, pend->board_type);
 333   white = (pend->seek_color == -1) ? -1 : 1 - pend->seek_color;
 334
 335   pprintf(p, "You accept the challenge of %s.\n", player_globals.parray[p1].name);
 336   pprintf_prompt(p1, "\n%s accepts your challenge.\n", pp->name);
 337
 338   if(!pend->status)
 339     delete_pending(pend);
 340
 341   withdraw_seeks(p);
 342   withdraw_seeks(p1);
 343
 344   pend_join_match (p,p1);
 345
 346   if (game_isblitz(wt, winc, bt, binc, category, board) == TYPE_BUGHOUSE) {
 347     bh = 1;
 348
 349     if ((partner = pp->partner) >= 0 &&
 350         (pp1 = player_globals.parray[p1].partner) >= 0) {
 351       unobserveAll(partner);         /* stop observing when match starts */
 352       unobserveAll(pp1);
 353
 354       pprintf(partner, "\nYour partner accepts the challenge of %s.\n", player_globals.parray[p1].name);
 355       pprintf(pp1, "\n%s accepts your partner's challenge.\n", pp->name);
 356
 357       pend_join_match (partner,pp1);
 358     } else {
 359       return COM_OK;
 360     }
 361   }
 362
 363   g1 = game_new(); /* create a game structure */
 364   if (g1 < 0) {
 365     sprintf(tmp, "There was a problem creating the new match.\n");
 366     pprintf(p, tmp);
 367     pprintf_prompt(p1, tmp);
 368   }
 369
 370   if (game_read(g1, p1, p) >= 0) {
 371           int swap;
 372           swap = p;
 373           p = p1;
 374           p1 = swap;
 375           pp = &player_globals.parray[p];
 376   } else if (game_read(g1, p, p1) < 0) { /* so no adjourned game */
 377     if (create_new_match(g1,p, p1, wt, winc, bt, binc, rated, category, board, white,0) == COM_FAILED)
 378       return COM_OK;
 379
 380  /* create first game */
 381
 382     if (bh) { /* do bughouse creation */
 383
 384       white = (pp->side == WHITE ? 0 : 1);
 385       g2 = game_new();
 386       if ((g2 < 0) || (create_new_match(g2,partner, pp1, wt, winc, bt, binc, rated, category, board,white,0) == COM_FAILED)) {
 387          sprintf(tmp, "There was a problem creating the new match.\n");
 388          pprintf_prompt(partner, tmp);
 389          pprintf_prompt(pp1, tmp);
 390          sprintf(tmp, "There was a problem creating your partner's match.\n");
 391          game_remove(g1); /* abort first game */
 392          return COM_OK;
 393        }
 394
 395       game_globals.garray[g1].link = g2; /* link the games */
 396       game_globals.garray[g2].link = g1;
 397
 398       sprintf(tmp, "\nYour partner is playing game %d (%s vs. %s).\n",
 399               g2 + 1, game_globals.garray[g2].white_name, game_globals.garray[g2].black_name);
 400       pprintf(p, tmp);
 401       pprintf_prompt(p1, tmp);
 402
 403       sprintf(tmp, "\nYour partner is playing game %d (%s vs. %s).\n",
 404               g1 + 1, game_globals.garray[g1].white_name, game_globals.garray[g1].black_name);
 405       pprintf_prompt(partner, tmp);
 406       pprintf_prompt(pp1, tmp);
 407     }
 408     return COM_OK;
 409   }
 410
 411        /* resume adjourned game */
 412
 413   game_delete(p, p1); /* remove the game from disk */
 414
 415   sprintf(tmp, "{Game %d (%s vs. %s) Continuing %s %s match.}\n",
 416         g1+1, pp->name, player_globals.parray[p1].name,
 417         rstr[game_globals.garray[g1].rated], bstr[game_globals.garray[g1].type]);
 418   pprintf(p, tmp);
 419   pprintf(p1, tmp);
 420   output_match_messages(p, p1, g1, "Continuing");
 421
 422   game_globals.garray[g1].white = p;
 423   game_globals.garray[g1].black = p1;
 424   game_globals.garray[g1].status = GAME_ACTIVE;
 425   game_globals.garray[g1].result = END_NOTENDED;
 426   game_globals.garray[g1].startTime = tenth_secs();
 427   game_globals.garray[g1].lastMoveTime = game_globals.garray[g1].startTime;
 428   game_globals.garray[g1].lastDecTime = game_globals.garray[g1].startTime;
 429   pp->game = g1;
 430   pp->opponent = p1;
 431   pp->side = WHITE;
 432   player_globals.parray[p1].game = g1;
 433   player_globals.parray[p1].opponent = p;
 434   player_globals.parray[p1].side = BLACK;
 435
 436   send_boards(g1);
 437
 438   /* obey any 'follow' lists */
 439   follow_start(p,p1);
 440
 441   return COM_OK;
 442 }
 443
 444 /* board and category are initially empty strings */
 445 static int parse_match_string(int p, int* wt,int* bt,int* winc,int* binc,
 446                                 int* white,int* rated,char* category,
 447                                 char* board, char* mstring)
 448 {
 449   int numba;
 450   int confused = 0;
 451   char parsebuf[100];
 452   int bughouse = 0;
 453
 454   while (!confused && (sscanf(mstring, " %99s", parsebuf) == 1)) {
 455     mstring = eatword(eatwhite(mstring));
 456
 457     if ((category[0] != '\0') && (board[0] == '\0') && !bughouse)
 458       strcpy(board, parsebuf);
 459     else if (isdigit(*parsebuf)) {
 460       if ((numba = atoi(parsebuf)) < 0) {
 461         pprintf(p, "You can't specify negative time controls.\n");
 462         return 0;
 463       } else if (numba > 999) {
 464         pprintf(p, "You can't specify time or inc above 999.\n");
 465         return 0;
 466       } else if (*wt == -1) {
 467         *wt = numba;
 468       } else if (*winc == -1) {
 469         *winc = numba;
 470       } else if (*bt == -1) {
 471         *bt = numba;
 472       } else if (*binc == -1) {
 473         *binc = numba;
 474       } else
 475         confused = 1;
 476
 477     } else if ((!strcmp("rated", parsebuf)) || (!strcmp("r",parsebuf))) {
 478       if (*rated == -1)
 479         *rated = 1;
 480       else
 481         confused = 1;
 482     } else if ((!strcmp("unrated", parsebuf)) || (!strcmp("u",parsebuf))) {
 483       if (*rated == -1)
 484         *rated = 0;
 485       else
 486         confused = 1;
 487     } else if (!strcmp("white", parsebuf) || !strcmp ("w", parsebuf)) {
 488       if (*white == -1)
 489         *white = 1;
 490       else
 491         confused = 1;
 492     } else if (!strcmp("black", parsebuf) || !strcmp ("b", parsebuf)) {
 493       if (*white == -1)
 494         *white = 0;
 495       else
 496         confused = 1;
 497
 498     } else if (category[0] == '\0') {
 499       if ((parsebuf[0] == 'w') && (isdigit(*(parsebuf + 1)))) {
 500         strcpy (category, "wild");
 501         strcpy (board, parsebuf+1);
 502       } else {
 503         strcpy(category,parsebuf);
 504         if (!strncmp("bughouse",category, strlen(category))
 505             && strlen(category) >= 3 || !strcmp("bh", category)) {
 506           strcpy(category, "bughouse");
 507           bughouse = 1;
 508         }
 509         // [HGM] allow some shortcuts for variant names
 510         if(!strcmp("bh", category)) {
 511           strcpy(category, "bughouse");
 512         } else
 513         if(!strcmp("zh", category)) {
 514           strcpy(category, "crazyhouse");
 515         } else
 516         if(!strcmp("fr", category)) {
 517           strcpy(category, "fischerandom");
 518         } else
 519         if(!strcmp("sj", category)) {
 520           strcpy(category, "shatranj");
 521         } else
 522         if(!strcmp("gc", category)) {
 523           strcpy(category, "gothic");
 524         } else
 525         if(!strcmp("ca", category)) {
 526           strcpy(category, "capablanca");
 527         } else
 528         if(!strcmp("cr", category)) {
 529           strcpy(category, "caparandom");
 530         } else
 531         if(!strcmp("su", category)) {
 532           strcpy(category, "super");
 533         } else
 534         if(!strcmp("sg", category)) {
 535           strcpy(category, "shogi");
 536         } else
 537         if(!strcmp("km", category)) {
 538           strcpy(category, "knightmate");
 539         } else
 540         if(!strcmp("gr", category)) {
 541           strcpy(category, "great");
 542         } else
 543         if(!strcmp("xq", category)) {
 544           strcpy(category, "xiangqi");
 545         }
 546       }
 547     } else
 548       confused = 1;
 549   }
 550
 551   if (confused) {
 552     pprintf(p, "Can't interpret %s in match command.\n", parsebuf);
 553     return 0;
 554   }
 555   if(category && (!board || !board[0]))
 556         strcpy(board, "0"); // [HGM] variants: always provide default board
 557   return 1;
 558 }
 559
 560 static void print_match_rating_info(int p,int p1,int type,int rated)
 561 {
 562   if (rated) {
 563     int win, draw, loss;
 564     double newsterr;
 565
 566     rating_sterr_delta(p1, p, type, time(0), RESULT_WIN, &win, &newsterr);
 567     rating_sterr_delta(p1, p, type, time(0), RESULT_DRAW, &draw, &newsterr);
 568     rating_sterr_delta(p1, p, type, time(0), RESULT_LOSS, &loss, &newsterr);
 569     pprintf(p1, "Your %s rating will change:  Win: %s%d,  Draw: %s%d,  Loss: %s%d\n",
 570             bstr[type],
 571             (win >= 0) ? "+" : "", win,
 572             (draw >= 0) ? "+" : "", draw,
 573             (loss >= 0) ? "+" : "", loss);
 574     pprintf(p1, "Your new RD will be %5.1f\n", newsterr);
 575
 576     rating_sterr_delta(p, p1, type, time(0), RESULT_WIN, &win, &newsterr);
 577     rating_sterr_delta(p, p1, type, time(0), RESULT_DRAW, &draw, &newsterr);
 578     rating_sterr_delta(p, p1, type, time(0), RESULT_LOSS, &loss, &newsterr);
 579     pprintf(p, "Your %s rating will change:  Win: %s%d,  Draw: %s%d,  Loss: %s%d\n",
 580             bstr[type],
 581             (win >= 0) ? "+" : "", win,
 582             (draw >= 0) ? "+" : "", draw,
 583             (loss >= 0) ? "+" : "", loss);
 584     pprintf(p, "Your new RD will be %5.1f\n", newsterr);
 585   }
 586 }
 587
 588 static void check_lists_match(int p,int p1)
 589 {
 590   struct player *pp = &player_globals.parray[p];
 591   if (in_list(p, L_COMPUTER, pp->name)) {
 592     pprintf(p1, "--** %s is a ", pp->name);
 593     pprintf_highlight(p1, "computer");
 594     pprintf(p1, " **--\n");
 595   }
 596   if (in_list(p, L_COMPUTER, player_globals.parray[p1].name)) {
 597     pprintf(p, "--** %s is a ", player_globals.parray[p1].name);
 598     pprintf_highlight(p, "computer");
 599     pprintf(p, " **--\n");
 600   }
 601   if (in_list(p, L_ABUSER, pp->name)) {
 602     pprintf(p1, "--** %s is in the ", pp->name);
 603     pprintf_highlight(p1, "abuser");
 604     pprintf(p1, " list **--\n");
 605   }
 606   if (in_list(p, L_ABUSER, player_globals.parray[p1].name)) {
 607     pprintf(p, "--** %s is in the ", player_globals.parray[p1].name);
 608     pprintf_highlight(p, "abuser");
 609     pprintf(p, " list **--\n");
 610   }
 611 }
 612
 613 int com_match(int p, param_list param)
 614 {
 615   struct player *pp = &player_globals.parray[p];
 616   int adjourned;                /* adjourned game? */
 617   int g;                        /* more adjourned game junk */
 618   int p1;
 619   int bh = 0, partner = 0, pp1 = 0;
 620   struct pending* pendfrom;
 621   struct pending* pendto;
 622   struct pending* pend;
 623   int wt = -1;                  /* white start time */
 624   int winc = -1;                /* white increment */
 625   int bt = -1;                  /* black start time */
 626   int binc = -1;                /* black increment */
 627   int rated = -1;               /* 1 = rated, 0 = unrated */
 628   int white = -1;               /* 1 = want white, 0 = want black */
 629   char category[100], board[100];
 630   textlist *clauses = NULL;
 631   int type = 0;
 632
 633   category[0] ='\0';
 634   board[0] ='\0';
 635
 636   if ((pp->game >= 0) && ((game_globals.garray[pp->game].status == GAME_EXAMINE)
 637 || (game_globals.garray[pp->game].status == GAME_SETUP))) {
 638
 639     pprintf(p, "You can't challenge while you are examining a game.\n");
 640     return COM_OK;
 641   }
 642
 643   if (pp->game >= 0) {
 644     pprintf(p, "You can't challenge while you are playing a game.\n");
 645     return COM_OK;
 646   }
 647
 648   stolower(param[0].val.word);
 649   p1 = player_find_part_login(param[0].val.word);
 650   if (p1 < 0) {
 651     pprintf(p, "No user named \"%s\" is logged in.\n", param[0].val.word);
 652     return COM_OK;
 653   }
 654
 655   if (p1 == p) {                /* Allowing to match yourself to enter
 656                                    analysis mode */
 657     ExamineScratch (p, param, 0);
 658     return COM_OK;
 659   }
 660
 661   if (!CheckPFlag(p1, PFLAG_OPEN)) {
 662     pprintf(p, "Player \"%s\" is not open to match requests.\n", player_globals.parray[p1].name);
 663     return COM_OK;
 664   }
 665
 666   if (player_globals.parray[p1].game >= 0) {
 667     pprintf(p, "Player \"%s\" is involved in another game.\n", player_globals.parray[p1].name);    return COM_OK;
 668   }
 669
 670   if (CheckPFlag(p, PFLAG_TOURNEY) && !CheckPFlag(p1, PFLAG_TOURNEY)) {
 671     pprintf(p, "You may only match players with their tournament variable set.\n");
 672     return COM_OK;
 673   }
 674
 675   if (!CheckPFlag(p, PFLAG_TOURNEY) && CheckPFlag(p1, PFLAG_TOURNEY)) {
 676     pprintf(p, "%s is in a tournament, and cannot accept other challenges.\n", player_globals.parray[p1].name);
 677     return COM_OK;
 678   }
 679
 680   if (!CheckPFlag(p, PFLAG_OPEN)) {
 681     PFlagON(p, PFLAG_OPEN);
 682     pprintf(p, "Setting you open for matches.\n");
 683   }
 684
 685
 686 /* look for an adjourned game between p and p1 */
 687   g = game_new();
 688   adjourned = (game_read(g, p, p1) >= 0) || (game_read(g, p1, p) >= 0);
 689   if (adjourned) {
 690     type = game_globals.garray[g].type;
 691     wt = game_globals.garray[g].wInitTime / 600;
 692     bt = game_globals.garray[g].bInitTime / 600;
 693     winc = game_globals.garray[g].wIncrement / 10;
 694     binc = game_globals.garray[g].bIncrement / 10;
 695     rated = game_globals.garray[g].rated;
 696   }
 697   game_remove(g);
 698
 699   pendto = find_pend(p, p1, PEND_MATCH);
 700
 701   pendfrom = find_pend(p1, p, PEND_MATCH);
 702
 703   if (!adjourned) {
 704     if (in_list(p1, L_NOPLAY, pp->login)) {
 705       pprintf(p, "You are on %s's noplay list.\n", player_globals.parray[p1].name);
 706       return COM_OK;
 707     }
 708     if (player_censored(p1, p)) {
 709       pprintf(p, "Player \"%s\" is censoring you.\n", player_globals.parray[p1].name);
 710       return COM_OK;
 711     }
 712     if (player_censored(p, p1)) {
 713       pprintf(p, "You are censoring \"%s\".\n", player_globals.parray[p1].name);
 714       return COM_OK;
 715     }
 716
 717     if (param[1].type != TYPE_NULL) {
 718       if (!parse_match_string(p, &wt,&bt,&winc,&binc,&white,&rated,category,
 719                                                   board,param[1].val.string))
 720       return COM_OK; /* couldn't parse */
 721     }
 722
 723     if (rated == -1)
 724       rated = BoolCheckPFlag(p, PFLAG_RATED);
 725     if (!CheckPFlag(p, PFLAG_REG) || !CheckPFlag(p1, PFLAG_REG))
 726       rated = 0;
 727
 728     if (winc == -1)
 729       winc = (wt == -1) ? pp->d_inc : 0;  /* match 5 == match 5 0 */
 730
 731     if (wt == -1)
 732       wt = pp->d_time;
 733
 734     if (bt == -1)
 735       bt = wt;
 736
 737     if (binc == -1)
 738       binc = winc;
 739
 740     if (category[0]) {
 741       if (!board[0] && strcmp(category,"bughouse")) {
 742         pprintf(p, "You must specify a board and a category.\n");
 743         return COM_OK;
 744
 745       } else if (board[0]) { /* not bughouse */
 746         char fname[MAX_FILENAME_SIZE];
 747
 748         sprintf(fname, "%s/%s/%s", BOARD_DIR, category, board);
 749         if (!file_exists(fname)) {
 750           pprintf(p, "No such category/board: %s/%s\n", category, board);
 751           return COM_OK;
 752         }
 753       }
 754     }
 755     type = game_isblitz(wt, winc, bt, binc, category, board);
 756
 757     if (!strcmp(category, "bughouse")) {
 758       type = TYPE_BUGHOUSE;
 759       if (rated && pp->partner >= 0 && player_globals.parray[p1].partner >= 0) {
 760         if (!CheckPFlag(pp->partner, PFLAG_REG)
 761               || !CheckPFlag(player_globals.parray[p1].partner, PFLAG_REG))
 762           rated = 0;
 763       }
 764     }
 765     if (rated && (type == TYPE_NONSTANDARD)) {
 766       pprintf(p, "Game is non-standard - reverting to unrated\n");
 767       rated = 0;
 768     }
 769     if (rated && (type == TYPE_UNTIMED)) {
 770       pprintf(p, "Game is untimed - reverting to unrated\n");
 771       rated = 0;
 772     }
 773     if ((pendfrom == NULL) && !CheckPFlag(p1, PFLAG_ROPEN)
 774         && (rated != BoolCheckPFlag(p1, PFLAG_RATED))) {
 775       pprintf(p, "%s only wants to play %s games.\n", player_globals.parray[p1].name,
 776               rstr[!rated]);
 777       pprintf_highlight(p1, "Ignoring");
 778       pprintf(p1, " %srated match request from %s.\n",
 779               (rated ? "" : "un"), pp->name);
 780       return COM_OK;
 781     }
 782
 783     /* Now check formula. */
 784     if (!adjourned
 785         && !GameMatchesFormula(p,p1, wt,winc,bt,binc, rated, type, &clauses)) {
 786       pprintf(p, "Match request does not fit formula for %s:\n",
 787               player_globals.parray[p1].name);
 788       pprintf(p, "%s's formula: %s\n", player_globals.parray[p1].name, player_globals.parray[p1].formula);
 789       ShowClauses (p, p1, clauses);
 790       ClearTextList(clauses);
 791       pprintf_highlight(p1, "Ignoring");
 792       pprintf_prompt(p1, " (formula): %s (%d) %s (%d) %s.\n",
 793                      pp->name,
 794                      GetRating(&player_globals.parray[p], type),
 795                      player_globals.parray[p1].name,
 796                      GetRating(&player_globals.parray[p1], type),
 797             game_str(rated, wt * 60, winc, bt * 60, binc, category, board));
 798       return COM_OK;
 799     }
 800
 801     if (type == TYPE_BUGHOUSE) {
 802       bh = 1;
 803       partner = pp->partner;
 804       pp1 = player_globals.parray[p1].partner;
 805
 806       if (pp < 0) {
 807         pprintf(p, "You have no partner for bughouse.\n");
 808         return COM_OK;
 809       }
 810       if (pp1 < 0) {
 811         pprintf(p, "Your opponent has no partner for bughouse.\n");
 812         return COM_OK;
 813       }
 814       if (partner == pp1) { /* should be an impossible case - DAV */
 815         pprintf(p, "You and your opponent both chose the same partner!\n");
 816         return COM_OK;
 817       }
 818       if (partner == p1 || pp1 == p) {
 819         pprintf(p, "You and your opponent can't choose each other as partners!\n");
 820         return COM_OK;
 821       }
 822       if (player_globals.parray[partner].partner != p) { /* another impossible case - DAV */
 823         pprintf(p, "Your partner hasn't chosen you as his partner!\n");
 824         return COM_OK;
 825       }
 826       if (player_globals.parray[pp1].partner != p1) { /* another impossible case - DAV */
 827         pprintf(p, "Your opponent's partner hasn't chosen your opponent as his partner!\n");
 828         return COM_OK;
 829       }
 830       if (!CheckPFlag(partner, PFLAG_OPEN) || player_globals.parray[partner].game >= 0) {
 831         pprintf(p, "Your partner isn't open to play right now.\n");
 832         return COM_OK;
 833       }
 834       if (!CheckPFlag(pp1, PFLAG_OPEN) || player_globals.parray[pp1].game >= 0) {
 835         pprintf(p, "Your opponent's partner isn't open to play right now.\n");
 836         return COM_OK;
 837       }
 838
 839       /* Bypass NOPLAY lists, censored lists, ratedness, privacy, and formula for now */
 840       /*  Active challenger/ee will determine these. */
 841     }
 842     /* Ok match offer will be made */
 843
 844   }                             /* adjourned games shouldn't have to worry
 845                                    about that junk? */
 846                                 /* keep incase of adjourned bughouse in future*/
 847
 848   if (pendto != NULL) {
 849     pprintf(p, "Updating offer already made to \"%s\".\n", player_globals.parray[p1].name);
 850   }
 851
 852   if (pendfrom != NULL) {
 853     if (pendto != NULL) {
 854       pprintf(p, "Pending list error!.\n");
 855       d_printf( "CHESSD: This shouldn't happen. You can't have a match pending from and to the same person.\n");
 856       return COM_OK;
 857     }
 858
 859     if (adjourned || ((wt == pendfrom->btime) &&
 860                       (winc == pendfrom->binc) &&
 861                       (bt == pendfrom->wtime) &&
 862                       (binc == pendfrom->winc) &&
 863                       (rated == pendfrom->rated) &&
 864                       ((white == -1) || (white + pendfrom->seek_color == 1)) &&
 865                (!strcmp(category, pendfrom->category)) &&
 866                  (!strcmp(board, pendfrom->board_type)))) {
 867       /* Identical match, should accept! */
 868       accept_match(pendfrom,p, p1);
 869       return COM_OK;
 870
 871     } else {
 872       delete_pending(pendfrom);
 873     }
 874   }
 875
 876   if (pendto == NULL)
 877     pend = add_pending(p,p1,PEND_MATCH);
 878   else
 879     pend = pendto;
 880
 881   pend->wtime = wt;
 882   pend->winc = winc;
 883   pend->btime = bt;
 884   pend->binc = binc;
 885   pend->rated = rated;
 886   pend->seek_color = white;
 887   pend->game_type = type;
 888   pend->category = strdup(category);
 889   pend->board_type = strdup (board);
 890
 891   if (pendfrom != NULL) {
 892     pprintf(p, "Declining offer from %s and offering new match parameters.\n", player_globals.parray[p1].name);
 893     pprintf(p1, "\n%s declines your match offer a match with these parameters:", pp->name);
 894   }
 895
 896   if (pendto != NULL) {
 897     pprintf(p, "Updating match request to: ");
 898     pprintf(p1, "\n%s updates the match request.\n", pp->name);
 899   } else {
 900     pprintf(p, "Issuing: ");
 901     pprintf(p1, "\n");
 902   }
 903
 904   pprintf(p, "%s (%s) %s", pp->name,
 905           ratstrii(GetRating(&player_globals.parray[p], type), p),
 906           colorstr[white + 1]);
 907   pprintf_highlight(p, "%s", player_globals.parray[p1].name);
 908   pprintf(p, " (%s) %s%s.\n",
 909           ratstrii(GetRating(&player_globals.parray[p1], type), p1),
 910           game_str(rated, wt * 60, winc, bt * 60, binc, category, board),
 911           adjustr[adjourned]);
 912   pprintf(p1, "Challenge: ");
 913   pprintf_highlight(p1, "%s", pp->name);
 914   pprintf(p1, " (%s) %s",
 915           ratstrii(GetRating(&player_globals.parray[p], type), p),
 916           colorstr[white + 1]);
 917   pprintf(p1, "%s (%s) %s%s.\n", player_globals.parray[p1].name,
 918           ratstrii(GetRating(&player_globals.parray[p1], type), p1),
 919           game_str(rated, wt * 60, winc, bt * 60, binc, category, board),
 920           adjustr[adjourned]);
 921   Bell (p1);
 922
 923   if (bh) {
 924
 925     pprintf(partner, "\nYour bughouse partner issuing %s (%s) %s",
 926             pp->name, ratstrii(GetRating(&player_globals.parray[p], type), p),
 927             colorstr[white + 1]);
 928     pprintf_highlight(partner, "%s", player_globals.parray[p1].name);
 929     pprintf(partner, " (%s) %s.\n",
 930             ratstrii(GetRating(&player_globals.parray[p1], type), p1),
 931             game_str(rated, wt * 60, winc, bt * 60, binc, category, board));
 932     pprintf(partner, "Your game would be ");
 933     pprintf_highlight(partner, "%s", player_globals.parray[pp1].name);
 934     pprintf_prompt(partner, " (%s) %s%s (%s) %s.\n",
 935           ratstrii(GetRating(&player_globals.parray[pp1], type), pp1),
 936           colorstr[white + 1], player_globals.parray[partner].name,
 937           ratstrii(GetRating(&player_globals.parray[partner], type), partner),
 938           game_str(rated, wt * 60, winc, bt * 60, binc, category, board));
 939     Bell (partner);
 940
 941     pprintf(pp1, "\nYour bughouse partner was challenged ");
 942     pprintf_highlight(pp1, "%s", pp->name);
 943     pprintf(pp1, " (%s) %s", ratstrii(GetRating(&player_globals.parray[p], type), p),
 944                              colorstr[white + 1]);
 945     pprintf(pp1, "%s (%s) %s.\n", player_globals.parray[p1].name,
 946             ratstrii(GetRating(&player_globals.parray[p1], type), p1),
 947             game_str(rated, wt * 60, winc, bt * 60, binc, category, board));
 948     pprintf(pp1, "Your game would be %s (%s) %s", player_globals.parray[pp1].name,
 949           ratstrii(GetRating(&player_globals.parray[pp1], type), pp1),
 950           colorstr[white + 1]);
 951     pprintf_highlight(pp1, "%s", player_globals.parray[partner].name);
 952     pprintf_prompt(pp1, " (%s) %s.\n",
 953           ratstrii(GetRating(&player_globals.parray[partner], type), partner),
 954           game_str(rated, wt * 60, winc, bt * 60, binc, category, board));
 955     Bell(pp1);
 956   }
 957
 958   check_lists_match (p,p1);
 959
 960   print_match_rating_info (p,p1,type,rated);
 961
 962   pprintf_prompt(p1, "You can \"accept\" or \"decline\", or propose different parameters.\n");
 963
 964   return COM_OK;
 965 }
 966
 967
 968 /*
 969   rmatch is used by mamer to start matches in tournaments
 970 */
 971 int com_rmatch(int p, param_list param)
 972 {
 973         struct player *pp = &player_globals.parray[p];
 974         int p1, p2;
 975
 976         if (!in_list(p, L_TD, pp->name)) {
 977                 pprintf(p, "Only TD programs are allowed to use this command.\n");
 978                 return COM_OK;
 979         }
 980
 981         if ((p1 = player_find_bylogin(param[0].val.word)) < 0 ||
 982             !CheckPFlag(p1, PFLAG_REG)) {
 983                 /* can't rmatch this user ... */
 984                 return COM_OK;
 985         }
 986
 987         if ((p2 = player_find_bylogin(param[1].val.word)) < 0 ||
 988             !CheckPFlag(p2, PFLAG_REG)) {
 989                 /* can't rmatch this user ... */
 990                 return COM_OK;
 991         }
 992
 993         return pcommand(p1, "match %s %s", param[1].val.word, param[2].val.string);
 994 }