d0434450a3cbe6979021a95d9ed03fd38a6b627d
[capablanca.git] / algcheck.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
22 #include "includes.h"
23
24 /* Well, lets see if I can list the possibilities
25  * Piece moves
26  * Ne4
27  * Nxe4
28  * Nce4
29  * Ncxe4
30  * R2f3
31  * R2xf3
32  * Special pawn moves
33  * e4
34  * ed
35  * exd
36  * exd5
37  * ed5
38  * Drop moves (bughouse, board edit)
39  * P@f7 P*f7
40  * #f7 #Nf7
41  * (o-o, o-o-o) Castling is handled earlier, so don't worry about that
42  * Of course any of these can have a + or ++ or = string on the end, just
43  * cut that off.
44  */
45
46 /* f - file
47  * r - rank
48  * p - piece
49  * x - x
50  * @ - drop character (bughouse)
51  */
52 static char *alg_list[] = {
53   "fxfr", "pxfr",               /* These two get confused in case of bishop */
54   "ffr", "pfr",                 /* These two get confused in case of bishop */
55   "pffr",
56   "pfxfr",
57   "prfr",
58   "prxfr",
59   "fr",
60   "ff",
61   "fxf",
62   "p@fr",
63   "#fr",
64   "#pfr",
65   NULL
66 };
67
68 #define ALG_UNKNOWN -1
69
70 static int get_move_info(const char *str, int *piece, int *ff, int *fr, int *tf, int *tr, int *bishconfusion)
71 {
72   char tmp[1024];
73   char *s;
74   int i, j, len;
75   char c;
76   int matchVal = -1;
77   int lpiece, lff, lfr, ltf, ltr;
78
79   *bishconfusion = 0;
80   strlcpy(tmp, str, sizeof(tmp));
81   if ((s = strchr(tmp, '+'))) { /* Cut off any check marks */
82     *s = '\0';
83   }
84   if ((s = strchr(tmp, '='))) { /* Cut off any promotion marks */
85     *s = '\0';
86   }
87   if ((s = strchr(tmp, '#'))) { /* Cut off any 'mates' marks */
88     *s = '\0';
89   }
90   *piece = *ff = *fr = *tf = *tr = ALG_UNKNOWN;
91   len = strlen(tmp);
92   for (i = 0; alg_list[i]; i++) {
93     lpiece = lff = lfr = ltf = ltr = ALG_UNKNOWN;
94     if (strlen(alg_list[i]) != len)
95       continue;
96     for (j = len - 1; j >= 0; j--) {
97       switch (alg_list[i][j]) {
98       case 'f':
99         if ((tmp[j] < 'a') || (tmp[j] > 'l')) // [HGM] upto l-file
100           goto nomatch;
101         if (ltf == ALG_UNKNOWN)
102           ltf = tmp[j] - 'a';
103         else
104           lff = tmp[j] - 'a';
105         break;
106       case 'r':
107         if ((tmp[j] < '0') || (tmp[j] > '9')) // [HGM] also match 0- and 9-rank
108           goto nomatch;
109         if (ltr == ALG_UNKNOWN)\r
110           ltr = tmp[j] - '0'; // [HGM] allow 0-rank for Xiangqi, correct later\r
111         else\r
112           lfr = tmp[j] - '0';
113         break;
114       case 'p':
115         if (isupper(tmp[j]))
116           c = tolower(tmp[j]);
117         else
118           c = tmp[j];
119         if (c == 'k')
120           lpiece = KING;
121         else if (c == 'e')   // [HGM] note that som piece indicators are ambiguous,
122           lpiece = ELEPHANT; //       and their true meaning depends on the variant,
123         else if (c == 'v')   //       which we do not know at this point.
124           lpiece = CENTAUR;
125         else if (c == 's')
126           lpiece = SILVER;
127         else if (c == 'g')
128           lpiece = GOLD;
129         else if (c == 'l')
130           lpiece = LANCE;
131         else if (c == 'f')
132           lpiece = FERZ;
133         else if (c == 'h')
134           lpiece = HORSE;
135         else if (c == 'w')
136           lpiece = WAZIR;
137         else if (c == 'o')
138           lpiece = SQUIRREL;
139         else if (c == 'q')
140           lpiece = QUEEN;
141         else if (c == 'c')
142           lpiece = MARSHALL;
143         else if (c == 'a')
144           lpiece = CARDINAL;
145         else if (c == 'm')
146           lpiece = MAN;
147         else if (c == 'r')
148           lpiece = ROOK;
149         else if (c == 'b')
150           lpiece = BISHOP;
151         else if (c == 'n')
152           lpiece = KNIGHT;
153         else if (c == 'p')
154           lpiece = PAWN;
155         else
156           goto nomatch;
157         break;
158       case 'x':
159         if ((tmp[j] != 'x') && (tmp[j] != 'X'))
160           goto nomatch;
161         break;
162       case '@':
163         if (tmp[j] != '@' && tmp[j] != '*')
164           goto nomatch;
165         lff = lfr = ALG_DROP;
166         break;
167       case '#':
168         if (tmp[j] != '#')
169           goto nomatch;
170         lff = lfr = ALG_DROP;
171         break;
172       default:
173         d_printf( "Unknown character in algebraic parsing\n");
174         break;
175       }
176     }
177     if (lpiece == ALG_UNKNOWN)
178       lpiece = PAWN;
179     if (lpiece == PAWN && (lfr == ALG_UNKNOWN)) {       /* ffr or ff */
180       if (lff != ALG_UNKNOWN) {
181         if (lff == ltf)
182           goto nomatch;
183         if ((lff - ltf != 1) && (ltf - lff != 1))
184           goto nomatch;
185       }
186     }
187     *piece = lpiece;            /* We have a match */
188     *tf = ltf;
189     *tr = ltr;
190     *ff = lff;
191     *fr = lfr;
192     if (matchVal != -1) {
193       /* We have two matches, it must be that Bxc4 vs. bxc4 problem */
194       /* Or it could be the Bc4 vs bc4 problem */
195       *bishconfusion = 1;
196     }
197     matchVal = i;
198 nomatch:;
199   }
200   if (matchVal != -1)
201     return MS_ALG;
202   else
203     return MS_NOTMOVE;
204 }
205
206 int alg_is_move(const char *mstr)
207 {
208         int piece=0, ff=0, fr=0, tf=0, tr=0, bc=0;
209
210         return get_move_info(mstr, &piece, &ff, &fr, &tf, &tr, &bc);
211 }
212
213 /* add any promotion qualifier from a move string */
214 static void add_promotion(struct game_state_t *gs, const char *mstr, struct move_t * mt)
215 {
216         char *s;
217         int piece, i;
218         s = strchr(mstr, '=');
219         if (s == NULL) {
220                 return;
221         }
222         
223         if (piecetype(gs->board[mt->fromFile][mt->fromRank]) != PAWN) {
224                 return;
225         }
226         if (mt->toRank != gs->ranks-1 && mt->toRank != 0) {
227                 return;
228         }
229
230         switch (tolower(s[1])) {
231         case 'f':
232                 piece = FERZ2;
233                 break;
234         case 'q':
235                 piece = QUEEN;
236                 break;
237         case 'c':\r
238                 if(!gs->capablancaPieces) return; // [HGM] should make variant-dependent piece mask\r
239                 piece = MARSHALL;\r
240                 break;\r
241         case 'a':\r
242                 if(!gs->capablancaPieces) return;\r
243                 piece = CARDINAL;\r
244                 break;\r
245         case 'm':\r
246                 if(!gs->royalKnight) return; // [HGM] only in knightmate\r
247                 piece = MAN;\r
248                 break;\r
249         case 'r':
250                 piece = ROOK;
251                 break;
252         case 'b':
253                 piece = BISHOP;
254                 break;
255         case 'n':
256                 if(gs->royalKnight) return; // [HGM] not in knightmate\r
257                 piece = KNIGHT;
258                 break;
259         // Superchess promotons: filtered out later by promoType
260         case 'g':
261                 piece = MASTODON;
262                 break;
263         case 'o':
264                 piece = SQUIRREL;
265                 break;
266         case 'w':
267                 piece = WOODY;
268                 break;
269         case 'v':
270                 piece = CENTAUR;
271                 break;
272         case 'e':\r
273                 piece = EMPRESS;
274                 break;
275         case 's':
276                 piece = PRINCESS;
277                 break;
278         default:
279                 return;
280         }
281
282         i = colorval(gs->board[mt->fromFile][mt->fromRank]) == WHITE ? 0 : 1;
283         if(piece >= WOODY && (gs->promoType != 2 || gs->holding[i][piece-1] == 0)) return;
284
285         mt->piecePromotionTo = piece | colorval(gs->board[mt->fromFile][mt->fromRank]);
286 }
287
288 /* We already know it is algebraic, get the move squares */
289 int alg_parse_move(char *mstr, struct game_state_t * gs, struct move_t * mt)
290 {
291         int f=0, r=0, tmpr=0, posf=0, posr=0, posr2=0;
292         int piece=0, ff=0, fr=0, tf=0, tr=0, bc=0;
293
294   if (get_move_info(mstr, &piece, &ff, &fr, &tf, &tr, &bc) != MS_ALG) {
295     d_printf( "CHESSD: Shouldn't try to algebraicly parse non-algabraic move string.\n");
296     return MOVE_ILLEGAL;
297   }
298   \r
299   // [HGM] check if move does not stray off board\r
300   if(gs->ranks < 10) { \r
301     if(tr == 0 || fr == 0) return MOVE_ILLEGAL; // used nonexistent 0-rank\r
302     if(tr != ALG_UNKNOWN) tr--; if(fr != ALG_UNKNOWN) fr--; // shift to lowest rank = 1\r
303   }\r
304   if(tr >= gs->ranks || fr >= gs->ranks || tf >= gs->files || ff >= gs->files)\r
305     return MOVE_ILLEGAL;\r
306
307   // [HGM] resolve ambiguity in piece, type based on variant
308   switch(piece) {
309     case ELEPHANT:
310       if(strstr(gs->variant, "super"))   piece = EMPRESS; else
311       if(strstr(gs->variant, "great"))   piece = MODERNELEPHANT; else
312       if(strstr(gs->variant, "courier")) piece = ALFIL2;
313       break;
314     case CARDINAL:
315       if(strstr(gs->variant, "super")) piece = AMAZON; else
316       if(strstr(gs->variant, "xiangqi")) piece = MANDARIN;
317       break;
318     case MARSHALL:
319       if(strstr(gs->variant, "xiangqi")) piece = CANNON;
320       break;
321     case SILVER:
322       if(strstr(gs->variant, "super")) piece = PRINCESS;
323       if(strstr(gs->variant, "great")) piece = MAN2;
324       break;
325     case BISHOP:
326       if(strstr(gs->variant, "shatranj")) piece = ALFIL;
327       break;
328     case QUEEN:
329       if(strstr(gs->variant, "shatranj")) piece = FERZ;
330       break;
331     case WAZIR:
332       if(strstr(gs->variant, "super")) piece = WOODY;
333       break;
334     case KNIGHT:
335       if(strstr(gs->variant, "shogi")) piece = HONORABLEHORSE;
336       break;
337     case MAN:
338       if(strstr(gs->variant, "great")) piece = MINISTER;
339       break;
340     case HORSE:
341       if(strstr(gs->variant, "great")) piece = PRIESTESS;
342       break;
343     case GOLD:
344       if(strstr(gs->variant, "great")) piece = MASTODON;
345       break;
346   }
347 \r
348   /* Resolve ambiguities in to-ness */
349   if (tf == ALG_UNKNOWN) {
350           d_printf("Ambiguous %s(%d)\n", __FUNCTION__, __LINE__);
351           return MOVE_AMBIGUOUS;        /* Must always know to file */
352   }
353   if (tr == ALG_UNKNOWN) {
354     posr = posr2 = ALG_UNKNOWN;
355     if (piece != PAWN) {
356             d_printf("Ambiguous %s(%d)\n", __FUNCTION__, __LINE__);
357             return MOVE_AMBIGUOUS;
358     }
359     if (ff == ALG_UNKNOWN) {
360             d_printf("Ambiguous %s(%d)\n", __FUNCTION__, __LINE__);
361             return MOVE_AMBIGUOUS;
362     }
363     /* Need to find pawn on ff that can take to tf and fill in ranks */
364     for (InitPieceLoop(gs->board, &f, &r, gs->onMove);
365          NextPieceLoop(gs->board, &f, &r, gs->onMove, gs->files, gs->ranks);) {
366       if ((ff != ALG_UNKNOWN) && (ff != f))
367         continue;
368       if (piecetype(gs->board[f][r]) != piece)
369         continue;
370       if (gs->onMove == WHITE) {
371         tmpr = r + 1;
372       } else {
373         tmpr = r - 1;
374       }
375 /*      if ((gs->board[tf][tmpr] == NOPIECE) ||
376           (iscolor(gs->board[tf][tmpr], gs->onMove))) continue;*/
377 /* patch from Soso, added by Sparky 3/16/95                    */
378       if (gs->board[tf][tmpr] == NOPIECE) {
379         if ((gs->ep_possible[((gs->onMove == WHITE) ? 0 : 1)][ff]) != (tf - ff))
380           continue;
381       } else {
382         if (iscolor(gs->board[tf][tmpr], gs->onMove))
383           continue;
384       }
385
386       if (legal_andcheck_move(gs, f, r, tf, tmpr)) {
387               if ((posr != ALG_UNKNOWN) && (posr2 != ALG_UNKNOWN)) {
388                       d_printf("Ambiguous %s(%d)\n", __FUNCTION__, __LINE__);
389                       return MOVE_AMBIGUOUS;
390               }
391         posr = tmpr;
392         posr2 = r;
393       }
394     }
395     tr = posr;
396     fr = posr2;
397   } else if (bc) {              /* Could be bxc4 or Bxc4, tr is known */
398     ff = ALG_UNKNOWN;
399     fr = ALG_UNKNOWN;
400     for (InitPieceLoop(gs->board, &f, &r, gs->onMove);
401          NextPieceLoop(gs->board, &f, &r, gs->onMove, gs->files, gs->ranks);) {
402             if ((piecetype(gs->board[f][r]) != PAWN) && (piecetype(gs->board[f][r]) != piece)) {
403                     // note that the interpretation Bxc4 is matched last, and has set piece to BISHOP
404                     continue;
405             }
406
407             if (legal_andcheck_move(gs, f, r, tf, tr)) {
408                     if ((piecetype(gs->board[f][r]) == PAWN) && (f != tolower(mstr[0]) - 'a')) {
409                             continue;
410                     }
411
412                     /* if its a lowercase 'b' then prefer the pawn move if there is one */
413                     if ((ff != ALG_UNKNOWN) && (fr != ALG_UNKNOWN) &&
414                         piecetype(gs->board[f][r]) == PAWN && mstr[0] >= 'a') {
415                             ff = f;
416                             fr = r;
417                             continue;
418                     }
419
420                     if ((ff != ALG_UNKNOWN) && (fr != ALG_UNKNOWN) &&
421                         piecetype(gs->board[ff][fr]) == PAWN && mstr[0] >= 'a') {
422                             continue;
423                     }
424
425                     if ((ff != ALG_UNKNOWN) && (fr != ALG_UNKNOWN)) {
426                             d_printf("Ambiguous %s(%d) mstr=%s\n", __FUNCTION__, __LINE__, mstr);
427                             return (MOVE_AMBIGUOUS);
428                     }
429                     ff = f;
430                     fr = r;
431             }
432     }
433   } else {                      /* The from position is unknown */
434     posf = ALG_UNKNOWN;
435     posr = ALG_UNKNOWN;
436     if ((ff == ALG_UNKNOWN) || (fr == ALG_UNKNOWN)) {
437       /* Need to find a piece that can go to tf, tr */
438       for (InitPieceLoop(gs->board, &f, &r, gs->onMove);
439            NextPieceLoop(gs->board, &f, &r, gs->onMove, gs->files, gs->ranks);) {
440         if ((ff != ALG_UNKNOWN) && (ff != f))
441           continue;
442         if ((fr != ALG_UNKNOWN) && (fr != r))
443           continue;
444         if (piecetype(gs->board[f][r]) != piece)
445           continue;
446         if (legal_andcheck_move(gs, f, r, tf, tr)) {
447                 if ((posf != ALG_UNKNOWN) && (posr != ALG_UNKNOWN)) {
448                         d_printf("Ambiguous %s(%d)\n", __FUNCTION__, __LINE__);
449                         return MOVE_AMBIGUOUS;
450                 }
451           posf = f;
452           posr = r;
453         }
454       }
455     } else if (ff == ALG_DROP) {
456       if (legal_andcheck_move(gs, ALG_DROP, piece, tf, tr)) {
457         posf = ALG_DROP;
458         posr = piece;
459       }
460     }
461     ff = posf;
462     fr = posr;
463   }
464   if ((tf == ALG_UNKNOWN) || (tr == ALG_UNKNOWN) ||
465       (ff == ALG_UNKNOWN) || (fr == ALG_UNKNOWN))
466     return MOVE_ILLEGAL;
467   mt->fromFile = ff;
468   mt->fromRank = fr;
469   mt->toFile = tf;
470   mt->toRank = tr;
471
472   add_promotion(gs, mstr, mt);
473
474   return MOVE_OK;
475 }
476
477 /* A assumes the move has yet to be made on the board */
478
479 /* Soso: rewrote alg_unparse function.
480  * Algebraic deparser - sets the mStr variable with move description
481  * in short notation. Used in last move report and in 'moves' command.
482  */
483
484 char *alg_unparse(struct game_state_t * gs, struct move_t * mt)
485 {
486   static char mStr[20];
487   char tmp[20];
488   int piece, f, r;
489   int ambig, r_ambig, f_ambig;
490   struct game_state_t fakeMove;
491
492   if (mt->fromFile == ALG_DROP) {
493     piece = mt->fromRank;
494   } else {
495     piece = piecetype(gs->board[mt->fromFile][mt->fromRank]);
496   }
497
498   if ((mt->fromFile == ALG_CASTLE) && (mt->toFile > mt->toRank)) { // [HGM] castle: K ends right of R\r
499     strcpy(mStr, "O-O");\r
500     goto check;\r
501   }\r
502   if ((mt->fromFile == ALG_CASTLE) && (mt->toFile < mt->toRank)) { // [HGM] castle: K ends left of R\r
503     strcpy(mStr, "O-O-O");\r
504     goto check;\r
505   }\r
506   strcpy(mStr, "");
507   switch (piece) {
508   case PAWN:
509     if (mt->fromFile == ALG_DROP) {
510       strcpy(mStr,"P");
511     } else if (mt->fromFile != mt->toFile 
512             || gs->board[mt->toFile][mt->toRank] != NOPIECE) { // [HGM] XQ: forward captures as "axa6"
513       sprintf(tmp, "%c", mt->fromFile + 'a');
514       strcpy(mStr, tmp);
515     }
516     break;
517   case KNIGHT:
518     strcpy(mStr, "N");
519     break;
520   case BISHOP:
521     strcpy(mStr, "B");
522     break;
523   case ROOK:
524     strcpy(mStr, "R");
525     break;
526   case ALFIL2:
527   case AMAZON:
528   case CARDINAL:\r
529     strcpy(mStr, "A");\r
530     break;\r
531   case CANNON:
532   case MARSHALL:\r
533     strcpy(mStr, "C");\r
534     break;\r
535   case MAN:\r
536     strcpy(mStr, "M");\r
537     break;\r
538   case FERZ:
539   case QUEEN:
540     strcpy(mStr, "Q");
541     break;
542   case EMPRESS:
543   case ELEPHANT:
544     strcpy(mStr, "E");
545     break;
546   case ALFIL:
547     strcpy(mStr, "B");
548     break;
549   case FERZ2:
550     strcpy(mStr, "F");
551     break;
552   case WOODY:
553   case WAZIR:
554     strcpy(mStr, "W");
555     break;
556   case SQUIRREL:
557     strcpy(mStr, "O");
558     break;
559   case CENTAUR:
560     strcpy(mStr, "V");
561     break;
562   case HORSE:
563     strcpy(mStr, "H");
564     break;
565   case HONORABLEHORSE:
566     strcpy(mStr, "N");
567     break;
568   case DRAGONKING:
569     strcpy(mStr, "J");
570     break;
571   case DRAGONHORSE:
572     strcpy(mStr, "I");
573     break;
574   case LANCE:
575     strcpy(mStr, "L");
576     break;
577   case PRINCESS:
578   case SILVER:
579     strcpy(mStr, "S");
580     break;
581   case MASTODON:
582   case GOLD:
583     strcpy(mStr, "G");
584     break;
585   case MANDARIN:
586     strcpy(mStr, "A");
587     break;
588   case KING:
589     strcpy(mStr, "K");
590     break;
591   default:
592     strcpy(mStr, "");
593     break;
594   }
595
596   if (mt->fromFile == ALG_DROP) {
597     strcat(mStr, "@");
598   } else {
599   /* Checks for ambiguity in short notation ( Ncb3, R8e8 or so) */
600   if (piece != PAWN) {
601     ambig = r_ambig = f_ambig = 0;
602     for (r = 0; r < gs->ranks; r++)\r
603       for (f = 0; f < gs->files; f++) {\r
604         if ((gs->board[f][r] != NOPIECE) && iscolor(gs->board[f][r], gs->onMove)
605             && (piecetype(gs->board[f][r]) == piece) &&
606             ((f != mt->fromFile) || (r != mt->fromRank))) {
607           if (legal_move(gs, f, r, mt->toFile, mt->toRank)) {
608             fakeMove = *gs;
609             fakeMove.board[f][r] = NOPIECE;
610             fakeMove.board[mt->toFile][mt->toRank] = piece | gs->onMove;
611             fakeMove.onMove = CToggle(fakeMove.onMove);
612             gs->onMove = CToggle(gs->onMove);
613
614 #if 0
615             d_printf("possible move %c%d%c%d against %c%d%c%d\n",
616                      'a' + f, r+1,
617                      'a' + mt->toFile, mt->toRank+1,
618                      'a' + mt->fromFile, mt->fromRank+1,
619                      'a' + mt->toFile, mt->toRank+1);
620 #endif
621
622             if (!in_check(&fakeMove)) {
623                     ambig++;
624                     if (f == mt->fromFile) {
625                             ambig++;
626                             f_ambig++;
627                     }
628                     if (r == mt->fromRank) {
629                             ambig++;
630                             r_ambig++;
631                     }
632             }
633             gs->onMove = CToggle(gs->onMove);
634           }
635         }
636       }
637     if (ambig > 0) {\r
638       /* Ambiguity in short notation, need to add file,rank or _both_ in\r
639          notation */\r
640       if (f_ambig == 0) {\r
641         sprintf(tmp, "%c", mt->fromFile + 'a');\r
642         strcat(mStr, tmp);\r
643       } else if (r_ambig == 0) {\r
644         sprintf(tmp, "%d", mt->fromRank + 1 - (gs->ranks > 9));\r
645         strcat(mStr, tmp);\r
646       } else {\r
647         sprintf(tmp, "%c%d", mt->fromFile + 'a', mt->fromRank + 1 - (gs->ranks > 9));\r
648         strcat(mStr, tmp);\r
649       }\r
650     }\r
651   }\r
652   if ((gs->board[mt->toFile][mt->toRank] != NOPIECE) ||\r
653       ((piece == PAWN) && (mt->fromFile != mt->toFile))) {\r
654     strcat(mStr, "x");\r
655   }\r
656   }\r
657   sprintf(tmp, "%c%d", mt->toFile + 'a', mt->toRank + 1 - (gs->ranks > 9));\r
658   strcat(mStr, tmp);\r
659 \r
660   if ((piece == PAWN) && (mt->piecePromotionTo != NOPIECE)) {\r
661     strcat(mStr, "=");          /* = before promoting piece */\r
662     switch (piecetype(mt->piecePromotionTo)) {\r
663     case KNIGHT:\r
664       strcat(mStr, "N");\r
665       break;\r
666     case BISHOP:\r
667       strcat(mStr, "B");\r
668       break;\r
669     case ROOK:\r
670       strcat(mStr, "R");\r
671       break;\r
672     case CARDINAL:\r
673       strcat(mStr, "A");\r
674       break;\r
675     case MARSHALL:\r
676       strcat(mStr, "C");\r
677       break;\r
678     case MAN:\r
679       strcat(mStr, "M");\r
680       break;\r
681     case QUEEN:\r
682       strcat(mStr, "Q");\r
683       break;\r
684     case FERZ2:\r
685       strcat(mStr, "F");\r
686       break;\r
687     case WOODY:\r
688       strcat(mStr, "W");\r
689       break;\r
690     case EMPRESS:\r
691       strcat(mStr, "E");\r
692       break;\r
693     case CENTAUR:\r
694       strcat(mStr, "V");\r
695       break;\r
696     case PRINCESS:\r
697       strcat(mStr, "S");\r
698       break;\r
699     case SQUIRREL:\r
700       strcat(mStr, "O");\r
701       break;\r
702     case MASTODON:\r
703       strcat(mStr, "G");\r
704       break;\r
705     default:\r
706       break;\r
707     }\r
708   }\r
709 check:;
710   fakeMove = *gs;
711   execute_move(&fakeMove, mt, 0);
712   fakeMove.onMove = CToggle(fakeMove.onMove);
713   if (in_check(&fakeMove)) {
714     strcat(mStr, "+");
715   }
716   return mStr;
717 }