fiddlerwoaroof/crawl - Change 754PQVFHYQER7P7NEHYNLQVOEALF6I23IQDNGNCOK5IV7OLAEXRQC

Split builder functions out from l_dgn.cc.

Now sub-2k lines of code.

Created by Robert Vollmert on October 20, 2009

754PQVFHYQER7P7NEHYNLQVOEALF6I23IQDNGNCOK5IV7OLAEXRQC

Dependencies

In channels

main

Change contents

Insertion in crawl-ref/source/makefile.obj at line 43 [5.79]
[3.2945]
[4.2830]
```
l_dgnbld.o \
```
Insertion in crawl-ref/source/l_libs.h at line 17 [6.2907]
[6.3009]
[7.2859]
```
extern const struct luaL_reg dgn_build_lib[];
```
Insertion in crawl-ref/source/l_libs.h at line 80 [6.2907]
[2.2968]
[8.4861]
```
dungeon_feature_type check_lua_feature(lua_State *ls, int idx);
```

File addition: l_dgnbld.cc (----------)

[9.24]

/*
 * File:       l_dgnbld.cc
 * Summary:    Building routines (library "dgn").
 */
#include "AppHdr.h"
#include <cmath>
#include "dlua.h"
#include "l_libs.h"
#include "dungeon.h"
// Return a metatable for a point on the map_lines grid.
static int dgn_grd_table(lua_State *ls)
{
    MAP(ls, 1, map);
    
    map_def **mapref = clua_new_userdata<map_def *>(ls, GRD_METATABLE);
    *mapref = map;
    
    return (1);
}
static int dgn_width(lua_State *ls)
{
    MAP(ls, 1, map);
    
    lua_pushnumber(ls, map->map.width());
    return (1);
}
static int dgn_height(lua_State *ls)
{
    MAP(ls, 1, map);
    
    lua_pushnumber(ls, map->map.height());
    return (1);
}
static void _clamp_to_bounds(int &x, int &y, bool edge_ok = false)
{
    const int edge_offset = edge_ok ? 0 : 1;
    x = std::min(std::max(x, X_BOUND_1 + edge_offset), X_BOUND_2 - edge_offset);
    y = std::min(std::max(y, Y_BOUND_1 + edge_offset), Y_BOUND_2 - edge_offset);
}
    
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 = check_lua_feature(ls, 5);
    
    _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 = check_lua_feature(ls, 5);
    dungeon_feature_type replace = check_lua_feature(ls, 6);
    
    // 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 = check_lua_feature(ls, 6);
    
    spec_room sr;
    sr.tl.x = x1;
    sr.br.x = x2;
    sr.tl.y = y1;
    sr.br.y = 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 = check_lua_feature(ls, 8);
    
    // [enne] The underscore is for DJGPP's brain damage.
    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 = check_lua_feature(ls, 4);
    
    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 = check_lua_feature(ls, 4);
    
    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 = check_lua_feature(ls, 4);
    
    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 = check_lua_feature(ls, 5);
    dungeon_feature_type replace = check_lua_feature(ls, 6);
    
    _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 = check_lua_feature(ls, 1);
    dungeon_feature_type replace = check_lua_feature(ls, 2);
    
    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 = check_lua_feature(ls, 3);
    
    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, true);
    _clamp_to_bounds(x2, y2, true);
    
    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 = check_lua_feature(ls, 5);
    
    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 = check_lua_feature(ls, 5);
    
    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 = check_lua_feature(ls, 3);
    
    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;
}
static int dgn_fill_disconnected_zones(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);
    
    dungeon_feature_type feat = check_lua_feature(ls, 5);
    
    process_disconnected_zones(from_x, from_y, to_x, to_y, true, feat);
    
    return 0;
}
const struct luaL_reg dgn_build_lib[] =
{
{ "grd_table", dgn_grd_table },
{ "width", dgn_width },
{ "height", dgn_height },
{ "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 },
{ "fill_disconnected_zones", dgn_fill_disconnected_zones },
{ NULL, NULL }
};

Replacement in crawl-ref/source/l_dgn_bf.cc at line 2 [10.3071]
B:BD[10.3075] → [10.3075:3100]
```
 * File:      l_dgnbf.cc
```
[10.3075]
[10.3100]
```
 * File:      l_dgn_bf.cc
```

Replacement in crawl-ref/source/l_dgn.cc at line 35 [12.1232]

B:BD[11.4387] → [11.4387:4458]

static dungeon_feature_type _check_lua_feature(lua_State *ls, int idx)

[11.4387]

[11.4458]

dungeon_feature_type check_lua_feature(lua_State *ls, int idx)

Replacement in crawl-ref/source/l_dgn.cc at line 49 [12.1232]
B:BD[11.5174] → [3.4650:4703]
```
dungeon_feature_type f = _check_lua_feature(ls, pos)
```
[11.5174]
[11.5231]
```
dungeon_feature_type f = check_lua_feature(ls, pos)
```

Deletion in crawl-ref/source/l_dgn.cc at line 1458 [12.1232]

B:BD[13.9804] → [14.2633:2635]

B:BD[14.3048] → [14.3048:3049]

B:BD[14.3069] → [15.4379:4446]

∅:D[15.4446] → [14.3114:3116]

B:BD[14.3114] → [14.3114:3116]

B:BD[14.3116] → [15.4447:4654]

∅:D[15.4654] → [14.3230:3233]

B:BD[14.3230] → [14.3230:3233]

B:BD[14.3233] → [16.8579:8699]

B:BD[16.8699] → [3.11194:11199]

∅:D[3.11199] → [16.8700:8791]

B:BD[16.8700] → [16.8700:8791]

B:BD[16.8791] → [3.11200:11205]

∅:D[3.11205] → [16.8792:9063]

B:BD[16.8792] → [16.8792:9063]

∅:D[16.9063] → [14.3233:3415]

B:BD[14.3233] → [14.3233:3415]

B:BD[14.3415] → [11.5584:5643]

B:BD[11.5643] → [3.11206:11211]

∅:D[3.11211] → [14.3568:3716]

B:BD[14.3568] → [14.3568:3716]

B:BD[14.3716] → [3.11212:11217]

∅:D[3.11217] → [14.3717:3821]

B:BD[14.3717] → [14.3717:3821]

B:BD[14.3821] → [3.11218:11223]

∅:D[3.11223] → [14.3822:4024]

B:BD[14.3822] → [14.3822:4024]

B:BD[14.4024] → [11.5644:5767]

B:BD[11.5767] → [3.11224:11229]

∅:D[3.11229] → [14.4339:4551]

B:BD[14.4339] → [14.4339:4551]

B:BD[14.4551] → [3.11230:11235]

∅:D[3.11235] → [14.4552:4700]

B:BD[14.4552] → [14.4552:4700]

B:BD[14.4700] → [3.11236:11241]

∅:D[3.11241] → [14.4701:4940]

B:BD[14.4701] → [14.4701:4940]

B:BD[14.4940] → [11.5768:5827]

B:BD[11.5827] → [3.11242:11247]

∅:D[3.11247] → [14.5093:5111]

B:BD[14.5093] → [14.5093:5111]

B:BD[14.5111] → [17.61262:61334]

B:BD[17.61334] → [3.11248:11253]

∅:D[3.11253] → [14.5176:5210]

B:BD[14.5176] → [14.5176:5210]

B:BD[14.5210] → [3.11254:11259]

∅:D[3.11259] → [14.5211:5520]

B:BD[14.5211] → [14.5211:5520]

B:BD[14.5520] → [11.5828:5887]

B:BD[11.5887] → [3.11260:11265]

∅:D[3.11265] → [18.2836:2929]

B:BD[14.5673] → [18.2836:2929]

∅:D[18.2929] → [14.5707:5747]

B:BD[14.5707] → [14.5707:5747]

B:BD[14.5747] → [18.2930:2978]

∅:D[18.2978] → [14.5794:5944]

B:BD[14.5794] → [14.5794:5944]

B:BD[14.5944] → [3.11266:11275]

∅:D[3.11275] → [14.5945:6136]

B:BD[14.5945] → [14.5945:6136]

B:BD[14.6136] → [3.11276:11285]

∅:D[3.11285] → [14.6137:6171]

B:BD[14.6137] → [14.6137:6171]

B:BD[14.6171] → [3.11286:11291]

∅:D[3.11291] → [14.6172:6364]

B:BD[14.6172] → [14.6172:6364]

B:BD[14.6364] → [11.5888:5947]

B:BD[11.5947] → [3.11292:11297]

∅:D[3.11297] → [14.6517:6661]

B:BD[14.6517] → [14.6517:6661]

B:BD[14.6661] → [3.11298:11303]

∅:D[3.11303] → [14.6662:6862]

B:BD[14.6662] → [14.6662:6862]

B:BD[14.6862] → [11.5948:6007]

B:BD[11.6007] → [3.11304:11309]

∅:D[3.11309] → [14.7015:7227]

B:BD[14.7015] → [14.7015:7227]

B:BD[14.7227] → [3.11310:11315]

∅:D[3.11315] → [14.7228:7420]

B:BD[14.7228] → [14.7228:7420]

B:BD[14.7420] → [11.6008:6067]

B:BD[11.6067] → [3.11316:11321]

∅:D[3.11321] → [14.7573:7770]

B:BD[14.7573] → [14.7573:7770]

B:BD[14.7770] → [3.11322:11327]

∅:D[3.11327] → [14.7771:7898]

B:BD[14.7771] → [14.7771:7898]

B:BD[14.7898] → [3.11328:11333]

∅:D[3.11333] → [14.7899:8142]

B:BD[14.7899] → [14.7899:8142]

B:BD[14.8142] → [11.6068:6191]

B:BD[11.6191] → [3.11334:11339]

∅:D[3.11339] → [14.8529:8746]

B:BD[14.8529] → [14.8529:8746]

B:BD[14.8746] → [3.11340:11349]

∅:D[3.11349] → [14.8747:8787]

B:BD[14.8747] → [14.8747:8787]

B:BD[14.8787] → [3.11350:11355]

∅:D[3.11355] → [14.8788:8884]

B:BD[14.8788] → [14.8788:8884]

B:BD[14.8884] → [11.6192:6315]

B:BD[11.6315] → [3.11356:11361]

∅:D[3.11361] → [14.9199:9317]

B:BD[14.9199] → [14.9199:9317]

B:BD[14.9317] → [3.11362:11367]

∅:D[3.11367] → [14.9318:9343]

B:BD[14.9318] → [14.9318:9343]

B:BD[14.9343] → [3.11368:11373]

∅:D[3.11373] → [14.9344:9527]

B:BD[14.9344] → [14.9344:9527]

B:BD[14.9527] → [3.11374:11379]

∅:D[3.11379] → [14.9528:9716]

B:BD[14.9528] → [14.9528:9716]

B:BD[14.9716] → [11.6316:6375]

B:BD[11.6375] → [3.11380:11385]

∅:D[3.11385] → [14.9869:10009]

B:BD[14.9869] → [14.9869:10009]

B:BD[14.10009] → [3.11386:11391]

∅:D[3.11391] → [15.4655:4727]

B:BD[14.10010] → [15.4655:4727]

B:BD[15.4727] → [3.11392:11397]

∅:D[3.11397] → [14.10071:10130]

B:BD[14.10071] → [14.10071:10130]

B:BD[14.10130] → [3.11398:11403]

∅:D[3.11403] → [14.10131:10341]

B:BD[14.10131] → [14.10131:10341]

B:BD[14.10341] → [11.6376:6435]

B:BD[11.6435] → [3.11404:11409]

∅:D[3.11409] → [19.24791:24859]

B:BD[14.10519] → [19.24791:24859]

∅:D[19.24859] → [14.10588:10802]

B:BD[14.10588] → [14.10588:10802]

B:BD[14.10802] → [11.6436:6495]

B:BD[11.6495] → [3.11410:11415]

∅:D[3.11415] → [19.24860:24932]

B:BD[14.10980] → [19.24860:24932]

∅:D[19.24932] → [14.11053:11187]

B:BD[14.11053] → [14.11053:11187]

B:BD[14.11187] → [11.6496:6555]

B:BD[11.6555] → [3.11416:11421]

∅:D[3.11421] → [19.24933:24987]

B:BD[14.11365] → [19.24933:24987]

∅:D[19.24987] → [14.11420:11756]

B:BD[14.11420] → [14.11420:11756]

B:BD[14.11756] → [3.11422:11427]

∅:D[3.11427] → [14.11757:11823]

B:BD[14.11757] → [14.11757:11823]

B:BD[14.11823] → [3.11428:11433]

∅:D[3.11433] → [14.11824:11916]

B:BD[14.11824] → [14.11824:11916]

B:BD[14.11916] → [3.11434:11439]

∅:D[3.11439] → [14.11917:11931]

B:BD[14.11917] → [14.11917:11931]

B:BD[14.11931] → [20.2638:2849]

B:BD[20.2849] → [3.11440:11445]

∅:D[3.11445] → [11.6556:6615]

B:BD[20.2850] → [11.6556:6615]

B:BD[11.6615] → [3.11446:11451]

∅:D[3.11451] → [20.3003:3075]

B:BD[20.3003] → [20.3003:3075]

B:BD[20.3075] → [3.11452:11457]

∅:D[3.11457] → [20.3076:3090]

B:BD[20.3076] → [20.3076:3090]

}
static void _clamp_to_bounds(int &x, int &y, bool edge_ok = false)
{
    const int edge_offset = edge_ok ? 0 : 1;
    x = std::min(std::max(x, X_BOUND_1 + edge_offset), X_BOUND_2 - edge_offset);
    y = std::min(std::max(y, Y_BOUND_1 + edge_offset), Y_BOUND_2 - edge_offset);
}
// Return a metatable for a point on the map_lines grid.
static int dgn_grd_table(lua_State *ls)
{
    MAP(ls, 1, map);
    
    map_def **mapref = clua_new_userdata<map_def *>(ls, GRD_METATABLE);
    *mapref = map;
    
    return (1);
}
static int dgn_width(lua_State *ls)
{
    MAP(ls, 1, map);
    
    lua_pushnumber(ls, map->map.width());
    return (1);
}
static int dgn_height(lua_State *ls)
{
    MAP(ls, 1, map);
    
    lua_pushnumber(ls, map->map.height());
    return (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 = _check_lua_feature(ls, 5);
    
    _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 = _check_lua_feature(ls, 5);
    dungeon_feature_type replace = _check_lua_feature(ls, 6);
    
    // 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 = _check_lua_feature(ls, 6);
    
    spec_room sr;
    sr.tl.x = x1;
    sr.br.x = x2;
    sr.tl.y = y1;
    sr.br.y = 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 = _check_lua_feature(ls, 8);
    
    // [enne] The underscore is for DJGPP's brain damage.
    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 = _check_lua_feature(ls, 4);
    
    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 = _check_lua_feature(ls, 4);
    
    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 = _check_lua_feature(ls, 4);
    
    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 = _check_lua_feature(ls, 5);
    dungeon_feature_type replace = _check_lua_feature(ls, 6);
    
    _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 = _check_lua_feature(ls, 1);
    dungeon_feature_type replace = _check_lua_feature(ls, 2);
    
    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 = _check_lua_feature(ls, 3);
    
    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, true);
    _clamp_to_bounds(x2, y2, true);
    
    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 = _check_lua_feature(ls, 5);
    
    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 = _check_lua_feature(ls, 5);
    
    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 = _check_lua_feature(ls, 3);
    
    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;
}
static int dgn_fill_disconnected_zones(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);
    
    dungeon_feature_type feat = _check_lua_feature(ls, 5);
    
    process_disconnected_zones(from_x, from_y, to_x, to_y, true, feat);
    
    return 0;

