home *** CD-ROM | disk | FTP | other *** search
/ Dream 57 / Amiga_Dream_57.iso / Amiga / Jeux / Reflexion / Crafty-15.19.lha / crafty-15.19 / src / chess.h < prev    next >
Text File  |  1998-09-13  |  44KB  |  1,093 lines
  1. /*
  2. ********************************************************************************
  3. *                                                                              *
  4. *   configuration information:  the following variables need to be set to      *
  5. *   indicate the machine configuration/capabilities.                           *
  6. *                                                                              *
  7. *   there are pre-defined machine types for the following machines: (1) SUN    *
  8. *   (2) DOS (3) ALPHA [DEC Alpha] (4) CRAY  (5) LINUX.  defining any of these  *
  9. *   names will produce a runnable executable.  for other machines, the names   *
  10. *   explained below must be individually DEFINED or UNDEFINED as needed.       *
  11. *                                                                              *
  12. *   HAS_64BITS:  define this for a machine that has true 64-bit hardware       *
  13. *   including leading-zero hardware, population count, etc.  ie, a Cray-like   *
  14. *   machine.                                                                   *
  15. *                                                                              *
  16. *   HAS_LONGLONG:  define this for a 32-bit machine with a compiler that       *
  17. *   supports the long long (64-bit) integer data and allows bitwise operations *
  18. *   on this data type.  this provides significantly faster execution time as   *
  19. *   the bitwise operators are done by the compiler rather than by procedure    *
  20. *   calls.                                                                     *
  21. *                                                                              *
  22. *   LITTLE_ENDIAN_ARCH:  define for a 32-bit machine that mangles the way data *
  23. *   is stored within a word.  This is currently true for all PC class machines *
  24. *   and false for other processors used in current workstations (SUN, etc.)    *
  25. *                                                                              *
  26. *   UNIX:  define this if the program is being run on a unix-based system,     *
  27. *   which causes the executable to use unix-specific runtime utilities.        *
  28. *                                                                              *
  29. *   SMP:  this enables the symmetric multiprocessing code that allows Crafty   *
  30. *   to spawn threads and execute a parallel search.  Note that if this is set, *
  31. *   then the next variable must be defined as well.                            *
  32. *                                                                              *
  33. *   CPUS=N:  this sets up data structures to the appropriate size to support   *
  34. *   up to N simultaneous search engines.  note that you can set this to a      *
  35. *   value larger than the max processors you currently have, because the mt=n  *
  36. *   command (added to the command line or your crafty.rc/.craftyrc file) will  *
  37. *   control how many threads are actually spawned.                             *
  38. *                                                                              *
  39. ********************************************************************************
  40. */
  41. #if !defined(TYPES_INCLUDED)
  42.  
  43. #if !defined(CPUS)
  44. #  define CPUS 1
  45. #endif
  46.  
  47. #if defined(SMP)
  48. #  if (defined(NT_i386) || defined(NT_AXP))
  49. #    include <windows.h>
  50. #    include <process.h>
  51. #  elif defined(LINUX) || defined(ALPHA) || defined(POSIX)
  52. #    include <pthread.h>
  53. #  endif
  54. #endif
  55.  
  56. #define TYPES_INCLUDED
  57.  
  58. #if defined(AIX)
  59. #  undef  HAS_64BITS           /* machine has 64-bit integers / operators     */
  60. #  define HAS_LONGLONG         /* machine has 32-bit/64-bit integers          */
  61. #  undef  LITTLE_ENDIAN_ARCH   /* machine stores bytes in "PC" order          */
  62. #  define UNIX                 /* system is unix-based                        */
  63. #endif
  64. #if defined(ALPHA)
  65. #  define HAS_64BITS           /* machine has 64-bit integers / operators     */
  66. #  undef  HAS_LONGLONG         /* machine has 32-bit/64-bit integers          */
  67. #  define LITTLE_ENDIAN_ARCH   /* machine stores bytes in "PC" order          */
  68. #  define UNIX                 /* system is unix-based                        */
  69. #endif
  70. #if defined(AMIGA)
  71. #  undef  HAS_64BITS           /* machine has 64-bit integers / operators     */
  72. #  define HAS_LONGLONG         /* machine has 32-bit/64-bit integers          */
  73. #  undef  LITTLE_ENDIAN_ARCH   /* machine stores bytes in "PC" order          */
  74. #  undef  UNIX                 /* system is unix-based                        */
  75. #endif
  76. #if defined(CRAY1)
  77. #  define HAS_64BITS           /* machine has 64-bit integers / operators     */
  78. #  undef  HAS_LONGLONG         /* machine has 32-bit/64-bit integers          */
  79. #  undef  LITTLE_ENDIAN_ARCH   /* machine stores bytes in "PC" order          */
  80. #  define UNIX                 /* system is unix-based                        */
  81. #endif
  82. #if defined(DOS)
  83. #  undef  HAS_64BITS           /* machine has 64-bit integers / operators     */
  84. #  define HAS_LONGLONG         /* machine has 32-bit/64-bit integers          */
  85. #  define LITTLE_ENDIAN_ARCH   /* machine stores bytes in "PC" order          */
  86. #  undef  UNIX                 /* system is unix-based                        */
  87. #endif
  88. #if defined(FreeBSD)
  89. #  undef  HAS_64BITS           /* machine has 64-bit integers / operators     */
  90. #  define HAS_LONGLONG         /* machine has 32-bit/64-bit integers          */
  91. #  define LITTLE_ENDIAN_ARCH   /* machine stores bytes in "PC" order          */
  92. #  define UNIX                 /* system is unix-based                        */
  93. #endif
  94. #if defined(HP)
  95. #  undef  HAS_64BITS           /* machine has 64-bit integers / operators     */
  96. #  define HAS_LONGLONG         /* machine has 32-bit/64-bit integers          */
  97. #  undef  LITTLE_ENDIAN_ARCH   /* machine stores bytes in "PC" order          */
  98. #  define UNIX                 /* system is unix-based                        */
  99. #endif
  100. #if defined(LINUX)
  101. #  undef  HAS_64BITS           /* machine has 64-bit integers / operators     */
  102. #  define HAS_LONGLONG         /* machine has 32-bit/64-bit integers          */
  103. #  define LITTLE_ENDIAN_ARCH   /* machine stores bytes in "PC" order          */
  104. #  define UNIX                 /* system is unix-based                        */
  105. #endif
  106. #if defined(MIPS)
  107. #  undef  HAS_64BITS           /* machine has 64-bit integers / operators     */
  108. #  define HAS_LONGLONG         /* machine has 32-bit/64-bit integers          */
  109. #  undef  LITTLE_ENDIAN_ARCH   /* machine stores bytes in "PC" order          */
  110. #  define UNIX                 /* system is unix-based                        */
  111. #endif
  112. #if defined(NEXT)
  113. #  undef  HAS_64BITS          /* machine has 64-bit integers / operators     */
  114. #  define HAS_LONGLONG        /* machine has 32-bit/64-bit integers          */
  115. #  undef  LITTLE_ENDIAN_ARCH  /* machine stores bytes in "PC" order          */
  116. #  define UNIX                /* system is unix-based                        */
  117. #endif
  118. #if defined(NT_AXP)
  119. #  undef  HAS_64BITS           /* machine has 64-bit integers / operators     */
  120. #  define HAS_LONGLONG         /* machine has 32-bit/64-bit integers          */
  121. #  define LITTLE_ENDIAN_ARCH   /* machine stores bytes in "PC" order          */
  122. #  undef  UNIX                 /* system is unix-based                        */
  123. #endif
  124. #if defined(NT_i386)
  125. #  undef  HAS_64BITS           /* machine has 64-bit integers / operators     */
  126. #  define HAS_LONGLONG         /* machine has 32-bit/64-bit integers          */
  127. #  define LITTLE_ENDIAN_ARCH   /* machine stores bytes in "PC" order          */
  128. #  undef  UNIX                 /* system is unix-based                        */
  129. #endif
  130. #if defined(OS2)
  131. #  undef  HAS_64BITS           /* machine has 64-bit integers / operators     */
  132. #  define HAS_LONGLONG         /* machine has 32-bit/64-bit integers          */
  133. #  define LITTLE_ENDIAN_ARCH   /* machine stores bytes in "PC" order          */
  134. #  define UNIX                 /* system is unix-based                        */
  135. #endif
  136. #if defined(SGI)
  137. #  undef  HAS_64BITS           /* machine has 64-bit integers / operators     */
  138. #  define HAS_LONGLONG         /* machine has 32-bit/64-bit integers          */
  139. #  undef  LITTLE_ENDIAN_ARCH   /* machine stores bytes in "PC" order          */
  140. #  define UNIX                 /* system is unix-based                        */
  141. #endif
  142. #if defined(SUN)
  143. #  undef  HAS_64BITS           /* machine has 64-bit integers / operators     */
  144. #  define HAS_LONGLONG         /* machine has 32-bit/64-bit integers          */
  145. #  undef  LITTLE_ENDIAN_ARCH   /* machine stores bytes in "PC" order          */
  146. #  define UNIX                 /* system is unix-based                        */
  147. #endif
  148. #if defined(SUN_BSD)
  149. #  undef  HAS_64BITS           /* machine has 64-bit integers / operators     */
  150. #  define HAS_LONGLONG         /* machine has 32-bit/64-bit integers          */
  151. #  undef  LITTLE_ENDIAN_ARCH   /* machine stores bytes in "PC" order          */
  152. #  define UNIX                 /* system is unix-based                        */
  153. #endif
  154.  
  155. #if defined(__MWERKS__)
  156. #  define MACOS
  157. #endif
  158.  
  159. #if defined(MACOS)
  160. #  undef  HAS_64BITS           /* machine has 64-bit integers / operators     */
  161. #  define HAS_LONGLONG         /* machine has 32-bit/64-bit integers          */
  162. #  undef  LITTLE_ENDIAN_ARCH   /* machine stores bytes in "PC" order          */
  163. #  undef  UNIX                 /* system is unix-based                        */
  164.  
  165. #  define COMPACT_ATTACKS
  166. #  define USE_ATTACK_FUNCTIONS  
  167.  
  168. #  define     BOOKDIR    "Books"
  169. #  define      LOGDIR     "Logs"
  170. #  define       TBDIR       "TB"
  171. #else
  172. #  define     BOOKDIR        "."
  173. #  define      LOGDIR        "."
  174. #  define       TBDIR     "./TB"
  175. #endif
  176.  
  177. #define     MAXPLY            65
  178. #define MAX_BLOCKS            64
  179. #define MAX_TC_NODES      300000
  180.  
  181. #if !defined(SMP)
  182. #  define lock_t int
  183. #endif
  184.  
  185. #if defined(SMP)
  186.  
  187. #if (defined(NT_i386) || defined(NT_AXP))
  188.  
  189. #  define pthread_attr_t  HANDLE
  190. #  define pthread_t       HANDLE
  191. #  define thread_t        HANDLE
  192. #  define tfork(t,f,p)    do {                                             \
  193.                 (pthread_t)_beginthreadex(0,0,(void *)(f),(void *)(p),0,0);  \
  194.               } while (0)
  195.  
  196. #if (defined (_M_ALPHA) && !defined(NT_INTEREX))
  197.    
  198. #  ifdef __cplusplus
  199.       extern "C" __int64 __asm (char *, ...);
  200. #     pragma intrinsic (__asm)
  201. #  endif
  202.  
  203.   typedef volatile int lock_t[1];
  204.  
  205. #  define LockInit(v)      ((v)[0] = 0)
  206. #  define UnLock(v)        ((v)[0] = 0)
  207.  
  208.    __inline void Lock (volatile int *hPtr) {
  209.    __asm ("lp: ldl_l v0,(a0);"
  210.           "    xor v0,1,v0;"
  211.           "    beq v0,lp;"
  212.           "    stl_c v0,(a0);"
  213.           "    beq v0,lp;"
  214.           "    mb;",
  215.           hPtr);
  216.    }
  217.  
  218. #elif (defined (_M_IX86) && !defined(NT_INTEREX))
  219.  
  220.    typedef volatile int lock_t[1];
  221.  
  222. #  define LockInit(v)      ((v)[0] = 0)
  223. #  define UnLock(v)        ((v)[0] = 0)
  224.  
  225.  
  226. __inline void Lock (volatile int *hPtr)
  227.     {
  228.     __asm
  229.       {
  230.         mov     ecx, hPtr
  231.    la:  mov     eax, 1
  232.         xchg    eax, [ecx]
  233.         test    eax, eax
  234.         jz      end
  235.    lb:  mov     eax, [ecx]
  236.         test    eax, eax
  237.         jz      la
  238.         jmp     lb
  239.    end:
  240.       }
  241.     }
  242.  
  243.  
  244. #else /* NT non-Alpha/Intel, without assembler Lock() */
  245.  
  246. #  define lock_t           volatile int
  247. #  define LockInit(v)      ((v) = 0)
  248. #  define Lock(v)          do {                                         \
  249.                              while(InterlockedExchange((LPLONG)&(v),1) != 0);   \
  250.                            } while (0)
  251. #  define UnLock(v)        ((v) = 0)
  252.  
  253. #endif /* architecture check */
  254.  
  255. #else  /* not NT, assume SMP using POSIX threads (LINUX, etc)  */
  256.  
  257. #if defined(MUTEX)
  258.  
  259. #  define Lock(v)          pthread_mutex_lock(&v)
  260. #  define LockInit(v)      pthread_mutex_init(&v,0)
  261. #  define UnLock(v)        pthread_mutex_unlock(&v)
  262. #  define lock_t           pthread_mutex_t
  263.  
  264. #elif defined(ALPHA)
  265.  
  266. #  include <machine/builtins.h>
  267.  
  268. #  define lock_t           volatile long
  269. #  define LockInit(v)      ((v) = 0)
  270. #  define Lock(v)          __LOCK_LONG(&(v))
  271. #  define UnLock(v)        __UNLOCK_LONG(&(v))
  272.  
  273. #else /* POSIX, but not using MUTEXes */
  274.  
  275. #  define exchange(adr,reg)                                  \
  276.      ({ volatile int _ret;                                   \
  277.      asm volatile ("xchgw %0,%1"                             \
  278.      : "=q" (_ret), "=m" (*(adr))    /* Output %0,%1 */      \
  279.      : "m"  (*(adr)), "0"  (reg));   /* Input (%2),%0 */     \
  280.      _ret;                                                   \
  281.      })
  282. #  define LockInit(p)           (p=0)
  283. #  define UnLock(p)             (exchange(&p,0))
  284. #  define Lock(p)               while(exchange(&p,1)) while(p)
  285. #  define lock_t                volatile int
  286.  
  287. #endif /* MUTEX */
  288.  
  289. #  define tfork(t,f,p)          pthread_create(&t,&pthread_attr,f,(void*) p)
  290.  
  291. #endif /* NT or POSIX */
  292.  
  293. #endif /*  SMP code */
  294.  
  295. #define      BOOK_CLUSTER_SIZE            600
  296. #define            MERGE_BLOCK           1000
  297. #define             SORT_BLOCK         400000
  298. #define         LEARN_INTERVAL             10
  299. #define        LEARN_WINDOW_LB            -40
  300. #define        LEARN_WINDOW_UB            +40
  301. #define      LEARN_COUNTER_BAD            -80
  302. #define     LEARN_COUNTER_GOOD           +100
  303.  
  304.  
  305. /*
  306.   fractional ply extensions.  these should be in units based on the
  307.   value of INCREMENT_PLY (default is 60).  a value of 60 means this
  308.   extension is exactly one ply.
  309. */
  310.  
  311. #define INCREMENT_PLY            60  /* 1.00 */
  312. #define NULL_MOVE_DEPTH         120  /* 2.00 */
  313. #define RAZORING_DEPTH           60  /* 1.00 */
  314.  
  315. #define MATE                  32768
  316. #define PAWN_VALUE              100
  317. #define KNIGHT_VALUE            300
  318. #define BISHOP_VALUE            300
  319. #define ROOK_VALUE              500
  320. #define QUEEN_VALUE             900
  321. #define KING_VALUE            40000
  322.   
  323. #if defined(HAS_64BITS)
  324.   typedef unsigned long BITBOARD;
  325. #else
  326. #  if defined(NT_i386) || defined(NT_AXP)
  327.     typedef unsigned __int64 BITBOARD;
  328. #  else
  329.     typedef unsigned long long BITBOARD;
  330. #  endif
  331. #endif
  332.  
  333. #include <time.h>
  334. #if !defined(CLOCKS_PER_SEC)
  335. #  define CLOCKS_PER_SEC 1000000
  336. #endif
  337. typedef enum { A1,B1,C1,D1,E1,F1,G1,H1,
  338.                A2,B2,C2,D2,E2,F2,G2,H2,
  339.                A3,B3,C3,D3,E3,F3,G3,H3,
  340.                A4,B4,C4,D4,E4,F4,G4,H4,
  341.                A5,B5,C5,D5,E5,F5,G5,H5,
  342.                A6,B6,C6,D6,E6,F6,G6,H6,
  343.                A7,B7,C7,D7,E7,F7,G7,H7,
  344.                A8,B8,C8,D8,E8,F8,G8,H8,
  345.                BAD_SQUARE } squares;
  346.  
  347. typedef enum {FILEA, FILEB, FILEC, FILED, FILEE, FILEF, FILEG, FILEH} files;
  348.  
  349. typedef enum {RANK1, RANK2, RANK3, RANK4, RANK5, RANK6, RANK7, RANK8} ranks;
  350.  
  351. typedef enum {empty=0, pawn=1, knight=2, king=3, 
  352.               bishop=5, rook=6, queen=7} PIECE;
  353.   
  354. typedef enum {empty_v=0, pawn_v=1, knight_v=2, 
  355.               bishop_v=3, rook_v=5, queen_v=9} PIECE_V;
  356.   
  357. typedef enum {no_extension=0, check_extension=1, recapture_extension=2,
  358.               passed_pawn_extension=4, one_reply_extension=8} EXTENSIONS;
  359.   
  360. typedef enum {cpu, elapsed, microseconds} TIME_TYPE;
  361.  
  362. typedef enum {think=1, puzzle=2, book=3, annotate=4} SEARCH_TYPE;
  363.  
  364. typedef enum {normal_mode, tournament_mode} PLAYING_MODE;
  365.  
  366. typedef enum {crafty, opponent} PLAYER;
  367.  
  368. typedef enum {book_learning=1, position_learning=2,
  369.               result_learning=4} LEARNING_MODE;
  370.   
  371. typedef struct {
  372.   unsigned char enpassant_target;
  373.   signed   char w_castle;
  374.   signed   char b_castle;
  375.   unsigned char rule_50_moves;
  376. } SEARCH_POSITION;
  377.  
  378. typedef  struct {
  379.   BITBOARD       w_occupied;
  380.   BITBOARD       b_occupied;
  381.   BITBOARD       occupied_rl90;
  382.   BITBOARD       occupied_rl45;
  383.   BITBOARD       occupied_rr45;
  384.   BITBOARD       rooks_queens;
  385.   BITBOARD       bishops_queens;
  386.   BITBOARD       w_pawn;
  387.   BITBOARD       w_knight;
  388.   BITBOARD       w_bishop;
  389.   BITBOARD       w_rook;
  390.   BITBOARD       w_queen;
  391.   BITBOARD       b_pawn;
  392.   BITBOARD       b_knight;
  393.   BITBOARD       b_bishop;
  394.   BITBOARD       b_rook;
  395.   BITBOARD       b_queen;
  396.   BITBOARD       hash_key;
  397.   unsigned int   pawn_hash_key;
  398.   int            material_evaluation;
  399.   signed char    white_king;
  400.   signed char    black_king;
  401.   signed char    board[64];
  402.   signed char    white_pieces;
  403.   signed char    white_minors;
  404.   signed char    white_majors;
  405.   signed char    white_pawns;
  406.   signed char    black_pieces;
  407.   signed char    black_minors;
  408.   signed char    black_majors;
  409.   signed char    black_pawns;
  410.   signed char    total_pieces;
  411. } POSITION;
  412.   
  413. typedef struct {
  414.   BITBOARD word1;
  415.   BITBOARD word2;
  416. } HASH_ENTRY;
  417.  
  418. typedef struct {
  419.   unsigned int key;
  420.   short    p_score;
  421.   unsigned char black_protected;
  422.   unsigned char black_pof;
  423.   unsigned char weak_b;
  424.   unsigned char passed_b;
  425.   unsigned char black_defects_k;
  426.   unsigned char black_defects_q;
  427.   unsigned char white_protected;
  428.   unsigned char white_pof;
  429.   unsigned char weak_w;
  430.   unsigned char passed_w;
  431.   unsigned char white_defects_k;
  432.   unsigned char white_defects_q;
  433.   unsigned char outside;
  434. } PAWN_HASH_ENTRY;
  435.   
  436. typedef struct {
  437.   int path[MAXPLY];
  438.   unsigned char path_hashed;
  439.   unsigned char path_length;
  440.   unsigned char path_iteration_depth;
  441. } PATH;
  442.   
  443. typedef struct {
  444.   int phase;
  445.   int remaining;
  446.   int *last;
  447. } NEXT_MOVE;
  448.  
  449. typedef struct {
  450.   BITBOARD position;
  451.   unsigned int status_played;
  452.   float learn;
  453. } BOOK_POSITION;
  454.  
  455. typedef struct {
  456.   unsigned char position[8];
  457.   unsigned char status;
  458.   unsigned char percent_play;
  459. } BB_POSITION;
  460.  
  461. struct tree {
  462.   POSITION        pos;
  463.   PAWN_HASH_ENTRY pawn_score;
  464.   NEXT_MOVE       next_status[MAXPLY];
  465.   BITBOARD        save_hash_key[MAXPLY+2];
  466.   BITBOARD        replist_w[128];
  467.   BITBOARD        replist_b[128];
  468.   BITBOARD        *rephead_w;
  469.   BITBOARD        *rephead_b;
  470.   BITBOARD        all_pawns;
  471.   SEARCH_POSITION position[MAXPLY+2];
  472.   unsigned int    save_pawn_hash_key[MAXPLY+2];
  473.   int             current_move[MAXPLY];
  474.   int             hash_move[MAXPLY];
  475.   int             *last[MAXPLY];
  476.   PATH            pv[MAXPLY];
  477.   unsigned int    nodes_searched;
  478.   unsigned int    fail_high;
  479.   unsigned int    fail_high_first;
  480.   unsigned int    evaluations;
  481.   unsigned int    transposition_probes;
  482.   unsigned int    transposition_hits;
  483.   unsigned int    pawn_probes;
  484.   unsigned int    pawn_hits;
  485.   unsigned int    tb_probes;
  486.   unsigned int    tb_probes_successful;
  487.   unsigned int    check_extensions_done;
  488.   unsigned int    recapture_extensions_done;
  489.   unsigned int    passed_pawn_extensions_done;
  490.   unsigned int    one_reply_extensions_done;
  491.   int             killer_move1[MAXPLY];
  492.   int             killer_move2[MAXPLY];
  493.   int             move_list[5120];
  494.   int             sort_value[256];
  495.   unsigned int    root_nodes[256];
  496.   signed char     in_check[MAXPLY];
  497.   signed char     extended_reason[MAXPLY];
  498.   signed char     current_phase[MAXPLY];
  499.   signed char     searched_this_root_move[256];
  500.   int             search_value;
  501.   int             w_safety, b_safety;
  502.   int             w_kingsq, b_kingsq;
  503.   lock_t          lock;
  504.   int             thread_id;
  505.   volatile char   stop;
  506.   volatile char   done;
  507.   struct tree     *volatile siblings[CPUS], *parent;
  508.   volatile int    nprocs;
  509.   int             alpha;
  510.   int             beta;
  511.   int             value;
  512.   int             wtm;
  513.   int             depth;
  514.   int             ply;
  515.   int             threat;
  516.   int             used;
  517. };
  518.   
  519. typedef struct tree TREE;
  520.  
  521. #if defined(COMPACT_ATTACKS)
  522. #  define NDIAG_ATTACKS   296
  523. #  define NRANK_ATTACKS    70
  524. #  define NFILE_ATTACKS    70
  525.  
  526. #  define NSHORT_MOBILITY  116
  527.  
  528. #  define MAX_ATTACKS_FROM_SQUARE 12
  529.  
  530.   struct at {
  531.     unsigned char which_attack[8][64];
  532.     BITBOARD      file_attack_bitboards[8][MAX_ATTACKS_FROM_SQUARE];
  533.     unsigned char rank_attack_bitboards[8][MAX_ATTACKS_FROM_SQUARE];
  534.     unsigned char length8_mobility[8][MAX_ATTACKS_FROM_SQUARE];
  535.     unsigned char short_mobility[NSHORT_MOBILITY];
  536.   };
  537.   typedef struct {
  538. /* Fields for the diagonal */
  539.     BITBOARD *d_attacks;
  540.     unsigned char *d_mobility;
  541.     unsigned char *d_which_attack;
  542.     unsigned char d_shift;
  543.     unsigned char d_mask;
  544.  
  545. /* Fields for the anti diagonal */
  546.     unsigned char ad_shift;
  547.     unsigned char ad_mask;
  548.     unsigned char *ad_which_attack;
  549.     unsigned char *ad_mobility;
  550.     BITBOARD *ad_attacks;
  551.   } DIAG_INFO;
  552. #endif  
  553.  
  554. /*  
  555.     DO NOT modify these.  these are constants, used in multiple modules.
  556.     modification may corrupt the search in any number of ways, all bad.
  557. */
  558.  
  559. #define WORTHLESS                 0
  560. #define LOWER_BOUND               1
  561. #define UPPER_BOUND               2
  562. #define EXACT_SCORE               3
  563. #define AVOID_NULL_MOVE           4
  564.  
  565. #define NULL_MOVE                 0
  566. #define DO_NULL                   1
  567. #define NO_NULL                   0
  568.  
  569. #define NONE                      0
  570. #define FIRST_PHASE               1
  571. #define HASH_MOVE                 1
  572. #define GENERATE_CAPTURE_MOVES    2
  573. #define CAPTURE_MOVES             3
  574. #define KILLER_MOVE_1             4
  575. #define KILLER_MOVE_2             5
  576. #define GENERATE_ALL_MOVES        6
  577. #define SORT_ALL_MOVES            7  
  578. #define HISTORY_MOVES_1           8
  579. #define HISTORY_MOVES_2           9
  580. #define REMAINING_MOVES          10
  581. #define ROOT_MOVES               11
  582.  
  583. #if !defined(CRAY1)
  584.   BITBOARD     Mask(int);
  585.   int          PopCnt(BITBOARD);
  586.   int          FirstOne(BITBOARD);
  587.   int          LastOne(BITBOARD);
  588. #endif
  589.   
  590. void           Analyze();
  591. void           Annotate();
  592. int            Attacked(TREE*, int, int);
  593. BITBOARD       AttacksFrom(TREE*, int, int);
  594. BITBOARD       AttacksTo(TREE*, int);
  595. void           Bench(void);
  596. int            Book(TREE*,int,int);
  597. int            BookMask(char*);
  598. void           BookUp(TREE*, char*, int, char**);
  599. void           BookSort(BB_POSITION*, int, int);
  600. #if defined(NT_i386) || defined(NT_AXP)
  601.   int _cdecl     BookUpCompare(const void *, const void *);
  602. #else
  603.   int            BookUpCompare(const void *, const void *);
  604. #endif
  605. BB_POSITION    BookUpNextPosition(int, int);
  606. int            CheckInput(void);
  607. void           ClearHashTables(void);
  608. void           ComputeAttacksAndMobility(void);
  609. void           CopyFromSMP(TREE*, TREE*);
  610. TREE*          CopyToSMP(TREE*);
  611. void           Delay232(int);
  612. void           DisplayBitBoard(BITBOARD);
  613. void           DisplayChessBoard(FILE*, POSITION);
  614. char*          DisplayEvaluation(int);
  615. char*          DisplayEvaluationWhisper(int);
  616. void           DisplayFT(int, int, int);
  617. char*          DisplayHHMM(unsigned int);
  618. void           DisplayPieceBoards(int*, int*);
  619. void           DisplayPV(TREE*, int, int, int, int, PATH*);
  620. char*          DisplaySQ(unsigned int);
  621. char*          DisplayTime(unsigned int);
  622. char*          DisplayTimeWhisper(unsigned int);
  623. void           DisplayTreeState(TREE*, int, int, int);
  624. void           Display2BitBoards(BITBOARD, BITBOARD);
  625. void           DisplayChessMove(char*, int);
  626. int            DrawScore(int);
  627. int            Drawn(TREE*, int);
  628. void           Edit(void);
  629. int            EnPrise(int, int);
  630. int            Evaluate(TREE*, int, int, int, int);
  631. int            EvaluateDevelopment(TREE*, int);
  632. int            EvaluateDraws(TREE*);
  633. int            EvaluateKingSafety(TREE*, int);
  634. int            EvaluateMate(TREE*);
  635. int            EvaluatePassedPawns(TREE*);
  636. int            EvaluatePassedPawnRaces(TREE*, int);
  637. int            EvaluatePawns(TREE*);
  638. void           EVTest(char *);
  639. int            FindBlockID(TREE*);
  640. char*          FormatPV(TREE*,int,PATH);
  641. int*           GenerateCaptures(TREE*, int, int, int*);
  642. int*           GenerateCheckEvasions(TREE*, int, int, int*);
  643. int*           GenerateNonCaptures(TREE*, int, int, int*);
  644. unsigned int   ReadClock(TIME_TYPE);
  645. int            HasOpposition(int, int, int);
  646. void           History(TREE*, int, int, int, int);
  647. void           Initialize(int);
  648. void           InitializeAttackBoards(void);
  649. void           InitializeChessBoard(SEARCH_POSITION*);
  650. int            InitializeFindAttacks(int, int, int);
  651. void           InitializeHashTables(void);
  652. void           InitializeMasks(void);
  653. void           InitializePawnMasks(void);
  654. void           InitializePieceMasks(void);
  655. void           InitializeRandomHash(void);
  656. void           InitializeSMP(void);
  657. void           InitializeZeroMasks(void);
  658. int            InputMove(TREE*, char*, int, int, int, int);
  659. int            InputMoveICS(TREE*, char*, int, int, int, int);
  660. BITBOARD       InterposeSquares(int, int, int);
  661. void           Interrupt(int);
  662. int            Iterate(int, int, int);
  663. int            KingPawnSquare(int, int, int, int);
  664. void           LearnBook(TREE*, int, int, int, int, int);
  665. void           LearnBookUpdate(TREE*, int, int, float);
  666. int            LearnFunction(int, int, int, int);
  667. void           LearnImport(TREE*, int, char**);
  668. void           LearnImportBook(TREE*, int, char**);
  669. void           LearnImportPosition(TREE*, int, char**);
  670. void           LearnPosition(TREE*, int, int, int);
  671. void           LearnPositionLoad(TREE*);
  672. void           LearnResult(TREE*, int);
  673. int            LegalMove(TREE*, int, int, int);
  674. int            LookUp(TREE*, int, int, int, int*, int*, int*);
  675. void           MakeMove(TREE*, int, int, int);
  676. void           MakeMoveRoot(TREE*, int, int);
  677. void           NewGame(int);
  678. int            NextEvasion(TREE*, int, int);
  679. int            NextMove(TREE*, int, int);
  680. int            NextRootMove(TREE*, int);
  681. char*          Normal(void);
  682. int            Option(TREE*);
  683. int            OptionMatch(char*, char*);
  684. void           OptionPerft(TREE*, int, int, int);
  685. char*          OutputMove(TREE*, int, int, int);
  686. char*          OutputMoveICS(TREE*, int);
  687. int            OutputGood(TREE*, char*, int, int);
  688. int            ParseTime(char*);
  689. void           Pass(void);
  690. void           Phase(void);
  691. int            PinnedOnKing(TREE*, int, int);
  692. int            Ponder(int);
  693. void           PreEvaluate(TREE*,int);
  694. void           Print(int, char*, ...);
  695. int            Quiesce(TREE*, int, int, int, int);
  696. unsigned int   Random32(void);
  697. BITBOARD       Random64(void);
  698. int            Read(int, char*);
  699. int            ReadChessMove(TREE*, FILE*, int, int);
  700. void           ReadClear();
  701. int            ReadPGN(FILE*,int);
  702. int            ReadNextMove(TREE*, char*, int, int);
  703. int            ReadParse(char*, char *args[], char*);
  704. int            ReadInput();
  705. int            RepetitionCheck(TREE*, int, int);
  706. int            RepetitionDraw(TREE*, int);
  707. void           ResignOrDraw(TREE*, int, int);
  708. void           RestoreGame(void);
  709. char*          Reverse(void);
  710. void           RootMoveList(int);
  711. int            Search(TREE*, int, int, int, int, int, int);
  712. void           SearchOutput(TREE*, int, int);
  713. int            SearchRoot(TREE*, int, int, int, int);
  714. int            SearchSMP(TREE*, int, int, int, int, int, int, int);
  715. void           SearchTrace(TREE*, int, int, int, int, int, char*, int);
  716. void           SetBoard(int,char**,int);
  717. void           SetChessBitBoards(SEARCH_POSITION*);
  718. void           StoreBest(TREE*, int, int, int, int, int, int);
  719. void           StorePV(TREE*, int,int);
  720. void           StoreRefutation(TREE*, int, int, int, int, int);
  721. int            Swap(TREE*, int, int, int);
  722. BITBOARD       SwapXray(TREE*, BITBOARD, int, int);
  723. void           Test(char *);
  724. int            Thread(TREE*);
  725. void*          ThreadInit(void*);
  726. void           ThreadStop(TREE*);
  727. int            ThreadWait(int, TREE*);
  728. void           TimeAdjust(int,PLAYER);
  729. int            TimeCheck(int);
  730. void           TimeSet(int);
  731. void           UnMakeMove(TREE*, int, int, int);
  732. int            ValidMove(TREE*, int, int, int);
  733. void           ValidatePosition(TREE*, int, int, char*);
  734. BITBOARD       ValidateComputeBishopAttacks(TREE*, int);
  735. BITBOARD       ValidateComputeRookAttacks(TREE*, int);
  736. void           Whisper(int, int, int, int, unsigned int, int, char*);
  737.   
  738. #if defined(HAS_64BITS) || defined(HAS_LONGLONG)
  739. #  define And(a,b)    ((a) & (b))
  740. #  define Or(a,b)     ((a) | (b))
  741. #  define Xor(a,b)    ((a) ^ (b))
  742. #  define Compl(a)    (~(a))
  743. #  define Shiftl(a,b) ((a) << (b))
  744. #  define Shiftr(a,b) ((a) >> (b))
  745. #  if defined(CRAY1)
  746. #    define PopCnt(a)     _popcnt(a)
  747. #    define FirstOne(a)   _leadz(a)
  748. #    define LastOne(a)    _leadz((a)^(a-1))
  749. #    define Mask(a)       _mask(a)
  750. #    define mask_1        _mask(1)
  751. #    define mask_2        _mask(2)
  752. #    define mask_3        _mask(3)
  753. #    define mask_4        _mask(4)
  754. #    define mask_8        _mask(8)
  755. #    define mask_16       _mask(16)
  756. #    define mask_32       _mask(32)
  757. #    define mask_72       _mask(72)
  758. #    define mask_80       _mask(80)
  759. #    define mask_85       _mask(85)
  760. #    define mask_96       _mask(96)
  761. #    define mask_107      _mask(107)
  762. #    define mask_108      _mask(108)
  763. #    define mask_112      _mask(112)
  764. #    define mask_118      _mask(118)
  765. #    define mask_120      _mask(120)
  766. #    define mask_121      _mask(121)
  767. #    define mask_127      _mask(127)
  768. #  endif
  769. #endif
  770.  
  771. #define ABSearch(tree,alpha,beta,wtm,depth,ply,donull)        \
  772.         (((depth) >= INCREMENT_PLY) ?                         \
  773.         Search(tree,alpha,beta,wtm,depth,ply,donull) :        \
  774.         Quiesce(tree,alpha,beta,wtm,ply))
  775.  
  776. #define Max(a,b)  (((a) > (b)) ? (a) : (b))
  777. #define Min(a,b)  (((a) < (b)) ? (a) : (b))
  778. #define FileDistance(a,b) abs(((a)&7) - ((b)&7))
  779. #define RankDistance(a,b) abs(((a)>>3) - ((b)>>3))
  780. #define Distance(a,b) Max(FileDistance(a,b),RankDistance(a,b))
  781.  
  782. /*  
  783.     the following macro is used to determine if one side is in check.  it
  784.     simply returns the result of Attacked().
  785. */
  786. #define Check(wtm)                                                     \
  787.   Attacked(tree, (wtm)?WhiteKingSQ:BlackKingSQ,ChangeSide(wtm))
  788. /*  
  789.     Attack() is used to determine if a newly promoted pawn (queen)
  790.     attacks <square>.  normally <square> will be the location of the opposing
  791.     king, but it can also be the location of the opposing side's queening
  792.     square in case this pawn prevents the other pawn from safely queening on
  793.     the next move.
  794. */
  795. #define Attack(square,queen,ply) !And(obstructed[square][queen],Occupied)
  796. /*  
  797.     the following macros are used to construct the attacks from a square.
  798.     the attacks are computed as four separate bit vectors, one for each of the
  799.     two diagonals, and one for the ranks and one for the files.  these can be
  800.     Or'ed together to produce the attack bitmaps for bishops, rooks and queens.
  801. */
  802. #if defined(COMPACT_ATTACKS) && defined(USE_ATTACK_FUNCTIONS)
  803.   extern BITBOARD AttacksRookFunc(int, POSITION *);
  804.   extern BITBOARD AttacksBishopFunc(DIAG_INFO *, POSITION *);
  805. #  define AttacksRook(a) AttacksRookFunc(a,&tree->pos)
  806. #  define AttacksBishop(a) AttacksBishopFunc(&diag_info[a],&tree->pos)
  807. #else
  808. #  define AttacksRook(a)    Or(AttacksRank(a),AttacksFile(a))
  809. #  define AttacksBishop(a)  Or(AttacksDiaga1(a),AttacksDiagh1(a))
  810. #endif
  811.  
  812. #define AttacksQueen(a)   Or(AttacksBishop(a),AttacksRook(a))
  813. #define Rank(x)       (((x)>>3)&7)
  814. #define File(x)       ((x)&7)
  815. #define ChangeSide(x) ((x)^1)
  816.  
  817. #if defined(COMPACT_ATTACKS)
  818. /*
  819.   On a 32 bit machine optimizes the right shift of a long long
  820.   where it is known that desired piece lies completely in one of
  821.   the 32 bit words.
  822. */
  823. #  if defined(USE_SPLIT_SHIFTS)
  824. #    define SplitShiftr(value,shift) ((shift) >= 32 ?             \
  825.        Shiftr ((unsigned long) Shiftr((value), 32), (shift)-32) : \
  826.        Shiftr ((unsigned long) (value), (shift)))
  827. #  else
  828. #    define SplitShiftr(value,shift) Shiftr(value,shift)
  829. #  endif
  830.  
  831. #  define AttacksDiaga1Int(diagp,boardp) \
  832.      (diagp)->ad_attacks[(diagp)->ad_which_attack[                \
  833.       And (SplitShiftr((boardp)->occupied_rl45,(diagp)->ad_shift),\
  834.       (diagp)->ad_mask)]]
  835.  
  836. #  define AttacksDiagh1Int(diagp,boardp)                          \
  837.      (diagp)->d_attacks[(diagp)->d_which_attack[                  \
  838.       And (SplitShiftr((boardp)->occupied_rr45,(diagp)->d_shift), \
  839.       (diagp)->d_mask)]]
  840.  
  841. /*
  842.   On a 32 bit machine optimizes promoting a smaller value to a long
  843.   long where it is known that the smaller piece will be completely
  844.   in one of the 32 bit words.
  845. */
  846. #  if defined(USE_SPLIT_SHIFTS)
  847. #    define SplitShiftl(value,shift)                              \
  848.        ((shift) >= 32 ? Shiftl((BITBOARD)                         \
  849.         Shiftl((unsigned long) (value), (shift)-32), 32) :        \
  850.        (BITBOARD) Shiftl((unsigned long) (value), (shift)))
  851. #  else
  852. #    define SplitShiftl(value,shift) Shiftl((BITBOARD) value,shift)
  853. #  endif
  854.  
  855. /*
  856.   The length of the following macro is a little excessive as the
  857.   rank_attacks lookup is duplicated.  Making it a function, or passing
  858.   in a temporary variable would simplify it significantly, although
  859.   hopefully the compiler recognizes the common subexpression.
  860. */
  861. #  define AttacksRankInt(a,boardp)                          \
  862.      SplitShiftl(at.rank_attack_bitboards[File(a)][         \
  863.      at.which_attack[File(a)][And(SplitShiftr(              \
  864.      Or((boardp)->w_occupied,(boardp)->b_occupied),         \
  865.      (Rank(~(a))<<3)+1),0x3f)]],Rank(~(a))<<3)
  866.  
  867. /* 
  868.   The final left shift in this is optimizable, but the optimization is
  869.   a little ugly to express.  There is no information that crosses the
  870.   word boundary in the shift so it can be implemented as two separate
  871.   word shifts that are joined together in a long long.
  872. */
  873. #  define AttacksFileInt(a,boardp)                          \
  874.      Shiftl(at.file_attack_bitboards[Rank(a)] [             \
  875.      at.which_attack[Rank(a)] [                             \
  876.      And(SplitShiftr((boardp)->occupied_rl90,               \
  877.      (File(~(a))<<3)+1),0x3f)]],File(~(a)) )
  878.  
  879. #  if defined(USE_ATTACK_FUNCTIONS)
  880.     extern BITBOARD AttacksRankFunc(int, POSITION *);
  881.     extern BITBOARD AttacksFileFunc(int, POSITION *);
  882.     extern BITBOARD AttacksDiaga1Func(DIAG_INFO *, POSITION *);
  883.     extern BITBOARD AttacksDiagh1Func(DIAG_INFO *, POSITION *);
  884.  
  885. #    define AttacksRank(a) AttacksRankFunc(a,&tree->pos)
  886. #    define AttacksFile(a) AttacksFileFunc(a,&tree->pos)
  887. #    define AttacksDiaga1(a) AttacksDiaga1Func(&diag_info[a],&tree->pos)
  888. #    define AttacksDiagh1(a) AttacksDiagh1Func(&diag_info[a],&tree->pos)
  889. #  else
  890. #    define AttacksRank(a) AttacksRankInt(a,&tree->pos)
  891. #    define AttacksFile(a) AttacksFileInt(a,&tree->pos)
  892. #    define AttacksDiaga1(a) AttacksDiaga1Int(&diag_info[a],&tree->pos)
  893. #    define AttacksDiagh1(a) AttacksDiagh1Int(&diag_info[a],&tree->pos)
  894. #  endif
  895.  
  896. #else
  897.  
  898. #  define AttacksRank(a)                                               \
  899.       rook_attacks_r0[(a)][And(Shiftr(Or(tree->pos.w_occupied,tree->pos.b_occupied),\
  900.                                       56-((a)&56)),255)]
  901. #  define AttacksFile(a)                                               \
  902.       rook_attacks_rl90[(a)][And(Shiftr(tree->pos.occupied_rl90,       \
  903.                                         56-(((a)&7)<<3)),255)]
  904. #  define AttacksDiaga1(a)                                             \
  905.       bishop_attacks_rl45[(a)][And(Shiftr(tree->pos.occupied_rl45,     \
  906.                                           bishop_shift_rl45[(a)]),255)]
  907. #  define AttacksDiagh1(a)                                             \
  908.       bishop_attacks_rr45[(a)][And(Shiftr(tree->pos.occupied_rr45,     \
  909.                                           bishop_shift_rr45[(a)]),255)]
  910. #endif /* defined(COMPACT_ATTACKS) */
  911. /*  
  912.     the following macros are used to compute the mobility for a sliding piece.
  913.     The basic idea is the same as the attack vectors above, but the result is 
  914.     an integer mobility factor rather than a bitboard.  this saves having to 
  915.     do a PopCnt() on the attack bit vector, which is much slower.
  916. */
  917. #define MobilityRook(a)   (MobilityRank(a)+MobilityFile(a))
  918.  
  919. #define MobilityBishop(a) (MobilityDiaga1(a)+MobilityDiagh1(a))
  920.  
  921. #define MobilityQueen(a)  (MobilityBishop(a)+MobilityRook(a))
  922.  
  923. #if defined(COMPACT_ATTACKS)
  924.  
  925. #  define MobilityDiaga1Int(diagp,boardp)                                   \
  926.      (diagp)->ad_mobility[(diagp)->ad_which_attack[                         \
  927.      And (SplitShiftr ((boardp)->occupied_rl45,                             \
  928.      (diagp)->ad_shift),(diagp)->ad_mask)]]
  929.  
  930. #  define MobilityDiagh1Int(diagp,boardp)                                   \
  931.      (diagp)->d_mobility[(diagp)->d_which_attack [                          \
  932.      And (SplitShiftr ((boardp)->occupied_rr45,                             \
  933.      (diagp)->d_shift),(diagp)->d_mask)]]
  934.  
  935. #  define MobilityRankInt(a,boardp)                                             \
  936.      at.length8_mobility[File(a)][                                          \
  937.      at.which_attack[File(a)][                                              \
  938.      And(SplitShiftr(Or((boardp)->w_occupied,                               \
  939.      (boardp)->b_occupied),(Rank(~(a))<<3)+1),0x3f)]]
  940.  
  941. #  define MobilityFileInt(a,boardp)                                             \
  942.      at.length8_mobility[Rank(a)][                                          \
  943.      at.which_attack[Rank(a)] [                                             \
  944.      And(SplitShiftr((boardp)->occupied_rl90,(File(~(a))<<3)+1),0x3f)]]
  945.  
  946. #  if defined(USE_ATTACK_FUNCTIONS)
  947.     extern unsigned MobilityRankFunc(int, POSITION *);
  948.     extern unsigned MobilityFileFunc(int, POSITION *);
  949.     extern unsigned MobilityDiaga1Func(DIAG_INFO *, POSITION *);
  950.     extern unsigned MobilityDiagh1Func(DIAG_INFO *, POSITION *);
  951.  
  952. #    define MobilityRank(a) MobilityRankFunc(a,&tree->pos)
  953. #    define MobilityFile(a) MobilityFileFunc(a,&tree->pos)
  954. #    define MobilityDiaga1(a) MobilityDiaga1Func(&diag_info[a],&tree->pos)
  955. #    define MobilityDiagh1(a) MobilityDiagh1Func(&diag_info[a],&tree->pos)
  956. #  else
  957. #    define MobilityRank(a) MobilityRankInt(a,&tree->pos)
  958. #    define MobilityFile(a) MobilityFileInt(a,&tree->pos)
  959. #    define MobilityDiaga1(a) MobilityDiaga1Int(&diag_info[a],&tree->pos)
  960. #    define MobilityDiagh1(a) MobilityDiagh1Int(&diag_info[a],&tree->pos)
  961. #  endif
  962.  
  963. #else
  964.  
  965. #  define MobilityRank(a)                                                   \
  966.      rook_mobility_r0[(a)][And(Shiftr(Or(tree->pos.w_occupied,              \
  967.                                          tree->pos.b_occupied),             \
  968.                                       56-((a)&56)),255)]
  969. #  define MobilityFile(a)                                                   \
  970.      rook_mobility_rl90[(a)][And(Shiftr(tree->pos.occupied_rl90,            \
  971.                                         56-(((a)&7)<<3)),255)]
  972. #  define MobilityDiaga1(a)                                                 \
  973.      bishop_mobility_rl45[(a)][And(Shiftr(tree->pos.occupied_rl45,          \
  974.                                           bishop_shift_rl45[(a)]),255)]
  975. #  define MobilityDiagh1(a)                                                 \
  976.      bishop_mobility_rr45[(a)][And(Shiftr(tree->pos.occupied_rr45,          \
  977.                                           bishop_shift_rr45[(a)]),255)]
  978. #endif  /* if defined(COMPACT_ATTACKS) */
  979.  
  980. /*  
  981.     the following macros are used to extract the pieces of a move that are
  982.     kept compressed into the rightmost 21 bits of a simple integer.
  983. */
  984.  
  985. #define From(a)             ((a)&63)
  986. #define To(a)               (((a)>>6)&63)
  987. #define Piece(a)            (((a)>>12)&7)
  988. #define Captured(a)         (((a)>>15)&7)
  989. #define Promote(a)          (((a)>>18)&7)
  990. #define CaptureOrPromote(a) (((a)>>15)&63)
  991. #define SetMask(a)          (set_mask[a])
  992. #define ClearMask(a)        (clear_mask[a])
  993.  
  994. /*  
  995.     the following macros are used to extract the correct bits for the piece
  996.     type desired.
  997. */
  998.  
  999. #define BlackPawns            (tree->pos.b_pawn)
  1000. #define BlackKnights          (tree->pos.b_knight)
  1001. #define BlackBishops          (tree->pos.b_bishop)
  1002. #define BlackRooks            (tree->pos.b_rook)
  1003. #define BlackQueens           (tree->pos.b_queen)
  1004. #define BlackKing             (set_mask[tree->pos.black_king])
  1005. #define BlackKingSQ           (tree->pos.black_king)
  1006. #define BlackCastle(ply)      (tree->position[ply].b_castle)
  1007. #define TotalBlackPawns       (tree->pos.black_pawns)
  1008. #define TotalBlackPieces      (tree->pos.black_pieces)
  1009. #define TotalBlackMaterial    (tree->pos.black_pieces+tree->black_pawns)
  1010. #define BlackPieces           (tree->pos.b_occupied)
  1011. #define BlackMinors           (tree->pos.black_minors)
  1012. #define BlackMajors           (tree->pos.black_majors)
  1013.  
  1014. #define WhitePawns            (tree->pos.w_pawn)
  1015. #define WhiteKnights          (tree->pos.w_knight)
  1016. #define WhiteBishops          (tree->pos.w_bishop)
  1017. #define WhiteRooks            (tree->pos.w_rook)
  1018. #define WhiteQueens           (tree->pos.w_queen)
  1019. #define WhiteKing             (set_mask[tree->pos.white_king])
  1020. #define WhiteKingSQ           (tree->pos.white_king)
  1021. #define WhiteCastle(ply)      (tree->position[ply].w_castle)
  1022. #define TotalWhitePawns       (tree->pos.white_pawns)
  1023. #define TotalWhitePieces      (tree->pos.white_pieces)
  1024. #define TotalWhiteMaterial    (tree->pos.white_pieces+tree->white_pawns)
  1025. #define WhitePieces           (tree->pos.w_occupied)
  1026. #define WhiteMinors           (tree->pos.white_minors)
  1027. #define WhiteMajors           (tree->pos.white_majors)
  1028.  
  1029. #define TotalPieces           (tree->pos.total_pieces)
  1030.  
  1031. #define Material              (tree->pos.material_evaluation)
  1032. #define Rule50Moves(ply)      (tree->position[ply].rule_50_moves)
  1033. #define HashKey               (tree->pos.hash_key)
  1034. #define PawnHashKey           (tree->pos.pawn_hash_key)
  1035. #define EnPassant(ply)        (tree->position[ply].enpassant_target)
  1036. #define EnPassantTarget(ply)  (EnPassant(ply) ? set_mask[EnPassant(ply)] : 0)
  1037. #define PieceOnSquare(sq)     (tree->pos.board[sq])
  1038. #define BishopsQueens         (tree->pos.bishops_queens)
  1039. #define RooksQueens           (tree->pos.rooks_queens)
  1040. #define Occupied              (Or(tree->pos.w_occupied,tree->pos.b_occupied))
  1041. #define OccupiedRL90          (tree->pos.occupied_rl90)
  1042. #define OccupiedRL45          (tree->pos.occupied_rl45)
  1043. #define OccupiedRR45          (tree->pos.occupied_rr45)
  1044.  
  1045. #define Sliding(piece)        ((piece) & 4)
  1046. #define SlidingDiag(piece)    (((piece) & 5) == 5)
  1047. #define SlidingRow(piece)     (((piece) & 6) == 6)
  1048. /*  
  1049.     the following macros are used to Set and Clear a specific bit in the
  1050.     second argument.  this is done to make the code more readable, rather
  1051.     than to make it faster.
  1052. */
  1053. #define ClearSet(a,b)       b=Xor(a,b)
  1054. #define Clear(a,b)          b=And(clear_mask[a],b)
  1055. #define ClearRL90(a,b)      b=And(clear_mask_rl90[a],b)
  1056. #define ClearRL45(a,b)      b=And(clear_mask_rl45[a],b)
  1057. #define ClearRR45(a,b)      b=And(clear_mask_rr45[a],b)
  1058. #define Set(a,b)            b=Or(set_mask[a],b)
  1059. #define SetRL90(a,b)        b=Or(set_mask_rl90[a],b)
  1060. #define SetRL45(a,b)        b=Or(set_mask_rl45[a],b)
  1061. #define SetRR45(a,b)        b=Or(set_mask_rr45[a],b)
  1062.  
  1063. #define HashPB32(a,b)       b=b_pawn_random32[a]^(b)
  1064. #define HashPW32(a,b)       b=w_pawn_random32[a]^(b)
  1065. #define HashPB(a,b)         b=Xor(b_pawn_random[a],b)
  1066. #define HashPW(a,b)         b=Xor(w_pawn_random[a],b)
  1067. #define HashNB(a,b)         b=Xor(b_knight_random[a],b)
  1068. #define HashNW(a,b)         b=Xor(w_knight_random[a],b)
  1069. #define HashBB(a,b)         b=Xor(b_bishop_random[a],b)
  1070. #define HashBW(a,b)         b=Xor(w_bishop_random[a],b)
  1071. #define HashRB(a,b)         b=Xor(b_rook_random[a],b)
  1072. #define HashRW(a,b)         b=Xor(w_rook_random[a],b)
  1073. #define HashQB(a,b)         b=Xor(b_queen_random[a],b)
  1074. #define HashQW(a,b)         b=Xor(w_queen_random[a],b)
  1075. #define HashKB(a,b)         b=Xor(b_king_random[a],b)
  1076. #define HashKW(a,b)         b=Xor(w_king_random[a],b)
  1077. #define HashEP(a,b)         b=Xor(enpassant_random[a],b)
  1078. #define HashCastleW(a,b)    b=Xor(castle_random_w[a],b);
  1079. #define HashCastleB(a,b)    b=Xor(castle_random_b[a],b);
  1080. #define SavePV(tree,ply,value,ph) do {                                      \
  1081.           tree->pv[ply-1].path[ply-1]=tree->current_move[ply-1];            \
  1082.           tree->pv[ply-1].path_length=ply-1;                                \
  1083.           tree->pv[ply-1].path_hashed=ph;                                   \
  1084.           tree->pv[ply-1].path_iteration_depth=iteration_depth;} while(0)
  1085. #define SavePVS(tree,ply,value,ph) do {                                     \
  1086.           tree->pv[ply-1].path[ply-1]=tree->current_move[ply-1];            \
  1087.           tree->pv[ply-1].path_length=ply-1;                                \
  1088.           tree->pv[ply-1].path_hashed=ph;                                   \
  1089.           tree->pv[ply-1].path_iteration_depth=iteration_depth;             \
  1090.           SearchOutput(tree,value,beta);} while(0)
  1091.  
  1092. #endif /* if defined(TYPES_INCLUDED) */
  1093.