fiddlerwoaroof/crawl - Change YFJLINBBEHE7RBETTARSYNWSO6QJ6MSPXFMSPSH2742QFC3L55SQC

Lua map improvements.

The previous dungeon layout.des functions all apply directly to the grid and so are unsuitable for use in vaults. This aims to correct that by providing lua functions that can manipulate maps (of glyphs).

grd[x][y] in a .des file can now be used to get and set glyphs in the current map. This should allow for less cumbersome map variations than what you can do with just SUBST and SHUFFLE.

To support that, map_def no longer batches up transforms–it applies them all immediately. This resulted in a good bit of refactoring.

FTILE/RTILE map commands now support setting the tile for multiple features at once.

There are also a small number of new lua functions that apply to maps (map_octa_room, map_smear, and map_extend). Ideally, these will eventually replace the existing builder funcs that work on grd.

Created by Enne Walker on October 18, 2009

YFJLINBBEHE7RBETTARSYNWSO6QJ6MSPXFMSPSH2742QFC3L55SQC

Dependencies

In channels

main

Change contents

Replacement in crawl-ref/source/util/levcomp.ypp at line 592 [10.75608]
B:BD[10.81070] → [11.3799:3836]
```
                    lc_map.main.add(
```
[10.81070]
[12.1666]
```
                    lc_map.mapchunk.add(
```
Replacement in crawl-ref/source/maps.h at line 65 [14.2007036]
B:BD[13.370] → [5.2694:2743]
```
const int              MAP_CACHE_VERSION = 1010;
```
[13.370]
[15.228]
```
const int              MAP_CACHE_VERSION = 1011;
```
Deletion in crawl-ref/source/mapdef.h at line 18 [10.591249]
B:BD[10.591553] → [11.5937:5957]
```
#include "luadgn.h"
```
Insertion in crawl-ref/source/mapdef.h at line 20 [10.591249]
[16.139801]
[17.72661]
```
#include "fixary.h"
#include "luadgn.h"
```
Insertion in crawl-ref/source/mapdef.h at line 23 [10.591249]
[17.72683]
[18.2251]
```
#include "stuff.h"
```
Deletion in crawl-ref/source/mapdef.h at line 25 [10.591249]
B:BD[18.2271] → [6.3144:3164]
```
#include "fixary.h"
```
Deletion in crawl-ref/source/mapdef.h at line 104 [10.591249]
B:BD[19.116] → [19.116:148]
B:BD[19.148] → [11.6299:6349]
B:BD[11.6349] → [20.4759:4777]
B:BD[20.4777] → [21.1083:1102]
B:BD[21.1102] → [22.1000:1019]
B:BD[22.1019] → [23.85573:85634]
∅:D[22.1037] → [11.6366:6373]
∅:D[20.4795] → [11.6366:6373]
∅:D[23.85634] → [11.6366:6373]
B:BD[11.6366] → [11.6366:6373]
```
class map_transformer
{
public:
    enum transform_type
    {
        TT_SHUFFLE,
        TT_SUBST,
        TT_NSUBST,
        TT_MARKER,
        TT_COLOUR,
        TT_ROCKTILE,
        TT_FLOORTILE
    };
```
Replacement in crawl-ref/source/mapdef.h at line 105 [10.591249]
∅:D[24.2990] → [11.6378:6386]
B:BD[11.6378] → [11.6378:6386]
∅:D[11.6386] → [19.148:184]
B:BD[19.148] → [19.148:184]
B:BD[19.184] → [20.4796:4857]
B:BD[19.286] → [11.6387:6478]
∅:D[11.6478] → [19.286:332]
B:BD[19.286] → [19.286:332]
```
public:
    virtual ~map_transformer() = 0;
    virtual std::string apply_transform(map_lines &map) = 0;
    virtual transform_type type() const = 0;
    virtual std::string describe() const = 0;
};
class subst_spec : public map_transformer
```
[24.2990]
[25.781]
```
class subst_spec
```
Deletion in crawl-ref/source/mapdef.h at line 117 [10.591249]
B:BD[25.941] → [24.2993:2994]
∅:D[24.2994] → [20.4858:4907]
B:BD[19.338] → [20.4858:4907]
B:BD[19.416] → [11.6479:6546]
```
    std::string apply_transform(map_lines &map);
    transform_type type() const;
    std::string describe() const;
```
Deletion in crawl-ref/source/mapdef.h at line 118 [10.591249]
B:BD[25.942] → [11.6547:6602]
```
    bool operator == (const subst_spec &other) const;
```
Replacement in crawl-ref/source/mapdef.h at line 126 [10.591249]
B:BD[21.1175] → [21.1175:1218]
```
class nsubst_spec : public map_transformer
```
[21.1175]
[21.1218]
```
class nsubst_spec
```
Deletion in crawl-ref/source/mapdef.h at line 130 [10.591249]
B:BD[21.1292] → [21.1292:1341]
B:BD[21.1377] → [21.1377:1465]
B:BD[21.1465] → [24.2997:2998]
```
    std::string apply_transform(map_lines &map);
    transform_type type() const { return TT_NSUBST; }
    std::string describe() const;
```
Replacement in crawl-ref/source/mapdef.h at line 141 [10.591249]
∅:D[23.85762] → [26.4996:5039]
B:BD[22.1146] → [26.4996:5039]
```
class colour_spec : public map_transformer
```
[23.85762]
[22.1190]
```
class colour_spec
```

Deletion in crawl-ref/source/mapdef.h at line 148 [10.591249]

B:BD[22.1347] → [22.1347:1484]

    std::string apply_transform(map_lines &map);
    transform_type type() const { return TT_COLOUR; }
    std::string describe() const;

Replacement in crawl-ref/source/mapdef.h at line 165 [10.591249]
B:BD[23.85955] → [23.85955:85996]
```
class tile_spec : public map_transformer
```
[23.85955]
[23.85996]
```
class tile_spec
```

Replacement in crawl-ref/source/mapdef.h at line 169 [10.591249]

B:BD[23.86006] → [23.86006:86083]

    tile_spec(int _key, bool _fix, bool _floor, const map_tile_list &_tiles)

[23.86006]

[23.86083]

    tile_spec(const std::string &_key, bool _fix, bool _floor, const map_tile_list &_tiles)

Deletion in crawl-ref/source/mapdef.h at line 174 [10.591249]

B:BD[23.86201] → [23.86201:86366]


    std::string apply_transform(map_lines &map);
    transform_type type() const { return (floor ? TT_FLOORTILE : TT_ROCKTILE); }
    std::string describe() const;

Replacement in crawl-ref/source/mapdef.h at line 178 [10.591249]
B:BD[23.86396] → [23.86396:86409]
```
    int key;
```
[23.86396]
[23.86409]
```
    std::string key;
```
Replacement in crawl-ref/source/mapdef.h at line 187 [10.591249]
B:BD[21.1528] → [26.5040:5084]
```
class shuffle_spec : public map_transformer
```
[21.1528]
[19.466]
```
class map_marker_spec
```
Deletion in crawl-ref/source/mapdef.h at line 189 [10.591249]
B:BD[19.468] → [26.5085:5094]
∅:D[26.5094] → [19.468:572]
B:BD[19.468] → [19.468:572]
B:BD[19.572] → [24.2999:3000]
∅:D[24.3000] → [20.4908:4957]
B:BD[19.577] → [20.4908:4957]
B:BD[19.655] → [11.6603:6780]
∅:D[19.655] → [25.1125:1129]
∅:D[11.6780] → [25.1125:1129]
B:BD[25.1125] → [25.1125:1129]
B:BD[25.1129] → [26.5095:5142]
∅:D[26.5142] → [20.5011:5013]
∅:D[27.24173] → [20.5011:5013]
B:BD[20.5011] → [20.5011:5013]
```
 public:
    std::string shuffle;
    shuffle_spec(const std::string &spec)
        : shuffle(spec)
    {
    }
    std::string apply_transform(map_lines &map);
    transform_type type() const;
    std::string describe() const;
    bool operator == (const shuffle_spec &other) const
    {
        return (shuffle == other.shuffle);
    }
};
class map_marker_spec : public map_transformer
{
```
Deletion in crawl-ref/source/mapdef.h at line 203 [10.591249]
B:BD[20.5207] → [20.5207:5274]
```
    transform_type type() const;
    std::string describe() const;
```

