if (grid_is_solid( grd[i + k][j + l] )

                        if (grid_is_opaque( grd[i + k][j + l] )

                    if (map_radius == 1000)

                    if (map_radius == 1000 && you.wizard)

                    || map_radius == 1000

                    || (map_radius == 1000 && you.wizard)

#include <vector>

    std::vector<coord_def> exits;

        : x(-1), y(-1), width(0), height(0), map()

        : x(-1), y(-1), width(0), height(0), map(),
          exits()

                vault_placement &vp,
                int vault_force, 
                int many_many);

               vault_placement &vp,
               int vault_force,
               std::vector<vault_placement> *avoid_vaults = NULL);

#include "misc.h"

                        vault_placement &);

                       vault_placement &,
                       std::vector<vault_placement> *);

                        vault_placement &);

                        vault_placement &,
                        std::vector<vault_placement> *);

        int which_vault, 
        int many_many )

        int which_vault,
        std::vector<vault_placement> *avoid)

    return write_vault( vdefs[which_vault], vgrid, place );

    return write_vault( vdefs[which_vault], vgrid, place, avoid );

                       vault_placement &place)

                       vault_placement &place,
                       std::vector<vault_placement> *avoid)

    resolve_map(place.map);

    return (place.orient =
            apply_vault_definition(place.map, map, place));

    // Try so many times to place the map. This will always succeed
    // unless there are conflicting map placements in 'avoid'.
    int tries = 10;
    do
        resolve_map(place.map);
    while ((place.orient =
            apply_vault_definition(place.map, map, place, avoid)) == MAP_NONE
           && tries-- > 0);
    return (place.orient);

static void apply_vault_grid(map_def &def, map_type map, 
                             vault_placement &place)

static bool is_grid_clobbered(int sx, int sy, int width, int height)
{
    for (int y = sy; y < sy + height; ++y)
    {
        for (int x = sx; x < sx + width; ++x)
        {
            int grid = grd[x][y];
            if (!grid_is_opaque(grid)
                && grid != DNGN_FLOOR
                && grid != DNGN_CLOSED_DOOR
                && grid != DNGN_OPEN_DOOR
                && grid != DNGN_SECRET_DOOR)
            {
                return (true);
            }
        }
    }
    return (false);
}
// 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(int x, int y, int width, int height,
                         std::vector<vault_placement> *avoid)
{
    if (!avoid)
        return (false);
    
    const dgn_region thisvault(x, y, width, height);
    for (int i = 0, size = avoid->size(); i < size; ++i)
    {
        const vault_placement &vp = (*avoid)[i];
        const dgn_region vault(vp.x, vp.y, vp.width, vp.height);
        if (thisvault.overlaps(vault))
            return (true);
    }
    return (is_grid_clobbered(x, y, width, height));
}
static bool apply_vault_grid(map_def &def, map_type map, 
                             vault_placement &place,
                             std::vector<vault_placement> *avoid)

    }
    if (bad_map_place(startx, starty, width, height, avoid))
    {
#ifdef DEBUG_DIAGNOSTICS
        mprf(MSGCH_DIAGNOSTICS, "Bad vault place: (%d,%d) dim (%d,%d)",
             startx, starty, width, height);
#endif
        return (false);

    return (true);

        vault_placement &place)

        vault_placement &place,
        std::vector<vault_placement> *avoid)

    apply_vault_grid(def, map, place);

    if (!apply_vault_grid(def, map, place, avoid))
        return (MAP_NONE);

	chmod ${MCHMOD} $(GAME)

struct spec_t

struct spec_room

    spec_room() : created(false), hooked_up(false), x1(0), y1(0), x2(0), y2(0)
    {
    }

typedef struct spec_t spec_room;

static void place_specific_stair(unsigned char stair);

static void place_specific_stair(int stair, const std::string &tag = "", int dl = 0);

    const dgn_region_list &forbidden);

    const dgn_region_list &forbidden,
    bool early_exit = false);

static void build_vaults(int level_number, int vault_number);

static bool build_secondary_vault(int level_number, int vault, int rune_subst = -1);
static bool build_vaults(int level_number, int vault_number, int rune_subst = -1,
                         bool build_only = false);

                       int &num_runes );

                       int &num_runes, int rune_subst = -1);

static void build_dungeon_level(int level_number, int level_type)

