4 #ifndef EVAL_ML_MINORPIECE_H
5 #define EVAL_ML_MINORPIECE_H
55 template <Player Owner>
58 assert(Owner == king.
owner());
59 const int king_y = (Owner ==
BLACK ?
61 return std::abs(x - king.
square().
x()) * 9 + king_y - 1;
65 return std::abs(x - king.
x());
67 template <
bool Attack>
70 const int king_x = king.
square().
x();
71 const int target_x = (king_x > 5 ? 10 - king_x : king_x);
72 if (king_x >= 6 || (king.
owner() ==
WHITE && king_x == 5))
74 return (x - 1) * 5 + target_x - 1 + (Attack ? 0 : 45);
78 int attack_index,
int defense_index,
79 int attack_index_y,
int defense_index_y,
80 int attack_index_x,
int defense_index_x)
90 int attack_index,
int defense_index,
91 int attack_index_y,
int defense_index_y,
92 int attack_index_x,
int defense_index_x)
111 !state.hasPieceOnStand<
PAWN>(P)) ||
114 state.countPiecesOnStand<
PAWN>(P) == 1))
120 const CArray<Square, 2> king_bw = {{ state.kingSquare<
BLACK>(), state.kingSquare<
WHITE>() }};
122 const CArray<Piece, 2> king_piece = {{ state.kingPiece(P),
123 state.kingPiece(
alt(P)) }};
128 const int attack_index =
index(kings[1], moved.
to().
x());
129 const int defense_index =
index(kings[0], moved.
to().
x());
130 const int attack_index_x =
131 indexX<true>(king_piece[1], moved.
to().
x());
132 const int defense_index_x =
133 indexX<false>(king_piece[0], moved.
to().
x());
135 const int attack_index_y = indexY<altP>(king_piece[1], moved.
to().
x());
136 const int defense_index_y = indexY<P>(king_piece[0], moved.
to().
x());
137 const int index_x = (moved.
to().
x() > 5 ? 10 -
138 moved.
to().
x() : moved.
to().
x());
139 if (state.isPawnMaskSet<altP>(moved.
to().
x()))
207 result -=
value(attack_index, defense_index, attack_index_y,
208 defense_index_y, attack_index_x, defense_index_x);
209 if (state.hasPieceOnStand<
PAWN>(P))
211 result -=
standValue(attack_index, defense_index, attack_index_y,
212 defense_index_y, attack_index_x, defense_index_x);
217 result +=
value(attack_index, defense_index, attack_index_y,
218 defense_index_y, attack_index_x, defense_index_x);
219 if (state.hasPieceOnStand<
PAWN>(P))
221 result +=
standValue(attack_index, defense_index, attack_index_y,
222 defense_index_y, attack_index_x, defense_index_x);
228 const int attack_index =
index(kings[1], moved.
to().
x());
229 const int defense_index =
index(kings[0], moved.
to().
x());
230 const int attack_index_x =
231 indexX<true>(king_piece[1], moved.
to().
x());
232 const int defense_index_x =
233 indexX<false>(king_piece[0], moved.
to().
x());
234 const int attack_index_y = indexY<altP>(king_piece[1], moved.
to().
x());
235 const int defense_index_y = indexY<P>(king_piece[0], moved.
to().
x());
238 result +=
value(attack_index, defense_index, attack_index_y,
239 defense_index_y, attack_index_x, defense_index_x);
240 if (state.hasPieceOnStand<
PAWN>(P))
242 result +=
standValue(attack_index, defense_index, attack_index_y,
243 defense_index_y, attack_index_x, defense_index_x);
248 result -=
value(attack_index, defense_index, attack_index_y,
249 defense_index_y, attack_index_x, defense_index_x);
250 if (state.hasPieceOnStand<
PAWN>(P))
252 result -=
standValue(attack_index, defense_index, attack_index_y,
253 defense_index_y, attack_index_x, defense_index_x);
256 const int index_x = (moved.
to().
x() > 5 ? 10 -
257 moved.
to().
x() : moved.
to().
x());
258 if (state.isPawnMaskSet<altP>(moved.
to().
x()))
297 if (captured ==
PAWN)
335 if (captured ==
PAWN)
337 const int attack_index =
index(kings[0], moved.
to().
x());
338 const int defense_index =
index(kings[1], moved.
to().
x());
339 const int attack_index_x =
340 indexX<true>(king_piece[0], moved.
to().
x());
341 const int defense_index_x =
342 indexX<false>(king_piece[1], moved.
to().
x());
343 const int attack_index_y = indexY<P>(king_piece[0], moved.
to().
x());
344 const int defense_index_y = indexY<altP>(king_piece[1], moved.
to().
x());
347 result -=
value(attack_index, defense_index, attack_index_y,
348 defense_index_y, attack_index_x, defense_index_x);
349 if (state.hasPieceOnStand<
PAWN>(
alt(P)))
351 result -=
standValue(attack_index, defense_index, attack_index_y,
352 defense_index_y, attack_index_x, defense_index_x);
357 result +=
value(attack_index, defense_index, attack_index_y,
358 defense_index_y, attack_index_x, defense_index_x);
361 result +=
standValue(attack_index, defense_index, attack_index_y,
362 defense_index_y, attack_index_x, defense_index_x);
368 (moved.
to().
x() > 5 ? 10 - moved.
to().
x() : moved.
to().
x());
369 if (state.isPawnMaskSet<P>(moved.
to().
x()))
491 static MultiInt eval(
const NumEffectState &state,
int black_pawn_count)
493 if (black_pawn_count > 9 && !state.hasPieceOnStand<
PAWN>(
WHITE))
495 else if (black_pawn_count < 9 && !state.hasPieceOnStand<
PAWN>(
BLACK))
506 return (P ==
BLACK ? (pos.
y() - 1) : (9 - pos.
y()));
523 template <osl::Player P>
550 return (P ==
BLACK ? (pos.
y() - 1) : (9 - pos.
y()));
553 static bool canRetreat(
const NumEffectState &state,
558 const CArray<Square, 2> &kings)
561 if (!canRetreat<P>(state,silver))
569 const Piece up_piece = state.pieceAt(up);
571 (state.hasEffectByPtype<
PAWN>(
alt(P), up) ||
575 std::abs(kings[P].x() - silver.
square().
x());
576 const int y_diff = (P ==
BLACK ?
577 silver.
square().
y() - kings[P].y() :
578 kings[P].y() - silver.
square().
y());
579 result +=
head_table[x_diff + 9 * (y_diff + 8)];
610 return (P ==
BLACK ? (pos.
y() - 1) : (9 - pos.
y()));
614 return (pos.
x() > 5 ? 9 - pos.
x() : pos.
x() - 1);
619 return (P ==
BLACK ? (pos.
y() - 1) : (9 - pos.
y())) + 5;
622 static bool canRetreat(
const NumEffectState &state,
632 state.pieceAt(r).isOnBoardByOwner(gold.
owner()) ||
633 state.hasEffectAt(
alt(gold.
owner()), r)) &&
635 state.pieceAt(l).isOnBoardByOwner(gold.
owner()) ||
636 state.hasEffectAt(
alt(gold.
owner()), l)))
645 const CArray<Square, 2> &kings)
647 assert(P==gold.
owner());
649 if (!canRetreat<P>(state, gold))
653 if (!canMoveToSide<P>(state, gold))
660 if ((state.pieceAt(uul).isEmpty() && !state.hasEffectAt(P, uul))
661 || (state.pieceAt(uur).isEmpty() && !state.hasEffectAt(P, uur)))
663 assert(state.kingSquare(gold.
owner()) == kings[gold.
owner()]);
664 const Square king = kings[P];
665 const int x_diff = std::abs(king.x() - gold.
square().
x());
666 const int y_diff = (P ==
BLACK ?
707 return (P ==
BLACK ? (pos.
y() - 1) : (9 - pos.
y()));
710 static bool cantAdvance(
const NumEffectState &state,
724 if (black_major_count == 4)
726 else if (black_major_count == 0)
752 const int y = (player ==
BLACK ? pos.
y() : 10 - pos.
y()) - 1;
753 return ptype * 9 + y;
774 const int x = (pos.
x() > 5 ? 10 - pos.
x() : pos.
x()) - 1;
775 return ptype * 5 + x;
786 template <Player Defense>
789 const Square king = state.kingSquare<Defense>();
797 const Piece p = state.pieceAt(ul);
798 if (!state.hasEffectAt<Defense>(ul) &&
801 state.hasEffectByPtypeStrict<
KNIGHT>(offense, ul))))
806 const Piece p = state.pieceAt(ur);
807 if (!state.hasEffectAt<Defense>(ur) &&
810 state.hasEffectByPtypeStrict<
KNIGHT>(offense, ur))))
818 template <Player King>
821 return (King ==
BLACK ? y - 1 : 9 - y) ;
863 const CArray2d<int, 2, 9> &pawns,
877 const int y_index = (P ==
BLACK ? y - 1 : 9 - y);
878 return index(P, up, up_up) + 1024 * y_index;
880 static CArray<MultiInt, 1024>
table;
892 const NumEffectState &state,
896 static void adjust(
int index,
int index_attack,
int index_defense,
900 static void evalOne(
const NumEffectState &state,
901 const PieceMask promoted,
903 template <
bool attack, Player owner>
906 const int y = (owner ==
BLACK ? king.
y() : 10 - king.
y());
907 return x_diff + (y - 1) * 9 + (attack ? 0 : 81);
921 const NumEffectState &state,
923 const CArray<PieceMask, 2> &effected_mask,
926 static void adjust(
int black_turn_king_attack,
927 int black_turn_king_defense,
928 int white_turn_king_attack,
929 int white_turn_king_defense,
932 static int index(
bool same_turn,
bool has_support,
Ptype ptype)
937 template <
bool Attack>
941 const int x_diff = std::abs(position.
x() - king.
x());
942 const int y_diff = (owner ==
BLACK ?
943 position.
y() - king.
y() :
944 king.
y() - position.
y());
945 return ((ptype + (same_turn ? 0 :
PTYPE_SIZE) +
946 (has_support ? 0 : PTYPE_SIZE * 2)) * 9 + x_diff) * 17 +
947 y_diff + 8 + (Attack ? 0 : 9792);
949 template <
bool Attack>
953 return indexK<Attack>(king, same_turn, has_support,
958 template <Player Attacked>
960 const NumEffectState &state,
961 const CArray<PieceMask, 2> &effected_mask,
962 const CArray<PieceMask, 2> &new_mask,
963 int moved_piece_number,
966 CArray<Square, 2> kings = {{ state.kingSquare<
BLACK>(),
967 state.kingSquare<
WHITE>() }};
969 PieceMask black_old = (~effected_mask[
alt(Attacked)]) & new_mask[
alt(Attacked)] & state.piecesOnBoard(Attacked);
970 black_old.reset(moved_piece_number);
971 while (black_old.any())
973 const Piece piece = state.pieceOf(black_old.takeOneBit());
974 const bool has_support =
975 new_mask[Attacked].test(piece.
number());
976 const int index_king_black_turn_attack =
977 indexK<true>(kings[
alt(Attacked)], Attacked ==
BLACK, has_support, piece);
978 const int index_king_white_turn_attack =
979 indexK<true>(kings[
alt(Attacked)], Attacked ==
WHITE, has_support, piece);
980 const int index_king_black_turn_defense =
981 indexK<false>(kings[Attacked], Attacked ==
BLACK, has_support, piece);
982 const int index_king_white_turn_defense =
983 indexK<false>(kings[Attacked], Attacked ==
WHITE, has_support, piece);
985 index_king_black_turn_attack, index_king_black_turn_defense,
986 index_king_white_turn_attack, index_king_white_turn_defense,
991 PieceMask black_new = effected_mask[
alt(Attacked)] & (~new_mask[
alt(Attacked)]) & state.piecesOnBoard(Attacked);
992 black_new.reset(moved_piece_number);
993 while (black_new.any())
995 const Piece piece = state.pieceOf(black_new.takeOneBit());
996 const bool has_support =
997 effected_mask[Attacked].test(piece.
number());
998 const int index_king_black_turn_attack =
999 indexK<true>(kings[
alt(Attacked)], Attacked ==
BLACK, has_support, piece);
1000 const int index_king_white_turn_attack =
1001 indexK<true>(kings[
alt(Attacked)], Attacked ==
WHITE, has_support, piece);
1002 const int index_king_black_turn_defense =
1003 indexK<false>(kings[Attacked], Attacked ==
BLACK, has_support, piece);
1004 const int index_king_white_turn_defense =
1005 indexK<false>(kings[Attacked], Attacked ==
WHITE, has_support, piece);
1007 index_king_black_turn_attack, index_king_black_turn_defense,
1008 index_king_white_turn_attack, index_king_white_turn_defense,
1012 PieceMask black_self_old = effected_mask[
alt(Attacked)] & new_mask[
alt(Attacked)] &
1013 effected_mask[Attacked] & (~new_mask[Attacked]) & state.piecesOnBoard(Attacked);
1014 black_self_old.reset(moved_piece_number);
1015 while (black_self_old.any())
1017 const Piece piece = state.pieceOf(black_self_old.takeOneBit());
1018 const int index_king_black_turn_attack =
1019 indexK<true>(kings[
alt(Attacked)], Attacked ==
BLACK,
false, piece);
1020 const int index_king_white_turn_attack =
1021 indexK<true>(kings[
alt(Attacked)], Attacked ==
WHITE,
false, piece);
1022 const int index_king_black_turn_defense =
1023 indexK<false>(kings[Attacked], Attacked ==
BLACK,
false, piece);
1024 const int index_king_white_turn_defense =
1025 indexK<false>(kings[Attacked], Attacked ==
WHITE,
false, piece);
1026 const int index_king_black_turn_attack_old =
1027 indexK<true>(kings[
alt(Attacked)], Attacked ==
BLACK,
true, piece);
1028 const int index_king_white_turn_attack_old =
1029 indexK<true>(kings[
alt(Attacked)], Attacked ==
WHITE,
true, piece);
1030 const int index_king_black_turn_defense_old =
1031 indexK<false>(kings[Attacked], Attacked ==
BLACK,
true, piece);
1032 const int index_king_white_turn_defense_old =
1033 indexK<false>(kings[Attacked], Attacked ==
WHITE,
true, piece);
1035 index_king_black_turn_attack_old, index_king_black_turn_defense_old,
1036 index_king_white_turn_attack_old, index_king_white_turn_defense_old,
1039 index_king_black_turn_attack, index_king_black_turn_defense,
1040 index_king_white_turn_attack, index_king_white_turn_defense,
1044 PieceMask black_self_new = effected_mask[
alt(Attacked)] & new_mask[
alt(Attacked)] &
1045 (~effected_mask[Attacked]) & new_mask[Attacked] & state.piecesOnBoard(Attacked);
1046 black_self_new.reset(moved_piece_number);
1047 while (black_self_new.any())
1049 const Piece piece = state.pieceOf(black_self_new.takeOneBit());
1050 const int index_king_black_turn_attack =
1051 indexK<true>(kings[
alt(Attacked)], Attacked ==
BLACK,
true, piece);
1052 const int index_king_white_turn_attack =
1053 indexK<true>(kings[
alt(Attacked)], Attacked ==
WHITE,
true, piece);
1054 const int index_king_black_turn_defense =
1055 indexK<false>(kings[Attacked], Attacked ==
BLACK,
true, piece);
1056 const int index_king_white_turn_defense =
1057 indexK<false>(kings[Attacked], Attacked ==
WHITE,
true, piece);
1058 const int index_king_black_turn_attack_old =
1059 indexK<true>(kings[
alt(Attacked)], Attacked ==
BLACK,
false, piece);
1060 const int index_king_white_turn_attack_old =
1061 indexK<true>(kings[
alt(Attacked)], Attacked ==
WHITE,
false, piece);
1062 const int index_king_black_turn_defense_old =
1063 indexK<false>(kings[Attacked], Attacked ==
BLACK,
false, piece);
1064 const int index_king_white_turn_defense_old =
1065 indexK<false>(kings[Attacked], Attacked ==
WHITE,
false, piece);
1068 index_king_black_turn_attack_old, index_king_black_turn_defense_old,
1069 index_king_white_turn_attack_old, index_king_white_turn_defense_old,
1072 index_king_black_turn_attack, index_king_black_turn_defense,
1073 index_king_white_turn_attack, index_king_white_turn_defense,
1107 static void eval(
const NumEffectState &state,
1108 CArray<PieceMask, 40> &attacked_mask,
1112 const NumEffectState &state,
1114 const CArray<PieceMask, 2> &effected_mask,
1115 CArray<PieceMask, 40> &attacked_mask,
1121 return (ptype + (same_turn ? 0 :
PTYPE_SIZE) +
1122 (has_support ? 0 : PTYPE_SIZE * 2)) * 16 + attack_ptype;
1136 template <
bool Plus>
1139 const Ptype attack_ptype,
1143 const int index_black_turn =
index(
BLACK == player, with_support,
1144 ptype, attack_ptype);
1145 const int index_white_turn =
index(
WHITE == player, with_support,
1146 ptype, attack_ptype);
1148 adjust<1>(index_black_turn, index_white_turn,
result);
1150 adjust<-1>(index_black_turn, index_white_turn,
result);
1156 int captured_number,
1157 const CArray<PieceMask, 2> &effected_mask,
1158 const CArray<PieceMask, 2> &new_mask,
1159 CArray<PieceMask, 40> &attacked_mask,
1163 PieceMask
old = (~effected_mask[
alt(P)]) & new_mask[
alt(P)] & state.piecesOnBoard(P);
1167 const Piece piece = state.pieceOf(old.takeOneBit());
1168 const bool has_support =
1169 new_mask[P].test(piece.
number());
1170 PieceMask attacking =
1171 state.effectSetAt(piece.
square()) &
1172 state.piecesOnBoard(
alt(P));
1173 attacked_mask[piece.
number()] = attacking;
1174 while (attacking.any())
1176 const Piece attack = state.pieceOf(attacking.takeOneBit());
1177 evalOnePiece<P == BLACK>(P, piece.
ptype(), attack.
ptype(),
1182 PieceMask new_without = effected_mask[
alt(P)] & (~new_mask[
alt(P)]) & state.piecesOnBoard(P);
1183 new_without.reset(p.
number());
1184 while (new_without.any())
1186 const Piece piece = state.pieceOf(new_without.takeOneBit());
1187 const bool has_support =
1188 effected_mask[P].test(piece.
number());
1189 PieceMask attacking = attacked_mask[piece.
number()];
1192 evalOnePiece<P != BLACK>(P, piece.
ptype(), moved.
oldPtype(),
1194 attacking.reset(p.
number());
1196 if (captured_number != -1 && attacking.test(captured_number))
1200 attacking.reset(captured_number);
1202 while (attacking.any())
1204 const Piece attack = state.pieceOf(attacking.takeOneBit());
1205 evalOnePiece<P != BLACK>(P, piece.
ptype(), attack.
ptype(),
1210 PieceMask self_old = effected_mask[
alt(P)] &
1212 effected_mask[P] & (~new_mask[P]) & state.piecesOnBoard(P);
1213 self_old.reset(p.
number());
1214 while (self_old.any())
1216 const Piece piece = state.pieceOf(self_old.takeOneBit());
1217 PieceMask old_attacking = attacked_mask[piece.
number()];
1220 evalOnePiece<P != BLACK>(P, piece.
ptype(), moved.
oldPtype(),
1222 old_attacking.reset(p.
number());
1224 if (captured_number != -1 && old_attacking.test(captured_number))
1228 old_attacking.reset(captured_number);
1230 while (old_attacking.any())
1232 const Piece attack = state.pieceOf(old_attacking.takeOneBit());
1233 evalOnePiece<P != BLACK>(P, piece.
ptype(), attack.
ptype(),
1236 PieceMask new_attacking = state.effectSetAt(piece.
square())
1237 & state.piecesOnBoard(
alt(P));
1238 attacked_mask[piece.
number()] = new_attacking;
1239 while (new_attacking.any())
1241 const Piece attack = state.pieceOf(new_attacking.takeOneBit());
1242 evalOnePiece<P == BLACK>(P, piece.
ptype(), attack.
ptype(),
1247 PieceMask self_new_with = effected_mask[
alt(P)] &
1249 (~effected_mask[P]) & new_mask[P] & state.piecesOnBoard(P);
1250 self_new_with.reset(p.
number());
1251 while (self_new_with.any())
1253 const Piece piece = state.pieceOf(self_new_with.takeOneBit());
1254 PieceMask old_attacking = attacked_mask[piece.
number()];
1257 evalOnePiece<P != BLACK>(P, piece.
ptype(), moved.
oldPtype(),
1259 old_attacking.reset(p.
number());
1261 if (captured_number != -1 && old_attacking.test(captured_number))
1265 old_attacking.reset(captured_number);
1267 while (old_attacking.any())
1269 const Piece attack = state.pieceOf(old_attacking.takeOneBit());
1270 evalOnePiece<P != BLACK>(P, piece.
ptype(), attack.
ptype(),
1273 PieceMask new_attacking = state.effectSetAt(piece.
square())
1274 & state.piecesOnBoard(
alt(P));
1275 attacked_mask[piece.
number()] = new_attacking;
1276 while (new_attacking.any())
1278 const Piece attack = state.pieceOf(new_attacking.takeOneBit());
1279 evalOnePiece<P == BLACK>(P, piece.
ptype(), attack.
ptype(),
1284 PieceMask effected = effected_mask[P];
1285 effected ^= new_mask[P];
1286 effected = ~effected;
1287 PieceMask attack_changed = effected_mask[
alt(P)] &
1289 effected & state.piecesOnBoard(P) &
1290 state.effectedChanged(
alt(P));
1291 attack_changed.reset(p.
number());
1292 while (attack_changed.any())
1294 const Piece attacked = state.pieceOf(attack_changed.takeOneBit());
1295 PieceMask attack_old_mask = attacked_mask[attacked.
number()];
1296 PieceMask attack_new_mask = state.effectSetAt(attacked.
square()) & state.piecesOnBoard(
alt(P));
1297 if (captured_number != -1 &&
1298 attack_old_mask.test(captured_number))
1300 evalOnePiece<P != BLACK>(P, attacked.
ptype(),
1302 new_mask[P].test(attacked.
number()),
1304 attack_old_mask.reset(captured_number);
1307 attack_old_mask.test(p.
number()))
1309 evalOnePiece<P != BLACK>(P, attacked.
ptype(),
1311 new_mask[P].test(attacked.
number()),
1313 attack_old_mask.reset(p.
number());
1316 attack_new_mask.test(p.
number()))
1318 evalOnePiece<P == BLACK>(P, attacked.
ptype(),
1320 new_mask[P].test(attacked.
number()),
1322 attack_new_mask.reset(p.
number());
1324 PieceMask gone = attack_old_mask & (~attack_new_mask);
1327 const Piece attacking = state.pieceOf(gone.takeOneBit());
1328 evalOnePiece<P != BLACK>(P, attacked.
ptype(),
1330 effected_mask[P].test(attacked.
number()),
1333 PieceMask added = (~attack_old_mask) & attack_new_mask;
1336 const Piece attacking = state.pieceOf(added.takeOneBit());
1337 evalOnePiece<P == BLACK>(P, attacked.
ptype(),
1339 new_mask[P].test(attacked.
number()),
1343 attacked_mask[attacked.
number()] = state.effectSetAt(attacked.
square()) & state.piecesOnBoard(
alt(P));
1358 template <Player Owner>
1363 const Ptype attack_ptype
1364 = state.findCheapAttack(
alt(piece.
owner()), piece.
square()).ptype();
1365 const bool has_support = state.hasEffectAt(piece.
owner(),
1367 return (piece.
ptype() +
1384 template<osl::Player P,osl::Ptype T>
1386 const CArray2d<int, 2, PTYPE_SIZE> &ptype_board_count,
1387 const osl::CArray<int,2> &kings_x,
1388 const osl::CArray<int,2> &kings_y);
1389 static void eval(
const NumEffectState &state,
1390 const CArray2d<int, 2, PTYPE_SIZE> &ptype_count,
1391 const CArray2d<int, 2, PTYPE_SIZE> &ptype_board_count,
1395 const NumEffectState &state,
1397 CArray2d<int, 2, PTYPE_SIZE> &ptype_count,
1398 CArray2d<int, 2, PTYPE_SIZE> &ptype_board_count,
1399 MultiInt &last_value_and_out,
unsigned int &ptypeo_mask);
1439 count - 1) + 720 + 800;
1479 count - 1) + 720 + 800;
1527 PtypeO ptypeO,
bool attack)
1529 const int y_diff = (p ==
BLACK ? king.
y() - pos.
y() : pos.
y() - king.
y());
1530 const int x_diff = std::abs(king.
x() - pos.
x());
1533 ptypeO =
alt(ptypeO);
1535 return y_diff + 8 + x_diff * 17 + (ptypeO -
PTYPEO_MIN) * 17 * 9 +
1536 (attack ? 0 : 4896);
1546 const CArray2d<int, 2, 9> &pawns);
1550 const CArray2d<int, 2, 9> &pawns,
1556 if (player ==
WHITE)
1559 pawn_y = (10 - pawn_y) % 10;
1561 return pawn_y + 10 * (y - 1 + 9 * ptype);
1573 const CArray2d<int, 2, 3> &gs_count);
1575 template <Player Defense>
1578 int king_x = (king.
x() > 5 ? 10 - king.
x() : king.
x());
1579 int king_y = (Defense ==
WHITE ? 10 - king.
y() : king.
y());
1580 return king_x - 1 + 5 * (king_y - 1+ 9 * (distance0 + 3 *
count));
1584 const CArray2d<int, 2, 3> &gs_count);
1585 template <Player Defense>
1587 int count1,
int count2)
1589 int king_x = (king.
x() > 5 ? 10 - king.
x() : king.
x());
1590 int king_y = (Defense ==
WHITE ? 10 - king.
y() : king.
y());
1591 return king_x + 5 * (king_y + 9 * (
std::min(5,count0) + 6 *
1617 if (P==
BLACK) index=((ptypeo_mask>>19)&0x1fc0)|((ptypeo_mask>>18)&0x3f);
1618 else index=((ptypeo_mask>>3)&0x1fc0)|((ptypeo_mask>>2)&0x3f);
1620 return table[index];
1622 return -
table[index];
1628 static std::pair<int,int>
matchRook(
const NumEffectState& state,
Piece rook,
1629 const CArray<bool,2>& has_silver,
1631 static std::pair<int,int>
matchGold(
const NumEffectState& state,
Piece gold,
1632 const CArray<bool,2>& has_silver,
1638 CArray<std::pair<Square,int>,2>& silver_drop);
1653 template <Player Defense>
1655 std::pair<Square,int>& bishop_drop,
1656 std::pair<Square,int>& rook_drop);
1658 CArray<std::pair<Square,int>,2>& bishop_drop,
1659 CArray<std::pair<Square,int>,2>& rook_drop);
1663 (
const NumEffectState& state,
Player defense,
1678 template <Player Defense>
1681 BoardMask& knight_fork_squares,
1682 std::pair<Square,int>& knight_drop);
1684 CArray<BoardMask,2>& knight_fork_squares,
1685 CArray<std::pair<Square,int>,2>& knight_drop);
1689 CArray<BoardMask,2>& knight_fork_squares,
1690 CArray<std::pair<Square,int>,2>& knight_drop);
1694 int y,
int x0,
int x1);
1705 template <Player P, Player Defense>
1707 (
const NumEffectState& state,
Move moved,
1708 BoardMask& knight_fork_squares);
1709 template <osl::Player Defense>
1711 (
const NumEffectState& state,
1712 bool has_knight,
const BoardMask& knight_fork_squares,
1713 std::pair<Square,int>& knight_drop);
1744 #endif // EVAL_ML_MINORPIECE_H