home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / gnu / gnushogi-1.1 / src / eval.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-04-26  |  68.5 KB  |  2,759 lines
  1. /*
  2.  * eval.c - C source for GNU SHOGI
  3.  *
  4.  * Copyright (c) 1993 Matthias Mutz
  5.  *
  6.  * GNU SHOGI is based on GNU CHESS
  7.  *
  8.  * Copyright (c) 1988,1989,1990 John Stanback
  9.  * Copyright (c) 1992 Free Software Foundation
  10.  *
  11.  * This file is part of GNU Shogi.
  12.  *
  13.  * GNU Shogi is free software; you can redistribute it and/or modify
  14.  * it under the terms of the GNU General Public License as published by
  15.  * the Free Software Foundation; either version 1, or (at your option)
  16.  * any later version.
  17.  *
  18.  * GNU Shogi is distributed in the hope that it will be useful,
  19.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21.  * GNU General Public License for more details.
  22.  *
  23.  * You should have received a copy of the GNU General Public License
  24.  * along with GNU Shogi; see the file COPYING.  If not, write to
  25.  * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  26.  */
  27. #include "gnushogi.h"
  28. #include "ataks.h" 
  29.  
  30. #ifdef USE_PATTERN
  31. #include "pattern.h"
  32. #endif
  33.  
  34. #ifdef THINK_C
  35. #include <string.h>
  36. #define bcopy(src,dst,len) memcpy(dst,src,len)
  37. #endif
  38.  
  39. #if !defined K32SEGMENTS
  40. #include "eval_data1.c"
  41. #endif
  42.  
  43. int EADD = 0;
  44. int EGET = 0;
  45.  
  46.  
  47. #ifdef DEBUG_EVAL
  48. extern short debug_eval;
  49. extern FILE *debug_eval_file;
  50. #endif
  51.  
  52.  
  53. static short in_opening_stage = true;
  54. static short behind_in_material[2] = {false, false};
  55.  
  56.  
  57. /* distance to enemy king */
  58. static const EnemyKingDistanceBonus[9] =
  59. {0, 20, 15, 8, 5, 3, 1, 0, 0};
  60.  
  61. /* distance to own king */
  62. static const OwnKingDistanceBonus[9] =
  63. {0, 10, 4, 1, 0, 0, 0, 0, 0};
  64.  
  65. /* distance to promotion zone */
  66. static const PromotionZoneDistanceBonus[NO_ROWS] =
  67. {0, 0, 0, 0, 4, 8, 10, 10, 10};
  68.  
  69. /* Bishop mobility bonus indexed by # reachable squares */
  70. static const short BMBLTY[20] =
  71. {0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 14, 14, 16, 16, 16, 16};
  72.  
  73. /* Rook mobility bonus indexed by # reachable squares */
  74. static const short RMBLTY[20] =
  75. {0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 14, 14, 16, 16, 16, 16};
  76.  
  77. /* Lance mobility bonus indexed by # reachable squares */
  78. static const short LMBLTY[8] =
  79. {0, 0, 0, 0, 1, 2, 4, 8};
  80.  
  81.  
  82. /* penalty for threats to king, indexed by number of such threats */
  83. static const short KTHRT[36] =
  84. {0, -8, -20, -36, -52, -68, -80, -80, -80, -80, -80, -80,
  85.  -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, -80,
  86.  -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, -80};
  87.  
  88.  
  89. /* No positional bonus ! */
  90. static const short NoAdvance[NO_SQUARES] =
  91. {  0,  0,  0,  0,  0,  0,  0,  0,  0,
  92.    0,  0,  0,  0,  0,  0,  0,  0,  0,
  93.    0,  0,  0,  0,  0,  0,  0,  0,  0,
  94.    0,  0,  0,  0,  0,  0,  0,  0,  0,
  95.    0,  0,  0,  0,  0,  0,  0,  0,  0,
  96.    0,  0,  0,  0,  0,  0,  0,  0,  0,
  97.    0,  0,  0,  0,  0,  0,  0,  0,  0, 
  98.    0,  0,  0,  0,  0,  0,  0,  0,  0, 
  99.    0,  0,  0,  0,  0,  0,  0,  0,  0 };
  100.  
  101. /* Pawn positional bonus (STATIC ROOK vs. STATIC ROOK) */
  102. static const short PawnAdvanceSS[NO_SQUARES] =
  103. {  0,  0,  0,  0,  0,  0,  0,  0,  0,
  104.    0,  0,  0,  0,  0,  0,  0,  0,  0,
  105.    0,  0,  0,  0,  0,  0,  0,  0,  0,
  106.    3, -2, 15,  4,  6,  1,  6,  8,  3, 
  107.    0, -5, -5,  0,  0,  0,  5, 10,  5, 
  108.    0,  0,  0,  0,  0,  0,  0,  0, 10, 
  109.    0,  0,  0,  0,  0,  0,  0,  0,  0, 
  110.    0,  0,  0,  0,  0,  0,  0,  0,  0, 
  111.    0,  0,  0,  0,  0,  0,  0,  0,  0 };
  112.  
  113. #define PawnAdvanceSR PawnAdvanceSS
  114.  
  115. /* Pawn positional bonus (RANGING ROOK vs. STATIC ROOK) */
  116. static const short PawnAdvanceRS[NO_SQUARES] =
  117. {  0,  0,  0,  0,  0,  0,  0,  0,  0,
  118.    0,  0,  0,  0,  0,  0,  0,  0,  0,
  119.    0,  0,  0,  0,  0,  0,  0,  0,  0,
  120.    3, -2, 15,  3,  5,  0, -2, -4,  3, 
  121.    1,  0,  8,  3,  5,  2,  2, -2, -2, 
  122.    0,  0,  0,  0,  0,  0,  0,  0,  0, 
  123.    0,  0,  0,  0,  0,  0,  0,  0,  0, 
  124.    0,  0,  0,  0,  0,  0,  0,  0,  0, 
  125.    0,  0,  0,  0,  0,  0,  0,  0,  0 };
  126.  
  127. #define PawnAdvanceRR PawnAdvanceRS
  128.  
  129. /* Lance positional bonus (STATIC ROOK vs. STATIC ROOK) */
  130. short LanceAdvanceSS[NO_SQUARES] =
  131. { 10,  5,  5,  5,  5,  5,  5,  5, 10,
  132.    2,  4,  4,  4,  4,  4,  4,  4,  2,
  133.    4,  1,  1,  1,  1,  1,  1,  1,  4,
  134.   -2, -2, -2, -2, -2, -2, -2, -2, -2, 
  135.   -4, -4, -4, -4, -4, -4, -4, -4, -4, 
  136.   -6, -6, -6, -6, -6, -6, -6, -6, -6,
  137.   -8, -8, -8, -8, -8, -8, -8, -8, -8, 
  138.   -9, -9, -9, -9, -9, -9, -9, -9, -9, 
  139.    0,  0,  0,  0,  0,  0,  0,  0,  0 }; /* impossible */
  140.  
  141. #define LanceAdvanceSR LanceAdvanceSS
  142. #define LanceAdvanceRS LanceAdvanceSS
  143. #define LanceAdvanceRR LanceAdvanceRS
  144.  
  145. /* Knight positional bonus (STATIC ROOK vs. STATIC ROOK) */
  146. short KnightAdvanceSS[NO_SQUARES] =
  147. {-9,  4,  4,  4, 4, 4, 4, 4,-9,
  148.  -9,  2,  2,  2, 2, 2, 2, 2,-9,
  149.  -9,  1,-10,  1, 1, 1, 1, 1,-9,
  150.  -9,  0,  0,  0, 0, 0, 0, 0,-9,
  151.  -9, -5,  0, -5, 0,-5, 0,-5,-9
  152.  -9,  0,  0,  0, 0, 0, 0, 0,-9,
  153.  -9, -9, -9, -9,-9,-9,-9,-9,-9,
  154.   0,  0,  0,  0, 0, 0, 0, 0, 0,  /* impossible */
  155.   0,  0,  0,  0, 0, 0, 0, 0, 0 };/* impossible */
  156.  
  157. #define KnightAdvanceSR KnightAdvanceSS
  158. #define KnightAdvanceRS KnightAdvanceSS
  159. #define KnightAdvanceRR KnightAdvanceRS
  160.  
  161. /* Silver positional bonus (STATIC ROOK vs. STATIC ROOK) */
  162. short SilverAdvanceSS[NO_SQUARES] =
  163. {  0,  0,  0,  0, -6,  0,  0,  0,  0,
  164.    0,  8,  3,  4,  0,  3,  2,  0,  0, 
  165.    0,  0, 10,  0,  0,  6,  6,  4,  0, 
  166.    0,  0,  0,  0,  4,  0,  4,  5,  0,
  167.    0,  0,  0,  0,  0,  0,  0,  0,  0, 
  168.    0,  0,  0,  0,  0,  0,  0,  0,  0, 
  169.    0,  0,  0,  0,  0,  0,  0,  0,  0, 
  170.    0,  0,  0,  0,  0,  0,  0,  0,  0, 
  171.    0,  0,  0,  0,  0,  0,  0,  0,  0 };
  172.  
  173. /* Silver positional bonus (STATIC ROOK vs. RANGING ROOK) */
  174. short SilverAdvanceSR[NO_SQUARES] =
  175. {  0,  0,  0,  0, -6,  0,  0,  0,  0,
  176.    0, -4, -4,  4,  0,  5,  3,  0,  0, 
  177.    0,  0, -4, -4,  2,  8,  6,  0,  0, 
  178.    0,  0,  0,  3,  0,  0,  4,  0,  0,
  179.    0,  0,  0,  0,  0,  0,  0,  0,  0,
  180.    0,  0,  0,  0,  0,  0,  0,  0,  0,
  181.    0,  0,  0,  0,  0,  0,  0,  0,  0,
  182.    0,  0,  0,  0,  0,  0,  0,  0,  0,
  183.    0,  0,  0,  0,  0,  0,  0,  0,  0 };
  184.  
  185. /* Silver positional bonus (RANGING ROOK vs. STATIC ROOK) */
  186. short SilverAdvanceRS[NO_SQUARES] =
  187. { -3,  0,  0,  0,  0,  0,  0,  0, -2,
  188.   -3, -1,  3,  3, -1, -1,  8, -1, -2, 
  189.   -2, -2,  0,  5, -1,  9, -2,  5, -3, 
  190.    0,  0,  5,  2,  5,  0,  0,  0,  0,
  191.    0,  0,  0,  0,  0,  0,  0,  0,  0,
  192.    0,  0,  0,  0,  0,  0,  0,  0,  0,
  193.    0,  0,  0,  0,  0,  0,  0,  0,  0,
  194.    0,  0,  0,  0,  0,  0,  0,  0,  0,
  195.    0,  0,  0,  0,  0,  0,  0,  0,  0 };
  196.  
  197. #define SilverAdvanceRR SilverAdvanceRS 
  198.  
  199. /* Gold positional bonus (STATIC ROOK vs. STATIC ROOK) */
  200. short GoldAdvanceSS[NO_SQUARES] =
  201. {  0,  0,  0,  0,  0,  0,  0,  0,  0,
  202.    0,  0, 10,  0,  6,  0,  0,  0,  0, 
  203.    0,  0,  0,  8,  0,  0,  0,  0,  0, 
  204.    0,  0,  0,  0,  0,  0,  0,  0,  0,
  205.    0,  0,  0,  0,  0,  0,  0,  0,  0, 
  206.    0,  0,  0,  0,  0,  0,  0,  0,  0,
  207.    0,  0,  0,  0,  0,  0,  0,  0,  0, 
  208.    0,  0,  0,  0,  0,  0,  0,  0,  0, 
  209.    0,  0,  0,  0,  0,  0,  0,  0,  0 };
  210.  
  211. /* Gold positional bonus (STATIC ROOK vs. RANGING ROOK) */
  212. short GoldAdvanceSR[NO_SQUARES] =
  213. {  0,  0,  0, 10,  0,  0,  0,  0,  0,
  214.    0,  0,  0,  0,  6,  0,  0,  0,  0, 
  215.    0,  0,  0,  0,  0,  0,  0,  0,  0, 
  216.    0,  0,  0,  0,  0,  0,  0,  0,  0,
  217.    0,  0,  0,  0,  0,  0,  0,  0,  0, 
  218.    0,  0,  0,  0,  0,  0,  0,  0,  0,
  219.    0,  0,  0,  0,  0,  0,  0,  0,  0, 
  220.    0,  0,  0,  0,  0,  0,  0,  0,  0, 
  221.    0,  0,  0,  0,  0,  0,  0,  0,  0 };
  222.  
  223. /* Gold positional bonus (RANGING ROOK vs. STATIC ROOK) */
  224. short GoldAdvanceRS[NO_SQUARES] =
  225. { -1,  0, -1,  0, -1,  0, -1, -1, -1,
  226.   -1,  0,  4, -1,  4, -1,  8,  0, -1, 
  227.   -2, -1,  0, -2,  0,  6,  0, -1, -2, 
  228.    0,  0,  0,  0,  0,  0,  0,  0,  0,
  229.    0,  0,  0,  0,  0,  0,  0,  0,  0, 
  230.    0,  0,  0,  0,  0,  0,  0,  0,  0,
  231.    0,  0,  0,  0,  0,  0,  0,  0,  0, 
  232.    0,  0,  0,  0,  0,  0,  0,  0,  0, 
  233.    0,  0,  0,  0,  0,  0,  0,  0,  0 };
  234.  
  235. #define GoldAdvanceRR GoldAdvanceRS
  236.  
  237. /* Bishop positional bonus (STATIC ROOK vs. STATIC ROOK) */
  238. short BishopAdvanceSS[NO_SQUARES] =
  239. {  3,  0,  0,  0,  0,  0,  0,  0,  3,
  240.    0,  4,  0,  8,  0,  0,  0,  3,  0, 
  241.    0,  0,  6,  0,  0,  0,  4,  0,  0, 
  242.    0,  2,  0,  3,  0,  3,  0,  2,  0,
  243.    0,  0,  2,  0,  3,  0,  0,  0,  0, 
  244.    0,  2,  0,  3,  0,  3,  0,  2,  0,
  245.    0,  0,  3,  0,  0,  0,  3,  0,  0, 
  246.    0,  3,  0,  0,  0,  0,  0,  3,  0, 
  247.    3,  0,  0,  0,  0,  0,  0,  0,  3 };
  248.  
  249. /* Bishop positional bonus (STATIC ROOK vs. RANGING ROOK) */
  250. short BishopAdvanceSR[NO_SQUARES] =
  251. {  3,  0,  0,  0,  0,  0,  0,  0,  3,
  252.    0, 10,  0,  2,  0,  0,  0,  3,  0, 
  253.    0,  0,  2,  0,  0,  0,  4,  0,  0, 
  254.    0,  2,  0,  3,  0,  3,  0,  2,  0,
  255.    0,  0,  2,  0,  3,  0,  0,  0,  0, 
  256.    0,  2,  0,  3,  0,  3,  0,  2,  0,
  257.    0,  0,  3,  0,  0,  0,  3,  0,  0, 
  258.    0,  3,  0,  0,  0,  0,  0,  3,  0, 
  259.    3,  0,  0,  0,  0,  0,  0,  0,  3 };
  260.  
  261. /* Bishop positional bonus (RANGING ROOK vs. STATIC ROOK) */
  262. short BishopAdvanceRS[NO_SQUARES] =
  263. {  3,  0,  0,  0,  0,  0,  0,  0,  3,
  264.    0,  4,  0,  2,  0,  0,  0,  3,  0, 
  265.    0,  0,  8,  0,  0,  0,  4,  0,  0, 
  266.    0,  2,  0,  3,  0,  3,  0,  2,  0,
  267.    0,  0,  2,  0,  3,  0,  0,  0,  0, 
  268.    0,  2,  0,  3,  0,  3,  0,  2,  0,
  269.    0,  0,  3,  0,  0,  0,  3,  0,  0, 
  270.    0,  3,  0,  0,  0,  0,  0,  3,  0, 
  271.    3,  0,  0,  0,  0,  0,  0,  0,  3 };
  272.  
  273. #define BishopAdvanceRR BishopAdvanceRS
  274.  
  275. /* Rook positional bonus (STATIC ROOK vs. STATIC ROOK) */
  276. short RookAdvanceSS[NO_SQUARES] =
  277. {  2,  0,  0,  0,  0,  0,  0,  4,  2,
  278.    2,  0,  0,  0,  0,  0,  0,  8,  2, 
  279.   -2,  0,  0,  0,  0,  0,  0,  2, -2, 
  280.   -2,  0,  0,  0,  0,  0,  0,  4, -2,
  281.   -2,  0,  0,  0,  0,  0,  0,  2, -2, 
  282.   -2,  0,  0,  0,  0,  0,  0,  2, -2,
  283.    4,  4,  4,  4,  4,  4,  4,  4,  4, 
  284.    6,  6,  6,  6,  6,  6,  6,  6,  6, 
  285.    8,  8,  8,  8,  8,  8,  8,  8,  8 };
  286.  
  287. /* Rook positional bonus (RANING ROOK vs. STATIC ROOK) */
  288. short RookAdvanceRS[NO_SQUARES] =
  289. {  2,  6,  6,  6,  6,  0,  0,  0,  2,
  290.    2,  4,  4,  4,  4,  0,  0,  0,  2, 
  291.   -2,  2,  3,  3,  3,  0,  0,  0, -2, 
  292.   -2,  4,  1,  1,  1,  0,  0,  0, -2,
  293.   -2,  0,  2,  2,  2,  0,  0,  0, -2, 
  294.   -2,  0,  0,  0,  0,  0,  0,  0, -2,
  295.    4,  4,  4,  4,  4,  4,  4,  4,  4, 
  296.    6,  6,  6,  6,  6,  6,  6,  6,  6, 
  297.    8,  8,  8,  8,  8,  8,  8,  8,  8 };
  298.  
  299. #define RookAdvanceSR RookAdvanceSS
  300. #define RookAdvanceRR RookAdvanceRS
  301.  
  302. /* King positional bonus inopening stage (STATIC ROOK vs. STATIC ROOK) */
  303. static const short KingAdvanceSS[NO_SQUARES] =
  304. {  0, -4, 10,  0, -6, -8,-10,-12,-12,
  305.   -2,  4,  6, -6, -8, -8,-10,-12,-12,
  306.   -6, -6, -6, -8, -8,-10,-11,-12,-12,
  307.  -12,-12,-12,-12,-12,-12,-12,-12,-12,
  308.  -12,-12,-12,-12,-12,-12,-12,-12,-12,
  309.  -12,-12,-12,-12,-12,-12,-12,-12,-12,
  310.  -12,-12,-12,-12,-12,-12,-12,-12,-12,
  311.  -12,-12,-12,-12,-12,-12,-12,-12,-12,
  312.  -12,-12,-12,-12,-12,-12,-12,-12,-12 };
  313.  
  314. /* King positional bonus inopening stage (STATIC ROOK vs. RANGING ROOK) */
  315. static const short KingAdvanceSR[NO_SQUARES] =
  316. {  5, -4, -4, -4, -6, -8,-10,-12,-12,
  317.   -2,  4, 10,  6, -8, -8,-10,-12,-12,
  318.   -6, -6, -6, -8, -8,-10,-11,-12,-12,
  319.  -12,-12,-12,-12,-12,-12,-12,-12,-12,
  320.  -12,-12,-12,-12,-12,-12,-12,-12,-12,
  321.  -12,-12,-12,-12,-12,-12,-12,-12,-12,
  322.  -12,-12,-12,-12,-12,-12,-12,-12,-12,
  323.  -12,-12,-12,-12,-12,-12,-12,-12,-12,
  324.  -12,-12,-12,-12,-12,-12,-12,-12,-12 };
  325.  
  326. /* King positional bonus inopening stage (RANGING ROOK vs. STATIC ROOK) */
  327. static const short KingAdvanceRS[NO_SQUARES] =
  328. {-12,-12, -8, -6, -4, -8,-10,-12,-12,
  329.  -12,-12, -8, -6, -8, 12, 16, 20, -8,
  330.  -12,-12, -6, -8, -8,-10,  0,  0, -4,
  331.  -12,-12,-12,-12,-12,-12,  0,  0,-12,
  332.  -12,-12,-12,-12,-12,-12,-12,-12,-12,
  333.  -12,-12,-12,-12,-12,-12,-12,-12,-12,
  334.  -12,-12,-12,-12,-12,-12,-12,-12,-12,
  335.  -12,-12,-12,-12,-12,-12,-12,-12,-12,
  336.  -12,-12,-12,-12,-12,-12,-12,-12,-12 };
  337.                                   
  338. #define KingAdvanceRR KingAdvanceRS
  339.                      
  340.  
  341.  
  342. static short Kfield[2][NO_SQUARES];
  343.  
  344. char GameType[2] = { UNKNOWN, UNKNOWN };
  345.  
  346. #ifdef USE_PATTERN
  347. OpeningPattern *attack_pattern[2], *castle_pattern[2];
  348. #endif
  349.  
  350. short Mpawn[2][NO_SQUARES]; 
  351. short Msilver[2][NO_SQUARES]; 
  352. short Mgold[2][NO_SQUARES]; 
  353.  
  354. static short *Mlance[2]; 
  355. static short *Mknight[2]; 
  356. static short *Mbishop[2]; 
  357. static short *Mrook[2]; 
  358.  
  359. static short Mking[2][NO_SQUARES];
  360.  
  361. static short c1, c2;
  362. static small_short *PC1, *PC2;
  363.  
  364. static long *atk1, *atk2;
  365.  
  366. static long int atak[2][NO_SQUARES];
  367. static short R2NDCOL, EDRNK2B, PWEAKH, PADVNCM, PAWNSHIELD;
  368. static short NADVNCM, SADVNCM, GADVNCM;
  369. static short PMBLTY, BDCLOSED, PSTRONG, P2STRONG;
  370.  
  371. static short PawnBonus, BishopBonus, RookBonus;
  372. static short KNIGHTPOST, KNIGHTSTRONG, BISHOPSTRONG, KATAK;
  373. static short RHOPN, RHOPNX, BHCLSD, BHCLSDX, KHOPN, KHOPNX, KSFTY;
  374.  
  375. static short LHOPN, LHOPNX, LPROTECT, NDNGR, LDNGR;
  376. static short SBEFOREG, BXCHG;
  377. static short LXRAY, BRXRAY;
  378. static short KINGED, KINGOD, PROMD;
  379.  
  380. static short KCASTLD, KMOVD, KADVNCM, OPENOK, OPENWRONG;
  381. static short ATAKD, HUNGP, HUNGX, PINVAL;
  382.  
  383. #ifdef USE_PATTERN
  384. static short PATTACK, PCASTLE;
  385. #endif
  386.  
  387.  
  388. short emtl[2];
  389. short pscore[2];
  390. short tmtl;
  391.  
  392.  
  393.  
  394. #if defined DEBUG8 || defined DEBUG_EVAL
  395.                                                
  396.  
  397. void
  398. debug_position (FILE *D)
  399. { 
  400.   short r, c, l, side, piece;
  401.  
  402.   fprintf (D, "\n current board is\n\n");
  403.   for (piece = pawn; piece <= king; piece++)
  404.     if (c = Captured[white][piece]) 
  405.       fprintf(D, "%i%c ",c,pxx[piece]);
  406.   fprintf (D, "\n");
  407.   for (c = 0; c < NO_COLS; c++)
  408.     fprintf (D, " %d", PawnCnt[white][c]); 
  409.   fprintf (D, "\n\n");
  410.   for (r = (NO_ROWS-1); r >= 0; r--)
  411.     {
  412.     for (c = 0; c < NO_COLS; c++)
  413.         {
  414.           l = locn (r, c);
  415.           if (color[l] == neutral)
  416.         fprintf (D, " -");
  417.           else if (color[l] == black)
  418.         fprintf (D, " %c", qxx[board[l]]);
  419.           else
  420.         fprintf (D, " %c", pxx[board[l]]);
  421.         }
  422.     fprintf (D, "\n");
  423.     }
  424.   fprintf (D, "\n");
  425.   for (c = 0; c < NO_COLS; c++)
  426.     fprintf (D, " %d", PawnCnt[black][c]); 
  427.   fprintf (D, "\n");
  428.   for (piece = pawn; piece <= king; piece++)
  429.     if (c = Captured[black][piece]) 
  430.       fprintf(D, "%i%c ",c,pxx[piece]);
  431.   fprintf(D, "\n");
  432. }                                      
  433.  
  434. void
  435. debug_svalue (FILE *D)
  436. { 
  437.   short r, c;
  438.  
  439.   for (r = (NO_ROWS-1); r >= 0; r--)
  440.     {
  441.     for (c = 0; c < NO_COLS; c++)
  442.         {
  443.           short sq = (r * NO_COLS) + c;
  444.           fprintf(D,"%5d",svalue[sq]);
  445.         }
  446.     fprintf (D, "\n");
  447.     }
  448.   fprintf (D, "\n");
  449. }                                      
  450.  
  451. void
  452. debug_table (FILE *D, short *table)
  453. { 
  454.   short r, c;
  455.  
  456.   for (r = (NO_ROWS-1); r >= 0; r--)
  457.     {
  458.     for (c = 0; c < NO_COLS; c++)
  459.         {
  460.           short sq = (r * NO_COLS) + c;
  461.           fprintf(D,"%5d",table[sq]);
  462.         }
  463.     fprintf (D, "\n");
  464.     }
  465.   fprintf (D, "\n");
  466. }                                      
  467.  
  468. void
  469. debug_ataks (FILE *D)
  470. {              
  471.   short side;
  472.   for (side = black; side <= white; side++)
  473.     {                 
  474.     short l,c,i;         
  475.     long *atk = atak[side];
  476.     fprintf(D, "\n");
  477.     for (l = NO_ROWS-1; l >= 0; l--) {
  478.       for (c = 0; c < NO_COLS; c++) {
  479.         short sq = (l * NO_COLS) + c;
  480.         long  v = atk[sq];
  481.         short n = (short)(v & CNT_MASK);
  482.         char s[20];
  483.         fprintf(D,"%2d",n);
  484.         strcpy(s,"");
  485.         if ( v & ctlP  ) strcat(s,"P"); 
  486.         if ( v & ctlPp ) strcat(s,"+P");
  487.         if ( v & ctlL  ) strcat(s,"L"); 
  488.         if ( v & ctlLp ) strcat(s,"+L"); 
  489.         if ( v & ctlN  ) strcat(s,"N"); 
  490.         if ( v & ctlNp ) strcat(s,"+N"); 
  491.         if ( v & ctlS  ) strcat(s,"S"); 
  492.         if ( v & ctlSp ) strcat(s,"+S"); 
  493.         if ( v & ctlG  ) strcat(s,"G"); 
  494.         if ( v & ctlB  ) strcat(s,"B"); 
  495.         if ( v & ctlBp ) strcat(s,"+B"); 
  496.         if ( v & ctlR  ) strcat(s,"R"); 
  497.         if ( v & ctlRp ) strcat(s,"+R"); 
  498.         if ( v & ctlK  ) strcat(s,"K");
  499.         fprintf(D,s);
  500.         for (i = strlen(s); i < 5; i++)
  501.         fprintf(D," ");
  502.         fprintf(D," "); 
  503.       }                              
  504.       fprintf(D,"\n");
  505.     }
  506.     fprintf(D, "\n");
  507.     }
  508. }
  509.  
  510. #endif
  511.  
  512.  
  513.  
  514.  
  515. /* ............    POSITIONAL EVALUATION ROUTINES    ............ */
  516.  
  517. /*
  518.  * Inputs are:
  519.  * pmtl[side] - value of pawns
  520.  * mtl[side]  - value of all material
  521.  * emtl[side] - value of all material - value of pawns - value of king
  522.  * hung[side] - count of hung pieces
  523.  * Tscore[ply] - search tree score for ply
  524.  * ply
  525.  * Pscore[ply] - positional score for ply ply
  526.  * INCscore    - bonus score or penalty for certain moves
  527.  * slk - single lone king flag
  528.  * Sdepth - search goal depth
  529.  * xwndw - evaluation window about alpha/beta
  530.  * EWNDW - second evaluation window about alpha/beta
  531.  * ChkFlag[ply]- checking piece at level ply or 0 if no check
  532.  */
  533.  
  534.  
  535.  
  536. int
  537. evaluate (register short int side,
  538.       register short int ply,
  539.       register short int alpha,
  540.       register short int beta,
  541.       short int INCscore,
  542.       short int *InChk)    /* output Check flag */
  543.  
  544. /*
  545.  * Compute an estimate of the score by adding the positional score from the
  546.  * previous ply to the material difference. If this score falls inside a
  547.  * window which is 180 points wider than the alpha-beta window (or within a
  548.  * 50 point window during quiescence search) call ScorePosition() to
  549.  * determine a score, otherwise return the estimated score. 
  550.  */
  551.  
  552. {
  553.     register short evflag, xside;
  554.     register short int slk;
  555.     short s, sq;
  556.     int HEVAL = false;
  557.  
  558.     xside = side ^ 1;
  559.     s = -Pscore[ply - 1] + mtl[side] - mtl[xside] + INCscore;
  560.     hung[black] = hung[white] = 0;
  561.           /* should we use the estimete or score the position */
  562.     if ((ply <= Sdepth ||
  563. #ifdef CACHE
  564.         (HEVAL = CheckEETable (side)) ||
  565. #endif
  566.     ((ply == Sdepth + 1 || ply == (Sdepth + 2)) && (s > (alpha - xwndw) && s < (beta + xwndw))) ||
  567.     (ply > (Sdepth + 2) && s >= (alpha - EWNDW) && s <= (beta + EWNDW))))
  568.       {
  569.       /* score the position */
  570.       ataks (side, atak[side]);
  571. #ifdef CHECKPIECELIST
  572.       if ( board[PieceList[xside][0]] != king )
  573.         {
  574.           printf("illegal xside PieceList\n");
  575.           exit(1);
  576.         }    
  577. #endif           
  578. #if ATAKSCROSSCHECK 
  579.       { int b1, b2;
  580.             sq = PieceList[xside][0];
  581.             b1 = SqAtakd (sq, side);
  582.         b2 = Anyatak (side, sq);
  583.             if ( b1 != b2 ) {
  584.               printf("SqAtakd %d != Anyatak %d for square %d\n",b1,b2,sq);
  585.               exit(1);
  586.             } else {
  587.               if ( b1 )
  588.             return ((SCORE_LIMIT+1001) - ply); 
  589.             }
  590.           }
  591. #else
  592.       if ( board[sq = PieceList[xside][0]] == king )
  593.       if (Anyatak (side, sq))
  594.           return ((SCORE_LIMIT+1001) - ply);
  595. #endif
  596.       ataks (xside, atak[xside]);
  597. #ifdef CHECKPIECELIST
  598.       if ( board[PieceList[side][0]] != king )
  599.         {
  600.           printf("illegal side PieceList\n");
  601.           exit(1);
  602.         }    
  603. #endif           
  604. #if ATAKSCROSSCHECK 
  605.       { int b1, b2;
  606.             sq = PieceList[side][0];
  607.             b1 = SqAtakd (sq, xside);
  608.         b2 = Anyatak (xside, sq);
  609.             if ( b1 != b2 ) {
  610.               printf("SqAtakd %d != Anyatak %d for square %d\n",b1,b2,sq);
  611.               exit(1);
  612.             } else {
  613.               *InChk = b1;
  614.             }
  615.           }
  616. #else
  617.       if ( board[sq = PieceList[side][0]] == king )
  618.         *InChk = Anyatak (xside, sq);
  619.       else
  620.         *InChk = false;
  621. #endif
  622. #if !defined BAREBONES
  623.       EvalNodes++;
  624. #endif         
  625.       if ( flag.tsume )
  626.         s = urand () % 50;
  627.       else  
  628.         s = ScorePosition (side);
  629.       }
  630.     else
  631.       {
  632.       /* use the estimate but look at check and slk */
  633.       short sq;
  634.       sq = PieceList[xside][0];
  635. #if CHECKPIECELIST 
  636.       if ( board[sq] != king )
  637.         {
  638.           printf("illegal xside 2 PieceList\n");
  639.           exit(1);
  640.         }
  641. #endif        
  642. #if ATAKSCROSSCHECK 
  643.       { int b1, b2;
  644.         ataks (side, atak[side]);
  645.             b1 = SqAtakd (sq, side);
  646.         b2 = Anyatak (side, sq);
  647.             if ( b1 != b2 ) {
  648.               printf("SqAtakd %d != Anyatak %d for square %d\n",b1,b2,sq);
  649.               exit(1);
  650.             } else {
  651.               if ( b1 )
  652.             return ((SCORE_LIMIT+1001) - ply); 
  653.             }
  654.           }
  655. #else
  656.       if ( board[sq] == king )
  657.       if ( SqAtakd (sq, side) )
  658.           return ((SCORE_LIMIT+1001) - ply);
  659. #endif
  660.       sq = PieceList[side][0];
  661. #if CHECKPIECELIST 
  662.       if ( board[sq] != king )
  663.         {
  664.           printf("illegal side 2 PieceList\n");
  665.           exit(1);
  666.         }
  667. #endif
  668. #if ATAKSCROSSCHECK 
  669.       { int b1, b2;
  670.         ataks (xside, atak[xside]);
  671.             b1 = SqAtakd (sq, xside);
  672.         b2 = Anyatak (xside, sq);
  673.             if ( b1 != b2 ) {
  674.               printf("SqAtakd %d != Anyatak %d for xsquare %d\n",b1,b2,sq);
  675.               exit(1);
  676.             } else {
  677.               *InChk = b1;
  678.             }
  679.           }
  680. #else
  681.       if ( board[sq] == king )
  682.         *InChk = SqAtakd (sq, xside); 
  683.       else
  684.         *InChk = false;
  685. #endif
  686.       }
  687.  
  688.     Pscore[ply] = s + (mtl[xside] - mtl[side]);
  689.     ChkFlag[ply - 1] = ((*InChk) ? Pindex[TOsquare] : 0);
  690.     return (s);
  691. }
  692.  
  693. inline
  694. int
  695. BRLscan (register short int sq, short int *mob)
  696.  
  697. /*
  698.  * Find (promoted) Bishop, (promoted) Rook, and Lance mobility, XRAY attacks, and pins. 
  699.  * Let BRL be the bishop, rook, or lance.
  700.  * Let P be the first piece (no king and no pawn) in a direction and let Q be the second
  701.  * piece in the same direction. If Q is an unprotected opponent's piece with 
  702.  * bigger relative value than BRL, there is a pin if P is an opponent's piece and
  703.  * there is an XRAY attack if P is an own piece.
  704.  * Increment the hung[] array if a pin is found.
  705.  */
  706. {
  707.     register unsigned char *ppos, *pdir;
  708.     register short s, mobx;
  709.     register short u, pin, ptyp;
  710.     short piece, *Kf, rvalue;
  711.     mobx = s = 0;
  712.     Kf = Kfield[c1];
  713.     piece = board[sq];
  714.  
  715.     rvalue = relative_value[piece];
  716.     ptyp = ptype[c1][unpromoted[piece]];
  717.     ppos = (*nextpos[ptyp])[sq];
  718.     pdir = (*nextdir[ptyp])[sq];
  719.  
  720.     u = ppos[sq];                         
  721.     pin = -1;            /* start new direction */
  722.     do
  723.       {
  724.       s += Kf[u];
  725. #ifdef DEBUG_EVAL
  726.       if ( debug_eval && Kf[u] != 0 )
  727.         fprintf(debug_eval_file,"add %d for controlling square near enemy king\n",Kf[u]);
  728. #endif
  729.       if (color[u] == neutral)
  730.         {
  731.         mobx++;
  732.         if (ppos[u] == pdir[u])
  733.             pin = -1;    /* oops new direction */
  734.         u = ppos[u];
  735.         }
  736.       else 
  737.         {   /* there is a piece in current direction */
  738.         if (pin < 0)
  739.             {   /* it's the first piece in the current direction */
  740.             if (piece == lance && color[u] == c1 )
  741.               {
  742.                   s += LPROTECT;
  743. #ifdef DEBUG_EVAL
  744.                   if ( debug_eval )
  745.                 fprintf(debug_eval_file,"adding %d for lance protection\n",LPROTECT);
  746. #endif
  747.               }
  748.             else if ( piece == bishop && board[u] == pawn )
  749.               {
  750.                   if ( color[u] == c1 )
  751.                 {
  752.                   s += 2*BHCLSD; 
  753. #ifdef DEBUG_EVAL
  754.                   if (debug_eval )
  755.                     fprintf(debug_eval_file,"add %d for own pawn in bishops direction\n",2*BHCLSD);
  756. #endif
  757.                 }
  758.                   else
  759.                 {
  760.                   s += 2*BHCLSDX;
  761. #ifdef DEBUG_EVAL
  762.                   if (debug_eval )
  763.                     fprintf(debug_eval_file,"add %d for opponents pawn in bishops direction\n",2*BHCLSDX);
  764. #endif
  765.                 }
  766.               }
  767.             if (board[u] == pawn || board[u] == king)
  768.                 u = pdir[u];
  769.             else
  770.               {
  771.                   if (ppos[u] != pdir[u])
  772.                   pin = u;    /* not on the edge and on to find a pin */
  773.                   u = ppos[u];
  774.               }
  775.             }
  776.         else
  777.             {
  778.             /* it's the second piece in the current direction */
  779.             if ( piece == bishop && board[u] == pawn )
  780.               {
  781.                   if ( color[u] == c1 )
  782.                 {
  783.                   s += BHCLSD; 
  784. #ifdef DEBUG_EVAL
  785.                   if (debug_eval )
  786.                     fprintf(debug_eval_file,"add %d for own pawn in bishops direction\n",BHCLSD);
  787. #endif
  788.                 }
  789.                   else
  790.                 {
  791.                   s += BHCLSDX;
  792. #ifdef DEBUG_EVAL
  793.                   if (debug_eval )
  794.                     fprintf(debug_eval_file,"add %d for opponents pawn in bishops direction\n",BHCLSDX);
  795. #endif
  796.                 }
  797.               }
  798.             if ((color[u] == c2) && 
  799.                         (relative_value[board[u]] > rvalue || atk2[u] == 0))
  800.               {
  801.                   if (color[pin] == c2)
  802.                 {
  803.                     s += PINVAL;
  804. #ifdef DEBUG_EVAL
  805.                     if ( debug_eval )
  806.                       fprintf(debug_eval_file,"adding %d for pin\n",PINVAL);
  807. #endif
  808.                     if (atk2[pin] == 0 || atk1[pin] > control[board[pin]] + 1)
  809.                     ++hung[c2];
  810.                 }
  811.                   else
  812.                 if ( piece == lance ) {
  813.                   s += LXRAY;
  814. #ifdef DEBUG_EVAL
  815.                   if ( debug_eval )
  816.                     fprintf(debug_eval_file,"lance xray: %d\n",LXRAY);
  817. #endif
  818.                 } else {
  819.                   s += BRXRAY; 
  820. #ifdef DEBUG_EVAL
  821.                   if ( debug_eval )
  822.                     fprintf(debug_eval_file,"bishop/rook xray: %d\n",BRXRAY);
  823. #endif
  824.                 }
  825.               }   
  826.             pin = -1;    /* new direction */
  827.             u = pdir[u];
  828.             }
  829.         }
  830.       }
  831.     while (u != sq);
  832.     *mob = mobx;
  833.     return s;
  834. }
  835.  
  836. inline
  837. short int
  838. KingScan (register short int sq)
  839.  
  840. /*
  841.  * Assign penalties if king can be threatened by checks, if squares near the
  842.  * king are controlled by the enemy (especially the queen), or if there are
  843.  * no pawns near the king. The following must be true: board[sq] == king c1
  844.  * == color[sq] c2 == otherside[c1]
  845.  */
  846.  
  847.  
  848. #define ScoreThreat \
  849.     if (color[u] != c2)\
  850.       if (atk1[u] == 0 || (atk2[u] & CNT_MASK) > 1) ++cnt;\
  851.       else s -= 3
  852.  
  853.  
  854. {
  855.     register short cnt;
  856.     register unsigned char *ppos, *pdir;
  857.     register short int s;
  858.     register short u, ptyp;
  859.     short int ok;
  860.  
  861.     s = 0;
  862.     cnt = 0;
  863.     { short p;
  864.       for ( p = pawn; p < king; p++ )
  865.     if ( HasPiece[c2][p] )
  866.           { short ptyp = ptype[c2][p];
  867.         ppos = (*nextpos[ptyp])[sq];
  868.         pdir = (*nextdir[ptyp])[sq];
  869.         u = ppos[sq];
  870.         do
  871.           {
  872.         if (atk2[u] & control[p])
  873.             ScoreThreat;
  874.         u = ((color[u] == neutral) ? ppos[u] : pdir[u]);
  875.           }
  876.         while (u != sq);
  877.           }
  878.     }
  879.     s += (KSFTY * KTHRT[cnt]);
  880.  
  881.     cnt = 0;
  882.     ok = false;
  883.     ptyp = ptype[black][king];
  884.     pdir = (*nextpos[ptyp])[sq];
  885.     u = pdir[sq];
  886.     do
  887.       {
  888.       if (board[u] == pawn)
  889.           ok = true;
  890.       if (atk2[u] > atk1[u])
  891.         {
  892.         ++cnt;
  893.         }
  894.       u = pdir[u];
  895.       }
  896.     while (u != sq);
  897.     if (!ok)
  898.     s -= KSFTY;
  899.     if (cnt > 1)
  900.     s -= KSFTY;
  901.     return (s);
  902. }
  903.  
  904. inline
  905. int
  906. trapped (register short int sq)
  907.  
  908. /*
  909.  * See if the attacked piece has unattacked squares to move to. The following
  910.  * must be true: c1 == color[sq] c2 == otherside[c1]
  911.  */
  912.  
  913. {
  914.     register short u, ptyp;
  915.     register unsigned char *ppos, *pdir;
  916.     register short int piece;
  917.  
  918.     piece = board[sq];
  919.     ptyp = ptype[c1][piece];
  920.     ppos = (*nextpos[ptyp])[sq];
  921.     pdir = (*nextdir[ptyp])[sq];
  922.       {
  923.       short rvalue = relative_value[piece];
  924.       u = ppos[sq];
  925.       do
  926.         {   
  927.         if (color[u] != c1)
  928.             if (atk2[u] == 0 || relative_value[board[u]] >= rvalue)
  929.               return (false);
  930.         u = ((color[u] == neutral) ? ppos[u] : pdir[u]);
  931.         }
  932.       while (u != sq);
  933.       }
  934. #ifdef DEBUG_EVAL
  935.     if ( debug_eval )
  936.       fprintf(debug_eval_file,"piece is trapped\n");
  937. #endif                             
  938.     return (true);
  939. }
  940.  
  941.  
  942.                                    
  943. #define mirrored(sq) (NO_SQUARES-1-sq)
  944. #define csquare(side,sq) ((side==black)?sq:mirrored(sq))
  945. #define crow(side,sq) row(csquare(side,sq))
  946. #define ccolumn(side,sq) column(csquare(side,sq))
  947.  
  948.  
  949. inline
  950. static short on_csquare(short side,short piece,short square)
  951. { short sq;
  952.   return(board[sq=csquare(side,square)]==piece && color[sq]==side);
  953. }
  954.     
  955. inline
  956. static short on_column(short side,short piece,short c)
  957. { short sq;
  958.   for (sq = c; sq < NO_SQUARES; sq+=9)
  959.     if (on_csquare(side,piece,sq))
  960.       return(true);
  961.   return(false);
  962. }
  963.  
  964. #define empty_square(side,square) (board[csquare(side,square)]==no_piece)
  965.  
  966. inline
  967. static short on_left_side(short side,short piece)
  968. { short c;
  969.   for (c=0; c<4; c++)
  970.     if (on_column(side,piece,c))
  971.       return(true);
  972.   return(false);
  973. }
  974.  
  975. inline
  976. static short on_right_side(short side,short piece)
  977. { short c;
  978.   for (c=5; c<NO_COLS; c++)
  979.     if (on_column(side,piece,c))
  980.       return(true);
  981.   return(false);
  982. }
  983.  
  984.  
  985. /* Distance bonus */
  986.  
  987. inline
  988. static
  989. short AddEnemyKingDistanceBonus (short sq)
  990. { short s = 0;
  991.   /* near enemy king */
  992.   if ( !in_opening_stage || behind_in_material[c1] )
  993.   if ( distance(sq,OwnKing) > 2 )
  994.     s = EnemyKingDistanceBonus[distance(sq,EnemyKing)];
  995.   return(s);
  996. }
  997.  
  998. inline
  999. static
  1000. short AddOwnKingDistanceBonus (short sq)
  1001. { short s = 0;
  1002.   /* near own king */
  1003.   if ( !in_opening_stage || behind_in_material[c1] )
  1004.     s = OwnKingDistanceBonus[distance(sq,OwnKing)];
  1005.   return(s);
  1006. }
  1007.  
  1008. inline
  1009. static
  1010. short AddPromotionZoneDistanceBonus (short sq)
  1011. { short s = 0;
  1012.   /* near promotion zone */
  1013.   if ( !in_opening_stage )
  1014.     s = PromotionZoneDistanceBonus[crow(c1,sq)];
  1015.   return(s);
  1016. }
  1017.  
  1018.  
  1019. static inline int
  1020. PawnValue (register short int sq, short int side)
  1021. /*
  1022.  * Calculate the positional value for a pawn on 'sq'.
  1023.  */
  1024.  
  1025. {
  1026.     register short s;
  1027.     long a1, a2;
  1028.  
  1029.     s = Mpawn[c1][csquare(c1,sq)];
  1030.  
  1031. #ifdef DEBUG_EVAL
  1032.     if ( debug_eval )
  1033.       fprintf(debug_eval_file,"inital value [%d] for pawn on %c%c: %d\n",
  1034.         csquare(c1,sq), cxx[column(sq)], rxx[row(sq)], s);
  1035. #endif
  1036.  
  1037.     s += PROMD * AddPromotionZoneDistanceBonus(sq);
  1038.  
  1039.     /* pawn mobility */
  1040.     {
  1041.     short u, ptyp;
  1042.     register unsigned char *pdir;
  1043.     ptyp = ptype[c1][pawn];
  1044.     pdir = (*nextdir[ptyp])[sq];
  1045.     u = pdir[sq];
  1046.     if ( u != sq )
  1047.       if ( color[u] == neutral ) {
  1048.             s += PMBLTY;
  1049. #ifdef DEBUG_EVAL
  1050.         if ( debug_eval )
  1051.               fprintf(debug_eval_file,"adding %d for mobility\n", PMBLTY);
  1052. #endif       
  1053.       }
  1054.     }
  1055.     
  1056.     a1 = atk1[sq];
  1057.     a2 = atk2[sq];
  1058.  
  1059.     if (a2 > 0)
  1060.       {
  1061.       if (a1 == 0 || a2 > ctlP + 1)
  1062.         {
  1063.         s += HUNGP;
  1064. #ifdef DEBUG_EVAL
  1065.         if ( debug_eval )
  1066.                   fprintf(debug_eval_file,"adding %d for hung\n", HUNGP);
  1067. #endif       
  1068.         if (trapped (sq)) {
  1069.             hung[c1] += 2;
  1070.         }
  1071.         hung[c1]++;
  1072.         }
  1073.       else if (a2 > a1) {
  1074.           s += ATAKD;   
  1075. #ifdef DEBUG_EVAL     
  1076.           if ( debug_eval )
  1077.                 fprintf(debug_eval_file,"adding %d for atacked piece\n",ATAKD);
  1078. #endif                             
  1079.       }
  1080.       }          
  1081.  
  1082.     if ( a1 > 0 ) {
  1083.       s += (a1 & CNT_MASK);
  1084. #ifdef DEBUG_EVAL
  1085.       if ( debug_eval )
  1086.         fprintf(debug_eval_file,"adding %d for protected piece\n",(a1 & CNT_MASK));
  1087. #endif                             
  1088.     }
  1089.  
  1090.     if ( sq == csquare(c1,20) ) {
  1091.       s += BDCLOSED;
  1092. #ifdef DEBUG_EVAL
  1093.       if ( debug_eval )
  1094.         fprintf(debug_eval_file,"adding %d for closed bishops diagonal\n",BDCLOSED);
  1095. #endif         
  1096.     }                    
  1097.  
  1098.     if ( (a1 & ((ctlR | ctlRp) | ctlL)) ) {
  1099.       s += PSTRONG;
  1100. #ifdef DEBUG_EVAL
  1101.       if ( debug_eval )
  1102.         fprintf(debug_eval_file,"adding %d for rook/lance-supported pawn\n", PSTRONG);
  1103. #endif
  1104.     }         
  1105.  
  1106.     if ( in_opening_stage )
  1107.       if ( crow(c1,sq) == 2 ) /* pawn on 3d rank */
  1108.         if ( Mvboard[(c1==black)?(sq+36):(sq-36)] )
  1109.           {  /* opposing pawn has been moved (even column == (sq & 1)) */
  1110.          s -= (sq & 1) ? PMBLTY : (3*PMBLTY)/2;   
  1111. #ifdef DEBUG_EVAL
  1112.          if ( debug_eval )
  1113.                fprintf(debug_eval_file,"adding %d for opposing pawn pushed\n",
  1114.                    -((sq & 1) ? PMBLTY : (3*PMBLTY)/2));
  1115. #endif         
  1116.           }
  1117.       
  1118.     if ( sq == csquare(c1,43) )
  1119.       {  
  1120.         if ( (atk2[csquare(c1,52)] & CNT_MASK) < 2 ) {
  1121.              s += P2STRONG;
  1122. #ifdef DEBUG_EVAL
  1123.          if ( debug_eval )
  1124.                fprintf(debug_eval_file,"adding %d for attacking pawn on 2nd col\n",
  1125.                    P2STRONG);
  1126. #endif         
  1127.           }
  1128.       }
  1129.  
  1130.     return (s);
  1131. }
  1132.  
  1133.  
  1134. static inline int
  1135. LanceValue (register short int sq, short int side)
  1136. /*
  1137.  * Calculate the positional value for a lance on 'sq'.
  1138.  */
  1139.  
  1140. {
  1141.     register short s;
  1142.     register short fyle;
  1143.     short mob;
  1144.     long a1, a2;
  1145.     short checked_trapped = false;
  1146.  
  1147.     s = Mlance[c1][csquare(c1,sq)];
  1148.     
  1149. #ifdef DEBUG_EVAL
  1150.     if ( debug_eval )
  1151.       fprintf(debug_eval_file,"inital value [%d] for lance on %c%c: %d\n",
  1152.         csquare(c1,sq), cxx[column(sq)], rxx[row(sq)], s);
  1153. #endif
  1154.  
  1155.     s += KINGOD * AddOwnKingDistanceBonus(sq);
  1156.  
  1157.     s += BRLscan (sq, &mob);
  1158.     s += LMBLTY[mob];
  1159.  
  1160.     fyle = column (sq);
  1161.  
  1162.     if (PC1[fyle] == 0)
  1163.       {
  1164.     s += LHOPN;
  1165. #ifdef DEBUG_EVAL
  1166.     if ( debug_eval )
  1167.       fprintf(debug_eval_file,"adding %d for no own pawn on lance file\n",LHOPN);
  1168. #endif
  1169.       }
  1170.     if (PC2[fyle] == 0)
  1171.       {
  1172.     s += LHOPNX;
  1173. #ifdef DEBUG_EVAL
  1174.     if ( debug_eval )
  1175.       fprintf(debug_eval_file,"adding %d for no opponents pawn on lance file\n",LHOPNX);
  1176. #endif
  1177.       }
  1178.  
  1179.     a2 = atk2[sq];
  1180.     a1 = atk1[sq];
  1181.  
  1182.     if (a2 > 0)
  1183.       {
  1184.       if (a1 == 0 || a2 > ctlL + 1)
  1185.         {
  1186.         s += HUNGP;
  1187. #ifdef DEBUG_EVAL
  1188.         if ( debug_eval )
  1189.                   fprintf(debug_eval_file,"adding %d for hung\n", HUNGP);
  1190. #endif              
  1191.         if (trapped (sq))
  1192.             hung[c1] += 2;
  1193.         hung[c1]++;
  1194.         }
  1195.       else if (a2 >= ctlL || a1 < ctlP)
  1196.         {
  1197.           s += ATAKD;
  1198. #ifdef DEBUG_EVAL     
  1199.           if ( debug_eval )
  1200.                 fprintf(debug_eval_file,"adding %d for atacked piece\n",ATAKD);
  1201. #endif       
  1202.         }                      
  1203.       }
  1204.  
  1205.     if ( !checked_trapped && crow(c1,sq) > 2 )
  1206.       {          
  1207.     if (trapped (sq))
  1208.       {
  1209.         s += LDNGR;
  1210. #ifdef DEBUG_EVAL     
  1211.         if ( debug_eval )
  1212.                 fprintf(debug_eval_file,"adding %d for lance in danger\n",LDNGR);
  1213. #endif                             
  1214.       }
  1215.     else
  1216.       {
  1217.         s += LDNGR / 4;
  1218. #ifdef DEBUG_EVAL     
  1219.         if ( debug_eval )
  1220.                 fprintf(debug_eval_file,"adding %d for lance in danger\n",LDNGR / 4);
  1221. #endif                             
  1222.       }
  1223.       }
  1224.  
  1225.     if ( a1 > 0 ) {
  1226.       s += (a1 & CNT_MASK);
  1227. #ifdef DEBUG_EVAL
  1228.       if ( debug_eval )
  1229.         fprintf(debug_eval_file,"adding %d for protected piece\n",(a1 & CNT_MASK));
  1230. #endif             
  1231.     }                
  1232.  
  1233.     return (s);
  1234. }
  1235.  
  1236. static inline int
  1237. KnightValue (register short int sq, short int side)
  1238. /*
  1239.  * Calculate the positional value for a knight on 'sq'.
  1240.  */
  1241.  
  1242. {
  1243.     register short s;
  1244.     long a1, a2;    
  1245.     short checked_trapped = false;
  1246.  
  1247.     s = Mknight[c1][csquare(c1,sq)];
  1248.  
  1249. #ifdef DEBUG_EVAL
  1250.     if ( debug_eval )
  1251.       fprintf(debug_eval_file,"inital value [%d] for knight on %c%c: %d\n",
  1252.         csquare(c1,sq), cxx[column(sq)], rxx[row(sq)], s);
  1253. #endif
  1254.  
  1255.     s += PROMD * AddPromotionZoneDistanceBonus(sq);
  1256.     s += KINGOD * AddOwnKingDistanceBonus(sq);
  1257.  
  1258.     a2 = atk2[sq];
  1259.     a1 = atk1[sq];
  1260.  
  1261.     if (a2 > 0)
  1262.       {
  1263.       if (a1 == 0 || a2 > ctlN + 1)
  1264.         {
  1265.         s += HUNGP;
  1266. #ifdef DEBUG_EVAL
  1267.         if ( debug_eval )
  1268.                   fprintf(debug_eval_file,"adding %d for hung\n", HUNGP);
  1269. #endif              
  1270.             checked_trapped = true;
  1271.         if (trapped (sq))
  1272.             hung[c1] += 2;
  1273.         hung[c1]++;
  1274.         }
  1275.       else if (a2 >= ctlN || a1 < ctlP)
  1276.         {
  1277.           s += ATAKD;
  1278. #ifdef DEBUG_EVAL     
  1279.           if ( debug_eval )
  1280.                 fprintf(debug_eval_file,"adding %d for atacked piece\n",ATAKD);
  1281. #endif                             
  1282.         }
  1283.       }         
  1284.  
  1285.     if ( !checked_trapped && crow(c1,sq) > 2 )
  1286.       {          
  1287.     if (trapped (sq))
  1288.       {
  1289.         s += NDNGR;
  1290. #ifdef DEBUG_EVAL     
  1291.         if ( debug_eval )
  1292.                 fprintf(debug_eval_file,"adding %d for knight in danger\n",NDNGR);
  1293. #endif                             
  1294.       }
  1295.     else
  1296.       {
  1297.         s += NDNGR / 4;
  1298. #ifdef DEBUG_EVAL     
  1299.         if ( debug_eval )
  1300.                 fprintf(debug_eval_file,"adding %d for knight in danger\n",NDNGR / 4);
  1301. #endif                             
  1302.       }
  1303.       }
  1304.  
  1305.     if ( a1 > 0 ) {
  1306.       s += (a1 & CNT_MASK);
  1307. #ifdef DEBUG_EVAL
  1308.       if ( debug_eval )
  1309.         fprintf(debug_eval_file,"adding %d for protected piece\n",(a1 & CNT_MASK));
  1310. #endif             
  1311.     }
  1312.                 
  1313.     return (s);
  1314. }
  1315.  
  1316. static inline int
  1317. SilverValue (register short int sq, short int side)
  1318. /*
  1319.  * Calculate the positional value for a silver on 'sq'.
  1320.  */
  1321.  
  1322. {
  1323.     register short s;
  1324.     long a1, a2;
  1325.  
  1326.     s = Msilver[c1][csquare(c1,sq)];
  1327.  
  1328.     s += KINGED * AddEnemyKingDistanceBonus(sq);
  1329.     s += KINGOD * AddOwnKingDistanceBonus(sq);
  1330.  
  1331.     a2 = atk2[sq];
  1332.     a1 = atk1[sq];
  1333.     if (a2 > 0)
  1334.       {
  1335.       if (a1 == 0 || a2 > ctlS + 1)
  1336.         {
  1337.         s += HUNGP;
  1338.         if (trapped (sq))
  1339.             hung[c1] += 2;
  1340.         hung[c1]++;
  1341.         }
  1342.       else if (a2 >= ctlS || a1 < ctlP)
  1343.           s += ATAKD;
  1344.       }
  1345.     if ( a1 > 0 )
  1346.       s += (a1 & CNT_MASK);
  1347.  
  1348.     if ( in_opening_stage && GameType[c1] == STATIC_ROOK )
  1349.     if ( csquare(c1,sq) == 12 )
  1350.       {
  1351.         short csq;
  1352.         if ( board[csq = csquare(c1,20)] == bishop && color[csq] == c1 )
  1353.         {
  1354.           s += 2 * OPENWRONG;
  1355.         }
  1356.           }
  1357.  
  1358.     /* proverb: silver before gold */
  1359.     {
  1360.     short u, ptyp;
  1361.     register unsigned char *pdir;
  1362.     ptyp = ptype[c2][pawn];
  1363.     pdir = (*nextdir[ptyp])[sq];
  1364.     u = pdir[sq];
  1365.     if ( u != sq )
  1366.       if ( color[u] == c1 && board[u] == gold )
  1367.             s += SBEFOREG;
  1368.     }
  1369.     return (s);
  1370. }
  1371.  
  1372. static inline int
  1373. GoldValue (register short int sq, short int side)
  1374. /*
  1375.  * Calculate the positional value for a gold on 'sq'.
  1376.  */
  1377.  
  1378. {
  1379.     register short s;
  1380.     long a1, a2;
  1381.  
  1382.     s = Mgold[c1][csquare(c1,sq)];
  1383.  
  1384.     s += KINGED * AddEnemyKingDistanceBonus(sq);
  1385.     s += KINGOD * AddOwnKingDistanceBonus(sq);
  1386.  
  1387.     a2 = atk2[sq];
  1388.     a1 = atk1[sq];
  1389.     if (a2 > 0)
  1390.       {
  1391.       if (a1 == 0 || a2 > ctlG + 1)
  1392.         {
  1393.         s += HUNGP;
  1394.         if (trapped (sq))
  1395.             hung[c1] += 2;
  1396.         hung[c1]++;
  1397.         }
  1398.       else if (a2 >= ctlG || a1 < ctlP)
  1399.           s += ATAKD;
  1400.       }
  1401.     if ( a1 > 0 )
  1402.       s += (a1 & CNT_MASK);
  1403.     return (s);
  1404. }
  1405.  
  1406. static inline int
  1407. BishopValue (register short int sq, short int side)
  1408. /*
  1409.  * Calculate the positional value for a bishop on 'sq'.
  1410.  */
  1411.  
  1412. {
  1413.     register short s;
  1414.     long a2, a1;
  1415.     short mob;
  1416.  
  1417.     s = Mbishop[c1][csquare(c1,sq)];
  1418.  
  1419. #ifdef DEBUG_EVAL
  1420.     if (debug_eval )
  1421.       fprintf(debug_eval_file,"inital value [%d] for bishop on %c%c: %d\n",
  1422.         csquare(c1,sq), cxx[column(sq)], rxx[row(sq)], s);
  1423. #endif
  1424.  
  1425.     s += BRLscan (sq, &mob);
  1426.     s += BMBLTY[mob];
  1427.  
  1428.     a2 = atk2[sq];
  1429.     if (a2 > 0)
  1430.       {
  1431.       a1 = atk1[sq];
  1432.       if (a1 == 0 || a2 > ctlB + 1)
  1433.         {
  1434.         s += HUNGP;
  1435. #ifdef DEBUG_EVAL
  1436.         if ( debug_eval )
  1437.                   fprintf(debug_eval_file,"adding %d for hung\n", HUNGP);
  1438. #endif       
  1439.         if (trapped (sq))
  1440.             hung[c1] += 2;
  1441.         hung[c1]++;
  1442.         }
  1443.       else if (a2 >= ctlB || a1 < ctlP)
  1444.         {
  1445.           s += ATAKD;
  1446. #ifdef DEBUG_EVAL     
  1447.           if ( debug_eval )
  1448.                 fprintf(debug_eval_file,"adding %d for atacked piece\n",ATAKD);
  1449. #endif                                                                         
  1450.         }
  1451.       }                      
  1452.  
  1453.     if ( in_opening_stage )
  1454.       {
  1455.     if ( GameType[c1] == RANGING_ROOK )
  1456.       {
  1457.         /* Bishops diagonal should not be open */
  1458.         if ( !on_csquare(c1,pawn,30) )
  1459.           s += OPENWRONG;
  1460.       }
  1461.     else if ( GameType[c2] == RANGING_ROOK )
  1462.       {
  1463.         /* Bishops diagonal should be open */
  1464.         if ( csquare(c1,sq) == 20 && on_csquare(c1,pawn,30) )
  1465.           s += OPENWRONG;
  1466.       }
  1467.       }     
  1468.   
  1469.     return (s);
  1470. }
  1471.  
  1472. static inline int
  1473. RookValue (register short int sq, short int side)
  1474. /*
  1475.  * Calculate the positional value for a rook on 'sq'.
  1476.  */
  1477.  
  1478. {
  1479.     register short s;
  1480.     register short fyle;
  1481.     long a2, a1;
  1482.     short mob, r, c;
  1483.  
  1484.     s = Mrook[c1][csquare(c1,sq)];
  1485.  
  1486. #ifdef DEBUG_EVAL
  1487.     if (debug_eval )
  1488.       fprintf(debug_eval_file,"inital value [%d] for rook on %c%c: %d\n",
  1489.         csquare(c1,sq), cxx[column(sq)], rxx[row(sq)], s);
  1490. #endif
  1491.  
  1492.     s += BRLscan (sq, &mob);
  1493.     s += RMBLTY[mob];
  1494.  
  1495. #ifdef DEBUG_EVAL
  1496.     if ( debug_eval && (c = RMBLTY[mob]) != 0 ) {
  1497.     s += c;
  1498.     fprintf(debug_eval_file,"adding rook for mobility %d value %d\n",mob,c);
  1499.     }
  1500. #endif
  1501.  
  1502.     fyle = column (sq);
  1503.  
  1504.     if (PC1[fyle] == 0) {
  1505.     s += RHOPN;  /* no own pawn on rook file */
  1506. #ifdef DEBUG_EVAL
  1507.     if ( debug_eval )
  1508.       fprintf(debug_eval_file,"adding %d for no own pawn on rook file\n",RHOPN);
  1509. #endif
  1510.     }
  1511.     if (PC2[fyle] == 0) {
  1512.     s += RHOPNX; /* no enemy pawn on rook file */
  1513. #ifdef DEBUG_EVAL
  1514.     if ( debug_eval )
  1515.       fprintf(debug_eval_file,"adding %d for no enemy pawn on rook file\n",RHOPNX);
  1516. #endif                                               
  1517.     }
  1518.  
  1519.     a2 = atk2[sq];
  1520.     if (a2 > 0)
  1521.       {
  1522.       a1 = atk1[sq];
  1523.       if (a1 == 0 || a2 > ctlR + 1)
  1524.         {
  1525.         s += HUNGP;
  1526. #ifdef DEBUG_EVAL
  1527.         if ( debug_eval )
  1528.                   fprintf(debug_eval_file,"adding %d for hung\n", HUNGP);
  1529. #endif       
  1530.         if (trapped (sq)) {
  1531.             hung[c1] += 2; 
  1532.         }
  1533.         hung[c1]++;
  1534.         }
  1535.       else if (a2 >= ctlR || a1 < ctlP) 
  1536.         {
  1537.           s += ATAKD;
  1538. #ifdef DEBUG_EVAL     
  1539.           if ( debug_eval )
  1540.                 fprintf(debug_eval_file,"adding %d for atacked piece\n",ATAKD);
  1541. #endif                                                                         
  1542.         }
  1543.       }
  1544.  
  1545.     if ( in_opening_stage ) {
  1546. #ifdef DEBUG_EVAL
  1547.       short s0 = s;
  1548. #endif
  1549.       if ( GameType[c1] == STATIC_ROOK )
  1550.         {
  1551.       short c = ccolumn(c1,sq);
  1552.       /* Bonus for rook on 8th file */
  1553.           if ( c == 7 ) {
  1554.         s += R2NDCOL;
  1555.       }
  1556.       /* Bonus for rook on right side, malus for rook on left side */
  1557.       c = 4 - c;
  1558.           if ( c < 0 ) {
  1559.         s += c + c + OPENOK;
  1560.       } else if ( c >= 0 ) {
  1561.         s += c + c + OPENWRONG;
  1562.       }
  1563.         }
  1564.       else if ( GameType[c1] == RANGING_ROOK )
  1565.         {
  1566.       /* Bonus for rook on left side and bishops diagonal closed, malus otherwise. */
  1567.           short c;
  1568.       c = 4 - ccolumn(c1,sq);
  1569.           if ( c >= 0 ) {
  1570.         /* Bishops diagonal should not be open */
  1571.         if ( on_csquare(c1,pawn,30) )
  1572.           s += OPENOK;
  1573.         else
  1574.           s += c + c + OPENWRONG;
  1575.           } else if ( c < 0 ) {
  1576.         s += c + c + OPENWRONG;
  1577.         /* Malus for king not on initial square */
  1578.         if ( !on_csquare(side,king,4) ) {
  1579.         s += 4 * OPENWRONG;      
  1580.         }
  1581.       }
  1582.         }
  1583. #ifdef DEBUG_EVAL
  1584.       if ( debug_eval && (s0 != s) )
  1585.       fprintf(debug_eval_file,"adding %d for opening\n",(s-s0));
  1586. #endif
  1587.     }
  1588.  
  1589.     return (s);
  1590. }
  1591.  
  1592. static inline int
  1593. PPawnValue (register short int sq, short int side)
  1594. /*
  1595.  * Calculate the positional value for a promoted pawn on 'sq'.
  1596.  */
  1597.  
  1598. {
  1599.     register short s;
  1600.     long a2, a1;
  1601.  
  1602.     s = 0;
  1603.  
  1604.     s += (KINGED + 2) * AddEnemyKingDistanceBonus(sq);
  1605.  
  1606.     a2 = atk2[sq];
  1607.     if (a2 > 0)
  1608.       {
  1609.       a1 = atk1[sq];
  1610.       if (a1 == 0 || a2 > ctlPp + 1)
  1611.         {
  1612.         s += HUNGP;
  1613.         if (trapped (sq))
  1614.             hung[c1] += 2;
  1615.         hung[c1]++;
  1616.         }
  1617.       else if (a2 >= ctlPp || a1 < ctlP)
  1618.           s += ATAKD;
  1619.       }
  1620.  
  1621.     return (s);
  1622. }
  1623.  
  1624. static inline int
  1625. PLanceValue (register short int sq, short int side)
  1626. /*
  1627.  * Calculate the positional value for a promoted lance on 'sq'.
  1628.  */
  1629.  
  1630. {
  1631.     register short s;
  1632.     long a2, a1;
  1633.  
  1634.     s = 0;
  1635.  
  1636.     s += (KINGED + 1) * AddEnemyKingDistanceBonus(sq);
  1637.  
  1638.     a2 = atk2[sq];
  1639.     if (a2 > 0)
  1640.       {
  1641.       a1 = atk1[sq];
  1642.       if (a1 == 0 || a2 > ctlLp + 1)
  1643.         {
  1644.         s += HUNGP;
  1645.         if (trapped (sq))
  1646.             hung[c1] += 2;
  1647.         hung[c1]++;
  1648.         }
  1649.       else if (a2 >= ctlLp || a1 < ctlP)
  1650.           s += ATAKD;
  1651.       }
  1652.  
  1653.     return (s);
  1654. }
  1655.  
  1656. static inline int
  1657. PKnightValue (register short int sq, short int side)
  1658. /*
  1659.  * Calculate the positional value for a promoted knight on 'sq'.
  1660.  */
  1661.  
  1662. {
  1663.     register short s;
  1664.     long a2, a1;
  1665.  
  1666.     s = 0;
  1667.  
  1668.     s += (KINGED + 1 ) * AddEnemyKingDistanceBonus(sq);
  1669.  
  1670.     a2 = atk2[sq];
  1671.     if (a2 > 0)
  1672.       {
  1673.       a1 = atk1[sq];
  1674.       if (a1 == 0 || a2 > ctlNp + 1)
  1675.         {
  1676.         s += HUNGP;
  1677.         if (trapped (sq))
  1678.             hung[c1] += 2;
  1679.         hung[c1]++;
  1680.         }
  1681.       else if (a2 >= ctlNp || a1 < ctlP)
  1682.           s += ATAKD;
  1683.       }
  1684.  
  1685.     return (s);
  1686. }
  1687.  
  1688. static inline int
  1689. PSilverValue (register short int sq, short int side)
  1690. /*
  1691.  * Calculate the positional value for a promoted silver on 'sq'.
  1692.  */
  1693.  
  1694. {
  1695.     register short s;
  1696.     long a2, a1;
  1697.  
  1698.     s = 0;
  1699.  
  1700.     s += (KINGED + 1) * AddEnemyKingDistanceBonus(sq);
  1701.  
  1702.     a2 = atk2[sq];
  1703.     if (a2 > 0)
  1704.       {
  1705.       a1 = atk1[sq];
  1706.       if (a1 == 0 || a2 > ctlSp + 1)
  1707.         {
  1708.         s += HUNGP;
  1709.         if (trapped (sq))
  1710.             hung[c1] += 2;
  1711.         hung[c1]++;
  1712.         }
  1713.       else if (a2 >= ctlSp || a1 < ctlP)
  1714.           s += ATAKD;
  1715.       }
  1716.  
  1717.     return (s);
  1718. }
  1719.  
  1720. static inline int
  1721. PBishopValue (register short int sq, short int side)
  1722. /*
  1723.  * Calculate the positional value for a promoted bishop on 'sq'.
  1724.  */
  1725.  
  1726. {
  1727.     register short s;
  1728.     long a2, a1;
  1729.     short mob;
  1730.  
  1731.     s = Mbishop[c1][csquare(c1,sq)];
  1732.     
  1733.     if ( InPromotionZone(c1,sq) )
  1734.       s += KINGED * AddEnemyKingDistanceBonus(sq);
  1735.  
  1736.     s += BRLscan (sq, &mob);
  1737.     s += BMBLTY[mob];
  1738.     a2 = atk2[sq];
  1739.     if (a2 > 0)
  1740.       {
  1741.       a1 = atk1[sq];
  1742.       if (a1 == 0 || a2 > ctlBp + 1)
  1743.         {
  1744.         s += HUNGP;
  1745.         if (trapped (sq))
  1746.             hung[c1] += 2;
  1747.         hung[c1]++;
  1748.         }
  1749.       else if (a2 >= ctlBp || a1 < ctlP)
  1750.           s += ATAKD;
  1751.       }
  1752.  
  1753.     return (s);
  1754. }
  1755.  
  1756. static inline int
  1757. PRookValue (register short int sq, short int side)
  1758. /*
  1759.  * Calculate the positional value for a promoted rook on 'sq'.
  1760.  */
  1761.  
  1762. {
  1763.     register short s;
  1764.     register short fyle;
  1765.     long a2, a1;
  1766.     short mob;
  1767.  
  1768.     s = Mrook[c1][csquare(c1,sq)];
  1769.  
  1770.     if ( InPromotionZone(c1,sq) )
  1771.       s += KINGED * AddEnemyKingDistanceBonus(sq);
  1772.  
  1773.     s += BRLscan (sq, &mob);
  1774.     s += RMBLTY[mob];
  1775.     fyle = column (sq);
  1776.     if (PC1[fyle] == 0)
  1777.     s += RHOPN;
  1778.     if (PC2[fyle] == 0)
  1779.     s += RHOPNX;
  1780.     a2 = atk2[sq];
  1781.     if (a2 > 0)
  1782.       {
  1783.       a1 = atk1[sq];
  1784.       if (a1 == 0 || a2 > ctlRp + 1)
  1785.         {
  1786.         s += HUNGP;
  1787.         if (trapped (sq))
  1788.             hung[c1] += 2;
  1789.         hung[c1]++;
  1790.         }
  1791.       else if (a2 >= ctlRp || a1 < ctlP)
  1792.           s += ATAKD;
  1793.       }
  1794.  
  1795.     return (s);
  1796. }
  1797.  
  1798. static inline int
  1799. KingValue (register short int sq, short int side)
  1800. /*
  1801.  * Calculate the positional value for a king on 'sq'.
  1802.  */
  1803. {
  1804.     register short s;
  1805.     register short fyle;
  1806.     long a2, a1;
  1807.  
  1808.     s = Mking[c1][csquare(c1,sq)];
  1809.  
  1810. #ifdef DEBUG_EVAL
  1811.     if (debug_eval )
  1812.       fprintf(debug_eval_file,"inital value [%d] for king on %c%c: %d\n",
  1813.         csquare(c1,sq), cxx[column(sq)], rxx[row(sq)], s);
  1814. #endif
  1815.  
  1816.     if (KSFTY > 0)
  1817.     s += KingScan (sq);
  1818.  
  1819.     if (Mvboard[kingP[c1]])
  1820.     s += KMOVD;
  1821.  
  1822.     fyle = column (sq);
  1823.     if (PC1[fyle] == 0)
  1824.       {
  1825.     s += KHOPN;
  1826. #ifdef DEBUG_EVAL
  1827.         if (debug_eval )
  1828.           fprintf(debug_eval_file,"adding %d for now own pawn on file\n",
  1829.         KHOPN);
  1830. #endif
  1831.       }
  1832.     if (PC2[fyle] == 0)
  1833.       {
  1834.     s += KHOPNX;
  1835. #ifdef DEBUG_EVAL
  1836.         if (debug_eval )
  1837.           fprintf(debug_eval_file,"adding %d for now opponents pawn on file\n",
  1838.         KHOPNX);
  1839. #endif
  1840.       }
  1841.  
  1842.     a2 = atk2[sq];
  1843.     if (a2 > 0)
  1844.       {
  1845.       a1 = atk1[sq];
  1846.       if (a1 == 0 || a2 > ctlK + 1)
  1847.         {
  1848.         s += HUNGP;
  1849. #ifdef DEBUG_EVAL
  1850.         if ( debug_eval )
  1851.                   fprintf(debug_eval_file,"adding %d for hung\n", HUNGP);
  1852. #endif              
  1853.         ++hung[c1];
  1854.         }
  1855.       else
  1856.         {
  1857.           s += ATAKD;
  1858. #ifdef DEBUG_EVAL
  1859.           if ( debug_eval )
  1860.                 fprintf(debug_eval_file,"adding %d for attacked piece\n", 
  1861.                 ATAKD);
  1862. #endif              
  1863.         }
  1864.       }  
  1865.                         
  1866.     if ( in_opening_stage ) {
  1867.       /* king has moved */
  1868.       if ( GameType[c1] == STATIC_ROOK )
  1869.         {
  1870.       /* Malus for king on right side or fifth file */
  1871.           short c;
  1872.       c = 4 - ccolumn(c1,sq);
  1873.       if ( c < 0 || (c == 0 && sq != kingP[c1]) ) {
  1874.         s += c + c + OPENWRONG;
  1875. #ifdef DEBUG_EVAL
  1876.         if ( debug_eval )
  1877.         fprintf(debug_eval_file,"add %d for king on right side (Static)\n",
  1878.                 c + c + OPENWRONG);
  1879. #endif
  1880.       }
  1881.         }
  1882.       else if ( GameType[c1] == RANGING_ROOK )
  1883.         {
  1884.       /* Malusalus for king on left side or fifth file */
  1885.           short c;
  1886.       c = 4 - ccolumn(c1,sq);
  1887.        if ( c > 0 || (c == 0 && sq != kingP[c1]) ) {
  1888.         s += c + c + OPENWRONG;
  1889. #ifdef DEBUG_EVAL
  1890.         if ( debug_eval )
  1891.         fprintf(debug_eval_file,"add %d for king on left side (Ranging)\n",
  1892.                 c + c + OPENWRONG);
  1893. #endif
  1894.       }
  1895.       /* Malus for king moved before rook switch */
  1896.       if ( sq != kingP[c1] )
  1897.         if ( on_csquare(side,rook,16) ) {
  1898.         s += 4 * OPENWRONG;         
  1899. #ifdef DEBUG_EVAL
  1900.             if ( debug_eval )
  1901.             fprintf(debug_eval_file,"add %d for king moved before rook switch (Ranging)\n",
  1902.                 4 * OPENWRONG);
  1903. #endif
  1904.         }
  1905.       /* Malus for defending general moved before king switch to right side */
  1906.       if ( ccolumn(c1,sq) < 6 )
  1907.         if ( Mvboard[csquare(c1,5)] || Mvboard[csquare(c1,6)] ) {
  1908.         s += 2 * OPENWRONG;         
  1909. #ifdef DEBUG_EVAL
  1910.             if ( debug_eval )
  1911.             fprintf(debug_eval_file,
  1912.             "add %d for defending general moved before king switch (Ranging)\n",
  1913.             2 * OPENWRONG);
  1914. #endif
  1915.         }
  1916.         }                       
  1917.     }
  1918.  
  1919.     return (s);
  1920. }
  1921.  
  1922.  
  1923.  
  1924.  
  1925. #ifdef USE_PATTERN
  1926.           
  1927. short
  1928. ScorePatternDistance (register short int side)
  1929.  
  1930. /*
  1931.  * Score distance to pattern regarding the game type which side plays.
  1932.  */
  1933.  
  1934. { 
  1935.   short ds, s = 0;
  1936.   OpeningPattern *p = NULL;
  1937.  
  1938. #ifdef DEBUG_EVAL
  1939.   if ( debug_eval )
  1940.     fprintf(debug_eval_file,"scoring castle pattern distance for PCASTLE=%d\n",
  1941.         PCASTLE);
  1942. #endif
  1943.  
  1944.   if ( PCASTLE != 0 && ((p = castle_pattern[side]) != NULL) )
  1945.     {
  1946.       ds = board_to_pattern_distance(side,p,PCASTLE,GameCnt);
  1947.       if ( ds != 0) {
  1948.         s += ds;
  1949. #ifdef DEBUG_EVAL
  1950.         if ( debug_eval && ds != 0 )
  1951.           fprintf(debug_eval_file,
  1952.             "add %d for max gain of %s to reachable castle patterns %s\n", 
  1953.             ds, ColorStr[side], p->name); 
  1954. #endif
  1955.       };
  1956.     }
  1957. #ifdef DEBUG_EVAL
  1958.   else if ( debug_eval && p == NULL )
  1959.     fprintf(debug_eval_file,"no castle pattern for %s\n",ColorStr[side]);
  1960. #endif
  1961.  
  1962. #ifdef DEBUG_EVAL
  1963.   if ( debug_eval )
  1964.     fprintf(debug_eval_file,"scoring attack pattern distance for PATTACK=%d\n",
  1965.         PATTACK);
  1966. #endif
  1967.  
  1968.   if ( PATTACK != 0 && ((p = attack_pattern[side]) != NULL) )
  1969.     {            
  1970.       ds = board_to_pattern_distance(side,p,PATTACK,GameCnt);
  1971.       if ( ds != 0 ) {
  1972.         s += ds;
  1973. #ifdef DEBUG_EVAL
  1974.         if ( debug_eval && ds != 0 )
  1975.           fprintf(debug_eval_file,
  1976.              "add %d for max gain of %s to reachable attack patterns %s\n",
  1977.              ds, ColorStr[side], p->name); 
  1978. #endif
  1979.       }
  1980.     }
  1981. #ifdef DEBUG_EVAL
  1982.   else if ( debug_eval && p == NULL )
  1983.     fprintf(debug_eval_file,"no attack pattern for %s\n",ColorStr[side]);
  1984. #endif
  1985.  
  1986.   return(s);
  1987. }
  1988.  
  1989.  
  1990. static
  1991. void
  1992. UpdatePatterns (short int side, short int GameCnt)
  1993.  
  1994. /*
  1995.  * Determine castle and attack pattern which should be reached next.
  1996.  * Only patterns are considered, which have not been reached yet.
  1997.  */
  1998.  
  1999. {
  2000.   char s[12];
  2001.   short xside = side ^ 1;
  2002.   OpeningPattern *p;
  2003. #ifdef DEBUG_EVAL
  2004.   short i;
  2005.   PatternSequence *sequence;
  2006. #endif
  2007.  
  2008.   strcpy(s,"CASTLE_?_?");
  2009.   s[7] = GameType[side];
  2010.   s[9] = GameType[xside];
  2011.   castle_pattern[side] = p = locate_opening_pattern(side,s,GameCnt);
  2012.  
  2013. #ifdef DEBUG_EVAL
  2014.   if ( debug_eval )
  2015.     if (p != NULL )
  2016.       {
  2017.         fprintf(debug_eval_file,"castle pattern of %s is %s\n",
  2018.                  ColorStr[side], p->name);
  2019.         fprintf(debug_eval_file,"reachable patterns: ");
  2020.         for (i=0,sequence=p->sequence; i<p->n; i++,sequence=sequence->next_pattern)
  2021.       if ( sequence->distance[side] != CANNOT_REACH )
  2022.         fprintf(debug_eval_file,"%d ",i);
  2023.         fprintf(debug_eval_file,"\n");
  2024.       }
  2025.     else
  2026.       {
  2027.         fprintf(debug_eval_file,"no castle pattern %s for %s\n",
  2028.                  s, ColorStr[side]);
  2029.       }
  2030. #endif
  2031.  
  2032.   strcpy(s,"ATTACK_?_?");
  2033.   s[7] = GameType[side];
  2034.   s[9] = GameType[xside];
  2035.   attack_pattern[side] = p = locate_opening_pattern(side,s,GameCnt);
  2036.   
  2037. #ifdef DEBUG_EVAL
  2038.   if ( debug_eval )
  2039.     if ( p != NULL )
  2040.       {
  2041.         fprintf(debug_eval_file,"attak pattern of %s is %s\n",
  2042.                   ColorStr[side], p->name);
  2043.         fprintf(debug_eval_file,"reachable patterns: ");
  2044.         for (i=0,sequence=p->sequence; i<p->n; i++,sequence=sequence->next_pattern)
  2045.       if ( sequence->distance[side] != CANNOT_REACH )
  2046.         fprintf(debug_eval_file,"%d ",i);
  2047.         fprintf(debug_eval_file,"\n");
  2048.       }
  2049.     else
  2050.       {
  2051.         fprintf(debug_eval_file,"no attak pattern %s for %s\n",
  2052.                   s, ColorStr[side]);
  2053.       }
  2054. #endif
  2055.  
  2056.  
  2057. }
  2058.  
  2059.  
  2060. #endif
  2061.  
  2062.  
  2063. short int
  2064. ScorePosition (register short int side)
  2065.  
  2066. /*
  2067.  * Perform normal static evaluation of board position. A score is generated
  2068.  * for each piece and these are summed to get a score for each side.
  2069.  */
  2070.  
  2071. {
  2072.     register short int score;
  2073.     register short sq, i, xside;
  2074.     short int s;
  2075.     short int escore;
  2076. #ifdef DEBUG_EVAL
  2077.     short int d;
  2078. #endif
  2079.  
  2080.     UpdateWeights ();
  2081.  
  2082. #ifdef DEBUG_EVAL
  2083.     if ( debug_eval )
  2084.       fprintf (debug_eval_file, "side = %d, stage = %d, in_opening = %d\n",
  2085.     side, stage, in_opening_stage );
  2086. #endif
  2087.  
  2088.     xside = side ^ 1;
  2089.     hung[black] = hung[white] = pscore[black] = pscore[white] = 0;
  2090.  
  2091. #ifdef CACHE
  2092. #ifdef DEBUG_EVAL
  2093.     if (debug_eval || !ProbeEETable (side, &s))
  2094. #else
  2095.     if (!ProbeEETable (side, &s))
  2096. #endif
  2097.     { 
  2098. #endif
  2099.       for (c1 = black; c1 <= white; c1++)
  2100.         {
  2101.         c2 = c1 ^ 1;
  2102.         /* atk1 is array of atacks on squares by my side */
  2103.         atk1 = atak[c1];
  2104.         /* atk2 is array of atacks on squares by other side */
  2105.         atk2 = atak[c2];
  2106.         /* same for PC1 and PC2 */
  2107.         PC1 = PawnCnt[c1];
  2108.         PC2 = PawnCnt[c2];
  2109.         for (i = PieceCnt[c1]; i >= 0; i--)
  2110.           {
  2111.               sq = PieceList[c1][i];
  2112.               switch (board[sq])
  2113.             {
  2114.             case pawn:
  2115.                 s = PawnValue (sq, side);
  2116.                 break;
  2117.             case knight:
  2118.                 s = KnightValue (sq, side);
  2119.                 break;
  2120.             case bishop:
  2121.                 s = BishopValue (sq, side);
  2122.                 break;
  2123.             case rook:
  2124.                 s = RookValue (sq, side);
  2125.                 break;
  2126.             case lance:
  2127.                 s = LanceValue (sq, side);
  2128.                 break;
  2129.             case silver:
  2130.                 s = SilverValue (sq, side);
  2131.                 break;
  2132.             case gold:
  2133.                 s = GoldValue (sq, side);
  2134.                 break;
  2135.             case ppawn:
  2136.                 s = PPawnValue (sq, side);
  2137.                 break;
  2138.             case plance:
  2139.                 s = PLanceValue (sq, side);
  2140.                 break;
  2141.             case pknight:
  2142.                 s = PKnightValue (sq, side);
  2143.                 break;
  2144.             case psilver:
  2145.                 s = PSilverValue (sq, side);
  2146.                 break;
  2147.             case pbishop:
  2148.                 s = PBishopValue (sq, side);
  2149.                 break;
  2150.             case prook:
  2151.                 s = PRookValue (sq, side);
  2152.                 break;
  2153.             case king:
  2154.                 s = KingValue (sq, side);
  2155.                 break;
  2156.             default:
  2157.                 s = 0;
  2158.                 break;
  2159.             }
  2160.               pscore[c1] += s;
  2161.               svalue[sq] = s;
  2162.           }
  2163.         }
  2164. #ifdef DEBUG_EVAL 
  2165.           if ( debug_eval ) {                      
  2166.         fprintf(debug_eval_file,"pscore[black] = %d, pscore[white] = %d\n",
  2167.         pscore[black], pscore[white]);
  2168.         debug_svalue(debug_eval_file);
  2169.       }
  2170. #endif
  2171.       if (hung[side] > 1) {
  2172. #ifdef DEBUG_EVAL
  2173.         if ( debug_eval ) {
  2174.           fprintf(debug_eval_file,"adding %d to pscore for %d hung %d pieces.\n",
  2175.           HUNGX, hung[side], side);
  2176.         }
  2177. #endif
  2178.         pscore[side] += HUNGX;
  2179.       }
  2180.       if (hung[xside] > 1) {
  2181. #ifdef DEBUG_EVAL
  2182.         if ( debug_eval ) {
  2183.           fprintf(debug_eval_file,"adding %d to pscore for %d hung %d pieces.\n",
  2184.         HUNGX, hung[xside], xside);
  2185.         }
  2186. #endif
  2187.         pscore[xside] += HUNGX;
  2188.       }
  2189.                      
  2190.           for (c1=black,c2=white; c1<=white; c1++,c2--) 
  2191.         {
  2192. #ifdef DEBUG_EVAL
  2193.           short ps0 = pscore[c1];
  2194. #endif
  2195.           /* Score fifth rank */
  2196.               for ( sq = 36; sq <= 44; sq++ ) 
  2197.             if ( color[sq] == c1 || atak[c1][sq] != 0 )
  2198.           pscore[c1]++;
  2199.  
  2200. #ifdef DEBUG_EVAL
  2201.           if ( debug_eval && ps0 != pscore[c1] )
  2202.         fprintf(debug_eval_file,"adding %d for %s's control of 5th rank\n",
  2203.               pscore[c1]-ps0, ColorStr[c1]);
  2204.           ps0 = pscore[c1];
  2205. #endif
  2206.  
  2207.           /* Score holes */
  2208.               for ( sq = ((c1==black)?0:54); sq<=((c1==black)?26:80); sq++ )
  2209.             if ( board[sq] == no_piece && atak[c1][sq] == 0 )
  2210.           pscore[c1]--;
  2211.  
  2212. #ifdef DEBUG_EVAL
  2213.           if ( debug_eval && ps0 != pscore[c1] )
  2214.         fprintf(debug_eval_file,"adding %d for holes in %s's camp\n",
  2215.               pscore[c1]-ps0, ColorStr[c1]);
  2216. #endif
  2217.  
  2218.           /* Scoring depending whether in opening stage or not */ 
  2219.  
  2220.           if ( in_opening_stage )
  2221.         {
  2222.               /* do not exchange bishops in ranging rook openings */
  2223.           if ( GameType[c1] == RANGING_ROOK )
  2224.           if ( Captured[c2][bishop] ) {
  2225.             pscore[c1] += BXCHG;
  2226. #ifdef DEBUG_EVAL   
  2227.             if ( debug_eval )
  2228.               fprintf(debug_eval_file,"adding %d for %s's bishop catched by opponent\n",
  2229.                            BXCHG, ColorStr[c1]);
  2230. #endif
  2231.           }
  2232.         }
  2233.           else
  2234.         {
  2235.           short d1 = HasPiece[c1][silver] + HasPiece[c1][gold];
  2236.           short d2 = Captured[c1][silver] + Captured[c1][gold];
  2237.               pscore[c1] += (d1*2 + d2*3) * stage / 2;
  2238. #ifdef DEBUG_EVAL 
  2239.           if ( debug_eval )
  2240.              fprintf(debug_eval_file,"adding %d for more valuable %s generals\n",
  2241.                              (d1*2 + d2*3) * stage / 2, ColorStr[c1]);
  2242. #endif
  2243.             }
  2244.         }
  2245.         
  2246.  
  2247. #ifdef USE_PATTERN
  2248.       /* Score pattern */
  2249.                    
  2250.       if ( in_opening_stage ) {    
  2251.         pscore[side]  += ScorePatternDistance (side);         
  2252.         pscore[xside] += ScorePatternDistance (xside);         
  2253.       }
  2254. #endif
  2255.  
  2256.           score = mtl[side] - mtl[xside] + pscore[side] - pscore[xside] + 10;
  2257.           if (dither)
  2258.               {
  2259.           if (flag.hash)
  2260.             gsrand (starttime + (unsigned int) hashbd);
  2261.           score += urand () % dither;
  2262.             }
  2263.  
  2264. #ifdef CACHE
  2265.       PutInEETable(side,score);
  2266. #endif
  2267. #ifdef DEBUG_EVAL
  2268.       if ( debug_eval )
  2269.         fprintf (debug_eval_file, "score = %d\n", score);
  2270. #endif
  2271.       return(score);
  2272. #ifdef CACHE
  2273.     }
  2274. #ifdef DEBUG_EVAL
  2275.       else
  2276.     { 
  2277.       if ( debug_eval )
  2278.         fprintf (debug_eval_file, "Score cached!\n" );
  2279.     }
  2280. #endif
  2281.                           
  2282. #ifdef DEBUG_EVAL
  2283.     if ( debug_eval )
  2284.       fprintf (debug_eval_file, "s = %d\n", s);
  2285. #endif
  2286.     return (s);
  2287. #endif
  2288. }
  2289.  
  2290.  
  2291.  
  2292.  
  2293. #define SS 1
  2294. #define RS 2
  2295. #define SR 3
  2296. #define RR 4
  2297.  
  2298.  
  2299. static
  2300.     short int *PawnAdvance[2],*LanceAdvance[2],*KnightAdvance[2],
  2301.     *SilverAdvance[2],*GoldAdvance[2],*BishopAdvance[2],*RookAdvance[2],
  2302.     *KingAdvance[2];
  2303.     
  2304.  
  2305. inline
  2306. static
  2307. void
  2308. SetOpeningStrategy(short c, short s)
  2309. { 
  2310. #ifdef DEBUG_EVAL
  2311.   if ( debug_eval )
  2312.     fprintf(debug_eval_file,"strategy for %s is ",ColorStr[c]);
  2313. #endif                  
  2314.   if ( s == RS ) {
  2315.     PawnAdvance[c] = PawnAdvanceRS;
  2316.     LanceAdvance[c] = LanceAdvanceRS;
  2317.     KnightAdvance[c] = KnightAdvanceRS;
  2318.     SilverAdvance[c] = SilverAdvanceRS;
  2319.     GoldAdvance[c] = GoldAdvanceRS;
  2320.     BishopAdvance[c] = BishopAdvanceRS;
  2321.     RookAdvance[c] = RookAdvanceRS;
  2322.     KingAdvance[c] = KingAdvanceRS;
  2323. #ifdef DEBUG_EVAL
  2324.     if ( debug_eval )
  2325.       fprintf(debug_eval_file,"Ranging vs. Static\n");
  2326. #endif                  
  2327.   } else if ( s == SR ) {
  2328.     PawnAdvance[c] = PawnAdvanceSR;
  2329.     LanceAdvance[c] = LanceAdvanceSR;
  2330.     KnightAdvance[c] = KnightAdvanceSR;
  2331.     SilverAdvance[c] = SilverAdvanceSR;
  2332.     GoldAdvance[c] = GoldAdvanceSR;
  2333.     BishopAdvance[c] = BishopAdvanceSR;
  2334.     RookAdvance[c] = RookAdvanceSR;
  2335.     KingAdvance[c] = KingAdvanceSR;
  2336. #ifdef DEBUG_EVAL
  2337.     if ( debug_eval )
  2338.       fprintf(debug_eval_file,"Static vs. Ranging\n");
  2339. #endif                  
  2340.   } else if ( s == RR ) {
  2341.     PawnAdvance[c] = PawnAdvanceRR;
  2342.     LanceAdvance[c] = LanceAdvanceRR;
  2343.     KnightAdvance[c] = KnightAdvanceRR;
  2344.     SilverAdvance[c] = SilverAdvanceRR;
  2345.     GoldAdvance[c] = GoldAdvanceRR;
  2346.     BishopAdvance[c] = BishopAdvanceRR;
  2347.     RookAdvance[c] = RookAdvanceRR;
  2348.     KingAdvance[c] = KingAdvanceRR;
  2349. #ifdef DEBUG_EVAL
  2350.     if ( debug_eval )
  2351.       fprintf(debug_eval_file,"Ranging vs. Ranging\n");
  2352. #endif                  
  2353.   } else {
  2354.     PawnAdvance[c] = PawnAdvanceSS;
  2355.     LanceAdvance[c] = LanceAdvanceSS;
  2356.     KnightAdvance[c] = KnightAdvanceSS;
  2357.     SilverAdvance[c] = SilverAdvanceSS;
  2358.     GoldAdvance[c] = GoldAdvanceSS;
  2359.     BishopAdvance[c] = BishopAdvanceSS;
  2360.     RookAdvance[c] = RookAdvanceSS;
  2361.     KingAdvance[c] = KingAdvanceSS;
  2362. #ifdef DEBUG_EVAL
  2363.     if ( debug_eval )
  2364.       fprintf(debug_eval_file,"Static vs. Static\n");
  2365. #endif                  
  2366.   }
  2367. }
  2368.  
  2369.  
  2370.  
  2371.  
  2372. #define AssignAdvance(b,w)\
  2373. {\
  2374.   SetOpeningStrategy(black,b);\
  2375.   SetOpeningStrategy(white,w);\
  2376. }                
  2377.  
  2378.  
  2379.  
  2380. static inline void
  2381. CopyBoard (short *a, short *b, short n, short d)
  2382. {                          
  2383.     register short *sqa, *sqb, i;
  2384.  
  2385.     if ( n == d )
  2386.       bcopy(a,b,NO_SQUARES*sizeof(short));
  2387.     else 
  2388.       for (sqa = a,sqb = b,i=0; i<NO_SQUARES; sqa++,sqb++,i++)
  2389.     if ( n == 1 )
  2390.         *sqb = (*sqa) / d;
  2391.         else
  2392.       if ( d == 1 )
  2393.         *sqb = n * (*sqa);
  2394.       else
  2395.         *sqb = (n * (*sqa)) / d;
  2396. }
  2397.  
  2398.  
  2399.  
  2400. static inline void
  2401. GuessGameType (void)
  2402. {
  2403.   /*
  2404.    * Try to determine the game type of "side".
  2405.    */
  2406.  
  2407.    short side, sq, StaticRook[2] = {0,0}, RangingRook[2] = {0,0};
  2408.   
  2409.    for ( side=black; side<=white; side++ ) {         
  2410.  
  2411.      /* static rook conditions */
  2412.  
  2413.      if ( on_column(side,rook,7) )
  2414.        StaticRook[side] += 3;
  2415.      if ( on_csquare(side,pawn,34) )
  2416.        StaticRook[side] += 6;
  2417.      else if ( on_csquare(side,pawn,43) )
  2418.        StaticRook[side] += 8;
  2419.      else if ( !on_column(side,pawn,7) )
  2420.        StaticRook[side] += 5;
  2421.      if ( empty_square(side,5) || empty_square(side,6) )
  2422.        StaticRook[side] += 2;
  2423.      if ( on_left_side(side,king) )
  2424.        StaticRook[side] += 2;
  2425.  
  2426.      /* ranging rook conditions */
  2427.  
  2428.      if ( on_left_side(side,rook) )
  2429.        RangingRook[side] += 5; 
  2430.      else if ( !on_column(side,rook,7) )
  2431.        RangingRook[side] += 3;
  2432.      if ( on_csquare(side,pawn,25) )
  2433.        RangingRook[side] += 1;
  2434.      if ( on_csquare(side,pawn,30) )
  2435.        RangingRook[side] += 1;
  2436.      else
  2437.        RangingRook[side] -= 2;
  2438.      if ( on_right_side(side,king) )
  2439.        RangingRook[side] += 2;
  2440.      if ( on_csquare(side,bishop,20) )
  2441.        if ( on_csquare(side,silver,11) || on_csquare(side,silver,12) ||
  2442.         on_csquare(side,silver,21) )
  2443.        RangingRook[side] += 3;
  2444.      
  2445.      if ( StaticRook[side] > 5 || RangingRook[side] > 5 )
  2446.          GameType[side] = (StaticRook[side] > RangingRook[side]) 
  2447.                   ? STATIC_ROOK : RANGING_ROOK;
  2448.      else
  2449.          GameType[side] = UNKNOWN;
  2450.  
  2451.    }
  2452.         
  2453. #ifdef DEBUG_EVAL
  2454. #define StringOfGameType(side)\
  2455.   (GameType[side] == STATIC_ROOK ? "Static Rook" :\
  2456.   (GameType[side] == RANGING_ROOK ? "Ranging Rook" : "UNKNOWN"))
  2457.  
  2458.    if ( debug_eval )
  2459.       fprintf(debug_eval_file,"guessing game type: %s vs. %s\n",
  2460.     StringOfGameType(black), StringOfGameType(white));
  2461. #endif          
  2462.  
  2463.    if ( GameType[black] == UNKNOWN || GameType[white] == UNKNOWN )
  2464.       {
  2465.          for (side = black; side <= white; side++)
  2466.            if ( side == computer && GameType[side] == UNKNOWN ) {
  2467.             /*
  2468.               * Game type is UNKNOWN.
  2469.            * Make a decision what type of game to play.
  2470.            * To make computer games more interesting, make a
  2471.            * random decision.
  2472.            */
  2473.                if ( !on_csquare(side,pawn,25) ) {
  2474.              /* Play static rook if rook pawn has been pushed! */
  2475.              GameType[side] = STATIC_ROOK;
  2476.            } else {
  2477.              unsigned int random = urand () % 100;
  2478.              short d = StaticRook[side] - RangingRook[side];
  2479.              switch ( GameType[side ^ 1] ) {
  2480.                case STATIC_ROOK:
  2481.               if ( random < 35 + d ) GameType[side] = STATIC_ROOK;
  2482.              else if ( random < 95 ) GameType[side] = RANGING_ROOK;
  2483.              break;
  2484.                case RANGING_ROOK:
  2485.              if ( random < 75 + d) GameType[side] = STATIC_ROOK;
  2486.              else if ( random < 95 ) GameType[side] = RANGING_ROOK;
  2487.              break;
  2488.                default:          
  2489.              if ( random < 33 + d) GameType[side] = STATIC_ROOK;
  2490.              else if ( random < 66 ) GameType[side] = RANGING_ROOK;
  2491.              }       
  2492.            }
  2493. #ifdef DEBUG_EVAL
  2494.          if ( debug_eval )
  2495.                fprintf(debug_eval_file,"decide game type: %s vs. %s\n",
  2496.          StringOfGameType(black), StringOfGameType(white));
  2497. #endif
  2498.        }
  2499.       }
  2500.  
  2501. }
  2502.  
  2503.  
  2504. #ifdef DEBUG_EVAL
  2505.  
  2506. #define StringOfGameType(side)\
  2507.   (GameType[side] == STATIC_ROOK ? "Static Rook" :\
  2508.   (GameType[side] == RANGING_ROOK ? "Ranging Rook" : "UNKNOWN"))
  2509.  
  2510. #endif
  2511.  
  2512.  
  2513.  
  2514. void
  2515. ExaminePosition (void)
  2516.  
  2517. /*
  2518.  * This is done one time before the search is started. Set up arrays Mwpawn,
  2519.  * Mbpawn, Mknight, Mbishop, Mking which are used in the SqValue() function
  2520.  * to determine the positional value of each piece.
  2521.  */
  2522.  
  2523. {
  2524.     register short i, sq, msq;
  2525.     register short fyle;
  2526.     short wpadv, bpadv, z, side, pp, j, k, val, Pd, rank;
  2527.  
  2528.     ataks (black, atak[black]);
  2529.     ataks (white, atak[white]);
  2530.                       
  2531. #ifdef DEBUG_EVAL
  2532.     if ( debug_eval ) {
  2533.       debug_position (debug_eval_file);
  2534.       /* debug_ataks (debug_eval_file); */
  2535.     }
  2536. #endif
  2537.  
  2538.     UpdateWeights ();  
  2539.  
  2540. #ifdef NOMEMSET
  2541.     { short c, p;
  2542.       for ( c = black; c <= white; c++ )
  2543.         for ( p = pawn; p <= king; p++ )
  2544.           HasPiece[c][p] = 0;
  2545.     }
  2546. #else
  2547.     memset ((char *)HasPiece, 0,(unsigned long)sizeof(HasPiece));
  2548. #endif                             
  2549.  
  2550.     for (side = black; side <= white; side++)
  2551.     for (i = PieceCnt[side]; i >= 0; i--)
  2552.         ++HasPiece[side][board[PieceList[side][i]]];
  2553.  
  2554.     GuessGameType();
  2555.  
  2556. #ifdef USE_PATTERN
  2557.     if ( in_opening_stage ) {
  2558.       for (side = black; side <= white; side++)
  2559.         UpdatePatterns (side, GameCnt);
  2560.     }
  2561. #endif
  2562.  
  2563.     if ( GameType[black] == STATIC_ROOK) {
  2564.       if ( GameType[white] == STATIC_ROOK ) {
  2565.         /* STATIC vs. STATIC */
  2566.         AssignAdvance(SS,SS);
  2567.       } else if ( GameType[white] == RANGING_ROOK ) {
  2568.         /* STATIC vs. RANGING */
  2569.         AssignAdvance(SR,RS);
  2570.       } else {
  2571.         /* STATIC vs. ??? */
  2572.         AssignAdvance(SS,SS);
  2573.       }
  2574.     } else if ( GameType[black] == RANGING_ROOK ) {
  2575.       if ( GameType[white] == STATIC_ROOK ) {
  2576.         /* RANGING vs. STATIC */
  2577.         AssignAdvance(RS,SR);
  2578.       } else if ( GameType[white] == RANGING_ROOK ) {
  2579.         /* RANGING vs. RANGING */
  2580.         AssignAdvance(RR,RR);
  2581.       } else {
  2582.         /* RANGING vs. ???? */
  2583.         AssignAdvance(RS,SR);
  2584.       }
  2585.     } else {
  2586.       if ( GameType[white] == STATIC_ROOK ) {
  2587.         /* ???? vs. STATIC */
  2588.         AssignAdvance(SS,SS);
  2589.       } else if ( GameType[white] == RANGING_ROOK ) {
  2590.         /* ???? vs. RANGING */
  2591.         AssignAdvance(SR,RS);
  2592.       } else {
  2593.         /* ???? vs. ???? */
  2594.         AssignAdvance(SS,SS);
  2595.       }
  2596.     }
  2597.  
  2598.     /* Weighted advance tables. Can be updated. */
  2599.  
  2600.     CopyBoard (PawnAdvance[black], Mpawn[black], PADVNCM, 10);
  2601.     CopyBoard (PawnAdvance[white], Mpawn[white], PADVNCM, 10);
  2602.     CopyBoard (SilverAdvance[black], Msilver[black], SADVNCM, 10);
  2603.     CopyBoard (SilverAdvance[white], Msilver[white], SADVNCM, 10);
  2604.     CopyBoard (GoldAdvance[black], Mgold[black], GADVNCM, 10);
  2605.     CopyBoard (GoldAdvance[white], Mgold[white], GADVNCM, 10);
  2606.     CopyBoard (KingAdvance[black], Mking[black], KADVNCM, 1);
  2607.     CopyBoard (KingAdvance[white], Mking[white], KADVNCM, 1);
  2608.                       
  2609.     /* Tables without weighted advances. Must not be updated! */
  2610.  
  2611.     for ( side = black; side <= white; side++ ) {
  2612.     Mlance[side]  = LanceAdvance[side];
  2613.     Mknight[side] = KnightAdvance[side];
  2614.     Mbishop[side] = BishopAdvance[side];
  2615.     Mrook[side]   = RookAdvance[side];
  2616.     }
  2617.  
  2618. #ifdef DEBUG_EVAL
  2619.     if ( debug_eval ) {
  2620.       fprintf(debug_eval_file,"relative pawn table weigth: %d\n",PADVNCM);
  2621.       fprintf(debug_eval_file,"relative silver table weigth: %d\n",SADVNCM);
  2622.       fprintf(debug_eval_file,"relative gold table weigth: %d\n",GADVNCM);
  2623.       fprintf(debug_eval_file,"relative king table weigth: %d\n",KADVNCM);
  2624.     }
  2625. #endif
  2626.  
  2627.     /* Build up weighted enemy-king distance tables. */                                
  2628.                            
  2629.     if ( KATAK == 0 ) 
  2630. #if defined(NOMEMSET) || defined(MSDOS)
  2631.       for (sq = 0; sq < NO_SQUARES; sq++) 
  2632.     Kfield[black][sq] = Kfield[white][sq] = 0;
  2633. #else 
  2634.       memset ((char *) Kfield, 0, (unsigned long)sizeof (Kfield));
  2635. #endif /* NOMEMSET */
  2636.     else
  2637.       for (sq = 0; sq < NO_SQUARES; sq++)
  2638.         {
  2639.       Kfield[black][sq] = (distance(sq,WhiteKing)==1) ? KATAK : 0;
  2640.       Kfield[white][sq] = (distance(sq,BlackKing)==1) ? KATAK : 0;
  2641.         }
  2642.     
  2643. #ifdef DEBUG_EVAL
  2644.     if ( debug_eval )
  2645.       for (side=black; side<=white; side++)
  2646.         {
  2647.       fprintf(debug_eval_file,"%s's pawn table\n\n",ColorStr[side]);
  2648.       debug_table(debug_eval_file,Mpawn[side]);
  2649.       fprintf(debug_eval_file,"%s's silver table\n\n",ColorStr[side]);
  2650.       debug_table(debug_eval_file,Msilver[side]);
  2651.       fprintf(debug_eval_file,"%s's gold table\n\n",ColorStr[side]);
  2652.       debug_table(debug_eval_file,Mgold[side]);
  2653.       fprintf(debug_eval_file,"%s's king table\n\n",ColorStr[side]);
  2654.       debug_table(debug_eval_file,Mking[side]);
  2655.       fprintf(debug_eval_file,"%s's distance to enemy king table\n\n",ColorStr[side]);
  2656.       debug_table(debug_eval_file,Kfield[side]);
  2657.         }
  2658. #endif
  2659.  
  2660. }
  2661.  
  2662.  
  2663. void
  2664. UpdateWeights (void)
  2665.  
  2666. /*
  2667.  * If material balance has changed, determine the values for the positional
  2668.  * evaluation terms.
  2669.  */
  2670.  
  2671. {
  2672.     register short s1, dio, io, os;
  2673.  
  2674.     emtl[black] = mtl[black] - pmtl[black] - valueK;
  2675.     emtl[white] = mtl[white] - pmtl[white] - valueK;
  2676.     tmtl = emtl[black] + emtl[white];
  2677.     
  2678.     behind_in_material[black] = ((mtl[white] - mtl[black]) > valueB);
  2679.     behind_in_material[white] = ((mtl[black] - mtl[white]) > valueB);
  2680.     
  2681.     /* GameCnt = number of half moves */
  2682.     
  2683.     if (GameCnt < 21)
  2684.       s1 = 0;            /*  0 <= GameCnt <= 20: stage = 0 */
  2685.     else if (GameCnt < 41)
  2686.       s1 = 1 + (GameCnt-20)/3;    /* 21 <= GameCnt <= 40: stage = 1..7 */
  2687.     else if (GameCnt < 61)
  2688.       s1 = 8 + (GameCnt-40)/5;    /* 41 <= GameCnt <= 60: stage = 8..11 */
  2689.     else
  2690.       s1 = 12 + (GameCnt-60)/7;
  2691.     
  2692.     if (s1 != stage)
  2693.       {                   
  2694.       stage = stage2 = s1;
  2695.  
  2696.           os = (GameType[black] == STATIC_ROOK && GameType[white] == STATIC_ROOK) ? 10 : 8;
  2697.       dio = (in_opening_stage = io = (s1 < os)) ? (os - s1) : 0;
  2698.  
  2699.       PADVNCM = io?12+s1:1;    /* advanced pawn multiplier */
  2700.           PMBLTY = 5;        /* pawn mobility */
  2701.       PSTRONG = 3;         /* pawn supported by rook/lance */
  2702.       BDCLOSED = -(dio*2);    /* bishops diagonal closed by pawn */
  2703.       P2STRONG = 20;    /* attacking pawn on 2nd col is strong */
  2704.  
  2705.       LHOPN = -4;        /* no own pawn on lance file ahead */
  2706.       LHOPNX = 4;        /* no enemy pawn on lance file ahead */
  2707.       LPROTECT = 6;        /* protect own piece with lance */
  2708.       LDNGR = -4;        /* lance is in danger */
  2709.       LXRAY = 8;        /* lance Xray attack on piece */
  2710.  
  2711.       NDNGR = -4;        /* knight is in danger */
  2712.       KNIGHTPOST = 2;    /* knight near enemy pieces */
  2713.       KNIGHTSTRONG = 2;    /* occupies pawn hole */
  2714.  
  2715.       SADVNCM = io?15+s1:1;    /* advanced silver multiplier */
  2716.           SBEFOREG = 2;      /* proverb: silver before gold */
  2717.  
  2718.       GADVNCM = io?14+s1:1;    /* advanced gold multiplier */
  2719.  
  2720.       BISHOPSTRONG = 4;    /* occupies pawn hole */
  2721.       BHCLSD = -3;        /* first or second piece in a bishop's direction is an own pawn */
  2722.       BHCLSDX = -2;        /* first or second piece in a bishop's direction is an opponents pawn */                     
  2723.       BRXRAY = 10;        /* bishop or rook Xray attack on piece */
  2724.       BXCHG = -10;        /* bishop exchange in ranging rook opening */
  2725.  
  2726.       RHOPN = 10;        /* no own pawn on rook file ahead */
  2727.       RHOPNX = 8;           /* no enemy pawn on rook file ahead */
  2728.           R2NDCOL = dio*2;    /* rook is on 2nd column */
  2729.  
  2730.       PINVAL = 15;        /* Pin */
  2731.  
  2732.       KADVNCM = io?1+s1:0;    /* advanced king multiplier */
  2733.       KHOPN = -8;        /* no own pawn in kings file */
  2734.       KHOPNX = KHOPN * 2;   /* no opponents pawn in kings file */
  2735.       KCASTLD = 20;         /* king protected by castle */
  2736.       KMOVD = 4;        /* proverb: a sitting king is a sitting duck */
  2737.       KATAK = io ? 1 : 8;    /* B,R,L attacks near enemy king */
  2738.       KSFTY = 4;            /* king safety */
  2739.  
  2740.           OPENOK = dio*2;    /* corresponding to opening pattern */
  2741.           OPENWRONG = -dio*3;    /* not correpsonding */
  2742.  
  2743.           KINGOD = 2+s1/4;    /* distance to own king multiplier */
  2744.           KINGED = 3+s1/4;    /* distance to enemy king multiplier */
  2745.           PROMD = 2+s1/4;    /* distance to promotion zone multiplier */
  2746.  
  2747.       ATAKD = -15;        /* defender > attacker */
  2748.       HUNGP = -14;        /* each hung piece */
  2749.       HUNGX = -18;        /* extra for >1 hung piece */
  2750.  
  2751. #ifdef USE_PATTERN
  2752.       PATTACK = dio;     /* attack pattern distance multiplier */
  2753.       PCASTLE = dio;     /* castle pattern distance multiplier */
  2754. #endif
  2755.  
  2756.       }
  2757. } 
  2758.  
  2759.