My Project
move_probability/feature.h
Go to the documentation of this file.
1 /* feature.h
2  */
3 #ifndef OSL_MOVE_PROBABILITY_FEATURE_H
4 #define OSL_MOVE_PROBABILITY_FEATURE_H
5 
8 #include "osl/additionalEffect.h"
10 #include <string>
11 
12 namespace osl
13 {
14  namespace move_probability
15  {
16  class Feature
17  {
18  std::string my_name;
19  int dim;
20  public:
21  Feature(std::string n, size_t d) : my_name(n), dim(d)
22  {
23  assert(dim > 0);
24  }
25  virtual ~Feature();
26  std::string name() const { return my_name; }
27  virtual double match(const StateInfo&, const MoveInfo&, int offset, const double *) const=0;
28  size_t dimension() const { return dim; }
29 
30  static int classifyEffect9(const NumEffectState& state, Player player, Square to)
31  {
32  const int a = std::min(2, state.countEffect(player, to));
33  int d = std::min(2,state.countEffect(alt(player), to));
34  if (a>d)
35  d += AdditionalEffect::hasEffect(state, to, alt(player));
36  return a*3 + d;
37  }
38  };
39 
40  class CheckFeature : public Feature
41  {
42  public:
43  enum { CHECK_CLASS = 4, RELATIVE_Y_CLASS = 3 };
46  {
47  }
48  static int checkIndex(const MoveInfo& move)
49  {
50  if (move.open_check)
51  return 3;
52  return (move.see > 0) ? 0 : ((move.see == 0) ? 1 : 2);
53  }
54  static int sign(const NumEffectState& state, Move move,
55  Player player)
56  {
57  const Square king = state.kingSquare(alt(player));
58  int ry = (move.to().y() - king.y())*osl::sign(player);
59  if (ry == 0) return 0;
60  return ry > 0 ? 1 : -1;
61  }
62  double match(const StateInfo& state, const MoveInfo& move, int offset, const double *w) const
63  {
64  if (! move.check && ! move.open_check)
65  return 0;
66  const Player player = move.player;
67  int index = sign(*state.state, move.move, player)+1;
68  index = (index*2 + move.move.isDrop())*PTYPE_SIZE
69  + move.move.ptype();
70  index = index*CHECK_CLASS + checkIndex(move);
71  return w[offset+index];
72  }
73  };
74  class TakeBackFeature : public Feature
75  {
76  public:
77  TakeBackFeature() : Feature("TakeBack", 3)
78  {
79  }
80  double match(const StateInfo& state, const MoveInfo& move, int offset, const double *w) const
81  {
82  if (! state.history->hasLastMove()
83  || state.history->lastMove().to() != move.move.to())
84  return 0;
85  int match = 2;
86  if (move.see >= 0) {
87  --match;
88  if (state.history->hasLastMove(2)
89  && state.history->lastMove(2).to() == move.move.to())
90  --match;
91  }
92  return w[offset + match];
93  }
94  };
95  class SeeFeature : public Feature
96  {
97  public:
98  enum { SeeClass = 23, YClass = 3, ProgressClass = 8 };
99  SeeFeature() : Feature("SeeFeature", SeeClass*(3+ProgressClass))
100  {
101  }
102  static int seeIndex(int see)
103  {
104  int index = see / 128;
105  if (see > 0) {
106  index = std::min(10, index);
107  index += 12;
108  } else if (see == 0) {
109  index += 11;
110  } else {
111  index += 10;
112  index = std::max(0, index);
113  }
114  return index;
115  }
116  double match(const StateInfo& state, const MoveInfo& move, int offset, const double *w) const
117  {
118  const int see_index = seeIndex(move.see);
119  const Player player = move.player;
120  const Square to = move.move.to();
121  const int promote_index = to.canPromote(player)
122  ? 1 : (to.canPromote(alt(player)) ? 2 : 0);
123  double sum = w[offset+see_index+promote_index*SeeClass];
124  int progress_index = YClass + state.progress8();
125  sum += w[offset+see_index+progress_index*SeeClass];
126  return sum;
127  }
128  };
129 
130  class CapturePtype : public Feature
131  {
132  public:
133  CapturePtype() : Feature("CapturePtype", PTYPE_SIZE*PTYPE_SIZE*2*3)
134  {
135  }
136  double match(const StateInfo& state, const MoveInfo& move, int offset, const double *w) const
137  {
138  const Ptype captured = move.move.capturePtype();
139  const Player player = move.player;
140  int index = (move.move.ptype())*PTYPE_SIZE + captured;
141  static_assert(PTYPE_EDGE == 1, "");
142  if (captured != PTYPE_EMPTY
143  && captured == state.threatened[alt(player)].ptype())
144  ++index;
145  if (move.see > 0)
146  index += PTYPE_SIZE*PTYPE_SIZE;
147  if (captured != PTYPE_EMPTY)
148  index += std::min(2, state.state->countPiecesOnStand(player, unpromote(captured)))
149  * (2*PTYPE_SIZE*PTYPE_SIZE);
150  return w[offset+index];
151  }
152  };
153 
154  class ContinueCapture : public Feature
155  {
156  public:
157  ContinueCapture() : Feature("ContinueCapture", 1) {}
158  double match(const StateInfo& state, const MoveInfo& move, int offset, const double *w) const
159  {
160  if (move.move.capturePtype() == PTYPE_EMPTY
161  || ! state.history->hasLastMove(2)
162  || state.history->lastMove(2).to() != move.move.from())
163  return 0;
164  return w[offset];
165  }
166  };
167 
169  class DropCaptured : public Feature
170  {
171  public:
172  DropCaptured() : Feature("DropCaptured", PTYPE_SIZE - PTYPE_BASIC_MIN) {}
173  double match(const StateInfo& state, const MoveInfo& move, int offset, const double *w) const
174  {
175  if (! move.move.isDrop()
176  || ! state.history->hasLastMove(2)
177  || ! state.history->lastMove(2).isNormal()
178  || state.history->lastMove(2).capturePtype() != move.move.ptype())
179  return 0.0;
180  const size_t index = move.move.ptype() - PTYPE_BASIC_MIN;
181  assert(index < dimension());
182  return w[index + offset];
183  }
184  };
185 
186  class SquareY : public Feature
187  {
188  public:
189  // PTYPE_SIZE, to [1,9], fromto [-3,3], drop|promote, progress8
190  enum {
191  DIM = 9*PTYPE_SIZE*16
192  };
193  SquareY() : Feature("SquareY", DIM)
194  {
195  }
196  static int fromTo(Square to, Square from) // [-3,3]
197  {
198  return std::max(-3, std::min(to.y() - from.y(), 3));
199  }
200  double match(const StateInfo& state, const MoveInfo& info, int offset, const double *w) const
201  {
202  const Move move = info.move;
203  const Player P = info.player;
204  const Square to = move.to().squareForBlack(P);
205  size_t index = ((to.y()-1)*PTYPE_SIZE + move.ptype())*16;
206  assert(index+16 <= dimension());
207  const int from_to = move.isDrop() ? 0
208  : fromTo(to, move.from().squareForBlack(P));
209  double sum = w[offset + index + from_to + 3];
210  if (move.isDrop() || move.isPromotion())
211  sum += w[offset + index + 7];
212  sum += w[offset + index + state.progress8()+8];
213  return sum;
214  }
215  };
216 
217  class SquareX : public Feature
218  {
219  public:
220  // PTYPE_SIZE, to [1,5], fromto [-3,3], drop|promote, progress8
221  SquareX() : Feature("SquareX", 5*PTYPE_SIZE*16)
222  {
223  }
224  static int fromTo(Square to, Square from) // [-3,3]
225  {
226  return std::max(-3, std::min(to.x() - from.x(), 3));
227  }
228  double match(const StateInfo& state, const MoveInfo& info, int offset, const double *w) const
229  {
230  const Move move = info.move;
231  int to = move.to().x();
232  int from_to = move.isDrop() ? 0 : fromTo(move.to(), move.from());
233  if (to > 5) {
234  to = 10 - to;
235  from_to = -from_to;
236  }
237  size_t index = ((to-1)*PTYPE_SIZE + move.ptype())*16;
238  assert(index+16 <= dimension());
239  double sum = w[offset + index + from_to + 3];
240  if (move.isDrop() || move.isPromotion())
241  sum += w[offset + index + 7];
242  sum += w[offset + index + state.progress8()+8];
243  return sum;
244  }
245  };
246 
247  class KingRelativeY : public Feature
248  {
249  public:
250  // PTYPE_SIZE, to [-8,8], fromto [-3,3], drop|promote, progress8
251  enum { ONE_DIM = 17*PTYPE_SIZE*16 };
252  KingRelativeY() : Feature("KingRelativeY", ONE_DIM*2)
253  {
254  }
255  double match(const StateInfo& state, const MoveInfo& info, int offset, const double *w) const
256  {
257  const Move move = info.move;
258  const Player P = info.player;
259  const Ptype ptype = move.ptype();
260 
261  const Square to = move.to().squareForBlack(P);
262  const Square my_king = state.state->kingSquare(P).squareForBlack(P);
263  const Square op_king = state.state->kingSquare(alt(P)).squareForBlack(P);
264  const int from_to = move.isDrop() ? 0
265  : SquareY::fromTo(to, move.from().squareForBlack(P));
266 
267  size_t index = ((to.y()-my_king.y()+8)*PTYPE_SIZE + ptype)*16;
268  assert(index+16 <= ONE_DIM);
269  double sum = w[offset + index + from_to + 3];
270  if (move.isDrop() || move.isPromotion())
271  sum += w[offset + index + 7];
272  sum += w[offset + index + state.progress8()+8];
273 
274  index = ((to.y()-op_king.y()+8)*PTYPE_SIZE + ptype)*16;
275  assert(index+16 <= ONE_DIM);
276  sum += w[offset + ONE_DIM + index + from_to + 3];
277  if (move.isDrop() || move.isPromotion())
278  sum += w[offset + ONE_DIM + index + 7];
279  sum += w[offset + ONE_DIM + index + state.progress8()+8];
280  return sum;
281  }
282  };
283  class KingRelativeX : public Feature
284  {
285  public:
286  // PTYPE_SIZE, to [0,8], fromto [-3,3], drop|promote, progress8
287  enum { ONE_DIM = 9*PTYPE_SIZE*16 };
288  KingRelativeX() : Feature("KingRelativeX", ONE_DIM*2)
289  {
290  }
291  double match(const StateInfo& state, const MoveInfo& info, int offset, const double *w) const
292  {
293  const Move move = info.move;
294  const Player P = info.player;
295  const Ptype ptype = move.ptype();
296 
297  const Square to = move.to();
298  const Square my_king = state.state->kingSquare(P);
299  const Square op_king = state.state->kingSquare(alt(P));
300  const int from_to = move.isDrop() ? 0
301  : SquareY::fromTo(to, move.from());
302  int dx = to.x() - my_king.x(), fx = from_to;
303  if (dx < 0) {
304  dx = -dx;
305  fx = -fx;
306  }
307  size_t index = (dx*PTYPE_SIZE + ptype)*16;
308  assert(index+16 <= ONE_DIM);
309  double sum = w[offset + index + fx + 3];
310  if (move.isDrop() || move.isPromotion())
311  sum += w[offset + index + 7];
312  sum += w[offset + index + state.progress8()+8];
313 
314  dx = to.x() - op_king.x(), fx = from_to;
315  if (dx < 0) {
316  dx = -dx;
317  fx = -fx;
318  }
319  index = (dx*PTYPE_SIZE + ptype)*16;
320  assert(index+16 <= ONE_DIM);
321  sum += w[offset + ONE_DIM + index + fx + 3];
322  if (move.isDrop() || move.isPromotion())
323  sum += w[offset + ONE_DIM + index + 7];
324  sum += w[offset + ONE_DIM + index + state.progress8()+8];
325  return sum;
326  }
327  };
328 
329  class FromEffect : public Feature
330  {
331  public:
333  {
334  }
335  double match(const StateInfo& state_info, const MoveInfo& info, int offset, const double *w) const
336  {
337  const Move move = info.move;
338  if (move.isDrop())
339  return 0;
340  const NumEffectState& state = *state_info.state;
341  const Ptype me = move.oldPtype();
342  const Ptype support = state.findCheapAttack(info.player, move.from()).ptype();
343  const Ptype attack = state.findCheapAttack(alt(info.player), move.from()).ptype();
344  const size_t index = (((me * PTYPE_SIZE) + support) * PTYPE_SIZE) + attack;
345  assert(index < dimension());
346  return w[index + offset];
347  }
348  };
349 
350  class ToEffect : public Feature
351  {
352  public:
354  {
355  }
356  static const Piece find(const NumEffectState& state,
357  Square to, const PieceMask& remove,
358  Player player)
359  {
360  assert(to.isOnBoard());
361  PieceMask pieces = state.piecesOnBoard(player)
362  & state.effectSetAt(to);
363  pieces &= ~remove;
364  return state.selectCheapPiece(pieces);
365  }
366  static void supportAttack(const NumEffectState& state,
367  Square to,
368  const PieceMask& my_pin,
369  const PieceMask& op_pin,
370  Player turn,
371  std::pair<Ptype,Ptype>& out)
372  {
373  out.first = find(state, to, my_pin, turn).ptype(); // support
374  out.second = find(state, to, op_pin, alt(turn)).ptype(); // attack
375  }
376  static void supportAttack(const StateInfo& info, Square to, Move move,
377  std::pair<Ptype,Ptype>& out)
378  {
379  const Player turn = info.state->turn();
380  if (move.isDrop())
381  return supportAttack(*(info.state), to, info.pin[turn],
382  info.pin[alt(turn)], turn, out);
383  PieceMask my_pin = info.pin[turn];
384  my_pin.set(info.state->pieceAt(move.from()).number());
385  supportAttack(*(info.state), to, my_pin, info.pin[alt(turn)],
386  turn, out);
387  }
388  static size_t supportAttack(const StateInfo& info, Square to, Move move)
389  {
390  std::pair<Ptype,Ptype> pair;
391  supportAttack(info, to, move, pair);
392  return pair.first * PTYPE_SIZE + pair.second;
393  }
394  double match(const StateInfo& state, const MoveInfo& info, int offset, const double *w) const
395  {
396  const Move move = info.move;
397  const Ptype me = move.ptype(), captured = move.capturePtype();
398  const size_t position_index = supportAttack(state, move.to(), move);
399  const size_t index = ((me * PTYPE_SIZE) + captured)
400  * PTYPE_SIZE * PTYPE_SIZE + position_index;
401  assert(index < dimension());
402  return w[index + offset];
403  }
404  };
405 
406  class FromEffectLong : public Feature
407  {
408  public:
409  FromEffectLong() : Feature("FromEffectLong", PTYPE_SIZE*8*8)
410  {
411  }
412  double match(const StateInfo& state_info, const MoveInfo& info, int offset, const double *w) const
413  {
414  const Move move = info.move;
415  if (move.isDrop())
416  return 0;
417  const NumEffectState& state = *state_info.state;
418  const Ptype ptype = move.oldPtype();
419  const CArray<bool,3> me = {{
420  state.longEffectAt<LANCE>(move.from(), info.player).any(),
421  state.longEffectAt<BISHOP>(move.from(), info.player).any(),
422  state.longEffectAt<ROOK>(move.from(), info.player).any(),
423  }};
424  const CArray<bool,3> op = {{
425  state.longEffectAt<LANCE>(move.from(), alt(info.player)).any(),
426  state.longEffectAt<BISHOP>(move.from(), alt(info.player)).any(),
427  state.longEffectAt<ROOK>(move.from(), alt(info.player)).any(),
428  }};
429  size_t index = ptype;
430  for (int i=0; i<3; ++i) {
431  index *= 2; index += me[i];
432  index *= 2; index += op[i];
433  }
434  assert(index < dimension());
435  return w[index + offset];
436  }
437  };
438 
439  class ToEffectLong : public Feature
440  {
441  public:
442  ToEffectLong() : Feature("ToEffectLong", PTYPE_SIZE*8*8)
443  {
444  }
445  double match(const StateInfo& state_info, const MoveInfo& info, int offset, const double *w) const
446  {
447  const Move move = info.move;
448  const NumEffectState& state = *state_info.state;
449  const Ptype ptype = move.oldPtype();
450  NumBitmapEffect effect=state.effectSetAt(move.to());
451  if (! move.isDrop())
452  effect.reset(state.pieceOnBoard(move.from()).number()+8);
453  const CArray<mask_t,3> pieces = {{
454  effect.selectLong<LANCE>() >> 8,
455  effect.selectLong<BISHOP>() >> 8,
456  effect.selectLong<ROOK>() >> 8
457  }};
458  size_t index = ptype;
459  for (int i=0; i<3; ++i) {
460  index *= 2;
461  index += (pieces[i] & state.piecesOnBoard(info.player).getMask(1)).any();
462  index *= 2;
463  index += (pieces[i] & state.piecesOnBoard(alt(info.player)).getMask(1)).any();
464  }
465  assert(index < dimension());
466  return w[index + offset];
467  }
468  };
469 
470  class PatternCommon : public Feature
471  {
472  public:
473  enum {
486  };
487  PatternCommon(const std::string& name, int dim) : Feature(name, dim)
488  {
489  }
490  double addOne(const StateInfo& state, int offset,
491  const double *w, Square position) const
492  {
493  if (! position.isOnBoardRegion() || state.state->pieceAt(position).isEdge()) {
494  size_t basic = ptypeOIndex(PTYPEO_EDGE) *SquareDim;
495  return w[offset + basic];
496  }
497  const StateInfo::pattern_square_t& cache
498  = state.pattern_cache[position.index()];
499  double sum = 0.0;
500  for (size_t i=0; i<cache.size() && cache[i] >= 0; ++i)
501  sum += w[offset + cache[i]];
502  return sum;
503  }
504  static void updateCache(StateInfo& info);
505  private:
506  static void updateCacheOne(Square target, StateInfo& info);
507  };
508 
509  template<bool TestPromotable>
510  class PatternBase : public PatternCommon
511  {
512  int dx, black_dy;
513  public:
514  enum {
515  PromotionSize = TestPromotable ? 3 : 1,
517  };
518  PatternBase(int x, int y)
519  : PatternCommon(name(x,y), DIM), dx(x), black_dy(y)
520  {
521  }
522  double match(const StateInfo& state, const MoveInfo& info, int offset, const double *w) const
523  {
524  const Move move = info.move;
525  const Ptype ptype = move.ptype();
526  int basic = ptype*PatternCacheSize;
527  int basic_from = (move.isPromotion() ? PTYPE_EDGE : PTYPE_EMPTY)
529  const Square to = move.to();
530  if (TestPromotable && to.canPromote(info.player))
531  offset += OneDim;
532  else if (TestPromotable && to.canPromote(alt(info.player)))
533  offset += 2*OneDim;
534  int dy = info.player == BLACK ? black_dy : -black_dy;
535  Square target = to + Offset(dx, dy);
536  double sum = 0.0;
537  if (move.from() != target)
538  sum += addOne(state, offset+basic, w, target);
539  else // move from here
540  sum += addOne(state, offset+basic_from, w, target);
541  if (dx == 0)
542  return sum;
543  target = to + Offset(-dx, dy);
544  if (move.from() != target)
545  sum += addOne(state, offset+basic, w, target);
546  else
547  sum += addOne(state, offset+basic_from, w, target);
548  return sum;
549  }
550  static std::string name(int x, int y)
551  {
552  return std::string("Pattern")
553  + (TestPromotable ? "P" : "")
554  + "X" + (char)('2'+x) + "Y"+(char)('2'+y);
555  }
556  };
557 
560 
562  {
563  public:
564  MoveFromOpposingSliders() : Feature("MoveFromOpposingSliders", 36*PTYPE_SIZE)
565  {
566  }
567  static int longPtype(const NumEffectState& state, Square position, Player player)
568  {
569  const int offset = PtypeFuns<LANCE>::indexNum*32;
570  mask_t p = state.longEffectAt<LANCE>(position, player);
571  if (p.any())
572  return state.hasEffectAt(player, state.pieceOf(p.takeOneBit()+offset).square());
573  p = state.longEffectAt<BISHOP>(position, player);
574  if (p.any())
575  return 2 + state.hasEffectAt(player, state.pieceOf(p.takeOneBit()+offset).square());
576  p = state.longEffectAt<ROOK>(position, player);
577  assert(p.any());
578  return 4 + state.hasEffectAt(player, state.pieceOf(p.takeOneBit()+offset).square());
579  }
580  double match(const StateInfo& state, const MoveInfo& move, int offset, const double *w) const
581  {
582  const Square from = move.move.from();
583  if (from.isPieceStand()
584  || ! state.pinByOpposingSliders(state.state->pieceOnBoard(from)))
585  return 0.0;
586  const int me = longPtype(*state.state, from, move.player);
587  const int op = longPtype(*state.state, from, alt(move.player));
588  return w[offset + (me*6+op)*PTYPE_SIZE+move.move.ptype()];
589  }
590  };
592  {
593  public:
594  AttackFromOpposingSliders() : Feature("AttackFromOpposingSliders", PTYPE_SIZE*PTYPE_SIZE*2)
595  {
596  }
597  double match(const StateInfo& state, const MoveInfo& info, int offset, const double *w) const
598  {
599  const Move move = info.move;
600  const Piece attack = state.state->findCheapAttack(alt(info.player), move.to());
601  if (! state.pinByOpposingSliders(attack))
602  return 0.0;
603  if (state.state->countEffect(alt(info.player), move.to()) == 1)
604  offset += PTYPE_SIZE*PTYPE_SIZE;
605  double sum = w[offset + PTYPE_EMPTY*PTYPE_SIZE+attack.ptype()]
606  + w[offset + move.ptype()*PTYPE_SIZE+PTYPE_EMPTY]
607  + w[offset + move.ptype()*PTYPE_SIZE+attack.ptype()];
608  if (info.see < 0)
609  sum += w[offset + PTYPE_EMPTY*PTYPE_SIZE+PTYPE_EMPTY]*info.see/1024.0;
610  return sum;
611  }
612  };
614  {
615  public:
616  AttackToOpposingSliders() : Feature("AttackToOpposingSliders", PTYPE_SIZE*PTYPE_SIZE*2)
617  {
618  }
619  double match(const StateInfo& state, const MoveInfo& info, int offset, const double *w) const
620  {
621  const Move move = info.move;
622  double sum = 0.0;
623  for (Piece piece: state.pin_by_opposing_sliders) {
624  if (! state.state->hasEffectIf(move.ptypeO(), move.to(),
625  piece.square()))
626  continue;
627  int base = (piece.owner() == info.player) ? PTYPE_SIZE*PTYPE_SIZE : 0;
628  sum += w[offset + base + PTYPE_EMPTY*PTYPE_SIZE+piece.ptype()]
629  + w[offset + base + move.ptype()*PTYPE_SIZE+PTYPE_EMPTY]
630  + w[offset + base + move.ptype()*PTYPE_SIZE+piece.ptype()];
631  if (info.see < 0)
632  sum += w[offset + base + PTYPE_EMPTY*PTYPE_SIZE+PTYPE_EMPTY]*info.see/1024.0;
633  }
634  return sum;
635  }
636  };
637  class PawnAttack : public Feature
638  {
639  public:
640  enum {
645  DIM = PawnSize*2
646  };
647  PawnAttack() : Feature("PawnAttack", DIM)
648  {
649  }
650  std::pair<int,int> squareStatus(const NumEffectState& state, Player player, Square to, Square& front) const
651  {
652  int u = 0, uu = 0;
653  const int dy = (player == BLACK) ? -1 : 1;
654  Square position = to + Offset(0, dy);
655  front = position;
656  Piece piece = state.pieceAt(position);
657  if (piece.isPiece())
658  u = piece.ptype() + ((piece.owner() == player) ? PTYPE_SIZE : 0);
659  assert(! piece.isEdge()); // pawn move
660  piece = state.pieceAt(position + Offset(0, dy));
661  if (piece.isPiece())
662  uu = piece.ptype() + ((piece.owner() == player) ? PTYPE_SIZE : 0);
663  return std::make_pair(u, uu);
664  }
665  double matchPtype(const StateInfo& state, const MoveInfo& move, int offset, const double *w) const
666  {
667  const Player player = move.player;
668  const Square to = move.move.to();
669 
670  Square front;
671  const std::pair<int,int> u = squareStatus(*state.state, player, to, front);
672 
673  int promotion = 0;
674  if (front.canPromote(player))
675  promotion = 1;
676  else if (front.canPromote(alt(player)))
677  promotion = 2;
678  offset += BasicSize*promotion;
679 
680  bool pawn_drop = move.move.isDrop();
681  const int index0 = (u.first*PTYPE_SIZE*2+u.second)*2 + pawn_drop;
682  double sum = w[offset + index0];
683 
684  const int effect = classifyEffect9(*state.state, player, front);
685  const int index1 = u.first*8 + move.move.to().squareForBlack(player).y()-2;
686  sum += w[offset + index1*9+effect];
687  return sum;
688  }
689  double match(const StateInfo& state, const MoveInfo& move, int offset, const double *w) const
690  {
691  if (move.move.ptype() == PAWN)
692  return matchPtype(state, move, offset, w);
693  if (move.move.ptype() == LANCE
694  && state.state->canDropPawnTo(move.player, move.move.to().x()))
695  return matchPtype(state, move, offset+PawnSize, w);
696  return 0.0;
697  }
698  };
699 
700  class BlockLong : public Feature
701  {
702  public:
703  enum {
706  OptionSize = 8, // King8, HasSupport, Promotable, Shadowing,...
709  };
710  BlockLong() : Feature("BlockLong", DIM)
711  {
712  }
713  static int longAttackIndex(osl::PtypeO ptypeo) // [0,7]?
714  {
715  const Ptype ptype = getPtype(ptypeo);
716  int index;
717  if (ptype == LANCE) index = 0;
718  else if (ptype == BISHOP) index = 1;
719  else if (ptype == ROOK) index = 2;
720  else {
721  assert(ptype == PROOK || ptype == PBISHOP);
722  index = 3;
723  }
724  if (getOwner(ptypeo) == WHITE) index += 4;
725  return index;
726  }
727  static double addPiece(const StateInfo& state, Piece piece,
728  Square to, const double *w, int offset)
729  {
730  assert(state.state->hasEffectByPiece(piece, to));
731  const Direction d
732  = Board_Table.getLongDirection<BLACK>(piece.square(), to);
734  cache = state.long_attack_cache[piece.number()][longToShort(d)];
735  double sum = 0.0;
736  for (int index: cache) {
737  assert(index < LongAttackSize);
738  sum += w[index+offset];
739  }
740  return sum;
741  }
742  static int ptypeSupport(Ptype moved, bool has_support)
743  {
744  return (moved*2 + has_support) * LongAttackSize;
745  }
746  static double findAll(const StateInfo& state, Player P,
747  Square target, const double *w, int offset)
748  {
749  mask_t m = state.state->longEffectAt(target, P);
750  double sum = 0.0;
751  while (m.any()) {
752  const Piece piece = state.state->pieceOf
753  (m.takeOneBit() +PtypeFuns<LANCE>::indexNum*32);
754  sum += addPiece(state, piece, target, w, offset);
755  }
756  m = state.state->longEffectAt(target, alt(P));
757  while (m.any()) {
758  const Piece piece = state.state->pieceOf
759  (m.takeOneBit()+PtypeFuns<LANCE>::indexNum*32);
760  sum += addPiece(state, piece, target, w, offset);
761  }
762  return sum;
763  }
764  static double findAll(const StateInfo& state, Move move, const double *w, int offset=0)
765  {
766  const Player P = move.player();
767  Square target = move.to();
768  int a = state.state->countEffect(P, target);
769  offset += ptypeSupport(move.ptype(), a+move.isDrop()>1);
770  return findAll(state, P, target, w, offset);
771  }
772  double match(const StateInfo& state, const MoveInfo& move, int offset, const double *w) const
773  {
774  return findAll(state, move.move, w, offset);
775  }
776  static void updateCache(StateInfo&);
777  private:
778  static void makeLongAttackOne(StateInfo& info,
779  Piece piece, Direction d);
780  };
781  class BlockLongFrom : public Feature
782  {
783  public:
784  enum {
786  };
787  BlockLongFrom() : Feature("BlockLongFrom", DIM)
788  {
789  }
790  static double findAll(const StateInfo& state, Move move, const double *w, int offset=0)
791  {
792  const Player P = move.player();
793  Square target = move.from();
794  return BlockLong::findAll(state, P, target, w, offset);
795  }
796  double match(const StateInfo& state, const MoveInfo& move, int offset, const double *w) const
797  {
798  if (move.move.isDrop())
799  return 0;
800  return findAll(state, move.move, w, offset);
801  }
802  };
803  class LongRecapture : public Feature
804  {
805  public:
806  enum {
808  };
809  LongRecapture() : Feature("LongRecapture", DIM)
810  {
811  }
812  double match(const StateInfo& info, const MoveInfo& move, int offset, const double *w) const
813  {
814  if (move.see >= 0)
815  return 0.0;
816  const NumEffectState& state = *info.state;
817  const Square to = move.move.to();
818  int a = state.countEffect(move.player, to)+move.move.isDrop()-1;
819  int d = state.countEffect(alt(move.player), to);
820  if (d == 1
821  || (d == 2 && a > 0
822  && state.hasEffectByPiece(state.kingPiece(alt(move.player)), to))) {
823  double sum = w[offset + (PTYPE_EMPTY)*BlockLong::LongAttackSize]
824  *move.see/1024.0;
825  offset += move.move.ptype() * BlockLong::LongAttackSize;
826  const Piece opponent = state.findCheapAttack(alt(move.player), to);
827  sum += BlockLong::findAll(info, move.player, opponent.square(), w, offset);
828  return sum;
829  }
830  return 0.0;
831  }
832  };
833  class AddEffectLong : public Feature
834  {
835  public:
836  enum {
838  };
839  AddEffectLong() : Feature("AddEffectLong", DIM)
840  {
841  }
842  static double addOne(Direction dir, const StateInfo& state, const MoveInfo& move, int offset, const double *w)
843  {
844  Offset diff = Board_Table.getOffset(move.player, dir);
845  Square to = move.move.to() + diff;
846  if (isLong(dir)) {
847  while (state.state->pieceAt(to).isEmpty())
848  to += diff;
849  }
850  if (! state.state->pieceAt(to).isPiece())
851  return 0.0;
852  return BlockLong::findAll(state, move.player, to, w, offset);
853  }
854  double match(const StateInfo& state, const MoveInfo& move, int offset, const double *w) const
855  {
856  offset += move.move.ptype()*BlockLong::LongAttackSize;
857  unsigned int directions = Ptype_Table.getMoveMask(move.move.ptype());
858  double sum = 0.0;
859  do {
860  Direction d = (Direction)(misc::BitOp::bsf(directions));
861  directions &= directions-1;
862  sum += addOne(d, state, move, offset, w);
863  } while (directions);
864  return sum;
865  }
866  };
867  class LanceAttack : public Feature
868  {
869  public:
870  enum {
872  DIM = PatternCacheSize*(8+4+4+1)
873  };
874  LanceAttack() : Feature("LanceAttack", DIM)
875  {
876  }
877  double match(const StateInfo& state, const MoveInfo& move, int offset, const double *w) const
878  {
879  if (move.move.ptype() != LANCE
880  || (! move.move.isDrop()
881  && move.move.capturePtype() == PTYPE_EMPTY))
882  return 0;
883  const Offset up = Board_Table.getOffset(move.player, U);
884  Square target = move.move.to() + up;
885  while (state.state->pieceAt(target).isEmpty())
886  target += up;
887  if (state.state->pieceAt(target).isOnBoardByOwner(move.player)) {
888  target += up;
889  if (state.state->pieceAt(target).ptype() == LANCE) {
890  while (state.state->pieceAt(target).isEmpty())
891  target += up;
892  }
893  }
894  if (state.state->pieceAt(target).isEdge())
895  target -= up;
896 
897  int y = move.move.to().y(), x = move.move.to().x();
898  if (move.player == WHITE)
899  y = 10-y;
900  y -= 2;
901  int dx1 = abs(state.state->kingSquare(move.player).x()-x);
902  int dx2 = abs(state.state->kingSquare(alt(move.player)).x()-x);
903  dx1 = std::min(dx1, 3);
904  dx2 = std::min(dx2, 3);
905  bool pawn = state.state->canDropPawnTo(alt(move.player), x);
906  assert(! state.state->pieceAt(target).isEdge());
907  const StateInfo::pattern_square_t& cache
908  = state.pattern_cache[target.index()];
909  double sum = 0.0;
910  for (size_t i=0; i<cache.size() && cache[i] >= 0; ++i) {
911  sum += w[offset + y*PatternCacheSize + cache[i]];
912  sum += w[offset + (8+dx1)*PatternCacheSize + cache[i]];
913  sum += w[offset + (12+dx1)*PatternCacheSize + cache[i]];
914  if (! pawn)
915  sum += w[offset + 16*PatternCacheSize + cache[i]];
916  }
917  return sum;
918  }
919  };
920  class BishopAttack : public Feature
921  {
922  public:
923  enum {
925  DIM = PatternCacheSize*2 // square:2
926  };
927  BishopAttack() : Feature("BishopAttack", DIM)
928  {
929  }
930  static double addSquare(Square target,
931  const StateInfo& info,
932  int offset, const double *w)
933  {
934  int type = 0;
935  const StateInfo::pattern_square_t& cache
936  = info.pattern_cache[target.index()];
937  double sum = 0.0;
938  for (size_t i=0; i<cache.size() && cache[i] >= 0; ++i) {
939  sum += w[offset + type + cache[i]];
940  }
941  return sum;
942  }
943  template <Direction D,Ptype Type>
944  static
945  double addOne(const StateInfo& info, Square to,
946  int offset, const double *w)
947  {
948  const NumEffectState& state = *info.state;
950  Square target = to + diff;
951  double sum = 0.0;
952  if (state.pieceAt(target).isEdge())
953  return sum;
954  if (state.pieceAt(target).isPiece()
955  && (state.pieceAt(target).ptype() != Type
956  || state.pieceAt(target).owner() != state.turn())) {
957  ; // almost included in direct pattern
958  } else {
959  while (state.pieceAt(target).isEmpty())
960  target += diff;
961  if (state.pieceAt(target).ptype() == Type
962  && state.pieceAt(target).owner() == state.turn()) {
963  // extend additional effect by the same ptype
964  target += diff;
965  while (state.pieceAt(target).isEmpty())
966  target += diff;
967  }
968  if (state.pieceAt(target).isEdge())
969  target -= diff;
970  sum += addSquare(target, info, offset, w);
971  if (! state.pieceAt(target).isPiece())
972  return sum;
973  }
974  // shadowing
975  target += diff;
976  if (state.pieceAt(target).isEdge())
977  return sum;
978  while (state.pieceAt(target).isEmpty())
979  target += diff;
980  if (state.pieceAt(target).isEdge())
981  target -= diff;
982  sum += addSquare(target, info, offset+PatternCacheSize, w);
983  return sum;
984  }
985  double match(const StateInfo& state, const MoveInfo& move, int offset, const double *w) const
986  {
987  if (unpromote(move.move.ptype()) != BISHOP)
988  return 0;
989  double sum = 0.0;
990  sum += addOne<UR,BISHOP>(state, move.move.to(), offset, w);
991  sum += addOne<UL,BISHOP>(state, move.move.to(), offset, w);
992  sum += addOne<DR,BISHOP>(state, move.move.to(), offset, w);
993  sum += addOne<DL,BISHOP>(state, move.move.to(), offset, w);
994  return sum;
995  }
996  };
997  class RookAttack : public Feature
998  {
999  public:
1000  enum {
1002  DIM = DirectionSize*3
1003  };
1004  RookAttack() : Feature("RookAttack", DIM)
1005  {
1006  }
1007  double match(const StateInfo& state, const MoveInfo& move, int offset, const double *w) const
1008  {
1009  if (unpromote(move.move.ptype()) != ROOK)
1010  return 0;
1011  const Square to = move.move.to();
1012  double sum = 0.0;
1013  sum += BishopAttack::addOne<R,ROOK>(state, to, offset, w);
1014  sum += BishopAttack::addOne<L,ROOK>(state, to, offset, w);
1015  const bool pawn_drop = state.state->canDropPawnTo(alt(move.player), to.x());
1016  const int scale = pawn_drop ? 1 : 2;
1017  sum += BishopAttack::addOne<U,ROOK>(state, to, offset+DirectionSize*scale, w);
1018  sum += BishopAttack::addOne<D,ROOK>(state, to, offset+DirectionSize*scale, w);
1019  return sum;
1020  }
1021  };
1022  class BreakThreatmate : public Feature
1023  {
1024  public:
1025  enum {
1034  };
1035  BreakThreatmate() : Feature("BreakThreatmate", DIM)
1036  {
1037  }
1038  static bool isKingMove(Move move)
1039  {
1040  return move.ptype() == KING;
1041  }
1042  static bool isOpeningKingRoad(Move move, Square king)
1043  {
1044  return ! move.isDrop()
1045  && move.from().isNeighboring8(king);
1046  }
1047  static bool isDefendingThreatmate(Move move, Move threatmate,
1048  const NumEffectState& state)
1049  {
1050  if (move.to() == threatmate.to()
1051  || state.hasEffectIf(move.ptypeO(), move.to(),
1052  threatmate.to()))
1053  return true;
1054  if (threatmate.isDrop())
1055  return false;
1056  Offset32 offset32=Offset32(threatmate.from(),move.to());
1057  EffectContent effect=Ptype_Table.getEffect(move.ptypeO(),offset32);
1058  if (! effect.hasEffect())
1059  return false;
1060  if (effect.offset() == threatmate.to()-threatmate.from())
1061  return state.isEmptyBetween(threatmate.from(), move.to());
1062  return false;
1063  }
1064  static bool isDefendingKing8(Move move, Square king,
1065  const NumEffectState& state)
1066  {
1068  (state, move.ptypeO(), move.to(), king))
1069  return true;
1070  mask_t m = state.longEffectAt(move.to(), alt(state.turn()));
1071  while (m.any()) {
1072  const Piece piece = state.pieceOf
1073  (m.takeOneBit() +PtypeFuns<LANCE>::indexNum*32);
1075  (state, piece.ptypeO(), piece.square(), king))
1076  return true;
1077  }
1078  return false;
1079  }
1080  double match(const StateInfo& info, const MoveInfo& move, int offset, const double *w) const
1081  {
1082  if (! info.threatmate_move.isNormal())
1083  return 0;
1084  const NumEffectState& state = *info.state;
1085  const StateInfo::pattern_square_t& cache
1086  = info.pattern_cache[move.move.to().index()];
1087  const int PatternAny = ptypeOIndex(PTYPEO_EDGE)*PatternCommon::SquareDim;
1088  double sum = 0.0;
1089  if (isKingMove(move.move)) {
1090  // king move
1091  sum += w[offset + KingMoveBase + PatternAny];
1092  for (size_t i=0; i<cache.size() && cache[i] >= 0; ++i) {
1093  sum += w[offset + KingMoveBase + cache[i]];
1094  }
1095  } else {
1096  const Square king = state.kingSquare(move.player);
1097  if (isOpeningKingRoad(move.move, king)) {
1098  // open king road
1099  int base = OpenRoadBase + move.move.ptype()*PatternCacheSize;
1100  sum += w[offset + base + PatternAny];
1101  for (size_t i=0; i<cache.size() && cache[i] >= 0; ++i) {
1102  sum += w[offset + base + cache[i]];
1103  }
1104  }
1106  state)) {
1107  // add effect to threatmate-move-at
1108  int base = move.move.ptype()*PatternCacheSize;
1109  sum += w[offset + base + PatternAny];
1110  for (size_t i=0; i<cache.size() && cache[i] >= 0; ++i) {
1111  sum += w[offset + base + cache[i]];
1112  }
1113  } else if (isDefendingKing8(move.move, king, state)) {
1114  // add effect to king8
1115  int base = move.move.ptype()*PatternCacheSize
1116  + AddEffect8Base;
1117  sum += w[offset + base + PatternAny];
1118  for (size_t i=0; i<cache.size() && cache[i] >= 0; ++i) {
1119  sum += w[offset + base + cache[i]];
1120  }
1121  }
1122  const Piece captured = state.pieceOnBoard(move.move.to());
1123  // capture
1124  if (captured.isPiece()) {
1126  (state, captured.ptypeO(), captured.square(), king)) {
1127  sum += w[offset + CaptureBase
1128  + captured.ptype()*PTYPE_SIZE+move.move.ptype()];
1129  sum += w[offset + CaptureBase
1130  + captured.ptype()*PTYPE_SIZE];
1131  }
1132  else {
1133  sum += w[offset + CaptureBase + captured.ptype()*PTYPE_SIZE
1134  + PTYPE_EDGE];
1135  }
1136  }
1137  }
1138  if (sum == 0.0)
1139  sum += w[offset + OtherMoveBase];
1140  return sum;
1141  }
1142  };
1143 
1144  class SendOff : public Feature
1145  {
1146  public:
1147  enum {
1149  };
1150  SendOff() : Feature("SendOff", DIM)
1151  {
1152  }
1153  double match(const StateInfo& info, const MoveInfo& move, int offset, const double *w) const
1154  {
1155  if (! info.sendoffs.isMember(move.move.to()))
1156  return 0;
1157  return w[offset + move.move.ptype()];
1158  }
1159  };
1160 
1161  class LureDefender : public Feature
1162  {
1163  public:
1164  enum {
1167  };
1168  LureDefender() : Feature("LureDefender", DIM)
1169  {
1170  }
1171  static double match(const NumEffectState& state, Move move, int see,
1172  const StateInfo::pinned_gs_t& pinned_list,
1173  int offset, const double *w)
1174  {
1175  const Square to = move.to(), king = state.kingSquare(alt(state.turn()));
1176  const Offset up = Board_Table.getOffset(state.turn(), U);
1177  const int basic_a = move.ptype() * PTYPE_SIZE*PTYPE_SIZE;
1178  double sum = 0.0;
1179  for (PinnedGeneral defense: pinned_list) {
1180  if (to != defense.attack)
1181  continue;
1182  assert(defense.general.owner() != move.player());
1183  assert(defense.covered.owner() != move.player());
1184  if (defense.general.square() == move.to()+up)
1185  offset += ATTACK_DIM;
1186  else if (state.hasEffectIf(move.ptypeO(), move.to(), defense.general.square()))
1187  offset += ATTACK_DIM*2;
1188  int a = basic_a;
1189  if (defense.covered.square().canPromote(state.turn())
1190  && canPromote(move.ptype()))
1191  a = promote(move.ptype()) * PTYPE_SIZE*PTYPE_SIZE;
1192  const int b = defense.general.ptype() * PTYPE_SIZE;
1193  const int c = defense.covered.ptype();
1194  sum += w[offset];
1195  if (see < 0)
1196  sum += w[offset+1] * see/1024.0;
1197  sum += w[offset + a];
1198  sum += w[offset + b];
1199  sum += w[offset + c];
1200  sum += w[offset + a + b];
1201  sum += w[offset + a + c];
1202  sum += w[offset + b + c];
1203  if (defense.covered.square().canPromote(state.turn())) {
1204  sum += w[offset + a + PTYPE_EDGE];
1205  sum += w[offset + b + PTYPE_EDGE];
1206  }
1207  if (defense.covered.square().isNeighboring8(king)) {
1208  sum += w[offset + a + KING];
1209  sum += w[offset + b + KING];
1210  }
1211  sum += w[offset + a + b + c];
1212  break;
1213  }
1214  return sum;
1215  }
1216  double match(const StateInfo& info, const MoveInfo& move, int offset, const double *w) const
1217  {
1218  return match(*info.state, move.move, move.see,
1219  info.exchange_pins[alt(move.player)], offset, w);
1220  }
1221  };
1222 
1224  {
1225  public:
1226  enum {
1228  };
1229  CheckmateIfCapture() : Feature("CheckmateIfCapture", DIM)
1230  {
1231  }
1232  double match(const StateInfo& info, const MoveInfo& move, int offset, const double *w) const
1233  {
1234  if (info.state->inCheck() || move.see > -256)
1235  return 0;
1236  const Square king = info.state->kingSquare(alt(move.player));
1237  if (move.move.capturePtype() != PTYPE_EMPTY
1238  && ! info.state->hasPieceOnStand<GOLD>(move.player)
1239  && ! info.state->hasPieceOnStand<SILVER>(move.player)
1240  && ! info.move_candidate_exists[alt(move.player)])
1241  return 0;
1243  (*info.state, move.move.ptypeO(), move.move.to(), king))
1244  return 0;
1245  if (hasSafeCapture(info.copy, move.move))
1246  return 0;
1247  int ptype_index = move.move.ptype()*PTYPE_SIZE;
1248  int capture_index = move.move.capturePtype();
1249  double sum = 0.0;
1250  sum += w[offset + ptype_index + capture_index];
1251  sum += w[offset + capture_index];
1252  sum += w[offset + ptype_index + PTYPE_EDGE];
1253  sum += w[offset + PTYPE_EDGE];
1254  return sum;
1255  }
1256  static bool hasSafeCapture(NumEffectState& state, Move);
1257  };
1258  class AttackKing8Long : public Feature
1259  {
1260  public:
1261  enum {
1263  };
1264  AttackKing8Long() : Feature("AttackKing8Long", DIM)
1265  {
1266  }
1267  double match(const StateInfo& state, const MoveInfo& info, int offset, const double *w) const
1268  {
1269  const Move move = info.move;
1270  double sum = 0.0;
1271  for (Piece piece: state.king8_long_pieces) {
1272  if (! state.state->hasEffectIf(move.ptypeO(), move.to(),
1273  piece.square()))
1274  continue;
1275  sum += w[offset + PTYPE_EMPTY*PTYPE_SIZE+piece.ptype()]
1276  + w[offset + move.ptype()*PTYPE_SIZE+PTYPE_EMPTY]
1277  + w[offset + move.ptype()*PTYPE_SIZE+piece.ptype()];
1278  if (state.pin_by_opposing_sliders.isMember(piece)
1279  && info.see < 0)
1280  sum += w[offset + PTYPE_EMPTY*PTYPE_SIZE+PTYPE_EDGE]*info.see/1024.0;
1281  }
1282  return sum;
1283  }
1284  };
1285  class OpposingPawn : public Feature
1286  {
1287  public:
1288  enum {
1289  DIM = /*king-x*/9 * /* stand-pawn */ 3 * /* others */ 2,
1290  };
1291  OpposingPawn() : Feature("OpposingPawn", DIM)
1292  {
1293  }
1294  double match(const StateInfo& state, const MoveInfo& info, int offset, const double *w) const
1295  {
1296  const Move move = info.move;
1297  if (move.ptype() != PAWN)
1298  return 0.0;
1299  const Square front = move.to() + Board_Table.getOffset(info.player, U);
1300  if (state.state->pieceAt(front).ptype() != PAWN)
1301  return 0.0;
1302  int king_x = abs(state.state->kingSquare(alt(info.player)).x() - front.x());
1303  int stand_pawn = state.state->countPiecesOnStand<PAWN>(info.player);
1304  if (move.isDrop())
1305  --stand_pawn;
1306  stand_pawn = std::min(2, stand_pawn);
1307  bool has_other = state.state->hasPieceOnStand<LANCE>(info.player)
1308  || state.state->hasPieceOnStand<KNIGHT>(info.player)
1309  || state.state->hasPieceOnStand<SILVER>(info.player)
1310  || state.state->hasPieceOnStand<GOLD>(info.player)
1311  || state.state->hasPieceOnStand<ROOK>(info.player)
1312  || state.state->hasPieceOnStand<BISHOP>(info.player);
1313  int index = (king_x * 3 + stand_pawn) * 2 + has_other;
1314  return w[offset + index];
1315  }
1316  };
1317 
1319  {
1320  public:
1321  enum {
1322  DIM = /*king-x*/9 * /* stand-pawn */ 3 * /* others */ 2 * /* capturepawn */ 2,
1323  };
1324  DropAfterOpposingPawn() : Feature("DropAfterOpposingPawn", DIM)
1325  {
1326  }
1327  double match(const StateInfo& state, const MoveInfo& info, int offset, const double *w) const
1328  {
1329  const Move move = info.move;
1330  if (move.ptype() != PAWN || ! move.isDrop() || ! state.history->hasLastMove())
1331  return 0.0;
1332  int to_x = move.to().x();
1333  const Move last_move = state.history->lastMove();
1334  if (! last_move.isNormal() || last_move.isDrop()
1335  || last_move.to().x() != to_x
1336  || last_move.from().x() != to_x)
1337  return 0.0;
1338 
1339  const Square front = move.to()+Board_Table.getOffset(info.player, U);
1340  if (! front.canPromote(info.player))
1341  return 0.0;
1342  int king_x = abs(state.state->kingSquare(alt(info.player)).x() - to_x);
1343  int stand_pawn = std::min(2, state.state->countPiecesOnStand<PAWN>(info.player)-1);
1344  bool has_other = state.state->hasPieceOnStand<LANCE>(info.player)
1345  || state.state->hasPieceOnStand<KNIGHT>(info.player)
1346  || state.state->hasPieceOnStand<SILVER>(info.player)
1347  || state.state->hasPieceOnStand<GOLD>(info.player)
1348  || state.state->hasPieceOnStand<ROOK>(info.player)
1349  || state.state->hasPieceOnStand<BISHOP>(info.player);
1350  bool follow_pawn_capture = last_move.capturePtype() == PAWN;
1351  int index = ((king_x * 3 + stand_pawn) * 2 + has_other) * 2 + follow_pawn_capture;
1352  return w[offset + index];
1353  }
1354  };
1355 
1356  class CoverPawn : public Feature
1357  {
1358  public:
1359  enum {
1360  DIM = 9 * 2 * PTYPE_SIZE * PTYPE_SIZE
1361  };
1362  CoverPawn() : Feature("CoverPawn", DIM)
1363  {
1364  }
1365  double match(const StateInfo& si, const MoveInfo& mi, int offset, const double *w) const
1366  {
1367  if (! si.history->hasLastMove() || si.state->inCheck()
1368  || mi.move.isCaptureOrPromotion())
1369  return 0.0;
1370  const Move last_move = si.history->lastMove();
1371  if (last_move.ptype() != PAWN)
1372  return 0.0;
1373  const Offset diff = Board_Table.getOffset(mi.player, U);
1374  const Square front = last_move.to()-diff, front2 = front-diff;
1375  if (si.state->pieceOnBoard(front).ptype() != PAWN // must be turn's pawn
1376  || si.state->pieceAt(front2).isOnBoardByOwner(alt(mi.player)))
1377  return 0.0;
1378  const bool cover = si.state->hasEffectIf
1379  (mi.move.ptypeO(), mi.move.to(), front);
1380  const Ptype moved = cover ? mi.move.ptype() : PTYPE_EDGE,
1381  threatened = si.state->pieceAt(front2).ptype();
1382  const int a = std::min(2,si.state->countEffect(alt(mi.player), front) - 1);
1383  assert(a >= 0);
1384  const int b = std::min(2,si.state->countEffect(mi.player, front));
1385  const int ptype_index = moved*PTYPE_SIZE+threatened;
1386  const bool has_pawn = si.state->hasPieceOnStand(alt(mi.player),PAWN);
1387  const int pawn_index = PTYPE_SIZE*PTYPE_SIZE;
1388  const int effect_index = (a*3+b)*2*PTYPE_SIZE*PTYPE_SIZE
1389  + (has_pawn ? pawn_index : 0);
1390  assert(effect_index >= 0);
1391  return w[offset + threatened]
1392  + w[offset + ptype_index]
1393  + w[offset + effect_index + ptype_index];
1394  }
1395  };
1396  class SacrificeAttack : public Feature
1397  {
1398  public:
1399  enum {
1401  DIM = StandCount * PTYPE_SIZE * 2
1402  };
1403  SacrificeAttack() : Feature("SacrificeAttack", DIM)
1404  {
1405  }
1406  double match(const StateInfo& si, const MoveInfo& mi, int offset, const double *w) const
1407  {
1408  const Square king = si.state->kingSquare(alt(mi.player));
1409  if (mi.see >= 0
1411  (*si.state, mi.move.ptypeO(), mi.move.to(), king)))
1412  return 0.0;
1413  assert(PieceStand::order[6] == PAWN);
1414  int stand = mi.standIndex(*si.state);
1415  int index = (stand * PTYPE_SIZE + mi.move.ptype()) * 2;
1416  double sum = w[offset + index];
1417  if (si.history->hasLastMove(2)) {
1418  Move my_last_move = si.history->lastMove(2);
1419  if (my_last_move.isNormal()
1421  (*si.state, my_last_move.ptypeO(), my_last_move.to(), king))
1422  sum += w[offset + index + 1];
1423  }
1424  return sum;
1425  }
1426  };
1427  class King5x5Ptype : public Feature
1428  {
1429  public:
1430  enum {
1432  DIM = 2 * ONE_DIM,
1433  };
1434  King5x5Ptype() : Feature("King5x5Ptype", DIM)
1435  {
1436  }
1437  static double addOne(Player king, Square center, const StateInfo& si, const MoveInfo& mi, int offset, const double *w)
1438  {
1439  const Square to = mi.move.to();
1440  int dx = center.x() - to.x();
1441  const int dy = center.y() - to.y();
1442  if (abs(dx) >= 3 || abs(dy) >= 3)
1443  return 0.0;
1444  if ((king == BLACK && center.x() > 5)
1445  || (king == WHITE && center.x() >= 5))
1446  dx = -dx;
1447  int sq_index = (dx+2)*5 + dy+2;
1448  bool a = mi.move.isDrop() ? si.state->hasEffectAt(mi.player, to)
1449  : si.state->countEffect(mi.player,to) >= 2;
1450  bool d = si.state->hasEffectAt(alt(mi.player), to);
1451  int index = (sq_index*4 + a*2+d) * PTYPE_SIZE*PTYPE_SIZE
1452  + mi.move.capturePtype()*PTYPE_SIZE + mi.move.ptype();
1453  return w[offset + index];
1454  }
1455  double match(const StateInfo& si, const MoveInfo& mi, int offset, const double *w) const
1456  {
1457  return
1458  addOne(mi.player, si.state->kingSquare(mi.player), si, mi, offset, w)
1459  + addOne(alt(mi.player), si.state->kingSquare(alt(mi.player)), si, mi,
1460  offset+ONE_DIM, w);
1461  }
1462  };
1463  class KingBlockade : public Feature
1464  {
1465  public:
1466  enum {
1470  DIM = 5 * StandCount
1471  };
1472  KingBlockade() : Feature("KingBlockade", DIM)
1473  {
1474  }
1475  static bool blockAll(const King8Info& ki, Square king, Move move,
1476  const NumEffectState& state,
1477  const CArray<Direction,3>& directions)
1478  {
1479  int liberty = 0;
1480  for (Direction d: directions) {
1481  if ((ki.liberty() & (1<<d)) == 0)
1482  continue;
1483  ++liberty;
1484  const Square sq = king + Board_Table.getOffset(alt(state.turn()), d);
1485  if (! state.hasEffectIf(move.ptypeO(), move.to(), sq))
1486  return false;
1487  }
1488  return liberty > 0;
1489  }
1490  double match(const StateInfo& si, const MoveInfo& mi, int offset, const double *w) const
1491  {
1492  const NumEffectState& state = *si.state;
1493  const King8Info ki = si.king8Info(alt(mi.player));
1494  const Square king = state.kingSquare(alt(mi.player));
1495  if (ki.libertyCount() == 0
1497  (state, mi.move.ptypeO(), mi.move.to(), king)))
1498  return 0.0;
1499  int stand = mi.standIndex(state);
1500  offset += stand*5;
1501  double sum = 0.0;
1502  if (ki.libertyCount() == 1) {
1503  const Square sq = king
1506  if (! state.hasEffectIf(mi.move.ptypeO(), mi.move.to(), sq))
1507  return 0.0;
1508  sum += w[offset+BlockLastOne];
1509  // fall through
1510  }
1511  const CArray<Direction,3> front3 = {{ UL, U, UR }};
1512  if (blockAll(ki, king, mi.move, state, front3))
1513  sum += w[offset+BlockFront];
1514  const CArray<Direction,3> left3 = {{ UL, L, DL }};
1515  if (blockAll(ki, king, mi.move, state, left3)) {
1516  const bool wide = (mi.player== WHITE && king.x() < 5)
1517  || (mi.player== BLACK && king.x() > 5);
1518  sum += w[offset+(wide ? BlockSideWide : BlockSideOther)];
1519  }
1520  const CArray<Direction,3> right3 = {{ UR, R, DR }};
1521  if (blockAll(ki, king, mi.move, state, right3)) {
1522  const bool wide = (mi.player== BLACK && king.x() < 5)
1523  || (mi.player== WHITE && king.x() > 5);
1524  sum += w[offset+ (wide ? BlockSideWide : BlockSideOther)];
1525  }
1526  const CArray<Direction,3> back3 = {{ DL, D, DR }};
1527  if (blockAll(ki, king, mi.move, state, back3))
1528  sum += w[offset+BlockBack];
1529  return sum;
1530  }
1531  };
1532  class CoverFork : public Feature
1533  {
1534  public:
1535  enum {
1537  };
1538  CoverFork() : Feature("CoverFork", DIM)
1539  {
1540  }
1541  static bool defending(const NumEffectState& state, Move move, Square target)
1542  {
1543  if (state.countEffect(alt(state.turn()), target) > 1)
1544  return false;
1545  if (state.hasEffectIf(move.ptypeO(), move.to(), target))
1546  return true;
1547  Piece attacking = state.findCheapAttack(alt(state.turn()), target);
1548  Offset o = Board_Table.getShortOffsetNotKnight(Offset32(move.to(), target));
1549  if (o.zero()
1550  || ! Board_Table.isBetween(move.to(), attacking.square(), target))
1551  return false;
1552  return state.countEffect(state.turn(), move.to()) >= (1-move.isDrop());
1553  }
1554  double match(const StateInfo& si, const MoveInfo& mi, int offset, const double *w) const
1555  {
1556  const NumEffectState& state = *si.state;
1557  PieceMask attacked = state.piecesOnBoard(mi.player)
1558  & state.effectedMask(alt(mi.player))
1559  & ~(state.effectedMask(mi.player));
1560  attacked.clearBit<PAWN>();
1561  offset += mi.move.ptype()*PTYPE_SIZE*PTYPE_SIZE;
1562  double sum = 0.0;
1563  while (attacked.any()) {
1564  Piece a = state.pieceOf(attacked.takeOneBit());
1565  if (! defending(state, mi.move, a.square()))
1566  continue;
1567  int index_a = a.ptype()*PTYPE_SIZE;
1568  PieceMask copy = attacked;
1569  while (copy.any()) {
1570  Piece b = state.pieceOf(copy.takeOneBit());
1571  if (! defending(state, mi.move, b.square()))
1572  continue;
1573  sum += w[offset];
1574  sum += w[offset+index_a];
1575  sum += w[offset+b.ptype()];
1576  sum += w[offset+index_a+b.ptype()];
1577  }
1578  }
1579  return sum;
1580  }
1581  };
1583  {
1584  public:
1585  enum {
1587  };
1588  ThreatmateByCapture() : Feature("ThreatmateByCapture", DIM)
1589  {
1590  }
1591  double match(const StateInfo& si, const MoveInfo& mi, int offset, const double *w) const
1592  {
1593  const Move move = mi.move;
1594  const Ptype captured = move.capturePtype();
1595  if (captured == PTYPE_EMPTY
1597  & 1<<(captured-PTYPE_BASIC_MIN)) == 0)
1598  return 0.0;
1599  double sum = 0.0;
1600  sum += w[offset];
1601  if (mi.see < 0)
1602  sum += w[offset+1] * mi.see/1024.0;
1603  sum += w[offset+captured];
1604  sum += w[offset+move.ptype()*PTYPE_SIZE];
1605  sum += w[offset+move.ptype()*PTYPE_SIZE+captured];
1606  return sum;
1607  }
1608  };
1609 
1611  {
1612  public:
1613  enum {
1614  DIM = 2*PTYPE_SIZE * PTYPE_SIZE
1615  };
1616  PromotionBySacrifice() : Feature("PromotionBySacrifice", DIM)
1617  {
1618  }
1619  double match(const StateInfo& si, const MoveInfo& mi, int offset, const double *w) const
1620  {
1621  const Move move = mi.move;
1622  if (mi.see >= 0 || move.isDrop()
1623  || si.state->inCheck()
1624  || si.threatmate_move.isNormal())
1625  return 0.0;
1626  const NumEffectState& state = *si.state;
1627  mask_t m = state.longEffectAt(move.from(), state.turn());
1628  m &= ~mask_t::makeDirect(PtypeFuns<LANCE>::indexMask);
1629  double sum = 0.0;
1630  while (m.any()) {
1631  const Piece piece = state.pieceOf
1632  (m.takeOneBit() +PtypeFuns<LANCE>::indexNum*32);
1633  assert(piece.ptype() != LANCE);
1634  if (piece.isPromoted()
1635  || piece.square().canPromote(mi.player))
1636  continue;
1638  assert(! o.zero());
1639  bool can_promote = false;
1640  Square to = move.from()+o;
1641  if (to == move.to())
1642  continue;
1643  while (state[to].isEmpty()) {
1644  if (to.canPromote(mi.player)
1645  && ! state.hasEffectAt(alt(mi.player), to))
1646  can_promote = true;
1647  to += o;
1648  }
1649  assert(state[to] != piece);
1650  int index = 0;
1651  if (piece.ptype() == ROOK)
1652  index += PTYPE_SIZE*PTYPE_SIZE;
1653  index += move.ptype()*PTYPE_SIZE;
1654  if (to.canPromote(mi.player)
1655  && state[to].isOnBoardByOwner(alt(mi.player))
1656  && ! state.hasEffectAt(alt(mi.player), to)) {
1657  sum += w[offset];
1658  sum += w[offset+1]*mi.see/1024.0;
1659  if (mi.check)
1660  sum += w[offset+2];
1661  if (state.hasEffectAt(alt(mi.player), piece.square())) {
1662  sum += w[offset+3];
1663  if (mi.check)
1664  sum += w[offset+4];
1665  }
1666  if (state.hasEffectIf(piece.ptypeO(), to,
1667  state.kingSquare(alt(mi.player))))
1668  sum += w[offset+5];
1669  sum += w[offset + index + state[to].ptype()];
1670  }
1671  else if (can_promote) {
1672  sum += w[offset];
1673  sum += w[offset+1]*mi.see/1024.0;
1674  if (mi.check)
1675  sum += w[offset+2];
1676  if (state.hasEffectAt(alt(mi.player), piece.square())) {
1677  sum += w[offset+3];
1678  if (mi.check)
1679  sum += w[offset+4];
1680  }
1681  sum += w[offset + index];
1682  }
1683  }
1684  return sum;
1685  }
1686  };
1687 
1688  class EscapeThreatened : public Feature
1689  {
1690  public:
1691  enum {
1692  DIM =(2*PTYPE_SIZE * PTYPE_SIZE) * 3 * PTYPE_SIZE
1693  };
1694  EscapeThreatened() : Feature("EscapeThreatened", DIM)
1695  {
1696  }
1697  double match(const StateInfo& si, const MoveInfo& mi, int offset, const double *w) const
1698  {
1699  const NumEffectState& state = *si.state;
1700  const Move move = mi.move;
1701  const Piece target = si.threatened[mi.player];
1702  if (mi.see > 0 || mi.check || mi.open_check
1703  || ! move.isNormal()
1704  || ! target.isPiece() || state.inCheck()
1705  || si.threatmate_move.isNormal()
1707  (state, move.ptypeO(), move.to(), state.kingSquare(alt(mi.player))))
1708  return 0.0;
1709  const int t0 = target.ptype()*PTYPE_SIZE*2*PTYPE_SIZE*3;
1710  const int t1 = t0 + state.findCheapAttack(alt(mi.player), target.square()).ptype()*2*PTYPE_SIZE*3;
1711  const int t2 = t1 + state.hasEffectAt(mi.player, target.square())*PTYPE_SIZE*3;
1712  double sum = 0.0;
1713  if (! move.isDrop() && state[move.from()] == target) {
1714  sum += w[offset + t0];
1715  sum += w[offset + t1];
1716  sum += w[offset + t2];
1717  return sum;
1718  }
1719  if (state.hasEffectIf(move.ptypeO(), move.to(),
1720  target.square())) {
1721  if (move.isDrop()
1722  || ! state.hasEffectIf(move.oldPtypeO(), move.from(),
1723  target.square())) {
1724  sum += w[offset + t0 + move.ptype()];
1725  sum += w[offset + t1 + move.ptype()];
1726  sum += w[offset + t2 + move.ptype()];
1727  return sum;
1728  }
1729  }
1730  // not related move
1731  offset += PTYPE_SIZE;
1732  if (move.isDrop())
1733  offset += PTYPE_SIZE;
1734  sum += w[offset + t0 + move.ptype()];
1735  sum += w[offset + t1 + move.ptype()];
1736  sum += w[offset + t2 + move.ptype()];
1737  return sum;
1738  }
1739  };
1740  class BookMove : public Feature
1741  {
1742  public:
1743  enum {
1744  DIM = 2
1745  };
1746  BookMove() : Feature("BookMove", DIM)
1747  {
1748  }
1749  double match(const StateInfo& si, const MoveInfo& mi, int offset, const double *w) const
1750  {
1751  if (! si.bookmove[0].isNormal())
1752  return 0.0;
1753  if (mi.move == si.bookmove[0] || mi.move == si.bookmove[1])
1754  return w[offset];
1755  return w[offset+1];
1756  }
1757  };
1758  }
1759 }
1760 #endif /* OSL_MOVE_PROBABILITY_FEATURE_H */
1761 // ;;; Local Variables:
1762 // ;;; mode:c++
1763 // ;;; c-basic-offset:2
1764 // ;;; End:
osl::move_probability::PatternCommon::LastEffectChangedBase
@ LastEffectChangedBase
Definition: move_probability/feature.h:482
osl::move_probability::CapturePtype::CapturePtype
CapturePtype()
Definition: move_probability/feature.h:133
osl::move_probability::PatternCommon::SupportSize
@ SupportSize
Definition: move_probability/feature.h:474
osl::move_probability::SeeFeature::SeeClass
@ SeeClass
Definition: move_probability/feature.h:98
osl::move_probability::LongRecapture
Definition: move_probability/feature.h:804
osl::Piece::number
int number() const
Definition: basic_type.h:828
osl::move_probability::Feature::~Feature
virtual ~Feature()
Definition: feature_.cc:8
osl::UR
@ UR
Definition: basic_type.h:315
osl::PieceMask::getMask
const mask_t getMask(int num) const
Definition: pieceMask.h:59
osl::SimpleState::pieceAt
const Piece pieceAt(Square sq) const
Definition: simpleState.h:167
osl::move_probability::PawnAttack
Definition: move_probability/feature.h:638
osl::move_probability::PatternCommon::OneDim
@ OneDim
Definition: move_probability/feature.h:485
osl::effect_util::AdditionalEffect::hasEffect
static bool hasEffect(const NumEffectState &, Square target, Player attack)
target に attack の追加利きが一つでもあるか. 相手の影利きが先にある場合は対象としない.
Definition: additionalEffect.cc:5
osl::move_probability::LanceAttack::LanceAttack
LanceAttack()
Definition: move_probability/feature.h:874
osl::move_probability::SquareY::match
double match(const StateInfo &state, const MoveInfo &info, int offset, const double *w) const
Definition: move_probability/feature.h:200
osl::move_probability::King5x5Ptype::addOne
static double addOne(Player king, Square center, const StateInfo &si, const MoveInfo &mi, int offset, const double *w)
Definition: move_probability/feature.h:1437
osl::Square
Definition: basic_type.h:532
osl::NumEffectState::piecesOnBoard
const PieceMask & piecesOnBoard(Player p) const
Definition: numEffectState.h:63
osl::move_probability::OpposingPawn::match
double match(const StateInfo &state, const MoveInfo &info, int offset, const double *w) const
Definition: move_probability/feature.h:1294
osl::move_probability::PawnAttack::PawnAttack
PawnAttack()
Definition: move_probability/feature.h:647
osl::move_probability::SquareX::fromTo
static int fromTo(Square to, Square from)
Definition: move_probability/feature.h:224
osl::NumEffectState::findCheapAttack
const Piece findCheapAttack(Player P, Square square) const
Definition: numEffectState.h:560
osl::move_probability::BookMove::BookMove
BookMove()
Definition: move_probability/feature.h:1746
osl::PieceMask::reset
void reset(int num)
Definition: pieceMask.h:54
osl::move_probability::KingBlockade::StandCount
@ StandCount
Definition: move_probability/feature.h:1467
osl::move_probability::BreakThreatmate::match
double match(const StateInfo &info, const MoveInfo &move, int offset, const double *w) const
Definition: move_probability/feature.h:1080
osl::move_probability::StateInfo::threatmate_move
Move threatmate_move
Definition: stateInfo.h:35
osl::checkmate::King8Info::liberty
unsigned int liberty() const
8-15 bit 目を 0-7bitにshiftして返す
Definition: king8Info.h:54
osl::move_probability::BishopAttack::match
double match(const StateInfo &state, const MoveInfo &move, int offset, const double *w) const
Definition: move_probability/feature.h:985
osl::move_probability::SquareY::fromTo
static int fromTo(Square to, Square from)
Definition: move_probability/feature.h:196
osl::move_probability::CoverFork::match
double match(const StateInfo &si, const MoveInfo &mi, int offset, const double *w) const
Definition: move_probability/feature.h:1554
osl::move_probability::PawnAttack::PTYPE2_DIM
@ PTYPE2_DIM
Definition: move_probability/feature.h:641
osl::move_probability::LongRecapture::LongRecapture
LongRecapture()
Definition: move_probability/feature.h:809
osl::move_probability::CheckFeature::checkIndex
static int checkIndex(const MoveInfo &move)
Definition: move_probability/feature.h:48
osl::move_probability::King5x5Ptype
Definition: move_probability/feature.h:1428
osl::move_probability::SeeFeature::seeIndex
static int seeIndex(int see)
Definition: move_probability/feature.h:102
osl::eval::min
int min(Player p, int v1, int v2)
Definition: evalTraits.h:92
osl::move_probability::BishopAttack::DIM
@ DIM
Definition: move_probability/feature.h:925
osl::EffectContent::offset
const Offset offset() const
返り値が0なら長い利きがない, 0以外なら辿るのに必要なoffset (2005/3/25 に仕様変更 - 長い利きだが隣の場合もoffsetを返す)
Definition: effectContent.h:44
osl::move_probability::ToEffect::ToEffect
ToEffect()
Definition: move_probability/feature.h:353
osl::move_probability::CheckFeature
Definition: move_probability/feature.h:41
osl::move_probability::BreakThreatmate::PatternCacheSize
@ PatternCacheSize
Definition: move_probability/feature.h:1026
osl::move_probability::StateInfo::bookmove
CArray< Move, 2 > bookmove
Definition: stateInfo.h:44
osl::move_probability::LureDefender::ATTACK_DIM
@ ATTACK_DIM
Definition: move_probability/feature.h:1165
osl::move_probability::TakeBackFeature
Definition: move_probability/feature.h:75
osl::WHITE
@ WHITE
Definition: basic_type.h:10
osl::move_probability::BlockLong::findAll
static double findAll(const StateInfo &state, Move move, const double *w, int offset=0)
Definition: move_probability/feature.h:764
osl::move_probability::SquareY
Definition: move_probability/feature.h:187
osl::move_probability::StateInfo::pin_by_opposing_sliders
PieceVector pin_by_opposing_sliders
Definition: stateInfo.h:25
osl::move_probability::TakeBackFeature::TakeBackFeature
TakeBackFeature()
Definition: move_probability/feature.h:77
osl::move_probability::BreakThreatmate::OpenRoadSize
@ OpenRoadSize
Definition: move_probability/feature.h:1028
osl::move_probability::KingBlockade::BlockSideWide
@ BlockSideWide
Definition: move_probability/feature.h:1469
osl::move_probability::KingBlockade::BlockSideOther
@ BlockSideOther
Definition: move_probability/feature.h:1469
osl::move_probability::KingBlockade::match
double match(const StateInfo &si, const MoveInfo &mi, int offset, const double *w) const
Definition: move_probability/feature.h:1490
osl::move_probability::KingBlockade::KingBlockade
KingBlockade()
Definition: move_probability/feature.h:1472
osl::move_probability::AttackFromOpposingSliders
Definition: move_probability/feature.h:592
osl::Square::isOnBoard
bool isOnBoard() const
盤面上を表すかどうかの判定. 1<=x() && x()<=9 && 1<=y() && y()<=9 Squareの内部表現に依存する.
Definition: basic_type.h:583
osl::move_probability::AddEffectLong
Definition: move_probability/feature.h:834
osl::move_probability::BreakThreatmate::KingMoveBase
@ KingMoveBase
Definition: move_probability/feature.h:1029
osl::move_probability::PawnAttack::squareStatus
std::pair< int, int > squareStatus(const NumEffectState &state, Player player, Square to, Square &front) const
Definition: move_probability/feature.h:650
osl::move_probability::CheckmateIfCapture::CheckmateIfCapture
CheckmateIfCapture()
Definition: move_probability/feature.h:1229
osl::move_probability::PatternCommon::AttackSize
@ AttackSize
Definition: move_probability/feature.h:475
osl::move_probability::StateInfo::possible_threatmate_ptype
unsigned int possible_threatmate_ptype
Definition: stateInfo.h:43
osl::Board_Table
const BoardTable Board_Table
Definition: tables.cc:95
osl::R
@ R
Definition: basic_type.h:317
osl::move_probability::LongRecapture::match
double match(const StateInfo &info, const MoveInfo &move, int offset, const double *w) const
Definition: move_probability/feature.h:812
osl::alt
constexpr Player alt(Player player)
Definition: basic_type.h:13
osl::move_probability::EscapeThreatened::DIM
@ DIM
Definition: move_probability/feature.h:1692
osl::move_probability::Feature::name
std::string name() const
Definition: move_probability/feature.h:26
osl::PtypeTable::getEffect
const EffectContent getEffect(PtypeO ptypeo, Square from, Square to) const
fromにいるptypeoがtoに利きを持つか?
Definition: ptypeTable.h:112
osl::PTYPE_SIZE
const int PTYPE_SIZE
Definition: basic_type.h:107
osl::move_probability::BlockLong::LongAttackSize
@ LongAttackSize
Definition: move_probability/feature.h:707
osl::move_probability::PatternPromotion
PatternBase< true > PatternPromotion
Definition: move_probability/feature.h:559
osl::move_probability::BlockLongFrom::findAll
static double findAll(const StateInfo &state, Move move, const double *w, int offset=0)
Definition: move_probability/feature.h:790
osl::move_probability::DropAfterOpposingPawn::match
double match(const StateInfo &state, const MoveInfo &info, int offset, const double *w) const
Definition: move_probability/feature.h:1327
osl::NumEffectState::effectSetAt
const NumBitmapEffect effectSetAt(Square sq) const
Definition: numEffectState.h:258
neighboring8Direct.h
osl::move_probability::KingRelativeY::match
double match(const StateInfo &state, const MoveInfo &info, int offset, const double *w) const
Definition: move_probability/feature.h:255
osl::move_probability::KingRelativeX::KingRelativeX
KingRelativeX()
Definition: move_probability/feature.h:288
osl::Offset32
Offset32Base< 8, 9 > Offset32
Definition: offset32.h:63
osl::move_probability::DropCaptured::DropCaptured
DropCaptured()
Definition: move_probability/feature.h:172
osl::promote
Ptype promote(Ptype ptype)
promote可能なptypeに対して,promote後の型を返す promote不可のptypeを与えてはいけない.
Definition: basic_type.h:173
osl::move_probability::SendOff
Definition: move_probability/feature.h:1145
osl::move_probability::Feature
Definition: move_probability/feature.h:17
osl::move_probability::ToEffect
Definition: move_probability/feature.h:351
osl::PtypeFuns
Definition: ptypeTraits.h:311
osl::move_probability::BreakThreatmate::CaptureBase
@ CaptureBase
Definition: move_probability/feature.h:1030
osl::move_probability::BlockLong::DIM
@ DIM
Definition: move_probability/feature.h:708
osl::move_probability::Feature::my_name
std::string my_name
Definition: move_probability/feature.h:18
osl::move_probability::BlockLongFrom::DIM
@ DIM
Definition: move_probability/feature.h:785
osl::move_probability::PatternCommon::PatternCacheSize
@ PatternCacheSize
Definition: move_probability/feature.h:484
osl::getPtype
Ptype getPtype(PtypeO ptypeO)
Definition: basic_type.h:217
osl::move_probability::KingRelativeY::KingRelativeY
KingRelativeY()
Definition: move_probability/feature.h:252
osl::move_probability::CoverFork::DIM
@ DIM
Definition: move_probability/feature.h:1536
osl::move_probability::DropCaptured
ä򤹤Ȥ
Definition: move_probability/feature.h:170
osl::move_probability::SacrificeAttack::DIM
@ DIM
Definition: move_probability/feature.h:1401
osl::move_probability::PatternCommon::MyKingBase
@ MyKingBase
Definition: move_probability/feature.h:478
osl::move_probability::FromEffect
Definition: move_probability/feature.h:330
osl::Move
圧縮していない moveの表現 .
Definition: basic_type.h:1052
osl::move_probability::PatternCommon::PinOpenBase
@ PinOpenBase
Definition: move_probability/feature.h:480
osl::move_probability::ToEffectLong::match
double match(const StateInfo &state_info, const MoveInfo &info, int offset, const double *w) const
Definition: move_probability/feature.h:445
osl::move_probability::PawnAttack::DIM
@ DIM
Definition: move_probability/feature.h:645
osl::Move::isCaptureOrPromotion
bool isCaptureOrPromotion() const
Definition: basic_type.h:1149
osl::move_probability::LureDefender::match
double match(const StateInfo &info, const MoveInfo &move, int offset, const double *w) const
Definition: move_probability/feature.h:1216
osl::move_probability::CapturePtype
Definition: move_probability/feature.h:131
osl::Piece::ptypeO
PtypeO ptypeO() const
Definition: basic_type.h:824
osl::move_probability::EscapeThreatened::EscapeThreatened
EscapeThreatened()
Definition: move_probability/feature.h:1694
osl::move_probability::StateInfo::pattern_cache
CArray< pattern_square_t, Square::SIZE > pattern_cache
Definition: stateInfo.h:30
osl::move_probability::BlockLongFrom::BlockLongFrom
BlockLongFrom()
Definition: move_probability/feature.h:787
osl::move_probability::LureDefender::match
static double match(const NumEffectState &state, Move move, int see, const StateInfo::pinned_gs_t &pinned_list, int offset, const double *w)
Definition: move_probability/feature.h:1171
osl::move_probability::RookAttack
Definition: move_probability/feature.h:998
osl::move_probability::KingBlockade::BlockFront
@ BlockFront
Definition: move_probability/feature.h:1468
osl::move_probability::KingBlockade::blockAll
static bool blockAll(const King8Info &ki, Square king, Move move, const NumEffectState &state, const CArray< Direction, 3 > &directions)
Definition: move_probability/feature.h:1475
osl::move_probability::King5x5Ptype::King5x5Ptype
King5x5Ptype()
Definition: move_probability/feature.h:1434
osl::move_probability::ToEffect::supportAttack
static size_t supportAttack(const StateInfo &info, Square to, Move move)
Definition: move_probability/feature.h:388
osl::move_probability::SquareY::DIM
@ DIM
Definition: move_probability/feature.h:191
osl::move_probability::StateInfo::king8_long_pieces
PieceVector king8_long_pieces
Definition: stateInfo.h:25
osl::BoardTable::getLongDirection
Direction getLongDirection(Offset32 offset32) const
Definition: boardTable.h:71
osl::move_probability::LanceAttack
Definition: move_probability/feature.h:868
osl::move_probability::BishopAttack::addOne
static double addOne(const StateInfo &info, Square to, int offset, const double *w)
Definition: move_probability/feature.h:945
osl::container::MoveStack::lastMove
const Move lastMove(size_t last=1) const
Definition: moveStack.h:28
osl::Square::isOnBoardRegion
bool isOnBoardRegion() const
squareがONBOARD_MINとONBOARD_MAXの間にある
Definition: basic_type.h:641
osl::move_probability::BreakThreatmate::AddEffect8Size
@ AddEffect8Size
Definition: move_probability/feature.h:1031
osl::move_probability::StateInfo::long_attack_cache
CArray2d< long_attack_t, 40, 8 > long_attack_cache
Definition: stateInfo.h:28
osl::PieceMask::set
void set(int num)
Definition: pieceMask.h:48
osl::move_probability::PatternCommon::LastToSize
@ LastToSize
Definition: move_probability/feature.h:481
osl::effect::NumBitmapEffect::selectLong
const mask_t selectLong() const
Definition: numBitmapEffect.h:138
osl::move_probability::PromotionBySacrifice::PromotionBySacrifice
PromotionBySacrifice()
Definition: move_probability/feature.h:1616
osl::NumEffectState::effectedMask
const PieceMask effectedMask(Player pl) const
pl からの利きが(1つ以上)ある駒一覧
Definition: numEffectState.h:130
osl::getOwner
Player getOwner(PtypeO ptypeO)
Definition: basic_type.h:256
osl::Offset
座標の差分
Definition: basic_type.h:430
osl::move_probability::StateInfo::pinByOpposingSliders
bool pinByOpposingSliders(Piece p) const
Definition: stateInfo.h:83
osl::move_probability::Pattern
PatternBase< false > Pattern
Definition: move_probability/feature.h:558
osl::move_probability::PawnAttack::PawnSize
@ PawnSize
Definition: move_probability/feature.h:644
osl::move_probability::BookMove
Definition: move_probability/feature.h:1741
osl::move_probability::AttackKing8Long::DIM
@ DIM
Definition: move_probability/feature.h:1262
osl::move_probability::LongRecapture::DIM
@ DIM
Definition: move_probability/feature.h:807
osl::move_probability::MoveFromOpposingSliders
Definition: move_probability/feature.h:562
osl::move_probability::CoverFork::CoverFork
CoverFork()
Definition: move_probability/feature.h:1538
osl::misc::mask_t
GeneralMask< mask_int_t > mask_t
Definition: mask.h:351
osl::move_probability::SacrificeAttack::StandCount
@ StandCount
Definition: move_probability/feature.h:1400
osl::Ptype
Ptype
駒の種類を4ビットでコード化する
Definition: basic_type.h:84
osl::move_probability::BreakThreatmate::DIM
@ DIM
Definition: move_probability/feature.h:1033
osl::move_probability::BreakThreatmate::OtherMoveBase
@ OtherMoveBase
Definition: move_probability/feature.h:1032
osl::LANCE
@ LANCE
Definition: basic_type.h:96
osl::move_probability::SquareX
Definition: move_probability/feature.h:218
osl::move_probability::KingBlockade::BlockLastOne
@ BlockLastOne
Definition: move_probability/feature.h:1468
osl::move_probability::BlockLong
Definition: move_probability/feature.h:701
osl::move_probability::SeeFeature::match
double match(const StateInfo &state, const MoveInfo &move, int offset, const double *w) const
Definition: move_probability/feature.h:116
osl::NumEffectState::hasEffectIf
bool hasEffectIf(PtypeO ptypeo, Square attacker, Square target) const
attackerにptypeoの駒がいると仮定した場合にtargetに利きがあるかどうか を stateをupdateしないで確かめる.
Definition: numEffectState.h:465
osl::move_probability::StateInfo
Definition: stateInfo.h:21
osl::move_probability::AddEffectLong::AddEffectLong
AddEffectLong()
Definition: move_probability/feature.h:839
osl::move_probability::PatternBase
Definition: move_probability/feature.h:511
osl::FixedCapacityVector< int, 8 >
osl::move_probability::MoveInfo::open_check
bool open_check
Definition: moveInfo.h:17
osl::move_probability::StateInfo::king8Info
King8Info king8Info(Player pl) const
Definition: stateInfo.h:88
osl::move_probability::KingBlockade::BlockBack
@ BlockBack
Definition: move_probability/feature.h:1469
osl::move_probability::KingRelativeY::ONE_DIM
@ ONE_DIM
Definition: move_probability/feature.h:251
osl::move_probability::ToEffectLong::ToEffectLong
ToEffectLong()
Definition: move_probability/feature.h:442
osl::move_probability::PatternCommon::updateCache
static void updateCache(StateInfo &info)
Definition: feature_.cc:14
osl::move_probability::ContinueCapture::ContinueCapture
ContinueCapture()
Definition: move_probability/feature.h:157
osl::PTYPEO_SIZE
const int PTYPEO_SIZE
Definition: basic_type.h:308
osl::NumEffectState::hasEffectAt
bool hasEffectAt(Square target) const
対象とするマスにあるプレイヤーの利きがあるかどうか.
Definition: numEffectState.h:324
osl::D
@ D
Definition: basic_type.h:319
osl::CArray::size
static size_t size()
Definition: container.h:76
osl::DirectionPlayerTraits
Definition: directionTraits.h:242
osl::move_probability::PatternCommon::MyKingSize
@ MyKingSize
Definition: move_probability/feature.h:478
osl::Ptype_Table
const PtypeTable Ptype_Table
Definition: tables.cc:97
osl::move_probability::SendOff::SendOff
SendOff()
Definition: move_probability/feature.h:1150
osl::move_probability::CoverPawn::CoverPawn
CoverPawn()
Definition: move_probability/feature.h:1362
osl::move_probability::ToEffect::supportAttack
static void supportAttack(const NumEffectState &state, Square to, const PieceMask &my_pin, const PieceMask &op_pin, Player turn, std::pair< Ptype, Ptype > &out)
Definition: move_probability/feature.h:366
osl::move_probability::BookMove::match
double match(const StateInfo &si, const MoveInfo &mi, int offset, const double *w) const
Definition: move_probability/feature.h:1749
osl::move_probability::PatternBase::name
static std::string name(int x, int y)
Definition: move_probability/feature.h:550
osl::Piece
駒.
Definition: basic_type.h:788
osl::Offset::zero
bool zero() const
Definition: basic_type.h:502
osl::NumEffectState::inCheck
bool inCheck(Player P) const
Pの玉が王手状態
Definition: numEffectState.h:88
osl::move_probability::MoveInfo
Definition: moveInfo.h:14
osl::move_probability::OpposingPawn::DIM
@ DIM
Definition: move_probability/feature.h:1289
osl::PtypeTable::getMoveMask
int getMoveMask(Ptype ptype) const
Definition: ptypeTable.h:84
osl::move_probability::Feature::classifyEffect9
static int classifyEffect9(const NumEffectState &state, Player player, Square to)
Definition: move_probability/feature.h:30
osl::GOLD
@ GOLD
Definition: basic_type.h:94
osl::move_probability::MoveInfo::move
Move move
Definition: moveInfo.h:15
osl::eval::max
int max(Player p, int v1, int v2)
Definition: evalTraits.h:84
osl::SimpleState::pieceOf
const Piece pieceOf(int num) const
Definition: simpleState.h:76
osl::checkmate::King8Info::libertyCount
unsigned int libertyCount() const
libertyの数
Definition: king8Info.h:82
osl::DR
@ DR
Definition: basic_type.h:320
osl::move_probability::CheckFeature::RELATIVE_Y_CLASS
@ RELATIVE_Y_CLASS
Definition: move_probability/feature.h:43
osl::move_probability::ThreatmateByCapture
Definition: move_probability/feature.h:1583
osl::move_probability::StateInfo::sendoffs
Square8 sendoffs
Definition: stateInfo.h:36
osl::move_probability::ThreatmateByCapture::match
double match(const StateInfo &si, const MoveInfo &mi, int offset, const double *w) const
Definition: move_probability/feature.h:1591
osl::Move::oldPtype
Ptype oldPtype() const
移動前のPtype, i.e., 成る手だった場合成る前
Definition: basic_type.h:1174
osl::move_probability::PinnedGeneral
Definition: pinnedGeneral.h:12
osl::move_probability::BishopAttack
Definition: move_probability/feature.h:921
osl::move_probability::StateInfo::state
const NumEffectState * state
Definition: stateInfo.h:22
osl::move_probability::PatternCommon::AttackBase
@ AttackBase
Definition: move_probability/feature.h:475
osl::move_probability::EscapeThreatened
Definition: move_probability/feature.h:1689
osl::SimpleState::pieceOnBoard
const Piece pieceOnBoard(Square sq) const
Definition: simpleState.h:170
osl::move_probability::King5x5Ptype::match
double match(const StateInfo &si, const MoveInfo &mi, int offset, const double *w) const
Definition: move_probability/feature.h:1455
osl::move_probability::RookAttack::DirectionSize
@ DirectionSize
Definition: move_probability/feature.h:1001
osl::move_probability::CheckFeature::CHECK_CLASS
@ CHECK_CLASS
Definition: move_probability/feature.h:43
osl::Square::isPieceStand
bool isPieceStand() const
Definition: basic_type.h:576
osl::NumEffectState::selectCheapPiece
const Piece selectCheapPiece(PieceMask effect) const
利きの中から安そうな駒を選ぶ
Definition: numEffectState.cc:100
osl::move_probability::BreakThreatmate::isDefendingKing8
static bool isDefendingKing8(Move move, Square king, const NumEffectState &state)
Definition: move_probability/feature.h:1064
osl::move_probability::PatternCommon::PromotionBase
@ PromotionBase
Definition: move_probability/feature.h:479
osl::KING
@ KING
Definition: basic_type.h:93
osl::move_probability::DropAfterOpposingPawn
Definition: move_probability/feature.h:1319
osl::Move::oldPtypeO
PtypeO oldPtypeO() const
移動前のPtypeO, i.e., 成る手だった場合成る前
Definition: basic_type.h:1168
osl::Square::index
unsigned int index() const
Definition: basic_type.h:572
osl::move_probability::BishopAttack::PatternCacheSize
@ PatternCacheSize
Definition: move_probability/feature.h:924
osl::move_probability::ThreatmateByCapture::ThreatmateByCapture
ThreatmateByCapture()
Definition: move_probability/feature.h:1588
osl::move_probability::BishopAttack::BishopAttack
BishopAttack()
Definition: move_probability/feature.h:927
osl::move_probability::DropAfterOpposingPawn::DIM
@ DIM
Definition: move_probability/feature.h:1322
osl::move_probability::PatternCommon::LastEffectChangedSize
@ LastEffectChangedSize
Definition: move_probability/feature.h:482
osl::move_probability::BreakThreatmate::isOpeningKingRoad
static bool isOpeningKingRoad(Move move, Square king)
Definition: move_probability/feature.h:1042
osl::move_probability::ToEffect::find
static const Piece find(const NumEffectState &state, Square to, const PieceMask &remove, Player player)
Definition: move_probability/feature.h:356
osl::move_probability::Feature::Feature
Feature(std::string n, size_t d)
Definition: move_probability/feature.h:21
osl::move_probability::PatternBase::PatternBase
PatternBase(int x, int y)
Definition: move_probability/feature.h:518
osl::BISHOP
@ BISHOP
Definition: basic_type.h:99
osl::container::PieceMask64::takeOneBit
int takeOneBit()
Definition: pieceMask64.h:82
osl::move_probability::CheckmateIfCapture::hasSafeCapture
static bool hasSafeCapture(NumEffectState &state, Move)
Definition: feature_.cc:205
osl::Move::capturePtype
Ptype capturePtype() const
Definition: basic_type.h:1180
osl::move_probability::LureDefender
Definition: move_probability/feature.h:1162
osl::move_probability::SendOff::match
double match(const StateInfo &info, const MoveInfo &move, int offset, const double *w) const
Definition: move_probability/feature.h:1153
osl::move_probability::MoveInfo::standIndex
int standIndex(const NumEffectState &state) const
Definition: moveInfo.h:22
osl::move_probability::EscapeThreatened::match
double match(const StateInfo &si, const MoveInfo &mi, int offset, const double *w) const
Definition: move_probability/feature.h:1697
osl::move_probability::CoverFork
Definition: move_probability/feature.h:1533
osl::Move::isDrop
bool isDrop() const
Definition: basic_type.h:1150
osl::Move::ptypeO
PtypeO ptypeO() const
移動後のPtype, i.e., 成る手だった場合成った後
Definition: basic_type.h:1162
osl::PAWN
@ PAWN
Definition: basic_type.h:95
osl::move_probability::LanceAttack::match
double match(const StateInfo &state, const MoveInfo &move, int offset, const double *w) const
Definition: move_probability/feature.h:877
osl::move_probability::PatternBase::black_dy
int black_dy
Definition: move_probability/feature.h:512
osl::NumEffectState::hasEffectByPiece
bool hasEffectByPiece(Piece attack, Square target) const
駒attack が target に利きを持つか (旧hasEffectToと統合)
Definition: numEffectState.h:450
osl::Square::square
unsigned int square
Definition: basic_type.h:533
osl::move_probability::CoverPawn
Definition: move_probability/feature.h:1357
osl::move_probability::KingRelativeX::match
double match(const StateInfo &state, const MoveInfo &info, int offset, const double *w) const
Definition: move_probability/feature.h:291
osl::move_probability::PawnAttack::match
double match(const StateInfo &state, const MoveInfo &move, int offset, const double *w) const
Definition: move_probability/feature.h:689
osl::move_probability::SacrificeAttack::SacrificeAttack
SacrificeAttack()
Definition: move_probability/feature.h:1403
osl::move_probability::ContinueCapture::match
double match(const StateInfo &state, const MoveInfo &move, int offset, const double *w) const
Definition: move_probability/feature.h:158
osl::container::Square8::isMember
bool isMember(Square position) const
Definition: square8.h:22
osl::move_probability::SeeFeature::YClass
@ YClass
Definition: move_probability/feature.h:98
osl::move_probability::OpposingPawn::OpposingPawn
OpposingPawn()
Definition: move_probability/feature.h:1291
osl::move_probability::AddEffectLong::addOne
static double addOne(Direction dir, const StateInfo &state, const MoveInfo &move, int offset, const double *w)
Definition: move_probability/feature.h:842
osl::Piece::isOnBoardByOwner
bool isOnBoardByOwner() const
piece がプレイヤーPの持ち物でかつボード上にある駒の場合は true.
Definition: basic_type.h:852
osl::move_probability::PromotionBySacrifice
Definition: move_probability/feature.h:1611
osl::L
@ L
Definition: basic_type.h:316
osl::move_probability::StateInfo::pin
CArray< PieceMask, 2 > pin
Definition: stateInfo.h:34
osl::move_probability::King5x5Ptype::DIM
@ DIM
Definition: move_probability/feature.h:1432
osl::move_probability::PatternCommon
Definition: move_probability/feature.h:471
osl::Piece::isPromoted
bool isPromoted() const
promoteした駒かどうかをチェックする
Definition: basic_type.h:898
osl::move_probability::KingRelativeX
Definition: move_probability/feature.h:284
osl::Offset32Base
差が uniqになるような座標の差分.
Definition: offset32.h:17
osl::move_probability::LanceAttack::DIM
@ DIM
Definition: move_probability/feature.h:872
osl::move_probability::CheckFeature::sign
static int sign(const NumEffectState &state, Move move, Player player)
Definition: move_probability/feature.h:54
osl::move_probability::ToEffect::match
double match(const StateInfo &state, const MoveInfo &info, int offset, const double *w) const
Definition: move_probability/feature.h:394
osl::move_probability::BreakThreatmate::CaptureSize
@ CaptureSize
Definition: move_probability/feature.h:1030
osl::move_probability::King5x5Ptype::ONE_DIM
@ ONE_DIM
Definition: move_probability/feature.h:1431
osl::move_probability::PromotionBySacrifice::match
double match(const StateInfo &si, const MoveInfo &mi, int offset, const double *w) const
Definition: move_probability/feature.h:1619
osl::move_probability::ThreatmateByCapture::DIM
@ DIM
Definition: move_probability/feature.h:1586
osl::move_probability::ToEffect::supportAttack
static void supportAttack(const StateInfo &info, Square to, Move move, std::pair< Ptype, Ptype > &out)
Definition: move_probability/feature.h:376
osl::move_probability::RookAttack::match
double match(const StateInfo &state, const MoveInfo &move, int offset, const double *w) const
Definition: move_probability/feature.h:1007
osl::BoardTable::getShortOffsetNotKnight
const Offset getShortOffsetNotKnight(Offset32 offset32) const
Longの利きの可能性のあるoffsetの場合は, 反復に使う offsetを Knight以外のShortの利きのoffsetの場合はそれ自身を返す.
Definition: boardTable.h:119
osl::move_probability::MoveFromOpposingSliders::MoveFromOpposingSliders
MoveFromOpposingSliders()
Definition: move_probability/feature.h:564
osl::Move::isNormal
bool isNormal() const
INVALID でも PASS でもない.
Definition: basic_type.h:1088
osl::Piece::owner
Player owner() const
Definition: basic_type.h:963
osl::move_probability::AttackToOpposingSliders::match
double match(const StateInfo &state, const MoveInfo &info, int offset, const double *w) const
Definition: move_probability/feature.h:619
osl::move_probability::BreakThreatmate::isDefendingThreatmate
static bool isDefendingThreatmate(Move move, Move threatmate, const NumEffectState &state)
Definition: move_probability/feature.h:1047
osl::move_probability::CoverPawn::match
double match(const StateInfo &si, const MoveInfo &mi, int offset, const double *w) const
Definition: move_probability/feature.h:1365
osl::move_probability::SacrificeAttack
Definition: move_probability/feature.h:1397
osl::move_probability::SquareX::SquareX
SquareX()
Definition: move_probability/feature.h:221
osl::PBISHOP
@ PBISHOP
Definition: basic_type.h:91
osl::Move::from
const Square from() const
Definition: basic_type.h:1125
osl::move_probability::CheckFeature::match
double match(const StateInfo &state, const MoveInfo &move, int offset, const double *w) const
Definition: move_probability/feature.h:62
osl::PieceStand::order
static const CArray< Ptype, 7 > order
持駒の表示で良く使われる順番.
Definition: bits/pieceStand.h:41
osl::move_probability::BlockLong::BasicAttack
@ BasicAttack
Definition: move_probability/feature.h:705
osl::SimpleState::hasPieceOnStand
bool hasPieceOnStand(Player player, Ptype ptype) const
Definition: simpleState.h:191
osl::Square::x
int x() const
将棋としてのX座標を返す.
Definition: basic_type.h:563
osl::move_probability::AttackToOpposingSliders::AttackToOpposingSliders
AttackToOpposingSliders()
Definition: move_probability/feature.h:616
osl::PtypeO
PtypeO
Player + Ptype [-15, 15] PtypeO の O は Owner の O.
Definition: basic_type.h:199
osl::Piece::isPiece
bool isPiece() const
Definition: basic_type.h:953
osl::captured
PtypeO captured(PtypeO ptypeO)
unpromoteすると共に,ownerを反転する.
Definition: basic_type.h:264
osl::misc::BitOp::bsf
static int bsf(Integer mask)
Definition: mask.h:138
osl::move_probability::AttackKing8Long::match
double match(const StateInfo &state, const MoveInfo &info, int offset, const double *w) const
Definition: move_probability/feature.h:1267
osl::NumEffectState
利きを持つ局面
Definition: numEffectState.h:34
osl::move_probability::KingBlockade
Definition: move_probability/feature.h:1464
osl::FixedCapacityVector::isMember
bool isMember(const T &e, const_iterator first, const_iterator last) const
Definition: container.h:257
osl::BoardTable::getOffset
const Offset getOffset(Direction dir) const
Definition: boardTable.h:47
osl::move_probability::CoverFork::defending
static bool defending(const NumEffectState &state, Move move, Square target)
Definition: move_probability/feature.h:1541
osl::Direction
Direction
Definition: basic_type.h:310
osl::move_probability::BlockLong::updateCache
static void updateCache(StateInfo &)
Definition: feature_.cc:113
osl::move_probability::SquareX::match
double match(const StateInfo &state, const MoveInfo &info, int offset, const double *w) const
Definition: move_probability/feature.h:228
osl::move_probability::TakeBackFeature::match
double match(const StateInfo &state, const MoveInfo &move, int offset, const double *w) const
Definition: move_probability/feature.h:80
osl::move_probability::FromEffect::FromEffect
FromEffect()
Definition: move_probability/feature.h:332
osl::move_probability::BlockLong::longAttackIndex
static int longAttackIndex(osl::PtypeO ptypeo)
Definition: move_probability/feature.h:713
osl::move_probability::CheckmateIfCapture::match
double match(const StateInfo &info, const MoveInfo &move, int offset, const double *w) const
Definition: move_probability/feature.h:1232
osl::move_probability::FromEffectLong::FromEffectLong
FromEffectLong()
Definition: move_probability/feature.h:409
osl::move_probability::SacrificeAttack::match
double match(const StateInfo &si, const MoveInfo &mi, int offset, const double *w) const
Definition: move_probability/feature.h:1406
osl::SimpleState::isEmptyBetween
bool isEmptyBetween(Square from, Square to, Offset offset, bool pieceExistsAtTo=false) const
Definition: simpleState.h:267
osl::ROOK
@ ROOK
Definition: basic_type.h:100
osl::move_probability::StateInfo::threatened
CArray< Piece, 2 > threatened
Definition: stateInfo.h:26
osl::move_probability::CoverPawn::DIM
@ DIM
Definition: move_probability/feature.h:1360
osl::move_probability::MoveInfo::see
int see
Definition: moveInfo.h:16
additionalEffect.h
osl::move_probability::PatternCommon::PinOpenSize
@ PinOpenSize
Definition: move_probability/feature.h:480
osl::Square::canPromote
bool canPromote() const
Definition: basic_type.h:659
osl::effect::NumBitmapEffect
現在の定義 (2005/3/4以降)
Definition: numBitmapEffect.h:29
osl::move_probability::KingBlockade::DIM
@ DIM
Definition: move_probability/feature.h:1470
osl::move_probability::CapturePtype::match
double match(const StateInfo &state, const MoveInfo &move, int offset, const double *w) const
Definition: move_probability/feature.h:136
osl::SimpleState::kingSquare
Square kingSquare() const
Definition: simpleState.h:94
osl::BoardTable::isBetween
bool isBetween(Square t, Square p0, Square p1) const
p0, p1の間にtがあるかどうか.
Definition: boardTable.h:172
osl::Square::y
int y() const
将棋としてのY座標を返す.
Definition: basic_type.h:567
osl::move_probability::PatternCommon::PatternCommon
PatternCommon(const std::string &name, int dim)
Definition: move_probability/feature.h:487
osl::move_probability::RookAttack::RookAttack
RookAttack()
Definition: move_probability/feature.h:1004
osl::sign
constexpr int sign(Player player)
Definition: basic_type.h:23
osl::isLong
constexpr bool isLong(Direction d)
Definition: basic_type.h:350
osl::move_probability::StateInfo::move_candidate_exists
CArray< bool, 2 > move_candidate_exists
Definition: stateInfo.h:39
osl::move_probability::PawnAttack::BasicSize
@ BasicSize
Definition: move_probability/feature.h:643
osl::move_probability::PatternBase::dx
int dx
Definition: move_probability/feature.h:512
osl::move_probability::MoveFromOpposingSliders::match
double match(const StateInfo &state, const MoveInfo &move, int offset, const double *w) const
Definition: move_probability/feature.h:580
osl::move_probability::Feature::dimension
size_t dimension() const
Definition: move_probability/feature.h:28
osl::EffectContent::hasEffect
bool hasEffect() const
短い利きがあるか,間がemptyなら長い利きがある
Definition: effectContent.h:34
osl::move_probability::MoveFromOpposingSliders::longPtype
static int longPtype(const NumEffectState &state, Square position, Player player)
Definition: move_probability/feature.h:567
osl::move_probability::LanceAttack::PatternCacheSize
@ PatternCacheSize
Definition: move_probability/feature.h:871
osl::Square::isNeighboring8
bool isNeighboring8(Square to) const
Definition: basic_type.cc:202
osl::Piece::square
const Square square() const
Definition: basic_type.h:832
osl::move_probability::MoveInfo::check
bool check
Definition: moveInfo.h:17
osl::longToShort
constexpr Direction longToShort(Direction d)
Definition: basic_type.h:380
osl::move_probability::PatternCommon::PromotionSize
@ PromotionSize
Definition: move_probability/feature.h:479
osl::PieceMask::any
bool any() const
Definition: pieceMask.h:57
osl::move_probability::BlockLong::addPiece
static double addPiece(const StateInfo &state, Piece piece, Square to, const double *w, int offset)
Definition: move_probability/feature.h:727
osl::move_probability::BlockLong::match
double match(const StateInfo &state, const MoveInfo &move, int offset, const double *w) const
Definition: move_probability/feature.h:772
osl::Piece::ptype
Ptype ptype() const
Definition: basic_type.h:821
osl::move_probability::DropCaptured::match
double match(const StateInfo &state, const MoveInfo &move, int offset, const double *w) const
Definition: move_probability/feature.h:173
osl::move_probability::BreakThreatmate
Definition: move_probability/feature.h:1023
osl::move_probability::SeeFeature::ProgressClass
@ ProgressClass
Definition: move_probability/feature.h:98
osl::move_probability::AttackKing8Long::AttackKing8Long
AttackKing8Long()
Definition: move_probability/feature.h:1264
osl::Piece::isEmpty
bool isEmpty() const
Definition: basic_type.h:913
osl::move_probability::AttackKing8Long
Definition: move_probability/feature.h:1259
osl::move_probability::SeeFeature
Definition: move_probability/feature.h:96
osl::Move::ptype
Ptype ptype() const
Definition: basic_type.h:1155
osl::BLACK
@ BLACK
Definition: basic_type.h:9
osl::move_probability::StateInfo::progress8
int progress8() const
Definition: stateInfo.h:92
osl::ptypeOIndex
unsigned int ptypeOIndex(PtypeO ptypeo)
Definition: basic_type.h:205
osl::move_probability::BlockLongFrom::match
double match(const StateInfo &state, const MoveInfo &move, int offset, const double *w) const
Definition: move_probability/feature.h:796
osl::move_probability::BreakThreatmate::OtherMoveSize
@ OtherMoveSize
Definition: move_probability/feature.h:1032
osl::move_probability::FromEffectLong
Definition: move_probability/feature.h:407
osl::canPromote
bool canPromote(Ptype ptype)
ptypeがpromote可能な型かどうかのチェック promote済みの場合はfalseを返す
Definition: basic_type.h:147
osl::move_probability::BishopAttack::addSquare
static double addSquare(Square target, const StateInfo &info, int offset, const double *w)
Definition: move_probability/feature.h:930
osl::PTYPE_BASIC_MIN
@ PTYPE_BASIC_MIN
Definition: basic_type.h:103
osl::move_probability::PawnAttack::matchPtype
double matchPtype(const StateInfo &state, const MoveInfo &move, int offset, const double *w) const
Definition: move_probability/feature.h:665
osl::PTYPE_EDGE
@ PTYPE_EDGE
Definition: basic_type.h:86
osl::move_probability::PatternCommon::SquareDim
@ SquareDim
Definition: move_probability/feature.h:483
moveInfo.h
osl::move_probability::MoveInfo::player
Player player
Definition: moveInfo.h:18
stateInfo.h
osl::move_probability::PatternCommon::updateCacheOne
static void updateCacheOne(Square target, StateInfo &info)
Definition: feature_.cc:25
osl::move_probability::BreakThreatmate::AddEffectSize
@ AddEffectSize
Definition: move_probability/feature.h:1027
osl::move_probability::StateInfo::history
const MoveStack * history
Definition: stateInfo.h:23
osl::move_probability::SendOff::DIM
@ DIM
Definition: move_probability/feature.h:1148
osl::SimpleState::kingPiece
const Piece kingPiece() const
Definition: simpleState.h:83
osl::move_probability::CheckFeature::CheckFeature
CheckFeature()
Definition: move_probability/feature.h:44
osl::DL
@ DL
Definition: basic_type.h:318
osl::move_probability::ToEffectLong
Definition: move_probability/feature.h:440
osl::move_probability::BookMove::DIM
@ DIM
Definition: move_probability/feature.h:1744
osl::move_probability::ContinueCapture
Definition: move_probability/feature.h:155
osl::SILVER
@ SILVER
Definition: basic_type.h:98
osl::move_probability::BlockLong::findAll
static double findAll(const StateInfo &state, Player P, Square target, const double *w, int offset)
Definition: move_probability/feature.h:746
osl::EffectContent
Definition: effectContent.h:11
osl::move_probability::PatternCommon::OpKingSize
@ OpKingSize
Definition: move_probability/feature.h:477
osl::move_probability::BreakThreatmate::OpenRoadBase
@ OpenRoadBase
Definition: move_probability/feature.h:1028
osl::move_probability::PatternBase::match
double match(const StateInfo &state, const MoveInfo &info, int offset, const double *w) const
Definition: move_probability/feature.h:522
osl::move_probability::PatternCommon::EffectSize
@ EffectSize
Definition: move_probability/feature.h:476
osl::move_probability::KingRelativeX::ONE_DIM
@ ONE_DIM
Definition: move_probability/feature.h:287
osl::move_probability::CheckmateIfCapture
Definition: move_probability/feature.h:1224
osl::move_probability::PatternCommon::EffectBase
@ EffectBase
Definition: move_probability/feature.h:476
osl::move_probability::AddEffectLong::match
double match(const StateInfo &state, const MoveInfo &move, int offset, const double *w) const
Definition: move_probability/feature.h:854
osl::move_probability::RookAttack::DIM
@ DIM
Definition: move_probability/feature.h:1002
osl::move_probability::AttackToOpposingSliders
Definition: move_probability/feature.h:614
osl::move_probability::BlockLong::AttackPtype
@ AttackPtype
Definition: move_probability/feature.h:704
osl::move_probability::PatternCommon::LastToBase
@ LastToBase
Definition: move_probability/feature.h:481
osl::PTYPE_EMPTY
@ PTYPE_EMPTY
Definition: basic_type.h:85
osl::move_probability::FromEffectLong::match
double match(const StateInfo &state_info, const MoveInfo &info, int offset, const double *w) const
Definition: move_probability/feature.h:412
osl::PROOK
@ PROOK
Definition: basic_type.h:92
osl::SimpleState::turn
Player turn() const
Definition: simpleState.h:220
osl::move_probability::SeeFeature::SeeFeature
SeeFeature()
Definition: move_probability/feature.h:99
osl::effect_util::Neighboring8Direct::hasEffect
static bool hasEffect(const NumEffectState &state, PtypeO ptypeo, Square from, Square target)
ptypeo の駒がfromからtargetの8近傍に直接の利きを持つか
Definition: neighboring8Direct.h:108
osl::move_probability::LureDefender::DIM
@ DIM
Definition: move_probability/feature.h:1166
osl::move_probability::BlockLong::BlockLong
BlockLong()
Definition: move_probability/feature.h:710
osl::move_probability::PromotionBySacrifice::DIM
@ DIM
Definition: move_probability/feature.h:1614
osl::move_probability::FromEffect::match
double match(const StateInfo &state_info, const MoveInfo &info, int offset, const double *w) const
Definition: move_probability/feature.h:335
osl::move_probability::PawnAttack::EFFECT_DIM
@ EFFECT_DIM
Definition: move_probability/feature.h:642
osl::Player
Player
Definition: basic_type.h:8
osl::move_probability::PatternBase::PromotionSize
@ PromotionSize
Definition: move_probability/feature.h:515
osl::move_probability::AddEffectLong::DIM
@ DIM
Definition: move_probability/feature.h:837
osl::move_probability::BlockLong::OptionSize
@ OptionSize
Definition: move_probability/feature.h:706
osl::NumEffectState::longEffectAt
const mask_t longEffectAt(Square target) const
Definition: numEffectState.h:298
osl::UL
@ UL
Definition: basic_type.h:313
osl::move_probability::BlockLong::ptypeSupport
static int ptypeSupport(Ptype moved, bool has_support)
Definition: move_probability/feature.h:742
osl::move_probability::OpposingPawn
Definition: move_probability/feature.h:1286
osl::CArray
Definition: container.h:20
osl::Move::to
const Square to() const
Definition: basic_type.h:1132
osl::move_probability::BlockLongFrom
Definition: move_probability/feature.h:782
osl::container::MoveStack::hasLastMove
bool hasLastMove(size_t last=1) const
Definition: moveStack.h:27
osl::SimpleState::canDropPawnTo
bool canDropPawnTo(Player player, int x) const
xの筋に歩を打てる
Definition: simpleState.h:155
osl::move_probability::BreakThreatmate::AddEffect8Base
@ AddEffect8Base
Definition: move_probability/feature.h:1031
osl::move_probability::BlockLong::makeLongAttackOne
static void makeLongAttackOne(StateInfo &info, Piece piece, Direction d)
Definition: feature_.cc:147
osl::move_probability::DropAfterOpposingPawn::DropAfterOpposingPawn
DropAfterOpposingPawn()
Definition: move_probability/feature.h:1324
osl::move_probability::StateInfo::exchange_pins
CArray< pinned_gs_t, 2 > exchange_pins
Definition: stateInfo.h:38
osl::move_probability::KingRelativeY
Definition: move_probability/feature.h:248
osl::move_probability::LureDefender::LureDefender
LureDefender()
Definition: move_probability/feature.h:1168
osl::U
@ U
Definition: basic_type.h:314
osl::Move::isPromotion
bool isPromotion() const
Definition: basic_type.h:1147
osl::PieceMask
駒番号のビットセット.
Definition: pieceMask.h:21
osl::move_probability::AttackFromOpposingSliders::AttackFromOpposingSliders
AttackFromOpposingSliders()
Definition: move_probability/feature.h:594
osl::move_probability::Feature::match
virtual double match(const StateInfo &, const MoveInfo &, int offset, const double *) const =0
osl::move_probability::BreakThreatmate::BreakThreatmate
BreakThreatmate()
Definition: move_probability/feature.h:1035
osl::NumEffectState::countEffect
int countEffect(Player player, Square target) const
利きの数を数える.
Definition: numEffectState.h:266
osl::Square::squareForBlack
const Square squareForBlack(Player player) const
Definition: basic_type.h:598
osl::checkmate::King8Info
敵玉の8近傍の状態を表す.
Definition: king8Info.h:29
osl::PieceMask::clearBit
void clearBit()
unpromote(PTYPE) の駒のbit を消す
Definition: pieceMask.h:74
osl::move_probability::PatternCommon::addOne
double addOne(const StateInfo &state, int offset, const double *w, Square position) const
Definition: move_probability/feature.h:490
osl::SimpleState::countPiecesOnStand
int countPiecesOnStand(Player pl, Ptype ptype) const
持駒の枚数を数える
Definition: simpleState.h:182
osl::move_probability::AttackFromOpposingSliders::match
double match(const StateInfo &state, const MoveInfo &info, int offset, const double *w) const
Definition: move_probability/feature.h:597
osl::move_probability::BreakThreatmate::KingMoveSize
@ KingMoveSize
Definition: move_probability/feature.h:1029
osl::move_probability::StateInfo::copy
NumEffectState copy
Definition: stateInfo.h:40
osl::move_probability::PatternCommon::OpKingBase
@ OpKingBase
Definition: move_probability/feature.h:477
osl::Move::player
Player player() const
Definition: basic_type.h:1195
osl::unpromote
Ptype unpromote(Ptype ptype)
ptypeがpromote後の型の時に,promote前の型を返す. promoteしていない型の時はそのまま返す
Definition: basic_type.h:157
osl
Definition: additionalEffect.h:6
osl::move_probability::SquareY::SquareY
SquareY()
Definition: move_probability/feature.h:193
osl::move_probability::Feature::dim
int dim
Definition: move_probability/feature.h:19
osl::move_probability::BreakThreatmate::isKingMove
static bool isKingMove(Move move)
Definition: move_probability/feature.h:1038
osl::move_probability::PatternBase::DIM
@ DIM
Definition: move_probability/feature.h:516
osl::KNIGHT
@ KNIGHT
Definition: basic_type.h:97
osl::move_probability::CheckmateIfCapture::DIM
@ DIM
Definition: move_probability/feature.h:1227
osl::Piece::isEdge
bool isEdge() const
Definition: basic_type.h:919