fiddlerwoaroof/crawl - Change PRG7UT7G56GT4W3FQ3KG5JRPGMKKJBFDLVHDLYFQK6IZW25JQLBQC

Pushing some dungeon-related lua functions back into C++.

git-svn-id: https://crawl-ref.svn.sourceforge.net/svnroot/crawl-ref/trunk@5176 c06c8d41-db1a-0410-9941-cceddc491573

Created by ennewalker on May 22, 2008

PRG7UT7G56GT4W3FQ3KG5JRPGMKKJBFDLVHDLYFQK6IZW25JQLBQC

Dependencies

In channels

main

Change contents

Insertion in crawl-ref/source/luadgn.cc at line 13 [5.1232]
[3.12910]
[4.73720]
```
#include <cmath>
```

Insertion in crawl-ref/source/luadgn.cc at line 1670 [5.1232]

[6.9804]

}
static dungeon_feature_type _get_lua_feature(lua_State *ls, int idx)
{
    dungeon_feature_type feat = (dungeon_feature_type)0;
    if (lua_isnumber(ls, idx))
        feat = (dungeon_feature_type)luaL_checkint(ls, idx);
    else if (lua_isstring(ls, idx))
        feat = dungeon_feature_by_name(luaL_checkstring(ls, idx));
    else
        luaL_argerror(ls, idx, "Feature must be a string or a feature index.");
    return feat;
}
static void _clamp_to_bounds(int &x, int &y)
{
    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);
}
static int dgn_fill_area(lua_State *ls)
{
    int x1 = luaL_checkint(ls, 1);
    int y1 = luaL_checkint(ls, 2);
    int x2 = luaL_checkint(ls, 3);
    int y2 = luaL_checkint(ls, 4);
    dungeon_feature_type feat = _get_lua_feature(ls, 5);
    if (!feat)
    {
        luaL_argerror(ls, 5, "Invalid feature.");
        return 0;
    }
    _clamp_to_bounds(x1, y1);
    _clamp_to_bounds(x2, y2);
    if (x2 < x1)
        std::swap(x1, x2);
    if (y2 < y1)
        std::swap(y1, y2);
    for (int y = y1; y <= y2; y++)
        for (int x = x1; x <= x2; x++)
            grd[x][y] = feat;
    return 0;
}
static int dgn_replace_area(lua_State *ls)
{
    int x1 = luaL_checkint(ls, 1);
    int y1 = luaL_checkint(ls, 2);
    int x2 = luaL_checkint(ls, 3);
    int y2 = luaL_checkint(ls, 4);
    dungeon_feature_type search = _get_lua_feature(ls, 5);
    if (!search)
    {
        luaL_argerror(ls, 5, "Invalid feature.");
        return 0;
    }
    dungeon_feature_type replace = _get_lua_feature(ls, 6);
    if (!replace)
    {
        luaL_argerror(ls, 6, "Invalid feature.");
        return 0;
    }
    // gracefully handle out of bound areas by truncating them.
    _clamp_to_bounds(x1, y1);
    _clamp_to_bounds(x2, y2);
    if (x2 < x1)
        std::swap(x1, x2);
    if (y2 < y1)
        std::swap(y1, y2);
    for (int y = y1; y <= y2; y++)
        for (int x = x1; x <= x2; x++)
            if (grd[x][y] == search)
                grd[x][y] = replace;
    return 0;
}
static int dgn_octa_room(lua_State *ls)
{
    int x1 = luaL_checkint(ls, 1);
    int y1 = luaL_checkint(ls, 2);
    int x2 = luaL_checkint(ls, 3);
    int y2 = luaL_checkint(ls, 4);
    int oblique = luaL_checkint(ls, 5);
    dungeon_feature_type fill = _get_lua_feature(ls, 6);
    if (!fill)
    {
        luaL_argerror(ls, 6, "Invalid feature.");
        return 0;
    }
    spec_room sr;
    sr.x1 = x1;
    sr.x2 = x2;
    sr.y1 = y1;
    sr.y2 = y2;
    octa_room(sr, oblique, fill);
    return 0;
}
static int dgn_make_pillars(lua_State *ls)
{
    int center_x = luaL_checkint(ls, 1);
    int center_y = luaL_checkint(ls, 2);
    int num = luaL_checkint(ls, 3);
    int scale_x = luaL_checkint(ls, 4);
    int big_radius = luaL_checkint(ls, 5);
    int pillar_radius = luaL_checkint(ls, 6);
    dungeon_feature_type fill = _get_lua_feature(ls, 8);
    if (!fill)
    {
        luaL_argerror(ls, 8, "Invalid feature.");
        return 0;
    }
    const float PI = 3.14159265f;
    for (int n = 0; n < num; n++)
    {
        float angle = n * 2 * PI / (float)num;
        int x = (int)std::floor(std::cos(angle) * big_radius * scale_x + 0.5f);
        int y = (int)std::floor(std::sin(angle) * big_radius + 0.5f);
        lua_pushvalue(ls, 7);
        lua_pushnumber(ls, center_x + x);
        lua_pushnumber(ls, center_y + y);
        lua_pushnumber(ls, pillar_radius);
        lua_pushnumber(ls, fill);
        lua_call(ls, 4, 0);
    }
    return 0;
}
static int dgn_make_square(lua_State *ls)
{
    int center_x = luaL_checkint(ls, 1);
    int center_y = luaL_checkint(ls, 2);
    int radius = std::abs(luaL_checkint(ls, 3));
    dungeon_feature_type fill = _get_lua_feature(ls, 4);
    if (!fill)
    {
        luaL_argerror(ls, 4, "Invalid feature.");
        return 0;
    }
    for (int x = -radius; x <= radius; x++)
        for (int y = -radius; y <= radius; y++)
            grd[center_x + x][center_y + y] = fill;
    return 0;
}
static int dgn_make_rounded_square(lua_State *ls)
{
    int center_x = luaL_checkint(ls, 1);
    int center_y = luaL_checkint(ls, 2);
    int radius = std::abs(luaL_checkint(ls, 3));
    dungeon_feature_type fill = _get_lua_feature(ls, 4);
    if (!fill)
    {
        luaL_argerror(ls, 4, "Invalid feature.");
        return 0;
    }
    for (int x = -radius; x <= radius; x++)
        for (int y = -radius; y <= radius; y++)
            if (std::abs(x) != radius || std::abs(y) != radius)
                grd[center_x + x][center_y + y] = fill;
    return 0;
}
static int dgn_make_circle(lua_State *ls)
{
    int center_x = luaL_checkint(ls, 1);
    int center_y = luaL_checkint(ls, 2);
    int radius = std::abs(luaL_checkint(ls, 3));
    dungeon_feature_type fill = _get_lua_feature(ls, 4);
    if (!fill)
    {
        luaL_argerror(ls, 4, "Invalid feature.");
        return 0;
    }
    for (int x = -radius; x <= radius; x++)
        for (int y = -radius; y <= radius; y++)
            if (x * x + y * y < radius * radius)
                grd[center_x + x][center_y + y] = fill;
    return 0;
}
static int dgn_in_bounds(lua_State *ls)
{
    int x = luaL_checkint(ls, 1);
    int y = luaL_checkint(ls, 2);
    lua_pushboolean(ls, in_bounds(x, y));
    return 1;
}
static int dgn_replace_first(lua_State *ls)
{
    int x = luaL_checkint(ls, 1);
    int y = luaL_checkint(ls, 2);
    int dx = luaL_checkint(ls, 3);
    int dy = luaL_checkint(ls, 4);
    dungeon_feature_type search = _get_lua_feature(ls, 5);
    if (!search)
    {
        luaL_argerror(ls, 5, "Invalid feature.");
        lua_pushboolean(ls, false);
        return 1;
    }
    dungeon_feature_type replace = _get_lua_feature(ls, 6);
    if (!replace)
    {
        luaL_argerror(ls, 6, "Invalid feature.");
        lua_pushboolean(ls, false);
        return 1;
    }
    _clamp_to_bounds(x, y);
    bool found = false;
    while (in_bounds(x, y))
    {
        if (grd[x][y] == search)
        {
            grd[x][y] = replace;
            found = true;
            break;
        }
        x += dx;
        y += dy;
    }
    lua_pushboolean(ls, found);
    return 1;
}
static int dgn_replace_random(lua_State *ls)
{
    dungeon_feature_type search = _get_lua_feature(ls, 1);
    if (!search)
    {
        luaL_argerror(ls, 1, "Invalid feature.");
        return 0;
    }
    dungeon_feature_type replace = _get_lua_feature(ls, 2);
    if (!replace)
    {
        luaL_argerror(ls, 2, "Invalid feature.");
        return 0;
    }
    int x, y;
    do
    {
        x = random2(GXM);
        y = random2(GYM);
    }
    while (grd[x][y] != search);
    grd[x][y] = replace;
    return 0;
}
static int dgn_spotty_level(lua_State *ls)
{
    bool seeded = lua_toboolean(ls, 1);
    int iterations = luaL_checkint(ls, 2);
    bool boxy = lua_toboolean(ls, 3);
    spotty_level(seeded, iterations, boxy);
    return 0;
}
static int dgn_smear_feature(lua_State *ls)
{
    int iterations = luaL_checkint(ls, 1);
    bool boxy = lua_toboolean(ls, 2);
    dungeon_feature_type feat = _get_lua_feature(ls, 3);
    if (!feat)
    {
        luaL_argerror(ls, 3, "Invalid feature.");
        return 0;
    }
    int x1 = luaL_checkint(ls, 4);
    int y1 = luaL_checkint(ls, 5);
    int x2 = luaL_checkint(ls, 6);
    int y2 = luaL_checkint(ls, 7);
    _clamp_to_bounds(x1, y1);
    _clamp_to_bounds(x2, y2);
    smear_feature(iterations, boxy, feat, x1, y1, x2, y2);
    return 0;
}
static int dgn_count_feature_in_box(lua_State *ls)
{
    int x1 = luaL_checkint(ls, 1);
    int y1 = luaL_checkint(ls, 2);
    int x2 = luaL_checkint(ls, 3);
    int y2 = luaL_checkint(ls, 4);
    dungeon_feature_type feat = _get_lua_feature(ls, 5);
    if (!feat)
    {
        luaL_argerror(ls, 5, "Invalid feature.");
        lua_pushnil(ls);
        return 1;
    }
    lua_pushnumber(ls, count_feature_in_box(x1, y1, x2, y2, feat)); 
    return 1;
}
static int dgn_count_antifeature_in_box(lua_State *ls)
{
    int x1 = luaL_checkint(ls, 1);
    int y1 = luaL_checkint(ls, 2);
    int x2 = luaL_checkint(ls, 3);
    int y2 = luaL_checkint(ls, 4);
    dungeon_feature_type feat = _get_lua_feature(ls, 5);
    if (!feat)
    {
        luaL_argerror(ls, 5, "Invalid feature.");
        lua_pushnil(ls);
        return 1;
    }
    lua_pushnumber(ls, count_antifeature_in_box(x1, y1, x2, y2, feat)); 
    return 1;
}
static int dgn_count_neighbours(lua_State *ls)
{
    int x = luaL_checkint(ls, 1);
    int y = luaL_checkint(ls, 2);
    dungeon_feature_type feat = _get_lua_feature(ls, 3);
    if (!feat)
    {
        luaL_argerror(ls, 3, "Invalid feature.");
        lua_pushnil(ls);
        return 1;
    }
    lua_pushnumber(ls, count_neighbours(x, y, feat)); 
    return 1;
}
static int dgn_join_the_dots(lua_State *ls)
{
    int from_x = luaL_checkint(ls, 1);
    int from_y = luaL_checkint(ls, 2);
    int to_x = luaL_checkint(ls, 3);
    int to_y = luaL_checkint(ls, 4);
    // TODO enne - push map masks to lua?
    unsigned map_mask = MMT_VAULT;
    bool early_exit = lua_toboolean(ls, 5);
    coord_def from(from_x, from_y);
    coord_def to(to_x, to_y);
    bool ret = join_the_dots(from, to, map_mask, early_exit);
    lua_pushboolean(ls, ret);
    return 1;

Replacement in crawl-ref/source/luadgn.cc at line 2101 [5.1232]

B:BD[7.18126] → [8.106229:106286]

    { "num_matching_markers", dgn_num_matching_markers},

[7.18126]

    { "num_matching_markers", dgn_num_matching_markers },

Replacement in crawl-ref/source/luadgn.cc at line 2106 [5.1232]

B:BD[8.106383] → [8.106383:106491]

B:BD[8.106491] → [9.7047:7382]

B:BD[9.7382] → [6.9808:9896]

    { "change_level_flags", dgn_change_level_flags},
    { "change_branch_flags", dgn_change_branch_flags},
    { "get_floor_colour", dgn_get_floor_colour},
    { "get_rock_colour",  dgn_get_rock_colour},
    { "change_floor_colour", dgn_change_floor_colour},
    { "change_rock_colour",  dgn_change_rock_colour},
    { "set_lt_callback", lua_dgn_set_lt_callback},
    { "fixup_stairs", dgn_fixup_stairs},
    { "floor_halo", dgn_floor_halo},
    { "random_walk", dgn_random_walk},
    { "apply_area_cloud", dgn_apply_area_cloud},

[8.106383]

[8.106491]

    { "change_level_flags", dgn_change_level_flags },
    { "change_branch_flags", dgn_change_branch_flags },
    { "get_floor_colour", dgn_get_floor_colour },
    { "get_rock_colour",  dgn_get_rock_colour },
    { "change_floor_colour", dgn_change_floor_colour },
    { "change_rock_colour",  dgn_change_rock_colour },
    { "set_lt_callback", lua_dgn_set_lt_callback },
    { "fixup_stairs", dgn_fixup_stairs },
    { "floor_halo", dgn_floor_halo },
    { "random_walk", dgn_random_walk },
    { "apply_area_cloud", dgn_apply_area_cloud },
    // building routines
    { "fill_area", dgn_fill_area },
    { "replace_area", dgn_replace_area },
    { "octa_room", dgn_octa_room },
    { "make_pillars", dgn_make_pillars },
    { "make_square", dgn_make_square },
    { "make_rounded_square", dgn_make_rounded_square },
    { "make_circle", dgn_make_circle },
    { "in_bounds", dgn_in_bounds },
    { "replace_first", dgn_replace_first },
    { "replace_random", dgn_replace_random },
    { "spotty_level", dgn_spotty_level },
    { "smear_feature", dgn_smear_feature },
    { "count_feature_in_box", dgn_count_feature_in_box },
    { "count_antifeature_in_box", dgn_count_antifeature_in_box },
    { "count_neighbours", dgn_count_neighbours },
    { "join_the_dots", dgn_join_the_dots },

Insertion in crawl-ref/source/dungeon.h at line 343 [11.3428186]

[10.3106]

[11.3429755]

struct spec_room
{
    bool created;
    bool hooked_up;
    int x1;
    int y1;
    int x2;
    int y2;
    spec_room() : created(false), hooked_up(false), x1(0), y1(0), x2(0), y2(0)
    {
    }
};
bool join_the_dots(const coord_def &from, const coord_def &to,
                   unsigned mmask, bool early_exit = false);
void spotty_level(bool seeded, int iterations, bool boxy);
void smear_feature(int iterations, bool boxy, dungeon_feature_type feature,
                   int x1, int y1, int x2, int y2);
bool octa_room(spec_room &sr, int oblique_max,
               dungeon_feature_type type_floor);
int count_feature_in_box(int x0, int y0, int x1, int y1,
                         dungeon_feature_type feat);
int count_antifeature_in_box(int x0, int y0, int x1, int y1,
                             dungeon_feature_type feat);
int count_neighbours(int x, int y, dungeon_feature_type feat);

Deletion in crawl-ref/source/dungeon.cc at line 84 [11.3429798]
B:BD[12.948662] → [12.948662:948665]
∅:D[12.948665] → [11.3431301:3431302]
B:BD[11.3431301] → [11.3431301:3431302]
B:BD[11.3431302] → [13.3198:3215]
∅:D[13.3215] → [14.84763:84765]
B:BD[14.84763] → [14.84763:84765]
∅:D[14.84765] → [11.3431318:3431404]
B:BD[11.3431318] → [11.3431318:3431404]
B:BD[11.3431404] → [13.3216:3308]
```
};
struct spec_room
{
    bool created;
    bool hooked_up;
    int x1;
    int y1;
    int x2;
    int y2;
    spec_room() : created(false), hooked_up(false), x1(0), y1(0), x2(0), y2(0)
    {
    }
```

Deletion in crawl-ref/source/dungeon.cc at line 144 [11.3429798]

B:BD[15.8724] → [15.8724:8864]

static bool _join_the_dots(const coord_def &from, const coord_def &to,
                           unsigned mmask, bool early_exit = false);

Deletion in crawl-ref/source/dungeon.cc at line 152 [11.3429798]
B:BD[11.3433466] → [15.9224:9291]
```
static void _spotty_level(bool seeded, int iterations, bool boxy);
```

Deletion in crawl-ref/source/dungeon.cc at line 161 [11.3429798]

B:BD[15.9646] → [15.9646:9758]

static bool _octa_room(spec_room &sr, int oblique_max,
                       dungeon_feature_type type_floor);

Replacement in crawl-ref/source/dungeon.cc at line 1390 [11.3429798]

B:BD[16.5670] → [15.17479:17604]

static int _count_feature_in_box(int x0, int y0, int x1, int y1,
                                 dungeon_feature_type feat)

[16.5670]

[16.5786]

int count_feature_in_box(int x0, int y0, int x1, int y1,
                         dungeon_feature_type feat)

Replacement in crawl-ref/source/dungeon.cc at line 1404 [11.3429798]

B:BD[17.8319] → [15.17615:17748]

static int _count_antifeature_in_box(int x0, int y0, int x1, int y1,
                                     dungeon_feature_type feat)

[17.8319]

[17.8450]

int count_antifeature_in_box(int x0, int y0, int x1, int y1,
                             dungeon_feature_type feat)

Replacement in crawl-ref/source/dungeon.cc at line 1407 [11.3429798]

B:BD[17.8452] → [15.17749:17819]

    return (x1-x0)*(y1-y0) - _count_feature_in_box(x0,y0,x1,y1,feat);

[17.8452]

[17.8521]

    return (x1-x0)*(y1-y0) - count_feature_in_box(x0,y0,x1,y1,feat);

Replacement in crawl-ref/source/dungeon.cc at line 1413 [11.3429798]

B:BD[17.8659] → [15.17891:17951]

    return _count_feature_in_box(x-1, y-1, x+2, y+2, feat);

[17.8659]

[16.5970]

    return count_feature_in_box(x-1, y-1, x+2, y+2, feat);

Replacement in crawl-ref/source/dungeon.cc at line 1995 [11.3429798]

B:BD[11.3558410] → [15.21413:21470]

        _spotty_level(false, 100 + random2(500), false);

[11.3558410]

[18.4351]

        spotty_level(false, 100 + random2(500), false);

Replacement in crawl-ref/source/dungeon.cc at line 2115 [11.3429798]
B:BD[11.3560437] → [15.22159:22208]
```
            _spotty_level(false, 0, coinflip());
```
[11.3560437]
[18.4650]
```
            spotty_level(false, 0, coinflip());
```

Replacement in crawl-ref/source/dungeon.cc at line 3723 [11.3429798]

B:BD[19.150629] → [15.28738:28812]

            if (_join_the_dots(c, myroom.random_edge_point(), MMT_VAULT))

[19.150629]

[20.230]

            if (join_the_dots(c, myroom.random_edge_point(), MMT_VAULT))

Replacement in crawl-ref/source/dungeon.cc at line 4013 [11.3429798]
B:BD[13.7714] → [15.31235:31286]
```
        _join_the_dots(p, floor, MMT_VAULT, true);
```
[13.7714]
[21.5378]
```
        join_the_dots(p, floor, MMT_VAULT, true);
```

Replacement in crawl-ref/source/dungeon.cc at line 5050 [11.3429798]

B:BD[22.3355] → [15.36737:36872]

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

[22.3355]

[19.156016]

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

Replacement in crawl-ref/source/dungeon.cc at line 5184 [11.3429798]

B:BD[11.3615730] → [15.37127:37197]

        if ( _count_antifeature_in_box(i, j, k, l, DNGN_FLOOR) == 0 )

[11.3615730]

[11.3615915]

        if ( count_antifeature_in_box(i, j, k, l, DNGN_FLOOR) == 0 )

Replacement in crawl-ref/source/dungeon.cc at line 5316 [11.3429798]

B:BD[11.3637873] → [15.37379:37455]

        const int numfloors = _count_feature_in_box(px-2, py-2, px+3, py+3,

[11.3637873]

[15.37455]

        const int numfloors = count_feature_in_box(px-2, py-2, px+3, py+3,

Replacement in crawl-ref/source/dungeon.cc at line 5319 [11.3429798]

B:BD[17.9494] → [15.37521:37824]

            _count_feature_in_box(px-2, py-2, px+3, py+3, DNGN_ROCK_WALL) +
            _count_feature_in_box(px-2, py-2, px+3, py+3, DNGN_CLOSED_DOOR) +
            _count_feature_in_box(px-2, py-2, px+3, py+3, DNGN_SECRET_DOOR) +
            _count_feature_in_box(px-2, py-2, px+3, py+3, DNGN_FLOOR);

[17.9494]

[11.3637948]

            count_feature_in_box(px-2, py-2, px+3, py+3, DNGN_ROCK_WALL) +
            count_feature_in_box(px-2, py-2, px+3, py+3, DNGN_CLOSED_DOOR) +
            count_feature_in_box(px-2, py-2, px+3, py+3, DNGN_SECRET_DOOR) +
            count_feature_in_box(px-2, py-2, px+3, py+3, DNGN_FLOOR);

Replacement in crawl-ref/source/dungeon.cc at line 5608 [11.3429798]
B:BD[11.3643886] → [15.38387:38453]
```
static void _spotty_level(bool seeded, int iterations, bool boxy)
```
[11.3643886]
[11.3643951]
```
void spotty_level(bool seeded, int iterations, bool boxy)
```

Insertion in crawl-ref/source/dungeon.cc at line 5701 [11.3429798]

[11.3646941]


void smear_feature(int iterations, bool boxy, dungeon_feature_type feature,
                   int x1, int y1, int x2, int y2)
{
    for (int i = 0; i < iterations; i++)
    {
        int x, y;
        bool diagonals, straights;
        do
        {
            x = random_range(x1+1, x2-1);
            y = random_range(y1+1, y2-1);
            diagonals = grd[x+1][y+1] == feature ||
                        grd[x-1][y+1] == feature ||
                        grd[x-1][y-1] == feature ||
                        grd[x+1][y-1] == feature;
            straights = grd[x+1][y] == feature ||
                        grd[x-1][y] == feature ||
                        grd[x][y+1] == feature ||
                        grd[x][y-1] == feature;
        }
        while (grd[x][y] == feature || !straights && (boxy || !diagonals));

Insertion in crawl-ref/source/dungeon.cc at line 5726 [11.3429798]
[11.3646942]
[15.38454]
```
        grd[x][y] = feature;
    }
}
```
Replacement in crawl-ref/source/dungeon.cc at line 5792 [11.3429798]
B:BD[11.3648731] → [15.39360:39404]
```
        _spotty_level(true, 0, coinflip());
```
[11.3648731]
[11.3648774]
```
        spotty_level(true, 0, coinflip());
```

Replacement in crawl-ref/source/dungeon.cc at line 5861 [11.3429798]

B:BD[11.3652667] → [15.40676:40750]

        if (exclusive && _count_antifeature_in_box(romx1[which_room] - 1,

[11.3652667]

[15.40750]

        if (exclusive && count_antifeature_in_box(romx1[which_room] - 1,

Replacement in crawl-ref/source/dungeon.cc at line 5885 [11.3429798]

B:BD[11.3653798] → [15.41191:41257]

            _join_the_dots( coord_def(rx1 + random2( rx2 - rx1 ),

[11.3653798]

[15.41257]

            join_the_dots( coord_def(rx1 + random2( rx2 - rx1 ),

Replacement in crawl-ref/source/dungeon.cc at line 5915 [11.3429798]

B:BD[11.3654704] → [15.41525:41596]

                _join_the_dots( coord_def( rx1 + random2( rx2 - rx1 ),

[11.3654704]

[15.41596]

                join_the_dots( coord_def( rx1 + random2( rx2 - rx1 ),

Replacement in crawl-ref/source/dungeon.cc at line 5987 [11.3429798]

B:BD[11.3656995] → [15.42136:42215]

        if (_count_antifeature_in_box(b1x-1, b1y-1, b2x+1, b2y+1, DNGN_FLOOR))

[11.3656995]

[17.10813]

        if (count_antifeature_in_box(b1x-1, b1y-1, b2x+1, b2y+1, DNGN_FLOOR))

Replacement in crawl-ref/source/dungeon.cc at line 6028 [11.3429798]
B:BD[11.3658571] → [15.42346:42392]
```
        _octa_room(sr, oblique_max, feature);
```
[11.3658571]
[11.3658616]
```
        octa_room(sr, oblique_max, feature);
```
Replacement in crawl-ref/source/dungeon.cc at line 6042 [11.3429798]
B:BD[11.3658844] → [15.42416:42440]
```
        _join_the_dots(
```
[11.3658844]
[19.157617]
```
        join_the_dots(
```
Replacement in crawl-ref/source/dungeon.cc at line 6049 [11.3429798]
B:BD[11.3659057] → [15.42441:42487]
```
        _spotty_level(true, 100, coinflip());
```
[11.3659057]
[11.3659102]
```
        spotty_level(true, 100, coinflip());
```

Replacement in crawl-ref/source/dungeon.cc at line 6081 [11.3429798]

B:BD[11.3661134] → [15.43205:43316]

static bool _octa_room(spec_room &sr, int oblique_max,
                       dungeon_feature_type type_floor)

[11.3661134]

[11.3661214]

bool octa_room(spec_room &sr, int oblique_max,
               dungeon_feature_type type_floor)

Replacement in crawl-ref/source/dungeon.cc at line 6774 [11.3429798]
B:BD[11.3675568] → [15.48265:48319]
```
        if (!_octa_room(sr, oblique_max, type_floor))
```
[11.3675568]
[11.3675621]
```
        if (!octa_room(sr, oblique_max, type_floor))
```
Replacement in crawl-ref/source/dungeon.cc at line 6809 [11.3429798]
B:BD[11.3676503] → [15.48361:48410]
```
            _octa_room(sr, oblique, DNGN_FLOOR);
```
[11.3676503]
[11.3676551]
```
            octa_room(sr, oblique, DNGN_FLOOR);
```
Replacement in crawl-ref/source/dungeon.cc at line 6822 [11.3429798]
B:BD[11.3676836] → [15.48411:48456]
```
        _octa_room(sr, oblique, type_floor);
```
[11.3676836]
[11.3676880]
```
        octa_room(sr, oblique, type_floor);
```

Deletion in crawl-ref/source/dat/layout.des at line 8 [23.3573]

B:BD[23.3988] → [23.3988:3996]

B:BD[23.3996] → [2.3104:3178]

∅:D[2.3178] → [23.3996:4177]

B:BD[23.3996] → [23.3996:4177]

B:BD[23.4177] → [2.3179:3233]

∅:D[2.3233] → [23.4232:4389]

B:BD[23.4232] → [23.4232:4389]

B:BD[23.4389] → [2.3234:3344]

∅:D[2.3344] → [23.4389:4518]

B:BD[23.4389] → [23.4389:4518]

B:BD[23.4518] → [2.3345:3386]

∅:D[2.3386] → [23.4560:4580]

B:BD[23.4560] → [23.4560:4580]

B:BD[23.4580] → [2.3387:3485]

∅:D[2.3485] → [23.4655:5278]

B:BD[23.4655] → [23.4655:5278]


lua {{
    -- TODO enne - most of these should probably get moved back into C++
    function fill_area(x1, y1, x2, y2, feature)
        for x = x1, x2 do
            for y = y1, y2 do
                dgn.grid(x, y, feature)
            end
        end
    end
    function octa_room(x1, y1, x2, y2, oblique, fill)
        local ob_temp = oblique
        local rock_wall = dgn.feature_number("rock_wall")
        local shallow_water = dgn.feature_number("shallow_water")
        local deep_water = dgn.feature_number("deep_water")
        local floor = dgn.feature_number("floor")
        for x = x1, x2 do
            for y = y1 + ob_temp, y2 - ob_temp do
                if dgn.grid(x, y) == rock_wall then
                    dgn.grid(x, y, fill)
                end
                if dgn.grid(x, y) == floor and (fill == shallow_water or fill == deep_water) then
                    dgn.grid(x, y, shallow_water)
                end
            end
            if x > x2 - oblique then
                ob_temp = ob_temp + 1
            elseif ob_temp > 0 then
                ob_temp = ob_temp - 1
            end
        end
    end
    function pillars(center_x, center_y, num, flip_x, big_radius, 
                     pillar_radius, pillar_routine, fill)
        for i = 0, num - 1 do
            local angle = i * 2 * math.pi / num
            local x = math.floor(math.cos(angle) * big_radius * flip_x + 0.5)
            local y = math.floor(math.sin(angle) * big_radius + 0.5)

Deletion in crawl-ref/source/dat/layout.des at line 9 [23.3573]

B:BD[23.5279] → [23.5279:7790]

B:BD[23.7790] → [2.3486:6514]

            pillar_routine(center_x + x, center_y + y, pillar_radius, fill)
        end
    end
    -- begin pillar functions
    function pillar_square(center_x, center_y, radius, fill)
        for x = -radius, radius do
            for y = -radius, radius do
                dgn.grid(center_x + x, center_y + y, fill)
            end
        end
    end
    function pillar_rounded_square(center_x, center_y, radius, fill)
        for x = -radius, radius do
            for y = -radius, radius do
                if math.abs(x) ~= radius or math.abs(y) ~= radius then
                    dgn.grid(center_x + x, center_y + y, fill)
                end
            end
        end
    end
    function pillar_circle(center_x, center_y, radius, fill)
        for x = -radius, radius do
            for y = -radius, radius do
                if x * x + y * y < radius * radius then
                    dgn.grid(center_x + x, center_y + y, fill)
                end
            end
        end
    end
    -- end pillar functions
    function select_from_weighted_table(tb)
        local value = nil
        local rollsize = 0
        for temp_val, temp_weight in pairs (tb) do
            if rollsize == 0 then
                value = temp_val
                rollsize = temp_weight
            else
                rollsize = rollsize + temp_weight
                if crawl.random2(rollsize) < temp_weight then
                    value = temp_val
                end
            end
        end
        return value
    end
    -- Randomly selects a grid with feature 'search' and sets it to 'replace'
    function replace_random(search, replace)
        local gxm, gym = dgn.max_bounds()
        local feature = nil, x, y
        while feature ~= search do
            x = crawl.random2(gxm)
            y = crawl.random2(gym)
            feature = dgn.grid(x, y)
        end
        dgn.grid(x, y, replace)
    end
    function valid(x, y)
        local gxm, gym = dgn.max_bounds()
        return (x >= 0 and y >= 0 and x < gxm and y < gym)
    end
    -- Walks from x, y along dx,dy until it finds 'search'
    function replace_first(x, y, dx, dy, search, replace)
        local feature = dgn.grid(x, y)
        while feature ~= search and valid(x,y) do
            x = x + dx
            y = y + dy
            feature = dgn.grid(x, y)
        end
        if valid(x, y) then
            dgn.grid(x, y, replace)
            return true
        else
            return false
        end
    end
    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
}}

Replacement in crawl-ref/source/dat/layout.des at line 23 [23.3573]
B:BD[2.6920] → [2.6920:6964]
```
    fill_area(0, 0, gxm - 1, gym - 1, wall)
```
[2.6920]
[2.6964]
```
    dgn.fill_area(0, 0, gxm - 1, gym - 1, wall)
```

Replacement in crawl-ref/source/dat/layout.des at line 28 [23.3573]

B:BD[2.7031] → [2.7031:7247]

    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)

[2.7031]

[2.7247]

    dgn.fill_area(10, 10, gxm - 10, 10 + width, floor)
    dgn.fill_area(10, 60 - width, gxm - 10, gym - 10, floor)
    dgn.fill_area(10, 10, 10 + width, gym - 10, floor)
    dgn.fill_area(60 - width, 10, gxm - 10, gym - 10, floor)

Replacement in crawl-ref/source/dat/layout.des at line 40 [23.3573]

B:BD[2.7449] → [2.7449:7591]

        fill_area(10, gym/2 - width2, gxm - 10, gym/2 + width2, floor)
        fill_area(gxm/2 - width2, 10, gxm/2 + width2, gym - 10, floor)

[2.7449]

[2.7591]

        dgn.fill_area(10, gym/2 - width2, gxm - 10, gym/2 + width2, floor)
        dgn.fill_area(gxm/2 - width2, 10, gxm/2 + width2, gym - 10, floor)

Replacement in crawl-ref/source/dat/layout.des at line 50 [23.3573]

B:BD[2.7829] → [2.7829:7891]

            local feature_name = select_from_weighted_table({

[2.7829]

[2.7891]

            local feature_name = crawl.random_element({

Replacement in crawl-ref/source/dat/layout.des at line 55 [23.3573]

B:BD[2.8014] → [2.8014:8079]

            local feature_idx = dgn.feature_number(feature_name)

[2.8014]

[2.8079]

            dgn.octa_room(25, 25, gxm - 25, gym - 25, oblique, feature_name)

Deletion in crawl-ref/source/dat/layout.des at line 57 [23.3573]
B:BD[2.8080] → [2.8080:8153]
```
            octa_room(25, 25, gxm - 25, gym - 25, oblique, feature_idx)
```

Replacement in crawl-ref/source/dat/layout.des at line 66 [23.3573]

B:BD[2.8357] → [2.8357:8415]

        spotty_level(spotty_boxy, 0, 0, gxm - 1, gym - 1)

[2.8357]

[2.8415]

        dgn.spotty_level(true, 0, spotty_boxy)

Replacement in crawl-ref/source/dat/layout.des at line 69 [23.3573]

B:BD[2.8483] → [2.8483:8555]

        smear_feature(smears, smear_boxy, wall, 0, 0, gxm - 1, gym - 1)

[2.8483]

[2.8555]

        dgn.smear_feature(smears, smear_boxy, wall, 0, 0, gxm - 1, gym - 1)

Replacement in crawl-ref/source/dat/layout.des at line 108 [23.3573]
B:BD[23.8732] → [23.8732:8772]
```
    fill_area(0, 0, gxm-1, gym-1, wall)
```
[23.8732]
[23.8772]
```
    dgn.fill_area(0, 0, gxm-1, gym-1, wall)
```

Replacement in crawl-ref/source/dat/layout.des at line 113 [23.3573]

B:BD[23.8873] → [23.8873:9185]

        fill_area(10, gym/2 - height - 1, gxm - 10, gym/2 - height - 1, clear)
        fill_area(10, gym/2 + height + 1, gxm - 10, gym/2 + height + 1, clear)
        fill_area(gxm/2 - width - 1, 10, gxm/2 - width - 1, gym - 10, clear)
        fill_area(gxm/2 + width + 1, 10, gxm/2 + width + 1, gym - 10, clear)

[23.8873]

[23.9185]

        dgn.fill_area(10, gym/2 - height - 1, gxm - 10, gym/2 - height - 1, clear)
        dgn.fill_area(10, gym/2 + height + 1, gxm - 10, gym/2 + height + 1, clear)
        dgn.fill_area(gxm/2 - width - 1, 10, gxm/2 - width - 1, gym - 10, clear)
        dgn.fill_area(gxm/2 + width + 1, 10, gxm/2 + width + 1, gym - 10, clear)

Replacement in crawl-ref/source/dat/layout.des at line 120 [23.3573]

B:BD[23.9216] → [23.9216:9348]

    fill_area(10, gym/2 - height, gxm - 10, gym/2 + height, floor)
    fill_area(gxm/2 - width, 10, gxm/2 + width, gym - 10, floor)

[23.9216]

[23.9348]

    dgn.fill_area(10, gym/2 - height, gxm - 10, gym/2 + height, floor)
    dgn.fill_area(gxm/2 - width, 10, gxm/2 + width, gym - 10, floor)

Replacement in crawl-ref/source/dat/layout.des at line 124 [23.3573]

B:BD[2.8615] → [2.8615:8678]

        spotty_level(crawl.coinflip(), 0, 0, gxm - 1, gym - 1)

[2.8615]

[2.8678]

        dgn.spotty_level(true, 0, crawl.coinflip())

Replacement in crawl-ref/source/dat/layout.des at line 149 [23.3573]

B:BD[23.9915] → [23.9915:10047]

    -- Step 1: Create octagon
    fill_area(0, 0, gxm - 1, gym - 1, wall)
    octa_room(10, 10, gxm - 10, gym - 10, oblique, floor)

[23.9915]

[23.10047]

    dgn.fill_area(0, 0, gxm - 1, gym - 1, "rock_wall")
    dgn.octa_room(10, 10, gxm - 10, gym - 10, oblique, "floor")

Replacement in crawl-ref/source/dat/layout.des at line 152 [23.3573]
B:BD[23.10048] → [2.8750:8779]
```
    if crawl.coinflip() then
```
[23.10048]
[2.8779]
```
    if crawl.coinflip() or true then
```

Replacement in crawl-ref/source/dat/layout.des at line 154 [23.3573]

B:BD[2.8831] → [2.8831:8902]

        smear_feature(iterations, false, wall, 0, 0, gxm - 1, gym - 1)

[2.8831]

[2.8902]

        dgn.smear_feature(iterations, false, wall, 0, 0, gxm - 1, gym - 1)

Replacement in crawl-ref/source/dat/layout.des at line 168 [23.3573]

B:BD[23.10366] → [23.10366:10443]

    local fill = dgn.feature_number(select_from_weighted_table(pillar_fill))

[23.10366]

[23.10443]

    local fill = dgn.feature_number(crawl.random_element(pillar_fill))

Replacement in crawl-ref/source/dat/layout.des at line 171 [23.3573]

B:BD[23.10485] → [23.10485:10563]

    local pillar_func = {pillar_circle, pillar_square, pillar_rounded_square}

[23.10485]

[23.10563]

    local pillar_func = {
        dgn.make_circle,
        dgn.make_square,
        dgn.make_rounded_square
    }

Insertion in crawl-ref/source/dat/layout.des at line 185 [23.3573]
[23.10953]
[23.10953]

Replacement in crawl-ref/source/dat/layout.des at line 192 [23.3573]

B:BD[23.11148] → [23.11148:11249]

    pillars(gxm/2, gym/2, num, 1, circle_radius, pillar_radius,
            pillar_func[type], fill)

[23.11148]

[23.11249]

    dgn.make_pillars(gxm/2, gym/2, num, 1, circle_radius, pillar_radius,
                     pillar_func[type], fill)

Replacement in crawl-ref/source/dat/layout.des at line 229 [23.3573]

B:BD[23.12186] → [23.12186:12239]

                replace_random(floor, stair_list[i])

[23.12186]

[23.12239]

                dgn.replace_random(floor, stair_list[i])

Replacement in crawl-ref/source/dat/layout.des at line 233 [23.3573]

B:BD[23.12378] → [23.12378:12449]

                ret = replace_first(gxm/2 + i - 2, 0, 0, 1, floor, st)

[23.12378]

[23.12449]

                ret = dgn.replace_first(gxm/2 + i-2, 0, 0, 1, floor, st)

Replacement in crawl-ref/source/dat/layout.des at line 235 [23.3573]

B:BD[23.12482] → [23.12482:12560]

                ret = replace_first(gxm - 1, gym/2 + i - 2, -1, 0, floor, st)

[23.12482]

[23.12560]

                ret = dgn.replace_first(gxm - 1, gym/2 + i-2, -1, 0, floor, st)

Replacement in crawl-ref/source/dat/layout.des at line 237 [23.3573]

B:BD[23.12593] → [23.12593:12671]

                ret = replace_first(gxm/2 + i - 2, gym - 1, 0, -1, floor, st)

[23.12593]

[23.12671]

                ret = dgn.replace_first(gxm/2 + i-2, gym - 1, 0, -1, floor, st)

Replacement in crawl-ref/source/dat/layout.des at line 239 [23.3573]

B:BD[23.12704] → [23.12704:12775]

                ret = replace_first(0, gym/2 + i - 2, 1, 0, floor, st)

[23.12704]

[23.12775]

                ret = dgn.replace_first(0, gym/2 + i-2, 1, 0, floor, st)

Insertion in crawl-ref/source/clua.cc at line 1985 [26.483969]

[24.939]

[25.3588]


static int crawl_random_element(lua_State *ls)
{
    const int table_idx = 1;
    const int value_idx = 2;
    if (lua_gettop(ls) == 0)
    {
        lua_pushnil(ls);
        return 1;
    }

Insertion in crawl-ref/source/clua.cc at line 1997 [26.483969]

[25.3589]

    // Only the first arg does anything now.  Maybe this should
    // select from a variable number of table args?
    lua_pop(ls, lua_gettop(ls) - 1);
    // Keep max value on the stack, as it could be any type of value.
    lua_pushnil(ls);
    int rollsize = 0;
    lua_pushnil(ls);
    while (lua_next(ls, table_idx) != 0)
    {
        const int weight_idx = -1;
        const int key_idx = -2;
        int this_weight = lua_isnil(ls, weight_idx) ?
            1 : (int)lua_tonumber(ls, weight_idx);
        if (rollsize > 0)
        {
            rollsize += this_weight;
            if (random2(rollsize) < this_weight)
            {
                lua_pushvalue(ls, key_idx);
                lua_replace(ls, value_idx);
            }
        }
        else
        {
            lua_pushvalue(ls, key_idx);
            lua_replace(ls, value_idx);
            rollsize = this_weight;
        }
        lua_pop(ls, 1);
    }
    lua_pushvalue(ls, value_idx);
    return 1;
}

Insertion in crawl-ref/source/clua.cc at line 2080 [26.483969]
[7.37364]
[26.526987]
```
    { "random_element", crawl_random_element },
```