Esempio n. 1
0
static void write_attack(slice_index si, stip_structure_traversal *st)
{
  state_type * const state = st->param;
  stip_length_type const save_length = state->length;
  structure_traversal_level_type const save_level = state->branch_level;;

  state->branch_level = st->level;
  state->length = SLICE_U(si).branch.length;

  if (st->level==structure_traversal_level_top
      && state->length>slack_length+2
      && SLICE_U(si).branch.min_length==state->length-1)
    state->nr_chars_written += fprintf(state->file,"%s","exact-");

  if (is_pser(si,st))
    state->nr_chars_written += fprintf(state->file,"%s","pser-");

  stip_traverse_structure_children(si,st);

  if (st->level==structure_traversal_level_top)
    state->nr_chars_written += fprintf(state->file,
                                                "%u",
                                                (SLICE_U(si).branch.length+1)/2);

  state->length = save_length;
  state->branch_level = save_level;
}
Esempio n. 2
0
/* 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 degenerate_tree_solve(slice_index si)
{
  stip_length_type const length = SLICE_U(si).branch.length;
  stip_length_type const min_length = SLICE_U(si).branch.min_length;
  stip_length_type const n_min = (min_length>=(length-solve_nr_remaining)+slack_length
                                  ? min_length-(length-solve_nr_remaining)
                                  : min_length);

  TraceFunctionEntry(__func__);
  TraceFunctionParam("%u",si);
  TraceFunctionParamListEnd();

  if (solve_nr_remaining>max_length_short_solutions+slack_length)
  {
    if (max_length_short_solutions>=2)
    {
      stip_length_type const parity = (solve_nr_remaining-slack_length)%2;
      stip_length_type const n_interm = max_length_short_solutions+slack_length-parity;
      if (delegate_solve(si,n_interm,n_min)>n_interm)
        delegate_solve(si,solve_nr_remaining,solve_nr_remaining);
    }
    else
      delegate_solve(si,solve_nr_remaining,solve_nr_remaining);
  }
  else
    delegate_solve(si,solve_nr_remaining,n_min);

  TraceFunctionExit(__func__);
  TraceFunctionResultEnd();
}
Esempio n. 3
0
slice_index alloc_command_line_options_parser(int argc, char **argv)
{
  slice_index const result = alloc_pipe(STCommandLineOptionsParser);
  SLICE_U(result).command_line_options_parser.argc = argc;
  SLICE_U(result).command_line_options_parser.argv = argv;
  return result;
}
Esempio n. 4
0
static void degenerate_tree_inserter_attack(slice_index si,
                                            stip_structure_traversal *st)
{
  TraceFunctionEntry(__func__);
  TraceFunctionParam("%u",si);
  TraceFunctionParamListEnd();

  if (st->activity==stip_traversal_activity_testing
      && SLICE_U(si).branch.length>=slack_length+2)
  {
    slice_index const finder = branch_find_slice(STFindShortest,
                                                 si,
                                                 stip_traversal_context_attack);
    if (finder!=no_slice) /* slice may already have been replaced */
    {
      stip_length_type const length = SLICE_U(finder).branch.length;
      stip_length_type const min_length = SLICE_U(finder).branch.min_length;
      pipe_substitute(finder,alloc_degenerate_tree_guard_slice(length,min_length));
    }
  }
  else
    stip_traverse_structure_children_pipe(si,st);

  TraceFunctionExit(__func__);
  TraceFunctionResultEnd();
}
Esempio n. 5
0
void command_line_options_parser_solve(slice_index si)
{
  int const argc = SLICE_U(si).command_line_options_parser.argc;
  char **argv = SLICE_U(si).command_line_options_parser.argv;
  int const idx_end_of_options = parseCommandlineOptions(argc,argv);
  char const *filename = idx_end_of_options<argc ? argv[idx_end_of_options] : "";
  slice_index const opener = input_plaintext_alloc_opener(filename);

  slice_insertion_insert(si,&opener,1);

  pipe_solve_delegate(si);
}
Esempio n. 6
0
static slice_index make_cagecirce_noncapture_finder(Side side)
{
  slice_index result;

  if (circe_variant.determine_rebirth_square==circe_determine_rebirth_square_cage
      || anticirce_variant.determine_rebirth_square==circe_determine_rebirth_square_cage)
  {
    slice_index const proxy_branch = alloc_proxy_slice();
    slice_index const help = alloc_help_branch(slack_length+1,slack_length+1);
    slice_index const proxy_goal = alloc_proxy_slice();
    slice_index const system = alloc_goal_capture_reached_tester_system();
    link_to_branch(proxy_goal,system);

    {
      slice_index const tester = branch_find_slice(STGoalReachedTester,
                                                   proxy_goal,
                                                   stip_traversal_context_intro);
      assert(tester!=no_slice);
      pipe_append(SLICE_NEXT2(tester),alloc_not_slice());
      SLICE_U(tester).goal_handler.goal.type = goal_negated;
      help_branch_set_end_goal(help,proxy_goal,1);
      link_to_branch(proxy_branch,help);
      result = alloc_conditional_pipe(STCageCirceNonCapturingMoveFinder,proxy_branch);
      solving_impose_starter(result,side);
    }
  }
  else
    result = alloc_proxy_slice();

  return result;
}
Esempio n. 7
0
static void write_series(slice_index si, stip_structure_traversal *st)
{
  state_type * const state = st->param;

  if (st->level==structure_traversal_level_top
      && state->length>slack_length+2
      && SLICE_U(si).branch.min_length>=state->length-1)
    state->nr_chars_written += fprintf(state->file,"%s","exact-");

  if (is_intro_series(si))
  {
    if (state->length%2==1)
      state->nr_chars_written += fprintf(state->file,"%u",(state->length+1)/2);
    else if (state->length>1)
      state->nr_chars_written += fprintf(state->file,"%u",state->length/2);
    state->nr_chars_written += fprintf(state->file,"%s","->");
    stip_traverse_structure_children(si,st);
  }
  else
  {
    state->nr_chars_written += fprintf(state->file,"%s", "ser-");

    if (is_help_reci(si))
    {
      state->nr_chars_written += fprintf(state->file,"%s", "reci-h");
      state->length += 2;
    }

    stip_traverse_structure_children(si,st);
    if (state->length%2==1)
      state->nr_chars_written += fprintf(state->file,"%u",(state->length+1)/2);
    else if (state->length>1)
      state->nr_chars_written += fprintf(state->file,"%u",state->length/2);
  }
}
Esempio n. 8
0
static void insert_maxthreatlength_guard(slice_index si,
                                         stip_structure_traversal *st)
{
  stip_length_type const length = SLICE_U(si).branch.length;

  TraceFunctionEntry(__func__);
  TraceFunctionParam("%u",si);
  TraceFunctionParamListEnd();

  stip_traverse_structure_children_pipe(si,st);

  if (length>=2*max_len_threat+slack_length)
  {
    boolean * const inserted = st->param;
    slice_index const threat_start = branch_find_slice(STMaxThreatLengthStart,
                                                       si,
                                                       st->context);
    slice_index const proxy = alloc_proxy_slice();
    slice_index const dummy = alloc_pipe(STDummyMove);
    slice_index const played = alloc_defense_played_slice();
    slice_index const prototype = alloc_maxthreatlength_guard(proxy);
    assert(threat_start!=no_slice);
    pipe_link(proxy,dummy);
    pipe_link(dummy,played);
    link_to_branch(played,threat_start);
    defense_branch_insert_slices(si,&prototype,1);

    *inserted = true;
  }

  TraceFunctionExit(__func__);
  TraceFunctionResultEnd();
}
Esempio n. 9
0
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();
}
/* 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 find_by_increasing_length_solve(slice_index si)
{
  stip_length_type result_intermediate = MOVE_HAS_NOT_SOLVED_LENGTH();
  stip_length_type const save_solve_nr_remaining = MOVE_HAS_SOLVED_LENGTH();

  TraceFunctionEntry(__func__);
  TraceFunctionParam("%u",si);
  TraceFunctionParamListEnd();

  for (solve_nr_remaining = SLICE_U(si).branch.min_length;
       solve_nr_remaining<=save_solve_nr_remaining;
       solve_nr_remaining += 2)
  {
    pipe_solve_delegate(si);
    if (solve_result==MOVE_HAS_SOLVED_LENGTH()
        && solve_nr_remaining<result_intermediate)
      result_intermediate = solve_nr_remaining;
  }

  solve_nr_remaining = save_solve_nr_remaining;

  solve_result = result_intermediate;

  TraceFunctionExit(__func__);
  TraceFunctionResultEnd();
}
Esempio n. 11
0
/* Find a STHelpMovePlayed slice with a specific parity
 * @param si identifies the entry slice of a help branch
 * @param parity indicates after which help move of the branch to insert
 * @return identifier of found STHelpMovePlayed slice; no_slice if no such slice was found
 */
