fiddlerwoaroof/crawl - Change AO3KHGKGSX2ZR24KJVIOTUY7EHYHMMI5W4HN3CAG4YGQHBOHLGDQC

dgn_place_map takes a coord_def to specify the centre of the map for minivaults and floating vaults. This placement can be activated using an asterisk (mapname*) when entering the name of the map in the &L command.

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

Created by dshaligram on October 25, 2007

AO3KHGKGSX2ZR24KJVIOTUY7EHYHMMI5W4HN3CAG4YGQHBOHLGDQC

Dependencies

In channels

main

Change contents

Replacement in crawl-ref/source/maps.h at line 24 [5.2007036]
B:BD[4.582811] → [4.582811:582848]
```
    int x, y;
    int width, height;
```
[4.582811]
[6.139090]
```
    coord_def pos;
    coord_def size;
```

Replacement in crawl-ref/source/maps.h at line 32 [5.2007036]

B:BD[4.582895] → [7.1847:1910]

        : x(-1), y(-1), width(0), height(0), orient(0), map(),

[4.582895]

[8.385]

        : pos(-1, -1), size(0, 0), orient(0), map(),

Insertion in crawl-ref/source/maps.h at line 44 [5.2007036]

[5.2007626]

[9.136]

// Given a rectangular region, slides it to fit into the map. size must be
// smaller than (GXM,GYM).
void fit_region_into_map_bounds(coord_def &pos, const coord_def &size);

Replacement in crawl-ref/source/maps.cc at line 67 [5.2007666]

B:BD[4.584389] → [4.584389:584504]

    mprf(MSGCH_DIAGNOSTICS, "Generating level: %s", 
                            vdefs[which_vault].name.c_str());

[4.584389]

[10.213]

    mprf(MSGCH_DIAGNOSTICS, "Generating level: %s (%d,%d)", 
         vdefs[which_vault].name.c_str(),
         place.pos.x, place.pos.y);

Insertion in crawl-ref/source/maps.cc at line 207 [5.2007666]

[8.2524]

void fit_region_into_map_bounds(coord_def &pos, const coord_def &size)
{
    ASSERT(size.x <= GXM && size.y <= GYM);
    if (pos.x < X_BOUND_1)
        pos.x = X_BOUND_1;
    if (pos.y < Y_BOUND_1)
        pos.y = Y_BOUND_1;
    if (pos.x + size.x - 1 > X_BOUND_2)
        pos.x = X_BOUND_2 - size.x + 1;
    if (pos.y + size.y - 1 > Y_BOUND_2)
        pos.y = Y_BOUND_2 - size.y + 1;
}

Replacement in crawl-ref/source/maps.cc at line 229 [5.2007666]
B:BD[5.2161853] → [4.586361:586393]
```
    int startx = 0, starty = 0;
```
[5.2161853]
[5.2161877]
```
    coord_def start(0, 0);
```
Replacement in crawl-ref/source/maps.cc at line 233 [5.2007666]
B:BD[4.586489] → [4.586489:586520]
```
        starty = GYM - height;
```
[4.586489]
[5.2161878]
```
        start.y = GYM - height;
```
Replacement in crawl-ref/source/maps.cc at line 237 [5.2007666]
B:BD[4.586616] → [4.586616:586646]
```
        startx = GXM - width;
```
[4.586616]
[5.2162022]
```
        start.x = GXM - width;
```
Replacement in crawl-ref/source/maps.cc at line 244 [5.2007666]
B:BD[4.586876] → [4.586876:586912]
```
        startx = (GXM - width) / 2;
```
[4.586876]
[5.2169503]
```
        start.x = (GXM - width) / 2;
```
Replacement in crawl-ref/source/maps.cc at line 249 [5.2007666]
B:BD[4.587036] → [4.587036:587073]
```
        starty = (GYM - height) / 2;
```
[4.587036]
[6.139354]
```
        start.y = (GYM - height) / 2;
```