static void reset_level()

    int i;          // generic loop variable
    int x,y;        // generic map loop variables

    make_box(0,0,GXM-1,GYM-1,DNGN_ROCK_WALL,DNGN_ROCK_WALL);

    make_box(0, 0, GXM - 1, GYM - 1, DNGN_ROCK_WALL, DNGN_ROCK_WALL);

    for (i = 0; i < MAX_TRAPS; i++)

    for (int i = 0; i < MAX_TRAPS; i++)

    for (i = 0; i < MAX_ITEMS; i++)

    for (int i = 0; i < MAX_ITEMS; i++)

    for (i = 0; i < MAX_MONSTERS; i++)

    for (int i = 0; i < MAX_MONSTERS; i++)

    for(x=0; x<GXM; x++)

    for(int x=0; x<GXM; x++)

        for(y=0; y<GYM; y++)

        for(int y=0; y<GYM; y++)

}

    int skip_build;
    skip_build = builder_by_type(level_number, level_type);

static void build_layout_skeleton(int level_number, int level_type,
                                  spec_room &sr)
{
    int skip_build = builder_by_type(level_number, level_type);

    spec_room sr = { false, false, 0, 0, 0, 0 };

}
static void build_dungeon_level(int level_number, int level_type)
{
    spec_room sr;

    reset_level();
    build_layout_skeleton(level_number, level_type, sr);

        for (x = 1; x < GXM; x++)
            for (y = 1; y < GYM; y++)

        for (int x = 1; x < GXM; x++)
            for (int y = 1; y < GYM; y++)

        for (x = 1; x < GXM; x++)
            for (y = 1; y < GYM; y++)

        for (int x = 1; x < GXM; x++)
            for (int y = 1; y < GYM; y++)

        for (x = 1; x < GXM; x++)

        for (int x = 1; x < GXM; x++)

            for (y = 1; y < GYM; y++)

            for (int y = 1; y < GYM; y++)

static int random_portal_vault(const std::string &tag)
{
    return random_map_for_tag(tag, false);
}
static bool place_portal_vault(int stair, const std::string &tag, int dlevel)
{
    const int vault = random_portal_vault(tag);
    if (vault == -1)
        return (false);
    return build_secondary_vault(dlevel, vault, stair);
}

static void place_specific_stair(unsigned char stair)

static void place_specific_feature(int feat)

    grd[sx][sy] = stair;

    grd[sx][sy] = feat;

static void place_specific_stair(int stair, const std::string &tag, int dlevel)
{
    if (tag.empty() || !place_portal_vault(stair, tag, dlevel))
        place_specific_feature(stair);
}

            place_specific_stair(DNGN_ENTER_HELL);

            place_specific_stair(DNGN_ENTER_HELL, "hell_entry", dlevel);

            place_specific_stair(DNGN_ENTER_PANDEMONIUM);

            place_specific_stair(DNGN_ENTER_PANDEMONIUM, "pan_entry", dlevel);

            place_specific_stair(DNGN_ENTER_ABYSS);

            place_specific_stair(DNGN_ENTER_ABYSS, "abyss_entry", dlevel);

            place_specific_stair(branches[i].entry_stairs);

            std::string entry_tag = std::string(branches[i].abbrevname);
            entry_tag += "_entry";
            lowercase(entry_tag);
            
            place_specific_stair(
                branches[i].entry_stairs,
                entry_tag,
                dlevel);

    vault_main(vgrid, place, force_vault, level_number);

    vault_main(vgrid, place, force_vault, &level_vaults);

static coord_def dig_away_dir(vault_placement &place,

static coord_def dig_away_dir(const vault_placement &place,

static void build_vaults(int level_number, int force_vault)

static std::vector<coord_def> external_connection_points(
    const vault_placement &place,
    const std::vector<coord_def> &target_connections)
{
    std::vector<coord_def> ex_connection_points;
    
    // Giving target_connections directly to build_rooms causes
    // problems with long, skinny vaults where paths to the exit
    // tend to cut through the vault. By backing out of the vault
    // one square, we improve connectibility.
    for (int i = 0, size = target_connections.size(); i < size; ++i)
    {
        const coord_def &p = target_connections[i];
        ex_connection_points.push_back(p + dig_away_dir(place, p));
    }
    return (ex_connection_points);
}
static dgn_region_list get_vault_regions()
{
    dgn_region_list vaults;
    for (int i = 0, size = level_vaults.size(); i < size; ++i)
    {
        const vault_placement &vp = level_vaults[i];
        vaults.push_back(dgn_region(vp.x, vp.y, vp.width, vp.height));
    }
    return (vaults);
}
static coord_def find_random_grid(int grid, const dgn_region_list &excluded)
{
    for (int i = 0; i < 100; ++i)
    {
        coord_def c( random_range(MAPGEN_BORDER + 1,
                                  GXM - MAPGEN_BORDER - 1),
                     random_range(MAPGEN_BORDER + 1,
                                  GYM - MAPGEN_BORDER - 1) );
        if (unforbidden(c, excluded) && grd(c) == grid)
            return c;
    }
    return coord_def(0, 0);
}
static void connect_vault(const vault_placement &vp)
{
    std::vector<coord_def> exc = external_connection_points(vp, vp.exits);
    dgn_region_list vaults = get_vault_regions();
    for (int i = 0, size = exc.size(); i < size; ++i)
    {
        const coord_def &p = exc[i];
        const coord_def floor = find_random_grid(DNGN_FLOOR, vaults);
        if (!floor.x && !floor.y)
            continue;
        join_the_dots(p, floor, vaults, true);
    }
}
/*
 * Places a vault somewhere in an already built level if possible.
 * Returns true if the vault was successfully placed.
 */
static bool build_secondary_vault(int level_number, int vault, int rune_subst)
{
    if (build_vaults(level_number, vault, rune_subst, true))
    {
        const vault_placement &vp = level_vaults[ level_vaults.size() - 1 ];
        connect_vault(vp);
        return (true);
    }
    return (false);
}
static bool build_vaults(int level_number, int force_vault, int rune_subst,
                         bool build_only)

    std::vector<coord_def> target_connections;

    std::vector<coord_def> &target_connections = place.exits;

    int gluggy = vault_main(vgrid, place, force_vault, level_number);

    const int gluggy = vault_main(vgrid, place, force_vault, &level_vaults);

    level_vaults.push_back(place);

    if (gluggy == MAP_NONE)
        return (false);

    dgn_region this_vault(place.x, place.y, place.width, place.height);

            if (!this_vault.contains( coord_def(vx, vy) ))
                continue;
            

                                      num_runes );

                                      num_runes,
                                      rune_subst );

    // If the map takes the whole screen, our work is done.
    if (gluggy == MAP_ENCOMPASS)
        return;

    // Must do this only after target_connections is finalised, or the vault
    // exits will not be correctly set.
    level_vaults.push_back(place);
    // If the map takes the whole screen or we were only requested to
    // build, our work is done.
    if (gluggy == MAP_ENCOMPASS || build_only)
        return (true);

        std::vector<coord_def> ex_connection_points;
        // Giving target_connections directly to build_rooms causes
        // problems with long, skinny vaults where paths to the exit
        // tend to cut through the vault. By backing out of the vault
        // one square, we improve connectability.
        for (int i = 0, size = target_connections.size(); i < size; ++i)
        {
            const coord_def &p = target_connections[i];
            ex_connection_points.push_back(p + dig_away_dir(place, p));
        }

        std::vector<coord_def> ex_connection_points =
            external_connection_points(place, target_connections);

                stair_exist[grd[stx][sty] - 82] = 1;

                stair_exist[grd[stx][sty] - DNGN_STONE_STAIRS_DOWN_I] = 1;

            // does this look funny to *you*? {dlb}
            if (stair_exist[(82 + j + (i * 4)) - 82] == 1)   

            const int stair = j + ((i == 0) ? DNGN_STONE_STAIRS_DOWN_I
                                   : DNGN_STONE_STAIRS_UP_I);
            if (stair_exist[stair - DNGN_STONE_STAIRS_DOWN_I] == 1)   

            grd[pos_x][pos_y] = j + ((i == 0) ? DNGN_STONE_STAIRS_DOWN_I
                                              : DNGN_STONE_STAIRS_UP_I);

            grd[pos_x][pos_y] = stair;

    return (true);

                       int &num_runes)

                       int &num_runes,
                       int rune_subst )

                if (rune_subst != -1)
                {
                    grd[vx][vy] = rune_subst;
                    break;
                }
                

    const dgn_region_list &forbidden)

    const dgn_region_list &forbidden,
    bool early_exit)

        if (early_exit && at != from && grd(at) == DNGN_FLOOR)
            return (true);
        

            spec_room sr = { false, false, 0,0,0,0 };

            spec_room sr;

        spec_room sr = { false, false, 0, 0, 0, 0 };

        spec_room sr;

    spec_room sr = { false, false, 0,0,0,0 };

    spec_room sr;

        spec_room sr = { false, false, 0, 0, 0, 0 };

        spec_room sr;

    spec_room sr = { false, false, 0, 0, 0, 0 };

    spec_room sr;

        mpr("Aim (press '?' for help, Shift-Dir to shoot in a  straight line.)", MSGCH_PROMPT);

        mpr("Aim (press '?' for help, Shift-Dir to shoot in a straight line.)",
            MSGCH_PROMPT);

