static void init_disturb_mate_rider_onedir(square target, int dir, unsigned int index)
{
square s;
enum
{
nr_DisturbMateDirRider = sizeof DisturbMateDirRider / sizeof DisturbMateDirRider[0]
};
TraceFunctionEntry(__func__);
TraceSquare(target);
TraceFunctionParam("%d",dir);
TraceFunctionParam("%u",index);
TraceFunctionParamListEnd();
assert(index<nr_DisturbMateDirRider);
for (s = target+2*dir; is_square_empty(s); s += dir)
{
DisturbMateDirRider[index][s].dir = -dir;
DisturbMateDirRider[index][s].target = target;
}
for (s = target-2*dir; is_square_empty(s); s -= dir)
{
DisturbMateDirRider[index][s].dir = dir;
DisturbMateDirRider[index][s].target = target;
}
DisturbMateDirRider[index][target+dir].dir = disturbance_by_rider_uninterceptable;
DisturbMateDirRider[index][target-dir].dir = disturbance_by_rider_uninterceptable;
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
static void maooa_rider_lion_generate_moves(numvec to_passed, numvec to_arrival)
{
square const sq_departure = curr_generation->departure;
square sq_passed = sq_departure+to_passed;
curr_generation->arrival = sq_departure+to_arrival;
while (is_square_empty(sq_passed) && is_square_empty(curr_generation->arrival))
{
sq_passed += to_arrival;
curr_generation->arrival += to_arrival;
}
if (!is_square_blocked(sq_passed) && !is_square_blocked(curr_generation->arrival))
{
if (!is_square_empty(sq_passed)
&& (is_square_empty(curr_generation->arrival)
|| piece_belongs_to_opponent(curr_generation->arrival)))
push_move();
if (is_square_empty(sq_passed) || is_square_empty(curr_generation->arrival))
{
sq_passed += to_arrival;
curr_generation->arrival += to_arrival;
while (is_square_empty(sq_passed) && is_square_empty(curr_generation->arrival))
{
push_move();
sq_passed += to_arrival;
curr_generation->arrival += to_arrival;
}
}
if (is_square_empty(sq_passed)
&& piece_belongs_to_opponent(curr_generation->arrival))
push_move();
}
}
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 maooa_generate_move(numvec to_passed, numvec to_arrival)
{
square const sq_departure = curr_generation->departure;
square const sq_passed = sq_departure+to_passed;
if (is_square_empty(sq_passed))
{
curr_generation->arrival = sq_departure+to_arrival;
if (is_square_empty(curr_generation->arrival)
|| piece_belongs_to_opponent(curr_generation->arrival))
hoppers_push_move(0,sq_passed);
}
}
static void maooahopper_generate_moves(vec_index_type k,
numvec to_intermediate)
{
numvec const to_arrival = vec[k];
square const sq_departure = curr_generation->departure;
square const sq_hurdle = sq_departure+to_intermediate;
if (!is_square_empty(sq_hurdle))
{
curr_generation->arrival = sq_departure+to_arrival;
if (is_square_empty(curr_generation->arrival)
|| piece_belongs_to_opponent(curr_generation->arrival))
hoppers_push_move(k,sq_hurdle);
}
}
/* Is the placed white king in check from a particular direction?
* @param dir direction
* @return true iff the placed white king is in check from dir
*/
static boolean check_from_direction(int dir)
{
square curr = being_solved.king_square[White]-dir;
boolean const is_diagonal = SquareCol(curr)==SquareCol(being_solved.king_square[White]);
boolean result;
TraceFunctionEntry(__func__);
TraceFunctionParam("%d",dir);
TraceFunctionParamListEnd();
while (is_square_empty(curr))
curr -= dir;
if (TSTFLAG(being_solved.spec[curr],Black))
{
piece_walk_type const checker = get_walk_of_piece_on_square(curr);
result = checker==Queen || checker==(is_diagonal ? Bishop : Rook);
}
else
result = false;
TraceFunctionExit(__func__);
TraceFunctionResult("%u",result);
TraceFunctionResultEnd();
return result;
}
static boolean rrefnech(square i1, validator_id evaluate)
{
square const sq_target = move_generation_stack[CURRMOVE_OF_PLY(nbply)].capture;
vec_index_type k;
if (!NoEdge(i1))
settraversed(i1);
for (k= vec_knight_start; k<=vec_knight_end; k++) {
square sq_departure = i1+vec[k];
while (is_square_empty(sq_departure))
{
if (!NoEdge(sq_departure) &&
!traversed(sq_departure)) {
if (rrefnech(sq_departure,evaluate))
return true;
break;
}
sq_departure += vec[k];
}
if (EVALUATE_OBSERVATION(evaluate,sq_departure,sq_target))
return true;
}
return false;
}
static boolean rrefcech(square i1, int x, validator_id evaluate)
{
square const sq_target = move_generation_stack[CURRMOVE_OF_PLY(nbply)].capture;
vec_index_type k;
/* ATTENTION: first call of rrefech: x must be 2 !! */
square sq_departure;
for (k= vec_knight_start; k <= vec_knight_end; k++)
if (x) {
sq_departure= i1+vec[k];
if (is_square_empty(sq_departure)) {
if (!NoEdge(sq_departure)) {
if (rrefcech(sq_departure,x-1,evaluate))
return true;
}
}
else if (EVALUATE_OBSERVATION(evaluate,sq_departure,sq_target))
return true;
}
else
for (k= vec_knight_start; k <= vec_knight_end; k++) {
sq_departure= i1+vec[k];
if (EVALUATE_OBSERVATION(evaluate,sq_departure,sq_target))
return true;
}
return false;
}
static void bouncy_nightrider_generate_moves_recursive(square step_departure)
{
vec_index_type k;
if (!NoEdge(step_departure))
settraversed(step_departure);
for (k= vec_knight_start; k<=vec_knight_end; k++)
{
curr_generation->arrival = step_departure+vec[k];
while (is_square_empty(curr_generation->arrival))
{
push_move();
if (!NoEdge(curr_generation->arrival) && !traversed(curr_generation->arrival))
{
bouncy_nightrider_generate_moves_recursive(curr_generation->arrival);
break;
}
else
curr_generation->arrival += vec[k];
}
if (piece_belongs_to_opponent(curr_generation->arrival))
push_move();
}
}
static boolean is_mate_square(Side other_side)
{
boolean result = false;
if (is_square_empty(being_solved.king_square[other_side]))
{
TraceFunctionEntry(__func__);
TraceEnumerator(Side,other_side,"");
TraceFunctionParamListEnd();
TraceSquare(being_solved.king_square[other_side]);TraceEOL();
occupy_square(being_solved.king_square[other_side],King,BIT(Royal)|BIT(other_side));
if (conditional_pipe_solve_delegate(temporary_hack_mate_tester[other_side])
==previous_move_has_solved)
result = true;
empty_square(being_solved.king_square[other_side]);
TraceFunctionExit(__func__);
TraceFunctionResult("%u",result);
TraceFunctionResultEnd();
}
return result;
}
boolean cat_check(validator_id evaluate)
{
square const sq_target = move_generation_stack[CURRMOVE_OF_PLY(nbply)].capture;
if (leapers_check(vec_knight_start,vec_knight_end,evaluate))
return true;
else
{
vec_index_type k;
for (k = vec_dabbaba_start; k<=vec_dabbaba_end; k++)
{
square middle_square= sq_target+vec[k];
while (is_square_empty(middle_square))
{
{
square const sq_departure= middle_square+cat_vectors[k-60];
if (EVALUATE_OBSERVATION(evaluate,sq_departure,sq_target))
return true;
}
{
square const sq_departure= middle_square+cat_vectors[k-56];
if (EVALUATE_OBSERVATION(evaluate,sq_departure,sq_target))
return true;
}
middle_square += vec[k];
}
}
return false;
}
}
static boolean are_all_imitator_arrivals_empty(square sq_departure, square sq_arrival)
{
unsigned int imi_idx;
int const diff = sq_arrival-sq_departure;
boolean result = true;
TraceFunctionEntry(__func__);
TraceSquare(sq_departure);
TraceSquare(sq_arrival);
TraceFunctionParamListEnd();
for (imi_idx = being_solved.number_of_imitators; imi_idx>0; imi_idx--)
{
square const j2 = being_solved.isquare[imi_idx-1]+diff;
if (j2!=sq_departure && !is_square_empty(j2))
{
result = false;
break;
}
}
TraceFunctionExit(__func__);
TraceFunctionResult("%u",result);
TraceFunctionResultEnd();
return result;
}
static boolean is_imitator_line_clear(unsigned int i,
numvec diff_first_necessarily_empty,
numvec step,
numvec diff_first_not_necessarily_empty)
{
boolean result = true;
square const sq_first_not_necessarily_empty = being_solved.isquare[i]+diff_first_not_necessarily_empty;
square sq_curr;
TraceFunctionEntry(__func__);
TraceValue("%u",i);
TraceValue("%d",diff_first_necessarily_empty);
TraceValue("%d",step);
TraceValue("%d",diff_first_not_necessarily_empty);
TraceFunctionParamListEnd();
for (sq_curr = being_solved.isquare[i]+diff_first_necessarily_empty; sq_curr!=sq_first_not_necessarily_empty; sq_curr += step)
{
TraceSquare(sq_curr);TraceEOL();
if (!is_square_empty(sq_curr))
{
result = false;
break;
}
}
TraceFunctionExit(__func__);
TraceFunctionResult("%u",result);
TraceFunctionResultEnd();
return result;
}
static void HandleAddedPiece(square s, void *param)
{
piece_addition_settings * const settings = param;
if (!is_square_empty(s))
{
if (settings->type==piece_addition_initial)
{
WriteSquare(&output_plaintext_engine,stdout,s);
output_plaintext_message(OverwritePiece);
underworld_make_space(nr_ghosts);
underworld[nr_ghosts-1].walk = get_walk_of_piece_on_square(s);
underworld[nr_ghosts-1].flags = being_solved.spec[s];
underworld[nr_ghosts-1].on = s;
}
else
{
move_effect_journal_do_circe_volcanic_remember(move_effect_reason_diagram_setup,
s);
move_effect_journal_do_piece_removal(move_effect_reason_diagram_setup,
s);
}
}
if (settings->type==piece_addition_twinning)
move_effect_journal_do_piece_creation(move_effect_reason_diagram_setup,
s,settings->walk,
settings->spec,
no_side);
else
occupy_square(s,settings->walk,settings->spec);
}
/* Try to solve in solve_nr_remaining half-moves.
* @param si slice index
* @note assigns solve_result the length of solution found and written, i.e.:
* previous_move_is_illegal the move just played is illegal
* this_move_is_illegal the move being played is illegal
* immobility_on_next_move the moves just played led to an
* unintended immobility on the next move
* <=n+1 length of shortest solution found (n+1 only if in next
* branch)
* n+2 no solution found in this branch
* n+3 no solution found in next branch
* (with n denominating solve_nr_remaining)
*/
void orthodox_mating_king_contact_generator_solve(slice_index si)
{
Side const moving = SLICE_STARTER(si);
Side const mated = advers(moving);
square const sq_mated_king = being_solved.king_square[mated];
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",si);
TraceFunctionParamListEnd();
assert(solve_nr_remaining==slack_length+1);
curr_generation->departure = being_solved.king_square[moving];
if (curr_generation->departure!=sq_mated_king)
{
vec_index_type k;
for (k = vec_queen_start; k<=vec_queen_end; k++)
{
curr_generation->arrival = curr_generation->departure+vec[k];
if ((is_square_empty(curr_generation->arrival)
|| TSTFLAG(being_solved.spec[curr_generation->arrival],mated))
&& move_diff_code[abs(sq_mated_king-curr_generation->arrival)]<=1+1)
push_move();
}
}
pipe_solve_delegate(si);
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
static boolean find_illegal_observation(void)
{
Side const save_trait = trait[nbply];
boolean result = false;
square square_h = square_h8;
int i;
TraceFunctionEntry(__func__);
TraceFunctionParamListEnd();
for (i = nr_rows_on_board; i>0; i--, square_h += dir_down)
{
int j;
square z = square_h;
for (j = nr_files_on_board; j>0; j--, z += dir_left)
if (!is_square_empty(z)
&& (is_piece_illegally_observed(White,z)
|| is_piece_illegally_observed(Black,z)))
{
result = true;
break;
}
}
/* We have juggled with trait[npbly] to be able to reuse Madrasi
* functionality. Now we have to clean up after ourselves: */
trait[nbply] = save_trait;
TraceFunctionExit(__func__);
TraceFunctionResult("%u",result);
TraceFunctionResultEnd();
return result;
}
static void reflecting_bishop_generate_moves_recursive(square in, numvec dir, unsigned int nr_remaining_reflections)
{
curr_generation->arrival = in+dir;
if (is_square_blocked(curr_generation->arrival))
return;
while (is_square_empty(curr_generation->arrival))
{
push_move();
curr_generation->arrival += dir;
}
if (piece_belongs_to_opponent(curr_generation->arrival))
push_move();
else if (nr_remaining_reflections>0 && is_square_blocked(curr_generation->arrival))
{
square const sq_reflection = curr_generation->arrival-dir;
vec_index_type const dir_index = find_vec_index(dir);
vec_index_type const dir_reflected_index = dir_index*2;
reflecting_bishop_generate_moves_recursive(sq_reflection,
angle_vectors[angle_90][dir_reflected_index],
nr_remaining_reflections-1);
reflecting_bishop_generate_moves_recursive(sq_reflection,
angle_vectors[angle_90][dir_reflected_index-1],
nr_remaining_reflections-1);
}
}
/* Try to solve in solve_nr_remaining half-moves.
* @param si slice index
* @note assigns solve_result the length of solution found and written, i.e.:
* previous_move_is_illegal the move just played is illegal
* this_move_is_illegal the move being played is illegal
* immobility_on_next_move the moves just played led to an
* unintended immobility on the next move
* <=n+1 length of shortest solution found (n+1 only if in next
* branch)
* n+2 no solution found in this branch
* n+3 no solution found in next branch
* (with n denominating solve_nr_remaining)
*/
void haunted_chess_ghost_summoner_solve(slice_index si)
{
underworld_index_type idx_ghost = nr_ghosts;
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",si);
TraceFunctionParamListEnd();
while (idx_ghost>0)
{
--idx_ghost;
if (is_square_empty(underworld[idx_ghost].on))
{
move_effect_journal_do_piece_readdition(move_effect_reason_summon_ghost,
underworld[idx_ghost].on,
underworld[idx_ghost].walk,
underworld[idx_ghost].flags,
no_side);
move_effect_journal_do_forget_ghost(idx_ghost);
}
}
pipe_solve_delegate(si);
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
/* Determine whether a specific piece delivers check to a specific side
* @param observer_origin potentially delivering check ...
* @note the piece on pos_checking must belong to advers(side)
* @note sets observation_result
*/
void marscirce_is_square_observed(slice_index si)
{
circe_rebirth_context_elmt_type * const context = &circe_rebirth_context_stack[circe_rebirth_context_stack_pointer-1];
square const sq_target = move_generation_stack[CURRMOVE_OF_PLY(nbply)].capture;
TraceFunctionEntry(__func__);
TraceValue("%u",si);
TraceFunctionParamListEnd();
assert(circe_rebirth_context_stack_pointer>0);
observation_result = false;
if (observing_walk[nbply]<Queen || observing_walk[nbply]>Bishop
|| CheckDir[observing_walk[nbply]][sq_target-context->rebirth_square]!=0)
{
if (is_square_empty(context->rebirth_square))
{
TraceSquare(context->rebirth_square);
TraceWalk(context->reborn_walk);
TraceValue("%u",TSTFLAG(being_solved.spec[context->rebirth_square],White));
TraceValue("%u",TSTFLAG(being_solved.spec[context->rebirth_square],Black));
TraceEOL();
occupy_square(context->rebirth_square,context->reborn_walk,context->reborn_spec);
pipe_is_square_observed_delegate(si);
empty_square(context->rebirth_square);
}
}
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
static boolean maooacheck(vec_index_type vec_index_pass_target_begin,
vec_index_type vec_index_pass_target_end,
validator_id evaluate)
{
square const sq_target = move_generation_stack[CURRMOVE_OF_PLY(nbply)].capture;
boolean result = false;
++observation_context;
for (interceptable_observation[observation_context].vector_index1 = vec_index_pass_target_end;
interceptable_observation[observation_context].vector_index1>=vec_index_pass_target_begin;
--interceptable_observation[observation_context].vector_index1)
{
numvec const vec_pass_target = vec[interceptable_observation[observation_context].vector_index1];
square const sq_pass = sq_target+vec_pass_target;
if (is_square_empty(sq_pass)
&& (maooacheck_onedir(sq_pass,2*interceptable_observation[observation_context].vector_index1,evaluate)
|| maooacheck_onedir(sq_pass,2*interceptable_observation[observation_context].vector_index1-1,evaluate)))
{
result = true;
break;
}
}
--observation_context;
return result;
}
static boolean maooarider_check(numvec to_passed,
numvec to_departure,
validator_id evaluate)
{
square const sq_target = move_generation_stack[CURRMOVE_OF_PLY(nbply)].capture;
square sq_passed = sq_target+to_passed;
square sq_departure= sq_target+to_departure;
while (is_square_empty(sq_passed) && is_square_empty(sq_departure))
{
sq_passed += to_departure;
sq_departure += to_departure;
}
return (is_square_empty(sq_passed)
&& EVALUATE_OBSERVATION(evaluate,sq_departure,sq_target));
}
/* Try to solve in solve_nr_remaining half-moves.
* @param si slice index
* @note assigns solve_result the length of solution found and written, i.e.:
* previous_move_is_illegal the move just played is illegal
* this_move_is_illegal the move being played is illegal
* immobility_on_next_move the moves just played led to an
* unintended immobility on the next move
* <=n+1 length of shortest solution found (n+1 only if in next
* branch)
* n+2 no solution found in this branch
* n+3 no solution found in next branch
* (with n denominating solve_nr_remaining)
*/
void haan_chess_hole_inserter_solve(slice_index si)
{
move_effect_journal_index_type const top = move_effect_journal_base[nbply+1];
move_effect_journal_index_type curr;
boolean piece_visited[MaxPieceId+1] = { false };
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",si);
TraceFunctionParamListEnd();
for (curr = move_effect_journal_base[nbply]; curr!=top; ++curr)
if (move_effect_journal[curr].type==move_effect_piece_movement)
{
PieceIdType const id = GetPieceId(move_effect_journal[curr].u.piece_movement.movingspec);
if (!piece_visited[id])
{
square const from = move_effect_journal[curr].u.piece_movement.from;
if (is_square_empty(from))
move_effect_journal_do_square_block(move_effect_journal[curr].reason,from);
piece_visited[id] = true;
}
}
else if (move_effect_journal[curr].type==move_effect_piece_removal
&& move_effect_journal[curr].reason==move_effect_reason_ep_capture)
{
PieceIdType const id = GetPieceId(move_effect_journal[curr].u.piece_removal.flags);
if (!piece_visited[id])
{
square const on = move_effect_journal[curr].u.piece_removal.on;
assert(is_square_empty(on));
move_effect_journal_do_square_block(move_effect_journal[curr].reason,on);
piece_visited[id] = true;
}
}
pipe_solve_delegate(si);
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
void intelligent_mate_generate_checking_moves(slice_index si)
{
unsigned int index;
TraceFunctionEntry(__func__);
TraceFunctionParamListEnd();
if (intelligent_reserve_masses(White,1,piece_gives_check))
{
for (index = 1; index<MaxPiece[White]; ++index)
{
square const *bnp;
white[index].usage = piece_gives_check;
for (bnp = boardnum; *bnp!=initsquare; ++bnp)
if (is_square_empty(*bnp))
{
switch (white[index].type)
{
case Queen:
case Rook:
case Bishop:
by_rider(si,index,*bnp);
break;
case Knight:
by_knight(si,index,*bnp);
break;
case Pawn:
by_unpromoted_pawn(si,index,*bnp);
by_promoted_pawn(si,index,*bnp);
break;
default:
assert(0);
break;
}
empty_square(*bnp);
}
white[index].usage = piece_is_unused;
}
intelligent_unreserve();
}
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
static boolean have_all_imitators_hurdle(numvec diff_hurdle)
{
unsigned int i;
for (i = 0; i!=being_solved.number_of_imitators; ++i)
{
square const sq_hurdle = being_solved.isquare[i]+diff_hurdle;
if (is_square_empty(sq_hurdle) || is_square_blocked(sq_hurdle))
return false;
}
return true;
}
/* Try to solve in solve_nr_remaining half-moves.
* @param si slice index
* @note assigns solve_result the length of solution found and written, i.e.:
* previous_move_is_illegal the move just played is illegal
* this_move_is_illegal the move being played is illegal
* immobility_on_next_move the moves just played led to an
* unintended immobility on the next move
* <=n+1 length of shortest solution found (n+1 only if in next
* branch)
* n+2 no solution found in this branch
* n+3 no solution found in next branch
* (with n denominating solve_nr_remaining)
*/
void circe_test_rebirth_square_empty_solve(slice_index si)
{
circe_rebirth_context_elmt_type const * const context = &circe_rebirth_context_stack[circe_rebirth_context_stack_pointer];
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",si);
TraceFunctionParamListEnd();
assert(context->reborn_walk!=Empty);
binary_solve_if_then_else(si,!is_square_empty(context->rebirth_square));
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
static void HandleAddedPiece(square s, void *param)
{
piece_addition_settings * const settings = param;
if (!is_square_empty(s))
{
move_effect_journal_do_circe_volcanic_remember(move_effect_reason_diagram_setup,s);
move_effect_journal_do_piece_removal(move_effect_reason_diagram_setup,s);
}
move_effect_journal_do_piece_creation(move_effect_reason_diagram_setup,
s,settings->walk,
settings->spec,
no_side);
}
static boolean marine_leaper_check(vec_index_type kanf, vec_index_type kend,
validator_id evaluate)
{
square const sq_target = move_generation_stack[CURRMOVE_OF_PLY(nbply)].capture;
vec_index_type k;
for (k = kanf; k<=kend; ++k)
{
square const sq_arrival = sq_target-vec[k];
square const sq_departure = sq_target+vec[k];
if (is_square_empty(sq_arrival)
&& EVALUATE_OBSERVATION(evaluate,sq_departure,sq_arrival))
return true;
}
return false;
}
/* Intercept a check to the white king with a white piece
* @param dir_from_rider direction from rider giving check to white king
* @param go_on what to do after each successful interception?
*/
static void white_piece(slice_index si, int dir_from_rider, void (*go_on)(slice_index si))
{
square where_to_intercept;
TraceFunctionEntry(__func__);
TraceFunctionParam("%d",dir_from_rider);
TraceFunctionParamListEnd();
for (where_to_intercept = being_solved.king_square[White]-dir_from_rider;
is_square_empty(where_to_intercept);
where_to_intercept -= dir_from_rider)
if (nr_reasons_for_staying_empty[where_to_intercept]==0)
white_piece_on(si,where_to_intercept,go_on);
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
static boolean find_flights(slice_index si,
Side side_in_check,
unsigned int nr_flights_to_find)
{
unsigned int nr_flights_found = 0;
square const save_king_square = being_solved.king_square[side_in_check];
piece_walk_type const king_walk = get_walk_of_piece_on_square(save_king_square);
Flags const king_flags = being_solved.spec[save_king_square];
square const save_departure = curr_generation->departure ;
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",si);
TraceFunctionParamListEnd();
siblingply(side_in_check);
curr_generation->departure = save_king_square;
move_generation_current_walk = king_walk;
generate_moves_for_piece_based_on_walk();
empty_square(save_king_square);
while (encore())
{
being_solved.king_square[side_in_check] = move_generation_stack[CURRMOVE_OF_PLY(nbply)].arrival;
if ((is_square_empty(being_solved.king_square[side_in_check])
|| TSTFLAG(being_solved.spec[being_solved.king_square[side_in_check]],advers(side_in_check)))
&& being_solved.king_square[side_in_check]!=being_solved.king_square[advers(side_in_check)]
&& !pipe_is_in_check_recursive_delegate(si,side_in_check))
++nr_flights_found;
pop_move();
}
being_solved.king_square[side_in_check] = save_king_square;
occupy_square(save_king_square,king_walk,king_flags);
curr_generation->departure = save_departure;
finply();
TraceFunctionExit(__func__);
TraceFunctionResult("%u",nr_flights_found>nr_flights_to_find);
TraceFunctionResultEnd();
return nr_flights_found>nr_flights_to_find;
}
/* Generate moves for a chinese leaper piece
* @param kbeg start of range of vector indices to be used
* @param kend end of range of vector indices to be used
*/
void chinese_leaper_generate_moves(vec_index_type kbeg, vec_index_type kend)
{
vec_index_type k;
for (k = kbeg; k<=kend; ++k)
{
curr_generation->arrival = curr_generation->departure + vec[k];
if (is_square_empty(curr_generation->arrival))
push_move();
else if (!is_square_blocked(curr_generation->arrival))
{
curr_generation->arrival += vec[k];
if (piece_belongs_to_opponent(curr_generation->arrival))
push_move();
}
}
}
