3 #ifndef OSL_NUM_EFFECT_STATE_H 
    4 #define OSL_NUM_EFFECT_STATE_H 
    9 #include <boost/cstdint.hpp> 
   25     bool operator==(
const NumEffectState& st1, 
const NumEffectState& st2);
 
   33 #if OSL_WORDSIZE == 32 
   93 #ifdef ALLOW_KING_ABSENCE 
  182         assert(p.
owner() == P);
 
  184         Square king=kingSquare<P>();
 
  190           return pinnedDir<BLACK>(p);
 
  192           return pinnedDir<WHITE>(p);
 
  201         assert(p.
owner() == P);
 
  209           return pinnedCanMoveTo<BLACK>(p, to);
 
  211           return pinnedCanMoveTo<WHITE>(p, to);
 
  219         assert(pinned.
owner() == P);
 
  228           return pinAttacker<BLACK>(pinned);
 
  230           return pinAttacker<WHITE>(pinned);
 
  260         const NumBitmapEffect effect = 
effectSetAt(target);
 
  261         const int all = effect.countEffect(player);
 
  263         return all - pins.countBit();
 
  269       template <Ptype PTYPE>
 
  277         return effectSetAt(target).selectLong<PTYPE>() >> 8;
 
  304         mask&=NumBitmapEffect::playerEffectMask<P>();
 
  315         mask&=NumBitmapEffect::playerEffectMask(player);
 
  322       template <Ptype PTYPE>
 
  325         return longEffectAt<PTYPE>(to, P).any();
 
  331       template <Ptype PTYPE>
 
  334         return allEffectAt<PTYPE>(attack, 
target).any();
 
  339       template <Ptype PTYPE>
 
  346           mask &= ~(
promoted.getMask<PTYPE>());
 
  353       template<Direction Dir,Player P>
 
  357         mask_t mask1=pieces_onboard.getMask(1);
 
  360                    : mask_t::makeDirect(0)) 
 
  363                      :  mask_t::makeDirect(0))
 
  366                      : mask_t::makeDirect(0)));
 
  369         mask1&=
effectSetAt(to).getMask(1)& NumBitmapEffect::longEffectMask();
 
  372           int num=mask1.takeOneBit()+NumBitmapEffect::longToNumOffset;
 
  387         assert(piece.
owner()==player);
 
  390         pieces_onboard.reset(num);
 
  419         mask&=NumBitmapEffect::playerEffectMask(player);
 
  420         return NumBitmapEffect::playerEffect(player).getMask(1) < mask;
 
  469           return hasEffectByWithRemove<BLACK>(
target,removed);
 
  471           return hasEffectByWithRemove<WHITE>(
target,removed);
 
  479       template <Ptype PTYPE>
 
  487       template <Ptype PTYPE>
 
  494           mask &= ~(
promoted.getMask<PTYPE>());
 
  505         assert(
pieceOf(piece).isOnBoardByOwner(owner));
 
  516         assert(piece.
owner() == owner);
 
  559         return pieceOf(pieces.takeOneBit());
 
  572         return hasEffectAt<PlayerTraits<P>::opponent>(
kingSquare(P),attack_piece);
 
  577           return hasEffectAt<BLACK>(
target, attackerPiece);
 
  579           return hasEffectAt<WHITE>(
target, attackerPiece);
 
  591 #if OSL_WORDSIZE == 64 
  592         mask_t mask=pieceMask.getMask(0);
 
  593         if (mask.none()) 
return false;
 
  598         if (mask.hasMultipleBit())
 
  603 #elif OSL_WORDSIZE == 32 
  604         mask_t mask0=pieceMask.getMask(0);
 
  605         mask_t mask1=pieceMask.getMask(1);
 
  611           if (mask0 == PieceMask::numToMask(num))
 
  615         else if (mask1.any())
 
  618           if (mask1==PieceMask::numToMask(num))
 
  640       template <
bool show_error>
 
  651       template <
class Function>
 
  658       template <
class Function>
 
  666       template <Player P, 