Replacement in crawl-ref/source/maps.cc at line 254 [5.2007666]

B:BD[6.139464] → [6.139464:139599]

        coord_def where = def.float_place();
        // No further sanity checks.
        startx = where.x;
        starty = where.y;

[6.139464]

[8.2702]

        if (map_bounds(place.pos))
        {
            start = place.pos - coord_def(width, height) / 2;
            fit_region_into_map_bounds(start, coord_def(width, height));
        }
        else
            start = def.float_place();

Replacement in crawl-ref/source/maps.cc at line 263 [5.2007666]

B:BD[8.2709] → [11.2063:2134]

    if (bad_map_place(def, startx, starty, width, height, check_place,

[8.2709]

[11.2134]

    if (bad_map_place(def, start.x, start.y, width, height, check_place,

Replacement in crawl-ref/source/maps.cc at line 268 [5.2007666]

B:BD[8.2873] → [8.2873:2918]

             startx, starty, width, height);

[8.2873]

[8.2918]

             start.x, start.y, width, height);

Replacement in crawl-ref/source/maps.cc at line 276 [5.2007666]

B:BD[4.587233] → [4.587233:587295]

            def.name.c_str(), startx, starty, width, height);

[4.587233]

[4.587295]

            def.name.c_str(), start.x, start.y, width, height);

Replacement in crawl-ref/source/maps.cc at line 279 [5.2007666]
B:BD[5.2169534] → [4.587303:587354]
```
    for (int y = starty; y < starty + height; ++y)
```
[5.2169534]
[4.587354]
```
    for (int y = start.y; y < start.y + height; ++y)
```

Replacement in crawl-ref/source/maps.cc at line 281 [5.2007666]

B:BD[4.587360] → [4.587360:587467]

        const std::string &s = lines[y - starty];
        strncpy(&map[y][startx], s.c_str(), s.length());

[4.587360]

[4.587467]

        const std::string &s = lines[y - start.y];
        strncpy(&map[y][start.x], s.c_str(), s.length());

Replacement in crawl-ref/source/maps.cc at line 285 [5.2007666]

B:BD[5.2169609] → [4.587474:587570]

    place.x = startx;
    place.y = starty;
    place.width = width;
    place.height = height;

[5.2169609]

[8.2950]

    place.pos  = start;
    place.size = coord_def(width, height);

Insertion in crawl-ref/source/mapdef.h at line 601 [4.591249]

[12.535]


    coord_def size() const { return coord_def(map.width(), map.height()); }

Replacement in crawl-ref/source/mapdef.cc at line 1307 [4.594797]

B:BD[13.8861] → [13.8861:8918]

    for (int i = 0, size = depths.size(); i < size; ++i)

[13.8861]

[13.8918]

    for (int i = 0, sz = depths.size(); i < sz; ++i)

Replacement in crawl-ref/source/mapdef.cc at line 1480 [4.594797]

B:BD[14.6300] → [14.6300:6357]

    for (int i = 0, size = depths.size(); i < size; ++i)

[14.6300]

[14.6357]

    for (int i = 0, sz = depths.size(); i < sz; ++i)

Insertion in crawl-ref/source/externs.h at line 314 [5.3270163]
[6.146487]
[5.3272140]
```
    bool origin() const
    {
        return (!x && !y);
    }
```

Insertion in crawl-ref/source/dungeon.h at line 82 [5.3428186]

[6.147353]

    {
    }
    dgn_region(const coord_def &_pos, const coord_def &_size)
        : pos(_pos), size(_size)

Replacement in crawl-ref/source/dungeon.h at line 306 [5.3428186]

∅:D[15.11792] → [11.2612:2678]

B:BD[11.2612] → [11.2612:2678]

bool dgn_place_map(int map, bool generating_level, bool clobber);

[15.11792]

[11.2678]

bool dgn_place_map(int map, bool generating_level, bool clobber,
                   const coord_def &pos = coord_def(-1, -1));

Replacement in crawl-ref/source/dungeon.cc at line 211 [5.3429798]