Deletion in crawl-ref/source/l_dgn.cc at line 1845 [12.1232]

∅:D[3.16410] → [21.3435:3436]

B:BD[22.22268] → [21.3435:3436]

B:BD[21.3436] → [3.16411:17232]


// building routines
{ "grd_table", dgn_grd_table },
{ "width", dgn_width },
{ "height", dgn_height },
{ "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 },
{ "fill_disconnected_zones", dgn_fill_disconnected_zones },

Insertion in crawl-ref/source/dlua.cc at line 310 [3.19392]
[3.42078]
[7.4587]
```
    luaL_openlib(dlua, "dgn", dgn_build_lib, 0);
```

Split builder functions out from l_dgn.cc.

Dependencies

In channels

Change contents

Insertion in crawl-ref/source/makefile.obj at line 43 [5.79]

Insertion in crawl-ref/source/l_libs.h at line 17 [6.2907]

Insertion in crawl-ref/source/l_libs.h at line 80 [6.2907]

File addition: l_dgnbld.cc (----------)

Replacement in crawl-ref/source/l_dgn_bf.cc at line 2 [10.3071]

Replacement in crawl-ref/source/l_dgn.cc at line 35 [12.1232]

Replacement in crawl-ref/source/l_dgn.cc at line 49 [12.1232]

Deletion in crawl-ref/source/l_dgn.cc at line 1458 [12.1232]

Deletion in crawl-ref/source/l_dgn.cc at line 1845 [12.1232]

Insertion in crawl-ref/source/dlua.cc at line 310 [3.19392]