Hack to bypass timeseal decoder
[capablanca.git] / lasker-2.2.3 / src / pending.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   pending.c
19
20   Sat Feb 10 - created - DAV
21
22 */
23 #include "includes.h"
24
25 extern const char *colorstr[];
26
27 /* iterator for player p */
28 static struct pending* next_pending(struct pending* current)
29 {
30
31  if (current == NULL) {
32    d_printf("NULL pointer passed to next_pending\n");
33    return NULL;
34  } else return current->next;
35 }
36  
37 /* deletor for pending - returns next item*/
38 struct pending *delete_pending(struct pending *current)
39 {
40         struct pending *p;
41
42         if (current == NULL) { 
43                 d_printf("NULL pointer passed to delete_pending\n");
44                 return NULL;
45         }
46  
47         player_globals.parray[current->whofrom].number_pend_from--;
48         player_globals.parray[current->whoto].number_pend_to--;
49
50         if (current->category != NULL) {
51                 free(current->category);
52         }
53         if (current->board_type != NULL) {
54                 free(current->board_type);
55         }
56         
57         if (current == seek_globals.pendlist) {
58                 seek_globals.pendlist = current->next;
59                 free(current);
60                 return seek_globals.pendlist;
61         }
62
63         for (p=seek_globals.pendlist; p && p->next != current; p=p->next) ;
64
65         if (!p) {
66                 d_printf("current not on pending list??");
67                 return NULL;
68         }
69
70         p->next = current->next;
71         free(current);
72         return p->next;
73 }
74
75 /* kills the whole pending list on shutdown */
76 void destruct_pending(void)
77 {
78         struct pending* current = seek_globals.pendlist;
79         
80         while (current != NULL)
81                 current = delete_pending(current); 
82
83
84 struct pending *add_pending(int from,int to,int type)
85 {
86         struct pending* new = (struct pending*) malloc(sizeof(struct pending));
87
88         new->whofrom = from;
89         new->whoto = to;
90         new->type = type;
91         new->next = seek_globals.pendlist;
92         new->category = NULL;
93         new->board_type = NULL;
94         
95         player_globals.parray[from].number_pend_from++;
96         player_globals.parray[to].number_pend_to++;
97         
98         seek_globals.pendlist = new;
99
100         return new;
101 }
102
103 static int check_current_pend(struct pending* current, int p, int p1, int type)
104 {
105     if ((p != -1) && ((current->whofrom) != p))
106       return 0;
107     if (current->whoto != p1 && p1 != -1)
108       return 0;
109     if ((type == PEND_ALL) || (current->type == type))
110       return 1;
111     if ((type < 0) && (current->type != -type))
112       return 1;
113 /* The above "if" allows a type of -PEND_SIMUL to match every request
114     EXCEPT simuls, for example.  I'm doing this because Heringer does
115     not want to decline simul requests when he makes a move in a sumul.
116     -- hersco. */
117
118     return 0;
119 }
120
121 /* from p to p1 */
122 struct pending *find_pend(int p, int p1, int type)
123 {
124         struct player *pp = &player_globals.parray[p];
125         /* -ve type can be used to decline all but that type */
126         struct pending* current = seek_globals.pendlist;
127         
128         if (((p != -1) && (!pp->number_pend_from)) || 
129             ((p1 != -1) && (!player_globals.parray[p1].number_pend_to)))
130                 return NULL;
131         
132         while (current != NULL) {
133                 if (check_current_pend(current,p,p1, type))
134                         return current;
135                 current = next_pending(current);
136         }
137         return NULL;
138 }
139
140 /* from p to p1 */
141 struct pending *add_request(int p, int p1, int type)
142 {
143         struct player *pp = &player_globals.parray[p];
144         struct pending* new = NULL;
145
146         if ((pp->number_pend_from) && 
147             (player_globals.parray[p1].number_pend_to)) {
148                 if ((new = find_pend(p, p1, type)) != NULL)
149                         return new;                  /* Already exists */
150         }
151
152         if ((new = add_pending(p,p1,type)) == NULL)
153                 return NULL;
154         return new;
155 }
156
157 /* removes all requests from p to p1 */
158 void remove_request(int p, int p1, int type)
159 {
160         struct pending* next;
161         struct pending* current = seek_globals.pendlist;
162
163         while (current != NULL) {
164                 next = next_pending(current);
165                 if (check_current_pend(current,p,p1,type))
166                         delete_pending(current);
167                 current = next;
168         }
169 }
170
171 /* made into 1 functions for speed */
172
173 /* decline offers to p and withdraw offers from p */
174 static void do_decline_withdraw_offers(int p,int p1, int offers, int partners, int wd)
175 {
176   struct player *pp = &player_globals.parray[p];
177   struct pending* offer = seek_globals.pendlist;
178   int type, p2;
179   char *pName = pp->name, *p2Name;
180   int decline;
181
182   if ((wd & DO_DECLINE) && (wd & DO_WITHDRAW)) { /* cut search times */
183     if (((p != -1)  && (!pp->number_pend_to)
184                     && (!pp->number_pend_from))
185         || ((p1 != -1) && (!player_globals.parray[p1].number_pend_to)
186                        && (!player_globals.parray[p1].number_pend_from)))
187       return;
188   }
189
190   if ((wd & DO_DECLINE) && (!(wd & DO_WITHDRAW))) { /* cut search times */
191     if (((p != -1) && (!pp->number_pend_to)) ||
192       ((p1 != -1) && (!player_globals.parray[p1].number_pend_from)))
193       return;
194   }
195
196   if ((!(wd & DO_DECLINE)) && (wd & DO_WITHDRAW)) { /* cut search times */
197     if (((p != -1) && (!pp->number_pend_from)) ||
198       ((p1 != -1) && (!player_globals.parray[p1].number_pend_to)))
199       return;
200   }
201
202   while (offer != NULL) {
203
204     decline = 0;
205     if ((wd & DO_DECLINE) && (check_current_pend(offer, p1, p, offers))) {
206       p2 = offer->whofrom;
207       decline = 1;
208     } else if ((wd & DO_WITHDRAW) && (check_current_pend(offer,p, p1, offers))) {
209       p2 = offer->whoto;
210     } else {
211       offer = offer->next;
212       continue;
213     }
214     
215     type = offer->type;
216     p2Name = player_globals.parray[p2].name;
217
218     switch (type) {
219       case PEND_MATCH:
220         if (partners) {
221           if (offer->game_type != TYPE_BUGHOUSE) {
222             offer = offer->next;
223             continue;
224           } else if (decline) {
225             if (offer->whoto == p) {
226               pprintf(p,
227                 "Either your opponent's partner or your partner has joined another match.\n");
228               pprintf_prompt(p,
229                 "Removing the bughouse offer from %s.\n",
230                 p2Name);
231
232               pprintf(p2,
233                 "Either your opponent's partner or your partner has joined another match.\n");
234               pprintf_prompt(p2,
235                 "Removing the bughouse offer to %s.\n",
236                 pName);
237
238             } else {
239               pprintf_prompt(p,
240                 "Your partner declines the bughouse offer from %s.\n",
241                 p2Name);
242               pprintf_prompt(p2,
243                 "%s declines the bughouse offer from your partner.\n",
244                 pName);
245             }
246
247           } else {
248             if (offer->whofrom == p) {
249               pprintf(p,
250                 "Either your opponent's partner or your partner has joined another match.\n");
251               pprintf_prompt(p,
252                 "Removing the bughouse offer to %s.\n",
253                 p2Name);
254
255               pprintf(p2,
256                 "Either your opponent's partner or your partner has joined another match.\n");
257               pprintf_prompt(p2,
258                 "Removing the bughouse offer from %s.\n",
259                 pName);
260
261             } else {
262               pprintf_prompt(p,
263                 "Your partner withdraws the bughouse offer to %s.\n",
264                 p2Name);
265               pprintf_prompt(p2,
266                 "%s withdraws the bughouse offer to your partner.\n",
267                 pName);
268             }
269           }
270         } else {
271
272           if (decline) {
273             pprintf_prompt(p2, "\n%s declines the match offer.\n", pName);
274             pprintf(p, "You decline the match offer from %s.\n", p2Name);
275           } else {
276             pprintf_prompt(p2, "\n%s withdraws the match offer.\n", pName);
277             pprintf(p, "You withdraw the match offer to %s.\n", p2Name);
278           }
279         }
280         break;
281       case PEND_DRAW:
282         if (decline) {
283           pprintf_prompt(p2, "\n%s declines draw request.\n", pName);
284           pprintf(p, "You decline the draw request from %s.\n", p2Name);
285         } else {
286           pprintf_prompt(p2, "\n%s withdraws draw request.\n", pName);
287           pprintf(p, "You withdraw the draw request to %s.\n", p2Name);
288         }
289         break;
290
291       case PEND_PAUSE:
292         if (decline) {
293           pprintf_prompt(p2, "\n%s declines pause request.\n", pName);
294           pprintf(p, "You decline the pause request from %s.\n", p2Name);
295         } else {
296           pprintf_prompt(p2, "\n%s withdraws pause request.\n", pName);
297           pprintf(p, "You withdraw the pause request to %s.\n", p2Name);
298         }
299         break;
300
301       case PEND_UNPAUSE:
302         if (decline) {
303           pprintf_prompt(p2, "\n%s declines unpause request.\n", pName);
304           pprintf(p, "You decline the unpause request from %s.\n", p2Name);
305         } else {
306           pprintf_prompt(p2, "\n%s withdraws unpause request.\n", pName);
307           pprintf(p, "You withdraw the unpause request to %s.\n", p2Name);
308         }
309         break;
310
311       case PEND_ABORT:
312         if (decline) {
313           pprintf_prompt(p2, "\n%s declines abort request.\n", pName);
314           pprintf(p, "You decline the abort request from %s.\n", p2Name);
315         } else {
316           pprintf_prompt(p2, "\n%s withdraws abort request.\n", pName);
317           pprintf(p, "You withdraw the abort request to %s.\n", p2Name);
318         }
319         break;
320
321       case PEND_TAKEBACK:
322         if (decline) {
323           pprintf_prompt(p2, "\n%s declines the takeback request.\n", pName);
324           pprintf(p, "You decline the takeback request from %s.\n", p2Name);
325         } else {
326           pprintf_prompt(p2, "\n%s withdraws the takeback request.\n", pName);
327           pprintf(p, "You withdraw the takeback request to %s.\n", p2Name);
328         }
329         break;
330
331       case PEND_ADJOURN:
332         if (decline) {
333           pprintf_prompt(p2, "\n%s declines the adjourn request.\n", pName);
334           pprintf(p, "You decline the adjourn request from %s.\n", p2Name);
335         } else {
336           pprintf_prompt(p2, "\n%s withdraws the adjourn request.\n", pName);
337           pprintf(p, "You withdraw the adjourn request to %s.\n", p2Name);
338         }
339         break;
340
341       case PEND_SWITCH:
342         if (decline) {
343           pprintf_prompt(p2, "\n%s declines the switch sides request.\n", pName);
344           pprintf(p, "You decline the switch sides request from %s.\n", p2Name);
345         } else {
346           pprintf_prompt(p2, "\n%s withdraws the switch sides request.\n", pName);
347           pprintf(p, "You withdraw the switch sides request to %s.\n", p2Name);
348         }
349         break;
350
351       case PEND_SIMUL:
352         if (decline) {
353           pprintf_prompt(p2, "\n%s declines the simul offer.\n", pName);
354           pprintf(p, "You decline the simul offer from %s.\n", p2Name);
355         } else { 
356           pprintf_prompt(p2, "\n%s withdraws the simul offer.\n", pName);
357           pprintf(p, "You withdraw the simul offer to %s.\n", p2Name);
358         }
359         break;
360
361       case PEND_PARTNER:
362         if (decline) {
363           pprintf_prompt(p2, "\n%s declines your partnership request.\n", pName);
364           pprintf(p, "You decline the partnership request from %s.\n", p2Name);
365         } else {
366           pprintf_prompt(p2, "\n%s withdraws partnership request.\n", pName);
367           pprintf(p, "You withdraw the partnership request to %s.\n", p2Name);
368         }
369         break;
370     }
371     offer = delete_pending(offer);
372   }
373 }
374
375 /* wd is DO_DECLINE to decline DO_WITHDRAW to withdraw  and both for mutual */
376 void decline_withdraw_offers(int p, int p1, int offerType,int wd)
377 {
378   struct player *pp = &player_globals.parray[p];
379   /* First get rid of bughouse offers from partner. */
380   /* last param in if is a safety check - shouldn't happen */
381
382  int partner;
383
384   if (p1 == -1)
385     partner = -1;
386   else
387     partner = player_globals.parray[p1].partner;
388
389   if ((offerType == PEND_MATCH || offerType == PEND_ALL)
390       && pp->partner >= 0 && player_globals.parray[pp->partner].partner == p)
391     do_decline_withdraw_offers(pp->partner, partner , PEND_MATCH,1,wd);
392
393
394   do_decline_withdraw_offers(p, p1, offerType,0,wd);
395 }
396
397 /* find nth offer from p */
398 static struct pending* find_nth_pendfrom(int p,int num)
399 {
400   struct pending* current = seek_globals.pendlist;
401
402   while (num) {
403     if (check_current_pend(current,p,-1,PEND_ALL))
404       num--;
405     if (num > 0)
406       current = next_pending(current);
407   }
408   return current;
409 }
410
411 /* find nth offer to p */
412 static struct pending* find_nth_pendto(int p,int num)
413 {
414   struct pending* current = seek_globals.pendlist;
415
416   while (num) {
417     if (check_current_pend(current,-1,p,PEND_ALL))
418       num--;
419     if (num > 0)
420       current = next_pending(current);
421   }
422   return current;
423 }
424
425 static int WordToOffer (int p, char *Word, int *type, int *p1)
426 {
427   /* Convert draw adjourn match takeback abort pause
428      simmatch switch partner or <name> to offer type. */
429   *p1 = -1;
430   if (!strcmp(Word, "match")) {
431     *type = PEND_MATCH;
432   } else if (!strcmp(Word, "draw")) {
433     *type = PEND_DRAW;
434   } else if (!strcmp(Word, "pause")) {
435     *type = PEND_PAUSE;
436   } else if (!strcmp(Word, "unpause")) {
437     *type = PEND_UNPAUSE;
438   } else if (!strcmp(Word, "abort")) {
439     *type = PEND_ABORT;
440   } else if (!strcmp(Word, "takeback")) {
441     *type = PEND_TAKEBACK;
442   } else if (!strcmp(Word, "adjourn")) {
443     *type = PEND_ADJOURN;
444   } else if (!strcmp(Word, "switch")) {
445     *type = PEND_SWITCH;
446   } else if (!strcmp(Word, "simul")) {
447     *type = PEND_SIMUL;
448   } else if (!strcmp(Word, "partner")) {
449     *type = PEND_PARTNER;
450   } else if (!strcmp(Word, "all")) {
451   } else {
452     *p1 = player_find_part_login(Word);
453     if (*p1 < 0) {
454       pprintf(p, "No user named \"%s\" is logged in.\n", Word);
455       return 0;
456     }
457   }
458   return 1;
459 }
460
461 int com_accept(int p, param_list param)
462 {
463   struct player *pp = &player_globals.parray[p];
464   int type = -1;
465   int p1;
466   int number; 
467   struct pending* current = NULL;
468
469   if (!(number = pp->number_pend_to)) {
470     pprintf(p, "You have no offers to accept.\n");
471     return COM_OK;
472   }
473
474   if (param[0].type == TYPE_NULL) {
475     if (number != 1) {
476       pprintf(p, "You have more than one offer to accept.\nUse \"pending\" to see them and \"accept n\" to choose which one.\n");
477       return COM_OK;
478     }
479     current = find_pend(-1,p,PEND_ALL);
480
481   } else if (param[0].type == TYPE_INT) {
482     if ((param[0].val.integer < 1) || (param[0].val.integer > number)) {
483       pprintf(p, "Out of range. Use \"pending\" to see the list of offers.\n");
484       return COM_OK;
485     }
486
487     current = find_nth_pendto(p,param[0].val.integer);
488
489   } else if (param[0].type == TYPE_WORD) {
490     if (!WordToOffer (p,param[0].val.word,&type,&p1))
491       return COM_OK;
492     if ((p1 < 0) && ((current = find_pend(-1, p, type)) == NULL)) {
493       pprintf(p, "There are no pending %s offers.\n", param[0].val.word);
494       return COM_OK;
495     } else if ((p1 >= 0) && (current = find_pend(p1, p, PEND_ALL)) == NULL) {
496       pprintf(p, "There are no pending offers from %s.\n", player_globals.parray[p1].name);
497       return COM_OK;
498     }
499   }
500
501   switch (current->type) {
502     case PEND_MATCH:
503       accept_match(current, p, current->whofrom);
504       return (COM_OK);
505       break;
506     case PEND_DRAW:
507       pcommand(p, "draw");
508       break;
509     case PEND_PAUSE:
510       pcommand(p, "pause");
511       break;
512     case PEND_UNPAUSE:
513       pcommand(p, "unpause");
514       break;
515     case PEND_ABORT:
516       pcommand(p, "abort");
517       break;
518     case PEND_TAKEBACK:
519       pcommand(p, "takeback %d", current->wtime);
520       break;
521     case PEND_SIMUL:
522       pcommand(p, "simmatch %s", player_globals.parray[current->whofrom].name);
523       break;
524     case PEND_SWITCH:
525       pcommand(p, "switch");
526       break;
527     case PEND_ADJOURN:
528       pcommand(p, "adjourn");
529       break;
530     case PEND_PARTNER:
531       pcommand(p, "partner %s", player_globals.parray[current->whofrom].name);
532       break;
533   }
534   return COM_OK_NOPROMPT;
535 }
536
537 static int com_decline_withdraw(int p, param_list param,int wd)
538 {
539   struct player *pp = &player_globals.parray[p];
540   int type = -1;
541   int p1;
542   int number;
543   struct pending* current = seek_globals.pendlist;
544
545   if (wd & DO_DECLINE) {
546     if (!(number = pp->number_pend_to)) {
547       pprintf(p, "You have no pending offers from other players.\n");
548       return COM_OK;
549     }
550   } else {
551     if (!(number = pp->number_pend_from)) {
552       pprintf(p, "You have no pending offers to other players.\n");
553       return COM_OK;
554     }
555   }
556
557
558   if (param[0].type == TYPE_NULL) {
559     if (number == 1) {
560       if (wd & DO_DECLINE) {
561         current = find_pend(-1,p,PEND_ALL);
562         p1 = current->whofrom;
563       } else {
564         current = find_pend(p,-1,PEND_ALL);
565         p1 = current->whoto;
566       }
567        type = current->type;
568     } else { 
569       if (wd & DO_DECLINE)
570         pprintf(p, "You have more than one pending offer.\nUse \"pending\" to see them and \"decline n\" to choose which one.\n");
571       else 
572         pprintf(p, "You have more than one pending offer.\nUse \"pending\" to see them and \"withdraw n\" to choose which one.\n");
573       return COM_OK;
574     }
575
576   } else if (param[0].type == TYPE_INT) {
577     if ((param[0].val.integer < 1) || (param[0].val.integer > number)) {
578       pprintf(p, "Out of range. Use \"pending\" to see the list of offers.\n");
579       return COM_OK;
580     }
581     if (wd & DO_DECLINE) {
582       current = find_nth_pendto(p,param[0].val.integer);
583       p1 = current->whofrom;
584     } else {
585       current = find_nth_pendfrom(p,param[0].val.integer);
586       p1 = current->whoto;
587     }
588     type = current->type;
589
590   } else if (!WordToOffer (p, param[0].val.word, &type, &p1))
591     return COM_OK;
592
593   decline_withdraw_offers(p, p1, type,wd);
594   return COM_OK;
595 }
596
597 int com_decline(int p, param_list param)
598 {
599  return com_decline_withdraw(p,param,DO_DECLINE);
600 }
601
602 int com_withdraw(int p, param_list param)
603 {
604  return com_decline_withdraw(p,param,DO_WITHDRAW);
605 }
606
607 static void pend_print(int p, struct pending *pend)
608 {
609
610   if (p == pend->whofrom) {
611     pprintf(p, "You are offering %s ", player_globals.parray[pend->whoto].name);
612   } else {
613     pprintf(p, "%s is offering ", player_globals.parray[pend->whofrom].name);
614   }
615
616   switch (pend->type) {
617   case PEND_MATCH:
618     pprintf(p, "a challenge: %s (%s) %s%s (%s) %s.\n",
619           player_globals.parray[pend->whofrom].name,
620           ratstrii(GetRating(&player_globals.parray[pend->whofrom], pend->game_type),
621                    pend->whofrom),
622           colorstr[pend->seek_color + 1], 
623           player_globals.parray[pend->whoto].name,
624           ratstrii(GetRating(&player_globals.parray[pend->whoto], pend->game_type),
625                    pend->whoto),
626           game_str(pend->rated, pend->wtime * 60, pend->winc,
627                    pend->btime * 60, pend->binc, pend->category, pend->board_type));
628     break;
629   case PEND_DRAW:
630     pprintf(p, "a draw.\n");
631     break;
632   case PEND_PAUSE:
633     pprintf(p, "to pause the clock.\n");
634     break;
635   case PEND_UNPAUSE:
636     pprintf(p, "to unpause the clock.\n");
637     break;
638   case PEND_ABORT:
639     pprintf(p, "to abort the game.\n");
640     break;
641   case PEND_TAKEBACK:
642     pprintf(p, "to takeback the last %d half moves.\n", pend->wtime);
643     break;
644   case PEND_SIMUL:
645     pprintf(p, "to play a simul match.\n");
646     break;
647   case PEND_SWITCH:
648     pprintf(p, "to switch sides.\n");
649     break;
650   case PEND_ADJOURN:
651     pprintf(p, "an adjournment.\n");
652     break;
653   case PEND_PARTNER:
654     pprintf(p, "to be bughouse partners.\n");
655     break;
656   }
657 }
658
659 int com_pending(int p, param_list param)
660 {
661   struct player *pp = &player_globals.parray[p];
662   struct pending* current = seek_globals.pendlist;
663   int num = 0;
664   int num2 = 0; 
665   int total = 0;
666
667   if ((total = pp->number_pend_from)) {
668     while ((current != NULL) && (num != total)) {
669       if (check_current_pend(current,p,-1,PEND_ALL)) {
670         if (!num)
671           pprintf(p, "Offers TO other players:\n");
672         num++;
673         pprintf(p, " %d: ",num);
674         pend_print(p, current); 
675       }
676       current = next_pending(current);
677     }
678     pprintf(p, "\nIf you wish to withdraw any of these offers type 'withdraw n'\nor just 'withdraw' if there is only one offer.\n\n");
679   } else
680     pprintf(p, "There are no offers pending TO other players.\n\n");
681
682   current = seek_globals.pendlist;
683
684   if ((total = pp->number_pend_to)) {
685     while ((current != NULL) && (num2 != total)) {
686       if (check_current_pend(current,-1,p,PEND_ALL)) {
687         if (!num2)
688           pprintf(p, "Offers FROM other players:\n");
689         num2++;
690         pprintf(p, " %d: ",num2);
691         pend_print(p, current);
692       }
693       current = next_pending(current);
694     }
695     pprintf(p, "\nIf you wish to accept any of these offers type 'accept n'\nor just 'accept' if there is only one offer.\n");
696   } else 
697     pprintf(p, "There are no offers pending FROM other players.\n");
698
699   return COM_OK;
700 }
701
702 void pend_join_match (int p, int p1)
703 {
704   struct player *pp = &player_globals.parray[p];
705   struct pending* current;
706   struct pending* next = seek_globals.pendlist; 
707
708   if ((pp->number_pend_from == 0) && (pp->number_pend_to == 0)
709       && (player_globals.parray[p1].number_pend_from == 0) && (player_globals.parray[p1].number_pend_to == 0))
710     return;
711
712   while (next != NULL) {
713     current = next;
714     next = next_pending(current);
715     if (check_current_pend(current,p,-1,-PEND_PARTNER)) {
716       pprintf_prompt(current->whoto, "\n%s, who was challenging you, has joined a match with %s.\n", pp->name, player_globals.parray[p1].name); 
717       pprintf(p, "Challenge to %s withdrawn.\n", player_globals.parray[current->whoto].name);
718       delete_pending(current);
719       continue;
720     }
721
722     if (check_current_pend(current,p1,-1,-PEND_PARTNER)) {
723       pprintf_prompt(current->whoto, "\n%s, who was challenging you, has joined a match with %s.\n", player_globals.parray[p1].name, pp->name);
724       pprintf(p1, "Challenge to %s withdrawn.\n", player_globals.parray[current->whoto].name);
725       delete_pending(current);
726       continue;
727     }
728
729     if (check_current_pend(current,-1,p,-PEND_PARTNER)) {
730       pprintf_prompt(current->whofrom, "\n%s, whom you were challenging, has joined a match with %s.\n", pp->name, player_globals.parray[p1].name);
731       pprintf(p, "Challenge from %s removed.\n", player_globals.parray[current->whofrom].name);
732       delete_pending(current);
733       continue;
734     }
735
736     if (check_current_pend(current,-1,p1,-PEND_PARTNER)) {
737       pprintf_prompt(current->whofrom, "\n%s, whom you were challenging, has joined a match with %s.\n", player_globals.parray[p1].name, pp->name);
738       pprintf(p1, "Challenge from %s removed.\n",
739               player_globals.parray[current->whofrom].name);
740       delete_pending(current);
741       continue;
742     }
743   }
744 }