pin.cc
Go to the documentation of this file.
00001 #include "osl/eval/ml/pin.h"
00002 using osl::MultiInt;
00003 
00004 osl::misc::CArray<int, osl::PTYPE_SIZE>
00005 osl::eval::ml::SimplePin::table;
00006 
00007 osl::misc::CArray2d<MultiInt, osl::PTYPE_SIZE, 17 * 9>
00008 osl::eval::ml::Pin::table;
00009 
00010 void osl::eval::ml::
00011 SimplePin::setUp(const Weights &weights)
00012 {
00013   table.fill(0);
00014   for (size_t i = 0; i < weights.dimension(); ++i)
00015   {
00016     table[i] = weights.value(i);
00017   }
00018 }
00019 
00020 int osl::eval::ml::
00021 SimplePin::eval(const NumEffectState &state,
00022                 PieceMask black_mask, PieceMask white_mask) const
00023 {
00024   int value = 0;
00025   while (black_mask.any())
00026   {
00027     const osl::Piece piece = state.pieceOf(black_mask.takeOneBit());
00028     value += table[piece.ptype()];
00029   }
00030   while (white_mask.any())
00031   {
00032     const osl::Piece piece = state.pieceOf(white_mask.takeOneBit());
00033     value -= table[piece.ptype()];
00034   }
00035   return value;
00036 }
00037 
00038 
00039 
00040 void osl::eval::ml::
00041 Pin::setUp(const Weights &weights,int stage)
00042 {
00043   for (int i = PTYPE_PIECE_MIN; i <= PTYPE_MAX; ++i)
00044   {
00045     for (int y = 0; y <= 16; ++y)
00046     {
00047       for (int x = 0; x <= 8; ++x)
00048       {
00049         const int distance = x * 17 + y;
00050         table[i][distance][stage] =
00051           weights.value((i - PTYPE_PIECE_MIN) * 17 * 9 + distance);
00052       }
00053     }
00054   }
00055 }
00056 
00057 MultiInt osl::eval::ml::
00058 Pin::eval(const NumEffectState &state,
00059           PieceMask black_mask, PieceMask white_mask)
00060 {
00061   MultiInt value;
00062   const Square black_king = state.kingSquare<BLACK>();
00063   const Square white_king = state.kingSquare<WHITE>();
00064   while (black_mask.any())
00065   {
00066     const osl::Piece piece = state.pieceOf(black_mask.takeOneBit());
00067     value += table[piece.ptype()][index(black_king, piece)];
00068   }
00069   while (white_mask.any())
00070   {
00071     const osl::Piece piece = state.pieceOf(white_mask.takeOneBit());
00072     value -= table[piece.ptype()][index(white_king, piece)];
00073   }
00074   return value;
00075 }
00076 
00077 osl::misc::CArray<MultiInt, 80>
00078 osl::eval::ml::PinPtypeAll::table;
00079 osl::misc::CArray<MultiInt, 48>
00080 osl::eval::ml::PinPtypeAll::pawn_table;
00081 osl::misc::CArray<MultiInt, 560>
00082 osl::eval::ml::PinPtypeAll::distance_table;
00083 
00084 void osl::eval::ml::
00085 PinPtype::setUp(const Weights &weights)
00086 {
00087   for (size_t i = 0; i < ONE_DIM; ++i)
00088   {
00089     for (int s=0; s<NStages; ++s)
00090       table[i][s] = weights.value(i + ONE_DIM*s);
00091   }
00092 }
00093 
00094 void osl::eval::ml::
00095 PinPtypeDistance::setUp(const Weights &weights)
00096 {
00097   for (size_t i = 0; i < ONE_DIM; ++i)
00098   {
00099     for (int s=0; s<NStages; ++s)
00100       distance_table[i][s] = weights.value(i + ONE_DIM*s);
00101   }
00102 }
00103 
00104 void osl::eval::ml::
00105 PinPtypePawnAttack::setUp(const Weights &weights)
00106 {
00107   for (size_t i = 0; i < ONE_DIM; ++i)
00108   {
00109     for (int s=0; s<NStages; ++s)
00110       pawn_table[i][s] = weights.value(i + ONE_DIM*s);
00111   }
00112 }
00113 
00114 template <osl::Player Defense>
00115 osl::MultiInt osl::eval::ml::
00116 PinPtypeAll::evalOne(const NumEffectState &state)
00117 {
00118   MultiInt result;
00119   const Square king = state.kingSquare<Defense>();
00120   osl::container::PieceMask pin_mask = state.pin(Defense);
00121   while (pin_mask.any())
00122   {
00123     const Piece piece = state.pieceOf(pin_mask.takeOneBit());
00124     if (!state.hasEffectAt<Defense>(piece.square()))
00125       continue;
00126     if (king.y() == piece.square().y()) // rook h
00127     {
00128       result +=
00129         (distance_table[(piece.ptype() + PTYPE_SIZE * 1) * 7 +
00130                         std::abs(king.x() - piece.square().x()) - 1] +
00131          table[(piece.ptype() + PTYPE_SIZE * 1)]);
00132       if (pawnAttack<Defense>(state, piece))
00133       {
00134         result += pawn_table[(piece.ptype() + PTYPE_SIZE * 0)];
00135       }
00136     }
00137     else if (king.x() == piece.square().x())
00138     {
00139       if (state.hasEffectByPtypeStrict<LANCE>(alt(Defense),
00140                                               piece.square())) // lance
00141       {
00142         result +=
00143           (distance_table[(piece.ptype() + PTYPE_SIZE * 4) * 7 +
00144                           std::abs(king.y() - piece.square().y()) - 1] +
00145            table[piece.ptype() + PTYPE_SIZE * 4]);
00146       }
00147       else // rook v
00148       {
00149         result +=
00150           (distance_table[(piece.ptype() + PTYPE_SIZE * 0) * 7 +
00151                           std::abs(king.y() - piece.square().y()) - 1] +
00152            table[piece.ptype() + PTYPE_SIZE * 0]);
00153       }
00154     }
00155     else // bishop
00156     {
00157       if ((Defense == BLACK && piece.square().y() < king.y()) ||
00158           (Defense == WHITE && piece.square().y() > king.y())) // u
00159       {
00160         result +=
00161           (distance_table[(piece.ptype() + PTYPE_SIZE * 2) * 7 +
00162                           std::abs(king.x() - piece.square().x()) - 1] +
00163            table[piece.ptype() + PTYPE_SIZE * 2]);
00164         if (pawnAttack<Defense>(state, piece))
00165         {
00166           result += pawn_table[(piece.ptype() + PTYPE_SIZE * 1)];
00167         }
00168       }
00169       else
00170       {
00171         result +=
00172           (distance_table[(piece.ptype() + PTYPE_SIZE * 3) * 7 +
00173                           std::abs(king.x() - piece.square().x()) - 1] +
00174            table[piece.ptype() + PTYPE_SIZE * 3]);
00175         if (pawnAttack<Defense>(state, piece))
00176         {
00177           result += pawn_table[(piece.ptype() + PTYPE_SIZE * 2)];
00178         }
00179       }
00180     }
00181   }
00182   return result;
00183 }
00184 
00185 osl::MultiInt osl::eval::ml::
00186 PinPtypeAll::eval(const NumEffectState &state)
00187 {
00188   return evalOne<BLACK>(state) - evalOne<WHITE>(state);
00189 }
00190 
00191 
00192 osl::misc::CArray<MultiInt, 80>
00193 osl::eval::ml::CheckShadowPtype::table;
00194 
00195 void osl::eval::ml::
00196 CheckShadowPtype::setUp(const Weights &weights)
00197 {
00198   for (size_t i = 0; i < ONE_DIM; ++i)
00199   {
00200     for (int s=0; s<NStages; ++s)
00201       table[i][s] = weights.value(i + ONE_DIM*s);
00202   }
00203 }
00204 
00205 template <osl::Player Defense>
00206 osl::MultiInt osl::eval::ml::
00207 CheckShadowPtype::evalOne(const NumEffectState &state) 
00208 {
00209   MultiInt result;
00210   const Square king = state.kingSquare<Defense>();
00211   PieceMask open_mask = state.checkShadow(alt(Defense));
00212   while (open_mask.any())
00213   {
00214     const Piece piece = state.pieceOf(open_mask.takeOneBit());
00215     if (king.y() == piece.square().y()) // rook h
00216     {
00217       result += table[piece.ptype() + PTYPE_SIZE * 1];
00218     }
00219     else if (king.x() == piece.square().x())
00220     {
00221       if (state.hasEffectByPtypeStrict<LANCE>(alt(Defense),
00222                                                 piece.square())) // lance
00223       {
00224         result += table[piece.ptype() + PTYPE_SIZE * 4];
00225       }
00226       else // rook v
00227       {
00228         result += table[piece.ptype() + PTYPE_SIZE * 0];
00229       }
00230     }
00231     else // bishop
00232     {
00233       if ((Defense == BLACK && piece.square().y() < king.y()) ||
00234           (Defense == WHITE && piece.square().y() > king.y())) // u
00235       {
00236         result += table[piece.ptype() + PTYPE_SIZE * 2];
00237       }
00238       else
00239       {
00240         result += table[piece.ptype() + PTYPE_SIZE * 3];
00241       }
00242     }
00243   }
00244   return result;
00245 }
00246 
00247 osl::MultiInt osl::eval::ml::
00248 CheckShadowPtype::eval(const NumEffectState &state)
00249 {
00250   return evalOne<BLACK>(state) - evalOne<WHITE>(state);
00251 }
00252 // ;;; Local Variables:
00253 // ;;; mode:c++
00254 // ;;; c-basic-offset:2
00255 // ;;; End:
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines