evaldiff.c

   1 #include <assert.h>
   2 #include "shogi.h"
   3
   4 void
   5 check_futile_score_quies( const tree_t * restrict ptree, unsigned int move,
   6                           int old_val, int new_val, int turn )
   7 {
   8   const int ifrom = I2From(move);
   9   int fsp, fmt, ipc_cap;
  10
  11   if ( I2PieceMove(move) == king )
  12     {
  13       fmt = new_val;
  14       fsp = new_val - old_val;
  15
  16       if ( turn )
  17         {
  18           fmt     += MATERIAL;
  19           ipc_cap  = -(int)UToCap(move);
  20         }
  21       else {
  22         fmt     -= MATERIAL;
  23         ipc_cap  = (int)UToCap(move);
  24       }
  25
  26       if ( ipc_cap )
  27         {
  28           fmt -= p_value_ex[15+ipc_cap];
  29           fsp -= estimate_score_diff( ptree, move, turn );
  30           if ( fsp > fmg_cap_king ) { fmg_cap_king = fsp; }
  31         }
  32       else if ( fsp > fmg_misc_king ) { fmg_misc_king = fsp; }
  33
  34       if ( fmt > fmg_mt ) { fmg_mt = fmt; }
  35     }
  36   else {
  37     fsp = new_val - old_val - estimate_score_diff( ptree, move, turn );
  38     if ( turn )
  39       {
  40         fmt     = new_val + MATERIAL;
  41         ipc_cap = -(int)UToCap(move);
  42       }
  43     else {
  44       fmt      = new_val - MATERIAL;
  45       ipc_cap  = (int)UToCap(move);
  46     }
  47     if ( ifrom >= nsquare )
  48       {
  49         if ( fsp > fmg_drop ) { fmg_drop = fsp; }
  50       }
  51     else {
  52       if ( I2IsPromote(move) )
  53         {
  54           fmt -= benefit2promo[7+I2PieceMove(move)];
  55         }
  56
  57       if ( ipc_cap )
  58         {
  59           fmt -= p_value_ex[15+ipc_cap];
  60           if ( fsp > fmg_cap ) { fmg_cap = fsp; }
  61         }
  62       else if ( fsp > fmg_misc ) { fmg_misc = fsp; }
  63     }
  64
  65     if ( fmt > fmg_mt )   { fmg_mt = fmt; }
  66   }
  67 }
  68
  69
  70 int
  71 eval_max_score( const tree_t * restrict ptree, unsigned int move,
  72                 int stand_pat, int turn, int diff )
  73 {
  74   int score_mt, score_sp, ipc_cap;
  75
  76   if ( I2From(move) >= nsquare )
  77     {
  78       score_sp = stand_pat + diff + fmg_drop + FMG_MG;
  79       score_mt = ( turn ? -MATERIAL : MATERIAL ) + fmg_mt + FMG_MG_MT;
  80     }
  81   else {
  82     score_sp = diff + stand_pat;
  83     score_mt = fmg_mt + FMG_MG_MT;
  84     if ( turn )
  85       {
  86         score_mt -= MATERIAL;
  87         ipc_cap   = -(int)UToCap(move);
  88       }
  89     else {
  90       score_mt += MATERIAL;
  91       ipc_cap   = (int)UToCap(move);
  92     }
  93     if ( I2PieceMove(move) == king )
  94       {
  95         if ( ipc_cap )
  96           {
  97             score_mt += p_value_ex[15+ipc_cap];
  98             score_sp += fmg_cap_king;
  99           }
 100         else { score_sp += fmg_misc_king; }
 101         score_sp += FMG_MG_KING;
 102       }
 103     else {
 104       if ( ipc_cap )
 105         {
 106           score_mt += p_value_ex[15+ipc_cap];
 107           score_sp += fmg_cap;
 108         }
 109       else { score_sp += fmg_misc; }
 110
 111       if ( I2IsPromote(move) )
 112         {
 113           score_mt += benefit2promo[7+I2PieceMove(move)];
 114         }
 115
 116       score_sp += FMG_MG;
 117     }
 118   }
 119   return score_mt < score_sp ? score_mt : score_sp;
 120 }
 121
 122
 123 int
 124 estimate_score_diff( const tree_t * restrict ptree, unsigned int move,
 125                      int turn )
 126 {
 127   const int ibk   = SQ_BKING;
 128   const int iwk   = Inv(SQ_WKING);
 129   const int ifrom = I2From(move);
 130   const int ito   = I2To(move);
 131   int diff, ipc_move, ipc_cap, ipro_pc_move;
 132
 133   if ( I2PieceMove(move) == king )
 134     {
 135       ipc_cap = (int)UToCap(move);
 136       if ( ipc_cap )
 137         {
 138           diff  = -(int)PcOnSq( ibk, aipos[15+ipc_cap]+ito );
 139           diff +=  (int)PcOnSq( iwk, aipos[15-ipc_cap]+Inv(ito) );
 140           diff /= FV_SCALE;
 141           if ( turn ) { diff -= p_value_ex[15+ipc_cap]; }
 142           else        { diff += p_value_ex[15-ipc_cap]; }
 143         }
 144       else { diff = 0; }
 145     }
 146   else if ( ifrom >= nsquare )
 147     {
 148       ipc_move = turn ? -(int)From2Drop(ifrom) : (int)From2Drop(ifrom);
 149       diff     = (int)PcOnSq( ibk, aipos[15+ipc_move]+ito );
 150       diff    -= (int)PcOnSq( iwk, aipos[15-ipc_move]+Inv(ito) );
 151       diff    /= FV_SCALE;
 152     }
 153   else {
 154     if ( turn )
 155       {
 156         ipc_move     = -(int)I2PieceMove(move);
 157         ipc_cap      =  (int)UToCap(move);
 158         ipro_pc_move = ipc_move - promote;
 159       }
 160     else {
 161       ipc_move     = (int)I2PieceMove(move);
 162       ipc_cap      = -(int)UToCap(move);
 163       ipro_pc_move = ipc_move + promote;
 164     }
 165     if ( I2IsPromote(move) && ipc_cap )
 166       {
 167         diff  = -(int)PcOnSq( ibk, aipos[15+ipc_move]     + ifrom );
 168         diff +=  (int)PcOnSq( ibk, aipos[15+ipro_pc_move] + ito );
 169         diff += -(int)PcOnSq( ibk, aipos[15+ipc_cap]      + ito );
 170         diff +=  (int)PcOnSq( iwk, aipos[15-ipc_move]     + Inv(ifrom) );
 171         diff += -(int)PcOnSq( iwk, aipos[15-ipro_pc_move] + Inv(ito) );
 172         diff +=  (int)PcOnSq( iwk, aipos[15-ipc_cap]      + Inv(ito) );
 173         diff /= FV_SCALE;
 174         if ( turn )
 175           {
 176             diff -= benefit2promo[7+ipc_move];
 177             diff -= p_value_ex[15+ipc_cap];
 178           }
 179         else {
 180           diff += benefit2promo[7+ipc_move];
 181           diff += p_value_ex[15+ipc_cap];
 182         }
 183       }
 184     else if ( ipc_cap )
 185       {
 186         diff  = -(int)PcOnSq( ibk, aipos[15+ipc_move] + ifrom );
 187         diff +=  (int)PcOnSq( ibk, aipos[15+ipc_move] + ito );
 188         diff += -(int)PcOnSq( ibk, aipos[15+ipc_cap]  + ito );
 189         diff +=  (int)PcOnSq( iwk, aipos[15-ipc_move] + Inv(ifrom) );
 190         diff += -(int)PcOnSq( iwk, aipos[15-ipc_move] + Inv(ito) );
 191         diff +=  (int)PcOnSq( iwk, aipos[15-ipc_cap]  + Inv(ito) );
 192         diff /= FV_SCALE;
 193         diff += turn ? -p_value_ex[15+ipc_cap] : p_value_ex[15+ipc_cap];
 194       }
 195     else if ( I2IsPromote(move) )
 196       {
 197         diff  = -(int)PcOnSq( ibk, aipos[15+ipc_move]     + ifrom );
 198         diff +=  (int)PcOnSq( ibk, aipos[15+ipro_pc_move] + ito );
 199         diff +=  (int)PcOnSq( iwk, aipos[15-ipc_move]     + Inv(ifrom) );
 200         diff += -(int)PcOnSq( iwk, aipos[15-ipro_pc_move] + Inv(ito) );
 201         diff /= FV_SCALE;
 202         diff += turn ? -benefit2promo[7+ipc_move] : benefit2promo[7+ipc_move];
 203       }
 204     else {
 205       diff  = -(int)PcOnSq( ibk, aipos[15+ipc_move] + ifrom );
 206       diff +=  (int)PcOnSq( ibk, aipos[15+ipc_move] + ito );
 207       diff +=  (int)PcOnSq( iwk, aipos[15-ipc_move] + Inv(ifrom) );
 208       diff += -(int)PcOnSq( iwk, aipos[15-ipc_move] + Inv(ito) );
 209       diff /= FV_SCALE;
 210     }
 211   }
 212
 213   if ( turn ) { diff = -diff; }
 214
 215   return diff;
 216 }