Exemplo n.º 1
0
void intelligent_place_black_piece(unsigned int placed_index,
                                   square placed_on,
                                   void (*go_on)(void))
{
  TraceFunctionEntry(__func__);
  TraceFunctionParam("%u",placed_index);
  TraceSquare(placed_on);
  TraceFunctionParamListEnd();

  switch (black[placed_index].type)
  {
    case Queen:
    case Rook:
    case Bishop:
      intelligent_place_black_rider(placed_index,placed_on,go_on);
      break;

    case Knight:
      intelligent_place_black_knight(placed_index,placed_on,go_on);
      break;

    case Pawn:
      intelligent_place_promoted_black_pawn(placed_index,placed_on,go_on);
      intelligent_place_unpromoted_black_pawn(placed_index,placed_on,go_on);
      break;

    default:
      assert(0);
      break;
  }

  TraceFunctionExit(__func__);
  TraceFunctionResultEnd();
}
Exemplo n.º 2
0
/* Intercept a check to the white king with a black piece on a square
 * @param where_to_intercept what square
 * @param is_diagonal true iff we are intercepting a check on a diagonal line
 * @param go_on what to do after each successful interception?
 */
static void black_piece_on(slice_index si,
                           square where_to_intercept,
                           boolean is_diagonal,
                           void (*go_on)(slice_index si))
{
  unsigned int intercepter_index;

  TraceFunctionEntry(__func__);
  TraceSquare(where_to_intercept);
  TraceFunctionParam("%u",is_diagonal);
  TraceFunctionParamListEnd();

  for (intercepter_index = 1; intercepter_index<MaxPiece[Black]; ++intercepter_index)
    if (black[intercepter_index].usage==piece_is_unused)
    {
      black[intercepter_index].usage = piece_intercepts;

      switch (black[intercepter_index].type)
      {
        case Pawn:
          promoted_black_pawn(si,
                              intercepter_index,where_to_intercept,
                              is_diagonal,
                              go_on);
          if (!TSTFLAGMASK(sq_spec[where_to_intercept],BIT(BlBaseSq)|BIT(BlPromSq)))
            intelligent_place_unpromoted_black_pawn(si,
                                                    intercepter_index,
                                                    where_to_intercept,
                                                    go_on);
          break;

        case Queen:
          break;

        case Rook:
          if (is_diagonal)
            intelligent_place_black_rider(si,
                                          intercepter_index,
                                          where_to_intercept,
                                          go_on);
          break;

        case Bishop:
          if (!is_diagonal)
            intelligent_place_black_rider(si,
                                          intercepter_index,
                                          where_to_intercept,
                                          go_on);
          break;

        case Knight:
          intelligent_place_black_knight(si,
                                         intercepter_index,
                                         where_to_intercept,
                                         go_on);
          break;

        default:
          assert(0);
          break;
      }

      black[intercepter_index].usage = piece_is_unused;
    }

  empty_square(where_to_intercept);

  TraceFunctionExit(__func__);
  TraceFunctionResultEnd();
}