/* Inialise the observation machinery with transmuting kings
* @param si identifies root slice of solving machinery
* @param side for whom
* @note invoked by transmuting_kings_initialise_observing()
*/
void transmuting_kings_initialise_observing(slice_index si, Side side)
{
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",si);
TraceEnumerator(Side,side);
TraceFunctionParamListEnd();
{
instrumentation_state_type state = { side, no_slice };
stip_structure_traversal st;
stip_structure_traversal_init(&st,&state);
stip_structure_traversal_override_single(&st,
STTestingIfSquareIsObserved,
&instrument_testing);
stip_structure_traversal_override_single(&st,
STTransmutingKingDetectNonTransmutation,
&remember_detector);
stip_traverse_structure(si,&st);
}
stip_instrument_observation_validation(si,side,STTransmutingKingsEnforceObserverWalk);
stip_instrument_check_validation(si,side,STTransmutingKingsEnforceObserverWalk);
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
/* Instrument a stipulation
* @param si identifies root slice of stipulation
*/
void solving_insert_republican_king_placers(slice_index si)
{
stip_structure_traversal st;
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",si);
TraceFunctionParamListEnd();
stip_structure_traversal_init(&st,0);
stip_structure_traversal_override_single(&st,
STMove,
&instrument_move);
stip_structure_traversal_override_single(&st,
STTemporaryHackFork,
&stip_traverse_structure_children_pipe);
if (RepublicanType==ConditionType1)
stip_structure_traversal_override_single(&st,
STGoalReachedTester,
&stip_traverse_structure_children_pipe);
stip_traverse_structure(si,&st);
if (RepublicanType==ConditionType1)
insert_type1_dead_end(si);
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
/* Instrument the solvers with Patrol Chess
* @param si identifies the root slice of the stipulation
*/
void solving_insert_take_and_make(slice_index si)
{
stip_structure_traversal st;
boolean collecting_rebirth_squares = false;
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",si);
TraceFunctionParamListEnd();
TraceStipulation(si);
stip_structure_traversal_init(&st,&collecting_rebirth_squares);
stip_structure_traversal_override_single(&st,
STExecutingKingCapture,
&stip_structure_visitor_noop);
if (CondFlag[normalp])
stip_structure_traversal_override_single(&st,
STDoneGeneratingMoves,
&insert_make_generator);
else
/* Extra rule: pawns must not 'make' to their base line */
stip_structure_traversal_override_single(&st,
STDoneGeneratingMoves,
&insert_make_generator_avoid_pawn_to_baseline);
stip_traverse_structure(si,&st);
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
/* Initialise solving with BGL
*/
void bgl_initialise_solving(slice_index si)
{
TraceFunctionEntry(__func__);
TraceFunctionParamListEnd();
{
stip_structure_traversal st;
stip_structure_traversal_init(&st,0);
stip_structure_traversal_override_single(&st,
STDoneGeneratingMoves,
&insert_remover);
stip_traverse_structure(si,&st);
}
{
stip_structure_traversal st;
stip_structure_traversal_init(&st,0);
stip_structure_traversal_override_single(&st,STMove,&instrument_move);
stip_traverse_structure(si,&st);
}
if (BGL_values[White]!=BGL_infinity)
{
stip_instrument_observation_validation(si,White,STBGLEnforcer);
stip_instrument_check_validation(si,White,STBGLEnforcer);
}
if (BGL_values[Black]!=BGL_infinity)
{
stip_instrument_observation_validation(si,Black,STBGLEnforcer);
stip_instrument_check_validation(si,Black,STBGLEnforcer);
}
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
/* Initialise the solving machinery with Extinction Chess
* @param si identifies root slice of stipulation
*/
void extinction_initialise_solving(slice_index si)
{
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",si);
TraceFunctionParamListEnd();
/* we have to actually play potentially extincting moves to find out whether
* they really are in conditions such as Circe
*/
stip_instrument_check_validation(si,
nr_sides,
STValidateCheckMoveByPlayingCapture);
{
stip_structure_traversal st;
stip_structure_traversal_init(&st,0);
stip_structure_traversal_override_single(&st,
STGoalKingCaptureReachedTester,
&substitute_extinction_tester);
stip_structure_traversal_override_single(&st,
STKingSquareObservationTester,
&substitute_all_pieces_observation_tester);
stip_traverse_structure(si,&st);
}
check_even_if_no_king();
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
/* Inialise the solving machinery with Face-to-face Chess
* @param si identifies root slice of solving machinery
*/
static void initialise_solving(slice_index si,
slice_type generator,
slice_type enforcer)
{
TraceFunctionEntry(__func__);
TraceFunctionParamListEnd();
solving_instrument_move_generation(si,nr_sides,generator);
{
stip_structure_traversal st;
stip_structure_traversal_init(&st,&enforcer);
stip_structure_traversal_override_single(&st,
STEnforceObserverWalk,
&substitute_enforce_confronted_walk);
stip_structure_traversal_override_single(&st,
STValidatingObserver,
&stip_structure_visitor_noop);
stip_structure_traversal_override_single(&st,
STValidatingObservationGeometry,
&stip_structure_visitor_noop);
stip_traverse_structure(si,&st);
}
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
/* Create the root slices of a battle branch
* @param adapter identifies the adapter slice at the beginning of the branch
* @param state address of structure holding state
*/
void battle_branch_make_root_slices(slice_index adapter,
spin_off_state_type *state)
{
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",adapter);
TraceFunctionParamListEnd();
{
stip_structure_traversal st;
stip_structure_traversal_init(&st,state);
stip_structure_traversal_override_by_structure(&st,
slice_structure_leaf,
&leaf_spin_off_copy);
stip_structure_traversal_override_by_structure(&st,
slice_structure_pipe,
&pipe_spin_off_copy);
stip_structure_traversal_override_by_structure(&st,
slice_structure_branch,
&pipe_spin_off_copy);
stip_structure_traversal_override_by_structure(&st,
slice_structure_fork,
&fork_make_root);
stip_structure_traversal_override_by_contextual(&st,
slice_contextual_binary,
&binary_make_root);
stip_structure_traversal_override_by_contextual(&st,
slice_contextual_conditional_pipe,
&conditional_pipe_spin_off_copy);
stip_structure_traversal_override_single(&st,
STReadyForDefense,
&ready_for_defense_make_root);
stip_structure_traversal_override_single(&st,
STConstraintTester,
&constraint_tester_make_root);
stip_structure_traversal_override_single(&st,
STGoalConstraintTester,
&goal_constraint_tester_make_root);
stip_structure_traversal_override_single(&st,
STReadyForDefense,
&ready_for_defense_make_root);
stip_structure_traversal_override_single(&st,
STEndOfRoot,
&serve_as_root_hook);
stip_traverse_structure(adapter,&st);
}
TraceFunctionExit(__func__);
TraceFunctionParamListEnd();
}
static void insert_promoters(slice_index si)
{
stip_structure_traversal st;
slice_index landing = no_slice;
TraceFunctionEntry(__func__);
TraceFunctionParamListEnd();
stip_structure_traversal_init(&st,&landing);
stip_structure_traversal_override_single(&st,STBeforePawnPromotion,&instrument_promotion);
stip_structure_traversal_override_single(&st,STLandingAfterPawnPromotion,&remember_landing);
stip_traverse_structure(si,&st);
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
/*
* Instrument the solving machinery with slices that write the solution in
* plain text
*/
void output_plaintext_instrument_solving(slice_index si)
{
stip_structure_traversal st;
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",si);
TraceFunctionParamListEnd();
TraceStipulation(si);
stip_structure_traversal_init(&st,0);
stip_structure_traversal_override_single(&st,
STOutputModeSelector,
&visit_output_mode_selector);
stip_traverse_structure(si,&st);
{
slice_index const prototypes[] =
{
alloc_output_plaintext_end_of_phase_writer_slice()
};
enum
{
nr_prototypes = sizeof prototypes / sizeof prototypes[0]
};
slice_insertion_insert(si,prototypes,nr_prototypes);
}
solving_insert_move_inversion_counter_slices(si);
pipe_solve_delegate(si);
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
/* Remember the id of the piece to be kissed
* @param si root of the solving machinery
*/
void goal_kiss_init_piece_id(slice_index si)
{
stip_structure_traversal st;
stip_structure_traversal_init(&st,0);
stip_structure_traversal_override_single(&st,STGoalReachedTester,&remember_id);
stip_traverse_structure(si,&st);
}
/* Instrument the solvers with Patrol Chess
* @param si identifies the root slice of the stipulation
*/
void solving_insert_nocapture(slice_index si)
{
stip_structure_traversal st;
boolean enabled[nr_sides] =
{
CondFlag[nocapture] || CondFlag[nowhcapture],
CondFlag[nocapture] || CondFlag[noblcapture]
};
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",si);
TraceFunctionParamListEnd();
TraceStipulation(si);
solving_impose_starter(si,SLICE_STARTER(si));
stip_structure_traversal_init(&st,&enabled);
stip_structure_traversal_override_single(&st,
STDoneGeneratingMoves,
&insert_remover);
stip_traverse_structure(si,&st);
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
/* Instrument slices with move tracers
*/
void solving_insert_imitator(slice_index si)
{
TraceFunctionEntry(__func__);
TraceFunctionParamListEnd();
{
stip_structure_traversal st;
stip_structure_traversal_init(&st,0);
stip_structure_traversal_override_single(&st,
STDoneGeneratingMoves,
&insert_remover);
stip_traverse_structure(si,&st);
}
if (!CondFlag[noiprom])
insert_promoters(si);
stip_instrument_moves(si,STImitatorMover);
stip_instrument_moves(si,STImitatorDetectIllegalMoves);
stip_instrument_observation_geometry_validation(si,
nr_sides,
STImitatorRemoveIllegalMoves);
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
/* Attempt to apply the postkey play option to the current stipulation
* @param root_proxy identifies root proxy slice
* @return true iff postkey play option is applicable (and has been
* applied)
*/
static boolean battle_branch_apply_postkeyplay(slice_index root_proxy)
{
boolean result;
slice_index postkey_slice = no_slice;
stip_structure_traversal st;
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",root_proxy);
TraceFunctionParamListEnd();
TraceStipulation(root_proxy);
stip_structure_traversal_init(&st,&postkey_slice);
stip_structure_traversal_override_by_structure(&st,
slice_structure_pipe,
&move_to_postkey);
stip_structure_traversal_override_by_contextual(&st,
slice_contextual_testing_pipe,
&move_to_postkey);
stip_structure_traversal_override_single(&st,
STAttackAdapter,
&attack_adapter_make_postkeyplay);
stip_structure_traversal_override_single(&st,
STHelpAdapter,
&stip_structure_visitor_noop);
stip_traverse_structure_children_pipe(root_proxy,&st);
if (postkey_slice==no_slice)
result = false;
else
{
link_to_branch(root_proxy,postkey_slice);
{
slice_index const prototype = alloc_move_inverter_slice();
slice_insertion_insert(root_proxy,&prototype,1);
}
result = true;
}
TraceFunctionExit(__func__);
TraceFunctionParam("%u",result);
TraceFunctionParamListEnd();
return result;
}
/* Spin off slices for testing whethere there is a solution
* @param si root slice of the stipulation
*/
void solving_spin_off_testers(slice_index si)
{
stip_structure_traversal st;
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",si);
TraceFunctionParamListEnd();
TraceStipulation(si);
stip_structure_traversal_init(&st,0);
stip_structure_traversal_override_by_structure(&st,
slice_structure_pipe,
&stip_spin_off_testers_pipe);
stip_structure_traversal_override_by_structure(&st,
slice_structure_branch,
&stip_spin_off_testers_pipe);
stip_structure_traversal_override_by_structure(&st,
slice_structure_fork,
&stip_spin_off_testers_fork);
stip_structure_traversal_override_by_structure(&st,
slice_structure_leaf,
&stip_spin_off_testers_leaf);
stip_structure_traversal_override_by_contextual(&st,
slice_contextual_binary,
&stip_spin_off_testers_binary);
stip_structure_traversal_override_by_contextual(&st,
slice_contextual_testing_pipe,
&stip_spin_off_testers_testing_pipe);
stip_structure_traversal_override_by_contextual(&st,
slice_contextual_conditional_pipe,
&stip_spin_off_testers_conditional_pipe);
stip_structure_traversal_override_single(&st,STTemporaryHackFork,&stip_spin_off_testers_pipe_skip);
stip_structure_traversal_override_single(&st,STPlaySuppressor,&stip_spin_off_testers_pipe_skip);
stip_structure_traversal_override_single(&st,STIfThenElse,&stip_spin_off_testers_if_then_else);
stip_traverse_structure(si,&st);
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
/* Has the input branch already been instrumend with a proofgame solver?
* @param start entry into input branch
* @return true iff input branch has already been instrumend
*/
boolean input_is_instrumented_with_proof(slice_index start)
{
boolean result = false;
stip_structure_traversal st;
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",start);
TraceFunctionParamListEnd();
stip_structure_traversal_init(&st,&result);
stip_structure_traversal_override_single(&st,STProofSolverBuilder,&report_instrumented);
stip_structure_traversal_override_single(&st,STAToBSolverBuilder,&report_instrumented);
stip_structure_traversal_override_single(&st,STStartOfCurrentTwin,&stip_structure_visitor_noop);
stip_traverse_structure(start,&st);
TraceFunctionExit(__func__);
TraceFunctionResult("%u",result);
TraceFunctionResultEnd();
return result;
}
/* Notify the output machinery about a twinning event
* @param si identifies the slice that detected the twinning (at the same time
* to be used as the starting point of any instrumentation)
* @param stage the twinning event
* @param continued is the twin continued?
*/
void output_notify_twinning(slice_index si,
twinning_event_type event,
boolean continued)
{
stip_structure_traversal st;
notification_struct e = { event, continued };
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",si);
TraceFunctionParam("%u",event);
TraceFunctionParam("%u",continued);
TraceFunctionParamListEnd();
stip_structure_traversal_init(&st,&e);
stip_structure_traversal_override_single(&st,STOutputPlaintextTwinIntroWriterBuilder,¬ify_medium);
stip_structure_traversal_override_single(&st,STOutputLaTeXTwinningWriterBuilder,¬ify_medium);
stip_traverse_structure(si,&st);
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
/* Instrument the solving machinery for BlackChecks
* @param si identifies root slice of stipulation
*/
void blackchecks_initialise_solving(slice_index si)
{
stip_structure_traversal st;
slice_index landing = no_slice;
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",si);
TraceFunctionParamListEnd();
stip_structure_traversal_init(&st,&landing);
stip_structure_traversal_override_single(&st,STGoalReachedTester,&stip_structure_visitor_noop);
stip_structure_traversal_override_single(&st,STMove,&instrument_move);
stip_structure_traversal_override_single(&st,STGeneratingMoves,&instrument_move_generator);
stip_structure_traversal_override_single(&st,
STLandingAfterMovingPieceMovement,
&remember_landing);
stip_traverse_structure(si,&st);
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
/* Instrument the solving machinery with king capture avoiders
* @param si identifies root slice of the solving machinery
*/
void solving_insert_king_capture_avoiders(slice_index si)
{
insertion_state state = root_state;
stip_structure_traversal st;
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",si);
TraceFunctionParamListEnd();
stip_structure_traversal_init(&st,&state);
stip_structure_traversal_override_single(&st,
STMove,
&instrument_move);
stip_structure_traversal_override_single(&st,
STGoalCounterMateReachedTester,
&remember_goal_with_potential_king_capture);
stip_structure_traversal_override_single(&st,
STGoalDoubleMateReachedTester,
&remember_goal_with_potential_king_capture);
stip_structure_traversal_override_single(&st,
STBrunnerDefenderFinder,
&stip_traverse_structure_children_pipe);
stip_structure_traversal_override_single(&st,
STKingCaptureLegalityTester,
&stip_traverse_structure_children_pipe);
stip_structure_traversal_override_single(&st,
STMoveLegalityTester,
&stip_traverse_structure_children_pipe);
stip_traverse_structure(si,&st);
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
/* Create the root slices of a help branch
* @param adapter identifies the adapter slice at the beginning of the branch
* @param state address of structure holding state
*/
void help_branch_make_root_slices(slice_index adapter,
spin_off_state_type *state)
{
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",adapter);
TraceFunctionParamListEnd();
{
stip_structure_traversal st;
TraceStipulation(adapter);
stip_structure_traversal_init(&st,state);
stip_structure_traversal_override_by_structure(&st,
slice_structure_pipe,
&pipe_spin_off_copy);
stip_structure_traversal_override_by_structure(&st,
slice_structure_branch,
&pipe_spin_off_copy);
stip_structure_traversal_override_by_contextual(&st,
slice_contextual_binary,
&binary_make_root);
stip_structure_traversal_override_by_structure(&st,
slice_structure_fork,
&fork_make_root);
stip_structure_traversal_override_by_contextual(&st,
slice_contextual_conditional_pipe,
&conditional_pipe_spin_off_copy);
stip_structure_traversal_override_single(&st,
STConstraintTester,
&constraint_tester_make_root);
stip_structure_traversal_override_single(&st,STEndOfRoot,&serve_as_root_hook);
stip_traverse_structure(adapter,&st);
}
TraceValue("%u\n",state->spun_off[adapter]);
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
/* Instrument the move generation machinery so that there are two paths which
* can be adapted separately.
* @param si root slice of solving machinery
* @param side side for which to instrument; pass nr_sides for both sides
* @note inserts proxy slices STMoveForPieceGeneratorStandardPath and
* STMoveForPieceGeneratorAlternativePath that can be used for adjusting the move
* generation
*/
void move_generator_instrument_for_alternative_paths(slice_index si, Side side)
{
stip_structure_traversal st;
solving_instrument_move_generation(si,
side,
STMoveForPieceGeneratorPathsJoint);
stip_structure_traversal_init(&st,0);
stip_structure_traversal_override_single(&st,
STMoveForPieceGeneratorPathsJoint,
&insert_separator);
stip_traverse_structure(si,&st);
}
static void insert_type1_dead_end(slice_index si)
{
stip_structure_traversal st;
TraceFunctionEntry(__func__);
TraceFunctionParamListEnd();
stip_structure_traversal_init(&st,0);
stip_structure_traversal_override_single(&st,STMove,&instrument_defense);
stip_traverse_structure(si,&st);
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
static void substitute_single_piece_move_generator(Side side)
{
stip_structure_traversal st;
TraceFunctionEntry(__func__);
TraceFunctionParamListEnd();
stip_structure_traversal_init(&st,0);
stip_structure_traversal_override_single(&st,STMoveGenerator,&do_substitute);
stip_traverse_structure(SLICE_NEXT2(temporary_hack_circe_take_make_rebirth_squares_finder[side]),&st);
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
static void insert_enforcers(slice_index si, stip_structure_traversal *st)
{
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",si);
TraceFunctionParamListEnd();
stip_traverse_structure_children(si,st);
{
stip_deep_copies_type copies;
stip_structure_traversal st_nested;
slice_index const * const threat_start = st->param;
slice_index const threat_start_tester = SLICE_TESTER(*threat_start);
assert(*threat_start!=no_slice);
assert(threat_start_tester!=no_slice);
assert(SLICE_TYPE(threat_start_tester)==STThreatStart);
{
slice_index const prototype = alloc_pipe(STThreatDefeatedTester);
attack_branch_insert_slices(threat_start_tester,&prototype,1);
}
init_deep_copy(&st_nested,st,&copies);
stip_structure_traversal_override_single(&st_nested,
STThreatDefeatedTester,
&move_and_stop_copying);
stip_structure_traversal_override_by_contextual(&st_nested,
slice_contextual_conditional_pipe,
©_shallow);
stip_structure_traversal_override_by_contextual(&st_nested,
slice_contextual_testing_pipe,
©_shallow);
stip_traverse_structure(threat_start_tester,&st_nested);
SLICE_NEXT2(si) = copies[threat_start_tester];
}
{
/* if the threats are short, max_unsolvable might interfere with enforcing
* them */
slice_index const prototype = alloc_reset_unsolvable_slice();
attack_branch_insert_slices(SLICE_NEXT2(si),&prototype,1);
}
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
/* Inialise the solving machinery with Anti-Mars Circe
* @param si identifies root slice of solving machinery
*/
void solving_initialise_antimars(slice_index si)
{
TraceFunctionEntry(__func__);
TraceFunctionParamListEnd();
{
stip_structure_traversal st;
stip_structure_traversal_init(&st,0);
stip_structure_traversal_override_single(&st,
STMoveForPieceGeneratorStandardPath,
&instrument_rebirth);
stip_structure_traversal_override_single(&st,
STMoveForPieceGeneratorAlternativePath,
&instrument_no_rebirth);
stip_traverse_structure(si,&st);
}
circe_initialise_solving(si,
&antimars_variant,
STMoveForPieceGeneratorStandardPath,
&slice_insertion_insert_contextually,
STAntimarsCirceConsideringRebirth);
circe_instrument_solving(si,
STAntimarsCirceConsideringRebirth,
STCirceDeterminedRebirth,
alloc_pipe(STMarscirceRemoveCapturer));
if (antimars_variant.rebirth_reason==move_effect_reason_rebirth_choice)
circe_instrument_solving(si,
STAntimarsCirceConsideringRebirth,
STAntimarsCirceConsideringRebirth,
alloc_pipe(STMoveGenerationPostMoveIterator));
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
/* Instrument a stipulation
* @param si identifies root slice of stipulation
*/
void mummer_initialise_solving(slice_index si)
{
instrumentation_state_type state = { false, no_side };
stip_structure_traversal st;
TraceFunctionEntry(__func__);
TraceFunctionParamListEnd();
TraceStipulation(si);
solving_impose_starter(si,SLICE_STARTER(si));
stip_structure_traversal_init(&st,&state);
/* instrumentation for regular mummer */
stip_structure_traversal_override_single(&st,
STMoveGenerator,
&instrument_move_generator);
stip_structure_traversal_override_single(&st,
STMummerOrchestrator,
&spin_off_measuring_branch);
stip_structure_traversal_override_single(&st,
STMummerDeadend,
&connect_solver_to_tester);
stip_structure_traversal_override_single(&st,
STExecutingKingCapture,
&stip_structure_visitor_noop);
if (mummer_strictness[White]!=mummer_strictness_ultra
&& mummer_strictness[Black]!=mummer_strictness_ultra)
stip_structure_traversal_override_single(&st,
STImmobilityTester,
&stip_structure_visitor_noop);
/* additional instrumentation for ultra mummer */
stip_structure_traversal_override_single(&st,
STUltraMummerMeasurerFork,
&instrument_ultra_mummer_measurer_fork);
stip_traverse_structure(si,&st);
if (mummer_strictness[White]==mummer_strictness_ultra)
{
stip_instrument_observation_validation(si,White,STValidatingObservationUltraMummer);
stip_instrument_check_validation(si,White,STValidatingObservationUltraMummer);
}
if (mummer_strictness[Black]==mummer_strictness_ultra)
{
stip_instrument_observation_validation(si,Black,STValidatingObservationUltraMummer);
stip_instrument_check_validation(si,Black,STValidatingObservationUltraMummer);
}
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
/* Execute the optimisations planned before and communicated using a series of
* invokations of ohneschach_stop_if_check_plan_to_optimise_away_stop()
* @param root root slice of the stiptulation
*/
void ohneschach_stop_if_check_execute_optimisations(slice_index root)
{
stip_structure_traversal st;
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",root);
TraceFunctionParamListEnd();
stip_structure_traversal_init(&st,0);
stip_structure_traversal_override_single(&st,
STOhneschachStopIfCheckAndNotMate,
&optimise_stop);
stip_traverse_structure(root,&st);
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
static void instrument(slice_index si)
{
/* we have to actually play potentially assassinating moves
*/
stip_instrument_check_validation(si,
nr_sides,
STValidateCheckMoveByPlayingCapture);
{
stip_structure_traversal st;
stip_structure_traversal_init(&st,0);
stip_structure_traversal_override_single(&st,
STKingSquareObservationTester,
&substitute_all_pieces_observation_tester);
stip_traverse_structure(si,&st);
}
}
/* When counting mating moves, it is not necessary to detect self-check in moves
* that don't deliver mate; remove the slices that would detect these
* self-checks
* @param si identifies slice where to start
*/
void optimise_away_unnecessary_selfcheckguards(slice_index si)
{
stip_structure_traversal st;
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",si);
TraceFunctionParamListEnd();
stip_structure_traversal_init(&st,0);
stip_structure_traversal_override_single(&st,
STExclusiveChessMatingMoveCounterFork,
&remove_guard);
stip_traverse_structure(si,&st);
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
/* Produce slices representing set play.
* This is supposed to be invoked from within the slice type specific
* functions invoked by stip_apply_setplay.
* @param adapter identifies the adapter slice into the battle branch
* @param state address of structure holding state
*/
void battle_branch_make_setplay(slice_index adapter, spin_off_state_type *state)
{
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",adapter);
TraceFunctionParamListEnd();
{
slice_index const start = branch_find_slice(STReadyForDefense,
adapter,
stip_traversal_context_intro);
stip_structure_traversal st;
slice_index const notend = branch_find_slice(STNotEndOfBranchGoal,
adapter,
stip_traversal_context_intro);
slice_index const prototype = alloc_pipe(STEndOfRoot);
assert(notend!=no_slice);
defense_branch_insert_slices(notend,&prototype,1);
assert(start!=no_slice);
stip_structure_traversal_init(&st,state);
st.context = stip_traversal_context_defense;
stip_structure_traversal_override_by_structure(&st,
slice_structure_pipe,
©_to_setplay);
stip_structure_traversal_override_by_structure(&st,
slice_structure_branch,
©_to_setplay);
stip_structure_traversal_override_by_structure(&st,
slice_structure_fork,
©_to_setplay);
stip_structure_traversal_override_single(&st,STEndOfRoot,&serve_as_root_hook);
stip_traverse_structure(start,&st);
TraceValue("%u",state->spun_off[start]);
TraceEOL();
state->spun_off[adapter] = state->spun_off[start];
}
TraceValue("%u",state->spun_off[adapter]);
TraceEOL();
TraceFunctionExit(__func__);
TraceFunctionParamListEnd();
}
/* Replace immobility tester slices' type
* @param si where to start (entry slice into stipulation)
*/
void immobility_testers_substitute_king_first(slice_index si)
{
stip_structure_traversal st;
TraceFunctionEntry(__func__);
TraceFunctionParamListEnd();
TraceStipulation(si);
stip_structure_traversal_init(&st,0);
stip_structure_traversal_override_single(&st,
STImmobilityTester,
&substitute_king_first);
stip_traverse_structure(si,&st);
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}