00001
00004 #include "osl/record/csaString.h"
00005
00006 #define NO_SAFE_MOVE_ACTION_IN_LIBOSL
00007 #define SIMPLE_STATE_ONLY
00008
00009 #include "osl/move_generator/addEffect_.h"
00010 #include "osl/move_generator/addEffectWithEffect.h"
00011 #include "osl/move_generator/escape_.h"
00012
00013 #ifdef NO_SAFE_MOVE_ACTION_IN_LIBOSL
00014 # include "osl/move_generator/open.tcc"
00015 # include "osl/move_generator/allMoves.tcc"
00016 # include "osl/move_generator/escape_.tcc"
00017 # include "osl/move_generator/capture_.tcc"
00018 # include "osl/move_generator/addEffect_.tcc"
00019 # include "osl/move_generator/addEffectWithEffect.tcc"
00020 #endif
00021
00022 #ifndef SIMPLE_STATE_ONLY
00023 # include "osl/boardBitEffect.h"
00024 # include "osl/evalHashEffectState.h"
00025 # include "osl/numEffectState.h"
00026 #endif
00027
00028 #include "osl/applyMove.h"
00029 #include "osl/move_action/store.h"
00030 #include "osl/move_action/safeFilter.h"
00031 #include "osl/perfmon.h"
00032 #include <time.h>
00033 #include <sys/time.h>
00034
00035 using namespace osl;
00036 using namespace osl::move_generator;
00037 using namespace osl::move_action;
00038
00039 int moveCount;
00040 int maxLevel;
00041
00042 template<Player P,typename State, bool isAttack,bool withEffect>
00043 void nextMoves(State& state,int level,Move lastMove);
00044
00045 template<class State, Player P, bool isAttack,bool withEffect>
00046 struct DoUndoHelper
00047 {
00048 State& state;
00049 int level;
00050 Move move;
00051
00052 DoUndoHelper(State& s, int level) : state(s), level(level), move(MOVE_INVALID){}
00053 void operator()(Position p)
00054 {
00055 assert(move!=MOVE_INVALID);
00056 nextMoves<P,State,isAttack,withEffect>(state,level,move);
00057 }
00058 };
00059
00060 template <Player P, typename State, bool isAttack,bool withEffect>
00061 void nextMoves(State& state,int level,Move lastMove)
00062 {
00063 typedef typename State::effect_state_t effect_t;
00064 if (level>maxLevel)
00065 return;
00066 MoveVector moves;
00067 typedef DoUndoHelper<State,PlayerTraits<P>::opponent,!isAttack,withEffect> helper_t;
00068 helper_t helper(state, level+1);
00069 Store store(moves);
00070 if (isAttack)
00071 {
00072 typedef SafeFilter<P,typename State::effect_state_t,Store> action_t;
00073 action_t safeAction(state,store);
00074 const Position opKingPosition
00075 =state.template getKingPosition<PlayerTraits<P>::opponent>();
00076 #if 1
00077 if (state.hasEffectBy(P,opKingPosition))
00078 return;
00079 #else
00080 assert(!state.hasEffectBy(P,opKingPosition));
00081 #endif
00082 if(withEffect)
00083 AddEffectWithEffect<typename State::effect_state_t,action_t>::
00084 generateMoves(P,(effect_t)state,opKingPosition,safeAction);
00085 #if 1
00086 else
00087 AddEffect<typename State::effect_state_t,action_t>::
00088 generateMoves(P,state,opKingPosition,safeAction);
00089 #endif
00090 }
00091 else
00092 {
00093 assert(!state.hasEffectBy(P,state.template getKingPosition<PlayerTraits<P>::opponent>()));
00094
00095 Escape<P,typename State::effect_state_t,Store>::
00096 generateKingEscape((effect_t)state, lastMove,store);
00097 }
00098
00099 size_t size=moves.size();
00100 for(size_t i=0;i<size;i++){
00101
00102 moveCount++;
00103 helper.move=moves[i];
00104 ApplyMove<P>::doUndoMove(state,moves[i],helper);
00105 }
00106 }
00107
00108 int main(int argc,char **argv){
00109 bool effectMode=false;
00110 bool hashMode=false;
00111 bool evalMode=false;
00112 bool nullMode=false;
00113 bool withEffectMode=false;
00114 bool simpleMode=false;
00115 bool boardBitMode=false;
00116 int level=3;
00117 extern char *optarg;
00118
00119 char c;
00120 while ((c = getopt(argc, argv, "l:dehEnwsb")) != EOF)
00121 {
00122 switch(c)
00123 {
00124 case 'l': level=atoi(optarg);
00125 break;
00126 case 'e': effectMode=true;
00127 break;
00128 case 'h': hashMode=true;
00129 break;
00130 case 'E': evalMode=true;
00131 break;
00132 case 'n': nullMode=true;
00133 break;
00134 case 'w': withEffectMode=true;
00135 break;
00136 case 's': simpleMode=true;
00137 break;
00138 case 'b': boardBitMode=true;
00139 break;
00140 default:
00141 std::cerr << "unknown option\n";
00142 return 1;
00143 }
00144 }
00145 SimpleState state=CsaString(
00146 "P1-KY * * * -KY * -FU-KE * \n"
00147 "P2 * * * * -OU * * * * \n"
00148 "P3 * * * -FU-FU+RY * * -KY\n"
00149 "P4-FU * * -GI * * * * * \n"
00150 "P5 * * * * * * * * * \n"
00151 "P6+FU * * +RY * * +FU * * \n"
00152 "P7 * +FU * +FU+FU+FU * * * \n"
00153 "P8 * * +OU * -TO * * * * \n"
00154 "P9+KY * * * * * * +KE * \n"
00155 "P+00KI00GI00GI00GI00KE00KE00FU00FU00FU00KI\n"
00156 "P-00KA00KA00KI00FU00FU00FU00FU00KI\n"
00157 "-\n").getInitialState();
00158 maxLevel=level;
00159 moveCount=0;
00160 clock_start();
00161
00162 #ifndef SIMPLE_STATE_ONLY
00163 if(evalMode)
00164 {
00165 std::cerr << "evalMode" << std::endl;
00166 NumEffectState neState(state);
00167 HashEffectState hState(neState);
00168 EvalHashEffectState eState(hState);
00169
00170 Move lastMove=newMove(newPosition(4,4),newPosition(4,3),PROOK,
00171 PTYPE_EMPTY,false,BLACK);
00172
00173 if(withEffectMode)
00174 nextMoves<WHITE,EvalHashEffectState,false,true>(eState,0,lastMove);
00175 else
00176 nextMoves<WHITE,EvalHashEffectState,false,false>(eState,0,lastMove);
00177 }
00178 else if(hashMode)
00179 {
00180 std::cerr << "hashMode" << std::endl;
00181 NumEffectState neState(state);
00182 HashEffectState hState(neState);
00183
00184 Move lastMove=newMove(newPosition(4,4),newPosition(4,3),PROOK,
00185 PTYPE_EMPTY,false,BLACK);
00186 if(withEffectMode)
00187 nextMoves<WHITE,HashEffectState,false,true>(hState,0,lastMove);
00188 else
00189 nextMoves<WHITE,HashEffectState,false,false>(hState,0,lastMove);
00190 }
00191 else if(effectMode);
00192 {
00193 assert(effectMode);
00194
00195 std::cerr << "effectMode" << std::endl;
00196 NumEffectState neState(state);
00197 Move lastMove=newMove(newPosition(4,4),newPosition(4,3),PROOK,
00198 PTYPE_EMPTY,false,BLACK);
00199 if(withEffectMode)
00200 nextMoves<WHITE,NumEffectState,false,true>(neState,0,lastMove);
00201 else
00202 nextMoves<WHITE,NumEffectState,false,false>(neState,0,lastMove);
00203 }
00204 #if 0
00205 else
00206 if(boardBitMode){
00207 std::cerr << "boardBitEffectMode" << std::endl;
00208 typedef BoardBitEffect<SimpleState> effect_state_t;
00209 effect_state_t neState(state);
00210 Move lastMove=newMove(newPosition(4,4),newPosition(4,3),PROOK,
00211 PTYPE_EMPTY,false,BLACK);
00212 nextMoves<WHITE,effect_state_t,false,true>(neState,0,lastMove);
00213 }
00214 #endif
00215 #if 0
00216 else if(nullMode){
00217 std::cerr << "nullBoardEffectMode" << std::endl;
00218 typedef NullBoardEffect<SimpleState> effect_state_t;
00219 effect_state_t neState(state);
00220 Move lastMove=newMove(newPosition(4,4),newPosition(4,3),PROOK,
00221 PTYPE_EMPTY,false,BLACK);
00222 nextMoves<WHITE,effect_state_t,false,true>(neState,0,lastMove);
00223 }
00224 #endif
00225 else
00226 #else
00227 if(simpleMode){
00228 std::cerr << "nullBoardEffectMode" << std::endl;
00229 typedef SimpleState effect_state_t;
00230 effect_state_t neState(state);
00231 Move lastMove=newMove(newPosition(4,4),newPosition(4,3),PROOK,
00232 PTYPE_EMPTY,false,BLACK);
00233 nextMoves<WHITE,effect_state_t,false,true>(neState,0,lastMove);
00234 }
00235 #endif
00236 clock_stop("total", moveCount+1);
00237 std::cerr << "maxLevel=" << maxLevel << ",moveCount=" << moveCount
00238 << std::endl;
00239 }
00240
00241
00242
00243