1 #ifndef _MOVE_GENERATOR_ADD_EFFECT8_TCC 
    2 #define _MOVE_GENERATOR_ADD_EFFECT8_TCC 
    8 #include <boost/static_assert.hpp> 
   13   namespace move_generator
 
   26       template <Player P,Ptype T,
class Action>
 
   34           if(state.pieceAt(pos).isEmpty() &&
 
   35              (T!=
PAWN || !state.isPawnMaskSet<P>(pos.
x()))){
 
   37                state.hasEffectByNotPinnedAndKing(
alt(P),pos)) 
continue;
 
   38             action.dropMove(pos,T,P);
 
   53       template <Player P,Ptype T,
class Action>
 
   59           for(;(p=state.pieceAt(from)).isEmpty();from+=offset){
 
   61               action.dropMove(from,T,P);
 
   62             else if(!state.hasEffectAt<altP>(from)){
 
   63               action.dropMove(from,T,P);
 
   64               if(++count>=countMax) 
return;
 
   82       template <Player P,Ptype T,
class Action>
 
   87         generateShortDrop<P,T,Action>(state,
target,action);
 
   92           if(offset.
zero()) 
break;
 
   95           assert(pos.isOnBoard());
 
   97           if(state.pieceAt(pos).isEmpty()){
 
   98             Piece p=state.pieceAt(from);
 
  101                !state.hasEffectByPiece(p,pos)) 
continue;
 
  104           generateLongDropWithOffset<P,T,Action>(state,pos,from,offset,2,action);
 
  108           if(po.first.isPieceStand()) 
break;
 
  111           assert(!offset.zero());
 
  112           generateLongDropWithOffset<P,T,Action>(state,pos-offset,pos,offset,2,action);
 
  117             if(poo.first.isPieceStand()) 
break;
 
  120             assert(!offset1.zero());
 
  122             assert(!offset2.zero());
 
  123             Piece p=state.pieceAt(pos);
 
  125               generateLongDropWithOffset<P,T,Action>(state,pos-offset1,
 
  126                                                      pos,offset1,2,action);
 
  127               generateLongDropWithOffset<P,T,Action>(state,pos-offset2,
 
  128                                                      pos+offset2,offset2,1,
 
  131             else if(p.isOnBoardByOwner<P>()){
 
  132               if(state.hasEffectByPiece(p,pos-offset1)){
 
  133                 generateLongDropWithOffset<P,T,Action>(state,pos-offset1,
 
  137               if(state.hasEffectByPiece(p,pos-offset2)){
 
  138                 generateLongDropWithOffset<P,T,Action>(state,pos-offset2,
 
  155       template <Player P,Ptype T,
class Action>
 
  171           Piece p=state.pieceAt(pos);
 
  173             if(!state.pinOrOpen(P).test(attacker.
number()) ||
 
  174                state.pinnedCanMoveTo<P>(attacker,pos))
 
  175               action.simpleMove(from,pos,T,
false,P);
 
  189         if(state.hasEffectByPiece(attacker,pos)){
 
  190           blocker=state.pieceAt(pos);
 
  193           if(abs(pos.
x()-target.
x())>1 || abs(pos.
y()-target.
y())>1)
 
  195           blocker=state.pieceAt(pos);
 
  200           for(
Square pos1=from+offset;pos1!=pos;pos1+=offset){
 
  201             Piece p=state.pieceAt(pos1);
 
  206                 for(pos1+=offset;pos1!=pos;pos1+=offset){
 
  207                   p=state.pieceAt(pos1);
 
  216               if(pos1==pos-offset &&
 
  217                  (pos+offset).isOnBoard() &&
 
  241       template<Player P,Ptype T>
 
  244         for(
Square pos=to+offset;pos!=from;pos+=offset){
 
  245           Piece p=state.pieceAt(pos);
 
  250               assert(!blocker.
isEdge());
 
  268       template<Player P,Ptype T>
 
  272         return canAddLongEffect<P,T>(state,from,to,blocker,offset);
 
  284       template <Player P,Ptype T,
class Action>
 
  295         if(!op.first.zero()){
 
  296           Square pos=target+op.first.blackOffset<P>();
 
  300             if(findBlocker<P>(state,attacker,target,from,pos,blocker,offset)){
 
  304                 state,blocker,action,1<<
primDir(d));
 
  317               state.hasEffectByPiece(attacker,pos) &&
 
  318               state.pieceAt(pos).isEmpty()){
 
  319             if(!state.pinOrOpen(P).test(attacker.
number()) ||
 
  320                state.pinnedCanMoveTo<P>(attacker,pos))
 
  321               action.simpleMove(from,pos,T,
false,P);
 
  327           if(op.first.zero()) 
break;
 
  328           Square pos1=target+op.first.blackOffset<P>();
 
  329           Square pos2=target+op.second.blackOffset<P>();
 
  331           if(pos1.
isOnBoard() && pos2.isOnBoard() &&
 
  332              state.pieceAt(pos1).isEmpty() &&
 
  334              state.hasEffectByPiece(attacker,pos1) &&
 
  335              canAddLongEffect<P,T>(state,pos1,pos2,blocker)){
 
  336             if(!state.pinOrOpen(P).test(attacker.
number()) ||
 
  337                state.pinnedCanMoveTo<P>(attacker,pos1))
 
  338               action.simpleMove(from,pos1,T,
false,P);
 
  346       template <Player P,Ptype T,
class Action>
 
  375       template <Player P,
class Action>
 
  397       template <Player P,Ptype T,
class Action>
 
  426       template<Player P,Ptype T,
class Action>
 
  433         action_t gkAction(state,target,action);
 
  434         state.template forEachOnBoard<P,T,action_t>(gkAction);
 
  436         if (state.template hasPieceOnStand<T>(P)){
 
  437           generateShortDrop<P,T,Action>(state,
target,action);
 
  441       template<Player P,Ptype T,
class Action>
 
  448         action_t gkAction(state,target,action);
 
  449         state.template forEachOnBoard<P,T,action_t>(gkAction);
 
  452       template<Player P,
class Action>
 
  457         action_t gkAction(state,target,action);
 
  458         state.template forEachOnBoard<P,GOLD,action_t>(gkAction);
 
  460         if (state.template hasPieceOnStand<GOLD>(P)){
 
  461           generateShortDrop<P,GOLD,Action>(state,
target,action);
 
  467     template<
class Action>
 
  471       using namespace addeffect8;
 
  473       if (state.template hasPieceOnStand<BISHOP>(P)){
 
  474         generateLongDrop<P,BISHOP,Action>(state,
target,action);
 
  476       if (state.template hasPieceOnStand<ROOK>(P)){
 
  477         generateLongDrop<P,ROOK,Action>(state,
target,action);
 
  482     template<
class Action>
 
  486       using namespace addeffect8;
 
  488       generateShort<P,PAWN,Action>(state,
target,action);
 
  489       generateLong<P,LANCE,Action>(state,
target,action);
 
  490       if (state.template hasPieceOnStand<LANCE>(P)){
 
  491         generateLongDrop<P,LANCE,Action>(state,
target,action);
 
  493       generateShort<P,KNIGHT,Action>(state,
target,action);
 
  494       generateShort<P,SILVER,Action>(state,
target,action);
 
  495       generateGold<P,Action>(state,
target,action);
 
  497       generateLong<P,BISHOP,Action>(state,
target,action);
 
  498       generateLong<P,ROOK,Action>(state,
target,action);
 
  502     template<
class Action>
 
  504     generate(
const NumEffectState& state,Action& action)
 
  506       generateNotBigDrop(state,action);
 
  507       generateBigDrop(state,action);