static slice_index help_branch_locate_played(slice_index si, unsigned int parity)
{
  slice_index result;

  TraceFunctionEntry(__func__);
  TraceFunctionParam("%u",si);
  TraceFunctionParam("%u",parity);
  TraceFunctionParamListEnd();

  {
    slice_index const ready = branch_find_slice(STReadyForHelpMove,si,stip_traversal_context_help);
    slice_index const played1 = branch_find_slice(STHelpMovePlayed,ready,stip_traversal_context_help);
    slice_index const played2 = branch_find_slice(STHelpMovePlayed,played1,stip_traversal_context_help);
    assert(ready!=no_slice);
    assert(played1!=no_slice);
    assert(played2!=no_slice);

    if (SLICE_U(ready).branch.length%2==parity%2)
      result = played1;
    else
      result = played2;
  }

  TraceFunctionExit(__func__);
  TraceFunctionResult("%u",result);
  TraceFunctionResultEnd();
  return result;
}
Esempio n. 12
0
/* Parse a not operator
 * @param tok input token
 * @param start index of entry into solving machinery
 * @param proxy index of branch; no_slice if operator couldn't be parsed
 * @param level nesting level of the operand (0 means top level)
 * @return remainder of input token; 0 if parsing failed
 */
static char *ParseStructuredStip_not(char *tok,
                                     slice_index start,
                                     slice_index proxy,
                                     expression_type *type,
                                     unsigned int level)
{
  TraceFunctionEntry(__func__);
  TraceFunctionParam("%s",tok);
  TraceFunctionParam("%u",start);
  TraceFunctionParam("%u",proxy);
  TraceFunctionParam("%u",level);
  TraceFunctionParamListEnd();

  tok = ParseStructuredStip_operand(tok+1,start,proxy,type,level);
  if (tok!=0)
  {
    if (*type==expression_type_goal)
    {
      slice_index const tester = branch_find_slice(STGoalReachedTester,
                                                   proxy,
                                                   stip_traversal_context_intro);
      assert(tester!=no_slice);
      pipe_append(SLICE_NEXT2(tester),alloc_not_slice());
      SLICE_U(tester).goal_handler.goal.type = goal_negated;
    }
    else
      pipe_append(proxy,alloc_not_slice());
  }

  TraceFunctionExit(__func__);
  TraceFunctionResult("%s",tok);
  TraceFunctionResultEnd();
  return tok;
}
Esempio n. 13
0
static void insert_selfcheck_guard_goal(slice_index si,
                                        stip_structure_traversal *st)
{
  in_branch_insertion_state_type * const state = st->param;
  slice_index const tester = SLICE_NEXT2(si);

  TraceFunctionEntry(__func__);
  TraceFunctionParam("%u",si);
  TraceFunctionParamListEnd();

  if (state->last_checked!=SLICE_STARTER(si)
      && get_stip_structure_traversal_state(tester,st)==slice_not_traversed)
  {
    boolean const save_is_instrumented = state->is_branch_instrumented;

    state->in_goal_tester = SLICE_U(si).goal_handler.goal.type;
    state->is_branch_instrumented = false;

    stip_traverse_structure_next_branch(si,st);

    if (!state->is_branch_instrumented)
    {
      slice_index const prototype = alloc_selfcheck_guard_slice();
      goal_branch_insert_slices(tester,&prototype,1);
    }

    state->is_branch_instrumented = save_is_instrumented;
    state->in_goal_tester = no_goal;
  }

  stip_traverse_structure_children_pipe(si,st);

  TraceFunctionExit(__func__);
  TraceFunctionResultEnd();
}
Esempio n. 14
0
static slice_index help_branch_locate_ready(slice_index si)
{
  slice_index result = si;

  TraceFunctionEntry(__func__);
  TraceFunctionParam("%u",si);
  TraceFunctionParamListEnd();

  result = branch_find_slice(STReadyForHelpMove,result,stip_traversal_context_help);
  assert(result!=no_slice);

  while ((SLICE_U(result).branch.length-slack_length)%2!=0)
  {
    slice_index const next = branch_find_slice(STReadyForHelpMove,
                                               result,
                                               stip_traversal_context_help);
    assert(next!=no_slice);
    if (result==next)
    {
      result = no_slice;
      break;
    }
    else
      result = next;
  }

  TraceFunctionExit(__func__);
  TraceFunctionResult("%u",result);
  TraceFunctionResultEnd();
  return result;
}
Esempio n. 15
0
static boolean is_help_play_implicit(slice_index si, stip_structure_traversal *st)
{
  boolean result = false;
  state_type const * const state = st->param;

  if(state->branch_level==structure_traversal_level_top)
  {
    slice_index const end_goal = branch_find_slice(STEndOfBranchGoal,
                                                   si,
                                                   st->context);
    if (end_goal!=no_slice)
    {
      slice_index const tester = branch_find_slice(STGoalReachedTester,
                                                   SLICE_NEXT2(end_goal),
                                                   st->context);
      if (tester!=no_slice)
      {
        goal_type const type = SLICE_U(tester).goal_handler.goal.type;
        result = type==goal_proofgame || type==goal_atob;
      }
    }
  }

  return result;
}
Esempio n. 16
0
/* Impose the starting side on a stipulation.
 * @param si identifies slice
 * @param st address of structure that holds the state of the traversal
 */
