case DNGN_ROCK_STAIRS_UP:

        case DNGN_ESCAPE_HATCH_UP:

        case DNGN_ROCK_STAIRS_DOWN:

        case DNGN_ESCAPE_HATCH_DOWN:

        case DNGN_ROCK_STAIRS_DOWN:

        case DNGN_ESCAPE_HATCH_DOWN:

        case DNGN_ROCK_STAIRS_UP:

        case DNGN_ESCAPE_HATCH_UP:

                        if (grid_is_rock_stair(grd(gc)))
                            learned_something_new(
                                TUT_SEEN_ESCAPE_HATCH, gc.x, gc.y);

                        if (grid_is_escape_hatch(grd(gc)))
                        {
                            learned_something_new(TUT_SEEN_ESCAPE_HATCH,
                                                  gc.x, gc.y);
                        }

       case DNGN_ROCK_STAIRS_DOWN:
       case DNGN_ROCK_STAIRS_UP:

       case DNGN_ESCAPE_HATCH_DOWN:
       case DNGN_ESCAPE_HATCH_UP:

       case DNGN_ROCK_STAIRS_DOWN:
       case DNGN_ROCK_STAIRS_UP:

       case DNGN_ESCAPE_HATCH_DOWN:
       case DNGN_ESCAPE_HATCH_UP:

const signed char IMPASSABLE = 0;
const signed char FORBIDDEN = -1;

const signed char IMPASSABLE  = 0;
const signed char FORBIDDEN   = -1;

    return (feature == DNGN_SHALLOW_WATER || feature == DNGN_CLOSED_DOOR? 2 :
            grid_is_trap(feature) ? 3 : 1);

    if (feature == DNGN_SHALLOW_WATER || feature == DNGN_CLOSED_DOOR)
        return 2;
    else if (grid_is_trap(feature))
        return 3;
        
    return 1;

    traversable_terrain[DNGN_ROCK_STAIRS_DOWN] =

    traversable_terrain[DNGN_ESCAPE_HATCH_DOWN] =

    traversable_terrain[DNGN_ROCK_STAIRS_UP] =

    traversable_terrain[DNGN_ESCAPE_HATCH_UP] =

    case DNGN_ROCK_STAIRS_DOWN:

    case DNGN_ESCAPE_HATCH_DOWN:

    case DNGN_ROCK_STAIRS_UP:

    case DNGN_ESCAPE_HATCH_UP:

            // Never use rock stairs as the last leg of the trip, since

            // Never use escape hatches as the last leg of the trip, since

            if (grid_is_rock_stair(si.grid)

            if (grid_is_escape_hatch(si.grid)

    case DNGN_STONE_STAIRS_DOWN_III: case DNGN_ROCK_STAIRS_DOWN:

    case DNGN_STONE_STAIRS_DOWN_III: case DNGN_ESCAPE_HATCH_DOWN:

    case DNGN_STONE_STAIRS_UP_III:   case DNGN_ROCK_STAIRS_UP:

    case DNGN_STONE_STAIRS_UP_III:   case DNGN_ESCAPE_HATCH_UP:

    if (type == TRAP_DART?
        random2(1 + level_number) > 2
        : one_chance_in(7))

    if (type == TRAP_DART ? random2(1 + level_number) > 2
                          : one_chance_in(7))
    {

    }

    case DNGN_ROCK_STAIRS_DOWN:

    case DNGN_ESCAPE_HATCH_DOWN:

    case DNGN_ROCK_STAIRS_UP:

    case DNGN_ESCAPE_HATCH_UP:

bool grid_is_rock_stair(dungeon_feature_type grid);

bool grid_is_escape_hatch(dungeon_feature_type grid);

bool grid_is_rock_stair(dungeon_feature_type grid)

bool grid_is_escape_hatch(dungeon_feature_type grid)

    switch (grid)
    {
    case DNGN_ROCK_STAIRS_UP:
    case DNGN_ROCK_STAIRS_DOWN:
        return (true);
    default:
        return (false);
    }

    return (grid == DNGN_ESCAPE_HATCH_UP || grid == DNGN_ESCAPE_HATCH_DOWN);

    case DNGN_ROCK_STAIRS_UP:

    case DNGN_ESCAPE_HATCH_UP:

    case DNGN_ROCK_STAIRS_DOWN:

    case DNGN_ESCAPE_HATCH_DOWN:

              || grid == DNGN_TRAP_NATURAL);

            || grid == DNGN_TRAP_NATURAL);

bool is_trap_square(int x, int y);

bool is_trap_square(dungeon_feature_type grid);

                if (grid_is_rock_stair(feat))

                if (grid_is_escape_hatch(feat))

bool is_trap_square(int x, int y)

