Implement S-Chess
[capablanca.git] / 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("sc", category)) {
535           strcpy(category, "seirawan");
536         } else
537         if(!strcmp("sg", category)) {
538           strcpy(category, "shogi");
539         } else
540         if(!strcmp("km", category)) {
541           strcpy(category, "knightmate");
542         } else
543         if(!strcmp("gr", category)) {
544           strcpy(category, "great");
545         } else
546         if(!strcmp("xq", category)) {
547           strcpy(category, "xiangqi");
548         }
549       }
550     } else
551       confused = 1;
552   }
553
554   if (confused) {
555     pprintf(p, "Can't interpret %s in match command.\n", parsebuf);
556     return 0;
557   }
558   if(category && (!board || !board[0]))
559         strcpy(board, "0"); // [HGM] variants: always provide default board
560   return 1;
561 }
562
563 static void print_match_rating_info(int p,int p1,int type,int rated)
564 {
565   if (rated) {
566     int win, draw, loss;
567     double newsterr;
568
569     rating_sterr_delta(p1, p, type, time(0), RESULT_WIN, &win, &newsterr);
570     rating_sterr_delta(p1, p, type, time(0), RESULT_DRAW, &draw, &newsterr);
571     rating_sterr_delta(p1, p, type, time(0), RESULT_LOSS, &loss, &newsterr);
572     pprintf(p1, "Your %s rating will change:  Win: %s%d,  Draw: %s%d,  Loss: %s%d\n",
573             bstr[type],
574             (win >= 0) ? "+" : "", win,
575             (draw >= 0) ? "+" : "", draw,
576             (loss >= 0) ? "+" : "", loss);
577     pprintf(p1, "Your new RD will be %5.1f\n", newsterr);
578
579     rating_sterr_delta(p, p1, type, time(0), RESULT_WIN, &win, &newsterr);
580     rating_sterr_delta(p, p1, type, time(0), RESULT_DRAW, &draw, &newsterr);
581     rating_sterr_delta(p, p1, type, time(0), RESULT_LOSS, &loss, &newsterr);
582     pprintf(p, "Your %s rating will change:  Win: %s%d,  Draw: %s%d,  Loss: %s%d\n",
583             bstr[type],
584             (win >= 0) ? "+" : "", win,
585             (draw >= 0) ? "+" : "", draw,
586             (loss >= 0) ? "+" : "", loss);
587     pprintf(p, "Your new RD will be %5.1f\n", newsterr);
588   }
589 }
590
591 static void check_lists_match(int p,int p1)
592 {
593   struct player *pp = &player_globals.parray[p];
594   if (in_list(p, L_COMPUTER, pp->name)) {
595     pprintf(p1, "--** %s is a ", pp->name);
596     pprintf_highlight(p1, "computer");
597     pprintf(p1, " **--\n");
598   }
599   if (in_list(p, L_COMPUTER, player_globals.parray[p1].name)) {
600     pprintf(p, "--** %s is a ", player_globals.parray[p1].name);
601     pprintf_highlight(p, "computer");
602     pprintf(p, " **--\n");
603   }
604   if (in_list(p, L_ABUSER, pp->name)) {
605     pprintf(p1, "--** %s is in the ", pp->name);
606     pprintf_highlight(p1, "abuser");
607     pprintf(p1, " list **--\n");
608   }
609   if (in_list(p, L_ABUSER, player_globals.parray[p1].name)) {
610     pprintf(p, "--** %s is in the ", player_globals.parray[p1].name);
611     pprintf_highlight(p, "abuser");
612     pprintf(p, " list **--\n");
613   }
614 }
615
616 int com_match(int p, param_list param)
617 {
618   struct player *pp = &player_globals.parray[p];
619   int adjourned;                /* adjourned game? */
620   int g;                        /* more adjourned game junk */
621   int p1;
622   int bh = 0, partner = 0, pp1 = 0;
623   struct pending* pendfrom;
624   struct pending* pendto;
625   struct pending* pend;
626   int wt = -1;                  /* white start time */
627   int winc = -1;                /* white increment */
628   int bt = -1;                  /* black start time */
629   int binc = -1;                /* black increment */
630   int rated = -1;               /* 1 = rated, 0 = unrated */
631   int white = -1;               /* 1 = want white, 0 = want black */
632   char category[100], board[100];
633   textlist *clauses = NULL;
634   int type = 0;
635
636   category[0] ='\0';
637   board[0] ='\0';
638
639   if ((pp->game >= 0) && ((game_globals.garray[pp->game].status == GAME_EXAMINE)
640 || (game_globals.garray[pp->game].status == GAME_SETUP))) {
641
642     pprintf(p, "You can't challenge while you are examining a game.\n");
643     return COM_OK;
644   }
645
646   if (pp->game >= 0) {
647     pprintf(p, "You can't challenge while you are playing a game.\n");
648     return COM_OK;
649   }
650
651   stolower(param[0].val.word);
652   p1 = player_find_part_login(param[0].val.word);
653   if (p1 < 0) {
654     pprintf(p, "No user named \"%s\" is logged in.\n", param[0].val.word);
655     return COM_OK;
656   }
657
658   if (p1 == p) {                /* Allowing to match yourself to enter
659                                    analysis mode */
660     ExamineScratch (p, param, 0);
661     return COM_OK;
662   }
663
664   if (!CheckPFlag(p1, PFLAG_OPEN)) {
665     pprintf(p, "Player \"%s\" is not open to match requests.\n", player_globals.parray[p1].name);
666     return COM_OK;
667   }
668
669   if (player_globals.parray[p1].game >= 0) {
670     pprintf(p, "Player \"%s\" is involved in another game.\n", player_globals.parray[p1].name);    return COM_OK;
671   }
672
673   if (CheckPFlag(p, PFLAG_TOURNEY) && !CheckPFlag(p1, PFLAG_TOURNEY)) {
674     pprintf(p, "You may only match players with their tournament variable set.\n");
675     return COM_OK;
676   }
677
678   if (!CheckPFlag(p, PFLAG_TOURNEY) && CheckPFlag(p1, PFLAG_TOURNEY)) {
679     pprintf(p, "%s is in a tournament, and cannot accept other challenges.\n", player_globals.parray[p1].name);
680     return COM_OK;
681   }
682
683   if (!CheckPFlag(p, PFLAG_OPEN)) {
684     PFlagON(p, PFLAG_OPEN);
685     pprintf(p, "Setting you open for matches.\n");
686   }
687
688
689 /* look for an adjourned game between p and p1 */
690   g = game_new();
691   adjourned = (game_read(g, p, p1) >= 0) || (game_read(g, p1, p) >= 0);
692   if (adjourned) {
693     type = game_globals.garray[g].type;
694     wt = game_globals.garray[g].wInitTime / 600;
695     bt = game_globals.garray[g].bInitTime / 600;
696     winc = game_globals.garray[g].wIncrement / 10;
697     binc = game_globals.garray[g].bIncrement / 10;
698     rated = game_globals.garray[g].rated;
699   }
700   game_remove(g);
701
702   pendto = find_pend(p, p1, PEND_MATCH);
703
704   pendfrom = find_pend(p1, p, PEND_MATCH);
705  
706   if (!adjourned) {
707     if (in_list(p1, L_NOPLAY, pp->login)) {
708       pprintf(p, "You are on %s's noplay list.\n", player_globals.parray[p1].name);
709       return COM_OK;
710     }
711     if (player_censored(p1, p)) {
712       pprintf(p, "Player \"%s\" is censoring you.\n", player_globals.parray[p1].name);
713       return COM_OK;
714     }
715     if (player_censored(p, p1)) {
716       pprintf(p, "You are censoring \"%s\".\n", player_globals.parray[p1].name);
717       return COM_OK;
718     }
719
720     if (param[1].type != TYPE_NULL) {
721       if (!parse_match_string(p, &wt,&bt,&winc,&binc,&white,&rated,category,
722                                                   board,param[1].val.string))
723       return COM_OK; /* couldn't parse */
724     }
725
726     if (rated == -1)
727       rated = BoolCheckPFlag(p, PFLAG_RATED);
728     if (!CheckPFlag(p, PFLAG_REG) || !CheckPFlag(p1, PFLAG_REG))
729       rated = 0;
730
731     if (winc == -1)
732       winc = (wt == -1) ? pp->d_inc : 0;  /* match 5 == match 5 0 */
733
734     if (wt == -1)
735       wt = pp->d_time;
736
737     if (bt == -1)
738       bt = wt;
739
740     if (binc == -1)
741       binc = winc;
742
743     if (category[0]) {
744       if (!board[0] && strcmp(category,"bughouse")) {
745         pprintf(p, "You must specify a board and a category.\n");
746         return COM_OK;
747
748       } else if (board[0]) { /* not bughouse */
749         char fname[MAX_FILENAME_SIZE];
750
751         sprintf(fname, "%s/%s/%s", BOARD_DIR, category, board);
752         if (!file_exists(fname)) {
753           pprintf(p, "No such category/board: %s/%s\n", category, board);
754           return COM_OK;
755         }
756       }
757     }
758     type = game_isblitz(wt, winc, bt, binc, category, board);
759
760     if (!strcmp(category, "bughouse")) {
761       type = TYPE_BUGHOUSE;
762       if (rated && pp->partner >= 0 && player_globals.parray[p1].partner >= 0) {
763         if (!CheckPFlag(pp->partner, PFLAG_REG)
764               || !CheckPFlag(player_globals.parray[p1].partner, PFLAG_REG))
765           rated = 0;
766       }
767     }
768     if (rated && (type == TYPE_NONSTANDARD)) {
769       pprintf(p, "Game is non-standard - reverting to unrated\n");
770       rated = 0;
771     }
772     if (rated && (type == TYPE_UNTIMED)) {
773       pprintf(p, "Game is untimed - reverting to unrated\n");
774       rated = 0;
775     }
776     if ((pendfrom == NULL) && !CheckPFlag(p1, PFLAG_ROPEN)
777         && (rated != BoolCheckPFlag(p1, PFLAG_RATED))) {
778       pprintf(p, "%s only wants to play %s games.\n", player_globals.parray[p1].name,
779               rstr[!rated]);
780       pprintf_highlight(p1, "Ignoring");
781       pprintf(p1, " %srated match request from %s.\n",
782               (rated ? "" : "un"), pp->name);
783       return COM_OK;
784     }
785
786     /* Now check formula. */
787     if (!adjourned
788         && !GameMatchesFormula(p,p1, wt,winc,bt,binc, rated, type, &clauses)) {
789       pprintf(p, "Match request does not fit formula for %s:\n",
790               player_globals.parray[p1].name);
791       pprintf(p, "%s's formula: %s\n", player_globals.parray[p1].name, player_globals.parray[p1].formula);
792       ShowClauses (p, p1, clauses);
793       ClearTextList(clauses);
794       pprintf_highlight(p1, "Ignoring");
795       pprintf_prompt(p1, " (formula): %s (%d) %s (%d) %s.\n",
796                      pp->name,
797                      GetRating(&player_globals.parray[p], type),
798                      player_globals.parray[p1].name,
799                      GetRating(&player_globals.parray[p1], type),
800             game_str(rated, wt * 60, winc, bt * 60, binc, category, board));
801       return COM_OK;
802     }
803
804     if (type == TYPE_BUGHOUSE) {
805       bh = 1;
806       partner = pp->partner;
807       pp1 = player_globals.parray[p1].partner;
808
809       if (pp < 0) {
810         pprintf(p, "You have no partner for bughouse.\n");
811         return COM_OK;
812       }
813       if (pp1 < 0) {
814         pprintf(p, "Your opponent has no partner for bughouse.\n");
815         return COM_OK;
816       }
817       if (partner == pp1) { /* should be an impossible case - DAV */
818         pprintf(p, "You and your opponent both chose the same partner!\n");
819         return COM_OK;
820       }
821       if (partner == p1 || pp1 == p) {
822         pprintf(p, "You and your opponent can't choose each other as partners!\n");
823         return COM_OK;
824       }
825       if (player_globals.parray[partner].partner != p) { /* another impossible case - DAV */
826         pprintf(p, "Your partner hasn't chosen you as his partner!\n");
827         return COM_OK;
828       }
829       if (player_globals.parray[pp1].partner != p1) { /* another impossible case - DAV */
830         pprintf(p, "Your opponent's partner hasn't chosen your opponent as his partner!\n");
831         return COM_OK;
832       }
833       if (!CheckPFlag(partner, PFLAG_OPEN) || player_globals.parray[partner].game >= 0) {
834         pprintf(p, "Your partner isn't open to play right now.\n");
835         return COM_OK;
836       }
837       if (!CheckPFlag(pp1, PFLAG_OPEN) || player_globals.parray[pp1].game >= 0) {
838         pprintf(p, "Your opponent's partner isn't open to play right now.\n");
839         return COM_OK;
840       }
841
842       /* Bypass NOPLAY lists, censored lists, ratedness, privacy, and formula for now */
843       /*  Active challenger/ee will determine these. */
844     }
845     /* Ok match offer will be made */
846
847   }                             /* adjourned games shouldn't have to worry
848                                    about that junk? */
849                                 /* keep incase of adjourned bughouse in future*/
850
851   if (pendto != NULL) {
852     pprintf(p, "Updating offer already made to \"%s\".\n", player_globals.parray[p1].name);
853   }
854
855   if (pendfrom != NULL) {
856     if (pendto != NULL) {
857       pprintf(p, "Pending list error!.\n");
858       d_printf( "CHESSD: This shouldn't happen. You can't have a match pending from and to the same person.\n");
859       return COM_OK;
860     }
861
862     if (adjourned || ((wt == pendfrom->btime) &&
863                       (winc == pendfrom->binc) &&
864                       (bt == pendfrom->wtime) &&
865                       (binc == pendfrom->winc) &&
866                       (rated == pendfrom->rated) &&
867                       ((white == -1) || (white + pendfrom->seek_color == 1)) &&
868                (!strcmp(category, pendfrom->category)) &&
869                  (!strcmp(board, pendfrom->board_type)))) {
870       /* Identical match, should accept! */
871       accept_match(pendfrom,p, p1);
872       return COM_OK;
873
874     } else {
875       delete_pending(pendfrom);
876     }
877   }
878
879   if (pendto == NULL)
880     pend = add_pending(p,p1,PEND_MATCH);
881   else
882     pend = pendto; 
883
884   pend->wtime = wt;
885   pend->winc = winc;
886   pend->btime = bt;
887   pend->binc = binc;
888   pend->rated = rated;
889   pend->seek_color = white;
890   pend->game_type = type;
891   pend->category = strdup(category);
892   pend->board_type = strdup (board);
893
894   if (pendfrom != NULL) {
895     pprintf(p, "Declining offer from %s and offering new match parameters.\n", player_globals.parray[p1].name);
896     pprintf(p1, "\n%s declines your match offer a match with these parameters:", pp->name);
897   }
898
899   if (pendto != NULL) {
900     pprintf(p, "Updating match request to: ");
901     pprintf(p1, "\n%s updates the match request.\n", pp->name);
902   } else {
903     pprintf(p, "Issuing: ");
904     pprintf(p1, "\n");
905   }
906
907   pprintf(p, "%s (%s) %s", pp->name,
908           ratstrii(GetRating(&player_globals.parray[p], type), p),
909           colorstr[white + 1]);
910   pprintf_highlight(p, "%s", player_globals.parray[p1].name);
911   pprintf(p, " (%s) %s%s.\n",
912           ratstrii(GetRating(&player_globals.parray[p1], type), p1),
913           game_str(rated, wt * 60, winc, bt * 60, binc, category, board),
914           adjustr[adjourned]);
915   pprintf(p1, "Challenge: ");
916   pprintf_highlight(p1, "%s", pp->name);
917   pprintf(p1, " (%s) %s",
918           ratstrii(GetRating(&player_globals.parray[p], type), p),
919           colorstr[white + 1]);
920   pprintf(p1, "%s (%s) %s%s.\n", player_globals.parray[p1].name,
921           ratstrii(GetRating(&player_globals.parray[p1], type), p1),
922           game_str(rated, wt * 60, winc, bt * 60, binc, category, board),
923           adjustr[adjourned]);
924   Bell (p1);
925
926   if (bh) {
927
928     pprintf(partner, "\nYour bughouse partner issuing %s (%s) %s",
929             pp->name, ratstrii(GetRating(&player_globals.parray[p], type), p),
930             colorstr[white + 1]);
931     pprintf_highlight(partner, "%s", player_globals.parray[p1].name);
932     pprintf(partner, " (%s) %s.\n",
933             ratstrii(GetRating(&player_globals.parray[p1], type), p1),
934             game_str(rated, wt * 60, winc, bt * 60, binc, category, board));
935     pprintf(partner, "Your game would be ");
936     pprintf_highlight(partner, "%s", player_globals.parray[pp1].name);
937     pprintf_prompt(partner, " (%s) %s%s (%s) %s.\n",
938           ratstrii(GetRating(&player_globals.parray[pp1], type), pp1),
939           colorstr[white + 1], player_globals.parray[partner].name,
940           ratstrii(GetRating(&player_globals.parray[partner], type), partner),
941           game_str(rated, wt * 60, winc, bt * 60, binc, category, board));
942     Bell (partner);
943
944     pprintf(pp1, "\nYour bughouse partner was challenged ");
945     pprintf_highlight(pp1, "%s", pp->name);
946     pprintf(pp1, " (%s) %s", ratstrii(GetRating(&player_globals.parray[p], type), p),
947                              colorstr[white + 1]);
948     pprintf(pp1, "%s (%s) %s.\n", player_globals.parray[p1].name,
949             ratstrii(GetRating(&player_globals.parray[p1], type), p1),
950             game_str(rated, wt * 60, winc, bt * 60, binc, category, board));
951     pprintf(pp1, "Your game would be %s (%s) %s", player_globals.parray[pp1].name,
952           ratstrii(GetRating(&player_globals.parray[pp1], type), pp1),
953           colorstr[white + 1]);
954     pprintf_highlight(pp1, "%s", player_globals.parray[partner].name);
955     pprintf_prompt(pp1, " (%s) %s.\n",
956           ratstrii(GetRating(&player_globals.parray[partner], type), partner),
957           game_str(rated, wt * 60, winc, bt * 60, binc, category, board));
958     Bell(pp1);
959   }
960
961   check_lists_match (p,p1);
962
963   print_match_rating_info (p,p1,type,rated);
964
965   pprintf_prompt(p1, "You can \"accept\" or \"decline\", or propose different parameters.\n");
966
967   return COM_OK;
968 }
969
970
971 /*
972   rmatch is used by mamer to start matches in tournaments
973 */
974 int com_rmatch(int p, param_list param)
975 {
976         struct player *pp = &player_globals.parray[p];
977         int p1, p2;
978
979         if (!in_list(p, L_TD, pp->name)) {
980                 pprintf(p, "Only TD programs are allowed to use this command.\n");
981                 return COM_OK;
982         }
983
984         if ((p1 = player_find_bylogin(param[0].val.word)) < 0 || 
985             !CheckPFlag(p1, PFLAG_REG)) {
986                 /* can't rmatch this user ... */
987                 return COM_OK;
988         }
989
990         if ((p2 = player_find_bylogin(param[1].val.word)) < 0 || 
991             !CheckPFlag(p2, PFLAG_REG)) {
992                 /* can't rmatch this user ... */
993                 return COM_OK;
994         }
995
996         return pcommand(p1, "match %s %s", param[1].val.word, param[2].val.string);
997 }