00001
00002
00003 #ifndef EVAL_PROGRESSEVAL_H
00004 #define EVAL_PROGRESSEVAL_H
00005
00006
00007
00008 #include "osl/effect_util/pin.h"
00009 #include "osl/eval/pieceEval.h"
00010 #include "osl/eval/minorPieceBonus.h"
00011
00012 #ifdef EXPERIMENTAL_EVAL
00013 # include "osl/eval/experimental/midgameEval.h"
00014 #else
00015 # include "osl/eval/ppair/piecePairPieceEval.h"
00016 #endif
00017 #include "osl/eval/endgame/attackDefense.h"
00018 #include "osl/eval/mobilityTable.h"
00019 #include "osl/progress/effect5x3.h"
00020 #include "osl/progress/effect5x3d.h"
00021 #include "osl/progress/progress32.h"
00022 #include "osl/mobility/rookMobility.h"
00023 #include "osl/mobility/bishopMobility.h"
00024 #include "osl/mobility/lanceMobility.h"
00025 #include "osl/state/numEffectState.h"
00026 #include <boost/static_assert.hpp>
00027
00028 namespace osl
00029 {
00030 namespace eval
00031 {
00032 struct ProgressDebugInfo
00033 {
00034 int eval, opening, endgame;
00035 int progress, progress_bonus;
00036 int progress_independent_bonus, progress_dependent_bonus;
00037 int minor_piece_bonus;
00038
00039
00040 int black_danger, black_defense, white_danger, white_defense;
00041
00042 int mobility_bonus, two_rook_bonus, knight_check_bonus, rook_rank_bonus,
00043 enter_king_bonus, middle_king_bonus, silver_penalty, gold_penalty;
00044
00045 int king8_attack_bonus, pin_bonus;
00046
00047 MinorPieceDebugInfo minor_piece_bonus_info;
00048 };
00049
00053 template <class OpeningEval>
00054 class ProgressEvalGeneral
00055 {
00056 public:
00057 typedef OpeningEval opening_eval_t;
00058 typedef endgame::AttackDefense endgame_eval_t;
00059 typedef progress::Effect5x3 progress_t;
00060 typedef progress::Effect5x3d defense_t;
00061 private:
00062 opening_eval_t opening_eval;
00063 endgame_eval_t endgame_eval;
00064 progress_t current_progress;
00065 defense_t defense_effect;
00066 MinorPieceBonus minor_piece_bonus;
00067
00068
00069 mutable CArray<PieceMask, 2> pin_mask;
00070 CArray2d<int, 2, DR+1> can_check_pieces;
00071 int progress_independent_bonus;
00072 int progress_dependent_bonus;
00073 int major_pieces;
00074 enum{
00075 INVALID=EvalTraits<BLACK>::MAX_VALUE+1,
00076 };
00077 mutable int cache;
00078
00079 static CArray<int, PTYPEO_SIZE> capture_values;
00080
00081 template<Player P, Ptype PTYPE, Direction Dir, Direction LongDir>
00082 void initializeCheckPieceDir(const NumEffectState &state, int count);
00083 template <Player P, Ptype PTYPE>
00084 void initializeCheckPiece(const NumEffectState &state);
00085 static void setUpInternal();
00086 public:
00087 ProgressEvalGeneral(const NumEffectState& state);
00088 void changeTurn() {}
00089 static bool initialized()
00090 {
00091 return opening_eval_t::initialized();
00092 }
00093 static bool setUp(const char *filename)
00094 {
00095 setUpInternal();
00096 return opening_eval_t::setUp(filename);
00097 }
00098 static bool setUp()
00099 {
00100 setUpInternal();
00101 return opening_eval_t::setUp();
00102 }
00103
00105 static const int ROUND_UP = 64;
00107 static int attackDefenseBonusT16(Progress16 black, Progress16 white,
00108 Progress16 black_defense,
00109 Progress16 white_defense)
00110 {
00111 return
00112 (white.value() * 2 - white_defense.value()
00113 - black.value() * 2 + black_defense.value())
00114 * 3200 / 2;
00115 }
00116 static int composeValue(int value_opening, int value_endgame,
00117 Progress16 progress16,
00118 Progress16 black,
00119 Progress16 white,
00120 Progress16 black_defense,
00121 Progress16 white_defense,
00122 int minor_piece_bonus,
00123 int progress_independent_bonus,
00124 int progress_dependent_bonus)
00125 {
00126 BOOST_STATIC_ASSERT(((PtypeEvalTraits<BISHOP>::val * 2 + PtypeEvalTraits<PAWN>::val) % 16) == 0);
00127 BOOST_STATIC_ASSERT((PtypeEvalTraits<PAWN>::val % 32) == 0);
00128 assert(progress16.isValid());
00129 assert(black.isValid());
00130 assert(white.isValid());
00131 assert(value_opening % 2 == 0);
00132 assert(value_endgame % 2 == 0);
00133
00134
00135
00136
00137 int result = value_opening*16 +
00138 progress16.value() * (value_endgame-value_opening +
00139 (attackDefenseBonusT16(black, white,
00140 black_defense,
00141 white_defense))
00142 / 16);
00143
00144 result += progress_independent_bonus;
00145 result += minor_piece_bonus;
00146 result += progress_dependent_bonus;
00147 result &= ~(ROUND_UP-1);
00148 assert(result % 2 == 0);
00149 return result;
00150 }
00151 const Progress16 progress16() const { return current_progress.progress16(); }
00152 const Progress16 progress16bonus(Player p) const {
00153 return current_progress.progress16bonus(p);
00154 }
00155 void invalidateCache(){
00156 cache=INVALID;
00157 }
00158 int value() const
00159 {
00160 if(cache==INVALID)
00161 cache = composeValue(
00162 openingValue(),
00163 endgame_eval.value(),
00164 progress16(),
00165 current_progress.progress16bonus(BLACK),
00166 current_progress.progress16bonus(WHITE),
00167 defense_effect.progress16(BLACK),
00168 defense_effect.progress16(WHITE),
00169 minor_piece_bonus.value(
00170 progress16(),
00171 progress16bonus(BLACK),
00172 progress16bonus(WHITE)),
00173 progress_independent_bonus,
00174 progress_dependent_bonus);
00175
00176 return cache;
00177 }
00178 const Progress32 progress32() const {
00179 return Progress32(current_progress.progress16(BLACK).value()
00180 + current_progress.progress16(WHITE).value());
00181 }
00182 static void setValues(const SimpleState&, Progress16 progress16,
00183 container::PieceValues&);
00184 static void setValues(const SimpleState& s, container::PieceValues& o);
00185
00186 int expect(const NumEffectState& state, Move move) const;
00187 void update(const NumEffectState& new_state, Move last_move);
00188 template <Player p>
00189 int calculateAttackBonusEach(const NumEffectState& state) const;
00190 template <Player Attack, Direction Dir>
00191 int calculateAttackBonusOne(const NumEffectState& state) const;
00192 int calculateKnightCheck(const NumEffectState& state) const;
00193 template <osl::Player P>
00194 int calculateKnightCheckEach(const NumEffectState& state) const;
00195 template <Player p>
00196 int calculateEnterKingBonus(const NumEffectState& state) const ;
00197 template <Player p>
00198 int calculateMiddleKingBonus(const NumEffectState& state) const;
00199 int calculateRookRankBonus(const NumEffectState& state) const;
00200
00201 public:
00202 static int infty()
00203 {
00204 assert(endgame_eval_t::infty() <= opening_eval_t::infty());
00205
00206 return composeValue(opening_eval_t::infty(), 0, Progress16(0),
00207 Progress16(0), Progress16(0), Progress16(0),
00208 Progress16(0), 0, 0, 0);
00209 }
00210
00211 static int captureValue(PtypeO ptypeO)
00212 {
00213 return capture_values[ptypeOIndex(ptypeO)];
00214 }
00215 static int seeScale()
00216 {
00217 return captureValue(newPtypeO(WHITE,PAWN))
00218 / PieceEval::captureValue(newPtypeO(WHITE,PAWN));
00219 }
00220
00221 const PieceMask pins(Player player) const {
00222 return pin_mask[playerToIndex(player)];
00223 }
00224
00225 int minorPieceValue() const {
00226 return minor_piece_bonus.value(progress16(),
00227 progress16bonus(BLACK),
00228 progress16bonus(WHITE));
00229 }
00230 int openingValue() const { return opening_eval.value(); }
00231 int endgameValue() const { return endgame_eval.value(); }
00232 ProgressDebugInfo debugInfo(const NumEffectState& state) const;
00233
00234
00235
00236 int calculatePinBonus(const NumEffectState& state) const;
00237 int calculateMobilityBonus(const NumEffectState& state) const;
00238 int calculateAttackRooks(const NumEffectState& state) const;
00239 int calculateAttackBonus(const NumEffectState& state) const;
00240 int calculateSilverPenalty(const NumEffectState& state) const;
00241 int calculateGoldPenalty(const NumEffectState& state) const;
00242
00243 int attackDefenseBonus() const
00244 {
00245 return progress16().value()
00246 * attackDefenseBonusT16(current_progress.progress16bonus(BLACK),
00247 current_progress.progress16bonus(WHITE),
00248 defense_effect.progress16(BLACK),
00249 defense_effect.progress16(WHITE))
00250 / 16;
00251 }
00252 };
00253
00254 #ifdef EXPERIMENTAL_EVAL
00255 typedef experimental::MidgameEval progress_eval_opening_t;
00256 #else
00257 typedef PiecePairPieceEval progress_eval_opening_t;
00258 #endif
00259 class ProgressEval : public ProgressEvalGeneral<progress_eval_opening_t>
00260 {
00261 public:
00262 explicit ProgressEval(const NumEffectState& state)
00263 : ProgressEvalGeneral<progress_eval_opening_t>(state)
00264 {
00265 }
00266 };
00267 }
00268 }
00269
00270 #endif
00271
00272
00273
00274