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