bool is_trap_square(dungeon_feature_type grid)

    return (grd[x][y] >= DNGN_TRAP_MECHANICAL
        && grd[x][y] <= DNGN_UNDISCOVERED_TRAP);

    return (grid >= DNGN_TRAP_MECHANICAL
            && grid <= DNGN_UNDISCOVERED_TRAP);

    case DNGN_STONE_STAIRS_UP_III: case DNGN_ROCK_STAIRS_DOWN:
    case DNGN_ROCK_STAIRS_UP: case DNGN_ENTER_SHOP:

    case DNGN_STONE_STAIRS_UP_III: case DNGN_ESCAPE_HATCH_DOWN:
    case DNGN_ESCAPE_HATCH_UP: case DNGN_ENTER_SHOP:

        const coord_def where_to_go =
            dgn_find_nearby_stair(DNGN_ROCK_STAIRS_DOWN, pos, true);

        const coord_def where_to_go
            = dgn_find_nearby_stair(DNGN_ESCAPE_HATCH_DOWN, pos, true);

                dgn_find_nearby_stair(DNGN_ROCK_STAIRS_DOWN,

                dgn_find_nearby_stair(DNGN_ESCAPE_HATCH_DOWN,

    if (!is_trap_square(monster->x, monster->y))

    if (!is_trap_square(grd[monster->x][monster->y]))

    if (grid_is_rock_stair(stair))

    if (grid_is_escape_hatch(stair))

    else if (grid_is_rock_stair(stair))

    else if (grid_is_escape_hatch(stair))

        && !grid_is_rock_stair(stair_find))

        && !grid_is_escape_hatch(stair_find))

        && stair_find <= DNGN_ROCK_STAIRS_DOWN

        && stair_find <= DNGN_ESCAPE_HATCH_DOWN

        && !grid_is_rock_stair(stair_find)

        && !grid_is_escape_hatch(stair_find)

        stair_taken = DNGN_ROCK_STAIRS_DOWN;

        stair_taken = DNGN_ESCAPE_HATCH_DOWN;

    "stone_stairs_down_iii", "rock_stairs_down", "stone_stairs_up_i",
    "stone_stairs_up_ii", "stone_stairs_up_iii", "rock_stairs_up", "",

    "stone_stairs_down_iii", "escape_hatch_down", "stone_stairs_up_i",
    "stone_stairs_up_ii", "stone_stairs_up_iii", "escape_hatch_up", "",

            if (grid_is_stone_stair(feat) || grid_is_rock_stair(feat))

            if (grid_is_stone_stair(feat) || grid_is_escape_hatch(feat))

             && stair_taken <= DNGN_ROCK_STAIRS_DOWN)

             && stair_taken <= DNGN_ESCAPE_HATCH_DOWN)

             && stair_taken <= DNGN_ROCK_STAIRS_UP)

             && stair_taken <= DNGN_ESCAPE_HATCH_UP)

        stair_taken = DNGN_ROCK_STAIRS_DOWN;

        stair_taken = DNGN_ESCAPE_HATCH_DOWN;

    DNGN_ROCK_STAIRS_DOWN,             //  85 - now escape hatch (Stonesoup 0.3)

    DNGN_ESCAPE_HATCH_DOWN,            //  85 - was: rock stairs (Stonesoup 0.3)

    DNGN_ROCK_STAIRS_UP,               //  89 - now escape hatch (Stonesoup 0.3)

    DNGN_ESCAPE_HATCH_UP,              //  89 - was: rock stairs (Stonesoup 0.3)

        const std::vector<std::string> &msgs =
            level_vaults[i].map.welcome_messages;

        const std::vector<std::string> &msgs
            = level_vaults[i].map.welcome_messages;

                dcgrid[x][y] =
                    coloured_feature(grd[x][y], env.grid_colours[x][y]);

            {
                dcgrid[x][y]
                    = coloured_feature(grd[x][y], env.grid_colours[x][y]);
            }

static void dgn_fill_zone(
    const coord_def &c, int zone, point_record &prec,
    bool (*passable)(const coord_def &) = dgn_square_is_passable)

static void dgn_fill_zone( const coord_def &c, int zone, point_record &prec,
                           bool (*passable)(const coord_def &)
                               = dgn_square_is_passable)

    {

    }

    {

    }

    {

                && grd[i][j] <= DNGN_ROCK_STAIRS_UP)

                && grd[i][j] <= DNGN_ESCAPE_HATCH_UP)

                && grd[i][j] <= DNGN_ROCK_STAIRS_DOWN)

                && grd[i][j] <= DNGN_ESCAPE_HATCH_DOWN)

    }

        {

        }

    {

    }

    ff.add_feat(DNGN_ROCK_STAIRS_DOWN);

    ff.add_feat(DNGN_ESCAPE_HATCH_DOWN);

                    && grd[x][y] <= DNGN_ROCK_STAIRS_UP)

                    && grd[x][y] <= DNGN_ESCAPE_HATCH_UP)

                    && grd[x][y] <= DNGN_ROCK_STAIRS_DOWN)
                    grd[x][y] = DNGN_ROCK_STAIRS_UP;

                    && grd[x][y] <= DNGN_ESCAPE_HATCH_DOWN)
                {
                    grd[x][y] = DNGN_ESCAPE_HATCH_UP;
                }

        {

            {

                    && grd[x][y] <= DNGN_ROCK_STAIRS_UP)

                    && grd[x][y] <= DNGN_ESCAPE_HATCH_UP)

            }
        }

    // turning additional stairs into rock stairs (with an attempt to keep

    // turning additional stairs into escape hatches (with an attempt to keep

    {

    }

            replace = DNGN_ROCK_STAIRS_UP;

            replace = DNGN_ESCAPE_HATCH_UP;

            replace = DNGN_ROCK_STAIRS_DOWN;

            replace = DNGN_ESCAPE_HATCH_DOWN;

            // into a rock stairs of the appropriate type.

            // into an escape hatch of the appropriate type.

    {

    }

    {

    }

            if ( (x-i)*(x-i)*b*b + (y-j)*(y-j)*a*a <=
                 a*a*b*b/2 + roll_dice(2, a*a*b*b)/4 + random2(3) )

            if ( (x-i)*(x-i)*b*b + (y-j)*(y-j)*a*a
                  <= a*a*b*b/2 + roll_dice(2, a*a*b*b)/4 + random2(3) )
            {

            }

        {

        }

        {

        }

    if ( i < margin || i >= GXM - margin ||
         j < margin || j >= GYM - margin ||
         taken[i][j] )

    if (i < margin || i >= GXM - margin || j < margin || j >= GYM - margin
        || taken[i][j])
    {

    }

            taken[i][j] = (grd[i][j] == DNGN_DEEP_WATER ||
                           grd[i][j] == DNGN_SHALLOW_WATER);

        {
            taken[i][j] = (grd[i][j] == DNGN_DEEP_WATER
                           || grd[i][j] == DNGN_SHALLOW_WATER);
        }

    do {

    do
    {

            for (int y = margin; y < GYM-margin; ++y)

           for (int y = margin; y < GYM-margin; ++y)

    } while ( ++num_tries < 100 &&
              count_connected(margin) != num_islands );

    }
    while ( ++num_tries < 100 && count_connected(margin) != num_islands );
    

            if (grd[i][j] == DNGN_DEEP_WATER &&
                count_neighbours(i, j, DNGN_FLOOR) > random2(random2(3)+1))

            if (grd[i][j] == DNGN_DEEP_WATER
                && count_neighbours(i, j, DNGN_FLOOR) > random2(random2(3)+1))
            {

            }

            {

            }

                {

                }

        {

            {

            }
        }

        do {

        do
        {

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

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

            do {

            do
            {

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

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

            do {

            do
            {

            } while ( grd[x][y] != DNGN_FLOOR );
            grd[x][y] =
                static_cast<dungeon_feature_type>(
                    DNGN_STONE_STAIRS_DOWN_I + i );

            }
            while ( grd[x][y] != DNGN_FLOOR );
            
            grd[x][y]
              = static_cast<dungeon_feature_type>(DNGN_STONE_STAIRS_DOWN_I + i);

            do {

            do
            {

            } while ( grd[x][y] != DNGN_FLOOR );
            grd[x][y] =
                static_cast<dungeon_feature_type>(
                    DNGN_STONE_STAIRS_UP_I + i);

            }
            while ( grd[x][y] != DNGN_FLOOR );
            grd[x][y]
                = static_cast<dungeon_feature_type>(DNGN_STONE_STAIRS_UP_I + i);

    {

    }

    {

                {

                    {

                    }
                }

    }

        for(x = sx; x <= ex; x++)
        {
            for(y = sy; y <= ey; y++)

        for (x = sx; x <= ex; x++)
            for (y = sy; y <= ey; y++)

        }

        for(bx=room_x1; bx<=room_x2; bx++)

        for (bx = room_x1; bx <= room_x2; bx++)

        for(by=room_y1+1; by<room_y2; by++)

        for (by = room_y1+1; by < room_y2; by++)

        for(bx=room_x1 + 1; bx < room_x2; bx++)
            for(by=room_y1 + 1; by < room_y2; by++)

        for (bx = room_x1 + 1; bx < room_x2; bx++)
            for (by = room_y1 + 1; by < room_y2; by++)

                    DNGN_ROCK_STAIRS_DOWN );

                    DNGN_ESCAPE_HATCH_DOWN );

                    DNGN_ROCK_STAIRS_UP );

                    DNGN_ESCAPE_HATCH_UP );

    {

    }

    dungeon_feature_type river_type =
        one_chance_in( 5 + level_number ) ? DNGN_SHALLOW_WATER 
        : DNGN_DEEP_WATER;

    dungeon_feature_type river_type
        = (one_chance_in( 5 + level_number ) ? DNGN_SHALLOW_WATER
                                             : DNGN_DEEP_WATER);

static bool _shaft_is_in_corridor(int x, int y)
{
    // first check horizontal neighbouring squares
    if ((!inside_level_bounds(x-1, y) || grd[x-1][y] < DNGN_SHALLOW_WATER)
        && (!inside_level_bounds(x+1, y) || grd[x+1][y] < DNGN_SHALLOW_WATER))
    {
        return true;
    }
    
    // now check vertical neighbouring squares
    if ((!inside_level_bounds(x, y-1) || grd[x][y-1] < DNGN_SHALLOW_WATER)
        && (!inside_level_bounds(x, y+1) || grd[x][y+1] < DNGN_SHALLOW_WATER))
    {
        return true;
    }
    // no corridor found
    return false;
}

        
        if (trap_type == TRAP_SHAFT && level_number <= 7)
        {
            // Disallow shaft construction in corridors!
            if ( _shaft_is_in_corridor(env.trap[i].x, env.trap[i].y) )
            {
                // choose again!
                trap_type = random_trap_for_place(level_number);
                
                // If we get shaft a second time, turn it into an alarm trap.
                if (trap_type == TRAP_SHAFT)
                    trap_type = TRAP_ALARM;
            }
        }

    while(grd[sx][sy] != DNGN_FLOOR || mgrd[sx][sy] != NON_MONSTER);

    while (grd[sx][sy] != DNGN_FLOOR || mgrd[sx][sy] != NON_MONSTER);

            {

                {

                            && grd[sx][sy] <= DNGN_ROCK_STAIRS_DOWN)

                        && grd[sx][sy] <= DNGN_ESCAPE_HATCH_DOWN)

                }
            }

            place_specific_stair(
                branches[i].entry_stairs,
                entry_tag,
                dlevel);

            place_specific_stair( branches[i].entry_stairs, entry_tag, dlevel);

                && grd[x_start][y_start] != DNGN_FLOOR);

           && grd[x_start][y_start] != DNGN_FLOOR);

            {

            }

    for (rx=sx; rx<=ex; rx++)
    {
        for(ry=sy; ry<=ey; ry++)

    for (rx = sx; rx <= ex; rx++)
        for (ry = sy; ry <= ey; ry++)

    }

    for(ry=sy+1; ry<ey; ry++)

    for (ry = sy+1; ry < ey; ry++)

    for(rx=sx+1; rx<ex; rx++)

    for (rx = sx+1; rx < ex; rx++)

    if (player_in_branch(BRANCH_SHOALS) && player_branch_depth() > 1 &&
        coinflip())

    if (player_in_branch(BRANCH_SHOALS) && player_branch_depth() > 1
        && coinflip())
    {

    }

    if (level_number <= 0 || level_type != LEVEL_DUNGEON ||
        !your_branch().has_uniques)

    if (level_number <= 0 || level_type != LEVEL_DUNGEON
        || !your_branch().has_uniques)
    {

    }

    while(one_chance_in(3))

    while (one_chance_in(3))

        while(which_unique < 0 || you.unique_creatures[which_unique])

        while (which_unique < 0 || you.unique_creatures[which_unique])

    {

                           MONS_PROGRAM_BUG, 0,
                           MMT_NO_MONS ))

                           MONS_PROGRAM_BUG, 0, MMT_NO_MONS ))

    }

    {

            if (grd[x][y]==DNGN_DEEP_WATER || grd[x][y]==DNGN_SHALLOW_WATER)

            if (grd[x][y] == DNGN_DEEP_WATER || grd[x][y] == DNGN_SHALLOW_WATER)

    }

                             std::min(random2avg(9, 2) +
                                      (random2(lava_spaces) / 10), 15));

                             std::min(random2avg(9, 2)
                               + (random2(lava_spaces) / 10), 15));

                             std::min(random2avg(9, 2) +
                                      (random2(water_spaces) / 10), 15));

                             std::min(random2avg(9, 2)
                               + (random2(water_spaces) / 10), 15));

    if (level_type == LEVEL_PANDEMONIUM ||
        player_in_branch(BRANCH_ECUMENICAL_TEMPLE))

    if (level_type == LEVEL_PANDEMONIUM
        || player_in_branch(BRANCH_ECUMENICAL_TEMPLE))
    {

    }

    {

    }

        /* No items in hell, the slime pits, the Hall */

        /* No random items in hell, the slime pits, the temple, the hall */

        {

        }

        {

        }

static void fill_monster_pit( spec_room &sr, 
                          FixedVector<pit_mons_def, MAX_PIT_MONSTERS> &pit_list,
                          int density, int lord_type, int lordx, int lordy )

static void fill_monster_pit( spec_room &sr, FixedVector<pit_mons_def,
                              MAX_PIT_MONSTERS> &pit_list, int density,
                              int lord_type, int lordx, int lordy )

    {

            {

            }

    }

        {

        }

        {

        }

        {

        }

        {

        }

        {

        }

        {

        }

    {

    }

    {

    }