#  O - place an appropriate rune here

#  O - place an appropriate rune here. For portal vaults, place the portal here.

#  O - place an appropriate rune here

#  O - place an appropriate rune here. In portal vaults, place the portal or
#      branch stair here.

##############################################################################
# Portal vaults
##############################################################################
# These vaults are used when the dungeon builder tries to place a portal/stair
# to a branch. There's no guarantee that one of these will be used because
# portal vaults are placed last, after the rest of the level is generated, and 
# will not be placed if they can't fit on the level without clobbering 
# something.
#
# With portal vaults (as with minivaults), smaller is better, since the dungeon
# builder will frequently not be able to fit large vaults in anywhere (it
# doesn't try very hard).
#
# Note that the rune symbol (O) is used for the portal in portal vaults. If you
# do not put an O anywhere in the vault, there will be no portal for that 
# branch!
#
##############################################################################
# Freedom of Choice (Orc entry)
NAME: david_orc_choice
TAGS: orc_entry
MONS: hobgoblin, orc sorcerer, orc warrior, orc
ITEM: scroll of blinking / scroll of recharging / scroll of fear
ITEM: scroll of teleport / scroll of remove curse / scroll of identify
ORIENT: float
MAP
xxxxxxxxxxxxxxxxxxxxxxxxx
xxxxxxxx.........xxxxxxxx
xxxxx.......O.......xxxxx
xxxx.................xxxx
xxxx....x.......x....xxxx
xxx....xxx.....xxx....xxx
xxx...xxxxx...xxxxx...xxx
xx.....xxx.....xxx.....xx
xx.....xxx.....xxx.....xx
x.......x..I.I..x...I...x
x.......x.......x.......x
x..x.x..x..x=x..x..x+x..x
x.xx.xx.x.xx=xx.x.xx~xx.x
x.x.%.x.x.x.d.x.x.x.4.x.x
x.x.1.x.x.x.2.x.x.x.4.x.x
x.x.%.x.x.x.3.x.x.x.e.x.x
x.xx.xx.x.xx=xx.x.xx~xx.x
x..x.x..x..x=x..x..x+x..x
x.......x.......x.......x
x.......x..I.I..x...I...x
xx.....xxx.....xxx.....xx
xx.....+.+.....+.+.....xx
xxx...xxxxx...xxxxx...xxx
xxx.@.xxxxxxxxxxxxx.@.xxx
ENDMAP
##############################################################################
# Generic Orc entry
NAME: david_orc_1
TAGS: orc_entry
MONS: orc
ORIENT: float
FLAGS: no_rotate
MAP
xxxx..@..xxxx
x.....I.....x
x...........x
.....111.....
@I...1O1...I@
.....111.....
x...........x
x.....I.....x
xxxx..@..xxxx
ENDMAP
##############################################################################
# Generic Vaults entry
NAME: david_vaults_1
TAGS: vault_entry
MONS: human
ORIENT: float
FLAGS: no_rotate
MAP
xxxxx.@.xxxxx
x...+...x...x
x...x...x...x
xxx=x111x...x
@.x.x111+.O.x
x.x.x111x...x
x.x.x...x...x
x.+.x...x...x
xxxxx.@.xxxxx
ENDMAP
##############################################################################
# Generic Lair entry
NAME: david_lair_1
TAGS: lair_entry
MONS: giant lizard, giant snail, yak, plant
ORIENT: float
FLAGS: no_rotate
CHANCE: 5000
MAP
xxxx..@..xxxx
xx.........xx
x...2...44..x
...4..1......
@....1O3....@
..........4..
x...4..2....x
xx.........xx
xxxx..@..xxxx
ENDMAP
##############################################################################
# Shrubbed Lair entry
NAME: david_lair_2
TAGS: lair_entry
MONS: plant, lindwurm
ORIENT: float
FLAGS: no_rotate
MAP
xxxxxxxxxxxxx
xx111111111xx
x112..111111x
x11.O..111...
x11...111...@
x111111......
x1..11......x
xx.........xx
xxxx..@..xxxx
ENDMAP