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