00001 #define SIMPLE_STATE_ONLY
00002
00008 #include "osl/record/csaString.h"
00009 #include "osl/simpleState.h"
00010 #include "osl/pawnMaskState.h"
00011
00012 #ifndef SIMPLE_STATE_ONLY
00013 # include "osl/boardBitEffect.h"
00014 # include "osl/signatureEffect.h"
00015 # include "osl/numSimpleEffect.h"
00016 # include "osl/numEffectState.h"
00017 # include "osl/evalHashEffectState.h"
00018 #endif // SIMPLE_STAFF_ONLY
00019
00020 #ifdef PPAIR_PERF
00021 # include "osl/piecePairEval.h"
00022 # include "osl/pieceEval.h"
00023 #endif
00024
00025 #include "osl/player.h"
00026 #include "osl/move_generator/allMoves.h"
00027 #include "osl/move_generator/allMoves.tcc"
00028 #include "osl/move_action/store.h"
00029 #include "osl/applyMove.h"
00030 #include "osl/perfmon.h"
00031 #include <iostream>
00032 #include <time.h>
00033 #include <sys/time.h>
00034
00035 using namespace osl;
00036
00037 int moveCount;
00038 int dropCount;
00039 int maxLevel;
00040
00041 int maxVal=0;
00042
00043 #ifdef PPAIR_PERF
00044 bool noPair = false;
00045 bool piecePair = false;
00046 int value;
00047 #endif
00048
00049 template<Player P,typename State,bool isMoveEval>
00050 void nextMoves(State& state,int level);
00051
00052 template<class State, Player P,bool isMoveEval>
00053 struct DoUndoHelper{
00054 State& state;
00055 int level;
00056
00057 DoUndoHelper(State& s, int level) : state(s), level(level){}
00058 void operator()(Position p){
00059 nextMoves<P,State,isMoveEval>(state,level);
00060 }
00061 };
00062
00063 template<Player P,typename State>
00064 void callValWithMove(State& state,Move move,Int2Type<false>){
00065 }
00066
00067 template<Player P,typename State>
00068 void callValWithMove(State& state,Move move,Int2Type<true>){
00069 typename State::eval_t ev = state.getEval();
00070 const int ret = ev.template computeValWithMove<State,P>(state, move);
00071 if(ret>maxVal){maxVal=ret;}
00072 }
00073
00074
00075 template<Player P,typename State,bool isMoveEval>
00076 void nextMoves(State& state,int level){
00077 if(level>maxLevel) return;
00078 MoveVector moves;
00079 DoUndoHelper<State,PlayerTraits<P>::opponent,isMoveEval> helper(state, level+1);
00080 move_action::Store action(moves);
00081 typedef move_generator::AllMoves<State,move_action::Store> generate_t;
00082 generate_t::generateMoves(P,state,action);
00083 size_t size=moves.size();
00084 for(size_t i=0;i<size;i++){
00085 callValWithMove<P,State>(state,moves[i],Int2Type<isMoveEval>());
00086 moveCount++;
00087 #ifdef PPAIR_PERF
00088 const int prevValue = value;
00089 if (noPair)
00090 value += PieceEval::diffWithMove(state, moves[i]);
00091 else if (piecePair)
00092 value += PiecePairEval::diffWithMove(state, moves[i]);
00093 #endif
00094 ApplyMove<P>::doUndoMove(state,moves[i],helper);
00095 #ifdef PPAIR_PERF
00096 value = prevValue;
00097 #endif
00098 }
00099 }
00100
00101 #ifdef ENABLE_DIRECT_MODE
00102 template<Player P,typename State,bool isMoveEval>
00103 void nextMovesDirect(State& state,int level);
00104
00105 template<class State,Player P,bool isMoveEval>
00106 struct CallNextMoves{
00107 State& state;
00108 int level;
00109 CallNextMoves(State& s, int level) : state(s), level(level){}
00110
00111 void operator()(Position p){
00112 nextMovesDirect<P,State,isMoveEval>(state,level);
00113 }
00114 };
00115
00116 template<typename State,Player P,bool isMoveEval>
00117 struct DirectCallAction{
00118 State& state;
00119 int level;
00120 DirectCallAction(State& s, int level) : state(s), level(level){}
00121 typedef CallNextMoves<State,PlayerTraits<P>::opponent,isMoveEval> next_t;
00122 void receiveSimpleMove(Position from,Position to,Ptype ptype, bool isPromote,Player p){
00123
00124 moveCount++;
00125 next_t caller(state,level);
00126 ApplyDoUndoSimpleMove<P,State>::template doUndoSimpleMove<next_t>
00127 (state,from,to,promoteMask(isPromote),caller);
00128 }
00129 void receiveUnknownMove(Position from,Position to,Piece p1,Ptype ptype,bool isPromote,Player p){
00130 next_t caller(state,level);
00131 moveCount++;
00132 if(p1==PIECE_EMPTY)
00133 ApplyDoUndoSimpleMove<P,State>::template doUndoSimpleMove<next_t>
00134 (state,from,to,promoteMask(isPromote),caller);
00135 else
00136 ApplyDoUndoCaptureMove<P,State>::template doUndoCaptureMove<next_t>
00137 (state,from,to,p1,promoteMask(isPromote),caller);
00138 }
00139 void receiveDropMove(Position to,Ptype ptype,Player p){
00140 moveCount++;
00141 next_t caller(state, level);
00142 ApplyDoUndoDropMove<P,State>::template doUndoDropMove<next_t>(state,to,ptype,caller);
00143 }
00144 };
00145
00146 template<Player P,typename State,bool isMoveEval>
00147 void nextMovesDirect(State& state,int level){
00148 if(level>maxLevel) return;
00149 DirectCallAction<State,P,isMoveEval> action(state, level+1);
00150 typedef move_generator::AllMoves<State,DirectCallAction<State,P,isMoveEval> > generate_t;
00151 generate_t::template generateMoves<P>(state,action);
00152 }
00153 #endif
00154
00155 int main(int argc,char **argv){
00156 bool directMode=false;
00157 bool effectMode=false;
00158 bool hashMode=false;
00159 bool evalMode=false;
00160 bool evalMoveMode=false;
00161 bool simpleMode=false;
00162 bool boardBitMode=false;
00163 bool signatureMode=false;
00164 int level=3;
00165 extern char *optarg;
00166
00167 char c;
00168 while ((c = getopt(argc, argv, "l:dehpPEmsbS")) != EOF)
00169 {
00170 switch(c)
00171 {
00172 case 'l': level=atoi(optarg);
00173 break;
00174 case 'd': directMode=true;
00175 break;
00176 case 'e': effectMode=true;
00177 break;
00178 case 'h': hashMode=true;
00179 break;
00180 case 'E': evalMode=true;
00181 break;
00182 case 'm': evalMoveMode=true;
00183 break;
00184 case 's': simpleMode=true;
00185 break;
00186 case 'b': boardBitMode=true;
00187 break;
00188 case 'S': signatureMode=true;
00189 break;
00190 #ifdef PPAIR_PERF
00191 case 'p': noPair=true;
00192 break;
00193 case 'P': piecePair=true;
00194 break;
00195 #endif
00196 default:
00197 std::cerr << "unknown option\n";
00198 return 1;
00199 }
00200 }
00201 SimpleState state=CsaString(
00202 "P1+RY * * * * * * -KE-KY\n"
00203 "P2 * * * +GI * -KI-KI-OU *\n"
00204 "P3 * * +TO * * * -GI-FU-FU\n"
00205 "P4-FU * -UM * -FU * -FU * *\n"
00206 "P5 * * +GI * * -FU * +FU+FU\n"
00207 "P6+FU+OU+GI+FU+FU * +FU * *\n"
00208 "P7 * +FU * +KE * * * * *\n"
00209 "P8 * * * * * * * * * \n"
00210 "P9-RY * * * * * * * +KY\n"
00211 "P+00KA00KY00FU00FU00FU00FU\n"
00212 "P-00KI00KI00KE00KE00KY\n"
00213 "+\n").getInitialState();
00214 maxLevel=level;
00215 moveCount=0;
00216 dropCount=0;
00217 clock_start();
00218 #ifndef SIMPLE_STATE_ONLY
00219 if(evalMoveMode){
00220 std::cerr << evalMode << std::endl;
00221 NumEffectState neState(state);
00222 HashEffectState hState(neState);
00223 EvalHashEffectState eState(hState);
00224
00225 if(directMode){
00226 std::cerr << "directMode" << std::endl;
00227 std::cerr << "is not implemented yet" << std::endl;
00228 #ifdef ENABLE_DIRECT_MODE
00229 nextMovesDirect<BLACK,EvalHashEffectState,true>(eState,0);
00230 #endif
00231 }
00232 else{
00233 nextMoves<BLACK,EvalHashEffectState,true>(eState,0);
00234 }
00235 }
00236 else if(evalMode){
00237 std::cerr << "evalMode" << std::endl;
00238 NumEffectState neState(state);
00239 HashEffectState hState(neState);
00240 EvalHashEffectState eState(hState);
00241
00242 if(directMode){
00243 std::cerr << "directMode" << std::endl;
00244 #ifdef ENABLE_DIRECT_MODE
00245 nextMovesDirect<BLACK,EvalHashEffectState,false>(eState,0);
00246 #endif
00247 }
00248 else{
00249 nextMoves<BLACK,EvalHashEffectState,false>(eState,0);
00250 }
00251 }
00252 else if(hashMode){
00253 std::cerr << "hashMode" << std::endl;
00254 NumEffectState neState(state);
00255 HashEffectState hState(neState);
00256
00257 if(directMode){
00258 std::cerr << "directMode" << std::endl;
00259 #ifdef ENABLE_DIRECT_MODE
00260 nextMovesDirect<BLACK,HashEffectState,false>(hState,0);
00261 #endif
00262 }
00263 else{
00264 nextMoves<BLACK,HashEffectState,false>(hState,0);
00265 }
00266 }
00267 else if(effectMode){
00268 std::cerr << "effectMode" << std::endl;
00269 NumEffectState neState(state);
00270
00271 if(directMode){
00272 std::cerr << "directMode" << std::endl;
00273 #ifdef ENABLE_DIRECT_MODE
00274 nextMovesDirect<BLACK,NumEffectState,false>(neState,0);
00275 #endif
00276 }
00277 else{
00278 nextMoves<BLACK,NumEffectState,false>(neState,0);
00279 }
00280 }
00281 else
00282 #ifndef PPAIR_PERF
00283 if(signatureMode){
00284 std::cerr << "signatureMode" << std::endl;
00285 SimpleState sState(state);
00286 typedef SignatureEffect<BoardBitEffect<SimpleState> > state_t;
00287 state_t bState(sState);
00288
00289 if(directMode){
00290 std::cerr << "directMode" << std::endl;
00291 #ifdef ENABLE_DIRECT_MODE
00292 nextMovesDirect<BLACK,state_t,false>(bState,0);
00293 #endif
00294 }
00295 else{
00296 nextMoves<BLACK,state_t,false>(bState,0);
00297 }
00298 }
00299 else
00300 if(boardBitMode){
00301 std::cerr << "boardBitMode" << std::endl;
00302 SimpleState sState(state);
00303 typedef BoardBitEffect<SimpleState> state_t;
00304 state_t bState(sState);
00305
00306 if(directMode){
00307 std::cerr << "directMode" << std::endl;
00308 #ifdef ENABLE_DIRECT_MODE
00309 nextMovesDirect<BLACK,state_t,false>(bState,0);
00310 #endif
00311 }
00312 else{
00313 nextMoves<BLACK,state_t,false>(bState,0);
00314 }
00315 }
00316 else
00317 #endif
00318 #endif
00319 if(simpleMode){
00320 std::cerr << "simpleMode" << std::endl;
00321 SimpleState sState(state);
00322
00323 if(directMode){
00324 std::cerr << "directMode" << std::endl;
00325 #ifdef ENABLE_DIRECT_MODE
00326 nextMovesDirect<BLACK,SimpleState,false>(sState,0);
00327 #endif
00328 }
00329 else{
00330 nextMoves<BLACK,SimpleState,false>(sState,0);
00331 }
00332 }
00333 else{
00334 PawnMaskState pState(state);
00335
00336 if(directMode){
00337 std::cerr << "directMode" << std::endl;
00338 #ifdef ENABLE_DIRECT_MODE
00339 nextMovesDirect<BLACK,PawnMaskState,false>(pState,0);
00340 #endif
00341 }
00342 else
00343 {
00344 nextMoves<BLACK,PawnMaskState,false>(pState,0);
00345 }
00346 }
00347 clock_stop("total", moveCount+1);
00348 std::cerr << "maxLevel=" << maxLevel << ",moveCount=" << moveCount <<
00349 ",dropCount=" << dropCount << std::endl;
00350
00351 }
00352
00353
00354
00355