const shop_struct *get_shop(int sx, int sy);

shop_struct *get_shop(int sx, int sy);

const shop_struct *get_shop(int sx, int sy)

shop_struct *get_shop(int sx, int sy)

static bool dgn_shift_item_around(const coord_def &pos, item_def &item)

static coord_def dgn_find_nearest_square(
    const coord_def &pos,
    bool (*acceptable)(const coord_def &),
    bool (*traversable)(const coord_def &) = NULL)

    std::list<coord_def> points;
    for (int yi = -1; yi <= 1; ++yi)

    memset(travel_point_distance, 0, sizeof(travel_distance_grid_t));
    
    std::list<coord_def> points[2];
    int iter = 0;
    points[iter].push_back(pos);
    while (!points[iter].empty())

        for (int xi = -1; xi <= 1; ++xi)

        for (std::list<coord_def>::iterator i = points[iter].begin();
             i != points[iter].end(); ++i)

            if (!xi && !yi)
                continue;

            const coord_def &p = *i;

            const coord_def np(pos.x + xi, pos.y + yi);
            if (!in_bounds(np) || travel_point_distance[np.x][np.y])
                continue;

            if (p != pos && acceptable(p))
                return (p);
            
            travel_point_distance[p.x][p.y] = 1;
            for (int yi = -1; yi <= 1; ++yi)
            {
                for (int xi = -1; xi <= 1; ++xi)
                {
                    if (!xi && !yi)
                        continue;

            travel_point_distance[np.x][np.y] = 1;

                    const coord_def np = p + coord_def(xi, yi);
                    if (!in_bounds(np) || travel_point_distance[np.x][np.y])
                        continue;

            const dungeon_feature_type feat = grd(np);
            if (!grid_is_solid(feat) && !grid_destroys_items(feat))
            {
                int index = item.index();
                move_item_to_grid(&index, np.x, np.y);
                return (true);

                    if (traversable && !traversable(np))
                        continue;
                    
                    points[!iter].push_back(np);
                }

        }

            points.push_back(np);
        }

        points[iter].clear();
        iter = !iter;

    for (std::list<coord_def>::iterator i = points.begin(); i != points.end();
         ++i)

    return (coord_def());
}
static bool item_safe_square(const coord_def &pos)
{
    const dungeon_feature_type feat = grd(pos);
    return (is_traversable(feat) && !grid_destroys_items(feat));
}
// Moves an item on the floor to the nearest adjacent floor-space.
static bool dgn_shift_item(const coord_def &pos, item_def &item)
{
    const coord_def np = dgn_find_nearest_square(pos, item_safe_square);
    if (in_bounds(np) && np != pos)

        if (dgn_shift_item_around(*i, item))
            return (true);

        int index = item.index();
        move_item_to_grid(&index, np.x, np.y);
        return (true);

// Moves an item on the floor to the nearest adjacent floor-space.
static bool dgn_shift_item(const coord_def &pos, item_def &item)

static bool is_critical_feature(dungeon_feature_type feat)

    memset(travel_point_distance, 0, sizeof(travel_distance_grid_t));
    travel_point_distance[pos.x][pos.y] = 0;
    return (dgn_shift_item_around(pos, item));

    return (grid_stair_direction(feat) != CMD_NO_CMD
            || grid_altar_god(feat) != GOD_NO_GOD);
}
static bool is_feature_shift_target(const coord_def &pos)
{
    return (grd(pos) == DNGN_FLOOR);

static bool dgn_shift_feature(const coord_def &pos)
{
    const dungeon_feature_type dfeat = grd(pos);
    if (!is_critical_feature(dfeat) && !env_find_marker(pos, MAT_ANY))
        return (false);
    
    const coord_def dest =
        dgn_find_nearest_square(pos, is_feature_shift_target);
    if (in_bounds(dest) && dest != pos)
    {
        grd(dest) = dfeat;
        if (dfeat == DNGN_ENTER_SHOP)
        {
            if (shop_struct *s = get_shop(pos.x, pos.y))
            {
                s->x = dest.x;
                s->y = dest.y;
            }
        }
        env_move_markers(pos, dest);
        if (see_grid(dest) && is_notable_terrain(dfeat))
            seen_notable_thing(dfeat, dest.x, dest.y);
    }
    return (true);
}

        dgn_shift_feature(pos);

    if (!check_place)

    if (!check_place || clobber)

            if (!clobber
                && (igrd[x][y] != NON_ITEM || mgrd[x][y] != NON_MONSTER))

            if (igrd[x][y] != NON_ITEM || mgrd[x][y] != NON_MONSTER)

void env_move_markers(const coord_def &from, const coord_def &to);

void env_move_markers(const coord_def &from, const coord_def &to)
{
    std::pair<dgn_marker_map::iterator, dgn_marker_map::iterator>
        els = env.markers.equal_range(from);

    std::list<map_marker*> markers;
    for (dgn_marker_map::iterator i = els.first; i != els.second; )
    {
        dgn_marker_map::iterator curr = i++;
        markers.push_back(curr->second);
        env.markers.erase(curr);
    }
    for (std::list<map_marker*>::iterator i = markers.begin();
         i != markers.end(); ++i)
    {
        (*i)->pos = to;
        env_add_marker(*i);
    }
}

#include "spells3.h"

    if (clobber)
        return (true);
    

                         && dfeat != DNGN_SHALLOW_WATER))
                 && (!clobber
                     || (!grid_is_solid(dfeat) && dfeat != DNGN_LAVA
                         && !grid_is_watery(dfeat))))
                || (!clobber
                    && (igrd[vx][vy] != NON_ITEM
                        || mgrd[vx][vy] != NON_MONSTER)))

                         && dfeat != DNGN_SHALLOW_WATER)))
                || igrd[vx][vy] != NON_ITEM
                || mgrd[vx][vy] != NON_MONSTER)

//
// NOTE: encompass maps will destroy the existing level!
// 

    bool fixup = false;

    if (mdef->orient == MAP_ENCOMPASS && !generating_level)
    {
        if (clobber)
        {
            // For encompass maps, clear the entire level.
            generating_level = true;
            fixup = true;
            reset_level();
            dungeon_events.clear();
        }
        else
        {
            mprf(MSGCH_DIAGNOSTICS,
                 "Cannot generate encompass map '%s' without clobber=true",
                 mdef->name.c_str());
            return (false);
        }
    }

    if (fixup)
    {
        link_items();
        env_activate_markers();
        // Force teleport to place the player somewhere sane.
        you_teleport_now(false, false);
    }
    if (fixup || !generating_level)
        setup_environment_effects();