class Function>
 
  673         assert(P == move.
player());
 
  702       template<Player P,Ptype T,
typename F>
 
  714       template<Player P,Ptype T,
typename F>
 
  729       template<Player P,
class Action>
 
  732 #if OSL_WORDSIZE == 64 
  733         mask_t mask=pieces.getMask(0);
 
  736           const int num=mask.takeOneBit();
 
  737           action.template doAction<P>(
pieceOf(num),sq);
 
  739 #elif OSL_WORDSIZE == 32 
  740         mask_t mask0=pieces.getMask(0);
 
  743           const int num=mask0.takeOneBit();
 
  744           action.template doAction<P>(
pieceOf(num),sq);
 
  746         mask_t mask1=pieces.getMask(1);
 
  749           const int num=mask1.takeOneBit()+32;
 
  750           action.template doAction<P>(
pieceOf(num),sq);
 
  759       template<Player P,
class Action>
 
  763         forEachEffect<P,Action>(pieceMask, sq, action);
 
  770       template<Player P,
class Action>
 
  775         forEachEffect<P,Action>(pieceMask, sq, action);
 
  783       template<Player P,
class Action>
 
  786         pieces.reset(piece.
number());
 
  787         forEachEffect<P,Action>(
pieces, sq, action);
 
  791       template<Player P,Ptype Type,
class Action,Direction Dir>
 
  793       template<Player P,Ptype Type,
class Action,Direction Dir>
 
  796         action.template doAction<P>(this->
pieceAt(pieceSquare),pieceSquare+offset);
 
  799       template<Player P,Ptype Type,
class Action,Direction Dir>
 
  801         forEachEffectOfPieceDir<P,Type,Action,Dir>(pieceSquare,action,Int2Type<(PtypeTraits<Type>::moveMask & 
DirectionTraits<Dir>::mask)!=0>());
 
  803       template<Player P,Ptype Type,
class Action,Direction Dir>
 
  805       template<Player P,Ptype Type,
class Action,Direction Dir>
 
  810         Square sq=pieceSquare+offset;
 
  812           action.template doAction<P>(piece,sq);
 
  813         action.template doAction<P>(piece,sq);
 
  816       template<Player P,Ptype Type,
class Action,Direction Dir>
 
  818         forEachEffectOfPieceLongDir<P,Type,Action,Dir>(pieceSquare,action,Int2Type<(PtypeTraits<Type>::moveMask & 
DirectionTraits<Dir>::mask)!=0>());
 
  828       template<Player P,Ptype Type,
class Action>
 
  830       template<
class Action>
 
  839       template <Player P, 
class Function>
 
  841                             Square from, 
Square to, 
int promoteMask,Function& func);
 
  844                           Piece& oldPiece, 
int& num, 
 
  846                           CArray<PieceMask,2>& pin_or_open_backup,
 
  847                           KingMobility& king_mobility_backup,
 
  848                           PieceMask& promoted_backup,
 
  849                           CArray<PieceMask,2>& effected_mask_backup,
 
  850                           CArray<PieceMask,2>& effected_changed_mask_backup,
 
  851                           CArray<uint64_t,2>& king8infos_backup,
 
  852                           MobilityTable &mobility_backup
 
  856                           const CArray<PieceMask,2>& pin_or_open_backup,
 
  857                           const KingMobility& king_mobility_backup,
 
  858                           const PieceMask& promoted_backup,
 
  859                           const CArray<PieceMask,2>& effected_mask_backup,
 
  860                           const CArray<PieceMask,2>& effected_changed_mask_backup,
 
  861                           const CArray<uint64_t,2>& king8infos_backup,
 
  862                           const MobilityTable &mobility_backup
 
  864       template <Player P, 
class Function>
 
  870                         int& numIndex, 
