static void explore_find_target_square()

static int prev_travel_moves[2] = {-1, -1};
static int prev_travel_index    = 0;
static struct coord_def prev_explore_target = coord_def(-30000, -30000);
static int anti_zigzag_dir = -1;
static void reset_zigzag_info()

    travel_pathfind tp;
    coord_def       seed = you.pos();

    prev_explore_target = coord_def(-30000, -30000);

    // "Improved" explore: keep moving in a line along the same
    // direction as the previous move, stop if we hit a barrier or
    // something that would slow us down, and use *that* as the
    // floodout seed.  This is meant to:
    //
    // 1) Prevent explore from sticking its head in a room and then
    //    backing out even though the room has unexplored corners
    //    because there are unexplored squares closer than the corners.
    //
    // 2) Similarly, prevent the behavior of going a little bit down
    //    a long, straight corridor only to back out of it because
    //    the nearest unexplored square in that corridor is
    //    LOS_RADIUS + 1 squares away, which is further away than
    //    another unexplored square which is in the opposite direction.
    // 
    // 3) Prevent the annoying zig-zag when exploring open spaces.
    //
    // We stop at squares that would slow us down so that we won't slog
    // across a bunch of shallow water just for the sake of going in
    // a straight line.
    //
    // Not yet used with greedy explore because I can't figure out
    // how to combined it with greediness in a way that won't display
    // weird or unintuitive behavior.
    if (you.running != RMODE_EXPLORE_GREEDY && Options.explore_improved
        && (you.prev_move_x || you.prev_move_y))
    {
        coord_def prev_move_delta = you.prev_move();

    prev_travel_moves[0] = -1;
    prev_travel_moves[1] = -1;
    prev_travel_index    =  0;
    anti_zigzag_dir      = -1;
}

        dungeon_feature_type feature;
        do {
            seed += prev_move_delta;
            feature = grd(seed);
        } while (is_travelsafe_square(seed.x, seed.y)
                 && is_traversable(feature)
                 && feature_traverse_cost(feature) == 1);

static void set_target_square(const coord_def &target)
{
    you.running.x = target.x;
    you.running.y = target.y;

        seed -= prev_move_delta;

    prev_explore_target = target;
}

        // Has moving along the straight line found an unexplored
        // square?  If so, just use that square as the target.
        if (!is_terrain_seen(seed + prev_move_delta) && seed != you.pos())
        {
            you.running.x = seed.x;
            you.running.y = seed.y;
            return;
        }
    }
    tp.set_floodseed(seed, true);

static void explore_find_target_square()
{
    travel_pathfind tp;
    tp.set_floodseed(you.pos(), true);

        you.running.x = whereto.x;
        you.running.y = whereto.y;

        // Anti-zigzag turned off, or found a greedy target so we
        // don't need anti-zigzaging.
        if (!Options.explore_improved || whereto != tp.unexplored_square())
        {
            set_target_square(whereto);
            reset_zigzag_info();
            return;
        }
        // If the two previous travel moves are perpendicular to each
        // other and the two previous explore targets are close to each
        // other, then we're probably zigzaging.
        if (prev_travel_moves[0] != -1
            && prev_travel_moves[1] != -1
            && (abs(prev_travel_moves[1] - prev_travel_moves[0]) % 4) == 2
            && grid_distance(prev_explore_target.x, prev_explore_target.y,
                             whereto.x, whereto.y) <= (LOS_RADIUS + 1))
        {
            // Try moving along the line that bisects the right angle.
            if (abs(prev_travel_moves[0] - prev_travel_moves[1]) == 6)
                anti_zigzag_dir = 0;
            else
                anti_zigzag_dir = std::min(prev_travel_moves[0],
                                           prev_travel_moves[1]) + 1;
        }
        // anti_zigzag_dir might have just been set, or might have
        // persisted from the previous call to
        // explore_find_target_square().
        if (anti_zigzag_dir != -1)
        {
            coord_def target = you.pos();
            coord_def delta  = Compass[anti_zigzag_dir];
            dungeon_feature_type feature;
            do {
                target += delta;
                feature = grd(target);
            } while (is_travelsafe_square(target.x, target.y)
                     && is_traversable(feature)
                     && feature_traverse_cost(feature) == 1);
            target -= delta;
            // Has moving along the straight line found an unexplored
            // square?
            if (!is_terrain_seen(target + delta) && target != you.pos())
            {
                set_target_square(target);
                return;
            }
            else
                anti_zigzag_dir = -1;
        }
        set_target_square(whereto);

        {

            reset_zigzag_info();
        }

        reset_zigzag_info();

        if (you.running < 0 && (*move_x || *move_y))
        {
            const int delta_to_dir[9] = {
                7,  0, 1,
                6, -1, 2,
                5,  4, 3
            };
            prev_travel_moves[prev_travel_index] =
                delta_to_dir[(*move_x + 1) + 3 * (*move_y + 1)];
            prev_travel_index = !prev_travel_index;
        }

    reset_zigzag_info();

    reset_zigzag_info();

        If set to true explore will used an expiremental improved algorithm
        which is meant to reduce backtracking and zig-zagging.  Currently
        only works with non-greedy explore.

        If set to true explore will attempt to reduce zig-zagging during
        auto-explore.  In most circumstances this will increase the
        number of turns spent to auto-explore an entire level by
        less than 1% (with a 2% increase the maximum), but with
        a 7% to 13% increase in the Shoals and in city-type levels
        such as those found in the Vaults.