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);