B:BD[11.3359] → [11.3359:3416]

                                  bool clobber = false);

[11.3359]

[16.1001]

                                  bool clobber = false,
                                  const coord_def &where = coord_def(-1, -1));

Replacement in crawl-ref/source/dungeon.cc at line 216 [5.3429798]

B:BD[11.3474] → [11.3474:3552]

                         bool generating_level = true, bool clobber = false);

[11.3474]

[17.359]

                         bool generating_level = true, bool clobber = false,
                         const coord_def &where = coord_def(-1, -1));

Replacement in crawl-ref/source/dungeon.cc at line 509 [5.3429798]

B:BD[12.2558] → [12.2558:2760]

    for (int y = place.y + place.height - 1; y >= place.y; --y)
        for (int x = place.x + place.width - 1; x >= place.x; --x)
            if (place.map.in_map(coord_def(x - place.x, y - place.y)))

[12.2558]

[12.2760]

    for (int y = place.pos.y + place.size.y - 1; y >= place.pos.y; --y)
        for (int x = place.pos.x + place.size.x - 1; x >= place.pos.x; --x)
            if (place.map.in_map(coord_def(x - place.pos.x, y - place.pos.y)))

Replacement in crawl-ref/source/dungeon.cc at line 533 [5.3429798]

B:BD[18.109664] → [18.109664:109866]

    for (int y = place.y + place.height - 1; y >= place.y; --y)
        for (int x = place.x + place.width - 1; x >= place.x; --x)
            if (place.map.in_map(coord_def(x - place.x, y - place.y)))

[18.109664]

[18.109866]

    for (int y = place.pos.y + place.size.y - 1; y >= place.pos.y; --y)
        for (int x = place.pos.x + place.size.x - 1; x >= place.pos.x; --x)
            if (place.map.in_map(coord_def(x - place.pos.x, y - place.pos.y)))

Replacement in crawl-ref/source/dungeon.cc at line 537 [5.3429798]

B:BD[18.109880] → [18.109880:109953]

                int key = place.map.map.glyph(x - place.x, y - place.y);

[18.109880]

[18.109953]

                int key = place.map.map.glyph(x - place.pos.x, y - place.pos.y);

Replacement in crawl-ref/source/dungeon.cc at line 3103 [5.3429798]
∅:D[19.515] → [20.728:781]
∅:D[21.1334] → [20.728:781]
∅:D[22.1547] → [20.728:781]
B:BD[20.728] → [20.728:781]
```
    for (int vx = v1x; vx < v1x + place.width; vx++)
```
[21.1334]
[20.781]
```
    for (int vx = v1x; vx < v1x + place.size.x; vx++)
```

Replacement in crawl-ref/source/dungeon.cc at line 3105 [5.3429798]

B:BD[20.787] → [20.787:845]

        for (int vy = v1y; vy < v1y + place.height; vy++)

[20.787]

[20.845]

        for (int vy = v1y; vy < v1y + place.size.y; vy++)

Replacement in crawl-ref/source/dungeon.cc at line 3138 [5.3429798]
∅:D[21.1496] → [20.1412:1465]
∅:D[22.1807] → [20.1412:1465]
B:BD[20.1412] → [20.1412:1465]
```
    for (int vx = v1x; vx < v1x + place.width; vx++)
```
[21.1496]
[20.1465]
```
    for (int vx = v1x; vx < v1x + place.size.x; vx++)
```

Replacement in crawl-ref/source/dungeon.cc at line 3140 [5.3429798]

B:BD[20.1526] → [20.1526:1584]

        for (int vy = v1y; vy < v1y + place.height; vy++)

[20.1471]

[20.1584]

        for (int vy = v1y; vy < v1y + place.size.y; vy++)

Replacement in crawl-ref/source/dungeon.cc at line 3167 [5.3429798]

B:BD[20.2217] → [20.2217:2350]

        v1x = random_range( margin, GXM - margin - place.width );
        v1y = random_range( margin, GYM - margin - place.height );