void impose_starter_goal_immobile_tester(slice_index si,
                                         stip_structure_traversal *st)
{
  Side * const starter = st->param;

  TraceFunctionEntry(__func__);
  TraceFunctionParam("%u",si);
  TraceEnumerator(Side,*starter,"");
  TraceFunctionParamListEnd();

  SLICE_STARTER(si) = *starter;
  stip_traverse_structure_children_pipe(si,st);

  {
    Side const immobilised = (SLICE_U(si).goal_filter.applies_to_who
                              ==goal_applies_to_starter
                              ? SLICE_STARTER(si)
                              : advers(SLICE_STARTER(si)));
    *starter = immobilised;
    stip_traverse_structure_conditional_pipe_tester(si,st);
  }

  *starter = SLICE_STARTER(si);

  TraceFunctionExit(__func__);
  TraceFunctionResultEnd();
}
Esempio n. 17
0
static void remember_id(slice_index si, stip_structure_traversal *st)
{
  Goal const goal = SLICE_U(si).goal_handler.goal;
  if (goal.type==goal_kiss)
    id_to_be_kissed = GetPieceId(being_solved.spec[goal.target]);

  stip_traverse_structure_children(si,st);
}
Esempio n. 18
0
/* Produce slices representing set play.
 * @param adapter identifies the adapter slice at the beginning of the branch
 * @param state address of structure holding state
 */
