alphaBetaPlayer.cc
Go to the documentation of this file.
00001 /* alphaBetaPlayer.cc
00002  */
00003 #include "osl/game_playing/alphaBetaPlayer.h"
00004 #include "osl/game_playing/searchPlayer.tcc"
00005 #include "osl/search/alphaBeta2.h"
00006 #include "osl/search/alphaBeta3.h"
00007 #include "osl/search/simpleHashTable.h"
00008 #include "osl/eval/progressEval.h"
00009 #include "osl/eval/pieceEval.h"
00010 #include <iostream>
00011 
00012 #ifndef MINIMAL
00013 osl::game_playing::
00014 AlphaBeta2ProgressEvalPlayer::AlphaBeta2ProgressEvalPlayer()
00015 {
00016 }
00017 
00018 osl::game_playing::
00019 AlphaBeta2ProgressEvalPlayer::~AlphaBeta2ProgressEvalPlayer()
00020 {
00021 }
00022 
00023 osl::game_playing::ComputerPlayer* osl::game_playing::
00024 AlphaBeta2ProgressEvalPlayer::clone() const 
00025 {
00026   return cloneIt(*this);
00027 }
00028 
00029 const osl::search::MoveWithComment osl::game_playing::
00030 AlphaBeta2ProgressEvalPlayer::searchWithSecondsForThisMove(const GameState& gs, const search::TimeAssigned& org)
00031 {
00032   const MilliSeconds::Interval consumed
00033     = setUpTable(gs, pawnValueOfTurn<AlphaBeta2ProgressEval>(gs.state().turn()));
00034   const search::TimeAssigned msec(adjust(org, consumed));
00035   searcher.reset();
00036   try 
00037   {
00038     searcher.reset(new AlphaBeta2ProgressEval(gs.state(), *checkmate_ptr, table_ptr.get(),
00039                                               *recorder_ptr));
00040   }
00041   catch (std::bad_alloc&)
00042   {
00043     std::cerr << "panic. allocation of AlphaBeta2 failed\n";
00044   }
00045   return SearchPlayer::search<AlphaBeta2ProgressEval>(gs, msec);
00046 }
00047 
00048 bool osl::game_playing::
00049 AlphaBeta2ProgressEvalPlayer::isReasonableMove(const GameState& gs,
00050                                    Move move, int pawn_sacrifice)
00051 {
00052   setUpTable(gs, pawnValueOfTurn<AlphaBeta2ProgressEval>(gs.state().turn()));
00053   AlphaBeta2ProgressEval searcher(gs.state(), *checkmate_ptr, table_ptr.get(),
00054                                   *recorder_ptr);  
00055   return SearchPlayer::isReasonableMoveBySearch(searcher, move, pawn_sacrifice);
00056 }
00057 #endif
00058 
00059 /* ------------------------------------------------------------------------- */
00060 
00061 osl::game_playing::
00062 AlphaBeta2OpenMidEndingEvalPlayer::AlphaBeta2OpenMidEndingEvalPlayer()
00063 {
00064 }
00065 
00066 osl::game_playing::
00067 AlphaBeta2OpenMidEndingEvalPlayer::~AlphaBeta2OpenMidEndingEvalPlayer()
00068 {
00069 }
00070 
00071 osl::game_playing::ComputerPlayer* osl::game_playing::
00072 AlphaBeta2OpenMidEndingEvalPlayer::clone() const 
00073 {
00074   return cloneIt(*this);
00075 }
00076 
00077 const osl::search::MoveWithComment osl::game_playing::
00078 AlphaBeta2OpenMidEndingEvalPlayer::searchWithSecondsForThisMove(const GameState& gs, const search::TimeAssigned& org)
00079 {
00080   const MilliSeconds::Interval consumed = setUpTable(gs, pawnValueOfTurn<AlphaBeta2OpenMidEndingEval>(gs.state().turn()));
00081   const search::TimeAssigned msec(adjust(org, consumed));
00082   searcher.reset();
00083   try 
00084   {
00085     searcher.reset(new AlphaBeta2OpenMidEndingEval(gs.state(), *checkmate_ptr, table_ptr.get(),
00086                                           *recorder_ptr));
00087   }
00088   catch (std::bad_alloc&)
00089   {
00090     std::cerr << "panic. allocation of AlphaBeta2 failed\n";
00091   }
00092   return SearchPlayer::search<AlphaBeta2OpenMidEndingEval>(gs, msec);
00093 }
00094 
00095 const osl::search::MoveWithComment osl::game_playing::
00096 AlphaBeta2OpenMidEndingEvalPlayer::analyzeWithSeconds(const GameState& gs, const search::TimeAssigned& org,
00097                                                       search::AlphaBeta2SharedRoot& out)
00098 {
00099   const search::MoveWithComment
00100     result = searchWithSecondsForThisMove(gs, org);
00101   out = dynamic_cast<AlphaBeta2OpenMidEndingEval&>(*searcher).sharedRootInfo();
00102   return result;
00103 }
00104 
00105 bool osl::game_playing::
00106 AlphaBeta2OpenMidEndingEvalPlayer::isReasonableMove(const GameState& gs,
00107                                    Move move, int pawn_sacrifice)
00108 {
00109   setUpTable(gs, pawnValueOfTurn<AlphaBeta2OpenMidEndingEval>(gs.state().turn()));
00110   AlphaBeta2OpenMidEndingEval searcher(gs.state(), *checkmate_ptr, table_ptr.get(),
00111                                   *recorder_ptr);  
00112   return SearchPlayer::isReasonableMoveBySearch(searcher, move, pawn_sacrifice);
00113 }
00114 
00115 /* ------------------------------------------------------------------------- */
00116 
00117 #ifndef MINIMAL
00118 osl::game_playing::
00119 AlphaBeta3OpenMidEndingEvalPlayer::AlphaBeta3OpenMidEndingEvalPlayer()
00120 {
00121 }
00122 
00123 osl::game_playing::
00124 AlphaBeta3OpenMidEndingEvalPlayer::~AlphaBeta3OpenMidEndingEvalPlayer()
00125 {
00126 }
00127 
00128 osl::game_playing::ComputerPlayer* osl::game_playing::
00129 AlphaBeta3OpenMidEndingEvalPlayer::clone() const 
00130 {
00131   return cloneIt(*this);
00132 }
00133 
00134 const osl::search::MoveWithComment osl::game_playing::
00135 AlphaBeta3OpenMidEndingEvalPlayer::searchWithSecondsForThisMove(const GameState& gs, const search::TimeAssigned& org)
00136 {
00137   const MilliSeconds::Interval consumed = setUpTable(gs, pawnValueOfTurn<AlphaBeta3>(gs.state().turn()));
00138   const search::TimeAssigned msec(adjust(org, consumed));
00139   searcher.reset();
00140   try 
00141   {
00142     searcher.reset(new AlphaBeta3(gs.state(), *checkmate_ptr, table_ptr.get(),
00143                                   *recorder_ptr));
00144   }
00145   catch (std::bad_alloc&)
00146   {
00147     std::cerr << "panic. allocation of AlphaBeta3 failed\n";
00148   }
00149   return SearchPlayer::search<AlphaBeta3>(gs, msec);
00150 }
00151 
00152 bool osl::game_playing::
00153 AlphaBeta3OpenMidEndingEvalPlayer::isReasonableMove(const GameState& gs,
00154                                    Move move, int pawn_sacrifice)
00155 {
00156   setUpTable(gs, pawnValueOfTurn<AlphaBeta3>(gs.state().turn()));
00157   AlphaBeta3 searcher(gs.state(), *checkmate_ptr, table_ptr.get(),
00158                                   *recorder_ptr);  
00159   return SearchPlayer::isReasonableMoveBySearch(searcher, move, pawn_sacrifice);
00160 }
00161 #endif
00162 /* ------------------------------------------------------------------------- */
00163 // ;;; Local Variables:
00164 // ;;; mode:c++
00165 // ;;; c-basic-offset:2
00166 // ;;; End:
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines