if (map.height() == 0)
        return ("Must define map.");

static char _plan_1();

static char _plan_1(int level_number);

    do_stairs = ((force_plan == 1) ? _plan_1() :

    do_stairs = ((force_plan == 1) ? _plan_1(level_number) :

static char _plan_1()

static char _plan_1(int level_number)

    int temp_rand = 0;          // probability determination {dlb}
    unsigned char width = (10 - random2(7));    // value range of [4,10] {dlb}
    _replace_area(10, 10, (GXM - 10), (10 + width), DNGN_ROCK_WALL, DNGN_FLOOR);
    _replace_area(10, (60 - width), (GXM - 10), (GYM - 10),
                  DNGN_ROCK_WALL, DNGN_FLOOR);
    _replace_area(10, 10, (10 + width), (GYM - 10), DNGN_ROCK_WALL, DNGN_FLOOR);
    _replace_area((60 - width), 10, (GXM - 10), (GYM - 10),
                  DNGN_ROCK_WALL, DNGN_FLOOR);
    // possible early returns {dlb}:
    temp_rand = random2(4);
    if (temp_rand > 2)          // 25% chance {dlb}
        return 3;
    else if (temp_rand > 1)     // 25% chance {dlb}
        return 2;
    else                        // 50% chance {dlb}
    {
        unsigned char width2 = (coinflip()? (1 + random2(5)) : 5);
        _replace_area(10, (35 - width2), (GXM - 10), (35 + width2),
                      DNGN_ROCK_WALL, DNGN_FLOOR);
        _replace_area((40 - width2), 10, (40 + width2), (GYM - 10),
                      DNGN_ROCK_WALL, DNGN_FLOOR);
    }
    // possible early returns {dlb}:
    temp_rand = random2(4);
    if (temp_rand > 2)          // 25% chance {dlb}
        return 3;
    else if (temp_rand > 1)     // 25% chance {dlb}
        return 2;
    else                        // 50% chance {dlb}
    {
        temp_rand = random2(15);
        if (temp_rand > 7)      // 7 in 15 odds {dlb}
        {
            spec_room sr;
            sr.x1 = 25;
            sr.y1 = 25;
            sr.x2 = (GXM - 25);
            sr.y2 = (GYM - 25);
            int oblique_max = 0;
            if (coinflip())
                oblique_max = 5 + random2(20);

            temp_rand = random2(7);

    const int vault = random_map_for_tag("layout", false, true);
    ASSERT(vault != -1);

            dungeon_feature_type floor_type =
                ((temp_rand > 1) ? DNGN_FLOOR :   // 5/7
                 (temp_rand > 0) ? DNGN_DEEP_WATER// 1/7
                                 : DNGN_LAVA);    // 1/7
            _octa_room(sr, oblique_max, floor_type);
        }
    }

    bool success = _build_vaults(level_number, vault);
    _ensure_vault_placed(success);

    // final return {dlb}:
    return (one_chance_in(5) ? 3 : 2);
}                               // end plan_1()

    return 0;
}                               // end plan_2()

    return (one_chance_in(4) ? 0 : 1);

    return 0;

    -- TODO enne - most of these should probably get moved back into C++

    function octa_room(x1, y1, x2, y2, oblique, floor)

    function octa_room(x1, y1, x2, y2, oblique, fill)

        local deep_water = dgn.feature_number("deep_water")
        local floor = dgn.feature_number("floor")

                    dgn.grid(x, y, floor)

                    dgn.grid(x, y, fill)

                if dgn.grid(x, y) == floor and floor == shallow_water then

                if dgn.grid(x, y) == floor and (fill == shallow_water or fill == deep_water) then

    function spotty_level(boxy, x1, y1, x2, y2)
        local iterations
        -- boxy levels have more clearing, so they get fewer iterations
        if boxy then
            iterations = 200 + crawl.random2(750)
        else
            iterations = 200 + crawl.random2(1500)
        end
        make_spotty(iterations, boxy, x1, y1, x2, y2)
    end
    -- randomly turns walls into floors
    function make_spotty(iterations, boxy, x1, y1, x2, y2)
        if x2 - x1 - 8 <= 0 or y2 - y1 - 8 <= 0 then
            return
        end
        local wall = dgn.feature_number("rock_wall")
        local floor = dgn.feature_number("floor")
        for i = 1, iterations do
            local x, y
            repeat
                x = crawl.random2(x2 - x1 - 7) + x1 + 4
                y = crawl.random2(y2 - y1 - 7) + y1 + 4
            until dgn.grid(x, y) ~= wall or
                  dgn.grid(x-1, y) ~= wall or
                  dgn.grid(x+1, y) ~= wall or
                  dgn.grid(x, y-1) ~= wall or
                  dgn.grid(x, y+1) ~= wall or
                  dgn.grid(x-2, y) ~= wall or
                  dgn.grid(x+2, y) ~= wall or
                  dgn.grid(x, y-2) ~= wall or
                  dgn.grid(x, y+2) ~= wall
            -- convenience function
            function replace_grid(x, y, search, replace)
                if dgn.grid(x, y) == search then
                    dgn.grid(x, y, replace)
                end
            end
            replace_grid(x, y, wall, floor)
            replace_grid(x, y-1, wall, floor)
            replace_grid(x, y+1, wall, floor)
            replace_grid(x-1, y, wall, floor)
            replace_grid(x+1, y, wall, floor)
            if boxy then
                replace_grid(x-1, y-1, wall, floor)
                replace_grid(x+1, y+1, wall, floor)
                replace_grid(x-1, y+1, wall, floor)
                replace_grid(x+1, y-1, wall, floor)
            end
        end
    end
    -- randomly extends walls onto floors
    function smear_feature(iterations, boxy, feature, x1, y1, x2, y2)
        for i = 1, iterations do
            local x, y
            function check_box(x, y, feature)
                return dgn.grid(x+1, y) == feature or
                    dgn.grid(x-1, y) == feature or
                    dgn.grid(x, y+1) == feature or
                    dgn.grid(x, y-1) == feature
            end
            function check_diagonal(x, y, feature)
                return dgn.grid(x+1, y+1) == feature or
                    dgn.grid(x-1, y+1) == feature or
                    dgn.grid(x-1, y-1) == feature or
                    dgn.grid(x+1, y-1) == feature
            end
            repeat
                x = crawl.random2(x2 - x1 - 2) + x1 + 1
                y = crawl.random2(y2 - y1 - 2) + y1 + 1
            until dgn.grid(x, y) ~= feature and
                  (check_box(x, y, feature) or 
                  not boxy and check_diagonal(x, y, feature))
            dgn.grid(x, y, feature)
        end
    end
}}
##############################################################
# layout_forbidden_doughnut
#
# This replaces dungeon.cc:_plan_1().  It usually creates a
# room with a large hole in the middle.
#
NAME:   layout_forbidden_donut
ORIENT: encompass
TAGS:   layout allow_dup
{{
    local gxm, gym = dgn.max_bounds()
    local wall = dgn.feature_number("rock_wall")
    local floor = dgn.feature_number("floor")
    fill_area(0, 0, gxm - 1, gym - 1, wall)
    local width = (10 - crawl.random2(7))
    -- construct donut
    fill_area(10, 10, gxm - 10, 10 + width, floor)
    fill_area(10, 60 - width, gxm - 10, gym - 10, floor)
    fill_area(10, 10, 10 + width, gym - 10, floor)
    fill_area(60 - width, 10, gxm - 10, gym - 10, floor)
    local spotty = crawl.coinflip()
    local smears = crawl.random2(300)
    -- sometimes add a hallway cross through center
    if crawl.coinflip() then
        local width2 = 1 + crawl.random2(5)
        fill_area(10, gym/2 - width2, gxm - 10, gym/2 + width2, floor)
        fill_area(gxm/2 - width2, 10, gxm/2 + width2, gym - 10, floor)
        -- sometimes add a small octagon room
        if crawl.coinflip() and crawl.random2(15) > 7 then
            local oblique = 0
            if crawl.coinflip() then
                oblique = 5 + crawl.random2(20)
            end
            local feature_name = select_from_weighted_table({
                ["floor"]      = 5,
                ["deep_water"] = 1,
                ["lava"]       = 1,
            })
            local feature_idx = dgn.feature_number(feature_name)
            octa_room(25, 25, gxm - 25, gym - 25, oblique, feature_idx)
            -- decrease spotty chance
            spotty = crawl.one_chance_in(5)
        end
    end
    local spotty_boxy = crawl.coinflip()
    local smear_boxy = crawl.coinflip()
    if spotty then
        spotty_level(spotty_boxy, 0, 0, gxm - 1, gym - 1)
    end
    if not spotty and crawl.one_chance_in(4) or spotty then
        smear_feature(smears, smear_boxy, wall, 0, 0, gxm - 1, gym - 1)
    end

MAP
ENDMAP

    -- TODO enne - add lua function for spotty()

    if not crawl.one_chance_in(4) then
        spotty_level(crawl.coinflip(), 0, 0, gxm - 1, gym - 1)
    end

.

##############################################################

#############################################################

    if crawl.coinflip() then
        local iterations = 100 + crawl.random2(200)
        smear_feature(iterations, false, wall, 0, 0, gxm - 1, gym - 1)
    end

.