void help_branch_make_setplay(slice_index adapter, spin_off_state_type *state)
{
  stip_length_type const length = SLICE_U(adapter).branch.length;
  stip_length_type min_length = SLICE_U(adapter).branch.min_length;

  TraceFunctionEntry(__func__);
  TraceFunctionParam("%u",adapter);
  TraceFunctionParamListEnd();

  assert(SLICE_TYPE(adapter)==STHelpAdapter);

  if (min_length==0)
    min_length = 2;

  if (length>1)
  {
    slice_index const next = SLICE_NEXT1(adapter);
    slice_index const prototypes[] =
    {
      alloc_help_adapter_slice(length-1,min_length-1),
      alloc_pipe(STEndOfRoot)
    };
    enum
    {
      nr_prototypes = sizeof prototypes / sizeof prototypes[0]
    };
    help_branch_insert_slices(next,prototypes,nr_prototypes);

    {
      slice_index const set_adapter = branch_find_slice(STHelpAdapter,
                                                        next,
                                                        stip_traversal_context_help);
      assert(set_adapter!=no_slice);
      help_branch_make_root_slices(set_adapter,state);
      state->spun_off[adapter] = state->spun_off[set_adapter];
      pipe_remove(set_adapter);
    }
  }

  TraceValue("%u\n",state->spun_off[adapter]);

  TraceFunctionExit(__func__);
  TraceFunctionParamListEnd();
}
Esempio n. 19
0
static void write_defense(slice_index si, stip_structure_traversal *st)
{
  state_type * const state = st->param;
  stip_length_type const save_length = state->length;
  structure_traversal_level_type const save_level = state->branch_level;;

  state->branch_level = st->level;
  state->length = SLICE_U(si).branch.length;

  stip_traverse_structure_children(si,st);

  if (st->level==structure_traversal_level_top)
    state->nr_chars_written += fprintf(state->file,
                                                "%u",
                                                SLICE_U(si).branch.length/2+1);

  state->length = save_length;
  state->branch_level = save_level;
}
Esempio n. 20
0
static void filter_output_mode(slice_index si, stip_structure_traversal *st)
{
  TraceFunctionEntry(__func__);
  TraceFunctionParam("%u",si);
  TraceFunctionParamListEnd();

  if (SLICE_U(si).output_mode_selector.mode==output_mode_tree)
    stip_traverse_structure_children_pipe(si,st);

  TraceFunctionExit(__func__);
  TraceFunctionResultEnd();
}
Esempio n. 21
0
static void increase_min_length_branch(slice_index si, stip_structure_traversal *st)
{
  TraceFunctionEntry(__func__);
  TraceFunctionParam("%u",si);
  TraceFunctionParamListEnd();

  stip_traverse_structure_children_pipe(si,st);
  SLICE_U(si).branch.min_length += 2;

  TraceFunctionExit(__func__);
  TraceFunctionParamListEnd();
}
Esempio n. 22
0
static void write_help(slice_index si, stip_structure_traversal *st)
{
  state_type * const state = st->param;

  if (state->reci_goal.type!=no_goal)
    stip_traverse_structure_children(si,st);
  else
  {
    if (st->level==structure_traversal_level_top
        && state->length>slack_length+2
        && SLICE_U(si).branch.min_length>=state->length-1)
      state->nr_chars_written += fprintf(state->file,"%s","exact-");

    if (is_help_reci(si))
    {
      state->nr_chars_written += fprintf(state->file,"%s", "reci-");
      state->length += 2;
    }

    if (is_pser(si,st))
    {
      if (branch_find_slice(STEndOfBranchGoal,si,stip_traversal_context_help)!=no_slice
          || branch_find_slice(STEndOfBranchGoalImmobile,si,stip_traversal_context_help)!=no_slice)
      {
        state->nr_chars_written += fprintf(state->file,"%s","phser-");
        ++state->length;
      }
      else if (branch_find_slice(STEndOfBranchForced,si,stip_traversal_context_help)!=no_slice)
        state->nr_chars_written += fprintf(state->file,"%s","phser-");
      else
      {
        state->nr_chars_written += fprintf(state->file,"%s","pser-");
        ++state->length;
      }
    }
    else if (!is_help_play_implicit(si,st))
      state->nr_chars_written += fprintf(state->file,"%s", "h");

    stip_traverse_structure_children(si,st);

    if (st->level==structure_traversal_level_top)
    {
      state->nr_chars_written += fprintf(state->file,"%u",state->length/2);
      if (state->length%2==1)
        state->nr_chars_written += fprintf(state->file,"%s",".5");
    }
    else
    {
      /* h part of a ser-h - no need to write length */
    }
  }
}
Esempio n. 23
0
/* 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 april_chess_fork_solve(slice_index si)
{
  circe_rebirth_context_elmt_type * const context = &circe_rebirth_context_stack[circe_rebirth_context_stack_pointer];

  TraceFunctionEntry(__func__);
  TraceFunctionParam("%u",si);
  TraceFunctionParamListEnd();

  binary_solve_if_then_else(si,!SLICE_U(si).circe_handler.variant->is_walk_affected[context->relevant_walk]);

  TraceFunctionExit(__func__);
  TraceFunctionResultEnd();
}
Esempio n. 24
0
static void end_insertion_if_too_short(slice_index si,
                                       stip_structure_traversal *st)
{
  TraceFunctionEntry(__func__);
  TraceFunctionParam("%u",si);
  TraceFunctionParamListEnd();

  if (SLICE_U(si).branch.length>slack_length+1)
    stip_traverse_structure_children_pipe(si,st);

  TraceFunctionExit(__func__);
  TraceFunctionResultEnd();
}
Esempio n. 25
0
/* Allocate a system of slices that tests whether a target square has been
 * reached
 * @return index of entry slice
 */
