13 for (
int y = 0; y <= 16; ++y)
15 for (
int x = 0; x <= 8; ++x)
17 const int distance = x * 17 + y;
18 attack_table[i][distance][stage] =
20 defense_table[i][distance][stage] =
42 const int attack_index = index(state,
BLACK,position, w_king);
43 const int defense_index = index(state,
BLACK,position, b_king);
44 value += attack_table[ptype][attack_index];
45 value += defense_table[ptype][defense_index];
49 const int attack_index = index(state,
WHITE,position, b_king);
50 const int defense_index = index(state,
WHITE,position, w_king);
51 value -= attack_table[ptype][attack_index];
52 value -= defense_table[ptype][defense_index];
58 template<osl::Player P>
75 const int attack_index = index(state, ptypeO, moved.
from(),
false);
76 const int defense_index = index(state,ptypeO, moved.
from(),
true);
79 value -= attack_table[moved.
oldPtype()][attack_index];
80 value -= defense_table[moved.
oldPtype()][defense_index];
84 value += attack_table[moved.
oldPtype()][attack_index];
85 value += defense_table[moved.
oldPtype()][defense_index];
89 const int attack_index = index(state, moved.
ptypeO(), moved.
to(),
false);
90 const int defense_index = index(state, moved.
ptypeO(), moved.
to(),
true);
93 value += attack_table[moved.
ptype()][attack_index];
94 value += defense_table[moved.
ptype()][defense_index];
98 value -= attack_table[moved.
ptype()][attack_index];
99 value -= defense_table[moved.
ptype()][defense_index];
106 const int attack_index = index(state, ptypeO, moved.
to(),
false);
107 const int defense_index = index(state,ptypeO, moved.
to(),
true);
110 value += attack_table[
captured][attack_index];
111 value += defense_table[
captured][defense_index];
115 value -= attack_table[
captured][attack_index];
116 value -= defense_table[
captured][defense_index];
129 for (
int i = 0; i < ONE_DIM; ++i)
132 table[i][s] = weights.
value(i + ONE_DIM*s);
136 template <
int Sign>
inline
141 out += table[attack] + table[defense];
143 out -= table[attack] + table[defense];
150 const CArray<Square, 2> kings = {{
151 state.kingSquare(
BLACK),
152 state.kingSquare(
WHITE),
154 PieceMask black = (~state.effectedMask(
BLACK)) & state.piecesOnBoard(
BLACK);
158 const Piece piece = state.pieceOf(black.takeOneBit());
159 const int index_attack = index(
BLACK, kings[
WHITE],
161 const int index_defense = index(
BLACK, kings[
BLACK],
162 piece) + ONE_DIM / 2;
163 adjust<1>(index_attack, index_defense,
result);
165 PieceMask white = (~state.effectedMask(
WHITE)) & state.piecesOnBoard(
WHITE);
169 const Piece piece = state.pieceOf(white.takeOneBit());
170 const int index_attack = index(
WHITE, kings[
BLACK],
172 const int index_defense = index(
WHITE, kings[
WHITE],
173 piece) + ONE_DIM / 2;
181 const NumEffectState &state,
183 const CArray<PieceMask, 2> &effected_mask,
189 const CArray<PieceMask, 2> new_mask = {{
190 state.effectedMask(
BLACK),
191 state.effectedMask(
WHITE)
193 const CArray<Square, 2> kings = {{
194 state.kingSquare<
BLACK>(),
195 state.kingSquare<
WHITE>(),
199 const Piece p = state.pieceAt(moved.
to());
204 const int index_attack =
207 const int index_defense =
209 moved.
from()) + ONE_DIM / 2;
211 adjust<-1>(index_attack, index_defense, result);
213 adjust<1>(index_attack, index_defense,
result);
219 PieceMask captured_mask =
220 effected_mask[moved.
player()] & (~state.piecesOnBoard(
BLACK)) &
221 (~state.piecesOnBoard(
WHITE));
223 if (!effected_mask[
alt(moved.
player())].test(captured_mask.takeOneBit()))
225 const int index_attack =
228 const int index_defense =
230 moved.
to()) + ONE_DIM / 2;
232 adjust<1>(index_attack, index_defense, result);
239 const int index_attack =
242 const int index_defense =
244 moved.
to()) + ONE_DIM / 2;
246 adjust<1>(index_attack, index_defense, result);
250 PieceMask onboard_black = state.piecesOnBoard(
BLACK);
253 PieceMask black_old = (~effected_mask[0]) & new_mask[0] & onboard_black;
254 black_old.reset(p.
number());
255 while (black_old.any())
257 const Piece piece = state.pieceOf(black_old.takeOneBit());
258 const int index_attack =
260 const int index_defense =
261 index(
BLACK, kings[
BLACK], piece) + ONE_DIM / 2;
265 PieceMask black_new = effected_mask[0] & (~new_mask[0]) & onboard_black;
266 black_new.reset(p.
number());
267 while (black_new.any())
269 const Piece piece = state.pieceOf(black_new.takeOneBit());
270 const int index_attack =
272 const int index_defense =
273 index(
BLACK, kings[
BLACK], piece) + ONE_DIM / 2;
274 adjust<1>(index_attack, index_defense,
result);
278 PieceMask onboard_white = state.piecesOnBoard(
WHITE);
280 PieceMask white_old = (~effected_mask[1]) & new_mask[1] & onboard_white;
281 white_old.reset(p.
number());
282 while (white_old.any())
284 const Piece piece = state.pieceOf(white_old.takeOneBit());
285 const int index_attack =
287 const int index_defense =
288 index(
WHITE, kings[
WHITE], piece) + ONE_DIM / 2;
289 adjust<1>(index_attack, index_defense,
result);
292 PieceMask white_new = effected_mask[1] & (~new_mask[1]) & onboard_white;
293 white_new.reset(p.
number());
294 while (white_new.any())
296 const Piece piece = state.pieceOf(white_new.takeOneBit());
297 const int index_attack =
299 const int index_defense =
300 index(
WHITE, kings[
WHITE], piece) + ONE_DIM / 2;
312 for (
int i = 0; i <
ONE_DIM; ++i)
325 out += table[black] - table[white];
327 out -= table[black] - table[white];
334 const CArray<Square,2> kings = {{
335 state.kingSquare(
BLACK),
336 state.kingSquare(
WHITE),
340 const Piece p = state.pieceOf(i);
343 const int black_index = index<BLACK>(p, kings[
BLACK]);
344 const int white_index = index<WHITE>(p, kings[
WHITE]);
345 adjust<1>(black_index, white_index,
result);
352 const NumEffectState& state,
363 const int index_black = index<BLACK>(moved.
oldPtypeO(), moved.
from(),
364 state.kingSquare<
BLACK>());
365 const int index_white = index<WHITE>(moved.
oldPtypeO(), moved.
from(),
366 state.kingSquare<
WHITE>());
373 const int index_black = index<BLACK>(ptypeO, moved.
to(),
374 state.kingSquare<
BLACK>());
375 const int index_white = index<WHITE>(ptypeO, moved.
to(),
376 state.kingSquare<
WHITE>());
381 const int index_black = index<BLACK>(moved.
ptypeO(), moved.
to(),
382 state.kingSquare<
BLACK>());
383 const int index_white = index<WHITE>(moved.
ptypeO(), moved.
to(),
384 state.kingSquare<
WHITE>());
385 adjust<1>(index_black, index_white,
result);
398 for (
size_t i = 0; i < weights.
dimension(); ++i)
400 table[i] = weights.
value(i);
411 const int min_x =
std::max(1, king.
x() - 2);
412 const int max_x =
std::min(9, king.
x() + 2);
413 const int min_y =
std::max(1, king.
y() - 2);
414 const int max_y =
std::min(9, king.
y() + 2);
418 for (
int y = min_y; y <= max_y; ++y)
420 for (
int x = min_x; x <= max_x; ++x)
429 piece =
std::min(16, mask.countBit());
434 return effect + 128 * piece_count;
440 int black_effect, black_piece, white_effect, white_piece;
441 countEffectAndPieces(state,
osl::BLACK, black_effect, black_piece);
442 countEffectAndPieces(state,
osl::WHITE, white_effect, white_piece);
443 return table[index(black_effect, black_piece)] - table[index(white_effect, white_piece)];
454 for (
int i = 0; i < ONE_DIM; ++i)
457 table[i][s] = weights.
value(i + ONE_DIM*s);
463 for (
int i = 0; i < ONE_DIM; ++i)
466 table[i][s] = weights.
value(i + ONE_DIM*s);
478 for (
int i = 0; i < ONE_DIM; ++i)
481 table[i][s] = weights.
value(i + ONE_DIM*s);
487 for (
int i = 0; i < ONE_DIM; ++i)
490 table[i][s] = weights.
value(i + ONE_DIM*s);
503 attack_table.fill(0);
504 defense_table.fill(0);
505 for (
size_t i = 0; i < DIM/2; ++i)
507 attack_table[i] = weights.
value(i);
508 defense_table[i] = weights.
value(i+DIM/2);
512 template <osl::Player Attack>
517 PieceMask& supported_mask,
522 int &attack_piece_supported,
523 CArray<int, 5> &verticals,
524 CArray<int, 5> &king_verticals)
526 king_verticals.fill(0);
529 const int min_x =
std::max(1, king.
x() - 2);
530 const int max_x =
std::min(9, king.
x() + 2);
531 const int min_y =
std::max(1, king.
y() - 2);
532 const int max_y =
std::min(9, king.
y() + 2);
533 int mask_all=(1<<5)-1;
534 verticals.fill(mask_all);
535 const int y_mask_base=(1 << (Defense ==
BLACK ? (min_y-king.
y()) + 2 : -(max_y-king.
y()) + 2));
537 mask_all ^= ((1<<(max_y-king.
y()+3))-y_mask_base);
539 mask_all ^= ((1<<(king.
y()-min_y+3))-y_mask_base);
541 int attack_count = 0;
542 int defense_count = 0;
543 for (
int x = min_x; x <= max_x; ++x)
545 int vertical_x=mask_all;
546 int king_vertical_x = 0;
548 int y_mask=y_mask_base;
549 for (
int y = min_y; y <= max_y; ++y, y_mask+=y_mask)
556 attack_count +=
count;
557 vertical_x |= y_mask;
563 king_vertical_x |= y_mask;
568 int y_mask=y_mask_base;
569 for (
int y = max_y; y >= min_y; --y, y_mask+=y_mask)
576 attack_count +=
count;
577 vertical_x |= y_mask;
583 king_vertical_x |= y_mask;
587 const int x_diff = king.
x() - x;
588 verticals[(Defense ==
BLACK ? 2 - x_diff : 2 + x_diff)] = vertical_x;
589 king_verticals[(Defense ==
BLACK ? 2 - x_diff : 2 + x_diff)] =
592 attack_effect =
std::min(127, attack_count);
593 defense_effect =
std::min(127, defense_count);
595 attack_piece =
std::min(16, attack_mask.countBit());
597 defense_piece =
std::min(16, defense_mask.countBit());
598 supported_mask = attack_mask & state.
effectedMask(Attack);
599 attack_piece_supported =
std::min(16, supported_mask.countBit());
611 attack_table.fill(0);
612 defense_table.fill(0);
613 for (
size_t i = 0; i < DIM/2; ++i)
615 attack_table[i] = weights.
value(i);
616 defense_table[i] = weights.
value(i+DIM/2);
626 for (
size_t i = 0; i < weights.
dimension(); ++i)
628 table[i] = weights.
value(i);
632 template <osl::Player defense>
637 const Piece king_piece = state.kingPiece<defense>();
639 const int min_x =
std::max(1, king.x() - 2);
640 const int max_x =
std::min(9, king.x() + 2);
641 const int min_y =
std::max(1, king.y() - 2);
642 const int max_y =
std::min(9, king.y() + 2);
644 PieceMask pieces=state.piecesOnBoard(defense);
647 for (
int x = min_x; x <= max_x; ++x)
649 for (
int y = min_y; y <= max_y; ++y)
652 if (state.pieceAt(target).isEmpty()
654 (pieces & state.effectSetAt(target)).any())
656 if (defense ==
BLACK)
657 result += table[index(x - king.x(), y - king.y())];
659 result -= table[index(king.x() - x, king.y() - y)];
666 template <osl::Player defense>
669 const CArray<int, 15>& opening,
const CArray<int, 15>& ending)
671 int result_o = 0, result_e = 0;
672 const Piece king_piece = state.kingPiece<defense>();
674 const int min_x =
std::max(1, king.x() - 2);
675 const int max_x =
std::min(9, king.x() + 2);
676 const int min_y =
std::max(1, king.y() - 2);
677 const int max_y =
std::min(9, king.y() + 2);
679 PieceMask pieces=state.piecesOnBoard(defense);
682 for (
int x = min_x; x <= max_x; ++x)
684 for (
int y = min_y; y <= max_y; ++y)
687 if (state.pieceAt(target).isEmpty()
689 (pieces & state.effectSetAt(target)).any())
691 if (defense ==
BLACK)
693 result_o += opening[index(x - king.x(), y - king.y())];
694 result_e += ending[index(x - king.x(), y - king.y())];
698 result_o -= opening[index(king.x() - x, king.y() - y)];
699 result_e -= ending[index(king.x() - x, king.y() - y)];
704 return std::make_pair(result_o, result_e);
709 const CArray<int, 15>& opening,
const CArray<int, 15>& ending)
711 std::pair<int,int> b = evalOne<BLACK>(state, opening, ending);
712 std::pair<int,int> w = evalOne<WHITE>(state, opening, ending);
713 CArray<int,2> result_o = {{ b.first, w.first }};
714 CArray<int,2> result_e = {{ b.second, w.second }};
715 return std::make_pair(result_o, result_e);
720 const CArray<int, 15>& opening,
const CArray<int, 15>& ending,
721 const CArray<int, 2>& last_opening_value,
722 const CArray<int, 2>& last_ending_value)
724 BoardMask mb = state.changedEffects(
BLACK), mw = state.changedEffects(
WHITE);
727 const Square kb = state.kingSquare<
BLACK>(), kw = state.kingSquare<
WHITE>();
730 std::pair<int,int> b = update_black
731 ? evalOne<BLACK>(state, opening, ending)
732 : std::make_pair(last_opening_value[0], last_ending_value[0]);
733 std::pair<int,int> w = update_white
734 ? evalOne<WHITE>(state, opening, ending)
735 : std::make_pair(last_opening_value[1], last_ending_value[1]);
736 CArray<int,2> result_o = {{ b.first, w.first }};
737 CArray<int,2> result_e = {{ b.second, w.second }};
738 return std::make_pair(result_o, result_e);
750 CArray<int, 2>
result = {{ evalOne<BLACK>(state, table), evalOne<WHITE>(state, table) }};
757 CArray<int, 2>
result = {{ evalOne<BLACK>(state, table), evalOne<WHITE>(state, table) }};
771 for (
size_t i = 0; i < weights.
dimension(); ++i)
773 table[i] = weights.
value(i);
778 template <osl::Player Defense>
781 const NumEffectState &state,
784 if (!state.hasEffectAt(
alt(Defense), target))
788 const int diff = state.countEffect(Defense, target) -
789 state.countEffect(
alt(Defense), target);
794 template <osl::Player Defense>
796 const NumEffectState &state,
Square king,
799 const Piece piece = state.pieceAt(target);
801 const int rel_x = std::abs(king.
x() - target.
x());
803 const int rel_y = (target.
y() - king.
y()) * (Defense ==
BLACK ? 1 : -1);
807 else if (piece.
owner() == Defense)
812 int val = rel_y + 2 + rel_x * 5 +
813 effectState<Defense>(state,
target) * 5 * 3 +
814 piece_owner * 5 * 3 * 8;
819 template <osl::Player Defense>
821 const NumEffectState &state)
824 const Square king = state.kingSquare<Defense>();
825 const int min_x =
std::max(1, king.
x() - 2);
826 const int max_x =
std::min(9, king.
x() + 2);
827 const int min_y =
std::max(1, king.
y() - 2);
828 const int max_y =
std::min(9, king.
y() + 2);
829 for (
int x = min_x; x <= max_x; ++x)
831 for (
int y = min_y; y <= max_y; ++y)
834 result += table[index<Defense>(state, king,
target)];
837 if (Defense ==
BLACK)
847 return evalOne<BLACK>(state) + evalOne<WHITE>(state);
864 for (
size_t i = 0; i < weights.
dimension(); ++i)
873 for (
size_t i = 0; i < weights.
dimension(); ++i)
882 for (
size_t i = 0; i < weights.
dimension(); ++i)
891 for (
size_t i = 0; i < weights.
dimension(); ++i)
899 for(
int rel_y_2=0;rel_y_2<5;rel_y_2++)
900 for(
int x_diff_2=0;x_diff_2<5;x_diff_2++)
901 for(
int es=0;es<8;es++)
902 for(
int po=0;po<3;po++)
903 for(
int king_x_1=0;king_x_1<5;king_x_1++){
904 int oldIndex=(rel_y_2+x_diff_2*5+es*5*5+po*5*5*8)*5+king_x_1;
905 int newIndex=po+3*(es+8*(rel_y_2+5*(x_diff_2+5*king_x_1)));
909 for(
int rel_y_2=0;rel_y_2<5;rel_y_2++)
910 for(
int rel_x=0;rel_x<3;rel_x++)
911 for(
int es=0;es<8;es++)
912 for(
int po=0;po<3;po++)
913 for(
int king_y_1=0;king_y_1<9;king_y_1++){
914 int oldIndex=(rel_y_2+rel_x*5+es*5*3+po*5*3*8)*9+king_y_1;
915 int newIndex=po+3*(es+8*(rel_y_2+5*(rel_x+3*king_y_1)));
919 for(
int d_effect=0;d_effect<16;d_effect++){
920 for(
int a_effect=0;a_effect<16;a_effect++){
925 int diff=d_effect-a_effect;
936 for(
int rel_y_2=0;rel_y_2<5;rel_y_2++)
937 for(
int x_diff_2=0;x_diff_2<5;x_diff_2++){
938 int rel_x=std::abs(x_diff_2-2);
939 for(
int es=0;es<8;es++)
940 for(
int po=0;po<3;po++)
941 for(
int king_x_1=0;king_x_1<5;king_x_1++)
942 for (
int king_y_1=0;king_y_1<9;king_y_1++) {
943 int oldIndex=((rel_y_2+x_diff_2*5+es*5*5+po*5*5*8)*9+king_y_1)*5 + king_x_1;
944 int newIndexX=po+3*(es+8*(rel_y_2+5*(x_diff_2+5*king_x_1)));
945 int newIndexY=po+3*(es+8*(rel_y_2+5*(rel_x+3*king_y_1)));
946 int newIndex=po+3*(es+8*(rel_y_2+5*(x_diff_2+5*(king_x_1+5*king_y_1))));
953 template <osl::Player Defense>
958 NumBitmapEffect effect=state.effectSetAt(target);
959 const int d_effect=effect.countEffect(Defense);
961 return effect_state_table[a_effect*16+d_effect];
964 template <osl::Player Defense>
966 const NumEffectState &state,
968 int rel_y,
int king_x,
int king_y,
int x_diff)
970 const Piece piece = state.pieceAt(target);
975 #ifdef __INTEL_COMPILER
976 piece_owner = (
unsigned int)((
int)(ptypeO)>>30);
978 piece_owner |= (ptypeO+14)>>4;
980 piece_owner=((ptypeO+14)>>4)|(((
unsigned int)ptypeO>>30)&0x2);
984 piece_owner=(((ptypeO+14)>>3)&0x2)|((
unsigned int)ptypeO>>31);
986 assert(piece_owner >= 0 && piece_owner < 3);
987 int effect_state_index = effectStateIndex3<Defense>(state,
target);
989 index_xy=piece_owner+effect_state_index+3*(8*((rel_y+2)+5*((x_diff+2)+5*(king_x-1+5*(king_y-1)))));
992 template <osl::Player Defense>
997 const Square king = state.kingSquare<Defense>();
998 const int min_dx =
std::max(1, king.
x() - 2)-king.
x();
999 const int max_dx =
std::min(9, king.
x() + 2)-king.
x();
1000 const int min_dy =
std::max(1, king.
y() - 2)-king.
y();
1001 const int max_dy =
std::min(9, king.
y() + 2)-king.
y();
1002 const int king_x = (king.
x() > 5 ? 10 - king.
x() : king.
x());
1003 const int king_y = (Defense ==
BLACK ? king.
y() : 10 - king.
y());
1004 if ((Defense ==
BLACK && king.
x() >= 6) ||
1005 (Defense ==
WHITE && king.
x() >= 5)){
1006 for (
int dx = min_dx; dx <= max_dx; ++dx)
1012 for (
int dy = min_dy; dy <= max_dy; ++dy)
1016 const int rel_y = dy * (Defense ==
BLACK ? 1 : -1);
1018 index<Defense>(state,
target, index_xy,
1019 rel_y,king_x,king_y,x_diff);
1020 out += xy_table[index_xy];
1025 for (
int dx = min_dx; dx <= max_dx; ++dx)
1031 for (
int dy = min_dy; dy <= max_dy; ++dy)
1035 const int rel_y = dy * (Defense ==
BLACK ? 1 : -1);
1037 index<Defense>(state,
target, index_xy,
1038 rel_y,king_x,king_y,x_diff);
1039 out += xy_table[index_xy];
1043 if (Defense !=
BLACK)
1053 evalOne<BLACK>(state, out[
BLACK]);
1054 evalOne<WHITE>(state, out[
WHITE]);
1059 const NumEffectState &state,
Move last_move,
1062 BoardMask mb = state.changedEffects(
BLACK), mw = state.changedEffects(
WHITE);
1065 const Square kb = state.kingSquare<
BLACK>(), kw = state.kingSquare<
WHITE>();
1072 evalOne<BLACK>(state, values[
BLACK]);
1076 evalOne<WHITE>(state, values[
WHITE]);
1081 template <
bool Opening>
1084 template <
bool Opening>
1088 for (
size_t i = 0; i < weights.
dimension(); ++i)
1090 table[i] = weights.
value(i);
1094 template <
bool Opening>
1095 template <osl::Player player>
1100 if ((player ==
BLACK && king.
x() >= 6) ||
1101 (player ==
WHITE && king.
x() >= 5))
1104 target_x = 10 - target.
x();
1109 target_x = target.
x();
1111 const int y = (player ==
BLACK ? king.
y() : 10 - king.
y());
1112 const int target_y = (player ==
BLACK ? target.
y() : 10 - target.
y());
1114 return target_y - y + 2 + (target_x - x + 2 ) * 5 + (y - 1) * 5 * 5
1115 + (x - 1) * 5 * 5 * 9;
1118 template <
bool Opening>
1119 template <osl::Player Defense>
1125 const int min_x =
std::max(1, king.
x() - 2);
1126 const int max_x =
std::min(9, king.
x() + 2);
1127 const int min_y =
std::max(1, king.
y() - 2);
1128 const int max_y =
std::min(9, king.
y() + 2);
1129 for (
int x = min_x; x <= max_x; ++x)
1131 for (
int y = min_y; y <= max_y; ++y)
1136 result += table[index<Defense>(king,
target)];
1140 if (Defense ==
BLACK)
1146 template <
bool Opening>
1150 return evalOne<BLACK>(state) + evalOne<WHITE>(state);
1153 template <
bool Opening>
1169 if (std::abs(self_king.
x() - from.
x()) <= 2 &&
1170 std::abs(self_king.
y() - from.
y()) <= 2)
1172 result += table[index(self_king, moved.
from(), moved.
player())] *
1176 if (std::abs(opp_king.
x() - from.
x()) <= 2 &&
1177 std::abs(opp_king.
y() - from.
y()) <= 2)
1179 result -= table[index(opp_king, from,
alt(moved.
player()))] *
1188 if (std::abs(self_king.
x() - to.
x()) <= 2 &&
1189 std::abs(self_king.
y() - to.
y()) <= 2)
1191 result -= table[index(self_king, to, moved.
player())] *
1194 if (std::abs(opp_king.
x() - to.
x()) <= 2 &&
1195 std::abs(opp_king.
y() - to.
y()) <= 2)
1197 result += table[index(opp_king, to,
alt(moved.
player()))] *
1211 for (
int i = 0; i < ONE_DIM; ++i)
1214 table[i][s] = weights.
value(i + ONE_DIM*s);
1220 for (
int i = 0; i < X_DIM; ++i)
1225 for (
int i = 0; i < Y_DIM; ++i)
1232 template <osl::Player King>
1236 const Square king = state.kingSquare<King>();
1237 const int vertical_index =
1238 index<King, VERTICAL>(
1241 const int vertical_index_x =
1242 indexX<King, VERTICAL>(
1246 const int vertical_index_y =
1247 indexY<King, VERTICAL>(
1251 const int horizontal_index =
1252 index<King, HORIZONTAL>(
1255 const int horizontal_index_x =
1256 indexX<King, HORIZONTAL>(
1260 const int horizontal_index_y =
1261 indexY<King, HORIZONTAL>(
1265 const int diagonal_index1 =
1266 index<King, DIAGONAL>(
1269 const int diagonal_index2 =
1270 index<King, DIAGONAL>(
1273 const int diagonal_index1_x =
1274 indexX<King, DIAGONAL>(
1278 const int diagonal_index2_x=
1279 indexX<King, DIAGONAL>(
1283 const int diagonal_index1_y =
1284 indexY<King, DIAGONAL>(
1288 const int diagonal_index2_y =
1289 indexY<King, DIAGONAL>(
1293 const MultiInt v = value(vertical_index, horizontal_index,
1294 diagonal_index1, diagonal_index2,
1295 vertical_index_x, horizontal_index_x,
1296 diagonal_index1_x, diagonal_index2_x,
1297 vertical_index_y , horizontal_index_y,
1298 diagonal_index1_y, diagonal_index2_y);
1313 evalOne<BLACK>(state,
result);
1314 evalOne<WHITE>(state,
result);
1320 const NumEffectState &state,
1324 const CArray<Square,2> kings = {{
1325 state.kingSquare(
BLACK),
1326 state.kingSquare(
WHITE),
1328 if ((std::abs(last_move.
to().
x() - kings[0].x()) <= 1 &&
1329 std::abs(last_move.
to().
y() - kings[0].y()) <= 1) ||
1330 (std::abs(last_move.
to().
x() - kings[1].x()) <= 1 &&
1331 std::abs(last_move.
to().
y() - kings[1].y()) <= 1))
1335 if ((std::abs(last_move.
from().
x() - kings[0].x()) <= 1 &&
1336 std::abs(last_move.
from().
y() - kings[0].y()) <= 1) ||
1337 (std::abs(last_move.
from().
x() - kings[1].x()) <= 1 &&
1338 std::abs(last_move.
from().
y() - kings[1].y()) <= 1))
1360 static CArray<MultiInt, 3240> old_table;
1361 for (
int i = 0; i < ONE_DIM; ++i)
1364 old_table[i][s] = weights.
value(i + ONE_DIM*s);
1366 for(
int king_x=0;king_x<5;king_x++)
1367 for(
int king_y=0;king_y<9;king_y++)
1368 for(
int dir=0;dir<8;dir++)
1369 for(
int mobility=0;mobility<9;mobility++){
1370 int oldIndex=king_x + 5 * (king_y + 9 * (dir + 8 * mobility));
1371 int newIndex=mobility+9*(dir+8*(king_y+9*king_x));
1373 table[newIndex][s]=old_table[oldIndex][s];
1380 static CArray<MultiInt, 3240> old_table;
1381 for (
int i = 0; i < ONE_DIM; ++i)
1384 old_table[i][s] = weights.
value(i + ONE_DIM*s);
1386 for(
int king_x=0;king_x<5;king_x++)
1387 for(
int king_y=0;king_y<9;king_y++)
1388 for(
int dir=0;dir<8;dir++)
1389 for(
int mobility=0;mobility<9;mobility++){
1390 int oldIndex=king_x + 5 * (king_y + 9 * (dir + 8 * mobility));
1391 int newIndex=mobility+9*(dir+8*(king_y+9*king_x));
1400 static CArray<MultiInt, 3240> old_table;
1401 for (
int i = 0; i < ONE_DIM; ++i)
1404 old_table[i][s] = weights.
value(i + ONE_DIM*s);
1406 for(
int king_x=0;king_x<5;king_x++)
1407 for(
int king_y=0;king_y<9;king_y++)
1408 for(
int dir=0;dir<8;dir++)
1409 for(
int mobility=0;mobility<9;mobility++){
1410 int oldIndex=king_x + 5 * (king_y + 9 * (dir + 8 * mobility));
1411 int newIndex=mobility+9*(dir+8*(king_y+9*king_x));
1415 for(
int i=0;i<3240;i++){
1423 template <osl::Player P>
1428 const Square king = state.kingSquare<P>();
1429 const int king_x = (king.
x() > 5 ? 10 - king.
x() : king.
x()) - 1;
1430 const int king_y = (P ==
BLACK ? king.
y() : 10 - king.
y()) - 1;
1431 int indexBase=9*8*(king_y+9*king_x);
1433 if (state.hasPieceOnStand<
ROOK>(
alt(P)))
1435 if(state.hasPieceOnStand<
BISHOP>(
alt(P))){
1437 rook_bishop_table[indexBase+0*9+mobilityDir<UL>(king,state.kingMobilityAbs(P,
UL))]+
1438 rook_bishop_table[indexBase+1*9+mobilityDir<U>(king,state.kingMobilityAbs(P,
U))]+
1439 rook_bishop_table[indexBase+2*9+mobilityDir<UR>(king,state.kingMobilityAbs(P,
UR))]+
1440 rook_bishop_table[indexBase+3*9+mobilityDir<L>(king,state.kingMobilityAbs(P,
L))]+
1441 rook_bishop_table[indexBase+4*9+mobilityDir<R>(king,state.kingMobilityAbs(P,
R))]+
1442 rook_bishop_table[indexBase+5*9+mobilityDir<DL>(king,state.kingMobilityAbs(P,
DL))]+
1443 rook_bishop_table[indexBase+6*9+mobilityDir<D>(king,state.kingMobilityAbs(P,
D))]+
1444 rook_bishop_table[indexBase+7*9+mobilityDir<DR>(king,state.kingMobilityAbs(P,
DR))];
1448 rook_table[indexBase+0*9+mobilityDir<UL>(king,state.kingMobilityAbs(P,
UL))]+
1449 rook_table[indexBase+1*9+mobilityDir<U>(king,state.kingMobilityAbs(P,
U))]+
1450 rook_table[indexBase+2*9+mobilityDir<UR>(king,state.kingMobilityAbs(P,
UR))]+
1451 rook_table[indexBase+3*9+mobilityDir<L>(king,state.kingMobilityAbs(P,
L))]+
1452 rook_table[indexBase+4*9+mobilityDir<R>(king,state.kingMobilityAbs(P,
R))]+
1453 rook_table[indexBase+5*9+mobilityDir<DL>(king,state.kingMobilityAbs(P,
DL))]+
1454 rook_table[indexBase+6*9+mobilityDir<D>(king,state.kingMobilityAbs(P,
D))]+
1455 rook_table[indexBase+7*9+mobilityDir<DR>(king,state.kingMobilityAbs(P,
DR))];
1458 else if(state.hasPieceOnStand<
BISHOP>(
alt(P))){
1460 bishop_table[indexBase+0*9+mobilityDir<UL>(king,state.kingMobilityAbs(P,
UL))]+
1461 bishop_table[indexBase+1*9+mobilityDir<U>(king,state.kingMobilityAbs(P,
U))]+
1462 bishop_table[indexBase+2*9+mobilityDir<UR>(king,state.kingMobilityAbs(P,
UR))]+
1463 bishop_table[indexBase+3*9+mobilityDir<L>(king,state.kingMobilityAbs(P,
L))]+
1464 bishop_table[indexBase+4*9+mobilityDir<R>(king,state.kingMobilityAbs(P,
R))]+
1465 bishop_table[indexBase+5*9+mobilityDir<DL>(king,state.kingMobilityAbs(P,
DL))]+
1466 bishop_table[indexBase+6*9+mobilityDir<D>(king,state.kingMobilityAbs(P,
D))]+
1467 bishop_table[indexBase+7*9+mobilityDir<DR>(king,state.kingMobilityAbs(P,
DR))];
1471 table[indexBase+0*9+mobilityDir<UL>(king,state.kingMobilityAbs(P,
UL))]+
1472 table[indexBase+1*9+mobilityDir<U>(king,state.kingMobilityAbs(P,
U))]+
1473 table[indexBase+2*9+mobilityDir<UR>(king,state.kingMobilityAbs(P,
UR))]+
1474 table[indexBase+3*9+mobilityDir<L>(king,state.kingMobilityAbs(P,
L))]+
1475 table[indexBase+4*9+mobilityDir<R>(king,state.kingMobilityAbs(P,
R))]+
1476 table[indexBase+5*9+mobilityDir<DL>(king,state.kingMobilityAbs(P,
DL))]+
1477 table[indexBase+6*9+mobilityDir<D>(king,state.kingMobilityAbs(P,
D))]+
1478 table[indexBase+7*9+mobilityDir<DR>(king,state.kingMobilityAbs(P,
DR))];
1482 if (state.hasPieceOnStand<
ROOK>(
alt(P)))
1484 if(state.hasPieceOnStand<
BISHOP>(
alt(P))){
1486 rook_bishop_table[indexBase+7*9+mobilityDir<UL>(king,state.kingMobilityAbs(P,
UL))]+
1487 rook_bishop_table[indexBase+6*9+mobilityDir<U>(king,state.kingMobilityAbs(P,
U))]+
1488 rook_bishop_table[indexBase+5*9+mobilityDir<UR>(king,state.kingMobilityAbs(P,
UR))]+
1489 rook_bishop_table[indexBase+4*9+mobilityDir<L>(king,state.kingMobilityAbs(P,
L))]+
1490 rook_bishop_table[indexBase+3*9+mobilityDir<R>(king,state.kingMobilityAbs(P,
R))]+
1491 rook_bishop_table[indexBase+2*9+mobilityDir<DL>(king,state.kingMobilityAbs(P,
DL))]+
1492 rook_bishop_table[indexBase+1*9+mobilityDir<D>(king,state.kingMobilityAbs(P,
D))]+
1493 rook_bishop_table[indexBase+0*9+mobilityDir<DR>(king,state.kingMobilityAbs(P,
DR))]);
1497 rook_table[indexBase+7*9+mobilityDir<UL>(king,state.kingMobilityAbs(P,
UL))]+
1498 rook_table[indexBase+6*9+mobilityDir<U>(king,state.kingMobilityAbs(P,
U))]+
1499 rook_table[indexBase+5*9+mobilityDir<UR>(king,state.kingMobilityAbs(P,
UR))]+
1500 rook_table[indexBase+4*9+mobilityDir<L>(king,state.kingMobilityAbs(P,
L))]+
1501 rook_table[indexBase+3*9+mobilityDir<R>(king,state.kingMobilityAbs(P,
R))]+
1502 rook_table[indexBase+2*9+mobilityDir<DL>(king,state.kingMobilityAbs(P,
DL))]+
1503 rook_table[indexBase+1*9+mobilityDir<D>(king,state.kingMobilityAbs(P,
D))]+
1504 rook_table[indexBase+0*9+mobilityDir<DR>(king,state.kingMobilityAbs(P,
DR))]);
1507 else if(state.hasPieceOnStand<
BISHOP>(
alt(P))){
1509 bishop_table[indexBase+7*9+mobilityDir<UL>(king,state.kingMobilityAbs(P,
UL))]+
1510 bishop_table[indexBase+6*9+mobilityDir<U>(king,state.kingMobilityAbs(P,
U))]+
1511 bishop_table[indexBase+5*9+mobilityDir<UR>(king,state.kingMobilityAbs(P,
UR))]+
1512 bishop_table[indexBase+4*9+mobilityDir<L>(king,state.kingMobilityAbs(P,
L))]+
1513 bishop_table[indexBase+3*9+mobilityDir<R>(king,state.kingMobilityAbs(P,
R))]+
1514 bishop_table[indexBase+2*9+mobilityDir<DL>(king,state.kingMobilityAbs(P,
DL))]+
1515 bishop_table[indexBase+1*9+mobilityDir<D>(king,state.kingMobilityAbs(P,
D))]+
1516 bishop_table[indexBase+0*9+mobilityDir<DR>(king,state.kingMobilityAbs(P,
DR))]);
1520 table[indexBase+7*9+mobilityDir<UL>(king,state.kingMobilityAbs(P,
UL))]+
1521 table[indexBase+6*9+mobilityDir<U>(king,state.kingMobilityAbs(P,
U))]+
1522 table[indexBase+5*9+mobilityDir<UR>(king,state.kingMobilityAbs(P,
UR))]+
1523 table[indexBase+4*9+mobilityDir<L>(king,state.kingMobilityAbs(P,
L))]+
1524 table[indexBase+3*9+mobilityDir<R>(king,state.kingMobilityAbs(P,
R))]+
1525 table[indexBase+2*9+mobilityDir<DL>(king,state.kingMobilityAbs(P,
DL))]+
1526 table[indexBase+1*9+mobilityDir<D>(king,state.kingMobilityAbs(P,
D))]+
1527 table[indexBase+0*9+mobilityDir<DR>(king,state.kingMobilityAbs(P,
DR))]);
1545 CArray<MultiInt, 2925> old_table;
1546 for (
int i = 0; i < ONE_DIM; ++i)
1549 old_table[i][s] = weights.
value(i + ONE_DIM*s);
1551 for(
int king_x=0;king_x<5;king_x++)
1552 for(
int king_y=0;king_y<9;king_y++)
1553 for(
int mobility=0;mobility<=32;mobility++){
1554 int oldIndex=king_x+5*(king_y+9*(mobility+8));
1555 int newIndex=mobility+33*(king_y+9*king_x);
1557 table[newIndex]=old_table[oldIndex];
1561 template <osl::Player P>
1566 const Square king = state.kingSquare<P>();
1567 int sum=state.kingMobilityAbs(P,
UL).
y()+state.kingMobilityAbs(P,
U).y()+
1568 state.kingMobilityAbs(P,
UR).y()+state.kingMobilityAbs(P,
R).x()-
1569 state.kingMobilityAbs(P,
DL).y()-state.kingMobilityAbs(P,
D).y()-
1570 state.kingMobilityAbs(P,
DR).y()-state.kingMobilityAbs(P,
L).x();
1571 const int king_x = (king.
x() > 5 ? 10 - king.
x() : king.
x()) - 1;
1572 const int king_y = (P ==
BLACK ? king.
y() : 10 - king.
y()) - 1;
1574 result = table[mobility+33*(king_y+9*king_x)];
1602 for (
int i = 0; i < ONE_DIM; ++i)
1605 table[i][s] = weights.
value(i + ONE_DIM*s);
1611 for (
int i = 0; i < ONE_DIM; ++i)
1620 for (
int i = 0; i < ONE_DIM; ++i)
1625 for(
int king_y=1;king_y<=9;king_y++)
1626 for(
int effect1=0;effect1<32;effect1++)
1627 for(
int effect2=0;effect2<32;effect2++)
1628 for(
int i=0;i<8;i++){
1629 int index0=effect1 + 32 * (effect2 + 32 * i);
1630 int index1=king_y - 1 + 9 *(effect1 + 32 * (effect2 + 32 * i));
1635 template<osl::Player P>
1638 const CArray<int, 5> &effects)
1640 const Square king=state.kingSquare<P>();
1641 const int king_y = (P==
BLACK ? king.
y() : 10 - king.
y());
1642 const int king_x = (king.
x() >= 6 ? 10 - king.
x() : king.
x());
1643 if ((P==
BLACK && king.
x() > 5) || (P==
WHITE && king.
x() < 5)){
1645 x_table[indexX(king_x,effects[2],effects[0],(2*3)+1)]+
1646 y_table[indexY(king_y,effects[0],effects[2],(0*3)+0)]+
1647 x_table[indexX(king_x,effects[3],effects[0],(1*3)+2)]+
1648 y_table[indexY(king_y,effects[0],effects[3],(0*3)+1)]+
1649 x_table[indexX(king_x,effects[4],effects[0],(0*3)+2)]+
1650 y_table[indexY(king_y,effects[0],effects[4],(0*3)+2)]+
1651 x_table[indexX(king_x,effects[2],effects[1],(2*3)+0)]+
1652 y_table[indexY(king_y,effects[1],effects[2],(1*3)+0)]+
1653 x_table[indexX(king_x,effects[3],effects[1],(1*3)+1)]+
1654 y_table[indexY(king_y,effects[1],effects[3],(1*3)+1)]+
1655 x_table[indexX(king_x,effects[4],effects[1],(0*3)+1)]+
1656 y_table[indexY(king_y,effects[1],effects[4],(1*3)+2)]+
1657 x_table[indexX(king_x,effects[3],effects[2],(1*3)+0)]+
1658 y_table[indexY(king_y,effects[2],effects[3],(2*3)+0)]+
1659 x_table[indexX(king_x,effects[4],effects[2],(0*3)+0)]+
1660 y_table[indexY(king_y,effects[2],effects[4],(2*3)+1)];
1664 x_table[indexX(king_x,effects[0],effects[2],(0*3)+0)]+
1665 y_table[indexY(king_y,effects[0],effects[2],(0*3)+0)]+
1666 x_table[indexX(king_x,effects[0],effects[3],(0*3)+1)]+
1667 y_table[indexY(king_y,effects[0],effects[3],(0*3)+1)]+
1668 x_table[indexX(king_x,effects[0],effects[4],(0*3)+2)]+
1669 y_table[indexY(king_y,effects[0],effects[4],(0*3)+2)]+
1670 x_table[indexX(king_x,effects[1],effects[2],(1*3)+0)]+
1671 y_table[indexY(king_y,effects[1],effects[2],(1*3)+0)]+
1672 x_table[indexX(king_x,effects[1],effects[3],(1*3)+1)]+
1673 y_table[indexY(king_y,effects[1],effects[3],(1*3)+1)]+
1674 x_table[indexX(king_x,effects[1],effects[4],(1*3)+2)]+
1675 y_table[indexY(king_y,effects[1],effects[4],(1*3)+2)]+
1676 x_table[indexX(king_x,effects[2],effects[3],(2*3)+0)]+
1677 y_table[indexY(king_y,effects[2],effects[3],(2*3)+0)]+
1678 x_table[indexX(king_x,effects[2],effects[4],(2*3)+1)]+
1679 y_table[indexY(king_y,effects[2],effects[4],(2*3)+1)];
1685 const CArray<int, 5> &black,
1686 const CArray<int, 5> &white)
1688 return evalOne<BLACK>(state,black)-evalOne<WHITE>(state,white);
1698 for (
int i = 0; i < ONE_DIM; ++i)
1701 table[i][s] = weights.
value(i + ONE_DIM*s);
1707 for (
int i = 0; i < ONE_DIM; ++i)
1714 template <osl::Player Attack>
1719 king25 = king25 & state.piecesOnBoard(Attack);
1720 const PieceMask promoted_mask = (king25 & state.promotedPieces());
1721 const bool with_knight =
1722 (king25 & ~state.promotedPieces()).
template selectBit<KNIGHT>().any();
1723 king25.clearBit<
KNIGHT>();
1724 king25.clearBit<
LANCE>();
1725 king25.clearBit<
PAWN>();
1726 king25 = king25 | promoted_mask;
1727 const int piece_count =
std::min(9, king25.countBit());
1728 const int stand_count =
std::min(9,
1729 state.countPiecesOnStand<
ROOK>(Attack) +
1730 state.countPiecesOnStand<
BISHOP>(Attack) +
1731 state.countPiecesOnStand<
GOLD>(Attack) +
1732 state.countPiecesOnStand<
SILVER>(Attack));
1733 const bool stand_with_knight = state.hasPieceOnStand<
KNIGHT>(Attack);
1735 PieceMask attacked =
1736 state.effectedMask(Attack) & state.piecesOnBoard(Defense);
1737 attacked.clearBit<
KNIGHT>();
1738 attacked.clearBit<
LANCE>();
1739 attacked.clearBit<
PAWN>();
1740 PieceMask attacking;
1741 while (attacked.any())
1743 const Piece piece = state.pieceOf(attacked.takeOneBit());
1744 attacking = attacking | state.effectSetAt(piece.
square());
1746 attacking = (attacking & state.piecesOnBoard(Attack) & ~king25);
1747 const int attacked_count =
std::min(5, attacking.countBit());
1748 if (Attack ==
BLACK)
1750 return table[index(piece_count, with_knight,
1751 stand_count, stand_with_knight, attacked_count)] +
1752 y_table[indexY(piece_count, with_knight,
1753 stand_count, stand_with_knight, attacked_count,
1754 state.kingSquare<
WHITE>().y())];
1758 return -(table[index(piece_count, with_knight,
1759 stand_count, stand_with_knight, attacked_count)] +
1760 y_table[indexY(piece_count, with_knight,
1761 stand_count, stand_with_knight, attacked_count,
1762 10 - state.kingSquare<
BLACK>().y())]);
1768 const CArray<PieceMask, 2> &king25_mask)
1770 return evalOne<BLACK>(state, king25_mask[
WHITE]) +
1771 evalOne<WHITE>(state, king25_mask[
BLACK]);
1784 for (
int i = 0; i < ONE_DIM; ++i)
1787 table[i][s] = weights.
value(i + ONE_DIM*s);
1793 for (
int i = 0; i < ONE_DIM; ++i)
1802 for (
int i = 0; i < ONE_DIM; ++i)
1811 const CArray<int, 5> &black,
1812 const CArray<int, 5> &white)
1814 const CArray<Square,2> kings = {{
1815 state.kingSquare<
BLACK>(),
1816 state.kingSquare<
WHITE>(),
1819 for (
size_t i = 1; i < black.size(); ++i)
1821 result += (table[index(black[i - 1], black[i], i - 1)] +
1823 black[i - 1], black[i], i - 1)] +
1825 black[i - 1], black[i], i - 1)]);
1826 result -= (table[index(white[i - 1], white[i], i - 1)] +
1828 white[i - 1], white[i], i - 1)] +
1830 white[i - 1], white[i], i - 1)]);
1843 for (
int i = 0; i < ONE_DIM; ++i)
1846 table[i][s] = weights.
value(i + ONE_DIM*s);
1852 for (
int i = 0; i < ONE_DIM; ++i)
1859 template <osl::Player Attack>
1865 PieceMask attack = king25 & state.piecesOnBoard(Attack);
1867 king25 & state.piecesOnBoard(Defense);
1868 const PieceMask attack_promoted_mask = (attack & state.promotedPieces());
1869 const PieceMask defense_promoted_mask = (defense & state.promotedPieces());
1870 attack.clearBit<
KNIGHT>();
1871 attack.clearBit<
LANCE>();
1872 attack.clearBit<
PAWN>();
1873 attack = attack | attack_promoted_mask;
1874 defense.clearBit<
KNIGHT>();
1875 defense.clearBit<
LANCE>();
1876 defense.clearBit<
PAWN>();
1877 defense = defense | defense_promoted_mask;
1878 const int attack_count =
std::min(9,
1880 state.countPiecesOnStand<
ROOK>(Attack) +
1881 state.countPiecesOnStand<
BISHOP>(Attack) +
1882 state.countPiecesOnStand<
GOLD>(Attack) +
1883 state.countPiecesOnStand<
SILVER>(Attack));
1884 const int defense_count =
std::min(9,
1885 defense.countBit() +
1886 state.countPiecesOnStand<
ROOK>(Defense) +
1887 state.countPiecesOnStand<
BISHOP>(Defense) +
1888 state.countPiecesOnStand<
GOLD>(Defense) +
1889 state.countPiecesOnStand<
SILVER>(Defense));
1890 const int y = (Attack ==
BLACK ? state.kingSquare<Defense>().y() :
1891 10 - state.kingSquare<Defense>().y());
1893 y_table[y - 1 + 9 * (attack_count + 10 * defense_count)];
1894 if (Attack ==
BLACK)
1902 const CArray<PieceMask, 2> &king25_mask)
1904 return evalOne<BLACK>(state, king25_mask[
WHITE]) +
1905 evalOne<WHITE>(state, king25_mask[
BLACK]);
1913 for (
size_t i=0; i<weights.
dimension(); ++i)
1914 table[i] = weights.
value(i);
1920 if (state.promotedPieces().any())
1922 PieceMask stand_all = state.standMask(
BLACK) | state.standMask(
WHITE);
1923 stand_all.clearBit<
BISHOP>();
1924 stand_all.clearBit<
PAWN>();
1925 if (stand_all.any())
1927 if (state.nth<
BISHOP>(0).owner() == state.nth<
BISHOP>(1).owner())
1929 if (state.nth<
BISHOP>(0).isOnBoard() != state.nth<
BISHOP>(1).isOnBoard())
1932 if (state.nth<
BISHOP>(0).isOnBoard()) {
1933 offset += BISHOP_ONE_DIM;
1934 if (state.hasEffectByPiece(state.nth<
BISHOP>(0),
1935 state.nth<
BISHOP>(1).square()))
1936 offset += BISHOP_ONE_DIM;
1938 return evalOne<BLACK>(state, offset) + evalOne<WHITE>(state, offset);
1941 template <osl::Player KingOwner>
1945 Square king = state.kingSquare(KingOwner);
1949 CArray<Piece,2> rook = {{
1952 if (rook[0].owner() == rook[1].owner())
1954 if (rook[0].owner() == KingOwner)
1955 std::swap(rook[0], rook[1]);
1956 int rook_index0 = indexKing(rook[0].square().squareForBlack(KingOwner));
1957 if (rook_index0 < 0)
1959 int rook_index1 = indexKing(rook[1].square().squareForBlack(
alt(KingOwner)));
1960 if (rook_index1 < 0)
1962 FixedCapacityVector<Square, 4> silver;
1963 for (
int i=0; i<state.nthLimit<
SILVER>(); ++i) {
1966 if (p.
owner() == KingOwner)
1970 if (silver.size() != 2 || silver[0].x() == silver[1].x())
1973 = indexSilver((silver[0].x() > silver[1].x()) ? silver[0] : silver[1]);
1974 int index = offset + (king_index*81+silver_index)*90;
1975 return table[index + rook_index0] *
playerToMul(KingOwner)
1976 + table[index + 45 + rook_index1] *
playerToMul(KingOwner);
1982 template <osl::Player KingOwner>
1986 Square king = state.kingSquare(KingOwner);
1987 if (king.
y() < 4 || king.
y() > 6)
1989 CArray2d<int, 2, 2>
count = {{{ 0 }}};
2010 return evalOne<BLACK>(state) + evalOne<WHITE>(state);
2017 for (
size_t i=0; i<weights.
dimension(); ++i)
2018 table[i] = weights.
value(i);
2029 template MultiInt KingPieceRelative::
2030 evalWithUpdate<BLACK>(
const NumEffectState &state,
2032 template MultiInt KingPieceRelative::
2033 evalWithUpdate<WHITE>(
const NumEffectState &state,
2042 template void King25EffectBoth::countEffectAndPiecesBoth<BLACK>(
const NumEffectState&, PieceMask&, PieceMask&,
int&,
int&,
int&,
int&,
int&, CArray<int, 5>&, CArray<int, 5>&);
2043 template void King25EffectBoth::countEffectAndPiecesBoth<WHITE>(
const NumEffectState&, PieceMask&, PieceMask&,
int&,
int&,
int&,
int&,
int&, CArray<int, 5>&, CArray<int, 5>&);