boolean magic_enforce_observer(slice_index si)
{
boolean result;
TraceFunctionEntry(__func__);
TraceFunctionParamListEnd();
if (are_we_finding_magic_views[nbply])
{
square const sq_observer = move_generation_stack[CURRMOVE_OF_PLY(nbply)].departure;
if (TSTFLAG(being_solved.spec[sq_observer],Magic))
{
if (pipe_validate_observation_recursive_delegate(si))
identify_line();
result = false; /* we need all views */
}
else
result = false;
}
else
result = pipe_validate_observation_recursive_delegate(si);
TraceFunctionExit(__func__);
TraceFunctionResult("%u",result);
TraceFunctionResultEnd();
return result;
}
/* Make sure that the observer has the expected walk - annanised or originally
* @return true iff the observation is valid
*/
boolean annan_enforce_observer_walk(slice_index si)
{
square const sq_departure = move_generation_stack[CURRMOVE_OF_PLY(nbply)].departure;
Side const side_attacking = trait[nbply];
numvec const dir_annaniser = side_attacking==White ? dir_down : dir_up;
square const pos_annaniser = sq_departure+dir_annaniser;
piece_walk_type walk;
boolean result;
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",si);
TraceFunctionParamListEnd();
if (annanises(side_attacking,pos_annaniser,sq_departure))
walk = get_walk_of_piece_on_square(pos_annaniser);
else
walk = get_walk_of_piece_on_square(sq_departure);
if (walk==observing_walk[nbply])
result = pipe_validate_observation_recursive_delegate(si);
else
result = false;
TraceFunctionExit(__func__);
TraceFunctionResult("%u",result);
TraceFunctionResultEnd();
return result;
}
boolean amu_count_observation(slice_index si)
{
boolean result;
TraceFunctionEntry(__func__);
TraceFunctionParamListEnd();
if (are_we_counting)
{
square const sq_departure = move_generation_stack[CURRMOVE_OF_PLY(nbply)].departure;
if (get_walk_of_piece_on_square(sq_departure)==observing_walk[nbply]
&& TSTFLAG(being_solved.spec[sq_departure],trait[nbply]))
{
/* this deals correctly with double attacks by the same piece (e.g. a rose) */
if (single_attacker_departure==sq_departure)
result = false;
else
{
++amu_attack_count;
single_attacker_departure = sq_departure;
result = amu_attack_count==2;
}
}
else
result = false;
}
else
result = pipe_validate_observation_recursive_delegate(si);
TraceFunctionExit(__func__);
TraceFunctionResult("%u",result);
TraceFunctionResultEnd();
return result;
}
/* Validate an observation according to Patrol Chess
* @return true iff the observation is valid
*/
boolean patrol_validate_observation(slice_index si)
{
boolean result;
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",si);
TraceFunctionParamListEnd();
if (TSTFLAG(being_solved.spec[move_generation_stack[CURRMOVE_OF_PLY(nbply)].departure],Patrol))
result = (is_mover_supported(CURRMOVE_OF_PLY(nbply))
&& pipe_validate_observation_recursive_delegate(si));
else
result = pipe_validate_observation_recursive_delegate(si);
TraceFunctionExit(__func__);
TraceFunctionResult("%u",result);
TraceFunctionResultEnd();
return result;
}
/* Make sure to behave correctly while detecting observations by vaulting kings
*/
boolean transmuting_kings_enforce_observer_walk(slice_index si)
{
boolean result;
square const sq_king = being_solved.king_square[trait[nbply]];
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",si);
TraceFunctionParamListEnd();
if (transmuting_kings_testing_transmutation[advers(trait[nbply])])
result = pipe_validate_observation_recursive_delegate(si);
else if (testing_with_non_transmuting_king[nbply])
{
assert(observing_walk[nbply]==get_walk_of_piece_on_square(sq_king));
if (move_generation_stack[CURRMOVE_OF_PLY(nbply)].departure==sq_king)
result = pipe_validate_observation_recursive_delegate(si);
else
result = false;
}
else if (move_generation_stack[CURRMOVE_OF_PLY(nbply)].departure==sq_king)
{
if (transmuting_kings_is_king_transmuting_as(observing_walk[nbply]))
{
piece_walk_type const save_walk = observing_walk[nbply];
observing_walk[nbply] = get_walk_of_piece_on_square(sq_king);
result = pipe_validate_observation_recursive_delegate(si);
observing_walk[nbply] = save_walk;
is_king_transmuting_as_observing_walk[nbply] = does_transmute;
}
else
{
result = false;
is_king_transmuting_as_observing_walk[nbply] = does_not_transmute;
}
}
else
result = pipe_validate_observation_recursive_delegate(si);
TraceFunctionExit(__func__);
TraceFunctionResult("%u",result);
TraceFunctionResultEnd();
return result;
}
/* Validate an observation according to Central Chess
* @return true iff the observation is valid
*/
boolean central_validate_observation(slice_index si)
{
boolean result;
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",si);
TraceFunctionParamListEnd();
result = (is_mover_supported(CURRMOVE_OF_PLY(nbply))
&& pipe_validate_observation_recursive_delegate(si));
TraceFunctionExit(__func__);
TraceFunctionResult("%u",result);
TraceFunctionResultEnd();
return result;
}
/* Validate an observation according to Superguards
* @return true iff the observation is valid
*/
boolean superguards_validate_observation(slice_index si)
{
boolean result;
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",si);
TraceFunctionParamListEnd();
result = (is_target_unguarded(CURRMOVE_OF_PLY(nbply))
&& pipe_validate_observation_recursive_delegate(si));
TraceFunctionExit(__func__);
TraceFunctionResult("%u",result);
TraceFunctionResultEnd();
return result;
}
/* Validate an observation according to Shielded Kings
* @return true iff the observation is valid
*/
boolean shielded_kings_validate_observation(slice_index si)
{
boolean result;
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",si);
TraceFunctionParamListEnd();
result = (is_not_king_captures_guarded_king(CURRMOVE_OF_PLY(nbply))
&& pipe_validate_observation_recursive_delegate(si));
TraceFunctionExit(__func__);
TraceFunctionResult("%u",result);
TraceFunctionResultEnd();
return result;
}
/* Make sure that the observer has the expected direction
* @return true iff the observation is valid
*/
boolean hunter_enforce_observer_direction(slice_index si)
{
boolean result;
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",si);
TraceFunctionParamListEnd();
result = ((direction_validator[nbply]==0
|| (*direction_validator[nbply])(CURRMOVE_OF_PLY(nbply)))
&& pipe_validate_observation_recursive_delegate(si));
TraceFunctionExit(__func__);
TraceFunctionResult("%u",result);
TraceFunctionResultEnd();
return result;
}
/* Validate an observation according to Disparate Chess
* @return true iff the observation is valid
*/
boolean disparate_validate_observation(slice_index si)
{
boolean result;
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",si);
TraceFunctionParamListEnd();
if (can_piece_move(CURRMOVE_OF_PLY(nbply)))
result = pipe_validate_observation_recursive_delegate(si);
else
result = false;
TraceFunctionExit(__func__);
TraceFunctionResult("%u",result);
TraceFunctionResultEnd();
return result;
}
/* Validate an observation according to Ultra-Mummer
* @return true iff the observation is valid
*/
boolean ultra_mummer_validate_observation(slice_index si)
{
Side const side_observing = trait[nbply];
boolean result;
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",si);
TraceFunctionParamListEnd();
conditional_pipe_solve_delegate(temporary_hack_ultra_mummer_length_measurer[side_observing]);
result = (*mummer_measure_length[side_observing])()==mum_length[nbply];
if (result)
result = pipe_validate_observation_recursive_delegate(si);
TraceFunctionExit(__func__);
TraceFunctionResult("%u",result);
TraceFunctionResultEnd();
return result;
}
boolean mars_enforce_observer(slice_index si)
{
circe_rebirth_context_elmt_type * const context = &circe_rebirth_context_stack[circe_rebirth_context_stack_pointer-1];
square const sq_departure = move_generation_stack[CURRMOVE_OF_PLY(nbply)].departure;
square const sq_observer = context->rebirth_square;
boolean result;
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",si);
TraceFunctionParamListEnd();
assert(circe_rebirth_context_stack_pointer>0);
if (sq_observer==sq_departure)
{
/* restore as if the capture had occcured directly, to allow other
* conditions (e.g. Madrasi) to correctly work. */
Flags const spec_observing = being_solved.spec[sq_observer];
empty_square(sq_observer);
occupy_square(context->rebirth_from,observing_walk[nbply],spec_observing);
move_generation_stack[CURRMOVE_OF_PLY(nbply)].departure = context->rebirth_from;
result = pipe_validate_observation_recursive_delegate(si);
move_generation_stack[CURRMOVE_OF_PLY(nbply)].departure = sq_observer;
empty_square(context->rebirth_from);
occupy_square(sq_observer,observing_walk[nbply],spec_observing);
}
else
result = false;
TraceFunctionExit(__func__);
TraceFunctionResult("%u",result);
TraceFunctionResultEnd();
return result;
}
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;
}
/* Make sure to behave correctly while detecting observations by vaulting kings
*/
boolean vaulting_kings_enforce_observer_walk(slice_index si)
{
boolean result;
Side const side_observing = trait[nbply];
square const sq_king = being_solved.king_square[side_observing];
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",si);
TraceFunctionParamListEnd();
if (transmuting_kings_testing_transmutation[advers(side_observing)])
result = pipe_validate_observation_recursive_delegate(si);
else if (move_generation_stack[CURRMOVE_OF_PLY(nbply)].departure==sq_king)
{
if (is_king_vaulting[nbply]==dont_know)
is_king_vaulting[nbply] = is_kingsquare_observed() ? does_vault : does_not_vault;
if (is_king_vaulting[nbply]==does_vault)
{
if (is_king_vaulter(side_observing,observing_walk[nbply]))
{
piece_walk_type const save_walk = observing_walk[nbply];
observing_walk[nbply] = get_walk_of_piece_on_square(sq_king);
result = pipe_validate_observation_recursive_delegate(si);
observing_walk[nbply] = save_walk;
if (!result && !vaulting_kings_transmuting[side_observing])
result = pipe_validate_observation_recursive_delegate(si);
}
else
result = pipe_validate_observation_recursive_delegate(si);
}
else
result = pipe_validate_observation_recursive_delegate(si);
}
else
result = pipe_validate_observation_recursive_delegate(si);
TraceFunctionExit(__func__);
TraceFunctionResult("%u",result);
TraceFunctionResultEnd();
return result;
}
/* 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));
}
