3 #include <boost/foreach.hpp> 
    7 template <
bool Opening, osl::Ptype MajorBasic>
 
   11 template <
bool Opening, osl::Ptype MajorBasic>
 
   15   for (
size_t i = 0; i < weights.
dimension(); ++i)
 
   17     table[i] = weights.
value(i);
 
   22 template <
bool Opening>
 
   25 template <
bool Opening>
 
   32 template <
bool Opening>
 
   37        i < PtypeTraits<ROOK>::indexLimit;
 
   40     const Piece piece = state.pieceOf(i);
 
   63   for (
int i = 0; i < ONE_DIM; ++i)
 
   67       RookPawnY::y_attack_table[i][s] = weights.
value(i + ONE_DIM * 2 * s);
 
   68       RookPawnY::y_defense_table[i][s] = weights.
value(i + ONE_DIM * 2 * s + ONE_DIM);
 
   77   for (
int i = 0; i < ONE_DIM; ++i)
 
   80       table[i][s] = weights.
value(i + ONE_DIM*s);
 
   86                 const CArray2d<int, 2, 9> &pawns)
 
   89   const CArray<Square,2> kings = {{
 
   90     state.kingSquare<
BLACK>(),
 
   91     state.kingSquare<
WHITE>(),
 
   94        i < PtypeTraits<ROOK>::indexLimit;
 
   97     const Piece piece = state.pieceOf(i);
 
  105           table[index(piece, pawn_y)] +
 
  106           y_attack_table[indexY(kings[
WHITE], piece, pawn_y)] +
 
  107           y_defense_table[indexY(kings[
BLACK], piece, pawn_y)];
 
  115           table[index(piece, y)] +
 
  116           y_attack_table[indexY(kings[
BLACK], piece, y)] +
 
  117           y_defense_table[indexY(kings[
WHITE], piece, y)];
 
  134 template <
bool Opening>
 
  137 template <
bool Opening>
 
  141   for (
size_t i = 0; i < weights.
dimension(); ++i)
 
  143     table[i] = weights.
value(i);
 
  147 template <
bool Opening>
 
  150   const NumEffectState &state, 
Piece piece)
 
  155 template <
bool Opening>
 
  156 template <osl::Ptype PTYPE>
 
  162        i < PtypeTraits<PTYPE>::indexLimit;
 
  165     const Piece piece = state.pieceOf(i);
 
  169       const int weight = table[index(state, piece)];
 
  179 template <
bool Opening>
 
  184   result += evalOne<ROOK>(state);
 
  185   result += evalOne<BISHOP>(state);
 
  186   result += evalOne<GOLD>(state);
 
  187   result += evalOne<SILVER>(state);
 
  208 template<osl::Player P>
 
  211  const NumEffectState& state,
 
  222   PtypeO uPtypeO=state.pieceAt(up).ptypeO();
 
  223   PtypeO dPtypeO=state.pieceAt(dp).ptypeO();
 
  224   PtypeO rPtypeO=state.pieceAt(rp).ptypeO();
 
  225   PtypeO lPtypeO=state.pieceAt(lp).ptypeO();
 
  227     uPtypeO=(
PtypeO)(static_cast<int>(uPtypeO)^(~15));
 
  228     dPtypeO=(
PtypeO)(static_cast<int>(dPtypeO)^(~15));
 
  229     rPtypeO=(
PtypeO)(static_cast<int>(rPtypeO)^(~15));
 
  230     lPtypeO=(
PtypeO)(static_cast<int>(lPtypeO)^(~15));
 
  239   assert((myKing.
y()-dp.
y())<(myKing.
y()-up.
y()));
 
  240   assert((myKing.
x()-lp.
x())<(myKing.
x()-rp.
x()));
 
  257   const CArray<Square,2> kings = {{ 
 
  258     state.kingSquare(
BLACK), 
 
  259     state.kingSquare(
WHITE), 
 
  265     const Piece p = state.pieceOf(i);
 
  268     Square up=state.mobilityOf(
U,i);
 
  269     Square dp=state.mobilityOf(
D,i);
 
  270     Square lp=state.mobilityOf(
L,i);
 
  271     Square rp=state.mobilityOf(
R,i);
 
  274       result+=evalOne<BLACK>(state,pos,kings[0],kings[1],up,dp,rp,lp,isP);
 
  276       result-=evalOne<WHITE>(state,pos,kings[1],kings[0],dp,up,lp,rp,isP);
 
  283   for (
size_t i = 0; i < ONE_DIM; ++i)
 
  285     attack_table[i][stage] = weights.
value(i);
 
  286     defense_table[i][stage] = weights.
value(i + ONE_DIM);
 
  292   for (
size_t i = 0; i < 32; ++i)
 
  302   CArray<MultiInt, 19584> piece_attack_table;
 
  303   CArray<MultiInt, 19584> piece_defense_table;
 
  304   for (
size_t i = 0; i < ONE_DIM; ++i)
 
  308       piece_attack_table[i][s] = weights.
value(i + ONE_DIM*2*s);
 
  309       piece_defense_table[i][s] = weights.
value(i + ONE_DIM*2*s + ONE_DIM);
 
  312   for(
int isP=0;isP<2;isP++)
 
  313     for(
int y_diff=-9;y_diff<=9;y_diff++)
 
  314       for(
int x_diff= -9;x_diff<=9;x_diff++){
 
  315         int i2=index2(x_diff,y_diff,isP);
 
  316         if(abs(x_diff)<9 && abs(y_diff)<9){
 
  318             -(attack_table[index(abs(x_diff),y_diff,
true,isP)]+
 
  319               attack_table[index(abs(x_diff),y_diff,
false,isP)]);
 
  321             -(defense_table[index(abs(x_diff),y_diff,
true,isP)]+
 
  322               defense_table[index(abs(x_diff),y_diff,
false,isP)]);
 
  326           int i1=index1(x_diff,y_diff,(
PtypeO)ptypeo,isP);
 
  327           int indexPieceH,indexPieceV;
 
  328           int table_ptypeo=ptypeo;
 
  335             indexPieceH= index0(abs(x_diff),-y_diff,(
PtypeO)ptypeo,
true,isP);
 
  336             indexPieceV= index0(abs(x_diff),-y_diff,(
PtypeO)ptypeo,
false,isP);
 
  338           attack_u[i1]=piece_attack_table[indexPieceV]+piece_table[table_ptypeo-
PTYPEO_MIN];
 
  339           defense_u[i1]=piece_defense_table[indexPieceV];
 
  340           attack_d[i1]=piece_attack_table[indexPieceV]+piece_table[table_ptypeo-
PTYPEO_MIN];
 
  341           defense_d[i1]=piece_defense_table[indexPieceV];
 
  343             for(
int y_diff_1=y_diff+1;y_diff_1<=8;y_diff_1++){
 
  344               int i=index(abs(x_diff),y_diff_1,
false,isP);
 
  345               attack_u[i1]+=attack_table[i];
 
  346               defense_u[i1]+=defense_table[i];
 
  348             for(
int y_diff_1=
std::max(-8,y_diff);y_diff_1<=8;y_diff_1++){
 
  349               int i=index(abs(x_diff),y_diff_1,
false,isP);
 
  350               attack_d[i1]-=attack_table[i];
 
  351               defense_d[i1]-=defense_table[i];
 
  354           attack_l[i1]=piece_attack_table[indexPieceH]+piece_table[table_ptypeo-
PTYPEO_MIN];
 
  355           defense_l[i1]=piece_defense_table[indexPieceH];
 
  356           attack_r[i1]=piece_attack_table[indexPieceH]+piece_table[table_ptypeo-
PTYPEO_MIN];
 
  357           defense_r[i1]=piece_defense_table[indexPieceH];
 
  359             for(
int x_diff_1=x_diff+1;x_diff_1<=8;x_diff_1++){
 
  360               int i=index(abs(x_diff_1),y_diff,
true,isP);
 
  361               attack_r[i1]+=attack_table[i];
 
  362               defense_r[i1]+=defense_table[i];
 
  364             for(
int x_diff_1=
std::max(-8,x_diff);x_diff_1<=8;x_diff_1++){
 
  365               int i=index(abs(x_diff_1),y_diff,
true,isP);
 
  366               attack_l[i1]-=attack_table[i];
 
  367               defense_l[i1]-=defense_table[i];
 
  381   for (
size_t i = 0; i < ONE_DIM; ++i)
 
  384       promote_defense_table[i][s] = weights.
value(i + ONE_DIM*s);
 
  390   for (
size_t i = 0; i < ONE_DIM; ++i)
 
  394         weights.
value(i + ONE_DIM*s);
 
  403        i < PtypeTraits<ROOK>::indexLimit;
 
  405     const Piece rook = state.pieceOf(i);
 
  410           Square pos=state.mobilityOf(
U,i);
 
  411           const Piece attacked = state.pieceAt(pos);
 
  413             const NumBitmapEffect effect = state.effectSetAt(pos);
 
  414             if (effect.countEffect(
WHITE) == 1){
 
  415               PieceMask mask = effect & state.piecesOnBoard(
WHITE);
 
  416               const Piece effect_piece = state.pieceOf(mask.takeOneBit());
 
  417               const int index = attacked.
ptype() * 16 + effect_piece.
ptype();
 
  418               result += promote_defense_table[index];
 
  420                   effect_piece.
square().
x() != rookPos.
x())
 
  423                   promote_defense_rook_table[
 
  424                     attacked.
ptype() * 9 +
 
  425                     mobility::RookMobility::countHorizontalAll<BLACK>(state,
 
  435           Square pos=state.mobilityOf(
D,i);
 
  436           const Piece attacked = state.pieceAt(pos);
 
  438             const NumBitmapEffect effect = state.effectSetAt(pos);
 
  439             if (effect.countEffect(
BLACK) == 1){
 
  440               PieceMask mask = effect & state.piecesOnBoard(
BLACK);
 
  441               const Piece effect_piece = state.pieceOf(mask.takeOneBit());
 
  442               const int index = attacked.
ptype() * 16 + effect_piece.
ptype();
 
  443               result -= promote_defense_table[index];
 
  445                   effect_piece.
square().
x() != rookPos.
x())
 
  448                   promote_defense_rook_table[
 
  449                     attacked.
ptype() * 9 +
 
  450                     mobility::RookMobility::countHorizontalAll<WHITE>(state,
 
  479 template<osl::Player P>
 
  482  const NumEffectState& state,
 
  493   PtypeO ulPtypeO=state.pieceAt(ulp).ptypeO();
 
  494   PtypeO urPtypeO=state.pieceAt(urp).ptypeO();
 
  495   PtypeO dlPtypeO=state.pieceAt(dlp).ptypeO();
 
  496   PtypeO drPtypeO=state.pieceAt(drp).ptypeO();
 
  498     ulPtypeO=(
PtypeO)(static_cast<int>(ulPtypeO)^(~15));
 
  499     urPtypeO=(
PtypeO)(static_cast<int>(urPtypeO)^(~15));
 
  500     dlPtypeO=(
PtypeO)(static_cast<int>(dlPtypeO)^(~15));
 
  501     drPtypeO=(
PtypeO)(static_cast<int>(drPtypeO)^(~15));
 
  510   result+=attack_ul[index1(opKing,ulp,ulPtypeO,isP)]+
 
  511     attack_ur[index1(opKing,urp,urPtypeO,isP)]+
 
  512     attack_dl[index1(opKing,dlp,dlPtypeO,isP)]+
 
  513     attack_dr[index1(opKing,drp,drPtypeO,isP)]+
 
  514     defense_ul[index1(myKing,ulp,ulPtypeO,isP)]+
 
  515     defense_ur[index1(myKing,urp,urPtypeO,isP)]+
 
  516     defense_dl[index1(myKing,dlp,dlPtypeO,isP)]+
 
  517     defense_dr[index1(myKing,drp,drPtypeO,isP)]+
 
  518     attack_nospace[index2(opKing,bishop,isP)]+
 
  519     defense_nospace[index2(myKing,bishop,isP)];
 
  526   const CArray<Square,2> kings = {{ 
 
  527     state.kingSquare(
BLACK), 
 
  528     state.kingSquare(
WHITE), 
 
  535       const Piece p = state.pieceOf(i);
 
  544         result+=evalOne<BLACK>(state,pos,kings[0],kings[1],ulp,urp,dlp,drp,isP);
 
  546         result-=evalOne<WHITE>(state,pos,kings[1],kings[0],drp,dlp,urp,ulp,isP);
 
  553   for (
size_t i = 0; i < ONE_DIM; ++i)
 
  555     attack_table[i][stage] = weights.
value(i);
 
  556     defense_table[i][stage] = weights.
value(i + ONE_DIM);
 
  562   for (
size_t i = 0; i < 32; ++i)
 
  573   CArray<MultiInt, 19584> piece_attack_table;
 
  574   CArray<MultiInt, 19584> piece_defense_table;
 
  575   for (
size_t i = 0; i < ONE_DIM; ++i)
 
  579       piece_attack_table[i][s] = weights.
value(i + ONE_DIM * 2 * s);
 
  580       piece_defense_table[i][s] = weights.
value(i + ONE_DIM * 2 * s + ONE_DIM);
 
  583   for(
int isP=0;isP<2;isP++)
 
  584     for(
int y_diff=-9;y_diff<=9;y_diff++)
 
  585       for(
int x_diff= -9;x_diff<=9;x_diff++){
 
  586         int i2=index2(x_diff,y_diff,isP);
 
  587         if(abs(x_diff)<9 && abs(y_diff)<9){
 
  589             -(attack_table[index(x_diff,y_diff,
true,isP)]+
 
  590               attack_table[index(x_diff,y_diff,
false,isP)]);
 
  592             -(defense_table[index(x_diff,y_diff,
true,isP)]+
 
  593               defense_table[index(x_diff,y_diff,
false,isP)]);
 
  597           int i1=index1(x_diff,y_diff,(
PtypeO)ptypeo,isP);
 
  598           int indexPieceUR,indexPieceUL;
 
  599           int table_ptypeo=ptypeo;
 
  606             indexPieceUR= index0(x_diff,y_diff,(
PtypeO)ptypeo,
true,isP);
 
  607             indexPieceUL= index0(x_diff,y_diff,(
PtypeO)ptypeo,
false,isP);
 
  609           attack_ul[i1]=piece_attack_table[indexPieceUL]+piece_table[table_ptypeo-
PTYPEO_MIN];
 
  610           defense_ul[i1]=piece_defense_table[indexPieceUL];
 
  611           attack_dr[i1]=piece_attack_table[indexPieceUL]+piece_table[table_ptypeo-
PTYPEO_MIN];
 
  612           defense_dr[i1]=piece_defense_table[indexPieceUL];
 
  614             int y_diff_1=y_diff+1, x_diff_1=x_diff-1;
 
  615             for(;y_diff_1<=8 && x_diff_1>=-8;y_diff_1++,x_diff_1--){
 
  616               if(std::abs(x_diff_1)<=8 && std::abs(y_diff_1)<=8){
 
  617                 int i=index(x_diff_1,y_diff_1,
false,isP);
 
  618                 attack_ul[i1]+=attack_table[i];
 
  619                 defense_ul[i1]+=defense_table[i];
 
  624             int y_diff_1=y_diff, x_diff_1=x_diff;
 
  625             for(;y_diff_1<=8 && x_diff_1>=-8;y_diff_1++,x_diff_1--){
 
  626               if(std::abs(x_diff_1)<=8 && std::abs(y_diff_1)<=8){
 
  627                 int i=index(x_diff_1,y_diff_1,
false,isP);
 
  628                 attack_dr[i1]-=attack_table[i];
 
  629                 defense_dr[i1]-=defense_table[i];
 
  633           attack_ur[i1]=piece_attack_table[indexPieceUR]+piece_table[table_ptypeo-
PTYPEO_MIN];
 
  634           defense_ur[i1]=piece_defense_table[indexPieceUR];
 
  635           attack_dl[i1]=piece_attack_table[indexPieceUR]+piece_table[table_ptypeo-
PTYPEO_MIN];
 
  636           defense_dl[i1]=piece_defense_table[indexPieceUR];
 
  638             int y_diff_1=y_diff+1, x_diff_1=x_diff+1;
 
  639             for(;y_diff_1<=8 && x_diff_1<=8;y_diff_1++,x_diff_1++){
 
  640               if(std::abs(x_diff_1)<=8 && std::abs(y_diff_1)<=8){
 
  641                 int i=index(x_diff_1,y_diff_1,
true,isP);
 
  642                 attack_ur[i1]+=attack_table[i];
 
  643                 defense_ur[i1]+=defense_table[i];
 
  648             int y_diff_1=y_diff, x_diff_1=x_diff;
 
  649             for(;y_diff_1<=8 && x_diff_1<=8;y_diff_1++,x_diff_1++){
 
  650               if(std::abs(x_diff_1)<=8 && std::abs(y_diff_1)<=8){
 
  651                 int i=index(x_diff_1,y_diff_1,
true,isP);
 
  652                 attack_dl[i1]-=attack_table[i];
 
  653                 defense_dl[i1]-=defense_table[i];
 
  667   for (
size_t i = 0; i < ONE_DIM; ++i)
 
  670       table[i][s] = weights.
value(i + ONE_DIM*s);
 
  677   for (
size_t i = 0; i < ONE_DIM; ++i)
 
  682   for(
int x_diff=0;x_diff<=8;x_diff++)
 
  683     for(
int y_diff=-8;y_diff<=8;y_diff++){
 
  684       for(
int i=0;i<32;i++)
 
  689   for(
int x_diff=0;x_diff<=8;x_diff++)
 
  690     for(
int y_diff=-8;y_diff<=8;y_diff++){
 
  700   for (
size_t i = 0; i < ONE_DIM; ++i)
 
  712        i < PtypeTraits<BISHOP>::indexLimit;
 
  714     const Piece p = state.pieceOf(i);
 
  720           if (!state.hasEffectAt(
BLACK, up)){
 
  722             const PtypeO ptypeo = state.pieceAt(up).ptypeO();
 
  723             const int index_k = indexK(
BLACK, ptypeo,
 
  724                                        std::abs(pos.
x() - king.
x()),
 
  726             result += king_table[index_k];
 
  727             result += 
x_table[indexX<BLACK>(ptypeo, pos.
x())];
 
  731       else if(pos.
y()<=8) {
 
  733         if (!state.hasEffectAt(
WHITE, up)){
 
  735           const PtypeO ptypeo = state.pieceAt(up).ptypeO();
 
  736           const int index_k = indexK(
WHITE, ptypeo,
 
  737                                      std::abs(pos.
x() - king.
x()),
 
  739           result -= king_table[index_k];
 
  740           result -= 
x_table[indexX<WHITE>(ptypeo, pos.
x())];
 
  753   for (
size_t i = 0; i < ONE_DIM; ++i)
 
  756       table[i][s] = weights.
value(i + ONE_DIM*s);
 
  760 template<osl::Player P>
 
  764   const Square king=state.kingSquare(P);
 
  767        i < PtypeTraits<ROOK>::indexLimit;
 
  770     const Piece rook = state.pieceOf(i);
 
  776          j < PtypeTraits<BISHOP>::indexLimit;
 
  779       const Piece bishop = state.pieceOf(j);
 
  784       result += table[index<P>(king, rook, bishop)];
 
  793   return evalOne<BLACK>(state)-evalOne<WHITE>(state);
 
  804   for (
size_t i = 0; i < ONE_DIM; ++i)
 
  808         weights.
value(i + ONE_DIM*s);
 
  815   for (
size_t i = 0; i < ONE_DIM; ++i)
 
  819         weights.
value(i + ONE_DIM*s);
 
  826   for (
size_t i = 0; i < ONE_DIM; ++i)
 
  830         weights.
value(i + ONE_DIM*s);
 
  839        i < PtypeTraits<BISHOP>::indexLimit;
 
  842     const Piece bishop = state.pieceOf(i);
 
  849                  state.kingSquare(
alt(bishop.
owner())),
 
  850                  bishop, 
self, opp, all);
 
  853       result += (self_table[
self] + opp_table[opp] + all_table[all]);
 
  857       result -= (self_table[
self] + opp_table[opp] + all_table[all]);
 
  865   const NumEffectState &state, 
Square king, 
Piece bishop,
 
  866   int &self_count, 
int &opp_count, 
int &total_count)
 
  872     self_count = opp_count = total_count = 8;
 
  876   assert(king.
x() != bishop.
square().
x());
 
  877   assert(king.
y() != bishop.
square().
y());
 
  902   self_count = opp_count = total_count = 0;
 
  903   for (
Square pos = state.mobilityOf(dir, bishop.
number());
 
  906     assert(pos.isOnBoard());
 
  907     const Piece piece = state.pieceAt(pos);
 
  908     if (!piece.isEmpty())
 
  911       if (piece.owner() == player)
 
  926   for (
size_t i = 0; i < ONE_DIM; ++i)
 
  929       table[i][s] = weights.
value(i + ONE_DIM*s);
 
  978     const Piece p = state.pieceAt(p1);
 
  979     const bool black_with_support =
 
  982     const bool white_with_support =
 
  987       result += table[index(p.
ptype(), black_with_support,
 
  988                             white_with_support)];
 
  992       result -= table[index(p.
ptype(), white_with_support,
 
  993                             black_with_support)];
 
 1005   CArray<MultiInt, 800> orig_table;
 
 1006   for (
size_t i = 0; i < ONE_DIM; ++i)
 
 1009       orig_table[i][s] = weights.
value(i + ONE_DIM*s);
 
 1011   for (
int owner = 0; owner < 2; ++owner)
 
 1013     const bool same_player = (owner == 0);
 
 1014     for (
int y1 = 0; y1 < 10; ++y1)
 
 1016       for (
int y2 = 0; y2 < 10; ++y2)
 
 1018         for (
int promoted1 = 0; promoted1 < 2; ++promoted1)
 
 1020           for (
int promoted2 = 0; promoted2 < 2; ++promoted2)
 
 1026               int promoted1p = promoted1;
 
 1027               int promoted2p = promoted2;
 
 1028               if (y1 > y2 || (y1 == y2 && !promoted1 && promoted2))
 
 1030                 std::swap(y1p, y2p);
 
 1031                 std::swap(promoted1p, promoted2p);
 
 1033               table[index(same_player, promoted1, promoted2,
 
 1035                 orig_table[index(same_player, promoted1p, promoted2p,
 
 1040               if (y1 + y2 > 10 || y1 == 0 ||
 
 1041                   (y1 + y2 == 10 && promoted1))
 
 1043                 const int idx = index(same_player, promoted1, promoted2,
 
 1045                 table[idx] = orig_table[idx];
 
 1049                 table[index(same_player, promoted1, promoted2,
 
 1051                   -orig_table[index(same_player, promoted2, promoted1,
 
 1052                                     (10 - y2) % 10, (10 - y1) % 10)];
 
 1072       result += table[index<true, BLACK>(rook1, rook2)];
 
 1076       result -= table[index<true, WHITE>(rook1, rook2)];
 
 1083       std::swap(rook1, rook2);
 
 1085     result += table[index<false, BLACK>(rook1, rook2)];
 
 1097   for (
size_t i = 0; i < ONE_DIM; ++i)
 
 1100       table[i][s] = weights.
value(i + ONE_DIM*s);
 
 1118   bool vertical = 
false;
 
 1152     const Piece p = state.pieceAt(p1);
 
 1153     const bool black_with_support =
 
 1156     const bool white_with_support =
 
 1161       result += table[index(p.
ptype(), black_with_support,
 
 1162                             white_with_support, vertical)];
 
 1166       result -= table[index(p.
ptype(), white_with_support,
 
 1167                             black_with_support, vertical)];
 
 1180   for (
size_t i = 0; i < ONE_DIM; ++i)
 
 1183       table[i][s] = weights.
value(i + ONE_DIM*s);
 
 1212   for (
size_t i = 0; i < ONE_DIM; ++i)
 
 1215       table[i][s] = weights.
value(i + ONE_DIM*s);
 
 1219 template <osl::Player Owner>
 
 1223   const Square king = state.kingSquare(Owner);
 
 1224   PieceMask pieces = state.effectedMask(
alt(Owner));
 
 1225   pieces &= state.piecesOnBoard(Owner);
 
 1226   pieces &= ~state.effectedMask(Owner);
 
 1228   while (pieces.any()) {
 
 1229     const Piece p = state.pieceOf(pieces.takeOneBit());
 
 1231     if (state.hasLongEffectAt<
ROOK>(
alt(Owner), sq)
 
 1238     if (state.hasLongEffectAt<
BISHOP>(
alt(Owner), sq)
 
 1252   return addOne<BLACK>(state) + addOne<WHITE>(state);
 
 1262   for (
size_t i = 0; i < ONE_DIM; ++i)
 
 1265       table[i][s] = weights.
value(i + ONE_DIM*s);
 
 1274        i < PtypeTraits<ROOK>::indexLimit;
 
 1277     const Piece rook = state.pieceOf(i);
 
 1283          i < PtypeTraits<SILVER>::indexLimit;
 
 1286       const Piece silver = state.pieceOf(i);
 
 1293            i < PtypeTraits<KNIGHT>::indexLimit;
 
 1296         const Piece knight = state.pieceOf(i);
 
 1307             result += table[index(9 - rook.
square().
x(), rook.
square().
y() - 1,
 
 1313             result += table[index(rook.
square().
x() - 1, rook.
square().
y() - 1,
 
 1322             result -= table[index(9 - rook.
square().
x(), 9 - rook.
square().
y(),
 
 1328             result -= table[index(rook.
square().
x() - 1, 9 - rook.
square().
y(),
 
 1346   for (
size_t i = 0; i < ONE_DIM; ++i)
 
 1349       table[i][s] = weights.
value(i + ONE_DIM*s);
 
 1358        i < PtypeTraits<BISHOP>::indexLimit;
 
 1361     const Piece bishop = state.pieceOf(i);
 
 1367          i < PtypeTraits<SILVER>::indexLimit;
 
 1370       const Piece silver = state.pieceOf(i);
 
 1377            i < PtypeTraits<KNIGHT>::indexLimit;
 
 1380         const Piece knight = state.pieceOf(i);
 
 1391             result += table[index(9 - bishop.
square().
x(), bishop.
square().
y() - 1,
 
 1397             result += table[index(bishop.
square().
x() - 1, bishop.
square().
y() - 1,
 
 1406             result -= table[index(9 - bishop.
square().
x(), 9 - bishop.
square().
y(),
 
 1412             result -= table[index(bishop.
square().
x() - 1, 9 - bishop.
square().
y(),
 
 1430   for (
size_t i = 0; i < ONE_DIM; ++i) {
 
 1432       table[i][s] = weights.
value(i + ONE_DIM*s);
 
 1434       table[i] += table[0];
 
 1438 template <osl::Player P>
 
 1443   if (state.hasEffectAt(
alt(P), sq)
 
 1446   typedef std::pair<Offset,Square> 
pair_t;
 
 1447   const CArray<pair_t, 7> bishop_attack =
 
 1457   const bool has_gold = state.hasPieceOnStand(
alt(P), 
GOLD);
 
 1458   const bool rook_support = state.hasEffectAt(P, sq);
 
 1459   BOOST_FOREACH(pair_t pair, bishop_attack) {
 
 1460     const Square attack_square = pair.second;
 
 1461     if (! state[attack_square].isEmpty()
 
 1462         || state.countEffect(P, attack_square) > 1)
 
 1464     const Square bishop_square = attack_square + pair.first;
 
 1465     Piece p = state[bishop_square];
 
 1467         || state.hasEffectAt(
alt(P), bishop_square))
 
 1469     int a = state.countEffect(
alt(P), attack_square) + has_gold;
 
 1470     if (a <= state.countEffect(P, attack_square))
 
 1472     const int i = index(state.findCheapAttack(P, attack_square).ptype(),
 
 1473                         state.findCheapAttack(
alt(P), attack_square).ptype(),
 
 1474                         has_gold, rook_support,
 
 1475                         state.hasEffectNotBy(P, rook, bishop_square));
 
 1487   for (
int i=0; i<state.nthLimit<
ROOK>(); ++i) {
 
 1493       addOne<BLACK>(state, rook, 
result);    
 
 1495       addOne<WHITE>(state, rook, 
result);    
 
 1514       template MultiInt KingRookBishop::evalOne<BLACK>(
const NumEffectState &state);
 
 1515       template MultiInt KingRookBishop::evalOne<WHITE>(
const NumEffectState &state);