[20.2217]

[20.2350]

        v1x = random_range( margin, GXM - margin - place.size.x );
        v1y = random_range( margin, GYM - margin - place.size.y );

Replacement in crawl-ref/source/dungeon.cc at line 3207 [5.3429798]

B:BD[5.3596572] → [17.1577:1615]

    if ( where.x > 0 && where.y > 0 )

[5.3596572]

[17.1615]

    if (in_bounds(where)) // not map_bounds, minivaults should never touch edge

Replacement in crawl-ref/source/dungeon.cc at line 3209 [5.3429798]

B:BD[17.1621] → [17.1621:1667]

        v1x = where.x;
        v1y = where.y;

[17.1621]

[17.1667]

        coord_def tl(where - place.size / 2);
        fit_region_into_map_bounds(tl, place.size);
        v1x = tl.x;
        v1y = tl.y;

Replacement in crawl-ref/source/dungeon.cc at line 3217 [5.3429798]
B:BD[5.3596611] → [20.2678:2716]
```
    place.x = v1x;
    place.y = v1y;
```
[5.3596611]
[23.18846]
```
    place.pos = coord_def(v1x, v1y);
```
Replacement in crawl-ref/source/dungeon.cc at line 3234 [5.3429798]
B:BD[5.3596909] → [17.1727:1780]
```
    for (int vx = v1x; vx < v1x + place.width; vx++)
```
[5.3596909]
[5.3596949]
```
    for (int vx = v1x; vx < v1x + place.size.x; vx++)
```

Replacement in crawl-ref/source/dungeon.cc at line 3236 [5.3429798]

B:BD[5.3596955] → [17.1781:1839]

        for (int vy = v1y; vy < v1y + place.height; vy++)

[5.3596955]

[5.3596999]

        for (int vy = v1y; vy < v1y + place.size.y; vy++)

Replacement in crawl-ref/source/dungeon.cc at line 3369 [5.3429798]
∅:D[24.388] → [6.152143:152207]
B:BD[6.152143] → [6.152143:152207]
```
        pos.x == place.x || pos.x == place.x + place.width - 1;
```
[24.388]
[24.389]
```
        pos.x == place.pos.x || pos.x == place.pos.x + place.size.x - 1;
```
Replacement in crawl-ref/source/dungeon.cc at line 3371 [5.3429798]
∅:D[24.407] → [6.152231:152296]
B:BD[6.152231] → [6.152231:152296]
```
        pos.y == place.y || pos.y == place.y + place.height - 1;
```
[24.407]
[25.282]
```
        pos.y == place.pos.y || pos.y == place.pos.y + place.size.y - 1;
```

Replacement in crawl-ref/source/dungeon.cc at line 3376 [5.3429798]

B:BD[25.363] → [25.363:428]

        const coord_def rel = pos - coord_def(place.x, place.y);

[25.363]

[25.428]

        const coord_def rel = pos - place.pos;

Replacement in crawl-ref/source/dungeon.cc at line 3400 [5.3429798]
B:BD[24.555] → [24.555:585]
```
        if (place.width == 1)
```
[24.555]
[24.585]
```
        if (place.size.x == 1)
```

Replacement in crawl-ref/source/dungeon.cc at line 3406 [5.3429798]

B:BD[24.767] → [24.767:817]

            dig_dir.x = pos.x == place.x? -1 : 1;

[24.767]

[24.817]

            dig_dir.x = pos.x == place.pos.x? -1 : 1;

Replacement in crawl-ref/source/dungeon.cc at line 3411 [5.3429798]
B:BD[24.830] → [24.830:861]
```
        if (place.height == 1)
```
[24.830]
[24.861]
```
        if (place.size.y == 1)
```

Replacement in crawl-ref/source/dungeon.cc at line 3417 [5.3429798]

B:BD[24.1043] → [24.1043:1093]

            dig_dir.y = pos.y == place.y? -1 : 1;

