if (moveIsCheck && pos.see_sign(m) >= 0)
result += CheckExtension[PvNode];
- if (pos.type_of_piece_on(move_from(m)) == PAWN)
+ if (piece_type(pos.piece_on(move_from(m))) == PAWN)
{
Color c = pos.side_to_move();
if (relative_rank(c, move_to(m)) == RANK_7)
}
if ( captureOrPromotion
- && pos.type_of_piece_on(move_to(m)) != PAWN
+ && piece_type(pos.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];
NodesSincePoll = 0;
current_search_time(get_system_time());
Limits = limits;
- TimeMgr.init(Limits, pos.startpos_ply_counter());
+ TimeMgr.init(Limits, pos.full_moves());
// Set output steram in normal or chess960 mode
cout << set960(pos.is_chess960());
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)
// At Root and at first iteration do a PV search on all the moves to score root moves
isPvMove = (PvNode && moveCount <= (RootNode ? depth <= ONE_PLY ? MAX_MOVES : MultiPV : 1));
givesCheck = pos.move_gives_check(move, ci);
- captureOrPromotion = pos.move_is_capture(move) || move_is_promotion(move);
+ captureOrPromotion = pos.move_is_capture_or_promotion(move);
// Step 12. Decide the new search depth
ext = extension<PvNode>(pos, move, captureOrPromotion, givesCheck, &dangerous);
// Update killers and history only for non capture moves that fails high
if ( bestValue >= beta
- && !pos.move_is_capture(move)
- && !move_is_promotion(move))
+ && !pos.move_is_capture_or_promotion(move))
{
if (move != ss->killers[0])
{
&& !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)
&& !inCheck
&& givesCheck
&& move != ttMove
- && !pos.move_is_capture(move)
- && !move_is_promotion(move)
+ && !pos.move_is_capture_or_promotion(move)
&& ss->eval + PawnValueMidgame / 4 < beta
&& !check_is_dangerous(pos, move, futilityBase, beta, &bestValue))
{
newAtt = pos.attacks_from(pc, to, occ);
// Rule 1. Checks which give opponent's king at most one escape square are dangerous
- b = kingAtt & ~pos.pieces_of_color(them) & ~newAtt & ~(1ULL << to);
+ b = kingAtt & ~pos.pieces(them) & ~newAtt & ~(1ULL << to);
if (!(b && (b & (b - 1))))
return true;
// Rule 2. Queen contact check is very dangerous
- if ( type_of_piece(pc) == QUEEN
+ if ( piece_type(pc) == QUEEN
&& bit_is_set(kingAtt, to))
return true;
// Rule 3. Creating new double threats with checks
- b = pos.pieces_of_color(them) & newAtt & ~oldAtt & ~(1ULL << ksq);
+ b = pos.pieces(them) & newAtt & ~oldAtt & ~(1ULL << ksq);
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
assert(move_is_ok(m));
assert(threat && move_is_ok(threat));
- assert(!pos.move_is_capture(m) && !move_is_promotion(m));
+ assert(!pos.move_is_capture_or_promotion(m));
assert(!pos.move_is_passed_pawn_push(m));
Square mfrom, mto, tfrom, tto;
// 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)
- || pos.type_of_piece_on(tfrom) == KING)
+ && ( piece_value_midgame(pos.piece_on(tfrom)) >= piece_value_midgame(pos.piece_on(tto))
+ || piece_type(pos.piece_on(tfrom)) == KING)
&& pos.move_attacks_square(m, tto))
return true;