gnushogi/eval.c

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