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);
}
}
static void identify_straight_line(void)
{
square const sq_observer = move_generation_stack[CURRMOVE_OF_PLY(nbply)].departure;
square const sq_observee = move_generation_stack[CURRMOVE_OF_PLY(nbply)].capture;
vec_index_type const idx = interceptable_observation[observation_context].vector_index1;
numvec const dir = vec[idx];
/* we identify straight lines by the two virtual squares just outside of the
* board
*/
square start = sq_observer;
square end = sq_observee;
do
{
start += dir;
} while (!is_square_blocked(start));
end = sq_observee;
do
{
end -= dir;
} while (!is_square_blocked(end));
PushMagicView(sq_observee,sq_observer,start,end);
}
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();
}
}
static boolean advance_rebirth_square(void)
{
boolean result = true;
TraceFunctionEntry(__func__);
TraceFunctionParamListEnd();
do
{
if (circe_rebirth_context_stack[circe_rebirth_context_stack_pointer].rebirth_square<square_h8)
++circe_rebirth_context_stack[circe_rebirth_context_stack_pointer].rebirth_square;
else
{
circe_rebirth_context_stack[circe_rebirth_context_stack_pointer].rebirth_square = initsquare;
result = false;
break;
}
} while (is_square_blocked(circe_rebirth_context_stack[circe_rebirth_context_stack_pointer].rebirth_square));
TraceSquare(circe_rebirth_context_stack[circe_rebirth_context_stack_pointer].rebirth_square);
TraceEOL();
TraceFunctionExit(__func__);
TraceFunctionResult("%u",result);
TraceFunctionResultEnd();
return result;
}
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;
}
static void identify_zigzag_line(void)
{
square const sq_observer = move_generation_stack[CURRMOVE_OF_PLY(nbply)].departure;
square const sq_observee = move_generation_stack[CURRMOVE_OF_PLY(nbply)].capture;
vec_index_type const idx_zig = interceptable_observation[observation_context].vector_index1;
vec_index_type const idx_zag = interceptable_observation[observation_context].auxiliary;
square sq_curr = sq_observee+vec[idx_zig];
TraceFunctionEntry(__func__);
TraceFunctionParamListEnd();
/* we identify zigzag lines by the two first off the board squares
*/
while (true)
{
if (is_square_blocked(sq_curr))
{
PushMagicView(sq_observee,sq_observer,sq_curr+vec[idx_zag],sq_curr);
break;
}
else
{
sq_curr += vec[idx_zag];
if (is_square_blocked(sq_curr))
{
PushMagicView(sq_observee,sq_observer,sq_curr+vec[idx_zig],sq_curr);
break;
}
else
sq_curr += vec[idx_zig];
}
}
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
static boolean maooariderlion_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;
}
if (!is_square_empty(sq_passed)
&& EVALUATE_OBSERVATION(evaluate,sq_departure,sq_target))
return true;
if (!is_square_blocked(sq_passed) && !is_square_blocked(sq_departure)
&& (is_square_empty(sq_passed) || is_square_empty(sq_departure)))
{
sq_passed += to_departure;
sq_departure += to_departure;
while (is_square_empty(sq_passed) && is_square_empty(sq_departure))
{
sq_passed += to_departure;
sq_departure += to_departure;
}
if (is_square_empty(sq_passed)
&& EVALUATE_OBSERVATION(evaluate,sq_departure,sq_target))
return true;
}
return false;
}
/* 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();
}
}
}
static boolean reflecting_bishop_check_recursive(square intermediate_square,
numvec k,
int x,
validator_id evaluate)
{
square const sq_target = move_generation_stack[CURRMOVE_OF_PLY(nbply)].capture;
if (is_square_blocked(intermediate_square+k))
return false;
else
{
numvec k1;
square const sq_reflection = find_end_of_line(intermediate_square,k);
piece_walk_type const p1 = get_walk_of_piece_on_square(sq_reflection);
if (x && p1==Invalid)
{
square const sq_departure = sq_reflection-k;
k1= 5;
while (vec[k1]!=k)
k1++;
k1 *= 2;
if (reflecting_bishop_check_recursive(sq_departure,
angle_vectors[angle_90][k1],
x-1,
evaluate))
return true;
k1--;
if (reflecting_bishop_check_recursive(sq_departure,
angle_vectors[angle_90][k1],
x-1,
evaluate))
return true;
}
else if (EVALUATE_OBSERVATION(evaluate,sq_reflection,sq_target))
return true;
return false;
}
}
/* Generate moves for a chinese rider 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_rider_generate_moves(vec_index_type kbeg, vec_index_type kend)
{
vec_index_type k;
for (k = kbeg; k<=kend; ++k)
{
numecoup const base = current_move[nbply];
square const sq_hurdle = generate_moves_on_line_segment(curr_generation->departure,k);
/* avoid accidentally "inheriting" the hurdle from some previous move */
hoppers_clear_hurdles(base);
if (!is_square_blocked(sq_hurdle))
{
curr_generation->arrival = find_end_of_line(sq_hurdle,vec[k]);
if (piece_belongs_to_opponent(curr_generation->arrival))
hoppers_push_move(k,sq_hurdle);
}
}
}
static void identify_doublehopper_line(void)
{
square const sq_observer = move_generation_stack[CURRMOVE_OF_PLY(nbply)].departure;
square const sq_observee = move_generation_stack[CURRMOVE_OF_PLY(nbply)].capture;
vec_index_type const idx_firstleg = interceptable_observation[observation_context].vector_index1;
numvec const dir_firstleg = vec[idx_firstleg];
vec_index_type const sq_intermediate = interceptable_observation[observation_context].auxiliary;
square sq_curr = sq_intermediate+dir_firstleg;
TraceFunctionEntry(__func__);
TraceFunctionParamListEnd();
/* we identify doublehopper lines by the intermediate square and the square
* just off the board on the first leg
*/
while (!is_square_blocked(sq_curr))
sq_curr += dir_firstleg;
PushMagicView(sq_observee,sq_observer,sq_curr,sq_intermediate);
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
