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)); }