home *** CD-ROM | disk | FTP | other *** search
/ C!T ROM 5 / ctrom5b.zip / ctrom5b / OS2 / SPEL / UCHESS / UCHESSRC / NONDSP.C < prev    next >
Text File  |  1994-11-03  |  19KB  |  894 lines
  1. /*
  2.  * nondsp.c - UNIX & MSDOS NON-DISPLAY, AND CHESSTOOL interface for Chess
  3.  *
  4.  * Copyright (c) 1988,1989,1990 John Stanback
  5.  * Copyright (c) 1992 Free Software Foundation
  6.  *
  7.  * This file is part of GNU CHESS.
  8.  *
  9.  * GNU Chess is free software; you can redistribute it and/or modify
  10.  * it under the terms of the GNU General Public License as published by
  11.  * the Free Software Foundation; either version 2, or (at your option)
  12.  * any later version.
  13.  *
  14.  * GNU Chess is distributed in the hope that it will be useful,
  15.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17.  * GNU General Public License for more details.
  18.  *
  19.  * You should have received a copy of the GNU General Public License
  20.  * along with GNU Chess; see the file COPYING.  If not, write to
  21.  * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  22.  */
  23.  
  24. #include <ctype.h>
  25. #include <signal.h>
  26.  
  27. void mysprintf(char *,char *,int);
  28. void mysprintf4(char *,char *,int);
  29. void mysprintf3(char *,char *,int,int);
  30. void algbr2 (short, short, short);
  31. #ifdef AMIGA
  32. #define __USE_SYSBASE
  33. #include <exec/types.h>
  34. #include <exec/exec.h>
  35. #include <proto/exec.h>
  36. #include <proto/dos.h>
  37. #include <proto/graphics.h>
  38. #include <proto/intuition.h>
  39. #endif
  40.  
  41. char HintString[80];
  42.  
  43.  
  44. #define SIGQUIT SIGINT
  45.  
  46. #include "gnuchess.h"
  47. #ifdef MSDOSREAL
  48. #include <dos.h>
  49. #include <conio.h>
  50. #include <stdlib.h>
  51. #include <string.h>
  52. #include <time.h>
  53. #else
  54. #include <dos.h>
  55. #include <conio.h>
  56. #include <stdlib.h>
  57. #include <string.h>
  58. #include <time.h>
  59. /*
  60. #include <sys/param.h>
  61. #include <sys/types.h>
  62. #include <sys/file.h>
  63. #include <sys/ioctl.h>
  64. */
  65. #endif
  66.  
  67. extern int thinkahead;
  68.  
  69. extern INTSIZE amigaboard[64],amigacolor[64];
  70. extern short int ISZERO;
  71. char  IllegalString[40];
  72. extern int AmigaStarted;
  73. extern int  global_tmp_score;
  74. extern int  previous_score;
  75. int IllegalMove=0;
  76. int Mate=0;
  77. int DrawnGame=0;
  78. char  MateString[40]={0};
  79. extern long OrigResponse;
  80.  
  81. #ifdef DEBUG
  82. INTSIZE int debuglevel = 0;
  83.  
  84. #endif /* DEBUG */
  85. unsigned INTSIZE int MV[MAXDEPTH];
  86. int MSCORE;
  87.  
  88. #if defined CHESSTOOL || defined XBOARD
  89. INTSIZE int chesstool = 1;
  90.  
  91. #else
  92. INTSIZE int chesstool = 0;
  93.  
  94. #endif /* CHESSTOOL */
  95. extern char __aligned mvstrhint[8][8];
  96. extern char mvstr[8][8];
  97. int __aligned mycnt1, mycnt2;
  98. char __aligned *DRAW;
  99. extern char *InPtr;
  100. extern INTSIZE int pscore[];
  101.  
  102. void mysprintf4(ostr,fstr,num)
  103. char *ostr,*fstr;
  104. int num;
  105. { // formats string "Tgt:%d xxx"
  106.  
  107.  int index;
  108.  int thou,hun,ten,one,rem;
  109.  
  110.  
  111.  ostr[0] = fstr[0];
  112.  ostr[1] = fstr[1];
  113.  ostr[2] = fstr[2];
  114.  ostr[3] = fstr[3];
  115.  ostr[4] = 0;
  116.  if (num < 0) 
  117.   {
  118.    num = -num;
  119.    index = 5;
  120.    strcat(ostr,"-");
  121.   }
  122.  else
  123.   {
  124.    index = 4;
  125.   }
  126.  thou = num / 1000;
  127.  rem = num-(num / 1000)*1000;
  128.  hun = (rem / 100);
  129.  rem = rem-(hun * 100);
  130.  ten = rem / 10;
  131.  rem = rem-(ten * 10);
  132.  one = rem;
  133.  if (thou)
  134.   {
  135.    ostr[index++] = thou+'0';
  136.   }
  137.  if ((hun)||(thou))
  138.   {
  139.    ostr[index++] = hun+'0';
  140.   }
  141.  if ((ten)||(hun)||(thou))
  142.   {
  143.    ostr[index++] = ten+'0';
  144.   }
  145.  ostr[index++] = one+'0';
  146.  ostr[index] = 0;
  147.  strcat(ostr,&fstr[6]);
  148. }
  149.  
  150. void mysprintf3(ostr,fstr,num,num2)
  151. char *ostr,*fstr;
  152. int num,num2;
  153. { // formats string "D%d S%d "
  154.  
  155.  int index;
  156.  int thou,hun,ten,one,rem;
  157.  
  158.  
  159.  ostr[0] = fstr[0]; // get the D
  160.  ostr[1] = 0;
  161.  if (num < 0) 
  162.   {
  163.    num = -num;
  164.    index = 2;
  165.    strcat(ostr,"-");
  166.   }
  167.  else
  168.   {
  169.    index = 1;
  170.   }
  171.  thou = num / 1000;
  172.  rem = num-(num / 1000)*1000;
  173.  hun = (rem / 100);
  174.  rem = rem-(hun * 100);
  175.  ten = rem / 10;
  176.  rem = rem-(ten * 10);
  177.  one = rem;
  178.  if (thou)
  179.   {
  180.    ostr[index++] = thou+'0';
  181.   }
  182.  if ((hun)||(thou))
  183.   {
  184.    ostr[index++] = hun+'0';
  185.   }
  186.  if ((ten)||(hun)||(thou))
  187.   {
  188.    ostr[index++] = ten+'0';
  189.   }
  190.  ostr[index++] = one+'0';
  191.  ostr[index++] = fstr[3];
  192.  ostr[index++] = fstr[4];
  193.  
  194.  if (num2 < 0)
  195.   {
  196.    num2 = -num2;
  197.    ostr[index++] = '-';
  198.   }
  199.  thou = num2 / 1000;
  200.  rem = num2-(num2 / 1000)*1000;
  201.  hun = (rem / 100);
  202.  rem = rem-(hun * 100);
  203.  ten = rem / 10;
  204.  rem = rem-(ten * 10);
  205.  one = rem;
  206.  if (thou)
  207.   {
  208.    ostr[index++] = thou+'0';
  209.   }
  210.  if ((hun)||(thou))
  211.   {
  212.    ostr[index++] = hun+'0';
  213.   }
  214.  if ((ten)||(hun)||(thou))
  215.   {
  216.    ostr[index++] = ten+'0';
  217.   }
  218.  ostr[index++] = one+'0';
  219.  ostr[index] = 0;
  220.  strcat(ostr,&fstr[7]);
  221. }
  222.  
  223.  
  224. void
  225. Initialize (void)
  226. {
  227.   mycnt1 = mycnt2 = 0;
  228. #if defined CHESSTOOL || defined XBOARD
  229. #ifndef SYSV
  230. /*  setlinebuf (stdout);*/
  231. #else
  232. /*  setvbuf (stdout, NULL, _IOLBF, BUFSIZ);*/
  233. #endif
  234. /*  printf (CP[43]);*/          /*Chess*/
  235.   if (!TCflag && (MaxResponseTime == 0))
  236.     MaxResponseTime = 15L*100L;
  237. #endif /* CHESSTOOL */
  238. }
  239.  
  240.  
  241. void DoAMove(void);
  242.  
  243. void DoAMove()
  244. {
  245.  char astr[40];
  246.  int r,c,l;
  247.  char piece;
  248.  
  249.       r = mvstr[0][3] - '1';
  250.       c = mvstr[0][2] - 'a';
  251.       l = ((flag.reverse) ? locn (7 - r, 7 - c) : locn (r, c));
  252.       if (color[l] == neutral)
  253.        {
  254.     //DisplayBeep(0L);
  255.     //Delay(25L);
  256.     //DisplayBeep(0L);
  257.     //Delay(25L);
  258.     //DisplayBeep(0L);
  259.     //Delay(25L);
  260.     piece = ' ';
  261.        }
  262.       else if (color[l] == white)
  263.     piece = qxx[board[l]]; /* white are lower case pieces */
  264.       else
  265.     piece = pxx[board[l]]; /* black are upper case pieces */
  266.   if (computer == black)
  267.    {
  268.     mysprintf(astr,"%d: ",GameCnt>>1);
  269.     strcat(astr,mvstr[0]);
  270.    }
  271.   else
  272.    {
  273.     mysprintf(astr,"%d: ",(GameCnt+1)>>1);   
  274.     strcat(astr,mvstr[0]);
  275.    }
  276.   DisplayComputerMove(astr);
  277.   if (piece != ' ')
  278.    AnimateAmigaMove(mvstr[0],piece);
  279. }
  280. void
  281. ExitChess (void)
  282. {
  283. /*  signal (SIGTERM, SIG_IGN);*/
  284.   //ListGame (0L);
  285.   if (AmigaStarted)
  286.    PM_ShutDown();
  287.   DosExit(0,0);
  288. }
  289.  
  290. void
  291. TerminateSearch ()
  292. {
  293. #ifdef MSDOSREAL
  294.   sig++;                        /* shut up the compiler */
  295. #endif /* MSDOS */
  296.   if (!flag.timeout)
  297.     flag.musttimeout = true;
  298.   flag.bothsides = false;
  299. }
  300.  
  301.  
  302. void
  303. help (void)
  304. {
  305. #ifdef NONEEDFORTHIS
  306.   ClrScreen ();
  307.   /*printz ("CHESS command summary\n");*/
  308.   printz (CP[40]);
  309.   printz ("----------------------------------------------------------------\n");
  310.   /*printz ("g1f3      move from g1 to f3      quit      Exit Chess\n");*/
  311.   printz (CP[158]);
  312.   /*printz ("Nf3       move knight to f3       beep      turn %s\n", (flag.beep) ? "off" : "on");*/
  313.   printz (CP[86], (flag.beep) ? CP[92] : CP[93]);
  314.   /*printz ("a7a8q     promote pawn to queen\n");*/
  315.   printz (CP[128], (flag.material) ? CP[92] : CP[93]);
  316.   /*printz ("o-o       castle king side        easy      turn %s\n", (flag.easy) ? "off" : "on");*/
  317.   printz (CP[173], (flag.easy) ? CP[92] : CP[93]);
  318.   /*printz ("o-o-o     castle queen side       hash      turn %s\n", (flag.hash) ? "off" : "on");*/
  319.   printz (CP[174], (flag.hash) ? CP[92] : CP[93]);
  320.   /*printz ("bd        redraw board            reverse   board display\n");*/
  321.   printz (CP[130]);
  322.   /*printz ("list      game to chess.lst       book      turn %s used %d of %d\n", (Book) ? "off" : "on", bookcount, BOOKSIZE);*/
  323.   printz (CP[170], (Book) ? CP[92] : CP[93], bookcount, BOOKSIZE);
  324.   /*printz ("undo      undo last ply           remove    take back a move\n");*/
  325.   printz (CP[200]);
  326.   /*printz ("edit      edit board              force     enter game moves\n");*/
  327.   printz (CP[153]);
  328.   /*printz ("switch    sides with computer     both      computer match\n");*/
  329.   printz (CP[194]);
  330.   /*printz ("white     computer plays white    black     computer plays black\n");*/
  331.   printz (CP[202]);
  332.   /*printz ("depth     set search depth        clock     set time control\n");*/
  333.   printz (CP[149]);
  334.   /*printz ("post      principle variation     hint      suggest a move\n");*/
  335.   printz (CP[177]);
  336.   /*printz ("save      game to file            get       game from file\n");*/
  337.   printz (CP[188]);
  338.   /*printz ("random    randomize play          new       start new game\n");*/
  339.   printz (CP[181]);
  340.   printz ("----------------------------------------------------------------\n");
  341.   /*printz ("Computer: %-12s Opponent:            %s\n",*/
  342.   printz (CP[46],
  343.       ColorStr[computer], ColorStr[opponent]);
  344.   /*printz ("Depth:    %-12d Response time:       %d sec\n",*/
  345.   printz (CP[51],
  346.       MaxSearchDepth, MaxResponseTime/100);
  347.   /*printz ("Random:   %-12s Easy mode:           %s\n",*/
  348.   printz (CP[99],
  349.       (dither) ? CP[93] : CP[92], (flag.easy) ? CP[93] : CP[92]);
  350.   /*printz ("Beep:     %-12s Transposition file: %s\n",*/
  351.   printz (CP[36],
  352.       (flag.beep) ? CP[93] : CP[92], (flag.hash) ? CP[93] : CP[92]);
  353.   /*printz ("Time Control %s %d moves %d seconds %d opr %d depth\n", (TCflag) ? "ON" : "OFF",*/
  354.   printz (CP[110], (TCflag) ? CP[93] : CP[92],
  355.       TimeControl.moves[white], TimeControl.clock[white] / 100, OperatorTime, MaxSearchDepth);
  356.   signal (SIGINT, TerminateSearch);
  357. #ifndef MSDOS
  358.   signal (SIGQUIT, TerminateSearch);
  359. #endif /* MSDOS */
  360. #endif
  361. }
  362.  
  363. #ifdef REALLYNEED
  364. void
  365. EditBoard (void)
  366.  
  367. /*
  368.  * Set up a board position. Pieces are entered by typing the piece followed
  369.  * by the location. For example, Nf3 will place a knight on square f3.
  370.  */
  371.  
  372. {
  373.   INTSIZE a, r, c, sq, i, found;
  374.   int tmpcolor;
  375.   char s[80];
  376.  
  377.   flag.regularstart = false;
  378.   if (thinkahead)
  379.    {
  380.     flag.back = true;
  381.     while (thinkahead)
  382.      {
  383.       DosSleep(500L);
  384.      }
  385.    }
  386.   Book = 0;
  387.   if (!OpenAmigaEditWindow())
  388.    { /* open the window which will give us back text string */
  389.     //DisplayBeep(0L);
  390.     //Delay(25L);
  391.     //DisplayBeep(0L);
  392.     return;
  393.    }
  394.  
  395.   a = tmpcolor = white;
  396.   do
  397.     {
  398.       GetEditText(s,&tmpcolor); /* amiga routine to get the command from user */
  399.       found=0;
  400.       if (s[0] == CP[28][0])    /*#*/
  401.     for (sq = 0; sq < 64; sq++)
  402.       {
  403.         board[sq] = no_piece;
  404.         color[sq] = neutral;
  405.       }
  406.       if (a != tmpcolor)        /*c*/
  407.     a = otherside[a];
  408.       c = s[1] - 'a';
  409.       r = s[2] - '1';
  410.       if ((c >= 0) && (c < 8) && (r >= 0) && (r < 8))
  411.     {
  412.       sq = locn (r, c);
  413.       color[sq] = a;
  414.       board[sq] = no_piece;
  415.       for (i = no_piece; i <= king; i++)
  416.         if ((s[0] == pxx[i]) || (s[0] == qxx[i]))
  417.           {
  418.         board[sq] = i;
  419.         found=1;
  420.         break;
  421.           }
  422.       if ((found==0)||(board[sq] == no_piece)) color[sq] = neutral; 
  423.     }
  424.   } while (s[0] != CP[29][0]);
  425.   for (sq = 0; sq < 64; sq++)
  426.     Mvboard[sq] = ((board[sq] != Stboard[sq]) ? 10 : 0);
  427.   CloseAmigaEditWindow(); /* Closes the edit window */
  428.   GameCnt = 0;
  429.   Game50 = 1;
  430.   ISZERO = 1;
  431.   ZeroRPT ();
  432.   Sdepth = 0;
  433.   InitializeStats ();
  434.   MoveMem128(board,amigaboard);
  435.   MoveMem128(color,amigacolor);
  436.   DrawAmigaBoard();
  437. }
  438.  
  439. #endif
  440.  
  441. void
  442. SetupBoard (void)
  443.  
  444. /*
  445.  * Compatibility with Unix chess and the nchesstool. Set up a board position.
  446.  * Eight lines of eight characters are used to setup the board. a8-h8 is the
  447.  * first line. Black pieces are  represented  by  uppercase characters.
  448.  */
  449. {
  450. }
  451.  
  452. void
  453. ShowDepth ()
  454. {
  455. }
  456.  
  457.  
  458. void
  459. ShowLine (INTSIZE unsigned int *bstline,char *astr)
  460. {
  461.  
  462.       algbr ((INTSIZE) (bstline[1] >> 8), (INTSIZE) (bstline[1] & 0xFF), false);
  463.       strcpy (astr,mvstr[0]);
  464. }
  465.  
  466. void
  467. ShowResults (INTSIZE int score, INTSIZE unsigned int *bstline)
  468. {
  469.  char astr[64];
  470.  char nstr[16];
  471.  
  472. #if !defined CHESSTOOL
  473. /*printf("GameCnt = %d PrevDepth = %d\n",GameCnt,GameList[GameCnt-1].depth);*/
  474.   if ((!flag.easy)&&(ThinkAheadDepth)&&(TCflag)&&(GameCnt > 1)&&(Sdepth > 2))
  475.    { /* check for lookahead abort */
  476.     if ((Sdepth >= ThinkAheadDepth)&&(Sdepth >= GameList[GameCnt-1].depth)&&
  477.     (Sdepth > GlobalTgtDepth)&&(global_tmp_score >= (previous_score-25)))
  478.      { /* a chance I may want to abort search here */
  479.     if (!flag.musttimeout)
  480.      { /* not already aborted */
  481.       if ((ThinkInARow < 4)||(Sdepth > ThinkAheadDepth))
  482.        { /* max 4 times in a row */
  483.         flag.musttimeout = true;
  484.         if (Sdepth == ThinkAheadDepth)
  485.          ThinkInARow++;
  486.         else /* you thought past thinkaheaddepth */
  487.          ThinkInARow = 0;
  488.        }
  489.      }
  490.      }
  491.    }
  492.   if (flag.post)
  493.     {
  494.       ElapsedTime (2);
  495.       mysprintf3(astr,"D%d S%d ", Sdepth, score);
  496.       ShowLine (bstline,nstr);
  497.       strcat(astr,nstr);
  498.       ShowMessage(astr);
  499.     }
  500. #else
  501.   REG int i;
  502.  
  503.   MSCORE = score;
  504.   MV[30] = ch;
  505.   for (i = 1; bstline[i] > 0; i++)
  506.     {
  507.       MV[i] = bstline[i];
  508.     } MV[i] = 0;
  509. #endif /* CHESSTOOL */
  510. }
  511.  
  512. void
  513. SearchStartStuff ()
  514. {
  515.  unsigned long numsecs;
  516.  char astr[64];
  517.  
  518. //  signal (SIGINT, TerminateSearch);
  519. //#ifndef MSDOS
  520. //  signal (SIGQUIT, TerminateSearch);
  521. //#endif /* MSDOS */
  522. #if !defined CHESSTOOL
  523. /*#ifndef AMIGA*/
  524.   if (flag.post)
  525.     {
  526.       numsecs = (ResponseTime*2L+51L)/100L;
  527.       if (TCflag)
  528.        mysprintf4(astr,"Tgt:%d secs  ", numsecs);
  529.       else
  530.        mysprintf4(astr,"Tgt:%d ply   ", MaxSearchDepth);
  531.       ShowMessage(astr);
  532.     }
  533. /*#endif*/
  534. #endif /* CHESSTOOL */
  535. }
  536. void
  537. OutputMove ()
  538. {
  539.  int r,c,l;
  540.  char astr[40];
  541.  char piece;
  542.  
  543. if(flag.illegal){
  544.  IllegalMove = 1;
  545.  strcpy(IllegalString,CP[225]);
  546.  return;
  547. }
  548. if (mvstr[0][0] == '\0') goto nomove;
  549. #ifdef notdef
  550.   if (flag.post)
  551.     {
  552.       REG int i;
  553.  
  554.       printz (" %6d%c ", MSCORE, MV[30]);
  555.       for (i = 1; MV[i] > 0; i++)
  556.     {
  557.       algbr ((INTSIZE) (MV[i] >> 8), (INTSIZE) (MV[i] & 0xFF), false);
  558.       printz ("%5s ", mvstr[0]);
  559.     }
  560.     }
  561.   printz ("\n");
  562. #endif
  563. nomove:
  564.   if ((root->flags & draw)||(root->score == -9999)||
  565.       (root->score == 9998)) goto summary;
  566. #if !defined CHESSTOOL
  567.   if (flag.post)
  568.     {
  569.       INTSIZE h, l, t;
  570.  
  571.       h = TREE;
  572.       l = 0;
  573.       t = TREE >> 1;
  574.       while (l != t)
  575.     {
  576.       if (Tree[t].f || Tree[t].t)
  577.         l = t;
  578.       else
  579.         h = t;
  580.       t = (l + h) >> 1;
  581.     }
  582.     }
  583.   UpdateDisplay (root->f, root->t, 0, root->flags);
  584.       r = mvstr[0][3] - '1';
  585.       c = mvstr[0][2] - 'a';
  586.       l = ((flag.reverse) ? locn (7 - r, 7 - c) : locn (r, c));
  587.       if (color[l] == neutral)
  588.        {
  589.     //DisplayBeep(0L);
  590.     //Delay(25L);
  591.     //DisplayBeep(0L);
  592.     //Delay(25L);
  593.     //DisplayBeep(0L);
  594.     //Delay(25L);
  595.     piece = ' ';
  596.        }
  597.       else if (color[l] == white)
  598.     piece = qxx[board[l]]; /* white are lower case pieces */
  599.       else
  600.     piece = pxx[board[l]]; /* black are upper case pieces */
  601.   if (computer == black)
  602.    {
  603.     mysprintf(astr,"%d: ",GameCnt>>1);
  604.     strcat(astr,mvstr[0]);
  605.    }
  606.   else
  607.    {
  608.     mysprintf(astr,"%d: ",(GameCnt+1)>>1);   
  609.     strcat(astr,mvstr[0]);
  610.    }
  611.   DisplayComputerMove(astr);
  612.   if (piece != ' ')
  613.    AnimateAmigaMove(mvstr[0],piece);
  614.   if ((flag.beep)&&(!flag.bothsides))
  615.    {
  616.     DosBeep(300,20);
  617.    }
  618. #endif /* CHESSTOOL */
  619.  summary:
  620.   if (root->flags & draw)
  621.     /*  printf ("Drawn game!\n");*/
  622.    {
  623.     /*printz (CP[57]);*/
  624.     DrawnGame = 1;
  625.    }
  626.   else if (root->score == -9999)
  627.    {
  628.     Mate = 1;
  629.     strcpy(MateString,ColorStr[opponent]);
  630.     strcat(MateString," mates!");
  631. /*    printz("%s mates!\n",ColorStr[opponent]);*/
  632.    }
  633.   else if (root->score == 9998)
  634.    {
  635.     Mate = 1;
  636.     DoAMove();
  637.     if (flag.bothsides)
  638.      {
  639.       strcpy(MateString,ColorStr[computer^1]);
  640.       strcat(MateString," mates!");
  641.      }
  642.     else
  643.      {
  644.       strcpy(MateString,ColorStr[computer]);
  645.       strcat(MateString," mates!");
  646.      }
  647. /*    printz("%s mates!\n",ColorStr[computer]);*/
  648.    }
  649. #if !defined CHESSTOOL && !defined XBOARD
  650. #ifdef VERYBUGGY
  651.   else if (root->score < -9000)
  652.     /*printf("%s has a forced mate!\n",ColorStr[opponent]);*/
  653.   else if (root->score > 9000)
  654.     /*printf("%s has a forced mate!\n",ColorStr[computer]);*/
  655. #endif /*VERYBUGGY*/
  656. #endif /* CHESSTOOL */
  657. }
  658.  
  659. void
  660. ClrScreen (void)
  661. {// not needed in PM or amiga version
  662. }
  663.  
  664.  
  665. //void
  666. //UpdateDisplay (INTSIZE int f, INTSIZE int t, INTSIZE int redraw, INTSIZE int isspec)
  667. //{
  668.  
  669.  
  670. //}
  671.  
  672. void
  673. skip ()
  674. {
  675.   while (*InPtr != ' ')
  676.     InPtr++;
  677.   while (*InPtr == ' ')
  678.     InPtr++;
  679. }
  680. void
  681. skipb ()
  682. {
  683.   while (*InPtr == ' ')
  684.     InPtr++;
  685. }
  686.  
  687. void
  688. ShowSidetoMove (void)
  689. {
  690. }
  691.  
  692. void
  693. PromptForMove (void)
  694. {
  695. #if !defined CHESSTOOL && !defined XBOARD && !defined AMIGA
  696.   /*printz ("\nYour move is? ");*/
  697.   printz (CP[124]);
  698. #endif /* CHESSTOOL */
  699. }
  700.  
  701.  
  702. //void
  703. //ShowCurrentMove (INTSIZE int pnt, INTSIZE int f, INTSIZE int t)
  704. //{
  705. //#ifdef MSDOSREAL
  706. //  f++;
  707. //  t++;
  708. //  pnt++;                        /* shut up the compiler */
  709. //#endif /* MSDOS */
  710. //}
  711.  
  712. void
  713. ChangeAlphaWindow (void)
  714. {
  715. }
  716.  
  717.  
  718. void
  719. ChangeBetaWindow (void)
  720. {
  721. }
  722.  
  723. void
  724. GiveHint (void)
  725. {
  726.   if (hint)
  727.     {
  728.       algbr2 ((INTSIZE) (hint >> 8), (INTSIZE) (hint & 0xFF), false);
  729.       strcpy(HintString,"Hint : ");
  730.       strcat(HintString,mvstrhint[0]);
  731.     }
  732.   else
  733.     strcpy (HintString,"No idea..");
  734.   DisplayComputerMove(HintString);
  735. }
  736.  
  737. void
  738. SelectLevel (timestring)
  739. char *timestring;
  740. {
  741.   int tmp;
  742.   char T[64], *p, *q;
  743.  
  744. #ifndef LONGINTS2
  745.   sscanf(timestring,"%hd %s",&TCmoves,T);
  746. #else
  747.   sscanf(timestring,"%d %s",&TCmoves,T);
  748. #endif
  749.   for (p = T; *p == ' '; p++) ;
  750.   TCminutes = strtol (p, &q, 10);
  751.   TCadd = 0;
  752.   if (TCminutes < 1)
  753.    TCminutes = 1;
  754.   if (TCmoves < 1)
  755.    TCmoves = 1;
  756. //  if ((TCminutes/TCmoves) > 0)
  757. //   {
  758.     //EnableMoveNow();
  759. //   }
  760. //  else
  761. //   {
  762. //    DisableMoveNow();
  763. //   }
  764.   if (*q == ':')
  765.     TCseconds = strtol (q + 1, (char **) NULL, 10);
  766.   else
  767.     TCseconds = 0;
  768. #ifdef OPERATORTIME
  769.   printz (CP[94]);
  770.   scanz ("%hd", &OperatorTime);
  771. #endif
  772.   if (TCmoves == 0) {
  773.     TCflag = false;
  774.     MaxResponseTime = TCminutes*60L*100L + TCseconds*100L;
  775.     TCminutes = TCseconds = 0;
  776.   } else {
  777.     TCflag = true;
  778.     MaxResponseTime = 0;
  779.     MaxSearchDepth = MAXDEPTH - 1;
  780.   }
  781.   SetTimeControl ();
  782.   tmp = player;
  783.   player = white;
  784.   UpdateClocks();
  785.   player = black;
  786.   UpdateClocks();
  787.   player = tmp;
  788. }
  789.  
  790. #ifdef DEBUG
  791. void
  792. ChangeDbLev (void)
  793. {
  794.   printz (CP[146]);
  795.   scanz ("%hd", &debuglevel);
  796. }
  797.  
  798. #endif /* DEBUG */
  799.  
  800. #ifdef NEEDED
  801. void
  802. ChangeSearchDepth (void)
  803. {
  804.  int Old;
  805.  
  806.  Old = MaxSearchDepth;
  807.  MaxSearchDepth = SetAmigaDepth();
  808.   if (MaxSearchDepth)
  809.    {
  810.     TCflag = !(MaxSearchDepth > 0);
  811.     //if (MaxSearchDepth > 2)
  812.      //EnableMoveNow();
  813.    }
  814.   else
  815.    MaxSearchDepth = Old;
  816. }
  817. #endif
  818.  
  819. void ChangeHashDepth (void)
  820. {
  821. }
  822.  
  823. void
  824. SetContempt (void)
  825. {
  826. }
  827.  
  828. void
  829. ChangeXwindow (void)
  830. {
  831. }
  832.  
  833. #ifdef DEBUGG
  834. void
  835. ShowPostnValue (INTSIZE int sq)
  836.  
  837. /*
  838.  * must have called ExaminePosition() first
  839.  */
  840.  
  841. {
  842.   char astr[80];
  843.   INTSIZE score;
  844.  
  845.   score = ScorePosition (color[sq]);
  846.   if (color[sq] != neutral){
  847.     sprintf (astr,"%3d%c ", svalue[sq],(color[sq] == black)?'b':'w');}
  848.   else
  849.     sprintf(astr," *   ");
  850.   ShowMessage(astr);
  851. }
  852.  
  853. void
  854. DoDebug (void)
  855. {
  856. }
  857.  
  858. void
  859. DoTable (INTSIZE table[64])
  860. {
  861.   char astr[16];
  862.   INTSIZE  sq,j,k;
  863.   ExaminePosition ();
  864.   for(j=7;j>=0;j--){
  865.   for(k=0;k<8;k++){
  866.     sq=j*8+k;
  867.     sprintf (astr,"%3d ", table[sq]);
  868.     ShowMessage(astr);
  869.   }
  870. }
  871. }
  872.  
  873. void
  874. ShowPostnValues (void)
  875. {
  876.   INTSIZE sq, score,j,k;
  877.   char astr[64];
  878.  
  879.   ExaminePosition ();
  880.   for(j=7;j>=0;j--){
  881.   for(k=0;k<8;k++){
  882.   sq=j*8+k;
  883.     ShowPostnValue (sq);
  884.   }
  885.   }
  886.   score = ScorePosition (opponent);
  887.  sprintf (astr,CP[103], score, mtl[computer], pscore[computer], mtl[opponent],pscore[opponent]);
  888.  ShowMessage(astr);
  889.  sprintf(astr,"hung white %d hung black %d\n",hung[white],hung[black]);
  890.  ShowMessage(astr);
  891. }
  892.  
  893. #endif
  894.