evaldiff.c

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