if (env.show(diff))

            if (show_bounds(diff) && env.show(diff))

// Determines if the coordinate is within bounds of an LOS array.
inline bool show_bounds(const coord_def &p)
{
    return (p.x >= 0 && p.x < ENV_SHOW_DIAMETER
            && p.y >= 0 && p.y < ENV_SHOW_DIAMETER);
}

int vault_main(vault_placement &vp,
               const map_def *vault,

int vault_main(vault_placement &vp, const map_def *vault,

int map_count_for_tag(const std::string &tag, bool want_minivault,
                      bool check_depth = false);

int map_count_for_tag(const std::string &tag, bool check_depth = false);

const map_def *random_map_for_place(const level_id &place, bool mini = false);

const map_def *random_map_for_place(const level_id &place);

const map_def *random_map_for_tag(const std::string &tag, bool want_minivault,

const map_def *random_map_for_tag(const std::string &tag,

extern map_place_check_t map_place_invalid;

extern map_place_check_t map_place_valid;

static bool bad_map_place(const map_def &map, const coord_def &c,
                          const coord_def &size);

static bool _safe_vault_place(const map_def &md,
                              const coord_def &c,
                              const coord_def &size);

map_place_check_t map_place_invalid = bad_map_place;

map_place_check_t map_place_valid = _safe_vault_place;

int vault_main( vault_placement &place,
                const map_def *vault,

int vault_main( vault_placement &place, const map_def *vault,

    // Return value of zero forces dungeon.cc to regenerate the level, except
    // for branch entry vaults where dungeon.cc just rejects the vault and
    // places a vanilla entry.

    // Return value of MAP_NONE forces dungeon.cc to regenerate the
    // level, except for branch entry vaults where dungeon.cc just
    // rejects the vault and places a vanilla entry.

}
// Determines if the region specified by (x, y, x + width - 1, y + height - 1)
// is a bad place to build a vault.
static bool bad_map_place(const map_def &map, const coord_def &c,
                          const coord_def &size)
{
    const std::vector<std::string> &lines = map.map.get_lines();
    for (rectangle_iterator r(c, c + size - 1); r; ++r)
    {
        const coord_def &p(*r);
        const coord_def dp = p - c;
        if (lines[dp.y][dp.x] == ' ')
            continue;
        if (dgn_Map_Mask[p.x][p.y])
            return (true);
        if (igrd(p) != NON_ITEM || mgrd(p) != NON_MONSTER)
            return (true);
        const dungeon_feature_type grid = grd(p);
        if (!grid_is_opaque(grid)
            && grid != DNGN_FLOOR
            && grid != DNGN_SHALLOW_WATER
            && grid != DNGN_CLOSED_DOOR
            && grid != DNGN_OPEN_DOOR
            && grid != DNGN_SECRET_DOOR)
        {
#ifdef DEBUG_DIAGNOSTICS
            mprf(MSGCH_DIAGNOSTICS,
                 "Rejecting place because of %s at (%d,%d)",
                 dungeon_feature_name(grid), p.x, p.y);
#endif
            return (true);
        }
    }
    return (false);

}
// Used for placement of vaults.
static bool _may_overwrite_feature(const dungeon_feature_type grid,
                                   bool water_ok, bool wall_ok = true)
{
    // Deep water grids may be overwritten if water_ok == true.
    if (grid == DNGN_DEEP_WATER)
        return (water_ok);
    // Handle all other non-LOS blocking grids here.
    if (!grid_is_opaque(grid)
        && grid != DNGN_FLOOR
        && grid != DNGN_SHALLOW_WATER
        && grid != DNGN_CLOSED_DOOR
        && grid != DNGN_OPEN_DOOR
        && grid != DNGN_SECRET_DOOR)
    {
        return (false);
    }
    if (grid_is_wall(grid))
        return (wall_ok);
    // Otherwise, feel free to clobber this feature.
    return (true);
}
static bool _safe_vault_place(const map_def &map,
                              const coord_def &c,
                              const coord_def &size)
{
    if (size.zero())
        return (true);
    const bool water_ok = map.has_tag("water_ok");
    const std::vector<std::string> &lines = map.map.get_lines();
    for (rectangle_iterator ri(c, c + size - 1); ri; ++ri)
    {
        const coord_def &cp(*ri);
        const coord_def &dp(cp - c);
        if (lines[dp.y][dp.x] == ' ')
            continue;
        if (dgn_Map_Mask[cp.x][cp.y])
            return (false);
        const dungeon_feature_type dfeat = grd(cp);
        // Don't overwrite features other than floor, rock wall, doors,
        // nor water, if !water_ok.
        if (!_may_overwrite_feature(dfeat, water_ok))
            return (false);
        // Don't overwrite items or monsters, either!
        if (igrd(cp) != NON_ITEM || mgrd(cp) != NON_MONSTER)
            return (false);
    }
    return (true);
}
static bool _connected_minivault_place(const coord_def &c,
                                       const vault_placement &place)
{
    if (place.size.zero())
        return (true);
    // Must not be completely isolated.
    const bool water_ok = place.map.has_tag("water_ok");
    const std::vector<std::string> &lines = place.map.map.get_lines();
    for (rectangle_iterator ri(c, c + place.size - 1); ri; ++ri)
    {
        const coord_def &ci(*ri);
        if (lines[ci.y - c.y][ci.x - c.x] == ' ')
            continue;
        if (_may_overwrite_feature(grd(ci), water_ok, false))
            return (true);
    }
    return (false);
}
static coord_def _find_minivault_place(
    const vault_placement &place,
    bool check_place)
{
    // [ds] The margin around the edges of the map where the minivault
    // won't be placed. Purely arbitrary as far as I can see.
    const int margin = MAPGEN_BORDER * 2;
    // Find a target area which can be safely overwritten.
    for (int tries = 0; tries < 600; ++tries)
    {
        coord_def v1(random_range( margin, GXM - margin - place.size.x ),
                     random_range( margin, GYM - margin - place.size.y ));
        if (check_place && !map_place_valid(place.map, v1, place.size))
            continue;
        if (_connected_minivault_place(v1, place))
            return (v1);
    }
    return (coord_def(-1, -1));

        const bool minivault = def.has_tag("minivault");

            fit_region_into_map_bounds(start, size);

            fit_region_into_map_bounds(start, size, minivault ? 2 : 0);
        }
        else if (minivault)
        {
            start = _find_minivault_place(place, check_place);
            if (map_bounds(start))
                fit_region_into_map_bounds(start, size, 2);

    if (check_place && map_place_invalid(def, start, size))

    if (check_place && !_safe_vault_place(def, start, size))

    static map_selector by_place(const level_id &place, bool mini)

    static map_selector by_place(const level_id &place)

        return map_selector(map_selector::PLACE, place, "", mini, false);

        return map_selector(map_selector::PLACE, place, "", false, false);

    static map_selector by_tag(const std::string &tag, bool mini,

    static map_selector by_tag(const std::string &tag,

                            mini, check_depth);

                            false, check_depth);

                && mapdef.is_minivault() == mini

        return (mapdef.has_tag(tag) && mapdef.is_minivault() == mini

        return (mapdef.has_tag(tag)

                map_selector msel = map_selector::by_tag(chance_tag, sel.mini,

                map_selector msel = map_selector::by_tag(chance_tag,

const map_def *random_map_for_place(const level_id &place, bool want_minivault)

const map_def *random_map_for_place(const level_id &place)

    return _random_map_by_selector(
        map_selector::by_place(place, want_minivault));

    return _random_map_by_selector(map_selector::by_place(place));

                                  bool want_minivault,

        map_selector::by_tag(tag, want_minivault, check_depth));

        map_selector::by_tag(tag, check_depth));

                      bool want_minivault,

        map_selector::by_tag(tag, want_minivault, check_depth)).size();

        map_selector::by_tag(tag, check_depth)).size();

    return (orient == MAP_NONE);

    return (has_tag("minivault"));

    // Fixup minivaults into floating vaults tagged "minivault".
    if (orient == MAP_NONE)
    {
        orient = MAP_FLOAT;
        tags += " minivault";
    }

        if (dgn_place_monster(mspec, you.your_level, c,
                              false, false, false))

        const int mid = dgn_place_monster(mspec, you.your_level, c,
                                          false, false, false);
        if (mid != -1)

            push_monster(ls, &menv[mgrd(c)]);

            push_monster(ls, &menv[mid]);

static std::auto_ptr<lua_datum> _dgn_map_bad_bounds_fn;

static std::auto_ptr<lua_datum> _dgn_map_safe_bounds_fn;

static bool _lua_map_place_invalid(const map_def &map,
                                   const coord_def &c,
                                   const coord_def &size)

static bool _lua_map_place_valid(const map_def &map,
                                 const coord_def &c,
                                 const coord_def &size)

    lua_stack_cleaner clean(_dgn_map_bad_bounds_fn->lua);

    lua_stack_cleaner clean(_dgn_map_safe_bounds_fn->lua);

    _dgn_map_bad_bounds_fn->push();

    _dgn_map_safe_bounds_fn->push();

    lua_State *ls = _dgn_map_bad_bounds_fn->lua;

    lua_State *ls = _dgn_map_safe_bounds_fn->lua;

    _dgn_map_bad_bounds_fn.reset(new lua_datum(vm, 1, false));

    _dgn_map_safe_bounds_fn.reset(new lua_datum(vm, 1, false));

        unwind_var<map_place_check_t> mpc(map_place_invalid,
                                          _lua_map_place_invalid);

        unwind_var<map_place_check_t> mpc(map_place_valid,
                                          _lua_map_place_valid);

        _dgn_map_bad_bounds_fn.reset(NULL);

        _dgn_map_safe_bounds_fn.reset(NULL);

        const bool mini = _lua_boolean(ls, 2, true);

        return _lua_push_map(ls, random_map_for_tag(tag, mini, check_depth));

        return _lua_push_map(ls, random_map_for_tag(tag, check_depth));

    const bool mini = _lua_boolean(ls, 2, true);
    return _lua_push_map(ls, random_map_for_place(lid, mini));

    return _lua_push_map(ls, random_map_for_place(lid));

static bool _build_minivaults(int level_number,
                              const map_def *vault,
                              bool clobber = false,
                              bool make_no_exits = false,
                              const coord_def &where = coord_def() );

static const map_def *_dgn_random_map_for_place(bool wantmini);

static const map_def *_dgn_random_map_for_place();

        const map_def *vault = random_map_for_tag("shoal_rune", true);
        _build_minivaults( level_number, vault, false, false,
                           centres[1] );

        const map_def *vault = random_map_for_tag("shoal_rune");
        _build_secondary_vault(level_number, vault, -1, false, false,
                               centres[1]);

                vault = _dgn_random_map_for_place(true);

                vault = _dgn_random_map_for_place();

            _build_minivaults( level_number, vault, false, false,
                               centres[i] );

            _build_secondary_vault(level_number, vault, -1, false, false,
                                   centres[i]);

            _build_minivaults(level_number, vault);

            _build_secondary_vault(level_number, vault);

    const map_def *vault = random_map_for_place(level_id::current(), false);

    const map_def *vault = random_map_for_place(level_id::current());

    return random_map_for_tag(tag, false, true);

    return random_map_for_tag(tag, true);

static const map_def *_dgn_random_map_for_place(bool wantmini)

static const map_def *_dgn_random_map_for_place()

    const map_def *vault = random_map_for_place(lid, wantmini);

    const map_def *vault = random_map_for_place(lid);

        vault = random_map_for_tag("entry", wantmini);

        vault = random_map_for_tag("entry");

    const map_def *vault = _dgn_random_map_for_place(false);

    const map_def *vault = _dgn_random_map_for_place();

            _build_minivaults(you.your_level, vault);

            _build_secondary_vault(you.your_level, vault);

                _build_minivaults(you.your_level, vault);

                _build_secondary_vault(you.your_level, vault);

    }
    int chance = you.your_level == 0? 50 : 100;
    while (chance && x_chance_in_y(chance, 100) || nvaults-- > 0)
    {
        const map_def *vault = _dgn_random_map_for_place(true);
        if (!vault)
            break;
        _build_minivaults(you.your_level, vault);
        chance /= 4;

    const map_def *vault = _dgn_random_map_for_place(false);

    const map_def *vault = _dgn_random_map_for_place();

        const map_def *sroom = random_map_for_tag("special_room", true, true);

        const map_def *sroom = random_map_for_tag("special_room", true);

            // ORIENT: encompass maps are unsuitable as secondary vaults.
            if (vault && vault->orient == MAP_ENCOMPASS)
                vault = NULL;

    _build_minivaults( level_number, vault, false, false, sr.tl);

    _build_secondary_vault( level_number, vault, -1, false, false, sr.tl);

// Used for placement of vaults.
static bool _may_overwrite_feature(const dungeon_feature_type grid,
                                   bool water_ok, bool rock_ok = true)
{
    // Floor, and closed/secret doors may always be overwritten.
    if (grid == DNGN_FLOOR
        || grid == DNGN_CLOSED_DOOR || grid == DNGN_SECRET_DOOR)
    {
        return (true);
    }
    if (grid == DNGN_ROCK_WALL)
        return (rock_ok);
    // Watery grids may be overwritten if water_ok == true.
    if (grid == DNGN_DEEP_WATER || grid == DNGN_SHALLOW_WATER)
        return (water_ok);
    // Otherwise, don't overwrite this feature.
    return (false);
}

static bool _safe_minivault_place(int v1x, int v1y,
                                  const vault_placement &place,
                                  bool clobber)
{
    if (clobber)
        return (true);

    const bool water_ok = place.map.has_tag("water_ok");
    const std::vector<std::string> &lines = place.map.map.get_lines();
    for (int vx = v1x; vx < v1x + place.size.x; vx++)
        for (int vy = v1y; vy < v1y + place.size.y; vy++)
        {
            if (lines[vy - v1y][vx - v1x] == ' ')
                continue;
            if (dgn_Map_Mask[vx][vy])
                return (false);
            const dungeon_feature_type dfeat = grd[vx][vy];
            // Don't overwrite features other than floor, rock wall, doors,
            // nor water, if !water_ok.
            if (!_may_overwrite_feature(dfeat, water_ok))
                return (false);
            // Don't overwrite items or monsters, either!
            if (igrd[vx][vy] != NON_ITEM || mgrd[vx][vy] != NON_MONSTER)
                return (false);
        }
    return (true);
}
static bool _connected_minivault_place(int v1x, int v1y,
                                       const vault_placement &place)
{
    // Must not be completely isolated.
    const bool water_ok = place.map.has_tag("water_ok");
    const std::vector<std::string> &lines = place.map.map.get_lines();
    for (int vx = v1x; vx < v1x + place.size.x; vx++)
        for (int vy = v1y; vy < v1y + place.size.y; vy++)
        {
            if (lines[vy - v1y][vx - v1x] == ' ')
                continue;
            // Overwrite floor, doors or water, but not rock walls.
            if (_may_overwrite_feature(grd[vx][vy], water_ok, false))
                return (true);
        }
    return (false);
}
static bool _find_minivault_place(const vault_placement &place,
                                  coord_def& v1, bool clobber)
{
    // [ds] The margin around the edges of the map where the minivault
    // won't be placed. Purely arbitrary as far as I can see.
    const int margin = MAPGEN_BORDER * 2;
    // Find a target area which can be safely overwritten.
    for (int tries = 0; tries < 600; ++tries)
    {
        v1.x = random_range( margin, GXM - margin - place.size.x );
        v1.y = random_range( margin, GYM - margin - place.size.y );
        if (!_safe_minivault_place( v1.x, v1.y, place, clobber ))
            continue;
        if (_connected_minivault_place(v1.x, v1.y, place))
            return (true);
    }
    return (false);
}
static bool _build_minivaults(int level_number, const map_def *vault,
                              bool clobber, bool make_no_exits,
                              const coord_def &where)
{
    if (dgn_check_connectivity && !dgn_zones)
        dgn_zones = _dgn_count_disconnected_zones(false);
    vault_placement place;
    place.level_number = level_number;
    vault_main(place, vault);
    coord_def v1;
    // Not map_bounds, minivaults should never touch edge.
    if (in_bounds(where))
    {
        coord_def tl(where - place.size / 2);
        fit_region_into_map_bounds(tl, place.size, 1);
        v1 = tl;
    }
    else if (!_find_minivault_place(place, v1, clobber))
        return (false);
    place.pos = v1;
    Level_Vaults.push_back(place);
#ifdef DEBUG_DIAGNOSTICS
    if (crawl_state.map_stat_gen)
        mapgen_report_map_use(place.map);
#endif
    dgn_register_place(place, true);
    place.apply_grid();
    if (!make_no_exits)
    {
        // This is a throwaway.
        std::vector<coord_def> &target_connections = place.exits;
        if (target_connections.empty() && place.map.has_tag("mini_float"))
            _pick_float_exits(place, target_connections);
        if (!target_connections.empty())
            _connect_vault(place);
    }
    return (true);
}                               // end build_minivaults()

    if (mdef->is_minivault())
    {
        did_map = _build_minivaults(you.your_level, mdef, clobber,
                                    make_no_exits, where);
    }
    else
    {
        dungeon_feature_type rune_subst = DNGN_FLOOR;
        if (mdef->has_tag_suffix("_entry"))
            rune_subst = _dgn_find_rune_subst_tags(mdef->tags);
        did_map = _build_secondary_vault(you.your_level, mdef, rune_subst,
                                         clobber, make_no_exits, where);
    }

    dungeon_feature_type rune_subst = DNGN_FLOOR;
    if (mdef->has_tag_suffix("_entry"))
        rune_subst = _dgn_find_rune_subst_tags(mdef->tags);
    did_map = _build_secondary_vault(you.your_level, mdef, rune_subst,
                                     clobber, make_no_exits, where);

    dgn_zones = _dgn_count_disconnected_zones(false);

    // Don't waste time trying to place encompass vaults as
    // secondaries.
    if (vault->orient == MAP_ENCOMPASS)
        return (false);

    if (gluggy == MAP_NONE || !gluggy)

    if (gluggy == MAP_NONE)

    if (target_connections.empty() && gluggy != MAP_ENCOMPASS)

    if (target_connections.empty() && gluggy != MAP_ENCOMPASS
        && (!place.map.is_minivault() || place.map.has_tag("mini_float")))
    {

    }

        const map_def *vault = random_map_for_tag("lab", true, false);

        const map_def *vault = random_map_for_tag("lab", false);

        if (!_build_minivaults(level_number, vault))

        if (!_build_secondary_vault(level_number, vault))

    const map_def *vault = random_map_for_tag("minotaur", true, false);

    const map_def *vault = random_map_for_tag("minotaur", false);

    if (!vault || !_build_minivaults(level_number, vault))

    if (!vault || !_build_secondary_vault(level_number, vault))

    if ((sroom = random_map_for_tag("special_room", true, true)) != NULL)

    if ((sroom = random_map_for_tag("special_room", true)) != NULL)

	    && (sroom = random_map_for_tag("special_room", true, true)) != NULL)

	    && (sroom = random_map_for_tag("special_room", true)) != NULL)

        const map_def *map = random_map_for_tag("trowel_portal", false, false);

        const map_def *map = random_map_for_tag("trowel_portal", false);

  local map = dgn.map_by_tag("ziggurat_loot_chamber")

  local map = dgn.map_by_tag("ziggurat_loot_chamber", false)

  local function bad_loot_bounds(map, px, py, xs, ys)

  local function good_loot_bounds(map, px, py, xs, ys)

    return not (inc == linc) or not safe_area()

    return (inc == linc) and safe_area()

    return dgn.with_map_bounds_fn(bad_loot_bounds, place_loot_chamber)

    return dgn.with_map_bounds_fn(good_loot_bounds, place_loot_chamber)

        const map_def *map = random_map_for_tag(map_name.c_str(), false);

        const map_def *map = random_map_for_tag(map_name.c_str());

        if (!find_map_by_name(dst) && !random_map_for_tag(dst, false))

        if (!find_map_by_name(dst) && !random_map_for_tag(dst))

Minivaults are distinguished from normal vaults by the absence of an
ORIENT: declaration. Any map without a specified ORIENT: is a
minivault. Minivaults are handled like floating vaults (ORIENT: float
vaults) in most respects. The differences are:

Minivaults are distinguished from normal vaults solely by the absence of an
ORIENT: declaration. Any map without a specified ORIENT: is a minivault.

1. Floating vaults may be placed before the rest of the level layout
   is generated, and the rest of the level may be built around the floating
   vault. This is never the case for minivaults.
2. Floating vaults may be placed anywhere in the map, including places
   completely separated from the rest of the level by rock. The
   dungeon builder will then connect the exits from the floating vault
   to the rest of the level, usually producing obvious "passages" from
   the floating vault to the main body of the level.
   In contrast, minivaults are placed such that at least one square of
   the minivault overlaps with an existing part of the level, and are
   thus more likely to look like part of the level. Unlike floating
   vaults, the dungeon builder assumes that any one square of overlap
   is enough to connect the minivault to the rest of the level and
   makes no effort to connect exits from the minivault to the level.
   You can ask the dungeon builder to connect exits from your
   minivault with the "mini_float" tag.

          make it a minivault. For special levels and (branch) entry
          vaults, you do need an ORIENT: line.

          make it a minivault.