mask_t& numMask,
 
  871                         CArray<PieceMask,2>& pin_or_open_backup,
 
  872                         KingMobility& king_mobility_backup,
 
  873                         CArray<PieceMask,2>& effected_mask_backup,
 
  874                         CArray<PieceMask,2>& effected_changed_mask_backup,
 
  875                         CArray<uint64_t,2>& king8infos_backup,
 
  876                         MobilityTable &mobility_backup);
 
  880                         const CArray<PieceMask,2>& pin_or_open_backup,
 
  881                         const KingMobility& king_mobility_backup,
 
  882                         const CArray<PieceMask,2>& effected_mask_backup,
 
  883                         const CArray<PieceMask,2>& effected_changed_mask_backup,
 
  884                         const CArray<uint64_t,2>& king8infos_backup,
 
  885                         const MobilityTable &mobility_backup);
 
  886       template <Player P, 
class Function>
 
  894                            PtypeO& new_ptypeo, 
int& num0, 
int& num1, 
 
  895                            int& num1Index, 
mask_t& num1Mask,
 
  896                            CArray<PieceMask,2>& pin_or_open_backup,
 
  897                            KingMobility& king_mobility_backup,
 
  898                            PieceMask& promoted_backup,
 
  899                            CArray<PieceMask,2>& effected_mask_backup,
 
  900                            CArray<PieceMask,2>& effected_changed_mask_backup,
 
  901                            CArray<uint64_t,2>& king8infos_backup,
 
  902                            MobilityTable &mobility_backup);
 
  908                            int num1Index, 
mask_t num1Mask,
 
  909                            const CArray<PieceMask,2>& pin_or_open_backup,
 
  910                            const KingMobility& king_mobility_backup,
 
  911                            const PieceMask& promoted_backup,
 
  912                            const CArray<PieceMask,2>& effected_mask_backup,
 
  913                            const CArray<PieceMask,2>& effected_changed_mask_backup,
 
  914                            const CArray<uint64_t,2>& king8infos_backup,
 
  915                            const MobilityTable &mobility_backup);
 
  917       template<Direction DIR>
 
  919                           PieceMask& pins, PieceMask 
const& onBoard,
Player defense)
 
  936 #ifdef ALLOW_KING_ABSENCE 
  941         if(!
isLong(longD) || (lastDir!=
UL && longD==lastDir)) 
return;
 
  974   using state::NumEffectState;
 
  977 template <osl::Player P, 
