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;
}
static boolean enforce_possibly_confronted_observer_walk(slice_index si,
numvec dir_confronter)
{
square const sq_departure = move_generation_stack[CURRMOVE_OF_PLY(nbply)].departure;
Side const side_attacking = trait[nbply];
square const pos_confronter = sq_departure+dir_confronter;
piece_walk_type walk;
boolean result;
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",si);
TraceFunctionParam("%d",dir_confronter);
TraceFunctionParamListEnd();
TraceSquare(sq_departure);
TraceSquare(pos_confronter);
TraceEOL();
if (TSTFLAG(being_solved.spec[pos_confronter],advers(side_attacking)))
walk = get_walk_of_piece_on_square(pos_confronter);
else
walk = get_walk_of_piece_on_square(sq_departure);
TraceWalk(walk);
TraceWalk(observing_walk[nbply]);
TraceEOL();
if (walk==observing_walk[nbply])
result = pipe_validate_observation_recursive_delegate(si);
else
result = false;
TraceFunctionExit(__func__);
TraceFunctionResult("%u",result);
TraceFunctionResultEnd();
return result;
}
/* Generate moves of a potentially transmuting king
* @param si identifies move generator slice
* @return true iff the king is transmuting (which doesn't necessarily mean that
* any moves were generated!)
*/
boolean generate_moves_of_transmuting_king(slice_index si)
{
boolean result = false;
piece_walk_type const *ptrans;
numecoup const save_current_move = CURRMOVE_OF_PLY(nbply);
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",si);
TraceFunctionParamListEnd();
for (ptrans = transmuting_kings_potential_transmutations; *ptrans!=Empty; ++ptrans)
if (transmuting_kings_is_king_transmuting_as(*ptrans))
{
pipe_move_generation_differnt_walk_delegate(si,*ptrans);
result = true;
}
remove_duplicate_moves_of_single_piece(save_current_move);
TraceFunctionExit(__func__);
TraceFunctionResult("%u",result);
TraceFunctionResultEnd();
return result;
}
static void identify_line(void)
{
square const sq_observer = move_generation_stack[CURRMOVE_OF_PLY(nbply)].departure;
TraceFunctionEntry(__func__);
TraceFunctionParamListEnd();
TraceSquare(sq_observer);
TraceWalk(being_solved.board[sq_observer]);
TraceEOL();
switch (being_solved.board[sq_observer])
{
/* TODO simplify using classes? */
case Rook:
case Queen:
case Bishop:
case NightRider:
case Waran:
case Camelrider:
case Zebrarider:
case Gnurider:
case SuperBerolinaPawn:
case SuperPawn:
case RookHunter:
case BishopHunter:
case WesirRider:
case FersRider:
case Elephant:
case Lion:
case RookLion:
case BishopLion:
case NightRiderLion:
case Pao:
case Leo:
case Vao:
case Nao:
case Locust:
case NightLocust:
case BishopLocust:
case RookLocust:
case Sirene:
case Triton:
case Nereide:
case Kangaroo:
case KangarooLion:
case Rabbit:
case Kao:
case Elk:
case RookMoose:
case BishopMoose:
case Eagle:
case RookEagle:
case BishopEagle:
case Sparrow:
case RookSparrow:
case BishopSparrow:
case Marguerite:
case EquiHopper:
case Orix:
case EdgeHog:
case Grasshopper:
case NightriderHopper:
case CamelRiderHopper:
case ZebraRiderHopper:
case GnuRiderHopper:
case RookHopper:
case BishopHopper:
case ContraGras:
case GrassHopper2:
case GrassHopper3:
case Bob:
case EquiStopper:
case MaoRider:
case MoaRider:
case MaoRiderLion:
case MoaRiderLion:
case Dolphin:
case Bouncer :
case RookBouncer:
case BishopBouncer:
identify_straight_line();
break;
case Rose:
case RoseLion:
case RoseHopper:
case RoseLocust:
case Rao:
identify_circular_line();
break;
case SpiralSpringer:
case DiagonalSpiralSpringer:
case SpiralSpringer40:
case SpiralSpringer20:
case SpiralSpringer33:
case SpiralSpringer11:
case BoyScout:
case GirlScout:
identify_zigzag_line();
break;
case DoubleGras:
case DoubleRookHopper:
case DoubleBishopper:
identify_doublehopper_line();
break;
case Amazone:
case Empress:
case Princess:
case Gryphon:
case Ship:
case Gral:
case Scorpion:
case Querquisite:
case MarineShip:
identify_combined_rider_leaper_line();
break;
case King:
case Poseidon:
case ErlKing:
case Knight:
case Zebra:
case Camel:
case Giraffe:
case RootFiftyLeaper:
case Bucephale:
case Wesir:
case Alfil:
case Fers:
case Dabbaba:
case Gnu:
case Antilope:
case Squirrel:
case Okapi:
case Leap37:
case Leap16:
case Leap24:
case Leap35:
case Leap15:
case Leap25:
case Bison:
case Zebu:
case Leap36:
case Mao:
case Moa:
case NonStopEquihopper:
case NonStopOrix:
case NonstopEquiStopper:
case KingHopper:
case KnightHopper:
case MarineKnight:
case Pawn:
case BerolinaPawn:
case ReversePawn:
case ChinesePawn:
case MarinePawn:
case RadialKnight:
case Treehopper:
case Leafhopper :
case GreaterTreehopper:
case GreaterLeafhopper:
case Skylla:
case Charybdis:
case Dragon:
identify_leaper_pseudoline();
break;
default:
assert(0);
break;
}
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
static void identify_leaper_pseudoline(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;
PushMagicView(sq_observee,sq_observer,sq_observer,sq_observee);
}
/* Validate an observation according to Imitators
* @return true iff the observation is valid
*/
boolean imitator_validate_observation(slice_index si)
{
square const sq_observer = move_generation_stack[CURRMOVE_OF_PLY(nbply)].departure;
boolean result;
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",si);
TraceFunctionParamListEnd();
TraceWalk(being_solved.board[sq_observer]);TraceEOL();
switch (being_solved.board[sq_observer])
{
case King:
case ErlKing:
case Knight:
case Wesir:
case Dabbaba:
case Fers:
case Alfil:
case Bucephale:
case Giraffe:
case Camel:
case Zebra:
case Okapi:
case Bison:
case Gnu:
case Antilope:
case Squirrel:
case RootFiftyLeaper:
case Leap15:
case Leap16:
case Leap24:
case Leap25:
case Leap35:
case Leap36:
case Leap37:
case Pawn:
case BerolinaPawn:
case ReversePawn:
{
square const sq_landing = move_generation_stack[CURRMOVE_OF_PLY(nbply)].arrival;
result = are_all_imitator_arrivals_empty(sq_observer,sq_landing);
break;
}
case Queen:
case Rook:
case Bishop:
case NightRider:
case Elephant:
case Waran:
case Camelrider:
case Zebrarider:
case Gnurider:
case Amazone:
case Empress:
case Princess:
case RookHunter:
case BishopHunter:
case WesirRider:
case FersRider:
result = avoid_observing_if_imitator_blocked_rider();
break;
case Mao:
case Moa:
result = avoid_observing_if_imitator_blocked_chinese_leaper();
break;
case NonStopEquihopper:
case NonStopOrix:
result = avoid_observing_if_imitator_blocked_nonstop_equihopper();
break;
case Orix:
result = avoid_observing_if_imitator_blocked_orix();
break;
case EquiHopper:
if (interceptable_observation[observation_context].vector_index1==0)
result = avoid_observing_if_imitator_blocked_nonstop_equihopper();
else
result = avoid_observing_if_imitator_blocked_orix();
break;
case Grasshopper:
case NightriderHopper:
case CamelRiderHopper:
case ZebraRiderHopper:
case GnuRiderHopper:
case RookHopper:
case BishopHopper:
case KingHopper:
case KnightHopper:
result = avoid_observing_if_imitator_blocked_rider_hopper();
break;
case ContraGras:
result = avoid_observing_if_imitator_blocked_contragrasshopper();
break;
case GrassHopper2:
result = avoid_observing_if_imitator_blocked_grasshopper_n(2);
break;
case GrassHopper3:
result = avoid_observing_if_imitator_blocked_grasshopper_n(3);
break;
case Elk:
case RookMoose:
case BishopMoose:
result = avoid_observing_if_imitator_blocked_angle_hopper(angle_45);
break;
case Eagle:
case RookEagle:
case BishopEagle:
result = avoid_observing_if_imitator_blocked_angle_hopper(angle_90);
break;
case Sparrow:
case RookSparrow:
case BishopSparrow:
result = avoid_observing_if_imitator_blocked_angle_hopper(angle_135);
break;
default:
result = true;
break;
}
if (result)
result = pipe_validate_observation_recursive_delegate(si);
TraceFunctionExit(__func__);
TraceFunctionResult("%u",result);
TraceFunctionResultEnd();
return result;
}
/* Validate the geometry of observation according to Grid Chess
* @return true iff the observation is valid
*/
boolean grid_validate_observation_geometry(slice_index si)
{
return (is_not_in_same_cell(CURRMOVE_OF_PLY(nbply))
&& pipe_validate_observation_recursive_delegate(si));
}
/* Determine the length of a move for the Black Checks condition; the higher the
* value the more likely the move is going to be played.
* @return a value expressing the precedence of this move
*/
int blackchecks_measure_length(void)
{
return move_generation_stack[CURRMOVE_OF_PLY(nbply)].arrival!=nullsquare;
}
boolean bouncy_nightrider_check(validator_id evaluate)
{
square const sq_target = move_generation_stack[CURRMOVE_OF_PLY(nbply)].capture;
clearedgestraversed();
return rrefnech(sq_target, evaluate);
}
boolean bouncy_knight_check(validator_id evaluate)
{
square const sq_target = move_generation_stack[CURRMOVE_OF_PLY(nbply)].capture;
return rrefcech(sq_target, 2, evaluate);
}
/* 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;
}
void push_move_copy(numecoup original)
{
++current_move[nbply];
move_generation_stack[CURRMOVE_OF_PLY(nbply)] = move_generation_stack[original];
}
/* Reject generated non-captures
* @param si identifies the slice
*/
void move_generation_reject_non_captures(slice_index si)
{
numecoup const base = CURRMOVE_OF_PLY(nbply);
pipe_move_generation_delegate(si);
move_generator_filter_noncaptures(base,&always_reject);
}
