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);