Exemple #1
0
void intelligent_place_white_rider(unsigned int placed_index,
                                   square placed_on,
                                   void (*go_on)(void))
{
  piece_walk_type const placed_type = white[placed_index].type;
  Flags const placed_flags = white[placed_index].flags;
  square const placed_comes_from = white[placed_index].diagram_square;
  int const dir = GuardDir[placed_type-Pawn][placed_on].dir;
  square const target = GuardDir[placed_type-Pawn][placed_on].target;

  TraceFunctionEntry(__func__);
  TraceFunctionParam("%u",placed_index);
  TraceSquare(placed_on);
  TraceFunctionParamListEnd();

  switch (dir)
  {
    case guard_dir_check_uninterceptable:
      break;

    case guard_dir_guard_uninterceptable:
      if (placed_index>index_of_guarding_piece
          && intelligent_reserve_officer_moves_from_to(White,
                                                       placed_comes_from,
                                                       placed_type,
                                                       placed_on))
      {
        occupy_square(placed_on,placed_type,placed_flags);
        (*go_on)();
        intelligent_unreserve();
      }
      break;

    default:
      if (intelligent_reserve_officer_moves_from_to(White,
                                                    placed_comes_from,
                                                    placed_type,
                                                    placed_on))
      {
        occupy_square(placed_on,placed_type,placed_flags);

        if (placed_index>index_of_guarding_piece
            || dir==0
            || TSTFLAG(being_solved.spec[target],Black)
            || !is_line_empty(placed_on,target,dir))
          (*go_on)();
        else
          intelligent_intercept_guard_by_white(target,dir,go_on);

        intelligent_unreserve();
      }
      break;
  }

  TraceFunctionExit(__func__);
  TraceFunctionResultEnd();
}
static void by_knight(slice_index si,
                      unsigned int index_of_checker,
                      square const check_from)
{
  int const diff = being_solved.king_square[Black]-check_from;
  int const dir = CheckDir[Knight][diff];

  TraceFunctionEntry(__func__);
  TraceFunctionParam("%u",index_of_checker);
  TraceSquare(check_from);
  TraceFunctionParamListEnd();

  if (dir!=0
      && intelligent_reserve_white_officer_moves_from_to_checking(white[index_of_checker].diagram_square,
                                                                  Knight,
                                                                  check_from))
  {
    occupy_square(check_from,Knight,white[index_of_checker].flags);
    init_disturb_mate_dir(check_from,being_solved.king_square[Black]-check_from);
    pipe_solve_delegate(si);
    fini_disturb_mate_dir();
    intelligent_unreserve();
  }

  TraceFunctionExit(__func__);
  TraceFunctionResultEnd();
}
Exemple #3
0
void intelligent_place_black_knight(unsigned int placed_index,
                                    square placed_on,
                                    void (*go_on)(void))
{
  Flags const placed_flags = black[placed_index].flags;
  square const placed_comes_from = black[placed_index].diagram_square;

  TraceFunctionEntry(__func__);
  TraceFunctionParam("%u",placed_index);
  TraceSquare(placed_on);
  TraceFunctionParamListEnd();

  if ((being_solved.king_square[White]==initsquare
       || CheckDir[Knight][being_solved.king_square[White]-placed_on]==0)
      && intelligent_reserve_officer_moves_from_to(Black,
                                                   placed_comes_from,
                                                   Knight,
                                                   placed_on))
  {
    occupy_square(placed_on,Knight,placed_flags);
    if (DisturbMateDirKnight[placed_on]==0)
      (*go_on)();
    else
      intelligent_pin_black_piece(placed_on,go_on);
    intelligent_unreserve();
  }

  TraceFunctionExit(__func__);
  TraceFunctionResultEnd();
}
Exemple #4
0
void intelligent_place_pinned_unpromoted_black_pawn(unsigned int placed_index,
                                                    square placed_on,
                                                    void (*go_on)(void))
{
  Flags const placed_flags = black[placed_index].flags;
  square const placed_comes_from = black[placed_index].diagram_square;

  TraceFunctionEntry(__func__);
  TraceFunctionParam("%u",placed_index);
  TraceSquare(placed_on);
  TraceFunctionParamListEnd();

  if (!TSTFLAGMASK(sq_spec[placed_on],BIT(BlBaseSq)|BIT(BlPromSq))
      && !black_pawn_attacks_king(placed_on)
      && intelligent_reserve_black_pawn_moves_from_to_no_promotion(placed_comes_from,
                                                                   placed_on))
  {
    occupy_square(placed_on,Pawn,placed_flags);
    (*go_on)();
    intelligent_unreserve();
  }

  TraceFunctionExit(__func__);
  TraceFunctionResultEnd();
}
Exemple #5
0
void intelligent_place_unpromoted_white_pawn(unsigned int placed_index,
                                             square placed_on,
                                             void (*go_on)(void))
{
  square const placed_comes_from = white[placed_index].diagram_square;
  Flags const placed_flags = white[placed_index].flags;

  TraceFunctionEntry(__func__);
  TraceFunctionParam("%u",placed_index);
  TraceSquare(placed_on);
  TraceFunctionParamListEnd();

  if (!TSTFLAGMASK(sq_spec[placed_on],BIT(WhBaseSq)|BIT(WhPromSq))
      && GuardDir[Pawn-Pawn][placed_on].dir<guard_dir_guard_uninterceptable
      && intelligent_reserve_white_pawn_moves_from_to_no_promotion(placed_comes_from,
                                                                   placed_on))
  {
    occupy_square(placed_on,Pawn,placed_flags);
    (*go_on)();
    intelligent_unreserve();
  }

  TraceFunctionExit(__func__);
  TraceFunctionResultEnd();
}
Exemple #6
0
static boolean avoid_observing_if_imitator_blocked_angle_hopper(angle_t angle)
{
  boolean result;
  square const sq_observer = move_generation_stack[CURRMOVE_OF_PLY(nbply)].departure;
  square const sq_landing = move_generation_stack[CURRMOVE_OF_PLY(nbply)].arrival;
  piece_walk_type const p = get_walk_of_piece_on_square(sq_observer);
  Flags const flags = being_solved.spec[sq_observer];
  vec_index_type const vec_index_departure_hurdle = 2*interceptable_observation[observation_context].vector_index1;
  numvec const vec_departure_hurdle1 = -angle_vectors[angle][vec_index_departure_hurdle];
  numvec const vec_departure_hurdle2 = -angle_vectors[angle][vec_index_departure_hurdle-1];
  square const sq_hurdle = sq_landing+vec[interceptable_observation[observation_context].vector_index1];
  numvec const diff_observer_hurdle = sq_hurdle-sq_observer;
  int const nr_steps1 = abs(diff_observer_hurdle/vec_departure_hurdle1);
  int const nr_steps2 = abs(diff_observer_hurdle/vec_departure_hurdle2);
  numvec step;

  if (nr_steps1==0)
    step = vec_departure_hurdle2;
  else if (nr_steps2==0)
    step = vec_departure_hurdle1;
  else
    step = nr_steps1<nr_steps2 ? vec_departure_hurdle1 : vec_departure_hurdle2;

  empty_square(sq_observer);
  result = (have_all_imitators_hurdle(diff_observer_hurdle)
            && are_all_imitator_lines_clear(step,step,diff_observer_hurdle)
            && are_all_imitator_arrivals_empty(sq_observer,sq_landing));
  occupy_square(sq_observer,p,flags);

  return result;
}
Exemple #7
0
/* Place the white king; intercept checks if necessary
 * @param place_on where to place the king
 * @param go_on what to do after having placed the king?
 */
