if (mapindex != -1 && vdefs[mapindex].has_tag("dummy"))
        mapindex = -1;
    

    coord_def random_point() const;

                         dungeon_feature_type feature);

                         dungeon_feature_type feature,
                         const dgn_region_list &forbidden = dgn_region_list());

static void build_minivaults(int level_number, int force_vault);

static bool build_minivaults(int level_number, int force_vault);

static void build_minivaults(int level_number, int force_vault)

static bool safe_minivault_place(int v1x, int v1y,
                                  const vault_placement &place)
{
    for (int vx = v1x; vx < v1x + place.width; vx++)
    {
        for (int vy = v1y; vy < v1y + place.height; vy++)
        {
            if ((grd[vx][vy] != DNGN_FLOOR
                 && grd[vx][vy] != DNGN_ROCK_WALL
                 && grd[vx][vy] != DNGN_CLOSED_DOOR
                 && grd[vx][vy] != DNGN_SECRET_DOOR)
                || 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: */
    for (int vx = v1x; vx < v1x + place.width; vx++)
    {
        //  if (vx != v1x && vx != v1x + 12) continue;
        for (int vy = v1y; vy < v1y + place.height; vy++)
        {
            if (grd[vx][vy] == DNGN_FLOOR
                || grd[vx][vy] == DNGN_CLOSED_DOOR
                || grd[vx][vy] == DNGN_SECRET_DOOR)
                return (true);
        }
    }
    return (false);
}
static bool find_minivault_place(const vault_placement &place,
                                 int &v1x, int &v1y)
{
    // [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)
    {
        v1x = random_range( margin, GXM - margin - place.width );
        v1y = random_range( margin, GYM - margin - place.height );
        if (!safe_minivault_place( v1x, v1y, place ))
            continue;
        if (connected_minivault_place(v1x, v1y, place))
            return (true);
    }
    return (false);
}
static bool build_minivaults(int level_number, int force_vault)

    level_vaults.push_back(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 = 12;
    /* find a target area which can be safely overwritten: */
    while(1)
    {
        v1x = random_range( margin, GXM - margin - place.width );
        v1y = random_range( margin, GYM - margin - place.height );
        for (vx = v1x; vx < v1x + place.width; vx++)
        {
            for (vy = v1y; vy < v1y + place.height; vy++)
            {
                // [ds] An escape hatch to keep from hanging forever looking
                // for a good place.
                if (one_chance_in(2000))
                    return;
                if ((grd[vx][vy] != DNGN_FLOOR
                        && grd[vx][vy] != DNGN_ROCK_WALL
                        && grd[vx][vy] != DNGN_CLOSED_DOOR
                        && grd[vx][vy] != DNGN_SECRET_DOOR)
                    || igrd[vx][vy] != NON_ITEM
                    || mgrd[vx][vy] != NON_MONSTER)
                {
                    goto out_of_check;
                }
            }
        }
        /* must not be completely isolated: */
        for (vx = v1x; vx < v1x + place.width; vx++)
        {
            //  if (vx != v1x && vx != v1x + 12) continue;
            for (vy = v1y; vy < v1y + place.height; vy++)
            {
                if (grd[vx][vy] == DNGN_FLOOR
                    || grd[vx][vy] == DNGN_CLOSED_DOOR
                    || grd[vx][vy] == DNGN_SECRET_DOOR)
                    goto break_out;
            }
        }
      out_of_check:
        continue;

      break_out:
        break;
    }

    if (!find_minivault_place(place, v1x, v1y))
        return (false);

    place.x = v1x;
    place.y = v1y;
    
    level_vaults.push_back(place);
    

    return (true);

    dungeon_feature_type feature)

    dungeon_feature_type feature, const dgn_region_list &forbidden)

            if (grd[x][y] == replace)

            if (grd[x][y] == replace && unforbidden(coord_def(x, y), forbidden))

static void find_maze_neighbours(const coord_def &c, coord_list &ns)

static void find_maze_neighbours(const coord_def &c,
                                 const dgn_region &region,
                                 coord_list &ns)

            if (cp.x >= MAPGEN_BORDER * 3 && cp.x < GXM - MAPGEN_BORDER * 3
                && cp.y >= MAPGEN_BORDER * 3 && cp.y < GYM - MAPGEN_BORDER * 3)
            {

            if (region.contains(cp))

            }

static void labyrinth_maze_recurse(const coord_def &c)

static void labyrinth_maze_recurse(const coord_def &c, const dgn_region &where)

    find_maze_neighbours(c, neighbours);

    find_maze_neighbours(c, where, neighbours);

        if (grd(nc) == DNGN_ROCK_WALL)
        {
            grd(nc) = DNGN_FLOOR;
            grd(c + (nc - c) / 2) = DNGN_FLOOR;
            if (!one_chance_in(3))
                labyrinth_maze_recurse(nc);
            else
                deferred.push_back(nc);
        }

        if (grd(nc) != DNGN_ROCK_WALL)
            continue;
        
        grd(nc) = DNGN_FLOOR;
        grd(c + (nc - c) / 2) = DNGN_FLOOR;
        
        if (!one_chance_in(5))
            labyrinth_maze_recurse(nc, where);
        else
            deferred.push_back(nc);

        labyrinth_maze_recurse(*i);
}
static coord_def random_point_in_lab()
{
    return coord_def( random_range(MAPGEN_BORDER * 3,
                                   GXM - MAPGEN_BORDER * 3 - 1),
                      random_range(MAPGEN_BORDER * 3,
                                   GYM - MAPGEN_BORDER * 3 - 1) );

        labyrinth_maze_recurse(*i, where);

static void labyrinth_build_maze(coord_def &e)

static void labyrinth_build_maze(coord_def &e, const dgn_region &lab)

    labyrinth_maze_recurse(random_point_in_lab());

    labyrinth_maze_recurse(lab.random_point(), lab);

        e = random_point_in_lab();

        e = lab.random_point();

}
static void init_minivault_placement(int vault, vault_placement &place)
{
    map_type vgrid;
    vault_main(vgrid, place, vault);

static void labyrinth_dimension_adjust(int delta, int &ds, int &dw)
{
    if (delta > MAPGEN_BORDER)
        delta = MAPGEN_BORDER;
    if (delta)
    {
        if (delta & 1)
            ++delta;
        ds -= delta;
        dw += delta * 2;
    }
}

    dgn_region lab =
        dgn_region::absolute( MAPGEN_BORDER * 5 / 2, MAPGEN_BORDER * 5 / 2,
                              GXM - MAPGEN_BORDER * 5 / 2 - 1,
                              GYM - MAPGEN_BORDER * 5 / 2 - 1 );
    
    // First decide if we're going to use a Lab minivault.
    int vault = random_map_for_tag("lab", true, false);
    vault_placement place;
    if (vault != -1)
    {
        init_minivault_placement(vault, place);
        int ex = place.width / 4, ey = place.height / 4;
        labyrinth_dimension_adjust(ex, lab.pos.x, lab.size.x);
        labyrinth_dimension_adjust(ey, lab.pos.y, lab.size.y);
    }
    

    labyrinth_build_maze(end);
    labyrinth_place_exit(end);
    link_items();

    labyrinth_build_maze(end, lab);

    // turn rock walls into undiggable stone or metal:

    if (vault == -1 || !build_minivaults(level_number, vault))
    {
        vault = -1;
        labyrinth_place_exit(end);
    }
    else
    {
        const vault_placement &rplace = *(level_vaults.end() - 1);
        if (rplace.map.has_tag("generate_loot"))
        {
            for (int y = rplace.y; y <= rplace.y + rplace.height - 1; ++y)
            {
                for (int x = rplace.x; x <= rplace.x + rplace.height - 1; ++x)
                {
                    if (grd[x][y] == DNGN_ROCK_STAIRS_UP)
                    {
                        labyrinth_place_items(coord_def(x, y));
                        break;
                    }
                }
            }
        }
        place.x = rplace.x;
        place.y = rplace.y;
        place.width = rplace.width;
        place.height = rplace.height;
    }
        // turn rock walls into undiggable stone or metal:

    replace_area(0,0,GXM-1,GYM-1,DNGN_ROCK_WALL,wall_xform);

    dgn_region_list vaults;
    vaults.push_back(
        dgn_region(place.x, place.y, place.width, place.height));
    
    replace_area(0, 0, GXM - 1, GYM - 1, DNGN_ROCK_WALL, wall_xform, vaults);
     
    link_items();

        coord_def( random_range( pos.x, pos.x + size.x - 1 ),

        coord_def( pos.x + random2(size.x),

                   random_range( pos.y, pos.y + size.y - 1 ) );

                   pos.y + random2(size.y) );
}
coord_def dgn_region::random_point() const
{
    return coord_def( pos.x + random2(size.x), pos.y + random2(size.y) );

#############################################################################
# Labyrinth minivaults
#############################################################################
# One layer of floor space *must* surround the minivault, or the player could
# be trapped in the labyrinth (the dummy is exempt from this requirement).
#
# You can use the "generate_loot" tag to indicate that you're not explicitly
# placing the loot and that the dungeon builder should generate random loot
# (on the upstair). Note that this is not the default, and if you neither use
# this tag nor provide loot in the map definition, the player will be
# disappointed.
#
# You *must* place the minotaur(s) yourself!
#############################################################################
# Dummy balancer
NAME: labyrinth_0
TAGS: lab dummy
CHANCE: 20
MAP
x
ENDMAP
#############################################################################
# A simple lair.
NAME: labyrinth_1
TAGS: lab generate_loot no_pool_fixup
MONS: minotaur
SHUFFLE: def
SUBST: d=^, e=^, f=.
MAP
.........
.ccccccc.
.cwwwwwc.
.cww<wwc.
.cwdefwc.
.ccc1ccc.
.c.....c.
.ccc+ccc.
.........
ENDMAP

CHANCE: 10000