My Project
numEffectState.h
Go to the documentation of this file.
1 /* numEffectState.h
2  */
3 #ifndef OSL_NUM_EFFECT_STATE_H
4 #define OSL_NUM_EFFECT_STATE_H
5 
8 #include "osl/bits/align16New.h"
9 
10 namespace osl
11 {
12  namespace checkmate
13  {
14  class King8Info;
15  }
16  class MoveVector;
17  class NumEffectState;
23  bool operator==(const NumEffectState& st1, const NumEffectState& st2);
24 
30  class NumEffectState : public SimpleState
31 #if OSL_WORDSIZE == 32
32  , public misc::Align16New
33 #endif
34  {
42 
43  friend bool operator==(const NumEffectState& st1,const NumEffectState& st2);
45  public:
46  // ----------------------------------------------------------------------
47  // 0. 将棋以外の操作
48  // ----------------------------------------------------------------------
49  explicit NumEffectState(const SimpleState& st=SimpleState(HIRATE));
52  void copyFrom(const NumEffectState& src);
53  void copyFrom(const SimpleState& src);
54  bool isConsistent(bool showError=true) const;
56  bool isConsistent(const NumEffectState& prev, Move moved, bool show_error=true) const;
57  void showEffect(std::ostream& os) const;
58 
59 
60  // ----------------------------------------------------------------------
61  // 1. 盤面全体の情報
62  // ----------------------------------------------------------------------
63  const PieceMask& piecesOnBoard(Player p) const { return pieces_onboard[p]; }
64  const PieceMask promotedPieces() const { return promoted; }
65  const PieceMask pin(Player king) const
66  {
67  return pin_or_open[king]&piecesOnBoard(king);
68  }
70  const PieceMask checkShadow(Player attack) const
71  {
72  return pin_or_open[alt(attack)]&piecesOnBoard(attack);
73  }
75  {
76  return pin_or_open[king];
77  }
78  uint64_t Iking8Info(Player king) const
79  {
80  return king8infos[king];
81  }
83 #ifdef __GNUC__
84  __attribute__ ((pure))
85 #endif
86  king8Info(Player king) const;
88  bool inCheck(Player P) const
89  {
90  const Square king = kingSquare(P);
91 #ifdef ALLOW_KING_ABSENCE
92  if (king.isPieceStand())
93  return false;
94 #endif
95  return hasEffectAt(alt(P), king);
96  }
98  bool inCheck() const { return inCheck(turn()); }
107  bool inUnblockableCheck(Player target) const {
108  const Square king_position = kingSquare(target);
109  Piece attacker_piece;
110  if (hasEffectAt(alt(target), king_position, attacker_piece)) {
111  if (attacker_piece == Piece::EMPTY())
112  return true; // multiple pieces
113  // sigle check
114  const Square from = attacker_piece.square();
115  const EffectContent effect
116  = Ptype_Table.getEffect(attacker_piece.ptypeO(),
117  from, king_position);
118  return effect.hasUnblockableEffect();
119  }
120  // no check
121  return false;
122  }
123 
125  {
126  return effects.effectedNumTable;
127  }
128 
130  const PieceMask effectedMask(Player pl) const
131  {
132  return effects.effected_mask[pl];
133  }
138  {
139  return effects.effected_changed_mask[pl];
140  }
141  bool hasChangedEffects() const {
143  }
144  const BoardMask changedEffects(Player pl) const{
145  assert(hasChangedEffects());
146  return effects.changedEffects(pl);
147  }
148  const BoardMask changedEffects() const{
150  return ret |= changedEffects(WHITE);
151  }
153  return effects.changedPieces();
154  }
155  template <Ptype PTYPE> bool longEffectChanged() const
156  {
157  return changedPieces().template hasLong<PTYPE>();
158  }
159  template <Ptype PTYPE> bool anyEffectChanged() const
160  {
161  return changedPieces().template hasAny<PTYPE>();
162  }
163 
165  const Piece findThreatenedPiece(Player P) const;
166 
167  // ----------------------------------------------------------------------
168  // 2. 駒に関する情報
169  // ----------------------------------------------------------------------
170  bool isOnBoardNum(int num) const
171  {
172  return piecesOnBoard(BLACK).test(num) || piecesOnBoard(WHITE).test(num);
173  }
174 
175  Square mobilityOf(Direction d,int num) const
176  {
177  return effects.mobilityTable.get(d,num);
178  }
180  {
181  return mobilityOf(d, p.number());
182  }
184  {
185  return Square::makeDirect(king_mobility[p][d]);
186  }
193  {
194  if (p == BLACK)
195  d = inverse(d);
196  return kingMobilityAbs(p, d);
197  }
202  template<Player P>
204  {
205  assert(p.owner() == P);
206  assert(pinOrOpen(P).test(p.number()));
207  Square king=kingSquare<P>();
208  return Board_Table.getShort8<P>(p.square(),king);
209  }
211  {
212  if (p.owner() == BLACK)
213  return pinnedDir<BLACK>(p);
214  else
215  return pinnedDir<WHITE>(p);
216  }
221  template<Player P>
222  bool pinnedCanMoveTo(Piece p,Square to) const
223  {
224  assert(p.owner() == P);
225  Direction d=pinnedDir<P>(p);
226  Square from=p.square();
227  return primDir(d)==primDirUnsafe(Board_Table.getShort8Unsafe<P>(from,to));
228  }
229  bool pinnedCanMoveTo(Piece p,Square to) const
230  {
231  if (p.owner() == BLACK)
232  return pinnedCanMoveTo<BLACK>(p, to);
233  else
234  return pinnedCanMoveTo<WHITE>(p, to);
235  }
239  template<Player P>
240  Piece pinAttacker(Piece pinned) const
241  {
242  assert(pinned.owner() == P);
243  assert(pinOrOpen(P).test(pinned.number()));
244  Direction d=pinnedDir<P>(pinned);
245  int attacker_num=longEffectNumTable()[pinned.number()][(P==BLACK ? d : inverseUnsafe(d))];
246  return pieceOf(attacker_num);
247  }
248  Piece pinAttacker(Piece pinned) const
249  {
250  if (pinned.owner() == BLACK)
251  return pinAttacker<BLACK>(pinned);
252  else
253  return pinAttacker<WHITE>(pinned);
254  }
255  // ----------------------------------------------------------------------
256  // 3. あるSquareへの利き
257  // ----------------------------------------------------------------------
259  {
260  return effects.effectSetAt(sq);
261  }
266  int countEffect(Player player,Square target) const
267  {
268  assert(target.isOnBoard());
269  return effectSetAt(target).countEffect(player);
270  }
276  int
277 #ifdef __GNUC__
278  __attribute__ ((pure))
279 #endif
280  countEffect(Player player,Square target, PieceMask pins) const
281  {
282  assert(target.isOnBoard());
283  const NumBitmapEffect effect = effectSetAt(target);
284  const int all = effect.countEffect(player);
285  pins &= effect;
286  return all - pins.countBit();
287  }
288 
289  // ----------------------------------------------------------------------
290  // 3.1 集合を返す
291  // ----------------------------------------------------------------------
292  template <Ptype PTYPE>
293  const mask_t allEffectAt(Player P, Square target) const
294  {
295  return effectSetAt(target).template selectBit<PTYPE>() & piecesOnBoard(P).template getMask<PTYPE>();
296  }
297  const mask_t allEffectAt(Player P, Ptype ptype, Square target) const;
298  template <Ptype PTYPE> const mask_t longEffectAt(Square target) const
299  {
300  return effectSetAt(target).selectLong<PTYPE>() >> 8;
301  }
302  template <Ptype PTYPE> const mask_t longEffectAt(Square target, Player owner) const
303  {
304  return longEffectAt<PTYPE>(target) & piecesOnBoard(owner).getMask(1);
305  }
306  const mask_t longEffectAt(Square target) const
307  {
308  return effectSetAt(target).selectLong() >> 8;
309  }
310  const mask_t longEffectAt(Square target, Player owner) const
311  {
312  return longEffectAt(target) & piecesOnBoard(owner).getMask(1);
313  }
314 
315  // ----------------------------------------------------------------------
316  // 3.2 bool を返す
317  // ----------------------------------------------------------------------
323  template<Player P>
324  bool hasEffectAt(Square target) const {
325  assert(target.isOnBoard());
326  mask_t mask=effectSetAt(target).getMask(1);
327  mask&=NumBitmapEffect::playerEffectMask<P>();
328  return !mask.none();
329  }
335  bool hasEffectAt(Player player,Square target) const {
336  assert(target.isOnBoard());
337  mask_t mask=effectSetAt(target).getMask(1);
338  mask&=NumBitmapEffect::playerEffectMask(player);
339  return !mask.none();
340  }
341 
345  template <Ptype PTYPE>
346  bool hasLongEffectAt(Player P, Square to) const {
347  static_assert((PTYPE == LANCE || PTYPE == BISHOP || PTYPE == ROOK), "ptype");
348  return longEffectAt<PTYPE>(to, P).any();
349  }
350 
354  template <Ptype PTYPE>
355  bool hasEffectByPtype(Player attack, Square target) const
356  {
357  return allEffectAt<PTYPE>(attack, target).any();
358  }
362  template <Ptype PTYPE>
363  bool hasEffectByPtypeStrict(Player attack, Square target) const
364  {
365  mask_t mask=allEffectAt<PTYPE>(attack, target);
366  if (isPromoted(PTYPE))
367  mask &= promoted.getMask<PTYPE>();
368  else
369  mask &= ~(promoted.getMask<PTYPE>());
370  return mask.any();
371  }
376  template<Direction Dir,Player P>
377  bool hasEffectInDirection(Square to) const {
378  static_assert((DirectionTraits<Dir>::isLong), "Dir");
380  mask_t mask1=pieces_onboard.getMask(1);
382  ? mask_t::makeDirect(PtypeFuns<LANCE>::indexMask)
383  : mask_t::makeDirect(0))
385  ? mask_t::makeDirect(PtypeFuns<BISHOP>::indexMask)
386  : mask_t::makeDirect(0))
388  ? mask_t::makeDirect(PtypeFuns<ROOK>::indexMask)
389  : mask_t::makeDirect(0)));
390  mask1 <<= 8;
391  // 短い利きを排除
393  while (mask1.any())
394  {
395  int num=mask1.takeOneBit()+NumBitmapEffect::longToNumOffset;
396  Square from = pieceOf(num).square();
399  return true;
400  }
401  return false;
402  }
409  bool hasEffectNotBy(Player player,Piece piece,Square target) const {
410  assert(piece.owner()==player);
412  int num=piece.number();
413  pieces_onboard.reset(num);
414  return (pieces_onboard&effectSetAt(target)).any();
415  }
420  assert(target.isOnBoard());
421  PieceMask m=piecesOnBoard(pl)& ~pinOrOpen(pl) & effectSetAt(target);
422  m.clearBit<KING>();
423  return m.any();
424  }
428  bool hasEffectByNotPinned(Player pl,Square target) const{
429  assert(target.isOnBoard());
430  PieceMask m=piecesOnBoard(pl)& ~pinOrOpen(pl) & effectSetAt(target);
431  return m.any();
432  }
439  bool hasMultipleEffectAt(Player player,Square target) const
440  {
441  mask_t mask=effectSetAt(target).getMask(1);
442  mask&=NumBitmapEffect::playerEffectMask(player);
443  return NumBitmapEffect::playerEffect(player).getMask(1) < mask;
444  }
445 
450  bool hasEffectByPiece(Piece attack, Square target) const
451  {
452  assert(attack.isPiece());
453  assert(target.isOnBoard());
454  return effectSetAt(target).test(attack.number());
455  }
456 
457 
465  bool hasEffectIf(PtypeO ptypeo,Square attacker,
466  Square target) const
467 #ifdef __GNUC__
468  __attribute__ ((pure))
469 #endif
470  {
471  Offset32 offset32=Offset32(target,attacker);
472  EffectContent effect=Ptype_Table.getEffect(ptypeo,offset32);
473  if (! effect.hasEffect())
474  return false;
475  if (effect.hasUnblockableEffect())
476  return true;
477  assert(Board_Table.getShortOffset(offset32) == effect.offset());
478  return this->isEmptyBetween(attacker,target,effect.offset());
479  }
483  template<Player P>
484  bool
485 #ifdef __GNUC__
486  __attribute__ ((pure))
487 #endif
488  hasEffectByWithRemove(Square target,Square removed) const;
489 
490  bool hasEffectByWithRemove(Player player, Square target,Square removed) const{
491  if (player==BLACK)
492  return hasEffectByWithRemove<BLACK>(target,removed);
493  else
494  return hasEffectByWithRemove<WHITE>(target,removed);
495  }
496 
497 
498  // ----------------------------------------------------------------------
499  // 3.3 pieceを探す
500  // ----------------------------------------------------------------------
502  template <Ptype PTYPE>
503  const Piece findAttackAt(Player attack, Square target) const
504  {
505  mask_t mask=allEffectAt<PTYPE>(attack, target);
506  if (mask.none())
507  return Piece::EMPTY();
508  return pieceOf(mask.takeOneBit()+PtypeFuns<PTYPE>::indexNum*32);
509  }
510  template <Ptype PTYPE>
511  const Piece findAttackAtStrict(Player attack, Square target) const
512  {
513  mask_t mask=allEffectAt<PTYPE>(attack, target);
514  if (isPromoted(PTYPE))
515  mask &= promoted.getMask<PTYPE>();
516  else
517  mask &= ~(promoted.getMask<PTYPE>());
518  if (mask.none())
519  return Piece::EMPTY();
520  return pieceOf(mask.takeOneBit()+PtypeFuns<PTYPE>::indexNum*32);
521  }
526  const Piece findLongAttackAt(Player owner, int piece, Direction d) const
527  {
528  assert(pieceOf(piece).isOnBoardByOwner(owner));
529  if (owner == BLACK)
530  d = inverse(d);
531  const int num = effects.effectedNumTable[piece][d];
532  if (num == EMPTY_NUM)
533  return Piece::EMPTY();
534  return pieceOf(num);
535  }
536  const Piece findLongAttackAt(Player owner, Piece piece, Direction d) const
537  {
538  assert(piece.isPiece());
539  assert(piece.owner() == owner);
540  return findLongAttackAt(owner, piece.number(), d);
541  }
542  const Piece findLongAttackAt(Piece piece, Direction d) const
543  {
544  assert(piece.isPiece());
545  return findLongAttackAt(piece.owner(), piece, d);
546  }
547  const Piece findLongAttackAt(Square square, Direction d) const
548  {
549  return findLongAttackAt(pieceOnBoard(square), d);
550  }
554  const Piece selectCheapPiece(PieceMask effect) const;
560  const Piece findCheapAttack(Player P, Square square) const
561  {
562  return selectCheapPiece(piecesOnBoard(P) & effectSetAt(square));
563  }
569  const Piece findCheapAttackNotBy(Player P, Square square, const PieceMask& ignore) const
570  {
572  pieces &= ~ignore;
573  return selectCheapPiece(pieces & effectSetAt(square));
574  }
575  const Piece findAttackNotBy(Player P, Square square, const PieceMask& ignore) const
576  {
578  pieces &= ~ignore;
579  pieces &= effectSetAt(square);
580  if (pieces.none())
581  return Piece::EMPTY();
582  return pieceOf(pieces.takeOneBit());
583  }
592  template<Player P>
593  bool findCheckPiece(Piece& attack_piece) const
594  {
595  return hasEffectAt<alt(P)>(kingSquare(P),attack_piece);
596  }
597  bool hasEffectAt(Player P, Square target,Piece& attackerPiece) const
598  {
599  if (P == BLACK)
600  return hasEffectAt<BLACK>(target, attackerPiece);
601  else
602  return hasEffectAt<WHITE>(target, attackerPiece);
603  }
610  template<Player P>
611  bool hasEffectAt(Square target,Piece& attackerPiece) const {
612  attackerPiece=Piece::EMPTY();
613  const PieceMask& pieceMask=piecesOnBoard(P)&effectSetAt(target);
614  mask_t mask=pieceMask.getMask(0);
615  if (mask.none()) return false;
620  if (mask.hasMultipleBit())
621  return true;
622  int num=mask.bsf();
623  attackerPiece=pieceOf(num);
624  return true;
625  }
626 
627  // ----------------------------------------------------------------------
628  // 4. 指手の検査・生成・適用
629  // ----------------------------------------------------------------------
630  // --- 2014/03
631  bool isSafeMove(Move move) const;
632  bool isCheck(Move move) const;
633  bool isPawnDropCheckmate(Move move) const;
634  bool isDirectCheck(Move move) const;
635  bool isOpenCheck(Move move) const;
636  // ---
637 
648  template <bool show_error>
649  bool isAlmostValidMove(Move move) const;
650  bool isAlmostValidMove(Move move,bool show_error=true) const;
651 
657  void generateLegal(MoveVector&) const;
665  void generateAllUnsafe(MoveVector&) const;
666 
667  void makeMove(Move move);
669  {
670  changeTurn();
673  }
674 
675  template <class Function>
676  void makeUnmakePass(Function &f)
677  {
678  changeTurn();
679  f(Square::STAND());
680  changeTurn();
681  }
682  template <class Function>
683  void makeUnmakeMove(Move move, Function &f)
684  {
685  if (move.player() == BLACK)
687  else
689  }
690  template <Player P, class Function>
691  void makeUnmakeMove(Player2Type<P> player, Move move, Function &f)
692  {
693  if (move.isPass())
694  return makeUnmakePass(f);
695  assert(move.isValid());
696  assert(isAlmostValidMove(move));
697  assert(P == move.player());
698  assert(P == turn());
699  Square from=move.from();
700  Square to=move.to();
701  if (from.isPieceStand())
702  {
703  assert(pieceAt(to) == Piece::EMPTY());
704  doUndoDropMove(player,to,move.ptype(),f);
705  }
706  else
707  {
708  assert(pieceAt(from) != Piece::EMPTY());
709  Piece captured=pieceAt(to);
710  if (captured != Piece::EMPTY())
711  {
712  doUndoCaptureMove(player,from,to,captured,move.promoteMask(),f);
713  }
714  else
715  {
716  doUndoSimpleMove(player,from,to,move.promoteMask(),f);
717  }
718  }
719  }
720  bool wasCheckEvasion(Move last_move) const;
721  // ----------------------------------------------------------------------
722  // 5. forEachXXX
723  // ----------------------------------------------------------------------
726  template<Player P,Ptype T,typename F>
727  void forEachOnBoard(F& func) const {
728  mask_t onMask=piecesOnBoard(P).template selectBit<T>() ;
729  while (onMask.any())
730  {
731  int num=onMask.takeOneBit()+((PtypeFuns<T>::indexNum)<<5);
732  Piece p = pieceOf(num);
733  func(p);
734  }
735  }
738  template<Player P,Ptype T,typename F>
739  void forEachOnBoardPtypeStrict(F& func) const
740  {
741  mask_t mask=piecesOnBoard(P).template selectBit<T>() ;
742  if (isPromoted(T))
743  mask &= promoted.getMask<T>();
744  else
745  mask &= ~(promoted.getMask<T>());
746  while (mask.any())
747  {
748  int num=mask.takeOneBit()+((PtypeFuns<T>::indexNum)<<5);
749  func(pieceOf(num));
750  }
751  }
752  private:
753  template<Player P,class Action>
754  void forEachEffect(const PieceMask& pieces, Square sq,Action & action) const
755  {
756 #if OSL_WORDSIZE == 64
757  mask_t mask=pieces.getMask(0);
758  while (mask.any())
759  {
760  const int num=mask.takeOneBit();
761  action.template doAction<P>(pieceOf(num),sq);
762  }
763 #elif OSL_WORDSIZE == 32
764  mask_t mask0=pieces.getMask(0);
765  while (mask0.any())
766  {
767  const int num=mask0.takeOneBit();
768  action.template doAction<P>(pieceOf(num),sq);
769  }
770  mask_t mask1=pieces.getMask(1);
771  while (mask1.any())
772  {
773  const int num=mask1.takeOneBit()+32;
774  action.template doAction<P>(pieceOf(num),sq);
775  }
776 #endif
777  }
778  public:
783  template<Player P,class Action>
784  void forEachEffect(Square sq,Action & action) const
785  {
786  const PieceMask pieceMask=piecesOnBoard(P)&effectSetAt(sq);
787  forEachEffect<P,Action>(pieceMask, sq, action);
788  }
794  template<Player P,class Action>
795  void forEachEffect(Square sq,Action & action,const PieceMask& pin) const
796  {
797  PieceMask pieceMask=piecesOnBoard(P)&effectSetAt(sq);
798  pieceMask &= ~pin;
799  forEachEffect<P,Action>(pieceMask, sq, action);
800  }
801 
807  template<Player P,class Action>
808  void forEachEffectNotBy(Square sq,Piece piece,Action & action) const {
810  pieces.reset(piece.number());
811  forEachEffect<P,Action>(pieces, sq, action);
812  }
813 
814  private:
815  template<Player P,Ptype Type,class Action,Direction Dir>
817  template<Player P,Ptype Type,class Action,Direction Dir>
818  void forEachEffectOfPieceDir(Square pieceSquare,Action & action,Int2Type<true>) const {
820  action.template doAction<P>(this->pieceAt(pieceSquare),pieceSquare+offset);
821  }
822 
823  template<Player P,Ptype Type,class Action,Direction Dir>
824  void forEachEffectOfPieceDir(Square pieceSquare,Action & action) const {
825  forEachEffectOfPieceDir<P,Type,Action,Dir>(pieceSquare,action,Int2Type<(PtypeTraits<Type>::moveMask & DirectionTraits<Dir>::mask)!=0>());
826  }
827  template<Player P,Ptype Type,class Action,Direction Dir>
829  template<Player P,Ptype Type,class Action,Direction Dir>
830  void forEachEffectOfPieceLongDir(Square pieceSquare,Action & action,Int2Type<true>) const {
831  Piece piece=this->pieceAt(pieceSquare);
833  assert(offset.intValue() != 35);
834  Square sq=pieceSquare+offset;
835  for (;this->pieceAt(sq).isEmpty();sq+=offset)
836  action.template doAction<P>(piece,sq);
837  action.template doAction<P>(piece,sq);
838  }
839 
840  template<Player P,Ptype Type,class Action,Direction Dir>
841  void forEachEffectOfPieceLongDir(Square pieceSquare,Action & action) const {
842  forEachEffectOfPieceLongDir<P,Type,Action,Dir>(pieceSquare,action,Int2Type<(PtypeTraits<Type>::moveMask & DirectionTraits<Dir>::mask)!=0>());
843  }
844  public:
852  template<Player P,Ptype Type,class Action>
853  void forEachEffectOfPiece(Square pieceSquare,Action & action) const;
854  template<class Action>
855  void forEachEffectOfPiece(Piece piece,Action & action) const;
856 
862  template <class Function, bool InterestEmpty>
863  void forEachEffectOfPtypeO(Square, PtypeO, Function& f) const;
864  template <Player P, class Function, bool InterestEmpty>
865  void forEachEffectOfPtypeO(Square, Ptype, Function& f) const;
866 
873  template <Player P>
874  Piece safeCaptureNotByKing(Square target, Piece king) const;
876  const Piece king = kingPiece(P);
877  if (P == BLACK)
878  return this->safeCaptureNotByKing<BLACK>(target, king);
879  else
880  return this->safeCaptureNotByKing<WHITE>(target, king);
881  }
887  template <class Action>
888  void forEachEffect(Player P, Square pos, Action& a) const {
889  if (P == BLACK)
890  this->template forEachEffect<BLACK>(pos,a);
891  else
892  this->template forEachEffect<WHITE>(pos,a);
893  }
897  void findEffect(Player P, Square target, PieceVector& out) const;
898 
899  private:
900  void doSimpleMove(Square from, Square to, int promoteMask);
901  void doDropMove(Square to,Ptype ptype);
902  void doCaptureMove(Square from, Square to, Piece target,int promoteMask);
903 
904  template <Player P, class Function>
905  void doUndoSimpleMove(Player2Type<P> player,
906  Square from, Square to, int promoteMask,Function& func);
907  template <Player P>
908  void prologueSimple(Player2Type<P>, Square from, Square to, int promoteMask,
909  Piece& oldPiece, int& num,
910  PtypeO& oldPtypeO, PtypeO& new_ptypeo,
911  CArray<PieceMask,2>& pin_or_open_backup,
912  KingMobility& king_mobility_backup,
913  PieceMask& promoted_backup,
914  CArray<PieceMask,2>& effected_mask_backup,
915  CArray<PieceMask,2>& effected_changed_mask_backup,
916  CArray<uint64_t,2>& king8infos_backup,
917  MobilityTable &mobility_backup
918  );
919  void epilogueSimple(Square from, Square to, Piece oldPiece,
920  int num, PtypeO oldPtypeO, PtypeO newPtypeO,
921  const CArray<PieceMask,2>& pin_or_open_backup,
922  const KingMobility& king_mobility_backup,
923  const PieceMask& promoted_backup,
924  const CArray<PieceMask,2>& effected_mask_backup,
925  const CArray<PieceMask,2>& effected_changed_mask_backup,
926  const CArray<uint64_t,2>& king8infos_backup,
927  const MobilityTable &mobility_backup
928  );
929  template <Player P, class Function>
930  void doUndoDropMove(Player2Type<P> player,
931  Square to, Ptype ptype, Function& func);
932  template <Player P>
933  void prologueDrop(Player2Type<P>, Square to, Ptype ptype,
934  Piece& oldPiece, int& num, PtypeO& ptypeO,
935  int& numIndex, mask_t& numMask,
936  CArray<PieceMask,2>& pin_or_open_backup,
937  KingMobility& king_mobility_backup,
938  CArray<PieceMask,2>& effected_mask_backup,
939  CArray<PieceMask,2>& effected_changed_mask_backup,
940  CArray<uint64_t,2>& king8infos_backup,
941  MobilityTable &mobility_backup);
942  template<Player P>
943  void epilogueDrop(Player2Type<P>, Square to, Ptype ptype, Piece oldPiece,
944  int num, PtypeO ptypeO, int numIndex, mask_t numMask,
945  const CArray<PieceMask,2>& pin_or_open_backup,
946  const KingMobility& king_mobility_backup,
947  const CArray<PieceMask,2>& effected_mask_backup,
948  const CArray<PieceMask,2>& effected_changed_mask_backup,
949  const CArray<uint64_t,2>& king8infos_backup,
950  const MobilityTable &mobility_backup);
951  template <Player P, class Function>
952  void doUndoCaptureMove(Player2Type<P> player, Square from,Square to,
953  Piece target, int promoteMask,Function& func);
954 
955  template<Player P>
956  void prologueCapture(Player2Type<P>, Square from, Square to, Piece target,
957  int promoteMask,
958  Piece& oldPiece, PtypeO& oldPtypeO, PtypeO& capturePtypeO,
959  PtypeO& new_ptypeo, int& num0, int& num1,
960  int& num1Index, mask_t& num1Mask,
961  CArray<PieceMask,2>& pin_or_open_backup,
962  KingMobility& king_mobility_backup,
963  PieceMask& promoted_backup,
964  CArray<PieceMask,2>& effected_mask_backup,
965  CArray<PieceMask,2>& effected_changed_mask_backup,
966  CArray<uint64_t,2>& king8infos_backup,
967  MobilityTable &mobility_backup);
968 
969  template<Player P>
970  void epilogueCapture(Player2Type<P>, Square from, Square to, Piece target,
971  Piece oldPiece, PtypeO oldPtypeO, PtypeO capturePtypeO,
972  PtypeO newPtypeO, int num0, int num1,
973  int num1Index, mask_t num1Mask,
974  const CArray<PieceMask,2>& pin_or_open_backup,
975  const KingMobility& king_mobility_backup,
976  const PieceMask& promoted_backup,
977  const CArray<PieceMask,2>& effected_mask_backup,
978  const CArray<PieceMask,2>& effected_changed_mask_backup,
979  const CArray<uint64_t,2>& king8infos_backup,
980  const MobilityTable &mobility_backup);
981  //
982  template<Direction DIR>
983  void makePinOpenDir(Square target,
984  PieceMask& pins, PieceMask const& onBoard,Player defense)
985  {
986  const Offset offset = DirectionTraits<DIR>::blackOffset();
987  Square sq=target-offset;
988  int num;
989  while(Piece::isEmptyNum(num=pieceAt(sq).number()))
990  sq-=offset;
991  king_mobility[defense][DIR]=static_cast<unsigned char>(sq.uintValue());
992  if(Piece::isEdgeNum(num)) return;
993  int num1=longEffectNumTable()[num][DIR];
994  if(Piece::isPieceNum(num1) && onBoard.test(num1)){
995  pins.set(num);
996  }
997  }
998  void recalcPinOpen(Square changed, Direction &lastDir, Player defense)
999  {
1000  Square target=kingSquare(defense);
1001 #ifdef ALLOW_KING_ABSENCE
1002  if (target.isPieceStand())
1003  return;
1004 #endif
1005  const Direction longD=Board_Table.getLongDirection<BLACK>(changed,target);
1006  if(!isLong(longD) || (lastDir!=UL && longD==lastDir)) return;
1007  lastDir=longD;
1008  Direction shortD=longToShort(longD);
1009  {
1010  // reset old pins
1011  Square oldPos=Square::makeDirect(king_mobility[defense][shortD]);
1012  int oldNum=pieceAt(oldPos).number();
1013  if(Piece::isPieceNum(oldNum))
1014  pin_or_open[defense].reset(oldNum);
1015  }
1016  const Offset offset = Board_Table.getOffsetForBlack(longD);
1017  Square sq=target-offset;
1018  int num;
1019  while(Piece::isEmptyNum(num=pieceAt(sq).number()))
1020  sq-=offset;
1021  king_mobility[defense][shortD]=static_cast<unsigned char>(sq.uintValue());
1022  if(Piece::isEdgeNum(num)) return;
1023  int num1=longEffectNumTable()[num][shortD];
1024  if(Piece::isPieceNum(num1) && piecesOnBoard(alt(defense)).test(num1)){
1025  pin_or_open[defense].set(num);
1026  }
1027  }
1028  PieceMask makePinOpen(Square target,Player defense);
1029  void makePinOpen(Player defense);
1030  template<Player P>
1031  void makeKing8Info();
1032  };
1033 
1034  inline bool operator!=(const NumEffectState& s1, const NumEffectState& s2)
1035  {
1036  return !(s1==s2);
1037  }
1038 } // namespace osl
1039 
1040 template <osl::Player P, typename Function>
1043  Square from, Square to, int promoteMask, Function& func)
1044 {
1045  Piece oldPiece;
1046  int num;
1047  PtypeO oldPtypeO, newPtypeO;
1048  CArray<PieceMask,2> pin_or_open_backup;
1049  KingMobility king_mobility_backup;
1050  PieceMask promoted_backup;
1051  CArray<PieceMask,2> effected_mask_backup;
1052  CArray<PieceMask,2> effected_changed_mask_backup;
1053  CArray<uint64_t,2> king8infos_backup;
1054  MobilityTable mobility_backup;
1055  prologueSimple(player, from, to, promoteMask, oldPiece, num, oldPtypeO, newPtypeO,
1056  pin_or_open_backup,
1057  king_mobility_backup,
1058  promoted_backup,
1059  effected_mask_backup, effected_changed_mask_backup,
1060  king8infos_backup,
1061  mobility_backup);
1062  if (promoteMask!=0 && num < PtypeTraits<PAWN>::indexLimit)
1063  {
1064  clearPawn(P,from);
1065  changeTurn();
1066  func(to);
1067  changeTurn();
1068  setPawn(P,from);
1069  }
1070  else
1071  {
1072  changeTurn();
1073  func(to);
1074  changeTurn();
1075  }
1076  epilogueSimple(from, to, oldPiece, num, oldPtypeO, newPtypeO,
1077  pin_or_open_backup,
1078  king_mobility_backup,
1079  promoted_backup, effected_mask_backup, effected_changed_mask_backup,
1080  king8infos_backup,
1081  mobility_backup);
1082 }
1083 
1084 template <osl::Player P, typename Function>
1086  Square to, Ptype ptype, Function& func)
1087 {
1088  Piece oldPiece;
1089  PtypeO ptypeO;
1090  int num, numIndex;
1091  mask_t numMask;
1092  CArray<PieceMask,2> pin_or_open_backup;
1093  KingMobility king_mobility_backup;
1094  CArray<PieceMask,2> effected_mask_backup;
1095  CArray<PieceMask,2> effected_changed_mask_backup;
1096  CArray<uint64_t,2> king8infos_backup;
1097  MobilityTable mobility_backup;
1098  prologueDrop(player, to, ptype, oldPiece, num, ptypeO, numIndex, numMask,
1099  pin_or_open_backup, king_mobility_backup,
1100  effected_mask_backup,effected_changed_mask_backup,
1101  king8infos_backup,
1102  mobility_backup);
1103  if (ptype==PAWN)
1104  {
1105  setPawn(P,to);
1106  changeTurn();
1107  func(to);
1108  changeTurn();
1109  clearPawn(P,to);
1110  }
1111  else
1112  {
1113  changeTurn();
1114  func(to);
1115  changeTurn();
1116  }
1117  epilogueDrop(player, to, ptype, oldPiece, num, ptypeO, numIndex, numMask,
1118  pin_or_open_backup, king_mobility_backup,
1119  effected_mask_backup,effected_changed_mask_backup,
1120  king8infos_backup,
1121  mobility_backup);
1122 }
1123 
1124 template <osl::Player P, typename Function>
1126  Square from,Square to, Piece target,
1127  int promoteMask,Function& func)
1128 {
1129  Piece oldPiece;
1130  PtypeO oldPtypeO, capturePtypeO, newPtypeO;
1131  int num0, num1, num1Index;
1132  mask_t num1Mask;
1133  CArray<PieceMask,2> pin_or_open_backup;
1134  KingMobility king_mobility_backup;
1135  PieceMask promoted_backup;
1136  CArray<PieceMask,2> effected_mask_backup;
1137  CArray<PieceMask,2> effected_changed_mask_backup;
1138  CArray<uint64_t,2> king8infos_backup;
1139  MobilityTable mobility_backup;
1140  prologueCapture(player, from, to, target, promoteMask, oldPiece, oldPtypeO,
1141  capturePtypeO, newPtypeO, num0, num1, num1Index,num1Mask,
1142  pin_or_open_backup, king_mobility_backup,
1143  promoted_backup,
1144  effected_mask_backup, effected_changed_mask_backup,
1145  king8infos_backup,
1146  mobility_backup);
1147 
1148  changeTurn();
1149  const Ptype capturePtype=target.ptype();
1150  if (capturePtype==PAWN)
1151  {
1152  clearPawn(alt(P),to);
1153  if (promoteMask!=0 && num0<PtypeTraits<PAWN>::indexLimit)
1154  {
1155  clearPawn(P,from);
1156  func(to);
1157  setPawn(P,from);
1158  }
1159  else
1160  {
1161  func(to);
1162  }
1163  setPawn(alt(P),to);
1164  }
1165  else if (promoteMask!=0 && num0<PtypeTraits<PAWN>::indexLimit)
1166  {
1167  clearPawn(P,from);
1168  func(to);
1169  setPawn(P,from);
1170  }
1171  else
1172  {
1173  func(to);
1174  }
1175  changeTurn();
1176 
1177  epilogueCapture(player, from, to, target, oldPiece, oldPtypeO, capturePtypeO, newPtypeO,
1178  num0, num1, num1Index,num1Mask,
1179  pin_or_open_backup, king_mobility_backup,
1180  promoted_backup,effected_mask_backup, effected_changed_mask_backup,
1181  king8infos_backup,
1182  mobility_backup);
1183 }
1184 
1185 template <class Action>
1187 forEachEffectOfPiece(Piece piece,Action & action) const
1188 {
1189  Square pieceSquare = piece.square();
1190  switch ((int)piece.ptypeO()) {
1191  case NEW_PTYPEO(WHITE,PAWN): forEachEffectOfPiece<WHITE,PAWN,Action>(pieceSquare,action); break;
1192  case NEW_PTYPEO(WHITE,LANCE): forEachEffectOfPiece<WHITE,LANCE,Action>(pieceSquare,action); break;
1193  case NEW_PTYPEO(WHITE,KNIGHT): forEachEffectOfPiece<WHITE,KNIGHT,Action>(pieceSquare,action); break;
1194  case NEW_PTYPEO(WHITE,SILVER): forEachEffectOfPiece<WHITE,SILVER,Action>(pieceSquare,action); break;
1195  case NEW_PTYPEO(WHITE,PPAWN): forEachEffectOfPiece<WHITE,PPAWN,Action>(pieceSquare,action); break;
1196  case NEW_PTYPEO(WHITE,PLANCE): forEachEffectOfPiece<WHITE,PLANCE,Action>(pieceSquare,action); break;
1197  case NEW_PTYPEO(WHITE,PKNIGHT): forEachEffectOfPiece<WHITE,PKNIGHT,Action>(pieceSquare,action); break;
1198  case NEW_PTYPEO(WHITE,PSILVER): forEachEffectOfPiece<WHITE,PSILVER,Action>(pieceSquare,action); break;
1199  case NEW_PTYPEO(WHITE,GOLD): forEachEffectOfPiece<WHITE,GOLD,Action>(pieceSquare,action); break;
1200  case NEW_PTYPEO(WHITE,BISHOP): forEachEffectOfPiece<WHITE,BISHOP,Action>(pieceSquare,action); break;
1201  case NEW_PTYPEO(WHITE,PBISHOP): forEachEffectOfPiece<WHITE,PBISHOP,Action>(pieceSquare,action); break;
1202  case NEW_PTYPEO(WHITE,ROOK): forEachEffectOfPiece<WHITE,ROOK,Action>(pieceSquare,action); break;
1203  case NEW_PTYPEO(WHITE,PROOK): forEachEffectOfPiece<WHITE,PROOK,Action>(pieceSquare,action); break;
1204  case NEW_PTYPEO(WHITE,KING): forEachEffectOfPiece<WHITE,KING,Action>(pieceSquare,action); break;
1205  case NEW_PTYPEO(BLACK,PAWN): forEachEffectOfPiece<BLACK,PAWN,Action>(pieceSquare,action); break;
1206  case NEW_PTYPEO(BLACK,LANCE): forEachEffectOfPiece<BLACK,LANCE,Action>(pieceSquare,action); break;
1207  case NEW_PTYPEO(BLACK,KNIGHT): forEachEffectOfPiece<BLACK,KNIGHT,Action>(pieceSquare,action); break;
1208  case NEW_PTYPEO(BLACK,SILVER): forEachEffectOfPiece<BLACK,SILVER,Action>(pieceSquare,action); break;
1209  case NEW_PTYPEO(BLACK,PPAWN): forEachEffectOfPiece<BLACK,PPAWN,Action>(pieceSquare,action); break;
1210  case NEW_PTYPEO(BLACK,PLANCE): forEachEffectOfPiece<BLACK,PLANCE,Action>(pieceSquare,action); break;
1211  case NEW_PTYPEO(BLACK,PKNIGHT): forEachEffectOfPiece<BLACK,PKNIGHT,Action>(pieceSquare,action); break;
1212  case NEW_PTYPEO(BLACK,PSILVER): forEachEffectOfPiece<BLACK,PSILVER,Action>(pieceSquare,action); break;
1213  case NEW_PTYPEO(BLACK,GOLD): forEachEffectOfPiece<BLACK,GOLD,Action>(pieceSquare,action); break;
1214  case NEW_PTYPEO(BLACK,BISHOP): forEachEffectOfPiece<BLACK,BISHOP,Action>(pieceSquare,action); break;
1215  case NEW_PTYPEO(BLACK,PBISHOP): forEachEffectOfPiece<BLACK,PBISHOP,Action>(pieceSquare,action); break;
1216  case NEW_PTYPEO(BLACK,ROOK): forEachEffectOfPiece<BLACK,ROOK,Action>(pieceSquare,action); break;
1217  case NEW_PTYPEO(BLACK,PROOK): forEachEffectOfPiece<BLACK,PROOK,Action>(pieceSquare,action); break;
1218  case NEW_PTYPEO(BLACK,KING): forEachEffectOfPiece<BLACK,KING,Action>(pieceSquare,action); break;
1219  default: assert(0);
1220  }
1221 }
1222 
1223 template <osl::Player P, osl::Ptype Type, class Action>
1225 forEachEffectOfPiece(Square pieceSquare,Action & action) const
1226 {
1227  forEachEffectOfPieceDir<P,Type,Action,UL>(pieceSquare,action);
1228  forEachEffectOfPieceDir<P,Type,Action,U>(pieceSquare,action);
1229  forEachEffectOfPieceDir<P,Type,Action,UR>(pieceSquare,action);
1230  forEachEffectOfPieceDir<P,Type,Action,L>(pieceSquare,action);
1231  forEachEffectOfPieceDir<P,Type,Action,R>(pieceSquare,action);
1232  forEachEffectOfPieceDir<P,Type,Action,DL>(pieceSquare,action);
1233  forEachEffectOfPieceDir<P,Type,Action,D>(pieceSquare,action);
1234  forEachEffectOfPieceDir<P,Type,Action,DR>(pieceSquare,action);
1235  forEachEffectOfPieceDir<P,Type,Action,UUL>(pieceSquare,action);
1236  forEachEffectOfPieceDir<P,Type,Action,UUR>(pieceSquare,action);
1237  forEachEffectOfPieceLongDir<P,Type,Action,LONG_UL>(pieceSquare,action);
1238  forEachEffectOfPieceLongDir<P,Type,Action,LONG_U>(pieceSquare,action);
1239  forEachEffectOfPieceLongDir<P,Type,Action,LONG_UR>(pieceSquare,action);
1240  forEachEffectOfPieceLongDir<P,Type,Action,LONG_L>(pieceSquare,action);
1241  forEachEffectOfPieceLongDir<P,Type,Action,LONG_R>(pieceSquare,action);
1242  forEachEffectOfPieceLongDir<P,Type,Action,LONG_DL>(pieceSquare,action);
1243  forEachEffectOfPieceLongDir<P,Type,Action,LONG_D>(pieceSquare,action);
1244  forEachEffectOfPieceLongDir<P,Type,Action,LONG_DR>(pieceSquare,action);
1245 }
1246 
1247 #include "osl/bits/pieceStand.h"
1248 #endif /* OSL_NUM_EFFECT_STATE_H */
1249 // ;;; Local Variables:
1250 // ;;; mode:c++
1251 // ;;; c-basic-offset:2
1252 // ;;; End:
osl::NumEffectState::hasEffectByNotPinnedAndKing
bool hasEffectByNotPinnedAndKing(Player pl, Square target) const
{pinされている駒, 玉以外}からの利きがある.
Definition: numEffectState.h:419
osl::Piece::number
int number() const
Definition: basic_type.h:828
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::NumEffectState::isConsistent
bool isConsistent(bool showError=true) const
Definition: numEffectState.cc:663
osl::NumEffectState::pinnedCanMoveTo
bool pinnedCanMoveTo(Piece p, Square to) const
Definition: numEffectState.h:229
osl::NumEffectState::doUndoCaptureMove
void doUndoCaptureMove(Player2Type< P > player, Square from, Square to, Piece target, int promoteMask, Function &func)
Definition: numEffectState.h:1125
osl::Square
Definition: basic_type.h:532
osl::NumEffectState::makeMove
void makeMove(Move move)
Definition: numEffectState.cc:201
osl::container::PieceMask64::countBit
int countBit() const
Definition: pieceMask64.h:78
osl::primDirUnsafe
constexpr Direction primDirUnsafe(Direction d)
8方向について,primitiveな4方向を求める dとしてknight, INVALIDなども来る
Definition: basic_type.h:374
osl::NumEffectState::piecesOnBoard
const PieceMask & piecesOnBoard(Player p) const
Definition: numEffectState.h:63
osl::NumEffectState::findCheapAttack
const Piece findCheapAttack(Player P, Square square) const
Definition: numEffectState.h:560
osl::NumEffectState::epilogueCapture
void epilogueCapture(Player2Type< P >, Square from, Square to, Piece target, Piece oldPiece, PtypeO oldPtypeO, PtypeO capturePtypeO, PtypeO newPtypeO, int num0, int num1, int num1Index, mask_t num1Mask, const CArray< PieceMask, 2 > &pin_or_open_backup, const KingMobility &king_mobility_backup, const PieceMask &promoted_backup, const CArray< PieceMask, 2 > &effected_mask_backup, const CArray< PieceMask, 2 > &effected_changed_mask_backup, const CArray< uint64_t, 2 > &king8infos_backup, const MobilityTable &mobility_backup)
Definition: numEffectState.cc:626
osl::EffectContent::offset
const Offset offset() const
返り値が0なら長い利きがない, 0以外なら辿るのに必要なoffset (2005/3/25 に仕様変更 - 長い利きだが隣の場合もoffsetを返す)
Definition: effectContent.h:44
osl::WHITE
@ WHITE
Definition: basic_type.h:10
osl::NumEffectState::copyFrom
void copyFrom(const NumEffectState &src)
主要部分を高速にコピーする.
Definition: numEffectState.cc:932
osl::NumEffectState::makeKing8Info
void makeKing8Info()
Definition: numEffectState.cc:50
osl::NumEffectState::findCheapAttackNotBy
const Piece findCheapAttackNotBy(Player P, Square square, const PieceMask &ignore) const
Definition: numEffectState.h:569
osl::Square::isOnBoard
bool isOnBoard() const
盤面上を表すかどうかの判定. 1<=x() && x()<=9 && 1<=y() && y()<=9 Squareの内部表現に依存する.
Definition: basic_type.h:583
osl::NumEffectState::pinAttacker
Piece pinAttacker(Piece pinned) const
Definition: numEffectState.h:248
osl::Board_Table
const BoardTable Board_Table
Definition: tables.cc:95
osl::inverse
constexpr Direction inverse(Direction d)
Definition: basic_type.h:358
osl::NumEffectState::safeCaptureNotByKing
Piece safeCaptureNotByKing(Square target, Piece king) const
玉の素抜きなしに合法手でtargetに移動可能かを判定
osl::NumEffectState::king8Info
const checkmate::King8Info king8Info(Player king) const
Definition: numEffectState.cc:44
osl::NumEffectState::Iking8Info
uint64_t Iking8Info(Player king) const
Definition: numEffectState.h:78
osl::NumEffectState::effects
effect::NumSimpleEffectTable effects
Definition: numEffectState.h:35
osl::alt
constexpr Player alt(Player player)
Definition: basic_type.h:13
osl::PtypeTable::getEffect
const EffectContent getEffect(PtypeO ptypeo, Square from, Square to) const
fromにいるptypeoがtoに利きを持つか?
Definition: ptypeTable.h:112
osl::NumEffectState::doCaptureMove
void doCaptureMove(Square from, Square to, Piece target, int promoteMask)
Definition: numEffectState.cc:260
osl::DirectionTraits::blackOffset
static const Offset blackOffset()
Definition: directionTraits.h:231
osl::NumEffectState::findCheckPiece
bool findCheckPiece(Piece &attack_piece) const
王手駒を探す
Definition: numEffectState.h:593
osl::NumEffectState::isDirectCheck
bool isDirectCheck(Move move) const
Definition: numEffectState.cc:1068
osl::NumEffectState::effectedChanged
const PieceMask effectedChanged(Player pl) const
前の指手でeffectedMask(pl)が変化したか.
Definition: numEffectState.h:137
osl::PLANCE
@ PLANCE
Definition: basic_type.h:88
osl::NumEffectState::effectSetAt
const NumBitmapEffect effectSetAt(Square sq) const
Definition: numEffectState.h:258
osl::NumEffectState::doUndoSimpleMove
void doUndoSimpleMove(Player2Type< P > player, Square from, Square to, int promoteMask, Function &func)
Definition: numEffectState.h:1042
osl::Offset32
Offset32Base< 8, 9 > Offset32
Definition: offset32.h:63
osl::NumEffectState::countEffect
int countEffect(Player player, Square target, PieceMask pins) const
利きの数を数える.
Definition: numEffectState.h:280
osl::effect::NumSimpleEffectTable::effectedNumTable
EffectedNumTable effectedNumTable
effected num
Definition: numSimpleEffect.h:43
osl::NumEffectState::isOnBoardNum
bool isOnBoardNum(int num) const
Definition: numEffectState.h:170
osl::PtypeFuns
Definition: ptypeTraits.h:311
osl::NumEffectState::hasChangedEffects
bool hasChangedEffects() const
Definition: numEffectState.h:141
osl::Move::isValid
bool isValid() const
Definition: basic_type.cc:246
osl::NumEffectState::forEachEffectOfPiece
void forEachEffectOfPiece(Square pieceSquare, Action &action) const
pieceSquareにある駒によって利きを受けるすべてのsquare (空白含む)について actionを実行する
Definition: numEffectState.h:1225
osl::PSILVER
@ PSILVER
Definition: basic_type.h:90
osl::NumEffectState::generateWithFullUnpromotions
void generateWithFullUnpromotions(MoveVector &) const
打歩詰め絡み以外では有利にはならない手も含め, 全ての合法手を生成す る(Move::ignoredUnpromoteも生成する).
Definition: numEffectState.cc:1105
osl::Move
圧縮していない moveの表現 .
Definition: basic_type.h:1052
osl::Piece::EMPTY
static const Piece EMPTY()
Definition: basic_type.h:797
osl::Piece::ptypeO
PtypeO ptypeO() const
Definition: basic_type.h:824
osl::NumEffectState::allEffectAt
const mask_t allEffectAt(Player P, Square target) const
Definition: numEffectState.h:293
osl::NumEffectState::longEffectNumTable
const EffectedNumTable & longEffectNumTable() const
Definition: numEffectState.h:124
osl::BoardTable::getLongDirection
Direction getLongDirection(Offset32 offset32) const
Definition: boardTable.h:71
osl::NumEffectState::forEachEffectOfPieceDir
void forEachEffectOfPieceDir(Square, Action &, Int2Type< false >) const
Definition: numEffectState.h:816
osl::NumEffectState::epilogueDrop
void epilogueDrop(Player2Type< P >, Square to, Ptype ptype, Piece oldPiece, int num, PtypeO ptypeO, int numIndex, mask_t numMask, const CArray< PieceMask, 2 > &pin_or_open_backup, const KingMobility &king_mobility_backup, const CArray< PieceMask, 2 > &effected_mask_backup, const CArray< PieceMask, 2 > &effected_changed_mask_backup, const CArray< uint64_t, 2 > &king8infos_backup, const MobilityTable &mobility_backup)
Definition: numEffectState.cc:503
osl::NumEffectState::findLongAttackAt
const Piece findLongAttackAt(Player owner, int piece, Direction d) const
pieceのd方向から長い利きがある場合にその駒を返す。
Definition: numEffectState.h:526
osl::effect::NumSimpleEffectTable::mobilityTable
mobility::MobilityTable mobilityTable
mobility
Definition: numSimpleEffect.h:41
osl::PtypeTraits
Definition: ptypeTraits.h:12
osl::BoardTable::getShort8
Direction getShort8(Square from, Square to) const
Definition: boardTable.h:147
osl::SimpleState
Definition: simpleState.h:35
osl::NumEffectState::prologueSimple
void prologueSimple(Player2Type< P >, Square from, Square to, int promoteMask, Piece &oldPiece, int &num, PtypeO &oldPtypeO, PtypeO &new_ptypeo, CArray< PieceMask, 2 > &pin_or_open_backup, KingMobility &king_mobility_backup, PieceMask &promoted_backup, CArray< PieceMask, 2 > &effected_mask_backup, CArray< PieceMask, 2 > &effected_changed_mask_backup, CArray< uint64_t, 2 > &king8infos_backup, MobilityTable &mobility_backup)
Definition: numEffectState.cc:321
osl::PieceMask::set
void set(int num)
Definition: pieceMask.h:48
osl::effect::NumBitmapEffect::selectLong
const mask_t selectLong() const
Definition: numBitmapEffect.h:138
osl::effect::NumSimpleEffectTable::clearEffectedChanged
void clearEffectedChanged()
Definition: numSimpleEffect.h:260
osl::newPtypeO
PtypeO newPtypeO(Player player, Ptype ptype)
Definition: basic_type.h:211
osl::NumEffectState::effectedMask
const PieceMask effectedMask(Player pl) const
pl からの利きが(1つ以上)ある駒一覧
Definition: numEffectState.h:130
osl::Offset
座標の差分
Definition: basic_type.h:430
osl::NumEffectState::epilogueSimple
void epilogueSimple(Square from, Square to, Piece oldPiece, int num, PtypeO oldPtypeO, PtypeO newPtypeO, const CArray< PieceMask, 2 > &pin_or_open_backup, const KingMobility &king_mobility_backup, const PieceMask &promoted_backup, const CArray< PieceMask, 2 > &effected_mask_backup, const CArray< PieceMask, 2 > &effected_changed_mask_backup, const CArray< uint64_t, 2 > &king8infos_backup, const MobilityTable &mobility_backup)
Definition: numEffectState.cc:401
osl::effect::NumSimpleEffectTable::effectSetAt
const NumBitmapEffect effectSetAt(Square pos) const
ある位置の利きデータを取り出す.
Definition: numSimpleEffect.h:219
osl::NumEffectState::forEachEffectOfPtypeO
void forEachEffectOfPtypeO(Square, Ptype, Function &f) const
osl::misc::mask_t
GeneralMask< mask_int_t > mask_t
Definition: mask.h:351
osl::Ptype
Ptype
駒の種類を4ビットでコード化する
Definition: basic_type.h:84
osl::LANCE
@ LANCE
Definition: basic_type.h:96
osl::NumEffectState::isPawnDropCheckmate
bool isPawnDropCheckmate(Move move) const
Definition: numEffectState.cc:1063
osl::misc::Player2Type
Definition: basic_type.h:75
osl::NumEffectState::hasEffectIf
bool hasEffectIf(PtypeO ptypeo, Square attacker, Square target) const
attackerにptypeoの駒がいると仮定した場合にtargetに利きがあるかどうか を stateをupdateしないで確かめる.
Definition: numEffectState.h:465
osl::NumEffectState::isSafeMove
bool isSafeMove(Move move) const
Definition: numEffectState.cc:1053
osl::NumEffectState::makeUnmakePass
void makeUnmakePass(Function &f)
Definition: numEffectState.h:676
osl::SimpleState::clearPawn
void clearPawn(Player pl, Square sq)
(internal)
Definition: simpleState.h:138
osl::NumEffectState::hasEffectAt
bool hasEffectAt(Square target) const
対象とするマスにあるプレイヤーの利きがあるかどうか.
Definition: numEffectState.h:324
osl::NumEffectState::forEachEffect
void forEachEffect(Square sq, Action &action) const
sq への利きを持つ各駒に関して処理を行う.
Definition: numEffectState.h:784
osl::EMPTY_NUM
const int EMPTY_NUM
Definition: basic_type.h:778
osl::DirectionPlayerTraits
Definition: directionTraits.h:242
osl::Ptype_Table
const PtypeTable Ptype_Table
Definition: tables.cc:97
osl::Move::promoteMask
int promoteMask() const
pieceに使うためのmaskなので
Definition: basic_type.h:1143
osl::effect::NumBitmapEffect::playerEffect
static NumBitmapEffect playerEffect()
Definition: numBitmapEffect.h:35
osl::NumEffectState::longEffectAt
const mask_t longEffectAt(Square target, Player owner) const
Definition: numEffectState.h:302
osl::Piece
駒.
Definition: basic_type.h:788
osl::NumEffectState::inCheck
bool inCheck(Player P) const
Pの玉が王手状態
Definition: numEffectState.h:88
osl::misc::Align16New
Definition: align16New.h:12
osl::NumEffectState::kingMobilityAbs
Square kingMobilityAbs(Player p, Direction d) const
Definition: numEffectState.h:183
osl::NumEffectState::longEffectAt
const mask_t longEffectAt(Square target) const
Definition: numEffectState.h:306
osl::NumEffectState::longEffectChanged
bool longEffectChanged() const
Definition: numEffectState.h:155
osl::GOLD
@ GOLD
Definition: basic_type.h:94
osl::SimpleState::pieceOf
const Piece pieceOf(int num) const
Definition: simpleState.h:76
osl::NumEffectState::recalcPinOpen
void recalcPinOpen(Square changed, Direction &lastDir, Player defense)
Definition: numEffectState.h:998
osl::NumEffectState::findAttackNotBy
const Piece findAttackNotBy(Player P, Square square, const PieceMask &ignore) const
Definition: numEffectState.h:575
osl::effect::NumBitmapEffect::playerEffectMask
static mask_t playerEffectMask()
Definition: numBitmapEffect.h:53
osl::NumEffectState::findAttackAt
const Piece findAttackAt(Player attack, Square target) const
return a piece s.t.
Definition: numEffectState.h:503
osl::NumEffectState::generateAllUnsafe
void generateAllUnsafe(MoveVector &) const
自殺を含めてすべての手を生成
Definition: numEffectState.cc:1081
osl::NumEffectState::hasEffectAt
bool hasEffectAt(Square target, Piece &attackerPiece) const
Definition: numEffectState.h:611
osl::NumEffectState::longEffectAt
const mask_t longEffectAt(Square target, Player owner) const
Definition: numEffectState.h:310
osl::NumEffectState::forEachEffect
void forEachEffect(Player P, Square pos, Action &a) const
forEachEffect の Player のtemplate 引数を通常の引数にしたバージョン
Definition: numEffectState.h:888
checkmate
osl::Square::uintValue
unsigned int uintValue() const
Definition: basic_type.h:539
osl::NumEffectState::hasEffectAt
bool hasEffectAt(Player P, Square target, Piece &attackerPiece) const
Definition: numEffectState.h:597
osl::SimpleState::pieceOnBoard
const Piece pieceOnBoard(Square sq) const
Definition: simpleState.h:170
osl::NumEffectState::anyEffectChanged
bool anyEffectChanged() const
Definition: numEffectState.h:159
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::KING
@ KING
Definition: basic_type.h:93
kingMobility.h
osl::effect::NumSimpleEffectTable::changedPieces
const NumBitmapEffect changedPieces() const
Definition: numSimpleEffect.h:238
osl::effect::NumSimpleEffectTable::clearChangedEffects
void clearChangedEffects()
Definition: numSimpleEffect.h:250
osl::effect::NumSimpleEffectTable::effected_mask
CArray< PieceMask, 2 > effected_mask
Definition: numSimpleEffect.h:38
osl::NumEffectState::makePinOpenDir
void makePinOpenDir(Square target, PieceMask &pins, PieceMask const &onBoard, Player defense)
Definition: numEffectState.h:983
osl::NumEffectState::findLongAttackAt
const Piece findLongAttackAt(Piece piece, Direction d) const
Definition: numEffectState.h:542
osl::NumEffectState::hasEffectByPtypeStrict
bool hasEffectByPtypeStrict(Player attack, Square target) const
target に ptype の利きがあるか? 成不成を区別
Definition: numEffectState.h:363
osl::BISHOP
@ BISHOP
Definition: basic_type.h:99
osl::NumEffectState::hasEffectNotBy
bool hasEffectNotBy(Player player, Piece piece, Square target) const
対象とするマスにあるプレイヤーの(ただしある駒以外)利きがあるかどうか.
Definition: numEffectState.h:409
osl::NumEffectState::prologueCapture
void prologueCapture(Player2Type< P >, Square from, Square to, Piece target, int promoteMask, Piece &oldPiece, PtypeO &oldPtypeO, PtypeO &capturePtypeO, PtypeO &new_ptypeo, int &num0, int &num1, int &num1Index, mask_t &num1Mask, CArray< PieceMask, 2 > &pin_or_open_backup, KingMobility &king_mobility_backup, PieceMask &promoted_backup, CArray< PieceMask, 2 > &effected_mask_backup, CArray< PieceMask, 2 > &effected_changed_mask_backup, CArray< uint64_t, 2 > &king8infos_backup, MobilityTable &mobility_backup)
Definition: numEffectState.cc:531
osl::NumEffectState::pinAttacker
Piece pinAttacker(Piece pinned) const
Pのpinされた駒から,そのpinの原因となっている長い利きを持つ駒を得る.
Definition: numEffectState.h:240
osl::NumEffectState::inCheck
bool inCheck() const
手番の玉が王手状態
Definition: numEffectState.h:98
osl::Piece::isEmptyNum
static bool isEmptyNum(int num)
Definition: basic_type.h:916
osl::NumEffectState::isOpenCheck
bool isOpenCheck(Move move) const
Definition: numEffectState.cc:1074
osl::NumEffectState::pinnedCanMoveTo
bool pinnedCanMoveTo(Piece p, Square to) const
pinされた駒pがtoに動けるか? pinに関係がなければtoへ動けるという前提
Definition: numEffectState.h:222
osl::NumEffectState::pinnedDir
Direction pinnedDir(Piece p) const
pinされた駒がPのKingから見てどの方向か? Pから見たdirectionを返す
Definition: numEffectState.h:203
osl::NumEffectState::forEachEffectNotBy
void forEachEffectNotBy(Square sq, Piece piece, Action &action) const
sq に移動する move を生成して action の member を呼び出す
Definition: numEffectState.h:808
osl::container::BoardMask::isInvalid
bool isInvalid() const
Definition: boardMask.h:39
osl::PAWN
@ PAWN
Definition: basic_type.h:95
osl::NumEffectState::hasLongEffectAt
bool hasLongEffectAt(Player P, Square to) const
あるマスにPTYPEの長い利きがあるかどうか.
Definition: numEffectState.h:346
osl::NumEffectState::hasEffectByPiece
bool hasEffectByPiece(Piece attack, Square target) const
駒attack が target に利きを持つか (旧hasEffectToと統合)
Definition: numEffectState.h:450
osl::NumEffectState::wasCheckEvasion
bool wasCheckEvasion(Move last_move) const
Definition: numEffectState.cc:175
osl::PPAWN
@ PPAWN
Definition: basic_type.h:87
osl::NumEffectState::kingMobilityOfPlayer
Square kingMobilityOfPlayer(Player p, Direction d) const
玉がd方向にどこまで動けるかを返す
Definition: numEffectState.h:192
osl::mobility::KingMobility
Definition: kingMobility.h:24
osl::PKNIGHT
@ PKNIGHT
Definition: basic_type.h:89
osl::NumEffectState::forEachOnBoardPtypeStrict
void forEachOnBoardPtypeStrict(F &func) const
T の成不成を区別
Definition: numEffectState.h:739
osl::NumEffectState::pieces_onboard
CArray< PieceMask, 2 > pieces_onboard
Definition: numEffectState.h:36
osl::NumEffectState::safeCaptureNotByKing
Piece safeCaptureNotByKing(Player P, Square target) const
Definition: numEffectState.h:875
osl::PieceMask::test
bool test(int num) const
Definition: pieceMask.h:45
osl::NumEffectState::hasEffectByWithRemove
bool hasEffectByWithRemove(Player player, Square target, Square removed) const
Definition: numEffectState.h:490
osl::PieceVector
Definition: container.h:305
osl::NumEffectState::NumEffectState
NumEffectState(const SimpleState &st=SimpleState(HIRATE))
Definition: numEffectState.cc:61
osl::Offset32Base
差が uniqになるような座標の差分.
Definition: offset32.h:17
osl::effect::NumSimpleEffectTable::effected_changed_mask
CArray< PieceMask, 2 > effected_changed_mask
Definition: numSimpleEffect.h:39
osl::NumEffectState::promoted
PieceMask promoted
成駒一覧
Definition: numEffectState.h:38
osl::mobility::MobilityTable
駒番号からMobilityContentを得る
Definition: mobilityTable.h:52
osl::NumEffectState::pinOrOpen
PieceMask pinOrOpen(Player king) const
Definition: numEffectState.h:74
osl::misc::Int2Type
Definition: basic_type.h:69
osl::SimpleState::setPawn
void setPawn(Player pl, Square sq)
(internal)
Definition: simpleState.h:142
osl::NumEffectState::promotedPieces
const PieceMask promotedPieces() const
Definition: numEffectState.h:64
osl::Piece::owner
Player owner() const
Definition: basic_type.h:963
numSimpleEffect.h
osl::PBISHOP
@ PBISHOP
Definition: basic_type.h:91
osl::Move::from
const Square from() const
Definition: basic_type.h:1125
osl::BoardTable::getOffsetForBlack
const Offset getOffsetForBlack(Direction dir) const
黒にとってのoffsetを返す
Definition: boardTable.h:37
osl::NumEffectState::pin_or_open
CArray< PieceMask, 2 > pin_or_open
Definition: numEffectState.h:39
osl::HIRATE
@ HIRATE
Definition: simpleState.h:21
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::NumEffectState::isAlmostValidMove
bool isAlmostValidMove(Move move) const
合法手かどうかを簡単に検査する.局面に依存するチェックのみ. ルール上指せない手である可能性がある場合は,isValidMove を用いる.
Definition: numEffectState.cc:823
osl::captured
PtypeO captured(PtypeO ptypeO)
unpromoteすると共に,ownerを反転する.
Definition: basic_type.h:264
osl::PtypeDirectionTraits
Definition: ptypeTraits.h:340
osl::NumEffectState
利きを持つ局面
Definition: numEffectState.h:34
osl::NumEffectState::pin
const PieceMask pin(Player king) const
Definition: numEffectState.h:65
osl::NumEffectState::inUnblockableCheck
bool inUnblockableCheck(Player target) const
target の王に合駒可能でない王手がかかっているかどうか.
Definition: numEffectState.h:107
osl::Direction
Direction
Definition: basic_type.h:310
osl::NumEffectState::forEachEffectOfPieceLongDir
void forEachEffectOfPieceLongDir(Square pieceSquare, Action &action, Int2Type< true >) const
Definition: numEffectState.h:830
osl::SimpleState::changeTurn
void changeTurn()
手番を変更する
Definition: simpleState.h:226
pieceStand.h
osl::NumEffectState::isCheck
bool isCheck(Move move) const
Definition: numEffectState.cc:1058
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::EffectContent::hasUnblockableEffect
bool hasUnblockableEffect() const
短い利きがある.長い利きの隣も含む
Definition: effectContent.h:38
osl::BoardTable::getShort8Unsafe
Direction getShort8Unsafe(Square from, Square to) const
8方向にいない場合も適当なものを返す.
Definition: boardTable.h:134
osl::NumEffectState::hasMultipleEffectAt
bool hasMultipleEffectAt(Player player, Square target) const
二つ以上の駒から利きがある.
Definition: numEffectState.h:439
osl::NumEffectState::forEachEffect
void forEachEffect(Square sq, Action &action, const PieceMask &pin) const
sq にある駒を取る move を生成して action の member を呼び出す.
Definition: numEffectState.h:795
osl::effect::EffectedNumTable
Definition: effectedNumTable.h:44
osl::effect::NumBitmapEffect
現在の定義 (2005/3/4以降)
Definition: numBitmapEffect.h:29
osl::SimpleState::kingSquare
Square kingSquare() const
Definition: simpleState.h:94
osl::NumEffectState::changedEffects
const BoardMask changedEffects() const
Definition: numEffectState.h:148
osl::primDir
constexpr Direction primDir(Direction d)
8方向について,primitiveな4方向を求める
Definition: basic_type.h:366
align16New.h
osl::isLong
constexpr bool isLong(Direction d)
Definition: basic_type.h:350
osl::NumEffectState::forEachEffect
void forEachEffect(const PieceMask &pieces, Square sq, Action &action) const
Definition: numEffectState.h:754
osl::isPromoted
bool isPromoted(Ptype ptype)
ptypeがpromote後の型かどうかのチェック
Definition: basic_type.h:137
osl::operator==
bool operator==(Square l, Square r)
Definition: basic_type.h:758
osl::EffectContent::hasEffect
bool hasEffect() const
短い利きがあるか,間がemptyなら長い利きがある
Definition: effectContent.h:34
osl::Piece::square
const Square square() const
Definition: basic_type.h:832
osl::longToShort
constexpr Direction longToShort(Direction d)
Definition: basic_type.h:380
osl::PieceMask::any
bool any() const
Definition: pieceMask.h:57
osl::NumEffectState::operator==
friend bool operator==(const NumEffectState &st1, const NumEffectState &st2)
駒番に依存した局面(インスタンス)比較をする.
osl::Piece::ptype
Ptype ptype() const
Definition: basic_type.h:821
osl::NumEffectState::forEachEffectOfPtypeO
void forEachEffectOfPtypeO(Square, PtypeO, Function &f) const
PtypeO が Square にいると仮定した時にの利きを列挙.
osl::BoardTable::getShortOffset
const Offset getShortOffset(Offset32 offset32) const
Longの利きの可能性のあるoffsetの場合は, 反復に使う offsetを Shortの利きのoffsetの場合はそれ自身を返す.
Definition: boardTable.h:110
osl::effect::NumSimpleEffectTable::changedEffects
const BoardMask changedEffects(Player pl) const
Definition: numSimpleEffect.h:235
osl::NumEffectState::doUndoDropMove
void doUndoDropMove(Player2Type< P > player, Square to, Ptype ptype, Function &func)
Definition: numEffectState.h:1085
osl::effect::NumBitmapEffect::countEffect
int countEffect(Player pl) const
Definition: numBitmapEffect.h:81
osl::Piece::isEmpty
bool isEmpty() const
Definition: basic_type.h:913
osl::Move::isPass
bool isPass() const
Definition: basic_type.h:1092
osl::Move::ptype
Ptype ptype() const
Definition: basic_type.h:1155
osl::BLACK
@ BLACK
Definition: basic_type.h:9
osl::NumEffectState::showEffect
void showEffect(std::ostream &os) const
Definition: numEffectState.cc:858
osl::NumEffectState::forEachEffectOfPieceLongDir
void forEachEffectOfPieceLongDir(Square pieceSquare, Action &action) const
Definition: numEffectState.h:841
osl::mobility::MobilityTable::get
const Square get(Direction d, int num) const
Definition: mobilityTable.h:65
osl::NumEffectState::findThreatenedPiece
const Piece findThreatenedPiece(Player P) const
取られそうなPの駒で価値が最大のもの
Definition: numEffectState.cc:139
osl::NumEffectState::changedEffects
const BoardMask changedEffects(Player pl) const
Definition: numEffectState.h:144
osl::SimpleState::pieces
CArray< Piece, Piece::SIZE > pieces
全てのpieceが登録されている
Definition: simpleState.h:55
osl::SimpleState::kingPiece
const Piece kingPiece() const
Definition: simpleState.h:83
osl::NumEffectState::hasEffectByNotPinned
bool hasEffectByNotPinned(Player pl, Square target) const
pinされている駒以外からの利きがある.
Definition: numEffectState.h:428
osl::SILVER
@ SILVER
Definition: basic_type.h:98
osl::EffectContent
Definition: effectContent.h:11
osl::Piece::isPieceNum
static bool isPieceNum(int num)
Definition: basic_type.h:926
osl::NumEffectState::doDropMove
void doDropMove(Square to, Ptype ptype)
Definition: numEffectState.cc:293
osl::NumEffectState::checkShadow
const PieceMask checkShadow(Player attack) const
attack の駒で動くと開き王手になる可能性がある集合
Definition: numEffectState.h:70
osl::MoveVector
Definition: container.h:293
osl::Square::makeDirect
static const Square makeDirect(int value)
Definition: basic_type.h:538
osl::NumEffectState::forEachEffectOfPieceDir
void forEachEffectOfPieceDir(Square pieceSquare, Action &action, Int2Type< true >) const
Definition: numEffectState.h:818
osl::NumEffectState::prologueDrop
void prologueDrop(Player2Type< P >, Square to, Ptype ptype, Piece &oldPiece, int &num, PtypeO &ptypeO, int &numIndex, mask_t &numMask, CArray< PieceMask, 2 > &pin_or_open_backup, KingMobility &king_mobility_backup, CArray< PieceMask, 2 > &effected_mask_backup, CArray< PieceMask, 2 > &effected_changed_mask_backup, CArray< uint64_t, 2 > &king8infos_backup, MobilityTable &mobility_backup)
Definition: numEffectState.cc:431
osl::PROOK
@ PROOK
Definition: basic_type.h:92
osl::SimpleState::turn
Player turn() const
Definition: simpleState.h:220
osl::NumEffectState::makeUnmakeMove
void makeUnmakeMove(Player2Type< P > player, Move move, Function &f)
Definition: numEffectState.h:691
osl::Offset::intValue
int intValue() const
Definition: basic_type.h:448
osl::NumEffectState::king8infos
CArray< uint64_t, 2 > king8infos
Definition: numEffectState.h:41
osl::NumEffectState::hasEffectInDirection
bool hasEffectInDirection(Square to) const
あるマスにあるDirectionでの長い利きがあるかどうか.
Definition: numEffectState.h:377
osl::Player
Player
Definition: basic_type.h:8
osl::NumEffectState::doSimpleMove
void doSimpleMove(Square from, Square to, int promoteMask)
Definition: numEffectState.cc:232
osl::NumEffectState::~NumEffectState
~NumEffectState()
Definition: numEffectState.cc:95
osl::NumEffectState::hasEffectByPtype
bool hasEffectByPtype(Player attack, Square target) const
target に ptype の利きがあるか? 成不成を区別しない
Definition: numEffectState.h:355
osl::NumEffectState::forEachEffectOfPieceDir
void forEachEffectOfPieceDir(Square pieceSquare, Action &action) const
Definition: numEffectState.h:824
osl::operator!=
bool operator!=(Offset l, Offset r)
Definition: basic_type.h:516
osl::NumEffectState::longEffectAt
const mask_t longEffectAt(Square target) const
Definition: numEffectState.h:298
osl::NumEffectState::state_t
NumEffectState state_t
Definition: numEffectState.h:44
osl::UL
@ UL
Definition: basic_type.h:313
osl::effect::NumBitmapEffect::longEffectMask
static const mask_t longEffectMask()
Definition: numBitmapEffect.h:107
osl::NumEffectState::king_mobility
KingMobility king_mobility
Definition: numEffectState.h:40
osl::NumEffectState::generateLegal
void generateLegal(MoveVector &) const
全ての合法手を生成する.
Definition: numEffectState.cc:1086
osl::NumEffectState::hasEffectByWithRemove
bool hasEffectByWithRemove(Square target, Square removed) const
osl::NumEffectState::makeUnmakeMove
void makeUnmakeMove(Move move, Function &f)
Definition: numEffectState.h:683
osl::Square::STAND
static const Square STAND()
Definition: basic_type.h:548
osl::CArray
Definition: container.h:20
osl::Move::to
const Square to() const
Definition: basic_type.h:1132
osl::NumEffectState::mobilityOf
Square mobilityOf(Direction d, int num) const
Definition: numEffectState.h:175
osl::Piece::isEdgeNum
static bool isEdgeNum(int num)
Definition: basic_type.h:922
osl::NumEffectState::findEffect
void findEffect(Player P, Square target, PieceVector &out) const
target に利きのあるPieceをoutに格納する
Definition: numEffectState.cc:1119
osl::NumEffectState::hasEffectAt
bool hasEffectAt(Player player, Square target) const
対象とするマスにあるプレイヤーの利きがあるかどうか.
Definition: numEffectState.h:335
NEW_PTYPEO
#define NEW_PTYPEO(player, ptype)
Definition: basic_type.h:204
osl::container::BoardMask
11 x 12
Definition: boardMask.h:21
osl::NumEffectState::findLongAttackAt
const Piece findLongAttackAt(Square square, Direction d) const
Definition: numEffectState.h:547
osl::DirectionTraits
Definition: directionTraits.h:225
osl::NumEffectState::findAttackAtStrict
const Piece findAttackAtStrict(Player attack, Square target) const
Definition: numEffectState.h:511
osl::NumEffectState::changedPieces
const NumBitmapEffect changedPieces() const
Definition: numEffectState.h:152
osl::PieceMask
駒番号のビットセット.
Definition: pieceMask.h:21
osl::NumEffectState::countEffect
int countEffect(Player player, Square target) const
利きの数を数える.
Definition: numEffectState.h:266
osl::checkmate::King8Info
敵玉の8近傍の状態を表す.
Definition: king8Info.h:29
osl::PieceMask::clearBit
void clearBit()
unpromote(PTYPE) の駒のbit を消す
Definition: pieceMask.h:74
osl::SimpleState::SimpleState
SimpleState()
Definition: simpleState.cc:12
osl::NumEffectState::makePinOpen
PieceMask makePinOpen(Square target, Player defense)
Definition: numEffectState.cc:884
osl::NumEffectState::forEachOnBoard
void forEachOnBoard(F &func) const
T は isBasic でなくても動くが unpromote(T) の結果と同じ.
Definition: numEffectState.h:727
osl::Move::player
Player player() const
Definition: basic_type.h:1195
osl::__attribute__
const PtypeO PTYPEO_EDGE __attribute__((unused))
osl
Definition: additionalEffect.h:6
osl::NumEffectState::forEachEffectOfPieceLongDir
void forEachEffectOfPieceLongDir(Square, Action &, Int2Type< false >) const
Definition: numEffectState.h:828
osl::NumEffectState::mobilityOf
Square mobilityOf(Direction d, Piece p) const
Definition: numEffectState.h:179
osl::effect::NumSimpleEffectTable
局面全体の利きデータ.
Definition: numSimpleEffect.h:27
osl::KNIGHT
@ KNIGHT
Definition: basic_type.h:97
osl::NumEffectState::makeMovePass
void makeMovePass()
Definition: numEffectState.h:668
osl::NumEffectState::findLongAttackAt
const Piece findLongAttackAt(Player owner, Piece piece, Direction d) const
Definition: numEffectState.h:536
osl::NumEffectState::pinnedDir
Direction pinnedDir(Piece p) const
Definition: numEffectState.h:210
osl::inverseUnsafe
constexpr Direction inverseUnsafe(Direction d)
Definition: basic_type.h:354