void intelligent_place_white_king(square place_on, void (*go_on)(void))
{
  TraceFunctionEntry(__func__);
  TraceSquare(place_on);
  TraceFunctionParamListEnd();

  if (!guards_from(place_on)
      && !is_square_uninterceptably_observed_ortho(Black,place_on)
      && intelligent_reserve_white_king_moves_from_to(white[index_of_king].diagram_square,
                                                      place_on))
  {
    being_solved.king_square[White] = place_on;
    occupy_square(place_on,King,white[index_of_king].flags);

    current_direction = vec_queen_start-1;
    go_on_after = go_on;
    continue_intercepting_checks();

    being_solved.king_square[White] = initsquare;
    empty_square(place_on);

    intelligent_unreserve();
  }

  TraceFunctionExit(__func__);
  TraceFunctionResultEnd();
}
Exemple #8
0
void intelligent_place_pinned_promoted_black_knight(unsigned int placed_index,
                                                    square placed_on,
                                                    void (*go_on)(void))
{
  square const placed_comes_from = black[placed_index].diagram_square;
  Flags const placed_flags = black[placed_index].flags;

  TraceFunctionEntry(__func__);
  TraceFunctionParam("%u",placed_index);
  TraceSquare(placed_on);
  TraceFunctionParamListEnd();

  if ((being_solved.king_square[White]==initsquare
       || CheckDir[Knight][being_solved.king_square[White]-placed_on]==0)
      && intelligent_reserve_promoting_black_pawn_moves_from_to(placed_comes_from,
                                                                Knight,
                                                                placed_on))
  {
    occupy_square(placed_on,Knight,placed_flags);
    (*go_on)();
    intelligent_unreserve();
  }

  TraceFunctionExit(__func__);
  TraceFunctionResultEnd();
}
Exemple #9
0
/* 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();
}
static void by_rider(slice_index si,
                     unsigned int index_of_checker,
                     square const check_from)
{
  piece_walk_type const checker_type = white[index_of_checker].type;
  Flags const checker_flags = white[index_of_checker].flags;
  int const diff = being_solved.king_square[Black]-check_from;
  int const dir = CheckDir[checker_type][diff];

  TraceFunctionEntry(__func__);
  TraceFunctionParam("%u",index_of_checker);
  TraceSquare(check_from);
  TraceFunctionParamListEnd();

  if (dir!=0
      && intelligent_reserve_white_officer_moves_from_to_checking(white[index_of_checker].diagram_square,
                                                                  checker_type,
                                                                  check_from))
  {
    occupy_square(check_from,checker_type,checker_flags);
    remember_mating_line(checker_type,check_from,+1);
    pipe_solve_delegate(si);
    remember_mating_line(checker_type,check_from,-1);
    intelligent_unreserve();
  }

  TraceFunctionExit(__func__);
  TraceFunctionResultEnd();
}
Exemple #11
0
static void HandleAddedPiece(square s, void *param)
{
    piece_addition_settings * const settings = param;

    if (!is_square_empty(s))
    {
        if (settings->type==piece_addition_initial)
        {
            WriteSquare(&output_plaintext_engine,stdout,s);
            output_plaintext_message(OverwritePiece);

            underworld_make_space(nr_ghosts);
            underworld[nr_ghosts-1].walk = get_walk_of_piece_on_square(s);
            underworld[nr_ghosts-1].flags = being_solved.spec[s];
            underworld[nr_ghosts-1].on = s;
        }
        else
        {
            move_effect_journal_do_circe_volcanic_remember(move_effect_reason_diagram_setup,
                    s);
            move_effect_journal_do_piece_removal(move_effect_reason_diagram_setup,
                                                 s);
        }
    }

    if (settings->type==piece_addition_twinning)
        move_effect_journal_do_piece_creation(move_effect_reason_diagram_setup,
                                              s,settings->walk,
                                              settings->spec,
                                              no_side);
    else
        occupy_square(s,settings->walk,settings->spec);
}
static void by_unpromoted_pawn(slice_index si,
                               unsigned int index_of_checker,
                               square const check_from)
{
  square const checker_from = white[index_of_checker].diagram_square;
  Flags const checker_flags = white[index_of_checker].flags;
  SquareFlags const prom_square = BIT(WhPromSq)|BIT(BlPromSq);

  TraceFunctionEntry(__func__);
  TraceFunctionParam("%u",index_of_checker);
  TraceSquare(check_from);
  TraceFunctionParamListEnd();

  if (!TSTFLAGMASK(sq_spec[check_from],prom_square)
      && GuardDir[Pawn-Pawn][check_from].dir==guard_dir_check_uninterceptable
      && intelligent_reserve_white_pawn_moves_from_to_checking(checker_from,check_from))
  {
    occupy_square(check_from,Pawn,checker_flags);
    init_disturb_mate_dir(check_from,being_solved.king_square[Black]-check_from);
    pipe_solve_delegate(si);
    fini_disturb_mate_dir();
    empty_square(check_from);
    intelligent_unreserve();
  }

  TraceFunctionExit(__func__);
  TraceFunctionResultEnd();
}
Exemple #13
0
static boolean is_mate_square(Side other_side)
{
  boolean result = false;

  if (is_square_empty(being_solved.king_square[other_side]))
  {
    TraceFunctionEntry(__func__);
    TraceEnumerator(Side,other_side,"");
    TraceFunctionParamListEnd();

    TraceSquare(being_solved.king_square[other_side]);TraceEOL();

    occupy_square(being_solved.king_square[other_side],King,BIT(Royal)|BIT(other_side));

    if (conditional_pipe_solve_delegate(temporary_hack_mate_tester[other_side])
        ==previous_move_has_solved)
      result = true;

    empty_square(being_solved.king_square[other_side]);

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

  return result;
}
Exemple #14
0
void intelligent_place_promoted_white_knight(unsigned int placed_index,
                                             square placed_on,
                                             void (*go_on)(void))
{
  square const placed_comes_from = white[placed_index].diagram_square;
  Flags const placed_flags = white[placed_index].flags;

  TraceFunctionEntry(__func__);
  TraceFunctionParam("%u",placed_index);
  TraceSquare(placed_on);
  TraceFunctionParamListEnd();

  if (GuardDir[Knight-Pawn][placed_on].dir<guard_dir_guard_uninterceptable
      && intelligent_reserve_promoting_white_pawn_moves_from_to(placed_comes_from,
                                                                Knight,
                                                                placed_on))
  {
    occupy_square(placed_on,Knight,placed_flags);
    (*go_on)();
    intelligent_unreserve();
  }

  TraceFunctionExit(__func__);
  TraceFunctionResultEnd();
}
Exemple #15
0
void intelligent_place_white_knight(unsigned int placed_index,
                                    square placed_on,
                                    void (*go_on)(void))
{
  square const placed_comes_from = white[placed_index].diagram_square;
  Flags const placed_flags = white[placed_index].flags;

  TraceFunctionEntry(__func__);
  TraceFunctionParam("%u",placed_index);
  TraceSquare(placed_on);
  TraceFunctionParamListEnd();

  switch (GuardDir[Knight-Pawn][placed_on].dir)
  {
    case guard_dir_check_uninterceptable:
      break;

    case guard_dir_guard_uninterceptable:
      if (placed_index>index_of_guarding_piece
          && intelligent_reserve_officer_moves_from_to(White,
                                                       placed_comes_from,
                                                       Knight,
                                                       placed_on))
      {
        occupy_square(placed_on,Knight,placed_flags);
        (*go_on)();
        intelligent_unreserve();
      }
      break;

    default:
      if (intelligent_reserve_officer_moves_from_to(White,
                                                    placed_comes_from,
                                                    Knight,
                                                    placed_on))
      {
        occupy_square(placed_on,Knight,placed_flags);
        (*go_on)();
        intelligent_unreserve();
      }
      break;
  }

  TraceFunctionExit(__func__);
  TraceFunctionResultEnd();
}
Exemple #16
0
static void generate_make_for_one_take(numecoup take_current,
                                       square take_capture)
{
  piece_walk_type const taken = get_walk_of_piece_on_square(take_capture);
  Flags const taken_spec = being_solved.spec[take_capture];
  square const take_departure = move_generation_stack[take_current].departure;
  square const take_arrival = move_generation_stack[take_current].arrival;
  numecoup const make_filtered_base = CURRMOVE_OF_PLY(nbply);
  numecoup make_current;

  TraceFunctionEntry(__func__);
  TraceFunctionParam("%u",take_current);
  TraceSquare(take_capture);
  TraceFunctionParamListEnd();

  empty_square(take_capture);
  occupy_square(take_arrival,
                get_walk_of_piece_on_square(take_departure),
                being_solved.spec[take_departure]);
  empty_square(take_departure);

  curr_generation->departure = take_arrival;
  move_generation_current_walk = taken;
  generate_moves_for_piece_based_on_walk();
  curr_generation->departure = take_departure;

  move_generator_filter_captures(make_filtered_base,&always_reject);

  for (make_current = make_filtered_base+1; make_current<=CURRMOVE_OF_PLY(nbply); ++make_current)
  {
    square const make_arrival = move_generation_stack[make_current].arrival;
    move_generation_stack[make_current] = move_generation_stack[take_current];
    move_generation_stack[make_current].arrival = make_arrival;
  }

  occupy_square(take_departure,
                get_walk_of_piece_on_square(take_arrival),
                being_solved.spec[take_arrival]);
  empty_square(take_arrival);
  occupy_square(take_capture,taken,taken_spec);

  TraceFunctionExit(__func__);
  TraceFunctionResultEnd();
}
Exemple #17
0
void intelligent_place_pinned_black_rider(unsigned int placed_index,
                                          square placed_on,
                                          void (*go_on)(void))
{
  piece_walk_type const intercepter_type = black[placed_index].type;
  Flags const placed_flags = black[placed_index].flags;
  square const placed_comes_from = black[placed_index].diagram_square;

  TraceFunctionEntry(__func__);
  TraceFunctionParam("%u",placed_index);
  TraceSquare(placed_on);
  TraceFunctionParamListEnd();

  {
    int const check_dir = find_interceptable_check_dir(intercepter_type,
                                                       placed_on);
    if (check_dir==0)
    {
      if (intelligent_reserve_officer_moves_from_to(Black,
                                                    placed_comes_from,
                                                    intercepter_type,
                                                    placed_on))
      {
        occupy_square(placed_on,intercepter_type,placed_flags);
        (*go_on)();
        intelligent_unreserve();
      }
    }
    else if (check_dir!=checkdir_uninterceptable
             && intelligent_reserve_officer_moves_from_to(Black,
                                                          placed_comes_from,
                                                          intercepter_type,
                                                          placed_on))
    {
      occupy_square(placed_on,intercepter_type,placed_flags);
      intelligent_intercept_check_by_black(check_dir,go_on);
      intelligent_unreserve();
    }
  }

  TraceFunctionExit(__func__);
  TraceFunctionResultEnd();
}
Exemple #18
0
static void place_rider(unsigned int placed_index,
                        piece_walk_type placed_type,
                        square placed_on,
                        void (*go_on)(void))
{
  rider_placement_stack_elmt_type const elmt = { placed_on, go_on, stack_top };

  TraceFunctionEntry(__func__);
  TraceFunctionParam("%u",placed_index);
  TraceWalk(placed_type);
  TraceSquare(placed_on);
  TraceFunctionParamListEnd();

  stack_top = &elmt;

  occupy_square(placed_on,placed_type,black[placed_index].flags);

  switch (how_does_rider_disturb(placed_type,placed_on))
  {
    case rider_doesnt_disturb:
      rider_placed();
      break;

    case rider_requires_interception:
    {
      rider_interception_stack_elmt_type elmt = {
          disturbance_by_rider_index_ranges[placed_type-Queen].start,
          disturbance_by_rider_index_ranges[placed_type-Queen].end,
          placed_on,
          rider_interception_top
      };
      rider_interception_top = &elmt;
      next_rider_interception();
      assert(rider_interception_top==&elmt);
      rider_interception_top = elmt.succ;

      intelligent_pin_black_piece(placed_on,&rider_placed);
      break;
    }

    case rider_requires_pin:
      intelligent_pin_black_piece(placed_on,&rider_placed);
      break;

    default:
      assert(0);
      break;
  }

  assert(stack_top==&elmt);
  stack_top = elmt.next;

  TraceFunctionExit(__func__);
  TraceFunctionResultEnd();
}
Exemple #19
0
static boolean init_rebirth_squares(circe_rebirth_context_elmt_type const *context)
{
  boolean result = false;
  square const sq_capture = context->relevant_square;
  piece_walk_type const pi_capturing = get_walk_of_piece_on_square(sq_capture);
  Flags const flags_capturing = being_solved.spec[sq_capture];

  /* we need to do this for this module to work in both Circe and Anticirce:
   * normally (i.e. unless e.g. mirror is selected), the capturee's walk
   * determines the squares reachable by the make part of moves, independently
   * of whether the reborn piece is the capturer or the capturee.
   */
  Side const relevant_side = (trait[context->relevant_ply]==context->relevant_side
                              ? advers(context->relevant_side)
                              : context->relevant_side);

  TraceFunctionEntry(__func__);
  TraceFunctionParamListEnd();

  take_make_circe_current_rebirth_square_index[stack_pointer] = take_make_circe_current_rebirth_square_index[stack_pointer-1];

  occupy_square(context->relevant_square,
		        context->relevant_walk,
		        context->reborn_spec);

  init_single_piece_move_generator(context->relevant_square);

  result = (conditional_pipe_solve_delegate(temporary_hack_circe_take_make_rebirth_squares_finder[relevant_side])
            ==previous_move_has_solved);

  assert(pi_capturing!=Invalid);

  if (pi_capturing==Empty) /* en passant, Locust, ... */
    empty_square(context->relevant_square);
  else
    occupy_square(context->relevant_square,pi_capturing,flags_capturing);

  TraceFunctionExit(__func__);
  TraceFunctionResult("%u",result);
  TraceFunctionResultEnd();
  return result;
}
Exemple #20
0
void intelligent_place_unpromoted_black_pawn(unsigned int placed_index,
                                             square placed_on,
                                             void (*go_on)(void))
{
  Flags const placed_flags = black[placed_index].flags;
  square const placed_comes_from = black[placed_index].diagram_square;

  TraceFunctionEntry(__func__);
  TraceFunctionParam("%u",placed_index);
  TraceSquare(placed_on);
  TraceFunctionParamListEnd();

  if (!TSTFLAGMASK(sq_spec[placed_on],BIT(BlBaseSq)|BIT(BlPromSq))
      && !black_pawn_attacks_king(placed_on)
      && intelligent_reserve_black_pawn_moves_from_to_no_promotion(placed_comes_from,
                                                                   placed_on))
  {
    occupy_square(placed_on,Pawn,placed_flags);

    switch (DisturbMateDirPawn[placed_on])
    {
      case disturbance_by_pawn_capture:
      case disturbance_by_pawn_interception_single:
        intelligent_pin_black_piece(placed_on,go_on);
        break;

      case disturbance_by_pawn_interception_double:
      {
        square const target = placed_on+2*dir_down;
        assert(is_square_empty(target));
        if (is_square_empty(placed_on+dir_down))
        {
          intelligent_intercept_black_move(placed_on,target,go_on);
          intelligent_pin_black_piece(placed_on,go_on);
        }
        else
          (*go_on)();
        break;
      }

      default:
        (*go_on)();
        break;
    }

    intelligent_unreserve();
  }

  TraceFunctionExit(__func__);
  TraceFunctionResultEnd();
}
Exemple #21
0
/* Redo the deneutralisation a half-neutral piece
 */
