void intelligent_place_pinned_unpromoted_black_pawn(unsigned int placed_index,
square placed_on,
void (*go_on)(void))
{
Flags const placed_flags = black[placed_index].flags;
square const placed_comes_from = black[placed_index].diagram_square;
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",placed_index);
TraceSquare(placed_on);
TraceFunctionParamListEnd();
if (!TSTFLAGMASK(sq_spec[placed_on],BIT(BlBaseSq)|BIT(BlPromSq))
&& !black_pawn_attacks_king(placed_on)
&& intelligent_reserve_black_pawn_moves_from_to_no_promotion(placed_comes_from,
placed_on))
{
occupy_square(placed_on,Pawn,placed_flags);
(*go_on)();
intelligent_unreserve();
}
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
static void by_unpromoted_pawn(slice_index si,
unsigned int index_of_checker,
square const check_from)
{
square const checker_from = white[index_of_checker].diagram_square;
Flags const checker_flags = white[index_of_checker].flags;
SquareFlags const prom_square = BIT(WhPromSq)|BIT(BlPromSq);
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",index_of_checker);
TraceSquare(check_from);
TraceFunctionParamListEnd();
if (!TSTFLAGMASK(sq_spec[check_from],prom_square)
&& GuardDir[Pawn-Pawn][check_from].dir==guard_dir_check_uninterceptable
&& intelligent_reserve_white_pawn_moves_from_to_checking(checker_from,check_from))
{
occupy_square(check_from,Pawn,checker_flags);
init_disturb_mate_dir(check_from,being_solved.king_square[Black]-check_from);
pipe_solve_delegate(si);
fini_disturb_mate_dir();
empty_square(check_from);
intelligent_unreserve();
}
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
void intelligent_place_unpromoted_white_pawn(unsigned int placed_index,
square placed_on,
void (*go_on)(void))
{
square const placed_comes_from = white[placed_index].diagram_square;
Flags const placed_flags = white[placed_index].flags;
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",placed_index);
TraceSquare(placed_on);
TraceFunctionParamListEnd();
if (!TSTFLAGMASK(sq_spec[placed_on],BIT(WhBaseSq)|BIT(WhPromSq))
&& GuardDir[Pawn-Pawn][placed_on].dir<guard_dir_guard_uninterceptable
&& intelligent_reserve_white_pawn_moves_from_to_no_promotion(placed_comes_from,
placed_on))
{
occupy_square(placed_on,Pawn,placed_flags);
(*go_on)();
intelligent_unreserve();
}
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
void intelligent_place_unpromoted_black_pawn(unsigned int placed_index,
square placed_on,
void (*go_on)(void))
{
Flags const placed_flags = black[placed_index].flags;
square const placed_comes_from = black[placed_index].diagram_square;
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",placed_index);
TraceSquare(placed_on);
TraceFunctionParamListEnd();
if (!TSTFLAGMASK(sq_spec[placed_on],BIT(BlBaseSq)|BIT(BlPromSq))
&& !black_pawn_attacks_king(placed_on)
&& intelligent_reserve_black_pawn_moves_from_to_no_promotion(placed_comes_from,
placed_on))
{
occupy_square(placed_on,Pawn,placed_flags);
switch (DisturbMateDirPawn[placed_on])
{
case disturbance_by_pawn_capture:
case disturbance_by_pawn_interception_single:
intelligent_pin_black_piece(placed_on,go_on);
break;
case disturbance_by_pawn_interception_double:
{
square const target = placed_on+2*dir_down;
assert(is_square_empty(target));
if (is_square_empty(placed_on+dir_down))
{
intelligent_intercept_black_move(placed_on,target,go_on);
intelligent_pin_black_piece(placed_on,go_on);
}
else
(*go_on)();
break;
}
default:
(*go_on)();
break;
}
intelligent_unreserve();
}
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
static void PushMagicViewsByOnePiece(piece_walk_type pi_magic)
{
square const *pos_viewed;
TraceFunctionEntry(__func__);
TraceWalk(pi_magic);
TraceFunctionParamListEnd();
for (pos_viewed = boardnum; *pos_viewed; pos_viewed++)
if (get_walk_of_piece_on_square(*pos_viewed)>Invalid
&& !TSTFLAGMASK(being_solved.spec[*pos_viewed],BIT(Magic)|BIT(Royal))
&& !is_piece_neutral(being_solved.spec[*pos_viewed]))
{
replace_observation_target(*pos_viewed);
observing_walk[nbply] = pi_magic;
/* ignore return value - it's ==false */
fork_is_square_observed_nested_delegate(temporary_hack_is_square_observed_specific[trait[nbply]],
EVALUATE(observation));
}
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
/* Intercept a check to the white king with a black piece on a square
* @param where_to_intercept what square
* @param is_diagonal true iff we are intercepting a check on a diagonal line
* @param go_on what to do after each successful interception?
*/
static void black_piece_on(slice_index si,
square where_to_intercept,
boolean is_diagonal,
void (*go_on)(slice_index si))
{
unsigned int intercepter_index;
TraceFunctionEntry(__func__);
TraceSquare(where_to_intercept);
TraceFunctionParam("%u",is_diagonal);
TraceFunctionParamListEnd();
for (intercepter_index = 1; intercepter_index<MaxPiece[Black]; ++intercepter_index)
if (black[intercepter_index].usage==piece_is_unused)
{
black[intercepter_index].usage = piece_intercepts;
switch (black[intercepter_index].type)
{
case Pawn:
promoted_black_pawn(si,
intercepter_index,where_to_intercept,
is_diagonal,
go_on);
if (!TSTFLAGMASK(sq_spec[where_to_intercept],BIT(BlBaseSq)|BIT(BlPromSq)))
intelligent_place_unpromoted_black_pawn(si,
intercepter_index,
where_to_intercept,
go_on);
break;
case Queen:
break;
case Rook:
if (is_diagonal)
intelligent_place_black_rider(si,
intercepter_index,
where_to_intercept,
go_on);
break;
case Bishop:
if (!is_diagonal)
intelligent_place_black_rider(si,
intercepter_index,
where_to_intercept,
go_on);
break;
case Knight:
intelligent_place_black_knight(si,
intercepter_index,
where_to_intercept,
go_on);
break;
default:
assert(0);
break;
}
black[intercepter_index].usage = piece_is_unused;
}
empty_square(where_to_intercept);
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
/* Find out whether the pawn that has just moved (if any) has the potential
* of being captured en passant
* @param sq_multistep_departure departure square of pawn move
* @return the square avoided by the multistep; initsquare if no multistep
*/
square en_passant_find_potential(square sq_multistep_departure)
{
square result = initsquare;
move_effect_journal_index_type const top = move_effect_journal_base[nbply];
move_effect_journal_index_type const movement = top+move_effect_journal_index_offset_movement;
piece_walk_type pi_moving = move_effect_journal[movement].u.piece_movement.moving;
square const sq_arrival = move_generation_stack[CURRMOVE_OF_PLY(nbply)].arrival;
TraceFunctionEntry(__func__);
TraceSquare(sq_multistep_departure);
TraceFunctionParamListEnd();
if (pi_moving>=Hunter0)
pi_moving = huntertypes[pi_moving-Hunter0].away;
switch (pi_moving)
{
case Pawn:
case MarinePawn:
{
numvec const dir_forward = trait[nbply]==White ? dir_up : dir_down;
SquareFlags const double_step = (trait[nbply]==White
? BIT(WhPawnDoublestepSq)|BIT(WhBaseSq)
: BIT(BlPawnDoublestepSq)|BIT(BlBaseSq));
if (sq_arrival-sq_multistep_departure==2*dir_forward
&& TSTFLAGMASK(sq_spec[sq_multistep_departure],double_step))
result = (sq_multistep_departure+sq_arrival) / 2;
break;
}
case BerolinaPawn:
{
numvec const dir_forward = trait[nbply]==White ? dir_up : dir_down;
SquareFlags const double_step = (trait[nbply]==White
? BIT(WhPawnDoublestepSq)|BIT(WhBaseSq)
: BIT(BlPawnDoublestepSq)|BIT(BlBaseSq));
numvec const v = sq_arrival-sq_multistep_departure;
if ((v==2*dir_forward+2*dir_left || v==2*dir_forward+2*dir_right)
&& TSTFLAGMASK(sq_spec[sq_multistep_departure],double_step))
result = (sq_multistep_departure+sq_arrival) / 2;
break;
}
case ReversePawn:
{
numvec const dir_backward = trait[nbply]==Black ? dir_up : dir_down;
SquareFlags const double_step = (trait[nbply]==Black
? BIT(WhPawnDoublestepSq)|BIT(WhBaseSq)
: BIT(BlPawnDoublestepSq)|BIT(BlBaseSq));
if (sq_arrival-sq_multistep_departure==2*dir_backward
&& TSTFLAGMASK(sq_spec[sq_multistep_departure],double_step))
result = (sq_multistep_departure+sq_arrival) / 2;
break;
}
default:
break;
}
TraceFunctionExit(__func__);
TraceSquare(result);
TraceFunctionResultEnd();
return result;
}
