summary |
shortlog |
log |
commit | commitdiff |
tree
raw |
patch |
inline | side by side (from parent 1:
be2925b)
No functional change.
Signed-off-by: Marco Costalba <mcostalba@gmail.com>
-MovePicker::MovePicker(const Position& p, Move ttm, const History& h, int parentCapture)
+MovePicker::MovePicker(const Position& p, Move ttm, const History& h, PieceType parentCapture)
: pos(p), H(h) {
assert (!pos.in_check());
// In ProbCut we consider only captures better than parent's move
: pos(p), H(h) {
assert (!pos.in_check());
// In ProbCut we consider only captures better than parent's move
- captureThreshold = parentCapture;
+ captureThreshold = piece_value_midgame(Piece(parentCapture));
phasePtr = ProbCutTable;
if ( ttm != MOVE_NONE
phasePtr = ProbCutTable;
if ( ttm != MOVE_NONE
for (MoveStack* cur = moves; cur != lastMove; cur++)
{
m = cur->move;
for (MoveStack* cur = moves; cur != lastMove; cur++)
{
m = cur->move;
- cur->score = pos.midgame_value_of_piece_on(move_to(m))
+ cur->score = piece_value_midgame(pos.piece_on(move_to(m)))
- pos.type_of_piece_on(move_from(m));
if (move_is_promotion(m))
- pos.type_of_piece_on(move_from(m));
if (move_is_promotion(m))
if ((seeScore = pos.see_sign(m)) < 0)
cur->score = seeScore - History::MaxValue; // Be sure we are at the bottom
else if (pos.move_is_capture(m))
if ((seeScore = pos.see_sign(m)) < 0)
cur->score = seeScore - History::MaxValue; // Be sure we are at the bottom
else if (pos.move_is_capture(m))
- cur->score = pos.midgame_value_of_piece_on(move_to(m))
+ cur->score = piece_value_midgame(pos.piece_on(move_to(m)))
- pos.type_of_piece_on(move_from(m)) + History::MaxValue;
else
cur->score = H.value(pos.piece_on(move_from(m)), move_to(m));
- pos.type_of_piece_on(move_from(m)) + History::MaxValue;
else
cur->score = H.value(pos.piece_on(move_from(m)), move_to(m));
public:
MovePicker(const Position&, Move, Depth, const History&, SearchStack*, Value);
MovePicker(const Position&, Move, Depth, const History&, Square recaptureSq);
public:
MovePicker(const Position&, Move, Depth, const History&, SearchStack*, Value);
MovePicker(const Position&, Move, Depth, const History&, Square recaptureSq);
- MovePicker(const Position&, Move, const History&, int parentCapture);
+ MovePicker(const Position&, Move, const History&, PieceType parentCapture);
Move get_next_move();
private:
Move get_next_move();
private:
Score Position::PieceSquareTable[16][64];
// Material values arrays, indexed by Piece
Score Position::PieceSquareTable[16][64];
// Material values arrays, indexed by Piece
-const Value Position::PieceValueMidgame[17] = {
+const Value PieceValueMidgame[17] = {
VALUE_ZERO,
PawnValueMidgame, KnightValueMidgame, BishopValueMidgame,
RookValueMidgame, QueenValueMidgame, VALUE_ZERO,
VALUE_ZERO,
PawnValueMidgame, KnightValueMidgame, BishopValueMidgame,
RookValueMidgame, QueenValueMidgame, VALUE_ZERO,
RookValueMidgame, QueenValueMidgame
};
RookValueMidgame, QueenValueMidgame
};
-const Value Position::PieceValueEndgame[17] = {
+const Value PieceValueEndgame[17] = {
VALUE_ZERO,
PawnValueEndgame, KnightValueEndgame, BishopValueEndgame,
RookValueEndgame, QueenValueEndgame, VALUE_ZERO,
VALUE_ZERO,
PawnValueEndgame, KnightValueEndgame, BishopValueEndgame,
RookValueEndgame, QueenValueEndgame, VALUE_ZERO,
RookValueEndgame, QueenValueEndgame
};
RookValueEndgame, QueenValueEndgame
};
-// Material values array used by SEE, indexed by PieceType
-const Value Position::seeValues[] = {
- VALUE_ZERO,
- PawnValueMidgame, KnightValueMidgame, BishopValueMidgame,
- RookValueMidgame, QueenValueMidgame, QueenValueMidgame*10
-};
-
// Early return if SEE cannot be negative because captured piece value
// is not less then capturing one. Note that king moves always return
// here because king midgame value is set to 0.
// Early return if SEE cannot be negative because captured piece value
// is not less then capturing one. Note that king moves always return
// here because king midgame value is set to 0.
- if (midgame_value_of_piece_on(to) >= midgame_value_of_piece_on(from))
+ if (piece_value_midgame(piece_on(to)) >= piece_value_midgame(piece_on(from)))
stm = opposite_color(color_of_piece_on(from));
stmAttackers = attackers & pieces_of_color(stm);
if (!stmAttackers)
stm = opposite_color(color_of_piece_on(from));
stmAttackers = attackers & pieces_of_color(stm);
if (!stmAttackers)
- return seeValues[capturedType];
+ return PieceValueMidgame[capturedType];
// The destination square is defended, which makes things rather more
// difficult to compute. We proceed by building up a "swap list" containing
// The destination square is defended, which makes things rather more
// difficult to compute. We proceed by building up a "swap list" containing
// destination square, where the sides alternately capture, and always
// capture with the least valuable piece. After each capture, we look for
// new X-ray attacks from behind the capturing piece.
// destination square, where the sides alternately capture, and always
// capture with the least valuable piece. After each capture, we look for
// new X-ray attacks from behind the capturing piece.
- swapList[0] = seeValues[capturedType];
+ swapList[0] = PieceValueMidgame[capturedType];
capturedType = type_of_piece_on(from);
do {
capturedType = type_of_piece_on(from);
do {
// Add the new entry to the swap list
assert(slIndex < 32);
// Add the new entry to the swap list
assert(slIndex < 32);
- swapList[slIndex] = -swapList[slIndex - 1] + seeValues[capturedType];
+ swapList[slIndex] = -swapList[slIndex - 1] + PieceValueMidgame[capturedType];
slIndex++;
// Remember the value of the capturing piece, and change the side to
slIndex++;
// Remember the value of the capturing piece, and change the side to
Color color_of_piece_on(Square s) const;
bool square_is_empty(Square s) const;
bool square_is_occupied(Square s) const;
Color color_of_piece_on(Square s) const;
bool square_is_empty(Square s) const;
bool square_is_occupied(Square s) const;
- Value midgame_value_of_piece_on(Square s) const;
- Value endgame_value_of_piece_on(Square s) const;
// Side to move
Color side_to_move() const;
// Side to move
Color side_to_move() const;
// Static exchange evaluation
int see(Move m) const;
int see_sign(Move m) const;
// Static exchange evaluation
int see(Move m) const;
int see_sign(Move m) const;
- static int see_value(PieceType pt);
// Accessing hash keys
Key get_key() const;
// Accessing hash keys
Key get_key() const;
static Key zobSideToMove;
static Score PieceSquareTable[16][64];
static Key zobExclusion;
static Key zobSideToMove;
static Score PieceSquareTable[16][64];
static Key zobExclusion;
- static const Value seeValues[8];
- static const Value PieceValueMidgame[17];
- static const Value PieceValueEndgame[17];
};
inline int64_t Position::nodes_searched() const {
};
inline int64_t Position::nodes_searched() const {
return !square_is_empty(s);
}
return !square_is_empty(s);
}
-inline Value Position::midgame_value_of_piece_on(Square s) const {
- return PieceValueMidgame[piece_on(s)];
-}
-
-inline Value Position::endgame_value_of_piece_on(Square s) const {
- return PieceValueEndgame[piece_on(s)];
-}
-
inline Color Position::side_to_move() const {
return sideToMove;
}
inline Color Position::side_to_move() const {
return sideToMove;
}
return !(pieces(PAWN, opposite_color(c)) & attack_span_mask(c, s));
}
return !(pieces(PAWN, opposite_color(c)) & attack_span_mask(c, s));
}
-inline int Position::see_value(PieceType pt) {
- return seeValues[pt];
-}
-
inline Key Position::get_key() const {
return st->key;
}
inline Key Position::get_key() const {
return st->key;
}
if ( captureOrPromotion
&& pos.type_of_piece_on(move_to(m)) != PAWN
&& ( pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK)
if ( captureOrPromotion
&& pos.type_of_piece_on(move_to(m)) != PAWN
&& ( pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK)
- - pos.midgame_value_of_piece_on(move_to(m)) == VALUE_ZERO)
+ - piece_value_midgame(pos.piece_on(move_to(m))) == VALUE_ZERO)
&& !move_is_special(m))
{
result += PawnEndgameExtension[PvNode];
&& !move_is_special(m))
{
result += PawnEndgameExtension[PvNode];
assert(rdepth >= ONE_PLY);
assert(rdepth >= ONE_PLY);
- MovePicker mp(pos, ttMove, H, Position::see_value(pos.captured_piece_type()));
+ MovePicker mp(pos, ttMove, H, pos.captured_piece_type());
CheckInfo ci(pos);
while ((move = mp.get_next_move()) != MOVE_NONE)
CheckInfo ci(pos);
while ((move = mp.get_next_move()) != MOVE_NONE)
&& !pos.move_is_passed_pawn_push(move))
{
futilityValue = futilityBase
&& !pos.move_is_passed_pawn_push(move))
{
futilityValue = futilityBase
- + pos.endgame_value_of_piece_on(move_to(move))
+ + piece_value_endgame(pos.piece_on(move_to(move)))
+ (move_is_ep(move) ? PawnValueEndgame : VALUE_ZERO);
if (futilityValue < alpha)
+ (move_is_ep(move) ? PawnValueEndgame : VALUE_ZERO);
if (futilityValue < alpha)
while (b)
{
victimSq = pop_1st_bit(&b);
while (b)
{
victimSq = pop_1st_bit(&b);
- futilityValue = futilityBase + pos.endgame_value_of_piece_on(victimSq);
+ futilityValue = futilityBase + piece_value_endgame(pos.piece_on(victimSq));
// Note that here we generate illegal "double move"!
if ( futilityValue >= beta
// Note that here we generate illegal "double move"!
if ( futilityValue >= beta
// Case 2: If the threatened piece has value less than or equal to the
// value of the threatening piece, don't prune moves which defend it.
if ( pos.move_is_capture(threat)
// Case 2: If the threatened piece has value less than or equal to the
// value of the threatening piece, don't prune moves which defend it.
if ( pos.move_is_capture(threat)
- && ( pos.midgame_value_of_piece_on(tfrom) >= pos.midgame_value_of_piece_on(tto)
+ && ( piece_value_midgame(pos.piece_on(tfrom)) >= piece_value_midgame(pos.piece_on(tto))
|| pos.type_of_piece_on(tfrom) == KING)
&& pos.move_attacks_square(m, tto))
return true;
|| pos.type_of_piece_on(tfrom) == KING)
&& pos.move_attacks_square(m, tto))
return true;
const Value QueenValueMidgame = Value(0x9D9);
const Value QueenValueEndgame = Value(0x9FE);
const Value QueenValueMidgame = Value(0x9D9);
const Value QueenValueEndgame = Value(0x9FE);
+extern const Value PieceValueMidgame[17];
+extern const Value PieceValueEndgame[17];
+
+inline Value piece_value_midgame(Piece p) {
+ return PieceValueMidgame[p];
+}
+
+inline Value piece_value_endgame(Piece p) {
+ return PieceValueEndgame[p];
+}
+
inline Value value_mate_in(int ply) {
return VALUE_MATE - ply;
}
inline Value value_mate_in(int ply) {
return VALUE_MATE - ply;
}