void redo_half_neutral_deneutralisation(move_effect_journal_entry_type const *entry)
{
  square const on = entry->u.half_neutral_phase_change.on;
  Side const to = entry->u.half_neutral_phase_change.side;

  TraceFunctionEntry(__func__);
  TraceFunctionParamListEnd();

  --being_solved.number_of_pieces[advers(to)][get_walk_of_piece_on_square(on)];
  occupy_square(on,get_walk_of_piece_on_square(on),being_solved.spec[on]&~BIT(advers(to)));

  TraceFunctionExit(__func__);
  TraceFunctionResultEnd();
}
Exemple #22
0
boolean mars_enforce_observer(slice_index si)
{
  circe_rebirth_context_elmt_type * const context = &circe_rebirth_context_stack[circe_rebirth_context_stack_pointer-1];
  square const sq_departure = move_generation_stack[CURRMOVE_OF_PLY(nbply)].departure;
  square const sq_observer = context->rebirth_square;
  boolean result;

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

  assert(circe_rebirth_context_stack_pointer>0);

  if (sq_observer==sq_departure)
  {
    /* restore as if the capture had occcured directly, to allow other
     * conditions (e.g. Madrasi) to correctly work. */
    Flags const spec_observing = being_solved.spec[sq_observer];

    empty_square(sq_observer);
    occupy_square(context->rebirth_from,observing_walk[nbply],spec_observing);
    move_generation_stack[CURRMOVE_OF_PLY(nbply)].departure = context->rebirth_from;

    result = pipe_validate_observation_recursive_delegate(si);

    move_generation_stack[CURRMOVE_OF_PLY(nbply)].departure = sq_observer;
    empty_square(context->rebirth_from);
    occupy_square(sq_observer,observing_walk[nbply],spec_observing);
  }
  else
    result = false;

  TraceFunctionExit(__func__);
  TraceFunctionResult("%u",result);
  TraceFunctionResultEnd();
  return result;
}
Exemple #23
0
static boolean castlingimok(square sq_departure, square sq_arrival)
{
  boolean ret= false;
  piece_walk_type const p = get_walk_of_piece_on_square(sq_departure);
  Flags const flags = being_solved.spec[sq_departure];

  /* I think this should work - clear the K, and move the Is, but don't clear the rook. */
  /* If the Is crash into the R, the move would be illegal as the K moves first.        */
  /* The only other test here is for long castling when the Is have to be clear to move */
  /* one step right (put K back first)as well as two steps left.                        */
  /* But there won't be an I one sq to the left of a1 (a8) so no need to clear the R    */

  switch (sq_arrival-sq_departure)
  {
    case 2*dir_right:  /* 00 - can short-circuit here (only follow K, if ok rest will be ok) */
      empty_square(sq_departure);
      ret = (are_all_imitator_arrivals_empty(sq_departure, sq_departure+dir_right)
             && are_all_imitator_arrivals_empty(sq_departure, sq_departure+2*dir_right));
      occupy_square(sq_departure,p,flags);
      break;

    case 2*dir_left:  /* 000 - follow K, (and move K as well), then follow R */
      empty_square(sq_departure);
      ret = (are_all_imitator_arrivals_empty(sq_departure, sq_departure+dir_left)
             && are_all_imitator_arrivals_empty(sq_departure, sq_departure+2*dir_left));
      occupy_square(sq_departure+2*dir_left,p,flags);
      ret = (ret
             && are_all_imitator_arrivals_empty(sq_departure, sq_departure+dir_left)
             && are_all_imitator_arrivals_empty (sq_departure, sq_departure)
             && are_all_imitator_arrivals_empty(sq_departure, sq_departure+dir_right));
      empty_square(sq_departure+2*dir_left);
      occupy_square(sq_departure,p,flags);
      break;
  }
  return ret;
}
Exemple #24
0
static boolean avoid_observing_if_imitator_blocked_nonstop_equihopper(void)
{
  boolean result;
  square const sq_observer = move_generation_stack[CURRMOVE_OF_PLY(nbply)].departure;
  square const sq_landing = move_generation_stack[CURRMOVE_OF_PLY(nbply)].arrival;
  piece_walk_type const p = get_walk_of_piece_on_square(sq_observer);
  Flags const flags = being_solved.spec[sq_observer];
  numvec const diff_hurdle = (sq_landing-sq_observer)/2;

  empty_square(sq_observer);
  result = (have_all_imitators_hurdle(diff_hurdle)
            && are_all_imitator_arrivals_empty(sq_observer,sq_landing));
  occupy_square(sq_observer,p,flags);

  return result;
}
Exemple #25
0
static boolean avoid_observing_if_imitator_blocked_contragrasshopper(void)
{
  boolean result;
  square const sq_observer = move_generation_stack[CURRMOVE_OF_PLY(nbply)].departure;
  square const sq_landing = move_generation_stack[CURRMOVE_OF_PLY(nbply)].arrival;
  piece_walk_type const p = get_walk_of_piece_on_square(sq_observer);
  Flags const flags = being_solved.spec[sq_observer];
  numvec const step = -vec[interceptable_observation[observation_context].vector_index1];

  empty_square(sq_observer);
  result = (have_all_imitators_hurdle(step)
            && are_all_imitator_lines_clear(step+step,step,sq_landing-sq_observer+step));
  occupy_square(sq_observer,p,flags);

  return result;
}
Exemple #26
0
static boolean find_flights(slice_index si,
                            Side side_in_check,
                            unsigned int nr_flights_to_find)
{
  unsigned int nr_flights_found = 0;
  square const save_king_square = being_solved.king_square[side_in_check];
  piece_walk_type const king_walk = get_walk_of_piece_on_square(save_king_square);
  Flags const king_flags = being_solved.spec[save_king_square];
  square const save_departure = curr_generation->departure ;

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

  siblingply(side_in_check);

  curr_generation->departure = save_king_square;
  move_generation_current_walk = king_walk;
  generate_moves_for_piece_based_on_walk();

  empty_square(save_king_square);

  while (encore())
  {
    being_solved.king_square[side_in_check] = move_generation_stack[CURRMOVE_OF_PLY(nbply)].arrival;
    if ((is_square_empty(being_solved.king_square[side_in_check])
         || TSTFLAG(being_solved.spec[being_solved.king_square[side_in_check]],advers(side_in_check)))
        && being_solved.king_square[side_in_check]!=being_solved.king_square[advers(side_in_check)]
        && !pipe_is_in_check_recursive_delegate(si,side_in_check))
      ++nr_flights_found;

    pop_move();
  }

  being_solved.king_square[side_in_check] = save_king_square;
  occupy_square(save_king_square,king_walk,king_flags);

  curr_generation->departure = save_departure;

  finply();

  TraceFunctionExit(__func__);
  TraceFunctionResult("%u",nr_flights_found>nr_flights_to_find);
  TraceFunctionResultEnd();
  return nr_flights_found>nr_flights_to_find;
}
Exemple #27
0
static boolean avoid_observing_if_imitator_blocked_chinese_leaper(void)
{
  boolean result;
  square const sq_observer = move_generation_stack[CURRMOVE_OF_PLY(nbply)].departure;
  square const sq_landing = move_generation_stack[CURRMOVE_OF_PLY(nbply)].arrival;
  piece_walk_type const p = get_walk_of_piece_on_square(sq_observer);
  Flags const flags = being_solved.spec[sq_observer];
  numvec const vec_pass_target = vec[interceptable_observation[observation_context].vector_index1];
  square const sq_pass = sq_landing+vec_pass_target;

  empty_square(sq_observer);
  result = (are_all_imitator_arrivals_empty(sq_observer,sq_pass)
            && are_all_imitator_arrivals_empty(sq_observer,sq_landing));
  occupy_square(sq_observer,p,flags);

  return result;
}
Exemple #28
0
/* Undo the neutralisation a half-neutral piece
 * @param curr identifies the neutralisation effect
 */