slice_index alloc_goal_target_reached_tester_system(square target)
{
  slice_index result;
  slice_index target_tester;
  Goal const goal = { goal_target, target };

  TraceFunctionEntry(__func__);
  TraceSquare(target);
  TraceFunctionParamListEnd();

  target_tester = alloc_pipe(STGoalTargetReachedTester);
  SLICE_U(target_tester).goal_handler.goal.type = goal_target;
  SLICE_U(target_tester).goal_handler.goal.target = target;
  pipe_link(target_tester,alloc_true_slice());

  result = alloc_goal_reached_tester_slice(goal,target_tester);

  TraceFunctionExit(__func__);
  TraceFunctionResult("%u",result);
  TraceFunctionResultEnd();
  return result;
}
Esempio n. 26
0
static void visit_output_mode_selector(slice_index si, stip_structure_traversal *st)
{
  TraceFunctionEntry(__func__);
  TraceFunctionParam("%u",si);
  TraceFunctionParamListEnd();

  if (SLICE_U(si).output_mode_selector.mode==output_mode_line)
    solving_insert_output_plaintext_line_slices(si);
  else
    solving_insert_output_plaintext_tree_slices(si);

  TraceFunctionExit(__func__);
  TraceFunctionResultEnd();
}
Esempio n. 27
0
/* Make the postkey play representation of a non-postkey play representation
 * @param adapter identifies adapter slice into battle branch
 * @return identifier to adapter slice into postkey representation
 */