Deletion in crawl-ref/source/mapdef.h at line 225 [10.591249]

∅:D[22.1650] → [11.6781:6925]

B:BD[25.1231] → [11.6781:6925]

B:BD[11.6925] → [21.1581:1607]

    void remove_shuffle(const std::string &s);
    void remove_subst(const std::string &s);
    void clear_shuffles();
    void clear_substs();
    void clear_nsubsts();

Deletion in crawl-ref/source/mapdef.h at line 226 [10.591249]
B:BD[20.5341] → [22.1651:1677]
```
    void clear_colours();
```
Deletion in crawl-ref/source/mapdef.h at line 230 [10.591249]
B:BD[23.86637] → [23.86637:86694]
```
    void clear_rocktiles();
    void clear_floortiles();
```

Insertion in crawl-ref/source/mapdef.h at line 235 [10.591249]

[28.279]

[24.3003]


    // Find rectangular bounds (inclusive) for uses of the glyph in the map.
    // Returns false if glyph could not be found.
    bool find_bounds(int glyph, coord_def &tl, coord_def &br) const;
    // Same as above, but for any of the glyphs in glyph_str.
    bool find_bounds(const char *glyph_str, coord_def &tl, coord_def &br) const;

Deletion in crawl-ref/source/mapdef.h at line 254 [10.591249]
B:BD[19.758] → [20.5453:5489]
∅:D[19.787] → [10.592416:592417]
∅:D[25.1280] → [10.592416:592417]
∅:D[20.5489] → [10.592416:592417]
∅:D[29.121792] → [10.592416:592417]
B:BD[10.592416] → [10.592416:592417]
```
    std::string apply_transforms();
```

Replacement in crawl-ref/source/mapdef.h at line 275 [10.591249]

B:BD[11.6969] → [11.6969:7083]

    std::vector<std::string> get_shuffle_strings() const;
    std::vector<std::string> get_subst_strings() const;

[11.6969]

[10.592702]


    rectangle_iterator get_iter() const;
    char operator () (const coord_def &c) const;
    char& operator () (const coord_def &c);

Replacement in crawl-ref/source/mapdef.h at line 280 [10.591249]

B:BD[10.592703] → [30.1292:1340]

    int operator () (const coord_def &c) const;

[10.592703]

[24.3011]

    // Extend map dimensions with glyph 'fill' to minimum width and height.
    void extend(int min_width, int min_height, char fill);

Deletion in crawl-ref/source/mapdef.h at line 285 [10.591249]
B:BD[19.830] → [20.5639:5668]
```
    void clear_transforms();
```
Deletion in crawl-ref/source/mapdef.h at line 304 [10.591249]
B:BD[16.139957] → [11.7084:7144]
```
    void clear_transforms(map_transformer::transform_type);
```
Deletion in crawl-ref/source/mapdef.h at line 330 [10.591249]
B:BD[10.592781] → [19.964:1011]
```
    std::vector<map_transformer *> transforms;
```

Replacement in crawl-ref/source/mapdef.h at line 656 [10.591249]

B:BD[11.7298] → [31.2852:2903]

    dlua_chunk      prelude, main, validate, veto;

[11.7298]

[32.1398]

    dlua_chunk      prelude, mapchunk, main, validate, veto;

Deletion in crawl-ref/source/mapdef.cc at line 338 [10.594797]
B:BD[19.1175] → [19.1175:1194]
∅:D[19.1194] → [10.595648:595649]
B:BD[10.595648] → [10.595648:595649]
B:BD[10.595649] → [19.1195:1309]
```
// map_transformer
map_transformer::~map_transformer()
{
}
////////////////////////////////////////////////////////////////////////
```
Replacement in crawl-ref/source/mapdef.cc at line 341 [10.594797]
B:BD[16.140625] → [23.87284:87335]
```
    : transforms(), markers(), lines(), overlay(),
```
[16.140625]
[22.2257]
```
    : markers(), lines(), overlay(),
```

Replacement in crawl-ref/source/mapdef.cc at line 352 [10.594797]

B:BD[19.1537] → [30.2325:2379]

int map_lines::operator () (const coord_def &c) const

[19.1537]

[30.2379]

rectangle_iterator map_lines::get_iter() const
{
    ASSERT(width() > 0);
    ASSERT(height() > 0);
    coord_def tl(0, 0);
    coord_def br(width() - 1, height() - 1);
    return rectangle_iterator(tl, br);
}
char map_lines::operator () (const coord_def &c) const
{
    return lines[c.y][c.x];
}
char& map_lines::operator () (const coord_def &c)

Deletion in crawl-ref/source/mapdef.cc at line 386 [10.594797]
B:BD[19.1690] → [20.6218:6242]
```
    clear_transforms();
```
Replacement in crawl-ref/source/mapdef.cc at line 391 [10.594797]
B:BD[19.1769] → [27.24316:24395]
∅:D[27.24395] → [20.6264:6288]
B:BD[19.1769] → [20.6264:6288]
```
    // Transforms and markers have to be regenerated, they will not be copied.
    clear_transforms();
```
[19.1769]
[20.6288]
```
    // Markers have to be regenerated, they will not be copied.
```
Deletion in crawl-ref/source/mapdef.cc at line 411 [10.594797]
B:BD[20.6590] → [20.6590:6660]
```
void map_lines::clear_transforms()
{
    clear_vector(transforms);
}
```

Replacement in crawl-ref/source/mapdef.cc at line 429 [10.594797]

B:BD[20.7024] → [27.24396:24456]

    transforms.push_back(new map_marker_spec(key[0], arg));

[20.7024]

[20.7254]

    map_marker_spec spec(key[0], arg);
    spec.apply_transform(*this);

Replacement in crawl-ref/source/mapdef.cc at line 438 [10.594797]

B:BD[33.5088] → [33.5088:5153]

    transforms.push_back(new map_marker_spec(key[0], function));

[33.5088]

[33.5153]

    map_marker_spec spec(key[0], function);
    spec.apply_transform(*this);

Insertion in crawl-ref/source/mapdef.cc at line 459 [10.594797]
[22.2518]
[22.2568]

Replacement in crawl-ref/source/mapdef.cc at line 632 [10.594797]

B:BD[22.4518] → [22.4518:4594]

    transforms.push_back( new colour_spec( key[0], sep == ':', colours ) );

[22.4518]

[22.4594]

    colour_spec spec(key[0], sep == ':', colours);
    overlay_colours(spec);

Replacement in crawl-ref/source/mapdef.cc at line 658 [10.594797]

B:BD[21.2581] → [21.2581:2653]

    transforms.push_back( new subst_spec( key[0], sep == ':', repl ) );

[21.2581]

[21.2653]

    subst_spec spec(key[0], sep == ':', repl); 
    subst(spec);

Replacement in crawl-ref/source/mapdef.cc at line 716 [10.594797]

B:BD[25.4260] → [21.4150:4211]

    transforms.push_back( new nsubst_spec(key[0], substs) );

[25.4260]

    nsubst_spec spec(key[0], substs);
    nsubst(spec);

Replacement in crawl-ref/source/mapdef.cc at line 728 [10.594797]
B:BD[25.4440] → [19.2399:2452]
```
        transforms.push_back( new shuffle_spec(s) );
```
[25.4440]
[25.4471]
```
        resolve_shuffle(s);
```
Replacement in crawl-ref/source/mapdef.cc at line 733 [10.594797]
B:BD[10.596216] → [11.9907:9962]
```
void map_lines::remove_shuffle(const std::string &raw)
```
[10.596216]
[11.9962]
```
int map_lines::width() const
```

Replacement in crawl-ref/source/mapdef.cc at line 735 [10.594797]

B:BD[11.9964] → [11.9964:10096]

B:BD[11.10096] → [34.4831:4898]

∅:D[34.4898] → [11.10161:10597]

B:BD[11.10161] → [11.10161:10597]

    std::string s = raw;
    const std::string err = check_shuffle(s);
    if (err.empty())
    {
        const shuffle_spec ss(s);
        for (int i = 0, vsize = transforms.size(); i < vsize; ++i)
        {
            if (transforms[i]->type() == map_transformer::TT_SHUFFLE)
            {
                const shuffle_spec *other =
                    dynamic_cast<shuffle_spec*>(transforms[i]);
                if (ss == *other)
                {
                    delete transforms[i];
                    transforms.erase( transforms.begin() + i );
                    return;
                }
            }
        }
    }