// 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);
    return (false);
}
// used for placement of rivers/lakes
static bool _may_overwrite_pos(const int i, const int j)
{
    const dungeon_feature_type grid = grd[i][j];
    // Don't overwrite any stairs or branch entrances.
    if (grid >= DNGN_ENTER_SHOP && grid <= DNGN_EXIT_PORTAL_VAULT
        || grid == DNGN_EXIT_HELL)
    {
        return (false);
    }

    // Don't overwrite feature if there's a monster or item there.
    // Otherwise, items/monsters might end up stuck in deep water.
    return (mgrd[i][j] == NON_MONSTER && igrd[i][j] == NON_ITEM);
}

    {

            if ((dfeat != DNGN_FLOOR
                 && dfeat != DNGN_ROCK_WALL
                 && dfeat != DNGN_CLOSED_DOOR
                 && dfeat != DNGN_SECRET_DOOR
                 && (!water_ok
                     || (dfeat != DNGN_DEEP_WATER
                         && dfeat != DNGN_SHALLOW_WATER)))
                || igrd[vx][vy] != NON_ITEM
                || mgrd[vx][vy] != NON_MONSTER)
            {

            // 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)

            }

    }

    {

            if (grd[vx][vy] == DNGN_FLOOR
                || grd[vx][vy] == DNGN_CLOSED_DOOR
                || grd[vx][vy] == DNGN_SECRET_DOOR
                || (water_ok
                    && (grd[vx][vy] == DNGN_SHALLOW_WATER ||
                        grd[vx][vy] == DNGN_DEEP_WATER)))

            // Overwrite floor, doors or water, but not rock walls.
            if (_may_overwrite_feature(grd[vx][vy], water_ok, false))

    }

    {

                dungeon_terrain_changed(coord_def(vx, vy),
                                        newgrid,
                                        true, true);

                dungeon_terrain_changed(coord_def(vx, vy), newgrid, true, true);

    }

                 cnx < end.x && !found_collision;
                 cnx++)

                 cnx < end.x && !found_collision; cnx++)

                     cny < end.y;
                     cny++)

                     cny < end.y; cny++)

            join_the_dots_rigorous(
                myroom.random_edge_point(),
                rom[which_room - 1].random_edge_point(),
                MMT_VAULT );

            join_the_dots_rigorous( myroom.random_edge_point(),
                                    rom[which_room - 1].random_edge_point(),
                                    MMT_VAULT );

            dig_dir.x =
                away_from_edge(pos.x,
                               MAPGEN_BORDER * 2,
                               GXM - MAPGEN_BORDER * 2);

        {
            dig_dir.x = away_from_edge(pos.x, MAPGEN_BORDER * 2,
                                       GXM - MAPGEN_BORDER * 2);
        }

            dig_dir.y =
                away_from_edge(pos.y,
                               MAPGEN_BORDER * 2,
                               GYM - MAPGEN_BORDER * 2);

        {
            dig_dir.y = away_from_edge(pos.y, MAPGEN_BORDER * 2,
                                       GYM - MAPGEN_BORDER * 2);
        }

            || dig_at.y < MAPGEN_BORDER
            || dig_at.y > (GYM - MAPGEN_BORDER - 1))

            || dig_at.y < MAPGEN_BORDER || dig_at.y > (GYM - MAPGEN_BORDER - 1))

            {

            }

static void dig_vault_loose(
    vault_placement &place,
    std::vector<coord_def> &targets)

static void dig_vault_loose( vault_placement &place,
                             std::vector<coord_def> &targets )

        dig_away_from(place, targets[i]);

         dig_away_from(place, targets[i]);

        {

        }
        

        {

        }

        {

        }

        {

        }

        did_map =
            build_minivaults(you.your_level, map, generating_level, clobber,
                             make_no_exits, where);

    {
        did_map = build_minivaults(you.your_level, map, generating_level,
                                   clobber, make_no_exits, where);
    }

        {

        }

    int  num_runes = 0;

    int num_runes = 0;

    {

    }

        excluded_regions.push_back(
            dgn_region::absolute(v1x, v1y, v2x, v2y));

        excluded_regions.push_back( dgn_region::absolute(v1x, v1y, v2x, v2y) );

    {

        {

                    && grd[stx][sty] <= DNGN_ROCK_STAIRS_UP)

                && grd[stx][sty] <= DNGN_ESCAPE_HATCH_UP)

        }
    }

    {

            const dungeon_feature_type stair =
                static_cast<dungeon_feature_type>(
                    j + ((i == 0) ? DNGN_STONE_STAIRS_DOWN_I
                         : DNGN_STONE_STAIRS_UP_I));

            const dungeon_feature_type stair
                = static_cast<dungeon_feature_type>(
                   j + ((i == 0) ? DNGN_STONE_STAIRS_DOWN_I
                                 : DNGN_STONE_STAIRS_UP_I));

    }

    {

    }

        const int item_made =
            items( spec.allow_uniques, spec.base_type, spec.sub_type, true,
                   item_level, spec.race, 0, spec.ego );

        const int item_made
            = items( spec.allow_uniques, spec.base_type, spec.sub_type, true,
                     item_level, spec.race, 0, spec.ego );

        const bool placed =
            place_monster( mindex, mid, monster_level,
                           m_generate_awake ? BEH_WANDER : BEH_SLEEP,
                           MHITNOT, true, vx, vy, false,
                           PROX_ANYWHERE, mspec.monnum);

        const bool placed
            = place_monster( mindex, mid, monster_level,
                             m_generate_awake ? BEH_WANDER : BEH_SLEEP,
                             MHITNOT, true, vx, vy, false,
                             PROX_ANYWHERE, mspec.monnum);

