home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / os2 / pmchessr / init.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-11-29  |  9.9 KB  |  339 lines
  1. //
  2. //  Copyright (C) 1986, 1987, 1988, 1989, 1990 Free Software Foundation, Inc.
  3. //  Copyright (c) 1988, 1989, 1990  John Stanback
  4. //
  5. //  Project:    OS/2 PM Port of GNU CHESS 3.1 (PmChess)
  6. //
  7. //  Version:    1990-11-17
  8. //
  9. //   Module:    Initialization Logic (Init.c)
  10. //
  11. //   Porter:    Ported to Windows 3.0 by Darly Baker
  12. //
  13. //   Porter:    Ported to OS/2 1.2+ by Kent Cedola
  14. //
  15. //   System:    OS2 1.2 using Microsoft C 6.0
  16. //
  17. //  Remarks:    This code converted from Windows to PM using a straight port
  18. //              method with some editing improvements.  Some of the logic
  19. //              required for poor old Windows has been removed since super-
  20. //              duper OS/2 is better with memory...
  21. //
  22. //  License:
  23. //
  24. //    CHESS is distributed in the hope that it will be useful, but WITHOUT ANY
  25. //    WARRANTY.  No author or distributor accepts responsibility to anyone for
  26. //    the consequences of using it or for whether it serves any particular
  27. //    purpose or works at all, unless he says so in writing.  Refer to the
  28. //    CHESS General Public License for full details.
  29. //
  30. //    Everyone is granted permission to copy, modify and redistribute CHESS,
  31. //    but only under the conditions described in the CHESS General Public
  32. //    License.  A copy of this license is supposed to have been given to you
  33. //    along with CHESS so you can know your rights and responsibilities.  It
  34. //    should be in a file named COPYING.  Among other things, the copyright
  35. //    notice and this notice must be preserved on all copies.
  36. //
  37.  
  38. #define INCL_DOS
  39. #define INCL_PM
  40. #include <os2.h>
  41. #include <stdio.h>
  42. #include <stdlib.h>
  43. #include <time.h>
  44. #include "PmChess.h"
  45. #include "GnuChess.h"
  46. #include "Defs.h"
  47.  
  48.  
  49. extern HWND hStats;
  50.  
  51. extern short far distdata[64][64], far taxidata[64][64];
  52.  
  53. extern FILE *hashfile;
  54. extern short stage, stage2, Developed[2];
  55. extern short ChkFlag[maxdepth], CptrFlag[maxdepth], PawnThreat[maxdepth];
  56. extern short Pscore[maxdepth], Tscore[maxdepth];
  57. extern short rehash;
  58.  
  59. extern struct hashval far hashcode[2][7][64];
  60.  
  61. //extern unsigned char far * history;
  62.  
  63. void
  64. Initialize_dist (void)
  65. {
  66.   register short a, b, d, di;
  67.  
  68.   for (a = 0; a < 64; a++)
  69.     for (b = 0; b < 64; b++)
  70.       {
  71.         d = abs (column (a) - column (b));
  72.         di = abs (row (a) - row (b));
  73.         taxidata[a][b] = d + di;
  74.         distdata[a][b] = (d > di ? d : di);
  75.       }
  76. }
  77.  
  78. static short Stboard[64] =
  79. {rook, knight, bishop, queen, king, bishop, knight, rook,
  80.  pawn, pawn, pawn, pawn, pawn, pawn, pawn, pawn,
  81.  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  82.  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  83.  pawn, pawn, pawn, pawn, pawn, pawn, pawn, pawn,
  84.  rook, knight, bishop, queen, king, bishop, knight, rook};
  85.  
  86. static short Stcolor[64] =
  87. {white, white, white, white, white, white, white, white,
  88.  white, white, white, white, white, white, white, white,
  89.  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  90.  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  91.  black, black, black, black, black, black, black, black,
  92.  black, black, black, black, black, black, black, black};
  93.  
  94. extern short board[64], color[64];
  95.  
  96. extern unsigned char far nextpos[8][64][64];
  97. extern unsigned char far nextdir[8][64][64];
  98. /*
  99.   ptype is used to separate white and black pawns, like this;
  100.   ptyp = ptype[side][piece]
  101.   piece can be used directly in nextpos/nextdir when generating moves
  102.   for pieces that are not black pawns.
  103. */
  104. static short ptype[2][8] =
  105. {
  106.   no_piece, pawn, knight, bishop, rook, queen, king, no_piece,
  107.   no_piece, bpawn, knight, bishop, rook, queen, king, no_piece};
  108.  
  109. static short direc[8][8] =
  110. {
  111.   0, 0, 0, 0, 0, 0, 0, 0,
  112.   10, 9, 11, 0, 0, 0, 0, 0,
  113.   8, -8, 12, -12, 19, -19, 21, -21,
  114.   9, 11, -9, -11, 0, 0, 0, 0,
  115.   1, 10, -1, -10, 0, 0, 0, 0,
  116.   1, 10, -1, -10, 9, 11, -9, -11,
  117.   1, 10, -1, -10, 9, 11, -9, -11,
  118.   -10, -9, -11, 0, 0, 0, 0, 0};
  119.  
  120. static short max_steps[8] =
  121. {0, 2, 1, 7, 7, 7, 1, 2};
  122.  
  123. static short nunmap[120] =
  124. {
  125.   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  126.   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  127.   -1, 0, 1, 2, 3, 4, 5, 6, 7, -1,
  128.   -1, 8, 9, 10, 11, 12, 13, 14, 15, -1,
  129.   -1, 16, 17, 18, 19, 20, 21, 22, 23, -1,
  130.   -1, 24, 25, 26, 27, 28, 29, 30, 31, -1,
  131.   -1, 32, 33, 34, 35, 36, 37, 38, 39, -1,
  132.   -1, 40, 41, 42, 43, 44, 45, 46, 47, -1,
  133.   -1, 48, 49, 50, 51, 52, 53, 54, 55, -1,
  134.   -1, 56, 57, 58, 59, 60, 61, 62, 63, -1,
  135.   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  136.   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
  137.  
  138.  
  139. void
  140. Initialize_moves (void)
  141.  
  142. /*
  143.   This procedure pre-calculates all moves for every piece from every square.
  144.   This data is stored in nextpos/nextdir and used later in the move generation
  145.   routines.
  146. */
  147.  
  148. {
  149.   short ptyp, po, p0, d, di, s, delta;
  150.   unsigned char far *ppos, far *pdir;
  151.   short dest[8][8];
  152.   short steps[8];
  153.   short sorted[8];
  154.  
  155.   for (ptyp = 0; ptyp < 8; ptyp++)
  156.     for (po = 0; po < 64; po++)
  157.       for (p0 = 0; p0 < 64; p0++)
  158.         {
  159.       nextpos[ptyp][po][p0] = (UCHAR)po;
  160.       nextdir[ptyp][po][p0] = (UCHAR)po;
  161.         }
  162.   for (ptyp = 1; ptyp < 8; ptyp++)
  163.     for (po = 21; po < 99; po++)
  164.       if (nunmap[po] >= 0)
  165.         {
  166.       ppos = nextpos[ptyp][nunmap[po]];
  167.       pdir = nextdir[ptyp][nunmap[po]];
  168.           /* dest is a function of direction and steps */
  169.           for (d = 0; d < 8; d++)
  170.             {
  171.               dest[d][0] = nunmap[po];
  172.               delta = direc[ptyp][d];
  173.               if (delta != 0)
  174.                 {
  175.                   p0 = po;
  176.                   for (s = 0; s < max_steps[ptyp]; s++)
  177.                     {
  178.                       p0 = p0 + delta;
  179.                       /*
  180.                         break if (off board) or
  181.                         (pawns only move two steps from home square)
  182.                       */
  183.                       if (nunmap[p0] < 0 || (ptyp == pawn || ptyp == bpawn)
  184.                           && s > 0 && (d > 0 || Stboard[nunmap[po]] != pawn))
  185.                         break;
  186.                       else
  187.                         dest[d][s] = nunmap[p0];
  188.                     }
  189.                 }
  190.               else
  191.                 s = 0;
  192.  
  193.               /*
  194.                 sort dest in number of steps order
  195.                 currently no sort is done due to compability with
  196.                 the move generation order in old gnu chess
  197.               */
  198.               steps[d] = s;
  199.               for (di = d; s > 0 && di > 0; di--)
  200.                 if (steps[sorted[di - 1]] == 0) /* should be: < s */
  201.                   sorted[di] = sorted[di - 1];
  202.                 else
  203.                   break;
  204.               sorted[di] = d;
  205.             }
  206.  
  207.           /*
  208.             update nextpos/nextdir,
  209.             pawns have two threads (capture and no capture)
  210.           */
  211.           p0 = nunmap[po];
  212.           if (ptyp == pawn || ptyp == bpawn)
  213.             {
  214.               for (s = 0; s < steps[0]; s++)
  215.                 {
  216.                   ppos[p0] = (unsigned char) dest[0][s];
  217.                   p0 = dest[0][s];
  218.                 }
  219.               p0 = nunmap[po];
  220.               for (d = 1; d < 3; d++)
  221.                 {
  222.                   pdir[p0] = (unsigned char) dest[d][0];
  223.                   p0 = dest[d][0];
  224.                 }
  225.             }
  226.           else
  227.             {
  228.               pdir[p0] = (unsigned char) dest[sorted[0]][0];
  229.               for (d = 0; d < 8; d++)
  230.                 for (s = 0; s < steps[sorted[d]]; s++)
  231.                   {
  232.                     ppos[p0] = (unsigned char) dest[sorted[d]][s];
  233.                     p0 = dest[sorted[d]][s];
  234.                     if (d < 7)
  235.                       pdir[p0] = (unsigned char) dest[sorted[d + 1]][0];
  236.                     /* else is already initialized */
  237.                   }
  238.             }
  239.         }
  240. }
  241.  
  242.  
  243. /* hmm.... shouldn`t main be moved to the interface routines */
  244. int
  245. init_main (HWND hWnd)
  246. {
  247.   short int ahead = true, hash = true;
  248.  
  249.   Level = 0;
  250.   TCflag = false;
  251.   OperatorTime = 0;
  252.   Initialize ();
  253.   Initialize_dist ();
  254.   Initialize_moves ();
  255.   NewGame (hWnd);
  256.   GetOpenings ( hWnd);
  257.  
  258.   flag.easy = ahead;
  259.   flag.hash = hash;
  260.   hashfile = NULL;
  261.   return (0);
  262. }
  263.  
  264.  
  265. void
  266. NewGame (HWND hWnd)
  267.  
  268. /*
  269.   Reset the board and other variables to start a new game.
  270. */
  271.  
  272. {
  273.   short l, c, p;
  274.  
  275.   stage = stage2 = -1;          /* the game is not yet started */
  276.  
  277.   if ( flag.post ) {
  278.       WinSendMsg(hStats, WM_SYSCOMMAND, MPFROMSHORT(SC_CLOSE), 0);
  279.       flag.post = false;
  280.   }
  281.  
  282.   flag.mate = flag.quit = flag.reverse = flag.bothsides = false;
  283.   flag.force = false;
  284.   flag.hash = flag.easy = flag.beep = flag.rcptr = true;
  285.   NodeCnt = et0 = epsquare = 0;
  286.   dither = 0;
  287.   Awindow = 90;
  288.   Bwindow = 90;
  289.   xwndw = 90;
  290.   MaxSearchDepth = 29;
  291.   contempt = 0;
  292.   GameCnt = 0;
  293.   Game50 = 1;
  294.   hint = 0x0C14;
  295.   ZeroRPT ();
  296.   Developed[white] = Developed[black] = false;
  297.   castld[white] = castld[black] = false;
  298.   PawnThreat[0] = CptrFlag[0] = false;
  299.   Pscore[0] = 12000;
  300.   Tscore[0] = 12000;
  301.   opponent = white;
  302.   computer = black;
  303.   for (l = 0; l < 2000; l++)
  304.       Tree[l].f = Tree[l].t = 0;
  305. #if ttblsz
  306.   rehash = 6;
  307.   ZeroTTable ();
  308.   srand ((unsigned int) 1);
  309.   for (c = white; c <= black; c++)
  310.     for (p = pawn; p <= king; p++)
  311.       for (l = 0; l < 64; l++)
  312.         {
  313.       hashcode[c][p][l].key = (((unsigned long) rand ()));
  314.       hashcode[c][p][l].key += (((unsigned long) rand ()) << 16);
  315.       hashcode[c][p][l].bd = (((unsigned long) rand ()));
  316.       hashcode[c][p][l].bd += (((unsigned long) rand ()) << 16);
  317.         }
  318. #endif /* ttblsz */
  319.   for (l = 0; l < 64; l++)
  320.     {
  321.       board[l] = Stboard[l];
  322.       color[l] = Stcolor[l];
  323.       Mvboard[l] = 0;
  324.     }
  325.   if (TCflag)
  326.     SetTimeControl ();
  327.   else if (Level == 0) {
  328.     OperatorTime = 1;
  329.     TCmoves = 60;
  330.     TCminutes = 5;
  331.     TCflag = (TCmoves > 1);
  332.     SetTimeControl ();
  333.   }
  334.   InitializeStats ();
  335.   time0 = time ((long *) 0);
  336.   ElapsedTime (1);
  337.   UpdateDisplay (hWnd, 0, 0, 1, 0);
  338. }
  339.