&& Level_Unique_Maps.find(map.name) == Level_Unique_Maps.end()

                               you.uniq_map_tags.end()));

                               you.uniq_map_tags.end())
            && map_has_no_tags(map, Level_Unique_Tags.begin(),
                               Level_Unique_Tags.end()));

                               bool check_depth)

                               bool check_depth,
                               const level_id &place = level_id::current())

        return map_selector(map_selector::TAG, level_id::current(), tag,

        return map_selector(map_selector::TAG, place, tag,

                map_selector msel = map_selector::by_tag(sel.tag, sel.mini,
                                                         sel.check_depth);

                map_selector msel = map_selector::by_tag(chance_tag, sel.mini,
                                                         sel.check_depth,
                                                         sel.place);

#include <set>

extern std::set<std::string> Level_Unique_Maps;
extern std::set<std::string> Level_Unique_Tags;

std::set<std::string> Level_Unique_Maps;
std::set<std::string> Level_Unique_Tags;

        Level_Unique_Maps.clear();
        Level_Unique_Tags.clear();

            Level_Unique_Maps.clear();
            Level_Unique_Tags.clear();

    if (map.has_tag("uniq"))
        Level_Unique_Maps.insert(map.name);

        else if (tag.find("luniq_") == 0)
            Level_Unique_Tags.insert(tag);

            ASSERT(!"Couldn't find region.");

            // [ds] Too many normal cases trigger this ASSERT, including
            // rivers that surround a stair with deep water.
            // ASSERT(!"Couldn't find region.");

    if (!player_in_branch(BRANCH_SHOALS))
        _place_minivaults();

    _place_minivaults();

        int vaultidx;
        do
        {
            vaultidx = _dgn_random_map_for_place(true);
        }
        while ( vaultidx == -1
                || !map_by_index(vaultidx)->has_tag("has_rune") );

        int vaultidx = random_map_for_tag("shoal_rune", true);

            while ( vaultidx == -1
                    || map_by_index(vaultidx)->has_tag("has_rune") );

            while ( vaultidx == -1 );

static void _place_minivaults(const std::string &tag, int lo, int hi, bool force)

static void _place_minivaults(const std::string &tag, int lo, int hi,
                              bool force)

    std::set<int> used;

        const int vault = random_map_in_depth(level_id::current(), true);
        if (vault != -1)

        int vault = -1;
        do

            _build_minivaults(you.your_level, vault);
            used.insert(vault);
        }

            vault = random_map_in_depth(level_id::current(), true);
            if (vault != -1)
                _build_minivaults(you.your_level, vault);
        } while (vault != -1 && map_by_index(vault)->has_tag("extra"));

        // If we've already used this minivault and it doesn't want duplicates,
        // break.
        if (used.find(vault) != used.end()
            && !map_by_index(vault)->has_tag("allow_dup"))
        {
            break;
        }

        used.insert(vault);

    if (one_chance_in(15))
    {
        _place_specific_stair(DNGN_ENTER_LABYRINTH, "lab_entry",
                              level_number, true);
    }

    if (!player_in_branch(BRANCH_MAIN_DUNGEON)
        && use_random_maps
        && can_create_vault)

    for ( ; ; )

        int vault = random_map_in_depth(level_id::current());

        if (!player_in_branch(BRANCH_MAIN_DUNGEON)
            && use_random_maps
            && can_create_vault)
        {
            int vault = random_map_in_depth(level_id::current());

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

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

        if (vault != -1 && _build_secondary_vault(you.your_level, vault, -1))
            can_create_vault = false;

            if (vault != -1
                && _build_secondary_vault(you.your_level, vault, -1))
            {
                const map_def &map(*map_by_index(vault));
                if (map.has_tag("extra"))
                    continue;
                can_create_vault = false;
            }
        }
        break;

PLACE:   Shoal:$
TAGS:    has_rune

TAGS:    shoal_rune

TAGS:   lab_entry transparent trowel_portal allow_dup
DEPTH:  12-26
ORIENT: float

TAGS:   luniq_lab chance_lab transparent trowel_portal allow_dup
# Nominal chance for labs was 1 chance in 15, but making it eligible as a
# random vault gives this vault more opportunities to be placed, so dropping
# chance to 2.85%.
CHANCE: 50 : 285
DEPTH:  12-27

KFEAT: O = enter_labyrinth

          A common case when using CHANCE is to assign a CHANCE to a
          set of maps. For instance, if you have a set of portal vault
          entries, and you want one of the set to be used on 5% of all
          levels, you can do this:
          NAME: portal_a
          CHANCE: 50 : 5%
          TAGS: chance_portal_group
          ...

          NAME: portal_b
          CHANCE: 50 : 5%
          TAGS: chance_portal_group
          ...
          That is, if you have a set of maps that use CHANCE and are
          tagged chance_xxx, then one map of that set will be used
          when the chance is met.
          

          * "chance_FOO": Maps can be tagged chance_ with any unique suffix
             to indicate that if the map's CHANCE roll is made, one of the maps
             tagged chance_FOO should be picked.

          * "extra": requests that the dungeon builder treat this as
             an extra vault and try to immediately place another vault of the
             same type it was trying to place when it placed this vault.
             "extra" is good to use for things like labyrinth entries
             that should not affect the chance of other minivaults on the level.
             If you use "extra", you probably want to use one of the
             "luniq" tags as well if your map is tagged "allow_dup".

          * "luniq": specifies that this vault can be used only once on a
             given level. "luniq" is only relevant when used with "allow_dup".
          * "luniq_BAR": (luniq_ with any suffix) specifies that only one
             of the vaults with this tag can be used on any given level.
             "luniq_BAR" is only relevant when used with "allow_dup".