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