home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 2 / FFMCD02.bin / new / game / think / uchess / source / uchessrc.lha / util.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-07-28  |  9.8 KB  |  430 lines
  1. /*
  2.  * util.c - C source for GNU 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. #include "gnuchess.h"
  24. unsigned int TTadd = 0;
  25. short int recycle;
  26. short int ISZERO = 1;
  27. extern char mvstr[4][6];
  28. #ifdef CACHE
  29. extern struct etable __far etab[2][ETABLE];
  30. #endif
  31.  
  32. int
  33. parse (FILE * fd, short unsigned int *mv, short int side, char *opening)
  34. {
  35.   register int c, i, r1, r2, c1, c2;
  36.   char s[128];
  37.   char *p;
  38.  
  39.   while ((c = getc (fd)) == ' ' || c == '\n') ;
  40.   i = 0;
  41.   s[0] = (char) c;
  42.   if (c == '!')
  43.     {
  44.       p = opening;
  45.       do
  46.     {
  47.       *p++ = c;
  48.       c = getc (fd);
  49.       if (c == '\n' || c == EOF)
  50.         {
  51.           *p = '\0';
  52.           return 0;
  53.         }
  54.       } while (true);
  55.     }
  56.   while (c != '?' && c != ' ' && c != '\t' && c != '\n' && c != EOF)
  57.     s[++i] = (char) (c = getc (fd));
  58.   s[++i] = '\0';
  59.   if (c == EOF)
  60.     return (-1);
  61.   if (s[0] == '!' || s[0] == ';' || i < 3)
  62.     {
  63.       while (c != '\n' && c != EOF)
  64.     c = getc (fd);
  65.       return (0);
  66.     }
  67.   if (s[4] == 'o')
  68.     *mv = ((side == black) ? LONGBLACKCASTLE : LONGWHITECASTLE);
  69.   else if (s[0] == 'o')
  70.     *mv = ((side == black) ? BLACKCASTLE : WHITECASTLE);
  71.   else
  72.     {
  73.       c1 = s[0] - 'a';
  74.       r1 = s[1] - '1';
  75.       c2 = s[2] - 'a';
  76.       r2 = s[3] - '1';
  77.       *mv = (locn (r1, c1) << 8) | locn (r2, c2);
  78.     }
  79.   if (c == '?')
  80.     {                /* Bad move, not for the program to play */
  81.       *mv |= 0x8000;        /* Flag it ! */
  82.       c = getc (fd);
  83.     }
  84.   return (1);
  85. }
  86.  
  87.  
  88. #if ttblsz
  89.  
  90. #define CB(i) (unsigned char) ((color[2 * (i)] ? 0x80 : 0)\
  91.            | (board[2 * (i)] << 4)\
  92.            | (color[2 * (i) + 1] ? 0x8 : 0)\
  93.            | (board[2 * (i) + 1]))
  94.  
  95. int
  96. ProbeTTable (short int side,
  97.          short int depth,
  98.          short int ply,
  99.          short int *alpha,
  100.          short int *beta,
  101.          short int *score)
  102.  
  103. /*
  104.  * Look for the current board position in the transposition table.
  105.  */
  106.  
  107. {
  108.   register struct hashentry *ptbl;
  109.   register /*unsigned*/ short i;  /*to match new type of rehash --tpm*/
  110.  
  111.   ptbl = &ttable[side][hashkey & (ttblsize - 1)];
  112.  
  113.   /* rehash max rehash times */
  114.   for (i = 0; (ptbl->depth) && (ptbl->hashbd != hashbd) && (i < rehash); i++) ptbl++;
  115.   if ((ptbl->depth>= (short)depth) && (ptbl->hashbd == hashbd))
  116. /*     ^^^^^^^^^^^^   we can use some informations of the entry even
  117.                       the depth is not large enough */
  118.     {
  119. #ifdef HASHTEST
  120.       for (i = 0; i < 32; i++)
  121.     {
  122.       if (ptbl->bd[i] != CB (i))
  123.         {
  124. #ifndef BAREBONES
  125.           HashCol++;
  126.           ShowMessage (CP[199]);    /*ttable collision detected*/
  127. #endif
  128.           break;
  129.         }
  130.     }
  131. #endif /* HASHTEST */
  132.  
  133.  
  134.       PV = SwagHt = ptbl->mv;
  135.       if ((short) ptbl->depth >= depth)
  136.     {
  137. #ifndef BAREBONES
  138.           HashCnt++;
  139. #endif
  140.       if (ptbl->flags & truescore)
  141.         {
  142.           *score = ptbl->score;
  143.           /* adjust *score so moves to mate is from root */
  144.           if (*score > 9000)
  145.         *score -= ply;
  146.           else if (*score < -9000)
  147.         *score += ply;
  148.           *beta = -20000;
  149.         }
  150. #ifdef notdef            /* Never happens! see search */
  151.       else if (ptbl->flags & upperbound)
  152.         {
  153.           if (ptbl->score < *beta)
  154.         *beta = ptbl->score + 1;
  155.         }
  156. #endif
  157.       else if (ptbl->flags & lowerbound)
  158.         {
  159.           if (ptbl->score > *alpha)
  160.         *alpha = ptbl->score - 1;
  161.         }
  162.       return (true);
  163.     }
  164.     }
  165.   return (false);
  166. }
  167.  
  168.  
  169. int
  170. PutInTTable (short int side,
  171.          short int score,
  172.          short int depth,
  173.          short int ply,
  174.          short int alpha,
  175.          short int beta,
  176.          short unsigned int mv)
  177.  
  178. /*
  179.  * Store the current board position in the transposition table.
  180.  */
  181.  
  182. {
  183.   register struct hashentry *ptbl;
  184.   register /*unsigned*/ short i;  /*to match new type of rehash --tpm*/
  185.  
  186.   ptbl = &ttable[side][hashkey & (ttblsize - 1)];
  187.  
  188.   /* rehash max rehash times */
  189.   for (i = 0; ptbl->depth && ptbl->hashbd != hashbd && i < rehash; i++)
  190.     ptbl++;
  191.   if (i == rehash) {
  192. #ifndef BAREBONES
  193.     THashCol++;
  194. #endif
  195.     ptbl += recycle;}
  196.   if (depth >= (short)ptbl->depth || ptbl->hashbd != hashbd)
  197.     {
  198. #ifndef BAREBONES
  199.       TTadd++;
  200.       HashAdd++; 
  201. #endif
  202.       ptbl->hashbd = hashbd;
  203.       ptbl->depth = (unsigned char) depth;
  204.       /* adjust score so moves to mate is from this ply */
  205.       if (score > 9000)
  206.     score += ply;
  207.       else if (score < -9000)
  208.     score -= ply;
  209.       ptbl->score = score;
  210.       ptbl->mv = mv;
  211. #ifdef DEBUG4
  212.       if (debuglevel & 32)
  213.     {
  214.       algbr (mv >> 8, mv & 0xff, 0);
  215.       printf ("-add-> d=%d s=%d p=%d a=%d b=%d %s\n", depth, score, ply, alpha, beta, mvstr);
  216.     }
  217. #endif
  218. /*#ifdef notdef
  219.       if (score < alpha)
  220.     ptbl->flags = upperbound;
  221.       else
  222. /*#endif /* 0 */
  223.       if (score > beta)
  224.     {
  225.       ptbl->flags = lowerbound;
  226.       ptbl->score = beta + 1;
  227.     }
  228.       else
  229.     ptbl->flags = truescore;
  230.  
  231. #ifdef HASHTEST
  232.       for (i = 0; i < 32; i++)
  233.     {
  234.       ptbl->bd[i] = CB (i);
  235.     }
  236. #endif /* HASHTEST */
  237.       return true;
  238.     }
  239.   return false;
  240. }
  241.  
  242.    
  243. static struct hashentry *ttagew, *ttageb;
  244.  
  245. void
  246. ZeroTTable (void)
  247. {
  248.    register struct hashentry *w, *b;
  249.  
  250. /* I am adding these 2 memsets! */
  251.   memset((char *)ttable[0],0,sizeof(struct hashentry)*(ttblsize+rehash));
  252.   memset((char *)ttable[1],0,sizeof(struct hashentry)*(ttblsize+rehash));
  253.   for(w=ttable[white],b=ttable[black];w<&ttable[white][ttblsize];w++,b++)
  254.    { w->depth = 0; b->depth = 0;}
  255.     ttagew = ttable[white]; ttageb = ttable[black];
  256. #ifdef CACHE
  257.    memset ((char *) etab, 0, sizeof (etab));
  258. #endif
  259. #ifdef notdef
  260.   register unsigned int a;
  261.   for (a = 0; a < ttblsize + (unsigned int)rehash; a++)
  262.     {
  263.       ttable[white][a].depth = 0;
  264.       ttable[black][a].depth = 0;
  265.     }
  266. #endif
  267.     TTadd = 0; 
  268. }
  269.  
  270. #ifdef HASHFILE
  271. int Fbdcmp(char *a,char *b)
  272. {
  273.     register int i;
  274.     for(i = 0;i<32;i++)
  275.         if(a[i] != b[i])return false;
  276.     return true;
  277. }
  278. int
  279. ProbeFTable (short int side,
  280.          short int depth,
  281.          short int ply,
  282.          short int *alpha,
  283.          short int *beta,
  284.          short int *score)
  285.  
  286. /*
  287.  * Look for the current board position in the persistent transposition table.
  288.  */
  289.  
  290. {
  291.   register short int i;
  292.   register unsigned long hashix;
  293.   struct fileentry new, t;
  294.  
  295.   hashix = ((side == white) ? (hashkey & 0xFFFFFFFE) : (hashkey | 1)) & filesz;
  296.  
  297.   for (i = 0; i < 32; i++)
  298.     new.bd[i] = CB (i);
  299.   new.flags = 0;
  300.   if (Mvboard[kingP[side]] == 0)
  301.     {
  302.       if (Mvboard[qrook[side]] == 0)
  303.     new.flags |= queencastle;
  304.       if (Mvboard[krook[side]] == 0)
  305.     new.flags |= kingcastle;
  306.     }
  307.   for (i = 0; i < frehash; i++)
  308.     {
  309.       fseek (hashfile,
  310.          sizeof (struct fileentry) * ((hashix + 2 * i) & (filesz)),
  311.          SEEK_SET);
  312.       fread (&t, sizeof (struct fileentry), 1, hashfile);
  313.       if (!t.depth) break;
  314.        if(!Fbdcmp(t.bd, new.bd)) continue;
  315.       if (((short int) t.depth >= depth) 
  316.       && (new.flags == (unsigned short)(t.flags & (kingcastle | queencastle))))
  317.     {
  318. #ifndef BAREBONES
  319.       FHashCnt++;
  320. #endif
  321.       PV = (t.f << 8) | t.t;
  322.       *score = (t.sh << 8) | t.sl;
  323.       /* adjust *score so moves to mate is from root */
  324.       if (*score > 9000)
  325.         *score -= ply;
  326.       else if (*score < -9000)
  327.         *score += ply;
  328.       if (t.flags & truescore)
  329.         {
  330.           *beta = -20000;
  331.         }
  332.       else if (t.flags & lowerbound)
  333.         {
  334.           if (*score > *alpha)
  335.         *alpha = *score - 1;
  336.         }
  337.       else if (t.flags & upperbound)
  338.         {
  339.           if (*score < *beta)
  340.         *beta = *score + 1;
  341.         }
  342.       return (true);
  343.     }
  344.     }
  345.   return (false);
  346. }
  347.  
  348. void
  349. PutInFTable (short int side,
  350.          short int score,
  351.          short int depth,
  352.          short int ply,
  353.          short int alpha,
  354.          short int beta,
  355.          short unsigned int f,
  356.          short unsigned int t)
  357.  
  358. /*
  359.  * Store the current board position in the persistent transposition table.
  360.  */
  361.  
  362. {
  363.   register unsigned short i;
  364.   register unsigned long hashix;
  365.   struct fileentry new, tmp;
  366.  
  367.   hashix = ((side == white) ? (hashkey & 0xFFFFFFFE) : (hashkey | 1)) & filesz;
  368.   for (i = 0; i < 32; i++) new.bd[i] = CB (i);
  369.   new.f = (unsigned char) f;
  370.   new.t = (unsigned char) t;
  371.   if (score < alpha)
  372.     new.flags = upperbound;
  373.   else
  374.     new.flags = ((score > beta) ? lowerbound : truescore);
  375.   if (Mvboard[kingP[side]] == 0)
  376.     {
  377.       if (Mvboard[qrook[side]] == 0)
  378.     new.flags |= queencastle;
  379.       if (Mvboard[krook[side]] == 0)
  380.     new.flags |= kingcastle;
  381.     }
  382.   new.depth = (unsigned char) depth;
  383.   /* adjust *score so moves to mate is from root */
  384.   if (score > 9000)
  385.     score += ply;
  386.   else if (score < -9000)
  387.     score -= ply;
  388.  
  389.  
  390.   new.sh = (unsigned char) (score >> 8);
  391.   new.sl = (unsigned char) (score & 0xFF);
  392.  
  393.   for (i = 0; i < frehash; i++)
  394.     {
  395.       fseek (hashfile,
  396.          sizeof (struct fileentry) * ((hashix + 2 * i) & (filesz)),
  397.          SEEK_SET);
  398.       if(fread (&tmp, sizeof (struct fileentry), 1, hashfile) == NULL){perror("hashfile");exit(1);}
  399.       if (tmp.depth && !Fbdcmp(tmp.bd,new.bd))continue;
  400.       if(tmp.depth == depth)break;
  401.       if (!tmp.depth || (short) tmp.depth < depth)
  402.     {
  403.       fseek (hashfile,
  404.          sizeof (struct fileentry) * ((hashix + 2 * i) & (filesz)),
  405.          SEEK_SET);
  406.       fwrite (&new, sizeof (struct fileentry), 1, hashfile);
  407. #ifndef BAREBONES
  408.           FHashAdd++;
  409. #endif
  410.       break;
  411.     }
  412.     }
  413. }
  414.  
  415. #endif /* HASHFILE */
  416. #endif /* ttblsz */
  417.  
  418. void
  419. ZeroRPT (void)
  420. {
  421. #ifdef NOMEMSET
  422.   register int side, i;
  423.   for (side = white; side <= black; side++)
  424.     for (i = 0; i < 256;)
  425.       rpthash[side][i++] = 0;
  426. #else
  427.    if(ISZERO){memset ((char *) rpthash, 0, sizeof (rpthash));ISZERO=0;}
  428. #endif
  429. }
  430.