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 {
00070 Store store(moves);
00071 if (isAttack)
00072 {
00073 typedef SafeFilter<P,typename State::effect_state_t,Store> action_t;
00074 action_t safeAction(state,store);
00075 const Position opKingPosition
00076 =state.template getKingPosition<PlayerTraits<P>::opponent>();
00077 #if 1
00078 if (state.hasEffectBy(P,opKingPosition))
00079 return;
00080 #else
00081 assert(!state.hasEffectBy(P,opKingPosition));
00082 #endif
00083 if(withEffect)
00084 AddEffectWithEffect<typename State::effect_state_t,action_t>::
00085 generateMoves(P,(effect_t)state,opKingPosition,safeAction);
00086 #if 1
00087 else
00088 AddEffect<typename State::effect_state_t,action_t>::
00089 generateMoves(P,state,opKingPosition,safeAction);
00090 #endif
00091 }
00092 else
00093 {
00094 assert(!state.hasEffectBy(P,state.template getKingPosition<PlayerTraits<P>::opponent>()));
00095
00096 Escape<P,typename State::effect_state_t,Store>::
00097 generateKingEscape((effect_t)state, lastMove,store);
00098 }
00099 }
00100 size_t size=moves.size();
00101 for(size_t i=0;i<size;i++){
00102
00103 moveCount++;
00104 helper.move=moves[i];
00105 ApplyMove<P>::doUndoMove(state,moves[i],helper);
00106 }
00107 }
00108
00109 int main(int argc,char **argv){
00110 bool effectMode=false;
00111 bool hashMode=false;
00112 bool evalMode=false;
00113 bool nullMode=false;
00114 bool withEffectMode=false;
00115 bool simpleMode=false;
00116 bool boardBitMode=false;
00117 int level=3;
00118 extern char *optarg;
00119
00120 char c;
00121 while ((c = getopt(argc, argv, "l:dehEnwsb")) != EOF)
00122 {
00123 switch(c)
00124 {
00125 case 'l': level=atoi(optarg);
00126 break;
00127 case 'e': effectMode=true;
00128 break;
00129 case 'h': hashMode=true;
00130 break;
00131 case 'E': evalMode=true;
00132 break;
00133 case 'n': nullMode=true;
00134 break;
00135 case 'w': withEffectMode=true;
00136 break;
00137 case 's': simpleMode=true;
00138 break;
00139 case 'b': boardBitMode=true;
00140 break;
00141 default:
00142 std::cerr << "unknown option\n";
00143 return 1;
00144 }
00145 }
00146 SimpleState state=CsaString(
00147 "P1-KY * * * -KY * -FU-KE * \n"
00148 "P2 * * * * -OU * * * * \n"
00149 "P3 * * * -FU-FU+RY * * -KY\n"
00150 "P4-FU * * -GI * * * * * \n"
00151 "P5 * * * * * * * * * \n"
00152 "P6+FU * * +RY * * +FU * * \n"
00153 "P7 * +FU * +FU+FU+FU * * * \n"
00154 "P8 * * +OU * -TO * * * * \n"
00155 "P9+KY * * * * * * +KE * \n"
00156 "P+00KI00GI00GI00GI00KE00KE00FU00FU00FU00KI\n"
00157 "P-00KA00KA00KI00FU00FU00FU00FU00KI\n"
00158 "-\n").getInitialState();
00159 maxLevel=level;
00160 moveCount=0;
00161 clock_start();
00162
00163 #ifndef SIMPLE_STATE_ONLY
00164 if(evalMode)
00165 {
00166 std::cerr << "evalMode" << std::endl;
00167 NumEffectState neState(state);
00168 HashEffectState hState(neState);
00169 EvalHashEffectState eState(hState);
00170
00171 Move lastMove=newMove(newPosition(4,4),newPosition(4,3),PROOK,
00172 PTYPE_EMPTY,false,BLACK);
00173
00174 if(withEffectMode)
00175 nextMoves<WHITE,EvalHashEffectState,false,true>(eState,0,lastMove);
00176 else
00177 nextMoves<WHITE,EvalHashEffectState,false,false>(eState,0,lastMove);
00178 }
00179 else if(hashMode)
00180 {
00181 std::cerr << "hashMode" << std::endl;
00182 NumEffectState neState(state);
00183 HashEffectState hState(neState);
00184
00185 Move lastMove=newMove(newPosition(4,4),newPosition(4,3),PROOK,
00186 PTYPE_EMPTY,false,BLACK);
00187 if(withEffectMode)
00188 nextMoves<WHITE,HashEffectState,false,true>(hState,0,lastMove);
00189 else
00190 nextMoves<WHITE,HashEffectState,false,false>(hState,0,lastMove);
00191 }
00192 else if(effectMode);
00193 {
00194 assert(effectMode);
00195
00196 std::cerr << "effectMode" << std::endl;
00197 NumEffectState neState(state);
00198 Move lastMove=newMove(newPosition(4,4),newPosition(4,3),PROOK,
00199 PTYPE_EMPTY,false,BLACK);
00200 if(withEffectMode)
00201 nextMoves<WHITE,NumEffectState,false,true>(neState,0,lastMove);
00202 else
00203 nextMoves<WHITE,NumEffectState,false,false>(neState,0,lastMove);
00204 }
00205 #if 0
00206 else
00207 if(boardBitMode){
00208 std::cerr << "boardBitEffectMode" << std::endl;
00209 typedef BoardBitEffect<SimpleState> effect_state_t;
00210 effect_state_t neState(state);
00211 Move lastMove=newMove(newPosition(4,4),newPosition(4,3),PROOK,
00212 PTYPE_EMPTY,false,BLACK);
00213 nextMoves<WHITE,effect_state_t,false,true>(neState,0,lastMove);
00214 }
00215 #endif
00216 #if 0
00217 else if(nullMode){
00218 std::cerr << "nullBoardEffectMode" << std::endl;
00219 typedef NullBoardEffect<SimpleState> effect_state_t;
00220 effect_state_t neState(state);
00221 Move lastMove=newMove(newPosition(4,4),newPosition(4,3),PROOK,
00222 PTYPE_EMPTY,false,BLACK);
00223 nextMoves<WHITE,effect_state_t,false,true>(neState,0,lastMove);
00224 }
00225 #endif
00226 else
00227 #else
00228 if(simpleMode){
00229 std::cerr << "nullBoardEffectMode" << std::endl;
00230 typedef SimpleState effect_state_t;
00231 effect_state_t neState(state);
00232 Move lastMove=newMove(newPosition(4,4),newPosition(4,3),PROOK,
00233 PTYPE_EMPTY,false,BLACK);
00234 nextMoves<WHITE,effect_state_t,false,true>(neState,0,lastMove);
00235 }
00236 #endif
00237 clock_stop("total", moveCount+1);
00238 std::cerr << "maxLevel=" << maxLevel << ",moveCount=" << moveCount
00239 << std::endl;
00240 }
00241
00242
00243
00244