void undo_half_neutral_neutralisation(move_effect_journal_entry_type const *entry)
{
  square const on = entry->u.half_neutral_phase_change.on;
  Side const from = entry->u.half_neutral_phase_change.side;

  TraceFunctionEntry(__func__);
  TraceFunctionParamListEnd();

  assert(TSTFLAG(being_solved.spec[on],White));
  assert(TSTFLAG(being_solved.spec[on],Black));
  assert(is_piece_neutral(being_solved.spec[on]));

  --being_solved.number_of_pieces[advers(from)][get_walk_of_piece_on_square(on)];
  occupy_square(on,get_walk_of_piece_on_square(on),being_solved.spec[on]&~BIT(advers(from)));

  TraceFunctionExit(__func__);
  TraceFunctionResultEnd();
}
Exemple #29
0
/* Neutralise a half-neutral piece
 * @param on position of the piece to be changed
 */
static void do_neutralisation(square on)
{
  move_effect_journal_entry_type * const entry = move_effect_journal_allocate_entry(move_effect_half_neutral_neutralisation,move_effect_reason_half_neutral_neutralisation);
  Side const from = TSTFLAG(being_solved.spec[on],White) ? White : Black;

  TraceFunctionEntry(__func__);
  TraceSquare(on);
  TraceEnumerator(Side,from);
  TraceFunctionParamListEnd();

  entry->u.half_neutral_phase_change.on = on;
  entry->u.half_neutral_phase_change.side = from;

  occupy_square(on,get_walk_of_piece_on_square(on),being_solved.spec[on]|BIT(advers(from)));
  ++being_solved.number_of_pieces[advers(from)][get_walk_of_piece_on_square(on)];

  TraceFunctionExit(__func__);
  TraceFunctionResultEnd();
}
Exemple #30
0
void intelligent_place_white_queen(unsigned int placed_index,
                                   square placed_on,
                                   void (*go_on)(void))
{
  piece_walk_type const placed_type = white[placed_index].type;
  Flags const placed_flags = white[placed_index].flags;
  square const placed_comes_from = white[placed_index].diagram_square;
  int const dir_ortho = GuardDir[Rook-Pawn][placed_on].dir;
  int const dir_diag = GuardDir[Bishop-Pawn][placed_on].dir;

  TraceFunctionEntry(__func__);
  TraceFunctionParam("%u",placed_index);
  TraceSquare(placed_on);
  TraceFunctionParamListEnd();

  if (dir_ortho<guard_dir_guard_uninterceptable
      && dir_diag<guard_dir_guard_uninterceptable
      && intelligent_reserve_officer_moves_from_to(White,
                                                   placed_comes_from,
                                                   placed_type,
                                                   placed_on))
  {
    square const target_ortho = GuardDir[Rook-Pawn][placed_on].target;

    stack_elmt_type const new_top = { placed_index, placed_on, go_on, stack_top };
    stack_top = &new_top;

    occupy_square(placed_on,placed_type,placed_flags);

    if (dir_ortho==0 || TSTFLAG(being_solved.spec[target_ortho],Black) || !is_line_empty(placed_on,target_ortho,dir_ortho))
      intercept_queen_diag();
    else
      intelligent_intercept_guard_by_white(target_ortho,dir_ortho,&intercept_queen_diag);

    assert(stack_top==&new_top);
    stack_top = stack_top->next;

    intelligent_unreserve();
  }

  TraceFunctionExit(__func__);
  TraceFunctionResultEnd();
}