17 for (
int x=1; x<=9; ++x) {
18 for (
int y=1; y<=9; ++y) {
19 const Square position(x,y);
28 const NumEffectState& state = *info.
state;
32 const CArray<Square,2> kings = {{
33 state.kingSquare(
BLACK),
34 state.kingSquare(
WHITE),
36 const Player turn = state.turn();
44 std::pair<Ptype,Ptype> pair;
48 int effect9 = classifyEffect9(state, turn, position);
49 cache[cur++] = basic + pair.first;
50 cache[cur++] = basic + AttackBase + pair.second;
51 cache[cur++] = basic + EffectBase + effect9;
58 cache[cur++] = basic + AttackBase +
PTYPE_EDGE;
60 assert(basic + EffectBase + effect9 < PatternCacheSize);
61 int op_king_distance = abs(kings[
alt(turn)].x()-position.
x())
62 + abs(kings[
alt(turn)].y()-position.
y());
63 if (op_king_distance == 0)
64 op_king_distance = state.king8Info(
alt(turn)).libertyCount();
67 if (op_king_distance < OpKingSize)
68 cache[cur++] = basic + OpKingBase + op_king_distance;
69 int my_king_distance = abs(kings[turn].x()-position.
x())
70 + abs(kings[turn].y()-position.
y());
71 if (my_king_distance == 0)
72 my_king_distance = state.king8Info(turn).libertyCount();
75 if (my_king_distance < MyKingSize)
76 cache[cur++] = basic + MyKingBase + my_king_distance;
79 cache[cur++] = basic + PromotionBase;
81 cache[cur++] = basic + PromotionBase + 1;
84 if (state.pinOrOpen(turn).test(target.
number()))
85 cache[cur++] = basic + PinOpenBase + (target.
owner() == turn);
86 if (state.pinOrOpen(
alt(turn)).test(target.
number()))
87 cache[cur++] = basic + PinOpenBase + 2 + (target.
owner() ==
alt(turn));
89 if (info.
history->hasLastMove()) {
90 if (info.
history->lastMove().to() == position)
91 cache[cur++] = basic + LastToBase;
92 for (
int i=1; i<4; ++i) {
93 if (! info.
history->hasLastMove(i+1))
95 if (info.
history->lastMove(i+1).to() == position)
96 cache[cur++] = basic + LastToBase + i;
101 if (info.
history->hasLastMove()) {
103 cache[cur++] = basic + LastEffectChangedBase;
106 cache[cur++] = basic + LastEffectChangedBase + ptype_index;
116 const NumEffectState& state = *info.
state;
118 i<PtypeTraits<LANCE>::indexLimit; ++i) {
119 const Piece p = state.pieceOf(i);
123 makeLongAttackOne(info, p, d);
126 i<PtypeTraits<BISHOP>::indexLimit; ++i) {
127 const Piece p = state.pieceOf(i);
130 makeLongAttackOne(info, p,
UL);
131 makeLongAttackOne(info, p,
UR);
132 makeLongAttackOne(info, p,
DL);
133 makeLongAttackOne(info, p,
DR);
136 i<PtypeTraits<ROOK>::indexLimit; ++i) {
137 const Piece p = state.pieceOf(i);
140 makeLongAttackOne(info, p,
L);
141 makeLongAttackOne(info, p,
R);
142 makeLongAttackOne(info, p,
U);
143 makeLongAttackOne(info, p,
D);
151 const NumEffectState& state = *info.
state;
154 const Player turn = state.turn();
158 Square attack_to2 = attack_to;
159 assert(! attack_to.isPieceStand());
160 if (attack_to.isEdge())
165 if (state.pieceAt(attack_to2).isEmpty()) {
168 }
while (state.pieceAt(attack_to2).isEmpty());
169 if (state.pieceAt(attack_to2).isEdge())
173 PtypeO attacked = state.pieceOnBoard(attack_to).ptypeO();
175 attacked =
alt(attacked);
176 int index = (longAttackIndex(attacking)*
PTYPEO_SIZE
178 out.push_back(index);
180 out.push_back(index + 1);
181 if (! state.hasEffectAt(turn, attack_to))
182 out.push_back(index + 2);
183 if (attack_to.canPromote(
alt(turn)))
184 out.push_back(index + 3);
185 Piece attacked2 = state.pieceAt(attack_to2);
187 out.push_back(index + 4);
188 if (! state.hasEffectAt(turn, attack_to2))
189 out.push_back(index + 5);
191 out.push_back(index + 6);
196 if (threat_at == attack_to
199 piece.
square(), attack_to)))
200 out.push_back(index + 7);