00001
00002
00003 #ifndef EVAL_PIECE_PAIR_EVAL_TCC
00004 #define EVAL_PIECE_PAIR_EVAL_TCC
00005
00006 #include "osl/eval/ppair/piecePairEval.h"
00007 #include "osl/eval/ppair/piecePairAssert.h"
00008 #include "osl/container/pieceValues.h"
00009 #include "osl/pieceTable.h"
00010 #include "osl/oslConfig.h"
00011
00012 template <class Table>
00013 osl::eval::ppair::
00014 PiecePairEvalTableBase<Table>::PiecePairEvalTableBase(const SimpleState& state)
00015 {
00016 for (int i=0; i<Piece::SIZE; i++) {
00017 for (int j=i; j<Piece::SIZE; j++) {
00018 val += Table::Table.valueOf
00019 (PiecePairIndex::indexOfPieceNum(state, i),
00020 PiecePairIndex::indexOfPieceNum(state, j));
00021 }
00022 }
00023 }
00024
00025 template <class Table>
00026 bool& osl::eval::ppair::
00027 PiecePairEvalTableBase<Table>::initializationFlag()
00028 {
00029 static bool flag = false;
00030 return flag;
00031 }
00032
00033 template <class Table>
00034 bool osl::eval::ppair::
00035 PiecePairEvalTableBase<Table>::setUp(const char *filename)
00036 {
00037 bool& result = initializationFlag();
00038 result = Table::Table.setUp(filename);
00039 return result;
00040 }
00041
00042 template <class Table>
00043 bool osl::eval::ppair::
00044 PiecePairEvalTableBase<Table>::setUp()
00045 {
00046 std::string filename = OslConfig::home();
00047 filename += "/data/sibling-attack.pair";
00048 return setUp(filename.c_str());
00049 }
00050
00051 template <class Table>
00052 int osl::eval::ppair::PiecePairEvalTableBase<Table>::
00053 adjustPairs(const SimpleState& state,
00054 unsigned int new_index)
00055 {
00056 int diff = 0;
00057 for (int i=0; i<Piece::SIZE; i++)
00058 {
00059 const Piece p=state.getPieceOf(i);
00060 if(p.isOnBoard()){
00061 const unsigned int target =
00062 PiecePairIndex::indexOf(p);
00063
00064 diff += Table::Table.valueOf(target, new_index);
00065 }
00066 }
00067 diff += Table::Table.valueOf(new_index, new_index);
00068 return diff;
00069 }
00070
00071 template <class Table>
00072 int osl::eval::ppair::PiecePairEvalTableBase<Table>::
00073 adjustPairs(const SimpleState& state,
00074 unsigned int old_index, unsigned int new_index)
00075 {
00076 int diff = 0;
00077 for (int i=0; i<Piece::SIZE; i++)
00078 {
00079 const Piece p=state.getPieceOf(i);
00080 if(p.isOnBoard()){
00081 const unsigned int target =
00082 PiecePairIndex::indexOf(p);
00083 diff -= Table::Table.valueOf(target, old_index);
00084
00085 diff += Table::Table.valueOf(target, new_index);
00086 }
00087 }
00088 diff -= Table::Table.valueOf(old_index, new_index);
00089 diff += Table::Table.valueOf(new_index, new_index);
00090 return diff;
00091 }
00092
00093 template <class Table>
00094 int osl::eval::ppair::PiecePairEvalTableBase<Table>::
00095 adjustPairs(const SimpleState& state,
00096 unsigned int old_index, unsigned int old_index2,
00097 unsigned int new_index)
00098 {
00099 int diff = 0;
00100 for (int i=0;i<Piece::SIZE; i++)
00101 {
00102 const Piece p=state.getPieceOf(i);
00103 if(p.isOnBoard()){
00104 const unsigned int target =
00105 PiecePairIndex::indexOf(p);
00106 diff += Table::Table.valueOf(target, new_index);
00107 diff -= Table::Table.valueOf(target, old_index);
00108 diff -= Table::Table.valueOf(target, old_index2);
00109 }
00110 }
00111
00112 diff -= Table::Table.valueOf(old_index, new_index);
00113 diff -= Table::Table.valueOf(old_index2, new_index);
00114 diff += Table::Table.valueOf(old_index, old_index2);
00115
00116 diff += Table::Table.valueOf(new_index, new_index);
00117 return diff;
00118 }
00119
00120
00121 template <class Table>
00122 int osl::eval::ppair::PiecePairEvalTableBase<Table>::
00123 adjustPairsAfterMove(const SimpleState& state,
00124 unsigned int new_index)
00125 {
00126 int diff = 0;
00127 for (int i=0; i<Piece::SIZE; i++)
00128 {
00129 const Piece p=state.getPieceOf(i);
00130 if (p.isOnBoard()) {
00131 const unsigned int target =
00132 PiecePairIndex::indexOf(p);
00133 diff += Table::Table.valueOf(target, new_index);
00134 }
00135 }
00136 return diff;
00137 }
00138
00139 template <class Table>
00140 int osl::eval::ppair::PiecePairEvalTableBase<Table>::
00141 adjustPairsAfterMove(const SimpleState& state,
00142 unsigned int old_index, unsigned int new_index)
00143 {
00144 int diff = 0;
00145 for (int i=0; i<Piece::SIZE; i++)
00146 {
00147 const Piece p=state.getPieceOf(i);
00148 if(p.isOnBoard()){
00149 const unsigned int target =
00150 PiecePairIndex::indexOf(p);
00151 diff -= Table::Table.valueOf(target, old_index);
00152 diff += Table::Table.valueOf(target, new_index);
00153 }
00154 }
00155 diff -= Table::Table.valueOf(old_index, old_index);
00156 diff += Table::Table.valueOf(new_index, old_index);
00157 return diff;
00158 }
00159
00160 template <class Table>
00161 int osl::eval::ppair::PiecePairEvalTableBase<Table>::
00162 adjustPairsAfterMove(const SimpleState& state,
00163 unsigned int old_index, unsigned int old_index2,
00164 unsigned int new_index)
00165 {
00166 int diff = 0;
00167 for (int i=0;i<Piece::SIZE; i++)
00168 {
00169 const Piece p=state.getPieceOf(i);
00170 if(p.isOnBoard()){
00171 const unsigned int target =
00172 PiecePairIndex::indexOf(p);
00173 diff += Table::Table.valueOf(target, new_index);
00174 diff -= Table::Table.valueOf(target, old_index);
00175 diff -= Table::Table.valueOf(target, old_index2);
00176 }
00177 }
00178
00179 diff += Table::Table.valueOf(new_index, old_index);
00180 diff += Table::Table.valueOf(new_index, old_index2);
00181
00182 diff -= Table::Table.valueOf(old_index, old_index2);
00183 diff -= Table::Table.valueOf(old_index, old_index);
00184 diff -= Table::Table.valueOf(old_index2, old_index2);
00185 return diff;
00186 }
00187
00188 template <class Table>
00189 void osl::eval::ppair::PiecePairEvalTableBase<Table>::
00190 setValues(const SimpleState& state, container::PieceValues& values)
00191 {
00192 values.fill(0);
00193
00194 for (int i=0; i<Piece::SIZE; i++) {
00195 const bool i_is_king = (Piece_Table.getPtypeOf(i) == KING);
00196 for (int j=0; j<Piece::SIZE; j++) {
00197 if (i==j)
00198 continue;
00199 const bool j_is_king = (Piece_Table.getPtypeOf(j) == KING);
00200
00201 const int relation_value = Table::Table.valueOf
00202 (PiecePairIndex::indexOfPieceNum(state, i),
00203 PiecePairIndex::indexOfPieceNum(state, j));
00204 if (i_is_king && (! j_is_king))
00205 {
00206 values[j] += relation_value;
00207 }
00208 else
00209 {
00210 values[i] += relation_value;
00211 }
00212 }
00213 }
00214 for (int i=0; i<Piece::SIZE; i++)
00215 {
00216 values[i] /= 2;
00217
00218 const unsigned int index = PiecePairIndex::indexOfPieceNum(state, i);
00219 const int self_value = Table::Table.valueOf(index, index);
00220 values[i] += self_value;
00221 }
00222 }
00223
00224
00225
00226 template <class Eval, class Table>
00227 osl::eval::ppair::
00228 PiecePairEval<Eval,Table>::PiecePairEval(const SimpleState& state)
00229 : PiecePairEvalTableBase<Table>(state)
00230 {
00231 }
00232
00233 template <class Eval, class Table>
00234 int osl::eval::ppair::PiecePairEval<Eval,Table>::
00235 expect(const SimpleState& state, Move m) const
00236 {
00237 const Ptype ptype = m.ptype();
00238 const Position to = m.to();
00239 const Player player = state.getTurn();
00240 if (m.isDrop()) {
00241 piece_pair_assert(state.getPieceAt(to) == Piece::EMPTY());
00242 return roundUp(this->val + Eval::diffAfterDropMove(state, to, newPtypeO(player, ptype)));
00243 }
00244
00245 const Position from = m.from();
00246 piece_pair_assert(state.getPieceAt(from) != Piece::EMPTY());
00247 if (m.capturePtype() == PTYPE_EMPTY) {
00248 piece_pair_assert(state.getPieceAt(to) == Piece::EMPTY());
00249 return roundUp(this->val + Eval::diffAfterSimpleMove(state, from, to, m.promoteMask()));
00250 }
00251 piece_pair_assert(state.getPieceAt(to) != Piece::EMPTY());
00252 return roundUp(this->val + Eval::diffAfterCaptureMove(state, from, to, m.capturePtypeO(), m.promoteMask()));
00253 }
00254
00255 #endif
00256
00257
00258
00259