[24.1043]

[24.1093]

            dig_dir.y = pos.y == place.pos.y? -1 : 1;

Replacement in crawl-ref/source/dungeon.cc at line 3487 [5.3429798]

B:BD[12.4104] → [25.754:828]

            if (!place.map.in_map(coord_def(xi - place.x, yi - place.y)))

[12.4104]

[12.4158]

            if (!place.map.in_map(coord_def(xi, yi) - place.pos))

Replacement in crawl-ref/source/dungeon.cc at line 3495 [5.3429798]

B:BD[12.4351] → [12.4351:4488]

    for (int y = place.y + 1; y < place.y + place.height - 1; ++y)
        for (int x = place.x + 1; x < place.x + place.width - 1; ++x)

[12.4351]

[12.4488]

    for (int y = place.pos.y + 1; y < place.pos.y + place.size.y - 1; ++y)
        for (int x = place.pos.x + 1; x < place.pos.x + place.size.x - 1; ++x)

Replacement in crawl-ref/source/dungeon.cc at line 3508 [5.3429798]

B:BD[6.153293] → [6.153293:153352]

    for (int y = place.y; y < place.y + place.height; ++y)

[6.153293]

[6.153352]

    for (int y = place.pos.y; y < place.pos.y + place.size.y; ++y)

Replacement in crawl-ref/source/dungeon.cc at line 3510 [5.3429798]

B:BD[6.153358] → [26.281:322]

∅:D[26.322] → [6.153398:153461]

B:BD[6.153398] → [6.153398:153461]

B:BD[6.153461] → [26.323:382]

∅:D[26.382] → [6.153519:153600]

B:BD[6.153519] → [6.153519:153600]

        if (grid_needs_exit(place.x, y))
            possible_exits.push_back( coord_def(place.x, y) );
        if (grid_needs_exit(place.x + place.width - 1, y))
            possible_exits.push_back( coord_def(place.x + place.width - 1, y) );

[6.153358]

[6.153600]

        if (grid_needs_exit(place.pos.x, y))
            possible_exits.push_back( coord_def(place.pos.x, y) );
        if (grid_needs_exit(place.pos.x + place.size.x - 1, y))
            possible_exits.push_back(
                coord_def(place.pos.x + place.size.x - 1, y) );

Replacement in crawl-ref/source/dungeon.cc at line 3517 [5.3429798]

B:BD[6.153607] → [6.153607:153673]

    for (int x = place.x + 1; x < place.x + place.width - 1; ++x)

[6.153607]

[6.153673]

    for (int x = place.pos.x + 1; x < place.pos.x + place.size.x - 1; ++x)

Replacement in crawl-ref/source/dungeon.cc at line 3519 [5.3429798]

B:BD[6.153679] → [26.383:424]

∅:D[26.424] → [6.153719:153782]

B:BD[6.153719] → [6.153719:153782]

B:BD[6.153782] → [26.425:485]

        if (grid_needs_exit(x, place.y))
            possible_exits.push_back( coord_def(x, place.y) );
        if (grid_needs_exit(x, place.y + place.height - 1))

[6.153679]

[6.153841]

        if (grid_needs_exit(x, place.pos.y))
            possible_exits.push_back( coord_def(x, place.pos.y) );
        if (grid_needs_exit(x, place.pos.y + place.size.y - 1))

Replacement in crawl-ref/source/dungeon.cc at line 3523 [5.3429798]

B:BD[6.153879] → [6.153879:153939]

                coord_def(x, place.y + place.height - 1) );

[6.153879]

[6.153939]

                coord_def(x, place.pos.y + place.size.y - 1) );

Insertion in crawl-ref/source/dungeon.cc at line 3641 [5.3429798]

[27.352]

[28.4200]

// 
// You can specify the centre of the map using "where" for floating vaults
// and minivaults. "where" is ignored for other vaults. XXX: it might be
// nice to specify a square that is not the centre, but is identified by
// a marker in the vault to be placed.

