home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / gnu / gnushogi-1.1 / src / main.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-04-17  |  13.6 KB  |  620 lines
  1. /*
  2.  * main.c - C source for GNU SHOGI based on GNU CHESS
  3.  *
  4.  * Copyright (c) 1988,1989,1990 John Stanback (GNU Chess)
  5.  * Copyright (c) 1992 Free Software Foundation 
  6.  * Copyright (c) 1993 Matthias Mutz (GNU Shogi)
  7.  *
  8.  * This file is part of GNU SHOGI.
  9.  *
  10.  * GNU Shogi is free software; you can redistribute it and/or modify
  11.  * it under the terms of the GNU General Public License as published by
  12.  * the Free Software Foundation; either version 1, or (at your option)
  13.  * any later version.
  14.  *
  15.  * GNU Shogi is distributed in the hope that it will be useful,
  16.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18.  * GNU General Public License for more details.
  19.  *
  20.  * You should have received a copy of the GNU General Public License
  21.  * along with GNU Shogi; see the file COPYING.  If not, write to
  22.  * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  23.  */
  24.  
  25.  
  26. #if !defined NO_MAIN
  27.  
  28. #include "version.h"
  29. #include "gnushogi.h"
  30.  
  31. #endif
  32.  
  33. #include <signal.h>
  34.  
  35. #if defined THINK_C
  36. #include <console.h>
  37. #include <time.h>
  38. #define MAKE_BOOK
  39. #endif
  40.  
  41. #if !defined K32SEGMENTS
  42. #include "main_data1.c"
  43. #include "main_data2.c"
  44. #endif
  45.  
  46.  
  47. #if defined HASGETTIMEOFDAY && defined THINK_C
  48.  
  49. #define USEC_PER_CLOCK (1000000 / CLOCKS_PER_SEC)
  50.  
  51. int gettimeofday(struct timeval *tp, void *tzp)
  52. { 
  53.    long clock_count = (long)clock();
  54.    tp->tv_sec = clock_count / CLOCKS_PER_SEC;
  55.    tp->tv_usec = (clock_count % CLOCKS_PER_SEC) * USEC_PER_CLOCK;
  56.    return(0);
  57. }
  58.  
  59. #endif
  60.  
  61. /*
  62.  * In a networked enviroment gnuchess might be compiled on different hosts
  63.  * with different random number generators, that is not acceptable if they
  64.  * are going to share the same transposition table.
  65.  */
  66. unsigned long int next = 1;
  67.  
  68. unsigned int
  69. urand (void)
  70. {
  71.   next *= 1103515245;
  72.   next += 12345;
  73.   return ((unsigned int) (next >> 16) & 0xFFFF);
  74. }
  75.  
  76. void
  77. gsrand (unsigned int seed)
  78. {
  79.   next = seed;
  80. }
  81.  
  82. #if ttblsz
  83. struct hashentry huge *ttable[2];
  84. unsigned int ttblsize;
  85. #endif
  86. #ifdef BINBOOK
  87. extern char *binbookfile;
  88. #endif
  89. extern char *bookfile;
  90.  
  91. unsigned long hashkey, hashbd;
  92. struct hashval hashcode[2][NO_PIECES][NO_SQUARES+(2*NO_PIECES)];
  93.  
  94. char savefile[128] = "";
  95. char listfile[128] = "";
  96.  
  97. #if defined HISTORY
  98. unsigned short *history;
  99. #endif
  100.  
  101. short rpthash[2][256];
  102. short TrPnt[MAXDEPTH];
  103. small_short PieceList[2][NO_SQUARES];
  104. small_short PawnCnt[2][NO_COLS];
  105. small_short Captured[2][NO_PIECES];
  106. small_short Mvboard[NO_SQUARES];
  107. short svalue[NO_SQUARES];
  108. struct flags flag;
  109.  
  110. short opponent, computer, WAwindow, WBwindow, BAwindow, BBwindow, dither,
  111.   INCscore;
  112. long ResponseTime, ExtraTime, MaxResponseTime, et, et0, time0, ft;
  113. long GenCnt, NodeCnt, ETnodes, EvalNodes, HashCnt, HashAdd, FHashCnt, FHashAdd,
  114.   HashCol, THashCol, filesz, hashmask, hashbase;
  115. long replus, reminus;
  116. short HashDepth = HASHDEPTH, HashMoveLimit = HASHMOVELIMIT;
  117. short player, xwndw;
  118. /*unsigned*/ short rehash; /* -1 is used as a flag --tpm */
  119. short Sdepth, Game50, MaxSearchDepth;
  120. short GameCnt = 0;
  121. short contempt;
  122. int Book;
  123. struct TimeControlRec TimeControl;
  124. int TCadd = 0;
  125. short TCflag, TCmoves, TCminutes, TCseconds, OperatorTime;
  126. short XCmoves[3], XCminutes[3], XCseconds[3], XC, XCmore;
  127. const short otherside[3] =
  128. {white, black, neutral};
  129. unsigned short hint;
  130. short int TOflag;        /* force search re-init if we backup search */
  131.  
  132. unsigned short killr0[MAXDEPTH], killr1[MAXDEPTH];
  133. unsigned short killr2[MAXDEPTH], killr3[MAXDEPTH];
  134. unsigned short PV, SwagHt, Swag0, Swag1, Swag2, Swag3, Swag4, sidebit;
  135.  
  136. const small_short sweep[NO_PIECES] =
  137. {false, false, true,  false, false, false, true, true,
  138.         false, false, false, false, true,  true,  false };
  139. small_short HasPiece[2][NO_PIECES]; 
  140. const short kingP[3] =
  141. {4, 76, 0};
  142. const short value[NO_PIECES] =
  143. {0, valueP,  valueL,  valueN,  valueS,  valueG,  valueB,  valueR,
  144.     valuePp, valueLp, valueNp, valueSp, valueBp, valueRp, valueK}; 
  145. const small_short relative_value[NO_PIECES] =
  146. {0, 1,       3,       4,       7,       9,       10,      12, 
  147.     2,       5,       6,       8,       11,      13,      14};
  148. const long control[NO_PIECES] =
  149. {0, ctlP, ctlL, ctlN, ctlS, ctlG, ctlB, ctlR,
  150.     ctlPp, ctlLp, ctlNp, ctlSp, ctlBp, ctlRp, ctlK };
  151.  
  152. short stage, stage2;
  153.  
  154. FILE *hashfile;
  155.  
  156. unsigned int starttime;
  157. short int ahead = true, hash = true;
  158.  
  159.  
  160. #if defined XSHOGI
  161. void
  162. TerminateChess (int sig)
  163. {
  164.   ExitChess ();
  165. }
  166.  
  167. #endif
  168.  
  169.  
  170.  
  171. int timeopp[MINGAMEIN], timecomp[MINGAMEIN];
  172. int compptr, oppptr;
  173. inline void
  174. TimeCalc ()
  175. {
  176. /* adjust number of moves remaining in gamein games */
  177.   int increment = 0;
  178.   int topsum = 0;
  179.   int tcompsum = 0;
  180.   int me,him;
  181.   int i;
  182. /* dont do anything til you have enough numbers */
  183.   if (GameCnt < (MINGAMEIN * 2)) return;
  184. /* calculate average time in sec for last MINGAMEIN moves */
  185.   for (i = 0; i < MINGAMEIN; i++)
  186.     {
  187.       tcompsum += timecomp[i];
  188.       topsum += timeopp[i];
  189.     }
  190.   topsum /= (100 * MINGAMEIN);
  191.   tcompsum /= (100 * MINGAMEIN);
  192. /* if I have less time than opponent add another move */
  193.     me = TimeControl.clock[computer]/100; 
  194.     him = TimeControl.clock[opponent]/100;
  195.     if(me < him) increment += 2;
  196.     if((him - me) > 60 || (me<him && me < 120))increment++;
  197. /* if I am losing more time with each move add another */
  198.   /*if ( !((me - him) > 60) && tcompsum > topsum) increment++;*/
  199.   if ( tcompsum > topsum) increment +=2;
  200. /* but dont let moves go below MINMOVES */
  201.   else if (TimeControl.moves[computer] < MINMOVES && !increment) increment++;
  202. /* if I am doing really well use more time per move */
  203.   else if (me > him && tcompsum < topsum) increment = -1;
  204.   TimeControl.moves[computer] += increment;
  205. }
  206.  
  207.  
  208.  
  209.  
  210. #ifdef DEBUG_INITS
  211.  
  212. /* print all possible moves for all pieces from all squares */
  213.  
  214. void DebugInits ()
  215. {                    
  216.    register short u, sq;
  217.    register unsigned char *ppos, *pdir;
  218.    char s[10];
  219.    short piece, ptyp;
  220.  
  221.    for ( piece = 0; piece < NO_PIECES; piece++ ) {
  222.      printf("move list for piece %i\n",piece);
  223.      for ( sq = 0; sq < NO_SQUARES; sq++ ) {
  224.        printf("  from square %i to ",sq);
  225.        ptyp = ptype[black][piece];
  226.        ppos = (*nextpos[ptyp])[sq];
  227.        u = ppos[sq]; 
  228.        do {
  229.           printf("%i",u);
  230.           u = ppos[u];
  231.           if (u != sq) printf(", ");
  232.        } while (u != sq); 
  233.        printf("\n");
  234.      };
  235.      /* pdir = (*nextdir[ptyp])[sq]; */
  236.      printf("\n");
  237.      scanf("%s",s);
  238.      if ( strcmp(s,"exit") == 0 )
  239.        exit(0);
  240.    };
  241. }
  242.  
  243. #endif          
  244.  
  245.  
  246. #if !defined NO_MAIN
  247.  
  248.  
  249. /* hmm.... shouldn`t main be moved to the interface routines */
  250. int
  251. main (int argc, char **argv)
  252. {
  253.   char *xwin = 0;
  254.   char *Lang = NULL;
  255.   size_t n;
  256. #ifdef THINK_C
  257.   console_options.ncols = 100;
  258.   cshow(stdout);
  259. #endif
  260. #if defined CACHE
  261.   n = sizeof(struct etable) * (size_t)ETABLE;
  262.   if ( !(etab[0] = (etable_field *)malloc(n)) ) {
  263.     ShowMessage ("cannot allocate cache table 0\n");
  264.   }
  265.   if ( !(etab[1] = (etable_field *)malloc(n)) ) {
  266.     ShowMessage ("cannot allocate cache table 1\n");
  267.   }
  268. #endif
  269. #if defined HISTORY
  270.   if ( !(history = (unsigned short *)malloc(sizeof_history)) ) {
  271.     ShowMessage ("cannot allocate history table\n");
  272.   }
  273. #endif
  274. #if defined THINK_C
  275.   gsrand (starttime = ((unsigned int) time ((time_t *) 0)));    /* init urand */
  276. #else
  277.   gsrand (starttime = ((unsigned int) time ((long *) 0)));    /* init urand */
  278. #endif
  279. #if ttblsz
  280.   ttblsize = ttblsz;
  281.   rehash = -1;
  282. #endif /* ttblsz */
  283.   if (argc > 2)
  284.     {
  285.       if (argv[1][0] == '-' && argv[1][1] == 'L')
  286.     {
  287.       Lang = argv[2];
  288.       argv += 2;
  289.       argc -= 2;
  290.     }
  291.     }
  292.   InitConst (Lang);
  293.   ColorStr[0] = CP[118];
  294.   ColorStr[1] = CP[119];
  295.   
  296. #if defined MAKE_BOOK
  297.   bookfile = BOOK;
  298.   binbookfile = BINBOOK;
  299.   booksize = 8000;
  300.   bookmaxply = 40;
  301. #endif
  302.  
  303.   while (argc > 1 && ((argv[1][0] == '-') || (argv[1][0] == '+')))
  304.     {
  305.       switch (argv[1][1])
  306.     {
  307.     case 'a':
  308.       ahead = ((argv[1][0] == '-') ? false : true);
  309.       break;
  310.     case 'b':
  311.       argv++;
  312.       argc--;
  313.       if (argc > 1)
  314.         {
  315.           bookfile = argv[1];
  316. #ifdef BINBOOK
  317.           binbookfile = NULL;
  318. #endif
  319.         }
  320.       break;
  321. #ifdef BINBOOK
  322.     case 'B':
  323.       argv++;
  324.       argc--;
  325.       if (argc > 1)
  326.         binbookfile = argv[1];
  327.       break;
  328. #endif
  329.     case 'h':
  330.       hash = ((argv[1][0] == '-') ? false : true);
  331.       break;
  332.     case 's':
  333.       argc--;
  334.       argv++;
  335.       if (argc > 1)
  336.         strcpy (savefile, argv[1]);
  337.       break; 
  338.     case 'l':
  339.       argc--;
  340.       argv++;
  341.       if (argc > 1)
  342.         strcpy (listfile, argv[1]);
  343.       break;
  344.     case 'S':
  345.       argc--;
  346.       argv++;
  347.       if(argc > 1)booksize = atoi(argv[1]);
  348.       break;
  349.     case 'P':
  350.       argc--;
  351.       argv++;
  352.       if(argc > 1)bookmaxply = atoi(argv[1]);
  353.       break;
  354.  
  355. #if ttblsz
  356.     case 'r':
  357.       if (argc > 2)
  358.         rehash = atoi (argv[2]);
  359.       argc--;
  360.       argv++;
  361.       if (rehash > MAXrehash)
  362.         rehash = MAXrehash;
  363.       break;
  364.     case 'T':
  365.       if (argc > 2)
  366.         ttblsize = atoi (argv[2]);
  367.       argc--;
  368.       argv++;
  369.       if (ttblsize > 0 && ttblsize < 24)
  370.         ttblsize = (1 << ttblsize);
  371.       else
  372.         ttblsize = ttblsz;
  373.       break;
  374. #ifdef HASHFILE
  375.     case 't':    /* create or test persistent transposition
  376.                  * table */
  377.       hashfile = fopen (HASHFILE, RWA_ACC);
  378.       if (hashfile)
  379.         {
  380.           fseek (hashfile, 0L, SEEK_END);
  381.           filesz = (ftell (hashfile) / sizeof (struct fileentry)) - 1;
  382.         }
  383.       if (hashfile != NULL)
  384.         {
  385.           long i, j;
  386.           int nr[MAXDEPTH];
  387.           struct fileentry n;
  388.  
  389.           printf (CP[49]);
  390.           for (i = 0; i < MAXDEPTH; i++)
  391.         nr[i] = 0;
  392.           fseek (hashfile, 0L, SEEK_END);
  393.           i = ftell (hashfile) / sizeof (struct fileentry);
  394.           fseek (hashfile, 0L, SEEK_SET);
  395.           for (j = 0; j < i + 1; j++)
  396.         {
  397.           fread (&n, sizeof (struct fileentry), 1, hashfile);
  398. if(n.depth >MAXDEPTH) {printf("ERROR\n");exit(1);}
  399.           if (n.depth)
  400.             {
  401.               nr[n.depth]++;
  402.               nr[0]++;
  403.             }
  404.         }
  405.           printf (CP[109],
  406.               nr[0], i);
  407.           for (j = 1; j < MAXDEPTH; j++)
  408.         printf ("%d ", nr[j]);
  409.           printf ("\n");
  410.         }
  411.       return 0;
  412.     case 'c':        /* create or test persistent transposition
  413.                  * table */
  414.       if (argc > 2)
  415.         filesz = atoi (argv[2]);
  416.       if (filesz > 0 && filesz < 24)
  417.         filesz = (1 << filesz) - 1 + MAXrehash;
  418.       else
  419.         filesz = Deffilesz + MAXrehash;
  420.       if ((hashfile = fopen (HASHFILE, RWA_ACC)) == NULL)
  421.         hashfile = fopen (HASHFILE, WA_ACC);
  422.       if (hashfile != NULL)
  423.         {
  424.           long j;
  425.           struct fileentry n;
  426.  
  427.           printf (CP[66]);
  428.           n.f = n.t = 0;
  429.           n.flags = 0;
  430.           n.depth = 0;
  431.           n.sh = n.sl = 0;
  432.           for (j = 0; j < filesz + 1; j++)
  433.         fwrite (&n, sizeof (struct fileentry), 1, hashfile);
  434.           fclose (hashfile);
  435.         }
  436.       else
  437.         printf (CP[50], HASHFILE);
  438.       return (0);
  439. #endif /* HASHFILE */
  440. #endif /* ttblsz */
  441.     case 'x':
  442.       xwin = &argv[1][2];
  443.       break;
  444.     case 'v':
  445.       fprintf (stderr, CP[102], version, patchlevel);
  446.       exit (1);
  447.     default:
  448.       fprintf (stderr, CP[113]);
  449.       exit (1);
  450.     }
  451.       argv++;
  452.       argc--;
  453.     }
  454.   XC = 0;
  455.   MaxResponseTime = 0;
  456. #if defined XSHOGI
  457.   signal (SIGTERM, TerminateChess);
  458. #endif
  459. #if defined XSHOGI
  460.   TCflag = true;
  461.   TCmoves = 40;
  462.   TCminutes = 5;
  463.   TCseconds = 0;
  464.   TCadd = 0;
  465.   OperatorTime = 0;
  466. #else
  467.   TCflag = false;
  468.   OperatorTime = 0;
  469. #endif
  470.   if (argc == 2)
  471.     {
  472.       char *p;
  473.       
  474.       MaxResponseTime = 100L * strtol (argv[1], &p, 10);
  475.       if (*p == ':')
  476.     MaxResponseTime = 60L * MaxResponseTime +
  477.       100L * strtol (++p, (char **) NULL, 10);
  478.       TCflag = false;
  479.       TCmoves = 0;
  480.       TCminutes = 0;
  481.       TCseconds = 0;
  482.     }
  483.   if (argc >= 3)
  484.     {
  485.       char *p;
  486.       if (argc > 9)
  487.     {
  488.       printf ("%s\n", CP[220]);
  489.       exit (1);
  490.     }
  491.       TCmoves = atoi (argv[1]);
  492.       TCminutes = (short)strtol (argv[2], &p, 10);
  493.       if (*p == ':')
  494.     TCseconds = (short)strtol (p + 1, (char **) NULL, 10);
  495.       else
  496.     TCseconds = 0;
  497.       TCflag = true;
  498.       argc -= 3;
  499.       argv += 3;
  500.       while (argc > 1)
  501.     {
  502.       XCmoves[XC] = atoi (argv[0]);
  503.       XCminutes[XC] = (short)strtol (argv[1], &p, 10);
  504.       if (*p == ':')
  505.         XCseconds[XC] = (short)strtol (p + 1, (char **) NULL, 10);
  506.       else
  507.         XCseconds[XC] = 0;
  508.       if (XCmoves[XC] && (XCminutes[XC] || XCseconds[XC]))
  509.         XC++;
  510.       else
  511.         {
  512.           printf (CP[220]);
  513.           exit (1);
  514.         }
  515.       argc -= 2;
  516.       argv += 2;
  517.     }
  518.       if (argc)
  519.     {
  520.       printf ("%s\n", CP[220]);
  521.       exit (1);
  522.     }
  523.     }
  524.   Initialize ();
  525.   Initialize_dist ();
  526.   Initialize_moves ();
  527. #ifdef DEBUG_INITS
  528.   DebugInits ();
  529. #endif
  530.   NewGame ();
  531.  
  532.   flag.easy = ahead;
  533.   flag.hash = hash;
  534.   if (xwin)
  535.     xwndw = atoi (xwin);
  536.  
  537.   hashfile = NULL;
  538. #if ttblsz
  539. #ifdef HASHFILE
  540.   hashfile = fopen (HASHFILE, RWA_ACC);
  541.   if (hashfile)
  542.     {
  543.       fseek (hashfile, 0L, SEEK_END);
  544.       filesz = ftell (hashfile) / sizeof (struct fileentry) - 1 - MAXrehash;
  545.               hashmask = filesz>>1;
  546.           hashbase = hashmask+1;
  547.     }               
  548. #else
  549. #ifndef BAREBONES
  550. #ifdef HASHFILE
  551.   else
  552. #endif
  553.     gotoXY (3, 0);
  554.     ShowMessage (CP[98]);
  555. #endif
  556. #endif /* HASHFILE */
  557. #endif /* ttblsz */
  558.   while (!(flag.quit))
  559.     {
  560.       oppptr = (oppptr + 1) % MINGAMEIN;
  561.       if (flag.bothsides && !flag.mate)
  562.     SelectMove (opponent, 1);
  563.       else
  564.     InputCommand ();
  565.       if (opponent == white)
  566.     if (flag.gamein || TCadd)
  567.       {
  568.         TimeCalc ();
  569.       }
  570.     else if (TimeControl.moves[opponent] == 0)
  571.       {
  572.         if (XC)
  573.           if (XCmore < XC)
  574.         {
  575.           TCmoves = XCmoves[XCmore];
  576.           TCminutes = XCminutes[XCmore];
  577.           TCseconds = XCseconds[XCmore];
  578.           XCmore++;
  579.         }
  580.         SetTimeControl ();
  581.       }
  582.  
  583.       compptr = (compptr + 1) % MINGAMEIN;
  584.       if (!(flag.quit || flag.mate || flag.force))
  585.     {
  586.       SelectMove (computer, 1);
  587.       if (computer == white)
  588.         if (flag.gamein)
  589.           {
  590.         TimeCalc ();
  591.           }
  592.         else if (TimeControl.moves[computer] == 0)
  593.           {
  594.         if (XC)
  595.           if (XCmore < XC)
  596.             {
  597.               TCmoves = XCmoves[XCmore];
  598.               TCminutes = XCminutes[XCmore];
  599.               TCseconds = XCseconds[XCmore];
  600.               XCmore++;
  601.             }
  602.         SetTimeControl ();
  603.           }
  604.     }
  605.     }
  606. #if ttblsz
  607. #ifdef HASHFILE
  608.   if (hashfile)
  609.     fclose (hashfile);
  610. #endif /* HASHFILE */
  611. #endif /* ttblsz */
  612.  
  613.   ExitChess ();
  614.   return (0);
  615. }
  616.  
  617.  
  618. #endif /* NO_MAIN */
  619.  
  620.