説明を見る。00001 #include "osl/eval/pin.h"
00002 using osl::MultiInt;
00003
00004 osl::CArray<int, osl::PTYPE_SIZE>
00005 osl::eval::ml::SimplePin::table;
00006
00007 osl::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::CArray<MultiInt, 80>
00078 osl::eval::ml::PinPtypeAll::table;
00079 osl::CArray<MultiInt, 48>
00080 osl::eval::ml::PinPtypeAll::pawn_table;
00081 osl::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 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())
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()))
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
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
00156 {
00157 if ((Defense == BLACK && piece.square().y() < king.y()) ||
00158 (Defense == WHITE && piece.square().y() > king.y()))
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::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())
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()))
00223 {
00224 result += table[piece.ptype() + PTYPE_SIZE * 4];
00225 }
00226 else
00227 {
00228 result += table[piece.ptype() + PTYPE_SIZE * 0];
00229 }
00230 }
00231 else
00232 {
00233 if ((Defense == BLACK && piece.square().y() < king.y()) ||
00234 (Defense == WHITE && piece.square().y() > king.y()))
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
00253
00254
00255