static bool dgn_place_monster(
    const vault_placement &place,
    mons_spec &mspec,
    int monster_level,
    int vx, int vy)

static bool dgn_place_monster( const vault_placement &place, mons_spec &mspec,
                               int monster_level, int vx, int vy)

    const bool generate_awake =
        mspec.generate_awake || place.map.has_tag("generate_awake");
    return dgn_place_monster(mspec, monster_level, vx, vy,
                             generate_awake);

    const bool generate_awake
        = mspec.generate_awake || place.map.has_tag("generate_awake");
        
    return dgn_place_monster(mspec, monster_level, vx, vy, generate_awake);

static bool dgn_place_one_monster(
    const vault_placement &place,
    mons_list &mons,
    int monster_level,
    int vx, int vy)

static bool dgn_place_one_monster( const vault_placement &place,
                                   mons_list &mons, int monster_level,
                                   int vx, int vy)

        {

        }

            (rawfeat == '>') ? DNGN_ROCK_STAIRS_DOWN :
            (rawfeat == '<') ? DNGN_ROCK_STAIRS_UP :

            (rawfeat == '>') ? DNGN_ESCAPE_HATCH_DOWN :
            (rawfeat == '<') ? DNGN_ESCAPE_HATCH_UP :

            (rawfeat == '\0')? DNGN_ROCK_WALL :
            DNGN_FLOOR); // includes everything else

            (rawfeat == '\0')? DNGN_ROCK_WALL
                             : DNGN_FLOOR); // includes everything else

            const trap_type trap =
                f.trap == TRAP_INDEPTH? random_trap_for_place(level_number)
                : static_cast<trap_type>(f.trap);

            const trap_type trap
                = (f.trap == TRAP_INDEPTH) ? random_trap_for_place(level_number)
                                           : static_cast<trap_type>(f.trap);

    grd[vx][vy] =
                  ((vgrid == -1)  ? grd[vx][vy] : 

    grd[vx][vy] = ((vgrid == -1)  ? grd[vx][vy] :

                   (vgrid == '>') ? DNGN_ROCK_STAIRS_DOWN :
                   (vgrid == '<') ? DNGN_ROCK_STAIRS_UP :

                   (vgrid == '>') ? DNGN_ESCAPE_HATCH_DOWN :
                   (vgrid == '<') ? DNGN_ESCAPE_HATCH_UP :

                   (vgrid == '\0')? DNGN_ROCK_WALL :
                                    DNGN_FLOOR); // includes everything else

                   (vgrid == '\0')? DNGN_ROCK_WALL
                                  : DNGN_FLOOR); // includes everything else

    case 'R':
    case '$':
    case '%':
    case '*':
    case '|':
    case 'P':                   // possible rune
    case 'O':                   // definite rune
    case 'Z':                   // definite orb

        case 'R':
        case '$':
        case '%':
        case '*':
        case '|':
        case 'P':                   // possible rune
        case 'O':                   // definite rune
        case 'Z':                   // definite orb

            which_depth = ((vgrid == '|'
                            || vgrid == 'P'
                            || vgrid == 'O'
                            || vgrid == 'Z') ? MAKE_GOOD_ITEM :
                           (vgrid == '*')    ? 5 + (level_number * 2)
                                             : level_number);

            which_depth = level_number;
            if (vgrid == '|' || vgrid == 'P' || vgrid == 'O' || vgrid == 'Z')
                which_depth = MAKE_GOOD_ITEM;
            else if (vgrid == '*')
                which_depth = 5 + (level_number * 2);

            item_made = items( 1, which_class, which_type, true, 
                               which_depth, spec );          

            item_made = items( 1, which_class, which_type, true,
                               which_depth, spec );

    {

    }

        const int mtype = 
            vgrid == 'H'? MONS_ORANGE_STATUE : MONS_SILVER_STATUE;

        const int mtype = (vgrid == 'H') ? MONS_ORANGE_STATUE
                                         : MONS_SILVER_STATUE;

        monster_level = ((vgrid == '8') ? (4 + (level_number * 2)) :
                          (vgrid == '9') ? (5 + level_number) : level_number);

        monster_level = level_number;
        if (vgrid == '8')
            monster_level = 4 + (level_number * 2);
        else if (vgrid == '9')
            monster_level = 5 + level_number;

static void replace_area(
    int sx, int sy, int ex, int ey, dungeon_feature_type replace,
    dungeon_feature_type feature, unsigned mapmask)

static void replace_area( int sx, int sy, int ex, int ey,
                          dungeon_feature_type replace,
                          dungeon_feature_type feature, unsigned mapmask)

    for(x=sx; x<=ex; x++)
        for(y=sy; y<=ey; y++)

    for (x = sx; x <= ex; x++)
        for (y = sy; y <= ey; y++)
        {

        }

static void jtd_init_surrounds(coord_set &coords,
                              unsigned mapmask,
                              const coord_def &c)