Replacement in crawl-ref/source/dungeon.cc at line 3655 [5.3429798]

∅:D[27.709] → [11.6690:6755]

B:BD[11.6690] → [11.6690:6755]

bool dgn_place_map(int map, bool generating_level, bool clobber)

[27.709]

[11.6755]

bool dgn_place_map(int map, bool generating_level, bool clobber,
                   const coord_def &where)

Replacement in crawl-ref/source/dungeon.cc at line 3683 [5.3429798]

B:BD[11.6877] → [11.6877:6955]

            build_minivaults(you.your_level, map, generating_level, clobber);

[11.6877]

[11.6955]

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

Replacement in crawl-ref/source/dungeon.cc at line 3691 [5.3429798]

B:BD[11.7204] → [11.7204:7272]

                                        generating_level, clobber);

[11.7204]

[11.7272]

                                        generating_level, clobber, where);

Replacement in crawl-ref/source/dungeon.cc at line 3698 [5.3429798]

B:BD[11.7421] → [11.7421:7475]

        for (int y = vp.y; y < vp.y + vp.height; ++y)

[11.7421]

[11.7475]

        for (int y = vp.pos.y; y < vp.pos.y + vp.size.y; ++y)

Replacement in crawl-ref/source/dungeon.cc at line 3700 [5.3429798]

B:BD[11.7485] → [11.7485:7542]

            for (int x = vp.x; x < vp.x + vp.width; ++x)

[11.7485]

[11.7542]

            for (int x = vp.pos.x; x < vp.pos.x + vp.size.x; ++x)

Replacement in crawl-ref/source/dungeon.cc at line 3733 [5.3429798]

B:BD[11.8053] → [11.8053:8101]

                                  bool clobber)

[11.8053]

[8.7977]

                                  bool clobber, const coord_def &where)

Replacement in crawl-ref/source/dungeon.cc at line 3736 [5.3429798]

B:BD[11.8168] → [11.8168:8217]

                     generating_level, clobber))

[11.8168]

[8.8040]

                     generating_level, clobber, where))

Replacement in crawl-ref/source/dungeon.cc at line 3748 [5.3429798]

B:BD[11.8283] → [11.8283:8345]

                         bool generating_level, bool clobber)

[11.8283]

[5.3597423]

                         bool generating_level, bool clobber,
                         const coord_def &where)

Insertion in crawl-ref/source/dungeon.cc at line 3773 [5.3429798]
[5.3598736]
[11.8346]
```
    if (map_bounds(where))
        place.pos = where;
    
```

Replacement in crawl-ref/source/dungeon.cc at line 3785 [5.3429798]

B:BD[5.3599021] → [8.8516:8588]

    dgn_region this_vault(place.x, place.y, place.width, place.height);

[5.3599021]

    dgn_region this_vault(place.pos, place.size);

Replacement in crawl-ref/source/dungeon.cc at line 3788 [5.3429798]

B:BD[5.3599112] → [21.1752:1809]

    for (vx = place.x; vx < place.x + place.width; vx++)

[5.3599112]

[5.3599145]

    for (vx = place.pos.x; vx < place.pos.x + place.size.x; vx++)

Replacement in crawl-ref/source/dungeon.cc at line 3790 [5.3429798]

B:BD[5.3599151] → [21.1810:1872]

        for (vy = place.y; vy < place.y + place.height; vy++)

[5.3599151]

[5.3599188]

        for (vy = place.pos.y; vy < place.pos.y + place.size.y; vy++)

Replacement in crawl-ref/source/dungeon.cc at line 3817 [5.3429798]
B:BD[5.3599495] → [3.6476:6539]
```
    place.map.map.apply_overlays(coord_def(place.x, place.y));
```
[5.3599495]
[29.5019]
```
    place.map.map.apply_overlays(place.pos);
```

Replacement in crawl-ref/source/dungeon.cc at line 3842 [5.3429798]

