/* 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();
}
/* Instrument the stipulation representation so that it can solve and enforce
* threats
* @param si identifies slice where to start
*/
void solving_insert_threat_handlers(slice_index si)
{
stip_structure_traversal st;
slice_index threat_start = no_slice;
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",si);
TraceFunctionParamListEnd();
stip_structure_traversal_init(&st,&threat_start);
stip_structure_traversal_override_by_contextual(&st,
slice_contextual_testing_pipe,
&stip_traverse_structure_children_pipe);
stip_structure_traversal_override_by_contextual(&st,
slice_contextual_conditional_pipe,
&stip_traverse_structure_children_pipe);
stip_structure_traversal_override(&st,
threat_handler_inserters,
nr_threat_handler_inserters);
stip_traverse_structure(si,&st);
reset_tables();
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
/* Instrument the solving machinery so that postkey play is suppressed
* @param si identifies the root of the solving machinery
*/
void solving_insert_play_suppressors(slice_index si)
{
stip_structure_traversal st;
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",si);
TraceFunctionParamListEnd();
stip_structure_traversal_init(&st,0);
stip_structure_traversal_override_by_contextual(&st,
slice_contextual_conditional_pipe,
&stip_traverse_structure_children_pipe);
stip_structure_traversal_override_by_contextual(&st,
slice_contextual_testing_pipe,
&stip_traverse_structure_children_pipe);
stip_structure_traversal_override_by_contextual(&st,
slice_contextual_binary,
&stip_traverse_structure_children_pipe);
stip_structure_traversal_override(&st,
play_suppressors_inserters,
nr_play_suppressors_inserters);
stip_traverse_structure(si,&st);
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();
}
/*
* 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();
}
/* 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();
}
/* 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);
}
/* 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();
}
/* Instrument a stipulation with STMaxSolutions*Filter slices
* @param si identifies slice where to start
*/
static void instrument_solvers(slice_index si)
{
stip_structure_traversal st;
insertion_struct insertion = { false, SLICE_NEXT2(si) };
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",si);
TraceFunctionParamListEnd();
TraceStipulation(si);
{
slice_index const prototypes[] =
{
alloc_maxsolutions_initialiser_slice()
};
enum
{
nr_prototypes = sizeof prototypes / sizeof prototypes[0]
};
slice_insertion_insert(si,prototypes,nr_prototypes);
}
stip_structure_traversal_init(&st,&insertion);
stip_structure_traversal_override_by_contextual(&st,
slice_contextual_conditional_pipe,
&stip_traverse_structure_children_pipe);
stip_structure_traversal_override(&st,
maxsolutions_filter_inserters,
nr_maxsolutions_filter_inserters);
stip_traverse_structure(si,&st);
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 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();
}
static void help_branch_insert_slices_impl(slice_index si,
slice_index const prototypes[],
unsigned int nr_prototypes,
slice_index base)
{
stip_structure_traversal st;
branch_slice_insertion_state_type state =
{
prototypes, nr_prototypes,
slice_rank_order, nr_slice_rank_order_elmts, 0,
branch_slice_rank_order_recursive,
0,
si,
0
};
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",si);
TraceFunctionParam("%u",nr_prototypes);
TraceFunctionParamListEnd();
slice_insertion_init_traversal(&st,&state,stip_traversal_context_help);
move_init_slice_insertion_traversal(&st);
state.base_rank = get_slice_rank(SLICE_TYPE(base),&state);
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();
}
/* Instrument stipulation with STKeepMatingFilter slices
* @param si identifies slice where to start
*/
void solving_insert_keepmating_filters(slice_index si)
{
insertion_state_type state = { { false, false } };
stip_structure_traversal st;
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",si);
TraceFunctionParamListEnd();
TraceStipulation(si);
stip_structure_traversal_init(&st,&state);
stip_structure_traversal_override_by_contextual(&st,
slice_contextual_end_of_branch,
&keepmating_filter_inserter_end_of_branch);
stip_structure_traversal_override_by_contextual(&st,
slice_contextual_conditional_pipe,
&keepmating_filter_inserter_end_of_branch);
stip_structure_traversal_override_by_contextual(&st,
slice_contextual_binary,
&keepmating_filter_inserter_binary);
stip_structure_traversal_override(&st,
keepmating_filter_inserters,
nr_keepmating_filter_inserters);
stip_traverse_structure(si,&st);
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();
}
static void move_generation_branch_insert_slices_impl(slice_index generating,
slice_index const prototypes[],
unsigned int nr_prototypes,
slice_index base)
{
stip_structure_traversal st;
branch_slice_insertion_state_type state =
{
prototypes,nr_prototypes,
slice_rank_order, nr_slice_rank_order_elmts, 1,
branch_slice_rank_order_nonrecursive,
0,
generating,
0
};
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",generating);
TraceFunctionParamListEnd();
state.base_rank = get_slice_rank(SLICE_TYPE(base),&state);
assert(state.base_rank!=no_slice_rank);
slice_insertion_init_traversal(&st,&state,stip_traversal_context_intro);
circe_init_slice_insertion_traversal(&st);
stip_traverse_structure(generating,&st);
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
/* 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 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();
}
/* 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_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();
}
/* 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 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();
}
/* Instrument the solving machinery with move generator slices
* @param si identifies root the solving machinery
*/
void solving_insert_move_generators(slice_index si)
{
stip_structure_traversal st;
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",si);
TraceFunctionParamListEnd();
stip_structure_traversal_init(&st,0);
stip_structure_traversal_override(&st,solver_inserters,nr_solver_inserters);
stip_traverse_structure(si,&st);
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
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 stipulation representation with proxy slices marking the
* beginning and end of the threat
* @param si identifies slice where to start
*/
void solving_insert_threat_boundaries(slice_index si)
{
stip_structure_traversal st;
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",si);
TraceFunctionParamListEnd();
stip_structure_traversal_init(&st,0);
stip_structure_traversal_override(&st,
threat_boundaries_inserters,
nr_threat_boundaries_inserters);
stip_traverse_structure(si,&st);
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();
}