static void jtd_init_surrounds(coord_set &coords, unsigned mapmask,
                               const coord_def &c)

    {

    }

                                   const coord_def &from,
                                   const coord_def &to,
                                   unsigned mapmask,
                                   bool early_exit)

                                   const coord_def &from, const coord_def &to,
                                   unsigned mapmask, bool early_exit)

    const bool found =
        join_the_dots_pathfind(coords, from, to, mapmask, early_exit);

    const bool found = join_the_dots_pathfind(coords, from, to, mapmask,
                                              early_exit);

static bool join_the_dots(
    const coord_def &from,
    const coord_def &to,
    unsigned mapmask,
    bool early_exit)

static bool join_the_dots( const coord_def &from, const coord_def &to,
                           unsigned mapmask, bool early_exit)

                          (temp_rand == 3 || temp_rand == 4) ? DNGN_ALTAR_OKAWARU
                                           : DNGN_ALTAR_ZIN);

                          (temp_rand == 3
                           || temp_rand == 4) ? DNGN_ALTAR_OKAWARU
                                              : DNGN_ALTAR_ZIN);

            {

            }

                  : random_range(1, MAX_RANDOM_SHOPS));          //  4.0% 

                                   : random_range(1, MAX_RANDOM_SHOPS)); // 0.4%

                                 "bzr_entry",
                                 level_number, true);

                                 "bzr_entry", level_number, true);

    {

    }

    {

    }

        && env.shop[i].type != SHOP_ARMOUR_ANTIQUE
        && env.shop[i].type != SHOP_GENERAL_ANTIQUE)

             && env.shop[i].type != SHOP_ARMOUR_ANTIQUE
             && env.shop[i].type != SHOP_GENERAL_ANTIQUE)

    {

    }

        int factor = random2(8)+12;

        int factor = random2(8) + 12;

        for (int k=0; k < NUM_BOOKS; k++)

        for (int k = 0; k < NUM_BOOKS; k++)

        for (i = DNGN_STONE_STAIRS_DOWN_I; i < DNGN_ROCK_STAIRS_UP; i++)

        for (i = DNGN_STONE_STAIRS_DOWN_I; i < DNGN_ESCAPE_HATCH_UP; i++)

            if (i == DNGN_ROCK_STAIRS_DOWN 

            if (i == DNGN_ESCAPE_HATCH_DOWN

                    && grd[j + 1][k] != DNGN_ROCK_WALL);

                   && grd[j + 1][k] != DNGN_ROCK_WALL);

    {

    }

    {

            place_specific_stair(
                static_cast<dungeon_feature_type>(
                    j + ((i==0) ? DNGN_STONE_STAIRS_DOWN_I
                         : DNGN_STONE_STAIRS_UP_I) ) );

            place_specific_stair( static_cast<dungeon_feature_type>(
                                   j + ((i==0) ? DNGN_STONE_STAIRS_DOWN_I
                                               : DNGN_STONE_STAIRS_UP_I)) );

    }

                                         : DNGN_STONE_WALL);

                                                          : DNGN_STONE_WALL);

        {

                place_specific_stair(
                    static_cast<dungeon_feature_type>(
                        j + ((i==0) ? DNGN_STONE_STAIRS_DOWN_I
                             : DNGN_STONE_STAIRS_UP_I) ) );

                place_specific_stair( static_cast<dungeon_feature_type>(
                                       j + ((i==0) ? DNGN_STONE_STAIRS_DOWN_I
                                                   : DNGN_STONE_STAIRS_UP_I)) );

        }

        DNGN_ROCK_WALL, DNGN_FLOOR);

                 DNGN_ROCK_WALL, DNGN_FLOOR);

        DNGN_ROCK_WALL, DNGN_FLOOR);

                 DNGN_ROCK_WALL, DNGN_FLOOR);

                   DNGN_ROCK_WALL, DNGN_FLOOR);

                     DNGN_ROCK_WALL, DNGN_FLOOR);

                   DNGN_ROCK_WALL, DNGN_FLOOR);

                     DNGN_ROCK_WALL, DNGN_FLOOR);

                                            DNGN_ROCK_WALL, DNGN_FLOOR);

                 DNGN_ROCK_WALL, DNGN_FLOOR);

                                            DNGN_ROCK_WALL, DNGN_FLOOR);

                 DNGN_ROCK_WALL, DNGN_FLOOR);

        {

        }

            {

            }

            {

            }

    {

    }

    {

    }

                  (temp_rand == 1 || temp_rand == 10) ? OBJ_ARMOUR :
                  (temp_rand == 2)                    ? OBJ_MISSILES :
                  (temp_rand == 3)                    ? OBJ_WANDS :
                  (temp_rand == 4)                    ? OBJ_MISCELLANY :
                  (temp_rand == 5)                    ? OBJ_SCROLLS :
                  (temp_rand == 6)                    ? OBJ_JEWELLERY :
                  (temp_rand == 7)                    ? OBJ_BOOKS
                  /* (temp_rand == 8) */              : OBJ_STAVES);

                      (temp_rand == 1 || temp_rand == 10) ? OBJ_ARMOUR :
                      (temp_rand == 2)                    ? OBJ_MISSILES :
                      (temp_rand == 3)                    ? OBJ_WANDS :
                      (temp_rand == 4)                    ? OBJ_MISCELLANY :
                      (temp_rand == 5)                    ? OBJ_SCROLLS :
                      (temp_rand == 6)                    ? OBJ_JEWELLERY :
                      (temp_rand == 7)                    ? OBJ_BOOKS
                   /* (temp_rand == 8) */                 : OBJ_STAVES);

    grd(end) = DNGN_ROCK_STAIRS_UP;

    grd(end) = DNGN_ESCAPE_HATCH_UP;

    {

    }

    {

    }

    dgn_region lab =
        dgn_region::absolute( LABYRINTH_BORDER,
                              LABYRINTH_BORDER,
                              GXM - LABYRINTH_BORDER - 1,
                              GYM - LABYRINTH_BORDER - 1 );

    dgn_region lab = dgn_region::absolute( LABYRINTH_BORDER,
                                           LABYRINTH_BORDER,
                                           GXM - LABYRINTH_BORDER - 1,
                                           GYM - LABYRINTH_BORDER - 1 );

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

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

    if ((grd[x-1][y] == DNGN_CLOSED_DOOR && is_wall(x-1,y-1) && is_wall(x-1,y+1))
     || (grd[x+1][y] == DNGN_CLOSED_DOOR && is_wall(x+1,y-1) && is_wall(x+1,y+1))
     || (grd[x][y-1] == DNGN_CLOSED_DOOR && is_wall(x-1,y-1) && is_wall(x+1,y-1))
     || (grd[x][y+1] == DNGN_CLOSED_DOOR && is_wall(x-1,y+1) && is_wall(x+1,y+1)))

    if (grd[x-1][y] == DNGN_CLOSED_DOOR && is_wall(x-1,y-1) && is_wall(x-1,y+1)
     || grd[x+1][y] == DNGN_CLOSED_DOOR && is_wall(x+1,y-1) && is_wall(x+1,y+1)
     || grd[x][y-1] == DNGN_CLOSED_DOOR && is_wall(x-1,y-1) && is_wall(x+1,y-1)
     || grd[x][y+1] == DNGN_CLOSED_DOOR && is_wall(x-1,y+1) && is_wall(x+1,y+1))

    for(i=bx1+1; i<bx2; i++)

    for (i = bx1+1; i < bx2; i++)

    for(i=by1+1; i<by2; i++)

    for (i = by1+1; i < by2; i++)

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

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

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

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

    while(new_doors > 0 && spot_count > 0)

    while (new_doors > 0 && spot_count > 0)

        for(i=bx1+1; i<bx2; i++)

        for (i = bx1+1; i < bx2; i++)

        for(i=by1+1; i<by2; i++)

        for (i = by1+1; i < by2; i++)

                ((temp_rand > 22) ? 1 : 3);

                (temp_rand > 22) ? 1
                                 : 3;

    {

    }

    {

            place_specific_stair(
                static_cast<dungeon_feature_type>(
                    j + ((i==0) ? DNGN_STONE_STAIRS_DOWN_I
                         : DNGN_STONE_STAIRS_UP_I) ) );

            place_specific_stair( static_cast<dungeon_feature_type>(
                                   j + ((i == 0) ? DNGN_STONE_STAIRS_DOWN_I
                                                 : DNGN_STONE_STAIRS_UP_I)) );

    }

    {

    }

            {

            }

    {

    }

    {

    }

        if (rox2[i] - rox1[i] > 5 && roy2[i] - roy1[i] > 5)

        if (rox2[i] - rox1[i] > 5 && roy2[i] - roy1[i] > 5
            && random2(100 - level_number) < 3)

            if (random2(100 - level_number) < 3)

            if (!one_chance_in(4))

                if (!one_chance_in(4))
                {
                    box_room( rox1[i] + 2, rox2[i] - 2, roy1[i] + 2,
                              roy2[i] - 2, (coinflip() ? DNGN_STONE_WALL

                box_room( rox1[i] + 2, rox2[i] - 2, roy1[i] + 2,
                          roy2[i] - 2, (coinflip() ? DNGN_STONE_WALL

                }
                else
                {
                    box_room( rox1[i] + 2, rox2[i] - 2, roy1[i] + 2,
                                 roy2[i] - 2, DNGN_METAL_WALL );
                }

            }
            else
            {
                box_room( rox1[i] + 2, rox2[i] - 2, roy1[i] + 2,
                          roy2[i] - 2, DNGN_METAL_WALL );
            }

                if (coinflip())
                {
                    treasure_area( level_number, rox1[i] + 3, rox2[i] - 3,
                                                 roy1[i] + 3, roy2[i] - 3 );
                }

            if (coinflip())
            {
                treasure_area( level_number, rox1[i] + 3, rox2[i] - 3,
                                             roy1[i] + 3, roy2[i] - 3 );

    }                           // end "for i"

    }

    {