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.getPieceOf(black_mask.takeOneBit());
00028 value += table[piece.ptype()];
00029 }
00030 while (white_mask.any())
00031 {
00032 const osl::Piece piece = state.getPieceOf(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 Position black_king = state.getKingPosition<BLACK>();
00063 const Position white_king = state.getKingPosition<WHITE>();
00064 while (black_mask.any())
00065 {
00066 const osl::Piece piece = state.getPieceOf(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.getPieceOf(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 Position king = state.getKingPosition<Defense>();
00120 osl::container::PieceMask pin_mask = state.pin(Defense);
00121 while (pin_mask.any())
00122 {
00123 const Piece piece = state.getPieceOf(pin_mask.takeOneBit());
00124 if (!state.hasEffectBy<Defense>(piece.position()))
00125 continue;
00126 if (king.y() == piece.position().y())
00127 {
00128 result +=
00129 (distance_table[(piece.ptype() + PTYPE_SIZE * 1) * 7 +
00130 std::abs(king.x() - piece.position().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.position().x())
00138 {
00139 if (state.hasEffectByPtypeStrict<LANCE>(PlayerTraits<Defense>::opponent,
00140 piece.position()))
00141 {
00142 result +=
00143 (distance_table[(piece.ptype() + PTYPE_SIZE * 4) * 7 +
00144 std::abs(king.y() - piece.position().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.position().y()) - 1] +
00152 table[piece.ptype() + PTYPE_SIZE * 0]);
00153 }
00154 }
00155 else
00156 {
00157 if ((Defense == BLACK && piece.position().y() < king.y()) ||
00158 (Defense == WHITE && piece.position().y() > king.y()))
00159 {
00160 result +=
00161 (distance_table[(piece.ptype() + PTYPE_SIZE * 2) * 7 +
00162 std::abs(king.x() - piece.position().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.position().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 }