typename Function>
 
  978 void osl::NumEffectState::
 
  979 doUndoSimpleMove(Player2Type<P> player,
 
  980                  Square from, 
Square to, 
int promoteMask, Function& func)
 
  985   CArray<PieceMask,2> pin_or_open_backup;
 
  986   KingMobility king_mobility_backup;
 
  987   PieceMask promoted_backup;
 
  988   CArray<PieceMask,2> effected_mask_backup;
 
  989   CArray<PieceMask,2> effected_changed_mask_backup;
 
  990   CArray<uint64_t,2> king8infos_backup;
 
  991   MobilityTable mobility_backup;
 
  992   prologueSimple(player, from, to, promoteMask, oldPiece, num, oldPtypeO, newPtypeO, 
 
  994                  king_mobility_backup,
 
  996                  effected_mask_backup, effected_changed_mask_backup,
 
 1013   epilogueSimple(from, to, oldPiece, num, oldPtypeO, newPtypeO, 
 
 1015                  king_mobility_backup,
 
 1016                  promoted_backup, effected_mask_backup, effected_changed_mask_backup,
 
 1021 template <osl::Player P, 
typename Function>
 
 1022 void osl::NumEffectState::doUndoDropMove(Player2Type<P> player,
 
 1029   CArray<PieceMask,2> pin_or_open_backup;
 
 1030   KingMobility king_mobility_backup;
 
 1031   CArray<PieceMask,2> effected_mask_backup;
 
 1032   CArray<PieceMask,2> effected_changed_mask_backup;
 
 1033   CArray<uint64_t,2> king8infos_backup;
 
 1034   MobilityTable mobility_backup;
 
 1035   prologueDrop(player, to, ptype, oldPiece, num, ptypeO, numIndex, numMask, 
 
 1036                pin_or_open_backup, king_mobility_backup,
 
 1037                effected_mask_backup,effected_changed_mask_backup,
 
 1054   epilogueDrop(player, to, ptype, oldPiece, num, ptypeO, numIndex, numMask, 
 
 1055                pin_or_open_backup, king_mobility_backup,
 
 1056                effected_mask_backup,effected_changed_mask_backup,
 
 1061 template <osl::Player P, 
typename Function>
 
 1062 void osl::NumEffectState::doUndoCaptureMove(Player2Type<P> player,
 
 1064                                        int promoteMask,Function& func)
 
 1068   int num0, num1, num1Index;
 
 1070   CArray<PieceMask,2> pin_or_open_backup;
 
 1071   KingMobility king_mobility_backup;
 
 1072   PieceMask promoted_backup;
 
 1073   CArray<PieceMask,2> effected_mask_backup;
 
 1074   CArray<PieceMask,2> effected_changed_mask_backup;
 
 1075   CArray<uint64_t,2> king8infos_backup;
 
 1076   MobilityTable mobility_backup;
 
 1077   prologueCapture(player, from, to, target, promoteMask, oldPiece, oldPtypeO, 
 
 1078                   capturePtypeO, newPtypeO, num0, num1, num1Index,num1Mask, 
 
 1079                   pin_or_open_backup, king_mobility_backup,
 
 1081                   effected_mask_backup, effected_changed_mask_backup,
 
 1087   if (capturePtype==
PAWN)
 
 1114   epilogueCapture(player, from, to, target, oldPiece, oldPtypeO, capturePtypeO, newPtypeO, 
 
 1115                   num0, num1, num1Index,num1Mask, 
 
 1116                   pin_or_open_backup, king_mobility_backup,
 
 1117                   promoted_backup,effected_mask_backup, effected_changed_mask_backup,
 
 1122 template <
class Action>
 
 1123 void osl::NumEffectState::
 
 1124 forEachEffectOfPiece(
Piece piece,Action & action)
 const  
 1127   switch ((
int)piece.
ptypeO()) {
 
 1128   case NEW_PTYPEO(
WHITE,
PAWN): forEachEffectOfPiece<WHITE,PAWN,Action>(pieceSquare,action); 
break;
 
 1129   case NEW_PTYPEO(
WHITE,
LANCE): forEachEffectOfPiece<WHITE,LANCE,Action>(pieceSquare,action); 
break;
 
 1130   case NEW_PTYPEO(
WHITE,
KNIGHT): forEachEffectOfPiece<WHITE,KNIGHT,Action>(pieceSquare,action); 
break;
 
 1131   case NEW_PTYPEO(
WHITE,
SILVER): forEachEffectOfPiece<WHITE,SILVER,Action>(pieceSquare,action); 
break;
 
 1132   case NEW_PTYPEO(
WHITE,
PPAWN): forEachEffectOfPiece<WHITE,PPAWN,Action>(pieceSquare,action); 
break;
 
 1133   case NEW_PTYPEO(
WHITE,
PLANCE): forEachEffectOfPiece<WHITE,PLANCE,Action>(pieceSquare,action); 
break;
 
 1136   case NEW_PTYPEO(
WHITE,
GOLD): forEachEffectOfPiece<WHITE,GOLD,Action>(pieceSquare,action); 
break;
 
 1137   case NEW_PTYPEO(
WHITE,
BISHOP): forEachEffectOfPiece<WHITE,BISHOP,Action>(pieceSquare,action); 
break;
 
 1139   case NEW_PTYPEO(
WHITE,
ROOK): forEachEffectOfPiece<WHITE,ROOK,Action>(pieceSquare,action); 
break;
 
 1140   case NEW_PTYPEO(
WHITE,
PROOK): forEachEffectOfPiece<WHITE,PROOK,Action>(pieceSquare,action); 
break;
 
 1141   case NEW_PTYPEO(
WHITE,
KING): forEachEffectOfPiece<WHITE,KING,Action>(pieceSquare,action); 
break;
 
 1142   case NEW_PTYPEO(
BLACK,
PAWN): forEachEffectOfPiece<BLACK,PAWN,Action>(pieceSquare,action); 
break;
 
 1143   case NEW_PTYPEO(
BLACK,
LANCE): forEachEffectOfPiece<BLACK,LANCE,Action>(pieceSquare,action); 
break;
 
 1144   case NEW_PTYPEO(
BLACK,
KNIGHT): forEachEffectOfPiece<BLACK,KNIGHT,Action>(pieceSquare,action); 
break;
 
 1145   case NEW_PTYPEO(
BLACK,
SILVER): forEachEffectOfPiece<BLACK,SILVER,Action>(pieceSquare,action); 
break;
 
 1146   case NEW_PTYPEO(
BLACK,
PPAWN): forEachEffectOfPiece<BLACK,PPAWN,Action>(pieceSquare,action); 
break;
 
 1147   case NEW_PTYPEO(
BLACK,
PLANCE): forEachEffectOfPiece<BLACK,PLANCE,Action>(pieceSquare,action); 
break;
 
 1150   case NEW_PTYPEO(
BLACK,
GOLD): forEachEffectOfPiece<BLACK,GOLD,Action>(pieceSquare,action); 
break;
 
 1151   case NEW_PTYPEO(
BLACK,
BISHOP): forEachEffectOfPiece<BLACK,BISHOP,Action>(pieceSquare,action); 
break;
 
 1153   case NEW_PTYPEO(
BLACK,
ROOK): forEachEffectOfPiece<BLACK,ROOK,Action>(pieceSquare,action); 
break;
 
 1154   case NEW_PTYPEO(
BLACK,
PROOK): forEachEffectOfPiece<BLACK,PROOK,Action>(pieceSquare,action); 
break;
 
 1155   case NEW_PTYPEO(
BLACK,
KING): forEachEffectOfPiece<BLACK,KING,Action>(pieceSquare,action); 
break;
 
 1160 template <osl::Player P, osl::Ptype Type, 
class Action>
 
 1161 void osl::NumEffectState::
 
 1162 forEachEffectOfPiece(
Square pieceSquare,Action & action)
 const  
 1164   forEachEffectOfPieceDir<P,Type,Action,UL>(pieceSquare,action);
 
 1165   forEachEffectOfPieceDir<P,Type,Action,U>(pieceSquare,action);
 
 1166   forEachEffectOfPieceDir<P,Type,Action,UR>(pieceSquare,action);
 
 1167   forEachEffectOfPieceDir<P,Type,Action,L>(pieceSquare,action);
 
 1168   forEachEffectOfPieceDir<P,Type,Action,R>(pieceSquare,action);
 
 1169   forEachEffectOfPieceDir<P,Type,Action,DL>(pieceSquare,action);
 
 1170   forEachEffectOfPieceDir<P,Type,Action,D>(pieceSquare,action);
 
 1171   forEachEffectOfPieceDir<P,Type,Action,DR>(pieceSquare,action);
 
 1172   forEachEffectOfPieceDir<P,Type,Action,UUL>(pieceSquare,action);
 
 1173   forEachEffectOfPieceDir<P,Type,Action,UUR>(pieceSquare,action);
 
 1174   forEachEffectOfPieceLongDir<P,Type,Action,LONG_UL>(pieceSquare,action);
 
 1175   forEachEffectOfPieceLongDir<P,Type,Action,LONG_U>(pieceSquare,action);
 
 1176   forEachEffectOfPieceLongDir<P,Type,Action,LONG_UR>(pieceSquare,action);
 
 1177   forEachEffectOfPieceLongDir<P,Type,Action,LONG_L>(pieceSquare,action);
 
 1178   forEachEffectOfPieceLongDir<P,Type,Action,LONG_R>(pieceSquare,action);
 
 1179   forEachEffectOfPieceLongDir<P,Type,Action,LONG_DL>(pieceSquare,action);
 
 1180   forEachEffectOfPieceLongDir<P,Type,Action,LONG_D>(pieceSquare,action);
 
 1181   forEachEffectOfPieceLongDir<P,Type,Action,LONG_DR>(pieceSquare,action);