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