B:BD[4.969586] → [30.1802:1955]

    const int v1x = place.x;
    const int v1y = place.y;
    const int v2x = place.x + place.width - 1;
    const int v2y = place.y + place.height - 1;

[4.969586]

[5.3600413]

    const int v1x = place.pos.x;
    const int v1y = place.pos.y;
    const int v2x = place.pos.x + place.size.x - 1;
    const int v2y = place.pos.y + place.size.y - 1;

Replacement in crawl-ref/source/dungeon.cc at line 4261 [5.3429798]

B:BD[2.322] → [2.322:450]

        && (vx == place.x || vy == place.y || vx == place.x + place.width - 1
            || vy == place.y + place.height - 1))

[2.322]

[2.450]

        && (vx == place.pos.x || vy == place.pos.y
            || vx == place.pos.x + place.size.x - 1
            || vy == place.pos.y + place.size.y - 1))

Replacement in crawl-ref/source/dungeon.cc at line 5966 [5.3429798]

B:BD[20.4585] → [20.4585:4642]

        int ex = place.width / 4, ey = place.height / 4;

[20.4585]

[20.4642]

        int ex = place.size.x / 4, ey = place.size.y / 4;

Replacement in crawl-ref/source/dungeon.cc at line 5985 [5.3429798]

B:BD[20.5089] → [20.5089:5164]

            for (int y = rplace.y; y <= rplace.y + rplace.height - 1; ++y)

[20.5089]

[20.5164]

            for (int y = rplace.pos.y;
                 y <= rplace.pos.y + rplace.size.y - 1; ++y)

Replacement in crawl-ref/source/dungeon.cc at line 5988 [5.3429798]

B:BD[20.5178] → [20.5178:5257]

                for (int x = rplace.x; x <= rplace.x + rplace.height - 1; ++x)

[20.5178]

[20.5257]

                for (int x = rplace.pos.x;
                     x <= rplace.pos.x + rplace.size.x - 1; ++x)

Replacement in crawl-ref/source/dungeon.cc at line 5999 [5.3429798]

B:BD[20.5514] → [20.5514:5644]

        place.x = rplace.x;
        place.y = rplace.y;
        place.width = rplace.width;
        place.height = rplace.height;

[20.5514]

[31.2025]

        place.pos  = rplace.pos;
        place.size = rplace.size;

Replacement in crawl-ref/source/dungeon.cc at line 6002 [5.3429798]

B:BD[31.2026] → [31.2026:2137]

        pad_region(dgn_region(place.x, place.y, place.width, place.height),
                   1, DNGN_FLOOR);

[31.2026]

[32.3029]

        pad_region(dgn_region(place.pos, place.size), 1, DNGN_FLOOR);

Replacement in crawl-ref/source/dungeon.cc at line 6006 [5.3429798]

B:BD[32.3191] → [32.3191:3295]

        end = coord_def(place.x + place.width / 2,
                        place.y + place.height / 2);

[32.3089]

[19.1154]

        end = place.pos + place.size / 2;

Replacement in crawl-ref/source/debug.cc at line 2845 [5.4016436]
B:BD[11.9275] → [11.9275:9335]
```
static void debug_load_map_by_name(const std::string &name)
```
[11.9275]
[11.9335]
```
static void debug_load_map_by_name(std::string name)
```
Insertion in crawl-ref/source/debug.cc at line 2847 [5.4016436]
[11.9337]
[11.9337]
```
    const bool place_on_us = strip_tag(name, "*", true);
    
```

Replacement in crawl-ref/source/debug.cc at line 2880 [5.4016436]

B:BD[11.9519] → [11.9519:9560]

    if (dgn_place_map(map, false, true))

[11.9519]

[11.9560]

    const map_def *toplace = map_by_index(map);
    coord_def where(-1, -1);
    if ((toplace->orient == MAP_FLOAT || toplace->orient == MAP_NONE)
        && place_on_us)
    {
        where = you.pos();
    }
    
    if (dgn_place_map(map, false, true, where))