home *** CD-ROM | disk | FTP | other *** search
/ Dream 57 / Amiga_Dream_57.iso / Amiga / Jeux / Reflexion / Crafty-15.19.lha / crafty-15.19 / src / output.c < prev    next >
C/C++ Source or Header  |  1998-09-13  |  6KB  |  193 lines
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include "chess.h"
  5. #include "data.h"
  6.  
  7. /* last modified 03/11/98 */
  8. /*
  9. ********************************************************************************
  10. *                                                                              *
  11. *   OutputMove() is responsible for converting the internal move format to a   *
  12. *   string that can be displayed.  first, it simply converts the from/to       *
  13. *   squares to fully-qualified algebraic (which includes O-O and O-O-O for     *
  14. *   castling moves).  next, we try several "shortcut" forms and call           *
  15. *   input_move(silent=1) to let it silently check the move for uniqueness.     *
  16. *   as soon as we get a non-ambiguous move, we return that text string.        *
  17. *                                                                              *
  18. ********************************************************************************
  19. */
  20. char* OutputMove(TREE *tree, int move, int ply, int wtm) {
  21.   static char text_move[10], new_text[10];
  22.   int *mvp;
  23.   char *text;
  24.   char piece_names[8] = { ' ','P','N','K',' ','B','R','Q'};
  25.  
  26.   text=text_move;
  27. /*
  28.    check for null_move first
  29. */
  30.   if (move == 0) {
  31.     strcpy(text,"null");
  32.     return(text);
  33.   }
  34. /*
  35.    check for castling first
  36. */
  37.   if ((Piece(move) == king) &&
  38.       (abs(From(move)-To(move)) == 2)) {
  39.     if (wtm) {
  40.       if (To(move) == 2) strcpy(text,"O-O-O");
  41.       else strcpy(text,"O-O");
  42.     }
  43.     else {
  44.       if (To(move) == 58) strcpy(text,"O-O-O");
  45.       else strcpy(text,"O-O");
  46.     }
  47.     return(text);
  48.   }
  49. /*
  50.    not a castling move.  convert to fully-qualified algebraic form
  51.    first.
  52. */
  53.   text=new_text;
  54.   if ((int) Piece(move) > pawn) *text++=piece_names[Piece(move)];
  55.   *text++=(From(move) & 7)+'a';
  56.   *text++=(From(move) / 8)+'1';
  57.   if (Captured(move)) *text++='x';
  58.   *text++=(To(move) & 7)+'a';
  59.   *text++=(To(move) / 8)+'1';
  60.   if (Promote(move)) {
  61.     *text++='=';
  62.     *text++=piece_names[Promote(move)];
  63.   }
  64. /*
  65.    determine if it's a checking move, or if it's mate.  if so, 
  66.    append "+" or "#" as appropriate.
  67. */
  68.   tree->position[MAXPLY]=tree->position[ply];
  69.   MakeMove(tree, MAXPLY, move, wtm);
  70.   if (Check(ChangeSide(wtm))) {
  71.     mvp=GenerateCheckEvasions(tree,MAXPLY+1, ChangeSide(wtm), tree->move_list+4800);
  72.     if (mvp == (tree->move_list+4800))
  73.       *text++='#';
  74.     else
  75.       *text++='+';
  76.   }
  77.   UnMakeMove(tree, MAXPLY, move, wtm);
  78.   *text='\0';
  79.   if (output_format > 0) return (new_text);
  80. /*
  81.    now, try some short forms.  if the moving piece is a pawn, and
  82.    it is not capturing anything, simply try the destination square
  83.    first: (e2e4->e4)
  84. */
  85.   if (Piece(move) == pawn) {
  86.     if (!Captured(move)) {
  87.       strcpy(text_move,new_text+2);
  88.       if (OutputGood(tree,text_move,ply,wtm)) return (text_move);
  89.     }
  90. /*
  91.    if the move is a pawn capturing a piece, try the short-form for pawn
  92.    capture moves: (e4xf5->exf5)
  93. */
  94.     text_move[0]=new_text[0];
  95.     strcpy(text_move+1,new_text+2);
  96.     if (OutputGood(tree,text_move,ply,wtm)) return (text_move);
  97. /*
  98.    punt, return the fully-qualified move.
  99. */
  100.     strcpy(text_move,new_text);
  101.     return (text_move);
  102.   }
  103. /*
  104.    if the move is a piece move, but not a capture, then try the short-
  105.    form for non-capturing moves:  (Ng1f3->Nf3)
  106. */
  107.   if (!Captured(move)) {
  108.     text_move[0]=new_text[0];
  109.     strcpy(text_move+1,new_text+3);
  110.     if (OutputGood(tree,text_move,ply,wtm)) return (text_move);
  111. /*
  112.    now try to qualify with the origin file only: (Ng1f3->Ngf3)
  113. */
  114.     text_move[0]=new_text[0];
  115.     text_move[1]=new_text[1];
  116.     strcpy(text_move+2,new_text+3);
  117.     if (OutputGood(tree,text_move,ply,wtm)) return (text_move);
  118. /*
  119.    now try to qualify with the origin rank only: (Ng1f3->N1f3)
  120. */
  121.     text_move[0]=new_text[0];
  122.     strcpy(text_move+1,new_text+2);
  123.     if (OutputGood(tree,text_move,ply,wtm)) return (text_move);
  124. /*
  125.    punt, return the fully-qualified move.
  126. */
  127.     strcpy(text_move,new_text);
  128.     return (text_move);
  129.   }
  130.   else {
  131. /*
  132.    if the move is a piece move, and a capture, then try the short-
  133.    form for capturing moves:  (Ng1xf3->Nxf3)
  134. */
  135.     text_move[0]=new_text[0];
  136.     strcpy(text_move+1,new_text+3);
  137.     if (OutputGood(tree,text_move,ply,wtm)) return (text_move);
  138. /*
  139.    next, try adding in the origin file: (Ng1xf3->Ngxf3)
  140. */
  141.     text_move[0]=new_text[0];
  142.     text_move[1]=new_text[1];
  143.     strcpy(text_move+2,new_text+3);
  144.     if (OutputGood(tree,text_move,ply,wtm)) return (text_move);
  145. /*
  146.    next, try adding in the origin rank: (Ng1xf3->N1xf3)
  147. */
  148.     text_move[0]=new_text[0];
  149.     strcpy(text_move+1,new_text+2);
  150.     if (OutputGood(tree,text_move,ply,wtm)) return (text_move);
  151. /*
  152.    punt, return the fully-qualified move.
  153. */
  154.     strcpy(text_move,new_text);
  155.     return (text_move);
  156.   }
  157. }
  158.  
  159. /* last modified 03/11/98 */
  160. /*
  161. ********************************************************************************
  162. *                                                                              *
  163. *   OutputMoveICS() is responsible for producing the rather primitive move     *
  164. *   format that the ics interface wants, namely [from][to][promote].           *
  165. *                                                                              *
  166. ********************************************************************************
  167. */
  168. char* OutputMoveICS(TREE *tree, int move) {
  169.   static char text_move[10];
  170.   char *text;
  171.   char piece_names[8] = { ' ','P','N','K',' ','B','R','Q'};
  172.  
  173. /*
  174.    convert to fully-qualified algebraic form first.
  175. */
  176.   text=text_move;
  177.   *text++=(From(move) & 7)+'a';
  178.   *text++=(From(move) / 8)+'1';
  179.   *text++=(To(move) & 7)+'a';
  180.   *text++=(To(move) / 8)+'1';
  181.   if (Promote(move))
  182.     *text++=piece_names[Promote(move)];
  183.   *text='\0';
  184.   return (text_move);
  185. }
  186.  
  187. int OutputGood(TREE *tree, char* text, int ply, int wtm)
  188. {
  189.   int new_move;
  190.   new_move=InputMove(tree,text,ply,wtm,1,0);
  191.   return (Piece(new_move));
  192. }
  193.