11 #  include "osl/boardBitEffect.h" 
   12 #  include "osl/signatureEffect.h" 
   16 #  include "osl/piecePairEval.h" 
   17 #  include "osl/pieceEval.h" 
   40 bool piecePair = 
false;
 
   44 template<Player P,
typename State,
bool isMoveEval>
 
   47 template<
class State, Player P,
bool isMoveEval>
 
   54     nextMoves<P,State,isMoveEval>(state,level);
 
   58 template<Player P,
typename State>
 
   62 template<Player P,
typename State>
 
   65   const int ret = ev.template computeValWithMove<State,P>(state, move);
 
   70 template<Player P,
typename State,
bool isMoveEval>
 
   77   size_t size=moves.size();
 
   78   for(
size_t i=0;i<size;i++){
 
   79     callValWithMove<P,State>(state,moves[i],Int2Type<isMoveEval>());
 
   82     const int prevValue = value;
 
   84       value += PieceEval::diffWithMove(state, moves[i]);
 
   86       value += PiecePairEval::diffWithMove(state, moves[i]);
 
   88     state.makeUnmakeMove(Player2Type<P>(),moves[i],helper);
 
   95 #ifdef ENABLE_DIRECT_MODE 
   96 template<Player P,
typename State,
bool isMoveEval>
 
   97 void nextMovesDirect(
State& state,
int level);
 
   99 template<
class State,Player P,
bool isMoveEval>
 
  100 struct CallNextMoves{
 
  103   CallNextMoves(
State& s, 
int level) : state(s), level(level){}
 
  105   void operator()(
Square p){
 
  106     nextMovesDirect<P,State,isMoveEval>(state,level);
 
  110 template<
typename State,Player P,
bool isMoveEval>
 
  111 struct DirectCallAction{
 
  114   DirectCallAction(
State& s, 
int level) : state(s), level(level){}
 
  115   typedef CallNextMoves<State,PlayerTraits<P>::opponent,isMoveEval> next_t;
 
  119     next_t caller(state,level);
 
  120     ApplyDoUndoSimpleMove<P,State>::template doUndoSimpleMove<next_t>
 
  121       (state,from,to,promoteMask(isPromote),caller);
 
  124     next_t  caller(state,level);
 
  127       ApplyDoUndoSimpleMove<P,State>::template doUndoSimpleMove<next_t>
 
  128         (state,from,to,promoteMask(isPromote),caller);
 
  130       ApplyDoUndoCaptureMove<P,State>::template doUndoCaptureMove<next_t>
 
  131         (state,from,to,p1,promoteMask(isPromote),caller);
 
  135     next_t  caller(state, level);
 
  136     ApplyDoUndoDropMove<P,State>::template doUndoDropMove<next_t>(state,to,ptype,caller);
 
  140 template<Player P,
typename State,
bool isMoveEval>
 
  141 void nextMovesDirect(
State& state,
int level){
 
  143   DirectCallAction<State,P,isMoveEval> action(state, level+1);
 
  145   generate_t::template generateMoves<P>(state,action);
 
  149 int main(
int argc,
char **argv){
 
  150   bool directMode=
false;
 
  151   bool effectMode=
false;
 
  153   bool boardBitMode=
false;
 
  154   bool signatureMode=
false;
 
  159   while ((c = getopt(argc, argv, 
"l:dehpPbS")) != EOF)
 
  163         case 'l':       level=atoi(optarg);
 
  165         case 'd':       directMode=
true;
 
  167         case 'e':       effectMode=
true;
 
  169         case 'h':       hashMode=
true;
 
  171         case 'b':       boardBitMode=
true;
 
  173         case 'S':       signatureMode=
true;
 
  176         case 'p':       noPair=
true;
 
  178         case 'P':       piecePair=
true;
 
  182           std::cerr << 
"unknown option\n";
 
  186   SimpleState state=CsaString(
 
  187                               "P1+RY *  *  *  *  *  * -KE-KY\n" 
  188                               "P2 *  *  * +GI * -KI-KI-OU *\n" 
  189                               "P3 *  * +TO *  *  * -GI-FU-FU\n" 
  190                               "P4-FU * -UM * -FU * -FU *  *\n" 
  191                               "P5 *  * +GI *  * -FU * +FU+FU\n" 
  192                               "P6+FU+OU+GI+FU+FU * +FU *  *\n" 
  193                               "P7 * +FU * +KE *  *  *  *  *\n" 
  194                               "P8 *  *  *  *  *  *  *  *  * \n" 
  195                               "P9-RY *  *  *  *  *  *  * +KY\n" 
  196                               "P+00KA00KY00FU00FU00FU00FU\n" 
  197                               "P-00KI00KI00KE00KE00KY\n" 
  198                               "+\n").getInitialState();
 
  204     std::cerr << 
"effectMode" << std::endl;
 
  205     NumEffectState neState(state);
 
  208       std::cerr << 
"directMode" << std::endl;
 
  209 #ifdef ENABLE_DIRECT_MODE 
  210       nextMovesDirect<BLACK,NumEffectState,false>(neState,0);
 
  214       nextMoves<BLACK,NumEffectState,false>(neState,0);
 
  221       std::cerr << 
"signatureMode" << std::endl;
 
  222       SimpleState sState(state);
 
  223       typedef SignatureEffect<BoardBitEffect<SimpleState> > 
state_t;
 
  224       state_t bState(sState);
 
  227         std::cerr << 
"directMode" << std::endl;
 
  228 #ifdef ENABLE_DIRECT_MODE 
  229         nextMovesDirect<BLACK,state_t,false>(bState,0);
 
  233         nextMoves<BLACK,state_t,false>(bState,0);
 
  238         std::cerr << 
"boardBitMode" << std::endl;
 
  239         SimpleState sState(state);
 
  240         typedef BoardBitEffect<SimpleState> 
state_t;
 
  241         state_t bState(sState);
 
  244           std::cerr << 
"directMode" << std::endl;
 
  245 #ifdef ENABLE_DIRECT_MODE 
  246           nextMovesDirect<BLACK,state_t,false>(bState,0);
 
  250           nextMoves<BLACK,state_t,false>(bState,0);
 
  256           std::cerr << 
"simpleMode" << std::endl;
 
  257           SimpleState sState(state);
 
  260             std::cerr << 
"directMode" << std::endl;
 
  261 #ifdef ENABLE_DIRECT_MODE 
  262             nextMovesDirect<BLACK,SimpleState,false>(sState,0);
 
  266             nextMoves<BLACK,SimpleState,false>(sState,0);