[11.9964]

[11.10597]

    return map_width;

Replacement in crawl-ref/source/mapdef.cc at line 738 [10.594797]
B:BD[11.10600] → [11.10600:10653]
```
void map_lines::remove_subst(const std::string &raw)
```
[11.10600]
[11.10653]
```
int map_lines::height() const
```

Replacement in crawl-ref/source/mapdef.cc at line 740 [10.594797]

B:BD[11.10655] → [11.10655:10986]

B:BD[11.10986] → [34.4899:4966]

∅:D[34.4966] → [11.11051:11446]

B:BD[11.11051] → [11.11051:11446]

    // Parsing subst specs is a pain, so we just let add_subst do the
    // work, then pop the subst off the end of the vector.
    if (add_subst(raw).empty())
    {
        map_transformer *sub = *transforms.rbegin();
        subst_spec spec = *dynamic_cast<subst_spec*>(sub);
        delete sub;
        transforms.pop_back();
        for (int i = 0, vsize = transforms.size(); i < vsize; ++i)
        {
            if (transforms[i]->type() == map_transformer::TT_SUBST)
            {
                subst_spec *cand = dynamic_cast<subst_spec*>(transforms[i]);
                if (spec == *cand)
                {
                    delete cand;
                    transforms.erase( transforms.begin() + i );
                    return;
                }
            }
        }
    }

[11.10655]

[11.11446]

    return lines.size();

Replacement in crawl-ref/source/mapdef.cc at line 743 [10.594797]

B:BD[11.11449] → [11.11449:11518]

void map_lines::clear_transforms(map_transformer::transform_type tt)

[11.11449]

[11.11518]

void map_lines::extend(int min_width, int min_height, char fill)

Replacement in crawl-ref/source/mapdef.cc at line 745 [10.594797]

B:BD[11.11520] → [11.11520:11768]

B:BD[11.11768] → [22.4615:4617]

    if (transforms.empty())
        return;
    for (int i = transforms.size() - 1; i >= 0; --i)
        if (transforms[i]->type() == tt)
        {
            delete transforms[i];
            transforms.erase( transforms.begin() + i );
        }
}

[11.11520]

[22.4617]

    min_width = std::max(1, min_width);
    min_height = std::max(1, min_height);

Replacement in crawl-ref/source/mapdef.cc at line 748 [10.594797]
B:BD[22.4618] → [22.4618:4702]
∅:D[22.4702] → [11.11768:11770]
B:BD[11.11768] → [11.11768:11770]
```
void map_lines::clear_colours()
{
    clear_transforms(map_transformer::TT_COLOUR);
}
```
[22.4618]
[11.11770]
```
    bool dirty = false;
    int old_width = width();
    int old_height = height();
```

Replacement in crawl-ref/source/mapdef.cc at line 752 [10.594797]

B:BD[11.11771] → [23.89114:89220]

#ifdef USE_TILE
void map_lines::clear_rocktiles()
{
    clear_transforms(map_transformer::TT_ROCKTILE);
}

[11.11771]

[23.89220]

    if (static_cast<int>(lines.size()) < min_height)
    {
        dirty = true;
        while (static_cast<int>(lines.size()) < min_height)
            add_line(std::string(min_width, fill));
    }

Replacement in crawl-ref/source/mapdef.cc at line 759 [10.594797]

B:BD[23.89221] → [23.89221:89320]

void map_lines::clear_floortiles()
{
    clear_transforms(map_transformer::TT_FLOORTILE);
}
#endif

[23.89221]

[23.89320]

    if (width() < min_width)
    {
        dirty = true;
        lines[0] += std::string(min_width - width(), fill);
        map_width = std::max(map_width, min_width);
    }

Replacement in crawl-ref/source/mapdef.cc at line 766 [10.594797]
∅:D[23.89321] → [11.11771:11859]
B:BD[11.11771] → [11.11771:11859]
```
void map_lines::clear_shuffles()
{
    clear_transforms(map_transformer::TT_SHUFFLE);
}
```
[23.89321]
[11.11859]
```
    if (!dirty)
        return;
```
Replacement in crawl-ref/source/mapdef.cc at line 769 [10.594797]
B:BD[11.11860] → [21.4212:4298]
```
void map_lines::clear_nsubsts()
{
    clear_transforms(map_transformer::TT_NSUBST);
}
```
[11.11860]
[21.4298]
```
    normalise(fill);
```

Replacement in crawl-ref/source/mapdef.cc at line 771 [10.594797]

∅:D[21.4299] → [11.11860:11893]

B:BD[11.11860] → [11.11860:11893]

B:BD[11.11893] → [24.3338:3387]

∅:D[24.3387] → [11.11946:11948]

B:BD[11.11946] → [11.11946:11948]

void map_lines::clear_substs()
{
    clear_transforms(map_transformer::TT_SUBST);
}

[21.4299]

