00001 #include "osl/eval/ml/kingTable.h"
00002 using osl::MultiInt;
00003
00004 osl::misc::CArray2d<MultiInt, osl::PTYPE_SIZE, 17 * 9> osl::eval::ml::KingPieceRelative::attack_table;
00005 osl::misc::CArray2d<MultiInt, osl::PTYPE_SIZE, 17 * 9> osl::eval::ml::KingPieceRelative::defense_table;
00006
00007 void osl::eval::ml::
00008 KingPieceRelative::setUp(const Weights &weights, int stage)
00009 {
00010 for (int i = PTYPE_PIECE_MIN; i <= PTYPE_MAX; ++i)
00011 {
00012 for (int y = 0; y <= 16; ++y)
00013 {
00014 for (int x = 0; x <= 8; ++x)
00015 {
00016 const int distance = x * 17 + y;
00017 attack_table[i][distance][stage] =
00018 weights.value((i - PTYPE_PIECE_MIN) * 17 * 9 + distance);
00019 defense_table[i][distance][stage] =
00020 weights.value((i - PTYPE_PIECE_MIN) * 17 * 9 + distance + TABLE_DIM);
00021 }
00022 }
00023 }
00024 }
00025
00026 MultiInt osl::eval::ml::
00027 KingPieceRelative::eval(const NumEffectState &state)
00028 {
00029 MultiInt value;
00030 const Position b_king = state.getKingPosition(BLACK);
00031 const Position w_king = state.getKingPosition(WHITE);
00032 for (int i = 0; i < osl::Piece::SIZE; ++i)
00033 {
00034 const osl::Piece piece = state.getPieceOf(i);
00035 if (!piece.isOnBoard())
00036 continue;
00037 const Ptype ptype = piece.ptype();
00038 const Position position = piece.position();
00039 if (piece.owner() == BLACK)
00040 {
00041 const int attack_index = index(state, BLACK,position, w_king);
00042 const int defense_index = index(state, BLACK,position, b_king);
00043 value += attack_table[ptype][attack_index];
00044 value += defense_table[ptype][defense_index];
00045 }
00046 else
00047 {
00048 const int attack_index = index(state, WHITE,position, b_king);
00049 const int defense_index = index(state, WHITE,position, w_king);
00050 value -= attack_table[ptype][attack_index];
00051 value -= defense_table[ptype][defense_index];
00052 }
00053 }
00054 return value;
00055 }
00056
00057 template<osl::Player P>
00058 MultiInt osl::eval::ml::
00059 KingPieceRelative::evalWithUpdate(const NumEffectState &state,
00060 Move moved, MultiInt const& last_value)
00061 {
00062 if (moved.isPass())
00063 return last_value;
00064
00065 if (moved.ptype() == osl::KING)
00066 {
00067 return eval(state);
00068 }
00069
00070 MultiInt value(last_value);
00071 if (!moved.isDrop())
00072 {
00073 const PtypeO ptypeO = moved.oldPtypeO();
00074 const int attack_index = index(state, ptypeO, moved.from(), false);
00075 const int defense_index = index(state,ptypeO, moved.from(), true);
00076 if (P == BLACK)
00077 {
00078 value -= attack_table[moved.oldPtype()][attack_index];
00079 value -= defense_table[moved.oldPtype()][defense_index];
00080 }
00081 else
00082 {
00083 value += attack_table[moved.oldPtype()][attack_index];
00084 value += defense_table[moved.oldPtype()][defense_index];
00085 }
00086 }
00087 {
00088 const int attack_index = index(state, moved.ptypeO(), moved.to(), false);
00089 const int defense_index = index(state, moved.ptypeO(), moved.to(), true);
00090 if (P == BLACK)
00091 {
00092 value += attack_table[moved.ptype()][attack_index];
00093 value += defense_table[moved.ptype()][defense_index];
00094 }
00095 else
00096 {
00097 value -= attack_table[moved.ptype()][attack_index];
00098 value -= defense_table[moved.ptype()][defense_index];
00099 }
00100 }
00101 const Ptype captured = moved.capturePtype();
00102 if (captured != PTYPE_EMPTY)
00103 {
00104 const PtypeO ptypeO = moved.capturePtypeO();
00105 const int attack_index = index(state, ptypeO, moved.to(), false);
00106 const int defense_index = index(state,ptypeO, moved.to(), true);
00107 if (P == BLACK)
00108 {
00109 value += attack_table[captured][attack_index];
00110 value += defense_table[captured][defense_index];
00111 }
00112 else
00113 {
00114 value -= attack_table[captured][attack_index];
00115 value -= defense_table[captured][defense_index];
00116 }
00117 }
00118 return value;
00119 }
00120
00121
00122 osl::misc::CArray<MultiInt, osl::eval::ml::KingPieceRelativeNoSupport::ONE_DIM>
00123 osl::eval::ml::KingPieceRelativeNoSupport::table;
00124
00125 void osl::eval::ml::
00126 KingPieceRelativeNoSupport::setUp(const Weights &weights)
00127 {
00128 for (int i = 0; i < ONE_DIM; ++i)
00129 {
00130 for (int s=0; s<NStages; ++s)
00131 table[i][s] = weights.value(i + ONE_DIM*s);
00132 }
00133 }
00134
00135 template <int Sign> inline
00136 void osl::eval::ml::
00137 KingPieceRelativeNoSupport::adjust(int attack, int defense, MultiInt& out)
00138 {
00139 if(Sign>0)
00140 out += table[attack] + table[defense];
00141 else
00142 out -= table[attack] + table[defense];
00143 }
00144
00145 MultiInt osl::eval::ml::
00146 KingPieceRelativeNoSupport::eval(const NumEffectState &state)
00147 {
00148 MultiInt result;
00149 const CArray<Position, 2> kings = {{
00150 state.getKingPosition(BLACK),
00151 state.getKingPosition(WHITE),
00152 }};
00153 PieceMask black = (~state.effectedMask(BLACK)) & state.getOnBoardMask(BLACK);
00154 black.reset(KingTraits<BLACK>::index);
00155 while (black.any())
00156 {
00157 const Piece piece = state.getPieceOf(black.takeOneBit());
00158 const int index_attack = index(BLACK, kings[PlayerTraits<WHITE>::index],
00159 piece);
00160 const int index_defense = index(BLACK, kings[PlayerTraits<BLACK>::index],
00161 piece) + ONE_DIM / 2;
00162 adjust<1>(index_attack, index_defense, result);
00163 }
00164 PieceMask white = (~state.effectedMask(WHITE)) & state.getOnBoardMask(WHITE);
00165 white.reset(KingTraits<WHITE>::index);
00166 while (white.any())
00167 {
00168 const Piece piece = state.getPieceOf(white.takeOneBit());
00169 const int index_attack = index(WHITE, kings[PlayerTraits<BLACK>::index],
00170 piece);
00171 const int index_defense = index(WHITE, kings[PlayerTraits<WHITE>::index],
00172 piece) + ONE_DIM / 2;
00173 adjust<-1>(index_attack, index_defense, result);
00174 }
00175 return result;
00176 }
00177
00178 MultiInt osl::eval::ml::
00179 KingPieceRelativeNoSupport::evalWithUpdate(
00180 const NumEffectState &state,
00181 Move moved,
00182 const CArray<PieceMask, 2> &effected_mask,
00183 const MultiInt &last_values)
00184 {
00185 if (moved.ptype() == KING)
00186 return eval(state);
00187
00188 const CArray<PieceMask, 2> new_mask = {{
00189 state.effectedMask(BLACK),
00190 state.effectedMask(WHITE)
00191 }};
00192 const CArray<Position, 2> kings = {{
00193 state.getKingPosition<BLACK>(),
00194 state.getKingPosition<WHITE>(),
00195 }};
00196
00197 MultiInt result(last_values);
00198 const Piece p = state.getPieceAt(moved.to());
00199 if (!moved.isDrop())
00200 {
00201 if (!effected_mask[p.owner()].test(p.number()))
00202 {
00203 const int index_attack =
00204 index(p.owner(), kings[alt(p.owner())],
00205 moved.oldPtype(), moved.from());
00206 const int index_defense =
00207 index(p.owner(), kings[p.owner()], moved.oldPtype(),
00208 moved.from()) + ONE_DIM / 2;
00209 if (p.owner() == BLACK)
00210 adjust<-1>(index_attack, index_defense, result);
00211 else
00212 adjust<1>(index_attack, index_defense, result);
00213 }
00214 }
00215 const Ptype captured = moved.capturePtype();
00216 if (captured != PTYPE_EMPTY)
00217 {
00218 PieceMask captured_mask =
00219 effected_mask[moved.player()] & (~state.getOnBoardMask(BLACK)) &
00220 (~state.getOnBoardMask(WHITE));
00221
00222 if (!effected_mask[alt(moved.player())].test(captured_mask.takeOneBit()))
00223 {
00224 const int index_attack =
00225 index(alt(p.owner()), kings[p.owner()],
00226 captured, moved.to());
00227 const int index_defense =
00228 index(alt(p.owner()), kings[alt(p.owner())], captured,
00229 moved.to()) + ONE_DIM / 2;
00230 if (p.owner() == BLACK)
00231 adjust<1>(index_attack, index_defense, result);
00232 else
00233 adjust<-1>(index_attack, index_defense, result);
00234 }
00235 }
00236 if (!new_mask[p.owner()].test(p.number()))
00237 {
00238 const int index_attack =
00239 index(p.owner(), kings[alt(p.owner())],
00240 moved.ptype(), moved.to());
00241 const int index_defense =
00242 index(p.owner(), kings[p.owner()], moved.ptype(),
00243 moved.to()) + ONE_DIM / 2;
00244 if (p.owner() == BLACK)
00245 adjust<1>(index_attack, index_defense, result);
00246 else
00247 adjust<-1>(index_attack, index_defense, result);
00248 }
00249 PieceMask onboard_black = state.getOnBoardMask(BLACK);
00250 onboard_black.reset(KingTraits<BLACK>::index);
00251
00252 PieceMask black_old = (~effected_mask[0]) & new_mask[0] & onboard_black;
00253 black_old.reset(p.number());
00254 while (black_old.any())
00255 {
00256 const Piece piece = state.getPieceOf(black_old.takeOneBit());
00257 const int index_attack =
00258 index(BLACK, kings[PlayerTraits<WHITE>::index], piece);
00259 const int index_defense =
00260 index(BLACK, kings[PlayerTraits<BLACK>::index], piece) + ONE_DIM / 2;
00261 adjust<-1>(index_attack, index_defense, result);
00262 }
00263
00264 PieceMask black_new = effected_mask[0] & (~new_mask[0]) & onboard_black;
00265 black_new.reset(p.number());
00266 while (black_new.any())
00267 {
00268 const Piece piece = state.getPieceOf(black_new.takeOneBit());
00269 const int index_attack =
00270 index(BLACK, kings[PlayerTraits<WHITE>::index], piece);
00271 const int index_defense =
00272 index(BLACK, kings[PlayerTraits<BLACK>::index], piece) + ONE_DIM / 2;
00273 adjust<1>(index_attack, index_defense, result);
00274 }
00275
00276
00277 PieceMask onboard_white = state.getOnBoardMask(WHITE);
00278 onboard_white.reset(KingTraits<WHITE>::index);
00279 PieceMask white_old = (~effected_mask[1]) & new_mask[1] & onboard_white;
00280 white_old.reset(p.number());
00281 while (white_old.any())
00282 {
00283 const Piece piece = state.getPieceOf(white_old.takeOneBit());
00284 const int index_attack =
00285 index(WHITE, kings[PlayerTraits<BLACK>::index], piece);
00286 const int index_defense =
00287 index(WHITE, kings[PlayerTraits<WHITE>::index], piece) + ONE_DIM / 2;
00288 adjust<1>(index_attack, index_defense, result);
00289 }
00290
00291 PieceMask white_new = effected_mask[1] & (~new_mask[1]) & onboard_white;
00292 white_new.reset(p.number());
00293 while (white_new.any())
00294 {
00295 const Piece piece = state.getPieceOf(white_new.takeOneBit());
00296 const int index_attack =
00297 index(WHITE, kings[PlayerTraits<BLACK>::index], piece);
00298 const int index_defense =
00299 index(WHITE, kings[PlayerTraits<WHITE>::index], piece) + ONE_DIM / 2;
00300 adjust<-1>(index_attack, index_defense, result);
00301 }
00302
00303 return result;
00304 }
00305
00306
00307 osl::misc::CArray<MultiInt, 2592> osl::eval::ml::PtypeYY::table;
00308
00309 void osl::eval::ml::PtypeYY::setUp(const Weights &weights)
00310 {
00311 for (int i = 0; i < ONE_DIM; ++i)
00312 {
00313 for (int s=0; s<NStages; ++s)
00314 table[i][s] = weights.value(i + ONE_DIM*s);
00315 }
00316 }
00317
00318 template <int Sign>
00319 inline
00320 void osl::eval::ml::
00321 PtypeYY::adjust(int black, int white, MultiInt &out)
00322 {
00323 if(Sign>0)
00324 out += table[black] - table[white];
00325 else
00326 out -= table[black] - table[white];
00327 }
00328
00329 MultiInt osl::eval::ml::
00330 PtypeYY::eval(const NumEffectState &state)
00331 {
00332 MultiInt result;
00333 const CArray<Position,2> kings = {{
00334 state.getKingPosition(BLACK),
00335 state.getKingPosition(WHITE),
00336 }};
00337 for (int i = 0; i < Piece::SIZE; ++i)
00338 {
00339 const Piece p = state.getPieceOf(i);
00340 if (!p.isOnBoard())
00341 continue;
00342 const int black_index = index<BLACK>(p, kings[BLACK]);
00343 const int white_index = index<WHITE>(p, kings[WHITE]);
00344 adjust<1>(black_index, white_index, result);
00345 }
00346
00347 return result;
00348 }
00349
00350 MultiInt osl::eval::ml::PtypeYY::evalWithUpdate(
00351 const NumEffectState& state,
00352 Move moved,
00353 const MultiInt &last_values)
00354 {
00355 if (moved.ptype() == KING && moved.to().y() != moved.from().y())
00356 {
00357 return eval(state);
00358 }
00359 MultiInt result(last_values);
00360 if (!moved.isDrop())
00361 {
00362 const int index_black = index<BLACK>(moved.oldPtypeO(), moved.from(),
00363 state.getKingPosition<BLACK>());
00364 const int index_white = index<WHITE>(moved.oldPtypeO(), moved.from(),
00365 state.getKingPosition<WHITE>());
00366 adjust<-1>(index_black, index_white, result);
00367 }
00368 Ptype captured = moved.capturePtype();
00369 if (captured != PTYPE_EMPTY)
00370 {
00371 const PtypeO ptypeO = newPtypeO(alt(moved.player()), captured);
00372 const int index_black = index<BLACK>(ptypeO, moved.to(),
00373 state.getKingPosition<BLACK>());
00374 const int index_white = index<WHITE>(ptypeO, moved.to(),
00375 state.getKingPosition<WHITE>());
00376 adjust<-1>(index_black, index_white, result);
00377 }
00378
00379 {
00380 const int index_black = index<BLACK>(moved.ptypeO(), moved.to(),
00381 state.getKingPosition<BLACK>());
00382 const int index_white = index<WHITE>(moved.ptypeO(), moved.to(),
00383 state.getKingPosition<WHITE>());
00384 adjust<1>(index_black, index_white, result);
00385 }
00386 return result;
00387 }
00388
00389
00390 osl::misc::CArray<int, osl::eval::ml::King25Effect::DIM>
00391 osl::eval::ml::King25Effect::table;
00392
00393 void osl::eval::ml::
00394 King25Effect::setUp(const Weights &weights)
00395 {
00396 table.fill(0);
00397 for (size_t i = 0; i < weights.dimension(); ++i)
00398 {
00399 table[i] = weights.value(i);
00400 }
00401 }
00402
00403 void osl::eval::ml::King25Effect::countEffectAndPieces(
00404 const osl::state::NumEffectState &state,
00405 const osl::Player attack,
00406 int &effect,
00407 int &piece)
00408 {
00409 const Position king = state.getKingPosition(alt(attack));
00410 const int min_x = std::max(1, king.x() - 2);
00411 const int max_x = std::min(9, king.x() + 2);
00412 const int min_y = std::max(1, king.y() - 2);
00413 const int max_y = std::min(9, king.y() + 2);
00414
00415 PieceMask mask;
00416 int count = 0;
00417 for (int y = min_y; y <= max_y; ++y)
00418 {
00419 for (int x = min_x; x <= max_x; ++x)
00420 {
00421 const Position target(x, y);
00422 count += state.countEffect(attack, target);
00423 mask |= state.getEffect(target);
00424 }
00425 }
00426 effect = std::min(255, count);
00427 mask = mask & state.getOnBoardMask(attack);
00428 piece = std::min(16, mask.countBit());
00429 }
00430
00431 int osl::eval::ml::King25Effect::index(int effect, int piece_count)
00432 {
00433 return effect + 128 * piece_count;
00434 }
00435
00436 int osl::eval::ml::King25Effect::eval(
00437 const osl::state::NumEffectState &state)
00438 {
00439 int black_effect, black_piece, white_effect, white_piece;
00440 countEffectAndPieces(state, osl::BLACK, black_effect, black_piece);
00441 countEffectAndPieces(state, osl::WHITE, white_effect, white_piece);
00442 return table[index(black_effect, black_piece)] - table[index(white_effect, white_piece)];
00443 }
00444
00445
00446 osl::misc::CArray<MultiInt, osl::eval::ml::King25Effect2::ONE_DIM>
00447 osl::eval::ml::King25Effect2::table;
00448 osl::misc::CArray<MultiInt, osl::eval::ml::King25EffectY2::ONE_DIM>
00449 osl::eval::ml::King25EffectY2::table;
00450
00451 void osl::eval::ml::King25Effect2::setUp(const Weights &weights)
00452 {
00453 for (int i = 0; i < ONE_DIM; ++i)
00454 {
00455 for (int s=0; s<NStages; ++s)
00456 table[i][s] = weights.value(i + ONE_DIM*s);
00457 }
00458 }
00459
00460 void osl::eval::ml::King25EffectY2::setUp(const Weights &weights)
00461 {
00462 for (int i = 0; i < ONE_DIM; ++i)
00463 {
00464 for (int s=0; s<NStages; ++s)
00465 table[i][s] = weights.value(i + ONE_DIM*s);
00466 }
00467 }
00468
00469
00470 osl::misc::CArray<MultiInt, osl::eval::ml::King25EffectSupported::ONE_DIM>
00471 osl::eval::ml::King25EffectSupported::table;
00472 osl::misc::CArray<MultiInt, osl::eval::ml::King25EffectSupportedY::ONE_DIM>
00473 osl::eval::ml::King25EffectSupportedY::table;
00474
00475 void osl::eval::ml::King25EffectSupported::setUp(const Weights &weights)
00476 {
00477 for (int i = 0; i < ONE_DIM; ++i)
00478 {
00479 for (int s=0; s<NStages; ++s)
00480 table[i][s] = weights.value(i + ONE_DIM*s);
00481 }
00482 }
00483
00484 void osl::eval::ml::King25EffectSupportedY::setUp(const Weights &weights)
00485 {
00486 for (int i = 0; i < ONE_DIM; ++i)
00487 {
00488 for (int s=0; s<NStages; ++s)
00489 table[i][s] = weights.value(i + ONE_DIM*s);
00490 }
00491 }
00492
00493
00494 osl::misc::CArray<int, osl::eval::ml::King25EffectBoth::DIM/2>
00495 osl::eval::ml::King25EffectBoth::attack_table;
00496 osl::misc::CArray<int, osl::eval::ml::King25EffectBoth::DIM/2>
00497 osl::eval::ml::King25EffectBoth::defense_table;
00498
00499 void osl::eval::ml::
00500 King25EffectBoth::setUp(const Weights &weights)
00501 {
00502 attack_table.fill(0);
00503 defense_table.fill(0);
00504 for (size_t i = 0; i < DIM/2; ++i)
00505 {
00506 attack_table[i] = weights.value(i);
00507 defense_table[i] = weights.value(i+DIM/2);
00508 }
00509 }
00510
00511 template <osl::Player Attack>
00512 void
00513 osl::eval::ml::King25EffectBoth::countEffectAndPiecesBoth(
00514 const osl::state::NumEffectState &state,
00515 PieceMask& mask,
00516 PieceMask& supported_mask,
00517 int &attack_effect,
00518 int &attack_piece,
00519 int &defense_effect,
00520 int &defense_piece,
00521 int &attack_piece_supported,
00522 CArray<int, 5> &verticals,
00523 CArray<int, 5> &king_verticals)
00524 {
00525 king_verticals.fill(0);
00526 const Player Defense = PlayerTraits<Attack>::opponent;
00527 const Position king = state.getKingPosition(Defense);
00528 const int min_x = std::max(1, king.x() - 2);
00529 const int max_x = std::min(9, king.x() + 2);
00530 const int min_y = std::max(1, king.y() - 2);
00531 const int max_y = std::min(9, king.y() + 2);
00532 int mask_all=(1<<5)-1;
00533 verticals.fill(mask_all);
00534 const int y_mask_base=(1 << (Defense == BLACK ? (min_y-king.y()) + 2 : -(max_y-king.y()) + 2));
00535 if(Defense==BLACK)
00536 mask_all ^= ((1<<(max_y-king.y()+3))-y_mask_base);
00537 else
00538 mask_all ^= ((1<<(king.y()-min_y+3))-y_mask_base);
00539 mask.resetAll();
00540 int attack_count = 0;
00541 int defense_count = 0;
00542 for (int x = min_x; x <= max_x; ++x)
00543 {
00544 int vertical_x=mask_all;
00545 int king_vertical_x = 0;
00546 if(Defense==BLACK){
00547 int y_mask=y_mask_base;
00548 for (int y = min_y; y <= max_y; ++y, y_mask+=y_mask)
00549 {
00550 const Position target(x, y);
00551 const int count = state.countEffect(Attack, target);
00552 defense_count += state.countEffect(alt(Attack), target);
00553 mask |= state.getEffect(target);
00554 if(count>0){
00555 attack_count += count;
00556 vertical_x |= y_mask;
00557 }
00558 const Piece piece = state.getPieceAt(target);
00559 if (count == 0 &&
00560 (piece.isEmpty() || piece.owner() == Attack))
00561 {
00562 king_vertical_x |= y_mask;
00563 }
00564 }
00565 }
00566 else{
00567 int y_mask=y_mask_base;
00568 for (int y = max_y; y >= min_y; --y, y_mask+=y_mask)
00569 {
00570 const Position target(x, y);
00571 const int count = state.countEffect(Attack, target);
00572 defense_count += state.countEffect(alt(Attack), target);
00573 mask |= state.getEffect(target);
00574 if(count>0){
00575 attack_count += count;
00576 vertical_x |= y_mask;
00577 }
00578 const Piece piece = state.getPieceAt(target);
00579 if (count == 0 &&
00580 (piece.isEmpty() || piece.owner() == Attack))
00581 {
00582 king_vertical_x |= y_mask;
00583 }
00584 }
00585 }
00586 const int x_diff = king.x() - x;
00587 verticals[(Defense == BLACK ? 2 - x_diff : 2 + x_diff)] = vertical_x;
00588 king_verticals[(Defense == BLACK ? 2 - x_diff : 2 + x_diff)] =
00589 king_vertical_x;
00590 }
00591 attack_effect = std::min(127, attack_count);
00592 defense_effect = std::min(127, defense_count);
00593 PieceMask attack_mask = mask & state.getOnBoardMask(Attack);
00594 attack_piece = std::min(16, attack_mask.countBit());
00595 PieceMask defense_mask = mask & state.getOnBoardMask(alt(Attack));
00596 defense_piece = std::min(16, defense_mask.countBit());
00597 supported_mask = attack_mask & state.effectedMask(Attack);
00598 attack_piece_supported = std::min(16, supported_mask.countBit());
00599 }
00600
00601
00602 osl::misc::CArray<int, osl::eval::ml::King25EffectY::DIM/2>
00603 osl::eval::ml::King25EffectY::attack_table;
00604 osl::misc::CArray<int, osl::eval::ml::King25EffectY::DIM/2>
00605 osl::eval::ml::King25EffectY::defense_table;
00606
00607 void osl::eval::ml::
00608 King25EffectY::setUp(const Weights &weights)
00609 {
00610 attack_table.fill(0);
00611 defense_table.fill(0);
00612 for (size_t i = 0; i < DIM/2; ++i)
00613 {
00614 attack_table[i] = weights.value(i);
00615 defense_table[i] = weights.value(i+DIM/2);
00616 }
00617 }
00618
00619
00620
00621 void osl::eval::ml::
00622 King25EmptyPositionNoEffect::setUpBase(const Weights &weights, CArray<int, 15>& table)
00623 {
00624 table.fill(0);
00625 for (size_t i = 0; i < weights.dimension(); ++i)
00626 {
00627 table[i] = weights.value(i);
00628 }
00629 }
00630
00631 template <osl::Player defense>
00632 int osl::eval::ml::
00633 King25EmptyPositionNoEffect::evalOne(const NumEffectState &state, const CArray<int, 15>& table)
00634 {
00635 int result = 0;
00636 const Piece king_piece = state.getKingPiece<defense>();
00637 const Position king = king_piece.position();
00638 const int min_x = std::max(1, king.x() - 2);
00639 const int max_x = std::min(9, king.x() + 2);
00640 const int min_y = std::max(1, king.y() - 2);
00641 const int max_y = std::min(9, king.y() + 2);
00642
00643 PieceMask pieces=state.getOnBoardMask(defense);
00644 pieces.reset(KingTraits<defense>::index);
00645
00646 for (int x = min_x; x <= max_x; ++x)
00647 {
00648 for (int y = min_y; y <= max_y; ++y)
00649 {
00650 Position target(x, y);
00651 if (state.getPieceAt(target).isEmpty()
00652 && !
00653 (pieces & state.getEffect(target)).any())
00654 {
00655 if (defense == BLACK)
00656 result += table[index(x - king.x(), y - king.y())];
00657 else
00658 result -= table[index(king.x() - x, king.y() - y)];
00659 }
00660 }
00661 }
00662 return result;
00663 }
00664
00665 template <osl::Player defense>
00666 std::pair<int,int> osl::eval::ml::
00667 King25EmptyPositionNoEffect::evalOne(const NumEffectState &state,
00668 const CArray<int, 15>& opening, const CArray<int, 15>& ending)
00669 {
00670 int result_o = 0, result_e = 0;
00671 const Piece king_piece = state.getKingPiece<defense>();
00672 const Position king = king_piece.position();
00673 const int min_x = std::max(1, king.x() - 2);
00674 const int max_x = std::min(9, king.x() + 2);
00675 const int min_y = std::max(1, king.y() - 2);
00676 const int max_y = std::min(9, king.y() + 2);
00677
00678 PieceMask pieces=state.getOnBoardMask(defense);
00679 pieces.reset(KingTraits<defense>::index);
00680
00681 for (int x = min_x; x <= max_x; ++x)
00682 {
00683 for (int y = min_y; y <= max_y; ++y)
00684 {
00685 Position target(x, y);
00686 if (state.getPieceAt(target).isEmpty()
00687 && !
00688 (pieces & state.getEffect(target)).any())
00689 {
00690 if (defense == BLACK)
00691 {
00692 result_o += opening[index(x - king.x(), y - king.y())];
00693 result_e += ending[index(x - king.x(), y - king.y())];
00694 }
00695 else
00696 {
00697 result_o -= opening[index(king.x() - x, king.y() - y)];
00698 result_e -= ending[index(king.x() - x, king.y() - y)];
00699 }
00700 }
00701 }
00702 }
00703 return std::make_pair(result_o, result_e);
00704 }
00705
00706 std::pair<osl::CArray<int,2>, osl::CArray<int,2> > osl::eval::ml::
00707 King25EmptyPositionNoEffect::eval(const NumEffectState &state,
00708 const CArray<int, 15>& opening, const CArray<int, 15>& ending)
00709 {
00710 std::pair<int,int> b = evalOne<BLACK>(state, opening, ending);
00711 std::pair<int,int> w = evalOne<WHITE>(state, opening, ending);
00712 CArray<int,2> result_o = {{ b.first, w.first }};
00713 CArray<int,2> result_e = {{ b.second, w.second }};
00714 return std::make_pair(result_o, result_e);
00715 }
00716
00717 std::pair<osl::CArray<int,2>, osl::CArray<int,2> > osl::eval::ml::
00718 King25EmptyPositionNoEffect::evalWithUpdate(const NumEffectState &state, Move last_move,
00719 const CArray<int, 15>& opening, const CArray<int, 15>& ending,
00720 const CArray<int, 2>& last_opening_value,
00721 const CArray<int, 2>& last_ending_value)
00722 {
00723 BoardMask mb = state.changedEffects(BLACK), mw = state.changedEffects(WHITE);
00724 mb.set(Position(last_move.to())); mb.set(Position(last_move.from()));
00725 mw.set(Position(last_move.to())); mw.set(Position(last_move.from()));
00726 const Position kb = state.getKingPosition<BLACK>(), kw = state.getKingPosition<WHITE>();
00727 const bool update_black = mb.anyInRange(Board_Mask_Table5x5.mask(kb));
00728 const bool update_white = mw.anyInRange(Board_Mask_Table5x5.mask(kw));
00729 std::pair<int,int> b = update_black
00730 ? evalOne<BLACK>(state, opening, ending)
00731 : std::make_pair(last_opening_value[0], last_ending_value[0]);
00732 std::pair<int,int> w = update_white
00733 ? evalOne<WHITE>(state, opening, ending)
00734 : std::make_pair(last_opening_value[1], last_ending_value[1]);
00735 CArray<int,2> result_o = {{ b.first, w.first }};
00736 CArray<int,2> result_e = {{ b.second, w.second }};
00737 return std::make_pair(result_o, result_e);
00738 }
00739
00740
00741 osl::misc::CArray<int, 15>
00742 osl::eval::ml::King25EmptyPositionNoEffectOpening::table;
00743 osl::misc::CArray<int, 15>
00744 osl::eval::ml::King25EmptyPositionNoEffectEnding::table;
00745
00746 const osl::CArray<int,2> osl::eval::ml::
00747 King25EmptyPositionNoEffectOpening::eval(const NumEffectState &state)
00748 {
00749 CArray<int, 2> result = {{ evalOne<BLACK>(state, table), evalOne<WHITE>(state, table) }};
00750 return result;
00751 }
00752
00753 const osl::CArray<int,2> osl::eval::ml::
00754 King25EmptyPositionNoEffectEnding::eval(const NumEffectState &state)
00755 {
00756 CArray<int, 2> result = {{ evalOne<BLACK>(state, table), evalOne<WHITE>(state, table) }};
00757 return result;
00758 }
00759
00760
00761
00762 template <int Stage>
00763 osl::misc::CArray<int, 5 * 3 * 8 * 3>
00764 osl::eval::ml::King25EffectEach<Stage>::table;
00765
00766 template <int Stage>
00767 void osl::eval::ml::
00768 King25EffectEach<Stage>::setUp(const Weights &weights)
00769 {
00770 for (size_t i = 0; i < weights.dimension(); ++i)
00771 {
00772 table[i] = weights.value(i);
00773 }
00774 }
00775
00776 template <int Stage>
00777 template <osl::Player Defense>
00778 osl::eval::ml::EffectState
00779 osl::eval::ml::King25EffectEach<Stage>::effectState(
00780 const NumEffectState &state,
00781 Position target)
00782 {
00783 if (!state.hasEffectBy(PlayerTraits<Defense>::opponent, target))
00784 {
00785 return static_cast<EffectState>(std::min(2, state.countEffect(Defense, target)));
00786 }
00787 const int diff = state.countEffect(Defense, target) -
00788 state.countEffect(PlayerTraits<Defense>::opponent, target);
00789 return static_cast<EffectState>(std::max(-2, std::min(2, diff)) + ATTACK_DIFF_0);
00790 }
00791
00792 template <int Stage>
00793 template <osl::Player Defense>
00794 int osl::eval::ml::King25EffectEach<Stage>::index(
00795 const NumEffectState &state, Position king,
00796 Position target)
00797 {
00798 const Piece piece = state.getPieceAt(target);
00799
00800 const int rel_x = std::abs(king.x() - target.x());
00801
00802 const int rel_y = (target.y() - king.y()) * (Defense == BLACK ? 1 : -1);
00803 int piece_owner;
00804 if (piece.isEmpty())
00805 piece_owner = 0;
00806 else if (piece.owner() == Defense)
00807 piece_owner = 1;
00808 else
00809 piece_owner = 2;
00810
00811 int val = rel_y + 2 + rel_x * 5 +
00812 effectState<Defense>(state, target) * 5 * 3 +
00813 piece_owner * 5 * 3 * 8;
00814 return val;
00815 }
00816
00817 template <int Stage>
00818 template <osl::Player Defense>
00819 int osl::eval::ml::King25EffectEach<Stage>::evalOne(
00820 const NumEffectState &state)
00821 {
00822 int result = 0;
00823 const Position king = state.getKingPosition<Defense>();
00824 const int min_x = std::max(1, king.x() - 2);
00825 const int max_x = std::min(9, king.x() + 2);
00826 const int min_y = std::max(1, king.y() - 2);
00827 const int max_y = std::min(9, king.y() + 2);
00828 for (int x = min_x; x <= max_x; ++x)
00829 {
00830 for (int y = min_y; y <= max_y; ++y)
00831 {
00832 Position target(x, y);
00833 result += table[index<Defense>(state, king, target)];
00834 }
00835 }
00836 if (Defense == BLACK)
00837 return result;
00838 else
00839 return -result;
00840 }
00841
00842 template <int Stage>
00843 int osl::eval::ml::
00844 King25EffectEach<Stage>::eval(const NumEffectState &state)
00845 {
00846 return evalOne<BLACK>(state) + evalOne<WHITE>(state);
00847 }
00848
00849 osl::misc::CArray<MultiInt, 5 * 3 * 8 * 3>
00850 osl::eval::ml::King25EffectEachBoth::table;
00851 osl::misc::CArray<MultiInt, 3000>
00852 osl::eval::ml::King25EffectEachBoth::x_table;
00853 osl::misc::CArray<MultiInt, 3240>
00854 osl::eval::ml::King25EffectEachBoth::y_table;
00855 osl::misc::CArray<MultiInt, 27000>
00856 osl::eval::ml::King25EffectEachBoth::xy_table;
00857 osl::misc::CArray<int, 256>
00858 osl::eval::ml::King25EffectEachBoth::effect_state_table;
00859
00860 void osl::eval::ml::
00861 King25EffectEachBothOpening::setUp(const Weights &weights)
00862 {
00863 for (size_t i = 0; i < weights.dimension(); ++i)
00864 {
00865 King25EffectEachBoth::table[i][0] = weights.value(i);
00866 }
00867 }
00868
00869 void osl::eval::ml::
00870 King25EffectEachBothMidgame::setUp(const Weights &weights)
00871 {
00872 for (size_t i = 0; i < weights.dimension(); ++i)
00873 {
00874 King25EffectEachBoth::table[i][1] = weights.value(i);
00875 }
00876 }
00877
00878 void osl::eval::ml::
00879 King25EffectEachBothMidgame2::setUp(const Weights &weights)
00880 {
00881 for (size_t i = 0; i < weights.dimension(); ++i)
00882 {
00883 King25EffectEachBoth::table[i][2] = weights.value(i);
00884 }
00885 }
00886
00887 void osl::eval::ml::
00888 King25EffectEachBothEnding::setUp(const Weights &weights)
00889 {
00890 for (size_t i = 0; i < weights.dimension(); ++i)
00891 {
00892 King25EffectEachBoth::table[i][EndgameIndex] = weights.value(i);
00893 }
00894 }
00895 void osl::eval::ml::
00896 King25EffectEachXY::setUp(const Weights &weights)
00897 {
00898 for(int rel_y_2=0;rel_y_2<5;rel_y_2++)
00899 for(int x_diff_2=0;x_diff_2<5;x_diff_2++)
00900 for(int es=0;es<8;es++)
00901 for(int po=0;po<3;po++)
00902 for(int king_x_1=0;king_x_1<5;king_x_1++){
00903 int oldIndex=(rel_y_2+x_diff_2*5+es*5*5+po*5*5*8)*5+king_x_1;
00904 int newIndex=po+3*(es+8*(rel_y_2+5*(x_diff_2+5*king_x_1)));
00905 for (int s=0; s<NStages; ++s)
00906 King25EffectEachBoth::x_table[newIndex][s] = weights.value(oldIndex + X_DIM*s);
00907 }
00908 for(int rel_y_2=0;rel_y_2<5;rel_y_2++)
00909 for(int rel_x=0;rel_x<3;rel_x++)
00910 for(int es=0;es<8;es++)
00911 for(int po=0;po<3;po++)
00912 for(int king_y_1=0;king_y_1<9;king_y_1++){
00913 int oldIndex=(rel_y_2+rel_x*5+es*5*3+po*5*3*8)*9+king_y_1;
00914 int newIndex=po+3*(es+8*(rel_y_2+5*(rel_x+3*king_y_1)));
00915 for (int s=0; s<NStages; ++s)
00916 King25EffectEachBoth::y_table[newIndex][s] = weights.value(oldIndex+ X_DIM * EvalStages + Y_DIM*s)+King25EffectEachBoth::table[oldIndex/9][s];
00917 }
00918 for(int d_effect=0;d_effect<16;d_effect++){
00919 for(int a_effect=0;a_effect<16;a_effect++){
00920 if(a_effect==0){
00921 King25EffectEachBoth::effect_state_table[a_effect*16+d_effect]=3*(std::min(2, d_effect));
00922 }
00923 else{
00924 int diff=d_effect-a_effect;
00925 King25EffectEachBoth::effect_state_table[a_effect*16+d_effect]=
00926 3*(std::max(-2, std::min(2, diff)) + ATTACK_DIFF_0);
00927 }
00928 }
00929 }
00930 }
00931
00932 void osl::eval::ml::
00933 King25EffectEachKXY::setUp(const Weights &weights)
00934 {
00935 for(int rel_y_2=0;rel_y_2<5;rel_y_2++)
00936 for(int x_diff_2=0;x_diff_2<5;x_diff_2++){
00937 int rel_x=std::abs(x_diff_2-2);
00938 for(int es=0;es<8;es++)
00939 for(int po=0;po<3;po++)
00940 for(int king_x_1=0;king_x_1<5;king_x_1++)
00941 for (int king_y_1=0;king_y_1<9;king_y_1++) {
00942 int oldIndex=((rel_y_2+x_diff_2*5+es*5*5+po*5*5*8)*9+king_y_1)*5 + king_x_1;
00943 int newIndexX=po+3*(es+8*(rel_y_2+5*(x_diff_2+5*king_x_1)));
00944 int newIndexY=po+3*(es+8*(rel_y_2+5*(rel_x+3*king_y_1)));
00945 int newIndex=po+3*(es+8*(rel_y_2+5*(x_diff_2+5*(king_x_1+5*king_y_1))));
00946 for (int s=0; s<NStages; ++s)
00947 King25EffectEachBoth::xy_table[newIndex][s] = weights.value(oldIndex + ONE_DIM*s)+King25EffectEachBoth::x_table[newIndexX][s]+King25EffectEachBoth::y_table[newIndexY][s];
00948 }
00949 }
00950 }
00951
00952 template <osl::Player Defense>
00953 int
00954 osl::eval::ml::King25EffectEachBoth::effectStateIndex3(
00955 const NumEffectState &state, Position target)
00956 {
00957 NumBitmapEffect effect=state.getEffect(target);
00958 const int d_effect=effect.countEffect(Defense);
00959 const int a_effect=effect.countEffect(PlayerTraits<Defense>::opponent);
00960 return effect_state_table[a_effect*16+d_effect];
00961 }
00962
00963 template <osl::Player Defense>
00964 void osl::eval::ml::King25EffectEachBoth::index(
00965 const NumEffectState &state,
00966 Position target, int &index_xy,
00967 int rel_y, int king_x, int king_y, int x_diff)
00968 {
00969 const Piece piece = state.getPieceAt(target);
00970
00971 int piece_owner;
00972 PtypeO ptypeO=piece.ptypeO();
00973 if(Defense==BLACK){
00974 #ifdef __INTEL_COMPILER
00975 piece_owner = (unsigned int)((int)(ptypeO)>>30);
00976 piece_owner &= 0x2;
00977 piece_owner |= (ptypeO+14)>>4;
00978 #else
00979 piece_owner=((ptypeO+14)>>4)|(((unsigned int)ptypeO>>30)&0x2);
00980 #endif
00981 }
00982 else{
00983 piece_owner=(((ptypeO+14)>>3)&0x2)|((unsigned int)ptypeO>>31);
00984 }
00985 assert(piece_owner >= 0 && piece_owner < 3);
00986 int effect_state_index = effectStateIndex3<Defense>(state, target);
00987
00988 index_xy=piece_owner+effect_state_index+3*(8*((rel_y+2)+5*((x_diff+2)+5*(king_x-1+5*(king_y-1)))));
00989 }
00990
00991 template <osl::Player Defense>
00992 void osl::eval::ml::King25EffectEachBoth::evalOne(
00993 const NumEffectState &state, MultiInt &out)
00994 {
00995 out.clear();
00996 const Position king = state.getKingPosition<Defense>();
00997 const int min_dx = std::max(1, king.x() - 2)-king.x();
00998 const int max_dx = std::min(9, king.x() + 2)-king.x();
00999 const int min_dy = std::max(1, king.y() - 2)-king.y();
01000 const int max_dy = std::min(9, king.y() + 2)-king.y();
01001 const int king_x = (king.x() > 5 ? 10 - king.x() : king.x());
01002 const int king_y = (Defense == BLACK ? king.y() : 10 - king.y());
01003 if ((Defense == BLACK && king.x() >= 6) ||
01004 (Defense == WHITE && king.x() >= 5)){
01005 for (int dx = min_dx; dx <= max_dx; ++dx)
01006 {
01007
01008
01009
01010 int x_diff = dx;
01011 for (int dy = min_dy; dy <= max_dy; ++dy)
01012 {
01013 const Position target(king.x()+dx, king.y()+dy);
01014
01015 const int rel_y = dy * (Defense == BLACK ? 1 : -1);
01016 int index_xy;
01017 index<Defense>(state, target, index_xy,
01018 rel_y,king_x,king_y,x_diff);
01019 out += xy_table[index_xy];
01020 }
01021 }
01022 }
01023 else {
01024 for (int dx = min_dx; dx <= max_dx; ++dx)
01025 {
01026
01027
01028
01029 int x_diff = -dx;
01030 for (int dy = min_dy; dy <= max_dy; ++dy)
01031 {
01032 const Position target(king.x()+dx, king.y()+dy);
01033
01034 const int rel_y = dy * (Defense == BLACK ? 1 : -1);
01035 int index_xy;
01036 index<Defense>(state, target, index_xy,
01037 rel_y,king_x,king_y,x_diff);
01038 out += xy_table[index_xy];
01039 }
01040 }
01041 }
01042 if (Defense != BLACK)
01043 {
01044 out = -out;
01045 }
01046 }
01047
01048 void osl::eval::ml::
01049 King25EffectEachBoth::eval(const NumEffectState &state,
01050 MultiIntPair &out)
01051 {
01052 evalOne<BLACK>(state, out[BLACK]);
01053 evalOne<WHITE>(state, out[WHITE]);
01054 }
01055
01056 void
01057 osl::eval::ml::King25EffectEachBoth::evalWithUpdate(
01058 const NumEffectState &state, Move last_move,
01059 MultiIntPair &values)
01060 {
01061 BoardMask mb = state.changedEffects(BLACK), mw = state.changedEffects(WHITE);
01062 mb.set(Position(last_move.to())); mb.set(Position(last_move.from()));
01063 mw.set(Position(last_move.to())); mw.set(Position(last_move.from()));
01064 const Position kb = state.getKingPosition<BLACK>(), kw = state.getKingPosition<WHITE>();
01065 const bool update_black = mb.anyInRange(Board_Mask_Table5x5.mask(kb)) ||
01066 mw.anyInRange(Board_Mask_Table5x5.mask(kb));
01067 const bool update_white = mw.anyInRange(Board_Mask_Table5x5.mask(kw)) ||
01068 mb.anyInRange(Board_Mask_Table5x5.mask(kw));
01069 if (update_black)
01070 {
01071 evalOne<BLACK>(state, values[BLACK]);
01072 }
01073 if (update_white)
01074 {
01075 evalOne<WHITE>(state, values[WHITE]);
01076 }
01077 }
01078
01079
01080 template <bool Opening>
01081 osl::misc::CArray<int, 1125> osl::eval::ml::King25EmptyAbs<Opening>::table;
01082
01083 template <bool Opening>
01084 void osl::eval::ml::
01085 King25EmptyAbs<Opening>::setUp(const Weights &weights)
01086 {
01087 for (size_t i = 0; i < weights.dimension(); ++i)
01088 {
01089 table[i] = weights.value(i);
01090 }
01091 }
01092
01093 template <bool Opening>
01094 template <osl::Player player>
01095 int osl::eval::ml::King25EmptyAbs<Opening>::index(Position king,
01096 Position target)
01097 {
01098 int x, target_x;
01099 if ((player == BLACK && king.x() >= 6) ||
01100 (player == WHITE && king.x() >= 5))
01101 {
01102 x = 10 - king.x();
01103 target_x = 10 - target.x();
01104 }
01105 else
01106 {
01107 x = king.x();
01108 target_x = target.x();
01109 }
01110 const int y = (player == BLACK ? king.y() : 10 - king.y());
01111 const int target_y = (player == BLACK ? target.y() : 10 - target.y());
01112
01113 return target_y - y + 2 + (target_x - x + 2 ) * 5 + (y - 1) * 5 * 5
01114 + (x - 1) * 5 * 5 * 9;
01115 }
01116
01117 template <bool Opening>
01118 template <osl::Player Defense>
01119 int osl::eval::ml::King25EmptyAbs<Opening>::evalOne(
01120 const osl::state::NumEffectState &state)
01121 {
01122 int result = 0;
01123 const Position king = state.getKingPosition<Defense>();
01124 const int min_x = std::max(1, king.x() - 2);
01125 const int max_x = std::min(9, king.x() + 2);
01126 const int min_y = std::max(1, king.y() - 2);
01127 const int max_y = std::min(9, king.y() + 2);
01128 for (int x = min_x; x <= max_x; ++x)
01129 {
01130 for (int y = min_y; y <= max_y; ++y)
01131 {
01132 Position target(x, y);
01133 if (target.isOnBoard() && state.getPieceAt(target).isEmpty())
01134 {
01135 result += table[index<Defense>(king, target)];
01136 }
01137 }
01138 }
01139 if (Defense == BLACK)
01140 return result;
01141 else
01142 return -result;
01143 }
01144
01145 template <bool Opening>
01146 int osl::eval::ml::King25EmptyAbs<Opening>::eval(
01147 const osl::state::NumEffectState &state)
01148 {
01149 return evalOne<BLACK>(state) + evalOne<WHITE>(state);
01150 }
01151
01152 template <bool Opening>
01153 int osl::eval::ml::King25EmptyAbs<Opening>::evalWithUpdate(
01154 const osl::state::NumEffectState &state, osl::Move moved,
01155 int last_value)
01156 {
01157 if (moved.ptype() == osl::KING)
01158 {
01159 return eval(state);
01160 }
01161 const osl::Position self_king = state.getKingPosition(moved.player());
01162 const osl::Position opp_king = state.getKingPosition(alt(moved.player()));
01163 int result = last_value;
01164
01165 if (!moved.isDrop())
01166 {
01167 const Position from = moved.from();
01168 if (std::abs(self_king.x() - moved.from().x()) <= 2 &&
01169 std::abs(self_king.y() - moved.from().y()) <= 2)
01170 {
01171 result += table[index(self_king, moved.from(), moved.player())] *
01172 (moved.player() == BLACK ? 1 : -1);
01173 }
01174
01175 if (std::abs(opp_king.x() - moved.from().x()) <= 2 &&
01176 std::abs(opp_king.y() - moved.from().y()) <= 2)
01177 {
01178 result -= table[index(opp_king, moved.from(), alt(moved.player()))] *
01179 (moved.player() == BLACK ? 1 : -1);
01180 }
01181 }
01182
01183 Ptype captured = moved.capturePtype();
01184 if (captured == PTYPE_EMPTY)
01185 {
01186 const Position to = moved.to();
01187 if (std::abs(self_king.x() - moved.to().x()) <= 2 &&
01188 std::abs(self_king.y() - moved.to().y()) <= 2)
01189 {
01190 result -= table[index(self_king, moved.to(), moved.player())] *
01191 (moved.player() == BLACK ? 1 : -1);
01192 }
01193 if (std::abs(opp_king.x() - moved.to().x()) <= 2 &&
01194 std::abs(opp_king.y() - moved.to().y()) <= 2)
01195 {
01196 result += table[index(opp_king, moved.to(), alt(moved.player()))] *
01197 (moved.player() == BLACK ? 1 : -1);
01198 }
01199 }
01200 return result;
01201
01202 }
01203
01204 osl::CArray<MultiInt, 3072> osl::eval::ml::King3Pieces::table;
01205 osl::CArray<MultiInt, 15360> osl::eval::ml::King3Pieces::x_table;
01206 osl::CArray<MultiInt, 27648> osl::eval::ml::King3Pieces::y_table;
01207
01208 void osl::eval::ml::King3Pieces::setUp(const Weights &weights)
01209 {
01210 for (int i = 0; i < ONE_DIM; ++i)
01211 {
01212 for (int s=0; s<NStages; ++s)
01213 table[i][s] = weights.value(i + ONE_DIM*s);
01214 }
01215 }
01216
01217 void osl::eval::ml::King3PiecesXY::setUp(const Weights &weights)
01218 {
01219 for (int i = 0; i < X_DIM; ++i)
01220 {
01221 for (int s=0; s<NStages; ++s)
01222 King3Pieces::x_table[i][s] = weights.value(i + ONE_DIM*s);
01223 }
01224 for (int i = 0; i < Y_DIM; ++i)
01225 {
01226 for (int s=0; s<NStages; ++s)
01227 King3Pieces::y_table[i][s] = weights.value(i + ONE_DIM*s + X_DIM);
01228 }
01229 }
01230
01231 template <osl::Player King>
01232 void osl::eval::ml::King3Pieces::evalOne(const NumEffectState &state,
01233 MultiInt &result)
01234 {
01235 const Position king = state.getKingPosition<King>();
01236 const int vertical_index =
01237 index<King, VERTICAL>(
01238 state.getPieceAt(king + DirectionPlayerTraits<U, King>::offset()).ptypeO(),
01239 state.getPieceAt(king + DirectionPlayerTraits<D, King>::offset()).ptypeO());
01240 const int vertical_index_x =
01241 indexX<King, VERTICAL>(
01242 king,
01243 state.getPieceAt(king + DirectionPlayerTraits<U, King>::offset()).ptypeO(),
01244 state.getPieceAt(king + DirectionPlayerTraits<D, King>::offset()).ptypeO());
01245 const int vertical_index_y =
01246 indexY<King, VERTICAL>(
01247 king,
01248 state.getPieceAt(king + DirectionPlayerTraits<U, King>::offset()).ptypeO(),
01249 state.getPieceAt(king + DirectionPlayerTraits<D, King>::offset()).ptypeO());
01250 const int horizontal_index =
01251 index<King, HORIZONTAL>(
01252 state.getPieceAt(king + DirectionPlayerTraits<L, King>::offset()).ptypeO(),
01253 state.getPieceAt(king + DirectionPlayerTraits<R, King>::offset()).ptypeO());
01254 const int horizontal_index_x =
01255 indexX<King, HORIZONTAL>(
01256 king,
01257 state.getPieceAt(king + DirectionPlayerTraits<L, King>::offset()).ptypeO(),
01258 state.getPieceAt(king + DirectionPlayerTraits<R, King>::offset()).ptypeO());
01259 const int horizontal_index_y =
01260 indexY<King, HORIZONTAL>(
01261 king,
01262 state.getPieceAt(king + DirectionPlayerTraits<L, King>::offset()).ptypeO(),
01263 state.getPieceAt(king + DirectionPlayerTraits<R, King>::offset()).ptypeO());
01264 const int diagonal_index1 =
01265 index<King, DIAGONAL>(
01266 state.getPieceAt(king + DirectionPlayerTraits<UL, King>::offset()).ptypeO(),
01267 state.getPieceAt(king + DirectionPlayerTraits<DR, King>::offset()).ptypeO());
01268 const int diagonal_index2 =
01269 index<King, DIAGONAL>(
01270 state.getPieceAt(king + DirectionPlayerTraits<UR, King>::offset()).ptypeO(),
01271 state.getPieceAt(king + DirectionPlayerTraits<DL, King>::offset()).ptypeO());
01272 const int diagonal_index1_x =
01273 indexX<King, DIAGONAL>(
01274 king,
01275 state.getPieceAt(king + DirectionPlayerTraits<UL, King>::offset()).ptypeO(),
01276 state.getPieceAt(king + DirectionPlayerTraits<DR, King>::offset()).ptypeO());
01277 const int diagonal_index2_x=
01278 indexX<King, DIAGONAL>(
01279 king,
01280 state.getPieceAt(king + DirectionPlayerTraits<UR, King>::offset()).ptypeO(),
01281 state.getPieceAt(king + DirectionPlayerTraits<DL, King>::offset()).ptypeO());
01282 const int diagonal_index1_y =
01283 indexY<King, DIAGONAL>(
01284 king,
01285 state.getPieceAt(king + DirectionPlayerTraits<UL, King>::offset()).ptypeO(),
01286 state.getPieceAt(king + DirectionPlayerTraits<DR, King>::offset()).ptypeO());
01287 const int diagonal_index2_y =
01288 indexY<King, DIAGONAL>(
01289 king,
01290 state.getPieceAt(king + DirectionPlayerTraits<UR, King>::offset()).ptypeO(),
01291 state.getPieceAt(king + DirectionPlayerTraits<DL, King>::offset()).ptypeO());
01292 const MultiInt v = value(vertical_index, horizontal_index,
01293 diagonal_index1, diagonal_index2,
01294 vertical_index_x, horizontal_index_x,
01295 diagonal_index1_x, diagonal_index2_x,
01296 vertical_index_y , horizontal_index_y,
01297 diagonal_index1_y, diagonal_index2_y);
01298 if (King == BLACK)
01299 {
01300 result += v;
01301 }
01302 else
01303 {
01304 result -= v;
01305 }
01306 }
01307
01308 MultiInt
01309 osl::eval::ml::King3Pieces::eval(const NumEffectState &state)
01310 {
01311 MultiInt result;
01312 evalOne<BLACK>(state, result);
01313 evalOne<WHITE>(state, result);
01314 return result;
01315 }
01316
01317 MultiInt
01318 osl::eval::ml::King3Pieces::evalWithUpdate(
01319 const NumEffectState &state,
01320 Move last_move,
01321 MultiInt &last_value)
01322 {
01323 const CArray<Position,2> kings = {{
01324 state.getKingPosition(BLACK),
01325 state.getKingPosition(WHITE),
01326 }};
01327 if ((std::abs(last_move.to().x() - kings[0].x()) <= 1 &&
01328 std::abs(last_move.to().y() - kings[0].y()) <= 1) ||
01329 (std::abs(last_move.to().x() - kings[1].x()) <= 1 &&
01330 std::abs(last_move.to().y() - kings[1].y()) <= 1))
01331 return eval(state);
01332 if (!last_move.isDrop())
01333 {
01334 if ((std::abs(last_move.from().x() - kings[0].x()) <= 1 &&
01335 std::abs(last_move.from().y() - kings[0].y()) <= 1) ||
01336 (std::abs(last_move.from().x() - kings[1].x()) <= 1 &&
01337 std::abs(last_move.from().y() - kings[1].y()) <= 1))
01338 return eval(state);
01339 }
01340 return last_value;
01341 }
01342
01343
01344
01345 osl::misc::CArray<int, 17 * 128> osl::eval::ml::King25EffectAttack::table;
01346 osl::misc::CArray<MultiInt, 17 * 128> osl::eval::ml::King25EffectDefense::table;
01347
01348 osl::misc::CArray<int, 17 * 128 * 9> osl::eval::ml::King25EffectYAttack::table;
01349 osl::misc::CArray<MultiInt, 17 * 128 * 9> osl::eval::ml::King25EffectYDefense::table;
01350
01351
01352 osl::misc::CArray<MultiInt, 3240> osl::eval::ml::KingMobility::table;
01353 osl::misc::CArray<MultiInt, 3240> osl::eval::ml::KingMobility::rook_table;
01354 osl::misc::CArray<MultiInt, 3240> osl::eval::ml::KingMobility::bishop_table;
01355 osl::misc::CArray<MultiInt, 3240> osl::eval::ml::KingMobility::rook_bishop_table;
01356
01357 void osl::eval::ml::KingMobility::setUp(const Weights &weights)
01358 {
01359 static CArray<MultiInt, 3240> old_table;
01360 for (int i = 0; i < ONE_DIM; ++i)
01361 {
01362 for (int s=0; s<NStages; ++s)
01363 old_table[i][s] = weights.value(i + ONE_DIM*s);
01364 }
01365 for(int king_x=0;king_x<5;king_x++)
01366 for(int king_y=0;king_y<9;king_y++)
01367 for(int dir=0;dir<8;dir++)
01368 for(int mobility=0;mobility<9;mobility++){
01369 int oldIndex=king_x + 5 * (king_y + 9 * (dir + 8 * mobility));
01370 int newIndex=mobility+9*(dir+8*(king_y+9*king_x));
01371 for (int s=0; s<NStages; ++s)
01372 table[newIndex][s]=old_table[oldIndex][s];
01373 }
01374 }
01375
01376 void osl::eval::ml::
01377 KingMobilityWithRook::setUp(const Weights &weights)
01378 {
01379 static CArray<MultiInt, 3240> old_table;
01380 for (int i = 0; i < ONE_DIM; ++i)
01381 {
01382 for (int s=0; s<NStages; ++s)
01383 old_table[i][s] = weights.value(i + ONE_DIM*s);
01384 }
01385 for(int king_x=0;king_x<5;king_x++)
01386 for(int king_y=0;king_y<9;king_y++)
01387 for(int dir=0;dir<8;dir++)
01388 for(int mobility=0;mobility<9;mobility++){
01389 int oldIndex=king_x + 5 * (king_y + 9 * (dir + 8 * mobility));
01390 int newIndex=mobility+9*(dir+8*(king_y+9*king_x));
01391 for (int s=0; s<NStages; ++s)
01392 KingMobility::rook_table[newIndex][s]=old_table[oldIndex][s];
01393 }
01394 }
01395
01396 void osl::eval::ml::
01397 KingMobilityWithBishop::setUp(const Weights &weights)
01398 {
01399 static CArray<MultiInt, 3240> old_table;
01400 for (int i = 0; i < ONE_DIM; ++i)
01401 {
01402 for (int s=0; s<NStages; ++s)
01403 old_table[i][s] = weights.value(i + ONE_DIM*s);
01404 }
01405 for(int king_x=0;king_x<5;king_x++)
01406 for(int king_y=0;king_y<9;king_y++)
01407 for(int dir=0;dir<8;dir++)
01408 for(int mobility=0;mobility<9;mobility++){
01409 int oldIndex=king_x + 5 * (king_y + 9 * (dir + 8 * mobility));
01410 int newIndex=mobility+9*(dir+8*(king_y+9*king_x));
01411 for (int s=0; s<NStages; ++s)
01412 KingMobility::bishop_table[newIndex][s]=old_table[oldIndex][s];
01413 }
01414 for(int i=0;i<3240;i++){
01415 KingMobility::rook_bishop_table[i]=
01416 KingMobility::table[i]+KingMobility::rook_table[i]+KingMobility::bishop_table[i];
01417 KingMobility::rook_table[i]+=KingMobility::table[i];
01418 KingMobility::bishop_table[i]+=KingMobility::table[i];
01419 }
01420 }
01421
01422 template <osl::Player P>
01423 osl::MultiInt osl::eval::ml::
01424 KingMobility::evalOne(const NumEffectState &state)
01425 {
01426 MultiInt result;
01427 const Position king = state.getKingPosition<P>();
01428 const int king_x = (king.x() > 5 ? 10 - king.x() : king.x()) - 1;
01429 const int king_y = (P == BLACK ? king.y() : 10 - king.y()) - 1;
01430 int indexBase=9*8*(king_y+9*king_x);
01431 if(P==BLACK){
01432 if (state.hasPieceOnStand<ROOK>(PlayerTraits<P>::opponent))
01433 {
01434 if(state.hasPieceOnStand<BISHOP>(PlayerTraits<P>::opponent)){
01435 result =
01436 rook_bishop_table[indexBase+0*9+mobilityDir<UL>(king,state.kingMobilityAbs(P, UL))]+
01437 rook_bishop_table[indexBase+1*9+mobilityDir<U>(king,state.kingMobilityAbs(P, U))]+
01438 rook_bishop_table[indexBase+2*9+mobilityDir<UR>(king,state.kingMobilityAbs(P, UR))]+
01439 rook_bishop_table[indexBase+3*9+mobilityDir<L>(king,state.kingMobilityAbs(P, L))]+
01440 rook_bishop_table[indexBase+4*9+mobilityDir<R>(king,state.kingMobilityAbs(P, R))]+
01441 rook_bishop_table[indexBase+5*9+mobilityDir<DL>(king,state.kingMobilityAbs(P, DL))]+
01442 rook_bishop_table[indexBase+6*9+mobilityDir<D>(king,state.kingMobilityAbs(P, D))]+
01443 rook_bishop_table[indexBase+7*9+mobilityDir<DR>(king,state.kingMobilityAbs(P, DR))];
01444 }
01445 else{
01446 result =
01447 rook_table[indexBase+0*9+mobilityDir<UL>(king,state.kingMobilityAbs(P, UL))]+
01448 rook_table[indexBase+1*9+mobilityDir<U>(king,state.kingMobilityAbs(P, U))]+
01449 rook_table[indexBase+2*9+mobilityDir<UR>(king,state.kingMobilityAbs(P, UR))]+
01450 rook_table[indexBase+3*9+mobilityDir<L>(king,state.kingMobilityAbs(P, L))]+
01451 rook_table[indexBase+4*9+mobilityDir<R>(king,state.kingMobilityAbs(P, R))]+
01452 rook_table[indexBase+5*9+mobilityDir<DL>(king,state.kingMobilityAbs(P, DL))]+
01453 rook_table[indexBase+6*9+mobilityDir<D>(king,state.kingMobilityAbs(P, D))]+
01454 rook_table[indexBase+7*9+mobilityDir<DR>(king,state.kingMobilityAbs(P, DR))];
01455 }
01456 }
01457 else if(state.hasPieceOnStand<BISHOP>(PlayerTraits<P>::opponent)){
01458 result =
01459 bishop_table[indexBase+0*9+mobilityDir<UL>(king,state.kingMobilityAbs(P, UL))]+
01460 bishop_table[indexBase+1*9+mobilityDir<U>(king,state.kingMobilityAbs(P, U))]+
01461 bishop_table[indexBase+2*9+mobilityDir<UR>(king,state.kingMobilityAbs(P, UR))]+
01462 bishop_table[indexBase+3*9+mobilityDir<L>(king,state.kingMobilityAbs(P, L))]+
01463 bishop_table[indexBase+4*9+mobilityDir<R>(king,state.kingMobilityAbs(P, R))]+
01464 bishop_table[indexBase+5*9+mobilityDir<DL>(king,state.kingMobilityAbs(P, DL))]+
01465 bishop_table[indexBase+6*9+mobilityDir<D>(king,state.kingMobilityAbs(P, D))]+
01466 bishop_table[indexBase+7*9+mobilityDir<DR>(king,state.kingMobilityAbs(P, DR))];
01467 }
01468 else{
01469 result =
01470 table[indexBase+0*9+mobilityDir<UL>(king,state.kingMobilityAbs(P, UL))]+
01471 table[indexBase+1*9+mobilityDir<U>(king,state.kingMobilityAbs(P, U))]+
01472 table[indexBase+2*9+mobilityDir<UR>(king,state.kingMobilityAbs(P, UR))]+
01473 table[indexBase+3*9+mobilityDir<L>(king,state.kingMobilityAbs(P, L))]+
01474 table[indexBase+4*9+mobilityDir<R>(king,state.kingMobilityAbs(P, R))]+
01475 table[indexBase+5*9+mobilityDir<DL>(king,state.kingMobilityAbs(P, DL))]+
01476 table[indexBase+6*9+mobilityDir<D>(king,state.kingMobilityAbs(P, D))]+
01477 table[indexBase+7*9+mobilityDir<DR>(king,state.kingMobilityAbs(P, DR))];
01478 }
01479 }
01480 else{
01481 if (state.hasPieceOnStand<ROOK>(PlayerTraits<P>::opponent))
01482 {
01483 if(state.hasPieceOnStand<BISHOP>(PlayerTraits<P>::opponent)){
01484 result = -(
01485 rook_bishop_table[indexBase+7*9+mobilityDir<UL>(king,state.kingMobilityAbs(P, UL))]+
01486 rook_bishop_table[indexBase+6*9+mobilityDir<U>(king,state.kingMobilityAbs(P, U))]+
01487 rook_bishop_table[indexBase+5*9+mobilityDir<UR>(king,state.kingMobilityAbs(P, UR))]+
01488 rook_bishop_table[indexBase+4*9+mobilityDir<L>(king,state.kingMobilityAbs(P, L))]+
01489 rook_bishop_table[indexBase+3*9+mobilityDir<R>(king,state.kingMobilityAbs(P, R))]+
01490 rook_bishop_table[indexBase+2*9+mobilityDir<DL>(king,state.kingMobilityAbs(P, DL))]+
01491 rook_bishop_table[indexBase+1*9+mobilityDir<D>(king,state.kingMobilityAbs(P, D))]+
01492 rook_bishop_table[indexBase+0*9+mobilityDir<DR>(king,state.kingMobilityAbs(P, DR))]);
01493 }
01494 else{
01495 result = -(
01496 rook_table[indexBase+7*9+mobilityDir<UL>(king,state.kingMobilityAbs(P, UL))]+
01497 rook_table[indexBase+6*9+mobilityDir<U>(king,state.kingMobilityAbs(P, U))]+
01498 rook_table[indexBase+5*9+mobilityDir<UR>(king,state.kingMobilityAbs(P, UR))]+
01499 rook_table[indexBase+4*9+mobilityDir<L>(king,state.kingMobilityAbs(P, L))]+
01500 rook_table[indexBase+3*9+mobilityDir<R>(king,state.kingMobilityAbs(P, R))]+
01501 rook_table[indexBase+2*9+mobilityDir<DL>(king,state.kingMobilityAbs(P, DL))]+
01502 rook_table[indexBase+1*9+mobilityDir<D>(king,state.kingMobilityAbs(P, D))]+
01503 rook_table[indexBase+0*9+mobilityDir<DR>(king,state.kingMobilityAbs(P, DR))]);
01504 }
01505 }
01506 else if(state.hasPieceOnStand<BISHOP>(PlayerTraits<P>::opponent)){
01507 result = -(
01508 bishop_table[indexBase+7*9+mobilityDir<UL>(king,state.kingMobilityAbs(P, UL))]+
01509 bishop_table[indexBase+6*9+mobilityDir<U>(king,state.kingMobilityAbs(P, U))]+
01510 bishop_table[indexBase+5*9+mobilityDir<UR>(king,state.kingMobilityAbs(P, UR))]+
01511 bishop_table[indexBase+4*9+mobilityDir<L>(king,state.kingMobilityAbs(P, L))]+
01512 bishop_table[indexBase+3*9+mobilityDir<R>(king,state.kingMobilityAbs(P, R))]+
01513 bishop_table[indexBase+2*9+mobilityDir<DL>(king,state.kingMobilityAbs(P, DL))]+
01514 bishop_table[indexBase+1*9+mobilityDir<D>(king,state.kingMobilityAbs(P, D))]+
01515 bishop_table[indexBase+0*9+mobilityDir<DR>(king,state.kingMobilityAbs(P, DR))]);
01516 }
01517 else{
01518 result = -(
01519 table[indexBase+7*9+mobilityDir<UL>(king,state.kingMobilityAbs(P, UL))]+
01520 table[indexBase+6*9+mobilityDir<U>(king,state.kingMobilityAbs(P, U))]+
01521 table[indexBase+5*9+mobilityDir<UR>(king,state.kingMobilityAbs(P, UR))]+
01522 table[indexBase+4*9+mobilityDir<L>(king,state.kingMobilityAbs(P, L))]+
01523 table[indexBase+3*9+mobilityDir<R>(king,state.kingMobilityAbs(P, R))]+
01524 table[indexBase+2*9+mobilityDir<DL>(king,state.kingMobilityAbs(P, DL))]+
01525 table[indexBase+1*9+mobilityDir<D>(king,state.kingMobilityAbs(P, D))]+
01526 table[indexBase+0*9+mobilityDir<DR>(king,state.kingMobilityAbs(P, DR))]);
01527 }
01528 }
01529 return result;
01530 }
01531
01532 osl::MultiInt osl::eval::ml::
01533 KingMobility::eval(const NumEffectState &state)
01534 {
01535 MultiInt result = evalOne<BLACK>(state) + evalOne<WHITE>(state);
01536 return result;
01537 }
01538
01539
01540 osl::misc::CArray<MultiInt, 45*33> osl::eval::ml::KingMobilitySum::table;
01541
01542 void osl::eval::ml::KingMobilitySum::setUp(const Weights &weights)
01543 {
01544 CArray<MultiInt, 2925> old_table;
01545 for (int i = 0; i < ONE_DIM; ++i)
01546 {
01547 for (int s=0; s<NStages; ++s)
01548 old_table[i][s] = weights.value(i + ONE_DIM*s);
01549 }
01550 for(int king_x=0;king_x<5;king_x++)
01551 for(int king_y=0;king_y<9;king_y++)
01552 for(int mobility=0;mobility<=32;mobility++){
01553 int oldIndex=king_x+5*(king_y+9*(mobility+8));
01554 int newIndex=mobility+33*(king_y+9*king_x);
01555 for (int s=0; s<NStages; ++s)
01556 table[newIndex]=old_table[oldIndex];
01557 }
01558 }
01559
01560 template <osl::Player P>
01561 osl::MultiInt osl::eval::ml::
01562 KingMobilitySum::evalOne(const NumEffectState &state)
01563 {
01564 MultiInt result;
01565 const Position king = state.getKingPosition<P>();
01566 int sum=state.kingMobilityAbs(P, UL).y()+state.kingMobilityAbs(P, U).y()+
01567 state.kingMobilityAbs(P, UR).y()+state.kingMobilityAbs(P, R).x()-
01568 state.kingMobilityAbs(P, DL).y()-state.kingMobilityAbs(P, D).y()-
01569 state.kingMobilityAbs(P, DR).y()-state.kingMobilityAbs(P, L).x();
01570 const int king_x = (king.x() > 5 ? 10 - king.x() : king.x()) - 1;
01571 const int king_y = (P == BLACK ? king.y() : 10 - king.y()) - 1;
01572 int mobility=sum-8;
01573 result = table[mobility+33*(king_y+9*king_x)];
01574 if (P == BLACK)
01575 {
01576 return result;
01577 }
01578 else
01579 {
01580 return -result;
01581 }
01582 }
01583
01584 osl::MultiInt osl::eval::ml::
01585 KingMobilitySum::eval(const NumEffectState &state)
01586 {
01587 MultiInt result = evalOne<BLACK>(state) + evalOne<WHITE>(state);
01588 return result;
01589 }
01590
01591
01592 osl::misc::CArray<MultiInt, 8192>
01593 osl::eval::ml::King25BothSide::table;
01594 osl::misc::CArray<MultiInt, 40960>
01595 osl::eval::ml::King25BothSide::x_table;
01596 osl::misc::CArray<MultiInt, 73728>
01597 osl::eval::ml::King25BothSide::y_table;
01598
01599 void osl::eval::ml::King25BothSide::setUp(const Weights &weights)
01600 {
01601 for (int i = 0; i < ONE_DIM; ++i)
01602 {
01603 for (int s=0; s<NStages; ++s)
01604 table[i][s] = weights.value(i + ONE_DIM*s);
01605 }
01606 }
01607
01608 void osl::eval::ml::King25BothSideX::setUp(const Weights &weights)
01609 {
01610 for (int i = 0; i < ONE_DIM; ++i)
01611 {
01612 for (int s=0; s<NStages; ++s)
01613 King25BothSide::x_table[i][s] = weights.value(i + ONE_DIM*s);
01614 }
01615 }
01616
01617 void osl::eval::ml::King25BothSideY::setUp(const Weights &weights)
01618 {
01619 for (int i = 0; i < ONE_DIM; ++i)
01620 {
01621 for (int s=0; s<NStages; ++s)
01622 King25BothSide::y_table[i][s] = weights.value(i + ONE_DIM*s);
01623 }
01624 for(int king_y=1;king_y<=9;king_y++)
01625 for(int effect1=0;effect1<32;effect1++)
01626 for(int effect2=0;effect2<32;effect2++)
01627 for(int i=0;i<8;i++){
01628 int index0=effect1 + 32 * (effect2 + 32 * i);
01629 int index1=king_y - 1 + 9 *(effect1 + 32 * (effect2 + 32 * i));
01630 King25BothSide::y_table[index1] += King25BothSide::table[index0];
01631 }
01632 }
01633
01634 template<osl::Player P>
01635 osl::MultiInt osl::eval::ml::
01636 King25BothSide::evalOne(const NumEffectState &state,
01637 const CArray<int, 5> &effects)
01638 {
01639 const Position king=state.getKingPosition<P>();
01640 const int king_y = (P==BLACK ? king.y() : 10 - king.y());
01641 const int king_x = (king.x() >= 6 ? 10 - king.x() : king.x());
01642 if ((P== BLACK && king.x() > 5) || (P==WHITE && king.x() < 5)){
01643 return
01644 x_table[indexX(king_x,effects[2],effects[0],(2*3)+1)]+
01645 y_table[indexY(king_y,effects[0],effects[2],(0*3)+0)]+
01646 x_table[indexX(king_x,effects[3],effects[0],(1*3)+2)]+
01647 y_table[indexY(king_y,effects[0],effects[3],(0*3)+1)]+
01648 x_table[indexX(king_x,effects[4],effects[0],(0*3)+2)]+
01649 y_table[indexY(king_y,effects[0],effects[4],(0*3)+2)]+
01650 x_table[indexX(king_x,effects[2],effects[1],(2*3)+0)]+
01651 y_table[indexY(king_y,effects[1],effects[2],(1*3)+0)]+
01652 x_table[indexX(king_x,effects[3],effects[1],(1*3)+1)]+
01653 y_table[indexY(king_y,effects[1],effects[3],(1*3)+1)]+
01654 x_table[indexX(king_x,effects[4],effects[1],(0*3)+1)]+
01655 y_table[indexY(king_y,effects[1],effects[4],(1*3)+2)]+
01656 x_table[indexX(king_x,effects[3],effects[2],(1*3)+0)]+
01657 y_table[indexY(king_y,effects[2],effects[3],(2*3)+0)]+
01658 x_table[indexX(king_x,effects[4],effects[2],(0*3)+0)]+
01659 y_table[indexY(king_y,effects[2],effects[4],(2*3)+1)];
01660 }
01661 else{
01662 return
01663 x_table[indexX(king_x,effects[0],effects[2],(0*3)+0)]+
01664 y_table[indexY(king_y,effects[0],effects[2],(0*3)+0)]+
01665 x_table[indexX(king_x,effects[0],effects[3],(0*3)+1)]+
01666 y_table[indexY(king_y,effects[0],effects[3],(0*3)+1)]+
01667 x_table[indexX(king_x,effects[0],effects[4],(0*3)+2)]+
01668 y_table[indexY(king_y,effects[0],effects[4],(0*3)+2)]+
01669 x_table[indexX(king_x,effects[1],effects[2],(1*3)+0)]+
01670 y_table[indexY(king_y,effects[1],effects[2],(1*3)+0)]+
01671 x_table[indexX(king_x,effects[1],effects[3],(1*3)+1)]+
01672 y_table[indexY(king_y,effects[1],effects[3],(1*3)+1)]+
01673 x_table[indexX(king_x,effects[1],effects[4],(1*3)+2)]+
01674 y_table[indexY(king_y,effects[1],effects[4],(1*3)+2)]+
01675 x_table[indexX(king_x,effects[2],effects[3],(2*3)+0)]+
01676 y_table[indexY(king_y,effects[2],effects[3],(2*3)+0)]+
01677 x_table[indexX(king_x,effects[2],effects[4],(2*3)+1)]+
01678 y_table[indexY(king_y,effects[2],effects[4],(2*3)+1)];
01679 }
01680 }
01681
01682 osl::MultiInt osl::eval::ml::
01683 King25BothSide::eval(const NumEffectState &state,
01684 const CArray<int, 5> &black,
01685 const CArray<int, 5> &white)
01686 {
01687 return evalOne<BLACK>(state,black)-evalOne<WHITE>(state,white);
01688 }
01689
01690 osl::misc::CArray<MultiInt, 2400>
01691 osl::eval::ml::King25Effect3::table;
01692 osl::misc::CArray<MultiInt, 21600>
01693 osl::eval::ml::King25Effect3::y_table;
01694
01695 void osl::eval::ml::King25Effect3::setUp(const Weights &weights)
01696 {
01697 for (int i = 0; i < ONE_DIM; ++i)
01698 {
01699 for (int s=0; s<NStages; ++s)
01700 table[i][s] = weights.value(i + ONE_DIM*s);
01701 }
01702 }
01703
01704 void osl::eval::ml::King25Effect3Y::setUp(const Weights &weights)
01705 {
01706 for (int i = 0; i < ONE_DIM; ++i)
01707 {
01708 for (int s=0; s<NStages; ++s)
01709 King25Effect3::y_table[i][s] = weights.value(i + ONE_DIM*s);
01710 }
01711 }
01712
01713 template <osl::Player Attack>
01714 osl::MultiInt osl::eval::ml::
01715 King25Effect3::evalOne(const NumEffectState &state,
01716 PieceMask king25)
01717 {
01718 king25 = king25 & state.getOnBoardMask(Attack);
01719 const PieceMask promoted_mask = (king25 & state.promotedPieces());
01720 const bool with_knight =
01721 (king25 & ~state.promotedPieces()).template selectBit<KNIGHT>().any();
01722 king25.clearBit<KNIGHT>();
01723 king25.clearBit<LANCE>();
01724 king25.clearBit<PAWN>();
01725 king25 = king25 | promoted_mask;
01726 const int piece_count = std::min(9, king25.countBit());
01727 const int stand_count = std::min(9,
01728 state.countPiecesOnStand<ROOK>(Attack) +
01729 state.countPiecesOnStand<BISHOP>(Attack) +
01730 state.countPiecesOnStand<GOLD>(Attack) +
01731 state.countPiecesOnStand<SILVER>(Attack));
01732 const bool stand_with_knight = state.hasPieceOnStand<KNIGHT>(Attack);
01733 const Player Defense = PlayerTraits<Attack>::opponent;
01734 PieceMask attacked =
01735 state.effectedMask(Attack) & state.getOnBoardMask(Defense);
01736 attacked.clearBit<KNIGHT>();
01737 attacked.clearBit<LANCE>();
01738 attacked.clearBit<PAWN>();
01739 PieceMask attacking;
01740 while (attacked.any())
01741 {
01742 const Piece piece = state.getPieceOf(attacked.takeOneBit());
01743 attacking = attacking | state.getEffect(piece.position());
01744 }
01745 attacking = (attacking & state.getOnBoardMask(Attack) & ~king25);
01746 const int attacked_count = std::min(5, attacking.countBit());
01747 if (Attack == BLACK)
01748 {
01749 return table[index(piece_count, with_knight,
01750 stand_count, stand_with_knight, attacked_count)] +
01751 y_table[indexY(piece_count, with_knight,
01752 stand_count, stand_with_knight, attacked_count,
01753 state.getKingPosition<WHITE>().y())];
01754 }
01755 else
01756 {
01757 return -(table[index(piece_count, with_knight,
01758 stand_count, stand_with_knight, attacked_count)] +
01759 y_table[indexY(piece_count, with_knight,
01760 stand_count, stand_with_knight, attacked_count,
01761 10 - state.getKingPosition<BLACK>().y())]);
01762 }
01763 }
01764
01765 osl::MultiInt osl::eval::ml::
01766 King25Effect3::eval(const NumEffectState &state,
01767 const CArray<PieceMask, 2> &king25_mask)
01768 {
01769 return evalOne<BLACK>(state, king25_mask[WHITE]) +
01770 evalOne<WHITE>(state, king25_mask[BLACK]);
01771 }
01772
01773
01774 osl::misc::CArray<MultiInt, 4096>
01775 osl::eval::ml::King25Mobility::table;
01776 osl::misc::CArray<MultiInt, 20480>
01777 osl::eval::ml::King25Mobility::x_table;
01778 osl::misc::CArray<MultiInt, 36864>
01779 osl::eval::ml::King25Mobility::y_table;
01780
01781 void osl::eval::ml::King25Mobility::setUp(const Weights &weights)
01782 {
01783 for (int i = 0; i < ONE_DIM; ++i)
01784 {
01785 for (int s=0; s<NStages; ++s)
01786 table[i][s] = weights.value(i + ONE_DIM*s);
01787 }
01788 }
01789
01790 void osl::eval::ml::King25MobilityX::setUp(const Weights &weights)
01791 {
01792 for (int i = 0; i < ONE_DIM; ++i)
01793 {
01794 for (int s=0; s<NStages; ++s)
01795 King25Mobility::x_table[i][s] = weights.value(i + ONE_DIM*s);
01796 }
01797 }
01798
01799 void osl::eval::ml::King25MobilityY::setUp(const Weights &weights)
01800 {
01801 for (int i = 0; i < ONE_DIM; ++i)
01802 {
01803 for (int s=0; s<NStages; ++s)
01804 King25Mobility::y_table[i][s] = weights.value(i + ONE_DIM*s);
01805 }
01806 }
01807
01808 osl::MultiInt osl::eval::ml::
01809 King25Mobility::eval(const NumEffectState &state,
01810 const CArray<int, 5> &black,
01811 const CArray<int, 5> &white)
01812 {
01813 const CArray<Position,2> kings = {{
01814 state.getKingPosition<BLACK>(),
01815 state.getKingPosition<WHITE>(),
01816 }};
01817 MultiInt result;
01818 for (size_t i = 1; i < black.size(); ++i)
01819 {
01820 result += (table[index(black[i - 1], black[i], i - 1)] +
01821 x_table[indexX<BLACK>(kings[BLACK],
01822 black[i - 1], black[i], i - 1)] +
01823 y_table[indexY<BLACK>(kings[BLACK],
01824 black[i - 1], black[i], i - 1)]);
01825 result -= (table[index(white[i - 1], white[i], i - 1)] +
01826 x_table[indexX<WHITE>(kings[WHITE],
01827 white[i - 1], white[i], i - 1)] +
01828 y_table[indexY<WHITE>(kings[WHITE],
01829 white[i - 1], white[i], i - 1)]);
01830 }
01831 return result;
01832 }
01833
01834
01835 osl::misc::CArray<MultiInt, 100>
01836 osl::eval::ml::King25EffectCountCombination::table;
01837 osl::misc::CArray<MultiInt, 900>
01838 osl::eval::ml::King25EffectCountCombination::y_table;
01839
01840 void osl::eval::ml::King25EffectCountCombination::setUp(const Weights &weights)
01841 {
01842 for (int i = 0; i < ONE_DIM; ++i)
01843 {
01844 for (int s=0; s<NStages; ++s)
01845 table[i][s] = weights.value(i + ONE_DIM*s);
01846 }
01847 }
01848
01849 void osl::eval::ml::King25EffectCountCombinationY::setUp(const Weights &weights)
01850 {
01851 for (int i = 0; i < ONE_DIM; ++i)
01852 {
01853 for (int s=0; s<NStages; ++s)
01854 King25EffectCountCombination::y_table[i][s] = weights.value(i + ONE_DIM*s);
01855 }
01856 }
01857
01858 template <osl::Player Attack>
01859 osl::MultiInt osl::eval::ml::
01860 King25EffectCountCombination::evalOne(const NumEffectState &state,
01861 PieceMask king25)
01862 {
01863 const Player Defense = PlayerTraits<Attack>::opponent;
01864 PieceMask attack = king25 & state.getOnBoardMask(Attack);
01865 PieceMask defense =
01866 king25 & state.getOnBoardMask(Defense);
01867 const PieceMask attack_promoted_mask = (attack & state.promotedPieces());
01868 const PieceMask defense_promoted_mask = (defense & state.promotedPieces());
01869 attack.clearBit<KNIGHT>();
01870 attack.clearBit<LANCE>();
01871 attack.clearBit<PAWN>();
01872 attack = attack | attack_promoted_mask;
01873 defense.clearBit<KNIGHT>();
01874 defense.clearBit<LANCE>();
01875 defense.clearBit<PAWN>();
01876 defense = defense | defense_promoted_mask;
01877 const int attack_count = std::min(9,
01878 attack.countBit() +
01879 state.countPiecesOnStand<ROOK>(Attack) +
01880 state.countPiecesOnStand<BISHOP>(Attack) +
01881 state.countPiecesOnStand<GOLD>(Attack) +
01882 state.countPiecesOnStand<SILVER>(Attack));
01883 const int defense_count = std::min(9,
01884 defense.countBit() +
01885 state.countPiecesOnStand<ROOK>(Defense) +
01886 state.countPiecesOnStand<BISHOP>(Defense) +
01887 state.countPiecesOnStand<GOLD>(Defense) +
01888 state.countPiecesOnStand<SILVER>(Defense));
01889 const int y = (Attack == BLACK ? state.getKingPosition<Defense>().y() :
01890 10 - state.getKingPosition<Defense>().y());
01891 MultiInt result = table[attack_count + 10 * defense_count] +
01892 y_table[y - 1 + 9 * (attack_count + 10 * defense_count)];
01893 if (Attack == BLACK)
01894 return result;
01895 else
01896 return -result;
01897 }
01898
01899 osl::MultiInt osl::eval::ml::
01900 King25EffectCountCombination::eval(const NumEffectState &state,
01901 const CArray<PieceMask, 2> &king25_mask)
01902 {
01903 return evalOne<BLACK>(state, king25_mask[WHITE]) +
01904 evalOne<WHITE>(state, king25_mask[BLACK]);
01905 }
01906
01907
01908 namespace osl
01909 {
01910 namespace eval
01911 {
01912 namespace ml
01913 {
01914 template MultiInt KingPieceRelative::
01915 evalWithUpdate<BLACK>(const NumEffectState &state,
01916 Move moved, MultiInt const& last_value);
01917 template MultiInt KingPieceRelative::
01918 evalWithUpdate<WHITE>(const NumEffectState &state,
01919 Move moved, MultiInt const& last_value);
01920
01921 template class King25EffectEach<0>;
01922 template class King25EffectEach<1>;
01923 template class King25EffectEach<2>;
01924 template class King25EmptyAbs<true>;
01925 template class King25EmptyAbs<false>;
01926
01927 template void King25EffectBoth::countEffectAndPiecesBoth<BLACK>(const NumEffectState&, PieceMask&, PieceMask&, int&, int&, int&, int&, int&, CArray<int, 5>&, CArray<int, 5>&);
01928 template void King25EffectBoth::countEffectAndPiecesBoth<WHITE>(const NumEffectState&, PieceMask&, PieceMask&, int&, int&, int&, int&, int&, CArray<int, 5>&, CArray<int, 5>&);
01929 }
01930 }
01931 }
01932
01933
01934
01935