1 #ifndef OSL_GENERATE_ESCAPE_MOVES_TCC 
    2 #define OSL_GENERATE_ESCAPE_MOVES_TCC 
   11   namespace move_generator
 
   19       template<Player P,
class Action,Ptype Type>
 
   21         if(state.template hasPieceOnStand<Type>(P)){
 
   22           if((Type!=
PAWN || !state.isPawnMaskSet(P,to.
x())) &&
 
   24             action.dropMove(to,Type,P);
 
   34       template<Player P,
class Action,
bool CheapOnly>
 
   37         bool gen = generateDrop<P,Action,PAWN>(state,to,action); 
if (CheapOnly && gen) 
return;
 
   38         gen = generateDrop<P,Action,LANCE>(state,to,action);     
if (CheapOnly && gen) 
return;
 
   39         gen = generateDrop<P,Action,KNIGHT>(state,to,action);    
if (CheapOnly && gen) 
return;
 
   40         gen = generateDrop<P,Action,SILVER>(state,to,action);    
if (CheapOnly && gen) 
return;
 
   41         gen = generateDrop<P,Action,GOLD>(state,to,action);      
if (CheapOnly && gen) 
return;
 
   42         gen = generateDrop<P,Action,BISHOP>(state,to,action);    
if (CheapOnly && gen) 
return;
 
   43         generateDrop<P,Action,ROOK>(state,to,action);      
 
   51       template<Player P,
class Action,
bool CheapOnly>
 
   55         const PieceMask pieces = state.effectSetAt(pos) & state.piecesOnBoard(P);
 
   59           m = pieces.selectBit<
LANCE>(); 
 
   62             m = pieces.selectBit<
KNIGHT>(); 
 
   65               m = pieces.selectBit<
SILVER>(); 
 
   68                 m = pieces.selectBit<
GOLD>(); 
 
   71                   m = pieces.selectBit<
BISHOP>(); 
 
   74                     m = pieces.selectBit<
ROOK>(); 
 
   84         const Piece p = state.pieceOf(m.takeOneBit() + offset);
 
   99     template<
class Action>
 
  100     template<Player P,
bool CheapOnly>
 
  106       assert(!offset.zero());
 
  107       for(
Square pos=to+offset;pos!=from;pos+=offset){
 
  108         assert(state.pieceAt(pos).isEmpty());
 
  112           generateDropAll<P,Action,false>(state,pos,action);
 
  116           const int e = state.countEffect(P, pos);
 
  118             blockByMoveOne<P,Action,CheapOnly>(state, pos, action);
 
  121             generateDropAll<P,Action,true>(state,pos,action);
 
  130     template<
class Action>
 
  131     template<Player P,
bool CheapOnly>
 
  137       assert(!offset.
zero());
 
  138       for(
Square pos=to+offset;pos!=from;pos+=offset){
 
  139         assert(state.pieceAt(pos).isEmpty()); 
 
  142         generateDropAll<P,Action,CheapOnly>(state,pos,action);
 
  145     template<
class Action>
 
  146     template<Player P,Ptype Type,
bool CheapOnly>
 
  152         generateEscape<P,Type>(state,p,action);
 
  154       else if(Type == 
KING){
 
  157           Piece attack_by_position;
 
  158           state.template findCheckPiece<P>(attack_by_position);
 
  159           assert(attacker == attack_by_position);
 
  164         generateCaptureKing<P>( state, p, attackFrom, action );
 
  166         generateEscape<P,Type>( state,p,action);
 
  168         generateBlockingKing<P,CheapOnly>(state,p,attackFrom,action);
 
  172         generateCapture<P>( state, p, attackFrom, action );
 
  174         generateEscape<P,Type>( state,p,action);
 
  176         generateBlocking<P,CheapOnly>(state,p,p.square(),attackFrom,action);
 
  180     template<
class Action>
 
  181     template<Player P,
bool CheapOnly>
 
  187       const bool is_attacked=
 
  189         state.template findCheckPiece<P>(attacker);
 
  191       generateMovesBy<P,KING,CheapOnly>(state,kingPiece,attacker,action);
 
  194     template<
class Action>
 
  195     template<Player P,Ptype TYPE,
bool CheapOnly>
 
  202       const bool is_attacked=
 
  204         state.template hasEffectAt<PlayerTraits<P>::opponent>(
target,attacker);
 
  206       generateMovesBy<P,TYPE,CheapOnly>(state,p,attacker,action);
 
  209     template<
class Action>
 
  210     template<Player P,
bool CheapOnly>
 
  214       switch(piece.
ptype()){
 
  215       case PAWN: generateMovesBy<P,PAWN,CheapOnly>(state,piece,attacker,action); 
break;
 
  216       case LANCE: generateMovesBy<P,LANCE,CheapOnly>(state,piece,attacker,action); 
break;
 
  217       case KNIGHT: generateMovesBy<P,KNIGHT,CheapOnly>(state,piece,attacker,action); 
break;
 
  218       case SILVER: generateMovesBy<P,SILVER,CheapOnly>(state,piece,attacker,action); 
break;
 
  219       case PPAWN: generateMovesBy<P,PPAWN,CheapOnly>(state,piece,attacker,action); 
break;
 
  220       case PLANCE: generateMovesBy<P,PLANCE,CheapOnly>(state,piece,attacker,action); 
break;
 
  221       case PKNIGHT: generateMovesBy<P,PKNIGHT,CheapOnly>(state,piece,attacker,action); 
break;
 
  222       case PSILVER: generateMovesBy<P,PSILVER,CheapOnly>(state,piece,attacker,action); 
break;
 
  223       case GOLD: generateMovesBy<P,GOLD,CheapOnly>(state,piece,attacker,action); 
break;
 
  224       case BISHOP: generateMovesBy<P,BISHOP,CheapOnly>(state,piece,attacker,action); 
break;
 
  225       case PBISHOP: generateMovesBy<P,PBISHOP,CheapOnly>(state,piece,attacker,action); 
break;
 
  226       case ROOK: generateMovesBy<P,ROOK,CheapOnly>(state,piece,attacker,action); 
break;
 
  227       case PROOK: generateMovesBy<P,PROOK,CheapOnly>(state,piece,attacker,action); 
break;
 
  228       case KING: generateMovesBy<P,KING,CheapOnly>(state,piece,attacker,action); 
break;
 
  233     template<
class Action>
 
  234     template<Player P,
bool shouldPromote,
bool CheapOnly>
 
  238       assert(piece.
owner() == P);
 
  241       state.template hasEffectAt<PlayerTraits<P>::opponent>(
target,attacker);
 
  242       generateMoves<P,CheapOnly>(state,piece,attacker,action);
 
  248 #endif // OSL_GENERATE_ESCAPE_MOVES_TCC