[11.11948]

    // Extend overlay matrix as well.
    if (overlay.get())
    {
        std::auto_ptr<overlay_matrix> new_overlay(
            new overlay_matrix(width(), height()));

Replacement in crawl-ref/source/mapdef.cc at line 777 [10.594797]

∅:D[11.11949] → [10.596216:596271]

B:BD[10.596216] → [10.596216:596271]

int map_lines::width() const
{
    return map_width;
}

[11.11949]

[10.596271]

        for (int y = 0; y < old_height; ++y)
            for (int x = 0; x < old_width; ++x)
                (*new_overlay)(x, y) = (*overlay)(x, y);

Replacement in crawl-ref/source/mapdef.cc at line 781 [10.594797]
B:BD[10.596272] → [10.596272:596329]
```
int map_lines::height() const
{
    return lines.size();
```
[10.596272]
[16.140760]
```
        overlay = new_overlay;
    }
```
Deletion in crawl-ref/source/mapdef.cc at line 852 [10.594797]
B:BD[10.596358] → [20.7576:7600]
```
    clear_transforms();
```

Replacement in crawl-ref/source/mapdef.cc at line 897 [10.594797]

B:BD[22.4971] → [22.4971:5045]

        while ((pos = lines[y].find(spec.key, pos)) != std::string::npos)

[22.4971]

[22.5045]

        while ((pos = lines[y].find_first_of(spec.key, pos)) != std::string::npos)

Deletion in crawl-ref/source/mapdef.cc at line 995 [10.594797]
B:BD[29.123677] → [20.7622:7664]
∅:D[19.2646] → [29.123752:123754]
∅:D[25.4979] → [29.123752:123754]
∅:D[20.7664] → [29.123752:123754]
B:BD[29.123752] → [29.123752:123754]
B:BD[29.123754] → [20.7665:7688]
B:BD[20.7688] → [34.5198:5261]
∅:D[34.5261] → [20.7689:7812]
B:BD[19.2708] → [20.7689:7812]
∅:D[20.7812] → [35.100:159]
B:BD[19.2755] → [35.100:159]
B:BD[35.159] → [20.7813:7854]
∅:D[35.185] → [29.123927:123930]
∅:D[36.429] → [29.123927:123930]
∅:D[19.2755] → [29.123927:123930]
∅:D[20.7854] → [29.123927:123930]
B:BD[29.123927] → [29.123927:123930]
```
std::string map_lines::apply_transforms()
{
    std::string error;
    for (int i = 0, vsize = transforms.size(); i < vsize; ++i)
    {
        error = transforms[i]->apply_transform(*this);
        if (!error.empty())
            return (error);
    }
    // Release the transforms so we don't try them again.
    clear_transforms();
    return ("");
}
```

Deletion in crawl-ref/source/mapdef.cc at line 1138 [10.594797]

B:BD[16.142290] → [11.11950:12058]

B:BD[11.12058] → [34.5723:5786]

∅:D[34.5786] → [11.12119:12269]

B:BD[11.12119] → [11.12119:12269]

}
std::vector<std::string> map_lines::get_shuffle_strings() const
{
    std::vector<std::string> shuffles;
    for (int i = 0, vsize = transforms.size(); i < vsize; ++i)
        if (transforms[i]->type() == map_transformer::TT_SHUFFLE)
            shuffles.push_back( transforms[i]->describe() );
    return (shuffles);

Deletion in crawl-ref/source/mapdef.cc at line 1140 [10.594797]

B:BD[11.12272] → [11.12272:12373]

B:BD[11.12373] → [34.5787:5850]

∅:D[34.5850] → [11.12434:12578]

B:BD[11.12434] → [11.12434:12578]

∅:D[11.12578] → [10.598503:598506]

∅:D[16.142290] → [10.598503:598506]

B:BD[10.598503] → [10.598503:598506]

std::vector<std::string> map_lines::get_subst_strings() const
{
    std::vector<std::string> substs;
    for (int i = 0, vsize = transforms.size(); i < vsize; ++i)
        if (transforms[i]->type() == map_transformer::TT_SUBST)
            substs.push_back( transforms[i]->describe() );
    return (substs);
}

Insertion in crawl-ref/source/mapdef.cc at line 1176 [10.594797]

[28.787]

[23.90541]

}
bool map_lines::find_bounds(int gly, coord_def &tl, coord_def &br) const
{
    tl = coord_def(width(), height());
    br = coord_def(-1, -1);
    if (width() == 0 || height() == 0)
        return false;
    for (rectangle_iterator ri(get_iter()); ri; ++ri)
    {
        const coord_def mc = *ri;
        if ((*this)(mc) != gly)
            continue;
        tl.x = std::min(tl.x, mc.x);
        tl.y = std::min(tl.y, mc.y);
        br.x = std::max(br.x, mc.x);
        br.y = std::max(br.y, mc.y);
    }
    return (br.x >= 0);

Insertion in crawl-ref/source/mapdef.cc at line 1200 [10.594797]

[23.90543]


bool map_lines::find_bounds(const char *str, coord_def &tl, coord_def &br) const
{
    tl = coord_def(width(), height());
    br = coord_def(-1, -1);
    if (width() == 0 || height() == 0)
        return false;

Insertion in crawl-ref/source/mapdef.cc at line 1209 [10.594797]

[23.90544]

    for (rectangle_iterator ri(get_iter()); ri; ++ri)
    {
        ASSERT(ri);
        const coord_def &mc = *ri;
        const size_t len = strlen(str);
        for (size_t i = 0; i < len; ++i)
        {
            if ((*this)(mc) == str[i])
            {
                tl.x = std::min(tl.x, mc.x);
                tl.y = std::min(tl.y, mc.y);
                br.x = std::max(br.x, mc.x);
                br.y = std::max(br.y, mc.y);
                break;
            }
        }
    }
    return (br.x >= 0);
}

Replacement in crawl-ref/source/mapdef.cc at line 1252 [10.594797]

B:BD[23.91021] → [23.91021:91096]

    std::string err = mapdef_split_key_item(sub, &key, &sep, &substitute);

[23.91021]

[23.91096]

    std::string err = mapdef_split_key_item(sub, &key, &sep, &substitute, -1);

Replacement in crawl-ref/source/mapdef.cc at line 1261 [10.594797]

B:BD[23.91273] → [23.91273:91350]

    transforms.push_back(new tile_spec(key[0], sep == ':', is_floor, list));

[23.91273]

[23.91350]

    tile_spec spec(key, sep == ':', is_floor, list);
    overlay_tiles(spec);

Deletion in crawl-ref/source/mapdef.cc at line 1280 [10.594797]

B:BD[23.91655] → [23.91655:91824]

std::string tile_spec::apply_transform(map_lines &map)
{
    map.overlay_tiles(*this);
    return ("");
}
std::string tile_spec::describe() const
{
    return ("");
}

Replacement in crawl-ref/source/mapdef.cc at line 1322 [10.594797]

B:BD[2.2677] → [2.2677:2739]

      main("dlmain"), validate("dlvalidate"), veto("dlveto"),

[2.2677]

[2.2739]

      mapchunk("dlmapchunk"), main("dlmain"),
      validate("dlvalidate"), veto("dlveto"),

Insertion in crawl-ref/source/mapdef.cc at line 1338 [10.594797]
[11.12845]
[11.12845]
```
    mapchunk.clear();
```
Insertion in crawl-ref/source/mapdef.cc at line 1407 [10.594797]
[37.2216]
[37.2216]
```
    mapchunk.write(outf);
```
Insertion in crawl-ref/source/mapdef.cc at line 1435 [10.594797]
[37.2262]
[37.2262]
```
    mapchunk.read(inf);
```
Insertion in crawl-ref/source/mapdef.cc at line 1531 [10.594797]
[11.13029]
[11.13029]
```
    mapchunk.set_file(s);
```
Insertion in crawl-ref/source/mapdef.cc at line 1549 [10.594797]
[11.13454]
[11.13454]
```
    {
```
Insertion in crawl-ref/source/mapdef.cc at line 1551 [10.594797]
[11.13481]
[11.13481]
```
        lua_pushnil(dlua);
    }
```

Insertion in crawl-ref/source/mapdef.cc at line 1555 [10.594797]

[11.13496]

[37.2368]

        err = mapchunk.load(dlua);
        if (err == -1000)
            lua_pushnil(dlua);
        else if (err)
            return (mapchunk.orig_error());

Replacement in crawl-ref/source/mapdef.cc at line 1568 [10.594797]
B:BD[11.13654] → [11.13654:13697]
```
    if (!dlua.callfn("dgn_run_map", 2, 0))
```
[11.13654]
[38.576]
```
    if (!dlua.callfn("dgn_run_map", 3, 0))
```
Insertion in crawl-ref/source/mapdef.cc at line 1618 [10.594797]
[38.767]
[38.767]
```
        return (res);
    if (mapchunk.rewrite_chunk_errors(res))
```
Replacement in crawl-ref/source/mapdef.cc at line 1689 [10.594797]
∅:D[39.1389] → [20.9688:9725]
∅:D[40.12434] → [20.9688:9725]
B:BD[11.14766] → [20.9688:9725]
```
    return (map.apply_transforms());
```
[40.12434]
[11.14783]
```
    return ("");
```
Replacement in crawl-ref/source/mapdef.cc at line 1978 [10.594797]
∅:D[40.12462] → [20.9758:9793]
B:BD[10.601779] → [20.9758:9793]
```
    return map.apply_transforms();
```
[40.12462]
[10.601814]
```
    return ("");
```

Deletion in crawl-ref/source/mapdef.cc at line 2064 [10.594797]

∅:D[41.101278] → [11.14885:15088]

B:BD[11.14885] → [11.14885:15088]

∅:D[11.15088] → [42.5917:5920]

B:BD[42.5917] → [42.5917:5920]

std::vector<std::string> map_def::get_shuffle_strings() const
{
    return map.get_shuffle_strings();
}
std::vector<std::string> map_def::get_subst_strings() const
{
    return map.get_subst_strings();
}

Deletion in crawl-ref/source/mapdef.cc at line 3120 [10.594797]

B:BD[25.5617] → [19.2857:2860]

B:BD[19.2860] → [20.9794:9850]

∅:D[20.9850] → [19.2909:2933]

B:BD[19.2909] → [19.2909:2933]

B:BD[19.2933] → [20.9851:9868]

∅:D[20.9868] → [19.2933:2936]

B:BD[19.2933] → [19.2933:2936]

B:BD[11.16035] → [11.16035:16899]

}
std::string subst_spec::apply_transform(map_lines &map)
{
    map.subst(*this);
    return ("");
}
map_transformer::transform_type subst_spec::type() const
{
    return (TT_SUBST);
}
std::string subst_spec::describe() const
{
    std::string subst(1, foo);
    subst += std::string(" ") + (fix? ':' : '=');
    for (int i = 0, size = repl.size(); i < size; ++i)
    {
        const glyph_weighted_replacement_t &gly = repl[i];
        subst += " ";
        subst += static_cast<char>(gly.first);
        if (gly.second != 10)
            subst += make_stringf(":%d", gly.second);
    }
    return (subst);
}
bool subst_spec::operator == (const subst_spec &other) const
{
    if (foo != other.foo || fix != other.fix)
        return (false);
    if (repl.size() != other.repl.size())
        return (false);
    for (int i = 0, size = repl.size(); i < size; ++i)
    {
        if (repl[i] != other.repl[i])
            return (false);
    }
    return (true);

Deletion in crawl-ref/source/mapdef.cc at line 3130 [10.594797]
B:BD[21.5646] → [21.5646:5748]
B:BD[21.5748] → [22.5153:5195]
∅:D[22.5195] → [21.5792:5794]
B:BD[21.5792] → [21.5792:5794]
B:BD[21.5794] → [22.5196:5213]
∅:D[22.5213] → [21.5834:5837]
B:BD[21.5834] → [21.5834:5837]
```
std::string nsubst_spec::apply_transform(map_lines &map)
{
    map.nsubst(*this);
    return ("");
}
std::string nsubst_spec::describe() const
{
    return ("");
}
```

Deletion in crawl-ref/source/mapdef.cc at line 3132 [10.594797]

B:BD[22.5304] → [22.5304:5415]


std::string colour_spec::apply_transform(map_lines &map)
{
    map.overlay_colours(*this);
    return ("");
}

Deletion in crawl-ref/source/mapdef.cc at line 3133 [10.594797]
B:BD[22.5416] → [22.5416:5458]
∅:D[22.5458] → [21.5879:5900]
B:BD[21.5879] → [21.5879:5900]
B:BD[21.5900] → [22.5459:5460]
```
std::string colour_spec::describe() const
{
    return ("");
}
```
Deletion in crawl-ref/source/mapdef.cc at line 3149 [10.594797]
∅:D[21.5976] → [19.3093:3110]
B:BD[19.3093] → [19.3093:3110]
B:BD[19.3110] → [20.9869:9927]
∅:D[20.9927] → [19.3161:3197]
B:BD[19.3161] → [19.3161:3197]
B:BD[19.3197] → [20.9928:9945]
∅:D[19.3197] → [25.5617:5619]
∅:D[20.9945] → [25.5617:5619]
B:BD[25.5617] → [25.5617:5619]
B:BD[25.5619] → [42.6170:6171]
B:BD[11.16903] → [11.16903:17059]
B:BD[11.17059] → [20.9946:10024]
```
// shuffle_spec
std::string shuffle_spec::apply_transform(map_lines &map)
{
    map.resolve_shuffle(shuffle);
    return ("");
}
map_transformer::transform_type shuffle_spec::type() const
{
    return (TT_SHUFFLE);
}
std::string shuffle_spec::describe() const
{
    return (shuffle);
}
//////////////////////////////////////////////////////////////////////////
```
Deletion in crawl-ref/source/mapdef.cc at line 3183 [10.594797]
∅:D[33.5744] → [20.10495:10498]
∅:D[40.12757] → [20.10495:10498]
B:BD[20.10495] → [20.10495:10498]
B:BD[20.10498] → [27.25002:25064]
∅:D[27.25064] → [20.10565:10594]
B:BD[20.10565] → [20.10565:10594]
B:BD[20.10594] → [27.25065:25111]
∅:D[27.25111] → [20.10645:10647]
B:BD[20.10645] → [20.10645:10647]
B:BD[20.10647] → [27.25112:25142]
```
}
map_transformer::transform_type map_marker_spec::type() const
{
    return (TT_MARKER);
}
std::string map_marker_spec::describe() const
{
    return ("unimplemented");
```

Replacement in crawl-ref/source/luadgn.cc at line 835 [43.1232]

B:BD[43.7432] → [43.7432:7470]

static int dgn_shuffle(lua_State *ls)

[43.7432]

[43.7470]

static int dgn_map_add_transform(
    lua_State *ls,
    std::string (map_lines::*add)(const std::string &s))

Replacement in crawl-ref/source/luadgn.cc at line 841 [43.1232]

B:BD[43.7522] → [43.7522:7587]

        return dlua_stringtable(ls, map->get_shuffle_strings());

[43.7522]

[43.7587]

        luaL_error(ls, "Expected args, got none.");

Replacement in crawl-ref/source/luadgn.cc at line 846 [43.1232]

B:BD[43.7683] → [43.7683:7722]

            map->map.clear_shuffles();

[43.7683]

[43.7722]

        {
            luaL_error(ls, "Unexpected nil.");
        }

Replacement in crawl-ref/source/luadgn.cc at line 851 [43.1232]

B:BD[43.7745] → [43.7745:7822]

            std::string err = map->map.add_shuffle(luaL_checkstring(ls, i));

[43.7745]

[43.7822]

            std::string err = (map->map.*add)(luaL_checkstring(ls, i));

Replacement in crawl-ref/source/luadgn.cc at line 860 [43.1232]
B:BD[43.7933] → [43.7933:7978]
```
static int dgn_shuffle_remove(lua_State *ls)
```
[43.7933]
[43.7978]
```
static int dgn_shuffle(lua_State *ls)
```

Replacement in crawl-ref/source/luadgn.cc at line 862 [43.1232]

B:BD[43.7980] → [43.7980:8134]

    MAP(ls, 1, map);
    for (int i = 2, size = lua_gettop(ls); i <= size; ++i)
        map->map.remove_shuffle(luaL_checkstring(ls, i));
    return (0);

[43.7980]

[43.8134]

    return dgn_map_add_transform(ls, &map_lines::add_shuffle);

Deletion in crawl-ref/source/luadgn.cc at line 864 [43.1232]

B:BD[43.8136] → [43.8136:8137]

B:BD[43.8137] → [21.5989:6131]

∅:D[21.6131] → [43.8173:8196]

B:BD[43.8173] → [43.8173:8196]

B:BD[43.8288] → [43.8288:8384]

B:BD[43.8384] → [21.6132:6165]

∅:D[21.6165] → [43.8421:8444]

B:BD[43.8421] → [43.8421:8444]

B:BD[43.8444] → [21.6166:6238]

∅:D[21.6238] → [43.8519:8610]

B:BD[43.8519] → [43.8519:8610]


static int dgn_map_add_transform(
    lua_State *ls,
    std::string (map_lines::*add)(const std::string &s),
    void (map_lines::*erase)())
{
    MAP(ls, 1, map);
    for (int i = 2, size = lua_gettop(ls); i <= size; ++i)
    {
        if (lua_isnil(ls, i))
            (map->map.*erase)();
        else
        {
            std::string err = (map->map.*add)(luaL_checkstring(ls, i));
            if (!err.empty())
                luaL_error(ls, err.c_str());
        }
    }

Deletion in crawl-ref/source/luadgn.cc at line 865 [43.1232]
B:BD[43.8611] → [44.3317:3333]
∅:D[44.3333] → [21.6239:6242]
B:BD[43.8631] → [21.6239:6242]
```
    return (0);
}
```

Replacement in crawl-ref/source/luadgn.cc at line 867 [43.1232]

B:BD[21.6280] → [21.6280:6400]

    return dgn_map_add_transform(ls, &map_lines::add_subst,
                                 &map_lines::clear_substs);

[21.6280]

[21.6400]

    return dgn_map_add_transform(ls, &map_lines::add_subst);

Replacement in crawl-ref/source/luadgn.cc at line 872 [43.1232]

B:BD[21.6442] → [21.6442:6564]

    return dgn_map_add_transform(ls, &map_lines::add_nsubst,
                                 &map_lines::clear_nsubsts);

[21.6442]

[22.5849]

    return dgn_map_add_transform(ls, &map_lines::add_nsubst);

Replacement in crawl-ref/source/luadgn.cc at line 877 [43.1232]

B:BD[22.5891] → [22.5891:6046]

    return dgn_map_add_transform(ls,
                                 &map_lines::add_colour,
                                 &map_lines::clear_colours);

[22.5891]

[43.8631]

    return dgn_map_add_transform(ls, &map_lines::add_colour);

Replacement in crawl-ref/source/luadgn.cc at line 880 [43.1232]
B:BD[43.8634] → [43.8634:8677]
```
static int dgn_subst_remove(lua_State *ls)
```
[43.8634]
[43.8677]
```
static int dgn_normalise(lua_State *ls)
```

Replacement in crawl-ref/source/luadgn.cc at line 883 [43.1232]

B:BD[43.8700] → [43.8700:8815]

    for (int i = 2, size = lua_gettop(ls); i <= size; ++i)
        map->map.remove_subst(luaL_checkstring(ls, i));

[43.8700]

[43.8815]

    map->map.normalise();

Insertion in crawl-ref/source/luadgn.cc at line 2059 [43.1232]

[45.3233]

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

Replacement in crawl-ref/source/luadgn.cc at line 2954 [43.1232]

B:BD[23.92411] → [23.92411:92572]

    return dgn_map_add_transform(ls,
                                 &map_lines::add_floortile,
                                 &map_lines::clear_floortiles);

[23.92411]

[23.92572]

    return dgn_map_add_transform(ls, &map_lines::add_floortile);

Replacement in crawl-ref/source/luadgn.cc at line 2963 [43.1232]

B:BD[23.92637] → [23.92637:92796]

    return dgn_map_add_transform(ls,
                                 &map_lines::add_rocktile,
                                 &map_lines::clear_rocktiles);

[23.92637]

[23.92796]

    return dgn_map_add_transform(ls, &map_lines::add_rocktile);

Deletion in crawl-ref/source/luadgn.cc at line 3025 [43.1232]
B:BD[43.12575] → [43.12575:12621]
```
    { "shuffle_remove", dgn_shuffle_remove },
```
Replacement in crawl-ref/source/luadgn.cc at line 3030 [43.1232]
∅:D[46.4117] → [43.12649:12691]
∅:D[22.6077] → [43.12649:12691]
∅:D[21.6595] → [43.12649:12691]
∅:D[47.7046] → [43.12649:12691]
∅:D[23.92885] → [43.12649:12691]
B:BD[43.12649] → [43.12649:12691]
```
    { "subst_remove", dgn_subst_remove },
```
[23.92885]
[43.12691]
```
    { "normalise", dgn_normalise },
```

Insertion in crawl-ref/source/luadgn.cc at line 3084 [43.1232]

[45.12559]

    { "grd_table", dgn_grd_table },
    { "width", dgn_width },
    { "height", dgn_height },

Insertion in crawl-ref/source/luadgn.cc at line 3540 [43.1232]

[40.22904]

}
// Return the integer stored in the table (on the stack) with the key name.
// If the key doesn't exist or the value is the wrong type, return defval.
static int _table_int(lua_State *ls, int idx, const char *name, int defval)
{
    lua_pushstring(ls, name);
    lua_gettable(ls, idx < 0 ? idx - 1 : idx);
    bool nil = lua_isnil(ls, idx);
    bool valid = lua_isnumber(ls, idx);
    if (!nil && !valid)
        luaL_error(ls, "'%s' in table, but not an int.", name);
    int ret = (!nil && valid ? lua_tonumber(ls, idx) : defval);
    lua_pop(ls, 1);
    return (ret);
}
// Return the character stored in the table (on the stack) with the key name.
// If the key doesn't exist or the value is the wrong type, return defval.
static char _table_char(lua_State *ls, int idx, const char *name, char defval)
{
    lua_pushstring(ls, name);
    lua_gettable(ls, idx < 0 ? idx - 1 : idx);
    bool nil = lua_isnil(ls, idx);
    bool valid = lua_isstring(ls, idx);
    if (!nil && !valid)
        luaL_error(ls, "'%s' in table, but not a string.", name);
    char ret = defval;
    if (!nil && valid)
    {
        const char *str = lua_tostring(ls, idx);
        if (str[0] && !str[1])
            ret = str[0];
        else
            luaL_error(ls, "'%s' has more than one character.", name);
    }
    lua_pop(ls, 1);
    return (ret);
}
// Return the string stored in the table (on the stack) with the key name.
// If the key doesn't exist or the value is the wrong type, return defval.
static const char* _table_str(lua_State *ls, int idx, const char *name, const char *defval)
{
    lua_pushstring(ls, name);
    lua_gettable(ls, idx < 0 ? idx - 1 : idx);
    bool nil = lua_isnil(ls, idx);
    bool valid = lua_isstring(ls, idx);
    if (!nil && !valid)
        luaL_error(ls, "'%s' in table, but not a string.", name);
    const char *ret = (!nil && valid ? lua_tostring(ls, idx) : defval);
    lua_pop(ls, 1);
    return (ret);
}
// Return the boolean stored in the table (on the stack) with the key name.
// If the key doesn't exist or the value is the wrong type, return defval.
static bool _table_bool(lua_State *ls, int idx, const char *name, bool defval)
{
    lua_pushstring(ls, name);
    lua_gettable(ls, idx < 0 ? idx - 1 : idx);
    bool nil = lua_isnil(ls, idx);
    bool valid = lua_isboolean(ls, idx);
    if (!nil && !valid)
        luaL_error(ls, "'%s' in table, but not a bool.", name);
    bool ret = (!nil && valid ? lua_toboolean(ls, idx) : defval);
    lua_pop(ls, 1);
    return (ret);

Insertion in crawl-ref/source/luadgn.cc at line 3611 [43.1232]

[40.22906]


#define BF_INT(ls, val, def) int val = _table_int(ls, -1, #val, def);
#define BF_CHAR(ls, val, def) char val = _table_char(ls, -1, #val, def);
#define BF_STR(ls, val, def) const char *val = _table_str(ls, -1, #val, def);
#define BF_BOOL(ls, val, def) bool val = _table_bool(ls, -1, #val, def);
static void bf_octa_room(lua_State *ls, map_lines &lines)
{
    int default_oblique = std::min(lines.width(), lines.height()) / 2 - 1;
    BF_INT(ls, oblique, default_oblique);
    BF_CHAR(ls, outside, 'x');
    BF_CHAR(ls, inside, '.');
    BF_STR(ls, replace, ".");
    coord_def tl, br;
    if (!lines.find_bounds(replace, tl, br))
        return;
    for (rectangle_iterator ri(tl, br); ri; ++ri)
    {
        const coord_def mc = *ri;
        char glyph = lines(mc);
        if (replace[0] && !strchr(replace, glyph))
            continue;
        int ob = 0;
        ob += std::max(oblique + tl.x - mc.x, 0);
        ob += std::max(oblique + mc.x - br.x, 0);

Insertion in crawl-ref/source/luadgn.cc at line 3640 [43.1232]

[40.22907]

[43.12874]

        bool is_inside = (mc.y >= tl.y + ob && mc.y <= br.y - ob);
        lines(mc) = is_inside ? inside : outside;
    }
}
static void bf_smear(lua_State *ls, map_lines &lines)
{
    BF_INT(ls, iterations, 1);
    BF_CHAR(ls, smear, 'x');
    BF_STR(ls, onto, ".");
    BF_BOOL(ls, boxy, false);
    const int max_test_per_iteration = 10;
    int sanity = 0;
    int max_sanity = iterations * max_test_per_iteration;
    for (int i = 0; i < iterations; i++)
    {
        bool diagonals, straights;
        coord_def mc;
        do
        {
            do
            {
                sanity++;
                mc.x = random_range(1, lines.width() - 2);
                mc.y = random_range(1, lines.height() - 2);
            }
            while (onto[0] && !strchr(onto, lines(mc)));
  
            // Prevent too many iterations. 
            if (sanity > max_sanity)
                return;
        
            // Is there a "smear" feature along the diagonal from mc?    
            diagonals = lines(coord_def(mc.x+1, mc.y+1)) == smear ||
                        lines(coord_def(mc.x-1, mc.y+1)) == smear ||
                        lines(coord_def(mc.x-1, mc.y-1)) == smear ||
                        lines(coord_def(mc.x+1, mc.y-1)) == smear;
            // Is there a "smear" feature up, down, left, or right from mc?
            straights = lines(coord_def(mc.x+1, mc.y)) == smear ||
                        lines(coord_def(mc.x-1, mc.y)) == smear ||
                        lines(coord_def(mc.x, mc.y+1)) == smear ||
                        lines(coord_def(mc.x, mc.y-1)) == smear;
        }
        while (!straights && (boxy || !diagonals));
     
        lines(mc) = smear; 
    }
}
static void bf_extend(lua_State *ls, map_lines &lines)
{
    BF_INT(ls, height, 1);
    BF_INT(ls, width, 1);
    BF_CHAR(ls, fill, 'x');
    lines.extend(width, height, fill);
}
typedef void (*bf_func)(lua_State *ls, map_lines &lines);
struct bf_entry
{
    const char* name;
    bf_func func;
};
// Create a separate list of builder funcs so that we can automatically
// generate a list of closures for them, rather than individually
// and explicitly exposing them to the dgn namespace.
static struct bf_entry bf_map[] =
{
    { "map_octa_room", &bf_octa_room },
    { "map_smear", &bf_smear },
    { "map_extend", &bf_extend }
};
static int dgn_call_builder_func(lua_State *ls)
{
    // This function gets called for all the builder functions that
    // operate on map_lines.
    MAP(ls, 1, map);
    if (!lua_istable(ls, 2) && !lua_isfunction(ls, 2))
        return luaL_argerror(ls, 2, "Expected table");
    bf_func *func = (bf_func *)lua_topointer(ls, lua_upvalueindex(1));
    if (!func)
        return luaL_error(ls, "Expected C function in closure upval");
 
    // Put the table on top.
    lua_settop(ls, 2);
    // Call the builder func itself.
    (*func)(ls, map->map);
    return (0);
}
static void _register_builder_funcs(lua_State *ls)
{
    lua_getglobal(ls, "dgn");
   
    const size_t num_entries = sizeof(bf_map) / sizeof(bf_entry); 
    for (size_t i = 0; i < num_entries; i++)
    {
        // Push a closure with the C function into the dgn table.
        lua_pushlightuserdata(ls, &bf_map[i].func);
        lua_pushcclosure(ls, &dgn_call_builder_func, 1);
        lua_setfield(ls, -2, bf_map[i].name);
    }
    lua_pop(ls, 1);
}

Insertion in crawl-ref/source/luadgn.cc at line 3778 [43.1232]
[8.4379]
[48.6610]
```
    _register_builder_funcs(dlua);
```
Replacement in crawl-ref/source/dat/entry.des at line 2487 [50.591]
∅:D[4.4495] → [49.2883:2942]
B:BD[51.29581] → [49.2883:2942]
```
FTILE:   ' = floor_grass, 1 = floor_grass, { = floor_grass
```
[4.4495]
[49.2942]
```
FTILE:   '1{ = floor_grass
```

Replacement in crawl-ref/source/dat/entry.des at line 3498 [50.591]

B:BD[52.599] → [49.3030:3264]

FTILE:   1=floor_dirt, 2=floor_dirt, 3=floor_dirt, 4=floor_dirt, +=floor_dirt
FTILE:   A=floor_dirt, B=floor_dirt, C=floor_dirt, D=floor_dirt, E=floor_dirt
FTILE:   a=floor_dirt, b=floor_dirt, c=floor_dirt, d=floor_dirt, e=floor_dirt

[52.599]

[53.921]

FTILE:   1234+ABCDEabcde = floor_dirt

Replacement in crawl-ref/source/dat/entry.des at line 4823 [50.591]
B:BD[49.3287] → [49.3287:3358]
```
FTILE:  . = floor_hall, ( = floor_hall, [ = floor_hall, { = floor_hall
```
[49.3287]
[54.1384]
```
FTILE:  .([{ = floor_hall
```
Replacement in crawl-ref/source/dat/entry.des at line 4886 [50.591]
B:BD[55.3350] → [9.3258:3327]
```
FTILE:  . = floor_lair
FTILE:  t = floor_lair
FTILE:  1 = floor_lair
```
[55.3350]
[55.3350]
```
FTILE:  .t1 = floor_lair
```

Insertion in crawl-ref/source/dat/entry.des at line 4914 [50.591]

[55.4162]

[56.4187]

ENDMAP
###########################################################
# Basic island, with variations
#
NAME:   enne_octagon_isle
ORIENT: float
TAGS:   entry
FTILE:  '[({ = floor_sand_stone
SUBST:  ' = .
{{
    map_octa_room({
        oblique = crawl.random_range(3,7),
        replace = '.',
        outside = 'W',
        inside  = '.'
    })
    if crawl.coinflip() then
        map_smear({iterations=20, smear='x', onto='.W', boxy = true})
    end
}}
SUBST: W:xw
MAP
 xxxxxxxxxxxxx 
x.............x
x.............x
x.............x
x.............x
......www......
.....w[''w.....
@....w'{'w....@
.....w''(w.....
......www......
x.............x
x.............x
x.............x
x.............x
 xxxxxxxxxxxxx

Insertion in crawl-ref/source/dat/clua/dungeon.lua at line 78 [11.17172]

[11.17790]

[27.48465]


   -- Convenience global variable, e.g. grd[x][y] = 'x'
   meta['grd'] = dgn.grd_table(map)

Replacement in crawl-ref/source/dat/clua/dungeon.lua at line 96 [11.17172]

B:BD[11.17968] → [11.17968:18031]

function dgn_run_map(prelude, main)
   if prelude or main then

[11.17968]

[31.8431]

function dgn_run_map(prelude, map, main)
   if prelude or map or main then

Insertion in crawl-ref/source/dat/clua/dungeon.lua at line 99 [11.17172]
[31.8488]
[11.18082]
```
      local ret
```

Replacement in crawl-ref/source/dat/clua/dungeon.lua at line 101 [11.17172]

B:BD[11.18104] → [31.8489:8608]

         local fn = setfenv(prelude, env)
         if not main then
            return fn()
         end
         fn()

[11.18104]

[11.18137]

         ret = setfenv(prelude, env)()
      end
      if map then
         ret = setfenv(map, env)()
         dgn.normalise(g_dgn_curr_map)

Replacement in crawl-ref/source/dat/clua/dungeon.lua at line 108 [11.17172]
B:BD[11.18166] → [31.8609:8646]
```
         return setfenv(main, env)()
```
[11.18166]
[11.18196]
```
         ret = setfenv(main, env)()
```
Insertion in crawl-ref/source/dat/clua/dungeon.lua at line 110 [11.17172]
[11.18206]
[30.12433]
```
      return ret
```
Replacement in crawl-ref/source/dat/clua/dungeon.lua at line 396 [11.17172]
B:BD[7.5214] → [7.5214:5220]
```
    ]]
```
[7.5214]
```
    ]]
```
Insertion in crawl-ref/source/clua.h at line 323 [57.481234]
[40.35902]
[11.19434]
```
#define GRD_METATABLE "dgn.grd"
#define GRD_COL_METATABLE "dgn.grdcol"
```
Insertion in crawl-ref/source/clua.cc at line 600 [57.483969]
[11.20212]
[11.20212]
```
void luaopen_grd(lua_State *ls);
```
Insertion in crawl-ref/source/clua.cc at line 630 [57.483969]
[11.20466]
[57.495232]
```
    luaopen_grd(_state);
```

Insertion in crawl-ref/source/clua.cc at line 2792 [57.483969]

[57.535301]


/////////////////////////////////////////////////////////////////////
// grd and grd_col handling (i.e. map_lines in a metatable)
struct mapcolumn
{
    map_def* map;
    int col;
};

Insertion in crawl-ref/source/clua.cc at line 2802 [57.483969]

[57.535302]

static int grd_get(lua_State *ls)
{
    // Return a metatable for this column in the map grid.
    map_def *map = *(map_def **) luaL_checkudata(ls, 1, GRD_METATABLE);
    int column = luaL_checkint(ls, 2);
    mapcolumn *mapref = clua_new_userdata<mapcolumn>(ls, GRD_COL_METATABLE);
    mapref->map = map;
    mapref->col = column;
    return (1);
}
static int grd_set(lua_State *ls)
{
    return (luaL_error(ls, "%s", "Cannot assign to read-only table."));
}
static char* grd_glyph(lua_State *ls, int &col, int &row)
{
    mapcolumn *mapc = (mapcolumn *)luaL_checkudata(ls, 1, GRD_COL_METATABLE);
    row = luaL_checkint(ls, 2);
    col = mapc->col;
    map_lines &lines = mapc->map->map;
    if (row < 1 || col < 1 || col > lines.width() || row > lines.height())
    {
        return (NULL);
    }
    coord_def mc(col - 1, row - 1);
    return (&lines(mc));
}
static int grd_col_get(lua_State *ls)
{
    int col, row;
    char *gly = grd_glyph(ls, col, row);
    if (!gly)
        return (luaL_error(ls, "Invalid coords: %d, %d", col, row));
    char buf[2];
    buf[0] = *gly;
    buf[1] = '\0';
    
    lua_pushstring(ls, buf); 
    return (1);
}
static int grd_col_set(lua_State *ls)
{
    int col, row;
    char *gly = grd_glyph(ls, col, row);
    if (!gly)
        return (luaL_error(ls, "Invalid coords: %d, %d", col, row));
    const char *str = luaL_checkstring(ls, 3);
    if (!str[0] || str[1])
        return (luaL_error(ls, "%s", "grd must be set to a single char."));
    (*gly) = str[0];
    return (0);
}
void luaopen_grd(lua_State *ls)
{
    // grd table
    luaL_newmetatable(ls, GRD_METATABLE);
    lua_pushstring(ls, "__index");
    lua_pushcfunction(ls, grd_get);
    lua_settable(ls, -3);
    lua_pushstring(ls, "__newindex");
    lua_pushcfunction(ls, grd_set);
    lua_settable(ls, -3);
    lua_pop(ls, 1);
    // grd col table    
    luaL_newmetatable(ls, GRD_COL_METATABLE);
    lua_pushstring(ls, "__index");
    lua_pushcfunction(ls, grd_col_get);
    lua_settable(ls, -3);
    lua_pushstring(ls, "__newindex");
    lua_pushcfunction(ls, grd_col_set);
    lua_settable(ls, -3);
    lua_pop(ls, 1);
}

Insertion in crawl-ref/docs/develop/level_design.txt at line 738 [58.350]

[23.98296]


          For convenience, multiple glyphs can be specified together as a
          group, e.g. ".[{( = floor_orc".

Insertion in crawl-ref/docs/develop/level_design.txt at line 1851 [58.350]

[3.4321]

[59.12987]


Additionally, the dgn module provides a global "grd" variable that
can access the current map glyphs.  The top left symbol in the map
can be assigned like this:
 grd[1][1] = 'x'

Insertion in crawl-ref/docs/develop/level_design.txt at line 1859 [58.350]
[59.12988]
[41.134608]
```
The bottom right symbol can be assigned like this:
```
Insertion in crawl-ref/docs/develop/level_design.txt at line 1861 [58.350]
[41.134609]
[59.12988]
```
 grd[width()][height()] = "."
```

Lua map improvements.

Dependencies

In channels

Change contents

Replacement in crawl-ref/source/util/levcomp.ypp at line 592 [10.75608]

Replacement in crawl-ref/source/maps.h at line 65 [14.2007036]

Deletion in crawl-ref/source/mapdef.h at line 18 [10.591249]

Insertion in crawl-ref/source/mapdef.h at line 20 [10.591249]

Insertion in crawl-ref/source/mapdef.h at line 23 [10.591249]

Deletion in crawl-ref/source/mapdef.h at line 25 [10.591249]

Deletion in crawl-ref/source/mapdef.h at line 104 [10.591249]

Replacement in crawl-ref/source/mapdef.h at line 105 [10.591249]

Deletion in crawl-ref/source/mapdef.h at line 117 [10.591249]

Deletion in crawl-ref/source/mapdef.h at line 118 [10.591249]

Replacement in crawl-ref/source/mapdef.h at line 126 [10.591249]

Deletion in crawl-ref/source/mapdef.h at line 130 [10.591249]

Replacement in crawl-ref/source/mapdef.h at line 141 [10.591249]

Deletion in crawl-ref/source/mapdef.h at line 148 [10.591249]

Replacement in crawl-ref/source/mapdef.h at line 165 [10.591249]

Replacement in crawl-ref/source/mapdef.h at line 169 [10.591249]

Deletion in crawl-ref/source/mapdef.h at line 174 [10.591249]

Replacement in crawl-ref/source/mapdef.h at line 178 [10.591249]

Replacement in crawl-ref/source/mapdef.h at line 187 [10.591249]

Deletion in crawl-ref/source/mapdef.h at line 189 [10.591249]

Deletion in crawl-ref/source/mapdef.h at line 203 [10.591249]

Deletion in crawl-ref/source/mapdef.h at line 225 [10.591249]

Deletion in crawl-ref/source/mapdef.h at line 226 [10.591249]

Deletion in crawl-ref/source/mapdef.h at line 230 [10.591249]

Insertion in crawl-ref/source/mapdef.h at line 235 [10.591249]

Deletion in crawl-ref/source/mapdef.h at line 254 [10.591249]

Replacement in crawl-ref/source/mapdef.h at line 275 [10.591249]

Replacement in crawl-ref/source/mapdef.h at line 280 [10.591249]

Deletion in crawl-ref/source/mapdef.h at line 285 [10.591249]

Deletion in crawl-ref/source/mapdef.h at line 304 [10.591249]

Deletion in crawl-ref/source/mapdef.h at line 330 [10.591249]

Replacement in crawl-ref/source/mapdef.h at line 656 [10.591249]

Deletion in crawl-ref/source/mapdef.cc at line 338 [10.594797]

Replacement in crawl-ref/source/mapdef.cc at line 341 [10.594797]

Replacement in crawl-ref/source/mapdef.cc at line 352 [10.594797]

Deletion in crawl-ref/source/mapdef.cc at line 386 [10.594797]

Replacement in crawl-ref/source/mapdef.cc at line 391 [10.594797]

Deletion in crawl-ref/source/mapdef.cc at line 411 [10.594797]

Replacement in crawl-ref/source/mapdef.cc at line 429 [10.594797]

Replacement in crawl-ref/source/mapdef.cc at line 438 [10.594797]

Insertion in crawl-ref/source/mapdef.cc at line 459 [10.594797]

Replacement in crawl-ref/source/mapdef.cc at line 632 [10.594797]

Replacement in crawl-ref/source/mapdef.cc at line 658 [10.594797]

Replacement in crawl-ref/source/mapdef.cc at line 716 [10.594797]

Replacement in crawl-ref/source/mapdef.cc at line 728 [10.594797]

Replacement in crawl-ref/source/mapdef.cc at line 733 [10.594797]

Replacement in crawl-ref/source/mapdef.cc at line 735 [10.594797]

Replacement in crawl-ref/source/mapdef.cc at line 738 [10.594797]

Replacement in crawl-ref/source/mapdef.cc at line 740 [10.594797]

Replacement in crawl-ref/source/mapdef.cc at line 743 [10.594797]

Replacement in crawl-ref/source/mapdef.cc at line 745 [10.594797]

Replacement in crawl-ref/source/mapdef.cc at line 748 [10.594797]

Replacement in crawl-ref/source/mapdef.cc at line 752 [10.594797]

Replacement in crawl-ref/source/mapdef.cc at line 759 [10.594797]

Replacement in crawl-ref/source/mapdef.cc at line 766 [10.594797]

Replacement in crawl-ref/source/mapdef.cc at line 769 [10.594797]

Replacement in crawl-ref/source/mapdef.cc at line 771 [10.594797]

Replacement in crawl-ref/source/mapdef.cc at line 777 [10.594797]

Replacement in crawl-ref/source/mapdef.cc at line 781 [10.594797]

Deletion in crawl-ref/source/mapdef.cc at line 852 [10.594797]

Replacement in crawl-ref/source/mapdef.cc at line 897 [10.594797]

Deletion in crawl-ref/source/mapdef.cc at line 995 [10.594797]

Deletion in crawl-ref/source/mapdef.cc at line 1138 [10.594797]

Deletion in crawl-ref/source/mapdef.cc at line 1140 [10.594797]

Insertion in crawl-ref/source/mapdef.cc at line 1176 [10.594797]

Insertion in crawl-ref/source/mapdef.cc at line 1200 [10.594797]

Insertion in crawl-ref/source/mapdef.cc at line 1209 [10.594797]

Replacement in crawl-ref/source/mapdef.cc at line 1252 [10.594797]

Replacement in crawl-ref/source/mapdef.cc at line 1261 [10.594797]

Deletion in crawl-ref/source/mapdef.cc at line 1280 [10.594797]

Replacement in crawl-ref/source/mapdef.cc at line 1322 [10.594797]

Insertion in crawl-ref/source/mapdef.cc at line 1338 [10.594797]

Insertion in crawl-ref/source/mapdef.cc at line 1407 [10.594797]

Insertion in crawl-ref/source/mapdef.cc at line 1435 [10.594797]

Insertion in crawl-ref/source/mapdef.cc at line 1531 [10.594797]

Insertion in crawl-ref/source/mapdef.cc at line 1549 [10.594797]