typedef std::vector<unsigned> vault_indices;

static int _random_map_by_selector(const map_selector &sel)

static vault_indices _eligible_maps_for_selector(const map_selector &sel)

    if (!sel.valid())
        return (-1);

    vault_indices eligible;
    if (sel.valid())
    {
        for (unsigned i = 0, size = vdefs.size(); i < size; ++i)
            if (sel.accept(vdefs[i]))
                eligible.push_back(i);
    }

    return (eligible);
}
static int _random_map_by_selector(const map_selector &sel);
static int _random_map_in_list(const map_selector &sel,
                               const vault_indices &filtered)
{

    typedef std::vector<unsigned> vault_indices;

    for (unsigned i = 0, size = vdefs.size(); i < size; ++i)
        if (sel.accept(vdefs[i]))

    for (unsigned f = 0, size = filtered.size(); f < size; ++f)
    {
        const int i = filtered[f];
        if (!sel.ignore_chance && vdefs[i].chance > 0)

            if (!sel.ignore_chance && vdefs[i].chance > 0)

            // There may be several alternatives for a portal
            // vault that want to be governed by one common
            // CHANCE. In this case each vault will use a
            // CHANCE, and a common chance_xxx tag. Pick the
            // first such vault for the chance roll. Note that
            // at this point we ignore chance_priority.
            const std::string tag = _vault_chance_tag(vdefs[i]);
            if (chance_tags.find(tag) == chance_tags.end())

                // There may be several alternatives for a portal
                // vault that want to be governed by one common
                // CHANCE. In this case each vault will use a
                // CHANCE, and a common chance_xxx tag. Pick the
                // first such vault for the chance roll. Note that
                // at this point we ignore chance_priority.
                const std::string tag = _vault_chance_tag(vdefs[i]);
                if (chance_tags.find(tag) == chance_tags.end())
                {
                    if (!tag.empty())
                        chance_tags.insert(tag);
                    chance.push_back(i);
                }
            }
            else
            {
                eligible.push_back(i);

                if (!tag.empty())
                    chance_tags.insert(tag);
                chance.push_back(i);

        else
        {
            eligible.push_back(i);
        }
    }

static int _random_map_by_selector(const map_selector &sel)
{
    const vault_indices filtered = _eligible_maps_for_selector(sel);
    return _random_map_in_list(sel, filtered);
}

static int _mg_random_vault_here(const level_id &place, bool mini)
{
    no_messages mx;
    map_selector sel = map_selector::by_depth(place, mini);
    sel.preserve_dummy = true;
    return _random_map_by_selector(sel);
}

    map_selector sel = map_selector::by_depth(place, wantmini);
    sel.preserve_dummy = true;
    no_messages mx;
    vault_indices filtered = _eligible_maps_for_selector(sel);

        const int v = _mg_random_vault_here(place, wantmini);

        const int v = _random_map_in_list(sel, filtered);

            make_stringf("%s (%.4f%%)",

            make_stringf("%s (%.2f%%)",

#include "chardump.h"

static void _clamp_to_bounds(int &x, int &y)

static void _clamp_to_bounds(int &x, int &y, bool edge_ok = false)

    x = std::min(std::max(x, X_BOUND_1+1), X_BOUND_2-1);
    y = std::min(std::max(y, Y_BOUND_1+1), Y_BOUND_2-1);

    const int edge_offset = edge_ok ? 0 : 1;
    x = std::min(std::max(x, X_BOUND_1 + edge_offset), X_BOUND_2 - edge_offset);
    y = std::min(std::max(y, Y_BOUND_1 + edge_offset), Y_BOUND_2 - edge_offset);

    _clamp_to_bounds(x1, y1);
    _clamp_to_bounds(x2, y2);

    _clamp_to_bounds(x1, y1, true);
    _clamp_to_bounds(x2, y2, true);

static int dgn_debug_dump_map(lua_State *ls)
{
    const int pos = lua_isuserdata(ls, 1) ? 2 : 1;
    if (lua_isstring(ls, pos))
        dump_map(lua_tostring(ls, pos), true);
    return (0);
}

    { "debug_dump_map", dgn_debug_dump_map },

    int ngood = 0;

                --nzones;

                ++ngood;

    return (nzones);

    return (nzones - ngood);

        if (kbhit() && getch() == ESCAPE)
            break;