slice_index battle_branch_make_postkeyplay(slice_index adapter)
{
  slice_index result;

  TraceFunctionEntry(__func__);
  TraceFunctionParam("%u",adapter);
  TraceFunctionParamListEnd();

  TraceStipulation(adapter);

  assert(SLICE_TYPE(adapter)==STAttackAdapter);

  {
    slice_index const notend = branch_find_slice(STNotEndOfBranchGoal,
                                                 adapter,
                                                 stip_traversal_context_intro);
    stip_length_type const length = SLICE_U(adapter).branch.length;
    stip_length_type const min_length = SLICE_U(adapter).branch.min_length;
    slice_index const proto = alloc_defense_adapter_slice(length-1,
                                                          min_length-1);
    assert(notend!=no_slice);
    defense_branch_insert_slices(notend,&proto,1);

    result = branch_find_slice(STDefenseAdapter,
                               notend,
                               stip_traversal_context_defense);
    assert(result!=no_slice);

    branch_shorten_slices(adapter,STDefenseAdapter,stip_traversal_context_intro);
    pipe_remove(adapter);
  }

  TraceFunctionExit(__func__);
  TraceFunctionParam("%u",result);
  TraceFunctionParamListEnd();
  return result;
}
Esempio n. 28
0
/* Shorten a help branch by 1 half move
 * @param identifies entry slice of branch to be shortened
 */
void help_branch_shorten(slice_index adapter)
{
  slice_index const next = SLICE_NEXT1(adapter);

  TraceFunctionEntry(__func__);
  TraceFunctionParam("%u",adapter);
  TraceFunctionParamListEnd();

  assert(SLICE_TYPE(adapter)==STHelpAdapter);

  {
    /* find the new spot for adapter by inserting a copy */
    slice_index const prototype = copy_slice(adapter);
    help_branch_insert_slices(next,&prototype,1);
  }

  {
    /* move adapter to its new spot */
    slice_index const copy = branch_find_slice(STHelpAdapter,
                                               next,
                                               stip_traversal_context_help);
    assert(copy!=no_slice);
    pipe_link(SLICE_PREV(adapter),next);
    pipe_append(copy,adapter);
    pipe_remove(copy);
  }

  /* adjust the length and min_length members */
  --SLICE_U(adapter).branch.length;
  if (SLICE_U(adapter).branch.min_length<=0)
    increase_min_length(adapter);
  --SLICE_U(adapter).branch.min_length;
  branch_shorten_slices(next,STHelpAdapter,stip_traversal_context_help);

  TraceFunctionExit(__func__);
  TraceFunctionResultEnd();
}
Esempio n. 29
0
static void stip_traverse_moves_fork_on_remaining(slice_index si,
                                                  stip_moves_traversal *st)
{
  TraceFunctionEntry(__func__);
  TraceFunctionParam("%u",si);
  TraceFunctionParamListEnd();

  if (st->remaining<=SLICE_U(si).fork_on_remaining.threshold)
    stip_traverse_moves(SLICE_NEXT2(si),st);
  else
    stip_traverse_moves(SLICE_NEXT1(si),st);

  TraceFunctionExit(__func__);
  TraceFunctionResultEnd();
}
Esempio n. 30
0
/* Allocate a STGoalCheckReachedTester slice.
 * @param starter_or_adversary is the starter or its adversary to be in check?
 * @return index of allocated slice
 */
slice_index alloc_goal_check_reached_tester_slice(goal_applies_to_starter_or_adversary starter_or_adversary)
{
  slice_index result;

  TraceFunctionEntry(__func__);
  TraceFunctionParamListEnd();

  result = alloc_pipe(STGoalCheckReachedTester);
  SLICE_U(result).goal_filter.applies_to_who = starter_or_adversary;

  TraceFunctionExit(__func__);
  TraceFunctionResult("%u",result);
  TraceFunctionResultEnd();
  return result;
}