lasker-2.2.3/src/gameproc.c

   1 /*
   2    Copyright (c) 1993 Richard V. Nash.
   3    Copyright (c) 2000 Dan Papasian
   4    Copyright (C) Andrew Tridgell 2002
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19 */
  20
  21 #include "includes.h"
  22
  23 /*Let users know that someone is available (format the message)*/
  24 static void getavailmess(int p, char* message)
  25 {
  26         struct player *pp = &player_globals.parray[p];
  27         char titles[100];
  28
  29         titles [0]='\0';
  30         AddPlayerLists(p,titles);
  31         sprintf (message,"%s%s Blitz (%s), Std (%s), Wild (%s), Light(%s), Bug(%s)\n"
  32                  "  is now available for matches.",
  33                  pp->name, titles,
  34         ratstrii(pp->b_stats.rating, p),
  35         ratstrii(pp->s_stats.rating, p),
  36         ratstrii(pp->w_stats.rating, p),
  37         ratstrii(pp->l_stats.rating, p),
  38         ratstrii(pp->bug_stats.rating, p));
  39 }
  40
  41 void getnotavailmess(int p, char* message)
  42 {
  43         struct player *pp = &player_globals.parray[p];
  44         char titles[100];
  45
  46         titles[0]='\0';
  47         AddPlayerLists(p,titles);
  48         sprintf (message,"%s%s is no longer available for matches.",
  49                  pp->name, titles);
  50 }
  51
  52 void announce_avail(int p)
  53 {
  54         struct player *pp = &player_globals.parray[p];
  55         char avail[200];
  56         int p1;
  57         if ((pp->game < 0) && (CheckPFlag(p, PFLAG_OPEN))) {
  58                 getavailmess (p,avail);
  59
  60                 for (p1 = 0; p1 < player_globals.p_num; p1++) {
  61                         if (p == p1)
  62                                 continue;
  63                         if (player_globals.parray[p1].status != PLAYER_PROMPT)
  64                                 continue;
  65                         if (CheckPFlag(p1, PFLAG_AVAIL) && CheckPFlag(p1, PFLAG_OPEN)
  66                             && (player_globals.parray[p1].game < 0))
  67                                 if (((pp->b_stats.rating <= player_globals.parray[p1].availmax) && (pp->b_stats.rating >= player_globals.parray[p1].availmin)) || (!player_globals.parray[p1].availmax))
  68                                         pprintf_prompt (p1,"\n%s\n",avail);
  69                 }
  70         }
  71 }
  72
  73 void announce_notavail(int p)
  74 {
  75         struct player *pp = &player_globals.parray[p];
  76         char avail[200];
  77         int p1;
  78
  79         getnotavailmess (p,avail);
  80
  81         for (p1 = 0; p1 < player_globals.p_num; p1++) {
  82                 if (p == p1)
  83                         continue;
  84                 if (player_globals.parray[p1].status != PLAYER_PROMPT)
  85                         continue;
  86                 if (CheckPFlag(p1, PFLAG_AVAIL) && CheckPFlag(p1, PFLAG_OPEN)
  87                     && (player_globals.parray[p1].game < 0))
  88                         if (((pp->b_stats.rating <= player_globals.parray[p1].availmax) && (pp->b_stats.rating >= player_globals.parray[p1].availmin)) || (!player_globals.parray[p1].availmax))
  89                                 pprintf_prompt (p1,"\n%s\n",avail);
  90         }
  91 }
  92
  93 void game_ended(int g, int winner, int why)
  94 {
  95   struct game *gg = &game_globals.garray[g];
  96   char outstr[200];
  97   char avail_black[200]; /* for announcing white/black avail */
  98   char avail_white[200];
  99   char avail_bugwhite[200];
 100   char avail_bugblack[200];
 101   char tmp[200];
 102   int p;
 103   int gl = gg->link;
 104   int rate_change = 0;
 105   int isDraw = 0;
 106   int whiteResult;
 107   char winSymbol[10];
 108   char EndSymbol[10];
 109   char *NameOfWinner, *NameOfLoser;
 110   int beingplayed = 0;          /* i.e. it wasn't loaded for adjudication */
 111   int print_avail = 0;
 112
 113   avail_white[0] = '\0';
 114   avail_black[0] = '\0';
 115   avail_bugwhite[0] = '\0';
 116   avail_bugblack[0] = '\0';
 117
 118   beingplayed = (player_globals.parray[gg->black].game == g);
 119
 120   sprintf(outstr, "\n{Game %d (%s vs. %s) ", g + 1,
 121           player_globals.parray[gg->white].name,
 122           player_globals.parray[gg->black].name);
 123   gg->result = why;
 124   gg->winner = winner;
 125   if (winner == WHITE) {
 126     whiteResult = RESULT_WIN;
 127     strcpy(winSymbol, "1-0");
 128     NameOfWinner = player_globals.parray[gg->white].name;
 129     NameOfLoser = player_globals.parray[gg->black].name;
 130   } else {
 131     whiteResult = RESULT_LOSS;
 132     strcpy(winSymbol, "0-1");
 133     NameOfWinner = player_globals.parray[gg->black].name;
 134     NameOfLoser = player_globals.parray[gg->white].name;
 135   }
 136   switch (why) {
 137   case END_CHECKMATE:
 138     sprintf(tmp, "%s checkmated} %s", NameOfLoser, winSymbol);
 139     strcpy(EndSymbol, "Mat");
 140     rate_change = 1;
 141     break;
 142   case END_BARE:
 143     sprintf(tmp, "%s bared} %s", NameOfLoser, winSymbol);
 144     strcpy(EndSymbol, "Bar");
 145     rate_change = 1;
 146     break;
 147   case END_RESIGN:
 148     sprintf(tmp, "%s resigns} %s", NameOfLoser, winSymbol);
 149     strcpy(EndSymbol, "Res");
 150     rate_change = 1;
 151     break;
 152   case END_FLAG:
 153     sprintf(tmp, "%s forfeits on time} %s", NameOfLoser, winSymbol);
 154     strcpy(EndSymbol, "Fla");
 155     rate_change = 1;
 156     break;
 157   case END_STALEMATE:
 158     sprintf(tmp, "Game drawn by stalemate} 1/2-1/2");
 159     isDraw = 1;
 160     strcpy(EndSymbol, "Sta");
 161     rate_change = 1;
 162     whiteResult = RESULT_DRAW;
 163     break;
 164   case END_AGREEDDRAW:
 165     sprintf(tmp, "Game drawn by mutual agreement} 1/2-1/2");
 166     isDraw = 1;
 167     strcpy(EndSymbol, "Agr");
 168     rate_change = 1;
 169     whiteResult = RESULT_DRAW;
 170     break;
 171   case END_BOTHFLAG:
 172     sprintf(tmp, "Game drawn because both players ran out of time} 1/2-1/2");
 173     isDraw = 1;
 174     strcpy(EndSymbol, "Fla");
 175     rate_change = 1;
 176     whiteResult = RESULT_DRAW;
 177     break;
 178   case END_REPETITION:
 179     sprintf(tmp, "Game drawn by repetition} 1/2-1/2");
 180     isDraw = 1;
 181     strcpy(EndSymbol, "Rep");
 182     rate_change = 1;
 183     whiteResult = RESULT_DRAW;
 184     break;
 185   case END_50MOVERULE:
 186     sprintf(tmp, "Game drawn by the 50 move rule} 1/2-1/2");
 187     isDraw = 1;
 188     strcpy(EndSymbol, "50");
 189     rate_change = 1;
 190     whiteResult = RESULT_DRAW;
 191     break;
 192   case END_ADJOURN:
 193     if (gl >= 0) {
 194       sprintf(tmp, "Bughouse game aborted.} *");
 195       whiteResult = RESULT_ABORT;
 196     } else {
 197     sprintf(tmp, "Game adjourned by mutual agreement} *");
 198     game_save(g);
 199     }
 200     break;
 201   case END_LOSTCONNECTION:
 202     sprintf(tmp, "%s lost connection; game ", NameOfWinner);
 203     if (CheckPFlag(gg->white, PFLAG_REG)
 204         && CheckPFlag(gg->black, PFLAG_REG)
 205         && gl < 0) {
 206       sprintf(tmp, "adjourned} *");
 207       game_save(g);
 208     } else
 209       sprintf(tmp, "aborted} *");
 210     whiteResult = RESULT_ABORT;
 211     break;
 212   case END_ABORT:
 213     sprintf(tmp, "Game aborted by mutual agreement} *");
 214     whiteResult = RESULT_ABORT;
 215     break;
 216   case END_COURTESY:
 217     sprintf(tmp, "Game courtesyaborted by %s} *", NameOfWinner);
 218     whiteResult = RESULT_ABORT;
 219     break;
 220   case END_COURTESYADJOURN:
 221     if (gl >= 0) {
 222       sprintf(tmp, "Bughouse game courtesyaborted by %s.} *", NameOfWinner);
 223       whiteResult = RESULT_ABORT;
 224     } else {
 225     sprintf(tmp, "Game courtesyadjourned by %s} *", NameOfWinner);
 226     game_save(g);
 227     }
 228     break;
 229   case END_NOMATERIAL:
 230     /* Draw by insufficient material (e.g., lone K vs. lone K) */
 231     sprintf(tmp, "Neither player has mating material} 1/2-1/2");
 232     isDraw = 1;
 233     strcpy(EndSymbol, "NM ");
 234     rate_change = 1;
 235     whiteResult = RESULT_DRAW;
 236     break;
 237   case END_FLAGNOMATERIAL:
 238     sprintf(tmp, "%s ran out of time and %s has no material to mate} 1/2-1/2",
 239             NameOfLoser, NameOfWinner);
 240     isDraw = 1;
 241     strcpy(EndSymbol, "TM ");
 242     rate_change = 1;
 243     whiteResult = RESULT_DRAW;
 244     break;
 245   case END_ADJWIN:
 246     sprintf(tmp, "%s wins by adjudication} %s", NameOfWinner, winSymbol);
 247     strcpy(EndSymbol, "Adj");
 248     rate_change = 1;
 249     break;
 250   case END_ADJDRAW:
 251     sprintf(tmp, "Game drawn by adjudication} 1/2-1/2");
 252     isDraw = 1;
 253     strcpy(EndSymbol, "Adj");
 254     rate_change = 1;
 255     whiteResult = RESULT_DRAW;
 256     break;
 257   case END_ADJABORT:
 258     sprintf(tmp, "Game aborted by adjudication} *");
 259     whiteResult = RESULT_ABORT;
 260     break;
 261   default:
 262     sprintf(tmp, "Hmm, the game ended and I don't know why} *");
 263     break;
 264   }
 265   strcat(outstr, tmp);
 266
 267   if (CheckPFlag(gg->white, PFLAG_TOURNEY) &&
 268       CheckPFlag(gg->black, PFLAG_TOURNEY)) {
 269           /* mamer wants more info */
 270           sprintf(tmp," [%d %d %d %d %d]",
 271                   gg->wInitTime/(60*10), gg->wIncrement/10, gg->rated, gg->private, (int)gg->type);
 272           strcat(outstr, tmp);
 273   }
 274
 275   strcat(outstr, "\n");
 276
 277   if (gg->rated && rate_change && gg->type != TYPE_BUGHOUSE)
 278     /* Adjust ratings; bughouse gets done later. */
 279     rating_update(g, -1);
 280
 281   if (beingplayed) {
 282     int printed = 0;
 283     int avail_printed = 0;
 284
 285     pprintf_noformat(gg->white, outstr);
 286     pprintf_noformat(gg->black, outstr);
 287     Bell (gg->white);
 288     Bell (gg->black);
 289
 290     gg->link = -1;              /*IanO: avoids recursion */
 291     if (gl >= 0 && game_globals.garray[gl].link >= 0) {
 292       pprintf_noformat(game_globals.garray[gl].white, outstr);
 293       pprintf_noformat(game_globals.garray[gl].black, outstr);
 294       if (CheckPFlag(game_globals.garray[gl].white, PFLAG_OPEN)) {
 295         getavailmess (game_globals.garray[gl].white, avail_bugwhite);
 296         print_avail = 1;
 297       }
 298       if (CheckPFlag(game_globals.garray[gl].black, PFLAG_OPEN)) {
 299         getavailmess (game_globals.garray[gl].black, avail_bugblack);
 300         print_avail = 1;
 301       }
 302       if ((gg->rated) && (rate_change)) {
 303         /* Adjust ratings */
 304         rating_update(g, gl);
 305       }
 306       game_ended(gl, CToggle(winner), why);
 307     }
 308
 309     if ((player_num_active_boards(gg->white) <= 1) /* not a simul or */
 310          && CheckPFlag(gg->white, PFLAG_OPEN)) {   /* simul is over? */
 311       getavailmess (gg->white,avail_white);
 312       print_avail = 1;
 313     } else {    /* Part of an ongoing simul!  Let's shrink the array. */
 314
 315     }
 316
 317     if (CheckPFlag(gg->black, PFLAG_OPEN)) {
 318       getavailmess (gg->black,avail_black);
 319       print_avail = 1;
 320     }
 321
 322     for (p = 0; p < player_globals.p_num; p++) {
 323       struct player *pp = &player_globals.parray[p];
 324       if ((p == gg->white) || (p == gg->black))
 325         continue;
 326       if (pp->status != PLAYER_PROMPT)
 327         continue;
 328
 329       if (CheckPFlag(p, PFLAG_GIN) || player_is_observe(p, g)) {
 330         pprintf_noformat(p, outstr);
 331         printed = 1;
 332       }
 333
 334       if (CheckPFlag(p, PFLAG_AVAIL) && (CheckPFlag(p, PFLAG_OPEN)) && (pp->game < 0) && (print_avail)) {
 335         if (((player_globals.parray[gg->white].b_stats.rating <= pp->availmax) && (player_globals.parray[gg->white].b_stats.rating >= pp->availmin)) || (!pp->availmax)) {
 336           pprintf (p,"\n%s",avail_white);
 337           avail_printed = 1;
 338         }
 339         if (((player_globals.parray[gg->black].b_stats.rating <= pp->availmax) && (player_globals.parray[gg->black].b_stats.rating >= pp->availmin)) || (!pp->availmax)) {
 340           pprintf (p,"\n%s",avail_black);
 341           avail_printed = 1;
 342         }
 343         if (gl == -1) /* bughouse ? */ {
 344           if (((player_globals.parray[game_globals.garray[gl].white].b_stats.rating <= pp->availmax) && (player_globals.parray[game_globals.garray[gl].white].b_stats.rating >= pp->availmin)) || (!pp->availmax)) {
 345             pprintf (p,"\n%s",avail_bugwhite);
 346             avail_printed = 1;
 347           }
 348           if (((player_globals.parray[game_globals.garray[gl].black].b_stats.rating <= pp->availmax) && (player_globals.parray[game_globals.garray[gl].black].b_stats.rating >= pp->availmin)) || (!pp->availmax)) {
 349             pprintf (p,"\n%s",avail_bugblack);
 350             avail_printed = 1;
 351           }
 352         }
 353         if (avail_printed) {
 354           avail_printed = 0;
 355           printed = 1;
 356           pprintf (p,"\n");
 357         }
 358       }
 359
 360       if (printed) {
 361         send_prompt(p);
 362         printed = 0;
 363       }
 364     }
 365
 366     if (!(gg->rated && rate_change)) {
 367       pprintf(gg->white, "No ratings adjustment done.\n");
 368       pprintf(gg->black, "No ratings adjustment done.\n");
 369     }
 370   }
 371
 372   if (rate_change && gl < 0)
 373     game_write_complete(g, isDraw, EndSymbol);
 374   /* Mail off the moves */
 375   if (CheckPFlag(gg->white, PFLAG_AUTOMAIL)) {
 376     pcommand(gg->white, "mailmoves");
 377   }
 378   if (CheckPFlag(gg->black, PFLAG_AUTOMAIL)) {
 379     pcommand(gg->black, "mailmoves");
 380   }
 381   if (!((player_globals.parray[gg->white].simul_info != NULL) &&
 382          (player_globals.parray[gg->white].simul_info->numBoards))) {
 383     player_globals.parray[gg->white].num_white++;
 384     PFlagOFF(gg->white, PFLAG_LASTBLACK);
 385     player_globals.parray[gg->black].num_black++;
 386     PFlagON(gg->black, PFLAG_LASTBLACK);
 387   }
 388   player_globals.parray[gg->white].last_opponent =
 389           strdup(gg->black_name);
 390   player_globals.parray[gg->black].last_opponent =
 391           strdup(gg->white_name);
 392   if (beingplayed) {
 393     player_globals.parray[gg->white].game = -1;
 394     player_globals.parray[gg->black].game = -1;
 395     player_globals.parray[gg->white].opponent = -1;
 396     player_globals.parray[gg->black].opponent = -1;
 397     if (gg->white != command_globals.commanding_player)
 398       send_prompt(gg->white);
 399     if (gg->black != command_globals.commanding_player)
 400       send_prompt(gg->black);
 401     if ((player_globals.parray[gg->white].simul_info != NULL) &&
 402          (player_globals.parray[gg->white].simul_info->numBoards))
 403       player_simul_over(gg->white, g, whiteResult);
 404   }
 405   game_finish(g);
 406 }
 407
 408 static int was_promoted(struct game *g, int f, int r)
 409 {
 410 #define BUGHOUSE_PAWN_REVERT 1
 411 #ifdef BUGHOUSE_PAWN_REVERT
 412   int i;
 413
 414   for (i = g->numHalfMoves-2; i > 0; i -= 2) {
 415     if (g->moveList[i].toFile == f && g->moveList[i].toRank == r) {
 416       if (g->moveList[i].piecePromotionTo) {
 417         switch(g->moveList[i].moveString[0]) { // [HGM] return original piece type rather than just TRUE
 418           case 'P': return PAWN;
 419           case 'N': return KNIGHT;
 420           case 'B': return BISHOP;
 421           case 'R': return ROOK;
 422           case 'L': return LANCE;
 423           case 'S': return SILVER;
 424           default:  return GOLD;
 425         }
 426       }
 427       if (g->moveList[i].fromFile == ALG_DROP)
 428         return 0;
 429       f = g->moveList[i].fromFile;
 430       r = g->moveList[i].fromRank;
 431     }
 432   }
 433 #endif
 434   return 0;
 435 }
 436
 437 int pIsPlaying (int p)
 438 {
 439         struct player *pp = &player_globals.parray[p];
 440         int g = pp->game;
 441         int p1 = pp->opponent;
 442
 443         if (g < 0 || game_globals.garray[g].status != GAME_ACTIVE) {
 444                 pprintf (p, "You are not playing a game.\n");
 445                 return 0;
 446         }
 447
 448         if (game_globals.garray[g].white != p && game_globals.garray[g].black != p) {
 449                 /* oh oh; big bad game bug. */
 450                 d_printf("BUG:  Player %s playing game %d according to player_globals.parray,"
 451                          "\n      but not according to game_globals.garray.\n", pp->name, g+1);
 452                 pprintf (p, "Disconnecting you from game number %d.\n", g+1);
 453                 pp->game = -1;
 454                 if (p1 >= 0 && player_globals.parray[p1].game == g
 455                     && game_globals.garray[g].white != p1 && game_globals.garray[g].black != p1) {
 456                         pprintf (p1, "Disconnecting you from game number %d.\n", g+1);
 457                         player_globals.parray[p1].game = -1;
 458                 }
 459                 return 0;
 460         }
 461         return 1;
 462 }
 463
 464 /* add clock increments */
 465 static void game_add_increment(struct player *pp, struct game *gg)
 466 {
 467         /* no update on first move */
 468         if (gg->game_state.moveNum == 1) return;
 469
 470         if (net_globals.con[pp->socket]->timeseal) {    /* does he use timeseal? */
 471                 if (pp->side == WHITE) {
 472                         gg->wRealTime += gg->wIncrement * 100;
 473                         gg->wTime = gg->wRealTime / 100;        /* remember to conv to
 474                                                                                                    tenth secs */
 475                 } else if (pp->side == BLACK) {
 476                         gg->bRealTime += gg->bIncrement * 100;  /* conv to ms */
 477                         gg->bTime = gg->bRealTime / 100;        /* remember to conv to
 478                                                                                                    tenth secs */
 479                 }
 480         } else {
 481                 if (gg->game_state.onMove == BLACK) {
 482                         gg->bTime += gg->bIncrement;
 483                 }
 484                 if (gg->game_state.onMove == WHITE) {
 485                         gg->wTime += gg->wIncrement;
 486                 }
 487         }
 488 }
 489
 490 /* updates clocks for a game with timeseal */
 491 void timeseal_update_clocks(struct player *pp, struct game *gg)
 492 {
 493         /* no update on first move */
 494         if (gg->game_state.moveNum == 1) return;
 495
 496         if (pp->side == WHITE) {
 497                 gg->wLastRealTime = gg->wRealTime;
 498                 gg->wTimeWhenMoved = net_globals.con[pp->socket]->time;
 499                 if (((gg->wTimeWhenMoved - gg->wTimeWhenReceivedMove) < 0) ||
 500                     (gg->wTimeWhenReceivedMove == 0)) {
 501                         /* might seem weird - but could be caused by a person moving BEFORE
 502                            he receives the board pos (this is possible due to lag) but it's
 503                            safe to say he moved in 0 secs :-) */
 504                         gg->wTimeWhenReceivedMove = gg->wTimeWhenMoved;
 505                 } else {
 506                         gg->wRealTime -= gg->wTimeWhenMoved - gg->wTimeWhenReceivedMove;
 507                 }
 508         } else if (pp->side == BLACK) {
 509                 gg->bLastRealTime = gg->bRealTime;
 510                 gg->bTimeWhenMoved = net_globals.con[pp->socket]->time;
 511                 if (((gg->bTimeWhenMoved - gg->bTimeWhenReceivedMove) < 0) ||
 512                     (gg->bTimeWhenReceivedMove == 0)) {
 513                         /* might seem weird - but could be caused by a person moving BEFORE
 514                            he receives the board pos (this is possible due to lag) but it's
 515                            safe to say he moved in 0 secs :-) */
 516                         gg->bTimeWhenReceivedMove = gg->bTimeWhenMoved;
 517                 } else {
 518                         gg->bRealTime -= gg->bTimeWhenMoved - gg->bTimeWhenReceivedMove;
 519                 }
 520         }
 521 }
 522
 523
 524 void process_move(int p, char *command)
 525 {
 526   struct player *pp = &player_globals.parray[p];
 527   struct game *gg;
 528   int g, result, len, i;
 529   struct move_t move;
 530   unsigned now = 0;
 531
 532   if (pp->game < 0) {
 533     pprintf(p, "You are not playing or examining a game.\n");
 534     return;
 535   }
 536   decline_withdraw_offers(p, -1, -PEND_SIMUL,DO_DECLINE);
 537
 538   g = pp->game;
 539   gg = &game_globals.garray[g];
 540
 541   if (gg->status == GAME_SETUP) {
 542     if (!attempt_drop(p,g,command)) {
 543       pprintf(p, "You are still setting up the position.\n");
 544       pprintf(p, "Type: 'setup done' when you are finished editing.\n");
 545     } else
 546     send_board_to(g, p);
 547     return;
 548   }
 549
 550   if (gg->status != GAME_EXAMINE) {
 551     if (!pIsPlaying(p)) return;
 552
 553     if (pp->side != gg->game_state.onMove) {
 554       pprintf(p, "It is not your move.\n");
 555       return;
 556     }
 557     if (gg->clockStopped) {
 558       pprintf(p, "Game clock is paused, use \"unpause\" to resume.\n");
 559       return;
 560     }
 561   }
 562   pp->promote = NOPIECE; // [HGM] this seemed to be uninitialized, which caused spurious promotion in Shogi
 563   if ((len = strlen(command)) > 1) {
 564     if (command[len - 2] == '=') {
 565 printf("promo '%s'\n", command);
 566       switch (tolower(command[strlen(command) - 1])) {
 567       case 'n':
 568         pp->promote = KNIGHT;
 569         break;
 570       case 'b':
 571         pp->promote = BISHOP;
 572         break;
 573       case 'r':
 574         pp->promote = ROOK;
 575         break;
 576       case 'a':
 577         pp->promote = CARDINAL;
 578         break;
 579       case 'c':
 580         pp->promote = MARSHALL;
 581         break;
 582       case 'm':
 583         pp->promote = MAN;
 584         break;
 585       case 'q':
 586         pp->promote = QUEEN;
 587         break;
 588       // courier promotion
 589       case 'f':
 590         pp->promote = FERZ2;
 591         break;
 592       // Superchess promotions
 593       case 'e':
 594         pp->promote = EMPRESS;
 595         break;
 596       case 's':
 597         pp->promote = PRINCESS;
 598         break;
 599       case 'v':
 600         pp->promote = CENTAUR;
 601         break;
 602       case 'w':
 603         pp->promote = WOODY;
 604         break;
 605       case 'o':
 606         pp->promote = SQUIRREL;
 607         break;
 608       case 'g':
 609         pp->promote = MASTODON;
 610         break;
 611       // Shogi promotions
 612       case '^':
 613       case '+':
 614         pp->promote = GOLD;
 615         break;
 616       case '=':
 617         pp->promote = NOPIECE;
 618         break;
 619       default:
 620         pprintf(p, "Don't understand that move.\n");
 621         return;
 622         break;
 623       }
 624     }
 625   }
 626
 627   switch (parse_move(command, &gg->game_state, &move, pp->promote)) {
 628   case MOVE_ILLEGAL:
 629     pprintf(p, "Illegal move.\n");
 630     return;
 631     break;
 632   case MOVE_AMBIGUOUS:
 633     pprintf(p, "Ambiguous move.\n");
 634     return;
 635     break;
 636   default:
 637     break;
 638   }
 639
 640   if (gg->status == GAME_EXAMINE) {
 641     gg->numHalfMoves++;
 642     if (gg->numHalfMoves > gg->examMoveListSize) {
 643       gg->examMoveListSize += 20;       /* Allocate 20 moves at a time */
 644       gg->examMoveList = (struct move_t *) realloc(gg->examMoveList, sizeof(struct move_t) * gg->examMoveListSize);
 645     }
 646     result = execute_move(&gg->game_state, &move, 1);
 647     move.atTime = now;
 648     move.tookTime = 0;
 649     MakeFENpos(g, move.FENpos);
 650     gg->examMoveList[gg->numHalfMoves - 1] = move;
 651     /* roll back time */
 652     if (gg->game_state.onMove == WHITE) {
 653       gg->wTime += (gg->lastDecTime - gg->lastMoveTime);
 654     } else {
 655       gg->bTime += (gg->lastDecTime - gg->lastMoveTime);
 656     }
 657     now = tenth_secs();
 658     if (gg->numHalfMoves == 0)
 659       gg->timeOfStart = now;
 660     gg->lastMoveTime = now;
 661     gg->lastDecTime = now;
 662
 663   } else {                      /* real game */
 664     i = pp->opponent;
 665     if ((player_globals.parray[i].simul_info != NULL) && (player_globals.parray[i].simul_info->numBoards &&
 666          (player_globals.parray[i].simul_info->boards[player_globals.parray[i].simul_info->onBoard] != g))) {
 667       pprintf(p, "It isn't your turn: wait until the simul giver is at your board.\n");
 668       return;
 669     }
 670     if (net_globals.con[pp->socket]->timeseal) {        /* does he use timeseal? */
 671             timeseal_update_clocks(pp, &game_globals.garray[g]);
 672     }
 673     /* we need to reset the opp's time for receiving the board since the
 674        timeseal decoder only alters the time if it's 0 Otherwise the time
 675        would be changed if the player did a refresh which would screw up
 676        the timings */
 677     if (pp->side == WHITE) {
 678       gg->bTimeWhenReceivedMove = 0;
 679     } else {
 680       gg->wTimeWhenReceivedMove = 0;
 681     }
 682
 683     game_update_time(g);
 684     game_add_increment(pp, gg);
 685
 686     /* Do the move */
 687     gg->numHalfMoves++;
 688     if (gg->numHalfMoves > gg->moveListSize) {
 689       gg->moveListSize += 20;   /* Allocate 20 moves at a time */
 690       gg->moveList = (struct move_t *) realloc(gg->moveList, sizeof(struct move_t) * gg->moveListSize);
 691     }
 692     result = execute_move(&gg->game_state, &move, 1);
 693     if (result == MOVE_OK && (gg->link >= 0 || gg->game_state.holdings) && move.pieceCaptured != NOPIECE) {
 694       /* transfer captured piece to partner */
 695       /* check if piece reverts to a pawn */
 696       int victim = move.pieceCaptured, partner = gg->link, demoted;
 697       // [HGM] zh: if not Bughouse, the game_state.holdings field decides what happens
 698       if(gg->link < 0) {
 699         partner = g; // pieces stay with current board
 700         if(gg->game_state.holdings == -1) victim ^= WHITE|BLACK; // flip color
 701       }
 702       if (demoted = was_promoted(&game_globals.garray[g], move.toFile, move.toRank))
 703         update_holding(partner, colorval(victim) | demoted); // [HGM] was_promoted now returns original piece type
 704       else
 705         update_holding(partner, victim);
 706     }
 707     now = tenth_secs();
 708     move.atTime = now;
 709     if (gg->numHalfMoves > 1) {
 710       move.tookTime = move.atTime - gg->lastMoveTime;
 711     } else {
 712       move.tookTime = move.atTime - gg->startTime;
 713     }
 714     gg->lastMoveTime = now;
 715     gg->lastDecTime = now;
 716     move.wTime = gg->wTime;
 717     move.bTime = gg->bTime;
 718
 719     if (net_globals.con[pp->socket]->timeseal) {        /* does he use timeseal? */
 720       if (pp->side == WHITE) {
 721         move.tookTime = (game_globals.garray[pp->game].wTimeWhenMoved -
 722                          game_globals.garray[pp->game].wTimeWhenReceivedMove) / 100;
 723       } else {
 724         move.tookTime = (game_globals.garray[pp->game].bTimeWhenMoved -
 725                          game_globals.garray[pp->game].bTimeWhenReceivedMove) / 100;
 726       }
 727     }
 728
 729     if (gg->numHalfMoves <= 2) {
 730             move.tookTime = 0;
 731     }
 732
 733     MakeFENpos(g, move.FENpos);
 734     gg->moveList[gg->numHalfMoves - 1] = move;
 735   }
 736
 737   send_boards(g);
 738
 739   if (result == MOVE_ILLEGAL) {
 740     pprintf(p, "Internal error, illegal move accepted!\n");
 741   }
 742   if ((result == MOVE_OK) && (gg->status == GAME_EXAMINE)) {
 743     int p1;
 744
 745     for (p1 = 0; p1 < player_globals.p_num; p1++) {
 746       if (player_globals.parray[p1].status != PLAYER_PROMPT)
 747         continue;
 748       if (player_is_observe(p1, g) || player_globals.parray[p1].game == g) {
 749         pprintf(p1, "%s moves: %s\n", pp->name, move.algString);
 750       }
 751     }
 752   }
 753   if (result == MOVE_CHECKMATE) {
 754     if (gg->status == GAME_EXAMINE) {
 755       int p1;
 756
 757       for (p1 = 0; p1 < player_globals.p_num; p1++) {
 758         if (player_globals.parray[p1].status != PLAYER_PROMPT)
 759           continue;
 760         if (player_is_observe(p1, g) || player_globals.parray[p1].game == g) {
 761           pprintf(p1, "%s has been checkmated.\n",
 762                   (CToggle(gg->game_state.onMove) == BLACK) ? "White" : "Black");
 763         }
 764       }
 765     } else {
 766       game_ended(g, CToggle(gg->game_state.onMove), END_CHECKMATE);
 767     }
 768   }
 769   if (result == MOVE_STALEMATE) {
 770     if (gg->status == GAME_EXAMINE) {
 771       int p1;
 772
 773       for (p1 = 0; p1 < player_globals.p_num; p1++) {
 774         if (player_globals.parray[p1].status != PLAYER_PROMPT)
 775           continue;
 776         if (player_is_observe(p1, g) || player_globals.parray[p1].game == g) {
 777           pprintf(p1, "Stalemate.\n");
 778         }
 779       }
 780     } else {
 781       game_ended(g, CToggle(gg->game_state.onMove), END_STALEMATE);
 782     }
 783   }
 784   if (result == MOVE_NOMATERIAL) {
 785     if (gg->status == GAME_EXAMINE) {
 786       int p1;
 787
 788       for (p1 = 0; p1 < player_globals.p_num; p1++) {
 789         if (player_globals.parray[p1].status != PLAYER_PROMPT)
 790           continue;
 791         if (player_is_observe(p1, g) || player_globals.parray[p1].game == g) {
 792           pprintf(p1, "No mating material.\n");
 793         }
 794       }
 795     } else {
 796       game_ended(g, CToggle(gg->game_state.onMove), END_NOMATERIAL);
 797     }
 798   }
 799   if (result == MOVE_BARE) {
 800     if (gg->status == GAME_EXAMINE) {
 801       int p1;
 802
 803       for (p1 = 0; p1 < player_globals.p_num; p1++) {
 804         if (player_globals.parray[p1].status != PLAYER_PROMPT)
 805           continue;
 806         if (player_is_observe(p1, g) || player_globals.parray[p1].game == g) {
 807           pprintf(p1, "%s bared.\n",
 808                   (gg->game_state.onMove == BLACK) ? "White" : "Black");
 809         }
 810       }
 811     } else {
 812       game_ended(g, gg->game_state.onMove, END_BARE);
 813     }
 814   }
 815 }
 816
 817 int com_resign(int p, param_list param)
 818 {
 819   struct player *pp = &player_globals.parray[p];
 820   int g, o, oconnected;
 821
 822   if (param[0].type == TYPE_NULL) {
 823     g = pp->game;
 824     if (!pIsPlaying(p))
 825       return COM_OK;
 826     else {
 827       decline_withdraw_offers(p, -1, -1, DO_DECLINE);
 828       game_ended(g, (game_globals.garray[g].white == p) ? BLACK : WHITE, END_RESIGN);
 829     }
 830   } else if (FindPlayer(p, param[0].val.word, &o, &oconnected)) {
 831     g = game_new();
 832     if (game_read(g, p, o) < 0) {
 833       if (game_read(g, o, p) < 0) {
 834         pprintf(p, "You have no stored game with %s\n", player_globals.parray[o].name);
 835         if (!oconnected)
 836           player_remove(o);
 837         return COM_OK;
 838       } else {
 839         game_globals.garray[g].white = o;
 840         game_globals.garray[g].black = p;
 841       }
 842     } else {
 843       game_globals.garray[g].white = p;
 844       game_globals.garray[g].black = o;
 845     }
 846     pprintf(p, "You resign your stored game with %s\n", player_globals.parray[o].name);
 847     pcommand(p, "message %s I have resigned our stored game \"%s vs. %s.\"",
 848              player_globals.parray[o].name,
 849              player_globals.parray[game_globals.garray[g].white].name,
 850              player_globals.parray[game_globals.garray[g].black].name);
 851     game_delete(game_globals.garray[g].white, game_globals.garray[g].black);
 852     game_ended(g, (game_globals.garray[g].white == p) ? BLACK : WHITE, END_RESIGN);
 853     if (!oconnected)
 854       player_remove(o);
 855   }
 856   return COM_OK;
 857 }
 858
 859 static int Check50MoveRule (int p, int g)
 860 {
 861   int num_reversible = game_globals.garray[g].numHalfMoves;
 862
 863   if (game_globals.garray[g].game_state.lastIrreversable >= 0) {
 864     num_reversible -= game_globals.garray[g].game_state.lastIrreversable;
 865   }
 866   if (num_reversible > 99) {
 867     game_ended(g, (game_globals.garray[g].white == p) ? BLACK : WHITE, END_50MOVERULE);
 868     return 1;
 869   }
 870   return 0;
 871 }
 872
 873 static char *GetFENpos (int g, int half_move)
 874 {
 875   if (half_move < 0)
 876     return game_globals.garray[g].FENstartPos;
 877   else return game_globals.garray[g].moveList[half_move].FENpos;
 878 }
 879
 880 static int CheckRepetition (int p, int g)
 881 {
 882   struct player *pp = &player_globals.parray[p];
 883   struct pending* pend;
 884   int move_num;
 885   int flag1 = 1, flag2 = 1;
 886   char *pos1 = GetFENpos (g, game_globals.garray[g].numHalfMoves - 1);
 887   char *pos2 = GetFENpos (g, game_globals.garray[g].numHalfMoves);
 888   char *pos;
 889
 890   if (game_globals.garray[g].numHalfMoves < 8)  /* can't have three repeats any quicker. */
 891     return 0;
 892
 893   for (move_num = game_globals.garray[g].game_state.lastIrreversable;
 894        move_num < game_globals.garray[g].numHalfMoves - 1; move_num++) {
 895     pos = GetFENpos (g, move_num);
 896     if (strlen(pos1) == strlen(pos) && !strcmp(pos1, pos))
 897       flag1++;
 898     if (strlen(pos2) == strlen(pos) && !strcmp(pos2, pos))
 899       flag2++;
 900   }
 901   if (flag1 >= 3 || flag2 >= 3) {
 902     if ((pend = find_pend(pp->opponent, p, PEND_DRAW)) != NULL) {
 903       delete_pending(pend);
 904       decline_withdraw_offers(p, -1, -1,DO_DECLINE);
 905     }
 906     game_ended(g, (game_globals.garray[g].white == p) ? BLACK : WHITE, END_REPETITION);
 907     return 1;
 908   }
 909   else return 0;
 910 }
 911
 912 int com_draw(int p, param_list param)
 913 {
 914   struct player *pp = &player_globals.parray[p];
 915   struct pending* pend;
 916   int p1, g = pp->game;
 917
 918   if (!pIsPlaying(p)) {
 919     return COM_OK;
 920   }
 921   if (Check50MoveRule (p, g) || CheckRepetition(p, g)) {
 922     return COM_OK;
 923   }
 924   p1 = pp->opponent;
 925
 926   if ((player_globals.parray[p1].simul_info != NULL) && (player_globals.parray[p1].simul_info->numBoards &&
 927         player_globals.parray[p1].simul_info->boards[player_globals.parray[p1].simul_info->onBoard] != g)) {
 928     pprintf(p, "You can only make requests when the simul player is at your board.\n");
 929     return COM_OK;
 930   }
 931
 932   if ((pend = (find_pend(pp->opponent, p, PEND_DRAW))) != NULL) {
 933     delete_pending(pend);
 934     decline_withdraw_offers(p, -1, -1,DO_DECLINE);
 935     game_ended(g, (game_globals.garray[g].white == p) ? BLACK : WHITE, END_AGREEDDRAW);
 936   } else {
 937     pprintf(pp->opponent, "\n");
 938     pprintf_highlight(pp->opponent, "%s", pp->name);
 939     pprintf_prompt(pp->opponent, " offers you a draw.\n");
 940     pprintf(p, "Draw request sent.\n");
 941     add_request(p, pp->opponent, PEND_DRAW);
 942   }
 943   return COM_OK;
 944 }
 945
 946 int com_pause(int p, param_list param)
 947 {
 948   struct player *pp = &player_globals.parray[p];
 949   int g, now;
 950   struct pending* pend;
 951
 952   if (!pIsPlaying(p)) {
 953     return COM_OK;
 954   }
 955   g = pp->game;
 956   if (game_globals.garray[g].wTime == 0) {
 957     pprintf(p, "You can't pause untimed games.\n");
 958     return COM_OK;
 959   }
 960   if (game_globals.garray[g].clockStopped) {
 961     pprintf(p, "Game is already paused, use \"unpause\" to resume.\n");
 962     return COM_OK;
 963   }
 964   if ((pend = find_pend(pp->opponent, p, PEND_PAUSE)) != NULL) {
 965     delete_pending(pend);
 966     game_globals.garray[g].clockStopped = 1;
 967     /* Roll back the time */
 968     if (game_globals.garray[g].game_state.onMove == WHITE) {
 969       game_globals.garray[g].wTime += (game_globals.garray[g].lastDecTime - game_globals.garray[g].lastMoveTime);
 970     } else {
 971       game_globals.garray[g].bTime += (game_globals.garray[g].lastDecTime - game_globals.garray[g].lastMoveTime);
 972     }
 973     now = tenth_secs();
 974     if (game_globals.garray[g].numHalfMoves == 0)
 975       game_globals.garray[g].timeOfStart = now;
 976     game_globals.garray[g].lastMoveTime = now;
 977     game_globals.garray[g].lastDecTime = now;
 978     send_boards(g);
 979     pprintf_prompt(pp->opponent, "\n%s accepted pause. Game clock paused.\n",
 980                    pp->name);
 981     pprintf(p, "Game clock paused.\n");
 982   } else {
 983     pprintf(pp->opponent, "\n");
 984     pprintf_highlight(pp->opponent, "%s", pp->name);
 985     pprintf_prompt(pp->opponent, " requests to pause the game.\n");
 986     pprintf(p, "Pause request sent.\n");
 987     add_request(p, pp->opponent, PEND_PAUSE);
 988   }
 989   return COM_OK;
 990 }
 991
 992 int com_unpause(int p, param_list param)
 993 {
 994   struct player *pp = &player_globals.parray[p];
 995   int g;
 996   int now;
 997   struct pending* pend;
 998
 999   if (!pIsPlaying(p)) {
1000     return COM_OK;
1001   }
1002
1003   g = pp->game;
1004
1005   if (!game_globals.garray[g].clockStopped) {
1006     pprintf(p, "Game is not paused.\n");
1007     return COM_OK;
1008   }
1009   if ((pend = find_pend(pp->opponent, p, PEND_UNPAUSE)) != NULL) {
1010     delete_pending(pend);
1011     game_globals.garray[g].clockStopped = 0;
1012     now = tenth_secs();
1013     if (game_globals.garray[g].numHalfMoves == 0)
1014       game_globals.garray[g].timeOfStart = now;
1015     game_globals.garray[g].lastMoveTime = now;
1016     game_globals.garray[g].lastDecTime = now;
1017     send_boards(g);
1018     pprintf(p, "Game clock resumed.\n");
1019     pprintf_prompt(pp->opponent, "\nGame clock resumed.\n");
1020   } else {
1021     pprintf(pp->opponent, "\n");
1022     pprintf_highlight(pp->opponent, "%s", pp->name);
1023     pprintf_prompt(pp->opponent, " requests to unpause the game.\n");
1024     pprintf(p, "Unpause request sent.\n");
1025     add_request(p, pp->opponent, PEND_UNPAUSE);
1026   }
1027   return COM_OK;
1028 }
1029
1030 int com_abort(int p, param_list param)
1031 {
1032   struct player *pp = &player_globals.parray[p];
1033   struct pending* pend;
1034   int p1, g, myColor, yourColor, myGTime, yourGTime;
1035   int courtesyOK = 1;
1036
1037   g = pp->game;
1038   if (!pIsPlaying(p))
1039     return COM_OK;
1040
1041   p1 = pp->opponent;
1042   if (p == game_globals.garray[g].white) {
1043     myColor = WHITE;
1044     yourColor = BLACK;
1045     myGTime = game_globals.garray[g].wTime;
1046     yourGTime = game_globals.garray[g].bTime;
1047   } else {
1048     myColor = BLACK;
1049     yourColor = WHITE;
1050     myGTime = game_globals.garray[g].bTime;
1051     yourGTime = game_globals.garray[g].wTime;
1052   }
1053   if ((player_globals.parray[p1].simul_info != NULL) &&
1054      (player_globals.parray[p1].simul_info->numBoards &&
1055         player_globals.parray[p1].simul_info->boards[player_globals.parray[p1].simul_info->onBoard] != g)) {
1056     pprintf(p, "You can only make requests when the simul player is at your board.\n");
1057     return COM_OK;
1058   }
1059   if ((pend = find_pend(p1, p, PEND_ABORT)) != NULL) {
1060     delete_pending(pend);
1061     decline_withdraw_offers(p, -1, -1,DO_DECLINE);
1062     game_ended(g, yourColor, END_ABORT);
1063   } else {
1064     game_update_time(g);
1065
1066     if (net_globals.con[pp->socket]->timeseal
1067         && game_globals.garray[g].game_state.onMove == myColor
1068         && game_globals.garray[g].flag_pending == FLAG_ABORT) {
1069       /* It's my move, opponent has asked for abort; I lagged out,
1070          my timeseal prevented courtesyabort, and I am sending an abort
1071          request before acknowledging (and processing) my opponent's
1072          courtesyabort.  OK, let's abort already :-). */
1073       decline_withdraw_offers(p, -1, -1,DO_DECLINE);
1074       game_ended(g, yourColor, END_ABORT);
1075     }
1076
1077     if (net_globals.con[player_globals.parray[p1].socket]->timeseal) {  /* opp uses timeseal? */
1078
1079       int yourRealTime = (myColor == WHITE  ?  game_globals.garray[g].bRealTime
1080                                             :  game_globals.garray[g].wRealTime);
1081       if (myGTime > 0 && yourGTime <= 0 && yourRealTime > 0) {
1082         /* Override courtesyabort; opponent still has time.  Check for lag. */
1083         courtesyOK = 0;
1084
1085         if (game_globals.garray[g].game_state.onMove != myColor
1086             && game_globals.garray[g].flag_pending != FLAG_CHECKING) {
1087           /* Opponent may be lagging; let's ask. */
1088           game_globals.garray[g].flag_pending = FLAG_ABORT;
1089           game_globals.garray[g].flag_check_time = time(0);
1090           pprintf(p, "Opponent has timeseal; trying to courtesyabort.\n");
1091           pprintf(p1, "\n[G]\n");
1092           return COM_OK;
1093         }
1094       }
1095     }
1096
1097     if (myGTime > 0 && yourGTime <= 0 && courtesyOK) {
1098       /* player wants to abort + opponent is out of time = courtesyabort */
1099       pprintf(p, "Since you have time, and your opponent has none, the game has been aborted.");
1100       pprintf(p1, "Your opponent has aborted the game rather than calling your flag.");
1101       decline_withdraw_offers(p, -1, -1, DO_DECLINE);
1102       game_ended(g, myColor, END_COURTESY);
1103     } else {
1104       pprintf(p1, "\n");
1105       pprintf_highlight(p1, "%s", pp->name);
1106       pprintf(p1, " would like to abort the game; ");
1107       pprintf_prompt(p1, "type \"abort\" to accept.\n");
1108       pprintf(p, "Abort request sent.\n");
1109       add_request(p, p1, PEND_ABORT);
1110     }
1111   }
1112   return COM_OK;
1113 }
1114
1115 static int player_has_mating_material(struct game_state_t *gs, int color)
1116 {
1117   int i, j;
1118   int piece;
1119   int minor_pieces = 0;
1120
1121   for (i = 0; i < gs->files; i++)
1122     for (j = 0; j < gs->ranks; j++) {
1123       piece = gs->board[i][j];
1124       switch (piecetype(piece)) {
1125       case BISHOP:
1126       case KNIGHT:
1127         if (iscolor(piece, color))
1128           minor_pieces++;
1129         break;
1130       case KING:
1131       case NOPIECE:
1132         break;
1133       default:
1134         if (iscolor(piece, color))
1135           return 1;
1136       }
1137     }
1138   return ((minor_pieces > 1) ? 1 : 0);
1139 }
1140
1141 int com_flag(int p, param_list param)
1142 {
1143         struct player *pp = &player_globals.parray[p];
1144         struct game *gg;
1145         int g;
1146         int myColor;
1147
1148         if (!pIsPlaying(p)) {
1149                 return COM_OK;
1150         }
1151         g = pp->game;
1152
1153         gg = &game_globals.garray[g];
1154
1155         myColor = (p == gg->white ? WHITE : BLACK);
1156         if (gg->type == TYPE_UNTIMED) {
1157                 pprintf(p, "You can't flag an untimed game.\n");
1158                 return COM_OK;
1159         }
1160         if (gg->numHalfMoves < 2) {
1161                 pprintf(p, "You cannot flag before both players have moved.\nUse abort instead.\n");
1162                 return COM_OK;
1163         }
1164         game_update_time(g);
1165
1166         {
1167                 int myTime, yourTime, opp = pp->opponent, serverTime;
1168
1169                 if (net_globals.con[pp->socket]->timeseal) {    /* does caller use timeseal? */
1170                         myTime = (myColor==WHITE?gg->wRealTime:gg->bRealTime);
1171                 } else {
1172                         myTime = (myColor == WHITE?gg->wTime:gg->bTime);
1173                 }
1174                 serverTime = (myColor == WHITE?gg->bTime:gg->wTime);
1175
1176                 if (net_globals.con[player_globals.parray[opp].socket]->timeseal) {     /* opp uses timeseal? */
1177                         yourTime = (myColor == WHITE?gg->bRealTime:gg->wRealTime);
1178                 } else {
1179                         yourTime = serverTime;
1180                 }
1181
1182                 /* the clocks to compare are now in myTime and yourTime */
1183                 if ((myTime <= 0) && (yourTime <= 0)) {
1184                         decline_withdraw_offers(p, -1, -1,DO_DECLINE);
1185                         game_ended(g, myColor, END_BOTHFLAG);
1186                         return COM_OK;
1187                 }
1188
1189                 if (yourTime > 0) {
1190                         /* Opponent still has time, but if that's only because s/he
1191                          * may be lagging, we should ask for an acknowledgement and then
1192                          * try to call the flag. */
1193
1194                         if (serverTime <= 0 && gg->game_state.onMove != myColor
1195                             && gg->flag_pending != FLAG_CHECKING) {
1196                                 /* server time thinks opponent is down, but RealTIme disagrees.
1197                                  * ask client to acknowledge it's alive. */
1198                                 gg->flag_pending = FLAG_CALLED;
1199                                 gg->flag_check_time = time(0);
1200                                 pprintf(p, "Opponent has timeseal; checking if (s)he's lagging.\n");
1201                                 pprintf (opp, "\n[G]\n");
1202                                 return COM_OK;
1203                         }
1204
1205                         /* if we're here, it means one of:
1206                          * 1. the server agrees opponent has time, whether lagging or not.
1207                          * 2. opp. has timeseal (if yourTime != serverTime), had time left
1208                          *    after the last move (yourTime > 0), and it's still your move.
1209                          * 3. we're currently checking a flag call after having receiving
1210                          *    acknowledgement from the other timeseal (and would have reset
1211                          *    yourTime if the flag were down). */
1212
1213                         pprintf(p, "Your opponent is not out of time!\n");
1214                         return COM_OK;
1215                 }
1216         }
1217
1218         decline_withdraw_offers(p, -1, -1,DO_DECLINE);
1219         if (player_has_mating_material(&gg->game_state, myColor))
1220                 game_ended(g, myColor, END_FLAG);
1221         else
1222                 game_ended(g, myColor, END_FLAGNOMATERIAL);
1223         return COM_OK;
1224 }
1225
1226 int com_adjourn(int p, param_list param)
1227 {
1228   struct player *pp = &player_globals.parray[p];
1229   struct pending* pend;
1230   int p1, g, myColor, yourColor;
1231
1232   if (!pIsPlaying(p))
1233     return COM_OK;
1234
1235   p1 = pp->opponent;
1236   g = pp->game;
1237   if (!CheckPFlag(p, PFLAG_REG) || !CheckPFlag(p, PFLAG_REG)) {
1238     pprintf(p, "Both players must be registered to adjourn a game.  Use \"abort\".\n");
1239     return COM_OK;
1240   }
1241   if (game_globals.garray[g].link >= 0) {
1242     pprintf(p, "Bughouse games cannot be adjourned.\n");
1243     return COM_OK;
1244   }
1245   myColor = (p == game_globals.garray[g].white ? WHITE : BLACK);
1246   yourColor = (myColor == WHITE ? BLACK : WHITE);
1247
1248   if ((pend = find_pend(p1, p, PEND_ADJOURN)) != NULL) {
1249     delete_pending(pend);
1250     decline_withdraw_offers(p, -1, -1,DO_DECLINE);
1251     game_ended(pp->game, yourColor, END_ADJOURN);
1252   } else {
1253     game_update_time(g);
1254     if (((myColor == WHITE) && (game_globals.garray[g].wTime > 0) && (game_globals.garray[g].bTime <= 0))
1255         || ((myColor == BLACK) && (game_globals.garray[g].bTime > 0) && (game_globals.garray[g].wTime <= 0))) {
1256 /* player wants to adjourn + opponent is out of time = courtesyadjourn */
1257       pprintf(p, "Since you have time, and your opponent has none, the game has been adjourned.");
1258       pprintf(p1, "Your opponent has adjourned the game rather than calling your flag.");
1259       decline_withdraw_offers(p, -1, -1,DO_DECLINE);
1260       game_ended(g, myColor, END_COURTESYADJOURN);
1261     } else {
1262       pprintf(p1, "\n");
1263       pprintf_highlight(p1, "%s", pp->name);
1264       pprintf(p1, " would like to adjourn the game; ");
1265       pprintf_prompt(p1, "type \"adjourn\" to accept.\n");
1266       pprintf(p, "Adjourn request sent.\n");
1267       add_request(p, p1, PEND_ADJOURN);
1268     }
1269   }
1270   return COM_OK;
1271 }
1272
1273 int com_takeback(int p, param_list param)
1274 {
1275   struct player *pp = &player_globals.parray[p];
1276   int nHalfMoves = 1, g, i, p1, pend_half_moves;
1277   struct pending* from;
1278
1279   if (!pIsPlaying(p))
1280     return COM_OK;
1281
1282   p1 = pp->opponent;
1283   if ((player_globals.parray[p1].simul_info != NULL) &&
1284      (player_globals.parray[p1].simul_info->numBoards &&
1285         player_globals.parray[p1].simul_info->boards[player_globals.parray[p1].simul_info->onBoard] !=
1286         pp->game)) {
1287     pprintf(p, "You can only make requests when the simul player is at your board.\n");
1288     return COM_OK;
1289   }
1290
1291   g = pp->game;
1292   if (game_globals.garray[g].link >= 0) {
1293     pprintf(p, "Takeback not implemented for bughouse games yet.\n");
1294     return COM_OK;
1295   }
1296   if (param[0].type == TYPE_INT) {
1297     nHalfMoves = param[0].val.integer;
1298     if (nHalfMoves <= 0) {
1299       pprintf (p,"You can't takeback less than 1 move.\n");
1300       return COM_OK;
1301     }
1302   }
1303   if ((from = find_pend(pp->opponent, p, PEND_TAKEBACK)) != NULL) {
1304     pend_half_moves = from->wtime;
1305     delete_pending(from);
1306     if (pend_half_moves == nHalfMoves) {
1307       /* Doing the takeback */
1308       decline_withdraw_offers(p, -1, -PEND_SIMUL,DO_DECLINE);
1309       for (i = 0; i < nHalfMoves; i++) {
1310         if (backup_move(g, REL_GAME) != MOVE_OK) {
1311           pprintf(game_globals.garray[g].white, "Can only backup %d moves\n", i);
1312           pprintf(game_globals.garray[g].black, "Can only backup %d moves\n", i);
1313           break;
1314         }
1315       }
1316
1317       game_globals.garray[g].wTimeWhenReceivedMove = 0;
1318       game_globals.garray[g].bTimeWhenReceivedMove = 0;
1319
1320       send_boards(g);
1321     } else {
1322
1323       if (!game_globals.garray[g].numHalfMoves) {
1324         pprintf(p, "There are no moves in your game.\n");
1325         pprintf_prompt(pp->opponent, "\n%s has declined the takeback request.\n",
1326                        pp->name);
1327         return COM_OK;
1328       }
1329
1330       if (game_globals.garray[g].numHalfMoves < nHalfMoves) {
1331         pprintf(p, "There are only %d half moves in your game.\n", game_globals.garray[g].numHalfMoves);
1332         pprintf_prompt(pp->opponent, "\n%s has declined the takeback request.\n",
1333                        pp->name);
1334         return COM_OK;
1335       }
1336       pprintf(p, "You disagree on the number of half-moves to takeback.\n");
1337       pprintf(p, "Alternate takeback request sent.\n");
1338       pprintf_prompt(pp->opponent, "\n%s proposes a different number (%d) of half-move(s).\n", pp->name, nHalfMoves);
1339       from = add_request(p, pp->opponent, PEND_TAKEBACK);
1340       from->wtime = nHalfMoves;
1341     }
1342   } else {
1343
1344     if (!game_globals.garray[g].numHalfMoves) {
1345       pprintf(p, "There are no moves in your game.\n");
1346       return COM_OK;
1347     }
1348     if (game_globals.garray[g].numHalfMoves < nHalfMoves) {
1349       pprintf(p, "There are only %d half moves in your game.\n", game_globals.garray[g].numHalfMoves);
1350       return COM_OK;
1351     }
1352     pprintf(pp->opponent, "\n");
1353     pprintf_highlight(pp->opponent, "%s", pp->name);
1354     pprintf_prompt(pp->opponent, " would like to take back %d half move(s).\n",
1355            nHalfMoves);
1356     pprintf(p, "Takeback request sent.\n");
1357     from = add_request(p, pp->opponent, PEND_TAKEBACK);
1358     from->wtime = nHalfMoves;
1359   }
1360   return COM_OK;
1361 }
1362
1363
1364 int com_switch(int p, param_list param)
1365 {
1366   struct player *pp = &player_globals.parray[p];
1367   int g = pp->game, tmp, now, p1;
1368   char *strTmp;
1369   struct pending* pend;
1370
1371   if (!pIsPlaying(p))
1372     return COM_OK;
1373
1374   p1 = pp->opponent;
1375   if ((player_globals.parray[p1].simul_info != NULL) && (player_globals.parray[p1].simul_info->numBoards &&
1376         player_globals.parray[p1].simul_info->boards[player_globals.parray[p1].simul_info->onBoard] != g)) {
1377     pprintf(p, "You can only make requests when the simul player is at your board.\n");
1378     return COM_OK;
1379   }
1380
1381   if (game_globals.garray[g].link >= 0) {
1382     pprintf(p, "Switch not implemented for bughouse games.\n");
1383     return COM_OK;
1384   }
1385   if ((pend = find_pend(pp->opponent, p, PEND_SWITCH)) != NULL) {
1386     delete_pending(pend);
1387     /* Doing the switch */
1388     decline_withdraw_offers(p, -1, -PEND_SIMUL,DO_DECLINE);
1389
1390     tmp = game_globals.garray[g].white;
1391     game_globals.garray[g].white = game_globals.garray[g].black;
1392     game_globals.garray[g].black = tmp;
1393     pp->side = (pp->side == WHITE) ? BLACK : WHITE;
1394     strTmp = strdup(game_globals.garray[g].white_name);
1395     strcpy(game_globals.garray[g].white_name, game_globals.garray[g].black_name);
1396     strcpy(game_globals.garray[g].black_name, strTmp);
1397     free(strTmp);
1398
1399     player_globals.parray[pp->opponent].side =
1400       (player_globals.parray[pp->opponent].side == WHITE) ? BLACK : WHITE;
1401     /* Roll back the time */
1402     if (game_globals.garray[g].game_state.onMove == WHITE) {
1403       game_globals.garray[g].wTime += (game_globals.garray[g].lastDecTime - game_globals.garray[g].lastMoveTime);
1404     } else {
1405       game_globals.garray[g].bTime += (game_globals.garray[g].lastDecTime - game_globals.garray[g].lastMoveTime);
1406     }
1407     now = tenth_secs();
1408     if (game_globals.garray[g].numHalfMoves == 0)
1409       game_globals.garray[g].timeOfStart = now;
1410     game_globals.garray[g].lastMoveTime = now;
1411     game_globals.garray[g].lastDecTime = now;
1412     send_boards(g);
1413     return COM_OK;
1414   }
1415   if (game_globals.garray[g].rated && game_globals.garray[g].numHalfMoves > 0) {
1416     pprintf(p, "You cannot switch sides once a rated game is underway.\n");
1417     return COM_OK;
1418   }
1419   pprintf(pp->opponent, "\n");
1420   pprintf_highlight(pp->opponent, "%s", pp->name);
1421   pprintf_prompt(pp->opponent, " would like to switch sides.\nType \"accept\" to switch sides, or \"decline\" to refuse.\n");
1422   pprintf(p, "Switch request sent.\n");
1423   add_request(p, pp->opponent, PEND_SWITCH);
1424   return COM_OK;
1425 }
1426
1427 int com_time(int p, param_list param)
1428 {
1429   struct player *pp = &player_globals.parray[p];
1430   int p1, g;
1431
1432   if (param[0].type == TYPE_NULL) {
1433     g = pp->game;
1434     if (!pIsPlaying(p))
1435       return COM_OK;
1436   } else {
1437     g = GameNumFromParam(p, &p1, &param[0]);
1438     if (g < 0)
1439       return COM_OK;
1440   }
1441   if ((g < 0) || (g >= game_globals.g_num) || (game_globals.garray[g].status != GAME_ACTIVE)) {
1442     pprintf(p, "There is no such game.\n");
1443     return COM_OK;
1444   }
1445   game_update_time(g);
1446   pprintf(p, "White (%s) : %d mins, %d secs\n",
1447           player_globals.parray[game_globals.garray[g].white].name,
1448           game_globals.garray[g].wTime / 600,
1449           (game_globals.garray[g].wTime - ((game_globals.garray[g].wTime / 600) * 600)) / 10);
1450   pprintf(p, "Black (%s) : %d mins, %d secs\n",
1451           player_globals.parray[game_globals.garray[g].black].name,
1452           game_globals.garray[g].bTime / 600,
1453           (game_globals.garray[g].bTime - ((game_globals.garray[g].bTime / 600) * 600)) / 10);
1454   return COM_OK;
1455 }
1456
1457 int com_ptime(int p, param_list param)
1458 {
1459   struct player *pp = &player_globals.parray[p];
1460   int retval, part = pp->partner;
1461
1462   if (part < 0) {
1463     pprintf(p, "You do not have a partner.\n");
1464     return COM_OK;
1465   }
1466   retval = pcommand (p, "time %s", player_globals.parray[part].name);
1467   if (retval == COM_OK)
1468     return COM_OK_NOPROMPT;
1469   else
1470     return retval;
1471 }
1472
1473 int com_boards(int p, param_list param)
1474 {
1475   char *category = NULL;
1476   char dname[MAX_FILENAME_SIZE];
1477   DIR *dirp;
1478   struct dirent *dp;
1479
1480   if (param[0].type == TYPE_WORD)
1481     category = param[0].val.word;
1482   if (category) {
1483     pprintf(p, "Boards Available For Category %s:\n", category);
1484     sprintf(dname, "%s/%s", BOARD_DIR, category);
1485   } else {
1486     pprintf(p, "Categories Available:\n");
1487     sprintf(dname, "%s", BOARD_DIR);
1488   }
1489   dirp = opendir(dname);
1490   if (!dirp) {
1491     pprintf(p, "No such category %s, try \"boards\".\n", category);
1492     return COM_OK;
1493   }
1494
1495 /* YUK! what a mess, how about printing an ordered directory? - DAV*/
1496
1497   for (dp = readdir(dirp); dp != NULL; dp = readdir(dirp)) {
1498     if (!strcmp(dp->d_name, "."))
1499       continue;
1500     if (!strcmp(dp->d_name, ".."))
1501       continue;
1502     pprintf(p, "%s\n", dp->d_name);
1503   }
1504   closedir(dirp);
1505   return COM_OK;
1506 }
1507
1508 int com_simmatch(int p, param_list param)
1509 {
1510   struct player *pp = &player_globals.parray[p];
1511   int p1, g, adjourned;
1512   int num;
1513   char tmp[100];
1514   struct pending* pend;
1515   char* board = NULL;
1516   char* category = NULL;
1517   char fname[MAX_FILENAME_SIZE];
1518
1519   if (pp->game >=0) {
1520     if (game_globals.garray[pp->game].status == GAME_EXAMINE) {
1521       pprintf(p, "You are still examining a game.\n");
1522       return COM_OK;
1523     }
1524     if (game_globals.garray[pp->game].status == GAME_SETUP) {
1525       pprintf(p, "You are still setting up a position.\n");
1526       return COM_OK;
1527     }
1528   }
1529   p1 = player_find_part_login(param[0].val.word);
1530   if (p1 < 0) {
1531     pprintf(p, "No user named \"%s\" is logged in.\n", param[0].val.word);
1532     return COM_OK;
1533   }
1534   if (p == p1) {
1535     pprintf(p, "You can't simmatch yourself!\n");
1536     return COM_OK;
1537   }
1538   if ((pend = find_pend(p1, p, PEND_SIMUL)) != NULL) {
1539
1540     /* Accepting Simul ! */
1541
1542     if ((pp->simul_info != NULL) &&
1543        (pp->simul_info->numBoards >= MAX_SIMUL)) {
1544       pprintf(p, "You are already playing the maximum of %d boards.\n", MAX_SIMUL);
1545       pprintf(p1, "Simul request removed, boards filled.\n");
1546       delete_pending(pend);
1547       return COM_OK;
1548     }
1549     unobserveAll(p);            /* stop observing when match starts */
1550     unobserveAll(p1);
1551
1552     g = game_new();
1553     adjourned = 0;
1554     if (game_read(g, p, p1) >= 0) {
1555       adjourned = 1;
1556       delete_pending(pend);
1557     }
1558
1559     if (!adjourned) {           /* no adjourned game, so begin a new game */
1560
1561       if ((pend->category != NULL) && (pend->board_type != NULL)) {
1562         board = strdup(pend->category);
1563         category = strdup(pend->board_type);
1564       }
1565
1566       delete_pending(pend);
1567
1568       if (create_new_match(g,p, p1, 0, 0, 0, 0, 0, ((board == NULL) ? "\0" : board), ((category == NULL) ? "\0" : category), 1,1) == COM_FAILED) {
1569         pprintf(p, "There was a problem creating the new match.\n");
1570         pprintf_prompt(p1, "There was a problem creating the new match.\n");
1571         game_remove(g);
1572
1573         if (board != NULL) {
1574           free (board);
1575           free (category);
1576         }
1577         return COM_OK;
1578       }
1579
1580       if (board != NULL) {
1581         free (board);
1582         free (category);
1583       }
1584
1585     } else {                    /* resume adjourned game */
1586       game_delete(p, p1);
1587
1588       sprintf(tmp, "{Game %d (%s vs. %s) Continuing %s %s simul.}\n", g + 1, pp->name, player_globals.parray[p1].name, rstr[game_globals.garray[g].rated], bstr[game_globals.garray[g].type]);
1589       pprintf(p, tmp);
1590       pprintf(p1, tmp);
1591
1592       game_globals.garray[g].white = p;
1593       game_globals.garray[g].black = p1;
1594       game_globals.garray[g].status = GAME_ACTIVE;
1595       game_globals.garray[g].startTime = tenth_secs();
1596       game_globals.garray[g].lastMoveTime = game_globals.garray[g].startTime;
1597       game_globals.garray[g].lastDecTime = game_globals.garray[g].startTime;
1598       pp->game = g;
1599       pp->opponent = p1;
1600       pp->side = WHITE;
1601       player_globals.parray[p1].game = g;
1602       player_globals.parray[p1].opponent = p;
1603       player_globals.parray[p1].side = BLACK;
1604       send_boards(g);
1605     }
1606
1607     if (pp->simul_info == NULL) {
1608       pp->simul_info = (struct simul_info_t *) malloc(sizeof(struct simul_info_t));
1609       pp->simul_info->numBoards = 0;
1610       pp->simul_info->onBoard = 0;
1611       pp->simul_info->num_wins = pp->simul_info->num_draws
1612         = pp->simul_info->num_losses = 0;
1613     }
1614     num = pp->simul_info->numBoards;
1615     /*    pp->simul_info->results[num] = -1; */
1616     pp->simul_info->boards[num] = pp->game;
1617     pp->simul_info->numBoards++;
1618     if (pp->simul_info->numBoards > 1 &&
1619         pp->simul_info->onBoard >= 0)
1620       player_goto_board(p, pp->simul_info->onBoard);
1621     else
1622       pp->simul_info->onBoard = 0;
1623     return COM_OK;
1624   }
1625   if (find_pend(-1, p, PEND_SIMUL) != NULL) {
1626     pprintf(p, "You cannot be the simul giver and request to join another simul.\nThat would just be too confusing for me and you.\n");
1627     return COM_OK;
1628   }
1629   if (pp->simul_info != NULL) {
1630     if (pp->simul_info->numBoards) {
1631       pprintf(p, "You cannot be the simul giver and request to join another simul.\nThat would just be too confusing for me and you.\n");
1632       return COM_OK;
1633     }
1634   }
1635   if (pp->game >=0) {
1636     pprintf(p, "You are already playing a game.\n");
1637     return COM_OK;
1638   }
1639   if (!CheckPFlag(p1, PFLAG_SIMOPEN)) {
1640     pprintf_highlight(p, "%s", player_globals.parray[p1].name);
1641     pprintf(p, " is not open to receiving simul requests.\n");
1642     return COM_OK;
1643   }
1644   if ((player_globals.parray[p1].simul_info != NULL) && (player_globals.parray[p1].simul_info->numBoards >= MAX_SIMUL)) {
1645     pprintf_highlight(p, "%s", player_globals.parray[p1].name);
1646     pprintf(p, " is already playing the maximum of %d boards.\n", MAX_SIMUL);
1647     return COM_OK;
1648   }
1649
1650 /* loon: checking for some crazy situations we can't allow :) */
1651
1652   if ((player_globals.parray[p1].simul_info != NULL) && (player_globals.parray[p1].game >=0) && (player_globals.parray[p1].simul_info->numBoards == 0)) {
1653     pprintf_highlight(p, "%s", player_globals.parray[p1].name);
1654     if (player_globals.parray[game_globals.garray[player_globals.parray[p1].game].white].simul_info->numBoards) {
1655       pprintf(p, " is playing in ");
1656       pprintf_highlight(p, "%s", player_globals.parray[player_globals.parray[p1].opponent].name);
1657       pprintf(p, "'s simul, and can't accept.\n");
1658     } else {
1659       pprintf(p, " can't begin a simul while playing a non-simul game.\n");
1660     }
1661     return COM_OK;
1662   }
1663
1664   g = game_new();               /* Check if an adjourned untimed game */
1665   adjourned = ((game_read(g, p, p1) < 0) && (game_read(g, p1, p) < 0)) ? 0 : 1;
1666   if (adjourned) {
1667     if (!(game_globals.garray[g].type == TYPE_UNTIMED))
1668       adjourned = 0;
1669   }
1670   game_remove(g);
1671
1672   pend = add_request(p, p1, PEND_SIMUL);
1673
1674   if ((param[1].type == TYPE_WORD) && (param[2].type == TYPE_WORD)) {
1675
1676     sprintf(fname, "%s/%s/%s", BOARD_DIR, param[1].val.word , param[2].val.word);
1677     if (!file_exists(fname)) {
1678       pprintf(p, "No such category/board: %s/%s\n", param[1].val.word , param[2].val.word);
1679       return COM_OK;
1680     }
1681     pend->category = strdup(param[1].val.word);
1682     pend->board_type = strdup(param[2].val.word);
1683   } else {
1684     pend->category = NULL;
1685     pend->board_type = NULL;
1686   }
1687
1688   pprintf(p1, "\n");
1689   pprintf_highlight(p1, "%s", pp->name);
1690   if (adjourned) {
1691     pprintf_prompt(p1, " requests to continue an adjourned simul game.\n");
1692     pprintf(p, "Request to resume simul sent. Adjourned game found.\n");
1693   } else {
1694     if (pend->category == NULL)
1695       pprintf_prompt(p1, " requests to join a simul match with you.\n");
1696     else
1697       pprintf_prompt(p1, " requests to join a %s %s simul match with you.\n",
1698                 pend->category,pend->board_type);
1699     pprintf(p, "Simul match request sent.\n");
1700   }
1701   return COM_OK;
1702 }
1703
1704 int com_goboard(int p, param_list param)
1705 {
1706   struct player *pp = &player_globals.parray[p];
1707   int on, g, p1, gamenum;
1708
1709   if (pp->simul_info == NULL) {
1710     pprintf(p, "You are not giving a simul.\n");
1711     return COM_OK;
1712   }
1713
1714   if (!pp->simul_info->numBoards) {
1715     pprintf(p, "You are not giving a simul.\n");
1716     return COM_OK;
1717   }
1718
1719   if (param[0].type == TYPE_WORD) {
1720
1721     p1 = player_find_part_login(param[0].val.word);
1722     if (p1 < 0) {
1723       pprintf(p, "No user named \"%s\" is logged in.\n", param[0].val.word);
1724       return COM_OK;
1725     }
1726     if (p == p1) {
1727       pprintf(p, "You can't goboard yourself!\n");
1728       return COM_OK;
1729     }
1730
1731     gamenum = player_globals.parray[p1].game;
1732     if (gamenum < 0) {
1733       pprintf (p,"%s is not playing a game.\n", player_globals.parray[p1].login);
1734       return COM_OK;
1735     }
1736
1737   } else {
1738     gamenum = param[0].val.integer - 1;
1739     if (gamenum < 0)
1740       gamenum = 0;
1741   }
1742
1743   on = pp->simul_info->onBoard;
1744   g = pp->simul_info->boards[on];
1745   if (gamenum == g) {
1746     pprintf(p, "You are already at that board!\n");
1747     return COM_OK;
1748   }
1749   if (pp->simul_info->numBoards > 1) {
1750     decline_withdraw_offers(p, -1, -PEND_SIMUL,DO_DECLINE);
1751     if (player_goto_simulgame_bynum(p, gamenum) !=-1) {
1752       if (g >= 0) {
1753         pprintf(game_globals.garray[g].black, "\n");
1754         pprintf_highlight(game_globals.garray[g].black, "%s", pp->name);
1755         pprintf_prompt(game_globals.garray[g].black, " has moved away from your board.\n");
1756       }
1757     } else
1758     pprintf(p, "You are not playing that game/person.\n");
1759   } else
1760     pprintf(p, "You are only playing one board!\n");
1761   return COM_OK;
1762 }
1763
1764 int com_simnext(int p, param_list param)
1765 {
1766   struct player *pp = &player_globals.parray[p];
1767   int on, g;
1768
1769   if (pp->simul_info == NULL) {
1770     pprintf(p, "You are not giving a simul.\n");
1771     return COM_OK;
1772   }
1773
1774   if (!pp->simul_info->numBoards) {
1775     pprintf(p, "You are not giving a simul.\n");
1776     return COM_OK;
1777   }
1778
1779   if (pp->simul_info->numBoards > 1) {
1780     decline_withdraw_offers(p, -1, -PEND_SIMUL,DO_DECLINE);
1781     on = pp->simul_info->onBoard;
1782     g = pp->simul_info->boards[on];
1783     if (g >= 0) {
1784       pprintf(game_globals.garray[g].black, "\n");
1785       pprintf_highlight(game_globals.garray[g].black, "%s", pp->name);
1786       pprintf_prompt(game_globals.garray[g].black, " is moving away from your board.\n");
1787       player_goto_next_board(p);
1788     }
1789   } else
1790     pprintf(p, "You are only playing one board!\n");
1791   return COM_OK;
1792 }
1793
1794 int com_simprev(int p, param_list param)
1795 {
1796   struct player *pp = &player_globals.parray[p];
1797   int on, g;
1798
1799   if (pp->simul_info == NULL) {
1800     pprintf(p, "You are not giving a simul.\n");
1801     return COM_OK;
1802   }
1803
1804   if (!pp->simul_info->numBoards) {
1805     pprintf(p, "You are not giving a simul.\n");
1806     return COM_OK;
1807   }
1808   if (pp->simul_info->numBoards > 1) {
1809     decline_withdraw_offers(p, -1, -PEND_SIMUL,DO_DECLINE);
1810     on = pp->simul_info->onBoard;
1811     g = pp->simul_info->boards[on];
1812     if (g >= 0) {
1813       pprintf(game_globals.garray[g].black, "\n");
1814       pprintf_highlight(game_globals.garray[g].black, "%s", pp->name);
1815       pprintf_prompt(game_globals.garray[g].black, " is moving back to the previous board.\n");
1816     }
1817     player_goto_prev_board(p);
1818   } else
1819     pprintf(p, "You are only playing one board!\n");
1820   return COM_OK;
1821 }
1822
1823 int com_simgames(int p, param_list param)
1824 {
1825   int p1 = p;
1826
1827   if (param[0].type == TYPE_WORD) {
1828     if ((p1 = player_find_part_login(param[0].val.word)) < 0) {
1829       pprintf(p, "No player named %s is logged in.\n", param[0].val.word);
1830       return COM_OK;
1831     }
1832   }
1833   if (p1 == p)
1834     pprintf(p, "You are playing %d simultaneous games.\n",
1835             player_num_active_boards(p1));
1836   else
1837     pprintf(p, "%s is playing %d simultaneous games.\n", player_globals.parray[p1].name,
1838             player_num_active_boards(p1));
1839   return COM_OK;
1840 }
1841
1842 int com_simpass(int p, param_list param)
1843 {
1844   struct player *pp = &player_globals.parray[p];
1845   int g, p1, on;
1846
1847   if (!pIsPlaying(p))
1848     return COM_OK;
1849
1850   g = pp->game;
1851   p1 = game_globals.garray[g].white;
1852
1853   if (player_globals.parray[p1].simul_info == NULL) {
1854     pprintf(p, "You are not participating in a simul.\n");
1855     return COM_OK;
1856   }
1857
1858   if (!player_globals.parray[p1].simul_info->numBoards) {
1859     pprintf(p, "You are not participating in a simul.\n");
1860     return COM_OK;
1861   }
1862   if (p == p1) {
1863     pprintf(p, "You are the simul holder and cannot pass!\n");
1864     return COM_OK;
1865   }
1866   if (player_num_active_boards(p1) == 1) {
1867     pprintf(p, "This is the only game, so passing is futile.\n");
1868     return COM_OK;
1869   }
1870   on = player_globals.parray[p1].simul_info->onBoard;
1871   if (player_globals.parray[p1].simul_info->boards[on] != g) {
1872     pprintf(p, "You cannot pass until the simul holder arrives!\n");
1873     return COM_OK;
1874   }
1875   if (game_globals.garray[g].passes >= MAX_SIMPASS) {
1876     Bell (p);
1877     pprintf(p, "You have reached your maximum of %d pass(es).\n", MAX_SIMPASS);
1878     pprintf(p, "Please move IMMEDIATELY!\n");
1879     pprintf_highlight(p1, "%s", pp->name);
1880     pprintf_prompt(p1, " tried to pass, but is out of passes.\n");
1881     return COM_OK;
1882   }
1883   decline_withdraw_offers(p, -1, -PEND_SIMUL,DO_DECLINE);
1884
1885   game_globals.garray[g].passes++;
1886   pprintf(p, "You have passed and have %d pass(es) left.\n",
1887           (MAX_SIMPASS - game_globals.garray[g].passes));
1888   pprintf_highlight(p1, "%s", pp->name);
1889   pprintf_prompt(p1, " has decided to pass and has %d pass(es) left.\n",
1890                  (MAX_SIMPASS - game_globals.garray[g].passes));
1891   player_goto_next_board(p1);
1892   return COM_OK;
1893 }
1894
1895 int com_simabort(int p, param_list param)
1896 {
1897   struct player *pp = &player_globals.parray[p];
1898
1899   if (pp->simul_info == NULL) {
1900     pprintf(p, "You are not giving a simul.\n");
1901     return COM_OK;
1902   }
1903
1904   if (!pp->simul_info->numBoards) {
1905     pprintf(p, "You are not giving a simul.\n");
1906     return COM_OK;
1907   }
1908   decline_withdraw_offers(p, -1, -PEND_SIMUL,DO_DECLINE);
1909   game_ended(pp->simul_info->boards[pp->simul_info->onBoard],
1910              WHITE, END_ABORT);
1911   return COM_OK;
1912 }
1913
1914 int com_simallabort(int p, param_list param)
1915 {
1916   struct player *pp = &player_globals.parray[p];
1917   int i;
1918
1919   if (pp->simul_info == NULL) {
1920     pprintf(p, "You are not giving a simul.\n");
1921     return COM_OK;
1922   }
1923
1924   if (!pp->simul_info->numBoards) {
1925     pprintf(p, "You are not giving a simul.\n");
1926     return COM_OK;
1927   }
1928
1929   decline_withdraw_offers(p, -1, -PEND_SIMUL,DO_DECLINE);
1930   for (i = 0; i < pp->simul_info->numBoards; i++)
1931     if (pp->simul_info->boards[i] >= 0)
1932       game_ended(pp->simul_info->boards[i],
1933                  WHITE, END_ABORT);
1934
1935   return COM_OK;
1936 }
1937
1938 int com_simadjourn(int p, param_list param)
1939 {
1940   struct player *pp = &player_globals.parray[p];
1941
1942   if (pp->simul_info == NULL) {
1943     pprintf(p, "You are not giving a simul.\n");
1944     return COM_OK;
1945   }
1946
1947   if (!pp->simul_info->numBoards) {
1948     pprintf(p, "You are not giving a simul.\n");
1949     return COM_OK;
1950   }
1951   decline_withdraw_offers(p, -1, -PEND_SIMUL,DO_DECLINE);
1952   game_ended(pp->simul_info->boards[pp->simul_info->onBoard],
1953              WHITE, END_ADJOURN);
1954   return COM_OK;
1955 }
1956
1957 int com_simalladjourn(int p, param_list param)
1958 {
1959   struct player *pp = &player_globals.parray[p];
1960   int i;
1961
1962   if (pp->simul_info == NULL) {
1963     pprintf(p, "You are not giving a simul.\n");
1964     return COM_OK;
1965   }
1966
1967   if (!pp->simul_info->numBoards) {
1968     pprintf(p, "You are not giving a simul.\n");
1969     return COM_OK;
1970   }
1971   decline_withdraw_offers(p, -1, -PEND_SIMUL,DO_DECLINE);
1972   for (i = 0; i < pp->simul_info->numBoards; i++)
1973     if (pp->simul_info->boards[i] >= 0)
1974       game_ended(pp->simul_info->boards[i],
1975                  WHITE, END_ADJOURN);
1976
1977   return COM_OK;
1978 }
1979
1980 int com_moretime(int p, param_list param)
1981 {
1982   struct player *pp = &player_globals.parray[p];
1983   int g, increment;
1984
1985   if ((pp->game >=0) &&((game_globals.garray[pp->game].status == GAME_EXAMINE) ||
1986         (game_globals.garray[pp->game].status == GAME_SETUP))) {
1987     pprintf(p, "You cannot use moretime in an examined game.\n");
1988     return COM_OK;
1989   }
1990   increment = param[0].val.integer;
1991   if (increment <= 0) {
1992     pprintf(p, "Moretime requires an integer value greater than zero.\n");
1993     return COM_OK;
1994   }
1995   if (!pIsPlaying(p))
1996     return COM_OK;
1997
1998   if (increment > 600) {
1999     pprintf(p, "Moretime has a maximum limit of 600 seconds.\n");
2000     increment = 600;
2001   }
2002   g = pp->game;
2003   if (game_globals.garray[g].white == p) {
2004     game_globals.garray[g].bTime += increment * 10;
2005     game_globals.garray[g].bRealTime += increment * 10 * 100;
2006     pprintf(p, "%d seconds were added to your opponents clock\n",
2007             increment);
2008     pprintf_prompt(pp->opponent,
2009                    "\nYour opponent has added %d seconds to your clock.\n",
2010                    increment);
2011   }
2012   if (game_globals.garray[g].black == p) {
2013     game_globals.garray[g].wTime += increment * 10;;
2014     game_globals.garray[g].wRealTime += increment * 10 * 100;
2015     pprintf(p, "%d seconds were added to your opponents clock\n",
2016             increment);
2017     pprintf_prompt(pp->opponent,
2018                    "\nYour opponent has added %d seconds to your clock.\n",
2019                    increment);
2020   }
2021   return COM_OK;
2022 }
2023