00001
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
00164
00165
00166