home *** CD-ROM | disk | FTP | other *** search
/ C!T ROM 5 / ctrom5b.zip / ctrom5b / OS2 / SPEL / UCHESS / UCHESSRC / UTIL.C < prev    next >
Text File  |  1994-11-01  |  13KB  |  577 lines

  1. //#define ZEROCACHE 1
  2. /*
  3.  * util.c - C source for GNU CHESS
  4.  *
  5.  * Copyright (c) 1988,1989,1990 John Stanback
  6.  * Copyright (c) 1992 Free Software Foundation
  7.  *
  8.  * This file is part of GNU CHESS.
  9.  *
  10.  * GNU Chess 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 2, or (at your option)
  13.  * any later version.
  14.  *
  15.  * GNU Chess 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 Chess; see the file COPYING.  If not, write to
  22.  * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  23.  */
  24. #include "gnuchess.h"
  25. unsigned int __aligned TTadd = 1;
  26. short int __aligned recycle;
  27. short int __aligned ISZERO = 1;
  28. extern char mvstr[8][8];
  29. #ifdef CACHE
  30. //extern struct etable __far __aligned etab[2][ETABLE];
  31. extern struct etable *etab[2];
  32. extern int etblsize;
  33. #endif
  34.  
  35. #ifndef AMIGA
  36. void MoveMem128(src,dest)
  37. void *src,*dest;
  38. {
  39.  register unsigned long *a,*b;
  40.  
  41.  a = (unsigned long *)dest;
  42.  b = (unsigned long *)src;
  43.  *a++ = *b++;
  44.  *a++ = *b++;
  45.  *a++ = *b++;
  46.  *a++ = *b++;
  47.  *a++ = *b++;
  48.  *a++ = *b++;
  49.  *a++ = *b++;
  50.  *a++ = *b++;
  51.  *a++ = *b++;
  52.  *a++ = *b++;
  53.  *a++ = *b++;
  54.  *a++ = *b++;
  55.  *a++ = *b++;
  56.  *a++ = *b++;
  57.  *a++ = *b++;
  58.  *a++ = *b++;
  59.  *a++ = *b++;
  60.  *a++ = *b++;
  61.  *a++ = *b++;
  62.  *a++ = *b++;
  63.  *a++ = *b++;
  64.  *a++ = *b++;
  65.  *a++ = *b++;
  66.  *a++ = *b++;
  67.  *a++ = *b++;
  68.  *a++ = *b++;
  69.  *a++ = *b++;
  70.  *a++ = *b++;
  71.  *a++ = *b++;
  72.  *a++ = *b++;
  73.  *a++ = *b++;
  74.  *a++ = *b++;
  75. }
  76.  
  77. void ClearMem(dest,cnt)
  78. void *dest;
  79. ULONG cnt;
  80. {
  81.  unsigned long *lptr;
  82.  unsigned char *cptr;
  83.  register int i;
  84.  ULONG rem,num;
  85.  
  86.  lptr = (unsigned long *)dest;
  87.  num = cnt >> 3; // cnt divided by 8
  88.  rem = cnt & 7; // remainder of cnt div 8
  89.  for(i=0;i<num;i++)
  90.   {
  91.    *lptr++ = 0L;
  92.    *lptr++ = 0L;
  93.   }
  94.  cptr = (unsigned char *)lptr;
  95.  while (rem)
  96.   {
  97.    *cptr++ = 0;
  98.    rem--;
  99.   }
  100. }
  101. #endif
  102.  
  103. int
  104. parse (FILE * fd, short unsigned int *mv, short int side, char *opening)
  105. {
  106.   register int c, i, r1, r2, c1, c2;
  107.   char s[128];
  108.   char *p;
  109.  
  110.   while ((c = getc (fd)) == ' ' || c == '\n') ;
  111.   i = 0;
  112.   s[0] = (char) c;
  113.   if (c == '!')
  114.     {
  115.       p = opening;
  116.       do
  117.     {
  118.       *p++ = c;
  119.       c = getc (fd);
  120.       if (c == '\n' || c == EOF)
  121.         {
  122.           *p = '\0';
  123.           return 0;
  124.         }
  125.       } while (true);
  126.     }
  127.   while (c != '?' && c != ' ' && c != '\t' && c != '\n' && c != EOF)
  128.     s[++i] = (char) (c = getc (fd));
  129.   s[++i] = '\0';
  130.   if (c == EOF)
  131.     return (-1);
  132.   if (s[0] == '!' || s[0] == ';' || i < 3)
  133.     {
  134.       while (c != '\n' && c != EOF)
  135.     c = getc (fd);
  136.       return (0);
  137.     }
  138.   if (s[4] == 'o')
  139.     *mv = ((side == black) ? LONGBLACKCASTLE : LONGWHITECASTLE);
  140.   else if (s[0] == 'o')
  141.     *mv = ((side == black) ? BLACKCASTLE : WHITECASTLE);
  142.   else
  143.     {
  144.       c1 = s[0] - 'a';
  145.       r1 = s[1] - '1';
  146.       c2 = s[2] - 'a';
  147.       r2 = s[3] - '1';
  148.       *mv = (locn (r1, c1) << 8) | locn (r2, c2);
  149.     }
  150.   if (c == '?')
  151.     {                           /* Bad move, not for the program to play */
  152.       *mv |= 0x8000;            /* Flag it ! */
  153.       c = getc (fd);
  154.     }
  155.   return (1);
  156. }
  157.  
  158. #ifdef OLDTTABLE
  159.  
  160. #if ttblsz
  161.  
  162. #define CB(i) (unsigned char) ((color[2 * (i)] ? 0x80 : 0)\
  163.            | (board[2 * (i)] << 4)\
  164.            | (color[2 * (i) + 1] ? 0x8 : 0)\
  165.            | (board[2 * (i) + 1]))
  166.  
  167. int
  168. ProbeTTable (short int side,
  169.          short int depth,
  170.          short int ply,
  171.          short int *alpha,
  172.          short int *beta,
  173.          short int *score)
  174.  
  175. /*
  176.  * Look for the current board position in the transposition table.
  177.  */
  178.  
  179. {
  180.   register struct hashentry *ptbl;
  181.   register /*unsigned*/ short i= 0;  /*to match new type of rehash --tpm*/
  182.  
  183.   ptbl = &ttable[side][hashkey % (ttblsize)];
  184.  
  185.   while (true)
  186.     {
  187.       if (ptbl->depth == 0)
  188.     return false;
  189.       if (ptbl->hashbd == hashbd)
  190.     break;
  191.       if (++i > rehash)
  192.     return false;
  193.       ptbl++;
  194.     }
  195.  
  196.   /* rehash max rehash times */
  197.   PV = SwagHt = ptbl->mv; // this is out of loop, in loop was wierd
  198.   if ((ptbl->depth >= (short) depth))
  199.     {
  200. #ifdef HASHTEST
  201.       for (i = 0; i < 32; i++)
  202.     {
  203.       if (ptbl->bd[i] != CB (i))
  204.         {
  205. #ifndef BAREBONES
  206.           HashCol++;
  207.           ShowMessage (CP[199]);    /*ttable collision detected*/
  208. #endif
  209.           break;
  210.         }
  211.     }
  212. #endif /* HASHTEST */
  213.  
  214.  
  215. //      PV = SwagHt = ptbl->mv; // was in loop in 4PL64 moved out for better perf
  216. #ifndef BAREBONES
  217.       HashCnt++;
  218. #endif
  219.       if (ptbl->flags & truescore)
  220.     {
  221.       *score = ptbl->score;
  222.       /* adjust *score so moves to mate is from root */
  223.       if (*score > 9000)
  224.         *score -= ply;
  225.       else if (*score < -9000)
  226.         *score += ply;
  227.       *beta = -20000;
  228.     }
  229.       else if (ptbl->flags & lowerbound)
  230.     {
  231.       if (ptbl->score > *alpha)
  232.         *alpha = ptbl->score; //  - 1;  FIX by K. Sian, was ptbl->score - 1
  233.     }
  234.       return (true);
  235.     }
  236.   return (false);
  237. }
  238.  
  239.  
  240.  
  241. #ifndef V4PL66
  242. int
  243. PutInTTable (short side,
  244.          short score,
  245.          short depth,
  246.          short ply,
  247.          short alpha,
  248.          short beta,
  249.          unsigned short mv)
  250.  
  251. /*
  252.  * Store the current board position in the transposition table.
  253.  */
  254.  
  255. {
  256.   register struct hashentry *ptbl;
  257.   register /*unsigned*/ short i = 0;    /*to match new type of rehash --tpm*/
  258.  
  259.   ptbl = &ttable[side][hashkey % ttblsize];
  260.   while (true)
  261.     {
  262.       if (ptbl->depth == 0 || ptbl->hashbd == hashbd)
  263.     break;
  264.       if (++i > rehash)
  265.     {
  266. #ifndef BAREBONES
  267.       THashCol++;
  268. #endif
  269.       ptbl += recycle;
  270.       break;
  271.     }
  272.       ptbl++;
  273.     }
  274.  
  275.   TTadd++;
  276. #ifndef BAREBONES
  277.   HashAdd++;
  278. #endif
  279.   ptbl->hashbd = hashbd;
  280.   ptbl->depth = (unsigned char) depth;
  281.   ptbl->mv = mv;
  282. #ifdef DEBUG
  283.   if (debuglevel & 32)
  284.     {
  285.       algbr (mv >> 8, mv & 0xff, 0);
  286.       printf ("-add-> h=%lx d=%d s=%d p=%d a=%d b=%d %s\n", hashbd, depth,
  287.          score , ply, alpha, beta, mvstr);
  288.     }
  289. #endif
  290.   if (score > beta)
  291.     {
  292.       ptbl->flags = lowerbound;
  293.       ptbl->score = beta + 1;
  294.     }
  295.   else
  296.     {
  297.       ptbl->flags = truescore;
  298.       /* adjust score so moves to mate is from this ply */
  299.       if (score > 9000)
  300.     score += ply;
  301.       else if (score < -9000)
  302.     score -= ply;
  303.       ptbl->score = score;
  304.     }
  305.  
  306. #ifdef HASHTEST
  307.   for (i = 0; i < 32; i++)
  308.     {
  309.       ptbl->bd[i] = CB (i);
  310.     }
  311. #endif /* HASHTEST */
  312.   return true;
  313. }
  314.  
  315. #else
  316. int
  317. PutInTTable (short int side,
  318.          short int score,
  319.          short int depth,
  320.          short int ply,
  321.          short int alpha,
  322.          short int beta,
  323.          short unsigned int mv)
  324.  
  325. /*
  326.  * Store the current board position in the transposition table.
  327.  */
  328.  
  329. {
  330.   register struct hashentry *ptbl;
  331.   register /*unsigned*/ short i= 0;  /*to match new type of rehash --tpm*/
  332.  
  333.   ptbl = &ttable[side][hashkey % (ttblsize)];
  334.  
  335.   while (true)
  336.     {
  337. //      if (ptbl->depth == 0 || ptbl->hashbd == hashbd)
  338. //      break;
  339.        if (ptbl->depth == 0) break;
  340.        else if(ptbl->hashbd == hashbd  && ptbl->depth > depth && abs(score) <9000) 
  341.      return false;
  342.        else if (ptbl->hashbd == hashbd) break;
  343.       if (++i > rehash)
  344.     {
  345. #ifndef BAREBONES
  346.       THashCol++;
  347. #endif
  348.       ptbl += recycle;
  349.       break;
  350.     }
  351.       ptbl++;
  352.     }
  353.  
  354. #ifndef BAREBONES
  355.   TTadd++;
  356.   HashAdd++;
  357. #endif
  358.   /* adjust score so moves to mate is from this ply */
  359.   if (score > 9000)
  360.     score += ply;
  361.   else if (score < -9000)
  362.     score -= ply;
  363.   ptbl->hashbd = hashbd;
  364.   ptbl->depth = (unsigned char) depth;
  365.   ptbl->score = score;
  366.   ptbl->mv = mv;
  367. #ifdef DEBUG4
  368.   if (debuglevel & 32)
  369.     {
  370.       algbr (mv >> 8, mv & 0xff, 0);
  371.       printf ("-add-> h=%lx d=%d s=%d p=%d a=%d b=%d %s\n", hashbd, depth, score, ply, alpha, beta, mvstr);
  372.     }
  373. #endif
  374.   if (score > beta)
  375.     {
  376.       ptbl->flags = lowerbound;
  377.       ptbl->score = beta + 1;
  378.     }
  379.   else
  380.     ptbl->flags = truescore;
  381.  
  382. #ifdef HASHTEST
  383.   for (i = 0; i < 32; i++)
  384.     {
  385.       ptbl->bd[i] = CB (i);
  386.     }
  387. #endif /* HASHTEST */
  388.   return true;
  389. }
  390. #endif // 4pl66
  391.  
  392.    
  393. // static struct hashentry *ttagew, *ttageb;
  394.  
  395. void
  396. ZeroTTable (void)
  397. {
  398. //   register struct hashentry *w, *b;
  399.  
  400. /* I am adding these 2 memsets! */
  401.  if (!TTadd)
  402.   return;
  403.  ClearMem(ttable[0],sizeof(struct hashentry)*(ttblsize+rehash));
  404.  ClearMem(ttable[1],sizeof(struct hashentry)*(ttblsize+rehash));
  405. #ifdef ZEROCACHE
  406. #ifdef CACHE
  407.   ClearMem(etab[0],sizeof(struct etable)*etblsize);
  408.   ClearMem(etab[1],sizeof(struct etable)*etblsize);
  409. //   ClearMem(etab,sizeof(struct etable)*2*etblsize);
  410. #endif // cache
  411. #endif // zerocache
  412.     TTadd = 0; 
  413. }
  414.  
  415. #ifdef HASHFILE
  416. int Fbdcmp(char *a,char *b)
  417. {
  418.     register int i;
  419.     for(i = 0;i<32;i++)
  420.         if(a[i] != b[i])return false;
  421.     return true;
  422. }
  423. int
  424. ProbeFTable (short int side,
  425.          short int depth,
  426.          short int ply,
  427.          short int *alpha,
  428.          short int *beta,
  429.          short int *score)
  430.  
  431. /*
  432.  * Look for the current board position in the persistent transposition table.
  433.  */
  434.  
  435. {
  436.   register short int i;
  437.   register unsigned long hashix;
  438.   struct fileentry new, t;
  439.  
  440.   hashix = ((side == white) ? (hashkey & 0xFFFFFFFE) : (hashkey | 1)) & filesz;
  441.  
  442.   for (i = 0; i < 32; i++)
  443.     new.bd[i] = CB (i);
  444.   new.flags = 0;
  445.   if (Mvboard[kingP[side]] == 0)
  446.     {
  447.       if (Mvboard[qrook[side]] == 0)
  448.     new.flags |= queencastle;
  449.       if (Mvboard[krook[side]] == 0)
  450.     new.flags |= kingcastle;
  451.     }
  452.   for (i = 0; i < frehash; i++)
  453.     {
  454.       fseek (hashfile,
  455.          sizeof (struct fileentry) * ((hashix + 2 * i) & (filesz)),
  456.          SEEK_SET);
  457.       fread (&t, sizeof (struct fileentry), 1, hashfile);
  458.       if (!t.depth) break;
  459.        if(!Fbdcmp(t.bd, new.bd)) continue;
  460.       if (((short int) t.depth >= depth) 
  461.       && (new.flags == (unsigned short)(t.flags & (kingcastle | queencastle))))
  462.     {
  463. #ifndef BAREBONES
  464.       FHashCnt++;
  465. #endif
  466.       PV = (t.f << 8) | t.t;
  467.       *score = (t.sh << 8) | t.sl;
  468.       /* adjust *score so moves to mate is from root */
  469.       if (*score > 9000)
  470.         *score -= ply;
  471.       else if (*score < -9000)
  472.         *score += ply;
  473.       if (t.flags & truescore)
  474.         {
  475.           *beta = -20000;
  476.         }
  477.       else if (t.flags & lowerbound)
  478.         {
  479.           if (*score > *alpha)
  480.         *alpha = *score - 1;
  481.         }
  482.       else if (t.flags & upperbound)
  483.         {
  484.           if (*score < *beta)
  485.         *beta = *score + 1;
  486.         }
  487.       return (true);
  488.     }
  489.     }
  490.   return (false);
  491. }
  492.  
  493. void
  494. PutInFTable (short int side,
  495.          short int score,
  496.          short int depth,
  497.          short int ply,
  498.          short int alpha,
  499.          short int beta,
  500.          short unsigned int f,
  501.          short unsigned int t)
  502.  
  503. /*
  504.  * Store the current board position in the persistent transposition table.
  505.  */
  506.  
  507. {
  508.   register unsigned short i;
  509.   register unsigned long hashix;
  510.   struct fileentry new, tmp;
  511.  
  512.   hashix = ((side == white) ? (hashkey & 0xFFFFFFFE) : (hashkey | 1)) & filesz;
  513.   for (i = 0; i < 32; i++) new.bd[i] = CB (i);
  514.   new.f = (unsigned char) f;
  515.   new.t = (unsigned char) t;
  516.   if (score < alpha)
  517.     new.flags = upperbound;
  518.   else
  519.     new.flags = ((score > beta) ? lowerbound : truescore);
  520.   if (Mvboard[kingP[side]] == 0)
  521.     {
  522.       if (Mvboard[qrook[side]] == 0)
  523.     new.flags |= queencastle;
  524.       if (Mvboard[krook[side]] == 0)
  525.     new.flags |= kingcastle;
  526.     }
  527.   new.depth = (unsigned char) depth;
  528.   /* adjust *score so moves to mate is from root */
  529.   if (score > 9000)
  530.     score += ply;
  531.   else if (score < -9000)
  532.     score -= ply;
  533.  
  534.  
  535.   new.sh = (unsigned char) (score >> 8);
  536.   new.sl = (unsigned char) (score & 0xFF);
  537.  
  538.   for (i = 0; i < frehash; i++)
  539.     {
  540.       fseek (hashfile,
  541.          sizeof (struct fileentry) * ((hashix + 2 * i) & (filesz)),
  542.          SEEK_SET);
  543.       if(fread (&tmp, sizeof (struct fileentry), 1, hashfile) == NULL){ShowMessage("hashfile");exit(1);}
  544.       if (tmp.depth && !Fbdcmp(tmp.bd,new.bd))continue;
  545.       if(tmp.depth == depth)break;
  546.       if (!tmp.depth || (short) tmp.depth < depth)
  547.     {
  548.       fseek (hashfile,
  549.          sizeof (struct fileentry) * ((hashix + 2 * i) & (filesz)),
  550.          SEEK_SET);
  551.       fwrite (&new, sizeof (struct fileentry), 1, hashfile);
  552. #ifndef BAREBONES
  553.       FHashAdd++;
  554. #endif
  555.       break;
  556.     }
  557.     }
  558. }
  559.  
  560. #endif /* HASHFILE */
  561. #endif /* ttblsz */
  562.  
  563. void
  564. ZeroRPT (void)
  565. {
  566. #ifdef NOMEMSET
  567.   register int side, i;
  568.   for (side = white; side <= black; side++)
  569.     for (i = 0; i < 256;)
  570.       rpthash[side][i++] = 0;
  571. #else
  572.    if(ISZERO){ClearMem(rpthash, sizeof (rpthash));ISZERO=0;}
  573. #endif
  574. }
  575.  
  576. #endif //OLDTTABLE
  577.