Value value_to_tt(Value v, int ply);
Value value_from_tt(Value v, int ply);
bool check_is_dangerous(const Position& pos, Move move, Value futilityBase, Value beta);
- bool allows(const Position& pos, Move first, Move second);
bool refutes(const Position& pos, Move first, Move second);
string uci_pv(const Position& pos, int depth, Value alpha, Value beta);
else
{
// The null move failed low, which means that we may be faced with
- // some kind of threat. If the previous move was reduced, check if
- // the move that refuted the null move was somehow connected to the
- // move which was reduced. If a connection is found, return a fail
+ // some kind of threat. If the previous move was reduced return a fail
// low score (which will cause the reduced move to fail high in the
// parent node, which will trigger a re-search with full depth).
- threatMove = (ss+1)->currentMove;
-
if ( depth < 5 * ONE_PLY
&& (ss-1)->reduction
- && threatMove != MOVE_NONE
- && allows(pos, (ss-1)->currentMove, threatMove))
+ && nullValue < beta - Value(128))
return alpha;
+
+ threatMove = (ss+1)->currentMove;
}
}
}
- // allows() tests whether the 'first' move at previous ply somehow makes the
- // 'second' move possible, for instance if the moving piece is the same in
- // both moves. Normally the second move is the threat (the best move returned
- // from a null search that fails low).
-
- bool allows(const Position& pos, Move first, Move second) {
-
- assert(is_ok(first));
- assert(is_ok(second));
- assert(color_of(pos.piece_on(from_sq(second))) == ~pos.side_to_move());
- assert(color_of(pos.piece_on(to_sq(first))) == ~pos.side_to_move());
-
- Square m1from = from_sq(first);
- Square m2from = from_sq(second);
- Square m1to = to_sq(first);
- Square m2to = to_sq(second);
-
- // The piece is the same or second's destination was vacated by the first move
- if (m1to == m2from || m2to == m1from)
- return true;
-
- // Second one moves through the square vacated by first one
- if (between_bb(m2from, m2to) & m1from)
- return true;
-
- // Second's destination is defended by the first move's piece
- Bitboard m1att = pos.attacks_from(pos.piece_on(m1to), m1to, pos.pieces() ^ m2from);
- if (m1att & m2to)
- return true;
-
- // Second move gives a discovered check through the first's checking piece
- if (m1att & pos.king_square(pos.side_to_move()))
- {
- assert(between_bb(m1to, pos.king_square(pos.side_to_move())) & m2from);
- return true;
- }
-
- return false;
- }
-
-
// refutes() tests whether a 'first' move is able to defend against a 'second'
// opponent's move. In this case will not be pruned. Normally the second move
// is the threat (the best move returned from a null search that fails low).