static boolean are_all_imitator_lines_clear(numvec diff_first_necessarily_empty, numvec step, numvec diff_first_not_necessarily_empty) { boolean result = true; unsigned int i; TraceFunctionEntry(__func__); TraceValue("%d",diff_first_necessarily_empty); TraceValue("%d",step); TraceValue("%d",diff_first_not_necessarily_empty); TraceFunctionParamListEnd(); TraceValue("%u\n",being_solved.number_of_imitators); for (i = 0; i!=being_solved.number_of_imitators; ++i) if (!is_imitator_line_clear(i,diff_first_necessarily_empty,step,diff_first_not_necessarily_empty)) { result = false; break; } TraceFunctionExit(__func__); TraceFunctionResult("%u",result); TraceFunctionResultEnd(); return result; }
/* Try to solve in solve_nr_remaining half-moves. * @param si slice index * @note assigns solve_result the length of solution found and written, i.e.: * previous_move_is_illegal the move just played is illegal * this_move_is_illegal the move being played is illegal * immobility_on_next_move the moves just played led to an * unintended immobility on the next move * <=n+1 length of shortest solution found (n+1 only if in next * branch) * n+2 no solution found in this branch * n+3 no solution found in next branch * (with n denominating solve_nr_remaining) */ void goalreachable_guard_mate_solve(slice_index si) { Side const just_moved = advers(SLICE_STARTER(si)); TraceFunctionEntry(__func__); TraceFunctionParam("%u",si); TraceFunctionParamListEnd(); --MovesLeft[just_moved]; TraceEnumerator(Side,SLICE_STARTER(si)); TraceEnumerator(Side,just_moved); TraceValue("%u",MovesLeft[SLICE_STARTER(si)]); TraceValue("%u",MovesLeft[just_moved]); TraceEOL(); pipe_this_move_doesnt_solve_if(si,!mate_isGoalReachable()); ++MovesLeft[just_moved]; TraceValue("%u",MovesLeft[SLICE_STARTER(si)]); TraceValue("%u",MovesLeft[just_moved]); TraceEOL(); TraceFunctionExit(__func__); TraceFunctionResultEnd(); }
/* Start a new ply as a sibling of the current ply, making the child the new * current ply * @param side the side at the move in the child ply */ void siblingply(Side side) { ply const elder = nbply; TraceFunctionEntry(__func__); TraceFunctionParamListEnd(); assert(ply_watermark<maxply); ply_stack[ply_stack_pointer++] = nbply; nbply = ply_watermark+1; current_move[nbply] = current_move[ply_watermark]; current_move_id[nbply] = current_move_id[ply_watermark]; ++ply_watermark; TraceValue("%u",elder); TraceValue("%u",nbply); TraceEOL(); parent_ply[nbply] = parent_ply[elder]; trait[nbply] = side; move_effect_journal_base[nbply+1] = move_effect_journal_base[nbply]; en_passant_top[nbply] = en_passant_top[nbply-1]; promotion_horizon[nbply] = move_effect_journal_base[nbply]; post_move_iteration_init_ply(); TraceFunctionExit(__func__); TraceFunctionResultEnd(); }
/* Iterate if square observation testing uses a post-move iterating slice (e.g. * for MarsCirce Super) * @param si identifies move generator slice */ void square_observation_post_move_iterator_solve(slice_index si) { TraceFunctionEntry(__func__); TraceFunctionParam("%u",si); TraceFunctionParamListEnd(); ++current_level; TraceValue("%u",current_level);TraceEOL(); if (current_level>iteration_level) { iteration_level = current_level; TraceValue("%u",iteration_level);TraceValue("%u",current_level);TraceEOL(); } do { pipe_is_square_observed_delegate(si); } while (iteration_level>current_level && !observation_result); --current_level; TraceValue("%u",current_level);TraceEOL(); post_move_iteration_cancel(); TraceFunctionExit(__func__); TraceFunctionResultEnd(); }
static void PushMagicViews(void) { TraceFunctionEntry(__func__); TraceFunctionParamListEnd(); magic_views_top[stack_pointer] = magic_views_top[stack_pointer-1]; siblingply(no_side); push_observation_target(initsquare); prev_observation_context[nbply] = observation_context; are_we_finding_magic_views[nbply] = true; PushMagicViewsByOneSide(White); PushMagicViewsByOneSide(Black); are_we_finding_magic_views[nbply] = false; /* TODO: remove double views by neutral magic pieces * apply same logic as for cross-eyed pieces? */ finply(); TraceValue("%u",nbply); TraceValue("%u\n",magic_views_top[nbply]); TraceFunctionExit(__func__); TraceFunctionResultEnd(); }
static void PushMagicView(square pos_viewed, square pos_magic, square start, square end) { unsigned int const top = magic_views_top[stack_pointer]; TraceFunctionEntry(__func__); TraceSquare(pos_viewed); TraceSquare(pos_magic); TraceSquare(start); TraceSquare(end); TraceFunctionParamListEnd(); assert(magic_views_top[stack_pointer]<magicviews_size); magicviews[top].pos_viewed = pos_viewed; magicviews[top].viewedid = GetPieceId(being_solved.spec[pos_viewed]); magicviews[top].magicpieceid = GetPieceId(being_solved.spec[pos_magic]); magicviews[top].line_start = start; magicviews[top].line_end = end; ++magic_views_top[stack_pointer]; TraceValue("%u",stack_pointer); TraceValue("%u\n",magic_views_top[stack_pointer]); TraceFunctionExit(__func__); TraceFunctionResultEnd(); }
static void remember_previous_move_as_undecidable(void) { append_to_table(exclusive_chess_undecidable_continuations[parent_ply[nbply]]); TraceValue("%u",nbply); TraceValue("%u",parent_ply[nbply]); TraceValue("%u\n",table_length(exclusive_chess_undecidable_continuations[parent_ply[nbply]])); }
static boolean is_imitator_line_clear(unsigned int i, numvec diff_first_necessarily_empty, numvec step, numvec diff_first_not_necessarily_empty) { boolean result = true; square const sq_first_not_necessarily_empty = being_solved.isquare[i]+diff_first_not_necessarily_empty; square sq_curr; TraceFunctionEntry(__func__); TraceValue("%u",i); TraceValue("%d",diff_first_necessarily_empty); TraceValue("%d",step); TraceValue("%d",diff_first_not_necessarily_empty); TraceFunctionParamListEnd(); for (sq_curr = being_solved.isquare[i]+diff_first_necessarily_empty; sq_curr!=sq_first_not_necessarily_empty; sq_curr += step) { TraceSquare(sq_curr);TraceEOL(); if (!is_square_empty(sq_curr)) { result = false; break; } } TraceFunctionExit(__func__); TraceFunctionResult("%u",result); TraceFunctionResultEnd(); return result; }
static void substitute_deadend_goal(slice_index si, stip_moves_traversal *st) { optimisation_state * const state = st->param; slice_index const save_optimisable_deadend = state->optimisable_deadend; TraceFunctionEntry(__func__); TraceFunctionParam("%u",si); TraceFunctionParamListEnd(); stip_traverse_moves_children(si,st); TraceValue("%u",state->optimisable_deadend); TraceValue("%u",state->end_of_branch_goal); TraceValue("%u\n",st->context); if (state->optimisable_deadend!=no_slice && state->end_of_branch_goal!=no_slice && st->context!=stip_traversal_context_attack) { slice_index const prototype = alloc_pipe(STDeadEndGoal); defense_branch_insert_slices(si,&prototype,1); pipe_remove(state->optimisable_deadend); } state->optimisable_deadend = save_optimisable_deadend; TraceFunctionExit(__func__); TraceFunctionResultEnd(); }
/* Determine whether a specific piece delivers check to a specific side * @param observer_origin potentially delivering check ... * @note the piece on pos_checking must belong to advers(side) * @note sets observation_result */ void marscirce_is_square_observed(slice_index si) { circe_rebirth_context_elmt_type * const context = &circe_rebirth_context_stack[circe_rebirth_context_stack_pointer-1]; square const sq_target = move_generation_stack[CURRMOVE_OF_PLY(nbply)].capture; TraceFunctionEntry(__func__); TraceValue("%u",si); TraceFunctionParamListEnd(); assert(circe_rebirth_context_stack_pointer>0); observation_result = false; if (observing_walk[nbply]<Queen || observing_walk[nbply]>Bishop || CheckDir[observing_walk[nbply]][sq_target-context->rebirth_square]!=0) { if (is_square_empty(context->rebirth_square)) { TraceSquare(context->rebirth_square); TraceWalk(context->reborn_walk); TraceValue("%u",TSTFLAG(being_solved.spec[context->rebirth_square],White)); TraceValue("%u",TSTFLAG(being_solved.spec[context->rebirth_square],Black)); TraceEOL(); occupy_square(context->rebirth_square,context->reborn_walk,context->reborn_spec); pipe_is_square_observed_delegate(si); empty_square(context->rebirth_square); } } TraceFunctionExit(__func__); TraceFunctionResultEnd(); }
/* Plan optimising away a STOhneschachStopIfCheckAndNotMate slice * @param stop identifies STOhneschachStopIfCheckAndNotMate slice * @param to_be_optimised true iff stop is going to be optimised away */ void ohneschach_stop_if_check_plan_to_optimise_away_stop(slice_index stop, boolean to_be_optimised) { slice_index const immobility_tester = SLICE_NEXT2(stop); TraceFunctionEntry(__func__); TraceFunctionParam("%u",stop); TraceFunctionParam("%u",to_be_optimised); TraceFunctionParamListEnd(); TraceValue("%u",fate[immobility_tester]); TraceEOL(); if (to_be_optimised) { fate[stop] = fate_stop_to_be_optimised; if (fate[immobility_tester]==fate_dont_know) fate[immobility_tester] = fate_immobility_tester_obsolete; } else { fate[stop] = fate_stop_not_to_be_optimised; fate[immobility_tester] = fate_immobility_tester_still_used; } TraceValue("->%u",fate[immobility_tester]); TraceEOL(); TraceFunctionExit(__func__); TraceFunctionResultEnd(); }
/* Try to solve in solve_nr_remaining half-moves. * @param si slice index * @note assigns solve_result the length of solution found and written, i.e.: * previous_move_is_illegal the move just played is illegal * this_move_is_illegal the move being played is illegal * immobility_on_next_move the moves just played led to an * unintended immobility on the next move * <=n+1 length of shortest solution found (n+1 only if in next * branch) * n+2 no solution found in this branch * n+3 no solution found in next branch * (with n denominating solve_nr_remaining) */ void imitator_pawn_promoter_solve(slice_index si) { TraceFunctionEntry(__func__); TraceFunctionParam("%u",si); TraceFunctionParamListEnd(); { square sq_arrival; Side as_side; find_potential_promotion_square(promotion_horizon[nbply],&sq_arrival,&as_side); assert(stack_pointer<stack_size); if (post_move_iteration_id[nbply]!=prev_post_move_iteration_id[stack_pointer]) promotion_into_imitator[stack_pointer] = is_square_occupied_by_promotable_pawn(sq_arrival,as_side); TraceValue("%u",post_move_iteration_id[nbply]); TraceValue("%u",prev_post_move_iteration_id[stack_pointer]); TraceValue("%u\n",promotion_into_imitator[stack_pointer]); if (promotion_into_imitator[stack_pointer]) { move_effect_journal_index_type const save_horizon = promotion_horizon[nbply]; promotion_horizon[nbply] = move_effect_journal_base[nbply+1]; move_effect_journal_do_piece_removal(move_effect_reason_pawn_promotion, sq_arrival); move_effect_journal_do_imitator_addition(move_effect_reason_pawn_promotion, sq_arrival); ++stack_pointer; fork_solve_delegate(si); --stack_pointer; promotion_horizon[nbply] = save_horizon; TraceValue("%u\n",post_move_iteration_locked[nbply]); if (!post_move_iteration_locked[nbply]) { promotion_into_imitator[stack_pointer] = false; lock_post_move_iterations(); } } else { ++stack_pointer; pipe_solve_delegate(si); --stack_pointer; } prev_post_move_iteration_id[stack_pointer] = post_move_iteration_id[nbply]; } TraceFunctionExit(__func__); TraceFunctionResultEnd(); }
/* Lock post move iterations in the current move retraction */ void lock_post_move_iterations(void) { TraceFunctionEntry(__func__); TraceFunctionParamListEnd(); post_move_iteration_locked[nbply] = true; ++post_move_iteration_id[nbply]; TraceValue("%u",nbply);TraceValue("%u\n",post_move_iteration_id[nbply]); TraceFunctionExit(__func__); TraceFunctionResultEnd(); }
boolean post_move_iteration_ply_was_ended(void) { boolean result = iteration_level==current_level; TraceFunctionEntry(__func__); TraceFunctionParamListEnd(); TraceValue("%u",iteration_level);TraceValue("%u",current_level);TraceEOL(); TraceFunctionExit(__func__); TraceFunctionResult("%u",result); TraceFunctionResultEnd(); return result; }
/* Determine whether the current post move iteration participant has the lock * @param true iff it has */ boolean post_move_have_i_lock(void) { boolean const result = iteration_level==current_level+1; TraceFunctionEntry(__func__); TraceFunctionParamListEnd(); TraceValue("%u",iteration_level);TraceValue("%u",current_level);TraceEOL(); TraceFunctionExit(__func__); TraceFunctionResult("%u",result); TraceFunctionResultEnd(); return result; }
void post_move_iteration_init_ply(void) { TraceFunctionEntry(__func__); TraceFunctionParamListEnd(); TraceValue("%u",current_level);TraceEOL(); iteration_level = current_level; TraceValue("%u",iteration_level);TraceEOL(); TraceFunctionExit(__func__); TraceFunctionResultEnd(); }
/* @return true iff >=1 black pieces needed to be immobilised */ boolean intelligent_stalemate_immobilise_black(void) { boolean result = false; immobilisation_state_type immobilisation_state = null_state; castling_rights_type const save_castling_flag = being_solved.castling_rights; TraceFunctionEntry(__func__); TraceFunctionParamListEnd(); /* we temporarily disable Black castling for two reasons: * 1. we are solving from the target position here where king or rook may be * at different positions than in the diagram; attempting to generate * (let alone) execute castling moves would cause problems in this case * 2. castlings are presumable never the only legal black moves */ CLRCASTLINGFLAGMASK(Black,k_cancastle); current_state = &immobilisation_state; conditional_pipe_solve_delegate(current_start_slice); next_trouble_maker(); current_state = 0; being_solved.castling_rights = save_castling_flag; if (immobilisation_state.worst.requirement>no_requirement) { assert(immobilisation_state.worst.target_square!=initsquare); TraceSquare(immobilisation_state.worst.target_square); TraceValue("%u",immobilisation_state.worst.requirement); TraceValue("%u\n",immobilisation_state.worst.nr_flight_directions); if (immobilisation_state.worst.requirement<immobilisation_impossible) { intelligent_stalemate_pin_black_piece(immobilisation_state.worst.target_square); if (immobilisation_state.worst.requirement<pin_required && can_we_block_all_necessary_squares(&immobilisation_state.worst)) block_squares(&immobilisation_state.worst); } result = true; } TraceFunctionExit(__func__); TraceFunctionResult("%u",result); TraceFunctionResultEnd(); return result; }
/* Iterate if move generation uses a post-move iterating slice (e.g. for * MarsCirce Super) * @param si identifies move generator slice */ void move_generation_post_move_iterator_solve(slice_index si) { TraceFunctionEntry(__func__); TraceFunctionParam("%u",si); TraceFunctionParamListEnd(); do { pipe_move_generation_delegate(si); TraceValue("%u",iteration_level);TraceValue("%u",current_level);TraceEOL(); } while (iteration_level>current_level); TraceFunctionExit(__func__); TraceFunctionResultEnd(); }
void post_move_iteration_end(void) { TraceFunctionEntry(__func__); TraceFunctionParamListEnd(); TraceValue("%u",iteration_level);TraceValue("%u",current_level);TraceEOL(); assert(iteration_level==current_level+1); --iteration_level; TraceValue("%u",iteration_level);TraceValue("%u",current_level);TraceEOL(); TraceFunctionExit(__func__); TraceFunctionResultEnd(); }
/* Determine whether a side observes a specific square * @param si identifies the tester slice * @note sets observation_result */ void marscirce_iterate_observers(slice_index si) { circe_rebirth_context_elmt_type * const context = &circe_rebirth_context_stack[circe_rebirth_context_stack_pointer]; Side const side_observing = trait[nbply]; square const *observer_origin; square const sq_target = move_generation_stack[CURRMOVE_OF_PLY(nbply)].capture; TraceFunctionEntry(__func__); TraceValue("%u",si); TraceFunctionParamListEnd(); observation_result = false; context->relevant_ply = nbply; for (observer_origin = boardnum; *observer_origin; ++observer_origin) if (*observer_origin!=sq_target /* no auto-observation */ && TSTFLAG(being_solved.spec[*observer_origin],side_observing) && get_walk_of_piece_on_square(*observer_origin)==observing_walk[nbply]) { context->rebirth_from = *observer_origin; context->reborn_walk = observing_walk[nbply]; context->reborn_spec = being_solved.spec[context->rebirth_from]; context->relevant_side = advers(side_observing); context->relevant_square = context->rebirth_from; pipe_is_square_observed_delegate(si); if (observation_result) break; } TraceFunctionExit(__func__); TraceFunctionResultEnd(); }
/* iterate until we detect an input token that identifies the user's language * @return the detected language */ static Language detect_user_language(char *tok) { Language result = LanguageCount; TraceFunctionEntry(__func__); TraceFunctionParam("%s",tok); TraceFunctionParamListEnd(); { Language candidate; for (candidate = 0; candidate<LanguageCount; ++candidate) { TraceValue("%u",candidate);TraceEOL(); if (GetUniqIndex(GlobalTokenCount,GlobalTokenString[candidate],tok)==BeginProblem) { result = candidate; break; } } } TraceFunctionExit(__func__); TraceFunctionResult("%u",result); TraceFunctionResultEnd(); return result; }
/* Try to solve in solve_nr_remaining half-moves. * @param si slice index * @note assigns solve_result the length of solution found and written, i.e.: * previous_move_is_illegal the move just played is illegal * this_move_is_illegal the move being played is illegal * immobility_on_next_move the moves just played led to an * unintended immobility on the next move * <=n+1 length of shortest solution found (n+1 only if in next * branch) * n+2 no solution found in this branch * n+3 no solution found in next branch * (with n denominating solve_nr_remaining) */ void goal_doublemate_reached_tester_solve(slice_index si) { TraceFunctionEntry(__func__); TraceFunctionParam("%u",si); TraceFunctionParamListEnd(); TraceValue("%u",nbply); TraceValue("%u",parent_ply[nbply]); TraceEOL(); pipe_this_move_doesnt_solve_if(si, !TSTFLAG(goal_preprequisites_met[parent_ply[nbply]], goal_doublemate)); TraceFunctionExit(__func__); TraceFunctionResultEnd(); }
static numecoup remove_illegal_moves_by_same_mao(numecoup curr, numecoup *new_top) { square const sq_departure = move_generation_stack[curr].departure; TraceFunctionEntry(__func__); TraceValue("%u",curr); TraceSquare(sq_departure); TraceFunctionParamListEnd(); while (curr<=CURRMOVE_OF_PLY(nbply) && move_generation_stack[curr].departure==sq_departure) { square const sq_arrival = move_generation_stack[curr].arrival; square const sq_hurdle = hoppper_moves_auxiliary[move_generation_stack[curr].id].sq_hurdle; if (are_all_imitator_arrivals_empty(sq_departure,sq_hurdle) && are_all_imitator_arrivals_empty(sq_departure,sq_arrival)) { ++*new_top; move_generation_stack[*new_top] = move_generation_stack[curr]; } ++curr; } TraceFunctionExit(__func__); TraceFunctionResult("%u",curr); TraceFunctionResultEnd(); return curr; }
static char *ParseLength(char *tok, stip_length_type *length) { char *end; unsigned long tmp_length; TraceFunctionEntry(__func__); TraceFunctionParam("%s",tok); TraceFunctionParamListEnd(); if (tok!=0 && *tok==0) /* allow white space before length, e.g. "dia 4" */ tok = ReadNextTokStr(); tmp_length = strtoul(tok,&end,10); TraceValue("%ld",tmp_length); TraceEOL(); if (tok==end || tmp_length>UINT_MAX) { output_plaintext_input_error_message(WrongInt,0); tok = 0; } else { *length = tmp_length; tok = end; } TraceFunctionExit(__func__); TraceFunctionResult("%s",tok); TraceFunctionResultEnd(); return tok; }
static void stip_traverse_moves_defense_adapter(slice_index si, stip_moves_traversal *st) { TraceFunctionEntry(__func__); TraceFunctionParam("%u",si); TraceFunctionParamListEnd(); if (st->context==stip_traversal_context_intro) { assert(st->remaining==STIP_MOVES_TRAVERSAL_LENGTH_UNINITIALISED); assert(st->full_length==STIP_MOVES_TRAVERSAL_LENGTH_UNINITIALISED); st->full_length = SLICE_U(si).branch.length-slack_length; TraceValue("->%u",st->full_length); TraceEOL(); st->remaining = st->full_length; st->context = stip_traversal_context_defense; stip_traverse_moves_pipe(si,st); st->context = stip_traversal_context_intro; st->remaining = STIP_MOVES_TRAVERSAL_LENGTH_UNINITIALISED; st->full_length = STIP_MOVES_TRAVERSAL_LENGTH_UNINITIALISED; } else stip_traverse_moves_pipe(si,st); TraceFunctionExit(__func__); TraceFunctionResultEnd(); }
static void insert_separator(slice_index si, stip_structure_traversal *st) { TraceFunctionEntry(__func__); TraceValue("%u",si); TraceFunctionParamListEnd(); stip_traverse_structure_children(si,st); { slice_index const proxy_standard = alloc_proxy_slice(); slice_index const standard = alloc_pipe(STMoveForPieceGeneratorStandardPath); slice_index const proxy_alternative = alloc_proxy_slice(); slice_index const alternative = alloc_pipe(STMoveForPieceGeneratorAlternativePath); slice_index const generator = alloc_binary_slice(STMoveForPieceGeneratorTwoPaths, proxy_standard, proxy_alternative); pipe_link(SLICE_PREV(si),generator); pipe_link(proxy_standard,standard); pipe_link(standard,si); pipe_link(proxy_alternative,alternative); pipe_link(alternative,si); } TraceFunctionExit(__func__); TraceFunctionResultEnd(); }
/* (Approximately) depth-first traversl of the stipulation * @param root start of the stipulation (sub)tree * @param st address of data structure holding parameters for the operation */ void stip_traverse_moves(slice_index root, stip_moves_traversal *st) { TraceFunctionEntry(__func__); TraceFunctionParam("%u",root); TraceFunctionParam("%p",st); TraceFunctionParamListEnd(); TraceValue("%u",st->remaining); TraceEOL(); TraceEnumerator(slice_type,SLICE_TYPE(root)); TraceEOL(); assert(SLICE_TYPE(root)<=nr_slice_types); if (st->remaining_watermark[root]<=st->remaining) { stip_moves_visitor const operation = st->map.visitors[SLICE_TYPE(root)]; assert(operation!=0); (*operation)(root,st); st->remaining_watermark[root] = st->remaining+1; } 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(); }
static void forget_deadend(slice_index si, stip_moves_traversal *st) { optimisation_state * const state = st->param; slice_index const save_optimisable_deadend = state->optimisable_deadend; TraceFunctionEntry(__func__); TraceFunctionParam("%u",si); TraceFunctionParamListEnd(); TraceValue("%u\n",state->optimisable_deadend); stip_traverse_moves_children(si,st); TraceValue("%u\n",state->optimisable_deadend); state->optimisable_deadend = save_optimisable_deadend; TraceValue("->%u\n",state->optimisable_deadend); TraceFunctionExit(__func__); TraceFunctionResultEnd(); }
/* Try to solve in solve_nr_remaining half-moves. * @param si slice index * @note assigns solve_result the length of solution found and written, i.e.: * previous_move_is_illegal the move just played is illegal * this_move_is_illegal the move being played is illegal * immobility_on_next_move the moves just played led to an * unintended immobility on the next move * <=n+1 length of shortest solution found (n+1 only if in next * branch) * n+2 no solution found in this branch * n+3 no solution found in next branch * (with n denominating solve_nr_remaining) */ void move_execution_post_move_iterator_solve(slice_index si) { TraceFunctionEntry(__func__); TraceFunctionParam("%u",si); TraceFunctionParamListEnd(); TraceValue("%u",iteration_level);TraceValue("%u",current_level);TraceEOL(); pipe_solve_delegate(si); TraceValue("%u",iteration_level);TraceValue("%u",current_level);TraceEOL(); if (iteration_level==current_level) pop_move(); TraceFunctionExit(__func__); TraceFunctionResultEnd(); }