fiddlerwoaroof/crawl - Change SIDH2P7NBIG5KEOE27XHD3ZT2NQ2OJZFN6VZXWNWYFFY5YVXSSVQC

Massive overhaul to move towards coord_def().

This might have introduced some bugs: I now get intermittent crashes on startup (this might have to do with the changes to special_room.) Sorry about that - committing before I need to do any more big conflict resolutions. Fixes coming later.

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

Created by haranp on July 30, 2008

SIDH2P7NBIG5KEOE27XHD3ZT2NQ2OJZFN6VZXWNWYFFY5YVXSSVQC

Dependencies

In channels

main

Change contents

Replacement in crawl-ref/source/xom.cc at line 707 [46.3]

B:BD[31.479] → [31.479:565]

            beam.target_x     = you.x_pos;
            beam.target_y     = you.y_pos;

[31.479]

[31.565]

            beam.target       = you.pos();

Replacement in crawl-ref/source/view.h at line 154 [49.13254]

B:BD[47.97] → [48.182:231]

void set_envmap_obj( int x, int y, int object );

[47.97]

[50.4]

void set_envmap_obj( const coord_def& where, int object );

Insertion in crawl-ref/source/view.h at line 159 [49.13254]

[48.266]

[51.373]

inline int get_envmap_obj(const coord_def& c) {
    return get_envmap_obj(c.x, c.y);
}

Insertion in crawl-ref/source/view.h at line 163 [49.13254]

[51.440]

inline void set_envmap_detected_item(const coord_def& c, bool detected = true) {
    set_envmap_detected_item(c.x, c.y, detected);
}

Insertion in crawl-ref/source/view.h at line 168 [49.13254]

[51.507]

[52.4]

inline void set_envmap_detected_mons(const coord_def& c, bool detected = true) {
    set_envmap_detected_mons(c.x, c.y, detected);
}

Insertion in crawl-ref/source/view.h at line 179 [49.13254]

[51.595]

[53.6]

inline bool is_envmap_detected_mons(const coord_def& c) {
    return is_envmap_detected_mons(c.x, c.y);
}

Insertion in crawl-ref/source/view.h at line 183 [49.13254]

[53.41]

[51.595]

inline bool is_envmap_item(const coord_def& c) {
    return is_envmap_item(c.x, c.y);
}

Insertion in crawl-ref/source/view.h at line 187 [49.13254]

[51.636]

inline void set_terrain_mapped( const coord_def& c ) {
    set_terrain_mapped(c.x,c.y);
}

Insertion in crawl-ref/source/view.h at line 191 [49.13254]

[51.675]

[54.5]

inline void set_terrain_seen( const coord_def& c ) {
    set_terrain_seen(c.x, c.y);
}

Insertion in crawl-ref/source/view.h at line 198 [49.13254]

[55.45]

[56.5]

inline bool is_terrain_changed( const coord_def& c ) {
    return is_terrain_changed(c.x,c.y);
}

Replacement in crawl-ref/source/view.cc at line 117 [49.16817]
B:BD[48.843] → [57.8:47]
```
static void _get_symbol( int x, int y,
```
[48.843]
[57.47]
```
static void _get_symbol( const coord_def& where,
```
Replacement in crawl-ref/source/view.cc at line 206 [49.16817]
B:BD[49.21113] → [48.2104:2149]
```
void set_envmap_obj( int x, int y, int obj )
```
[49.21113]
[51.4017]
```
void set_envmap_obj( const coord_def& where, int obj )
```
Replacement in crawl-ref/source/view.cc at line 208 [49.16817]
B:BD[51.4019] → [48.2150:2182]
```
    env.map[x][y].object = obj;
```
[51.4019]
[58.635]
```
    env.map(where).object = obj;
```
Replacement in crawl-ref/source/view.cc at line 210 [49.16817]
B:BD[58.651] → [40.40:72]
```
    tiles.update_minimap(x, y);
```
[58.651]
[58.736]
```
    tiles.update_minimap(where.x, where.y);
```
Insertion in crawl-ref/source/view.cc at line 298 [49.16817]
[49.21918]
[51.4900]
```
void clear_envmap_grid( const coord_def& p )
{
    env.map(p).clear();
}
```

Replacement in crawl-ref/source/view.cc at line 384 [49.16817]

B:BD[48.2974] → [57.925:981]

    _get_symbol(0, 0, object, &ch, NULL, magic_mapped);

[48.2974]

[48.3029]

    _get_symbol(coord_def(0,0), object, &ch, NULL, magic_mapped);

Replacement in crawl-ref/source/view.cc at line 388 [49.16817]

B:BD[49.33008] → [57.982:1058]

static int _view_emphasised_colour(int x, int y, dungeon_feature_type feat,

[49.33008]

[57.1058]

static int _view_emphasised_colour(const coord_def& where,
                                   dungeon_feature_type feat,

Replacement in crawl-ref/source/view.cc at line 392 [49.16817]

B:BD[59.147] → [59.147:227]

    if (is_travelable_stair(feat) && !travel_cache.know_stair(coord_def(x, y)))

[59.147]

[59.227]

    if (is_travelable_stair(feat) && !travel_cache.know_stair(where))

Replacement in crawl-ref/source/view.cc at line 401 [49.16817]
B:BD[60.294] → [57.1124:1169]
```
static bool _show_bloodcovered(int x, int y)
```
[60.294]
[60.338]
```
static bool _show_bloodcovered(const coord_def& where)
```
Replacement in crawl-ref/source/view.cc at line 403 [49.16817]
B:BD[60.340] → [61.941:983]
```
    if (!is_bloodcovered(coord_def(x,y)))
```
[60.340]
[60.371]
```
    if (!is_bloodcovered(where))
```
Replacement in crawl-ref/source/view.cc at line 406 [49.16817]
B:BD[60.396] → [60.396:439]
```
    dungeon_feature_type grid = grd[x][y];
```
[60.396]
[60.439]
```
    dungeon_feature_type grid = grd(where);
```
Replacement in crawl-ref/source/view.cc at line 412 [49.16817]
B:BD[59.372] → [57.1170:1209]
```
static void _get_symbol( int x, int y,
```
[59.372]
[57.1209]
```
static void _get_symbol( const coord_def& where,
```

Replacement in crawl-ref/source/view.cc at line 431 [49.16817]

B:BD[61.1053] → [61.1053:1103]

                && is_sanctuary(coord_def(x,y)) )

[61.1053]

[62.375]

                && is_sanctuary(where) )

Replacement in crawl-ref/source/view.cc at line 433 [49.16817]

B:BD[62.389] → [62.389:454]

                if (env.map[x][y].property == FPROP_SANCTUARY_1)

[62.389]

[62.454]

                if (env.map(where).property == FPROP_SANCTUARY_1)

Replacement in crawl-ref/source/view.cc at line 435 [49.16817]

B:BD[62.502] → [62.502:572]

                else if (env.map[x][y].property == FPROP_SANCTUARY_2)

[62.502]

[62.572]

                else if (env.map(where).property == FPROP_SANCTUARY_2)

Replacement in crawl-ref/source/view.cc at line 445 [49.16817]

B:BD[60.591] → [57.1355:1431]

            else if (object < NUM_REAL_FEATURES && _show_bloodcovered(x,y))

[60.591]

[60.666]

            else if (object < NUM_REAL_FEATURES && _show_bloodcovered(where))

Replacement in crawl-ref/source/view.cc at line 449 [49.16817]

B:BD[62.898] → [60.722:797]

            else if (object < NUM_REAL_FEATURES && env.grid_colours[x][y])

[62.898]

[63.98]

            else if (object < NUM_REAL_FEATURES && env.grid_colours(where))

Replacement in crawl-ref/source/view.cc at line 451 [49.16817]

B:BD[63.112] → [63.112:172]

                *colour = env.grid_colours[x][y] | colmask;

[63.112]

[63.172]

                *colour = env.grid_colours(where) | colmask;

Replacement in crawl-ref/source/view.cc at line 463 [49.16817]

∅:D[57.1481] → [63.566:643]

B:BD[63.566] → [63.566:643]

                            x, y, static_cast<dungeon_feature_type>(object),

[57.1481]

[63.643]

                            where, static_cast<dungeon_feature_type>(object),

Replacement in crawl-ref/source/view.cc at line 467 [49.16817]

B:BD[64.31] → [65.8:72]

            if (object < NUM_REAL_FEATURES && inside_halo(x, y)

[64.31]

[6.8]

            if (object < NUM_REAL_FEATURES && inside_halo(where)

Replacement in crawl-ref/source/view.cc at line 476 [49.16817]

B:BD[51.6940] → [66.210:253]

        if ((x || y) && fdef.is_notable())

[51.6940]

[67.181]

        if ((!where.origin()) && fdef.is_notable())

Replacement in crawl-ref/source/view.cc at line 478 [49.16817]

B:BD[67.256] → [67.256:296]

                                x, y );

[67.256]

[51.7019]

                                where );

Replacement in crawl-ref/source/view.cc at line 655 [49.16817]

B:BD[59.1218] → [57.1944:2014]

            _view_emphasised_colour(x, y, grid_value, feature_colour,

[59.1218]

[57.2014]

            _view_emphasised_colour(coord_def(x, y), grid_value, feature_colour,

Insertion in crawl-ref/source/view.cc at line 702 [49.16817]

[68.7543]

[51.9144]

            // FIXME convert to using p everywhere.
            const coord_def p(x,y);

Replacement in crawl-ref/source/view.cc at line 727 [49.16817]

B:BD[49.39967] → [48.4178:4251]

            set_envmap_obj(x, y, is_terrain_known(x, y)? grd[x][y] : 0);

[49.39967]

[51.9884]

            set_envmap_obj(p, is_terrain_known(p)? grd(p) : 0);

Replacement in crawl-ref/source/view.cc at line 732 [49.16817]

B:BD[58.1079] → [58.1079:1152]

            set_envmap_obj(x, y, is_terrain_known(x, y)? grd[x][y] : 0);

[58.1079]

[58.1152]

            set_envmap_obj(p, is_terrain_known(p)? grd(p) : 0);

Replacement in crawl-ref/source/view.cc at line 734 [49.16817]

B:BD[58.1190] → [58.1190:1250]

            env.tile_bk_bg[x][y] = is_terrain_known(x, y) ?

[58.1190]

[69.74]

            env.tile_bk_bg[x][y] = is_terrain_known(p) ?

Replacement in crawl-ref/source/view.cc at line 1105 [49.16817]

B:BD[70.484] → [70.484:578]

    const int ex = monster->x - you.x_pos + 9;
    const int ey = monster->y - you.y_pos + 9;

[70.484]

[70.578]

    const coord_def e = monster->pos() - you.pos() + coord_def(9,9);

Replacement in crawl-ref/source/view.cc at line 1110 [49.16817]

B:BD[70.655] → [70.655:717]

        if (grd[monster->x][monster->y] == DNGN_SHALLOW_WATER

[70.655]

[70.717]

        if (grd(monster->pos()) == DNGN_SHALLOW_WATER

Replacement in crawl-ref/source/view.cc at line 1114 [49.16817]

B:BD[70.820] → [57.2371:2409]

B:BD[57.2409] → [71.7:62]

∅:D[71.62] → [72.12:53]

B:BD[70.908] → [72.12:53]

            _set_show_backup(ex, ey);
            env.show[ex][ey]     = DNGN_INVIS_EXPOSED;
            env.show_col[ex][ey] = BLUE;

[70.820]

[70.950]

            _set_show_backup(e.x, e.y);
            env.show[e.x][e.y]     = DNGN_INVIS_EXPOSED;
            env.show_col[e.x][e.y] = BLUE;

Replacement in crawl-ref/source/view.cc at line 1123 [49.16817]
B:BD[70.1069] → [57.2410:2444]
```
        _set_show_backup(ex, ey);
```
[70.1069]
[70.1102]
```
        _set_show_backup(e.x, e.y);
```

Replacement in crawl-ref/source/view.cc at line 1125 [49.16817]

B:BD[70.1103] → [71.102:169]

∅:D[71.169] → [70.1166:1221]

B:BD[70.1166] → [70.1166:1221]

    env.show[ex][ey]     = monster->type + DNGN_START_OF_MONSTERS;
    env.show_col[ex][ey] = get_mons_colour( monster );

[70.1103]

[58.1364]

    env.show[e.x][e.y]     = monster->type + DNGN_START_OF_MONSTERS;
    env.show_col[e.x][e.y] = get_mons_colour( monster );

Replacement in crawl-ref/source/view.cc at line 1152 [49.16817]

B:BD[73.231] → [73.231:282]

            if (mgrd[monster->x][monster->y] != s)

[73.231]

[73.282]

            if (mgrd(monster->pos()) != s)

Replacement in crawl-ref/source/view.cc at line 1160 [49.16817]

∅:D[74.103] → [73.630:676]

B:BD[73.630] → [73.630:676]

                     monster->x, monster->y);

[74.103]

[73.676]

                     monster->pos().x, monster->pos().y);

Replacement in crawl-ref/source/view.cc at line 1162 [49.16817]

B:BD[73.683] → [73.683:802]

                ASSERT(mgrd[monster->x][monster->y] == NON_MONSTER);
                mgrd[monster->x][monster->y] = s;

[73.683]

[73.802]

                ASSERT(mgrd(monster->pos()) == NON_MONSTER);
                mgrd(monster->pos()) = s;

Replacement in crawl-ref/source/view.cc at line 1170 [49.16817]

B:BD[58.1383] → [58.1383:1448]

            tile_place_monster(monster->x, monster->y, s, true);

[58.1383]

[58.1448]

            tile_place_monster(monster->pos().x, monster->pos().y, s, true);

Replacement in crawl-ref/source/view.cc at line 1396 [49.16817]

B:BD[49.49112] → [70.1826:1909]

B:BD[49.49220] → [70.1910:1979]

    coord_def gp;
    for (gp.y = (you.y_pos - 8); (gp.y < you.y_pos + 9); gp.y++)
        for (gp.x = (you.x_pos - 8); (gp.x < you.x_pos + 9); gp.x++)

[49.49112]

[49.49298]

    for (radius_iterator ri(you.pos(), LOS_RADIUS, true, false); ri; ++ri)
    {
        if (igrd(*ri) != NON_ITEM)

Replacement in crawl-ref/source/view.cc at line 1400 [49.16817]

B:BD[49.49308] → [57.3028:3083]

∅:D[70.2011] → [49.49388:49402]

∅:D[57.3083] → [49.49388:49402]

B:BD[49.49388] → [49.49388:49402]

B:BD[49.49402] → [57.3084:3236]

∅:D[57.3236] → [49.54297:54311]

B:BD[49.54297] → [49.54297:54311]

            if (in_bounds(gp) && igrd(gp) != NON_ITEM)
            {
                const coord_def ep = gp - you.pos() + coord_def(9, 9);
                if (env.show(ep))
                    _update_item_grid(gp, ep);
            }

[49.49308]

[70.2219]

            const coord_def ep = *ri - you.pos() + coord_def(9, 9);
            if (env.show(ep))
                _update_item_grid(*ri, ep);

Insertion in crawl-ref/source/view.cc at line 1404 [49.16817]
[70.2229]
[70.2230]
```
    }
```

Replacement in crawl-ref/source/view.cc at line 1411 [49.16817]

B:BD[75.899] → [57.3237:3307]

    _get_symbol( 0, 0, _get_item_dngn_code( *item ), glych, glycol );

[75.899]

[75.967]

    _get_symbol( coord_def(0,0), _get_item_dngn_code( *item ), glych, glycol );

Replacement in crawl-ref/source/view.cc at line 1418 [49.16817]

B:BD[75.1123] → [57.3308:3385]

    _get_symbol( 0, 0, mons->type + DNGN_START_OF_MONSTERS, glych, glycol );

[75.1123]

[70.2233]

    _get_symbol( coord_def(0,0), mons->type + DNGN_START_OF_MONSTERS,
                 glych, glycol );

Replacement in crawl-ref/source/view.cc at line 1425 [49.16817]

B:BD[70.2322] → [70.2322:2436]

    const int ex = env.cloud[cloudno].x - you.x_pos + 9;
    const int ey = env.cloud[cloudno].y - you.y_pos + 9;

[70.2322]

[76.379]

    const coord_def e = env.cloud[cloudno].pos - you.pos() + coord_def(9,9);

Replacement in crawl-ref/source/view.cc at line 1485 [49.16817]

B:BD[70.3832] → [57.3438:3468]

B:BD[57.3468] → [71.170:209]

∅:D[71.209] → [77.425:466]

B:BD[70.3896] → [77.425:466]

    _set_show_backup(ex, ey);
    env.show[ex][ey]     = DNGN_CLOUD;
    env.show_col[ex][ey] = which_colour;

[70.3832]

[58.1629]

    _set_show_backup(e.x, e.y);
    env.show(e)     = DNGN_CLOUD;
    env.show_col(e) = which_colour;

Replacement in crawl-ref/source/view.cc at line 1490 [49.16817]

B:BD[58.1646] → [77.467:521]

    tile_place_cloud(ex, ey, env.cloud[cloudno].type,

[58.1646]

[77.521]

    tile_place_cloud(e.x, e.y, env.cloud[cloudno].type,

Replacement in crawl-ref/source/view.cc at line 1509 [49.16817]

B:BD[49.54859] → [49.54859:54917]

            if (see_grid(env.cloud[s].x, env.cloud[s].y))

[49.54858]

[57.3469]

            if (see_grid(env.cloud[s].pos))

Replacement in crawl-ref/source/view.cc at line 1615 [49.16817]

B:BD[78.1440] → [78.1440:1501]

                     you.x_pos, you.y_pos, player_distance);

[78.1440]

[78.1501]

                     you.pos().x, you.pos().y, player_distance);

Replacement in crawl-ref/source/view.cc at line 1654 [49.16817]

B:BD[78.2768] → [78.2768:2822]

                             monster->x, monster->y);

[78.2768]

[78.2822]

                             monster->pos().x, monster->pos().y);

Replacement in crawl-ref/source/view.cc at line 1663 [49.16817]

B:BD[78.3130] → [78.3130:3207]

                 monster->name(DESC_PLAIN).c_str(), monster->x, monster->y);

[78.3130]

[78.3207]

                 monster->name(DESC_PLAIN).c_str(),
                 monster->pos().x, monster->pos().y);

Replacement in crawl-ref/source/view.cc at line 3124 [49.16817]

B:BD[56.303] → [56.303:369]

    find_travel_pos(you.x_pos, you.y_pos, NULL, NULL, &features);

[56.303]

[56.369]

    find_travel_pos(you.pos(), NULL, NULL, &features);

Replacement in crawl-ref/source/view.cc at line 3147 [49.16817]

B:BD[49.75299] → [79.1190:1260]

        find_travel_pos(you.x_pos, you.y_pos, NULL, NULL, &features);

[49.75299]

[79.1260]

        find_travel_pos(you.pos(), NULL, NULL, &features);

Replacement in crawl-ref/source/view.cc at line 3187 [49.16817]
B:BD[79.2244] → [79.2244:2274]
```
    int screen_y = you.y_pos;
```
[79.2244]
[79.2274]
```
    int screen_y = you.pos().y;
```

Replacement in crawl-ref/source/view.cc at line 3204 [49.16817]

B:BD[79.2969] → [48.6181:6280]

    int curs_x = you.x_pos - start_x + 1;
    int curs_y = you.y_pos - screen_y + half_screen + 1;

[79.2969]

[79.3060]

    int curs_x = you.pos().x - start_x + 1;
    int curs_y = you.pos().y - screen_y + half_screen + 1;

Replacement in crawl-ref/source/view.cc at line 3272 [49.16817]

B:BD[68.24562] → [68.24562:24636]

            find_travel_pos(you.x_pos, you.y_pos, NULL, NULL, &features);

[68.24562]

[68.24636]

            find_travel_pos(you.pos(), NULL, NULL, &features);

Replacement in crawl-ref/source/view.cc at line 3484 [49.16817]

∅:D[48.6700] → [79.8717:8782]

B:BD[79.8717] → [79.8717:8782]

            if (travel_mode && x == you.x_pos && y == you.y_pos)

[48.6700]

[79.8782]

            if (travel_mode && x == you.pos().x && y == you.pos().y)

Deletion in crawl-ref/source/view.cc at line 3608 [49.16817]
∅:D[80.380] → [81.345:346]
B:BD[81.345] → [81.345:346]
∅:D[81.346] → [49.79137:79170]
B:BD[49.79137] → [49.79137:79170]
```
    int i, j, k, l, empty_count;
```

Replacement in crawl-ref/source/view.cc at line 3619 [49.16817]

∅:D[54.204] → [49.79222:79292]

∅:D[51.37772] → [49.79222:79292]

B:BD[49.79222] → [49.79222:79292]

B:BD[49.79298] → [49.79298:79382]

B:BD[49.79382] → [51.37773:37837]

∅:D[51.37837] → [49.79425:79497]

B:BD[49.79425] → [49.79425:79497]

B:BD[49.79497] → [51.37838:37900]

∅:D[51.37900] → [49.79497:79498]

B:BD[49.79497] → [49.79497:79498]

B:BD[49.79498] → [51.37901:37975]

    for (i = you.x_pos - map_radius; i < you.x_pos + map_radius; i++)
        for (j = you.y_pos - map_radius; j < you.y_pos + map_radius; j++)
        {
            if (proportion < 100 && random2(100) >= proportion)
                continue;       // note that proportion can be over 100
            if (!map_bounds(i, j))
                continue;
            const int dist = grid_distance( you.x_pos, you.y_pos, i, j );

[54.204]

[51.37975]

    for ( radius_iterator ri(you.pos(), map_radius, true, false); ri; ++ri )
    {
        if (proportion < 100 && random2(100) >= proportion)
            continue;       // note that proportion can be over 100
        
        const int dist = grid_distance( you.pos(), *ri );

Replacement in crawl-ref/source/view.cc at line 3626 [49.16817]

B:BD[51.37976] → [51.37976:38051]

            if (dist > pfar && one_chance_in(3))
                continue;

[51.37976]

[51.38051]

        if (dist > pfar && one_chance_in(3))
            continue;

Replacement in crawl-ref/source/view.cc at line 3629 [49.16817]
B:BD[51.38052] → [51.38052:38099]
∅:D[51.38099] → [49.79564:79590]
B:BD[49.79564] → [49.79564:79590]
```
            if (dist > very_far && coinflip())
                continue;
```
[51.38052]
[51.38100]
```
        if (dist > very_far && coinflip())
            continue;
```

Replacement in crawl-ref/source/view.cc at line 3632 [49.16817]

B:BD[51.38101] → [51.38101:38184]

            if (is_terrain_changed(i, j))
                clear_envmap_grid(i, j);

[51.38101]

[49.79590]

        if (is_terrain_changed(*ri))
            clear_envmap_grid(*ri);

Replacement in crawl-ref/source/view.cc at line 3636 [49.16817]

B:BD[58.2933] → [58.2933:3001]

B:BD[58.3001] → [82.249:432]

∅:D[82.432] → [58.3203:3217]

B:BD[58.3203] → [58.3203:3217]

            if (!wizard_map && is_terrain_known(i,j))
            {
                // Can't use set_envmap_obj because that would
                // overwrite the gmap.
                env.tile_bk_bg[i][j] = tile_idx_unseen_terrain(i, j, grd[i][j]);
            }

[58.2933]

[58.3217]

        if (!wizard_map && is_terrain_known(*ri))
        {
            // Can't use set_envmap_obj because that would
            // overwrite the gmap.
            env.tile_bk_bg(*ri) = tile_idx_unseen_terrain(ri->x, ri->y,
                                                          grd(*ri));
        }

Replacement in crawl-ref/source/view.cc at line 3644 [49.16817]
B:BD[58.3224] → [58.3224:3225]
∅:D[58.3225] → [54.205:260]
B:BD[49.79591] → [54.205:260]
∅:D[54.260] → [49.79651:79677]
∅:D[68.27066] → [49.79651:79677]
∅:D[51.38225] → [49.79651:79677]
B:BD[49.79651] → [49.79651:79677]
```
            if (!wizard_map && is_terrain_known(i, j))
                continue;
```
[58.3224]
[49.79677]
```
        
        if (!wizard_map && is_terrain_known(*ri))
            continue;
```
Replacement in crawl-ref/source/view.cc at line 3648 [49.16817]
B:BD[49.79678] → [49.79678:79707]
```
            empty_count = 8;
```
[49.79678]
[49.79707]
```
        bool open = true;
```

Replacement in crawl-ref/source/view.cc at line 3650 [49.16817]

B:BD[49.79708] → [51.38226:38301]

            if (grid_is_solid(grd[i][j]) && grd[i][j] != DNGN_CLOSED_DOOR)

[49.79708]

[49.79780]

        if (grid_is_solid(grd(*ri)) && grd(*ri) != DNGN_CLOSED_DOOR)
        {
            open = false;
            for ( adjacent_iterator ai(*ri); ai; ++ai )

Replacement in crawl-ref/source/view.cc at line 3655 [49.16817]

B:BD[49.79794] → [51.38302:38344]

B:BD[49.79852] → [51.38345:38391]

∅:D[51.38391] → [49.79896:79918]

B:BD[49.79896] → [49.79896:79918]

B:BD[49.79918] → [51.38392:38438]

∅:D[51.38438] → [49.79964:80002]

B:BD[49.79964] → [49.79964:80002]

                for (k = -1; k <= 1; k++)
                    for (l = -1; l <= 1; l++)
                    {
                        if (k == 0 && l == 0)
                            continue;

[49.79794]

[49.80002]

                if (map_bounds(*ai) && (!grid_is_opaque(grd(*ai))
                                        || grd(*ai) == DNGN_CLOSED_DOOR))
                {
                    open = true;
                    break;
                }
            }
        }

Replacement in crawl-ref/source/view.cc at line 3664 [49.16817]

B:BD[49.80003] → [51.38439:38496]

∅:D[51.38496] → [49.80125:80151]

B:BD[49.80125] → [49.80125:80151]

B:BD[49.80151] → [51.38497:38578]

∅:D[51.38578] → [49.80194:80220]

B:BD[49.80194] → [49.80194:80220]

                        if (!map_bounds( i + k, j + l ))
                        {
                            --empty_count;
                            continue;
                        }

[49.80003]

[51.38579]

        if (open > 0)
        {
            if (wizard_map || !get_envmap_obj(*ri))
                set_envmap_obj(*ri, grd(*ri));

Replacement in crawl-ref/source/view.cc at line 3669 [49.16817]

B:BD[51.38580] → [83.5:69]

B:BD[83.69] → [84.8:104]

∅:D[84.104] → [51.38717:38760]

B:BD[51.38717] → [51.38717:38760]

B:BD[51.38760] → [84.105:131]

∅:D[84.131] → [49.80220:80242]

∅:D[51.38760] → [49.80220:80242]

B:BD[49.80220] → [49.80220:80242]

B:BD[49.80260] → [49.80260:80308]

                        if (grid_is_opaque( grd[i + k][j + l] )
                            && grd[i + k][j + l] != DNGN_CLOSED_DOOR)
                        {
                            empty_count--;
                        }
                    }
            }
            if (empty_count > 0)

[51.38580]

[51.38761]

            // Hack to give demonspawn Pandemonium mutation the ability
            // to detect exits magically.
            if (wizard_map
                || player_mutation_level(MUT_PANDEMONIUM) > 1
                && grd(*ri) == DNGN_EXIT_PANDEMONIUM)

Replacement in crawl-ref/source/view.cc at line 3675 [49.16817]

B:BD[51.38775] → [54.261:318]

∅:D[54.318] → [48.6819:6872]

B:BD[48.6819] → [48.6819:6872]

∅:D[48.6872] → [85.1823:1824]

B:BD[51.38892] → [85.1823:1824]

B:BD[51.38893] → [51.38893:39015]

B:BD[51.39015] → [84.132:291]

∅:D[84.291] → [85.2070:2088]

∅:D[54.414] → [85.2070:2088]

B:BD[85.2070] → [85.2070:2088]

∅:D[85.2088] → [51.39215:39261]

B:BD[51.39215] → [51.39215:39261]

B:BD[51.39261] → [85.2089:2107]

∅:D[85.2107] → [51.39261:39282]

B:BD[51.39261] → [51.39261:39282]

B:BD[51.39282] → [85.2108:2126]

∅:D[85.2126] → [51.39282:39330]

B:BD[51.39282] → [51.39282:39330]

B:BD[51.39330] → [85.2127:2145]

                if (wizard_map || !get_envmap_obj(i, j))
                    set_envmap_obj(i, j, grd[i][j]);
                // Hack to give demonspawn Pandemonium mutation the ability
                // to detect exits magically.
                if (wizard_map
                    || player_mutation_level(MUT_PANDEMONIUM) > 1
                       && grd[i][j] == DNGN_EXIT_PANDEMONIUM)
                {
                    set_terrain_seen( i, j );
                }
                else
                {
                    set_terrain_mapped( i, j );
                }

[51.38775]

[51.39330]

                set_terrain_seen( *ri );

Insertion in crawl-ref/source/view.cc at line 3677 [49.16817]

[51.39344]

[49.80366]

            else
                set_terrain_mapped( *ri );

Insertion in crawl-ref/source/view.cc at line 3680 [49.16817]
[49.80376]
[57.9046]
```
    }
```
Replacement in crawl-ref/source/view.cc at line 3683 [49.16817]
∅:D[81.364] → [49.80382:80437]
∅:D[86.2262] → [49.80382:80437]
B:BD[49.80382] → [49.80382:80437]
```
}                               // end magic_mapping()
```
[86.2262]
[49.87782]
```
}
```

Replacement in crawl-ref/source/view.cc at line 3695 [49.16817]

B:BD[49.88526] → [49.88526:88668]

        if (monster->x > you.x_pos - 9 && monster->x < you.x_pos + 9
            && monster->y > you.y_pos - 9 && monster->y < you.y_pos + 9)

[49.88526]

[49.88668]

        if ( grid_distance(monster->pos(), you.pos()) <= LOS_RADIUS )

Replacement in crawl-ref/source/view.cc at line 3697 [49.16817]

B:BD[49.88678] → [49.88678:88760]

            if (env.show[monster->x - you.x_pos + 9][monster->y - you.y_pos + 9])

[49.88678]

[49.88760]

            const coord_def diff = monster->pos() - you.pos() + coord_def(9,9);
            if (env.show(diff))

Replacement in crawl-ref/source/view.cc at line 3708 [49.16817]

B:BD[49.88930] → [49.88930:89078]

        if (monster->x > myFoe->x - 9 && monster->x < myFoe->x + 9
            && monster->y > myFoe->y - 9 && monster->y < myFoe->y + 9)
        {

[49.88930]

[49.89078]

        if ( grid_distance( monster->pos(), myFoe->pos() ) <= LOS_RADIUS )

Deletion in crawl-ref/source/view.cc at line 3710 [49.16817]
B:BD[49.89105] → [49.89105:89115]
```
        }
```
Replacement in crawl-ref/source/view.cc at line 4560 [49.16817]
B:BD[51.63656] → [87.57:104]
```
unsigned get_screen_glyph( const coord_def &p)
```
[51.63656]
[87.104]
```
unsigned get_screen_glyph( int x, int y )
```
Replacement in crawl-ref/source/view.cc at line 4562 [49.16817]
B:BD[87.106] → [87.106:145]
```
    return get_screen_glyph(p.x, p.y);
```
[87.106]
[87.145]
```
    return get_screen_glyph(coord_def(x,y));
```
Replacement in crawl-ref/source/view.cc at line 4565 [49.16817]
∅:D[87.148] → [76.383:425]
B:BD[51.63656] → [76.383:425]
```
unsigned get_screen_glyph( int x, int y )
```
[87.148]
[51.63701]
```
unsigned get_screen_glyph( const coord_def& p )
```

Replacement in crawl-ref/source/view.cc at line 4567 [49.16817]

B:BD[51.63703] → [88.184:247]

    const coord_def ep = view2show(grid2view(coord_def(x,y)));

[51.63703]

[49.102291]

    const coord_def ep = view2show(grid2view(p));

Replacement in crawl-ref/source/view.cc at line 4574 [49.16817]
B:BD[51.63920] → [51.63920:63958]
```
        return get_envmap_char(x, y);
```
[51.63920]
[49.102877]
```
        return get_envmap_char(p.x, p.y);
```
Replacement in crawl-ref/source/view.cc at line 4576 [49.16817]
B:BD[49.103108] → [57.9056:9103]
```
    _get_symbol( x, y, object, &ch, &colour );
```
[49.102878]
[51.64090]
```
    _get_symbol( p, object, &ch, &colour );
```

Replacement in crawl-ref/source/view.cc at line 4639 [49.16817]

B:BD[49.104536] → [57.9104:9172]

                _get_symbol( gc.x, gc.y, object, &glych, &glycol );

[49.104473]

[51.65971]

                _get_symbol( gc, object, &glych, &glycol );

Replacement in crawl-ref/source/view.cc at line 4735 [49.16817]
B:BD[70.5065] → [57.9422:9477]
```
    _get_symbol( pos.x, pos.y, object, &ch, &colour );
```
[70.5065]
[70.5119]
```
    _get_symbol( pos, object, &ch, &colour );
```

Replacement in crawl-ref/source/view.cc at line 4873 [49.16817]

B:BD[89.241] → [89.241:377]

                            learned_something_new(TUT_SEEN_ESCAPE_HATCH,
                                                  gc.x, gc.y);

[89.241]

[89.377]

                            learned_something_new(TUT_SEEN_ESCAPE_HATCH, gc);

Replacement in crawl-ref/source/view.cc at line 4876 [49.16817]

B:BD[90.72] → [90.72:152]

                            learned_something_new(TUT_SEEN_BRANCH, gc.x, gc.y);

[90.72]

[61.4073]

                            learned_something_new(TUT_SEEN_BRANCH, gc);

Replacement in crawl-ref/source/view.cc at line 4879 [49.16817]

∅:D[90.179] → [63.899:979]

B:BD[91.358] → [63.899:979]

                            learned_something_new(TUT_SEEN_STAIRS, gc.x, gc.y);

[90.179]

[90.180]

                            learned_something_new(TUT_SEEN_STAIRS, gc);

Replacement in crawl-ref/source/view.cc at line 4882 [49.16817]

∅:D[61.4182] → [48.8188:8267]

B:BD[48.8188] → [48.8188:8267]

                            learned_something_new(TUT_SEEN_ALTAR, gc.x, gc.y);

[61.4182]

[63.980]

                            learned_something_new(TUT_SEEN_ALTAR, gc);

Replacement in crawl-ref/source/view.cc at line 4884 [49.16817]

∅:D[63.1042] → [48.8388:8466]

B:BD[48.8388] → [48.8388:8466]

                            learned_something_new(TUT_SEEN_DOOR, gc.x, gc.y);

[63.1042]

[63.1043]

                            learned_something_new(TUT_SEEN_DOOR, gc);

Replacement in crawl-ref/source/view.cc at line 4886 [49.16817]

∅:D[63.1104] → [48.8586:8664]

B:BD[48.8586] → [48.8586:8664]

                            learned_something_new(TUT_SEEN_SHOP, gc.x, gc.y);

[63.1104]

[90.207]

                            learned_something_new(TUT_SEEN_SHOP, gc);

Replacement in crawl-ref/source/view.cc at line 4892 [49.16817]

B:BD[90.491] → [90.491:571]

                            learned_something_new(TUT_STAIR_BRAND, gc.x, gc.y);

[90.491]

[90.571]

                            learned_something_new(TUT_STAIR_BRAND, gc);

Replacement in crawl-ref/source/view.cc at line 4937 [49.16817]

B:BD[48.9112] → [57.9612:9681]

                    _get_symbol( gc.x, gc.y, object, &ch, &colour );

[48.9112]

[92.450]

                    _get_symbol( gc, object, &ch, &colour );

Replacement in crawl-ref/source/view.cc at line 4978 [49.16817]

B:BD[49.109431] → [57.9682:9751]

                    _get_symbol( gc.x, gc.y, object, &ch, &colour );

[49.109201]

[49.109689]

                    _get_symbol( gc, object, &ch, &colour );

Replacement in crawl-ref/source/view.cc at line 5035 [49.16817]

B:BD[51.72583] → [57.9891:10018]

                            _get_symbol( gc.x, gc.y,
                                         Show_Backup(ep), &ch, &colour );

[51.72583]

[48.10332]

                            _get_symbol( gc, Show_Backup(ep), &ch, &colour );

Replacement in crawl-ref/source/tutorial.h at line 46 [95.3315]

B:BD[93.225] → [94.407:488]

void learned_something_new(tutorial_event_type seen_what, int x = 0, int y = 0);

[93.225]

[96.165]

void learned_something_new(tutorial_event_type seen_what,
                           coord_def gc = coord_def(0,0));

Replacement in crawl-ref/source/tutorial.cc at line 270 [95.5936]

B:BD[97.328] → [97.328:623]

    for (int x = you.x_pos - 10; x <= you.x_pos + 10; x++)
        for (int y = you.y_pos - 10; y <= you.y_pos + 10; y++)
        {
            if (!in_bounds(x,y))
                continue;
            if (grd[x][y] == DNGN_SECRET_DOOR)
                grd[x][y] = DNGN_CLOSED_DOOR;
        }

[97.328]

[97.623]

    for ( radius_iterator ri(you.pos(), 10, true, false); ri; ++ri )
        if ( grd(*ri) == DNGN_SECRET_DOOR )
            grd(*ri) = DNGN_CLOSED_DOOR;

Replacement in crawl-ref/source/tutorial.cc at line 1180 [95.5936]

B:BD[90.2051] → [98.4695:4763]

            learned_something_new(TUT_MONSTER_BRAND, mon.x, mon.y);

[90.2051]

[90.2105]

            learned_something_new(TUT_MONSTER_BRAND, mon.pos());

Replacement in crawl-ref/source/tutorial.cc at line 1182 [95.5936]

B:BD[90.2138] → [98.4764:4835]

            learned_something_new(TUT_MONSTER_FRIENDLY, mon.x, mon.y);

[90.2138]

[90.2195]

            learned_something_new(TUT_MONSTER_FRIENDLY, mon.pos());

Replacement in crawl-ref/source/tutorial.cc at line 1213 [95.5936]
B:BD[99.551] → [98.4836:4874]
```
    const coord_def gc(mon.x, mon.y);
```
[99.551]
[98.4874]
```
    const coord_def gc = mon.pos();
```

Replacement in crawl-ref/source/tutorial.cc at line 1300 [95.5936]

B:BD[90.2250] → [90.2250:2314]

        learned_something_new(TUT_MONSTER_BRAND, mon.x, mon.y);

[90.2250]

[90.2314]

        learned_something_new(TUT_MONSTER_BRAND, mon.pos());

Replacement in crawl-ref/source/tutorial.cc at line 1302 [95.5936]

B:BD[90.2343] → [90.2343:2410]

        learned_something_new(TUT_MONSTER_FRIENDLY, mon.x, mon.y);

[90.2343]

[100.30280]

        learned_something_new(TUT_MONSTER_FRIENDLY, mon.pos());

Replacement in crawl-ref/source/tutorial.cc at line 1308 [95.5936]
B:BD[94.10738] → [94.10738:10783]
```
    if (mgrd[item.x][item.y] != NON_MONSTER)
```
[94.10738]
[94.10783]
```
    if (mgrd(item.pos) != NON_MONSTER)
```
Replacement in crawl-ref/source/tutorial.cc at line 1318 [95.5936]
∅:D[94.10886] → [101.313:365]
B:BD[101.313] → [101.313:365]
```
            && mgrd[item.x][item.y] == NON_MONSTER)
```
[94.10886]
[101.365]
```
            && mgrd(item.pos) == NON_MONSTER)
```

Replacement in crawl-ref/source/tutorial.cc at line 1320 [95.5936]

B:BD[101.375] → [101.375:444]

            learned_something_new(TUT_SEEN_CARRION, item.x, item.y);

[101.375]

[101.444]

            learned_something_new(TUT_SEEN_CARRION, item.pos);

Replacement in crawl-ref/source/tutorial.cc at line 1340 [95.5936]
B:BD[102.716] → [98.4984:5036]
```
    const coord_def gc = coord_def(item.x, item.y);
```
[102.716]
[98.5036]
```
    const coord_def gc = item.pos;
```

Replacement in crawl-ref/source/tutorial.cc at line 1436 [95.5936]

B:BD[100.31385] → [93.402:474]

void learned_something_new(tutorial_event_type seen_what, int x, int y)

[100.31385]

[103.557]

void learned_something_new(tutorial_event_type seen_what, coord_def gc)

Replacement in crawl-ref/source/tutorial.cc at line 1449 [95.5936]

B:BD[99.1482] → [99.1482:1558]

    const int ex = x - you.x_pos + 9;
    const int ey = y - you.y_pos + 9;

[99.1482]

[48.10997]

    const coord_def e = gc - you.pos() + coord_def(9,9);

Deletion in crawl-ref/source/tutorial.cc at line 1453 [95.5936]
B:BD[104.2720] → [102.847:853]
B:BD[102.853] → [98.5147:5177]
```
#else
    const coord_def gc(x, y);
```
Replacement in crawl-ref/source/tutorial.cc at line 1639 [95.5936]
B:BD[101.866] → [96.6112:6142]
```
        if (x <= 0 || y <= 0)
```
[101.866]
[96.6142]
```
        if (gc.x <= 0 || gc.y <= 0)
```
Replacement in crawl-ref/source/tutorial.cc at line 1643 [95.5936]
B:BD[96.6202] → [96.6202:6234]
```
            int i = igrd[x][y];
```
[96.6202]
[96.6234]
```
            int i = igrd(gc);
```
Replacement in crawl-ref/source/tutorial.cc at line 1778 [95.5936]
∅:D[105.4353] → [90.9343:9382]
B:BD[96.10522] → [90.9343:9382]
```
        if (mgrd[x][y] != NON_MONSTER)
```
[105.4353]
[90.9382]
```
        if (mgrd(gc) != NON_MONSTER)
```

Replacement in crawl-ref/source/tutorial.cc at line 1781 [95.5936]

B:BD[103.669] → [96.10584:10658]

        object = env.show[ex][ey];
        colour = env.show_col[ex][ey];

[103.669]

[96.10658]

        object = env.show(e);
        colour = env.show_col(e);

Replacement in crawl-ref/source/tutorial.cc at line 1806 [95.5936]
B:BD[90.9473] → [90.9473:9512]
```
        if (mgrd[x][y] != NON_MONSTER)
```
[90.9473]
[90.9512]
```
        if (mgrd(gc) != NON_MONSTER)
```

Replacement in crawl-ref/source/tutorial.cc at line 1811 [95.5936]

B:BD[99.4379] → [96.11418:11492]

        object = env.show[ex][ey];
        colour = env.show_col[ex][ey];

[99.4379]

[96.11492]

        object = env.show(e);
        colour = env.show_col(e);

Replacement in crawl-ref/source/tutorial.cc at line 1835 [95.5936]
∅:D[105.4423] → [90.9662:9701]
B:BD[90.9662] → [90.9662:9701]
```
        if (mgrd[x][y] != NON_MONSTER)
```
[105.4423]
[90.9701]
```
        if (mgrd(gc) != NON_MONSTER)
```

Replacement in crawl-ref/source/tutorial.cc at line 1839 [95.5936]

∅:D[105.4497] → [90.9794:9868]

B:BD[90.9794] → [90.9794:9868]

        object = env.show[ex][ey];
        colour = env.show_col[ex][ey];

[105.4497]

[90.9868]

        object = env.show(e);
        colour = env.show_col(e);

Replacement in crawl-ref/source/tutorial.cc at line 1868 [95.5936]

B:BD[105.4698] → [105.4698:4775]

        if (mgrd[x][y] != NON_MONSTER || (you.x_pos == x && you.y_pos == y))

[105.4698]

[90.11114]

        if (mgrd(gc) != NON_MONSTER || (you.pos() == gc))

Replacement in crawl-ref/source/tutorial.cc at line 1879 [95.5936]
B:BD[96.12064] → [106.133:179]
```
        if (x == you.x_pos && y == you.y_pos)
```
[96.12064]
[106.179]
```
        if (you.pos() == gc)
```

Replacement in crawl-ref/source/tutorial.cc at line 1887 [95.5936]

B:BD[99.4740] → [96.12242:12316]

        object = env.show[ex][ey];
        colour = env.show_col[ex][ey];

[99.4740]

[96.12316]

        object = env.show(e);
        colour = env.show_col(e);

Replacement in crawl-ref/source/tutorial.cc at line 1904 [95.5936]

B:BD[99.5054] → [96.12756:12830]

        object = env.show[ex][ey];
        colour = env.show_col[ex][ey];

[99.5054]

[96.12830]

        object = env.show(e);
        colour = env.show_col(e);

Replacement in crawl-ref/source/tutorial.cc at line 1936 [95.5936]

B:BD[99.5268] → [96.13615:13686]

             << _colourize_glyph(YELLOW, get_screen_glyph(x,y)) << " "

[99.5268]

[99.5370]

             << _colourize_glyph(YELLOW, get_screen_glyph(gc)) << " "

Replacement in crawl-ref/source/tutorial.cc at line 1956 [95.5936]

B:BD[99.5496] → [96.14092:14162]

             << _colourize_glyph(WHITE, get_screen_glyph(x,y)) << " "

[99.5496]

[99.5578]

             << _colourize_glyph(WHITE, get_screen_glyph(gc)) << " "

Replacement in crawl-ref/source/tutorial.cc at line 1975 [95.5936]

B:BD[90.11624] → [90.11624:11694]

             << _colourize_glyph(WHITE, get_screen_glyph(x,y)) << " "

[90.11624]

[107.19134]

             << _colourize_glyph(WHITE, get_screen_glyph(gc)) << " "

Replacement in crawl-ref/source/tutorial.cc at line 2492 [95.5936]

B:BD[90.14369] → [90.14369:14456]

        const god_type new_god   = (god_type) x;
        const int      old_piety = y;

[90.14369]

[90.14456]

        const god_type new_god   = (god_type) gc.x;
        const int      old_piety = gc.y;

Replacement in crawl-ref/source/travel.h at line 85 [68.29464]

B:BD[68.30491] → [108.134:205]

void find_travel_pos(int you_x, int you_y, char *move_x, char *move_y,

[68.30491]

[68.31480]

void find_travel_pos(const coord_def& youpos, char *move_x, char *move_y,

Replacement in crawl-ref/source/travel.h at line 112 [68.29464]
B:BD[68.32179] → [68.32179:32212]
```
void start_travel(int x, int y);
```
[68.32179]
[68.32212]
```
void start_travel(const coord_def& p);
```

Replacement in crawl-ref/source/travel.h at line 486 [68.29464]

B:BD[68.37497] → [68.37497:37653]

    // Updates/creates a StairInfo for the stair at (x, y) in grid coordinates
    void update_stair(int x, int y, const level_pos &p, bool guess = false);

[68.37497]

[68.37653]

    // Updates/creates a StairInfo for the stair at stairpos in grid coordinates
    void update_stair(const coord_def& stairpos, const level_pos &p,
                      bool guess = false);

Replacement in crawl-ref/source/travel.cc at line 189 [68.39949]

B:BD[68.45034] → [68.45034:45096]

        int x = env.trap[i].x,
            y = env.trap[i].y;

[68.45034]

[109.586]

        int x = env.trap[i].pos.x,
            y = env.trap[i].pos.y;

Replacement in crawl-ref/source/travel.cc at line 596 [68.39949]
B:BD[51.87199] → [51.87199:87242]
```
bool is_branch_stair(int gridx, int gridy)
```
[51.87199]
[51.87242]
```
bool is_branch_stair(const coord_def& pos)
```
Deletion in crawl-ref/source/travel.cc at line 598 [68.39949]
B:BD[51.87244] → [110.2112:2151]
∅:D[110.2151] → [68.59775:59776]
∅:D[51.87282] → [68.59775:59776]
B:BD[68.59775] → [68.59775:59776]
```
    const coord_def pos(gridx, gridy);
```
Replacement in crawl-ref/source/travel.cc at line 763 [68.39949]
B:BD[50.736] → [109.3050:3101]
```
static bool _is_valid_explore_target(int x, int y)
```
[50.736]
[50.786]
```
static bool _is_valid_explore_target(const coord_def& where)
```

Replacement in crawl-ref/source/travel.cc at line 766 [68.39949]

B:BD[50.842] → [50.842:879]

B:BD[50.885] → [50.885:990]

    for (int yi = -1; yi <= 1; ++yi)
        for (int xi = -1; xi <= 1; ++xi)
        {
            if (!xi && !yi)
                continue;

[50.842]

[50.990]

    for ( adjacent_iterator ai(where); ai; ++ai )
        if (!is_terrain_seen(*ai))
            return (true);

Deletion in crawl-ref/source/travel.cc at line 770 [68.39949]

B:BD[50.991] → [50.991:1101]

B:BD[50.1101] → [48.11399:11441]

∅:D[48.11441] → [50.1163:1204]

B:BD[50.1163] → [50.1163:1204]

B:BD[50.1210] → [50.1210:1211]

            const int ax = x + xi, ay = y + yi;
            if (!in_bounds(ax, ay))
                continue;
            if (!is_terrain_seen(ax, ay))
                return (true);
        }

Replacement in crawl-ref/source/travel.cc at line 773 [68.39949]
∅:D[111.196] → [50.1320:1368]
B:BD[50.1320] → [50.1320:1368]
```
        return (lev && lev->needs_visit(x, y));
```
[111.196]
[50.1368]
```
        return (lev && lev->needs_visit(where));
```
Replacement in crawl-ref/source/travel.cc at line 822 [68.39949]
B:BD[112.592] → [112.592:652]
```
    you.running.x = target.x;
    you.running.y = target.y;
```
[112.592]
[112.687]
```
    you.running.pos = target;
```
Replacement in crawl-ref/source/travel.cc at line 1037 [68.39949]
∅:D[113.1013] → [114.2333:2390]
B:BD[68.64404] → [114.2333:2390]
```
        if (grd[you.x_pos][you.y_pos] == DNGN_ENTER_SHOP
```
[113.1013]
[114.2390]
```
        if (grd(you.pos()) == DNGN_ENTER_SHOP
```
Replacement in crawl-ref/source/travel.cc at line 1041 [68.39949]
∅:D[111.262] → [114.2514:2582]
B:BD[114.2514] → [114.2514:2582]
```
            if (lev && lev->shop_needs_visit(you.x_pos, you.y_pos))
```
[111.262]
[114.2582]
```
            if (lev && lev->shop_needs_visit(you.pos()))
```

Replacement in crawl-ref/source/travel.cc at line 1050 [68.39949]

B:BD[50.1529] → [50.1529:1556]

B:BD[50.1556] → [115.165:237]

B:BD[115.237] → [109.4053:4125]

        if (!you.running.x
            || you.running.x == you.x_pos && you.running.y == you.y_pos
            || !_is_valid_explore_target(you.running.x, you.running.y))

[50.1529]

[50.1701]

        if (!you.running.pos.x
            || you.running.pos == you.pos()
            || !_is_valid_explore_target(you.running.pos))

Replacement in crawl-ref/source/travel.cc at line 1058 [68.39949]

B:BD[68.64572] → [51.88141:88200]

    if (you.running == RMODE_INTERLEVEL && !you.running.x)

[68.64572]

[68.64625]

    if (you.running == RMODE_INTERLEVEL && !you.running.pos.x)

Replacement in crawl-ref/source/travel.cc at line 1063 [68.39949]

B:BD[68.64843] → [9.135:208]

        if (!_find_transtravel_square(level_target.p) || !you.running.x)

[68.64843]

[68.64910]

        if (!_find_transtravel_square(level_target.p) || !you.running.pos.x)

Replacement in crawl-ref/source/travel.cc at line 1075 [68.39949]

B:BD[68.65281] → [68.65281:65344]

        find_travel_pos(you.x_pos, you.y_pos, move_x, move_y);

[68.65281]

[116.14]

        find_travel_pos(you.pos(), move_x, move_y);

Replacement in crawl-ref/source/travel.cc at line 1095 [68.39949]

B:BD[116.350] → [116.350:452]

            const int new_x = you.x_pos + *move_x;
            const int new_y = you.y_pos + *move_y;

[116.350]

[116.452]

            const coord_def newpos = you.pos() + coord_def(*move_x, *move_y);

Replacement in crawl-ref/source/travel.cc at line 1097 [68.39949]

B:BD[116.453] → [116.453:519]

            if (new_x == you.running.x && new_y == you.running.y)

[116.453]

[116.519]

            if (newpos == you.running.pos)

Replacement in crawl-ref/source/travel.cc at line 1100 [68.39949]

∅:D[111.338] → [116.605:724]

B:BD[116.605] → [116.605:724]

                if (lev && lev->needs_visit(new_x, new_y)
                    && !lev->shop_needs_visit(new_x, new_y))

[111.338]

[116.724]

                if (lev && lev->needs_visit(newpos)
                    && !lev->shop_needs_visit(newpos))

Replacement in crawl-ref/source/travel.cc at line 1110 [68.39949]

B:BD[117.1544] → [117.1544:1615]

                        explore_stopped_pos = coord_def(new_x, new_y);

[117.1544]

[116.860]

                        explore_stopped_pos = newpos;

Replacement in crawl-ref/source/travel.cc at line 1125 [68.39949]

B:BD[68.65770] → [51.88351:88425]

            if (you.x_pos == you.running.x && you.y_pos == you.running.y)

[68.65770]

[68.65836]

            if (you.pos() == you.running.pos)

Replacement in crawl-ref/source/travel.cc at line 1181 [68.39949]

B:BD[51.89031] → [51.89031:89086]

                    you.running.x = you.running.y = 0;

[51.89031]

[68.68019]

                    you.running.pos.reset();

Replacement in crawl-ref/source/travel.cc at line 1733 [68.39949]
B:BD[85.22377] → [118.1382:1423]
```
void find_travel_pos(int youx, int youy,
```
[85.22377]
[85.22419]
```
void find_travel_pos(const coord_def& youpos,
```
Replacement in crawl-ref/source/travel.cc at line 1740 [68.39949]
B:BD[85.22576] → [119.666:672]
∅:D[119.672] → [85.22576:22687]
B:BD[85.22576] → [85.22576:22687]
B:BD[85.22687] → [119.673:679]
```
    {
        tp.set_src_dst(coord_def(youx, youy),
                       coord_def(you.running.x, you.running.y));
    }
```
[85.22576]
[85.22687]
```
        tp.set_src_dst(youpos, you.running.pos);
```
Replacement in crawl-ref/source/travel.cc at line 1742 [68.39949]
B:BD[85.22696] → [85.22696:22745]
```
        tp.set_floodseed(coord_def(youx, youy));
```
[85.22696]
[85.22745]
```
        tp.set_floodseed(youpos);
```
Replacement in crawl-ref/source/travel.cc at line 1751 [68.39949]
B:BD[85.22917] → [85.22917:22953]
```
    if (dest.x == 0 && dest.y == 0)
```
[85.22917]
[85.22953]
```
    if (dest.origin())
```

Replacement in crawl-ref/source/travel.cc at line 1758 [68.39949]

B:BD[85.23072] → [85.23072:23138]

        *move_x = dest.x - youx;
        *move_y = dest.y - youy;

[85.23072]

[85.23138]

        *move_x = dest.x - youpos.x;
        *move_y = dest.y - youpos.y;

Replacement in crawl-ref/source/travel.cc at line 2374 [68.39949]
B:BD[120.371] → [121.5107:5155]
```
        start_travel(pos.p.pos.x, pos.p.pos.y);
```
[120.371]
[120.415]
```
        start_travel(pos.p.pos);
```
Replacement in crawl-ref/source/travel.cc at line 2427 [68.39949]
B:BD[51.91567] → [51.91567:91610]
```
        you.running.x = you.running.y = 0;
```
[51.91567]
[68.96353]
```
        you.running.pos.reset();
```
Replacement in crawl-ref/source/travel.cc at line 2435 [68.39949]
B:BD[68.96709] → [122.823:883]
```
    return grid_stair_direction(grd[you.x_pos][you.y_pos]);
```
[68.96709]
[68.96764]
```
    return grid_stair_direction(grd(you.pos()));
```

Replacement in crawl-ref/source/travel.cc at line 2503 [68.39949]

B:BD[85.23455] → [119.807:921]

            if (!deltadist
                && (stair.x != target.pos.x || stair.y != target.pos.y))
            {

[85.23455]

[68.100194]

            if (!deltadist && stair != target.pos)

Deletion in crawl-ref/source/travel.cc at line 2505 [68.39949]
B:BD[68.100226] → [119.922:936]
```
            }
```

Replacement in crawl-ref/source/travel.cc at line 2521 [68.39949]

B:BD[68.100951] → [68.100951:101017]

B:BD[68.101017] → [9.209:264]

            if (player_level == target.id && stair.x == you.x_pos
                && stair.y == you.y_pos)
            {

[68.100951]

[68.101062]

            if (player_level == target.id && stair == you.pos())

Deletion in crawl-ref/source/travel.cc at line 2523 [68.39949]
B:BD[68.101103] → [9.265:279]
```
            }
```

Replacement in crawl-ref/source/travel.cc at line 2558 [68.39949]

B:BD[85.23533] → [109.9108:9228]

            if (!deltadist
                && (you.x_pos != si.position.x || you.y_pos != si.position.y))
            {

[85.23533]

[68.102398]

            if (!deltadist && you.pos() != si.position)

Deletion in crawl-ref/source/travel.cc at line 2560 [68.39949]
B:BD[68.102430] → [109.9229:9243]
```
            }
```

Replacement in crawl-ref/source/travel.cc at line 2607 [68.39949]

B:BD[68.103626] → [123.727:866]

                    if (cur == player_level && you.x_pos == stair.x
                        && you.y_pos == stair.y)
                    {

[68.103626]

[68.103747]

                    if (cur == player_level && you.pos() == stair)

Deletion in crawl-ref/source/travel.cc at line 2609 [68.39949]
B:BD[68.103797] → [123.867:889]
```
                    }
```

Replacement in crawl-ref/source/travel.cc at line 2649 [68.39949]

B:BD[68.105290] → [109.9744:9871]

                if (cur == player_level && you.x_pos == stair.x
                    && you.y_pos == stair.y)
                {

[68.105290]

[68.105403]

                if (cur == player_level && you.pos() == stair)

Deletion in crawl-ref/source/travel.cc at line 2651 [68.39949]
B:BD[68.105449] → [109.9872:9890]
```
                }
```
Replacement in crawl-ref/source/travel.cc at line 2689 [68.39949]
∅:D[85.23573] → [68.106181:106248]
B:BD[68.106181] → [68.106181:106248]
```
    find_travel_pos(target.pos.x, target.pos.y, NULL, NULL, NULL);
```
[85.23573]
[68.106248]
```
    find_travel_pos(target.pos, NULL, NULL, NULL);
```
Replacement in crawl-ref/source/travel.cc at line 2714 [68.39949]
B:BD[110.2509] → [110.2509:2556]
```
    coord_def cur_stair(you.x_pos, you.y_pos);
```
[110.2509]
[118.2484]
```
    coord_def cur_stair(you.pos());
```
Replacement in crawl-ref/source/travel.cc at line 2720 [68.39949]
B:BD[68.107079] → [68.107079:107140]
```
    find_travel_pos(you.x_pos, you.y_pos, NULL, NULL, NULL);
```
[68.107079]
[68.107140]
```
    find_travel_pos(you.pos(), NULL, NULL, NULL);
```

Replacement in crawl-ref/source/travel.cc at line 2732 [68.39949]

B:BD[68.107359] → [51.91885:91961]

        you.running.x = best_stair.x;
        you.running.y = best_stair.y;

[68.107359]

[121.5858]

        you.running.pos = best_stair;

Replacement in crawl-ref/source/travel.cc at line 2760 [68.39949]
B:BD[68.107933] → [68.107933:107965]
```
void start_travel(int x, int y)
```
[68.107933]
[68.107965]
```
void start_travel(const coord_def& p)
```
Replacement in crawl-ref/source/travel.cc at line 2763 [68.39949]
B:BD[68.107992] → [124.110:152]
```
    if (x == you.x_pos && y == you.y_pos)
```
[68.107992]
[125.3657]
```
    if (p == you.pos())
```
Replacement in crawl-ref/source/travel.cc at line 2767 [68.39949]
B:BD[126.207] → [126.207:251]
```
    you.travel_x = x;
    you.travel_y = y;
```
[126.207]
[68.108043]
```
    you.travel_x = p.x;
    you.travel_y = p.y;
```

Replacement in crawl-ref/source/travel.cc at line 2773 [68.39949]

∅:D[121.5904] → [85.23650:23696]

B:BD[51.91994] → [85.23650:23696]

B:BD[85.23696] → [109.10684:10753]

    you.running.x = x;
    you.running.y = y;
    level_target  = level_pos(level_id::current(), coord_def(x, y));

[121.5904]

[118.2522]

    you.running.pos = p;
    level_target  = level_pos(level_id::current(), p);

Replacement in crawl-ref/source/travel.cc at line 2813 [68.39949]
B:BD[114.4146] → [116.1064:1103]
```
    you.running.x = you.running.y = 0;
```
[114.4146]
[109.10781]
```
    you.running.pos.reset();
```

Replacement in crawl-ref/source/travel.cc at line 3040 [68.39949]

B:BD[68.116084] → [118.2532:2600]

∅:D[118.2600] → [127.237:280]

B:BD[68.116153] → [127.237:280]

        find_travel_pos(stairs[s].position.x, stairs[s].position.y,
                        NULL, NULL, NULL);

[68.116084]

[68.116188]

        find_travel_pos(stairs[s].position, NULL, NULL, NULL);

Replacement in crawl-ref/source/travel.cc at line 3059 [68.39949]

B:BD[68.116687] → [68.116687:116762]

void LevelInfo::update_stair(int x, int y, const level_pos &p, bool guess)

[68.116687]

[68.116762]

void LevelInfo::update_stair(const coord_def& stairpos, const level_pos &p,
                             bool guess)

Replacement in crawl-ref/source/travel.cc at line 3062 [68.39949]
B:BD[68.116764] → [68.116764:116802]
```
    stair_info *si = get_stair(x, y);
```
[68.116764]
[68.116802]
```
    stair_info *si = get_stair(stairpos);
```
Replacement in crawl-ref/source/travel.cc at line 3094 [68.39949]
B:BD[128.1678] → [128.1678:1732]
```
        create_placeholder_stair(coord_def(x, y), p);
```
[128.1672]
[68.117695]
```
        create_placeholder_stair(stairpos, p);
```

Replacement in crawl-ref/source/travel.cc at line 3288 [68.39949]

B:BD[68.121427] → [48.11651:11685]

B:BD[68.121526] → [48.11686:11724]

    for (int y = 0; y < GYM; ++y)
        for (int x = 0; x < GXM; ++x)

[68.121427]

[68.121568]

    for ( rectangle_iterator ri(1); ri; ++ri )
    {
        const dungeon_feature_type grid = grd(*ri);
        const int envc = env.map(*ri).object;
        if ((*ri == you.pos() || envc)
            && is_travelable_stair(grid)
            && (is_terrain_seen(*ri) || !is_branch_stair(*ri)))

Replacement in crawl-ref/source/travel.cc at line 3297 [68.39949]
B:BD[68.121578] → [129.1127:1178]
∅:D[129.1178] → [48.11759:11804]
B:BD[48.11759] → [48.11759:11804]
∅:D[130.475] → [68.121694:121695]
∅:D[131.1875] → [68.121694:121695]
∅:D[48.11804] → [68.121694:121695]
B:BD[68.121694] → [68.121694:121695]
B:BD[68.121695] → [109.12051:12110]
∅:D[109.12110] → [118.2837:2882]
B:BD[128.2991] → [118.2837:2882]
∅:D[118.2882] → [128.3037:3107]
B:BD[128.3037] → [128.3037:3107]
∅:D[128.3107] → [68.121746:121866]
∅:D[48.11964] → [68.121746:121866]
∅:D[51.92494] → [68.121746:121866]
B:BD[68.121746] → [68.121746:121866]
B:BD[68.121866] → [48.11965:12010]
∅:D[110.2645] → [68.121918:121969]
∅:D[48.12010] → [68.121918:121969]
B:BD[68.121918] → [68.121918:121969]
```
            dungeon_feature_type grid = grd[x][y];
            int envc = env.map[x][y].object;
            if ((x == you.x_pos && y == you.y_pos || envc)
                && is_travelable_stair(grid)
                && (is_terrain_seen(x, y) || !is_branch_stair(x, y)))
            {
                // Convert to grid coords, because that's what we use
                // everywhere else.
                const coord_def stair(x, y);
                st.push_back(stair);
            }
```
[68.121578]
[68.121969]
```
            st.push_back(*ri);
```
Insertion in crawl-ref/source/travel.cc at line 3299 [68.39949]
[68.121979]
[68.121985]
```
    }
```
Insertion in crawl-ref/source/travel.cc at line 3548 [68.39949]
[68.127674]
[68.127855]
```
    coord_def pos(x,y);
```
Replacement in crawl-ref/source/travel.cc at line 3550 [68.39949]
B:BD[68.127883] → [68.127883:127941]
B:BD[68.127941] → [110.2646:2677]
```
    {
        x = you.x_pos;
        y = you.y_pos;
    }
    const coord_def pos(x, y);
```
[68.127883]
[132.2849]
```
        pos = you.pos();
```
Replacement in crawl-ref/source/travel.cc at line 3685 [68.39949]
B:BD[51.92705] → [51.92705:92748]
```
    : runmode(0), mp(0), hp(0), x(0), y(0)
```
[51.92705]
[51.92748]
```
    : runmode(0), mp(0), hp(0), pos(0,0)
```
Replacement in crawl-ref/source/travel.cc at line 3699 [68.39949]
B:BD[51.93028] → [51.93028:93058]
```
        x = 0;
        y = 0;
```
[51.93028]
[51.93058]
```
        pos.reset();
```
Replacement in crawl-ref/source/travel.cc at line 3706 [68.39949]
B:BD[51.93144] → [51.93144:93200]
```
        x = Compass[dir].x;
        y = Compass[dir].y;
```
[51.93144]
[51.93200]
```
        pos = Compass[dir];
```

Replacement in crawl-ref/source/travel.cc at line 3754 [68.39949]

B:BD[51.94247] → [51.94247:94331]

    run_check[index].dx = Compass[dir].x;
    run_check[index].dy = Compass[dir].y;

[51.94247]

[51.94331]

    run_check[index].delta = Compass[dir];

Replacement in crawl-ref/source/travel.cc at line 3756 [68.39949]

B:BD[51.94332] → [51.94332:94434]

    const int targ_x = you.x_pos + Compass[dir].x;
    const int targ_y = you.y_pos + Compass[dir].y;

[51.94332]

[51.94434]

    const coord_def targ = you.pos() + Compass[dir];

Replacement in crawl-ref/source/travel.cc at line 3758 [68.39949]

B:BD[51.94435] → [109.12839:12911]

    run_check[index].grid = _base_grid_type( grd[ targ_x ][ targ_y ] );

[51.94435]

[51.94506]

    run_check[index].grid = _base_grid_type( grd(targ) );

Replacement in crawl-ref/source/travel.cc at line 3775 [68.39949]

B:BD[51.94858] → [51.94858:94922]

    if (env.cgrid[you.x_pos + x][you.y_pos + y] != EMPTY_CLOUD)

[51.94858]

[51.94922]

    if (env.cgrid(you.pos() + pos) != EMPTY_CLOUD)

Replacement in crawl-ref/source/travel.cc at line 3778 [68.39949]
B:BD[51.94946] → [51.94946:95005]
```
    if (mgrd[you.x_pos + x][you.y_pos + y] != NON_MONSTER)
```
[51.94946]
[51.95005]
```
    if (mgrd(you.pos() + pos) != NON_MONSTER)
```

Replacement in crawl-ref/source/travel.cc at line 3783 [68.39949]

B:BD[51.95067] → [51.95067:95179]

B:BD[51.95179] → [133.233:280]

B:BD[133.280] → [109.12912:12968]

        const int targ_x = you.x_pos + run_check[i].dx;
        const int targ_y = you.y_pos + run_check[i].dy;
        const dungeon_feature_type targ_grid =
            _base_grid_type( grd[ targ_x ][ targ_y ] );

[51.95067]

[51.95252]

        const coord_def targ = you.pos() + run_check[i].delta;
        const dungeon_feature_type targ_grid = _base_grid_type(grd(targ));

Replacement in crawl-ref/source/travel.cc at line 3812 [68.39949]
B:BD[51.95766] → [134.233:271]
```
    return (runmode > 0 && !x && !y);
```
[51.95766]
[114.4147]
```
    return (runmode > 0 && pos.origin());
```
Replacement in crawl-ref/source/travel.cc at line 3844 [68.39949]
B:BD[51.96034] → [51.96034:96049]
```
    x = y = 0;
```
[51.96034]
[51.96049]
```
    pos.reset();
```
Replacement in crawl-ref/source/traps.cc at line 279 [135.5308]
B:BD[135.11193] → [135.11193:11257]
```
    pbolt.target_x = you.x_pos;
    pbolt.target_y = you.y_pos;
```
[135.11193]
[135.11257]
```
    pbolt.target = you.pos();
```
Replacement in crawl-ref/source/traps.cc at line 328 [135.5308]
B:BD[135.12336] → [61.5787:5841]
```
    trap_item( base_type, sub_type, pbolt.target() );
```
[135.12336]
[135.12406]
```
    trap_item( base_type, sub_type, pbolt.target );
```

Replacement in crawl-ref/source/traps.cc at line 410 [135.5308]

B:BD[136.300] → [136.300:368]

                grd[you.x_pos][you.y_pos] = DNGN_UNDISCOVERED_TRAP;

[136.300]

[136.368]

                grd(you.pos()) = DNGN_UNDISCOVERED_TRAP;

Replacement in crawl-ref/source/traps.cc at line 452 [135.5308]

B:BD[135.15056] → [61.5975:6049]

            trap_item( OBJ_MISSILES, MI_THROWING_NET, env.trap[i].pos());

[135.15056]

[135.15142]

            trap_item( OBJ_MISSILES, MI_THROWING_NET, env.trap[i].pos);

Replacement in crawl-ref/source/traps.cc at line 456 [135.5308]

B:BD[135.15242] → [61.6097:6146]

            grd(env.trap[i].pos()) = DNGN_FLOOR;

[135.15242]

[135.15302]

            grd(env.trap[i].pos) = DNGN_FLOOR;

Replacement in crawl-ref/source/traps.cc at line 471 [135.5308]

B:BD[137.321] → [137.321:389]

                grd[you.x_pos][you.y_pos] = DNGN_UNDISCOVERED_TRAP;

[137.321]

[137.389]

                grd(you.pos()) = DNGN_UNDISCOVERED_TRAP;

Replacement in crawl-ref/source/traps.cc at line 482 [135.5308]

B:BD[138.592] → [138.592:652]

            grd[env.trap[i].x][env.trap[i].y] = DNGN_FLOOR;

[138.592]

[138.652]

            grd(env.trap[i].pos) = DNGN_FLOOR;

Replacement in crawl-ref/source/traps.cc at line 489 [135.5308]

B:BD[137.432] → [139.952:1016]

            grd[you.x_pos][you.y_pos] = DNGN_UNDISCOVERED_TRAP;

[137.432]

[139.1016]

            grd(you.pos()) = DNGN_UNDISCOVERED_TRAP;

Replacement in crawl-ref/source/traps.cc at line 504 [135.5308]

B:BD[135.15694] → [135.15694:15758]

    learned_something_new(TUT_SEEN_TRAP, you.x_pos, you.y_pos);

[135.15694]

[140.2198]

    learned_something_new(TUT_SEEN_TRAP, you.pos());

Replacement in crawl-ref/source/traps.cc at line 514 [135.5308]

B:BD[141.327] → [142.1028:1141]

        if (env.trap[i].x == pos.x && env.trap[i].y == pos.y
            && env.trap[i].type != TRAP_UNASSIGNED)

[141.327]

[141.443]

        if (env.trap[i].pos == pos && env.trap[i].type != TRAP_UNASSIGNED)

Replacement in crawl-ref/source/traps.cc at line 535 [135.5308]

B:BD[135.16013] → [135.16013:16125]

        if (env.trap[i].x == you.x_pos + disa.dx
            && env.trap[i].y == you.y_pos + disa.dy)
        {

[135.16013]

[135.16125]

        if (env.trap[i].pos == you.pos() + disa.delta)

Deletion in crawl-ref/source/traps.cc at line 537 [135.5308]
B:BD[135.16144] → [135.16144:16154]
```
        }
```

Replacement in crawl-ref/source/traps.cc at line 568 [135.5308]

B:BD[135.16748] → [139.1040:1164]

            if (env.trap[i].type == TRAP_NET
                && (env.trap[i].x != you.x_pos || env.trap[i].y != you.y_pos))

[135.16748]

[135.16872]

            if (env.trap[i].type == TRAP_NET && env.trap[i].pos != you.pos())

Replacement in crawl-ref/source/traps.cc at line 574 [135.5308]

B:BD[135.16998] → [61.6147:6282]

                move_player_to_grid( coord_def(env.trap[i].x, env.trap[i].y),
                                     true, false, true);

[135.16998]

[135.17085]

                move_player_to_grid( env.trap[i].pos, true, false, true);

Replacement in crawl-ref/source/traps.cc at line 588 [135.5308]
B:BD[135.17323] → [135.17323:17345]
```
    struct bolt beam;
```
[135.17323]
[135.17345]
```
    bolt beam;
```

Replacement in crawl-ref/source/traps.cc at line 590 [135.5308]

B:BD[135.17346] → [135.17346:17428]

    beam.target_x = you.x_pos + disa.dx;
    beam.target_y = you.y_pos + disa.dy;

[135.17346]

[135.17428]

    beam.target = you.pos() + disa.delta;

Replacement in crawl-ref/source/traps.cc at line 593 [135.5308]

B:BD[135.17467] → [61.6283:6350]

        trap_item( OBJ_MISSILES, MI_THROWING_NET, beam.target() );

[135.17467]

[135.17549]

        trap_item( OBJ_MISSILES, MI_THROWING_NET, beam.target );

Replacement in crawl-ref/source/traps.cc at line 605 [135.5308]
B:BD[135.17920] → [135.17920:17984]
```
    grd[you.x_pos + disa.dx][you.y_pos + disa.dy] = DNGN_FLOOR;
```
[135.17920]
[135.17984]
```
    grd(you.pos() + disa.delta) = DNGN_FLOOR;
```
Replacement in crawl-ref/source/traps.cc at line 975 [135.5308]
B:BD[135.23940] → [61.6888:6933]
```
        if (env.trap[which_trap].pos() == xy
```
[135.23940]
[143.302]
```
        if (env.trap[which_trap].pos == xy
```
Replacement in crawl-ref/source/tilesdl.cc at line 867 [98.19415]
B:BD[98.40233] → [98.40233:40255]
```
    if (item.x != -1)
```
[98.40233]
[98.40255]
```
    if (item.pos.x != -1)
```

Replacement in crawl-ref/source/tilesdl.cc at line 935 [98.19415]

B:BD[98.42124] → [98.42124:42202]

    for (int i = igrd[you.x_pos][you.y_pos]; i != NON_ITEM; i = mitm[i].link)

[98.42124]

[98.42202]

    for (int i = igrd(you.pos()); i != NON_ITEM; i = mitm[i].link)

Replacement in crawl-ref/source/tilesdl.cc at line 962 [98.19415]

B:BD[98.43000] → [98.43000:43082]

        for (int i = igrd[you.x_pos][you.y_pos]; i != NON_ITEM; i = mitm[i].link)

[98.43000]

[98.43082]

        for (int i = igrd(you.pos()); i != NON_ITEM; i = mitm[i].link)

Replacement in crawl-ref/source/tilereg.cc at line 369 [98.54399]
B:BD[98.63519] → [98.63519:63570]
```
    bool halo = inside_halo(you.x_pos, you.y_pos);
```
[98.63519]
[98.63570]
```
    bool halo = inside_halo(you.pos());
```
Replacement in crawl-ref/source/tilereg.cc at line 1069 [98.54399]
B:BD[98.83156] → [98.83156:83186]
```
    start_travel(gc.x, gc.y);
```
[98.83156]
[98.83186]
```
    start_travel(gc);
```
Replacement in crawl-ref/source/tilereg.cc at line 2061 [98.54399]
B:BD[98.112063] → [98.112063:112101]
```
            start_travel(gc.x, gc.y);
```
[98.112063]
[98.112101]
```
            start_travel(gc);
```
Replacement in crawl-ref/source/tilepick.cc at line 160 [58.96318]
B:BD[144.181] → [144.181:217]
```
    int grid = grd[mon->x][mon->y];
```
[144.181]
[144.217]
```
    int grid = grd(mon->pos());
```

Replacement in crawl-ref/source/tilepick.cc at line 4254 [58.96318]

B:BD[145.1978] → [145.1978:2104]

            const int gx = view2gridX(x + 1) + cx - you.x_pos;
            const int gy = view2gridY(y + 1) + cy - you.y_pos;

[145.1978]

[58.217609]

            const int gx = view2gridX(x + 1) + cx - you.pos().x;
            const int gy = view2gridY(y + 1) + cy - you.pos().y;

Replacement in crawl-ref/source/tilepick.cc at line 4289 [58.96318]
B:BD[146.734] → [146.734:775]
```
                if (inside_halo(gx, gy))
```
[146.734]
[147.4230]
```
                if (inside_halo(gc))
```

Replacement in crawl-ref/source/tilepick.cc at line 4291 [58.96318]

B:BD[147.4248] → [148.539:612]

                    if (see_grid(gx, gy) && mgrd[gx][gy] != NON_MONSTER)

[147.4248]

[146.836]

                    if (see_grid(gc) && mgrd(gc) != NON_MONSTER)

Replacement in crawl-ref/source/tilepick.cc at line 4293 [58.96318]

B:BD[146.1087] → [146.1087:1146]

                        monsters* m = &menv[mgrd[gx][gy]];

[146.858]

[146.1146]

                        monsters* m = &menv[mgrd(gc)];

Replacement in crawl-ref/source/tilepick.cc at line 4304 [58.96318]

B:BD[146.1532] → [36.420:491]

                if (print_blood && is_bloodcovered(coord_def(gx, gy)))

[146.1532]

[146.1592]

                if (print_blood && is_bloodcovered(gc))

Deletion in crawl-ref/source/terrain.cc at line 448 [135.26938]
B:BD[135.36215] → [135.36215:36225]
```
        {
```

Replacement in crawl-ref/source/terrain.cc at line 449 [135.26938]

∅:D[61.7705] → [135.36282:36382]

B:BD[135.36282] → [135.36282:36382]

            {
                s->x = dest.x;
                s->y = dest.y;
            }
        }

[61.7705]

[135.36382]

                s->pos = dest;

Replacement in crawl-ref/source/terrain.cc at line 550 [135.26938]
B:BD[135.38151] → [135.38151:38204]
```
            seen_notable_thing(nfeat, pos.x, pos.y);
```
[135.38151]
[149.1249]
```
            seen_notable_thing(nfeat, pos);
```
Replacement in crawl-ref/source/terrain.cc at line 587 [135.26938]
B:BD[135.38764] → [135.38764:38798]
```
    FixedVector< char, 2 > empty;
```
[135.38764]
[135.38798]
```
    coord_def empty;
```

Replacement in crawl-ref/source/terrain.cc at line 633 [135.26938]

B:BD[135.40060] → [150.280:350]

∅:D[150.350] → [135.40131:40316]

B:BD[135.40131] → [135.40131:40316]

            if (empty_surrounds( you.x_pos, you.y_pos, DNGN_FLOOR, 1,
                                 false, empty ))
            {
                escape = true;
            }
            else
            {
                escape = false;
            }

[135.40060]

[135.40316]

            escape = empty_surrounds(you.pos(), DNGN_FLOOR, 1, false, empty);

Deletion in crawl-ref/source/terrain.cc at line 639 [135.26938]
B:BD[61.7890] → [61.7890:7954]
```
                && (entry.x != empty[0] || entry.y != empty[1])
```

Replacement in crawl-ref/source/terrain.cc at line 642 [135.26938]

B:BD[135.40649] → [61.8002:8074]

                empty[0] = entry.x;
                empty[1] = entry.y;

[135.40649]

[135.40721]

                empty = entry;

Replacement in crawl-ref/source/terrain.cc at line 660 [135.26938]

B:BD[135.40994] → [135.40994:41103]

        const coord_def pos(empty[0], empty[1]);
        if (in_bounds(pos) && !is_grid_dangerous(grd(pos)))

[135.40994]

[135.41103]

        if (in_bounds(empty) && !is_grid_dangerous(grd(empty)))

Replacement in crawl-ref/source/terrain.cc at line 663 [135.26938]

B:BD[135.41162] → [61.8075:8135]

            move_player_to_grid( pos, false, false, true );

[135.41162]

[135.41237]

            move_player_to_grid( empty, false, false, true );

Replacement in crawl-ref/source/tags.cc at line 897 [49.164589]

B:BD[49.182035] → [49.182035:182103]

    marshallShort(th, you.x_pos);
    marshallShort(th, you.y_pos);

[49.182035]

[49.182103]

    marshallShort(th, you.pos().x);
    marshallShort(th, you.pos().y);

Replacement in crawl-ref/source/tags.cc at line 1285 [49.164589]
B:BD[151.6834] → [151.6834:6856]
```
    you.moveto(x, y);
```
[151.6834]
[49.189463]
```
    you.moveto(coord_def(x, y));
```

Replacement in crawl-ref/source/tags.cc at line 1646 [49.164589]

B:BD[49.204344] → [49.204344:204428]

        marshallByte(th, env.cloud[i].x);
        marshallByte(th, env.cloud[i].y);

[49.204344]

[49.204428]

        marshallByte(th, env.cloud[i].pos.x);
        marshallByte(th, env.cloud[i].pos.y);

Replacement in crawl-ref/source/tags.cc at line 1662 [49.164589]

B:BD[49.204771] → [49.204771:204853]

        marshallByte(th, env.shop[i].x);
        marshallByte(th, env.shop[i].y);

[49.204771]

[49.204853]

        marshallByte(th, env.shop[i].pos.x);
        marshallByte(th, env.shop[i].pos.y);

Replacement in crawl-ref/source/tags.cc at line 1685 [49.164589]

B:BD[152.3135] → [152.3135:3197]

    marshallShort(th, item.x);
    marshallShort(th, item.y);

[152.3135]

[152.3197]

    marshallShort(th, item.pos.x);
    marshallShort(th, item.pos.y);

Replacement in crawl-ref/source/tags.cc at line 1690 [49.164589]
B:BD[152.3292] → [153.469:507]
```
    if (item.x == -1 && item.y == -1)
```
[152.3292]
[153.507]
```
    if (item.pos.x == -1 && item.pos.y == -1)
```

Replacement in crawl-ref/source/tags.cc at line 1693 [49.164589]

B:BD[153.557] → [153.557:618]

        marshallShort(th, igrd[item.x][item.y]);  //  unused

[153.557]

[152.3349]

        marshallShort(th, igrd(item.pos));  //  unused

Replacement in crawl-ref/source/tags.cc at line 1713 [49.164589]

B:BD[119.6018] → [119.6018:6106]

    item.x           = unmarshallShort(th);
    item.y           = unmarshallShort(th);

[119.6018]

[119.6106]

    item.pos.x       = unmarshallShort(th);
    item.pos.y       = unmarshallShort(th);

Replacement in crawl-ref/source/tags.cc at line 1737 [49.164589]

B:BD[49.205213] → [49.205213:205295]

        marshallByte(th, env.trap[i].x);
        marshallByte(th, env.trap[i].y);

[49.205213]

[49.205295]

        marshallByte(th, env.trap[i].pos.x);
        marshallByte(th, env.trap[i].pos.y);

Replacement in crawl-ref/source/tags.cc at line 1776 [49.164589]

B:BD[152.4916] → [152.4916:5038]

    marshallByte(th, m.x);
    marshallByte(th, m.y);
    marshallByte(th, m.target_x);
    marshallByte(th, m.target_y);

[152.4916]

[154.414]

    marshallByte(th, m.pos().x);
    marshallByte(th, m.pos().y);
    marshallByte(th, m.target.x);
    marshallByte(th, m.target.y);

Replacement in crawl-ref/source/tags.cc at line 1983 [49.164589]

B:BD[49.208564] → [49.208564:208654]

        env.cloud[i].x = unmarshallByte(th);
        env.cloud[i].y = unmarshallByte(th);

[49.208564]

[119.6693]

        env.cloud[i].pos.x = unmarshallByte(th);
        env.cloud[i].pos.y = unmarshallByte(th);

Replacement in crawl-ref/source/tags.cc at line 2000 [49.164589]

B:BD[49.209017] → [49.209017:209105]

        env.shop[i].x = unmarshallByte(th);
        env.shop[i].y = unmarshallByte(th);

[49.209017]

[49.209105]

        env.shop[i].pos.x = unmarshallByte(th);
        env.shop[i].pos.y = unmarshallByte(th);

Replacement in crawl-ref/source/tags.cc at line 2023 [49.164589]

∅:D[67.1767] → [49.209501:209589]

∅:D[119.6842] → [49.209501:209589]

B:BD[49.209501] → [49.209501:209589]

        env.trap[i].x = unmarshallByte(th);
        env.trap[i].y = unmarshallByte(th);

[119.6842]

[49.209589]

        env.trap[i].pos.x = unmarshallByte(th);
        env.trap[i].pos.y = unmarshallByte(th);

Replacement in crawl-ref/source/tags.cc at line 2047 [49.164589]

B:BD[119.7087] → [119.7087:7263]

    m.x               = unmarshallByte(th);
    m.y               = unmarshallByte(th);
    m.target_x        = unmarshallByte(th);
    m.target_y        = unmarshallByte(th);

[119.7087]

[154.454]

    m.position.x      = unmarshallByte(th);
    m.position.y      = unmarshallByte(th);
    m.target.x        = unmarshallByte(th);
    m.target.y        = unmarshallByte(th);

Replacement in crawl-ref/source/tags.cc at line 2129 [49.164589]
B:BD[155.1874] → [155.1874:1906]
```
            mgrd[m.x][m.y] = i;
```
[155.1874]
[49.214022]
```
            mgrd(m.pos()) = i;
```

Replacement in crawl-ref/source/stuff.cc at line 402 [49.224557]

B:BD[156.1679] → [156.1679:2040]

∅:D[157.147] → [49.228237:228247]

∅:D[156.2040] → [49.228237:228247]

B:BD[49.228237] → [49.228237:228247]

    coord_def p;
    for (p.x = you.x_pos - 1; p.x <= you.x_pos + 1; ++p.x)
        for (p.y = you.y_pos - 1; p.y <= you.y_pos + 1; ++p.y)
        {
            if (p == you.pos())
                continue;
            if (const monsters *mon = monster_at(p))
            {
                if (!mons_friendly(mon))
                    return (2);
            }
        }

[156.1679]

[156.2041]

    for ( adjacent_iterator ai; ai; ++ai )
        if (const monsters *mon = monster_at(*ai))
            if (!mons_friendly(mon))
                return (2);

Replacement in crawl-ref/source/stuff.cc at line 1281 [49.224557]

B:BD[140.2880] → [140.2880:2933]

∅:D[140.2933] → [51.108398:108461]

B:BD[51.108398] → [51.108398:108461]

                && mgrd[x_pos][y_pos] != NON_MONSTER
                && (x_pos != you.x_pos || y_pos != you.y_pos))

[140.2880]

[51.108461]

                 && mgrd[x_pos][y_pos] != NON_MONSTER
                 && (coord_def(x_pos,y_pos) != you.pos()))

Replacement in crawl-ref/source/stuff.cc at line 1629 [49.224557]

B:BD[51.115942] → [51.115942:115994]

            if (gx == you.x_pos && gy == you.y_pos)

[51.115942]

[51.115994]

            if (gx == you.pos().x && gy == you.pos().y)

Replacement in crawl-ref/source/state.cc at line 199 [158.1546]

B:BD[158.6614] → [86.4981:5076]

                   mon->x, mon->y,
                   see_grid(mon->x, mon->y)? "yes" : "no");

[158.6614]

[158.6697]

                   mon->pos().x, mon->pos().y,
                   see_grid(mon->pos())? "yes" : "no");

Insertion in crawl-ref/source/stash.h at line 230 [68.138156]

[114.5028]

    bool  needs_visit(const coord_def& c) const {
        return needs_visit(c.x, c.y);
    }

Insertion in crawl-ref/source/stash.h at line 234 [68.138156]

[114.5076]

    bool  shop_needs_visit(const coord_def& c) const {
        return shop_needs_visit(c.x, c.y);
    }

Insertion in crawl-ref/source/stash.h at line 300 [68.138156]

[68.145448]

    }
    ShopInfo &get_shop(const coord_def& p)
    {
        return get_shop(p.x, p.y);

Insertion in crawl-ref/source/stash.h at line 358 [68.138156]
[68.146960]
[68.146960]
```
inline bool is_stash( const coord_def& p ) { return is_stash(p.x, p.y); }
```

Replacement in crawl-ref/source/stash.cc at line 149 [68.147324]

B:BD[68.151181] → [68.151181:151229]

        xp = you.x_pos;
        yp = you.y_pos;

[68.151181]

[68.151229]

        xp = you.pos().x;
        yp = you.pos().y;

Replacement in crawl-ref/source/stash.cc at line 266 [68.147324]
B:BD[68.152748] → [67.2694:2716]
```
    feat = grd[x][y];
```
[68.152748]
[67.2716]
```
    coord_def p(x,y);
    feat = grd(p);
```
Replacement in crawl-ref/source/stash.cc at line 274 [68.147324]
B:BD[67.2828] → [61.8345:8394]
```
        trap = trap_type_at_xy(coord_def(x, y));
```
[67.2828]
[118.4905]
```
        trap = trap_type_at_xy(p);
```
Replacement in crawl-ref/source/stash.cc at line 278 [68.147324]
B:BD[68.152839] → [68.152839:152881]
```
    if (x == you.x_pos && y == you.y_pos)
```
[68.152839]
[68.152881]
```
    if (p == you.pos())
```

Replacement in crawl-ref/source/stash.cc at line 1058 [68.147324]

B:BD[68.169620] → [68.169620:169666]

        x = you.x_pos;
        y = you.y_pos;

[68.169620]

[68.169666]

        x = you.pos().x;
        y = you.pos().y;

Insertion in crawl-ref/source/spl-util.h at line 103 [49.242902]

[159.698]

typedef int cloud_func(coord_def where, int pow, int spreadrate,
                       cloud_type type, kill_category whose,
                       killer_type killer);

Replacement in crawl-ref/source/spl-util.h at line 129 [49.242902]

B:BD[49.245382] → [160.283:350]

B:BD[160.350] → [45.1252:1316]

∅:D[160.401] → [130.750:825]

∅:D[45.1316] → [130.750:825]

B:BD[130.750] → [130.750:825]

void apply_area_cloud(int (*func) (int, int, int, int, cloud_type,
                                   kill_category, killer_type),
                      int x, int y, int pow, int number, cloud_type ctype,

[49.245382]

[45.1317]

void apply_area_cloud(cloud_func func, const coord_def& where,
                      int pow, int number, cloud_type ctype,

Replacement in crawl-ref/source/spl-util.cc at line 56 [49.245665]

B:BD[161.258] → [162.158:228]

B:BD[162.228] → [45.1424:1491]

∅:D[45.1491] → [162.282:348]

B:BD[162.282] → [162.282:348]

B:BD[162.348] → [45.1492:1566]

static bool _cloud_helper(int (*func)(int, int, int, int, cloud_type,
                                      kill_category, killer_type),
                          int x, int y, int pow, int spread_rate,
                          cloud_type ctype, kill_category, killer_type );

[161.258]

[49.246966]

static bool _cloud_helper(cloud_func func, const coord_def& where,
                          int pow, int spread_rate,
                          cloud_type ctype, kill_category whose,
                          killer_type killer);

Replacement in crawl-ref/source/spl-util.cc at line 584 [49.245665]

B:BD[49.259424] → [159.5984:6082]

    int rv = cf(coord_def(you.x_pos + bmove.dx, you.y_pos + bmove.dy),
                power, 1);

[49.259424]

[49.259497]

    int rv = cf(you.pos() + bmove.delta, power, 1);

Replacement in crawl-ref/source/spl-util.cc at line 610 [49.245665]

B:BD[49.260782] → [160.715:783]

B:BD[160.783] → [45.2761:2826]

∅:D[160.835] → [163.583:620]

∅:D[130.1096] → [163.583:620]

∅:D[45.2826] → [163.583:620]

B:BD[163.583] → [163.583:620]

void apply_area_cloud( int (*func) (int, int, int, int, cloud_type,
                                    kill_category, killer_type),
                       int x, int y,

[49.260782]

[130.1097]

void apply_area_cloud( cloud_func func, const coord_def& where,

Replacement in crawl-ref/source/spl-util.cc at line 615 [49.245665]

B:BD[49.260911] → [49.260911:261061]

    int spread, clouds_left = number;
    int good_squares = 0, neighbours[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
    int dx = 1, dy = 1;
    bool x_first;

[49.260911]

[49.261061]

    int good_squares = 0;
    int neighbours[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };

Replacement in crawl-ref/source/spl-util.cc at line 618 [49.245665]

B:BD[49.261062] → [162.522:589]

B:BD[162.589] → [45.2933:2993]

∅:D[162.641] → [49.261123:261146]

∅:D[163.766] → [49.261123:261146]

∅:D[160.1016] → [49.261123:261146]

∅:D[45.2993] → [49.261123:261146]

B:BD[49.261123] → [49.261123:261146]

    if (clouds_left && _cloud_helper(func, x, y, pow, spread_rate,
                                     ctype, whose, killer))
        clouds_left--;

[49.261062]

[49.261146]

    if (number && _cloud_helper(func, where, pow, spread_rate, ctype, whose,
                                killer))
        number--;

Replacement in crawl-ref/source/spl-util.cc at line 622 [49.245665]
B:BD[49.261147] → [49.261147:261169]
```
    if (!clouds_left)
```
[49.261147]
[49.261169]
```
    if (number == 0)
```

Deletion in crawl-ref/source/spl-util.cc at line 624 [49.245665]

B:BD[49.261185] → [49.261185:261289]


    if (coinflip())
        dx *= -1;
    if (coinflip())
        dy *= -1;
    x_first = coinflip();

Replacement in crawl-ref/source/spl-util.cc at line 625 [49.245665]

B:BD[49.261290] → [49.261290:261313]

B:BD[49.261313] → [162.642:718]

B:BD[162.718] → [45.2994:3058]

∅:D[162.774] → [49.261383:261488]

∅:D[163.844] → [49.261383:261488]

∅:D[160.1147] → [49.261383:261488]

∅:D[45.3058] → [49.261383:261488]

B:BD[49.261383] → [49.261383:261488]

B:BD[49.261488] → [162.775:851]

B:BD[162.851] → [45.3059:3123]

∅:D[162.907] → [49.261558:261662]

∅:D[163.922] → [49.261558:261662]

∅:D[160.1278] → [49.261558:261662]

∅:D[45.3123] → [49.261558:261662]

B:BD[49.261558] → [49.261558:261662]

    if (x_first)
    {
        if (clouds_left && _cloud_helper(func, x + dx, y, pow, spread_rate,
                                         ctype, whose, killer))
        {
            clouds_left--;
            good_squares++;
            neighbours[0]++;
        }
        if (clouds_left && _cloud_helper(func, x - dx, y, pow, spread_rate,
                                         ctype, whose, killer))
        {
            clouds_left--;
            good_squares++;
            neighbours[1]++;
        }

[49.261290]

[49.261662]

    // These indices depend on the order in Compass (see acr.cc)
    int compass_order_orth[4] = { 2, 6, 4, 0 };
    int compass_order_diag[4] = { 1, 3, 5, 7 };

Replacement in crawl-ref/source/spl-util.cc at line 629 [49.245665]

B:BD[49.261663] → [162.908:984]

B:BD[162.984] → [45.3124:3188]

∅:D[163.1000] → [49.261733:261837]

∅:D[162.1040] → [49.261733:261837]

∅:D[160.1409] → [49.261733:261837]

∅:D[45.3188] → [49.261733:261837]

B:BD[49.261733] → [49.261733:261837]

        if (clouds_left && _cloud_helper(func, x, y + dy, pow, spread_rate,
                                         ctype, whose, killer))
        {
            clouds_left--;
            good_squares++;
            neighbours[2]++;
        }

[49.261663]

[49.261837]

    int* const arrs[2] = { compass_order_orth, compass_order_diag };

Replacement in crawl-ref/source/spl-util.cc at line 631 [49.245665]

B:BD[49.261838] → [162.1041:1117]

B:BD[162.1117] → [45.3189:3253]

∅:D[163.1078] → [49.261908:262027]

∅:D[162.1173] → [49.261908:262027]

∅:D[160.1540] → [49.261908:262027]

∅:D[45.3253] → [49.261908:262027]

B:BD[49.261908] → [49.261908:262027]

        if (clouds_left && _cloud_helper(func, x, y - dy, pow, spread_rate,
                                         ctype, whose, killer))
        {
            clouds_left--;
            good_squares++;
            neighbours[3]++;
        }
    }
    else

[49.261838]

[49.262027]

    for ( int m = 0; m < 2; ++m )

Replacement in crawl-ref/source/spl-util.cc at line 633 [49.245665]

B:BD[49.262033] → [162.1174:1250]

B:BD[162.1250] → [45.3254:3318]

∅:D[163.1156] → [49.262103:262208]

∅:D[162.1306] → [49.262103:262208]

∅:D[160.1671] → [49.262103:262208]

∅:D[45.3318] → [49.262103:262208]

B:BD[49.262103] → [49.262103:262208]

B:BD[49.262208] → [162.1307:1383]

B:BD[162.1383] → [45.3319:3383]

        if (clouds_left && _cloud_helper(func, x, y + dy, pow, spread_rate,
                                         ctype, whose, killer))
        {
            clouds_left--;
            good_squares++;
            neighbours[2]++;
        }
        if (clouds_left && _cloud_helper(func, x, y - dy, pow, spread_rate,
                                         ctype, whose, killer))

[49.262033]

[49.262278]

        // Randomise, but do orthogonals first and diagonals later.
        std::random_shuffle( arrs[m], arrs[m] + 4 );
        for ( int i = 0; i < 4 && number; ++i )

Replacement in crawl-ref/source/spl-util.cc at line 637 [49.245665]

B:BD[49.262288] → [49.262288:262383]

B:BD[49.262383] → [162.1440:1516]

B:BD[162.1516] → [45.3384:3448]

∅:D[163.1312] → [49.262453:262558]

∅:D[162.1572] → [49.262453:262558]

∅:D[160.1933] → [49.262453:262558]

∅:D[45.3448] → [49.262453:262558]

B:BD[49.262453] → [49.262453:262558]

B:BD[49.262558] → [162.1573:1649]

B:BD[162.1649] → [45.3449:3513]

∅:D[163.1390] → [49.262628:262722]

∅:D[162.1705] → [49.262628:262722]

∅:D[160.2064] → [49.262628:262722]

∅:D[45.3513] → [49.262628:262722]

B:BD[49.262628] → [49.262628:262722]

            clouds_left--;
            good_squares++;
            neighbours[3]++;
        }
        if (clouds_left && _cloud_helper(func, x + dx, y, pow, spread_rate,
                                         ctype, whose, killer))
        {
            clouds_left--;
            good_squares++;
            neighbours[0]++;
        }
        if (clouds_left && _cloud_helper(func, x - dx, y, pow, spread_rate,
                                         ctype, whose, killer))
        {
            clouds_left--;
            good_squares++;
            neighbours[1]++;

[49.262288]

[49.262722]

            const int aux = arrs[m][i];
            if ( _cloud_helper(func, where + Compass[aux],
                               pow, spread_rate, ctype, whose, killer))
            {
                number--;
                good_squares++;
                neighbours[aux]++;
            }

Deletion in crawl-ref/source/spl-util.cc at line 646 [49.245665]

B:BD[49.262732] → [49.262732:262739]

B:BD[49.262739] → [162.1706:1844]

B:BD[162.1844] → [45.3514:3574]

∅:D[163.1469] → [49.262870:262955]

∅:D[162.1896] → [49.262870:262955]

∅:D[160.2192] → [49.262870:262955]

∅:D[45.3574] → [49.262870:262955]

B:BD[49.262870] → [49.262870:262955]

B:BD[49.262955] → [162.1897:1974]

B:BD[162.1974] → [45.3575:3635]

∅:D[163.1548] → [49.263026:263111]

∅:D[162.2026] → [49.263026:263111]

∅:D[160.2320] → [49.263026:263111]

∅:D[45.3635] → [49.263026:263111]

B:BD[49.263026] → [49.263026:263111]

B:BD[49.263111] → [162.2027:2104]

B:BD[162.2104] → [45.3636:3696]

∅:D[163.1627] → [49.263182:263260]

∅:D[162.2156] → [49.263182:263260]

∅:D[160.2448] → [49.263182:263260]

∅:D[45.3696] → [49.263182:263260]

B:BD[49.263182] → [49.263182:263260]

    }
    // Mow diagonals; we could randomize dx & dy again here.
    if (clouds_left && _cloud_helper(func, x + dx, y + dy, pow, spread_rate,
                                     ctype, whose, killer))
    {
        clouds_left--;
        good_squares++;
        neighbours[4]++;
    }
    if (clouds_left && _cloud_helper(func, x - dx, y + dy, pow, spread_rate,
                                     ctype, whose, killer))
    {
        clouds_left--;
        good_squares++;
        neighbours[5]++;
    }
    if (clouds_left && _cloud_helper(func, x + dx, y - dy, pow, spread_rate,
                                     ctype, whose, killer))
    {
        clouds_left--;
        good_squares++;
        neighbours[6]++;

Replacement in crawl-ref/source/spl-util.cc at line 648 [49.245665]

B:BD[49.263267] → [162.2157:2234]

B:BD[162.2234] → [45.3697:3757]

    if (clouds_left && _cloud_helper(func, x - dx, y - dy, pow, spread_rate,
                                     ctype, whose, killer))

[49.263267]

[49.263338]

    // Get a random permutation.
    int perm[8];
    for ( int i = 0; i < 8; ++i )
        perm[i] = i;
    std::random_shuffle(perm, perm+8);
    for (int i = 0; i < 8 && number; i++)

Replacement in crawl-ref/source/spl-util.cc at line 655 [49.245665]

B:BD[49.263344] → [49.263344:263422]

        clouds_left--;
        good_squares++;
        neighbours[7]++;
    }

[49.263344]

[49.263422]

        // Spread (in random order.)
        const int j = perm[i];

Replacement in crawl-ref/source/spl-util.cc at line 658 [49.245665]

B:BD[49.263423] → [162.2287:2326]

∅:D[162.2326] → [49.263463:263565]

B:BD[49.263463] → [49.263463:263565]

    if (!clouds_left || !good_squares)
        return;
    for (int i = 0; i < 8 && clouds_left; i++)
    {
        if (neighbours[i] == 0)

[49.263423]

[49.263565]

        if (neighbours[j] == 0)

Replacement in crawl-ref/source/spl-util.cc at line 661 [49.245665]

B:BD[49.263588] → [49.263588:263664]

        spread = clouds_left / good_squares;
        clouds_left -= spread;

[49.263588]

[49.263664]

        int spread = number / good_squares;
        number -= spread;

Replacement in crawl-ref/source/spl-util.cc at line 664 [49.245665]

B:BD[49.263688] → [49.263688:263734]

B:BD[49.263734] → [45.3758:3839]

∅:D[45.3839] → [160.2650:2693]

B:BD[160.2650] → [160.2650:2693]

∅:D[163.1781] → [49.263801:263836]

∅:D[160.2693] → [49.263801:263836]

B:BD[49.263801] → [49.263801:263836]

B:BD[49.263836] → [45.3840:3921]

∅:D[45.3921] → [160.2767:2810]

B:BD[160.2767] → [160.2767:2810]

∅:D[163.1856] → [49.263903:263938]

∅:D[160.2810] → [49.263903:263938]

B:BD[49.263903] → [49.263903:263938]

B:BD[49.263938] → [45.3922:4003]

∅:D[45.4003] → [160.2884:2927]

B:BD[160.2884] → [160.2884:2927]

∅:D[163.1931] → [49.264005:264040]

∅:D[160.2927] → [49.264005:264040]

B:BD[49.264005] → [49.264005:264040]

B:BD[49.264040] → [45.4004:4085]

∅:D[45.4085] → [160.3001:3044]

B:BD[160.3001] → [160.3001:3044]

∅:D[163.2006] → [49.264107:264142]

∅:D[160.3044] → [49.264107:264142]

B:BD[49.264107] → [49.264107:264142]

B:BD[49.264142] → [160.3045:3123]

B:BD[160.3123] → [45.4086:4137]

∅:D[163.2086] → [49.264214:264249]

∅:D[160.3166] → [49.264214:264249]

∅:D[45.4137] → [49.264214:264249]

B:BD[49.264214] → [49.264214:264249]

B:BD[49.264249] → [160.3167:3245]

B:BD[160.3245] → [45.4138:4189]

∅:D[163.2166] → [49.264321:264356]

∅:D[160.3288] → [49.264321:264356]

∅:D[45.4189] → [49.264321:264356]

B:BD[49.264321] → [49.264321:264356]

B:BD[49.264356] → [160.3289:3367]

B:BD[160.3367] → [45.4190:4241]

∅:D[163.2246] → [49.264428:264463]

∅:D[160.3410] → [49.264428:264463]

∅:D[45.4241] → [49.264428:264463]

B:BD[49.264428] → [49.264428:264463]

B:BD[49.264463] → [160.3411:3489]

B:BD[160.3489] → [45.4242:4293]

∅:D[163.2326] → [49.264535:264564]

∅:D[160.3532] → [49.264535:264564]

∅:D[45.4293] → [49.264535:264564]

B:BD[49.264535] → [49.264535:264564]


        switch (i)
        {
        case 0:
            apply_area_cloud(func, x + dx, y, pow, spread, ctype, whose, killer,
                             spread_rate);
            break;
        case 1:
            apply_area_cloud(func, x - dx, y, pow, spread, ctype, whose, killer,
                             spread_rate);
            break;
        case 2:
            apply_area_cloud(func, x, y + dy, pow, spread, ctype, whose, killer,
                             spread_rate);
            break;
        case 3:
            apply_area_cloud(func, x, y - dy, pow, spread, ctype, whose, killer,
                             spread_rate);
            break;
        case 4:
            apply_area_cloud(func, x + dx, y + dy, pow, spread, ctype, whose,
                             killer, spread_rate);
            break;
        case 5:
            apply_area_cloud(func, x - dx, y + dy, pow, spread, ctype, whose,
                             killer, spread_rate);
            break;
        case 6:
            apply_area_cloud(func, x + dx, y - dy, pow, spread, ctype, whose,
                             killer, spread_rate);
            break;
        case 7:
            apply_area_cloud(func, x - dx, y - dy, pow, spread, ctype, whose,
                             killer, spread_rate);
            break;
        }

[49.263688]

[49.264564]

        apply_area_cloud(func, where + Compass[j], pow, spread, ctype, whose,
                         killer, spread_rate);

Replacement in crawl-ref/source/spl-util.cc at line 667 [49.245665]
B:BD[49.264570] → [49.264570:264628]
```
}                               // end apply_area_cloud()
```
[49.264570]
[49.264628]
```
}
```
Replacement in crawl-ref/source/spl-util.cc at line 692 [49.245665]
∅:D[51.118902] → [49.265177:265241]
B:BD[49.265177] → [49.265177:265241]
```
    pbolt.source_x = you.x_pos;
    pbolt.source_y = you.y_pos;
```
[51.118902]
[49.265241]
```
    pbolt.source = you.pos();
```

Replacement in crawl-ref/source/spl-util.cc at line 854 [49.245665]

B:BD[161.997] → [162.2327:2397]

B:BD[162.2397] → [45.5230:5297]

∅:D[45.5297] → [162.2451:2517]

B:BD[162.2451] → [162.2451:2517]

static bool _cloud_helper(int (*func)(int, int, int, int, cloud_type,
                                      kill_category, killer_type),
                          int x, int y, int pow, int spread_rate,

[161.997]

[45.5298]

static bool _cloud_helper(cloud_func func, const coord_def& where,
                          int pow, int spread_rate,

Replacement in crawl-ref/source/spl-util.cc at line 859 [49.245665]

B:BD[49.267952] → [51.119681:119750]

    if (!grid_is_solid(grd[x][y]) && env.cgrid[x][y] == EMPTY_CLOUD)

[49.267952]

[49.268028]

    if (!grid_is_solid(grd(where)) && env.cgrid(where) == EMPTY_CLOUD)

Replacement in crawl-ref/source/spl-util.cc at line 861 [49.245665]

B:BD[49.268034] → [45.5411:5471]

        func(x, y, pow, spread_rate, ctype, whose, killer);

[49.268034]

[86.6201]

        func(where, pow, spread_rate, ctype, whose, killer);

Replacement in crawl-ref/source/spl-cast.cc at line 961 [49.293070]

B:BD[29.1219] → [29.1219:1345]

    mon->x          = you.x_pos;
    mon->y          = you.y_pos;
    mon->target_x   = spd.tx;
    mon->target_y   = spd.ty;

[29.1219]

[29.1345]

    mon->pos()      = you.pos();
    mon->target     = spd.target;

Replacement in crawl-ref/source/spl-cast.cc at line 966 [49.293070]
B:BD[29.1397] → [29.1397:1447]
```
    else if (mgrd[spd.tx][spd.ty] == NON_MONSTER)
```
[29.1397]
[29.1447]
```
    else if (mgrd(spd.target) == NON_MONSTER)
```
Replacement in crawl-ref/source/spl-cast.cc at line 974 [49.293070]
B:BD[29.1567] → [29.1567:1608]
```
        mon->foe = mgrd[spd.tx][spd.ty];
```
[29.1567]
[29.1608]
```
        mon->foe = mgrd(spd.target);
```

Replacement in crawl-ref/source/spl-cast.cc at line 1703 [49.293070]

B:BD[49.329887] → [164.212:282]

        if (beam.target_x == you.x_pos && beam.target_y == you.y_pos)

[49.329887]

[164.282]

        if (beam.target == you.pos())

Replacement in crawl-ref/source/spl-cast.cc at line 2505 [49.293070]

B:BD[45.18128] → [45.18128:18311]

    beam.source_x = target->pos().x;
    beam.source_y = target->pos().y;
    beam.target_x = target->pos().x;
    beam.target_y = target->pos().y;
    beam.pos      = target->pos();

[45.18128]

[45.18311]

    beam.source = target->pos();
    beam.target = target->pos();
    beam.pos    = target->pos();

Replacement in crawl-ref/source/spl-cast.cc at line 2809 [49.293070]

B:BD[45.26975] → [45.26975:27081]

            big_cloud( CLOUD_GREY_SMOKE, kc, kt,
                       target->pos().x, target->pos().y,

[45.26975]

[45.27081]

            big_cloud( CLOUD_GREY_SMOKE, kc, kt, target->pos(),

Deletion in crawl-ref/source/spl-cast.cc at line 2837 [49.293070]
B:BD[165.2862] → [166.3654:3655]

Replacement in crawl-ref/source/spl-cast.cc at line 3885 [49.293070]

B:BD[45.47471] → [45.47471:47550]

                       target->pos().x, target->pos().y, 20, 7 + random2(7) );

[45.47471]

[49.377869]

                       target->pos(), 20, 7 + random2(7) );

Deletion in crawl-ref/source/spl-cast.cc at line 4072 [49.293070]
∅:D[45.52053] → [166.4404:4405]
B:BD[165.31906] → [166.4404:4405]

Replacement in crawl-ref/source/spl-cast.cc at line 4095 [49.293070]

B:BD[45.52564] → [45.52564:52641]

                      target->pos().x, target->pos().y, 20, 8 + random2(4));

[45.52564]

[49.383932]

                      target->pos(), 20, 8 + random2(4));

Replacement in crawl-ref/source/spl-cast.cc at line 4339 [49.293070]

B:BD[45.58211] → [45.58211:58331]

            big_cloud(CLOUD_STINK, kc, kt,
                      target->pos().x, target->pos().y, 20, 9 + random2(4));

[45.58211]

[165.37732]

            big_cloud(CLOUD_STINK, kc, kt, target->pos(), 20, 9 + random2(4));

Replacement in crawl-ref/source/spl-cast.cc at line 4371 [49.293070]

B:BD[45.59252] → [45.59252:59376]

            big_cloud( CLOUD_POISON, kc, kt,
                       target->pos().x, target->pos().y, 20, 8 + random2(5) );

[45.59252]

[49.391383]

            big_cloud(CLOUD_POISON, kc, kt, target->pos(), 20, 8 + random2(5));

Replacement in crawl-ref/source/spl-cast.cc at line 4479 [49.293070]

B:BD[45.61781] → [45.61781:61901]

            big_cloud(CLOUD_STINK, kc, kt,
                      target->pos().x, target->pos().y, 20, 8 + random2(5));

[45.61781]

[165.40994]

            big_cloud(CLOUD_STINK, kc, kt, target->pos(), 20, 8 + random2(5));

Replacement in crawl-ref/source/spl-cast.cc at line 4510 [49.293070]

B:BD[45.62505] → [45.62505:62626]

            big_cloud(CLOUD_POISON, kc, kt,
                      target->pos().x, target->pos().y, 20, 7 + random2(7));

[45.62505]

[165.41644]

            big_cloud(CLOUD_POISON, kc, kt, target->pos(), 20, 7 + random2(7));

Replacement in crawl-ref/source/spells4.h at line 22 [49.434549]
∅:D[159.6575] → [160.3845:3909]
B:BD[49.434956] → [160.3845:3909]
```
int make_a_normal_cloud(int x, int y, int pow, int spread_rate,
```
[159.6575]
[45.63201]
```
int make_a_normal_cloud(coord_def where, int pow, int spread_rate,
```
Replacement in crawl-ref/source/spells4.h at line 29 [49.434549]
B:BD[49.435140] → [167.164:197]
∅:D[167.197] → [168.161:192]
B:BD[49.435140] → [168.161:192]
```
void remove_divine_shield(void);
void cast_divine_shield(void);
```
[49.435140]
[49.435140]
```
void remove_divine_shield();
void cast_divine_shield();
```
Replacement in crawl-ref/source/spells4.cc at line 381 [49.436250]
B:BD[49.451335] → [49.451335:451392]
```
    for (int x = you.x_pos - 8; x <= you.x_pos + 8; x++)
```
[49.451335]
[49.451392]
```
    for ( radius_iterator ri(you.pos(), 8); ri; ++ri )
```

Replacement in crawl-ref/source/spells4.cc at line 383 [49.436250]

B:BD[49.451398] → [49.451398:451459]

        for (int y = you.y_pos - 8; y <= you.y_pos + 8; y++)

[49.451398]

[49.451459]

        if (grd(*ri) == DNGN_SECRET_DOOR && random2(pow) > random2(15))

Replacement in crawl-ref/source/spells4.cc at line 385 [49.436250]

B:BD[49.451469] → [49.451469:451558]

B:BD[49.451558] → [169.158:191]

∅:D[169.191] → [49.451592:451710]

B:BD[49.451592] → [49.451592:451710]

B:BD[49.451710] → [170.184:226]

∅:D[170.226] → [49.451756:451795]

B:BD[49.451756] → [49.451756:451795]

            if (x < 5 || x > GXM - 5 || y < 5 || y > GYM - 5)
                continue;
            if (!see_grid(x, y))
                continue;
            if (grd[x][y] == DNGN_SECRET_DOOR && random2(pow) > random2(15))
            {
                reveal_secret_door(x, y);
                found++;
            }

[49.451469]

[49.451795]

            reveal_secret_door(*ri);
            found++;

Replacement in crawl-ref/source/spells4.cc at line 1072 [49.436250]

B:BD[49.479349] → [160.3969:4033]

int make_a_normal_cloud(int x, int y, int pow, int spread_rate,

[49.479349]

[45.63599]

int make_a_normal_cloud(coord_def where, int pow, int spread_rate,

Replacement in crawl-ref/source/spells4.cc at line 1079 [49.436250]
∅:D[45.63792] → [61.9175:9216]
B:BD[49.479409] → [61.9175:9216]
```
    place_cloud( ctype, coord_def(x, y),
```
[45.63792]
[163.3980]
```
    place_cloud( ctype, where,
```
Deletion in crawl-ref/source/spells4.cc at line 1089 [49.436250]
B:BD[49.480715] → [159.9795:9830]
```
    int x = where.x, y = where.y;
```
Deletion in crawl-ref/source/spells4.cc at line 1090 [49.436250]
B:BD[49.480716] → [171.165:197]
```
    int dx, dy, nx = x, ny = y;
```
Replacement in crawl-ref/source/spells4.cc at line 1100 [49.436250]
∅:D[162.5762] → [172.4161:4235]
B:BD[49.480888] → [172.4161:4235]
```
    if (grd[x][y] != DNGN_ROCK_WALL && grd[x][y] != DNGN_CLEAR_ROCK_WALL)
```
[162.5762]
[49.481186]
```
    if (grd(where) != DNGN_ROCK_WALL && grd(where) != DNGN_CLEAR_ROCK_WALL)
```

Replacement in crawl-ref/source/spells4.cc at line 1106 [49.436250]

B:BD[49.481261] → [49.481261:481309]

    dx = x - you.x_pos;
    dy = y - you.y_pos;

[49.481261]

[49.481309]

    coord_def delta = where - you.pos();
    coord_def n = where;

Replacement in crawl-ref/source/spells4.cc at line 1111 [49.436250]
B:BD[49.481334] → [171.235:267]
```
        if (!in_bounds(nx, ny))
```
[49.481334]
[49.481491]
```
        if (!in_bounds(n))
```
Replacement in crawl-ref/source/spells4.cc at line 1117 [49.436250]
B:BD[49.481596] → [49.481596:481625]
```
        switch (grd[nx][ny])
```
[49.481596]
[49.481625]
```
        switch (grd(n))
```
Replacement in crawl-ref/source/spells4.cc at line 1120 [49.436250]
B:BD[49.481652] → [171.268:312]
```
            if (grid_is_solid(grd[nx][ny]))
```
[49.481652]
[171.312]
```
            if (grid_is_solid(grd(n)))
```
Replacement in crawl-ref/source/spells4.cc at line 1130 [49.436250]
B:BD[49.481821] → [49.481821:481865]
```
            nx += dx;
            ny += dy;
```
[49.481821]
[49.481865]
```
            n += delta;
```

Replacement in crawl-ref/source/spells4.cc at line 1162 [49.436250]

B:BD[35.252] → [35.252:308]

    start_delay( DELAY_PASSWALL, 1 + howdeep, nx, ny );

[35.252]

[49.482731]

    start_delay( DELAY_PASSWALL, 1 + howdeep, n.x, n.y );

Replacement in crawl-ref/source/spells4.cc at line 1387 [49.436250]

B:BD[173.1521] → [34.281:355]

    beem.source_x       = you.x_pos;
    beem.source_y       = you.y_pos;

[173.1521]

[34.355]

    beem.source         = you.pos();

Replacement in crawl-ref/source/spells4.cc at line 1673 [49.436250]

B:BD[49.500290] → [49.500290:500362]

        apply_area_cloud(make_a_normal_cloud, menv[mon].x, menv[mon].y,

[49.500290]

[45.63841]

        apply_area_cloud(make_a_normal_cloud, menv[mon].pos(),

Replacement in crawl-ref/source/spells4.cc at line 1733 [49.436250]
B:BD[174.439] → [174.439:507]
```
    beam.source_x    = you.x_pos;
    beam.source_y    = you.y_pos;
```
[174.439]
[174.507]
```
    beam.source      = you.pos();
```
Deletion in crawl-ref/source/spells4.cc at line 1742 [49.436250]
∅:D[174.710] → [49.502250:502251]
∅:D[175.1915] → [49.502250:502251]
B:BD[49.502250] → [49.502250:502251]
B:BD[49.502251] → [174.711:796]
```
    const int grid = grd[spd.tx][spd.ty];
    const int mon  = mgrd[spd.tx][spd.ty];
```

Replacement in crawl-ref/source/spells4.cc at line 1743 [49.436250]

B:BD[49.502341] → [174.797:852]

    const bool okay_to_dest = in_bounds(spd.target());

[49.502341]

[49.502479]

    const dungeon_feature_type grid = grd(spd.target);
    const int mon = mgrd(spd.target);

Replacement in crawl-ref/source/spells4.cc at line 1915 [49.436250]

B:BD[49.507077] → [49.507077:507102]

B:BD[49.507102] → [175.2279:2320]

∅:D[175.2320] → [49.507144:507191]

B:BD[49.507144] → [49.507144:507191]

B:BD[49.507191] → [176.1428:1784]

        if (okay_to_dest
            && (grid == DNGN_ORCISH_IDOL
                || grid == DNGN_GRANITE_STATUE
                || pow >= 40 && grid == DNGN_ROCK_WALL && one_chance_in(3)
                || pow >= 40 && grid == DNGN_CLEAR_ROCK_WALL
                   && one_chance_in(3)
                || pow >= 60 && grid == DNGN_STONE_WALL && one_chance_in(10)
                || pow >= 60 && grid == DNGN_CLEAR_STONE_WALL
                   && one_chance_in(10)))

[49.507077]

[49.507349]

        if ((grid == DNGN_ORCISH_IDOL
             || grid == DNGN_GRANITE_STATUE
             || pow >= 40 && grid == DNGN_ROCK_WALL && one_chance_in(3)
             || pow >= 40 && grid == DNGN_CLEAR_ROCK_WALL
             && one_chance_in(3)
             || pow >= 60 && grid == DNGN_STONE_WALL && one_chance_in(10)
             || pow >= 60 && grid == DNGN_CLEAR_STONE_WALL
             && one_chance_in(10)))

Replacement in crawl-ref/source/spells4.cc at line 1926 [49.436250]
B:BD[174.3713] → [174.3713:3759]
```
            grd[spd.tx][spd.ty] = DNGN_FLOOR;
```
[174.3713]
[174.3759]
```
            grd(spd.target) = DNGN_FLOOR;
```

Replacement in crawl-ref/source/spells4.cc at line 1942 [49.436250]

B:BD[49.507972] → [177.2854:2924]

        if (okay_to_dest && pow >= 80 && x_chance_in_y(pow / 5, 500))

[49.507972]

[49.508037]

        if (pow >= 80 && x_chance_in_y(pow / 5, 500))

Replacement in crawl-ref/source/spells4.cc at line 1945 [49.436250]
B:BD[174.4029] → [174.4029:4075]
```
            grd[spd.tx][spd.ty] = DNGN_FLOOR;
```
[174.4029]
[49.508130]
```
            grd(spd.target) = DNGN_FLOOR;
```

Replacement in crawl-ref/source/spells4.cc at line 1962 [49.436250]

B:BD[49.508707] → [176.2233:2308]

        if (okay_to_dest && grid == DNGN_GREEN_CRYSTAL_WALL && coinflip())

[49.508707]

[49.508909]

        if (grid == DNGN_GREEN_CRYSTAL_WALL && coinflip())

Replacement in crawl-ref/source/spells4.cc at line 1965 [49.436250]
B:BD[174.4342] → [174.4342:4388]
```
            grd[spd.tx][spd.ty] = DNGN_FLOOR;
```
[174.4342]
[49.509015]
```
            grd(spd.target) = DNGN_FLOOR;
```
Replacement in crawl-ref/source/spells4.cc at line 1976 [49.436250]
B:BD[49.509171] → [61.9217:9258]
```
        trap = trap_at_xy(spd.target());
```
[49.509171]
[175.2372]
```
        trap = trap_at_xy(spd.target);
```

Replacement in crawl-ref/source/spells4.cc at line 1994 [49.436250]

B:BD[49.509895] → [49.509895:509931]

B:BD[49.509931] → [174.4761:4807]

∅:D[174.4807] → [49.509979:510040]

B:BD[49.509979] → [49.509979:510040]

        if (okay_to_dest)
        {
            grd[spd.tx][spd.ty] = DNGN_FLOOR;
            env.trap[trap].type = TRAP_UNASSIGNED;
        }

[49.509895]

[49.510040]

        grd(spd.target) = DNGN_FLOOR;
        env.trap[trap].type = TRAP_UNASSIGNED;

Replacement in crawl-ref/source/spells4.cc at line 2005 [49.436250]
∅:D[162.7124] → [49.510231:510257]
B:BD[49.510231] → [49.510231:510257]
B:BD[49.510257] → [174.4808:4854]
```
        if (okay_to_dest)
            grd[spd.tx][spd.ty] = DNGN_FLOOR;
```
[162.7124]
[49.510305]
```
        grd(spd.target) = DNGN_FLOOR;
```
Replacement in crawl-ref/source/spells4.cc at line 2065 [49.436250]
B:BD[49.512032] → [49.512032:512081]
```
    const int mons = mgrd[ targ.tx ][ targ.ty ];
```
[49.512032]
[49.512081]
```
    const int mons = mgrd(targ.target);
```
Replacement in crawl-ref/source/spells4.cc at line 2102 [49.436250]
B:BD[178.569] → [178.569:614]
```
    if (grid_is_solid(target.tx, target.ty))
```
[178.569]
[179.754]
```
    if (grid_is_solid(target.target))
```
Replacement in crawl-ref/source/spells4.cc at line 2109 [49.436250]
B:BD[178.707] → [178.707:760]
```
    if (trans_wall_blocking( target.tx, target.ty ))
```
[178.707]
[172.4696]
```
    if (trans_wall_blocking( target.target ))
```

Replacement in crawl-ref/source/spells4.cc at line 2149 [49.436250]

B:BD[49.513992] → [180.364:424]

    if (mgrd[targ.tx][targ.ty] == NON_MONSTER || targ.isMe)

[49.513992]

[49.514060]

    if (mgrd(targ.target) == NON_MONSTER || targ.isMe)

Replacement in crawl-ref/source/spells4.cc at line 2155 [49.436250]
B:BD[49.514132] → [172.4771:4820]
```
    if (trans_wall_blocking( targ.tx, targ.ty ))
```
[49.514132]
[172.4820]
```
    if (trans_wall_blocking( targ.target ))
```
Replacement in crawl-ref/source/spells4.cc at line 2222 [49.436250]
B:BD[49.516756] → [180.877:934]
```
    monsters *monster = &menv[ mgrd[targ.tx][targ.ty] ];
```
[49.516756]
[49.516820]
```
    monsters *monster = &menv[ mgrd(targ.target) ];
```
Replacement in crawl-ref/source/spells4.cc at line 2271 [49.436250]
B:BD[172.4907] → [172.4907:4956]
```
    if (trans_wall_blocking( beam.tx, beam.ty ))
```
[172.4907]
[172.4956]
```
    if (trans_wall_blocking( beam.target ))
```

Replacement in crawl-ref/source/spells4.cc at line 2278 [49.436250]

B:BD[49.518136] → [67.4442:4511]

    const dungeon_feature_type grid = grd[ you.x_pos ][ you.y_pos ];

[49.518136]

[49.518188]

    const dungeon_feature_type grid = grd(you.pos());

Replacement in crawl-ref/source/spells4.cc at line 2296 [49.436250]
B:BD[49.519004] → [49.519004:519043]
```
    if (!see_grid( beam.tx, beam.ty ))
```
[49.519004]
[49.519043]
```
    if (!see_grid( beam.target ))
```
Replacement in crawl-ref/source/spells4.cc at line 2303 [49.436250]
B:BD[49.519164] → [49.519164:519213]
```
    const int item = igrd[ beam.tx ][ beam.ty ];
```
[49.519164]
[49.519213]
```
    const int item = igrd(beam.target);
```
Replacement in crawl-ref/source/spells4.cc at line 2306 [49.436250]
B:BD[49.519245] → [49.519245:519298]
```
        const int  mon = mgrd[ beam.tx ][ beam.ty ];
```
[49.519245]
[49.519298]
```
        const int  mon = mgrd(beam.target);
```
Replacement in crawl-ref/source/spells4.cc at line 2344 [49.436250]
B:BD[49.520307] → [181.165:216]
```
    if (move_top_item( beam.target(), you.pos() ))
```
[49.520307]
[49.520372]
```
    if (move_top_item( beam.target, you.pos() ))
```

Replacement in crawl-ref/source/spells4.cc at line 2364 [49.436250]

B:BD[182.441] → [180.951:1006]

∅:D[180.1006] → [183.251:298]

B:BD[182.490] → [183.251:298]

           const int mon = mgrd[ beam.tx ][ beam.ty ];
           remove_item_stationary(mitm[item]);

[182.441]

[175.2544]

            const int mon = mgrd(beam.target);
            remove_item_stationary(mitm[item]);

Replacement in crawl-ref/source/spells4.cc at line 2367 [49.436250]

∅:D[175.2545] → [183.310:345]

B:BD[183.310] → [183.310:345]

B:BD[183.345] → [184.221:277]

           if (mon != NON_MONSTER)
               (&menv[mon])->del_ench(ENCH_HELD, true);

[175.2545]

[182.639]

            if (mon != NON_MONSTER)
                (&menv[mon])->del_ench(ENCH_HELD, true);

Replacement in crawl-ref/source/spells3.h at line 66 [49.526814]
B:BD[185.251] → [186.166:204]
```
bool inside_halo(int posx, int posy);
```
[185.227]
[49.528806]
```
bool inside_halo(const coord_def& where);
```

Replacement in crawl-ref/source/spells3.cc at line 201 [49.531613]

B:BD[49.536995] → [187.167:227]

    if (mgrd[beam.tx][beam.ty] == NON_MONSTER || beam.isMe)

[49.536995]

[49.537094]

    if (mgrd(beam.target) == NON_MONSTER || beam.isMe)

Replacement in crawl-ref/source/spells3.cc at line 205 [49.531613]

B:BD[49.537154] → [188.167:226]

        monsters *monster = &menv[mgrd[beam.tx][beam.ty]];

[49.537154]

[49.537203]

        monsters *monster = &menv[mgrd(beam.target)];

Replacement in crawl-ref/source/spells3.cc at line 246 [49.531613]

B:BD[49.537806] → [187.914:974]

    if (mgrd[beam.tx][beam.ty] == NON_MONSTER || beam.isMe)

[49.537806]

[49.537993]

    if (mgrd(beam.target) == NON_MONSTER || beam.isMe)

Replacement in crawl-ref/source/spells3.cc at line 250 [49.531613]

B:BD[49.538053] → [188.862:921]

        monsters *monster = &menv[mgrd[beam.tx][beam.ty]];

[49.538053]

[49.538102]

        monsters *monster = &menv[mgrd(beam.target)];

Replacement in crawl-ref/source/spells3.cc at line 1327 [49.531613]

B:BD[189.477] → [4.160:218]

            if (pos.x != you.x_pos || pos.y != you.y_pos)

[189.477]

[189.535]

            if (pos != you.pos())

Replacement in crawl-ref/source/spells3.cc at line 1330 [49.531613]
∅:D[189.574] → [190.759:797]
B:BD[49.550600] → [190.759:797]
```
            you.moveto(pos.x, pos.y);
```
[189.574]
[49.550666]
```
            you.moveto(pos);
```

Replacement in crawl-ref/source/spells3.cc at line 1332 [49.531613]

B:BD[49.550667] → [191.507:634]

∅:D[191.634] → [49.550796:550924]

B:BD[49.550796] → [49.550796:550924]

            if (grd[you.x_pos][you.y_pos] != DNGN_FLOOR
                    && grd[you.x_pos][you.y_pos] != DNGN_SHALLOW_WATER
                || mgrd[you.x_pos][you.y_pos] != NON_MONSTER
                || env.cgrid[you.x_pos][you.y_pos] != EMPTY_CLOUD)

[49.550667]

[49.550924]

            if (grd(you.pos()) != DNGN_FLOOR
                    && grd(you.pos()) != DNGN_SHALLOW_WATER
                || mgrd(you.pos()) != NON_MONSTER
                || env.cgrid(you.pos()) != EMPTY_CLOUD)

Replacement in crawl-ref/source/spells3.cc at line 1349 [49.531613]
B:BD[49.551245] → [192.150:174]
```
        int newx, newy;
```
[49.551245]
[49.551304]
```
        coord_def newpos;
```

Replacement in crawl-ref/source/spells3.cc at line 1353 [49.531613]

B:BD[49.551326] → [190.798:924]

            newx = random_range(X_BOUND_1 + 1, X_BOUND_2 - 1);
            newy = random_range(Y_BOUND_1 + 1, Y_BOUND_2 - 1);

[49.551326]

[49.551424]

            newpos.set( random_range(X_BOUND_1 + 1, X_BOUND_2 - 1),
                        random_range(Y_BOUND_1 + 1, Y_BOUND_2 - 1) );

Replacement in crawl-ref/source/spells3.cc at line 1356 [49.531613]

B:BD[49.551434] → [191.743:848]

∅:D[191.848] → [192.368:475]

B:BD[192.368] → [192.368:475]

        while (grd[newx][newy] != DNGN_FLOOR
                   && grd[newx][newy] != DNGN_SHALLOW_WATER
               || mgrd[newx][newy] != NON_MONSTER
               || env.cgrid[newx][newy] != EMPTY_CLOUD);

[49.551434]

[193.167]

        while (grd(newpos) != DNGN_FLOOR
                   && grd(newpos) != DNGN_SHALLOW_WATER
               || mgrd(newpos) != NON_MONSTER
               || env.cgrid(newpos) != EMPTY_CLOUD);

Replacement in crawl-ref/source/spells3.cc at line 1362 [49.531613]
B:BD[189.624] → [4.219:271]
```
        if (newx != you.x_pos || newy != you.y_pos)
```
[189.624]
[189.676]
```
        if (newpos != you.pos())
```
Replacement in crawl-ref/source/spells3.cc at line 1365 [49.531613]
B:BD[192.476] → [192.476:530]
```
        if ( newx == you.x_pos && newy == you.y_pos )
```
[192.476]
[192.530]
```
        if ( newpos == you.pos() )
```
Replacement in crawl-ref/source/spells3.cc at line 1367 [49.531613]
B:BD[192.590] → [192.590:631]
```
        else if ( see_grid(newx, newy) )
```
[192.590]
[192.631]
```
        else if ( see_grid(newpos) )
```
Replacement in crawl-ref/source/spells3.cc at line 1372 [49.531613]
B:BD[151.7160] → [192.771:823]
```
        you.x_pos = newx;
        you.y_pos = newy;
```
[151.7160]
[192.823]
```
        you.position = newpos;
```

Replacement in crawl-ref/source/spells3.cc at line 1414 [49.531613]

B:BD[49.552532] → [194.576:638]

B:BD[49.552596] → [194.639:705]

∅:D[194.705] → [49.552658:552668]

B:BD[49.552658] → [49.552658:552668]

B:BD[49.552668] → [113.1162:1229]

∅:D[113.1229] → [49.552765:552811]

B:BD[49.552765] → [49.552765:552811]

B:BD[49.552811] → [113.1230:1287]

∅:D[113.1287] → [49.552874:552928]

B:BD[49.552874] → [49.552874:552928]

    for (int srx = you.x_pos - 1; srx < you.x_pos + 2; srx++)
        for (int sry = you.y_pos - 1; sry < you.y_pos + 2; sry++)
        {
            // Tile already occupied by monster or yourself {dlb}:
            if (mgrd[srx][sry] != NON_MONSTER
                || srx == you.x_pos && sry == you.y_pos)
            {
                continue;
            }

[49.552531]

[194.706]

    for ( adjacent_iterator ai; ai; ++ai )
    {
        // Tile already occupied by monster
        if (mgrd(*ai) != NON_MONSTER)
            continue;

Replacement in crawl-ref/source/spells3.cc at line 1420 [49.531613]

B:BD[194.707] → [195.454:495]

∅:D[195.495] → [194.746:772]

B:BD[194.746] → [194.746:772]

            if ( one_chance_in(powc/5) )
                continue;

[194.707]

[49.552928]

        // This is where power comes in.
        if ( one_chance_in(powc/5) )
            continue;

Replacement in crawl-ref/source/spells3.cc at line 1424 [49.531613]

B:BD[49.552929] → [194.773:807]

B:BD[194.807] → [196.865:939]

∅:D[197.229] → [49.553048:553062]

∅:D[198.232] → [49.553048:553062]

∅:D[194.874] → [49.553048:553062]

∅:D[196.939] → [49.553048:553062]

B:BD[49.553048] → [49.553048:553062]

B:BD[49.553062] → [194.875:934]

∅:D[194.934] → [49.553125:553238]

B:BD[49.553125] → [49.553125:553238]

            bool proceed = false;
            for (unsigned int i = 0; i < ARRAYSZ(safe_to_overwrite); ++i)
            {
                if (grd[srx][sry] == safe_to_overwrite[i])
                {
                    proceed = true;
                    break;
                }
            }

[49.552929]

[49.553238]

        bool proceed = false;
        for (unsigned int i=0; i < ARRAYSZ(safe_to_overwrite) && !proceed; ++i)
            if (grd(*ai) == safe_to_overwrite[i])
                proceed = true;

Replacement in crawl-ref/source/spells3.cc at line 1429 [49.531613]

B:BD[49.553239] → [49.553239:553359]

            // checkpoint one - do we have a legitimate tile? {dlb}
            if (!proceed)
                continue;

[49.553239]

[49.553359]

        // checkpoint one - do we have a legitimate tile? {dlb}
        if (!proceed)
            continue;

Replacement in crawl-ref/source/spells3.cc at line 1433 [49.531613]

B:BD[49.553360] → [49.553360:553424]

            int objl = igrd[srx][sry];
            int hrg = 0;

[49.553360]

[49.553424]

        // hate to see the orb get destroyed by accident {dlb}:
        for ( stack_iterator si(*ai); si && proceed; ++si )
            if (si->base_type == OBJ_ORBS)
                proceed = false;

Replacement in crawl-ref/source/spells3.cc at line 1438 [49.531613]

B:BD[49.553425] → [49.553425:553476]

B:BD[49.553476] → [199.167:239]

∅:D[199.239] → [49.553548:553702]

B:BD[49.553548] → [49.553548:553702]

            while (objl != NON_ITEM)
            {
                // hate to see the orb get destroyed by accident {dlb}:
                if (mitm[objl].base_type == OBJ_ORBS)
                {
                    proceed = false;
                    break;
                }

[49.553425]

[49.553702]

        // checkpoint two - is the orb resting in the tile? {dlb}:
        if (!proceed)
            continue;
        
        // Destroy all items on the square.
        for ( stack_iterator si(*ai); si; ++si )
            destroy_item(si->index());
        
        // deal with clouds {dlb}:
        if (env.cgrid(*ai) != EMPTY_CLOUD)
            delete_cloud( env.cgrid(*ai) );

Replacement in crawl-ref/source/spells3.cc at line 1450 [49.531613]

B:BD[49.553703] → [49.553703:554333]

B:BD[49.554333] → [194.935:963]

B:BD[194.963] → [61.9714:9784]

                hrg = mitm[objl].link;
                objl = hrg;
            }
            // checkpoint two - is the orb resting in the tile? {dlb}:
            if (!proceed)
                continue;
            objl = igrd[srx][sry];
            hrg = 0;
            while (objl != NON_ITEM)
            {
                hrg = mitm[objl].link;
                destroy_item(objl);
                objl = hrg;
            }
            // deal with clouds {dlb}:
            if (env.cgrid[srx][sry] != EMPTY_CLOUD)
                delete_cloud( env.cgrid[srx][sry] );
            // mechanical traps are destroyed {dlb}:
            int which_trap;
            if ((which_trap = trap_at_xy(coord_def(srx, sry))) != -1)

[49.553703]

[49.554392]

        // mechanical traps are destroyed {dlb}:
        int which_trap = trap_at_xy(*ai);
        if ( which_trap != -1 )
        {
            trap_struct& trap(env.trap[which_trap]);
            if (trap_category(trap.type) == DNGN_TRAP_MECHANICAL)

Replacement in crawl-ref/source/spells3.cc at line 1457 [49.531613]

B:BD[49.554406] → [49.554406:554741]

                if (trap_category(env.trap[which_trap].type)
                                                    == DNGN_TRAP_MECHANICAL)
                {
                    env.trap[which_trap].type = TRAP_UNASSIGNED;
                    env.trap[which_trap].x = 1;
                    env.trap[which_trap].y = 1;
                }

[49.554406]

[49.554741]

                trap.type = TRAP_UNASSIGNED;
                trap.pos.set(1,1);

Insertion in crawl-ref/source/spells3.cc at line 1460 [49.531613]
[49.554755]
[49.554755]
```
        }
```

Replacement in crawl-ref/source/spells3.cc at line 1462 [49.531613]

B:BD[49.554756] → [113.1288:1334]

∅:D[113.1334] → [49.554802:554874]

B:BD[49.554802] → [49.554802:554874]

B:BD[49.554874] → [113.1335:1345]

            // Finally, place the wall {dlb}:
            grd[srx][sry] = DNGN_ROCK_WALL;
            number_built++;
        }

[49.554756]

[49.554933]

        // Finally, place the wall {dlb}:
        grd(*ai) = DNGN_ROCK_WALL;
        number_built++;
    }

Replacement in crawl-ref/source/spells3.cc at line 1494 [49.531613]
B:BD[49.555087] → [49.555087:555135]
```
}                               // end entomb()
```
[49.555087]
[62.1712]
```
}
```

Replacement in crawl-ref/source/spells3.cc at line 1496 [49.531613]

B:BD[62.1713] → [5.167:237]

// Is (posx, posy) inside a circle within LOS, with the given radius,

[62.1713]

[5.237]

// Is where inside a circle within LOS, with the given radius,

Replacement in crawl-ref/source/spells3.cc at line 1499 [49.531613]
∅:D[5.335] → [193.313:371]
B:BD[199.396] → [193.313:371]
```
static int _inside_circle(int posx, int posy, int radius)
```
[5.335]
[199.458]
```
static int _inside_circle(const coord_def& where, int radius)
```
Replacement in crawl-ref/source/spells3.cc at line 1501 [49.531613]
B:BD[199.460] → [199.460:502]
```
    if (!inside_level_bounds(posx, posy))
```
[199.460]
[200.167]
```
    if (!inside_level_bounds(where))
```
Replacement in crawl-ref/source/spells3.cc at line 1504 [49.531613]
B:BD[200.187] → [201.167:226]
```
    const coord_def ep = grid2view(coord_def(posx, posy));
```
[200.187]
[61.9975]
```
    const coord_def ep = grid2view(where);
```
Replacement in crawl-ref/source/spells3.cc at line 1508 [49.531613]
B:BD[199.522] → [199.522:581]
```
    int dist = distance(posx, posy, you.x_pos, you.y_pos);
```
[199.522]
[199.581]
```
    const int dist = distance(where, you.pos());
```

Replacement in crawl-ref/source/spells3.cc at line 1618 [49.531613]

B:BD[62.3294] → [202.2405:2479]

    env.sanctuary_pos.x = you.x_pos;
    env.sanctuary_pos.y = you.y_pos;

[62.3294]

[202.2479]

    env.sanctuary_pos  = you.pos();

Replacement in crawl-ref/source/spells3.cc at line 1634 [49.531613]

B:BD[185.297] → [118.6765:6857]

∅:D[118.6857] → [203.217:303]

B:BD[203.217] → [203.217:303]

B:BD[203.303] → [193.390:449]

B:BD[193.449] → [204.335:390]

    for (int x = -radius; x <= radius; x++)
        for (int y = -radius; y <= radius; y++)
        {
            int posx = you.x_pos + x;
            int posy = you.y_pos + y;
            int dist = _inside_circle(posx, posy, radius);
            if (dist == -1)
                continue;

[185.297]

[204.390]

    for ( radius_iterator ri(you.pos(), radius, false, false); ri; ++ri )
    {
        int dist = _inside_circle(*ri, radius);
        
        if (dist == -1)
            continue;

Replacement in crawl-ref/source/spells3.cc at line 1641 [49.531613]

B:BD[204.391] → [204.391:430]

B:BD[204.430] → [205.230:377]

            coord_def pos(posx, posy);
            if (env.map(pos).property == FPROP_BLOODY
                && see_grid(pos))
            {
                blood_count++;
            }

[204.391]

[193.547]

        const coord_def pos = *ri;
        if (env.map(pos).property == FPROP_BLOODY && see_grid(pos))
            blood_count++;

Replacement in crawl-ref/source/spells3.cc at line 1645 [49.531613]

B:BD[193.548] → [61.10311:10361]

∅:D[61.10361] → [206.167:222]

B:BD[205.435] → [206.167:222]

∅:D[206.222] → [205.523:587]

B:BD[205.523] → [205.523:587]

B:BD[205.587] → [61.10362:10421]

∅:D[61.10421] → [205.653:781]

B:BD[205.653] → [205.653:781]

∅:D[205.781] → [203.815:1188]

B:BD[185.396] → [203.815:1188]

B:BD[203.1188] → [207.167:210]

∅:D[207.210] → [203.1232:1385]

B:BD[203.1232] → [203.1232:1385]

            if (trap_type_at_xy(pos) != NUM_TRAPS
                && grd(pos) == DNGN_UNDISCOVERED_TRAP)
            {
                const dungeon_feature_type type =
                    trap_category( trap_type_at_xy(pos) );
                grd(pos) = type;
                set_envmap_obj(posx, posy, type);
                trap_count++;
            }
            // forming patterns
            if (pattern == 0    // outward rays
                  && (x == 0 || y == 0 || x == y || x == -y)
                || pattern == 1 // circles
                  && (dist >= (radius-1)*(radius-1) && dist <= radius*radius
                      || dist >= (radius/2-1)*(radius/2-1)
                         && dist <= radius*radius/4)
               || pattern == 2 // latticed
                  && (x%2 == 0 || y%2 == 0)
                || pattern == 3 // cross-like
                  && (abs(x)+abs(y) < 5 && x != y && x != -y))

[193.548]

[203.1385]

        if (trap_type_at_xy(pos) != NUM_TRAPS
            && grd(pos) == DNGN_UNDISCOVERED_TRAP)
        {
            const dungeon_feature_type type =
                trap_category( trap_type_at_xy(pos) );
            grd(pos) = type;
            set_envmap_obj(pos, type);
            trap_count++;
        }
        
        // forming patterns
        const int x = pos.x - you.pos().x, y = pos.y - you.pos().y;
        if (pattern == 0    // outward rays
            && (x == 0 || y == 0 || x == y || x == -y)
            || pattern == 1 // circles
            && (dist >= (radius-1)*(radius-1) && dist <= radius*radius
                || dist >= (radius/2-1)*(radius/2-1)
                && dist <= radius*radius/4)
            || pattern == 2 // latticed
            && (x%2 == 0 || y%2 == 0)
            || pattern == 3 // cross-like
            && (abs(x)+abs(y) < 5 && x != y && x != -y))
        {
            env.map(pos).property = FPROP_SANCTUARY_1; // yellow
        }
        else
            env.map(pos).property = FPROP_SANCTUARY_2; // white
        
        // scare all attacking monsters inside sanctuary, and make
        // all friendly monsters inside sanctuary stop attacking and
        // move towards the player.
        int monster = mgrd(pos);
        if (monster != NON_MONSTER)
        {
            monsters* mon = &menv[monster];
            
            if (mons_friendly(mon))

Replacement in crawl-ref/source/spells3.cc at line 1683 [49.531613]

B:BD[203.1399] → [203.1399:1475]

                env.map[posx][posy].property = FPROP_SANCTUARY_1; // yellow

[203.1399]

[203.1475]

                mon->foe       = MHITYOU;
                mon->target    = you.pos();
                mon->behaviour = BEH_SEEK;
                behaviour_event(mon, ME_EVAL, MHITYOU);

Replacement in crawl-ref/source/spells3.cc at line 1688 [49.531613]

B:BD[203.1489] → [203.1489:1581]

B:BD[203.1581] → [207.211:212]

B:BD[207.212] → [208.167:351]

∅:D[208.351] → [204.431:515]

B:BD[207.273] → [204.431:515]

            else
                env.map[posx][posy].property = FPROP_SANCTUARY_2; // white
            // scare all attacking monsters inside sanctuary, and make
            // all friendly monsters inside sanctuary stop attacking and
            // move towards the player.
            int monster = mgrd[posx][posy];
            if (monster != NON_MONSTER)

[203.1489]

[207.301]

            else if (!mons_wont_attack(mon))

Replacement in crawl-ref/source/spells3.cc at line 1690 [49.531613]
B:BD[207.315] → [204.516:564]
∅:D[204.564] → [207.359:360]
B:BD[207.359] → [207.359:360]
B:BD[207.360] → [208.352:392]
```
                monsters* mon = &menv[monster];
                if (mons_friendly(mon))
```
[207.315]
[208.392]
```
                if (mons_is_mimic(mon->type))
```

Replacement in crawl-ref/source/spells3.cc at line 1692 [49.531613]

B:BD[208.410] → [208.410:654]

                   mon->foe       = MHITYOU;
                   mon->target_x  = you.x_pos;
                   mon->target_y  = you.y_pos;
                   mon->behaviour = BEH_SEEK;
                   behaviour_event(mon, ME_EVAL, MHITYOU);

[208.410]

[208.654]

                    mimic_alert(mon);
                    if(you.can_see(mon))
                    {
                        scare_count++;
                        seen_mon = mon;
                    }

Replacement in crawl-ref/source/spells3.cc at line 1699 [49.531613]

B:BD[208.672] → [208.672:721]

                else if (!mons_wont_attack(mon))

[208.672]

[207.404]

                else if (mon->add_ench(mon_enchant(ENCH_FEAR, 0, KC_YOU)))

Replacement in crawl-ref/source/spells3.cc at line 1701 [49.531613]

B:BD[207.422] → [204.610:660]

                    if (mons_is_mimic(mon->type))

[207.422]

[207.513]

                    behaviour_event(mon, ME_SCARE, MHITYOU);
                    
                    // Check to see that monster is actually fleeing,
                    // since plants can't flee.
                    if (mons_is_fleeing(mon) && you.can_see(mon))

Replacement in crawl-ref/source/spells3.cc at line 1707 [49.531613]

B:BD[207.535] → [204.661:748]

∅:D[204.748] → [207.589:615]

B:BD[207.589] → [207.589:615]

B:BD[207.615] → [204.749:836]

∅:D[204.836] → [207.751:777]

B:BD[207.751] → [207.751:777]

B:BD[207.777] → [204.837:1054]

∅:D[207.988] → [185.397:398]

∅:D[204.1054] → [185.397:398]

∅:D[203.1597] → [185.397:398]

B:BD[62.4422] → [185.397:398]

B:BD[185.398] → [204.1055:1364]

∅:D[204.1364] → [207.1238:1264]

B:BD[207.1238] → [207.1238:1264]

                        mimic_alert(mon);
                        if(you.can_see(mon))
                        {
                            scare_count++;
                            seen_mon = mon;
                        }
                    }
                    else if (mon->add_ench(mon_enchant(ENCH_FEAR, 0,
                             KC_YOU)))
                    {
                        behaviour_event(mon, ME_SCARE, MHITYOU);
                        // Check to see that monster is actually fleeing,
                        // since plants can't flee.
                        if (mons_is_fleeing(mon) && you.can_see(mon))
                        {
                            scare_count++;
                            seen_mon = mon;
                        }

[207.535]

[207.1264]

                        scare_count++;
                        seen_mon = mon;

Deletion in crawl-ref/source/spells3.cc at line 1711 [49.531613]

B:BD[204.1383] → [204.1383:1622]

            } // if (monster != NON_MONSTER)
            if (!is_harmless_cloud(cloud_type_at(pos)))
            {
                delete_cloud(env.cgrid[posx][posy]);
                if (see_grid(pos))
                    cloud_count++;

Replacement in crawl-ref/source/spells3.cc at line 1712 [49.531613]

∅:D[204.1636] → [207.1368:1393]

B:BD[207.1368] → [207.1368:1393]

        } // radius loop

[204.1636]

[207.1393]

        } // if (monster != NON_MONSTER)
        
        if (!is_harmless_cloud(cloud_type_at(pos)))
        {
            delete_cloud(env.cgrid(pos));
            if (see_grid(pos))
                cloud_count++;
        }
    } // radius loop

Replacement in crawl-ref/source/spells3.cc at line 1764 [49.531613]
B:BD[186.209] → [186.209:246]
```
bool inside_halo(int posx, int posy)
```
[186.209]
[186.246]
```
bool inside_halo(const coord_def& where)
```
Replacement in crawl-ref/source/spells3.cc at line 1769 [49.531613]
∅:D[103.1317] → [186.248:310]
B:BD[186.248] → [186.248:310]
```
    return (_inside_circle(posx, posy, halo_radius()) != -1);
```
[103.1317]
[185.1335]
```
    return (_inside_circle(where, halo_radius()) != -1);
```
Replacement in crawl-ref/source/spells3.cc at line 1772 [49.531613]
∅:D[62.5289] → [49.555136:555164]
B:BD[49.555136] → [49.555136:555164]
```
void cast_poison_ammo(void)
```
[185.1338]
[49.555164]
```
void cast_poison_ammo()
```
Replacement in crawl-ref/source/spells3.cc at line 1855 [49.531613]
∅:D[209.3936] → [49.557591:557680]
B:BD[49.557591] → [49.557591:557680]
```
    FixedVector < char, 2 > empty;
    struct monsters *monster = 0;       // NULL {dlb}
```
[209.3936]
[49.557680]
```
    monsters *monster = 0;
```
Deletion in crawl-ref/source/spells3.cc at line 1857 [49.531613]
B:BD[49.557681] → [49.557681:557711]
```
    empty[0] = empty[1] = 0;
```

Replacement in crawl-ref/source/spells3.cc at line 1894 [49.531613]

B:BD[49.558887] → [209.4099:4248]

        if (empty_surrounds(you.x_pos, you.y_pos, DNGN_FLOOR, 3, false, empty)
            && monster->move_to_pos( coord_def(empty[0], empty[1])) )

[49.558887]

[49.558964]

        coord_def empty;
        if (empty_surrounds(you.pos(), DNGN_FLOOR, 3, false, empty)
            && monster->move_to_pos( empty ) )

Replacement in crawl-ref/source/spells3.cc at line 1921 [49.531613]
B:BD[49.560040] → [49.560040:560094]
```
    else if (grd[you.x_pos][you.y_pos] != DNGN_FLOOR)
```
[49.560040]
[49.560094]
```
    else if (grd(you.pos()) != DNGN_FLOOR)
```

Deletion in crawl-ref/source/spells2.h at line 43 [49.562867]

∅:D[210.174] → [49.564817:565024]

∅:D[211.1244] → [49.564817:565024]

B:BD[49.564817] → [49.564817:565024]

// last updated 24may2000 {dlb}
/* ***********************************************************************
 * called from: spell
 * *********************************************************************** */

Deletion in crawl-ref/source/spells2.h at line 44 [49.562867]
∅:D[212.79] → [49.565053:565262]
∅:D[210.212] → [49.565053:565262]
∅:D[213.217] → [49.565053:565262]
B:BD[49.565053] → [49.565053:565262]
```
// last updated 24may2000 {dlb}
/* ***********************************************************************
 * called from: spell
 * *********************************************************************** */
```

Replacement in crawl-ref/source/spells2.h at line 45 [49.562867]

∅:D[214.226] → [49.565305:565762]

B:BD[49.565305] → [49.565305:565762]

B:BD[49.565762] → [12.168:207]

∅:D[12.207] → [49.565802:566022]

B:BD[49.565802] → [49.565802:566022]


// last updated 24may2000 {dlb}
/* ***********************************************************************
 * called from: spell
 * *********************************************************************** */
unsigned char detect_items( int pow );
// last updated 24may2000 {dlb}
/* ***********************************************************************
 * called from: spell
 * *********************************************************************** */
unsigned char detect_traps( int pow );
// last updated 24may2000 {dlb}
/* ***********************************************************************
 * called from: item_use - spell
 * *********************************************************************** */

[214.226]

[49.566022]

int detect_items( int pow );
int detect_traps( int pow );

Deletion in crawl-ref/source/spells2.h at line 48 [49.562867]

B:BD[49.566056] → [49.566056:566276]


// last updated 24may2000 {dlb}
/* ***********************************************************************
 * called from: item_use - spell
 * *********************************************************************** */

Deletion in crawl-ref/source/spells2.h at line 49 [49.562867]

B:BD[49.566308] → [49.566308:566417]

B:BD[49.566686] → [49.566686:566788]


// last updated 24may2000 {dlb}
/* ***********************************************************************
 * called from: ability
 * *********************************************************************** */

Deletion in crawl-ref/source/spells2.h at line 50 [49.562867]

B:BD[49.566814] → [49.566814:566923]

B:BD[49.567167] → [49.567167:567334]


// last updated 24may2000 {dlb}
/* ***********************************************************************
 * called from: ability - food - it_use2 - spell
 * returns TRUE if a stat was restored.
 * *********************************************************************** */

Deletion in crawl-ref/source/spells2.h at line 52 [49.562867]
B:BD[215.229] → [216.427:428]

Deletion in crawl-ref/source/spells2.h at line 53 [49.562867]

B:BD[49.567399] → [216.429:636]

// last updated 24may2000 {dlb}
/* ***********************************************************************
 * called from: spell
 * *********************************************************************** */

Deletion in crawl-ref/source/spells2.h at line 54 [49.562867]

∅:D[216.666] → [49.567399:567617]

B:BD[49.567399] → [49.567399:567617]


// last updated 24may2000 {dlb}
/* ***********************************************************************
 * called from: ability - spell
 * *********************************************************************** */

Deletion in crawl-ref/source/spells2.h at line 58 [49.562867]

∅:D[217.6660] → [218.571:800]

B:BD[219.1722] → [218.571:800]


// last updated 24may2000 {dlb}
/* ***********************************************************************
 * called from: ability - religion - spell
 * *********************************************************************** */

Deletion in crawl-ref/source/spells2.h at line 61 [49.562867]

B:BD[218.928] → [218.928:1145]

// last updated 24may2000 {dlb}
/* ***********************************************************************
 * called from: ability - spell
 * *********************************************************************** */

Deletion in crawl-ref/source/spells2.h at line 63 [49.562867]

B:BD[220.222] → [220.222:439]

// last updated 24may2000 {dlb}
/* ***********************************************************************
 * called from: it_use3 - spell
 * *********************************************************************** */

Deletion in crawl-ref/source/spells2.h at line 66 [49.562867]

B:BD[220.622] → [220.622:840]


// last updated 24may2000 {dlb}
/* ***********************************************************************
 * called from: ability - spell
 * *********************************************************************** */

Deletion in crawl-ref/source/spells2.h at line 69 [49.562867]

∅:D[221.483] → [222.645:863]

∅:D[217.7044] → [222.645:863]

B:BD[222.645] → [222.645:863]


// last updated 24may2000 {dlb}
/* ***********************************************************************
 * called from: ability - spell
 * *********************************************************************** */

Deletion in crawl-ref/source/spells2.h at line 74 [49.562867]

B:BD[49.567664] → [49.567664:567771]

B:BD[49.567771] → [216.667:710]

∅:D[216.710] → [49.567793:567871]

B:BD[49.567793] → [49.567793:567871]

// last updated 24may2000 {dlb}
/* ***********************************************************************
 * called from: ability - religion - spell
 * *********************************************************************** */

Deletion in crawl-ref/source/spells2.h at line 76 [49.562867]
∅:D[223.182] → [49.567903:567904]
∅:D[224.484] → [49.567903:567904]
∅:D[225.567] → [49.567903:567904]
∅:D[216.848] → [49.567903:567904]
B:BD[49.567903] → [49.567903:567904]
B:BD[49.567904] → [216.849:1066]
```
// last updated 24may2000 {dlb}
/* ***********************************************************************
 * called from: ability - spell
 * *********************************************************************** */
```
Deletion in crawl-ref/source/spells2.h at line 77 [49.562867]
∅:D[226.626] → [49.567904:568012]
∅:D[216.1109] → [49.567904:568012]
∅:D[217.7389] → [49.567904:568012]
B:BD[49.567904] → [49.567904:568012]
B:BD[49.569025] → [49.569025:569135]
```
// last updated 24may2000 {dlb}
/* ***********************************************************************
 * called from: ability - spell
 * *********************************************************************** */
```
Replacement in crawl-ref/source/spells2.cc at line 61 [49.569242]
∅:D[227.313] → [49.570606:570644]
B:BD[49.570606] → [49.570606:570644]
```
unsigned char detect_traps( int pow )
```
[49.570606]
[49.570644]
```
int detect_traps( int pow )
```
Replacement in crawl-ref/source/spells2.cc at line 63 [49.569242]
B:BD[49.570646] → [49.570646:570681]
```
    unsigned char traps_found = 0;
```
[49.570646]
[49.570681]
```
    int traps_found = 0;
```
Replacement in crawl-ref/source/spells2.cc at line 70 [49.569242]
B:BD[49.570764] → [49.570764:570822]
```
    for (int count_x = 0; count_x < MAX_TRAPS; count_x++)
```
[49.570764]
[49.570822]
```
    for (int i = 0; i < MAX_TRAPS; i++)
```

Replacement in crawl-ref/source/spells2.cc at line 72 [49.569242]

B:BD[49.570828] → [49.570828:570922]

        const int etx = env.trap[ count_x ].x;
        const int ety = env.trap[ count_x ].y;

[49.570828]

[49.570922]

        const coord_def p = env.trap[i].pos;

Replacement in crawl-ref/source/spells2.cc at line 74 [49.569242]

B:BD[49.570923] → [49.570923:571158]

        // Used to just be visible screen:
        // if (etx > you.x_pos - 15 && etx < you.x_pos + 15
        //     && ety > you.y_pos - 8 && ety < you.y_pos + 8)
        if (grid_distance( you.x_pos, you.y_pos, etx, ety ) < range)

[49.570923]

[49.571158]

        if (grid_distance( you.pos(), p) < range
            && grd(p) == DNGN_UNDISCOVERED_TRAP)

Replacement in crawl-ref/source/spells2.cc at line 77 [49.569242]

B:BD[49.571168] → [49.571168:571274]

            if (grd[ etx ][ ety ] == DNGN_UNDISCOVERED_TRAP)
            {
                traps_found++;

[49.571168]

[49.571274]

            traps_found++;

Replacement in crawl-ref/source/spells2.cc at line 79 [49.569242]

B:BD[49.571275] → [49.571275:571352]

B:BD[49.571352] → [48.12640:12697]

∅:D[48.12697] → [51.148860:148906]

B:BD[51.148860] → [51.148860:148906]

∅:D[51.148906] → [49.571401:571415]

B:BD[49.571401] → [49.571401:571415]

                grd[ etx ][ ety ] = trap_category( env.trap[count_x].type );
                set_envmap_obj(etx, ety, grd[etx][ety]);
                set_terrain_mapped(etx, ety);
            }

[49.571275]

[49.571415]

            grd(p) = trap_category( env.trap[i].type );
            set_envmap_obj(p, grd(p));
            set_terrain_mapped(p);

Replacement in crawl-ref/source/spells2.cc at line 88 [49.569242]
B:BD[49.571513] → [49.571513:571551]
```
unsigned char detect_items( int pow )
```
[49.571513]
[49.571551]
```
int detect_items( int pow )
```

Replacement in crawl-ref/source/spells2.cc at line 93 [49.569242]

B:BD[49.571590] → [49.571590:571625]

B:BD[49.571625] → [228.1005:1059]

    unsigned char items_found = 0;
    const int     map_radius  = 8 + random2(8) + pow;

[49.571590]

[49.571709]

    int items_found = 0;
    const int map_radius  = 8 + random2(8) + pow;

Replacement in crawl-ref/source/spells2.cc at line 96 [49.569242]

B:BD[49.571710] → [49.571710:571784]

B:BD[49.571790] → [49.571790:571878]

B:BD[49.571878] → [53.198:232]

∅:D[53.232] → [49.571944:571970]

B:BD[49.571944] → [49.571944:571970]

    for (int i = you.x_pos - map_radius; i < you.x_pos + map_radius; i++)
        for (int j = you.y_pos - map_radius; j < you.y_pos + map_radius; j++)
        {
            if (!in_bounds(i, j))
                continue;

[49.571710]

[49.571970]

    for ( radius_iterator ri(you.pos(), map_radius, true, false); ri; ++ri )
    {

Replacement in crawl-ref/source/spells2.cc at line 99 [49.569242]

B:BD[49.571971] → [228.1060:1333]

            // Don't expose new dug out areas:
            // Note: assumptions are being made here about how
            // terrain can change (eg it used to be solid, and
            // thus item free).
            if (is_terrain_changed(i, j))
                continue;

[49.571971]

[228.1333]

        // Don't expose new dug out areas:
        // Note: assumptions are being made here about how
        // terrain can change (eg it used to be solid, and
        // thus item free).
        if (is_terrain_changed(*ri))
            continue;

Replacement in crawl-ref/source/spells2.cc at line 106 [49.569242]

∅:D[228.1334] → [53.233:341]

B:BD[49.571971] → [53.233:341]

∅:D[53.341] → [49.572011:572025]

B:BD[49.572011] → [49.572011:572025]

B:BD[49.572025] → [229.425:457]

∅:D[229.457] → [48.12698:12756]

B:BD[49.572025] → [48.12698:12756]

∅:D[48.12756] → [51.148985:149033]

B:BD[51.148985] → [51.148985:149033]

            if (igrd[i][j] != NON_ITEM
                && (!get_envmap_obj(i, j) || !is_envmap_item(i, j)))
            {
                items_found++;
                set_envmap_obj(i, j, DNGN_ITEM_DETECTED);
                set_envmap_detected_item(i, j);

[228.1334]

[58.233756]

        if (igrd(*ri) != NON_ITEM
            && (!get_envmap_obj(*ri) || !is_envmap_item(*ri)))
        {
            items_found++;
            
            set_envmap_obj(*ri, DNGN_ITEM_DETECTED);
            set_envmap_detected_item(*ri);

Replacement in crawl-ref/source/spells2.cc at line 114 [49.569242]

B:BD[58.233772] → [58.233772:233954]

                // Don't replace previously seen items with an unseen one.
                if (!is_terrain_seen(i,j))
                    tile_place_tile_bk(i, j, TILE_UNSEEN_ITEM);

[58.233772]

[58.233954]

            // Don't replace previously seen items with an unseen one.
            if (!is_terrain_seen(*ri))
                tile_place_tile_bk(ri->x, ri->y, TILE_UNSEEN_ITEM);

Deletion in crawl-ref/source/spells2.cc at line 118 [49.569242]
∅:D[51.149033] → [49.572070:572084]
∅:D[68.191770] → [49.572070:572084]
∅:D[58.233961] → [49.572070:572084]
B:BD[49.572070] → [49.572070:572084]
```
            }
```
Insertion in crawl-ref/source/spells2.cc at line 119 [49.569242]
[49.572094]
[49.572100]
```
    }
```

Replacement in crawl-ref/source/spells2.cc at line 142 [49.569242]

B:BD[49.572182] → [162.8359:8438]

static bool _mark_detected_creature(int gridx, int gridy, const monsters *mon,

[49.572182]

[162.8438]

static bool _mark_detected_creature(coord_def where, const monsters *mon,

Replacement in crawl-ref/source/spells2.cc at line 147 [49.569242]
B:BD[58.234012] → [58.234012:234046]
```
    int idx = mgrd[gridx][gridy];
```
[58.234012]
[58.234046]
```
    int idx = mgrd(where);
```
Replacement in crawl-ref/source/spells2.cc at line 155 [49.569242]
B:BD[51.149750] → [51.149750:149771]
```
        int gx, gy;
```
[51.149750]
[228.1335]
```
        
        coord_def place;
```

Replacement in crawl-ref/source/spells2.cc at line 161 [49.569242]

B:BD[51.149859] → [51.149859:149977]

            gx = gridx + random2(fuzz_diam) - fuzz_radius;
            gy = gridy + random2(fuzz_diam) - fuzz_radius;

[51.149859]

[51.149977]

            place.set( where.x + random2(fuzz_diam) - fuzz_radius,
                       where.y + random2(fuzz_diam) - fuzz_radius );

Replacement in crawl-ref/source/spells2.cc at line 166 [49.569242]
B:BD[228.1586] → [228.1586:1620]
```
            if (see_grid(gx, gy))
```
[228.1586]
[228.1620]
```
            if (see_grid(place))
```

Replacement in crawl-ref/source/spells2.cc at line 170 [49.569242]

B:BD[228.1709] → [228.1709:1758]

            if (is_envmap_detected_mons(gx, gy))

[228.1709]

[228.1758]

            if (is_envmap_detected_mons(place))

Replacement in crawl-ref/source/spells2.cc at line 175 [49.569242]

B:BD[228.1917] → [228.1917:1983]

∅:D[228.1983] → [171.591:651]

B:BD[230.197] → [171.591:651]

            if (map_bounds(gx, gy) && !is_terrain_changed(gx, gy)
                && mon->can_pass_through_feat(grd[gx][gy]))

[228.1917]

[51.150045]

            if (map_bounds(place) && !is_terrain_changed(place)
                && mon->can_pass_through_feat(grd(place)))

Replacement in crawl-ref/source/spells2.cc at line 184 [49.569242]

B:BD[51.150166] → [51.150166:150234]

        {
            gridx = gx;
            gridy = gy;
        }

[51.150166]

[51.150234]

            where = place;

Replacement in crawl-ref/source/spells2.cc at line 187 [49.569242]

B:BD[51.150241] → [48.12757:12827]

∅:D[48.12827] → [51.150298:150342]

B:BD[51.150298] → [51.150298:150342]

    set_envmap_obj(gridx, gridy, mon->type + DNGN_START_OF_MONSTERS);
    set_envmap_detected_mons(gridx, gridy);

[51.150241]

[229.568]

    set_envmap_obj(where, mon->type + DNGN_START_OF_MONSTERS);
    set_envmap_detected_mons(where);

Replacement in crawl-ref/source/spells2.cc at line 191 [49.569242]

B:BD[58.234071] → [231.1198:1254]

    tile_place_monster(gridx, gridy, idx, false, true);

[58.234071]

[58.234121]

    tile_place_monster(where.x, where.y, idx, false, true);

Replacement in crawl-ref/source/spells2.cc at line 214 [49.569242]

B:BD[49.572391] → [49.572391:572465]

B:BD[49.572471] → [49.572471:572549]

    for (int i = you.x_pos - map_radius; i < you.x_pos + map_radius; i++)
        for (int j = you.y_pos - map_radius; j < you.y_pos + map_radius; j++)

[49.572356]

[49.572549]

    for (radius_iterator ri(you.pos(), map_radius, true, false); ri; ++ri)
    {
        if (mgrd(*ri) != NON_MONSTER)

Replacement in crawl-ref/source/spells2.cc at line 218 [49.569242]
B:BD[49.572559] → [232.239:273]
∅:D[232.273] → [49.572625:572651]
B:BD[49.572625] → [49.572625:572651]
```
            if (!in_bounds(i, j))
                continue;
```
[49.572559]
[49.572651]
```
            monsters *mon = &menv[ mgrd(*ri) ];
            creatures_found++;
```

Replacement in crawl-ref/source/spells2.cc at line 221 [49.569242]

B:BD[49.572652] → [49.572652:572695]

            if (mgrd[i][j] != NON_MONSTER)

[49.572652]

[49.572695]

            _mark_detected_creature(*ri, mon, fuzz_chance, fuzz_radius);
            
            // Assuming that highly intelligent spellcasters can
            // detect scrying. -- bwr
            if (mons_intel( mon->type ) == I_HIGH
                && mons_class_flag( mon->type, M_SPELLCASTER ))

Replacement in crawl-ref/source/spells2.cc at line 228 [49.569242]

B:BD[49.572709] → [214.495:548]

B:BD[214.548] → [232.274:310]

B:BD[232.500] → [162.8575:8653]

∅:D[232.577] → [49.572834:572904]

∅:D[229.792] → [49.572834:572904]

∅:D[162.8653] → [49.572834:572904]

∅:D[51.150835] → [49.572834:572904]

∅:D[68.192078] → [49.572834:572904]

B:BD[49.572834] → [49.572834:572904]

B:BD[49.572904] → [51.150836:150878]

∅:D[51.150878] → [49.572946:573000]

B:BD[49.572946] → [49.572946:573000]

B:BD[49.573000] → [51.150879:150947]

∅:D[51.150947] → [49.573062:573080]

B:BD[49.573062] → [49.573062:573080]

B:BD[49.573080] → [61.10480:10556]

∅:D[61.10556] → [49.573205:573223]

B:BD[49.573205] → [49.573205:573223]

                monsters *mon = &menv[ mgrd[i][j] ];
                creatures_found++;
                _mark_detected_creature(i, j, mon, fuzz_chance, fuzz_radius);
                // Assuming that highly intelligent spellcasters can
                // detect scrying. -- bwr
                if (mons_intel( mon->type ) == I_HIGH
                    && mons_class_flag( mon->type, M_SPELLCASTER ))
                {
                    behaviour_event( mon, ME_DISTURB, MHITYOU, you.pos() );
                }

[49.572709]

[49.573223]

                behaviour_event( mon, ME_DISTURB, MHITYOU, you.pos() );

Insertion in crawl-ref/source/spells2.cc at line 231 [49.569242]
[49.573247]
[49.573253]
```
    }
```
Replacement in crawl-ref/source/spells2.cc at line 240 [49.569242]
B:BD[49.573393] → [49.573393:573429]
```
    char adx = 0;
    char ady = 0;
```
[49.573393]
[49.573429]
```
    int adx = 0;
    int ady = 0;
```

Replacement in crawl-ref/source/spells2.cc at line 243 [49.569242]

B:BD[49.573430] → [49.573430:573523]

B:BD[49.573523] → [68.192079:192110]

∅:D[68.192110] → [49.573554:573592]

B:BD[49.573554] → [49.573554:573592]

    char minx = you.x_pos - 6;
    char maxx = you.x_pos + 7;
    char miny = you.y_pos - 6;
    char maxy = you.y_pos + 7;
    char xinc = 1;
    char yinc = 1;

[49.573430]

[49.573592]

    int minx = you.pos().x - 6;
    int maxx = you.pos().x + 7;
    int miny = you.pos().y - 6;
    int maxy = you.pos().y + 7;
    int xinc = 1;
    int yinc = 1;

Replacement in crawl-ref/source/spells2.cc at line 252 [49.569242]

B:BD[49.573619] → [49.573619:573679]

        minx = you.x_pos + 6;
        maxx = you.x_pos - 7;

[49.573619]

[49.573679]

        minx = you.pos().x + 6;
        maxx = you.pos().x - 7;

Replacement in crawl-ref/source/spells2.cc at line 259 [49.569242]

B:BD[49.573731] → [49.573731:573791]

        miny = you.y_pos + 6;
        maxy = you.y_pos - 7;

[49.573731]

[49.573791]

        miny = you.pos().y + 6;
        maxy = you.pos().y - 7;

Replacement in crawl-ref/source/spells2.cc at line 270 [49.569242]

B:BD[49.574039] → [61.10654:10728]

                if (igrd(ad) == NON_ITEM || env.cgrid(ad) != EMPTY_CLOUD)

[49.574039]

[49.574163]

                if (env.cgrid(ad) != EMPTY_CLOUD)

Replacement in crawl-ref/source/spells2.cc at line 809 [49.569242]
B:BD[49.594349] → [213.271:335]
```
    int mgr = mgrd[you.x_pos + vmove.dx][you.y_pos + vmove.dy];
```
[49.594349]
[49.594713]
```
    int mgr = mgrd(you.pos() + vmove.delta);
```

Replacement in crawl-ref/source/spells2.cc at line 883 [49.569242]

B:BD[49.596584] → [32.176:242]

    const int mgr = mgrd[you.x_pos + spd.dx][you.y_pos + spd.dy];

[49.596584]

[172.5796]

    const int mgr = mgrd(you.pos() + spd.delta);

Replacement in crawl-ref/source/spells2.cc at line 1396 [49.569242]
B:BD[233.851] → [233.851:874]
```
    struct dist smove;
```
[233.851]
[233.874]
```
    coord_def targ;
    dist smove;
```
Deletion in crawl-ref/source/spells2.cc at line 1399 [49.569242]
B:BD[233.875] → [233.875:938]
```
    int dir_x;
    int dir_y;
    int targ_x;
    int targ_y;
```
Deletion in crawl-ref/source/spells2.cc at line 1400 [49.569242]
B:BD[233.995] → [217.8075:8076]

Replacement in crawl-ref/source/spells2.cc at line 1414 [49.569242]

B:BD[233.1316] → [233.1316:1442]

        dir_x  = smove.dx;
        dir_y  = smove.dy;
        targ_x = you.x_pos + dir_x;
        targ_y = you.y_pos + dir_y;

[233.1316]

[233.1442]

        targ = you.pos() + smove.delta;

Replacement in crawl-ref/source/spells2.cc at line 1416 [49.569242]
B:BD[233.1443] → [233.1443:1492]
```
        if (mgrd[targ_x][targ_y] != NON_MONSTER)
```
[233.1443]
[233.1492]
```
        if (mgrd(targ) != NON_MONSTER)
```

Replacement in crawl-ref/source/spells2.cc at line 1418 [49.569242]

B:BD[233.1502] → [233.1502:1571]

            if (player_monster_visible(&menv[mgrd[targ_x][targ_y]]))

[233.1502]

[233.1571]

            if (player_monster_visible(&menv[mgrd(targ)]))

Replacement in crawl-ref/source/spells2.cc at line 1426 [49.569242]
B:BD[233.1782] → [233.1782:1825]
```
        else if (dir_x == 0 && dir_y == 0)
```
[233.1782]
[233.1825]
```
        else if (smove.delta.origin())
```

Replacement in crawl-ref/source/spells2.cc at line 1429 [49.569242]

B:BD[233.1966] → [233.1966:2103]

                 && (grd[ targ_x ][ targ_y ] == DNGN_ROCK_WALL
                     || grd[ targ_x ][ targ_y ] == DNGN_CLEAR_ROCK_WALL))

[233.1966]

[233.2103]

                 && (grd(targ) == DNGN_ROCK_WALL
                     || grd(targ) == DNGN_CLEAR_ROCK_WALL))

Replacement in crawl-ref/source/spells2.cc at line 1432 [49.569242]

B:BD[233.2113] → [233.2113:2189]

            if (targ_x <= 6 || targ_x >= 74 || targ_y <= 6 || targ_y >= 64)

[233.2113]

[233.2189]

            const int boundary = 6;
            if (targ.x <= boundary
                || targ.x >= GXM - boundary
                || targ.y <= boundary
                || targ.y >= GYM - boundary)

Replacement in crawl-ref/source/spells2.cc at line 1453 [49.569242]
B:BD[233.2535] → [233.2535:2577]
```
        grd[targ_x][targ_y] = DNGN_FLOOR;
```
[233.2535]
[233.2577]
```
        grd(targ) = DNGN_FLOOR;
```

Replacement in crawl-ref/source/spells2.cc at line 1455 [49.569242]

B:BD[233.2583] → [233.2583:2709]

    else if (env.cgrid[targ_x][targ_y] != EMPTY_CLOUD
             && env.cloud[env.cgrid[targ_x][targ_y]].type == CLOUD_FIRE

[233.2583]

[233.2709]

    else if (env.cgrid(targ) != EMPTY_CLOUD
             && env.cloud[env.cgrid(targ)].type == CLOUD_FIRE

Replacement in crawl-ref/source/spells2.cc at line 1460 [49.569242]
B:BD[233.2825] → [233.2825:2874]
```
        delete_cloud(env.cgrid[targ_x][targ_y]);
```
[233.2825]
[233.2874]
```
        delete_cloud(env.cgrid(targ));
```
Replacement in crawl-ref/source/spells2.cc at line 1462 [49.569242]
B:BD[233.2880] → [233.2880:2926]
```
    else if (grd[targ_x][targ_y] == DNGN_LAVA
```
[233.2880]
[233.2926]
```
    else if (grd(targ) == DNGN_LAVA
```

Replacement in crawl-ref/source/spells2.cc at line 1467 [49.569242]

B:BD[233.3048] → [233.3048:3224]

    else if ((grd[targ_x][targ_y] == DNGN_DEEP_WATER
                || grd[targ_x][targ_y] == DNGN_SHALLOW_WATER
                || grd[targ_x][targ_y] == DNGN_FOUNTAIN_BLUE)

[233.3048]

[233.3224]

    else if ((grd(targ) == DNGN_DEEP_WATER
                || grd(targ) == DNGN_SHALLOW_WATER
                || grd(targ) == DNGN_FOUNTAIN_BLUE)

Replacement in crawl-ref/source/spells2.cc at line 1474 [49.569242]

B:BD[233.3348] → [233.3348:3452]

    else if (grd[targ_x][targ_y] >= DNGN_FLOOR
             && env.cgrid[targ_x][targ_y] == EMPTY_CLOUD

[233.3348]

[233.3452]

    else if (grd(targ) >= DNGN_FLOOR
             && env.cgrid(targ) == EMPTY_CLOUD

Replacement in crawl-ref/source/spells2.cc at line 1512 [49.569242]

B:BD[233.4820] → [233.4820:4962]

B:BD[233.4962] → [234.169:228]

B:BD[234.228] → [23.169:207]

            mgen_data(mon,
                      friendly ? BEH_FRIENDLY : BEH_HOSTILE,
                      dur, coord_def(targ_x, targ_y),
                      friendly ? you.pet_target : MHITYOU,
                      0, god)) == -1)

[233.4820]

[233.5029]

            mgen_data(mon, friendly ? BEH_FRIENDLY : BEH_HOSTILE,
                      dur, targ, friendly ? you.pet_target : MHITYOU, 0, god))
        == -1)

Replacement in crawl-ref/source/spells2.cc at line 1783 [49.569242]
B:BD[216.2810] → [216.2810:2848]
```
    mitm[i].x = 0;
    mitm[i].y = 0;
```
[216.2810]
[216.2848]
```
    mitm[i].pos.reset();
```

Replacement in crawl-ref/source/spells1.h at line 33 [49.611815]

B:BD[49.613353] → [235.178:243]

int cast_healing(int pow, int target_x = -1, int target_y = -1);

[49.613353]

[236.170]

int cast_healing(int pow, const coord_def& where = coord_def(-1,1));

Replacement in crawl-ref/source/spells1.h at line 41 [49.611815]

B:BD[49.613384] → [49.613384:613619]

B:BD[49.613619] → [130.2023:2099]

// last updated 24may2000 {dlb}
/* ***********************************************************************
 * called from: beam - it_use3 - spells - spells1
 * *********************************************************************** */
void big_cloud(cloud_type cl_type, kill_category whose, int cl_x, int cl_y,

[49.613384]

[45.63942]

void big_cloud(cloud_type cl_type, kill_category whose, const coord_def& where,

Replacement in crawl-ref/source/spells1.h at line 43 [49.611815]

B:BD[45.63999] → [45.63999:64074]

void big_cloud(cloud_type cl_type, killer_type killer, int cl_x, int cl_y,

[45.63999]

[160.4142]

void big_cloud(cloud_type cl_type, killer_type killer, const coord_def& where,

Replacement in crawl-ref/source/spells1.h at line 46 [49.611815]

B:BD[45.64151] → [45.64151:64228]

∅:D[45.64228] → [49.613690:613929]

B:BD[49.613690] → [49.613690:613929]

B:BD[49.613929] → [172.6063:6154]

               int cl_x, int cl_y, int pow, int size, int spread_rate = -1);
// last updated 24may2000 {dlb}
/* ***********************************************************************
 * called from: acr (WIZARD only) - item_use - spell
 * *********************************************************************** */
int blink(int pow, bool high_level_controlled_blink,
          bool wizard_blink = false);

[45.64151]

[49.613947]

               const coord_def& where, int pow, int size, int spread_rate = -1);

Insertion in crawl-ref/source/spells1.h at line 48 [49.611815]
[49.613948]
[49.613948]
```
int blink(int pow, bool high_level_controlled_blink, bool wizard_blink = false);
```

Deletion in crawl-ref/source/spells1.h at line 50 [49.611815]

B:BD[49.613949] → [49.613949:614124]

/* ***********************************************************************
 * called from: spell
 * *********************************************************************** */

Deletion in crawl-ref/source/spells1.h at line 66 [49.611815]

B:BD[49.614566] → [49.614566:614794]


// last updated 24may2000 {dlb}
/* ***********************************************************************
 * called from: ability - spell - spells1
 * *********************************************************************** */

Deletion in crawl-ref/source/spells1.h at line 68 [49.611815]

B:BD[49.614821] → [49.614821:615039]


// last updated 24may2000 {dlb}
/* ***********************************************************************
 * called from: spell - spells1
 * *********************************************************************** */

Deletion in crawl-ref/source/spells1.h at line 78 [49.611815]

B:BD[49.615330] → [49.615330:615532]

// last updated sept 18
/* ***********************************************************************
 * called from: religion
 * *********************************************************************** */

Deletion in crawl-ref/source/spells1.h at line 79 [49.611815]

∅:D[237.1946] → [49.615554:615793]

B:BD[49.615554] → [49.615554:615793]


// last updated 24may2000 {dlb}
/* ***********************************************************************
 * called from: acr (WIZARD only) - item_use - spell
 * *********************************************************************** */

Deletion in crawl-ref/source/spells1.h at line 80 [49.611815]

∅:D[238.216] → [49.615819:616036]

B:BD[49.615819] → [49.615819:616036]


// last updated 24may2000 {dlb}
/* ***********************************************************************
 * called from: acr - spells1
 * *********************************************************************** */

Deletion in crawl-ref/source/spells1.h at line 81 [49.611815]

B:BD[49.616067] → [49.616067:616286]


// last updated 24may2000 {dlb}
/* ***********************************************************************
 * called from: ability - spell
 * *********************************************************************** */

Deletion in crawl-ref/source/spells1.h at line 82 [49.611815]

B:BD[49.616311] → [49.616311:616565]


// last updated 24may2000 {dlb}
/* ***********************************************************************
 * called from: ability - decks - fight - spell - spells - spells1
 * *********************************************************************** */

Replacement in crawl-ref/source/spells1.cc at line 109 [49.616635]

B:BD[49.618453] → [61.11608:11680]

            if (!beam.isValid || coord_def(beam.target()) == you.pos())

[49.618453]

[49.618484]

            if (!beam.isValid || beam.target == you.pos())

Replacement in crawl-ref/source/spells1.cc at line 123 [49.616635]
B:BD[172.6847] → [61.11681:11731]
```
            if (see_grid_no_trans(beam.target()))
```
[172.6847]
[49.618658]
```
            if (see_grid_no_trans(beam.target))
```

Replacement in crawl-ref/source/spells1.cc at line 125 [49.616635]

B:BD[49.618681] → [61.11732:11791]

            else if (trans_wall_blocking( beam.target() ))

[49.618681]

[172.6963]

            else if (trans_wall_blocking( beam.target ))

Replacement in crawl-ref/source/spells1.cc at line 143 [49.616635]

B:BD[239.300] → [240.171:237]

∅:D[240.237] → [172.7474:7522]

B:BD[172.7474] → [172.7474:7522]

        if (wizard_blink && grid_is_solid(grd[beam.tx][beam.ty]))
            grd[beam.tx][beam.ty] = DNGN_FLOOR;

[239.300]

[49.618809]

        if (wizard_blink && grid_is_solid(grd(beam.target)))
            grd(beam.target) = DNGN_FLOOR;

Replacement in crawl-ref/source/spells1.cc at line 146 [49.616635]

B:BD[49.618810] → [51.152980:153029]

∅:D[51.153029] → [49.618868:618922]

B:BD[49.618868] → [49.618868:618922]

        if (grid_is_solid(grd[beam.tx][beam.ty])
            || mgrd[beam.tx][beam.ty] != NON_MONSTER)

[49.618810]

[49.618922]

        if (grid_is_solid(grd(beam.target))
            || mgrd(beam.target) != NON_MONSTER)

Replacement in crawl-ref/source/spells1.cc at line 163 [49.616635]

B:BD[241.1071] → [61.11792:11859]

            move_player_to_grid(beam.target(), false, true, true);

[241.1071]

[49.619268]

            move_player_to_grid(beam.target, false, true, true);

Replacement in crawl-ref/source/spells1.cc at line 399 [49.616635]

B:BD[51.157583] → [61.13020:13156]

        beam.source_x = source.x;
        beam.source_y = source.y;
        beam.target_x = target.x;
        beam.target_y = target.y;

[51.157583]

[51.157695]

        beam.source = source;
        beam.target = target;

Replacement in crawl-ref/source/spells1.cc at line 506 [49.616635]
B:BD[49.623997] → [172.8022:8077]
```
        if (trans_wall_blocking(spelld.tx, spelld.ty))
```
[49.623997]
[172.8077]
```
        if (trans_wall_blocking(spelld.target))
```
Replacement in crawl-ref/source/spells1.cc at line 511 [49.616635]
B:BD[172.8177] → [172.8177:8227]
```
        else if (!see_grid(spelld.tx, spelld.ty))
```
[172.8177]
[49.624042]
```
        else if (!see_grid(spelld.target))
```
Replacement in crawl-ref/source/spells1.cc at line 517 [49.616635]
∅:D[242.369] → [243.196:258]
B:BD[243.196] → [243.196:258]
```
        if (spelld.tx == you.x_pos && spelld.ty == you.y_pos)
```
[242.369]
[243.258]
```
        if (spelld.target == you.pos())
```

Replacement in crawl-ref/source/spells1.cc at line 523 [49.616635]

B:BD[49.624131] → [244.322:381]

        const int cloud = env.cgrid[spelld.tx][spelld.ty];

[49.624131]

[244.381]

        const int cloud = env.cgrid(spelld.target);

Replacement in crawl-ref/source/spells1.cc at line 525 [49.616635]

B:BD[244.382] → [244.382:503]

        if (grid_is_solid(grd[ spelld.tx ][ spelld.ty ]) ||
            mgrd[ spelld.tx ][ spelld.ty ] != NON_MONSTER ||

[244.382]

[244.503]

        if (grid_is_solid(grd(spelld.target)) ||
            mgrd(spelld.target) != NON_MONSTER ||

Replacement in crawl-ref/source/spells1.cc at line 550 [49.616635]

B:BD[49.624554] → [61.13191:13254]

    place_cloud( CLOUD_FIRE, spelld.target(), durat, KC_YOU );

[49.624554]

[86.10641]

    place_cloud( CLOUD_FIRE, spelld.target, durat, KC_YOU );

Replacement in crawl-ref/source/spells1.cc at line 570 [49.616635]
B:BD[245.261] → [245.261:327]
```
    if (beem.target_x != you.x_pos || beem.target_y != you.y_pos)
```
[245.261]
[173.2890]
```
    if (beem.target != you.pos())
```

Replacement in crawl-ref/source/spells1.cc at line 573 [49.616635]

B:BD[245.352] → [245.352:432]

        beem.source_x      = you.x_pos;
        beem.source_y      = you.y_pos;

[245.352]

[245.432]

        beem.source        = you.pos();

Replacement in crawl-ref/source/spells1.cc at line 600 [49.616635]

B:BD[49.625613] → [163.4730:4825]

    big_cloud( cty, whose,
               beam.target_x, beam.target_y, pow, 8 + random2(3) );

[49.625613]

[51.158974]

    big_cloud( cty, whose, beam.target, pow, 8 + random2(3) );

Replacement in crawl-ref/source/spells1.cc at line 605 [49.616635]

B:BD[130.2306] → [45.64279:64350]

               int cl_x, int cl_y, int pow, int size, int spread_rate)

[130.2306]

[45.64350]

               const coord_def& where, int pow, int size, int spread_rate)

Replacement in crawl-ref/source/spells1.cc at line 608 [49.616635]

B:BD[45.64420] → [45.64420:64471]

              cl_x, cl_y, pow, size, spread_rate);

[45.64420]

[45.64471]

              where, pow, size, spread_rate);

Replacement in crawl-ref/source/spells1.cc at line 612 [49.616635]

∅:D[45.64529] → [160.4201:4272]

B:BD[130.2306] → [160.4201:4272]

               int cl_x, int cl_y, int pow, int size, int spread_rate)

[45.64529]

[49.626013]

               const coord_def& where, int pow, int size, int spread_rate)

Replacement in crawl-ref/source/spells1.cc at line 615 [49.616635]

B:BD[45.64600] → [45.64600:64651]

              cl_x, cl_y, pow, size, spread_rate);

[45.64600]

[45.64651]

              where, pow, size, spread_rate);

Replacement in crawl-ref/source/spells1.cc at line 619 [49.616635]

B:BD[45.64730] → [45.64730:64801]

               int cl_x, int cl_y, int pow, int size, int spread_rate)

[45.64730]

[45.64801]

               const coord_def& where, int pow, int size, int spread_rate)

Replacement in crawl-ref/source/spells1.cc at line 621 [49.616635]
∅:D[45.64803] → [163.4933:4998]
B:BD[49.626015] → [163.4933:4998]
```
    apply_area_cloud(make_a_normal_cloud, cl_x, cl_y, pow, size,
```
[45.64803]
[45.64804]
```
    apply_area_cloud(make_a_normal_cloud, where, pow, size,
```

Replacement in crawl-ref/source/spells1.cc at line 688 [49.616635]

B:BD[246.1643] → [27.171:247]

static int _healing_spell(int healed, int target_x = -1, int target_y = -1)

[246.1643]

[49.626181]

static int _healing_spell(int healed, const coord_def where = coord_def(0,0))

Replacement in crawl-ref/source/spells1.cc at line 695 [49.616635]
∅:D[247.201] → [248.333:375]
B:BD[248.333] → [248.333:375]
```
    if (target_x == -1 || target_y == -1)
```
[247.201]
[249.171]
```
    if (where.origin())
```

Replacement in crawl-ref/source/spells1.cc at line 704 [49.616635]

B:BD[246.1906] → [247.253:356]

        spd.tx = target_x;
        spd.ty = target_y;
        spd.isValid = in_bounds(spd.tx, spd.ty);

[246.1906]

[246.1988]

        spd.target = where;
        spd.isValid = in_bounds(spd.target);

Replacement in crawl-ref/source/spells1.cc at line 714 [49.616635]
B:BD[49.626515] → [247.380:432]
```
    if (spd.tx == you.x_pos && spd.ty == you.y_pos)
```
[49.626515]
[49.626555]
```
    if (spd.target == you.pos())
```
Replacement in crawl-ref/source/spells1.cc at line 721 [49.616635]
B:BD[49.626649] → [247.433:475]
```
    const int mgr = mgrd[spd.tx][spd.ty];
```
[49.626649]
[250.175]
```
    const int mgr = mgrd(spd.target);
```
Replacement in crawl-ref/source/spells1.cc at line 800 [49.616635]
B:BD[49.627757] → [26.171:225]
```
int cast_healing(int pow, int target_x, int target_y)
```
[49.627757]
[49.627786]
```
int cast_healing(int pow, const coord_def& where)
```

Replacement in crawl-ref/source/spells1.cc at line 804 [49.616635]

B:BD[49.627825] → [26.256:334]

    return (_healing_spell(pow + roll_dice(2, pow) - 2, target_x, target_y));

[49.627825]

[236.258]

    return (_healing_spell(pow + roll_dice(2, pow) - 2, where));

Replacement in crawl-ref/source/shopping.cc at line 159 [49.759950]
B:BD[251.1272] → [252.2478:2535]
```
    ShopInfo &si  = StashTrack.get_shop(shop.x, shop.y);
```
[251.1272]
[251.1325]
```
    ShopInfo &si  = StashTrack.get_shop(shop.pos);
```

Replacement in crawl-ref/source/shopping.cc at line 235 [49.759950]

B:BD[49.763421] → [61.13681:13756]

    const std::string hello = "Welcome to " + shop_name(shop.pos()) + "!";

[49.763421]

[253.361]

    const std::string hello = "Welcome to " + shop_name(shop.pos) + "!";

Replacement in crawl-ref/source/shopping.cc at line 243 [49.759950]
B:BD[251.2262] → [111.3229:3282]
```
        StashTrack.get_shop(shop.x, shop.y).reset();
```
[251.2262]
[84.2897]
```
        StashTrack.get_shop(shop.pos).reset();
```

Replacement in crawl-ref/source/shopping.cc at line 497 [49.759950]

B:BD[49.768557] → [61.13757:13871]

        move_item_to_grid( &item_got,
                           coord_def(env.shop[shop].x, env.shop[shop].y) );

[49.768557]

[254.7105]

        move_item_to_grid( &item_got, env.shop[shop].pos );

Replacement in crawl-ref/source/shopping.cc at line 1644 [49.759950]
B:BD[49.797633] → [49.797633:797703]
```
        if (env.shop[i].x == you.x_pos && env.shop[i].y == you.y_pos)
```
[49.797627]
[49.797703]
```
        if (env.shop[i].pos == you.pos())
```

Replacement in crawl-ref/source/shopping.cc at line 1657 [49.759950]

B:BD[253.921] → [61.13872:13945]

        mprf("%s appears to be closed.", shop_name(shop.pos()).c_str());

[253.921]

[253.998]

        mprf("%s appears to be closed.", shop_name(shop.pos).c_str());

Replacement in crawl-ref/source/shopping.cc at line 1675 [49.759950]
B:BD[49.798306] → [61.14033:14080]
```
        if (env.shop[shoppy].pos() == where &&
```
[49.798306]
[49.798374]
```
        if (env.shop[shoppy].pos == where &&
```

Replacement in crawl-ref/source/religion.cc at line 757 [49.804403]

B:BD[255.3029] → [255.3029:3091]

            && grd[you.x_pos][you.y_pos] == DNGN_DEEP_WATER);

[255.3029]

[256.2866]

            && grd(you.pos()) == DNGN_DEEP_WATER);

Replacement in crawl-ref/source/religion.cc at line 905 [49.804403]

B:BD[257.1138] → [257.1138:1203]

            && !grid_destroys_items( grd[you.x_pos][you.y_pos] )

[257.1138]

[257.1203]

            && !grid_destroys_items( grd(you.pos()) )

Replacement in crawl-ref/source/religion.cc at line 994 [49.804403]
B:BD[258.1169] → [43.2985:3041]
```
    if (grid_destroys_items(grd[you.x_pos][you.y_pos]))
```
[258.1169]
[259.230]
```
    if (grid_destroys_items(grd(you.pos())))
```

Replacement in crawl-ref/source/religion.cc at line 1754 [49.804403]

B:BD[51.175403] → [51.175403:175470]

                && !grid_destroys_items(grd[you.x_pos][you.y_pos])

[51.175403]

[51.175470]

                && !grid_destroys_items(grd(you.pos()))

Replacement in crawl-ref/source/religion.cc at line 1866 [49.804403]

B:BD[51.179573] → [51.179573:179647]

                    && !(grid_destroys_items(grd[you.x_pos][you.y_pos])))

[51.179573]

[49.817580]

                    && !(grid_destroys_items(grd(you.pos()))))

Replacement in crawl-ref/source/religion.cc at line 1922 [49.804403]

B:BD[260.337] → [261.189:279]

    if (Options.stash_tracking == STM_EXPLICIT
        && is_stash(you.x_pos, you.y_pos))

[260.337]

[261.279]

    if (Options.stash_tracking == STM_EXPLICIT && is_stash(you.pos()))

Replacement in crawl-ref/source/religion.cc at line 1996 [49.804403]

B:BD[262.429] → [263.147:221]

    const god_type altar_god = grid_altar_god(grd[you.x_pos][you.y_pos]);

[262.429]

[264.162]

    const god_type altar_god = grid_altar_god(grd(you.pos()));

Replacement in crawl-ref/source/religion.cc at line 2018 [49.804403]

B:BD[264.691] → [264.691:759]

            god_pitch( grid_altar_god(grd[you.x_pos][you.y_pos]) );

[264.691]

[264.759]

            god_pitch( grid_altar_god(grd(you.pos())) );

Replacement in crawl-ref/source/religion.cc at line 3404 [49.804403]

B:BD[24.2748] → [24.2748:2826]

        beam.target_x     = you.x_pos;
        beam.target_y     = you.y_pos;

[24.2748]

[24.2826]

        beam.target       = you.pos();

Replacement in crawl-ref/source/religion.cc at line 4537 [49.804403]

B:BD[265.2037] → [266.2785:3009]

        const int ystart = MAX(0,       you.y_pos - 9);
        const int yend   = MIN(GYM - 1, you.y_pos + 9);
        const int xstart = MAX(0,       you.x_pos - 9);
        const int xend   = MIN(GXM - 1, you.x_pos + 9);

[265.2037]

[267.4021]

        for ( radius_iterator ri(you.pos(), 9); ri; ++ri )
        {
            if ( mgrd(*ri) == NON_MONSTER )
                continue;

Replacement in crawl-ref/source/religion.cc at line 4542 [49.804403]

B:BD[267.4022] → [267.4022:4047]

B:BD[267.4047] → [268.2971:3016]

B:BD[268.3016] → [14.2663:2673]

∅:D[14.2673] → [268.3016:3065]

B:BD[268.3016] → [268.3016:3065]

        // monster check
        for (int y = ystart; y <= yend; ++y)
        {
            for (int x = xstart; x <= xend; ++x)

[267.4022]

[265.2195]

            monsters *monster = &menv[mgrd(*ri)];
            if (is_orcish_follower(monster))

Replacement in crawl-ref/source/religion.cc at line 4545 [49.804403]

B:BD[265.2209] → [269.2880:2942]

B:BD[269.2942] → [17.2695:2742]

                const unsigned short targ_monst = mgrd[x][y];
                if (targ_monst != NON_MONSTER)

[265.2209]

[265.2446]

                num_followers++;
                
                if (mons_player_visible(monster)
                    && !mons_is_sleeping(monster)
                    && !mons_is_confused(monster)
                    && !mons_cannot_act(monster))

Replacement in crawl-ref/source/religion.cc at line 4552 [49.804403]
B:BD[265.2464] → [269.2992:3051]
B:BD[269.3051] → [270.2706:2759]
∅:D[271.2571] → [265.2665:2687]
∅:D[270.2759] → [265.2665:2687]
∅:D[269.3245] → [265.2665:2687]
∅:D[272.3850] → [265.2665:2687]
∅:D[267.4507] → [265.2665:2687]
∅:D[203.5289] → [265.2665:2687]
B:BD[265.2665] → [265.2665:2687]
B:BD[265.2687] → [267.4508:4549]
```
                    monsters *monster = &menv[targ_monst];
                    if (is_orcish_follower(monster))
                    {
                        num_followers++;
```
[265.2464]
[273.411]
```
                    const int hd = monster->hit_dice;
```

Replacement in crawl-ref/source/religion.cc at line 4554 [49.804403]

B:BD[273.412] → [269.3246:3419]

B:BD[269.3419] → [268.3066:3124]

∅:D[274.2870] → [273.689:715]

∅:D[268.3124] → [273.689:715]

∅:D[269.3479] → [273.689:715]

∅:D[267.4781] → [273.689:715]

∅:D[203.5507] → [273.689:715]

B:BD[273.689] → [273.689:715]

B:BD[273.715] → [269.3480:3542]

∅:D[269.3542] → [267.4844:4845]

∅:D[203.5566] → [267.4844:4845]

B:BD[267.4844] → [267.4844:4845]

B:BD[267.4845] → [268.3125:3201]

∅:D[268.3201] → [267.4920:5240]

B:BD[267.4920] → [267.4920:5240]

                        if (mons_player_visible(monster)
                            && !mons_is_sleeping(monster)
                            && !mons_is_confused(monster)
                            && !mons_cannot_act(monster))
                        {
                            const int hd = monster->hit_dice;
                            // During penance followers get a saving throw.
                            if (random2((you.piety-you.penance[GOD_BEOGH])/18) +
                                random2(you.skills[SK_INVOCATIONS]-6)
                                  > random2(hd) + hd + random2(5))
                            {
                                continue;
                            }

[273.412]

[267.5240]

                    // During penance followers get a saving throw.
                    if (random2((you.piety-you.penance[GOD_BEOGH])/18) +
                        random2(you.skills[SK_INVOCATIONS]-6)
                        > random2(hd) + hd + random2(5))
                    {
                        continue;
                    }

Replacement in crawl-ref/source/religion.cc at line 4562 [49.804403]

B:BD[267.5241] → [269.3543:3604]

∅:D[275.3494] → [269.3604:3677]

B:BD[269.3604] → [269.3604:3677]

B:BD[269.3677] → [268.3202:3265]

                            monster->attitude = ATT_HOSTILE;
                            behaviour_event(monster, ME_ALERT, MHITYOU);
                            // For now CREATED_FRIENDLY stays.

[267.5241]

[273.778]

                    monster->attitude = ATT_HOSTILE;
                    behaviour_event(monster, ME_ALERT, MHITYOU);
                    // For now CREATED_FRIENDLY stays.

Replacement in crawl-ref/source/religion.cc at line 4566 [49.804403]

B:BD[273.779] → [269.3678:3743]

∅:D[269.3743] → [267.5492:5562]

∅:D[203.5755] → [267.5492:5562]

B:BD[267.5492] → [267.5492:5562]

                            if (player_monster_visible(monster))
                                num_reconvert++; // only visible ones

[273.779]

[276.16164]

                    if (player_monster_visible(monster))
                        num_reconvert++; // only visible ones

Replacement in crawl-ref/source/religion.cc at line 4569 [49.804403]
B:BD[276.16165] → [267.5563:5609]
∅:D[265.2754] → [276.16317:16343]
∅:D[267.5609] → [276.16317:16343]
B:BD[276.16317] → [276.16317:16343]
B:BD[276.16385] → [265.2755:2777]
```
                            reconvert = true;
                        }
                    }
```
[276.16165]
[265.2777]
```
                    reconvert = true;
```

Replacement in crawl-ref/source/religion.cc at line 4936 [49.804403]

B:BD[90.26413] → [277.4146:4217]

    learned_something_new(TUT_EXCOMMUNICATE, (int)new_god, old_piety);

[90.26413]

[28.2645]

    // Evil hack.
    learned_something_new(TUT_EXCOMMUNICATE,
                          coord_def((int)new_god, old_piety));

Replacement in crawl-ref/source/religion.cc at line 5246 [49.804403]
B:BD[278.2511] → [278.2511:2551]
```
    int i = igrd[you.x_pos][you.y_pos];
```
[278.2511]
[279.2944]
```
    int i = igrd(you.pos());
```
Replacement in crawl-ref/source/player.cc at line 329 [49.962854]
∅:D[61.18738] → [48.12846:12906]
B:BD[51.342455] → [48.12846:12906]
```
                set_envmap_obj(you.x_pos, you.y_pos, type);
```
[61.18738]
[51.342535]
```
                set_envmap_obj(you.pos(), type);
```
Deletion in crawl-ref/source/player.cc at line 5549 [49.962854]
B:BD[51.356156] → [158.9278:9316]
∅:D[158.9316] → [51.356156:356187]
B:BD[51.356156] → [51.356156:356187]
```
    prev_grd_targ = coord_def(0, 0);
    x_pos = 0;
    y_pos = 0;
```
Replacement in crawl-ref/source/player.cc at line 5550 [49.962854]
B:BD[51.356188] → [61.18860:18892]
```
    prev_move = coord_def(0,0);
```
[51.356188]
[280.2330]
```
    prev_grd_targ.reset();
    position.reset();
    prev_move.reset();
```
Replacement in crawl-ref/source/player.cc at line 5608 [49.962854]
B:BD[51.357719] → [51.357719:357765]
```
        inv[i].x = -1;
        inv[i].y = -1;
```
[51.357719]
[51.357765]
```
        inv[i].pos.set(-1, -1);
```
Deletion in crawl-ref/source/player.cc at line 5676 [49.962854]
B:BD[281.2556] → [281.2556:2627]
```
coord_def player::pos() const
{
    return coord_def(x_pos, y_pos);
}
```
Replacement in crawl-ref/source/player.cc at line 5684 [49.962854]
∅:D[138.3235] → [282.260:318]
B:BD[282.260] → [282.260:318]
```
            && grid_is_water(grd[you.x_pos][you.y_pos]));
```
[138.3235]
[281.2853]
```
            && grid_is_water(grd(you.pos())));
```
Deletion in crawl-ref/source/player.cc at line 6696 [49.962854]
B:BD[151.7430] → [151.7430:7466]
B:BD[151.7466] → [283.1922:1951]
∅:D[283.1951] → [284.149:151]
∅:D[151.7543] → [284.149:151]
B:BD[284.149] → [284.149:151]
B:BD[284.151] → [151.7544:7545]
```
void player::moveto(int x, int y)
{
    moveto(coord_def(x, y));
}
```
Replacement in crawl-ref/source/player.cc at line 6699 [49.962854]
∅:D[283.1991] → [151.7587:7621]
∅:D[285.3841] → [151.7587:7621]
B:BD[151.7587] → [151.7587:7621]
```
    x_pos = c.x;
    y_pos = c.y;
```
[285.3841]
[151.7621]
```
    position = c;
```
Replacement in crawl-ref/source/player.cc at line 6999 [49.962854]
B:BD[138.5002] → [138.5002:5036]
```
        switch(grd[x_pos][y_pos])
```
[138.5002]
[138.5036]
```
        switch (grd(you.pos()))
```

Replacement in crawl-ref/source/overmap.h at line 20 [49.1068481]

B:BD[49.1069220] → [67.4765:4840]

void seen_notable_thing( dungeon_feature_type which_thing, int x, int y );

[49.1069220]

[286.3040]

void seen_notable_thing(dungeon_feature_type which_thing, const coord_def& pos);

Replacement in crawl-ref/source/overmap.cc at line 62 [49.1070017]

B:BD[49.1071326] → [67.4842:4916]

void seen_notable_thing( dungeon_feature_type which_thing, int x, int y )

[49.1071326]

[51.358584]

void seen_notable_thing( dungeon_feature_type which_thing,
                         const coord_def& pos )

Replacement in crawl-ref/source/overmap.cc at line 66 [49.1070017]

B:BD[283.2409] → [283.2409:2485]

    dungeon_events.fire_position_event(DET_PLAYER_IN_LOS, coord_def(x, y));

[283.2409]

[140.6742]

    dungeon_events.fire_position_event(DET_PLAYER_IN_LOS, pos);

Deletion in crawl-ref/source/overmap.cc at line 72 [49.1070017]
∅:D[140.6745] → [110.138420:138451]
B:BD[287.7996] → [110.138420:138451]
```
    const coord_def pos(x, y);
```

Replacement in crawl-ref/source/overmap.cc at line 528 [49.1070017]

B:BD[288.4669] → [110.138452:138499]

B:BD[110.138499] → [132.6113:6167]

    const coord_def pos(you.x_pos, you.y_pos);
    const level_pos curpos(level_id::current(), pos);

[288.4669]

[288.4788]

    const level_pos curpos(level_id::current(), you.pos());

Replacement in crawl-ref/source/overmap.cc at line 615 [49.1070017]
B:BD[138.8459] → [138.8459:8504]
```
    if (is_stair(grd[you.x_pos][you.y_pos]))
```
[138.8459]
[138.8504]
```
    if (is_stair(grd(you.pos())))
```

Replacement in crawl-ref/source/output.cc at line 566 [49.1088282]

B:BD[289.7948] → [289.7948:8000]

                 "%2d,%2d", you.x_pos, you.y_pos );

[289.7948]

[289.8000]

                 "%2d,%2d", you.pos().x, you.pos().y );

Replacement in crawl-ref/source/newgame.cc at line 1289 [49.1132300]

B:BD[290.10391] → [291.181:243]

            you.inv[i].x = -1;
            you.inv[i].y = -1;

[290.10391]

            you.inv[i].pos.set(-1, -1);

Replacement in crawl-ref/source/mtransit.cc at line 207 [152.8445]
B:BD[292.6156] → [292.6156:6197]
```
        coord_def pos(item->x, item->y);
```
[292.6156]
[292.6197]
```
        coord_def pos = item->pos;
```
Replacement in crawl-ref/source/mtransit.cc at line 287 [152.8445]
B:BD[152.11340] → [152.11340:11381]
```
            m.target_x = m.target_y = 0;
```
[152.11340]
[293.908]
```
            m.target.reset();
```
Replacement in crawl-ref/source/mtransit.cc at line 318 [152.8445]
B:BD[152.11992] → [152.11992:12021]
```
            it.x = it.y = 0;
```
[152.11992]
[152.12021]
```
            it.pos.reset();
```
Replacement in crawl-ref/source/mstuff2.cc at line 59 [49.1340842]
B:BD[49.1342239] → [89.4746:4800]
```
    if (!is_trap_square(grd[monster->x][monster->y]))
```
[49.1342239]
[51.397045]
```
    if (!is_trap_square(grd(monster->pos())))
```
Replacement in crawl-ref/source/mstuff2.cc at line 65 [49.1340842]
B:BD[49.1342397] → [49.1342397:1342428]
B:BD[49.1342428] → [61.19806:19855]
```
    // new function call {dlb}
    int which_trap = trap_at_xy(monster->pos());
```
[49.1342397]
[294.2541]
```
    const int which_trap = trap_at_xy(monster->pos());
```
Insertion in crawl-ref/source/mstuff2.cc at line 68 [49.1340842]
[49.1342528]
[49.1342528]
```
    
    trap_struct& trap(env.trap[which_trap]);
```

Replacement in crawl-ref/source/mstuff2.cc at line 71 [49.1340842]

B:BD[49.1342529] → [49.1342529:1342607]

    bool trapKnown = (grd[monster->x][monster->y] != DNGN_UNDISCOVERED_TRAP);

[49.1342529]

[49.1342607]

    bool trapKnown = (grd(monster->pos()) != DNGN_UNDISCOVERED_TRAP);

Replacement in crawl-ref/source/mstuff2.cc at line 76 [49.1340842]
B:BD[49.1342841] → [49.1342841:1342863]
```
    struct bolt beem;
```
[49.1342841]
[49.1342863]
```
    bolt beem;
```

Replacement in crawl-ref/source/mstuff2.cc at line 83 [49.1340842]

B:BD[49.1343009] → [49.1343009:1343087]

        if (trap_category(env.trap[which_trap].type) == DNGN_TRAP_MECHANICAL)

[49.1343009]

[49.1343087]

        if (trap_category(trap.type) == DNGN_TRAP_MECHANICAL)

Replacement in crawl-ref/source/mstuff2.cc at line 96 [49.1340842]
B:BD[49.1343536] → [49.1343536:1343575]
```
    switch (env.trap[which_trap].type)
```
[49.1343529]
[49.1343575]
```
    switch (trap.type)
```

Replacement in crawl-ref/source/mstuff2.cc at line 268 [49.1340842]

B:BD[182.1971] → [182.1971:2021]

B:BD[182.2021] → [61.19992:20041]

        trap_item( OBJ_MISSILES, MI_THROWING_NET,
                   env.trap[which_trap].pos() );

[182.1962]

[294.2623]

        trap_item( OBJ_MISSILES, MI_THROWING_NET, trap.pos );

Replacement in crawl-ref/source/mstuff2.cc at line 273 [49.1340842]

B:BD[183.1182] → [61.20090:20144]

∅:D[61.20144] → [182.2164:2217]

B:BD[182.2164] → [182.2164:2217]

        grd(env.trap[which_trap].pos()) = DNGN_FLOOR;
        env.trap[which_trap].type = TRAP_UNASSIGNED;

[183.1182]

[182.2217]

        grd(trap.pos) = DNGN_FLOOR;
        trap.type = TRAP_UNASSIGNED;

Replacement in crawl-ref/source/mstuff2.cc at line 338 [49.1340842]

B:BD[138.9865] → [138.9865:10000]

            grd[env.trap[which_trap].x][env.trap[which_trap].y] = DNGN_FLOOR;
            env.trap[which_trap].type = TRAP_UNASSIGNED;

[138.9865]

[138.10000]

            grd(trap.pos) = DNGN_FLOOR;
            trap.type = TRAP_UNASSIGNED;

Replacement in crawl-ref/source/mstuff2.cc at line 406 [49.1340842]

B:BD[49.1350612] → [49.1350612:1350692]

            beem.target_x = monster->x;
            beem.target_y = monster->y;

[49.1350612]

[49.1350692]

            beem.target = monster->pos();

Replacement in crawl-ref/source/mstuff2.cc at line 414 [49.1340842]
B:BD[49.1350857] → [49.1350857:1350863]
B:BD[49.1350863] → [140.6952:7012]
∅:D[140.7012] → [295.1322:1387]
B:BD[295.1322] → [295.1322:1387]
∅:D[295.1387] → [49.1350943:1350949]
B:BD[49.1350943] → [49.1350943:1350949]
```
    {
        grd[env.trap[which_trap].x][env.trap[which_trap].y]
                     = trap_category(env.trap[which_trap].type);
    }
```
[49.1350857]
[49.1350949]
```
        grd(trap.pos) = trap_category(trap.type);
```

Replacement in crawl-ref/source/mstuff2.cc at line 897 [49.1340842]

B:BD[296.4921] → [296.4921:5065]

    if (!pbolt.target_x && !pbolt.target_y)
    {
        pbolt.target_x = monster->target_x;
        pbolt.target_y = monster->target_y;
    }

[296.4921]

[296.5065]

    if (pbolt.target.origin())
        pbolt.target = monster->target;

Replacement in crawl-ref/source/mstuff2.cc at line 969 [49.1340842]

B:BD[297.3067] → [297.3067:3145]

    pbolt.source_x       = monster->x;
    pbolt.source_y       = monster->y;

[297.3067]

[297.3145]

    pbolt.source         = monster->pos();

Replacement in crawl-ref/source/mstuff2.cc at line 986 [49.1340842]

B:BD[49.1362546] → [49.1362546:1362620]

        pbolt.target_x = monster->x;
        pbolt.target_y = monster->y;

[49.1362546]

[51.399823]

        pbolt.target = monster->pos();

Replacement in crawl-ref/source/mstuff2.cc at line 1041 [49.1340842]
B:BD[49.1363725] → [61.20518:20572]
```
    monster->x = newpos.x;
    monster->y = newpos.y;
```
[49.1363725]
[49.1363771]
```
    monster->moveto(newpos);
```

Replacement in crawl-ref/source/mstuff2.cc at line 1549 [49.1340842]

B:BD[298.537] → [61.20625:20703]

    if (really_returns && mons_thrown_object_destroyed(&item, pbolt.target(),

[298.537]

[61.20703]

    if (really_returns && mons_thrown_object_destroyed(&item, pbolt.target,

Replacement in crawl-ref/source/mstuff2.cc at line 1620 [49.1340842]

B:BD[299.5803] → [299.5803:5875]

    beam.target_x     = monster->x;
    beam.target_y     = monster->y;

[299.5803]

[299.5875]

    beam.target       = monster->pos();

Replacement in crawl-ref/source/monstuff.h at line 198 [49.1390580]
B:BD[49.1396618] → [211.4749:4807]
```
bool shift_monster(monsters *mon, int x = 0, int y = 0 );
```
[49.1396618]
[51.411124]
```
bool shift_monster(monsters *mon, coord_def p = coord_def(0,0) );
```
Replacement in crawl-ref/source/monstuff.cc at line 116 [49.1396662]
B:BD[300.8943] → [300.8943:9005]
```
    item.x         = mimic->x;
    item.y         = mimic->y;
```
[300.8943]
[300.9005]
```
    item.pos = mimic->pos();
```
Replacement in crawl-ref/source/monstuff.cc at line 119 [49.1396662]
B:BD[49.1399209] → [49.1399209:1399257]
```
    int prop = 127 * mimic->x + 269 * mimic->y;
```
[49.1399209]
[18.2569]
```
    int prop = 127 * mimic->pos().x + 269 * mimic->pos().y;
```

Replacement in crawl-ref/source/monstuff.cc at line 128 [49.1396662]

B:BD[49.1399355] → [49.1399355:1399426]

        item.sub_type = (59 * mimic->x + 79 * mimic->y) % NUM_WEAPONS;

[49.1399355]

[49.1399426]

        item.sub_type = (59*mimic->pos().x + 79*mimic->pos().y) % NUM_WEAPONS;

Replacement in crawl-ref/source/monstuff.cc at line 148 [49.1396662]

B:BD[49.1400087] → [49.1400087:1400158]

        item.sub_type = (59 * mimic->x + 79 * mimic->y) % NUM_ARMOURS;

[49.1400087]

[49.1400158]

        item.sub_type = (59*mimic->pos().x + 79*mimic->pos().y) % NUM_ARMOURS;

Replacement in crawl-ref/source/monstuff.cc at line 343 [49.1396662]
B:BD[49.1405390] → [301.2761:2819]
```
    if (grid_destroys_items(grd[monster->x][monster->y]))
```
[49.1405390]
[301.2819]
```
    if (grid_destroys_items(grd(monster->pos())))
```

Replacement in crawl-ref/source/monstuff.cc at line 1369 [49.1396662]

B:BD[49.1420025] → [49.1420025:1420150]

B:BD[49.1420150] → [302.751:819]

    int jex = 0, jey = 0;       // loop variables {dlb}
    bool foundSpot = false;     // to rid code of hideous goto {dlb}
    monsters *child = NULL;     // value determined with loop {dlb}

[49.1420025]

[49.1420225]

    monsters *child = NULL;

Insertion in crawl-ref/source/monstuff.cc at line 1373 [49.1396662]
[49.1420323]
[49.1420323]
```
    coord_def child_spot;
    int num_spots = 0;
```
Replacement in crawl-ref/source/monstuff.cc at line 1378 [49.1396662]
∅:D[154.3151] → [49.1420380:1420415]
B:BD[49.1420380] → [49.1420380:1420415]
```
    for (jex = -1; jex < 3; jex++)
```
[154.3151]
[49.1420415]
```
    for ( adjacent_iterator ai(parent->pos()); ai; ++ai )
```

Replacement in crawl-ref/source/monstuff.cc at line 1380 [49.1396662]

B:BD[49.1420421] → [154.3152:3221]

∅:D[154.3221] → [49.1420490:1420579]

B:BD[49.1420490] → [49.1420490:1420579]

        // Loop moves beyond those tiles contiguous to parent {dlb}:
        if (jex > 1)
            return (false);
        for (jey = -1; jey < 2; jey++)

[49.1420421]

[49.1420579]

        if (mgrd(*ai) == NON_MONSTER
            && parent->can_pass_through(*ai)
            && (*ai != you.pos()))

Replacement in crawl-ref/source/monstuff.cc at line 1384 [49.1396662]

B:BD[49.1420589] → [49.1420589:1420721]

B:BD[49.1420721] → [230.661:739]

∅:D[230.739] → [49.1420802:1420970]

∅:D[51.418250] → [49.1420802:1420970]

B:BD[49.1420802] → [49.1420802:1420970]

            // 10-50 for now - must take clouds into account:
            if (mgrd[parent->x + jex][parent->y + jey] == NON_MONSTER
                && parent->can_pass_through(parent->x + jex, parent->y + jey)
                && (parent->x + jex != you.x_pos || parent->y + jey != you.y_pos))
            {
                foundSpot = true;
                break;
            }

[49.1420589]

[49.1420970]

            if ( one_chance_in(++num_spots) )
                child_spot = *ai;

Insertion in crawl-ref/source/monstuff.cc at line 1387 [49.1396662]
[49.1420980]
[49.1420980]
```
    }
```
Replacement in crawl-ref/source/monstuff.cc at line 1389 [49.1396662]
B:BD[49.1420981] → [49.1420981:1421023]
B:BD[49.1421023] → [154.3222:3248]
```
        if (foundSpot)
            break;
    }   // end of for jex
```
[49.1420981]
[49.1421076]
```
    if ( num_spots == 0 )
        return (false);
```
Replacement in crawl-ref/source/monstuff.cc at line 1392 [49.1396662]
B:BD[49.1421077] → [49.1421077:1421156]
```
    int k = 0;                  // must remain outside loop that follows {dlb}
```
[49.1421077]
[49.1421156]
```
    int k = 0;
```
Replacement in crawl-ref/source/monstuff.cc at line 1420 [49.1396662]
∅:D[303.1295] → [49.1422189:1422253]
∅:D[304.7679] → [49.1422189:1422253]
B:BD[49.1422189] → [49.1422189:1422253]
```
    child->x = parent->x + jex;
    child->y = parent->y + jey;
```
[49.1422056]
[49.1422253]
```
    child->moveto(child_spot);
```

Replacement in crawl-ref/source/monstuff.cc at line 1458 [49.1396662]

B:BD[49.1423469] → [305.204:279]

    const dungeon_feature_type current_tile = grd[monster->x][monster->y];

[49.1423469]

[49.1423531]

    const dungeon_feature_type current_tile = grd(monster->pos());

Replacement in crawl-ref/source/monstuff.cc at line 1703 [49.1396662]

B:BD[49.1428933] → [61.22493:22601]

    // FIXME Shouldn't this use monsters::move_to_pos() ?
    monster->x = near.x;
    monster->y = near.y;

[49.1428933]

[61.22601]

    monster->moveto(near);

Replacement in crawl-ref/source/monstuff.cc at line 1854 [49.1396662]
B:BD[306.3430] → [306.3430:3478]
```
    mgrd[monster->x][monster->y] = NON_MONSTER;
```
[306.3430]
[306.3478]
```
    mgrd(monster->pos()) = NON_MONSTER;
```
Replacement in crawl-ref/source/monstuff.cc at line 1856 [49.1396662]
B:BD[306.3479] → [306.3479:3527]
```
    monster->x = loc.x;
    monster->y = loc.y;
```
[306.3479]
[306.3527]
```
    monster->moveto(loc);
```
Replacement in crawl-ref/source/monstuff.cc at line 1858 [49.1396662]
B:BD[306.3528] → [306.3528:3587]
```
    mgrd[monster->x][monster->y] = monster_index(monster);
```
[306.3528]
[306.3587]
```
    mgrd(monster->pos()) = monster_index(monster);
```
Replacement in crawl-ref/source/monstuff.cc at line 1864 [49.1396662]
B:BD[306.3681] → [306.3681:3718]
```
// the valid location is set in loc.
```
[306.3681]
[306.3718]
```
// the valid location is set in loc. (Otherwise loc becomes garbage.)
```
Replacement in crawl-ref/source/monstuff.cc at line 1867 [49.1396662]
∅:D[306.3771] → [49.1432185:1432239]
B:BD[49.1432185] → [49.1432185:1432239]
B:BD[49.1432239] → [307.550:602]
```
    int loc_x = you.x_pos;
    int loc_y = you.y_pos;
    const int mgrid = grd[monster->x][monster->y];
```
[306.3771]
[140.7853]
```
    loc = you.pos();
    const dungeon_feature_type mgrid = grd(monster->pos());
```

Replacement in crawl-ref/source/monstuff.cc at line 1876 [49.1396662]

B:BD[49.1432240] → [308.4853:4929]

    const bool mon_dest_okay = _habitat_okay( monster, grd[loc_x][loc_y] );

[49.1432240]

[309.1926]

    const bool mon_dest_okay = _habitat_okay( monster, grd(you.pos()) );

Deletion in crawl-ref/source/monstuff.cc at line 1890 [49.1396662]

B:BD[49.1432415] → [49.1432415:1432724]

        int temp_x, temp_y;
        for (int x = -1; x <= 1; x++)
        {
            temp_x = you.x_pos + x;
            if (temp_x < 0 || temp_x >= GXM)
                continue;
            for (int y = -1; y <= 1; y++)
            {
                if (x == 0 && y == 0)
                    continue;

Replacement in crawl-ref/source/monstuff.cc at line 1891 [49.1396662]

B:BD[49.1432725] → [49.1432725:1432844]

                temp_y = you.y_pos + y;
                if (temp_y < 0 || temp_y >= GYM)
                    continue;

[49.1432725]

[49.1432844]

        for ( adjacent_iterator ai; ai; ++ai )
            if (mgrd(*ai) == NON_MONSTER && _habitat_okay( monster, grd(*ai)))
                if (one_chance_in(++num_found))
                    loc = *ai;

Deletion in crawl-ref/source/monstuff.cc at line 1896 [49.1396662]

B:BD[49.1432845] → [49.1432845:1432901]

B:BD[49.1432901] → [308.4930:5000]

∅:D[308.5000] → [49.1432970:1433364]

B:BD[49.1432970] → [49.1432970:1433364]

                if (mgrd[temp_x][temp_y] == NON_MONSTER
                    && _habitat_okay( monster, grd[temp_x][temp_y] ))
                {
                    // Found an appropiate space... check if we
                    // switch the current choice to this one.
                    num_found++;
                    if (one_chance_in(num_found))
                    {
                        loc_x = temp_x;
                        loc_y = temp_y;
                    }
                }
            }
        }

Replacement in crawl-ref/source/monstuff.cc at line 1900 [49.1396662]
B:BD[49.1433419] → [49.1433419:1433439]
B:BD[49.1433439] → [306.3772:3818]
∅:D[306.3818] → [49.1433646:1433661]
B:BD[49.1433646] → [49.1433646:1433661]
```
    if (swap)
    {
        loc.x = loc_x;
        loc.y = loc_y;
    }
    else
```
[49.1433419]
[49.1433661]
```
    if (!swap)
```

Replacement in crawl-ref/source/monstuff.cc at line 2029 [49.1396662]

B:BD[154.3562] → [61.23827:23905]

            mon->target_x = src_pos.x;
            mon->target_y = src_pos.y;

[154.3562]

[49.1437423]

            mon->target = src_pos;

Replacement in crawl-ref/source/monstuff.cc at line 2142 [49.1396662]

B:BD[49.1439134] → [49.1439134:1439212]

            mon->target_x = you.x_pos;
            mon->target_y = you.y_pos;

[49.1439134]

[49.1439212]

            mon->target = you.pos();

Replacement in crawl-ref/source/monstuff.cc at line 2147 [49.1396662]

B:BD[49.1439306] → [49.1439306:1439388]

            mon->target_x = menv[src].x;
            mon->target_y = menv[src].y;

[49.1439306]

[49.1439388]

            mon->target = menv[src].pos();

Replacement in crawl-ref/source/monstuff.cc at line 2287 [49.1396662]
B:BD[310.5590] → [310.5590:5670]
∅:D[310.5670] → [154.4844:4854]
B:BD[154.4844] → [154.4844:4854]
```
        {
            mon->target_x = ri->x;
            mon->target_y = ri->y;
        }
```
[310.5590]
[310.5671]
```
            mon->target = *ri;
```

Replacement in crawl-ref/source/monstuff.cc at line 2519 [49.1396662]

B:BD[49.1440651] → [49.1440651:1440747]

        mon->target_x = 10 + random2(GXM - 10);
        mon->target_y = 10 + random2(GYM - 10);

[49.1440651]

[49.1440747]

        mon->target.set( 10 + random2(GXM - 10), 10 + random2(GYM - 10) );

Replacement in crawl-ref/source/monstuff.cc at line 2625 [49.1396662]
B:BD[49.1442565] → [49.1442565:1442627]
```
        int foe_x = you.x_pos;
        int foe_y = you.y_pos;
```
[49.1442565]
[49.1442627]
```
        coord_def foepos = you.pos();
```

Replacement in crawl-ref/source/monstuff.cc at line 2634 [49.1396662]

B:BD[49.1442817] → [311.3774:3848]

                foe_x   = you.x_pos;
                foe_y   = you.y_pos;

[49.1442817]

[312.4223]

                foepos = you.pos();

Replacement in crawl-ref/source/monstuff.cc at line 2644 [49.1396662]

B:BD[49.1443325] → [49.1443325:1443409]

                foe_x = menv[mon->foe].x;
                foe_y = menv[mon->foe].y;

[49.1443325]

[49.1443409]

                foepos = menv[mon->foe].pos();

Replacement in crawl-ref/source/monstuff.cc at line 2657 [49.1396662]

B:BD[49.1443733] → [49.1443733:1443805]

            mon->target_x = mon->x;
            mon->target_y = mon->y;

[49.1443733]

[49.1443805]

            mon->target = mon->pos();

Replacement in crawl-ref/source/monstuff.cc at line 2671 [49.1396662]

B:BD[49.1444137] → [49.1444137:1444231]

                    mon->target_x = you.x_pos;
                    mon->target_y = you.y_pos;

[49.1444137]

[49.1444231]

                    mon->target = you.pos();

Replacement in crawl-ref/source/monstuff.cc at line 2700 [49.1396662]

B:BD[313.3530] → [313.3530:3624]

                        mon->target_x = foe_x;
                        mon->target_y = foe_y;

[313.3530]

[313.3624]

                        mon->target = foepos;

Replacement in crawl-ref/source/monstuff.cc at line 2714 [49.1396662]

B:BD[49.1445000] → [314.7638:7714]

                    if (mon->x == mon->target_x && mon->y == mon->target_y)

[49.1445000]

[49.1445100]

                    if (mon->pos() == mon->target)

Replacement in crawl-ref/source/monstuff.cc at line 2719 [49.1396662]

∅:D[311.4352] → [49.1445263:1445441]

∅:D[315.9849] → [49.1445263:1445441]

B:BD[49.1445263] → [49.1445263:1445441]

                            {
                                mon->target_x = you.x_pos;
                                mon->target_y = you.y_pos;
                            }

[311.4352]

[49.1445441]

                                mon->target = you.pos();

Replacement in crawl-ref/source/monstuff.cc at line 2726 [49.1396662]

B:BD[49.1445672] → [49.1445672:1445864]

                            {
                                mon->target_x = menv[mon->foe].x;
                                mon->target_y = menv[mon->foe].y;
                            }

[49.1445672]

[49.1445864]

                                mon->target = menv[mon->foe].pos();

Replacement in crawl-ref/source/monstuff.cc at line 2853 [49.1396662]

B:BD[311.5701] → [311.5701:5833]

                            if (mon->x == mon->travel_path[0].x
                                && mon->y == mon->travel_path[0].y)

[311.5701]

[311.5833]

                            if (mon->pos() == mon->travel_path[0])

Replacement in crawl-ref/source/monstuff.cc at line 2861 [49.1396662]

B:BD[311.6135] → [311.6135:6285]

                                    mon->target_x = mon->travel_path[0].x;
                                    mon->target_y = mon->travel_path[0].y;

[311.6135]

[311.6285]

                                    mon->target = mon->travel_path[0];

Replacement in crawl-ref/source/monstuff.cc at line 2869 [49.1396662]

B:BD[311.6699] → [311.6699:6841]

                                mon->target_x = mon->travel_path[0].x;
                                mon->target_y = mon->travel_path[0].y;

[311.6699]

[311.6841]

                                mon->target = mon->travel_path[0];

Replacement in crawl-ref/source/monstuff.cc at line 2876 [49.1396662]

B:BD[311.7034] → [61.24914:25040]

                    const int dist = grid_distance(mon->pos(),
                                                   you.pos());

[311.7034]

[311.7175]

                    const int dist = grid_distance(mon->pos(), you.pos());

Replacement in crawl-ref/source/monstuff.cc at line 2932 [49.1396662]

∅:D[316.4925] → [311.9016:9162]

B:BD[311.9016] → [311.9016:9162]

                        if (mp.start_pathfind(mon, coord_def(you.x_pos,
                                                             you.y_pos)))

[316.4925]

[311.9162]

                        if (mp.start_pathfind(mon, you.pos()))

Replacement in crawl-ref/source/monstuff.cc at line 2938 [49.1396662]

∅:D[317.2849] → [311.9422:9564]

B:BD[311.9422] → [311.9422:9564]

                                mon->target_x = mon->travel_path[0].x;
                                mon->target_y = mon->travel_path[0].y;

[317.2849]

[311.9564]

                                mon->target = mon->travel_path[0];

Replacement in crawl-ref/source/monstuff.cc at line 2970 [49.1396662]

B:BD[49.1447406] → [49.1447406:1447526]

                    mon->target_x = 10 + random2(GXM - 10);
                    mon->target_y = 10 + random2(GYM - 10);

[49.1447406]

[49.1447526]

                    mon->target.set(10 + random2(GXM - 10),
                                    10 + random2(GYM - 10));

Replacement in crawl-ref/source/monstuff.cc at line 2977 [49.1396662]

B:BD[49.1447665] → [49.1447665:1447759]

                    mon->target_x = you.x_pos;
                    mon->target_y = you.y_pos;

[49.1447665]

[49.1447759]

                    mon->target = you.pos();

Replacement in crawl-ref/source/monstuff.cc at line 2983 [49.1396662]

∅:D[318.7037] → [49.1447822:1447922]

B:BD[49.1447822] → [49.1447822:1447922]

                mon->target_x = menv[mon->foe].x;
                mon->target_y = menv[mon->foe].y;

[318.7037]

[49.1447922]

                mon->target = menv[mon->foe].pos();

Replacement in crawl-ref/source/monstuff.cc at line 3018 [49.1396662]

B:BD[319.5249] → [319.5249:5371]

                        mon->target_x = e[e_index].target.x;
                        mon->target_y = e[e_index].target.y;

[319.5248]

[320.2701]

                        mon->target = e[e_index].target;

Replacement in crawl-ref/source/monstuff.cc at line 3025 [49.1396662]

B:BD[320.2831] → [321.2934:3062]

                        mon->target_x = 10 + random2(GXM - 10);
                        mon->target_y = 10 + random2(GYM - 10);

[320.2831]

[319.5481]

                        mon->target.set(10 + random2(GXM - 10),
                                        10 + random2(GYM - 10));

Replacement in crawl-ref/source/monstuff.cc at line 3032 [49.1396662]

B:BD[322.2698] → [30.2574:2608]

∅:D[30.2608] → [323.2816:2923]

B:BD[323.2816] → [323.2816:2923]

                if (e_index != -1
                    && mon->x == e[e_index].target.x
                    && mon->y == e[e_index].target.y)

[322.2698]

[323.2923]

                if (e_index != -1 && mon->pos() == e[e_index].target)

Replacement in crawl-ref/source/monstuff.cc at line 3067 [49.1396662]

B:BD[49.1448970] → [176.7288:7355]

            if (mon->x == mon->target_x && mon->y == mon->target_y

[49.1448970]

[313.3647]

            if (mon->pos() == mon->target

Replacement in crawl-ref/source/monstuff.cc at line 3080 [49.1396662]

B:BD[324.4554] → [324.4554:4670]

                    if (mon->x == mon->travel_path[0].x
                        && mon->y == mon->travel_path[0].y)

[324.4554]

[324.4670]

                    if (mon->pos() == mon->travel_path[0])

Replacement in crawl-ref/source/monstuff.cc at line 3099 [49.1396662]

B:BD[311.10744] → [311.10744:10878]

                            mon->target_x = mon->travel_path[0].x;
                            mon->target_y = mon->travel_path[0].y;

[311.10744]

[324.5060]

                            mon->target = mon->travel_path[0];

Replacement in crawl-ref/source/monstuff.cc at line 3102 [49.1396662]

B:BD[311.10939] → [311.10939:11003]

                                 mon->target_x, mon->target_y);

[311.10939]

[324.5198]

                                 mon->target.x, mon->target.y);

Replacement in crawl-ref/source/monstuff.cc at line 3129 [49.1396662]

B:BD[324.6516] → [324.6516:6658]

                                mon->target_x = mon->travel_path[i].x;
                                mon->target_y = mon->travel_path[i].y;

[324.6516]

[324.6658]

                                mon->target = mon->travel_path[i];

Replacement in crawl-ref/source/monstuff.cc at line 3163 [49.1396662]

B:BD[324.7781] → [324.7781:7931]

                                    mon->target_x = mon->travel_path[0].x;
                                    mon->target_y = mon->travel_path[0].y;

[324.7781]

[318.7362]

                                    mon->target = mon->travel_path[0];

Replacement in crawl-ref/source/monstuff.cc at line 3166 [49.1396662]

B:BD[325.2720] → [325.2720:2792]

                                         mon->target_x, mon->target_y);

[325.2720]

[318.7516]

                                         mon->target.x, mon->target.y);

Replacement in crawl-ref/source/monstuff.cc at line 3244 [49.1396662]

B:BD[324.8642] → [324.8642:8792]

                                    mon->target_x = mon->travel_path[0].x;
                                    mon->target_y = mon->travel_path[0].y;

[324.8642]

[311.12485]

                                    mon->target = mon->travel_path[0];

Replacement in crawl-ref/source/monstuff.cc at line 3251 [49.1396662]

∅:D[318.9062] → [311.12661:12807]

∅:D[94.36460] → [311.12661:12807]

B:BD[311.12661] → [311.12661:12807]

                                    mon->target_x = mon->patrol_point.x;
                                    mon->target_y = mon->patrol_point.y;

[94.36460]

[324.8792]

                                    mon->target = mon->patrol_point;

Replacement in crawl-ref/source/monstuff.cc at line 3257 [49.1396662]

B:BD[324.8971] → [311.12808:12878]

                                mon->patrol_point  = coord_def(0, 0);

[324.8971]

[311.12878]

                                mon->patrol_point.reset();

Replacement in crawl-ref/source/monstuff.cc at line 3276 [49.1396662]

B:BD[154.6558] → [326.2574:2694]

                    mon->target_x = 10 + random2(GXM - 10);
                    mon->target_y = 10 + random2(GYM - 10);

[154.6558]

[154.6678]

                    mon->target.set(10 + random2(GXM - 10),
                                    10 + random2(GYM - 10));

Replacement in crawl-ref/source/monstuff.cc at line 3325 [49.1396662]

∅:D[154.7156] → [327.320:406]

B:BD[327.320] → [327.320:406]

                mon->target_x = you.x_pos;
                mon->target_y = you.y_pos;

[154.7156]

[327.406]

                mon->target = you.pos();

Replacement in crawl-ref/source/monstuff.cc at line 3331 [49.1396662]
∅:D[328.2677] → [49.1450122:1450200]
∅:D[154.7217] → [49.1450122:1450200]
B:BD[49.1450122] → [49.1450122:1450200]
```
                mon->target_x = foe_x;
                mon->target_y = foe_y;
```
[328.2677]
[49.1450200]
```
                mon->target = foepos;
```

Replacement in crawl-ref/source/monstuff.cc at line 3356 [49.1396662]

B:BD[49.1450595] → [49.1450595:1450673]

                mon->target_x = foe_x;
                mon->target_y = foe_y;

[49.1450595]

[49.1450673]

                mon->target = foepos;

Replacement in crawl-ref/source/monstuff.cc at line 3410 [49.1396662]

B:BD[49.1451033] → [329.922:976]

    const int mx = mon->x;
    const int my = mon->y;

[49.1451033]

[330.1472]

    const int mx = mon->pos().x;
    const int my = mon->pos().y;

Deletion in crawl-ref/source/monstuff.cc at line 3456 [49.1396662]
∅:D[331.6035] → [332.3748:3777]
∅:D[333.6087] → [332.3748:3777]
B:BD[332.3748] → [332.3748:3777]
```
    int mons_count = weight;
```

Replacement in crawl-ref/source/monstuff.cc at line 3457 [49.1396662]

B:BD[332.3808] → [13.2568:2656]

∅:D[13.2656] → [332.4054:4055]

∅:D[266.3122] → [332.4054:4055]

∅:D[333.6152] → [332.4054:4055]

∅:D[209.12437] → [332.4054:4055]

B:BD[332.4054] → [332.4054:4055]

B:BD[332.4055] → [333.6153:6170]

    int ystart = 0;
    int xstart = 0;
    int yend = GXM - 1;
    int xend = GYM - 1;
    if (near_by)

[332.3808]

[333.6170]

    // A radius_iterator with radius == max(GXM,GYM) will sweep the whole
    // level.
    radius_iterator ri(you.pos(), near_by ? 9 : std::max(GXM,GYM),
                       true, in_sight);
    
    for ( ; ri; ++ri )

Replacement in crawl-ref/source/monstuff.cc at line 3464 [49.1396662]
B:BD[333.6176] → [266.3123:3307]
∅:D[334.3006] → [333.6461:6468]
∅:D[266.3307] → [333.6461:6468]
B:BD[333.6461] → [333.6461:6468]
B:BD[333.6468] → [266.3308:3330]
∅:D[266.3330] → [334.3007:3050]
B:BD[332.4076] → [334.3007:3050]
B:BD[334.3050] → [266.3331:3337]
∅:D[266.3337] → [334.3050:3097]
B:BD[334.3050] → [334.3050:3097]
```
        ystart = MAX(0,       you.y_pos - 9);
        xstart = MAX(0,       you.x_pos - 9);
          yend = MIN(GYM - 1, you.y_pos + 9);
          xend = MIN(GXM - 1, you.x_pos + 9);
    }
    // Monster check.
    for ( int y = ystart; y <= yend; ++y )
    {
        for ( int x = xstart; x <= xend; ++x )
```
[333.6176]
[266.3338]
```
        if ( mgrd(*ri) != NON_MONSTER )
```
Replacement in crawl-ref/source/monstuff.cc at line 3466 [49.1396662]
∅:D[334.3097] → [209.12438:12515]
∅:D[266.3348] → [209.12438:12515]
B:BD[332.4164] → [209.12438:12515]
```
            if ( mgrd[x][y] != NON_MONSTER && (!in_sight || see_grid(x,y)) )
```
[266.3348]
[332.4226]
```
            monsters *mon = &menv[mgrd(*ri)];
            if (suitable(mon))
```

Replacement in crawl-ref/source/monstuff.cc at line 3469 [49.1396662]

B:BD[332.4240] → [331.6036:6122]

∅:D[331.6122] → [335.4972:4990]

B:BD[335.4972] → [335.4972:4990]

B:BD[335.4990] → [331.6123:6460]

                monsters *mon = &menv[mgrd[x][y]];
                if (suitable(mon))
                {
                    // FIXME: if the intent is to favour monsters
                    // named by $DEITY, we should set a flag on the
                    // monster (something like MF_DEITY_PREFERRED) and
                    // use that instead of checking the name, given
                    // that other monsters can also have names.

[332.4240]

[176.7402]

                // FIXME: if the intent is to favour monsters
                // named by $DEITY, we should set a flag on the
                // monster (something like MF_DEITY_PREFERRED) and
                // use that instead of checking the name, given
                // that other monsters can also have names.

Replacement in crawl-ref/source/monstuff.cc at line 3475 [49.1396662]

B:BD[176.7403] → [176.7403:7706]

∅:D[176.7706] → [331.6460:6517]

B:BD[331.6460] → [331.6460:6517]

∅:D[331.6517] → [335.5100:5163]

∅:D[209.12591] → [335.5100:5163]

B:BD[335.5100] → [335.5100:5163]

B:BD[335.5163] → [336.3748:3812]

B:BD[336.3812] → [177.6535:6593]

∅:D[177.6593] → [331.6518:6560]

B:BD[335.5279] → [331.6518:6560]

∅:D[331.6560] → [335.5321:5401]

B:BD[335.5321] → [335.5321:5401]

B:BD[335.5401] → [331.6561:6599]

∅:D[331.6599] → [335.5439:5457]

B:BD[335.5439] → [335.5439:5457]

                    // True, but it's currently only used for orcs, and
                    // Blork and Urug also being preferred to non-named orcs
                    // is fine, I think. Once more gods name followers (and
                    // prefer them) that should be changed, of course. (jpeg)
                    if (prefer_named && mon->is_named())
                    {
                        mons_count += 2;
                        // Named monsters have doubled chances.
                        if (x_chance_in_y(2, mons_count))
                            chosen = mon;
                    }
                    else if (one_chance_in(++mons_count))
                        chosen = mon;
                }

[176.7403]

[332.4422]

                // True, but it's currently only used for orcs, and
                // Blork and Urug also being preferred to non-named orcs
                // is fine, I think. Once more gods name followers (and
                // prefer them) that should be changed, of course. (jpeg)
                // Named monsters have doubled chances.
                int mon_weight = ((prefer_named && mon->is_named()) ? 2 : 1);
                if ( x_chance_in_y(mon_weight, (weight += mon_weight)) )
                    chosen = mon;

Replacement in crawl-ref/source/monstuff.cc at line 3527 [49.1396662]
B:BD[336.4060] → [336.4060:4119]
```
    const dungeon_feature_type feat = grd[mon->x][mon->y];
```
[336.4060]
[336.4119]
```
    const dungeon_feature_type feat = grd(mon->pos());
```
Replacement in crawl-ref/source/monstuff.cc at line 3583 [49.1396662]
∅:D[302.1270] → [49.1465541:1465559]
∅:D[308.5693] → [49.1465541:1465559]
B:BD[49.1465541] → [49.1465541:1465559]
```
{
    int dx, dy;
```
[308.5693]
[336.5624]
```
{    
    coord_def delta;
```
Replacement in crawl-ref/source/monstuff.cc at line 3597 [49.1396662]
∅:D[61.26545] → [337.2574:2634]
B:BD[338.457] → [337.2574:2634]
```
             && monster->target_pos() == env.sanctuary_pos)
```
[61.26545]
[339.2935]
```
             && monster->target == env.sanctuary_pos)
```
Replacement in crawl-ref/source/monstuff.cc at line 3614 [49.1396662]
∅:D[314.8001] → [49.1465663:1465737]
B:BD[49.1465663] → [49.1465663:1465737]
```
        dx = you.x_pos - monster->x;
        dy = you.y_pos - monster->y;
```
[314.8001]
[49.1465737]
```
        delta = you.pos() - monster->pos();
```

Replacement in crawl-ref/source/monstuff.cc at line 3617 [49.1396662]

B:BD[49.1465752] → [49.1465752:1465854]

    {
        dx = monster->target_x - monster->x;
        dy = monster->target_y - monster->y;
    }

[49.1465752]

[49.1465854]

        delta = monster->target - monster->pos();

Replacement in crawl-ref/source/monstuff.cc at line 3620 [49.1396662]

B:BD[336.5689] → [61.26546:26644]

    mmov.x = (dx > 0) ? 1 : ((dx < 0) ? -1 : 0);
    mmov.y = (dy > 0) ? 1 : ((dy < 0) ? -1 : 0);

[336.5689]

[49.1465978]

    mmov.x = (delta.x > 0) ? 1 : ((delta.x < 0) ? -1 : 0);
    mmov.y = (delta.y > 0) ? 1 : ((delta.y < 0) ? -1 : 0);

Replacement in crawl-ref/source/monstuff.cc at line 3625 [49.1396662]
B:BD[119.13978] → [61.26645:26697]
```
            || monster->target_pos() != you.pos()))
```
[119.13978]
[49.1466019]
```
            || monster->target != you.pos()))
```
Replacement in crawl-ref/source/monstuff.cc at line 3627 [49.1396662]
B:BD[49.1466025] → [61.26698:26742]
```
        mmov.x *= -1;
        mmov.y *= -1;
```
[49.1466025]
[202.4785]
```
        mmov *= -1;
```

Replacement in crawl-ref/source/monstuff.cc at line 3640 [49.1396662]

B:BD[314.8199] → [61.26905:26982]

    if (monster->target_x + mmov.x < 0 || monster->target_x + mmov.x >= GXM)

[314.8199]

[61.26982]

    const coord_def s = monster->target + mmov;
    if (s.x < 0 || s.x >= GXM)

Replacement in crawl-ref/source/monstuff.cc at line 3643 [49.1396662]
∅:D[61.27002] → [49.1466251:1466252]
B:BD[49.1466251] → [49.1466251:1466252]
B:BD[49.1466252] → [61.27003:27080]
```
    if (monster->target_y + mmov.y < 0 || monster->target_y + mmov.y >= GYM)
```
[61.27002]
[61.27080]
```
    if (s.y < 0 || s.y >= GYM)
```
Replacement in crawl-ref/source/monstuff.cc at line 3647 [49.1396662]
B:BD[202.5207] → [61.27101:27133]
```
    if (mmov == coord_def(0,0))
```
[202.5207]
[49.1466422]
```
    if (mmov.origin())
```
Replacement in crawl-ref/source/monstuff.cc at line 3656 [49.1396662]
B:BD[49.1466764] → [340.2897:2938]
```
    if (grid_distance(dx, dy, 0, 0) > 3)
```
[49.1466764]
[49.1466807]
```
    if (delta.rdist() > 3)
```

Replacement in crawl-ref/source/monstuff.cc at line 3658 [49.1396662]

B:BD[49.1466813] → [49.1466813:1466854]

B:BD[49.1466854] → [339.3013:3075]

∅:D[339.3075] → [49.1466915:1466943]

B:BD[49.1466915] → [49.1466915:1466943]

B:BD[49.1466943] → [61.27134:27162]

∅:D[61.27162] → [49.1466971:1466981]

B:BD[49.1466971] → [49.1466971:1466981]

        if (abs(dx) > abs(dy))
        {
            // Sometimes we'll just move parallel the x axis.
            if (coinflip())
                mmov.y = 0;
        }

[49.1466813]

[49.1466981]

        // Sometimes we'll just move parallel the x axis.
        if (abs(delta.x) > abs(delta.y) && coinflip())
            mmov.y = 0;

Replacement in crawl-ref/source/monstuff.cc at line 3662 [49.1396662]

B:BD[49.1466982] → [49.1466982:1467023]

B:BD[49.1467023] → [339.3076:3138]

∅:D[339.3138] → [49.1467084:1467112]

B:BD[49.1467084] → [49.1467084:1467112]

B:BD[49.1467112] → [61.27163:27191]

∅:D[61.27191] → [49.1467140:1467150]

B:BD[49.1467140] → [49.1467140:1467150]

        if (abs(dy) > abs(dx))
        {
            // Sometimes we'll just move parallel the y axis.
            if (coinflip())
                mmov.x = 0;
        }

[49.1466982]

[49.1467150]

        // Sometimes we'll just move parallel the y axis.
        if (abs(delta.y) > abs(delta.x) && coinflip())
            mmov.x = 0;

Replacement in crawl-ref/source/monstuff.cc at line 3666 [49.1396662]
B:BD[49.1467156] → [49.1467156:1467213]
```
}                               // end handle_movement()
```
[49.1467156]
[49.1467213]
```
}
```

Replacement in crawl-ref/source/monstuff.cc at line 3728 [49.1396662]

B:BD[341.6833] → [342.6899:6966]

    if (monster_can_submerge(monster, grd[monster->x][monster->y])

[341.6833]

[343.5198]

    if (monster_can_submerge(monster, grd(monster->pos()))

Replacement in crawl-ref/source/monstuff.cc at line 3746 [49.1396662]

B:BD[344.3429] → [344.3429:3495]

            || env.cgrid[monster->x][monster->y] != EMPTY_CLOUD))

[344.3429]

[345.1264]

            || env.cgrid(monster->pos()) != EMPTY_CLOUD))

Replacement in crawl-ref/source/monstuff.cc at line 3881 [49.1396662]

∅:D[113.5953] → [346.162:258]

B:BD[49.1472150] → [346.162:258]

∅:D[346.258] → [49.1472240:1472241]

B:BD[49.1472240] → [49.1472240:1472241]

B:BD[49.1472332] → [49.1472332:1472420]

            int dx = sgn(targ->x - monster->x);
            int dy = sgn(targ->y - monster->y);
            const int tx = monster->x + dx;
            const int ty = monster->y + dy;

[113.5953]

[49.1472420]

            coord_def diff = targ->pos() - monster->pos();
            coord_def sg(sgn(diff.x), sgn(diff.y));
            coord_def t = monster->pos() + sg;

Replacement in crawl-ref/source/monstuff.cc at line 3885 [49.1396662]
B:BD[49.1472421] → [339.3139:3185]
```
            if (!inside_level_bounds(tx, ty))
```
[49.1472421]
[49.1472479]
```
            if (!inside_level_bounds(t))
```
Replacement in crawl-ref/source/monstuff.cc at line 3888 [49.1396662]
B:BD[49.1472506] → [51.422922:422967]
```
            if (!grid_is_solid(grd[tx][ty]))
```
[49.1472506]
[49.1472559]
```
            if (!grid_is_solid(grd(t)))
```

Replacement in crawl-ref/source/monstuff.cc at line 4433 [49.1396662]

∅:D[176.8675] → [347.204:309]

B:BD[49.1481817] → [347.204:309]

            if (monster->target_pos() == you.pos()
                && see_grid_no_trans(monster->pos()))

[176.8675]

[49.1481899]

            if (monster->target == you.pos()
                && see_grid_no_trans(monster->pos())
                && grid_distance( monster->pos(), you.pos()) == 2)

Replacement in crawl-ref/source/monstuff.cc at line 4437 [49.1396662]

B:BD[49.1481913] → [49.1481913:1482022]

B:BD[49.1482022] → [115.3206:3268]

∅:D[115.3268] → [49.1482088:1482138]

B:BD[49.1482088] → [49.1482088:1482138]

B:BD[49.1482138] → [348.2625:2694]

∅:D[348.2694] → [49.1482200:1482218]

B:BD[49.1482200] → [49.1482200:1482218]

                int dx = abs(monster->x - you.x_pos);
                int dy = abs(monster->y - you.y_pos);
                if (dx == 2 && dy <= 2 || dy == 2 && dx <= 2)
                {
                    ret = true;
                    monster_attack( monster_index(monster), false );
                }

[49.1481913]

[49.1482218]

                ret = true;
                monster_attack( monster_index(monster), false );

Replacement in crawl-ref/source/monstuff.cc at line 4443 [49.1396662]

B:BD[49.1482294] → [115.3269:3361]

B:BD[115.3361] → [310.7517:7575]

            int foe_x = menv[monster->foe].x;
            int foe_y = menv[monster->foe].y;
            coord_def foe_pos = menv[monster->foe].pos();

[49.1482294]

[154.7365]

            coord_def foepos = menv[monster->foe].pos();

Replacement in crawl-ref/source/monstuff.cc at line 4445 [49.1396662]

∅:D[154.7423] → [115.3362:3435]

B:BD[49.1482352] → [115.3362:3435]

B:BD[115.3435] → [310.7576:7633]

            if (monster->target_x == foe_x && monster->target_y == foe_y
                && monster->mon_see_grid(foe_pos, true))

[154.7423]

[49.1482472]

            if (monster->target == foepos
                && monster->mon_see_grid(foepos, true)
                && grid_distance(monster->pos(), foepos) == 2)

Replacement in crawl-ref/source/monstuff.cc at line 4449 [49.1396662]

B:BD[49.1482486] → [115.3498:3661]

∅:D[115.3661] → [49.1482682:1482732]

B:BD[49.1482682] → [49.1482682:1482732]

B:BD[49.1482732] → [348.2695:2776]

∅:D[348.2776] → [49.1482808:1482826]

B:BD[49.1482808] → [49.1482808:1482826]

                int dx = abs(monster->x - foe_x);
                int dy = abs(monster->y - foe_y);
                if (dx == 2 && dy <= 2 || dy == 2 && dx <= 2)
                {
                    ret = true;
                    monsters_fight(monster_index(monster), monster->foe, false);
                }

[49.1482486]

[49.1482826]

                ret = true;
                monsters_fight(monster_index(monster), monster->foe, false);

Replacement in crawl-ref/source/monstuff.cc at line 4588 [49.1396662]
B:BD[349.9053] → [349.9053:9125]
```
    beem.source_x     = monster->x;
    beem.source_y     = monster->y;
```
[349.9053]
[349.9125]
```
    beem.source       = monster->pos();
```

Replacement in crawl-ref/source/monstuff.cc at line 4636 [49.1396662]

B:BD[49.1487407] → [349.10610:10691]

            beem.target_x = monster->x;
            beem.target_y = monster->y;

[49.1487407]

[349.10691]

            beem.target = monster->pos();

Replacement in crawl-ref/source/monstuff.cc at line 4645 [49.1396662]
B:BD[349.10853] → [349.10853:10933]
∅:D[349.10933] → [49.1487633:1487634]
B:BD[49.1487633] → [49.1487633:1487634]
```
            beem.target_x = monster->x;
            beem.target_y = monster->y;
```
[349.10853]
[349.10934]
```
            beem.target = monster->pos();
```
Replacement in crawl-ref/source/monstuff.cc at line 4656 [49.1396662]
B:BD[349.11199] → [349.11199:11279]
∅:D[349.11279] → [49.1487887:1487888]
B:BD[49.1487887] → [49.1487887:1487888]
```
            beem.target_x = monster->x;
            beem.target_y = monster->y;
```
[349.11199]
[349.11280]
```
            beem.target = monster->pos();
```

Replacement in crawl-ref/source/monstuff.cc at line 4669 [49.1396662]

B:BD[49.1488096] → [49.1488096:1488185]

                beem.target_x = monster->x;
                beem.target_y = monster->y;

[49.1488096]

[49.1488185]

                beem.target = monster->pos();

Replacement in crawl-ref/source/monstuff.cc at line 5200 [49.1396662]

∅:D[350.3081] → [140.9097:9160]

B:BD[49.1496836] → [140.9097:9160]

∅:D[140.9160] → [49.1496900:1497014]

B:BD[49.1496900] → [49.1496900:1497014]

                            && (monster->target_x != you.x_pos
                                || monster->target_y != you.y_pos
                                || coinflip()))

[350.3081]

[49.1497014]

                            && (monster->target != you.pos() || coinflip()))

Replacement in crawl-ref/source/monstuff.cc at line 5394 [49.1396662]
B:BD[351.1907] → [61.28285:28345]
```
    if (!archer && adjacent(beem.target(), monster->pos()))
```
[351.1907]
[49.1505304]
```
    if (!archer && adjacent(beem.target, monster->pos()))
```

Replacement in crawl-ref/source/monstuff.cc at line 5419 [49.1396662]

B:BD[352.839] → [299.22784:23032]

        && ( beem.target_x == you.x_pos && beem.target_y == you.y_pos
                && you.caught()
             || mgrd[beem.target_x][beem.target_y] != NON_MONSTER
                && mons_is_caught(&menv[mgrd[beem.target_x][beem.target_y]]) ))

[352.839]

[352.938]

        && ( beem.target == you.pos() && you.caught()
             || mgrd(beem.target) != NON_MONSTER
             && mons_is_caught(&menv[mgrd(beem.target)])))

Replacement in crawl-ref/source/monstuff.cc at line 5586 [49.1396662]

B:BD[353.3332] → [353.3332:3442]

    if (!mover->can_pass_through(moved->x, moved->y)
        || !moved->can_pass_through(mover->x, mover->y))

[353.3332]

[353.3442]

    if (!mover->can_pass_through(moved->pos())
        || !moved->can_pass_through(mover->pos()))

Replacement in crawl-ref/source/monstuff.cc at line 5592 [49.1396662]

B:BD[353.3477] → [353.3477:3609]

    if (!monster_habitable_grid(mover, grd[moved->x][moved->y])
        || !monster_habitable_grid(moved, grd[mover->x][mover->y]))

[353.3477]

[353.3609]

    if (!monster_habitable_grid(mover, grd(moved->pos()))
        || !monster_habitable_grid(moved, grd(mover->pos())))

Replacement in crawl-ref/source/monstuff.cc at line 5602 [49.1396662]
B:BD[353.3770] → [353.3770:3826]
```
    mover->x = moved_pos.x;
    mover->y = moved_pos.y;
```
[353.3770]
[354.2799]
```
    mover->pos() = moved_pos;
```
Replacement in crawl-ref/source/monstuff.cc at line 5604 [49.1396662]
∅:D[354.2800] → [353.3829:3885]
B:BD[353.3829] → [353.3829:3885]
```
    moved->x = mover_pos.x;
    moved->y = mover_pos.y;
```
[354.2800]
[353.3885]
```
    moved->pos() = mover_pos;
```

Replacement in crawl-ref/source/monstuff.cc at line 5620 [49.1396662]

B:BD[303.3080] → [355.585:644]

    const dungeon_feature_type feat = grd[mon->x][mon->y];

[303.3080]

[314.8335]

    const dungeon_feature_type feat = grd(mon->pos());

Replacement in crawl-ref/source/monstuff.cc at line 5658 [49.1396662]

B:BD[314.8550] → [314.8550:8610]

        && env.cgrid[monster->x][monster->y] != EMPTY_CLOUD

[314.8550]

[314.8610]

        && env.cgrid(monster->pos()) != EMPTY_CLOUD

Replacement in crawl-ref/source/monstuff.cc at line 5743 [49.1396662]

B:BD[49.1507806] → [51.430742:430804]

        if (env.cgrid[monster->x][monster->y] != EMPTY_CLOUD)

[49.1507806]

[51.430804]

        if (env.cgrid(monster->pos()) != EMPTY_CLOUD)

Replacement in crawl-ref/source/monstuff.cc at line 5784 [49.1396662]

∅:D[113.7551] → [342.7099:7170]

B:BD[51.431292] → [342.7099:7170]

∅:D[342.7170] → [51.431369:431434]

B:BD[51.431369] → [51.431369:431434]

        if (monster_can_submerge(monster, grd[monster->x][monster->y])
            && env.cgrid[monster->x][monster->y] != EMPTY_CLOUD)

[113.7551]

[51.431434]

        if (monster_can_submerge(monster, grd(monster->pos()))
            && env.cgrid(monster->pos()) != EMPTY_CLOUD)

Replacement in crawl-ref/source/monstuff.cc at line 5802 [49.1396662]
B:BD[49.1510133] → [51.432765:432818]
```
        if (igrd[monster->x][monster->y] != NON_ITEM
```
[49.1510133]
[356.3178]
```
        if (igrd(monster->pos()) != NON_ITEM
```

Replacement in crawl-ref/source/monstuff.cc at line 5825 [49.1396662]

B:BD[357.3602] → [357.3602:3723]

                && abs(monster->target_x - monster->x) <= 1
                && abs(monster->target_y - monster->y) <= 1)

[357.3602]

[357.3723]

                && grid_distance(monster->target, monster->pos()) <= 1)

Replacement in crawl-ref/source/monstuff.cc at line 5890 [49.1396662]

B:BD[154.8461] → [61.28590:28665]

                if (monster->x + mmov.x < 0 || monster->x + mmov.x >= GXM)

[154.8461]

[61.28665]

                const coord_def s = monster->pos() + mmov;
                if (s.x < 0 || s.x >= GXM)

Replacement in crawl-ref/source/monstuff.cc at line 5894 [49.1396662]

B:BD[49.1511069] → [61.28698:28773]

                if (monster->y + mmov.y < 0 || monster->y + mmov.y >= GYM)

[49.1511069]

[61.28773]

                if (s.y < 0 || s.y >= GYM)

Replacement in crawl-ref/source/monstuff.cc at line 5903 [49.1396662]

B:BD[61.29023] → [61.29023:29076]

                    && (mmov.x != 0 || mmov.y != 0))

[61.29023]

[154.9123]

                    && !mmov.origin())

Replacement in crawl-ref/source/monstuff.cc at line 5930 [49.1396662]

B:BD[49.1512200] → [51.434367:434453]

        beem.target_x = monster->target_x;
        beem.target_y = monster->target_y;

[49.1512200]

[49.1512500]

        beem.target = monster->target;

Replacement in crawl-ref/source/monstuff.cc at line 6008 [49.1396662]

B:BD[182.7151] → [182.7151:7287]

                        monster->target_x = 10 + random2(GXM - 10);
                        monster->target_y = 10 + random2(GYM - 10);

[182.7151]

[182.7287]

                        monster->target.set(10 + random2(GXM - 10),
                                            10 + random2(GYM - 10));

Replacement in crawl-ref/source/monstuff.cc at line 6035 [49.1396662]

B:BD[182.7979] → [182.7979:8115]

                        monster->target_x = 10 + random2(GXM - 10);
                        monster->target_y = 10 + random2(GYM - 10);

[182.7979]

[182.8115]

                        monster->target.set(10 + random2(GXM - 10),
                                            10 + random2(GYM - 10));

Replacement in crawl-ref/source/monstuff.cc at line 6047 [49.1396662]
∅:D[314.9890] → [182.8456:8520]
B:BD[182.8456] → [182.8456:8520]
```
                    mgrd[monster->x][monster->y] = NON_MONSTER;
```
[314.9890]
[49.1516337]
```
                    mgrd(monster->pos()) = NON_MONSTER;
```
Replacement in crawl-ref/source/monstuff.cc at line 6089 [49.1396662]
∅:D[314.10007] → [358.2409:2465]
B:BD[358.2409] → [358.2409:2465]
```
            mgrd[monster->x][monster->y] = NON_MONSTER;
```
[314.10007]
[140.9515]
```
            mgrd(monster->pos()) = NON_MONSTER;
```
Replacement in crawl-ref/source/monstuff.cc at line 6120 [49.1396662]
B:BD[49.1518736] → [314.10008:10060]
```
        const int mx = monster->x, my = monster->y;
```
[49.1518736]
[314.10060]
```
        const coord_def oldpos = monster->pos();
```

Replacement in crawl-ref/source/monstuff.cc at line 6124 [49.1396662]

B:BD[51.439242] → [140.9553:9591]

∅:D[140.9591] → [359.2541:2606]

B:BD[51.439281] → [359.2541:2606]

        if (!invalid_monster(monster)
            && (monster->x != mx || monster->y != my))
        {

[51.439242]

[51.439340]

        if (!invalid_monster(monster) && (monster->pos() != oldpos))

Deletion in crawl-ref/source/monstuff.cc at line 6126 [49.1396662]
B:BD[51.439380] → [359.2607:2617]
```
        }
```
Replacement in crawl-ref/source/monstuff.cc at line 6203 [49.1396662]
B:BD[49.1520155] → [140.9694:9744]
```
        for (item = igrd[monster->x][monster->y];
```
[49.1520155]
[49.1520206]
```
        for (item = igrd(monster->pos());
```
Replacement in crawl-ref/source/monstuff.cc at line 6218 [49.1396662]
∅:D[360.976] → [49.1521074:1521148]
∅:D[140.9746] → [49.1521074:1521148]
B:BD[49.1521074] → [49.1521074:1521148]
```
            if (mitm[igrd[monster->x][monster->y]].base_type != OBJ_GOLD)
```
[140.9746]
[49.1521148]
```
            if (mitm[igrd(monster->pos())].base_type != OBJ_GOLD)
```
Replacement in crawl-ref/source/monstuff.cc at line 6293 [49.1396662]
∅:D[361.2886] → [362.4039:4105]
∅:D[140.9750] → [362.4039:4105]
B:BD[362.4039] → [362.4039:4105]
```
    for (item = igrd[monster->x][monster->y]; item != NON_ITEM; )
```
[361.2886]
[49.1523076]
```
    for (item = igrd(monster->pos()); item != NON_ITEM; )
```

Replacement in crawl-ref/source/monstuff.cc at line 6388 [49.1396662]

B:BD[363.2869] → [364.1865:1927]

                 m2->name(DESC_PLAIN).c_str(), m2->x, m2->y);

[363.2869]

[51.442370]

                 m2->name(DESC_PLAIN).c_str(), m2->pos().x, m2->pos().y);

Replacement in crawl-ref/source/monstuff.cc at line 6405 [49.1396662]
B:BD[303.6921] → [61.29850:29886]
```
    mon->x = n.x;
    mon->y = n.y;
```
[303.6921]
[61.29886]
```
    mon->moveto(n);
```
Replacement in crawl-ref/source/monstuff.cc at line 6407 [49.1396662]
∅:D[61.29920] → [51.443115:443116]
B:BD[51.443115] → [51.443115:443116]
B:BD[51.443116] → [61.29921:29957]
```
    m2->x  = c.x;
    m2->y  = c.y;
```
[61.29920]
[51.443378]
```
    m2->moveto(c);
```
Replacement in crawl-ref/source/monstuff.cc at line 6452 [49.1396662]
B:BD[365.2720] → [61.30405:30449]
```
    monster->x = f.x;
    monster->y = f.y;
```
[365.2720]
[365.2721]
```
    monster->pos() = f;
```

Replacement in crawl-ref/source/monstuff.cc at line 6597 [49.1396662]

B:BD[366.2971] → [61.30809:30905]

            const int x = where.x - monster->x;
            const int y = where.y - monster->y;

[366.2971]

[365.2727]

            const int x = where.x - monster->pos().x;
            const int y = where.y - monster->pos().y;

Replacement in crawl-ref/source/monstuff.cc at line 6693 [49.1396662]

B:BD[367.4631] → [90.26815:26886]

            learned_something_new(TUT_SEEN_SECRET_DOOR, pos.x, pos.y);

[367.4631]

            learned_something_new(TUT_SEEN_SECRET_DOOR, pos);

Replacement in crawl-ref/source/monstuff.cc at line 6961 [49.1396662]

B:BD[357.5008] → [357.5008:5079]

        if (monster_can_submerge(monster, grd[monster->x][monster->y])

[357.5008]

[357.5079]

        if (monster_can_submerge(monster, grd(monster->pos()))

Replacement in crawl-ref/source/monstuff.cc at line 7012 [49.1396662]
B:BD[61.32659] → [61.32659:32695]
```
    if (mmov.x == 0 && mmov.y == 0)
```
[61.32659]
[312.7333]
```
    if (mmov.origin())
```

Replacement in crawl-ref/source/monstuff.cc at line 7018 [49.1396662]

B:BD[49.1530502] → [368.9280:9396]

∅:D[368.9521] → [49.1536825:1536826]

B:BD[49.1536825] → [49.1536825:1536826]

B:BD[49.1536826] → [369.6856:6922]

∅:D[369.6922] → [368.9588:9845]

B:BD[368.9588] → [368.9588:9845]

             const int targ_x = monster->x + count_x - 1;
             const int targ_y = monster->y + count_y - 1;
             // Bounds check - don't consider moving out of grid!
             if (targ_x < 0 || targ_x >= GXM || targ_y < 0 || targ_y >= GYM)
             {
                 good_move[count_x][count_y] = false;
                 continue;
             }
             dungeon_feature_type target_grid = grd[targ_x][targ_y];

[49.1530502]

[49.1536953]

            const int targ_x = monster->pos().x + count_x - 1;
            const int targ_y = monster->pos().y + count_y - 1;
            
            // Bounds check - don't consider moving out of grid!
            if (targ_x < 0 || targ_x >= GXM || targ_y < 0 || targ_y >= GYM)
            {
                good_move[count_x][count_y] = false;
                continue;
            }
            dungeon_feature_type target_grid = grd[targ_x][targ_y];

Replacement in crawl-ref/source/monstuff.cc at line 7029 [49.1396662]

B:BD[49.1536954] → [368.9846:9941]

∅:D[368.9941] → [49.1537048:1537049]

B:BD[49.1537048] → [49.1537048:1537049]

B:BD[49.1537049] → [368.9942:10061]

B:BD[368.10061] → [61.32696:32774]

             if (target_grid == DNGN_DEEP_WATER)
                 deep_water_available = true;
             const monsters* mons = dynamic_cast<const monsters*>(monster);
             good_move[count_x][count_y] =
                 _mon_can_move_to_pos(mons, coord_def(count_x-1, count_y-1));

[49.1536954]

[369.6923]

            if (target_grid == DNGN_DEEP_WATER)
                deep_water_available = true;
            
            const monsters* mons = dynamic_cast<const monsters*>(monster);
            good_move[count_x][count_y] =
                _mon_can_move_to_pos(mons, coord_def(count_x-1, count_y-1));

Replacement in crawl-ref/source/monstuff.cc at line 7100 [49.1396662]

B:BD[49.1540512] → [49.1540512:1540591]

                    && grd[monster->x + count_x - 1][monster->y + count_y - 1]

[49.1540512]

[49.1540591]

                    && grd[monster->pos().x + count_x - 1][monster->pos().y + count_y - 1]

Replacement in crawl-ref/source/monstuff.cc at line 7120 [49.1396662]

B:BD[49.1541221] → [61.33240:33370]

        int current_distance = grid_distance(monster->pos(),
                                             monster->target_pos());

[49.1541221]

[49.1541424]

        int current_distance = grid_distance(monster->pos(), monster->target);

Replacement in crawl-ref/source/monstuff.cc at line 7161 [49.1396662]

B:BD[49.1542324] → [340.3289:3568]

                    dist[i] = grid_distance(monster->x + compass_x[newdir],
                                            monster->y + compass_y[newdir],
                                            monster->target_x,
                                            monster->target_y);

[49.1542324]

[49.1542609]

                    dist[i] = grid_distance(monster->pos().x + compass_x[newdir],
                                            monster->pos().y + compass_y[newdir],
                                            monster->target.x,
                                            monster->target.y);

Replacement in crawl-ref/source/monstuff.cc at line 7346 [49.1396662]
B:BD[49.1547745] → [49.1547745:1547817]
```
        if (pbolt.target_x == you.x_pos && pbolt.target_y == you.y_pos)
```
[49.1547745]
[49.1547817]
```
        if (pbolt.target == you.pos())
```
Replacement in crawl-ref/source/monstuff.cc at line 7361 [49.1396662]
B:BD[49.1548145] → [49.1548145:1548193]
```
    int wc = env.cgrid[monster->x][monster->y];
```
[49.1548145]
[49.1548193]
```
    int wc = env.cgrid(monster->pos());
```
Replacement in crawl-ref/source/monstuff.cc at line 7723 [49.1396662]
B:BD[51.447892] → [22.2569:2632]
```
// Moves a monster to approximately (x, y) and returns true if
```
[51.447892]
[22.2632]
```
// Moves a monster to approximately p and returns true if
```
Replacement in crawl-ref/source/monstuff.cc at line 7727 [49.1396662]
B:BD[51.448046] → [302.3081:3131]
```
bool shift_monster( monsters *mon, int x, int y )
```
[51.448046]
[51.448103]
```
bool shift_monster( monsters *mon, coord_def p )
```
Replacement in crawl-ref/source/monstuff.cc at line 7729 [49.1396662]
B:BD[51.448105] → [51.448105:448134]
```
    bool found_move = false;
```
[51.448105]
[51.448134]
```
    coord_def result;
```
Deletion in crawl-ref/source/monstuff.cc at line 7731 [49.1396662]
B:BD[51.448135] → [51.448135:448190]
```
    int i, j;
    int tx, ty;
    int nx = 0, ny = 0;
```

Replacement in crawl-ref/source/monstuff.cc at line 7733 [49.1396662]

B:BD[51.448210] → [51.448210:448236]

    if (x == 0 && y == 0)

[51.448210]

[51.448236]

    if (p.origin())
        p = mon->pos();
    for ( adjacent_iterator ai(p); ai; ++ai )

Replacement in crawl-ref/source/monstuff.cc at line 7738 [49.1396662]

B:BD[51.448242] → [369.7649:7714]

∅:D[369.7714] → [51.448306:448433]

B:BD[51.448306] → [51.448306:448433]

        // Try and find a random floor space some distance away.
        for (i = 0; i < 50; i++)
        {
            tx = 5 + random2( GXM - 10 );
            ty = 5 + random2( GYM - 10 );

[51.448242]

[51.448433]

        // Don't drop on anything but vanilla floor right now.
        if (grd(*ai) != DNGN_FLOOR)
            continue;

Replacement in crawl-ref/source/monstuff.cc at line 7742 [49.1396662]

B:BD[51.448434] → [51.448434:448575]

            int dist = grid_distance(x, y, tx, ty);
            if (grd[tx][ty] == DNGN_FLOOR && dist > 10)
                break;
        }

[51.448434]

[51.448575]

        if (mgrd(*ai) != NON_MONSTER)
            continue;

Replacement in crawl-ref/source/monstuff.cc at line 7745 [49.1396662]

B:BD[51.448576] → [51.448576:448625]

        if (i == 50)
            return (false);

[51.448576]

[51.448625]

        if (*ai == you.pos())
            continue;
        if (one_chance_in(++count))
            result = *ai;

Replacement in crawl-ref/source/monstuff.cc at line 7752 [49.1396662]

B:BD[51.448632] → [51.448632:448662]

B:BD[51.448668] → [51.448668:448761]

B:BD[51.448761] → [339.4876:4922]

∅:D[305.447] → [51.448827:448854]

∅:D[339.4922] → [51.448827:448854]

B:BD[51.448827] → [51.448827:448854]

B:BD[51.448854] → [369.7715:7782]

∅:D[370.2693] → [51.448920:449141]

∅:D[369.7782] → [51.448920:449141]

B:BD[51.448920] → [51.448920:449141]

B:BD[51.449141] → [305.448:488]

∅:D[305.488] → [51.449200:449323]

B:BD[51.449200] → [51.449200:449323]

B:BD[51.449329] → [51.449329:449350]

    for (i = -1; i <= 1; i++)
        for (j = -1; j <= 1; j++)
        {
            tx = x + i;
            ty = y + j;
            if (!inside_level_bounds(tx, ty))
                continue;
            // Don't drop on anything but vanilla floor right now.
            if (grd[tx][ty] != DNGN_FLOOR)
                continue;
            if (mgrd[tx][ty] != NON_MONSTER)
                continue;
            if (tx == you.x_pos && ty == you.y_pos)
                continue;
            if (one_chance_in(++count))
            {
                nx = tx;
                ny = ty;
                found_move = true;
            }
        }
    if (found_move)

[51.448632]

[51.449350]

    if (count > 0)

Replacement in crawl-ref/source/monstuff.cc at line 7754 [49.1396662]

B:BD[51.449356] → [51.449356:449528]

        const int mon_index = mgrd[mon->x][mon->y];
        mgrd[mon->x][mon->y] = NON_MONSTER;
        mgrd[nx][ny] = mon_index;
        mon->x = nx;
        mon->y = ny;

[51.449356]

[51.449528]

        const int mon_index = mgrd(mon->pos());
        mgrd(mon->pos()) = NON_MONSTER;
        mgrd(result) = mon_index;
        mon->moveto(result);

Replacement in crawl-ref/source/monstuff.cc at line 7760 [49.1396662]
B:BD[51.449535] → [51.449535:449560]
```
    return (found_move);
```
[51.449535]
[51.449560]
```
    return (count > 0);
```

Replacement in crawl-ref/source/monplace.h at line 276 [49.1638277]

B:BD[49.1640286] → [49.1640286:1640513]

B:BD[49.1640513] → [305.492:599]

∅:D[305.599] → [49.1640580:1640652]

∅:D[51.450206] → [49.1640580:1640652]

B:BD[49.1640580] → [49.1640580:1640652]

// last updated 12may2000 {dlb}
/* ***********************************************************************
 * called from: misc - monplace - spells3
 * *********************************************************************** */
bool empty_surrounds( int emx, int emy, dungeon_feature_type spc_wanted,
                      int radius,
                      bool allow_centre, FixedVector<char, 2>& empty );

[49.1640286]

[49.1640652]

bool empty_surrounds( const coord_def& where, dungeon_feature_type spc_wanted,
                      int radius, bool allow_centre, coord_def& empty );

Replacement in crawl-ref/source/monplace.cc at line 689 [49.1641732]

B:BD[371.26656] → [371.26656:26805]

                if (grid_distance( you.x_pos, you.y_pos,
                                   mg.pos.x, mg.pos.y ) < 2 + random2(3))
                {

[371.26656]

[371.26805]

                if (grid_distance( you.pos(), mg.pos ) < 2 + random2(3))

Deletion in crawl-ref/source/monplace.cc at line 691 [49.1641732]
B:BD[371.26841] → [371.26841:26859]
```
                }
```

Replacement in crawl-ref/source/monplace.cc at line 695 [49.1641732]

B:BD[371.26962] → [372.7105:7242]

                close_to_player = (distance(you.x_pos, you.y_pos,
                                            mg.pos.x, mg.pos.y) < 64);

[371.26962]

[373.4040]

                close_to_player = (distance(you.pos(), mg.pos) < 64);

Replacement in crawl-ref/source/monplace.cc at line 752 [49.1641732]
B:BD[324.9751] → [324.9751:9806]
```
        mon->patrol_point = coord_def(mon->x, mon->y);
```
[324.9751]
[324.9806]
```
        mon->patrol_point = mon->pos();
```

Replacement in crawl-ref/source/monplace.cc at line 755 [49.1641732]

B:BD[324.9886] → [324.9886:9947]

             mon->name(DESC_PLAIN).c_str(), mon->x, mon->y);

[324.9886]

[324.9947]

             mon->name(DESC_PLAIN).c_str(), mon->pos().x, mon->pos().y);

Replacement in crawl-ref/source/monplace.cc at line 872 [49.1641732]
B:BD[49.1654318] → [371.29814:29864]
```
    menv[id].x = fpos.x;
    menv[id].y = fpos.y;
```
[49.1654318]
[49.1654360]
```
    menv[id].moveto(fpos);
```
Replacement in crawl-ref/source/monplace.cc at line 2046 [49.1641732]
B:BD[49.1675013] → [49.1675013:1675048]
```
    FixedVector < char, 2 > empty;
```
[49.1674993]
[110.138520]
```
    coord_def empty;
```
Deletion in crawl-ref/source/monplace.cc at line 2049 [49.1641732]
B:BD[49.1675191] → [49.1675191:1675228]
```
    empty[0] = 0;
    empty[1] = 0;
```
Replacement in crawl-ref/source/monplace.cc at line 2057 [49.1641732]
∅:D[374.7572] → [371.40586:40645]
B:BD[375.2803] → [371.40586:40645]
∅:D[371.40645] → [51.459607:459671]
B:BD[51.459607] → [51.459607:459671]
```
    if (empty_surrounds( p.x, p.y, spcw, 2, true, empty ))
    {
        pos.x = empty[0];
        pos.y = empty[1];
    }
```
[374.7572]
[376.2546]
```
    if (empty_surrounds( p, spcw, 2, true, empty ))
        pos = empty;
```

Replacement in crawl-ref/source/monplace.cc at line 2166 [49.1641732]

B:BD[49.1677106] → [305.1633:1705]

B:BD[305.1705] → [375.2804:2856]

∅:D[375.2856] → [51.460725:460778]

B:BD[51.460725] → [51.460725:460778]

bool empty_surrounds(int emx, int emy, dungeon_feature_type spc_wanted,
                     int radius, bool allow_centre,
                     FixedVector < char, 2 > &empty)

[49.1677106]

[49.1677243]

bool empty_surrounds(const coord_def& where, dungeon_feature_type spc_wanted,
                     int radius, bool allow_centre, coord_def& empty)

Deletion in crawl-ref/source/monplace.cc at line 2169 [49.1641732]
B:BD[49.1677245] → [49.1677245:1677263]
B:BD[49.1677263] → [374.8182:8183]
```
    bool success;
```
Replacement in crawl-ref/source/monplace.cc at line 2170 [49.1641732]
∅:D[377.5344] → [49.1677325:1677389]
B:BD[49.1677325] → [49.1677325:1677389]
```
    bool playerSummon = (emx == you.x_pos && emy == you.y_pos);
```
[377.5344]
[49.1677389]
```
    bool playerSummon = (where == you.pos());
```

Deletion in crawl-ref/source/monplace.cc at line 2173 [49.1641732]

B:BD[49.1677482] → [49.1677482:1677509]

B:BD[49.1677509] → [51.460779:460837]

B:BD[49.1677647] → [51.460838:460900]

∅:D[51.460900] → [49.1677704:1677833]

B:BD[49.1677704] → [49.1677704:1677833]

    int count_x, count_y;
    for (count_x = -radius; count_x <= radius; count_x++)
        for (count_y = -radius; count_y <= radius; count_y++)
        {
            success = false;
            if (!allow_centre && count_x == 0 && count_y == 0)
                continue;

Replacement in crawl-ref/source/monplace.cc at line 2174 [49.1641732]

B:BD[49.1677834] → [49.1677834:1677906]

            int tx = emx + count_x;
            int ty = emy + count_y;

[49.1677834]

[49.1677906]

    for ( radius_iterator ri(where, radius, true, false, !allow_centre);
          ri; ++ri)
    {
        bool success = false;

Replacement in crawl-ref/source/monplace.cc at line 2179 [49.1641732]

B:BD[49.1677907] → [49.1677907:1677985]

            if (tx == you.x_pos && ty == you.y_pos)
                continue;

[49.1677907]

[49.1677985]

        if ( *ri == you.pos() )
            continue;
        
        if (mgrd(*ri) != NON_MONSTER)
            continue;

Replacement in crawl-ref/source/monplace.cc at line 2185 [49.1641732]

B:BD[49.1677986] → [378.2751:2786]

∅:D[378.2786] → [379.245:271]

B:BD[379.245] → [379.245:271]

            if (!in_bounds(tx,ty))
                continue;

[49.1677986]

[379.271]

        // Players won't summon out of LOS, or past transparent walls.
        if (!see_grid_no_trans(*ri) && playerSummon)
            continue;

Replacement in crawl-ref/source/monplace.cc at line 2189 [49.1641732]

∅:D[379.272] → [49.1677986:1678058]

B:BD[49.1677986] → [49.1677986:1678058]

B:BD[49.1678058] → [372.9482:9557]

∅:D[372.9557] → [172.11619:11679]

B:BD[172.11619] → [172.11619:11679]

∅:D[172.11679] → [49.1678156:1678259]

B:BD[49.1678156] → [49.1678156:1678259]

B:BD[49.1678259] → [51.460901:460959]

∅:D[51.460959] → [49.1678411:1678443]

B:BD[49.1678411] → [49.1678411:1678443]

            if (mgrd[tx][ty] != NON_MONSTER)
                continue;
            // Players won't summon out of LOS, or past transparent walls.
            if (!see_grid_no_trans(tx, ty) && playerSummon)
                continue;
            if (grd[tx][ty] == spc_wanted)
                success = true;
            if (grid_compatible(spc_wanted, grd[tx][ty]))
                success = true;

[379.272]

[49.1678443]

        success =
            (grd(*ri) == spc_wanted) || grid_compatible(spc_wanted, grd(*ri));
        
        if (success && one_chance_in(++good_count))
            empty = *ri;
    }

Deletion in crawl-ref/source/monplace.cc at line 2196 [49.1641732]
B:BD[49.1678444] → [51.460960:461016]
∅:D[51.461016] → [49.1678664:1678678]
B:BD[49.1678664] → [49.1678664:1678678]
∅:D[377.5398] → [51.461017:461079]
B:BD[49.1678730] → [51.461017:461079]
∅:D[51.461079] → [49.1678839:1678853]
B:BD[49.1678839] → [49.1678839:1678853]
B:BD[49.1678853] → [377.5399:5409]
∅:D[377.5409] → [49.1679098:1679099]
B:BD[49.1679098] → [49.1679098:1679099]
```
            if (success && one_chance_in(++good_count))
            {
                empty[0] = tx;
                empty[1] = ty;
            }
        }
```
Replacement in crawl-ref/source/monplace.cc at line 2377 [49.1641732]
B:BD[143.4602] → [143.4602:4642]
```
    target = coord_def(mon->x, mon->y);
```
[143.4602]
[143.4642]
```
    target = mon->pos();
```

Replacement in crawl-ref/source/mon-util.cc at line 2305 [49.1699344]

B:BD[380.2676] → [61.35403:35467]

    if (is_sanctuary(you.pos()) || is_sanctuary(beam.source()))

[380.2676]

[49.1735287]

    if (is_sanctuary(you.pos()) || is_sanctuary(beam.source))

Replacement in crawl-ref/source/mon-util.cc at line 2450 [49.1699344]

B:BD[381.8415] → [61.35686:35763]

        if (spell_harms_target(monspell) && is_sanctuary(mon->target_pos()))

[381.8415]

[381.8525]

        if (spell_harms_target(monspell) && is_sanctuary(mon->target))

Replacement in crawl-ref/source/mon-util.cc at line 2862 [49.1699344]

B:BD[155.5367] → [155.5367:5429]

B:BD[155.5429] → [311.13821:13900]

      ac(0), ev(0), speed(0), speed_increment(0), x(0), y(0),
      target_x(0), target_y(0), patrol_point(0, 0), travel_target(MTRAV_NONE),

[155.5367]

[324.11123]

      ac(0), ev(0), speed(0), speed_increment(0),
      target(0,0), patrol_point(0, 0), travel_target(MTRAV_NONE),

Replacement in crawl-ref/source/mon-util.cc at line 2911 [49.1699344]

B:BD[331.8092] → [331.8092:8151]

    if (in_bounds(x, y))
        mgrd[x][y] = NON_MONSTER;

[331.8092]

[331.8151]

    if (in_bounds(pos()))
        mgrd(pos()) = NON_MONSTER;

Replacement in crawl-ref/source/mon-util.cc at line 2914 [49.1699344]
B:BD[331.8152] → [331.8152:8167]
B:BD[331.8167] → [311.13901:13938]
```
    x = y = 0;
    patrol_point  = coord_def(0, 0);
```
[331.8152]
[311.13938]
```
    position.reset();
    patrol_point.reset();
```

Replacement in crawl-ref/source/mon-util.cc at line 2933 [49.1699344]

B:BD[155.6164] → [155.6164:6302]

    x                 = mon.x;
    y                 = mon.y;
    target_x          = mon.target_x;
    target_y          = mon.target_y;

[155.6164]

[154.11652]

    position          = mon.position;
    target            = mon.target;

Deletion in crawl-ref/source/mon-util.cc at line 2955 [49.1699344]
∅:D[3.169] → [155.6786:6789]
B:BD[155.6786] → [155.6786:6789]
∅:D[155.6789] → [281.7900:7965]
B:BD[281.7900] → [281.7900:7965]
B:BD[281.7965] → [305.1836:1919]
```
}
coord_def monsters::pos() const
{
    return coord_def(x, y);
}
coord_def monsters::target_pos() const
{
    return coord_def(target_x, target_y);
```
Replacement in crawl-ref/source/mon-util.cc at line 2959 [49.1699344]
B:BD[281.7999] → [67.5144:5193]
```
    const dungeon_feature_type grid = grd[x][y];
```
[281.7999]
[342.13627]
```
    const dungeon_feature_type grid = grd(pos());
```
Replacement in crawl-ref/source/mon-util.cc at line 2970 [49.1699344]
B:BD[281.8150] → [67.5194:5243]
```
    const dungeon_feature_type grid = grd[x][y];
```
[281.8150]
[281.8182]
```
    const dungeon_feature_type grid = grd(pos());
```
Insertion in crawl-ref/source/mon-util.cc at line 4579 [49.1699344]
[281.10049]
[281.10049]
```
void monsters::moveto( const coord_def& c )
{
    position = c;
}
```
Replacement in crawl-ref/source/mon-util.cc at line 4709 [49.1699344]
B:BD[382.3401] → [382.3401:3433]
```
    return (inside_halo(x, y));
```
[382.3401]
[182.13006]
```
    return (inside_halo(pos()));
```
Replacement in crawl-ref/source/mon-util.cc at line 5067 [49.1699344]
B:BD[383.1382] → [383.1382:1424]
```
        x = place.x;
        y = place.y;
```
[383.1382]
[383.1424]
```
        moveto(place);
```

Replacement in crawl-ref/source/mon-util.cc at line 5087 [49.1699344]

B:BD[155.7933] → [152.13393:13469]

        x = random_range(6, GXM - 7);
        y = random_range(6, GYM - 7);

[155.7933]

[155.8005]

        position.set(random_range(6, GXM - 7), random_range(6, GYM - 7));

Replacement in crawl-ref/source/mon-util.cc at line 5089 [49.1699344]

B:BD[155.8011] → [57.32575:32641]

    while ((grd[x][y] != DNGN_FLOOR || mgrd[x][y] != NON_MONSTER)

[155.8011]

[152.13547]

    while ((grd(pos()) != DNGN_FLOOR || mgrd(pos()) != NON_MONSTER)

Replacement in crawl-ref/source/mon-util.cc at line 5100 [49.1699344]
B:BD[152.13747] → [152.13747:13789]
```
        mgrd[x][y] = monster_index(this);
```
[152.13747]
[152.13789]
```
        mgrd(pos()) = monster_index(this);
```
Replacement in crawl-ref/source/mon-util.cc at line 5329 [49.1699344]
B:BD[327.660] → [154.12024:12086]
```
        target_x  = you.x_pos;
        target_y  = you.y_pos;
```
[327.660]
[154.12086]
```
        target    = you.pos();
```
Replacement in crawl-ref/source/mon-util.cc at line 5336 [49.1699344]
B:BD[369.8462] → [369.8462:8506]
```
            patrol_point = coord_def(0, 0);
```
[369.8462]
[369.8506]
```
            patrol_point.reset();
```
Replacement in crawl-ref/source/mon-util.cc at line 5358 [49.1699344]
B:BD[384.4233] → [384.4233:4267]
```
    coord_def pos, target_square;
```
[384.4233]
[384.4267]
```
    coord_def target_square;
```

Deletion in crawl-ref/source/mon-util.cc at line 5360 [49.1699344]

B:BD[384.4299] → [384.4299:4300]

B:BD[384.4300] → [20.2725:2859]

∅:D[20.2859] → [384.4434:4504]

B:BD[384.4434] → [384.4434:4504]


    for (pos.x = you.x_pos - 1; pos.x <= you.x_pos + 1; ++pos.x)
        for (pos.y = you.y_pos - 1; pos.y <= you.y_pos + 1; ++pos.y)
        {
            if (pos == you.pos())
                continue;

Replacement in crawl-ref/source/mon-util.cc at line 5361 [49.1699344]

B:BD[384.4505] → [384.4505:4564]

B:BD[384.4564] → [385.2575:2631]

∅:D[385.2631] → [384.4621:4751]

B:BD[384.4621] → [384.4621:4751]

            if (in_bounds(pos) && mgrd(pos) == NON_MONSTER
                && monster_can_submerge(mon, grd(pos)))
            {
                if (one_chance_in(++okay_squares))
                    target_square = pos;
            }
        }

[384.4505]

[384.4751]

    for ( adjacent_iterator ai; ai; ++ai )
        if (mgrd(*ai) == NON_MONSTER && monster_can_submerge(mon, grd(*ai)))
            if (one_chance_in(++okay_squares))
                target_square = *ai;

Replacement in crawl-ref/source/mon-util.cc at line 5372 [49.1699344]

B:BD[384.4900] → [20.2860:2928]

        mon->x = target_square.x;
        mon->y = target_square.y;

[384.4900]

[384.4970]

        mon->moveto(target_square);

Replacement in crawl-ref/source/mon-util.cc at line 5384 [49.1699344]

B:BD[384.5350] → [20.3030:3164]

    for (pos.x = you.x_pos - 1; pos.x <= you.x_pos + 1; ++pos.x)
        for (pos.y = you.y_pos - 1; pos.y <= you.y_pos + 1; ++pos.y)

[384.5350]

[384.5484]

    for ( adjacent_iterator ai; ai; ++ai )
    {
        if (mgrd(*ai) == NON_MONSTER
            && monster_habitable_grid(mon, grd(*ai))
            && trap_type_at_xy(*ai) == NUM_TRAPS)

Replacement in crawl-ref/source/mon-util.cc at line 5390 [49.1699344]

B:BD[384.5494] → [384.5494:5614]

B:BD[384.5614] → [385.2710:2767]

B:BD[385.2767] → [61.35876:35930]

∅:D[61.35930] → [384.5735:5855]

B:BD[384.5735] → [384.5735:5855]

            if (pos == you.pos())
                continue;
            if (in_bounds(pos) && mgrd(pos) == NON_MONSTER
                && monster_habitable_grid(mon, grd(pos))
                && trap_type_at_xy(pos) == NUM_TRAPS)
            {
                if (one_chance_in(++okay_squares))
                    target_square = pos;
            }

[384.5494]

[384.5855]

            if (one_chance_in(++okay_squares))
                target_square = *ai;

Insertion in crawl-ref/source/mon-util.cc at line 5393 [49.1699344]
[384.5865]
[384.5865]
```
    }
```

Replacement in crawl-ref/source/mon-util.cc at line 5401 [49.1699344]

B:BD[384.6014] → [21.2575:2643]

        mon->x = target_square.x;
        mon->y = target_square.y;

[384.6014]

[384.6084]

        mon->moveto(target_square);

Replacement in crawl-ref/source/mon-util.cc at line 5642 [49.1699344]

B:BD[19.2630] → [19.2630:2707]

                 && grid_compatible(grd[this->x][this->y], DNGN_DEEP_WATER))

[19.2630]

[386.1398]

                 && grid_compatible(grd(pos()), DNGN_DEEP_WATER))

Replacement in crawl-ref/source/mon-util.cc at line 6012 [49.1699344]
∅:D[387.4140] → [304.20573:20617]
B:BD[304.20573] → [304.20573:20617]
```
        if (env.cgrid[x][y] != EMPTY_CLOUD)
```
[387.4140]
[304.20617]
```
        if (env.cgrid(pos()) != EMPTY_CLOUD)
```
Replacement in crawl-ref/source/mon-util.cc at line 6028 [49.1699344]
B:BD[304.20999] → [342.14665:14718]
```
        const dungeon_feature_type grid = grd[x][y];
```
[304.20999]
[304.21029]
```
        const dungeon_feature_type grid = grd(pos());
```
Replacement in crawl-ref/source/mon-util.cc at line 6398 [49.1699344]
∅:D[176.10555] → [388.3676:3726]
B:BD[389.1101] → [388.3676:3726]
```
bool monsters::can_see(const actor *target) const
```
[176.10555]
[389.1139]
```
bool monsters::can_see(const actor *targ) const
```

Replacement in crawl-ref/source/mon-util.cc at line 6400 [49.1699344]

B:BD[389.1141] → [389.1141:1200]

    if (this == target)
        return visible_to(target);

[389.1141]

[389.1200]

    if (this == targ)
        return visible_to(targ);

Replacement in crawl-ref/source/mon-util.cc at line 6403 [49.1699344]
B:BD[389.1201] → [389.1201:1236]
```
    if (!target->visible_to(this))
```
[389.1201]
[86.21710]
```
    if (!targ->visible_to(this))
```
Replacement in crawl-ref/source/mon-util.cc at line 6406 [49.1699344]
B:BD[389.1259] → [389.1259:1298]
```
    if (target->atype() == ACT_PLAYER)
```
[389.1259]
[389.1298]
```
    if (targ->atype() == ACT_PLAYER)
```

Replacement in crawl-ref/source/mon-util.cc at line 6409 [49.1699344]

B:BD[389.1331] → [388.3727:3792]

    const monsters* mon = dynamic_cast<const monsters*>(target);

[389.1331]

[389.1508]

    const monsters* mon = dynamic_cast<const monsters*>(targ);

Replacement in crawl-ref/source/mon-util.cc at line 6467 [49.1699344]
B:BD[386.1578] → [357.7093:7144]
```
        && (!monster_can_submerge(this, grd[x][y])
```
[386.1578]
[357.7144]
```
        && (!monster_can_submerge(this, grd(pos()))
```
Replacement in crawl-ref/source/mon-util.cc at line 6486 [49.1699344]
∅:D[390.10426] → [209.12896:12932]
B:BD[209.12896] → [209.12896:12932]
```
    x = newpos.x;
    y = newpos.y;
```
[390.10426]
[209.12932]
```
    position = newpos;
```
Replacement in crawl-ref/source/mon-util.cc at line 6504 [49.1699344]
B:BD[138.15111] → [138.15111:15137]
```
        switch(grd[x][y])
```
[138.15111]
[138.15137]
```
        switch(grd(pos()))
```
Replacement in crawl-ref/source/mon-util.cc at line 6970 [49.1699344]
B:BD[341.19704] → [341.19704:19746]
```
    if (see_grid(monster->x, monster->y))
```
[341.19704]
[341.19746]
```
    if (see_grid(monster->pos()))
```

Replacement in crawl-ref/source/mon-util.cc at line 6972 [49.1699344]

B:BD[341.19752] → [341.19752:19817]

        dungeon_feature_type feat = grd[monster->x][monster->y];

[341.19752]

[66.2511]

        dungeon_feature_type feat = grd(monster->pos());

Deletion in crawl-ref/source/misc.h at line 22 [49.1928926]

∅:D[158.9888] → [49.1929187:1929432]

B:BD[49.1929187] → [49.1929187:1929432]

// last updated 08jan2001 {gdl}
/* ***********************************************************************
 * called from: ability - decks - fight - it_use2 - spells1
 * *********************************************************************** */

Deletion in crawl-ref/source/misc.h at line 23 [49.1928926]

B:BD[49.1929468] → [49.1929468:1929674]


// last updated 12may2000 {dlb}
/* ***********************************************************************
 * called from: acr
 * *********************************************************************** */

Deletion in crawl-ref/source/misc.h at line 24 [49.1928926]

∅:D[391.132] → [49.1929700:1929809]

B:BD[49.1929700] → [49.1929700:1929809]

B:BD[49.1930286] → [49.1930286:1930404]


// last updated 12may2000 {dlb}
/* ***********************************************************************
 * called from: acr - effects - spells3
 * *********************************************************************** */

Replacement in crawl-ref/source/misc.h at line 27 [49.1928926]

B:BD[392.2663] → [392.2663:2664]

B:BD[49.1931218] → [49.1931218:1931462]

B:BD[49.1931725] → [49.1931725:1931977]

∅:D[393.571] → [49.1931977:1931978]

B:BD[49.1931977] → [49.1931977:1931978]


// Created Sept 1, 2000 -- bwr
/* ***********************************************************************
 * called from: acr misc
 * *********************************************************************** */
void merfolk_start_swimming(void);
// last updated 12may2000 {dlb}
/* ***********************************************************************
 * called from: acr - misc - player - stuff
 * *********************************************************************** */
void new_level(void);

[394.8908]

[395.84]

void merfolk_start_swimming();
void new_level();

Deletion in crawl-ref/source/misc.h at line 30 [49.1928926]
∅:D[395.128] → [49.1931978:1932186]
∅:D[120.1307] → [49.1931978:1932186]
∅:D[132.6266] → [49.1931978:1932186]
B:BD[49.1931978] → [49.1931978:1932186]
```
// last updated 12may2000 {dlb}
/* ***********************************************************************
 * called from: delay
 * *********************************************************************** */
```
Replacement in crawl-ref/source/misc.h at line 106 [49.1928926]
B:BD[170.2616] → [170.2616:2655]
```
void reveal_secret_door(int x, int y);
```
[170.2616]
[396.2598]
```
void reveal_secret_door(const coord_def& p);
```

Replacement in crawl-ref/source/misc.cc at line 310 [49.1933596]

∅:D[397.3431] → [398.5376:5492]

B:BD[399.12939] → [398.5376:5492]

    ASSERT(blood.x >= 0 && blood.y >= 0);
    for (int o = igrd[blood.x][blood.y]; o != NON_ITEM; o = mitm[o].link)

[397.3431]

[399.13001]

    ASSERT(blood.pos.x >= 0 && blood.pos.y >= 0);
    for (int o = igrd[blood.pos.x][blood.pos.y]; o != NON_ITEM; o = mitm[o].link)

Replacement in crawl-ref/source/misc.cc at line 395 [49.1933596]
B:BD[398.6682] → [61.36753:36811]
```
    move_item_to_grid( &o, coord_def(blood.x, blood.y) );
```
[398.6682]
[398.6729]
```
    move_item_to_grid( &o, blood.pos );
```
Deletion in crawl-ref/source/misc.cc at line 620 [49.1933596]
B:BD[400.3610] → [400.3610:3672]
```
        item.x           = -1;
        item.y           = -1;
```
Insertion in crawl-ref/source/misc.cc at line 625 [49.1933596]
[400.3823]
[398.12987]
```
        item.pos.set(-1, -1);
```
Replacement in crawl-ref/source/misc.cc at line 656 [49.1933596]
∅:D[397.4400] → [398.13798:13838]
B:BD[398.13798] → [398.13798:13838]
```
    int o = igrd[you.x_pos][you.y_pos];
```
[397.4400]
[398.13838]
```
    int o = igrd(you.pos());
```
Deletion in crawl-ref/source/misc.cc at line 1025 [49.1933596]
B:BD[401.3093] → [401.3093:3155]
```
        item.x           = -1;
        item.y           = -1;
```
Insertion in crawl-ref/source/misc.cc at line 1032 [49.1933596]
[401.3359]
[398.19822]
```
        item.pos.set(-1, -1);
```
Replacement in crawl-ref/source/misc.cc at line 1040 [49.1933596]
∅:D[300.10212] → [398.19989:20055]
B:BD[398.19989] → [398.19989:20055]
```
    int o = igrd[you.x_pos][you.y_pos];
    while (o != NON_ITEM)
```
[300.10212]
[398.20055]
```
    for ( stack_iterator si(you.pos()); si; ++si )
```

Replacement in crawl-ref/source/misc.cc at line 1042 [49.1933596]

B:BD[398.20061] → [398.20061:20106]

B:BD[398.20106] → [402.6227:6273]

        if (mitm[o].base_type == OBJ_POTIONS
            && mitm[o].sub_type == POT_DECAY)

[398.20061]

[398.20205]

        if (si->base_type == OBJ_POTIONS && si->sub_type == POT_DECAY)

Replacement in crawl-ref/source/misc.cc at line 1045 [49.1933596]

B:BD[398.20263] → [398.20263:20310]

            inc_mitm_item_quantity(o, amount);

[398.20263]

[398.20310]

            inc_mitm_item_quantity(si->index(), amount);

Deletion in crawl-ref/source/misc.cc at line 1048 [49.1933596]
B:BD[398.20340] → [398.20340:20366]
```
        o = mitm[o].link;
```
Replacement in crawl-ref/source/misc.cc at line 1052 [49.1933596]
∅:D[300.10258] → [403.9315:9372]
B:BD[403.9315] → [403.9315:9372]
```
    if (!grid_destroys_items(grd[you.x_pos][you.y_pos]))
```
[300.10258]
[403.9372]
```
    if (!grid_destroys_items(grd(you.pos())))
```
Deletion in crawl-ref/source/misc.cc at line 1234 [49.1933596]
B:BD[49.1937131] → [49.1937131:1937142]
B:BD[49.1937368] → [49.1937368:1937369]
```
    int i;
```

Replacement in crawl-ref/source/misc.cc at line 1244 [49.1933596]

B:BD[391.428] → [139.10855:11013]

    for (int srx = you.x_pos - max_dist; srx <= you.x_pos + max_dist; ++srx)
        for (int sry = you.y_pos - max_dist; sry <= you.y_pos + max_dist; ++sry)

[391.428]

[49.1937495]

    for (radius_iterator ri(you.pos(), max_dist); ri; ++ri )
    {
        // Must have LOS, with no translucent walls in the way.
        if (see_grid_no_trans(*ri))

Replacement in crawl-ref/source/misc.cc at line 1249 [49.1933596]

B:BD[49.1937505] → [397.6657:6725]

∅:D[397.6725] → [139.11014:11059]

B:BD[172.11756] → [139.11014:11059]

∅:D[391.642] → [49.1937995:1938009]

∅:D[139.11059] → [49.1937995:1938009]

∅:D[172.11802] → [49.1937995:1938009]

B:BD[49.1937995] → [49.1937995:1938009]

B:BD[49.1938009] → [397.6726:6798]

∅:D[397.6798] → [391.715:789]

B:BD[391.715] → [391.715:789]

            // Must have LOS, with no translucent walls in the way.
            if (see_grid_no_trans(srx, sry))
            {
                // Maybe we want distance() instead of grid_distance()?
                int dist = grid_distance(srx, sry, you.x_pos, you.y_pos);

[49.1937505]

[49.1938051]

            // Maybe we want distance() instead of grid_distance()?
            int dist = grid_distance(*ri, you.pos());
            // Don't exclude own square; may be levitating.
            // XXX: Currently, levitating over a trap will always detect it.
            if (dist == 0)
                ++dist;

Replacement in crawl-ref/source/misc.cc at line 1257 [49.1933596]

B:BD[49.1938052] → [397.6799:6944]

∅:D[397.6944] → [391.853:912]

B:BD[391.853] → [391.853:912]

                // Don't exclude own square; may be levitating.
                // XXX: Currently, levitating over a trap will always detect it.
                if (dist == 0)
                    ++dist;

[49.1938052]

[404.266]

            // Making this harsher by removing the old +1...
            int effective = you.skills[SK_TRAPS_DOORS] / (2*dist - 1);

Replacement in crawl-ref/source/misc.cc at line 1260 [49.1933596]

B:BD[404.267] → [397.6945:7010]

∅:D[397.7010] → [391.991:1066]

B:BD[391.991] → [391.991:1066]

                // Making this harsher by removing the old +1...
                int effective = you.skills[SK_TRAPS_DOORS] / (2*dist - 1);

[404.267]

[404.268]

            if (grd(*ri) == DNGN_SECRET_DOOR && x_chance_in_y(effective+1, 17))
            {
                mpr("You found a secret door!");
                reveal_secret_door(*ri);
                exercise(SK_TRAPS_DOORS, (coinflip() ? 2 : 1));
            }
            else if (grd(*ri) == DNGN_UNDISCOVERED_TRAP
                     && x_chance_in_y(effective + 1, 17))
            {
                const int i = trap_at_xy(*ri);

Replacement in crawl-ref/source/misc.cc at line 1271 [49.1933596]

B:BD[404.269] → [139.11060:11114]

B:BD[139.11114] → [177.7053:7110]

                if (grd[srx][sry] == DNGN_SECRET_DOOR
                    && x_chance_in_y(effective + 1, 17))

[404.269]

[391.1186]

                if (i != -1)

Replacement in crawl-ref/source/misc.cc at line 1273 [49.1933596]

∅:D[170.2707] → [391.1258:1311]

B:BD[391.1258] → [391.1258:1311]

B:BD[391.1311] → [90.27011:27061]

                    mpr("You found a secret door!");
                    reveal_secret_door(srx, sry);

[391.1204]

[139.11164]

                    grd(*ri) = trap_category(env.trap[i].type);
                    mpr("You found a trap!");
                    learned_something_new(TUT_SEEN_TRAP, *ri);

Replacement in crawl-ref/source/misc.cc at line 1279 [49.1933596]

B:BD[391.1399] → [139.11233:11298]

B:BD[139.11298] → [177.7111:7173]

                else if (grd[srx][sry] == DNGN_UNDISCOVERED_TRAP
                         && x_chance_in_y(effective + 1, 17))

[391.1399]

[391.1509]

                else

Replacement in crawl-ref/source/misc.cc at line 1281 [49.1933596]

B:BD[391.1527] → [61.39041:39098]

∅:D[61.39098] → [404.270:271]

B:BD[391.1573] → [404.270:271]

∅:D[404.271] → [391.1594:1627]

B:BD[391.1594] → [391.1594:1627]

B:BD[391.1627] → [405.202:224]

∅:D[405.224] → [391.1627:1700]

B:BD[391.1627] → [391.1627:1700]

B:BD[391.1700] → [405.225:275]

B:BD[405.275] → [106.4871:4944]

∅:D[106.4944] → [139.11353:11425]

B:BD[405.275] → [139.11353:11425]

∅:D[406.2979] → [405.275:517]

∅:D[139.11425] → [405.275:517]

B:BD[405.275] → [405.275:517]

                    i = trap_at_xy(coord_def(srx, sry));
                    if (i != -1)
                    {
                        grd[srx][sry] = trap_category(env.trap[i].type);
                        mpr("You found a trap!");
                        learned_something_new(TUT_SEEN_TRAP, srx, sry);
                        exercise(SK_TRAPS_DOORS, (coinflip() ? 2 : 1));
                    }
                    else
                    {
                        // Maybe we shouldn't kill the trap for debugging
                        // purposes - oh well.
                        grd[srx][sry] = DNGN_FLOOR;

[391.1527]

[407.2580]

                    // Maybe we shouldn't kill the trap for debugging
                    // purposes - oh well.
                    grd(*ri) = DNGN_FLOOR;

Replacement in crawl-ref/source/misc.cc at line 1285 [49.1933596]

B:BD[407.2602] → [8.2580:2696]

                        mpr("You found a buggy trap! It vanishes!",
                            MSGCH_DIAGNOSTICS);

[407.2602]

[407.2719]

                    mpr("You found a buggy trap! It vanishes!",
                        MSGCH_DIAGNOSTICS);

Deletion in crawl-ref/source/misc.cc at line 1288 [49.1933596]
∅:D[407.2726] → [405.586:608]
B:BD[405.586] → [405.586:608]
```
                    }
```
Replacement in crawl-ref/source/misc.cc at line 1291 [49.1933596]
B:BD[49.1938223] → [49.1938223:1938236]
```
    return;
```
[49.1938217]
[397.7011]
```
    }
```

Replacement in crawl-ref/source/misc.cc at line 1427 [49.1933596]

B:BD[408.3190] → [408.3190:3295]

    coord_def pos(you.x_pos, you.y_pos);
    level_id  next_level_id = level_id::get_next_level_id(pos);

[408.3190]

[394.10170]

    level_id  next_level_id = level_id::get_next_level_id(you.pos());

Replacement in crawl-ref/source/misc.cc at line 1441 [49.1933596]
B:BD[408.3785] → [408.3785:3820]
```
    else if (is_exclude_root(pos))
```
[408.3785]
[408.3820]
```
    else if (is_exclude_root(you.pos()))
```

Replacement in crawl-ref/source/misc.cc at line 1462 [49.1933596]

B:BD[409.4388] → [409.4388:4469]

                                                   : grd[you.x_pos][you.y_pos]);

[409.4388]

[410.12293]

                                       : grd(you.pos()));

Replacement in crawl-ref/source/misc.cc at line 1610 [49.1933596]
B:BD[33.3070] → [33.3070:3120]
```
    int stair_x = you.x_pos, stair_y = you.y_pos;
```
[33.3070]
[49.1947805]
```
    const coord_def stair_pos = you.pos();
```
Replacement in crawl-ref/source/misc.cc at line 1668 [49.1933596]
B:BD[68.249842] → [411.3058:3095]
∅:D[411.3095] → [399.19000:19034]
B:BD[68.249877] → [399.19000:19034]
∅:D[399.19034] → [68.249912:249946]
B:BD[68.249912] → [68.249912:249946]
```
            lp.id    = new_level_id;
            lp.pos.x = you.x_pos;
            lp.pos.y = you.y_pos;
```
[68.249842]
[68.249946]
```
            lp.id  = new_level_id;
            lp.pos = you.pos();
```

Replacement in crawl-ref/source/misc.cc at line 1688 [49.1933596]

B:BD[33.3214] → [33.3214:3288]

                old_level_info.update_stair(stair_x, stair_y, lp, guess);

[33.3214]

[33.3288]

                old_level_info.update_stair(stair_pos, lp, guess);

Replacement in crawl-ref/source/misc.cc at line 1701 [49.1933596]

B:BD[68.251565] → [68.251565:251714]

                lp.pos.x = stair_x;
                lp.pos.y = stair_y;
                new_level_info.update_stair(you.x_pos, you.y_pos, lp, true);

[68.251565]

[68.251714]

                lp.pos = stair_pos;
                new_level_info.update_stair(you.pos(), lp, true);

Replacement in crawl-ref/source/misc.cc at line 1847 [49.1933596]
B:BD[68.252251] → [68.252251:252301]
```
    int stair_x = you.x_pos, stair_y = you.y_pos;
```
[68.252251]
[68.252301]
```
    const coord_def stair_pos = you.pos();
```
Replacement in crawl-ref/source/misc.cc at line 2118 [49.1933596]
B:BD[49.1957956] → [49.1957956:1958004]
```
        grd[you.x_pos][you.y_pos] = DNGN_FLOOR;
```
[49.1957956]
[49.1958004]
```
        grd(you.pos()) = DNGN_FLOOR;
```
Replacement in crawl-ref/source/misc.cc at line 2195 [49.1933596]
B:BD[68.253108] → [412.3458:3495]
B:BD[412.3495] → [399.19247:19281]
∅:D[399.19281] → [68.253178:253212]
B:BD[68.253178] → [68.253178:253212]
```
            lp.id    = new_level_id;
            lp.pos.x = you.x_pos;
            lp.pos.y = you.y_pos;
```
[68.253108]
[68.253212]
```
            lp.id  = new_level_id;
            lp.pos = you.pos();
```

Replacement in crawl-ref/source/misc.cc at line 2198 [49.1933596]

B:BD[68.253213] → [68.253213:253276]

            old_level_info.update_stair(stair_x, stair_y, lp);

[68.253213]

[68.253276]

            old_level_info.update_stair(stair_pos, lp);

Replacement in crawl-ref/source/misc.cc at line 2204 [49.1933596]

B:BD[68.253510] → [68.253510:253647]

            lp.pos.x = stair_x;
            lp.pos.y = stair_y;
            new_level_info.update_stair(you.x_pos, you.y_pos, lp, true);

[68.253510]

[68.253647]

            lp.pos = stair_pos;
            new_level_info.update_stair(you.pos(), lp, true);

Replacement in crawl-ref/source/misc.cc at line 2296 [49.1933596]

B:BD[413.1692] → [411.3189:3261]

    int  dist    = grid_distance(you.x_pos, you.y_pos, mon->x, mon->y);

[413.1692]

[336.5802]

    int  dist    = grid_distance(you.pos(), mon->pos());

Replacement in crawl-ref/source/misc.cc at line 2305 [49.1933596]
∅:D[336.6011] → [414.2918:2976]
B:BD[414.2918] → [414.2918:2976]
```
                    || !see_grid_no_trans(mon->x, mon->y)
```
[336.6011]
[415.11034]
```
                    || !see_grid_no_trans(mon->pos())
```
Replacement in crawl-ref/source/misc.cc at line 2629 [49.1933596]
B:BD[170.2709] → [170.2709:2747]
```
void reveal_secret_door(int x, int y)
```
[170.2709]
[170.2747]
```
void reveal_secret_door(const coord_def& p)
```
Replacement in crawl-ref/source/misc.cc at line 2631 [49.1933596]
B:BD[170.2749] → [170.2749:2792]
```
    ASSERT(grd[x][y] == DNGN_SECRET_DOOR);
```
[170.2749]
[170.2792]
```
    ASSERT(grd(p) == DNGN_SECRET_DOOR);
```

Replacement in crawl-ref/source/misc.cc at line 2633 [49.1933596]

B:BD[170.2793] → [61.39441:39519]

∅:D[61.39519] → [170.2860:2942]

B:BD[170.2860] → [170.2860:2942]

    dungeon_feature_type door = grid_secret_door_appearance(coord_def(x, y));
    grd[x][y] = grid_is_opaque(door) ?
        DNGN_CLOSED_DOOR : DNGN_OPEN_DOOR;

[170.2793]

[90.27105]

    dungeon_feature_type door = grid_secret_door_appearance(p);
    grd(p) = grid_is_opaque(door) ? DNGN_CLOSED_DOOR : DNGN_OPEN_DOOR;

Replacement in crawl-ref/source/misc.cc at line 2636 [49.1933596]
B:BD[90.27134] → [90.27134:27189]
```
    learned_something_new(TUT_SEEN_SECRET_DOOR, x, y);
```
[90.27134]
[170.2942]
```
    learned_something_new(TUT_SEEN_SECRET_DOOR, p);
```
Replacement in crawl-ref/source/makeitem.cc at line 2843 [416.927]
B:BD[416.98022] → [417.57285:57325]
```
        item.x = 0;
        item.y = 0;
```
[416.98022]
[417.57325]
```
        item.pos.reset();
```
Replacement in crawl-ref/source/makeitem.cc at line 2925 [416.927]
B:BD[416.99999] → [416.99999:100035]
```
    mthing.x = 0;
    mthing.y = 0;
```
[416.99999]
[416.100035]
```
    mthing.pos.reset();
```
Replacement in crawl-ref/source/makeitem.cc at line 3648 [416.927]
B:BD[416.123266] → [416.123266:123298]
```
    item.x = 0;
    item.y = 0;
```
[416.123266]
[416.123298]
```
    item.pos.reset();
```

Replacement in crawl-ref/source/luadgn.cc at line 1574 [419.1232]

B:BD[418.106138] → [160.7169:7241]

static int make_a_lua_cloud(int x, int y, int garbage, int spread_rate,

[418.106138]

[45.82209]

static int make_a_lua_cloud(coord_def where, int garbage, int spread_rate,

Replacement in crawl-ref/source/luadgn.cc at line 1583 [419.1232]
B:BD[160.7493] → [45.82327:82403]
∅:D[61.39977] → [160.7550:7551]
∅:D[45.82403] → [160.7550:7551]
B:BD[160.7550] → [160.7550:7551]
```
    place_cloud( ctype, coord_def(x, y), pow, whose, killer, spread_rate );
```
[160.7493]
[160.7551]
```
    place_cloud( ctype, where, pow, whose, killer, spread_rate );
```

Replacement in crawl-ref/source/luadgn.cc at line 1666 [419.1232]

B:BD[160.9687] → [160.9687:9741]

    apply_area_cloud(make_a_lua_cloud, x, y, 0, size,

[160.9687]

[45.82404]

    apply_area_cloud(make_a_lua_cloud, coord_def(x, y), 0, size,

Replacement in crawl-ref/source/luadgn.cc at line 1769 [419.1232]

B:BD[420.5111] → [420.5111:5175]

    sr.x1 = x1;
    sr.x2 = x2;
    sr.y1 = y1;
    sr.y2 = y2;

[420.5111]

[420.5175]

    sr.tl.x = x1;
    sr.br.x = x2;
    sr.tl.y = y1;
    sr.br.y = y2;

Replacement in crawl-ref/source/luadgn.cc at line 2288 [419.1232]

∅:D[159.13301] → [421.366:489]

B:BD[283.21322] → [421.366:489]

LUARET1(you_x_pos, number, you.x_pos)
LUARET1(you_y_pos, number, you.y_pos)
LUARET2(you_pos, number, you.x_pos, you.y_pos)

[159.13301]

[283.21322]

LUARET1(you_x_pos, number, you.pos().x)
LUARET1(you_y_pos, number, you.pos().y)
LUARET2(you_pos, number, you.pos().x, you.pos().y)

Replacement in crawl-ref/source/items.h at line 126 [49.2580284]
B:BD[68.342184] → [68.342184:342215]
```
void origin_set(int x, int y);
```
[68.342184]
[68.342215]
```
void origin_set(const coord_def& where);
```
Replacement in crawl-ref/source/items.cc at line 96 [49.2584728]
B:BD[49.2586140] → [49.2586140:2586172]
```
void fix_item_coordinates(void)
```
[49.2586140]
[49.2586172]
```
void fix_item_coordinates()
```

Replacement in crawl-ref/source/items.cc at line 106 [49.2584728]

B:BD[49.2586400] → [49.2586400:2586462]

                mitm[i].x = x;
                mitm[i].y = y;

[49.2586400]

[49.2586462]

                mitm[i].pos.x = x;
                mitm[i].pos.y = y;

Replacement in crawl-ref/source/items.cc at line 124 [49.2584728]

B:BD[49.2586946] → [49.2586946:2587021]

        if (!is_valid_item(mitm[i]) || (mitm[i].x == 0 && mitm[i].y == 0))

[49.2586946]

[49.2587021]

        if (!is_valid_item(mitm[i]) || mitm[i].pos.origin())

Replacement in crawl-ref/source/items.cc at line 132 [49.2584728]

B:BD[49.2587191] → [49.2587191:2587290]

        mitm[i].link = igrd[ mitm[i].x ][ mitm[i].y ];
        igrd[ mitm[i].x ][ mitm[i].y ] = i;

[49.2587191]

[49.2587290]

        mitm[i].link = igrd( mitm[i].pos );
        igrd( mitm[i].pos ) = i;

Replacement in crawl-ref/source/items.cc at line 177 [49.2584728]

∅:D[177.9897] → [422.703:737]

B:BD[49.2588566] → [422.703:737]

B:BD[49.2588602] → [422.738:776]

∅:D[422.776] → [49.2588636:2588646]

B:BD[49.2588636] → [49.2588636:2588646]

B:BD[49.2588646] → [177.9898:9933]

∅:D[177.9933] → [49.2588681:2588849]

B:BD[49.2588681] → [49.2588681:2588849]

    for (int x = 5; x < GXM; x++)
        for (int y = 5; y < GYM; y++)
        {
            // 1. Not near player!
            if (x > you.x_pos - 9 && x < you.x_pos + 9
                && y > you.y_pos - 9 && y < you.y_pos + 9)
            {
                continue;
            }

[177.9897]

[49.2588849]

    for ( rectangle_iterator ri(1); ri; ++ri )
    {
        if ( grid_distance( you.pos(), *ri ) <= 9 )
            continue;

Replacement in crawl-ref/source/items.cc at line 182 [49.2584728]

B:BD[49.2588850] → [422.777:800]

B:BD[422.800] → [177.9934:9990]

∅:D[175.6316] → [422.801:872]

∅:D[177.9990] → [422.801:872]

B:BD[49.2588907] → [422.801:872]

            int next;
            // Iterate through the grids list of items.
            for (int item = igrd[x][y]; item != NON_ITEM; item = next)

[49.2588850]

[49.2588974]

        for ( stack_iterator si(*ri); si; ++si )
        {
            if (_item_ok_to_clean(si->index()) && x_chance_in_y(15, 100))

Replacement in crawl-ref/source/items.cc at line 186 [49.2584728]

B:BD[49.2588988] → [49.2588988:2589063]

B:BD[49.2589063] → [177.9991:10062]

                next = mitm[item].link; // in case we can't get it later.
                if (_item_ok_to_clean(item) && x_chance_in_y(15, 100))

[49.2588988]

[49.2589128]

                if (is_fixed_artefact(*si))

Replacement in crawl-ref/source/items.cc at line 188 [49.2584728]

B:BD[49.2589146] → [423.2543:2644]

∅:D[423.2644] → [49.2589203:2589225]

B:BD[49.2589203] → [49.2589203:2589225]

B:BD[49.2589225] → [177.10063:10116]

∅:D[177.10116] → [423.2645:2719]

B:BD[49.2589277] → [423.2645:2719]

∅:D[423.2719] → [49.2589358:2589450]

B:BD[49.2589358] → [49.2589358:2589450]

B:BD[49.2589450] → [423.2720:2776]

∅:D[423.2776] → [49.2589515:2589537]

B:BD[49.2589515] → [49.2589515:2589537]

B:BD[49.2589537] → [177.10117:10165]

∅:D[177.10165] → [423.2777:2879]

B:BD[49.2589584] → [423.2777:2879]

∅:D[423.2879] → [424.452:511]

B:BD[51.632013] → [424.452:511]

∅:D[424.511] → [49.2589735:2589926]

∅:D[51.632068] → [49.2589735:2589926]

B:BD[49.2589735] → [49.2589735:2589926]

                    const item_def& obj(mitm[item]);
                    if (is_fixed_artefact(obj))
                    {
                        // 7. Move uniques to abyss.
                        set_unique_item_status( OBJ_WEAPONS, obj.special,
                                                UNIQ_LOST_IN_ABYSS );
                    }
                    else if (is_unrandom_artefact(obj))
                    {
                        // 9. Unmark unrandart.
                        const int z = find_unrandart_index(obj);
                        if (z != -1)
                            set_unrandart_exist(z, false);
                    }
                    // POOF!
                    destroy_item( item );
                    if (first_cleaned == NON_ITEM)
                        first_cleaned = item;

[49.2589146]

[49.2589926]

                    // 7. Move uniques to abyss.
                    set_unique_item_status( OBJ_WEAPONS, si->special,
                                            UNIQ_LOST_IN_ABYSS );
                }
                else if (is_unrandom_artefact(*si))
                {
                    // 9. Unmark unrandart.
                    const int z = find_unrandart_index(*si);
                    if (z != -1)
                        set_unrandart_exist(z, false);

Insertion in crawl-ref/source/items.cc at line 199 [49.2584728]

[49.2589944]

[177.10166]

                
                if (first_cleaned == NON_ITEM)
                    first_cleaned = si->index();
                // POOF!
                destroy_item( si->index() );

Replacement in crawl-ref/source/items.cc at line 206 [49.2584728]
∅:D[177.10180] → [49.2589974:2589975]
B:BD[49.2589974] → [49.2589974:2589975]
B:BD[49.2589975] → [86.26679:26689]
```
        }
```
[177.10180]
[49.2590009]
```
        }    
    }
```
Replacement in crawl-ref/source/items.cc at line 360 [49.2584728]
B:BD[49.2593238] → [175.6753:6801]
```
    if (mitm[dest].x == 0 && mitm[dest].y == 0)
```
[49.2593238]
[49.2593287]
```
    if (mitm[dest].pos.origin())
```

Replacement in crawl-ref/source/items.cc at line 379 [49.2584728]

B:BD[49.2593843] → [49.2593843:2593919]

                    mitm[dest].x = 0;
                    mitm[dest].y = 0;

[49.2593843]

[49.2593919]

                    mitm[dest].pos.reset();

Replacement in crawl-ref/source/items.cc at line 401 [49.2584728]
B:BD[49.2594529] → [49.2594529:2594587]
```
        if (igrd[ mitm[dest].x ][ mitm[dest].y ] == dest)
```
[49.2594529]
[49.2594587]
```
        if (igrd(mitm[dest].pos) == dest)
```

Replacement in crawl-ref/source/items.cc at line 404 [49.2584728]

B:BD[49.2594641] → [49.2594641:2594709]

            igrd[ mitm[dest].x ][ mitm[dest].y ] = mitm[dest].link;

[49.2594641]

[49.2594709]

            igrd(mitm[dest].pos) = mitm[dest].link;

Replacement in crawl-ref/source/items.cc at line 406 [49.2584728]

B:BD[49.2594710] → [49.2594710:2594770]

            mitm[dest].x = 0;
            mitm[dest].y = 0;

[49.2594710]

[49.2594770]

            mitm[dest].pos.reset();

Replacement in crawl-ref/source/items.cc at line 412 [49.2584728]

B:BD[425.9599] → [426.3523:3597]

∅:D[426.3597] → [427.3011:3042]

B:BD[427.3011] → [427.3011:3042]

        for (int c = igrd[ mitm[dest].x ][ mitm[dest].y ]; c != NON_ITEM;
             c = mitm[c].link)

[425.9599]

[49.2594993]

        for (stack_iterator si(mitm[dest].pos); si; ++si)

Replacement in crawl-ref/source/items.cc at line 415 [49.2584728]
∅:D[425.9647] → [49.2595049:2595115]
B:BD[49.2595049] → [49.2595049:2595115]
```
            if (is_valid_item( mitm[c] ) && mitm[c].link == dest)
```
[425.9647]
[49.2595115]
```
            if (is_valid_item(*si) && si->link == dest)
```

Replacement in crawl-ref/source/items.cc at line 418 [49.2584728]

B:BD[49.2595160] → [49.2595160:2595277]

                mitm[c].link = mitm[dest].link;
                mitm[dest].x = 0;
                mitm[dest].y = 0;

[49.2595160]

[49.2595277]

                si->link = mitm[dest].link;
                mitm[dest].pos.reset();

Replacement in crawl-ref/source/items.cc at line 429 [49.2584728]

∅:D[428.4241] → [427.3125:3202]

B:BD[427.3125] → [427.3125:3202]

          mitm[dest].name(DESC_PLAIN).c_str(), mitm[dest].x, mitm[dest].y );

[428.4241]

[49.2595516]

          mitm[dest].name(DESC_PLAIN).c_str(),
         mitm[dest].pos.x, mitm[dest].pos.y );

Deletion in crawl-ref/source/items.cc at line 442 [49.2584728]
∅:D[425.9678] → [49.2596002:2596046]
B:BD[49.2596002] → [49.2596002:2596046]
```
    mitm[dest].x = 0;
    mitm[dest].y = 0;
```
Insertion in crawl-ref/source/items.cc at line 443 [49.2584728]
[425.9716]
[429.45952]
```
    mitm[dest].pos.reset();
```

Replacement in crawl-ref/source/items.cc at line 552 [49.2584728]

B:BD[301.4979] → [301.4979:5083]

        if (player_in_branch(BRANCH_HALL_OF_ZOT)
            && item.x != -1 && item.y != -1)
        {

[301.4979]

[301.5083]

        if (player_in_branch(BRANCH_HALL_OF_ZOT) && !in_inventory(item))

Deletion in crawl-ref/source/items.cc at line 554 [49.2584728]
B:BD[301.5146] → [301.5146:5156]
```
        }
```
Replacement in crawl-ref/source/items.cc at line 708 [49.2584728]
B:BD[49.2606186] → [68.343097:343135]
```
    origin_set(you.x_pos, you.y_pos);
```
[51.633668]
[49.2606229]
```
    origin_set(you.pos());
```
Replacement in crawl-ref/source/items.cc at line 896 [49.2584728]
B:BD[68.345842] → [377.9030:9076]
```
static int _first_corpse_monnum(int x, int y)
```
[68.345842]
[68.345887]
```
static int _first_corpse_monnum(const coord_def& where)
```
Replacement in crawl-ref/source/items.cc at line 947 [49.2584728]
∅:D[430.4267] → [68.346034:346064]
∅:D[431.15729] → [68.346034:346064]
B:BD[68.346034] → [68.346034:346064]
```
void origin_set(int x, int y)
```
[431.15729]
[68.346064]
```
void origin_set(const coord_def& where)
```
Replacement in crawl-ref/source/items.cc at line 949 [49.2584728]
B:BD[68.346066] → [377.9643:9688]
```
    int monnum = _first_corpse_monnum(x, y);
```
[68.346066]
[68.346110]
```
    int monnum = _first_corpse_monnum(where);
```
Replacement in crawl-ref/source/items.cc at line 951 [49.2584728]
B:BD[68.346158] → [87.4536:4590]
```
    for (stack_iterator si(coord_def(x,y)); si; ++si)
```
[68.346158]
[68.346232]
```
    for (stack_iterator si(where); si; ++si)
```

Replacement in crawl-ref/source/items.cc at line 966 [49.2584728]

B:BD[68.346465] → [68.346465:346525]

void origin_set_monstercorpse(item_def &item, int x, int y)

[68.346465]

[68.346525]

void origin_set_monstercorpse(item_def &item, const coord_def& where)

Replacement in crawl-ref/source/items.cc at line 968 [49.2584728]
B:BD[68.346527] → [377.9724:9775]
```
    item.orig_monnum = _first_corpse_monnum(x, y);
```
[68.346527]
[68.346577]
```
    item.orig_monnum = _first_corpse_monnum(where);
```

Replacement in crawl-ref/source/items.cc at line 971 [49.2584728]

B:BD[68.346580] → [432.7185:7242]

static void _origin_freeze(item_def &item, int x, int y)

[68.346580]

[68.346629]

static void _origin_freeze(item_def &item, const coord_def& where)

Replacement in crawl-ref/source/items.cc at line 975 [49.2584728]

B:BD[68.346666] → [68.346666:346769]

        if (!item.orig_monnum && x != -1 && y != -1)
            origin_set_monstercorpse(item, x, y);

[68.346666]

[175.7422]

        if (!item.orig_monnum && where.x != -1 && where.y != -1)
            origin_set_monstercorpse(item, where);

Replacement in crawl-ref/source/items.cc at line 1533 [49.2584728]
B:BD[418.106819] → [418.106819:106864]
```
    coord_def pos(mitm[obj].x, mitm[obj].y);
```
[418.106819]
[418.106864]
```
    coord_def p = mitm[obj].pos;
```

Replacement in crawl-ref/source/items.cc at line 1535 [49.2584728]

B:BD[418.106904] → [418.106904:106963]

        dgn_event(DET_ITEM_PICKUP, pos, 0, obj, -1), pos);

[418.106904]

[68.354542]

        dgn_event(DET_ITEM_PICKUP, p, 0, obj, -1), p);

Deletion in crawl-ref/source/items.cc at line 1540 [49.2584728]
B:BD[68.354629] → [68.354629:354673]
```
    item.x      = -1;
    item.y      = -1;
```
Insertion in crawl-ref/source/items.cc at line 1541 [49.2584728]
[68.354701]
[433.4182]
```
    item.pos.set(-1, -1);
```
Replacement in crawl-ref/source/items.cc at line 1550 [49.2584728]
B:BD[51.635516] → [432.8601:8649]
```
    _origin_freeze(item, you.x_pos, you.y_pos);
```
[51.635516]
[377.10052]
```
    _origin_freeze(item, you.pos());
```
Replacement in crawl-ref/source/items.cc at line 1670 [49.2584728]
B:BD[434.2785] → [61.41069:41105]
```
    item.x = p.x;
    item.y = p.y;
```
[434.2785]
[49.2618482]
```
    item.pos = p;
```
Replacement in crawl-ref/source/items.cc at line 1697 [49.2584728]
B:BD[49.2618788] → [61.41469:41513]
```
        si->x = to.x;
        si->y = to.y;
```
[49.2618788]
[434.2870]
```
        si->pos = to;
```
Replacement in crawl-ref/source/items.cc at line 1758 [49.2584728]
B:BD[61.42242] → [61.42242:42282]
```
    new_item.x = 0;
    new_item.y = 0;
```
[61.42242]
[61.42282]
```
    new_item.pos.reset();
```

Replacement in crawl-ref/source/items.cc at line 2111 [49.2584728]

B:BD[435.1247] → [435.1247:1344]

            if ((item.flags & ISFLAG_DROPPED)
                && (item.x != -1 || item.y != -1))

[435.1247]

[435.1344]

            if ((item.flags & ISFLAG_DROPPED) && !in_inventory(item))

Replacement in crawl-ref/source/items.cc at line 2448 [49.2584728]
B:BD[394.13616] → [394.13616:13654]
```
    if (item.x != -1 || item.y != -1)
```
[394.13616]
[394.13654]
```
    if (!in_inventory(item))
```
Insertion in crawl-ref/source/itemprop.cc at line 29 [51.646661]
[135.89031]
[51.647099]
```
#include "invent.h"
```
Replacement in crawl-ref/source/itemprop.cc at line 489 [51.646661]
B:BD[394.14157] → [402.6575:6613]
```
    if (item.x == -1 && item.y == -1)
```
[394.14157]
[394.14228]
```
    if (in_inventory(item))
```

Replacement in crawl-ref/source/itemprop.cc at line 523 [51.646661]

B:BD[51.666066] → [436.4543:4618]

    if (item.x == -1 && item.y == -1 && you.equip[EQ_WEAPON] == item.link)

[51.666066]

[436.4618]

    if (in_inventory(item) && you.equip[EQ_WEAPON] == item.link)

Replacement in crawl-ref/source/itemname.cc at line 199 [49.2667494]
∅:D[437.881] → [438.10487:10562]
B:BD[49.2680817] → [438.10487:10562]
```
    if (descrip == DESC_INVENTORY_EQUIP && this->x == -1 && this->y == -1)
```
[437.881]
[49.2680890]
```
    if (descrip == DESC_INVENTORY_EQUIP && in_inventory(*this))
```
Replacement in crawl-ref/source/item_use.cc at line 1846 [49.2781507]
B:BD[439.3453] → [439.3453:3517]
```
    pbolt.source_x = you.x_pos;
    pbolt.source_y = you.y_pos;
```
[439.3453]
[439.3517]
```
    pbolt.source   = you.pos();
```

Replacement in crawl-ref/source/item_use.cc at line 1944 [49.2781507]

B:BD[49.2813452] → [49.2813452:2813544]

        thr.tx = you.x_pos + random2(13) - 6;
        thr.ty = you.y_pos + random2(13) - 6;

[49.2813452]

[49.2813544]

        thr.target = you.pos() + coord_def(random2(13)-6, random2(13)-6);

Replacement in crawl-ref/source/item_use.cc at line 2582 [49.2781507]

B:BD[179.1919] → [61.42866:42925]

        hit = (affect(pbolt, pbolt.target(), &item) != 0);

[179.1919]

[440.685]

        hit = (affect(pbolt, pbolt.target, &item) != 0);

Replacement in crawl-ref/source/item_use.cc at line 2584 [49.2781507]

B:BD[440.724] → [61.42926:42986]

            beam_drop_object(pbolt, &item, pbolt.target());

[440.724]

[179.2063]

            beam_drop_object(pbolt, &item, pbolt.target);

Replacement in crawl-ref/source/item_use.cc at line 2595 [49.2781507]

B:BD[298.2281] → [61.42987:43067]

        if (did_return && thrown_object_destroyed(&item, pbolt.target(), true))

[298.2281]

[279.4945]

        if (did_return && thrown_object_destroyed(&item, pbolt.target, true))

Replacement in crawl-ref/source/item_use.cc at line 3493 [49.2781507]

B:BD[49.2842465] → [49.2842465:2842567]

        zap_wand.tx = you.x_pos + random2(13) - 6;
        zap_wand.ty = you.y_pos + random2(13) - 6;

[49.2842465]

[49.2842567]

        zap_wand.target = you.pos() + coord_def(random2(13)-6, random2(13)-6);

Replacement in crawl-ref/source/item_use.cc at line 3500 [49.2781507]
∅:D[436.5735] → [49.2843290:2843352]
B:BD[49.2843290] → [49.2843290:2843352]
```
    beam.source_x = you.x_pos;
    beam.source_y = you.y_pos;
```
[436.5735]
[51.760445]
```
    beam.source = you.pos();
```
Replacement in crawl-ref/source/item_use.cc at line 3503 [49.2781507]
B:BD[49.2843419] → [441.7590:7645]
```
    beam.aimed_at_feet = (beam.target() == you.pos());
```
[49.2843419]
[436.5829]
```
    beam.aimed_at_feet = (beam.target == you.pos());
```
Replacement in crawl-ref/source/item_use.cc at line 3801 [49.2781507]
∅:D[442.7505] → [418.106981:107036]
∅:D[441.7854] → [418.106981:107036]
B:BD[443.2544] → [418.106981:107036]
```
            set_terrain_changed(you.x_pos, you.y_pos);
```
[441.7854]
[418.107036]
```
            set_terrain_changed(you.pos());
```
Replacement in crawl-ref/source/item_use.cc at line 3812 [49.2781507]
∅:D[444.2919] → [418.107047:107098]
∅:D[442.7679] → [418.107047:107098]
B:BD[158.16569] → [418.107047:107098]
```
        set_terrain_changed(you.x_pos, you.y_pos);
```
[444.2919]
[418.107098]
```
        set_terrain_changed(you.pos());
```

Replacement in crawl-ref/source/item_use.cc at line 3850 [49.2781507]

B:BD[86.34920] → [86.34920:34994]

        beam.target_x   = you.x_pos;
        beam.target_y   = you.y_pos;

[86.34920]

[86.34994]

        beam.target     = you.pos();

Replacement in crawl-ref/source/item_use.cc at line 4376 [49.2781507]

B:BD[445.577] → [7.2648:2758]

        big_cloud( random_smoke_type(), KC_YOU, you.x_pos, you.y_pos,
                   50, 8 + random2(8));

[445.577]

[446.2872]

        big_cloud(random_smoke_type(), KC_YOU, you.pos(), 50, 8 + random2(8));

Replacement in crawl-ref/source/item_use.cc at line 4412 [49.2781507]

B:BD[82.16434] → [82.16434:16512]

        beam.target_x     = you.x_pos;
        beam.target_y     = you.y_pos;

[82.16434]

[82.16512]

        beam.target       = you.pos();

Replacement in crawl-ref/source/it_use3.cc at line 271 [49.2870456]

B:BD[49.2878242] → [447.397:503]

    const int x_distance = abs(beam.tx - you.x_pos);
    const int y_distance = abs(beam.ty - you.y_pos);

[49.2878242]

[49.2878328]

    const coord_def delta = beam.target - you.pos();
    const int x_distance = abs(delta.x);
    const int y_distance = abs(delta.y);

Replacement in crawl-ref/source/it_use3.cc at line 280 [49.2870456]
B:BD[447.539] → [347.382:433]
```
    else if (!see_grid_no_trans(beam.tx, beam.ty))
```
[447.539]
[347.433]
```
    else if (!see_grid_no_trans(beam.target))
```
Replacement in crawl-ref/source/it_use3.cc at line 285 [49.2870456]
∅:D[347.512] → [49.2878422:2878474]
∅:D[447.539] → [49.2878422:2878474]
B:BD[49.2878422] → [49.2878422:2878474]
```
    else if (mgrd[beam.tx][beam.ty] == NON_MONSTER)
```
[347.512]
[49.2878474]
```
    else if (mgrd(beam.target) == NON_MONSTER)
```

Replacement in crawl-ref/source/it_use3.cc at line 302 [49.2870456]

B:BD[49.2878541] → [447.1088:1234]

        const int x_middle = MAX(beam.tx, you.x_pos) - (x_distance / 2);
        const int y_middle = MAX(beam.ty, you.y_pos) - (y_distance / 2);

[49.2878541]

[49.2878750]

        const int x_middle = MAX(beam.target.x, you.pos().x) - (x_distance / 2);
        const int y_middle = MAX(beam.target.y, you.pos().y) - (y_distance / 2);

Replacement in crawl-ref/source/it_use3.cc at line 308 [49.2870456]

B:BD[447.1326] → [154.12438:12497]

        if ((beam.tx == you.x_pos || beam.ty == you.y_pos)

[447.1326]

[154.12497]

        if ((beam.target.x == you.pos().x || beam.target.y == you.pos().y)

Replacement in crawl-ref/source/it_use3.cc at line 316 [49.2870456]

B:BD[447.1620] → [448.3828:3897]

                success = you_attack(mgrd[beam.tx][beam.ty], false);

[447.1620]

[49.2879844]

                success = you_attack(mgrd(beam.target), false);

Replacement in crawl-ref/source/it_use3.cc at line 327 [49.2870456]

B:BD[447.1839] → [448.3930:3995]

            success = you_attack(mgrd[beam.tx][beam.ty], false);

[447.1839]

[448.3995]

            success = you_attack(mgrd(beam.target), false);

Replacement in crawl-ref/source/it_use3.cc at line 332 [49.2870456]
B:BD[448.4036] → [448.4036:4082]
```
            int mid = mgrd[beam.tx][beam.ty];
```
[448.4036]
[448.4082]
```
            int mid = mgrd(beam.target);
```

Replacement in crawl-ref/source/it_use3.cc at line 335 [49.2870456]

B:BD[448.4132] → [448.4132:4195]

                monsters *mon = &menv[mgrd[beam.tx][beam.ty]];

[448.4132]

[448.4195]

                monsters *mon = &menv[mgrd(beam.target)];

Replacement in crawl-ref/source/it_use3.cc at line 342 [49.2870456]
B:BD[447.1849] → [447.1849:1900]
```
        you_attack(mgrd[beam.tx][beam.ty], false);
```
[447.1849]
[49.2880111]
```
        you_attack(mgrd(beam.target), false);
```

Replacement in crawl-ref/source/it_use3.cc at line 804 [49.2870456]

B:BD[49.2894654] → [49.2894654:2894846]

            beam.source_x = you.x_pos;
            beam.source_y = you.y_pos;
            beam.target_x = you.x_pos + random2(13) - 6;
            beam.target_y = you.y_pos + random2(13) - 6;

[49.2894654]

[49.2894846]

            beam.source = you.pos();
            beam.target = you.pos() + coord_def(random2(13)-6, random2(13)-6);

Replacement in crawl-ref/source/it_use3.cc at line 848 [49.2870456]
∅:D[130.4191] → [163.7497:7561]
B:BD[163.7497] → [163.7497:7561]
```
                   you.x_pos, you.y_pos, 20, 10 + random2(8) );
```
[130.4191]
[46.51364]
```
                   you.pos(), 20, 10 + random2(8) );
```

Replacement in crawl-ref/source/it_use3.cc at line 854 [49.2870456]

B:BD[49.2896431] → [163.7562:7663]

        big_cloud(CLOUD_POISON, KC_YOU,
                  you.x_pos, you.y_pos, 20, 7 + random2(5));

[49.2896431]

[46.51396]

        big_cloud(CLOUD_POISON, KC_YOU, you.pos(), 20, 7 + random2(5));

Replacement in crawl-ref/source/it_use3.cc at line 860 [49.2870456]

B:BD[49.2896617] → [163.7664:7745]

        big_cloud(CLOUD_COLD, KC_YOU, you.x_pos, you.y_pos, 20, 8 + random2(5));

[49.2896617]

[46.51428]

        big_cloud(CLOUD_COLD, KC_YOU, you.pos(), 20, 8 + random2(5));

Replacement in crawl-ref/source/it_use3.cc at line 876 [49.2870456]
B:BD[49.2897081] → [49.2897081:2897151]
```
        beam.target_x = you.x_pos;
        beam.target_y = you.y_pos;
```
[49.2897081]
[51.765900]
```
        beam.target = you.pos();
```

Replacement in crawl-ref/source/invent.cc at line 146 [49.2920632]

B:BD[449.4116] → [449.4116:4176]

    if (item->link == -1 || item->x != -1 || item->y != -1)

[449.4116]

[449.4176]

    if (item->link == -1 || item->pos.x != -1 || item->pos.y != -1)

Replacement in crawl-ref/source/invent.cc at line 698 [49.2920632]
B:BD[68.374867] → [68.374867:374902]
```
    return i.x == -1 && i.y == -1;
```
[68.374867]
[68.374902]
```
    return i.pos.x == -1 && i.pos.y == -1;
```
Replacement in crawl-ref/source/files.cc at line 1055 [49.3084589]
B:BD[394.16193] → [394.16193:16235]
```
        if (item.x == -1 && item.y == -1)
```
[394.16193]
[394.16235]
```
        if (item.pos.x == -1 && item.pos.y == -1)
```

Replacement in crawl-ref/source/files.cc at line 1219 [49.3084589]

B:BD[450.5473] → [450.5473:5505]

            you.moveto(45, 35);

[450.5473]

[49.3104402]

            you.moveto(coord_def(45, 35)); // FIXME: should be abyss_center

Insertion in crawl-ref/source/externs.h at line 83 [49.3270163]

[451.11308]

[281.81211]


struct coord_def
{
    int         x;
    int         y;
    explicit coord_def( int x_in = 0, int y_in = 0 ) : x(x_in), y(y_in) { }
    void set(int xi, int yi)
    {
        x = xi;
        y = yi;
    }
    void reset()
    {
        set(0, 0);
    }

Insertion in crawl-ref/source/externs.h at line 102 [49.3270163]

[281.81212]

    int distance_from(const coord_def &b) const;
    bool operator == (const coord_def &other) const
    {
        return x == other.x && y == other.y;
    }
    bool operator != (const coord_def &other) const
    {
        return !operator == (other);
    }
    bool operator <  (const coord_def &other) const
    {
        return (x < other.x) || (x == other.x && y < other.y);
    }
    const coord_def &operator += (const coord_def &other)
    {
        x += other.x;
        y += other.y;
        return (*this);
    }
    const coord_def &operator += (int offset)
    {
        x += offset;
        y += offset;
        return (*this);
    }
    const coord_def &operator -= (const coord_def &other)
    {
        x -= other.x;
        y -= other.y;
        return (*this);
    }
    const coord_def &operator -= (int offset)
    {
        x -= offset;
        y -= offset;
        return (*this);
    }
    const coord_def &operator /= (int div)
    {
        x /= div;
        y /= div;
        return (*this);
    }
    const coord_def &operator *= (int mul)
    {
        x *= mul;
        y *= mul;
        return (*this);
    }
    coord_def operator + (const coord_def &other) const
    {
        coord_def copy = *this;
        return (copy += other);
    }
    coord_def operator + (int other) const
    {
        coord_def copy = *this;
        return (copy += other);
    }
    coord_def operator - (const coord_def &other) const
    {
        coord_def copy = *this;
        return (copy -= other);
    }
    coord_def operator - (int other) const
    {
        coord_def copy = *this;
        return (copy -= other);
    }
    coord_def operator / (int div) const
    {
        coord_def copy = *this;
        return (copy /= div);
    }
    coord_def operator * (int mul) const
    {
        coord_def copy = *this;
        return (copy *= mul);
    }
    int abs() const
    {
        return (x * x + y * y);
    }
    int rdist() const
    {
        return (std::max(std::abs(x), std::abs(y)));
    }
    bool origin() const
    {
        return (!x && !y);
    }
};

Replacement in crawl-ref/source/externs.h at line 227 [49.3270163]

∅:D[150.6759] → [281.81341:81380]

∅:D[452.84000] → [281.81341:81380]

B:BD[281.81341] → [281.81341:81380]

    virtual coord_def pos() const = 0;

[150.6759]

[281.81380]

    virtual void moveto(const coord_def &c) = 0;
    virtual const coord_def& pos() const { return position; }
    virtual coord_def& pos() { return position; }

Deletion in crawl-ref/source/externs.h at line 381 [49.3270163]
∅:D[138.22190] → [68.440112:440115]
∅:D[281.82339] → [68.440112:440115]
∅:D[452.86361] → [68.440112:440115]
B:BD[68.440112] → [68.440112:440115]
∅:D[68.440115] → [49.3272011:3272012]
B:BD[49.3272011] → [49.3272011:3272012]
∅:D[68.440264] → [49.3272012:3272069]
B:BD[49.3272012] → [49.3272012:3272069]
```
};
struct coord_def
{
    int         x;
    int         y;
```
Replacement in crawl-ref/source/externs.h at line 382 [49.3270163]
B:BD[49.3272070] → [85.26553:26629]
```
    explicit coord_def( int x_in = 0, int y_in = 0 ) : x(x_in), y(y_in) { }
```
[49.3272070]
[110.145842]
```
    coord_def position;
};
```
Deletion in crawl-ref/source/externs.h at line 385 [49.3270163]
B:BD[110.145843] → [110.145843:145910]
B:BD[110.145910] → [85.26630:26679]
∅:D[85.26679] → [110.145910:145916]
B:BD[110.145910] → [110.145910:145916]
B:BD[110.145916] → [453.11307:11357]
B:BD[453.11357] → [150.6772:6773]
∅:D[150.6773] → [454.6481:6539]
B:BD[110.145921] → [454.6481:6539]
∅:D[454.6539] → [68.440319:440371]
B:BD[68.440319] → [68.440319:440371]
B:BD[68.440371] → [454.6540:6598]
∅:D[454.6598] → [85.26680:26717]
B:BD[68.440425] → [85.26680:26717]
∅:D[85.26717] → [287.19485:19492]
B:BD[68.440470] → [287.19485:19492]
B:BD[287.19492] → [454.6599:6657]
∅:D[454.6657] → [287.19546:19609]
B:BD[287.19546] → [287.19546:19609]
B:BD[287.19609] → [110.145922:145929]
B:BD[110.145929] → [454.6658:6722]
∅:D[454.6722] → [110.145989:146063]
B:BD[110.145989] → [110.145989:146063]
B:BD[110.146063] → [455.519:644]
B:BD[455.644] → [150.6774:6775]
∅:D[150.6775] → [454.6723:6787]
B:BD[110.146068] → [454.6723:6787]
∅:D[454.6787] → [110.146128:146172]
B:BD[110.146128] → [110.146128:146172]
B:BD[110.146172] → [455.645:770]
∅:D[455.770] → [151.12318:12434]
B:BD[110.146172] → [151.12318:12434]
B:BD[151.12434] → [305.7760:7876]
∅:D[305.7876] → [110.146172:146202]
∅:D[151.12434] → [110.146172:146202]
B:BD[110.146172] → [110.146172:146202]
B:BD[110.146202] → [150.6776:6777]
∅:D[150.6777] → [454.6788:6850]
B:BD[110.146207] → [454.6788:6850]
∅:D[454.6850] → [110.146265:146297]
B:BD[110.146265] → [110.146265:146297]
B:BD[110.146297] → [151.12435:12467]
∅:D[151.12467] → [68.440470:440476]
∅:D[287.19609] → [68.440470:440476]
∅:D[110.146343] → [68.440470:440476]
B:BD[68.440470] → [68.440470:440476]
B:BD[68.440476] → [110.146344:146345]
B:BD[110.146345] → [455.771:891]
∅:D[455.891] → [454.6851:6913]
B:BD[110.146345] → [454.6851:6913]
∅:D[454.6913] → [110.146403:146435]
B:BD[110.146403] → [110.146403:146435]
B:BD[110.146435] → [151.12468:12507]
B:BD[151.12507] → [455.892:1012]
∅:D[455.1012] → [151.12507:12616]
B:BD[151.12507] → [151.12507:12616]
∅:D[151.12616] → [454.6914:6921]
B:BD[110.146481] → [454.6914:6921]
B:BD[454.6921] → [305.7877:7992]
B:BD[305.7992] → [150.6778:6779]
∅:D[150.6779] → [454.6921:6979]
∅:D[305.7997] → [454.6921:6979]
B:BD[454.6921] → [454.6921:6979]
B:BD[454.6979] → [456.298:333]
B:BD[456.333] → [63.11393:11446]
∅:D[456.379] → [110.146481:146487]
∅:D[454.6979] → [110.146481:146487]
∅:D[63.11446] → [110.146481:146487]
B:BD[110.146481] → [110.146481:146487]
B:BD[110.146487] → [457.2112:2176]
∅:D[457.2176] → [49.3272140:3272143]
∅:D[110.146487] → [49.3272140:3272143]
∅:D[68.440476] → [49.3272140:3272143]
B:BD[49.3272140] → [49.3272140:3272143]
```
    void set(int xi, int yi)
    {
        x = xi;
        y = yi;
    }
    void reset()
    {
        set(0, 0);
    }
    int distance_from(const coord_def &b) const;
    bool operator == (const coord_def &other) const
    {
        return x == other.x && y == other.y;
    }
    bool operator != (const coord_def &other) const
    {
        return !operator == (other);
    }
    bool operator <  (const coord_def &other) const
    {
        return (x < other.x) || (x == other.x && y < other.y);
    }
    const coord_def &operator += (const coord_def &other)
    {
        x += other.x;
        y += other.y;
        return (*this);
    }
    const coord_def &operator += (int offset)
    {
        x += offset;
        y += offset;
        return (*this);
    }
    const coord_def &operator -= (const coord_def &other)
    {
        x -= other.x;
        y -= other.y;
        return (*this);
    }
    const coord_def &operator -= (int offset)
    {
        x -= offset;
        y -= offset;
        return (*this);
    }
    const coord_def &operator /= (int div)
    {
        x /= div;
        y /= div;
        return (*this);
    }
    const coord_def &operator *= (int mul)
    {
        x *= mul;
        y *= mul;
        return (*this);
    }
    coord_def operator + (const coord_def &other) const
    {
        coord_def copy = *this;
        return (copy += other);
    }
    coord_def operator + (int other) const
    {
        coord_def copy = *this;
        return (copy += other);
    }
    coord_def operator - (const coord_def &other) const
    {
        coord_def copy = *this;
        return (copy -= other);
    }
    coord_def operator - (int other) const
    {
        coord_def copy = *this;
        return (copy -= other);
    }
    coord_def operator / (int div) const
    {
        coord_def copy = *this;
        return (copy /= div);
    }
    coord_def operator * (int mul) const
    {
        coord_def copy = *this;
        return (copy *= mul);
    }
    int abs() const
    {
        return (x * x + y * y);
    }
    int rdist() const
    {
        return (std::max(std::abs(x), std::abs(y)));
    }
    bool origin() const
    {
        return (!x && !y);
    }
};
```
Replacement in crawl-ref/source/externs.h at line 398 [49.3270163]
B:BD[133.530] → [133.530:554]
```
    int dx;
    int dy;
```
[133.530]
[49.3274653]
```
    coord_def delta;
```

Replacement in crawl-ref/source/externs.h at line 423 [49.3270163]

B:BD[49.3275248] → [150.6797:6868]

∅:D[150.6868] → [49.3275320:3275391]

B:BD[49.3275320] → [49.3275320:3275391]

    short  x;          // x-location;         for inventory items = -1
    short  y;          // y-location;         for inventory items = -1

[49.3275248]

[49.3275391]

    coord_def pos;     // for inventory items == (-1, -1)

Replacement in crawl-ref/source/externs.h at line 437 [49.3270163]

B:BD[68.440717] → [51.896116:896185]

                 x(0), y(0), link(NON_ITEM), slot(0), orig_place(0),

[68.440717]

[458.1058]

                 pos(), link(NON_ITEM), slot(0), orig_place(0),

Replacement in crawl-ref/source/externs.h at line 478 [49.3270163]
B:BD[51.896341] → [51.896341:896355]
```
    int x, y;
```
[51.896341]
[51.896355]
```
    coord_def pos;
```
Replacement in crawl-ref/source/externs.h at line 601 [49.3270163]
B:BD[49.3276024] → [49.3276024:3276050]
```
  int x_pos;
  int y_pos;
```
[49.3276024]
[49.3276050]
```
  coord_def youpos;
```

Replacement in crawl-ref/source/externs.h at line 794 [49.3270163]

∅:D[150.7059] → [151.12617:12765]

B:BD[281.82555] → [151.12617:12765]

    // Low-level move the player to (x, y). Use these functions instead of
    // changing x_pos and y_pos directly.
    void moveto(int x, int y);

[150.7059]

[151.12765]

    // Low-level move the player. Use this instead of changing pos directly.

Deletion in crawl-ref/source/externs.h at line 830 [49.3270163]
∅:D[342.27974] → [281.82820:82847]
∅:D[452.86467] → [281.82820:82847]
B:BD[281.82820] → [281.82820:82847]
```
    coord_def pos() const;
```
Replacement in crawl-ref/source/externs.h at line 1044 [49.3270163]
∅:D[459.2119] → [49.3280593:3280691]
B:BD[49.3280593] → [49.3280593:3280691]
```
    unsigned char x;
    unsigned char y;
    unsigned char target_x;
    unsigned char target_y;
```
[459.2119]
[154.14000]
```
    coord_def target;
```
Insertion in crawl-ref/source/externs.h at line 1097 [49.3270163]
[283.24114]
[209.13577]
```
    
    void moveto(const coord_def& c);
```
Deletion in crawl-ref/source/externs.h at line 1155 [49.3270163]
∅:D[452.88459] → [281.83631:83658]
B:BD[281.83631] → [281.83631:83658]
B:BD[281.83658] → [305.7998:8032]
```
    coord_def pos() const;
    coord_def target_pos() const;
```
Replacement in crawl-ref/source/externs.h at line 1326 [49.3270163]
B:BD[49.3281190] → [163.7841:7883]
```
    int           x;
    int           y;
```
[49.3281190]
[130.5022]
```
    coord_def     pos;
```
Deletion in crawl-ref/source/externs.h at line 1339 [49.3270163]
∅:D[45.85976] → [61.43877:43930]
B:BD[460.803] → [61.43877:43930]
```
    coord_def pos() const { return coord_def(x,y); }
```
Replacement in crawl-ref/source/externs.h at line 1343 [49.3270163]
B:BD[49.3281330] → [49.3281330:3281384]
```
    unsigned char       x;
    unsigned char       y;
```
[49.3281330]
[49.3281384]
```
    coord_def           pos;
```
Deletion in crawl-ref/source/externs.h at line 1349 [49.3270163]
B:BD[49.3281524] → [61.43931:43984]
```
    coord_def pos() const { return coord_def(x,y); }
```
Replacement in crawl-ref/source/externs.h at line 1353 [49.3270163]
B:BD[49.3281549] → [49.3281549:3281603]
```
    unsigned char       x;
    unsigned char       y;
```
[49.3281549]
[67.7325]
```
    coord_def pos;
```
Deletion in crawl-ref/source/externs.h at line 1355 [49.3270163]
B:BD[67.7352] → [61.43985:44039]
```
    coord_def pos() const { return coord_def(x,y); }
```

Replacement in crawl-ref/source/effects.cc at line 1835 [49.3382105]

B:BD[154.14579] → [154.14579:14697]

        mon->patrol_point = (clear ? coord_def(0, 0)
                                   : coord_def(mon->x, mon->y));

[154.14579]

[154.14697]

        mon->patrol_point = (clear ? coord_def(0, 0) : mon->pos());

Replacement in crawl-ref/source/effects.cc at line 1997 [49.3382105]

B:BD[49.3427592] → [333.8278:8420]

        if (!targ.isValid || mgrd[targ.tx][targ.ty] == NON_MONSTER
            || !player_monster_visible(&env.mons[mgrd[targ.tx][targ.ty]]))

[49.3427592]

[49.3427660]

        if (!targ.isValid || mgrd(targ.target) == NON_MONSTER
            || !player_monster_visible(&env.mons[mgrd(targ.target)]))

Replacement in crawl-ref/source/effects.cc at line 2004 [49.3382105]
B:BD[49.3427737] → [49.3427737:3427782]
```
        mons_targd = mgrd[targ.tx][targ.ty];
```
[49.3427737]
[49.3427782]
```
        mons_targd = mgrd(targ.target);
```
Replacement in crawl-ref/source/effects.cc at line 2496 [49.3382105]
B:BD[461.13027] → [461.13027:13061]
```
                struct bolt boom;
```
[461.13027]
[462.17104]
```
                bolt boom;
```

Replacement in crawl-ref/source/effects.cc at line 2500 [49.3382105]

∅:D[462.17252] → [461.13202:13288]

B:BD[461.13202] → [461.13202:13288]

                boom.target_x = you.x_pos;
                boom.target_y = you.y_pos;

[462.17252]

[461.13288]

                boom.target   = you.pos();

Replacement in crawl-ref/source/effects.cc at line 2681 [49.3382105]

B:BD[72.5114] → [72.5114:5177]

∅:D[72.5177] → [463.3897:3960]

B:BD[463.3897] → [463.3897:3960]

         monster_index(mon), range, long_time, mon->x, mon->y,
         mon->foe, mon->target_x, mon->target_y, mon->flags );

[72.5114]

[72.5178]

         monster_index(mon), range, long_time, mon->pos().x, mon->pos().y,
         mon->foe, mon->target.x, mon->target.y, mon->flags );

Replacement in crawl-ref/source/effects.cc at line 2699 [49.3382105]

B:BD[463.4347] → [72.5244:5352]

            mon->target_x = 10 + random2( GXM - 10 );
            mon->target_y = 10 + random2( GYM - 10 );

[463.4347]

[463.4457]

            mon->target.set(10 + random2(GXM - 10), 10 + random2(GYM - 10));

Replacement in crawl-ref/source/effects.cc at line 2713 [49.3382105]

B:BD[463.4915] → [441.9054:9116]

        if (grid_distance(mon->pos(), mon->target_pos()) < 3)

[463.4915]

[463.4992]

        if (grid_distance(mon->pos(), mon->target) < 3)

Replacement in crawl-ref/source/effects.cc at line 2718 [49.3382105]
B:BD[464.4490] → [441.9117:9166]
```
            if (mon->pos() == mon->target_pos())
```
[464.4490]
[463.5184]
```
            if (mon->pos() == mon->target)
```

Replacement in crawl-ref/source/effects.cc at line 2723 [49.3382105]

∅:D[464.4556] → [463.5344:5438]

B:BD[463.5344] → [463.5344:5438]

                    mon->target_x = you.x_pos;
                    mon->target_y = you.y_pos;

[464.4556]

[463.5438]

                    mon->target = you.pos();

Replacement in crawl-ref/source/effects.cc at line 2728 [49.3382105]

∅:D[464.4633] → [463.5570:5680]

B:BD[463.5570] → [463.5570:5680]

                    mon->target_x += (random2(3) - 1);
                    mon->target_y += (random2(3) - 1);

[464.4633]

[463.5680]

                    mon->target.x += (random2(3) - 1);
                    mon->target.y += (random2(3) - 1);

Replacement in crawl-ref/source/effects.cc at line 2739 [49.3382105]
B:BD[463.5831] → [463.5831:5881]
```
            shift_monster( mon, mon->x, mon->y );
```
[463.5831]
[463.5881]
```
            shift_monster( mon, mon->pos() );
```

Replacement in crawl-ref/source/effects.cc at line 2742 [49.3382105]

B:BD[463.5904] → [463.5904:5979]

            mprf(MSGCH_DIAGNOSTICS, "shifted to (%d,%d)", mon->x, mon->y);

[463.5904]

[463.5979]

            mprf(MSGCH_DIAGNOSTICS, "shifted to (%d,%d)",
                 mon->pos().x, mon->pos().y);

Replacement in crawl-ref/source/effects.cc at line 2753 [49.3382105]
B:BD[463.6125] → [463.6125:6173]
```
        coord_def inc(mon->target_pos() - pos);
```
[463.6125]
[463.6173]
```
        coord_def inc(mon->target - pos);
```

Replacement in crawl-ref/source/effects.cc at line 2778 [49.3382105]

B:BD[463.6756] → [463.6756:6847]

    if (!shift_monster( mon, pos.x, pos.y ))
        shift_monster( mon, mon->x, mon->y );

[463.6756]

[463.6847]

    if (!shift_monster( mon, pos ))
        shift_monster( mon, mon->pos() );

Replacement in crawl-ref/source/effects.cc at line 2782 [49.3382105]

B:BD[463.6870] → [463.6870:6936]

    mprf(MSGCH_DIAGNOSTICS, "moved to (%d,%d)", mon->x, mon->y );

[463.6870]

[72.5544]

    mprf(MSGCH_DIAGNOSTICS, "moved to (%d,%d)", mon->pos().x, mon->pos().y );

Replacement in crawl-ref/source/effects.cc at line 2871 [49.3382105]

B:BD[465.4149] → [442.8130:8197]

static void _maybe_restart_fountain_flow(const int x, const int y,

[465.4149]

[442.8197]

static void _maybe_restart_fountain_flow(const coord_def& where,

Replacement in crawl-ref/source/effects.cc at line 2874 [49.3382105]
B:BD[465.4229] → [442.8256:8300]
```
     dungeon_feature_type grid = grd[x][y];
```
[465.4229]
[398.23888]
```
     dungeon_feature_type grid = grd(where);
```
Replacement in crawl-ref/source/effects.cc at line 2879 [49.3382105]
B:BD[442.8406] → [466.2650:2691]
```
     int t = 0;
     while (tries > t++)
```
[442.8406]
[465.4254]
```
     for ( int i = 0; i < tries; ++i )
```
Replacement in crawl-ref/source/effects.cc at line 2886 [49.3382105]
∅:D[467.10942] → [442.8490:8552]
B:BD[442.8490] → [442.8490:8552]
```
          grd[x][y] = static_cast<dungeon_feature_type> (grid
```
[467.10942]
[442.8552]
```
          grd(where) = static_cast<dungeon_feature_type> (grid
```

Replacement in crawl-ref/source/effects.cc at line 2889 [49.3382105]

B:BD[466.2693] → [467.10943:10990]

∅:D[467.10990] → [442.8700:8747]

B:BD[442.8700] → [442.8700:8747]

          if (is_terrain_seen(coord_def(x,y)))
              set_envmap_obj(x, y, grd[x][y]);

[466.2693]

[465.4554]

          if (is_terrain_seen(where))
              set_envmap_obj(where, grd(where));

Replacement in crawl-ref/source/effects.cc at line 2893 [49.3382105]

B:BD[467.11024] → [61.44278:44325]

∅:D[61.44325] → [465.4623:4674]

B:BD[465.4623] → [465.4623:4674]

          if (is_bloodcovered(coord_def(x,y)))
              env.map[x][y].property = FPROP_NONE;

[467.11024]

[466.2694]

          if (is_bloodcovered(where))
              env.map(where).property = FPROP_NONE;

Replacement in crawl-ref/source/effects.cc at line 2897 [49.3382105]

∅:D[467.11075] → [465.4738:4778]

B:BD[465.4738] → [465.4738:4778]

B:BD[465.4778] → [61.44326:44338]

∅:D[61.44338] → [118.23693:23738]

B:BD[465.4778] → [118.23693:23738]

∅:D[118.23738] → [465.4822:4839]

B:BD[465.4822] → [465.4822:4839]

B:BD[465.4839] → [61.44339:44548]

∅:D[61.44548] → [465.5042:5059]

B:BD[465.5042] → [465.5042:5059]

B:BD[465.5059] → [61.44549:44561]

∅:D[61.44561] → [442.8749:8767]

B:BD[442.8749] → [442.8749:8767]

          for (int i = -1; i <= 1; i++)
          {
               for (int j = -1; j <= 1; j++)
               {
                   if (is_bloodcovered(coord_def(x+i,y+j))
                       && one_chance_in(5))
                   {
                       env.map[x+i][y+j].property = FPROP_NONE;
                   }
               }
          }
          return;

[467.11075]

[465.5059]

          for ( adjacent_iterator ai(where); ai; ++ai )
              if (is_bloodcovered(*ai) && one_chance_in(5))
                  env.map(*ai).property = FPROP_NONE;
          break;

Deletion in crawl-ref/source/effects.cc at line 2916 [49.3382105]
B:BD[461.24861] → [461.24861:24878]
```
    int cx, cy;
```

Replacement in crawl-ref/source/effects.cc at line 2964 [49.3382105]

B:BD[461.26427] → [465.5283:5361]

        for (cx = 0; cx < GXM; cx++)
            for (cy = 0; cy < GYM; cy++)

[461.26427]

[461.26507]

        for ( rectangle_iterator ri(1); ri; ++ri )
        {
            if (grd(*ri) >= DNGN_DRY_FOUNTAIN_BLUE
                && grd(*ri) < DNGN_PERMADRY_FOUNTAIN)

Replacement in crawl-ref/source/effects.cc at line 2969 [49.3382105]

B:BD[461.26521] → [442.8768:8887]

∅:D[465.5542] → [461.26640:26658]

∅:D[442.8887] → [461.26640:26658]

B:BD[461.26640] → [461.26640:26658]

B:BD[461.26658] → [465.5543:5618]

∅:D[465.5618] → [461.27106:27124]

B:BD[461.27106] → [461.27106:27124]

                if (grd[cx][cy] >= DNGN_DRY_FOUNTAIN_BLUE
                    && grd[cx][cy] < DNGN_PERMADRY_FOUNTAIN)
                {
                    _maybe_restart_fountain_flow(cx, cy, fountain_checks);
                }

[461.26521]

[461.27124]

                _maybe_restart_fountain_flow(*ri, fountain_checks);

Insertion in crawl-ref/source/effects.cc at line 2971 [49.3382105]
[461.27138]
[461.27148]
```
        }
```

Replacement in crawl-ref/source/dungeon.h at line 316 [49.3428186]

∅:D[468.2725] → [54.2828:2963]

B:BD[54.2828] → [54.2828:2963]

bool place_specific_trap(int spec_x, int spec_y,  trap_type spec_type);
void place_spec_shop(int level_number, int shop_x, int shop_y,

[468.2725]

[54.2963]

bool place_specific_trap(const coord_def& where, trap_type spec_type);
void place_spec_shop(int level_number, const coord_def& where,

Replacement in crawl-ref/source/dungeon.h at line 327 [49.3428186]

∅:D[469.10826] → [470.410:468]

B:BD[470.410] → [470.410:468]

                       int monster_level, int vx, int vy,

[469.10826]

[471.4885]

                       int monster_level, const coord_def& where,

Replacement in crawl-ref/source/dungeon.h at line 348 [49.3428186]
B:BD[420.13390] → [420.13390:13438]
```
    int x1;
    int y1;
    int x2;
    int y2;
```
[420.13390]
[420.13438]
```
    
    coord_def tl;
    coord_def br;
```

Replacement in crawl-ref/source/dungeon.h at line 352 [49.3428186]

B:BD[420.13439] → [420.13439:13518]

    spec_room() : created(false), hooked_up(false), x1(0), y1(0), x2(0), y2(0)

[420.13439]

[420.13518]

    spec_room() : created(false), hooked_up(false), tl(), br()

Insertion in crawl-ref/source/dungeon.h at line 355 [49.3428186]
[420.13530]
[420.13530]
```
    coord_def random_spot() const;
```

Insertion in crawl-ref/source/dungeon.h at line 372 [49.3428186]

[420.14052]

inline int count_feature_in_box( const coord_def& p1, const coord_def& p2,
                          dungeon_feature_type feat )
{
    return count_feature_in_box(p1.x, p1.y, p2.x, p2.y, feat);
}

Insertion in crawl-ref/source/dungeon.cc at line 95 [49.3429798]

[456.568]

[49.3431404]

};
const struct coord_def OrthCompass[4] =
{
    coord_def(0, -1), coord_def(0, 1), coord_def(-1, 0), coord_def(1, 0)

Insertion in crawl-ref/source/dungeon.cc at line 101 [49.3429798]

[49.3431407]

[49.3431441]


// FIXME: maintaining previous behaviour, but why are we forbidding the
// last row and column?
coord_def spec_room::random_spot() const
{
    return coord_def( random_range(tl.x, br.x-1), random_range(tl.y, br.y-1) );
}

Insertion in crawl-ref/source/dungeon.cc at line 120 [49.3429798]

[472.6627]

static void _replace_area(const coord_def& p1, const coord_def& p2,
                          dungeon_feature_type replace,
                          dungeon_feature_type feature,
                          unsigned mmask = 0, bool needs_update = false);

Replacement in crawl-ref/source/dungeon.cc at line 127 [49.3429798]

B:BD[472.6797] → [473.3219:3293]

                          unsigned mmask = 0, bool needs_update = false);

[472.6797]

[472.6844]

                          unsigned mmask = 0, bool needs_update = false)
{
    _replace_area( coord_def(sx, sy), coord_def(ex, ey),
                   replace, feature, mmask, needs_update );
}

Replacement in crawl-ref/source/dungeon.cc at line 231 [49.3429798]

B:BD[472.12230] → [472.12230:12305]

                        int level_number, int vx, int vy, int altar_count,

[472.12230]

[472.12305]

                        int level_number, const coord_def& where,
                        int altar_count,

Replacement in crawl-ref/source/dungeon.cc at line 959 [49.3429798]

B:BD[474.2996] → [41.2684:2741]

        if (!is_valid_item(mitm[i]) || (mitm[i].x == 0))

[474.2996]

[474.3071]

        item_def& item(mitm[i]);
        if (!is_valid_item(item) || (item.pos.x == 0))

Deletion in crawl-ref/source/dungeon.cc at line 962 [49.3429798]
B:BD[474.3093] → [474.3093:3138]
```
        coord_def gc(mitm[i].x, mitm[i].y);
```
Replacement in crawl-ref/source/dungeon.cc at line 963 [49.3429798]
B:BD[474.3139] → [474.3139:3166]
```
        if (in_bounds(gc))
```
[474.3139]
[474.3166]
```
        if (in_bounds(item.pos))
```

Replacement in crawl-ref/source/dungeon.cc at line 965 [49.3429798]

B:BD[474.3176] → [474.3176:3225]

            dungeon_feature_type feat = grd(gc);

[474.3176]

[474.3225]

            dungeon_feature_type feat = grd(item.pos);

Replacement in crawl-ref/source/dungeon.cc at line 971 [49.3429798]

B:BD[474.3351] → [474.3351:3428]

                 "Item buggily placed in feature at (%d, %d).", gc.x, gc.y);

[474.3351]

[474.3428]

                 "Item buggily placed in feature at (%d, %d).",
                 item.pos.x, item.pos.y);

Replacement in crawl-ref/source/dungeon.cc at line 979 [49.3429798]

B:BD[474.3529] → [474.3529:3609]

                 "Item buggily placed out of bounds at (%d, %d).", gc.x, gc.y);

[474.3529]

[474.3609]

                 "Item buggily placed out of bounds at (%d, %d).",
                 item.pos.x, item.pos.y);

Replacement in crawl-ref/source/dungeon.cc at line 985 [49.3429798]

B:BD[474.3704] → [474.3704:3824]

        mitm[i].base_type = OBJ_UNASSIGNED;
        mitm[i].quantity = 0;
        mitm[i].x = 0;
        mitm[i].y = 0;

[474.3704]

[49.3441040]

        item.base_type = OBJ_UNASSIGNED;
        item.quantity = 0;
        item.pos.reset();

Replacement in crawl-ref/source/dungeon.cc at line 1000 [49.3429798]

∅:D[475.4683] → [83.4389:4469]

B:BD[49.3441184] → [83.4389:4469]

B:BD[83.4469] → [411.3349:3363]

∅:D[411.3363] → [476.12209:12265]

∅:D[83.4469] → [476.12209:12265]

B:BD[476.12209] → [476.12209:12265]

B:BD[476.12265] → [89.6339:6397]

        for (int x = 1; x < GXM; x++)
            for (int y = 1; y < GYM; y++)
            {
                if (grd[x][y] >= DNGN_STONE_STAIRS_UP_I
                    && grd[x][y] <= DNGN_ESCAPE_HATCH_UP)

[475.4683]

[475.4684]

        for ( rectangle_iterator ri(1); ri; ++ri )
        {
                if (grd(*ri) >= DNGN_STONE_STAIRS_UP_I
                    && grd(*ri) <= DNGN_ESCAPE_HATCH_UP)

Replacement in crawl-ref/source/dungeon.cc at line 1005 [49.3429798]

B:BD[475.4702] → [475.4702:4763]

B:BD[475.4763] → [477.3527:3549]

∅:D[477.3549] → [478.6191:6232]

B:BD[475.4763] → [478.6191:6232]

∅:D[478.6232] → [475.4803:4934]

∅:D[122.31224] → [475.4803:4934]

B:BD[475.4803] → [475.4803:4934]

B:BD[475.4934] → [477.3550:3572]

∅:D[477.3572] → [475.4934:4972]

B:BD[475.4934] → [475.4934:4972]

                    if (grd[x][y] == DNGN_STONE_STAIRS_UP_I)
                    {
                        env.markers.add(
                            new map_feature_marker(coord_def(x,y),
                                                   grd[x][y]));
                    }
                    grd[x][y] = exit;

[475.4702]

[475.4972]

                    if (grd(*ri) == DNGN_STONE_STAIRS_UP_I)
                        env.markers.add(new map_feature_marker(*ri, grd(*ri)));
                    grd(*ri) = exit;

Replacement in crawl-ref/source/dungeon.cc at line 1017 [49.3429798]

B:BD[49.3441912] → [83.4470:4550]

∅:D[83.4550] → [476.12549:12607]

B:BD[476.12549] → [476.12549:12607]

B:BD[476.12607] → [468.2862:2920]

∅:D[468.2920] → [89.6458:6476]

B:BD[89.6458] → [89.6458:6476]

B:BD[89.6476] → [468.2921:2965]

∅:D[468.2965] → [89.6530:6548]

B:BD[89.6530] → [89.6530:6548]

        for (int x = 1; x < GXM; x++)
            for (int y = 1; y < GYM; y++)
                if (grd[x][y] >= DNGN_STONE_STAIRS_DOWN_I
                    && grd[x][y] <= DNGN_ESCAPE_HATCH_UP)
                {
                    grd[x][y] = DNGN_FLOOR;
                }

[49.3441912]

[49.3442744]

        for (rectangle_iterator ri(1); ri; ++ri)
        {
            if (grd(*ri) >= DNGN_STONE_STAIRS_DOWN_I
                && grd(*ri) <= DNGN_ESCAPE_HATCH_UP)
            {
                grd(*ri) = DNGN_FLOOR;
            }
        }

Replacement in crawl-ref/source/dungeon.cc at line 1026 [49.3429798]

B:BD[49.3442750] → [468.2966:3047]

    else if (at_branch_bottom()
             && you.level_type == LEVEL_DUNGEON)

[49.3442750]

[49.3442962]

    else if (at_branch_bottom() && you.level_type == LEVEL_DUNGEON)

Replacement in crawl-ref/source/dungeon.cc at line 1029 [49.3429798]

∅:D[468.3122] → [83.4551:4589]

B:BD[49.3442968] → [83.4551:4589]

B:BD[49.3443012] → [83.4590:4632]

B:BD[49.3443064] → [49.3443064:3443122]

B:BD[49.3443122] → [468.3123:3183]

∅:D[468.3183] → [49.3443179:3443197]

∅:D[89.6607] → [49.3443179:3443197]

B:BD[49.3443179] → [49.3443179:3443197]

B:BD[49.3443197] → [468.3184:3238]

∅:D[468.3238] → [479.301:319]

B:BD[49.3443241] → [479.301:319]

        for (int x = 1; x < GXM; x++)
            for (int y = 1; y < GYM; y++)
                if (grd[x][y] >= DNGN_STONE_STAIRS_DOWN_I
                    && grd[x][y] <= DNGN_ESCAPE_HATCH_DOWN)
                {
                    grd[x][y] = DNGN_ESCAPE_HATCH_UP;
                }

[468.3122]

[479.343]

        for (rectangle_iterator ri(1); ri; ++ri)
        {
            if (grd(*ri) >= DNGN_STONE_STAIRS_DOWN_I
                && grd(*ri) <= DNGN_ESCAPE_HATCH_DOWN)
            {
                grd(*ri) = DNGN_ESCAPE_HATCH_UP;
            }
        }

Deletion in crawl-ref/source/dungeon.cc at line 1038 [49.3429798]
B:BD[479.349] → [468.3239:3240]
Replacement in crawl-ref/source/dungeon.cc at line 2453 [49.3429798]
∅:D[480.5310] → [89.8950:8998]
B:BD[49.3566032] → [89.8950:8998]
```
static bool _shaft_is_in_corridor(int x, int y)
```
[480.5310]
[89.8998]
```
static bool _shaft_is_in_corridor(const coord_def& c)
```

Replacement in crawl-ref/source/dungeon.cc at line 2455 [49.3429798]

B:BD[89.9000] → [480.5311:5363]

∅:D[480.5363] → [89.9051:9205]

B:BD[89.9051] → [89.9051:9205]

    // First check horizontal neighbouring squares.
    if ((!inside_level_bounds(x-1, y) || grd[x-1][y] < DNGN_SHALLOW_WATER)
        && (!inside_level_bounds(x+1, y) || grd[x+1][y] < DNGN_SHALLOW_WATER))

[89.9000]

[89.9205]

    const coord_def adjs[] = { coord_def(-1,0), coord_def(1,0),
                               coord_def(0,-1), coord_def(0,1) };
    
    for ( unsigned int i = 0; i < ARRAYSZ(adjs); ++i )

Replacement in crawl-ref/source/dungeon.cc at line 2460 [49.3429798]

B:BD[89.9211] → [162.13151:13174]

        return (true);

[89.9211]

[89.9232]

        const coord_def spot = c + adjs[i];
        if ( !inside_level_bounds(spot) || grd(spot) < DNGN_SHALLOW_WATER )
            return (true);

Deletion in crawl-ref/source/dungeon.cc at line 2464 [49.3429798]
B:BD[89.9238] → [140.13750:13751]
B:BD[140.13751] → [480.5364:5412]
∅:D[480.5412] → [89.9290:9450]
B:BD[89.9290] → [89.9290:9450]
B:BD[89.9450] → [162.13175:13198]
∅:D[162.13198] → [89.9471:9477]
B:BD[89.9471] → [89.9471:9477]
B:BD[89.9477] → [162.13199:13200]
B:BD[162.13200] → [142.6497:6523]
```
    // Now check vertical neighbouring squares.
    if ((!inside_level_bounds(x, y-1) || grd[x][y-1] < DNGN_SHALLOW_WATER)
        && (!inside_level_bounds(x, y+1) || grd[x][y+1] < DNGN_SHALLOW_WATER))
    {
        return (true);
    }
    // No corridor found.
```

Replacement in crawl-ref/source/dungeon.cc at line 2484 [49.3429798]

B:BD[49.3566302] → [362.23750:23834]

            env.trap[i].x = random2(GXM);
            env.trap[i].y = random2(GYM);

[49.3566302]

[49.3566406]

            env.trap[i].pos.x = random2(GXM);
            env.trap[i].pos.y = random2(GYM);

Replacement in crawl-ref/source/dungeon.cc at line 2487 [49.3429798]
B:BD[49.3566416] → [362.23835:23898]
```
        while (grd[env.trap[i].x][env.trap[i].y] != DNGN_FLOOR
```
[49.3566416]
[362.23898]
```
        while (grd(env.trap[i].pos) != DNGN_FLOOR
```

Replacement in crawl-ref/source/dungeon.cc at line 2499 [49.3429798]

B:BD[89.9658] → [89.9658:9729]

            if ( _shaft_is_in_corridor(env.trap[i].x, env.trap[i].y) )

[89.9658]

[89.9729]

            if ( _shaft_is_in_corridor(env.trap[i].pos) )

Replacement in crawl-ref/source/dungeon.cc at line 2510 [49.3429798]

B:BD[49.3567411] → [49.3567411:3567479]

        grd[env.trap[i].x][env.trap[i].y] = DNGN_UNDISCOVERED_TRAP;

[51.963883]

[162.13229]

        grd(env.trap[i].pos) = DNGN_UNDISCOVERED_TRAP;

Replacement in crawl-ref/source/dungeon.cc at line 3174 [49.3429798]

B:BD[49.3584078] → [49.3584078:3584182]

    int bkout = 0;
    int cx = 0, cy = 0;
    int sx = 0, sy = 0;
    int dx = 0, dy = 0;
    int i,j;

[49.3584078]

[49.3584182]

    coord_def c, delta;
    int i = 0;

Deletion in crawl-ref/source/dungeon.cc at line 3179 [49.3429798]
B:BD[49.3584279] → [49.3584279:3584328]
```
        return;
  grolko:
    if (bkout > 100)
```
Replacement in crawl-ref/source/dungeon.cc at line 3181 [49.3429798]
B:BD[49.3584345] → [49.3584345:3584369]
```
    switch (random2(4))
```
[49.3584345]
[49.3584369]
```
    bool is_ok = false;
    for ( int tries = 0; tries < 100 && !is_ok; ++tries )
```

Replacement in crawl-ref/source/dungeon.cc at line 3184 [49.3429798]

B:BD[49.3584375] → [49.3584375:3585024]

    case 0:
        // go up from north edge
        cx = sr.x1 + (random2(sr.x2 - sr.x1));
        cy = sr.y1;
        dx = 0;
        dy = -1;
        break;
    case 1:
        // go down from south edge
        cx = sr.x1 + (random2(sr.x2 - sr.x1));
        cy = sr.y2;
        dx = 0;
        dy = 1;
        break;
    case 2:
        // go left from west edge
        cy = sr.y1 + (random2(sr.y2 - sr.y1));
        cx = sr.x1;
        dx = -1;
        dy = 0;
        break;
    case 3:
        // go right from east edge
        cy = sr.y1 + (random2(sr.y2 - sr.y1));
        cx = sr.x2;
        dx = 1;
        dy = 0;
        break;
    }

[49.3584375]

[49.3585024]

        is_ok = true;

Replacement in crawl-ref/source/dungeon.cc at line 3186 [49.3429798]

B:BD[49.3585025] → [49.3585025:3585051]

    sx = cx;
    sy = cy;

[49.3585025]

[49.3585051]

        // Set direction.
        switch (random2(4))
        {
        case 0:
            // go up from north edge
            c.set( random_range(sr.tl.x, sr.br.x - 1), sr.tl.y );
            delta.set(0, -1);
            break;
        case 1:
            // go down from south edge
            c.set( random_range(sr.tl.x, sr.br.x - 1), sr.br.y );
            delta.set(0,  1);
            break;
        case 2:
            // go left from west edge
            c.set( sr.tl.x, random_range(sr.tl.y, sr.br.y - 1) );
            delta.set(-1, 0);
            break;
        case 3:
            // go right from east edge
            c.set( sr.br.x, random_range(sr.tl.y, sr.br.y - 1) );
            delta.set( 1, 0);
            break;
        }

Replacement in crawl-ref/source/dungeon.cc at line 3211 [49.3429798]
B:BD[49.3585052] → [49.3585052:3585124]
```
    for (i = 0; i < 100; i++)
    {
        sx += dx;
        sy += dy;
```
[49.3585052]
[49.3585124]
```
        coord_def s = c;
```

Replacement in crawl-ref/source/dungeon.cc at line 3213 [49.3429798]

B:BD[49.3585125] → [480.6733:6793]

∅:D[480.6793] → [190.1888:1920]

B:BD[49.3585184] → [190.1888:1920]

        // Quit if we run off the map before finding floor.
        if (!in_bounds(sx, sy))

[49.3585125]

[49.3585250]

        // Note that we need to remember the value of i when we break out.
        for (i = 0; i < 100; i++)

Replacement in crawl-ref/source/dungeon.cc at line 3216 [49.3429798]
B:BD[49.3585260] → [49.3585260:3585316]
```
            bkout++;
            goto grolko;
        }
```
[49.3585260]
[49.3585316]
```
            s += delta;
```

Replacement in crawl-ref/source/dungeon.cc at line 3218 [49.3429798]

B:BD[49.3585317] → [49.3585317:3585636]

        // look around for floor
        if (i > 0)
        {
            if (grd[sx + 1][sy] == DNGN_FLOOR)
                break;
            if (grd[sx][sy + 1] == DNGN_FLOOR)
                break;
            if (grd[sx - 1][sy] == DNGN_FLOOR)
                break;
            if (grd[sx][sy - 1] == DNGN_FLOOR)

[49.3585317]

[49.3585636]

            // Quit if we run off the map before finding floor.
            if (!in_bounds(s))
            {
                is_ok = false;

Insertion in crawl-ref/source/dungeon.cc at line 3223 [49.3429798]

[49.3585659]

            }
            if (i > 0)
            {
                // look around for floor
                bool found_floor = false;
                for ( int j = 0; j < 4; ++j )
                {
                    const coord_def spot = s + OrthCompass[j];
                    if ( !in_bounds(spot) )
                        is_ok = false;
                    else if ( grd(spot) == DNGN_FLOOR )
                        found_floor = true;
                }
                if ( found_floor )
                    break;
            }

Replacement in crawl-ref/source/dungeon.cc at line 3244 [49.3429798]
B:BD[49.3585676] → [49.3585676:3585702]
```
    sx = cx;
    sy = cy;
```
[49.3585676]
[49.3585702]
```
    if ( !is_ok )
        return;
```
Replacement in crawl-ref/source/dungeon.cc at line 3247 [49.3429798]
B:BD[49.3585703] → [49.3585703:3585735]
```
    for (j = 0; j < i + 2; j++)
```
[49.3585703]
[49.3585735]
```
    coord_def s = c;
    for (int j = 0; j < i + 2; j++)
```

Replacement in crawl-ref/source/dungeon.cc at line 3251 [49.3429798]

B:BD[49.3585741] → [49.3585741:3585839]

        if (grd[sx][sy] == DNGN_BUILDER_SPECIAL_WALL)
            grd[sx][sy] = DNGN_CLOSED_DOOR;

[49.3585741]

[49.3585839]

        if (grd(s) == DNGN_BUILDER_SPECIAL_WALL)
            grd(s) = DNGN_CLOSED_DOOR;

Replacement in crawl-ref/source/dungeon.cc at line 3254 [49.3429798]

B:BD[49.3585840] → [230.4123:4181]

∅:D[230.4181] → [49.3585900:3585951]

B:BD[49.3585900] → [49.3585900:3585951]

        if (j > 0 && grd[sx + dx][sy + dy] > DNGN_MINWALL
            && grd[sx + dx][sy + dy] < DNGN_FLOOR)

[49.3585840]

[89.11452]

        if (j > 0
            && grd(s + delta) > DNGN_MINWALL
            && grd(s + delta) < DNGN_FLOOR)

Replacement in crawl-ref/source/dungeon.cc at line 3258 [49.3429798]
∅:D[89.11462] → [49.3585951:3586005]
B:BD[49.3585951] → [49.3585951:3586005]
```
            grd[sx][sy] = DNGN_BUILDER_SPECIAL_FLOOR;
```
[89.11462]
[89.11463]
```
            grd(s) = DNGN_BUILDER_SPECIAL_FLOOR;
```

Replacement in crawl-ref/source/dungeon.cc at line 3261 [49.3429798]

B:BD[49.3586006] → [49.3586006:3586103]

        if (grd[sx][sy] == DNGN_ROCK_WALL)
            grd[sx][sy] = DNGN_BUILDER_SPECIAL_FLOOR;

[49.3586006]

[49.3586103]

        if (grd(s) == DNGN_ROCK_WALL)
            grd(s) = DNGN_BUILDER_SPECIAL_FLOOR;

Replacement in crawl-ref/source/dungeon.cc at line 3264 [49.3429798]
B:BD[49.3586104] → [49.3586104:3586140]
```
        sx += dx;
        sy += dy;
```
[49.3586104]
[49.3586140]
```
        s += delta;
```
Replacement in crawl-ref/source/dungeon.cc at line 3268 [49.3429798]
B:BD[49.3586172] → [49.3586172:3586221]
```
}                               // end specr_2()
```
[49.3586172]
[51.964793]
```
}
```

Replacement in crawl-ref/source/dungeon.cc at line 3274 [49.3429798]

B:BD[472.26865] → [371.48444:48522]

                               monster_type lord_type, int lordx, int lordy )

[472.26865]

[51.965135]

                               monster_type lord_type, const coord_def& lordpos)

Replacement in crawl-ref/source/dungeon.cc at line 3276 [49.3429798]
B:BD[51.965137] → [51.965137:965154]
```
    int i, x, y;
```
[51.965137]
[51.965154]
```
    int i;
```
Replacement in crawl-ref/source/dungeon.cc at line 3314 [49.3429798]
B:BD[371.48613] → [154.16218:16266]
```
        mg.pos       = coord_def(lordx, lordy);
```
[371.48613]
[314.12548]
```
        mg.pos       = lordpos;
```

Replacement in crawl-ref/source/dungeon.cc at line 3316 [49.3429798]

∅:D[314.12549] → [371.48664:48756]

B:BD[371.48664] → [371.48664:48756]

        mons_place(
            mgen_data::sleeper_at(lord_type, coord_def(lordx, lordy)));

[314.12549]

[371.48756]

        mons_place(mgen_data::sleeper_at(lord_type, lordpos));

Replacement in crawl-ref/source/dungeon.cc at line 3320 [49.3429798]
B:BD[480.6982] → [481.3392:3429]
```
    for (x = sr.x1; x <= sr.x2; ++x)
```
[480.6982]
[481.3429]
```
    for ( rectangle_iterator ri(sr.tl, sr.br); ri; ++ri )
```

Replacement in crawl-ref/source/dungeon.cc at line 3322 [49.3429798]

B:BD[481.3435] → [481.3435:3476]

∅:D[481.3476] → [51.966424:966434]

B:BD[51.966424] → [51.966424:966434]

B:BD[51.966434] → [480.6983:7059]

∅:D[480.7059] → [51.966509:966578]

B:BD[51.966509] → [51.966509:966578]

        for (y = sr.y1; y <= sr.y2; ++y)
        {
            // Avoid the boss (or anyone else we may have dropped already).
            if (mgrd[x][y] != NON_MONSTER)
                continue;

[481.3435]

[51.966578]

        // Avoid the boss (or anyone else we may have dropped already).
        if (mgrd(*ri) != NON_MONSTER)
            continue;

Replacement in crawl-ref/source/dungeon.cc at line 3326 [49.3429798]
B:BD[51.966579] → [51.966579:966629]
```
            const int roll = random2( die_size );
```
[51.966579]
[51.966629]
```
        const int roll = random2( die_size );
```

Replacement in crawl-ref/source/dungeon.cc at line 3328 [49.3429798]

B:BD[51.966630] → [482.3811:3861]

∅:D[482.3861] → [51.966679:966739]

B:BD[51.966679] → [51.966679:966739]

            // Density skip (no need to iterate).
            if (roll >= rare_sum)
                continue;

[51.966630]

[49.3586221]

        // Density skip (no need to iterate).
        if (roll >= rare_sum)
            continue;

Replacement in crawl-ref/source/dungeon.cc at line 3332 [49.3429798]

B:BD[49.3586222] → [483.2753:2824]

B:BD[483.2824] → [481.3477:3521]

            // Run through the cumulative chances and place a monster.
            for (i = 0; i < num_types; ++i)

[49.3586222]

[481.3521]

        // Run through the cumulative chances and place a monster.
        for (i = 0; i < num_types; ++i)
        {
            if (roll < pit_list[i].rare)

Replacement in crawl-ref/source/dungeon.cc at line 3337 [49.3429798]

∅:D[481.3535] → [51.966869:966932]

B:BD[51.966869] → [51.966869:966932]

B:BD[51.966932] → [371.48763:48795]

B:BD[371.48795] → [481.3536:3665]

∅:D[481.3665] → [51.967048:967093]

∅:D[154.16398] → [51.967048:967093]

∅:D[371.48935] → [51.967048:967093]

B:BD[51.967048] → [51.967048:967093]

                if (roll < pit_list[i].rare)
                {
                    mons_place(
                        mgen_data::sleeper_at(pit_list[i].type,
                                              coord_def(x, y)));
                    break;
                }

[481.3535]

[481.3666]

                mons_place(
                    mgen_data::sleeper_at(pit_list[i].type, *ri));
                break;

Deletion in crawl-ref/source/dungeon.cc at line 3350 [49.3429798]
B:BD[49.3586372] → [49.3586372:3586386]
```
    int x, y;
```
Deletion in crawl-ref/source/dungeon.cc at line 3353 [49.3429798]
B:BD[49.3586529] → [480.7133:7196]
```
    int temp_rand = 0;      // probability determination {dlb}
```
Replacement in crawl-ref/source/dungeon.cc at line 3356 [49.3429798]
B:BD[49.3586656] → [49.3586656:3586687]
```
    char lordx = 0, lordy = 0;
```
[49.3586656]
[49.3586687]
```
    coord_def lordpos;
```

Replacement in crawl-ref/source/dungeon.cc at line 3372 [49.3429798]

B:BD[49.3587199] → [49.3587199:3587299]

    sr.x1 = room_x1 + 1;
    sr.x2 = room_x2 - 1;
    sr.y1 = room_y1 + 1;
    sr.y2 = room_y2 - 1;

[49.3587199]

[49.3587299]

    sr.tl.set(room_x1 + 1, room_y1 + 1);
    sr.br.set(room_x2 - 1, room_y2 - 1);

Replacement in crawl-ref/source/dungeon.cc at line 3445 [49.3429798]

∅:D[480.7951] → [49.3589290:3589331]

B:BD[49.3589290] → [49.3589290:3589331]

B:BD[49.3589341] → [49.3589341:3589469]

B:BD[49.3589469] → [371.49004:49032]

B:BD[371.49032] → [154.16399:16530]

∅:D[154.16530] → [49.3589585:3589599]

∅:D[371.49167] → [49.3589585:3589599]

B:BD[49.3589585] → [49.3589585:3589599]

        for (x = sr.x1; x <= sr.x2; x++)
            for (y = sr.y1; y <= sr.y2; y++)
            {
                if (one_chance_in(4))
                    continue;
                mons_place(
                    mgen_data::sleeper_at( mons_alloc[random2(10)],
                                           coord_def(x, y) ));
            }

[480.7951]

[140.14194]

        for (rectangle_iterator ri(sr.tl, sr.br); ri; ++ri)
            if (!one_chance_in(4))
                mons_place(mgen_data::sleeper_at(mons_alloc[random2(10)], *ri));

Replacement in crawl-ref/source/dungeon.cc at line 3452 [49.3429798]

B:BD[49.3589653] → [49.3589653:3589749]

        lordx = sr.x1 + random2(sr.x2 - sr.x1);
        lordy = sr.y1 + random2(sr.y2 - sr.y1);

[49.3589653]

[49.3589749]

        lordpos = sr.random_spot();

Replacement in crawl-ref/source/dungeon.cc at line 3468 [49.3429798]

∅:D[480.8231] → [49.3590353:3590394]

B:BD[49.3590353] → [49.3590353:3590394]

B:BD[49.3590404] → [49.3590404:3590531]

        for (x = sr.x1; x <= sr.x2; x++)
            for (y = sr.y1; y <= sr.y2; y++)
            {
                if (one_chance_in(4))
                    continue;

[480.8231]

[49.3590531]

        for ( rectangle_iterator ri(sr.tl, sr.br); ri; ++ri )
            if ( *ri != lordpos && !one_chance_in(4) )
                mons_place(mgen_data::sleeper_at(mons_alloc[random2(10)], *ri));

Deletion in crawl-ref/source/dungeon.cc at line 3472 [49.3429798]

B:BD[49.3590532] → [480.8232:8282]

∅:D[480.8282] → [49.3590582:3590659]

B:BD[49.3590582] → [49.3590582:3590659]

B:BD[49.3590659] → [371.49168:49196]

B:BD[371.49196] → [154.16531:16662]

∅:D[154.16662] → [49.3590774:3590788]

∅:D[371.49333] → [49.3590774:3590788]

B:BD[49.3590774] → [49.3590774:3590788]

B:BD[49.3590798] → [49.3590798:3590799]

                // We'll put the boss down later.
                if (x == lordx && y == lordy)
                    continue;
                mons_place(
                    mgen_data::sleeper_at( mons_alloc[random2(10)],
                                           coord_def(x, y) ));
            }

Replacement in crawl-ref/source/dungeon.cc at line 3473 [49.3429798]

∅:D[480.8321] → [371.49334:49469]

B:BD[49.3590836] → [371.49334:49469]

        mons_place(
            mgen_data::sleeper_at( MONS_BIG_KOBOLD,
                                   coord_def(lordx, lordy) ));

[480.8321]

[49.3590916]

        mons_place(mgen_data::sleeper_at(MONS_BIG_KOBOLD, lordpos));

Replacement in crawl-ref/source/dungeon.cc at line 3480 [49.3429798]

B:BD[49.3591106] → [49.3591106:3591147]

B:BD[49.3591157] → [49.3591157:3591257]

        for (x = sr.x1; x <= sr.x2; x++)
            for (y = sr.y1; y <= sr.y2; y++)
            {
                temp_rand = random2(11);

[49.3591106]

[49.3591257]

        for ( rectangle_iterator ri(sr.tl, sr.br); ri; ++ri )
        {
            const int temp_rand = random2(11);

Replacement in crawl-ref/source/dungeon.cc at line 3484 [49.3429798]

B:BD[49.3591258] → [49.3591258:3591951]

                obj_type = ((temp_rand > 8) ? OBJ_WEAPONS :       // 2 in 11
                            (temp_rand > 6) ? OBJ_ARMOUR :        // 2 in 11
                            (temp_rand > 5) ? OBJ_MISSILES :      // 1 in 11
                            (temp_rand > 4) ? OBJ_WANDS :         // 1 in 11
                            (temp_rand > 3) ? OBJ_SCROLLS :       // 1 in 11
                            (temp_rand > 2) ? OBJ_JEWELLERY :     // 1 in 11
                            (temp_rand > 1) ? OBJ_BOOKS :         // 1 in 11
                            (temp_rand > 0) ? OBJ_STAVES          // 1 in 11
                                            : OBJ_POTIONS);       // 1 in 11

[49.3591258]

[49.3591951]

            obj_type = ((temp_rand > 8) ? OBJ_WEAPONS :       // 2 in 11
                        (temp_rand > 6) ? OBJ_ARMOUR :        // 2 in 11
                        (temp_rand > 5) ? OBJ_MISSILES :      // 1 in 11
                        (temp_rand > 4) ? OBJ_WANDS :         // 1 in 11
                        (temp_rand > 3) ? OBJ_SCROLLS :       // 1 in 11
                        (temp_rand > 2) ? OBJ_JEWELLERY :     // 1 in 11
                        (temp_rand > 1) ? OBJ_BOOKS :         // 1 in 11
                        (temp_rand > 0) ? OBJ_STAVES          // 1 in 11
                        : OBJ_POTIONS);       // 1 in 11

Replacement in crawl-ref/source/dungeon.cc at line 3494 [49.3429798]

B:BD[49.3591952] → [49.3591952:3592022]

B:BD[49.3592022] → [46.53724:53805]

                thing_created = items( 1, obj_type, OBJ_RANDOM, true,
                                       level_number * 3, MAKE_ITEM_RANDOM_RACE);

[49.3591952]

[49.3592086]

            thing_created = items( 1, obj_type, OBJ_RANDOM, true,
                                   level_number * 3, MAKE_ITEM_RANDOM_RACE);

Replacement in crawl-ref/source/dungeon.cc at line 3497 [49.3429798]

B:BD[49.3592087] → [49.3592087:3592278]

                if (thing_created != NON_ITEM)
                {
                    mitm[thing_created].x = x;
                    mitm[thing_created].y = y;
                }
            }

[49.3592087]

[49.3592288]

            if (thing_created != NON_ITEM)
                mitm[thing_created].pos = *ri;
        }

Replacement in crawl-ref/source/dungeon.cc at line 3504 [49.3429798]

B:BD[371.49490] → [371.49490:49621]

B:BD[371.49621] → [154.16726:16821]

            mgen_data::sleeper_at(
                MONS_GUARDIAN_NAGA,
                coord_def(sr.x1 + random2( sr.x2 - sr.x1 ),
                          sr.y1 + random2( sr.y2 - sr.y1 )),
                MG_PATROLLING ));

[371.49490]

[49.3592501]

            mgen_data::sleeper_at( MONS_GUARDIAN_NAGA, sr.random_spot(),
                                   MG_PATROLLING ));

Replacement in crawl-ref/source/dungeon.cc at line 3525 [49.3429798]

B:BD[49.3592779] → [49.3592779:3592792]

    int x,y;

[49.3592768]

[49.3592792]

    for ( rectangle_iterator ri(sr.tl, sr.br); ri; ++ri )
    {
        if (coinflip())
            continue;
        
        const int i = get_item_slot();
        if (i == NON_ITEM)
            continue;

Replacement in crawl-ref/source/dungeon.cc at line 3534 [49.3429798]

B:BD[49.3592793] → [49.3592793:3592830]

B:BD[49.3592836] → [49.3592836:3592942]

B:BD[49.3592942] → [484.3133:3176]

∅:D[484.3176] → [49.3592975:3593006]

B:BD[49.3592975] → [49.3592975:3593006]

B:BD[49.3593006] → [484.3177:3203]

∅:D[484.3203] → [49.3593042:3593311]

B:BD[49.3593042] → [49.3593042:3593311]

    for (x = sr.x1; x <= sr.x2; x++)
        for (y = sr.y1; y <= sr.y2; y++)
        {
            if (coinflip())
                continue;
            const int i = get_item_slot();
            if (i == NON_ITEM)
                continue;
            mitm[i].quantity = 1;
            mitm[i].base_type = OBJ_FOOD;
            mitm[i].sub_type = (one_chance_in(25) ? FOOD_ROYAL_JELLY
                                                  : FOOD_HONEYCOMB);
            mitm[i].x = x;
            mitm[i].y = y;

[49.3592793]

[49.3593311]

        item_def& item(mitm[i]);
        
        item.quantity = 1;
        item.base_type = OBJ_FOOD;
        item.sub_type = (one_chance_in(25) ? FOOD_ROYAL_JELLY : FOOD_HONEYCOMB);
        item.pos = *ri;
        item_colour( item );
    }

Replacement in crawl-ref/source/dungeon.cc at line 3543 [49.3429798]
B:BD[49.3593312] → [49.3593312:3593358]
```
            item_colour( mitm[i] );
        }
```
[49.3593312]
[49.3593364]
```
    const coord_def queenpos(sr.random_spot());
```
Deletion in crawl-ref/source/dungeon.cc at line 3545 [49.3429798]
B:BD[49.3593366] → [484.3204:3314]
∅:D[484.3314] → [49.3593482:3593483]
B:BD[49.3593482] → [49.3593482:3593483]
```
    const int queenx = sr.x1 + random2(sr.x2 - sr.x1);
    const int queeny = sr.y1 + random2(sr.y2 - sr.y1);
```

Replacement in crawl-ref/source/dungeon.cc at line 3546 [49.3429798]

∅:D[482.3941] → [49.3593483:3593520]

B:BD[49.3593483] → [49.3593483:3593520]

B:BD[49.3593526] → [49.3593526:3593647]

    for (x = sr.x1; x <= sr.x2; x++)
        for (y = sr.y1; y <= sr.y2; y++)
        {
            if (x == queenx && y == queeny)
                continue;

[482.3941]

[49.3593647]

    for ( rectangle_iterator ri(sr.tl, sr.br); ri; ++ri )
    {
        if (*ri == queenpos)
            continue;

Replacement in crawl-ref/source/dungeon.cc at line 3551 [49.3429798]

B:BD[49.3593648] → [480.8496:8543]

∅:D[480.8543] → [49.3593695:3593696]

B:BD[49.3593695] → [49.3593695:3593696]

B:BD[49.3593696] → [371.49686:49749]

B:BD[371.49749] → [154.16822:16939]

B:BD[154.16939] → [482.3942:4016]

∅:D[482.4016] → [49.3593881:3593891]

∅:D[371.49888] → [49.3593881:3593891]

∅:D[51.967492] → [49.3593881:3593891]

B:BD[49.3593881] → [49.3593881:3593891]

B:BD[49.3593897] → [49.3593897:3593898]

B:BD[49.3593898] → [371.49889:49964]

B:BD[371.49964] → [154.16940:16980]

B:BD[154.16980] → [482.4017:4046]

            // The hive is chock full of bees!
            mons_place(
                mgen_data::sleeper_at(
                    one_chance_in(7) ? MONS_KILLER_BEE_LARVA
                                     : MONS_KILLER_BEE,
                    coord_def(x, y),
                    MG_PATROLLING));
        }
    mons_place(
        mgen_data::sleeper_at(
            MONS_QUEEN_BEE,
            coord_def(queenx, queeny ),
            MG_PATROLLING));

[49.3593648]

[371.50006]

        // The hive is chock full of bees!
        
        mons_place(
            mgen_data::sleeper_at(
                one_chance_in(7) ? MONS_KILLER_BEE_LARVA
                                 : MONS_KILLER_BEE,
                *ri, MG_PATROLLING));
    }
    
    mons_place(mgen_data::sleeper_at(MONS_QUEEN_BEE, queenpos, MG_PATROLLING));

Replacement in crawl-ref/source/dungeon.cc at line 3657 [49.3429798]

B:BD[472.27596] → [472.27596:27664]

                                  int &v1x, int &v1y, bool clobber)

[472.27596]

[485.1925]

                                  coord_def& v1, bool clobber)

Replacement in crawl-ref/source/dungeon.cc at line 3666 [49.3429798]

B:BD[485.2217] → [457.3469:3603]

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

[485.2217]

[485.2350]

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

Replacement in crawl-ref/source/dungeon.cc at line 3669 [49.3429798]

B:BD[485.2351] → [472.27665:27729]

        if (!_safe_minivault_place( v1x, v1y, place, clobber ))

[485.2351]

[485.2405]

        if (!_safe_minivault_place( v1.x, v1.y, place, clobber ))

Replacement in crawl-ref/source/dungeon.cc at line 3672 [49.3429798]

B:BD[485.2428] → [472.27730:27787]

        if (_connected_minivault_place(v1x, v1y, place))

[485.2428]

[485.2484]

        if (_connected_minivault_place(v1.x, v1.y, place))

Replacement in crawl-ref/source/dungeon.cc at line 3700 [49.3429798]
B:BD[49.3595210] → [49.3595210:3595228]
```
    int v1x, v1y;
```
[486.4618]
[49.3596571]
```
    coord_def v1;
```
Replacement in crawl-ref/source/dungeon.cc at line 3707 [49.3429798]
B:BD[457.3783] → [457.3783:3823]
```
        v1x = tl.x;
        v1y = tl.y;
```
[457.3783]
[487.1667]
```
        v1 = tl;
```

Replacement in crawl-ref/source/dungeon.cc at line 3709 [49.3429798]

B:BD[487.1673] → [472.28047:28110]

    else if (!_find_minivault_place(place, v1x, v1y, clobber))

[487.1673]

[485.2653]

    else if (!_find_minivault_place(place, v1, clobber))

Replacement in crawl-ref/source/dungeon.cc at line 3712 [49.3429798]
B:BD[49.3596611] → [457.3824:3861]
```
    place.pos = coord_def(v1x, v1y);
```
[49.3596611]
[431.18846]
```
    place.pos = v1;
```

Replacement in crawl-ref/source/dungeon.cc at line 3728 [49.3429798]

∅:D[480.9128] → [457.3862:3916]

B:BD[49.3596909] → [457.3862:3916]

B:BD[49.3596955] → [457.3917:3975]

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

[480.9128]

[49.3596999]

    for (rectangle_iterator ri(v1, v1 + place.size); ri; ++ri)
    {
        const coord_def vdelta = *ri - v1;
        // FIXME: why the y and x swap?
        const int feat = vgrid[vdelta.y][vdelta.x];
        if (feat == ' ')
            continue;
        const dungeon_feature_type oldgrid = grd(*ri);
        altar_count = _vault_grid( place,
                                   level_number, *ri,
                                   altar_count,
                                   acq_item_class,
                                   feat, target_connections,
                                   num_runes );
        if (!building_level)

Replacement in crawl-ref/source/dungeon.cc at line 3747 [49.3429798]

B:BD[49.3597009] → [488.1587:1698]

B:BD[488.1698] → [54.4922:4984]

B:BD[54.4984] → [472.28140:28471]

∅:D[472.28471] → [54.4985:5167]

B:BD[489.148944] → [54.4985:5167]

B:BD[54.5167] → [89.13349:13430]

∅:D[89.13430] → [478.6271:6346]

B:BD[490.696] → [478.6271:6346]

∅:D[478.6346] → [54.5303:5317]

B:BD[54.5303] → [54.5303:5317]

            const int feat = vgrid[vy - v1y][vx - v1x];
            if (feat == ' ')
                continue;
            const dungeon_feature_type oldgrid = grd[vx][vy];
            altar_count = _vault_grid( place,
                                       level_number, vx, vy,
                                       altar_count,
                                       acq_item_class,
                                       feat, target_connections,
                                       num_runes );
            if (!building_level)
            {
                link_items();
                const dungeon_feature_type newgrid = grd[vx][vy];
                grd[vx][vy] = oldgrid;
                dungeon_terrain_changed(coord_def(vx, vy), newgrid, true, true);
                env.markers.remove_markers_at(coord_def(vx, vy), MAT_ANY);
            }

[49.3597009]

[49.3597288]

            link_items();
            const dungeon_feature_type newgrid = grd(*ri);
            grd(*ri) = oldgrid;
            dungeon_terrain_changed(*ri, newgrid, true, true);
            env.markers.remove_markers_at(*ri, MAT_ANY);

Insertion in crawl-ref/source/dungeon.cc at line 3753 [49.3429798]
[49.3597298]
[485.2762]
```
    }
```
Replacement in crawl-ref/source/dungeon.cc at line 3755 [49.3429798]
B:BD[485.2763] → [491.6420:6475]
```
    place.map.map.apply_overlays(coord_def(v1x, v1y));
```
[485.2763]
[54.5376]
```
    place.map.map.apply_overlays(v1);
```
Deletion in crawl-ref/source/dungeon.cc at line 4290 [49.3429798]
∅:D[431.18969] → [49.3598813:3598829]
B:BD[49.3598813] → [49.3598813:3598829]
```
    int vx, vy;
```

Replacement in crawl-ref/source/dungeon.cc at line 4295 [49.3429798]

∅:D[480.9352] → [457.6281:6347]

B:BD[49.3599112] → [457.6281:6347]

B:BD[49.3599151] → [457.6348:6418]

∅:D[488.1872] → [49.3599188:3599198]

∅:D[457.6418] → [49.3599188:3599198]

B:BD[49.3599188] → [49.3599188:3599198]

B:BD[49.3599198] → [488.1873:1911]

∅:D[488.1911] → [83.8648:8674]

B:BD[83.8648] → [83.8648:8674]

    for (vx = place.pos.x; vx < place.pos.x + place.size.x; vx++)
        for (vy = place.pos.y; vy < place.pos.y + place.size.y; vy++)
        {
            if (vgrid[vy][vx] == ' ')
                continue;

[480.9352]

[54.8470]

    for ( rectangle_iterator ri(place.pos, place.pos + place.size); ri; ++ri )
    {
        if (vgrid[ri->x][ri->y] == ' ')
            continue;

Replacement in crawl-ref/source/dungeon.cc at line 4300 [49.3429798]

B:BD[54.8471] → [54.8471:8533]

B:BD[54.8533] → [472.32717:33108]

∅:D[472.33108] → [54.8534:8840]

B:BD[83.8789] → [54.8534:8840]

B:BD[54.8840] → [490.697:818]

B:BD[490.818] → [478.6450:6525]

∅:D[478.6525] → [54.8976:8990]

B:BD[54.8976] → [54.8976:8990]

            const dungeon_feature_type oldgrid = grd[vx][vy];
            altar_count = _vault_grid( place,
                                       level_number, vx, vy, altar_count,
                                       acq_item_class,
                                       vgrid[vy][vx],
                                       target_connections,
                                       num_runes,
                                       rune_subst );
            if (!generating_level)
            {
                // Have to link items each square at a time, or
                // dungeon_terrain_changed could blow up.
                link_items();
                const dungeon_feature_type newgrid = grd[vx][vy];
                grd[vx][vy] = oldgrid;
                dungeon_terrain_changed(coord_def(vx, vy), newgrid,
                                        true, true);
                env.markers.remove_markers_at(coord_def(vx, vy), MAT_ANY);
            }

[54.8471]

[49.3599478]

        const dungeon_feature_type oldgrid = grd(*ri);
        altar_count = _vault_grid( place, level_number, *ri, altar_count,
                                   acq_item_class,
                                   vgrid[ri->x][ri->y],
                                   target_connections,
                                   num_runes,
                                   rune_subst );
        if (!generating_level)
        {
            // Have to link items each square at a time, or
            // dungeon_terrain_changed could blow up.
            link_items();
            const dungeon_feature_type newgrid = grd(*ri);
            grd(*ri) = oldgrid;
            dungeon_terrain_changed(*ri, newgrid, true, true);
            env.markers.remove_markers_at(*ri, MAT_ANY);

Insertion in crawl-ref/source/dungeon.cc at line 4317 [49.3429798]
[49.3599488]
[49.3599494]
```
    }
```

Replacement in crawl-ref/source/dungeon.cc at line 4439 [49.3429798]

B:BD[472.33502] → [472.33502:33565]

                                      int x, int y, int level)

[472.33502]

[492.10357]

                                      const coord_def& where, int level)

Replacement in crawl-ref/source/dungeon.cc at line 4466 [49.3429798]
B:BD[492.10688] → [492.10688:10750]
```
        mitm[item_made].x = x;
        mitm[item_made].y = y;
```
[492.10688]
[493.473]
```
        mitm[item_made].pos = where;
```

Replacement in crawl-ref/source/dungeon.cc at line 4473 [49.3429798]

B:BD[11.2791] → [11.2791:2967]

    if (grd[x][y] == DNGN_DEEP_WATER)
        grd[x][y] = DNGN_SHALLOW_WATER;
    else if (grd[x][y] <= DNGN_MINMOVE || grd[x][y] == DNGN_LAVA)
        grd[x][y] = DNGN_FLOOR;

[11.2791]

[127.1347]

    if (grd(where) == DNGN_DEEP_WATER)
        grd(where) = DNGN_SHALLOW_WATER;
    else if (grd(where) <= DNGN_MINMOVE || grd(where) == DNGN_LAVA)
        grd(where) = DNGN_FLOOR;

Replacement in crawl-ref/source/dungeon.cc at line 4480 [49.3429798]

∅:D[470.630] → [127.1405:1468]

∅:D[472.33621] → [127.1405:1468]

B:BD[127.1405] → [127.1405:1468]

                                      int x, int y, int level)

[472.33621]

[127.1468]

                                      const coord_def& where, int level)

Replacement in crawl-ref/source/dungeon.cc at line 4484 [49.3429798]

B:BD[127.1539] → [472.33622:33687]

        _dgn_place_item_explicit(list.get_item(i), x, y, level);

[127.1539]

[492.10756]

        _dgn_place_item_explicit(list.get_item(i), where, level);

Replacement in crawl-ref/source/dungeon.cc at line 4487 [49.3429798]

B:BD[489.149118] → [472.33688:33750]

static void _dgn_place_item_explicit(int index, int x, int y,

[489.149118]

[494.6087]

static void _dgn_place_item_explicit(int index, const coord_def& where,

Replacement in crawl-ref/source/dungeon.cc at line 4503 [49.3429798]
B:BD[494.6344] → [472.33751:33800]
```
    _dgn_place_item_explicit(spec, x, y, level);
```
[494.6344]
[492.10808]
```
    _dgn_place_item_explicit(spec, where, level);
```

Replacement in crawl-ref/source/dungeon.cc at line 4597 [49.3429798]

B:BD[469.13605] → [471.5275:5349]

∅:D[471.5349] → [480.9419:9480]

B:BD[470.912] → [480.9419:9480]

                       int monster_level, int vx, int vy, bool force_pos,
                       bool generate_awake, bool patrolling)

[469.13605]

[492.10926]

                       int monster_level, const coord_def& where,
                       bool force_pos, bool generate_awake, bool patrolling)

Replacement in crawl-ref/source/dungeon.cc at line 4631 [49.3429798]
∅:D[495.2792] → [345.27828:27881]
∅:D[496.24241] → [345.27828:27881]
B:BD[345.27828] → [345.27828:27881]
```
                grd[vx][vy] = habitat2grid(habitat);
```
[495.2792]
[495.2793]
```
                grd(where) = habitat2grid(habitat);
```
Replacement in crawl-ref/source/dungeon.cc at line 4641 [49.3429798]
B:BD[154.17272] → [154.17272:17314]
```
        mg.pos       = coord_def(vx, vy);
```
[154.17272]
[471.5350]
```
        mg.pos       = where;
```

Replacement in crawl-ref/source/dungeon.cc at line 4658 [49.3429798]

B:BD[472.34184] → [472.34184:34251]

                                int monster_level, int vx, int vy)

[472.34184]

[470.1273]

                                int monster_level, const coord_def& where)

Replacement in crawl-ref/source/dungeon.cc at line 4666 [49.3429798]

B:BD[480.9710] → [471.5405:5471]

    return dgn_place_monster(mspec, monster_level, vx, vy, false,

[480.9710]

[471.5471]

    return dgn_place_monster(mspec, monster_level, where, false,

Replacement in crawl-ref/source/dungeon.cc at line 4672 [49.3429798]

B:BD[472.34390] → [472.34390:34442]

                                    int vx, int vy)

[472.34390]

[497.1046]

                                    const coord_def& where)

Replacement in crawl-ref/source/dungeon.cc at line 4677 [49.3429798]

B:BD[469.13946] → [472.34443:34511]

        if (_dgn_place_monster(place, spec, monster_level, vx, vy))

[469.13946]

[497.1233]

        if (_dgn_place_monster(place, spec, monster_level, where))

Replacement in crawl-ref/source/dungeon.cc at line 4760 [49.3429798]

B:BD[472.34722] → [472.34722:34762]

                        int vx, int vy,

[472.34722]

[472.34762]

                        const coord_def& where,

Replacement in crawl-ref/source/dungeon.cc at line 4776 [49.3429798]

B:BD[492.11783] → [67.11377:11448]

            grd[vx][vy] = static_cast<dungeon_feature_type>( f.feat );

[492.11783]

[492.11817]

            grd(where) = static_cast<dungeon_feature_type>( f.feat );

Replacement in crawl-ref/source/dungeon.cc at line 4781 [49.3429798]

B:BD[492.11892] → [472.35095:35163]

            altar_count = _vault_grid( place, level_number, vx, vy,

[492.11892]

[472.35163]

            altar_count = _vault_grid( place, level_number, where,

Replacement in crawl-ref/source/dungeon.cc at line 4787 [49.3429798]

B:BD[492.12191] → [492.12191:12250]

            place_spec_shop(level_number, vx, vy, f.shop);

[492.12191]

[492.12250]

            place_spec_shop(level_number, where, f.shop);

Replacement in crawl-ref/source/dungeon.cc at line 4794 [49.3429798]
∅:D[140.14746] → [492.12434:12481]
B:BD[492.12434] → [492.12434:12481]
```
            place_specific_trap(vx, vy, trap);
```
[140.14746]
[492.12481]
```
            place_specific_trap(where, trap);
```
Replacement in crawl-ref/source/dungeon.cc at line 4797 [49.3429798]
B:BD[492.12504] → [492.12504:12542]
```
            grd[vx][vy] = DNGN_FLOOR;
```
[492.12504]
[49.3605472]
```
            grd(where) = DNGN_FLOOR;
```

Replacement in crawl-ref/source/dungeon.cc at line 4800 [49.3429798]

B:BD[497.1341] → [472.35359:35426]

        _dgn_place_one_monster(place, mons, level_number, vx, vy);

[497.1341]

[492.12642]

        _dgn_place_one_monster(place, mons, level_number, where);

Replacement in crawl-ref/source/dungeon.cc at line 4803 [49.3429798]

B:BD[127.1652] → [472.35427:35491]

        _dgn_place_multiple_items(items, vx, vy, level_number);

[127.1652]

[492.12749]

        _dgn_place_multiple_items(items, where, level_number);

Replacement in crawl-ref/source/dungeon.cc at line 4811 [49.3429798]

B:BD[498.465] → [371.50411:50435]

B:BD[371.50435] → [16.2668:2763]

        create_monster(
            mgen_data::hostile_at(
                _random_evil_statue(), coord_def(vx, vy)));

[498.465]

[498.591]

        create_monster(mgen_data::hostile_at( _random_evil_statue(), where));

Replacement in crawl-ref/source/dungeon.cc at line 4815 [49.3429798]
∅:D[366.7794] → [89.16320:16370]
B:BD[49.3605518] → [89.16320:16370]
```
    grd[vx][vy] = ((vgrid == -1)  ? grd[vx][vy] :
```
[366.7794]
[492.12865]
```
    grd(where)  = ((vgrid == -1)  ? grd(where) :
```
Replacement in crawl-ref/source/dungeon.cc at line 4860 [49.3429798]
B:BD[49.3607726] → [110.155544:155592]
```
        targets.push_back( coord_def(vx, vy) );
```
[49.3607726]
[49.3607774]
```
        targets.push_back( where );
```
Replacement in crawl-ref/source/dungeon.cc at line 4863 [49.3429798]
B:BD[49.3607803] → [49.3607803:3607853]
```
        place_specific_trap(vx, vy, TRAP_RANDOM);
```
[49.3607803]
[49.3607853]
```
        place_specific_trap(where, TRAP_RANDOM);
```

Replacement in crawl-ref/source/dungeon.cc at line 4866 [49.3429798]

B:BD[499.118898] → [500.7560:7634]

        place_specific_trap(vx, vy, random_trap_for_place(level_number));

[499.118898]

[499.118972]

        place_specific_trap(where, random_trap_for_place(level_number));

Replacement in crawl-ref/source/dungeon.cc at line 4871 [49.3429798]

B:BD[501.322] → [457.6636:6793]

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

[501.322]

[501.450]

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

Replacement in crawl-ref/source/dungeon.cc at line 4875 [49.3429798]
B:BD[501.456] → [501.456:504]
```
        targets.push_back( coord_def(vx, vy) );
```
[501.456]
[501.504]
```
        targets.push_back( where );
```

Replacement in crawl-ref/source/dungeon.cc at line 4930 [49.3429798]

B:BD[83.9718] → [67.11733:11814]

                    grd[vx][vy] = static_cast<dungeon_feature_type>(rune_subst);

[83.9718]

[83.9764]

                    grd(where) = static_cast<dungeon_feature_type>(rune_subst);

Replacement in crawl-ref/source/dungeon.cc at line 4968 [49.3429798]

B:BD[49.3610614] → [49.3610614:3610694]

                mitm[item_made].x = vx;
                mitm[item_made].y = vy;

[49.3610614]

[49.3610694]

                mitm[item_made].pos = where;

Replacement in crawl-ref/source/dungeon.cc at line 4976 [49.3429798]

B:BD[489.151429] → [472.35648:35724]

        _dgn_place_item_explicit(vgrid - 'd', vx, vy, place, level_number);

[489.151429]

[489.151517]

        _dgn_place_item_explicit(vgrid - 'd', where, place, level_number);

Replacement in crawl-ref/source/dungeon.cc at line 4983 [49.3429798]
B:BD[51.970389] → [51.970389:970423]
```
        grd[vx][vy] = DNGN_FLOOR;
```
[51.970389]
[51.970423]
```
        grd(where) = DNGN_FLOOR;
```

Replacement in crawl-ref/source/dungeon.cc at line 4985 [49.3429798]

B:BD[51.970424] → [371.50622:50646]

B:BD[371.50646] → [16.2764:2826]

        create_monster(
            mgen_data::hostile_at(mtype, coord_def(vx, vy)));

[51.970424]

[51.970535]

        create_monster(mgen_data::hostile_at(mtype, where));

Replacement in crawl-ref/source/dungeon.cc at line 5006 [49.3429798]

B:BD[49.3611393] → [472.35725:35803]

        _dgn_place_monster(place, monster_type_thing, monster_level, vx, vy);

[49.3611393]

[49.3611526]

        _dgn_place_monster(place, monster_type_thing, monster_level, where);

Replacement in crawl-ref/source/dungeon.cc at line 5024 [49.3429798]
∅:D[473.3783] → [472.35804:35863]
B:BD[49.3611703] → [472.35804:35863]
```
static void _replace_area( int sx, int sy, int ex, int ey,
```
[473.3783]
[472.35863]
```
static void _replace_area( const coord_def& p1, const coord_def& p2,
```

Replacement in crawl-ref/source/dungeon.cc at line 5029 [49.3429798]

B:BD[49.3611812] → [49.3611812:3611825]

B:BD[49.3611825] → [89.17751:17817]

    int x,y;
    for (x = sx; x <= ex; x++)
        for (y = sy; y <= ey; y++)

[49.3611812]

[89.17817]

    for ( rectangle_iterator ri(p1, p2); ri; ++ri )
    {
        if (grd(*ri) == replace && unforbidden(*ri, mapmask))

Replacement in crawl-ref/source/dungeon.cc at line 5033 [49.3429798]

∅:D[89.17827] → [502.5052:5131]

B:BD[49.3611881] → [502.5052:5131]

            if (grd[x][y] == replace && unforbidden(coord_def(x, y), mapmask))

[89.17827]

[473.3906]

            grd(*ri) = feature;
            if (needs_update && is_terrain_seen(*ri))

Replacement in crawl-ref/source/dungeon.cc at line 5036 [49.3429798]
∅:D[485.2933] → [49.3611919:3611956]
∅:D[473.3920] → [49.3611919:3611956]
∅:D[502.5131] → [49.3611919:3611956]
B:BD[49.3611919] → [49.3611919:3611956]
B:BD[49.3611956] → [467.12149:12218]
∅:D[467.12218] → [473.3992:4061]
B:BD[473.3992] → [473.3992:4061]
```
                grd[x][y] = feature;
                if (needs_update && is_terrain_seen(coord_def(x,y)))
                {
                    set_envmap_obj(x, y, feature);
```
[473.3920]
[473.4061]
```
                set_envmap_obj(*ri, feature);
```

Replacement in crawl-ref/source/dungeon.cc at line 5038 [49.3429798]

B:BD[473.4077] → [473.4077:4132]

                    tile_place_tile_bk(x, y, feature);

[473.4077]

[473.4132]

                tile_place_tile_bk(ri->x, ri->y, feature);

Deletion in crawl-ref/source/dungeon.cc at line 5040 [49.3429798]
B:BD[473.4139] → [473.4139:4157]
```
                }
```
Insertion in crawl-ref/source/dungeon.cc at line 5042 [49.3429798]
[89.17838]
[49.3611956]
```
    }
```
Deletion in crawl-ref/source/dungeon.cc at line 5446 [49.3429798]
B:BD[49.3638998] → [49.3638998:3639019]
```
    int timeout = 0;
```
Replacement in crawl-ref/source/dungeon.cc at line 5447 [49.3429798]
B:BD[49.3639052] → [49.3639052:3639124]
```
    unsigned char shop_place_x = 0;
    unsigned char shop_place_y = 0;
```
[49.3639020]
[503.391]
```
    coord_def shop_place;
```
Replacement in crawl-ref/source/dungeon.cc at line 5470 [49.3429798]
B:BD[49.3639532] → [49.3639532:3639554]
```
        timeout = 0;
```
[49.3639532]
[49.3639554]
```
        int timeout = 0;
        
```

Replacement in crawl-ref/source/dungeon.cc at line 5474 [49.3429798]

B:BD[49.3639575] → [190.2193:2335]

            shop_place_x = random_range(X_BOUND_1 + 1, X_BOUND_2 - 1);
            shop_place_y = random_range(Y_BOUND_1 + 1, Y_BOUND_2 - 1);

[49.3639575]

[49.3639677]

            shop_place.set(random_range(X_BOUND_1 + 1, X_BOUND_2 - 1),
                           random_range(Y_BOUND_1 + 1, Y_BOUND_2 - 1));

Replacement in crawl-ref/source/dungeon.cc at line 5482 [49.3429798]
B:BD[49.3639769] → [49.3639769:3639832]
```
        while (grd[shop_place_x][shop_place_y] != DNGN_FLOOR);
```
[49.3639769]
[49.3639832]
```
        while (grd(shop_place) != DNGN_FLOOR);
```

Replacement in crawl-ref/source/dungeon.cc at line 5492 [49.3429798]

B:BD[503.758] → [503.758:890]

        {
            place_spec_shop(level_number,
                            shop_place_x, shop_place_y, SHOP_RANDOM);
        }

[503.758]

[49.3639913]

            place_spec_shop(level_number, shop_place, SHOP_RANDOM);

Replacement in crawl-ref/source/dungeon.cc at line 5494 [49.3429798]
B:BD[49.3639919] → [49.3639919:3639972]
```
}                               // end place_shops()
```
[49.3639919]
[49.3639972]
```
}
```
Replacement in crawl-ref/source/dungeon.cc at line 5502 [49.3429798]
∅:D[140.15079] → [504.12197:12243]
B:BD[51.971677] → [504.12197:12243]
```
                      int shop_x, int shop_y,
```
[140.15079]
[504.12243]
```
                      const coord_def& where,
```
Insertion in crawl-ref/source/dungeon.cc at line 5630 [49.3429798]
[49.3642509]
[49.3642509]
```
        item_def& item( mitm[orb] );
```

Replacement in crawl-ref/source/dungeon.cc at line 5636 [49.3429798]

∅:D[480.11515] → [472.38240:38321]

B:BD[505.1134] → [472.38240:38321]

∅:D[472.38321] → [505.1214:1257]

B:BD[505.1214] → [505.1214:1257]

        if (_need_varied_selection(env.shop[i].type) && !is_artefact(mitm[orb]))
            stocked[mitm[orb].sub_type]++;

[480.11515]

[505.1257]

        if (_need_varied_selection(env.shop[i].type) && !is_artefact(item))
            stocked[item.sub_type]++;

Replacement in crawl-ref/source/dungeon.cc at line 5639 [49.3429798]

∅:D[505.1258] → [51.972116:972212]

B:BD[49.3642510] → [51.972116:972212]

        if (representative && mitm[orb].base_type == OBJ_WANDS)
            mitm[orb].plus = 7;

[505.1258]

[51.972212]

        if (representative && item.base_type == OBJ_WANDS)
            item.plus = 7;

Replacement in crawl-ref/source/dungeon.cc at line 5643 [49.3429798]
∅:D[480.11569] → [49.3642562:3642616]
B:BD[49.3642562] → [49.3642562:3642616]
```
        mitm[orb].x = 0;
        mitm[orb].y = 5 + i;
```
[480.11569]
[49.3642616]
```
        item.pos.set(0, 5+i);
```

Replacement in crawl-ref/source/dungeon.cc at line 5649 [49.3429798]

B:BD[49.3642791] → [49.3642791:3642852]

            set_ident_flags( mitm[orb], ISFLAG_IDENT_MASK );

[49.3642791]

[49.3642852]

            set_ident_flags( item, ISFLAG_IDENT_MASK );

Replacement in crawl-ref/source/dungeon.cc at line 5653 [49.3429798]
B:BD[49.3642869] → [49.3642869:3642925]
```
    env.shop[i].x = shop_x;
    env.shop[i].y = shop_y;
```
[49.3642869]
[49.3642925]
```
    env.shop[i].pos = where;
```
Replacement in crawl-ref/source/dungeon.cc at line 5655 [49.3429798]
B:BD[49.3642926] → [49.3642926:3642969]
```
    grd[shop_x][shop_y] = DNGN_ENTER_SHOP;
```
[49.3642926]
[51.972214]
```
    grd(where) = DNGN_ENTER_SHOP;
```

Replacement in crawl-ref/source/dungeon.cc at line 6118 [49.3429798]

∅:D[83.10037] → [49.3658218:3658298]

B:BD[49.3658218] → [49.3658218:3658298]

        sr.x1 = 25;
        sr.y1 = 25;
        sr.x2 = 55;
        sr.y2 = 45;

[83.10037]

[49.3658298]

        sr.tl.set(25,25);
        sr.br.set(55,45);

Replacement in crawl-ref/source/dungeon.cc at line 6202 [49.3429798]
∅:D[480.12114] → [49.3661532:3661568]
B:BD[49.3661532] → [49.3661532:3661568]
```
    for (x = sr.x1; x < sr.x2; x++)
```
[480.12114]
[49.3661568]
```
    for (x = sr.tl.x; x < sr.br.x; x++)
```

Replacement in crawl-ref/source/dungeon.cc at line 6204 [49.3429798]

B:BD[49.3661574] → [49.3661574:3661634]

        for (y = sr.y1 + oblique; y < sr.y2 - oblique; y++)

[49.3661574]

[49.3661644]

        for (y = sr.tl.y + oblique; y < sr.br.y - oblique; y++)

Replacement in crawl-ref/source/dungeon.cc at line 6208 [49.3429798]
B:BD[49.3661790] → [49.3661790:3661827]
```
        if (x > sr.x2 - oblique_max)
```
[49.3661741]
[49.3661827]
```
        if (x > sr.tl.x - oblique_max)
```
Replacement in crawl-ref/source/dungeon.cc at line 6218 [49.3429798]
B:BD[49.3661889] → [49.3661889:3661925]
```
    for (x = sr.x1; x < sr.x2; x++)
```
[49.3661889]
[49.3661925]
```
    for (x = sr.tl.x; x < sr.br.x; x++)
```

Replacement in crawl-ref/source/dungeon.cc at line 6220 [49.3429798]

B:BD[49.3661931] → [49.3661931:3661991]

        for (y = sr.y1 + oblique; y < sr.y2 - oblique; y++)

[49.3661931]

[49.3661991]

        for (y = sr.tl.y + oblique; y < sr.br.y - oblique; y++)

Replacement in crawl-ref/source/dungeon.cc at line 6232 [49.3429798]
B:BD[42.2799] → [42.2799:2836]
```
        if (x > sr.x2 - oblique_max)
```
[42.2799]
[42.2836]
```
        if (x > sr.br.x - oblique_max)
```

Replacement in crawl-ref/source/dungeon.cc at line 6328 [49.3429798]

B:BD[506.3553] → [506.3553:3659]

        {
            mitm[treasure_item].x = end.x;
            mitm[treasure_item].y = end.y;
        }

[506.3553]

[506.3659]

            mitm[treasure_item].pos = end;

Deletion in crawl-ref/source/dungeon.cc at line 6789 [49.3429798]
B:BD[49.3673463] → [49.3673463:3673529]
```
    int x_count = 0;
    int y_count = 0;
    int item_made = 0;
```

Replacement in crawl-ref/source/dungeon.cc at line 6798 [49.3429798]

B:BD[49.3673693] → [49.3673693:3673747]

B:BD[49.3673753] → [49.3673753:3673914]

    for (x_count = ta1_x; x_count < ta2_x; x_count++)
        for (y_count = ta1_y; y_count < ta2_y; y_count++)
        {
            if (grd[x_count][y_count] != DNGN_FLOOR || coinflip())
                continue;

[49.3673693]

[49.3673914]

    // Gah. FIXME.
    coord_def tl(ta1_x, ta1_y);
    coord_def br(ta2_x-1, ta2_y-1);
    for (rectangle_iterator ri(tl, br); ri; ++ri)
    {
        if (grd(*ri) != DNGN_FLOOR || coinflip())
            continue;

Replacement in crawl-ref/source/dungeon.cc at line 6807 [49.3429798]

B:BD[49.3673915] → [49.3673915:3673979]

            item_made = items( 1, OBJ_RANDOM, OBJ_RANDOM, true,

[49.3673915]

[467.12772]

        int item_made = items( 1, OBJ_RANDOM, OBJ_RANDOM, true,

Insertion in crawl-ref/source/dungeon.cc at line 6810 [49.3429798]

[467.12888]

[49.3674046]

        
        if (item_made != NON_ITEM)
            mitm[item_made].pos = *ri;
    }

Deletion in crawl-ref/source/dungeon.cc at line 6815 [49.3429798]

B:BD[49.3674047] → [49.3674047:3674214]

B:BD[49.3674220] → [49.3674220:3674221]

            if (item_made != NON_ITEM)
            {
                mitm[item_made].x = x_count;
                mitm[item_made].y = y_count;
            }
        }

Replacement in crawl-ref/source/dungeon.cc at line 6853 [49.3429798]

B:BD[49.3675351] → [49.3675351:3675499]

        sr.x1 = 8 + random2(43);
        sr.y1 = 8 + random2(35);
        sr.x2 = sr.x1 + 5 + random2(15);
        sr.y2 = sr.y1 + 5 + random2(10);

[49.3675351]

[49.3675499]

        sr.tl.set(8 + random2(43), 8 + random2(35) );
        sr.br.set(5 + random2(15), 5 + random2(10) );
        sr.br += sr.tl;

Replacement in crawl-ref/source/dungeon.cc at line 6857 [49.3429798]
B:BD[49.3675500] → [49.3675500:3675567]
```
        oblique_max = (sr.x2 - sr.x1) / 2;      //random2(20) + 5;
```
[49.3675500]
[49.3675567]
```
        oblique_max = (sr.br.x - sr.tl.x) / 2;
```

Replacement in crawl-ref/source/dungeon.cc at line 6886 [49.3429798]

B:BD[49.3676229] → [49.3676229:3676378]

        sr.x1 = 8 + random2(30);
        sr.y1 = 8 + random2(22);
        sr.x2 = sr.x1 + 20 + random2(10);
        sr.y2 = sr.y1 + 20 + random2(8);

[49.3676229]

[49.3676378]

        sr.tl.set(8 + random2(30), 8 + random2(22));
        sr.br.set(20 + random2(10), 20 + random2(8));
        sr.br += sr.tl;

Replacement in crawl-ref/source/dungeon.cc at line 6910 [49.3429798]

∅:D[480.12901] → [49.3676904:3677037]

B:BD[49.3676904] → [49.3676904:3677037]

    sr.x1 = 8 + random2(30);
    sr.y1 = 8 + random2(22);
    sr.x2 = sr.x1 + 20 + random2(10);
    sr.y2 = sr.y1 + 20 + random2(8);

[480.12901]

[49.3677037]

    sr.tl.set(8 + random2(30), 8 + random2(22));
    sr.br.set(20 + random2(10), 20 + random2(8));
    sr.br += sr.tl;

Replacement in crawl-ref/source/dungeon.cc at line 6915 [49.3429798]
∅:D[480.12937] → [472.48457:48535]
B:BD[49.3677072] → [472.48457:48535]
```
    if (_find_in_area(sr.x1, sr.y1, sr.x2, sr.y2, DNGN_BUILDER_SPECIAL_WALL))
```
[480.12937]
[49.3677149]
```
    if (count_feature_in_box(sr.tl, sr.br, DNGN_BUILDER_SPECIAL_WALL) > 0)
```

Replacement in crawl-ref/source/dungeon.cc at line 6925 [49.3429798]

∅:D[480.12964] → [472.48536:48688]

B:BD[49.3677385] → [472.48536:48688]

    _replace_area(sr.x1, sr.y1, sr.x2, sr.y2, DNGN_ROCK_WALL, type_floor);
    _replace_area(sr.x1, sr.y1, sr.x2, sr.y2, DNGN_CLOSED_DOOR, type_floor);

[480.12964]

[49.3677535]

    _replace_area(sr.tl, sr.br, DNGN_ROCK_WALL, type_floor);
    _replace_area(sr.tl, sr.br, DNGN_CLOSED_DOOR, type_floor);

Replacement in crawl-ref/source/dungeon.cc at line 6951 [49.3429798]

B:BD[49.3678136] → [49.3678136:3678212]

        i = sr.x1;
        j = sr.y1;
        k = sr.x2;
        l = sr.y2;

[49.3678136]

[49.3678212]

        i = sr.tl.x;
        j = sr.tl.y;
        k = sr.br.x;
        l = sr.br.y;

Replacement in crawl-ref/source/dungeon.cc at line 6981 [49.3429798]
B:BD[49.3678902] → [49.3678902:3678957]
```
    int i, j;
    if (sr.x2 < sr.x1 || sr.y2 < sr.y1)
```
[49.3678902]
[49.3678957]
```
    if (sr.br.x < sr.tl.x || sr.br.y < sr.tl.y)
```

Replacement in crawl-ref/source/dungeon.cc at line 6984 [49.3429798]

B:BD[49.3678974] → [49.3678974:3679011]

B:BD[49.3679017] → [49.3679017:3679178]

    for (i = sr.x1; i <= sr.x2; i++)
        for (j = sr.y1; j <= sr.y2; j++)
        {
            if (grd[i][j] == target)
                grd[i][j] = (((i + j) % 2) ? floor2 : floor1);
        }

[49.3678974]

[162.14005]

    for ( rectangle_iterator ri(sr.tl, sr.br); ri; ++ri )
        if (grd(*ri) == target)
            grd(*ri) = ((ri->x + ri->y) % 2) ? floor2 : floor1;

Deletion in crawl-ref/source/dungeon.cc at line 7049 [49.3429798]
B:BD[49.3681135] → [49.3681135:3681223]
```
    FixedVector < char, 2 > pos;
    FixedVector < char, 2 > jpos;
    char doing = 0;
```
Insertion in crawl-ref/source/dungeon.cc at line 7061 [49.3429798]
[49.3681477]
[49.3681477]
```
            coord_def pos, jpos;
```

Replacement in crawl-ref/source/dungeon.cc at line 7068 [49.3429798]

B:BD[49.3681571] → [507.12875:12987]

∅:D[507.12987] → [49.3681681:3681779]

B:BD[49.3681681] → [49.3681681:3681779]

                pos[0]  = rox1[i];      // - 1;
                pos[1]  = roy1[i] + random2(roy2[i] - roy1[i]);
                jpos[0] = rox2[last_room];      // + 1;
                jpos[1] = roy1[last_room]

[49.3681571]

[507.12988]

                pos.x  = rox1[i];      // - 1;
                pos.y  = roy1[i] + random2(roy2[i] - roy1[i]);
                jpos.x = rox2[last_room];      // + 1;
                jpos.y = roy1[last_room]

Replacement in crawl-ref/source/dungeon.cc at line 7077 [49.3429798]

B:BD[49.3681936] → [507.13063:13175]

∅:D[507.13175] → [49.3682046:3682144]

B:BD[49.3682046] → [49.3682046:3682144]

                pos[1]  = roy1[i];      // - 1;
                pos[0]  = rox1[i] + random2(rox2[i] - rox1[i]);
                jpos[1] = roy2[last_room];      // + 1;
                jpos[0] = rox1[last_room]

[49.3681936]

[49.3682144]

                pos.y  = roy1[i];      // - 1;
                pos.x  = rox1[i] + random2(rox2[i] - rox1[i]);
                jpos.y = roy2[last_room];      // + 1;
                jpos.x = rox1[last_room]

Replacement in crawl-ref/source/dungeon.cc at line 7085 [49.3429798]
B:BD[49.3682260] → [49.3682260:3682319]
```
            while (pos[0] != jpos[0] || pos[1] != jpos[1])
```
[49.3682260]
[49.3682319]
```
            while (pos != jpos)
```

Replacement in crawl-ref/source/dungeon.cc at line 7087 [49.3429798]

B:BD[49.3682333] → [49.3682333:3682658]

                doing = (coinflip()? 1 : 0);
                if (pos[doing] < jpos[doing])
                    pos[doing]++;
                else if (pos[doing] > jpos[doing])
                    pos[doing]--;
                if (grd[pos[0]][pos[1]] == DNGN_ROCK_WALL)
                    grd[pos[0]][pos[1]] = DNGN_FLOOR;

[49.3682333]

[49.3682658]

                // make a corridor
                if ( coinflip() )
                {
                    if ( pos.x < jpos.x )
                        pos.x++;
                    else if ( pos.x > jpos.x )
                        pos.x--;
                }
                else
                {
                    if ( pos.y < jpos.y )
                        pos.y++;
                    else if ( pos.y > jpos.y )
                        pos.y--;
                }
                if (grd(pos) == DNGN_ROCK_WALL)
                    grd(pos) = DNGN_FLOOR;

Replacement in crawl-ref/source/dungeon.cc at line 7106 [49.3429798]
B:BD[49.3682673] → [49.3682673:3682724]
```
            if (grd[pos[0]][pos[1]] == DNGN_FLOOR)
```
[49.3682673]
[49.3682724]
```
            if (grd(pos) == DNGN_FLOOR)
```

Replacement in crawl-ref/source/dungeon.cc at line 7108 [49.3429798]

B:BD[49.3682738] → [49.3682738:3683008]

                if ((grd[pos[0] + 1][pos[1]] == DNGN_ROCK_WALL
                        && grd[pos[0] - 1][pos[1]] == DNGN_ROCK_WALL)
                    || (grd[pos[0]][pos[1] + 1] == DNGN_ROCK_WALL
                        && grd[pos[0]][pos[1] - 1] == DNGN_ROCK_WALL))

[49.3682738]

[49.3683008]

                if ((grd[pos.x + 1][pos.y] == DNGN_ROCK_WALL
                     && grd[pos.x - 1][pos.y] == DNGN_ROCK_WALL)
                    || (grd[pos.x][pos.y + 1] == DNGN_ROCK_WALL
                        && grd[pos.x][pos.y - 1] == DNGN_ROCK_WALL))

Replacement in crawl-ref/source/dungeon.cc at line 7113 [49.3429798]

B:BD[49.3683026] → [67.14392:14455]

                    grd[pos[0]][pos[1]] = DNGN_GRANITE_STATUE;

[49.3683026]

[49.3683073]

                    grd(pos) = DNGN_GRANITE_STATUE;

Replacement in crawl-ref/source/dungeon.cc at line 7125 [49.3429798]

B:BD[49.3683357] → [49.3683357:3683509]

        sr.x1 = rox1[spec_room_done];
        sr.x2 = rox2[spec_room_done];
        sr.y1 = roy1[spec_room_done];
        sr.y2 = roy2[spec_room_done];

[49.3683357]

[472.49572]

        sr.tl.set( rox1[spec_room_done], roy1[spec_room_done] );
        sr.br.set( rox2[spec_room_done], roy2[spec_room_done] );

Replacement in crawl-ref/source/dungeon.cc at line 7133 [49.3429798]

B:BD[49.3683697] → [472.49616:49673]

        _replace_area(sr.x1-1, sr.y1-1, sr.x2+1,sr.y1-1,

[49.3683697]

[472.49673]

        _replace_area(sr.tl.x-1, sr.tl.y-1, sr.br.x+1,sr.tl.y-1,

Replacement in crawl-ref/source/dungeon.cc at line 7135 [49.3429798]

B:BD[472.49739] → [472.49739:49796]

        _replace_area(sr.x1-1, sr.y1-1, sr.x2+1,sr.y1-1,

[472.49739]

[472.49796]

        _replace_area(sr.tl.x-1, sr.tl.y-1, sr.br.x+1,sr.tl.y-1,

Replacement in crawl-ref/source/dungeon.cc at line 7137 [49.3429798]

B:BD[472.49859] → [472.49859:49916]

        _replace_area(sr.x1-1, sr.y1-1, sr.x2+1,sr.y1-1,

[472.49859]

[472.49916]

        _replace_area(sr.tl.x-1, sr.tl.y-1, sr.br.x+1,sr.tl.y-1,

Replacement in crawl-ref/source/dungeon.cc at line 7141 [49.3429798]

B:BD[49.3684016] → [472.49986:50043]

        _replace_area(sr.x1-1, sr.y2+1, sr.x2+1,sr.y2+1,

[49.3684016]

[472.50043]

        _replace_area(sr.tl.x-1, sr.br.y+1, sr.br.x+1,sr.br.y+1,

Replacement in crawl-ref/source/dungeon.cc at line 7143 [49.3429798]

B:BD[472.50109] → [472.50109:50166]

        _replace_area(sr.x1-1, sr.y2+1, sr.x2+1,sr.y2+1,

[472.50109]

[472.50166]

        _replace_area(sr.tl.x-1, sr.br.y+1, sr.br.x+1,sr.br.y+1,

Replacement in crawl-ref/source/dungeon.cc at line 7145 [49.3429798]

B:BD[472.50229] → [472.50229:50286]

        _replace_area(sr.x1-1, sr.y2+1, sr.x2+1,sr.y2+1,

[472.50229]

[472.50286]

        _replace_area(sr.tl.x-1, sr.br.y+1, sr.br.x+1,sr.br.y+1,

Replacement in crawl-ref/source/dungeon.cc at line 7149 [49.3429798]

B:BD[49.3684333] → [472.50356:50414]

        _replace_area(sr.x1-1, sr.y1-1, sr.x1-1, sr.y2+1,

[49.3684333]

[472.50414]

        _replace_area(sr.tl.x-1, sr.tl.y-1, sr.tl.x-1, sr.br.y+1,

Replacement in crawl-ref/source/dungeon.cc at line 7151 [49.3429798]

B:BD[472.50480] → [472.50480:50538]

        _replace_area(sr.x1-1, sr.y1-1, sr.x1-1, sr.y2+1,

[472.50480]

[472.50538]

        _replace_area(sr.tl.x-1, sr.tl.y-1, sr.tl.x-1, sr.br.y+1,

Replacement in crawl-ref/source/dungeon.cc at line 7153 [49.3429798]

B:BD[472.50601] → [472.50601:50659]

        _replace_area(sr.x1-1, sr.y1-1, sr.x1-1, sr.y2+1,

[472.50601]

[472.50659]

        _replace_area(sr.tl.x-1, sr.tl.y-1, sr.tl.x-1, sr.br.y+1,

Replacement in crawl-ref/source/dungeon.cc at line 7157 [49.3429798]

B:BD[49.3684654] → [472.50729:50787]

        _replace_area(sr.x2+1, sr.y1-1, sr.x2+1, sr.y2+1,

[49.3684654]

[472.50787]

        _replace_area(sr.br.x+1, sr.tl.y-1, sr.br.x+1, sr.br.y+1,

Replacement in crawl-ref/source/dungeon.cc at line 7159 [49.3429798]

B:BD[472.50853] → [472.50853:50911]

        _replace_area(sr.x2+1, sr.y1-1, sr.x2+1, sr.y2+1,

[472.50853]

[472.50911]

        _replace_area(sr.br.x+1, sr.tl.y-1, sr.br.x+1, sr.br.y+1,

Replacement in crawl-ref/source/dungeon.cc at line 7161 [49.3429798]

B:BD[472.50974] → [472.50974:51032]

        _replace_area(sr.x2+1, sr.y1-1, sr.x2+1, sr.y2+1,

[472.50974]

[472.51032]

        _replace_area(sr.br.x+1, sr.tl.y-1, sr.br.x+1, sr.br.y+1,

Replacement in crawl-ref/source/dungeon.cc at line 7181 [49.3429798]

B:BD[49.3685349] → [49.3685349:3685429]

    int temp_rand = 0;          // probability determination {dlb}
    int x,y;

[49.3685349]

[49.3685429]

    for (rectangle_iterator ri(sr.tl, sr.br); ri; ++ri)
    {
        if (grd(*ri) == DNGN_FLOOR || grd(*ri) == DNGN_BUILDER_SPECIAL_FLOOR)
        {
            const int temp_rand = random2(24);
            
            const monster_type mon_type =
                ((temp_rand > 11) ? MONS_ZOMBIE_SMALL :  // 50.0%
                 (temp_rand >  7) ? MONS_WIGHT :         // 16.7%
                 (temp_rand >  3) ? MONS_NECROPHAGE :    // 16.7%
                 (temp_rand >  0) ? MONS_WRAITH          // 12.5%
                                  : MONS_VAMPIRE);       //  4.2%

Replacement in crawl-ref/source/dungeon.cc at line 7194 [49.3429798]

B:BD[49.3685430] → [49.3685430:3685467]

B:BD[49.3685473] → [49.3685473:3685514]

B:BD[49.3685524] → [49.3685524:3685622]

B:BD[49.3685652] → [49.3685652:3685694]

B:BD[49.3685694] → [371.50805:51201]

∅:D[371.51201] → [49.3686084:3686085]

B:BD[49.3686084] → [49.3686084:3686085]

B:BD[49.3686085] → [371.51202:51327]

∅:D[371.51327] → [49.3686157:3686171]

B:BD[49.3686157] → [49.3686157:3686171]

    for (x = sr.x1; x <= sr.x2; x++)
        for (y = sr.y1; y <= sr.y2; y++)
            if (grd[x][y] == DNGN_FLOOR || grd[x][y] == DNGN_BUILDER_SPECIAL_FLOOR)
            {
                temp_rand = random2(24);
                const monster_type mon_type =
                    ((temp_rand > 11) ? MONS_ZOMBIE_SMALL :  // 50.0%
                     (temp_rand >  7) ? MONS_WIGHT :         // 16.7%
                     (temp_rand >  3) ? MONS_NECROPHAGE :    // 16.7%
                     (temp_rand >  0) ? MONS_WRAITH          // 12.5%
                                      : MONS_VAMPIRE);       //  4.2%
                mons_place(
                    mgen_data::sleeper_at(
                        mon_type, coord_def(x, y) ));
            }

[49.3685430]

[480.13362]

            mons_place(mgen_data::sleeper_at(mon_type, *ri));
        }
    }

Replacement in crawl-ref/source/dungeon.cc at line 7202 [49.3429798]

B:BD[51.973053] → [51.973053:973161]

    const int lordx = sr.x1 + random2(sr.x2 - sr.x1);
    const int lordy = sr.y1 + random2(sr.y2 - sr.y1);

[51.973053]

[51.973161]

    const coord_def lordpos = sr.random_spot();

Replacement in crawl-ref/source/dungeon.cc at line 7237 [49.3429798]

B:BD[51.973981] → [472.51423:51498]

    _fill_monster_pit( sr, pit_list, 90, MONS_PROGRAM_BUG, lordx, lordy );

[51.973981]

[51.974055]

    _fill_monster_pit( sr, pit_list, 90, MONS_PROGRAM_BUG, lordpos );

Replacement in crawl-ref/source/dungeon.cc at line 7240 [49.3429798]

B:BD[51.974058] → [89.22827:22898]

bool place_specific_trap(int spec_x, int spec_y,  trap_type spec_type)

[51.974058]

[49.3686369]

bool place_specific_trap(const coord_def& where, trap_type spec_type)

Replacement in crawl-ref/source/dungeon.cc at line 7266 [49.3429798]

B:BD[49.3686618] → [142.6553:6701]

            env.trap[tcount].x    = spec_x;
            env.trap[tcount].y    = spec_y;
            grd[spec_x][spec_y]   = DNGN_UNDISCOVERED_TRAP;

[49.3686618]

[142.6701]

            env.trap[tcount].pos  = where;
            grd(where)            = DNGN_UNDISCOVERED_TRAP;

Replacement in crawl-ref/source/directn.h at line 131 [49.3696722]

B:BD[135.98000] → [135.98000:98195]

    bool isMe;          // selected self (convenience: tx == you.x_pos,
                        // ty == you.y_pos)
    bool isEndpoint;    // Does the player want the attack to stop at (tx,ty)?

[135.98000]

[135.98195]

    bool isMe;          // selected self (convenience: target == you.pos())
    bool isEndpoint;    // Does the player want the attack to stop at target?

Replacement in crawl-ref/source/directn.h at line 135 [49.3696722]

B:BD[135.98311] → [135.98311:98460]

    int  tx,ty;         // target x,y or logical extension of beam to map edge
    int  dx,dy;         // delta x and y if direction - always -1,0,1

[135.98311]

[135.98460]

    coord_def target;   // target x,y or logical extension of beam to map edge
    coord_def delta;    // delta x and y if direction - always -1,0,1

Deletion in crawl-ref/source/directn.h at line 141 [49.3696722]

B:BD[135.98584] → [135.98584:98705]


    // target - source (source == you.pos())
    coord_def target() const
    {
        return coord_def(tx, ty);
    }

Insertion in crawl-ref/source/directn.h at line 152 [49.3696722]

[68.450755]

inline bool in_viewport_bounds(const coord_def& pos) {
  return in_viewport_bounds(pos.x, pos.y);
}

Replacement in crawl-ref/source/directn.cc at line 107 [49.3697945]

∅:D[61.45256] → [162.14419:14496]

B:BD[162.14419] → [162.14419:14496]

                                  FixedVector<char, 2> &mfp, char direction,

[61.45256]

[44.2771]

                                  coord_def &mfp, char direction,

Replacement in crawl-ref/source/directn.cc at line 114 [49.3697945]

∅:D[61.45390] → [162.14817:14885]

B:BD[162.14817] → [162.14817:14885]

                          FixedVector<char, 2> &mfp, int direction,

[61.45390]

[44.2859]

                          coord_def &mfp, int direction,

Replacement in crawl-ref/source/directn.cc at line 129 [49.3697945]
B:BD[508.4068] → [508.4068:4097]
```
    moves.dx = moves.dy = 0;
```
[508.4068]
[509.5614]
```
    moves.delta.reset();
```

Replacement in crawl-ref/source/directn.cc at line 163 [49.3697945]

B:BD[98.174110] → [98.174110:174233]

            moves.dx = delta.x;
            moves.dy = delta.y;
            moves.isMe = (delta.x == 0) && (delta.y == 0);

[98.174110]

[98.174233]

            moves.delta = delta;
            moves.isMe = delta.origin();

Replacement in crawl-ref/source/directn.cc at line 171 [49.3697945]
B:BD[510.260] → [510.260:297]
```
            moves.dx = moves.dy = 0;
```
[510.260]
[510.297]
```
            moves.delta.reset();
```

Replacement in crawl-ref/source/directn.cc at line 179 [49.3697945]

B:BD[508.4264] → [508.4264:4338]

            moves.dx = Compass[i].x;
            moves.dy = Compass[i].y;

[508.4264]

[508.4338]

            moves.delta = Compass[i];

Replacement in crawl-ref/source/directn.cc at line 187 [49.3697945]

B:BD[511.3744] → [512.7466:7529]

    while (!moves.isCancel && moves.dx == 0 && moves.dy == 0);

[511.3744]

[508.4575]

    while (!moves.isCancel && moves.delta.origin());

Replacement in crawl-ref/source/directn.cc at line 294 [49.3697945]

B:BD[513.6553] → [513.6553:6647]

    return (grd[mon->x][mon->y] == DNGN_SHALLOW_WATER
            && see_grid(mon->x, mon->y)

[513.6553]

[513.6647]

    return (grd(mon->pos()) == DNGN_SHALLOW_WATER
            && see_grid(mon->pos())

Replacement in crawl-ref/source/directn.cc at line 380 [49.3697945]

B:BD[158.19930] → [158.19930:20034]

        else if (you.prev_grd_targ.x == you.x_pos
                 && you.prev_grd_targ.y == you.y_pos)

[158.19930]

[158.20034]

        else if (you.prev_grd_targ == you.pos())

Replacement in crawl-ref/source/directn.cc at line 398 [49.3697945]
∅:D[511.4441] → [158.20312:20392]
∅:D[150.7605] → [158.20312:20392]
B:BD[158.20312] → [158.20312:20392]
```
        moves.tx = you.prev_grd_targ.x;
        moves.ty = you.prev_grd_targ.y;
```
[150.7605]
[158.20392]
```
        moves.target = you.prev_grd_targ;
```

Replacement in crawl-ref/source/directn.cc at line 401 [49.3697945]

B:BD[158.20414] → [61.45715:45780]

        find_ray(you.pos(), moves.target(), true, ray, 0, true);

[158.20414]

[158.20511]

        find_ray(you.pos(), moves.target, true, ray, 0, true);

Replacement in crawl-ref/source/directn.cc at line 407 [49.3697945]
B:BD[158.20614] → [158.20614:20678]
```
        moves.tx   = you.x_pos;
        moves.ty   = you.y_pos;
```
[158.20614]
[158.20678]
```
        moves.target = you.pos();
```
Replacement in crawl-ref/source/directn.cc at line 435 [49.3697945]
∅:D[511.4866] → [158.21138:21204]
B:BD[158.21138] → [158.21138:21204]
```
        moves.tx = montarget->x;
        moves.ty = montarget->y;
```
[511.4866]
[158.21204]
```
        moves.target = montarget->pos();
```

Replacement in crawl-ref/source/directn.cc at line 438 [49.3697945]

B:BD[158.21226] → [61.45847:45912]

        find_ray(you.pos(), moves.target(), true, ray, 0, true);

[158.21226]

[158.21323]

        find_ray(you.pos(), moves.target, true, ray, 0, true);

Replacement in crawl-ref/source/directn.cc at line 568 [49.3697945]

B:BD[49.3700724] → [508.5503:5586]

    FixedVector < char, 2 > objfind_pos;
    FixedVector < char, 2 > monsfind_pos;

[49.3700724]

[508.5586]

    coord_def objfind_pos, monsfind_pos;

Replacement in crawl-ref/source/directn.cc at line 571 [49.3697945]
∅:D[514.1608] → [49.3700868:3700897]
∅:D[515.2827] → [49.3700868:3700897]
B:BD[49.3700868] → [49.3700868:3700897]
B:BD[508.5631] → [508.5631:5683]
```
    moves.dx = moves.dy = 0;
    moves.tx = you.x_pos;
    moves.ty = you.y_pos;
```
[49.3700736]
[516.303]
```
    moves.delta.reset();
    moves.target = you.pos();
```

Replacement in crawl-ref/source/directn.cc at line 576 [49.3697945]

B:BD[415.11955] → [61.45913:45969]

        find_ray(you.pos(), moves.target(), true, ray);

[415.11955]

[517.160]

        find_ray(you.pos(), moves.target, true, ray);

Replacement in crawl-ref/source/directn.cc at line 594 [49.3697945]

B:BD[518.833] → [518.833:915]

                moves.tx = montarget->x;
                moves.ty = montarget->y;

[518.833]

[518.915]

                moves.target = montarget->pos();

Replacement in crawl-ref/source/directn.cc at line 611 [49.3697945]

B:BD[519.745] → [519.745:813]

                 && moves.tx == you.x_pos && moves.ty == you.y_pos)

[519.745]

[248.4886]

                && moves.target == you.pos())

Replacement in crawl-ref/source/directn.cc at line 613 [49.3697945]
∅:D[248.4900] → [519.813:868]
B:BD[519.813] → [519.813:868]
```
                terse_describe_square(moves.target());
```
[248.4900]
[248.4901]
```
                terse_describe_square(moves.target);
```

Replacement in crawl-ref/source/directn.cc at line 628 [49.3697945]

B:BD[520.874] → [521.2240:2304]

        cursorxy( grid2viewX(moves.tx), grid2viewY(moves.ty) );

[520.874]

[508.5917]

        cursorxy( grid2viewX(moves.target.x), grid2viewY(moves.target.y) );

Replacement in crawl-ref/source/directn.cc at line 652 [49.3697945]

B:BD[58.5934027] → [58.5934027:5934093]

                moves.tx = gc.x;
                moves.ty = gc.y;

[58.5934027]

[58.5934093]

                moves.target = gc;

Replacement in crawl-ref/source/directn.cc at line 664 [49.3697945]

B:BD[58.5934364] → [441.9217:9277]

        if (target_unshifted && moves.target() == you.pos()

[58.5934364]

[522.9898]

        if (target_unshifted && moves.target == you.pos()

Replacement in crawl-ref/source/directn.cc at line 682 [49.3697945]
B:BD[523.495] → [441.9278:9323]
```
            if (moves.target() == you.pos())
```
[523.495]
[523.561]
```
            if (moves.target == you.pos())
```

Replacement in crawl-ref/source/directn.cc at line 692 [49.3697945]

B:BD[524.2692] → [518.1246:1322]

∅:D[517.856] → [508.6079:6116]

∅:D[518.1322] → [508.6079:6116]

B:BD[508.6079] → [508.6079:6116]

        const int old_tx = moves.tx + (skip_iter ? 500 : 0); // hmmm...hack
        const int old_ty = moves.ty;

[524.2692]

[49.3701076]

        coord_def old_target = moves.target;
        if ( skip_iter )
            old_target.x += 500; // hmmm...hack

Replacement in crawl-ref/source/directn.cc at line 705 [49.3697945]

∅:D[37.4248] → [61.46036:46106]

B:BD[525.7258] → [61.46036:46106]

            if (_find_square_wrapper(moves.target(), monsfind_pos, 1,

[37.4248]

[525.7332]

            if (_find_square_wrapper(moves.target, monsfind_pos, 1,

Replacement in crawl-ref/source/directn.cc at line 709 [49.3697945]

B:BD[525.7479] → [525.7479:7567]

                moves.tx = monsfind_pos[0];
                moves.ty = monsfind_pos[1];

[525.7479]

[525.7567]

                moves.target = monsfind_pos;

Replacement in crawl-ref/source/directn.cc at line 728 [49.3697945]
∅:D[162.15498] → [508.6515:6591]
B:BD[508.6515] → [508.6515:6591]
```
            moves.tx += Compass[i].x;
            moves.ty += Compass[i].y;
```
[162.15498]
[508.6591]
```
            moves.target += Compass[i];
```

Replacement in crawl-ref/source/directn.cc at line 744 [49.3697945]

B:BD[508.7079] → [526.3992:4086]

                moves.dx       = Compass[i].x;
                moves.dy       = Compass[i].y;

[508.7079]

[508.7161]

                moves.delta    = Compass[i];

Replacement in crawl-ref/source/directn.cc at line 746 [49.3697945]

B:BD[508.7231] → [526.4087:4197]

                moves.tx       = you.x_pos + moves.dx;
                moves.ty       = you.y_pos + moves.dy;

[508.7231]

[526.4197]

                moves.target   = you.pos() + moves.delta;

Replacement in crawl-ref/source/directn.cc at line 758 [49.3697945]

B:BD[522.10069] → [522.10069:10205]

                {
                    moves.tx += Compass[i].x * 3;
                    moves.ty += Compass[i].y * 3;
                }

[522.10069]

[522.10205]

                    moves.target += Compass[i] * 3;

Replacement in crawl-ref/source/directn.cc at line 760 [49.3697945]

B:BD[522.10226] → [522.10226:10354]

                {
                    moves.tx += Compass[i].x;
                    moves.ty += Compass[i].y;
                }

[522.10226]

[508.7694]

                    moves.target += Compass[i];

Replacement in crawl-ref/source/directn.cc at line 791 [49.3697945]

B:BD[515.2904] → [61.46107:46167]

            show_beam = find_ray(you.pos(), moves.target(),

[515.2904]

[515.2979]

            show_beam = find_ray(you.pos(), moves.target,

Replacement in crawl-ref/source/directn.cc at line 812 [49.3697945]

B:BD[150.7784] → [61.46168:46232]

                show_beam = find_ray(you.pos(), moves.target(),

[150.7784]

[454.8101]

                show_beam = find_ray(you.pos(), moves.target,

Replacement in crawl-ref/source/directn.cc at line 819 [49.3697945]

B:BD[514.1643] → [514.1643:1763]

            moves.tx = you.x_pos;
            moves.ty = you.y_pos;
            moves.dx = 0;
            moves.dy = 0;

[514.1643]

[514.1763]

            moves.target = you.pos();
            moves.delta.reset();

Replacement in crawl-ref/source/directn.cc at line 830 [49.3697945]

B:BD[162.15634] → [61.46233:46302]

            if (_find_square_wrapper(moves.target(), objfind_pos, 1,

[162.15634]

[162.15707]

            if (_find_square_wrapper(moves.target, objfind_pos, 1,

Replacement in crawl-ref/source/directn.cc at line 835 [49.3697945]

B:BD[514.2346] → [514.2346:2432]

                moves.tx = objfind_pos[0];
                moves.ty = objfind_pos[1];

[514.2346]

[514.2432]

                moves.target = objfind_pos;

Replacement in crawl-ref/source/directn.cc at line 876 [49.3697945]

B:BD[508.8867] → [526.4655:4757]

                    moves.tx       = montarget->x;
                    moves.ty       = montarget->y;

[508.8867]

[526.4757]

                    moves.target   = montarget->pos();

Replacement in crawl-ref/source/directn.cc at line 897 [49.3697945]

B:BD[513.7133] → [513.7133:7269]

                && mgrd[moves.tx][moves.ty] != NON_MONSTER
                && _mon_submerged_in_water(&menv[mgrd[moves.tx][moves.ty]]))

[513.7133]

[513.7269]

                && mgrd(moves.target) != NON_MONSTER
                && _mon_submerged_in_water(&menv[mgrd(moves.target)]))

Replacement in crawl-ref/source/directn.cc at line 906 [49.3697945]
B:BD[158.21623] → [158.21623:21672]
```
            you.prev_grd_targ = coord_def(0, 0);
```
[158.21623]
[150.7791]
```
            you.prev_grd_targ.reset();
```
Replacement in crawl-ref/source/directn.cc at line 909 [49.3697945]
∅:D[514.2863] → [508.9209:9253]
∅:D[526.4890] → [508.9209:9253]
B:BD[508.9209] → [508.9209:9253]
```
            mid = mgrd[moves.tx][moves.ty];
```
[526.4890]
[158.21675]
```
            mid = mgrd(moves.target);
```
Replacement in crawl-ref/source/directn.cc at line 913 [49.3697945]
B:BD[508.9328] → [441.9324:9374]
```
            else if (moves.target() == you.pos())
```
[508.9328]
[158.21746]
```
            else if (moves.target == you.pos())
```

Replacement in crawl-ref/source/directn.cc at line 916 [49.3697945]

B:BD[158.21804] → [158.21804:21871]

                you.prev_grd_targ = coord_def(moves.tx, moves.ty);

[158.21804]

[525.8105]

                you.prev_grd_targ = moves.target;

Replacement in crawl-ref/source/directn.cc at line 927 [49.3697945]

B:BD[508.9483] → [61.46303:46375]

            if (_find_square_wrapper( moves.target(), objfind_pos, dir,

[508.9483]

[162.15940]

            if (_find_square_wrapper( moves.target, objfind_pos, dir,

Replacement in crawl-ref/source/directn.cc at line 933 [49.3697945]

B:BD[508.9817] → [508.9817:9903]

                moves.tx = objfind_pos[0];
                moves.ty = objfind_pos[1];

[508.9817]

[508.9903]

                moves.target = objfind_pos;

Replacement in crawl-ref/source/directn.cc at line 943 [49.3697945]

B:BD[508.10205] → [61.46376:46449]

            if (_find_square_wrapper( moves.target(), monsfind_pos, dir,

[508.10205]

[162.16303]

            if (_find_square_wrapper( moves.target, monsfind_pos, dir,

Replacement in crawl-ref/source/directn.cc at line 947 [49.3697945]

B:BD[508.10376] → [508.10376:10464]

                moves.tx = monsfind_pos[0];
                moves.ty = monsfind_pos[1];

[508.10376]

[508.10464]

                moves.target = monsfind_pos;

Replacement in crawl-ref/source/directn.cc at line 967 [49.3697945]

B:BD[527.792] → [2.162:225]

            if (!you.wizard || !in_bounds(moves.tx, moves.ty))

[527.792]

[527.840]

            if (!you.wizard || !in_bounds(moves.target))

Replacement in crawl-ref/source/directn.cc at line 970 [49.3697945]
∅:D[512.7572] → [527.863:907]
B:BD[527.863] → [527.863:907]
```
            mid = mgrd[moves.tx][moves.ty];
```
[512.7572]
[527.907]
```
            mid = mgrd(moves.target);
```

Replacement in crawl-ref/source/directn.cc at line 1006 [49.3697945]

B:BD[528.10986] → [528.10986:11049]

            if (!you.wizard || !in_bounds(moves.tx, moves.ty))

[528.10986]

[528.11049]

            if (!you.wizard || !in_bounds(moves.target))

Replacement in crawl-ref/source/directn.cc at line 1008 [49.3697945]
B:BD[528.11072] → [528.11072:11116]
```
            mid = mgrd[moves.tx][moves.ty];
```
[528.11072]
[528.11116]
```
            mid = mgrd(moves.target);
```

Replacement in crawl-ref/source/directn.cc at line 1017 [49.3697945]

B:BD[341.34969] → [341.34969:35032]

            if (!you.wizard || !in_bounds(moves.tx, moves.ty))

[341.34969]

[341.35032]

            if (!you.wizard || !in_bounds(moves.target))

Replacement in crawl-ref/source/directn.cc at line 1019 [49.3697945]
B:BD[341.35055] → [341.35055:35099]
```
            mid = mgrd[moves.tx][moves.ty];
```
[341.35055]
[341.35099]
```
            mid = mgrd(moves.target);
```

Replacement in crawl-ref/source/directn.cc at line 1027 [49.3697945]

B:BD[529.10593] → [529.10593:10656]

            if (!you.wizard || !in_bounds(moves.tx, moves.ty))

[529.10593]

[529.10656]

            if (!you.wizard || !in_bounds(moves.target))

Replacement in crawl-ref/source/directn.cc at line 1029 [49.3697945]
B:BD[529.10679] → [529.10679:10723]
```
            mid = mgrd[moves.tx][moves.ty];
```
[529.10679]
[529.10723]
```
            mid = mgrd(moves.target);
```

Replacement in crawl-ref/source/directn.cc at line 1037 [49.3697945]

B:BD[530.2736] → [530.2736:2799]

            if (!you.wizard || !in_bounds(moves.tx, moves.ty))

[530.2736]

[530.2799]

            if (!you.wizard || !in_bounds(moves.target))

Replacement in crawl-ref/source/directn.cc at line 1039 [49.3697945]

B:BD[530.2822] → [530.2822:2885]

            wizard_move_player_or_monster(moves.tx, moves.ty);

[530.2822]

[530.2885]

            wizard_move_player_or_monster(moves.target);

Replacement in crawl-ref/source/directn.cc at line 1047 [49.3697945]

B:BD[143.10739] → [143.10739:10802]

            if (!you.wizard || !in_bounds(moves.tx, moves.ty))

[143.10739]

[143.10802]

            if (!you.wizard || !in_bounds(moves.target))

Replacement in crawl-ref/source/directn.cc at line 1049 [49.3697945]
B:BD[143.10825] → [143.10825:10869]
```
            mid = mgrd[moves.tx][moves.ty];
```
[143.10825]
[143.10869]
```
            mid = mgrd(moves.target);
```

Replacement in crawl-ref/source/directn.cc at line 1060 [49.3697945]

B:BD[45.86937] → [45.86937:87000]

            if (!you.wizard || !in_bounds(moves.tx, moves.ty))

[45.86937]

[45.87000]

            if (!you.wizard || !in_bounds(moves.target))

Replacement in crawl-ref/source/directn.cc at line 1062 [49.3697945]

B:BD[45.87023] → [45.87023:87134]

            mid = mgrd[moves.tx][moves.ty];
            if (mid == NON_MONSTER && you.pos() != moves.target())

[45.87023]

[45.87134]

            mid = mgrd(moves.target);
            if (mid == NON_MONSTER && you.pos() != moves.target)

Replacement in crawl-ref/source/directn.cc at line 1070 [49.3697945]
B:BD[508.10760] → [531.9502:9552]
```
            full_describe_square(moves.target());
```
[508.10760]
[532.617]
```
            full_describe_square(moves.target);
```
Replacement in crawl-ref/source/directn.cc at line 1100 [49.3697945]
B:BD[143.10994] → [441.9375:9422]
```
                && moves.target() == you.pos()
```
[143.10994]
[143.11060]
```
                && moves.target == you.pos()
```

Replacement in crawl-ref/source/directn.cc at line 1120 [49.3697945]

B:BD[520.1475] → [533.2876:2946]

            else if (moves.isTarget && !see_grid(moves.tx, moves.ty))

[520.1475]

[508.11573]

            else if (moves.isTarget && !see_grid(moves.target))

Replacement in crawl-ref/source/directn.cc at line 1139 [49.3697945]

B:BD[508.11989] → [521.2305:2384]

        if ( !in_viewport_bounds(grid2viewX(moves.tx), grid2viewY(moves.ty)) )

[518.1386]

[49.3704091]

        if ( !in_viewport_bounds(grid2view(moves.target)) )

Replacement in crawl-ref/source/directn.cc at line 1142 [49.3697945]
∅:D[516.1224] → [508.12036:12098]
B:BD[49.3704101] → [508.12036:12098]
```
            moves.tx = old_tx;
            moves.ty = old_ty;
```
[516.1224]
[515.3404]
```
            moves.target = old_target;
```
Replacement in crawl-ref/source/directn.cc at line 1147 [49.3697945]
B:BD[515.3449] → [143.11165:11219]
```
        if (old_tx != moves.tx || old_ty != moves.ty)
```
[515.3449]
[515.3505]
```
        if (old_target != moves.target)
```

Replacement in crawl-ref/source/directn.cc at line 1150 [49.3697945]

B:BD[515.3546] → [61.46450:46523]

            show_beam = show_beam && find_ray(you.pos(), moves.target(),

[515.3546]

[61.46523]

            show_beam = show_beam && find_ray(you.pos(), moves.target,

Replacement in crawl-ref/source/directn.cc at line 1166 [49.3697945]
B:BD[520.1815] → [531.9553:9604]
```
            terse_describe_square(moves.target());
```
[520.1815]
[49.3704355]
```
            terse_describe_square(moves.target);
```

Replacement in crawl-ref/source/directn.cc at line 1172 [49.3697945]

B:BD[71.6382] → [61.46591:46655]

            || show_beam && find_ray(you.pos(), moves.target(),

[71.6382]

[71.6461]

            || show_beam && find_ray(you.pos(), moves.target,

Replacement in crawl-ref/source/directn.cc at line 1181 [49.3697945]

B:BD[143.11454] → [143.11454:11574]

                && in_vlos(grid2viewX(moves.tx), grid2viewY(moves.ty))
                && moves.target() != you.pos() )

[143.11454]

[515.3942]

                && in_vlos(grid2view(moves.target))
                && moves.target != you.pos() )

Replacement in crawl-ref/source/directn.cc at line 1187 [49.3697945]

B:BD[520.2008] → [533.3311:3367]

                while (raycopy.pos() != moves.target())

[520.2008]

[515.4144]

                while (raycopy.pos() != moves.target)

Replacement in crawl-ref/source/directn.cc at line 1198 [49.3697945]

B:BD[515.4543] → [454.8334:8395]

                    raycopy.advance_through(moves.target());

[515.4543]

[515.4582]

                    raycopy.advance_through(moves.target);

Replacement in crawl-ref/source/directn.cc at line 1202 [49.3697945]

B:BD[58.5934634] → [58.5934634:5934695]

                draw_ray_glyph(moves.target(), MAGENTA, '*',

[58.5934634]

[513.7831]

                draw_ray_glyph(moves.target, MAGENTA, '*',

Replacement in crawl-ref/source/directn.cc at line 1213 [49.3697945]
B:BD[49.3704387] → [441.9423:9471]
```
    moves.isMe = (moves.target() == you.pos());
```
[49.3704387]
[534.320]
```
    moves.isMe = (moves.target == you.pos());
```
Replacement in crawl-ref/source/directn.cc at line 1326 [49.3697945]
B:BD[522.10550] → [522.10550:10582]
```
    if (!moves.dx && !moves.dy)
```
[522.10550]
[522.10582]
```
    if ( moves.delta.origin() )
```

Replacement in crawl-ref/source/directn.cc at line 1332 [49.3697945]

B:BD[522.10691] → [522.10691:10713]

B:BD[522.10713] → [454.8396:8432]

∅:D[454.8432] → [522.10750:10796]

B:BD[522.10750] → [522.10750:10796]

    if (moves.dx > 0)
        mx = (GXM - 1) - you.x_pos;
    if (moves.dx < 0)
        mx = you.x_pos;

[522.10691]

[522.10796]

    if (moves.delta.x > 0)
        mx = (GXM - 1) - you.pos().x;
    if (moves.delta.x < 0)
        mx = you.pos().x;

Replacement in crawl-ref/source/directn.cc at line 1337 [49.3697945]

B:BD[522.10797] → [522.10797:10901]

    if (moves.dy > 0)
        my = (GYM - 1) - you.y_pos;
    if (moves.dy < 0)
        my = you.y_pos;

[522.10797]

[522.10901]

    if (moves.delta.y > 0)
        my = (GYM - 1) - you.pos().y;
    if (moves.delta.y < 0)
        my = you.pos().y;

Replacement in crawl-ref/source/directn.cc at line 1349 [49.3697945]

B:BD[522.11021] → [522.11021:11105]

    moves.tx = you.x_pos + moves.dx * mx;
    moves.ty = you.y_pos + moves.dy * my;

[522.11021]

[522.11105]

    moves.target.x = you.pos().x + moves.delta.x * mx;
    moves.target.y = you.pos().y + moves.delta.y * my;

Replacement in crawl-ref/source/directn.cc at line 1619 [49.3697945]

∅:D[61.48358] → [162.17372:17440]

B:BD[162.17372] → [162.17372:17440]

                          FixedVector<char, 2> &mfp, int direction,

[61.48358]

[61.48359]

                          coord_def &mfp, int direction,

Replacement in crawl-ref/source/directn.cc at line 1689 [49.3697945]

B:BD[519.941] → [437.1832:1894]

                mfp[0] = ctrx;
                mfp[1] = ctry;

[519.941]

[519.1007]

                mfp = vyou;

Replacement in crawl-ref/source/directn.cc at line 1692 [49.3697945]

B:BD[519.1049] → [61.48714:48785]

            return _find_square(coord_def(ctrx, ctry), mfp, direction,

[519.1049]

[61.48785]

            return _find_square(vyou, mfp, direction,

Replacement in crawl-ref/source/directn.cc at line 1808 [49.3697945]

B:BD[49.3717161] → [68.464217:464329]

        const int targ_x = you.x_pos + temp_xps - ctrx;
        const int targ_y = you.y_pos + temp_yps - ctry;

[49.3717161]

[49.3717268]

        const int targ_x = you.pos().x + temp_xps - ctrx;
        const int targ_y = you.pos().y + temp_yps - ctry;

Replacement in crawl-ref/source/directn.cc at line 1826 [49.3697945]
∅:D[151.17940] → [49.3718054:3718116]
∅:D[68.464724] → [49.3718054:3718116]
B:BD[49.3718054] → [49.3718054:3718116]
```
            mfp[0] = temp_xps;
            mfp[1] = temp_yps;
```
[151.17940]
[49.3718116]
```
            mfp.set(temp_xps, temp_yps);
```

Replacement in crawl-ref/source/directn.cc at line 1843 [49.3697945]

∅:D[61.49470] → [162.18439:18516]

B:BD[162.18439] → [162.18439:18516]

                                  FixedVector<char, 2> &mfp, char direction,

[61.49470]

[61.49471]

                                  coord_def& mfp, char direction,

Replacement in crawl-ref/source/directn.cc at line 1852 [49.3697945]
∅:D[535.1260] → [508.13333:13399]
∅:D[511.8070] → [508.13333:13399]
∅:D[415.14446] → [508.13333:13399]
∅:D[162.18993] → [508.13333:13399]
B:BD[508.13333] → [508.13333:13399]
```
    mfp[0] = view2gridX(mfp[0]);
    mfp[1] = view2gridY(mfp[1]);
```
[162.18993]
[508.13399]
```
    mfp = view2grid(mfp);
```

Replacement in crawl-ref/source/describe.cc at line 1640 [49.3736416]

B:BD[536.9979] → [536.9979:10038]

                    << "x: " << item.x << " y: " << item.y

[536.9979]

[536.10038]

                    << "x: " << item.pos.x << " y: " << item.pos.y

Replacement in crawl-ref/source/delay.cc at line 225 [49.3963459]
B:BD[537.2801] → [538.4580:4627]
```
    seed_rng( weight + you.x_pos + you.y_pos);
```
[537.2801]
[538.4627]
```
    seed_rng( weight + you.pos().x + you.pos().y);
```

Replacement in crawl-ref/source/delay.cc at line 731 [49.3963459]

B:BD[51.998082] → [51.998082:998132]

B:BD[51.998132] → [539.2675:2726]

            && mitm[ delay.parm1 ].x == you.x_pos
            && mitm[ delay.parm1 ].y == you.y_pos)

[51.998082]

[49.3968122]

            && mitm[ delay.parm1 ].pos == you.pos())

Replacement in crawl-ref/source/delay.cc at line 1423 [49.3963459]
∅:D[540.2927] → [51.1011384:1011449]
∅:D[134.3869] → [51.1011384:1011449]
B:BD[51.1011384] → [51.1011384:1011449]
```
    return direction_to_command( you.running.x, you.running.y );
```
[134.3869]
[51.1011449]
```
    return direction_to_command( you.running.pos.x, you.running.pos.y );
```
Replacement in crawl-ref/source/decks.cc at line 1367 [49.3987460]
B:BD[541.1521] → [541.1521:1575]
```
        mon.x = you.x_pos;
        mon.y = you.y_pos;
```
[541.1521]
[541.1575]
```
        mon.moveto(you.pos());
```

Replacement in crawl-ref/source/decks.cc at line 1470 [49.3987460]

B:BD[542.19134] → [542.19134:19160]

B:BD[542.19160] → [467.16320:16398]

    int fx = -1, fy = -1;
    for (int dx = -1; dx <= 1; ++dx)
        for (int dy = -1; dy <= 1; ++dy)

[542.19134]

[49.3997949]

    coord_def f;
    for (adjacent_iterator ai; ai; ++ai)
    {
        if (grd(*ai) == DNGN_FLOOR
            && trap_at_xy(*ai) == -1
            && one_chance_in(++count))

Replacement in crawl-ref/source/decks.cc at line 1477 [49.3987460]
B:BD[49.3997959] → [542.19249:19287]
∅:D[542.19287] → [49.3998036:3998062]
B:BD[49.3998036] → [49.3998036:3998062]
B:BD[49.3998062] → [472.58816:58817]
∅:D[472.58817] → [542.19288:19374]
B:BD[49.3998062] → [542.19288:19374]
B:BD[542.19374] → [472.58818:58819]
B:BD[472.58819] → [61.51876:51956]
∅:D[61.51956] → [467.16468:16511]
B:BD[467.16468] → [467.16468:16511]
∅:D[467.16511] → [49.3998259:3998273]
∅:D[542.19446] → [49.3998259:3998273]
∅:D[472.58934] → [49.3998259:3998273]
B:BD[49.3998259] → [49.3998259:3998273]
B:BD[49.3998273] → [472.58935:58987]
∅:D[542.19587] → [49.3998359:3998373]
∅:D[472.58987] → [49.3998359:3998373]
B:BD[49.3998359] → [49.3998359:3998373]
```
            if ( dx == 0 && dy == 0 )
                continue;
            const int rx = you.x_pos + dx;
            const int ry = you.y_pos + dy;
            if (grd[rx][ry] == DNGN_FLOOR && trap_at_xy(coord_def(rx,ry)) == -1
                && one_chance_in(++count))
            {
                 fx = rx;
                 fy = ry;
            }
```
[49.3997959]
[49.3998552]
```
            f = *ai;
```
Insertion in crawl-ref/source/decks.cc at line 1479 [49.3987460]
[49.3998562]
[49.3998714]
```
    }
```
Replacement in crawl-ref/source/decks.cc at line 1481 [49.3987460]
B:BD[49.3998715] → [467.16512:16558]
```
    if (fx >= 0)              // found a spot
```
[49.3998715]
[542.19643]
```
    if (count > 0)              // found a spot
```
Replacement in crawl-ref/source/decks.cc at line 1483 [49.3987460]
B:BD[542.19649] → [467.16559:16615]
```
        if (place_specific_trap(fx, fy, TRAP_TELEPORT))
```
[542.19649]
[49.3998967]
```
        if (place_specific_trap(f, TRAP_TELEPORT))
```

Replacement in crawl-ref/source/decks.cc at line 1488 [49.3987460]

B:BD[542.19827] → [61.51957:52018]

                const int i = trap_at_xy(coord_def(fx, fy));

[542.19827]

[542.19877]

                const int i = trap_at_xy(f);

Replacement in crawl-ref/source/decks.cc at line 1490 [49.3987460]

B:BD[542.19933] → [542.19933:20000]

                    grd[fx][fy] = trap_category(env.trap[i].type);

[542.19933]

[543.2965]

                    grd(f) = trap_category(env.trap[i].type);

Replacement in crawl-ref/source/decks.cc at line 1523 [49.3987460]

B:BD[543.3469] → [467.16721:16792]

            if (place_specific_trap(you.x_pos, you.y_pos, TRAP_SHAFT))

[543.3469]

[543.3542]

            if (place_specific_trap(you.pos(), TRAP_SHAFT))

Replacement in crawl-ref/source/decks.cc at line 1552 [49.3987460]

B:BD[441.10394] → [441.10394:10458]

                place_specific_trap(ri->x, ri->y, TRAP_RANDOM);

[441.10394]

[544.960]

                place_specific_trap(*ri, TRAP_RANDOM);

Insertion in crawl-ref/source/debug.h at line 117 [49.4011741]
[341.35329]
[468.5539]
```
class coord_def;
```
Replacement in crawl-ref/source/debug.h at line 120 [49.4011741]
B:BD[529.11006] → [530.3024:3074]
```
void wizard_move_player_or_monster(int x, int y);
```
[529.11006]
[468.5591]
```
void wizard_move_player_or_monster(const coord_def& where);
```

Replacement in crawl-ref/source/debug.cc at line 524 [49.4016436]

B:BD[175.10286] → [441.11274:11383]

    if (!dgn_place_monster(mspec, you.your_level,
                           place.x, place.y, true, false))

[175.10286]

[341.36447]

    if (!dgn_place_monster(mspec, you.your_level, place, true, false))

Replacement in crawl-ref/source/debug.cc at line 1693 [49.4016436]
B:BD[49.4045781] → [49.4045781:4045829]
```
    struct dist stth;
    int steth_x, steth_y;
```
[49.4045781]
[304.35017]
```
    dist stth;
    coord_def stethpos;
```

Replacement in crawl-ref/source/debug.cc at line 1710 [49.4016436]

B:BD[49.4046058] → [49.4046058:4046140]

        {
            steth_x = stth.tx;
            steth_y = stth.ty;
        }

[49.4046058]

[49.4046140]

            stethpos = stth.target;

Replacement in crawl-ref/source/debug.cc at line 1712 [49.4016436]

B:BD[49.4046153] → [49.4046153:4046259]

        {
            steth_x = you.x_pos + stth.dx;
            steth_y = you.x_pos + stth.dy;
        }

[49.4046153]

[49.4046259]

            stethpos = you.pos() + stth.delta;

Replacement in crawl-ref/source/debug.cc at line 1714 [49.4016436]
B:BD[49.4046260] → [49.4046260:4046316]
```
        if (env.cgrid[steth_x][steth_y] != EMPTY_CLOUD)
```
[49.4046260]
[49.4046316]
```
        if (env.cgrid(stethpos) != EMPTY_CLOUD)
```

Replacement in crawl-ref/source/debug.cc at line 1717 [49.4016436]

∅:D[175.11142] → [545.21806:21937]

B:BD[545.21806] → [545.21806:21937]

                 env.cloud[ env.cgrid[steth_x][steth_y] ].type,
                 env.cloud[ env.cgrid[steth_x][steth_y] ].decay );

[175.11142]

[49.4046578]

                 env.cloud[ env.cgrid(stethpos) ].type,
                 env.cloud[ env.cgrid(stethpos) ].decay );

Replacement in crawl-ref/source/debug.cc at line 1721 [49.4016436]
B:BD[49.4046589] → [49.4046589:4046640]
```
        if (mgrd[steth_x][steth_y] == NON_MONSTER)
```
[49.4046589]
[49.4046640]
```
        if (mgrd(stethpos) == NON_MONSTER)
```

Replacement in crawl-ref/source/debug.cc at line 1723 [49.4016436]

B:BD[49.4046650] → [545.21938:22018]

            mprf(MSGCH_DIAGNOSTICS, "item grid = %d", igrd[steth_x][steth_y] );

[49.4046650]

[49.4046777]

            mprf(MSGCH_DIAGNOSTICS, "item grid = %d", igrd(stethpos) );

Replacement in crawl-ref/source/debug.cc at line 1727 [49.4016436]
B:BD[49.4046808] → [49.4046808:4046844]
```
        i = mgrd[steth_x][steth_y];
```
[49.4046808]
[49.4046844]
```
        i = mgrd(stethpos);
```
Insertion in crawl-ref/source/debug.cc at line 1729 [49.4016436]
[49.4046850]
[49.4046850]
```
    monsters& mons(menv[i]);
```

Replacement in crawl-ref/source/debug.cc at line 1734 [49.4016436]

B:BD[545.22092] → [364.4255:4306]

∅:D[364.4306] → [545.22170:22218]

∅:D[363.12989] → [545.22170:22218]

B:BD[545.22170] → [545.22170:22218]

B:BD[545.22218] → [546.2849:3109]

         menv[i].name(DESC_CAP_THE, true).c_str(),
         i, menv[i].type, menv[i].x, menv[i].y,
         ((menv[i].attitude == ATT_HOSTILE)       ? "hostile" :
          (menv[i].attitude == ATT_FRIENDLY)      ? "friendly" :
          (menv[i].attitude == ATT_NEUTRAL)       ? "neutral" :
          (menv[i].attitude == ATT_GOOD_NEUTRAL)  ? "good neutral"

[545.22092]

[546.3109]

         mons.name(DESC_CAP_THE, true).c_str(),
         i, mons.type, mons.pos().x, mons.pos().y,
         ((mons.attitude == ATT_HOSTILE)       ? "hostile" :
          (mons.attitude == ATT_FRIENDLY)      ? "friendly" :
          (mons.attitude == ATT_NEUTRAL)       ? "neutral" :
          (mons.attitude == ATT_GOOD_NEUTRAL)  ? "good neutral"

Replacement in crawl-ref/source/debug.cc at line 1746 [49.4016436]

∅:D[371.53365] → [547.9002:9058]

B:BD[547.9002] → [547.9002:9058]

B:BD[547.9058] → [175.11201:11254]

∅:D[175.11254] → [545.22657:22779]

B:BD[545.22657] → [545.22657:22779]

B:BD[545.22779] → [371.53366:53545]

∅:D[371.53545] → [545.22779:22821]

B:BD[545.22779] → [545.22779:22821]

         menv[i].hit_dice,
         menv[i].experience,
         menv[i].hit_points, menv[i].max_hit_points,
         menv[i].ac, menv[i].ev,
         mons_resist_magic( &menv[i] ),
         menv[i].speed, menv[i].speed_increment,
         menv[i].base_monster != MONS_PROGRAM_BUG ? " base=" : "",
         menv[i].base_monster != MONS_PROGRAM_BUG ?
         get_monster_data(menv[i].base_monster)->name : "",
         menv[i].number, menv[i].flags );

[371.53365]

[49.4047821]

         mons.hit_dice,
         mons.experience,
         mons.hit_points, mons.max_hit_points,
         mons.ac, mons.ev,
         mons_resist_magic( &mons ),
         mons.speed, mons.speed_increment,
         mons.base_monster != MONS_PROGRAM_BUG ? " base=" : "",
         mons.base_monster != MONS_PROGRAM_BUG ?
         get_monster_data(mons.base_monster)->name : "",
         mons.number, mons.flags );

Replacement in crawl-ref/source/debug.cc at line 1758 [49.4016436]
∅:D[468.6479] → [342.29987:30042]
B:BD[345.27896] → [342.29987:30042]
```
    const habitat_type hab = mons_habitat( &menv[i] );
```
[468.6479]
[49.4047952]
```
    const habitat_type hab = mons_habitat( &mons );
```

Replacement in crawl-ref/source/debug.cc at line 1767 [49.4016436]

B:BD[548.3813] → [25.2686:3077]

         (mons_is_sleeping(&menv[i])        ? "sleep" :
          mons_is_wandering(&menv[i])       ? "wander" :
          mons_is_seeking(&menv[i])         ? "seek" :
          mons_is_fleeing(&menv[i])         ? "flee" :
          mons_is_cornered(&menv[i])        ? "cornered" :
          mons_is_panicking(&menv[i])       ? "panic" :
          mons_is_lurking(&menv[i])         ? "lurk"

[548.3813]

[25.3077]

         (mons_is_sleeping(&mons)        ? "sleep" :
          mons_is_wandering(&mons)       ? "wander" :
          mons_is_seeking(&mons)         ? "seek" :
          mons_is_fleeing(&mons)         ? "flee" :
          mons_is_cornered(&mons)        ? "cornered" :
          mons_is_panicking(&mons)       ? "panic" :
          mons_is_lurking(&mons)         ? "lurk"

Replacement in crawl-ref/source/debug.cc at line 1775 [49.4016436]

∅:D[25.3135] → [545.23438:23579]

∅:D[548.3813] → [545.23438:23579]

∅:D[464.5145] → [545.23438:23579]

∅:D[345.28505] → [545.23438:23579]

B:BD[545.23438] → [545.23438:23579]

B:BD[545.23579] → [345.28506:28575]

∅:D[345.28575] → [364.4307:4370]

B:BD[545.23649] → [364.4307:4370]

B:BD[364.4370] → [549.5216:5267]

B:BD[549.5267] → [217.15648:15735]

         menv[i].behaviour,
         ((menv[i].foe == MHITYOU)            ? "you" :
          (menv[i].foe == MHITNOT)            ? "none" :
          (menv[menv[i].foe].type == -1)      ? "unassigned monster"
          : menv[menv[i].foe].name(DESC_PLAIN, true).c_str()),
         menv[i].foe,
         menv[i].foe_memory,
         menv[i].target_x, menv[i].target_y,
         god_name(menv[i].god).c_str() );

[25.3135]

[49.4049101]

         mons.behaviour,
         ((mons.foe == MHITYOU)            ? "you" :
          (mons.foe == MHITNOT)            ? "none" :
          (menv[mons.foe].type == -1)      ? "unassigned monster"
          : menv[mons.foe].name(DESC_PLAIN, true).c_str()),
         mons.foe,
         mons.foe_memory,
         mons.target.x, mons.target.y,
         god_name(mons.god).c_str() );

Replacement in crawl-ref/source/debug.cc at line 1787 [49.4016436]

B:BD[545.23966] → [545.23966:24161]

         mons_res_fire( &menv[i] ),
         mons_res_cold( &menv[i] ),
         mons_res_elec( &menv[i] ),
         mons_res_poison( &menv[i] ),
         mons_res_negative_energy( &menv[i] ) );

[545.23966]

[49.4050019]

         mons_res_fire( &mons ),
         mons_res_cold( &mons ),
         mons_res_elec( &mons ),
         mons_res_poison( &mons ),
         mons_res_negative_energy( &mons ) );

Replacement in crawl-ref/source/debug.cc at line 1794 [49.4016436]
B:BD[304.35069] → [550.11161:11212]
```
         menv[i].describe_enchantments().c_str());
```
[304.35069]
[49.4050056]
```
         mons.describe_enchantments().c_str());
```
Replacement in crawl-ref/source/debug.cc at line 1796 [49.4016436]
B:BD[49.4050057] → [175.11255:11297]
∅:D[175.11297] → [49.4050100:4050151]
B:BD[49.4050100] → [49.4050100:4050151]
```
    if (menv[i].type == MONS_PLAYER_GHOST
        || menv[i].type == MONS_PANDEMONIUM_DEMON)
```
[49.4050057]
[49.4050151]
```
    if (mons.type == MONS_PLAYER_GHOST
        || mons.type == MONS_PANDEMONIUM_DEMON)
```

Replacement in crawl-ref/source/debug.cc at line 1799 [49.4016436]

B:BD[49.4050157] → [155.34384:34472]

        ASSERT(menv[i].ghost.get());
        const ghost_demon &ghost = *menv[i].ghost;

[49.4050157]

[155.34472]

        ASSERT(mons.ghost.get());
        const ghost_demon &ghost = *mons.ghost;

Replacement in crawl-ref/source/debug.cc at line 1821 [49.4016436]

B:BD[49.4051117] → [545.24468:24536]

    mprf("    x: %d; y: %d; link: %d", item.x, item.y, item.link );

[49.4051117]

[158.23048]

    mprf("    x: %d; y: %d; link: %d", item.pos.x, item.pos.y, item.link );

Replacement in crawl-ref/source/debug.cc at line 1861 [49.4016436]

B:BD[49.4052594] → [49.4052594:4052652]

                if (mitm[obj].x != x || mitm[obj].y != y)

[49.4052594]

[49.4052652]

                if (mitm[obj].pos.x != x || mitm[obj].pos.y != y)

Replacement in crawl-ref/source/debug.cc at line 1890 [49.4016436]

B:BD[49.4053700] → [551.1400:1461]

        if ((mitm[i].x > 0 || mitm[i].y > 0) && !visited[i])

[49.4053700]

[49.4053799]

        if ((mitm[i].pos.x > 0 || mitm[i].pos.y > 0) && !visited[i])

Replacement in crawl-ref/source/debug.cc at line 1896 [49.4016436]

B:BD[545.24765] → [545.24765:24838]

                 mitm[i].x, mitm[i].y, igrd[ mitm[i].x ][ mitm[i].y ] );

[545.24765]

[49.4054076]

                 mitm[i].pos.x, mitm[i].pos.y, igrd( mitm[i].pos ));

Replacement in crawl-ref/source/debug.cc at line 1906 [49.4016436]
∅:D[364.4443] → [545.24974:25027]
∅:D[363.13134] → [545.24974:25027]
B:BD[545.24974] → [545.24974:25027]
```
                             menv[j].x, menv[j].y );
```
[364.4443]
[49.4054611]
```
                             menv[j].pos().x, menv[j].pos().y );
```

Replacement in crawl-ref/source/debug.cc at line 1967 [49.4016436]

B:BD[545.25190] → [363.13317:13362]

                  i, monster.x, monster.y );

[545.25190]

[175.11707]

                  i, monster.pos().x, monster.pos().y );

Replacement in crawl-ref/source/debug.cc at line 1989 [49.4016436]

∅:D[38.2866] → [552.3920:3989]

B:BD[552.3920] → [552.3920:3989]

                     x, y, m->name(DESC_PLAIN).c_str(), m->x, m->y);

[38.2866]

[38.2867]

                     x, y, m->name(DESC_PLAIN).c_str(), m->pos().x, m->pos().y);

Replacement in crawl-ref/source/debug.cc at line 2002 [49.4016436]

B:BD[38.3151] → [38.3151:3210]

                 m->name(DESC_PLAIN).c_str(), m->x, m->y);

[38.3151]

[38.3210]

                 m->name(DESC_PLAIN).c_str(), m->pos().x, m->pos().y);

Replacement in crawl-ref/source/debug.cc at line 2971 [49.4016436]

B:BD[179.2804] → [440.921:983]

        beam.target_x = mon.x;
        beam.target_y = mon.y;

[179.2804]

[440.983]

        beam.target = mon.pos();

Replacement in crawl-ref/source/debug.cc at line 3496 [49.4016436]
B:BD[51.1039048] → [51.1039048:1039101]
```
    place_specific_trap(you.x_pos, you.y_pos, trap);
```
[51.1039048]
[51.1039101]
```
    place_specific_trap(you.pos(), trap);
```
Replacement in crawl-ref/source/debug.cc at line 3547 [49.4016436]
B:BD[51.1040688] → [175.12459:12517]
```
    place_spec_shop(you.your_level, you.x_pos, you.y_pos,
```
[51.1040688]
[51.1040747]
```
    place_spec_shop(you.your_level, you.pos(),
```
Replacement in crawl-ref/source/debug.cc at line 4103 [49.4016436]
B:BD[529.15952] → [529.15952:15998]
```
    new_item.x    = 0;
    new_item.y    = 0;
```
[529.15952]
[529.15998]
```
    new_item.pos.reset();
```
Replacement in crawl-ref/source/debug.cc at line 4125 [49.4016436]
B:BD[530.3114] → [530.3114:3153]
```
static void _move_player(int x, int y)
```
[530.3113]
[530.3153]
```
static void _move_player(const coord_def& where)
```

Replacement in crawl-ref/source/debug.cc at line 4130 [49.4016436]

B:BD[530.3211] → [530.3211:3290]

B:BD[530.3290] → [61.52421:52482]

    if (!you.can_pass_through_feat(grd[x][y]))
        grd[x][y] = DNGN_FLOOR;
    move_player_to_grid(coord_def(x, y), false, true, true);

[530.3211]

[530.3340]

    if (!you.can_pass_through_feat(grd(where)))
        grd(where) = DNGN_FLOOR;
    move_player_to_grid(where, false, true, true);

Replacement in crawl-ref/source/debug.cc at line 4135 [49.4016436]
B:BD[530.3343] → [530.3343:3393]
```
static void _move_monster(int x, int y, int mid1)
```
[530.3343]
[530.3393]
```
static void _move_monster(const coord_def& where, int mid1)
```
Replacement in crawl-ref/source/debug.cc at line 4141 [49.4016436]
B:BD[530.3511] → [530.3511:3569]
```
    if (!moves.isValid || !in_bounds(moves.tx, moves.ty))
```
[530.3511]
[530.3569]
```
    if (!moves.isValid || !in_bounds(moves.target))
```
Replacement in crawl-ref/source/debug.cc at line 4147 [49.4016436]
B:BD[530.3697] → [553.3082:3123]
```
    int mid2 = mgrd[moves.tx][moves.ty];
```
[530.3697]
[553.3123]
```
    int mid2 = mgrd(moves.target);
```

Replacement in crawl-ref/source/debug.cc at line 4156 [49.4016436]

B:BD[529.16554] → [530.3934:4059]

    mon1->x = moves.tx;
    mon1->y = moves.ty;
    mgrd[moves.tx][moves.ty] = mid1;
    mon1->check_redraw(moves.target());

[529.16554]

[530.4059]

    mon1->moveto(moves.target);
    mgrd(moves.target) = mid1;
    mon1->check_redraw(moves.target);

Replacement in crawl-ref/source/debug.cc at line 4160 [49.4016436]
B:BD[530.4060] → [530.4060:4083]
```
    mgrd[x][y] = mid2;
```
[530.4060]
[530.4083]
```
    mgrd(where) = mid2;
```

Replacement in crawl-ref/source/debug.cc at line 4164 [49.4016436]

B:BD[530.4112] → [530.4112:4200]

        mon2->x = x;
        mon2->y = y;
        mon1->check_redraw(coord_def(x, y));

[530.4112]

[530.4200]

        mon2->moveto(where);
        mon1->check_redraw(where);

Replacement in crawl-ref/source/debug.cc at line 4169 [49.4016436]
B:BD[530.4209] → [530.4209:4258]
```
void wizard_move_player_or_monster(int x, int y)
```
[530.4209]
[530.4258]
```
void wizard_move_player_or_monster(const coord_def& where)
```
Replacement in crawl-ref/source/debug.cc at line 4184 [49.4016436]
B:BD[530.4502] → [530.4502:4528]
```
    int mid = mgrd[x][y];
```
[530.4502]
[530.4528]
```
    int mid = mgrd(where);
```
Replacement in crawl-ref/source/debug.cc at line 4187 [49.4016436]
B:BD[530.4557] → [530.4557:4585]
```
        _move_player(x, y);
```
[530.4557]
[530.4585]
```
        _move_player(where);
```
Replacement in crawl-ref/source/debug.cc at line 4189 [49.4016436]
B:BD[530.4594] → [530.4594:4628]
```
        _move_monster(x, y, mid);
```
[530.4594]
[530.4628]
```
        _move_monster(where, mid);
```
Replacement in crawl-ref/source/debug.cc at line 4214 [49.4016436]
B:BD[448.4588] → [448.4588:4628]
```
         mon.x, mon.y, dest.x, dest.y);
```
[448.4588]
[143.12029]
```
         mon.pos().x, mon.pos().y, dest.x, dest.y);
```

Replacement in crawl-ref/source/debug.cc at line 4594 [49.4016436]

B:BD[554.11525] → [554.11525:11666]

            for (int y = 0; y < GYM; ++y)
                for (int x = 0; x < GXM; ++x)
                    set_envmap_obj(x, y, grd[x][y]);

[554.11525]

[175.12633]

            coord_def c;
            for (c.y = 0; c.y < GYM; ++c.y)
                for (c.x = 0; c.x < GXM; ++c.x)
                    set_envmap_obj(c, grd(c));

Replacement in crawl-ref/source/clua.cc at line 735 [68.483969]
B:BD[68.499071] → [15.2974:3021]
```
LUARET2(you_pos, number, you.x_pos, you.y_pos)
```
[68.499071]
[68.499071]
```
LUARET2(you_pos, number, you.pos().x, you.pos().y)
```

Replacement in crawl-ref/source/clua.cc at line 1054 [68.483969]

B:BD[68.506120] → [68.506120:506182]

static int item_on_floor(const item_def &item, int x, int y);

[68.506120]

[68.506182]

static int item_on_floor(const item_def &item, const coord_def& where);

Replacement in crawl-ref/source/clua.cc at line 1091 [68.483969]

B:BD[68.506975] → [68.506975:507040]

    int floor_link = item_on_floor(*item, you.x_pos, you.y_pos);

[68.506975]

[68.507040]

    int floor_link = item_on_floor(*item, you.pos());

Replacement in crawl-ref/source/clua.cc at line 1594 [68.483969]

B:BD[68.517299] → [68.517299:517360]

static int item_on_floor(const item_def &item, int x, int y)

[68.517299]

[68.517360]

static int item_on_floor(const item_def &item, const coord_def& where)

Replacement in crawl-ref/source/clua.cc at line 1597 [68.483969]

B:BD[68.517417] → [68.517417:517491]

    for (int link = igrd[x][y]; link != NON_ITEM; link = mitm[link].link)

[68.517417]

[68.517491]

    for (int link = igrd(where); link != NON_ITEM; link = mitm[link].link)

Replacement in crawl-ref/source/clua.cc at line 1617 [68.483969]

B:BD[68.517808] → [68.517808:517872]

        int ilink =  item_on_floor(item, you.x_pos, you.y_pos);

[68.517808]

[68.517872]

        int ilink =  item_on_floor(item, you.pos());

Replacement in crawl-ref/source/clua.cc at line 2335 [68.483969]

B:BD[68.532889] → [68.532889:532944]

    lua_pushnumber(ls, int(mons->x) - int(you.x_pos));

[68.532889]

[68.532944]

    lua_pushnumber(ls, int(mons->pos().x) - int(you.pos().x));

Replacement in crawl-ref/source/clua.cc at line 2341 [68.483969]

B:BD[68.533034] → [68.533034:533089]

    lua_pushnumber(ls, int(mons->y) - int(you.y_pos));

[68.533034]

[68.533089]

    lua_pushnumber(ls, int(mons->pos().y) - int(you.pos().y));

Replacement in crawl-ref/source/cloud.cc at line 78 [49.4095717]

B:BD[162.31755] → [61.52948:53032]

    env.cloud[ cloud ].x           = p.x;
    env.cloud[ cloud ].y           = p.y;

[162.31755]

[162.31835]

    env.cloud[ cloud ].pos         = p;

Replacement in crawl-ref/source/cloud.cc at line 110 [49.4095717]
B:BD[555.4288] → [441.11941:11997]
```
    for ( adjacent_iterator ai(cloud.pos()); ai; ++ai )
```
[555.4288]
[555.4326]
```
    for ( adjacent_iterator ai(cloud.pos); ai; ++ai )
```

Replacement in crawl-ref/source/cloud.cc at line 167 [49.4095717]

∅:D[163.8968] → [555.5864:5937]

B:BD[555.5864] → [555.5864:5937]

            && grd[env.cloud[cc].x][env.cloud[cc].y] == DNGN_DEEP_WATER)

[163.8968]

[555.5937]

            && grd(env.cloud[cc].pos) == DNGN_DEEP_WATER)

Replacement in crawl-ref/source/cloud.cc at line 172 [49.4095717]

∅:D[163.9019] → [555.6097:6168]

B:BD[555.6097] → [555.6097:6168]

                && grd[env.cloud[cc].x][env.cloud[cc].y] == DNGN_LAVA)

[163.9019]

[555.6168]

                 && grd(env.cloud[cc].pos) == DNGN_LAVA)

Replacement in crawl-ref/source/cloud.cc at line 178 [49.4095717]

B:BD[392.4648] → [61.53881:53938]

                                env.cloud[cc].pos(), 2);

[392.4648]

[392.4715]

                                env.cloud[cc].pos, 2);

Replacement in crawl-ref/source/cloud.cc at line 188 [49.4095717]

B:BD[555.6554] → [61.53939:54001]

        const coord_def cloud_pos = env.cloud[ cloud ].pos();

[555.6554]

[555.6654]

        const coord_def cloud_pos = env.cloud[ cloud ].pos;

Replacement in crawl-ref/source/cloud.cc at line 192 [49.4095717]

B:BD[162.32883] → [162.32883:32973]

        env.cloud[ cloud ].x            = 0;
        env.cloud[ cloud ].y            = 0;

[162.32883]

[162.32973]

        env.cloud[ cloud ].pos.reset();

Replacement in crawl-ref/source/cloud.cc at line 207 [49.4095717]

B:BD[49.4097020] → [49.4097020:4097117]

        const int old_x = env.cloud[ cloud ].x;
        const int old_y = env.cloud[ cloud ].y;

[49.4097020]

[61.54113]

        const coord_def oldpos = env.cloud[cloud].pos;
        env.cgrid(oldpos) = EMPTY_CLOUD;

Replacement in crawl-ref/source/cloud.cc at line 210 [49.4095717]
B:BD[61.54148] → [61.54148:54244]
∅:D[162.33161] → [49.4097238:4097289]
∅:D[61.54244] → [49.4097238:4097289]
B:BD[49.4097238] → [49.4097238:4097289]
```
        env.cloud[ cloud ].x        = newpos.x;
        env.cloud[ cloud ].y        = newpos.y;
        env.cgrid[ old_x ][ old_y ] = EMPTY_CLOUD;
```
[61.54148]
[49.4097289]
```
        env.cloud[cloud].pos = newpos;
```

Replacement in crawl-ref/source/beam.h at line 111 [49.4124541]

∅:D[556.8287] → [135.105841:105895]

B:BD[135.105841] → [135.105841:105895]

    int         source_x, source_y;    // beam origin

[556.8287]

[135.105895]

    coord_def   source;                // beam origin
    coord_def   target;                // intended target
    coord_def   pos;                   // actual position

Deletion in crawl-ref/source/beam.h at line 116 [49.4124541]
B:BD[135.105952] → [135.105952:106010]
B:BD[135.106010] → [557.689:747]
```
    int         target_x, target_y;    // intended target
    coord_def   pos;                   // actual position
```
Deletion in crawl-ref/source/beam.h at line 170 [49.4124541]
B:BD[135.108354] → [135.108354:108438]
B:BD[135.108438] → [61.54857:54947]
∅:D[61.54947] → [135.108438:108444]
B:BD[135.108438] → [135.108438:108444]
```
    coord_def target() const
    {
        return (coord_def(target_x, target_y));
    }
    coord_def source() const
    {
        return (coord_def(source_x, source_y));
    }
```

Replacement in crawl-ref/source/beam.cc at line 688 [49.4128068]

B:BD[34.4097] → [34.4097:4173]

    pbolt.source_x       = you.x_pos;
    pbolt.source_y       = you.y_pos;

[34.4097]

[34.4173]

    pbolt.source         = you.pos();

Replacement in crawl-ref/source/beam.cc at line 1771 [49.4128068]

B:BD[58.5937029] → [58.5937029:5937075]

B:BD[58.5937075] → [558.3672:3817]

        tile_beam = tileidx_item_throw(*item,
                                       pbolt.target_x - pbolt.source_x,
                                       pbolt.target_y - pbolt.source_y);

[58.5937029]

[58.5937162]

        const coord_def diff = pbolt.target - pbolt.source;
        tile_beam = tileidx_item_throw(*item, diff.x, diff.y);

Replacement in crawl-ref/source/beam.cc at line 1786 [49.4128068]

B:BD[296.11239] → [296.11239:11331]

              pbolt.source_x, pbolt.source_y,
              pbolt.target_x, pbolt.target_y,

[296.11239]

[296.11331]

              pbolt.source.x, pbolt.source.y,
              pbolt.target.x, pbolt.target.y,

Replacement in crawl-ref/source/beam.cc at line 1795 [49.4128068]

B:BD[49.4170541] → [559.33221:33346]

    pbolt.aimed_at_feet = (pbolt.target_x == pbolt.source_x
                           && pbolt.target_y == pbolt.source_y);

[49.4170541]

[51.1228632]

    pbolt.aimed_at_feet = (pbolt.target == pbolt.source);

Replacement in crawl-ref/source/beam.cc at line 1805 [49.4128068]

B:BD[560.255] → [61.56201:56273]

        find_ray( pbolt.source(), pbolt.target(), true, ray, 0, true );

[560.255]

[560.256]

        find_ray( pbolt.source, pbolt.target, true, ray, 0, true );

Replacement in crawl-ref/source/beam.cc at line 1809 [49.4128068]
∅:D[176.11817] → [454.8635:8680]
B:BD[51.1228821] → [454.8635:8680]
```
        ray.advance_through(pbolt.target());
```
[176.11817]
[49.4171324]
```
        ray.advance_through(pbolt.target);
```
Replacement in crawl-ref/source/beam.cc at line 1906 [49.4128068]
B:BD[51.1230130] → [61.57011:57050]
```
        if (testpos == pbolt.target())
```
[51.1230130]
[61.57050]
```
        if (testpos == pbolt.target)
```

Replacement in crawl-ref/source/beam.cc at line 1995 [49.4128068]

B:BD[454.8913] → [454.8913:8962]

            ray.advance_through(pbolt.target());

[454.8913]

[454.8962]

            ray.advance_through(pbolt.target);

Replacement in crawl-ref/source/beam.cc at line 2011 [49.4128068]
B:BD[49.4178912] → [61.57619:57662]
```
    coord_def targetcopy = pbolt.target();
```
[49.4178912]
[49.4178970]
```
    coord_def targetcopy = pbolt.target;
```

Replacement in crawl-ref/source/beam.cc at line 2017 [49.4128068]

B:BD[49.4179036] → [61.57700:57778]

        pbolt.target_x = targetcopy.x;
        pbolt.target_y = targetcopy.y;

[49.4179036]

[49.4179094]

        pbolt.target = targetcopy;

Replacement in crawl-ref/source/beam.cc at line 2550 [49.4128068]

B:BD[246.7414] → [246.7414:7474]

B:BD[246.7474] → [248.4996:5054]

∅:D[248.5054] → [246.7556:7570]

B:BD[246.7556] → [246.7556:7570]

            if (cast_healing(5 + roll_dice( pbolt.damage ),
                             monster->x, monster->y) > 0)
            {

[246.7414]

[246.7570]

            if (cast_healing(5 + roll_dice( pbolt.damage ), monster->pos()) > 0)

Deletion in crawl-ref/source/beam.cc at line 2552 [49.4128068]
B:BD[246.7615] → [246.7615:7629]
```
            }
```

Replacement in crawl-ref/source/beam.cc at line 2812 [49.4128068]

B:BD[559.34790] → [559.34790:34891]

    pbolt.source_x      = monster->x;    // always safe to do.
    pbolt.source_y      = monster->y;

[559.34790]

[78.7909]

    pbolt.source        = monster->pos();

Replacement in crawl-ref/source/beam.cc at line 2919 [49.4128068]
B:BD[49.4201820] → [61.58024:58074]
```
    beam.target_x = p.x;
    beam.target_y = p.y;
```
[49.4201820]
[49.4201866]
```
    beam.target = p;
```

Replacement in crawl-ref/source/beam.cc at line 2984 [49.4128068]

B:BD[49.4203345] → [45.97520:97596]

        big_cloud(CLOUD_POISON, _whose_kill(beam), beam.killer(), p.x, p.y,

[49.4203345]

[45.97596]

        big_cloud(CLOUD_POISON, _whose_kill(beam), beam.killer(), p,

Replacement in crawl-ref/source/beam.cc at line 2993 [49.4128068]

B:BD[467.21843] → [45.97635:97715]

        big_cloud( cl_type, _whose_kill(beam), beam.killer(), p.x, p.y, 0, 9 );

[467.21843]

[49.4203736]

        big_cloud( cl_type, _whose_kill(beam), beam.killer(), p, 0, 9 );

Replacement in crawl-ref/source/beam.cc at line 2999 [49.4128068]

B:BD[561.54580] → [45.97716:97791]

        big_cloud( CLOUD_COLD, _whose_kill(beam), beam.killer(), p.x, p.y,

[561.54580]

[561.54635]

        big_cloud( CLOUD_COLD, _whose_kill(beam), beam.killer(), p,

Replacement in crawl-ref/source/beam.cc at line 3050 [49.4128068]
B:BD[49.4204932] → [61.58350:58400]
```
    if (beam.aimed_at_spot && p == beam.target())
```
[49.4204932]
[51.1237162]
```
    if (beam.aimed_at_spot && p == beam.target)
```

Replacement in crawl-ref/source/beam.cc at line 3178 [49.4128068]

B:BD[562.2953] → [558.4052:4121]

                || beam.aimed_at_spot && beam.target() == mon->pos()

[562.2953]

[558.4121]

                || beam.aimed_at_spot && beam.target == mon->pos()

Replacement in crawl-ref/source/beam.cc at line 3571 [49.4128068]
B:BD[51.1241722] → [61.62451:62507]
```
    int dist = grid_distance(beem.target(), you.pos());
```
[51.1241722]
[51.1241834]
```
    int dist = grid_distance(beem.target, you.pos());
```

Replacement in crawl-ref/source/beam.cc at line 3587 [49.4128068]

B:BD[51.1241924] → [51.1241924:1242087]

    int xfuzz = random_range(-2, 2),
        yfuzz = random_range(-2, 2);
    const int newx = beem.target_x + xfuzz,
              newy = beem.target_y + yfuzz;

[51.1241924]

[559.36592]

    coord_def fuzz( random_range(-2, 2), random_range(-2, 2) );
    coord_def newtarget = beem.target + fuzz;

Replacement in crawl-ref/source/beam.cc at line 3590 [49.4128068]
∅:D[559.36593] → [51.1242087:1242117]
B:BD[51.1242087] → [51.1242087:1242117]
B:BD[51.1242117] → [559.36594:36667]
∅:D[559.36667] → [51.1242198:1242264]
B:BD[51.1242198] → [51.1242198:1242264]
∅:D[51.1242264] → [49.4222578:4222584]
B:BD[49.4222578] → [49.4222578:4222584]
```
    if (in_bounds(newx, newy)
        && (newx != beem.source_x
            || newy != beem.source_y))
    {
        beem.target_x = newx;
        beem.target_y = newy;
    }
```
[559.36593]
[51.1242265]
```
    if (in_bounds(newtarget))
        beem.target = newtarget;
```
Replacement in crawl-ref/source/beam.cc at line 4347 [49.4128068]
B:BD[49.4233593] → [51.1246482:1246524]
```
    const int tid = mgrd[mon->x][mon->y];
```
[49.4233593]
[439.10142]
```
    const int tid = mgrd(mon->pos());
```

Replacement in crawl-ref/source/beam.cc at line 4372 [49.4128068]

B:BD[439.10418] → [296.12197:12272]

            || (thrower == KILL_YOU_MISSILE && !see_grid(mon->x, mon->y)))

[439.10418]

[49.4234114]

            || (thrower == KILL_YOU_MISSILE && !see_grid(mon->pos())))

Replacement in crawl-ref/source/beam.cc at line 4399 [49.4128068]
B:BD[51.1247043] → [51.1247043:1247088]
```
            if (!see_grid( mon->x, mon->y ))
```
[51.1247043]
[51.1247088]
```
            if (!see_grid( mon->pos() ))
```
Replacement in crawl-ref/source/beam.cc at line 4407 [49.4128068]
B:BD[51.1247294] → [559.37972:38017]
```
        else if (see_grid( mon->x, mon->y ))
```
[51.1247294]
[51.1247307]
```
        else if (see_grid( mon->pos() ))
```

Replacement in crawl-ref/source/beam.cc at line 4430 [49.4128068]

B:BD[439.10610] → [563.3135:3270]

                    const bool target = (beam.target_x == mon->x
                                         && beam.target_y == mon->y);

[439.10610]

[563.3270]

                    const bool target = (beam.target == mon->pos());

Replacement in crawl-ref/source/beam.cc at line 4536 [49.4128068]

B:BD[564.4068] → [439.11387:11448]

            if (see_grid(mon->x, mon->y) && !beam.is_tracer)

[564.4068]

[78.8676]

            if (see_grid(mon->pos()) && !beam.is_tracer)

Replacement in crawl-ref/source/beam.cc at line 4588 [49.4128068]

B:BD[565.4845] → [565.4845:4972]

                const bool target = (beam.target_x == mon->x
                                     && beam.target_y == mon->y);

[565.4845]

[563.3670]

                const bool target = (beam.target == mon->pos());

Replacement in crawl-ref/source/beam.cc at line 5183 [49.4128068]
B:BD[49.4249717] → [61.62871:62905]
```
    coord_def p = pbolt.target();
```
[49.4249717]
[566.6208]
```
    coord_def p = pbolt.target;
```

Replacement in crawl-ref/source/beam.cc at line 5314 [49.4128068]

B:BD[49.4253381] → [39.2818:2885]

    if (in_bounds(beam.source()) && beam.source() != beam.target()

[49.4253381]

[567.1195]

    if (in_bounds(beam.source) && beam.source != beam.target

Replacement in crawl-ref/source/beam.cc at line 5318 [49.4128068]

B:BD[567.1289] → [39.2886:2958]

        int     max_dist = grid_distance(beam.source(), beam.target());

[567.1289]

[567.1428]

        int     max_dist = grid_distance(beam.source, beam.target);

Replacement in crawl-ref/source/beam.cc at line 5321 [49.4128068]

B:BD[567.1480] → [61.63003:63073]

        find_ray( beam.source(), beam.target(), true, ray, 0, true );

[567.1480]

[567.1598]

        find_ray( beam.source, beam.target, true, ray, 0, true );

Replacement in crawl-ref/source/beam.cc at line 5324 [49.4128068]
B:BD[567.1657] → [61.63074:63114]
```
        if (ray.pos() == beam.source())
```
[567.1657]
[567.1723]
```
        if (ray.pos() == beam.source)
```

Replacement in crawl-ref/source/beam.cc at line 5331 [49.4128068]

B:BD[567.1822] → [39.2959:3024]

        while (dist++ <= max_dist && ray.pos() != beam.target())

[567.1822]

[567.1958]

        while (dist++ <= max_dist && ray.pos() != beam.target)

Replacement in crawl-ref/source/beam.cc at line 5391 [49.4128068]

B:BD[567.3785] → [567.3785:3851]

        beam.target_x = ray.x();
        beam.target_y = ray.y();

[567.3785]

[567.3851]

        beam.target = ray.pos();

Replacement in crawl-ref/source/beam.cc at line 5399 [49.4128068]
B:BD[49.4253489] → [61.63115:63152]
```
    if (is_sanctuary(beam.target()))
```
[49.4253489]
[568.2934]
```
    if (is_sanctuary(beam.target))
```

Replacement in crawl-ref/source/beam.cc at line 5401 [49.4128068]

B:BD[568.2940] → [467.22051:22129]

        if (!beam.is_tracer && see_grid(beam.target()) && !beam.name.empty())

[568.2940]

[467.22129]

        if (!beam.is_tracer && see_grid(beam.target) && !beam.name.empty())

Replacement in crawl-ref/source/beam.cc at line 5412 [49.4128068]
B:BD[545.26251] → [175.15898:15937]
```
         beam.target_x, beam.target_y,
```
[545.26251]
[175.15937]
```
         beam.target.x, beam.target.y,
```
Replacement in crawl-ref/source/beam.cc at line 5422 [49.4128068]
B:BD[49.4253975] → [61.63153:63191]
```
    noisy(10 + 5 * r, beam.target());
```
[49.4253975]
[49.4254028]
```
    noisy(10 + 5 * r, beam.target);
```

Replacement in crawl-ref/source/beam.cc at line 5495 [49.4128068]

B:BD[57.41185] → [57.41185:41254]

                 && see_grid(beam.target_x + i, beam.target_y + j) )

[57.41185]

[57.41254]

                 && see_grid(beam.target + coord_def(i,j)))

Replacement in crawl-ref/source/beam.cc at line 5518 [49.4128068]
B:BD[49.4256646] → [61.63677:63720]
```
    coord_def realpos = beam.target() + p;
```
[49.4256646]
[49.4256716]
```
    coord_def realpos = beam.target + p;
```
Replacement in crawl-ref/source/beam.cc at line 5575 [49.4128068]
B:BD[296.12442] → [61.64231:64275]
```
    const coord_def loc(beam.target() + p);
```
[296.12442]
[204.5849]
```
    const coord_def loc(beam.target + p);
```

Replacement in crawl-ref/source/beam.cc at line 5693 [49.4128068]

∅:D[569.9271] → [51.1254254:1254329]

B:BD[51.1254254] → [51.1254254:1254329]

B:BD[51.1254329] → [557.1030:1101]

               flavour(BEAM_MAGIC), source_x(0), source_y(0), damage(0,0),
               ench_power(0), hit(0), target_x(0), target_y(0), pos(),

[569.9271]

[51.1254393]

               flavour(BEAM_MAGIC), source(), target(), pos(), damage(0,0),
               ench_power(0), hit(0),

Replacement in crawl-ref/source/beam.cc at line 5740 [49.4128068]
B:BD[51.1255105] → [51.1255105:1255147]
```
    target_x = d.tx;
    target_y = d.ty;
```
[51.1255105]
[51.1255147]
```
    target = d.target;
```

Replacement in crawl-ref/source/beam.cc at line 5753 [49.4128068]

B:BD[557.1575] → [557.1575:1709]

    {
        target_x = pos.x;
        target_y = pos.y;
    }
    std::swap(source_x, target_x);
    std::swap(source_y, target_y);

[557.1575]

[557.1709]

        target = pos;
    std::swap(source, target);

Replacement in crawl-ref/source/acr.cc at line 182 [49.4397395]

∅:D[61.64937] → [570.2766:2840]

B:BD[432.16604] → [570.2766:2840]

∅:D[570.2840] → [432.16604:16729]

B:BD[432.16604] → [432.16604:16729]

static int  _check_adjacent(dungeon_feature_type feat, int &dx, int &dy);
static void _open_door(int move_x, int move_y, bool check_confused = true);
static void _close_door(int move_x, int move_y);

[61.64937]

[432.16729]

static int  _check_adjacent(dungeon_feature_type feat, coord_def& delta);
static void _open_door(coord_def move, bool check_confused = true);
static void _open_door(int x, int y, bool check_confused = true)
{
    _open_door(coord_def(x,y), check_confused);
}
static void _close_door(coord_def move);

Replacement in crawl-ref/source/acr.cc at line 1000 [49.4397395]

B:BD[449.12563] → [449.12563:12623]

                 you.x_pos, you.y_pos, name.c_str(), feat);

[449.12563]

[449.12623]

                 you.pos().x, you.pos().y, name.c_str(), feat);

Replacement in crawl-ref/source/acr.cc at line 1144 [49.4397395]

B:BD[571.2859] → [571.2859:2927]

            if (!is_valid_item(item) || item.x == 0 || item.y == 0)

[571.2859]

[49.4416414]

            if (!is_valid_item(item) || item.pos.x == 0 || item.pos.y == 0)

Replacement in crawl-ref/source/acr.cc at line 1148 [49.4397395]

B:BD[571.2967] → [571.2967:3021]

                mprf("(%2d,%2d): %s", item.x, item.y,

[571.2967]

[571.3021]

                mprf("(%2d,%2d): %s", item.pos.x, item.pos.y,

Replacement in crawl-ref/source/acr.cc at line 2005 [49.4397395]

B:BD[572.15660] → [572.15660:15716]

    case CMD_CLOSE_DOOR:      _close_door(0, 0); break;

[572.15660]

[49.4428255]

    case CMD_CLOSE_DOOR:      _close_door(coord_def(0, 0)); break;

Replacement in crawl-ref/source/acr.cc at line 2169 [49.4397395]
B:BD[68.551174] → [68.551174:551222]
```
            start_travel( lmove.tx, lmove.ty );
```
[68.551174]
[49.4432505]
```
            start_travel( lmove.target );
```

Replacement in crawl-ref/source/acr.cc at line 2217 [49.4397395]

B:BD[68.551767] → [10.3029:3107]

            if (you.running.x == you.x_pos && you.running.y == you.running.y)

[68.551767]

[10.3107]

            if (you.running.pos == you.pos())

Replacement in crawl-ref/source/acr.cc at line 2222 [49.4397395]

B:BD[10.3203] → [10.3203:3258]

            else if (!you.running.x || !you.running.y)

[10.3203]

[10.3258]

            else if (!you.running.pos.x || !you.running.pos.y)

Replacement in crawl-ref/source/acr.cc at line 2230 [49.4397395]

B:BD[10.3478] → [10.3478:3534]

            start_travel(you.running.x, you.running.y);

[10.3478]

[68.551848]

            start_travel(you.running.pos);

Replacement in crawl-ref/source/acr.cc at line 2276 [49.4397395]
B:BD[190.2887] → [190.2887:2931]
```
                start_travel(pos.x, pos.y);
```
[190.2887]
[190.2931]
```
                start_travel(pos);
```

Replacement in crawl-ref/source/acr.cc at line 2345 [49.4397395]

B:BD[531.28881] → [531.28881:28931]

                    start_travel(dest.x, dest.y);

[531.28881]

[531.28931]

                    start_travel(dest);

Replacement in crawl-ref/source/acr.cc at line 2349 [49.4397395]
B:BD[531.29001] → [531.29001:29047]
```
                if (see_grid(dest.x, dest.y))
```
[531.29001]
[531.29047]
```
                if (see_grid(dest))
```
Replacement in crawl-ref/source/acr.cc at line 3047 [49.4397395]
B:BD[292.8712] → [61.65291:65330]
```
        ASSERT(in_bounds(trap.pos()));
```
[292.8712]
[292.8755]
```
        ASSERT(in_bounds(trap.pos));
```
Replacement in crawl-ref/source/acr.cc at line 3049 [49.4397395]
B:BD[292.8756] → [61.65331:65380]
```
        handle_items_on_shaft(trap.pos(), true);
```
[292.8756]
[292.8809]
```
        handle_items_on_shaft(trap.pos, true);
```
Replacement in crawl-ref/source/acr.cc at line 3448 [49.4397395]
∅:D[573.8432] → [570.2977:3049]
B:BD[570.2977] → [570.2977:3049]
```
static int _check_adjacent(dungeon_feature_type feat, int &dx, int &dy)
```
[573.8432]
[570.3049]
```
static int _check_adjacent(dungeon_feature_type feat, coord_def& delta)
```

Replacement in crawl-ref/source/acr.cc at line 3457 [49.4397395]

B:BD[441.12689] → [441.12689:12761]

            dx = ai->x - you.x_pos;
            dy = ai->y - you.y_pos;

[441.12689]

[441.12761]

            delta = *ai - you.pos();

Replacement in crawl-ref/source/acr.cc at line 3467 [49.4397395]
∅:D[573.8655] → [432.27428:27496]
∅:D[467.25082] → [432.27428:27496]
B:BD[49.4464531] → [432.27428:27496]
```
static void _open_door(int move_x, int move_y, bool check_confused)
```
[467.25082]
[49.4464579]
```
static void _open_door(coord_def move, bool check_confused)
```
Deletion in crawl-ref/source/acr.cc at line 3469 [49.4397395]
B:BD[49.4464581] → [49.4464581:4464654]
B:BD[49.4464654] → [182.26886:26887]
```
    struct dist door_move;
    int dx, dy;             // door x, door y
```

Replacement in crawl-ref/source/acr.cc at line 3477 [49.4397395]

B:BD[570.3462] → [570.3462:3547]

    if ((!check_confused || !you.duration[DUR_CONF])
        && !(move_x || move_y))

[570.3462]

[570.3547]

    if ((!check_confused || !you.duration[DUR_CONF]) && move.origin())

Replacement in crawl-ref/source/acr.cc at line 3479 [49.4397395]

B:BD[570.3553] → [570.3553:3621]

        if (_check_adjacent(DNGN_CLOSED_DOOR, move_x, move_y) == 0)

[570.3553]

[570.3621]

        if (_check_adjacent(DNGN_CLOSED_DOOR, move) == 0)

Replacement in crawl-ref/source/acr.cc at line 3488 [49.4397395]

B:BD[51.1279473] → [51.1279473:1279539]

        move_x = random2(3) - 1;
        move_y = random2(3) - 1;

[51.1279473]

[51.1279539]

        move.x = random2(3) - 1;
        move.y = random2(3) - 1;

Replacement in crawl-ref/source/acr.cc at line 3492 [49.4397395]
∅:D[51.1279546] → [49.4464655:4464709]
B:BD[49.4464655] → [49.4464655:4464709]
```
    door_move.dx = move_x;
    door_move.dy = move_y;
```
[51.1279546]
[49.4464709]
```
    dist door_move;
    door_move.delta = move;
    coord_def doorpos;
```
Replacement in crawl-ref/source/acr.cc at line 3496 [49.4397395]
B:BD[49.4464710] → [49.4464710:4464736]
```
    if (move_x || move_y)
```
[49.4464710]
[49.4464736]
```
    if (!move.origin())
```

Replacement in crawl-ref/source/acr.cc at line 3498 [49.4397395]

B:BD[49.4464742] → [49.4464742:4464831]

        // convenience
        dx = you.x_pos + move_x;
        dy = you.y_pos + move_y;

[49.4464742]

[49.4464831]

        doorpos = you.pos() + move;

Replacement in crawl-ref/source/acr.cc at line 3500 [49.4397395]
B:BD[49.4464832] → [49.4464832:4464870]
```
        const int mon = mgrd[dx][dy];
```
[49.4464832]
[49.4464870]
```
        const int mon = mgrd(doorpos);
```
Replacement in crawl-ref/source/acr.cc at line 3519 [49.4397395]
B:BD[51.1279584] → [154.17637:17681]
```
            you_attack(mgrd[dx][dy], true);
```
[51.1279584]
[49.4465039]
```
            you_attack(mgrd(doorpos), true);
```

Replacement in crawl-ref/source/acr.cc at line 3527 [49.4397395]

B:BD[49.4465172] → [138.25068:25165]

        if (grd[dx][dy] >= DNGN_TRAP_MECHANICAL
            && grd[dx][dy] <= DNGN_TRAP_NATURAL)

[49.4465172]

[49.4465253]

        if (grd(doorpos) >= DNGN_TRAP_MECHANICAL
            && grd(doorpos) <= DNGN_TRAP_NATURAL)

Replacement in crawl-ref/source/acr.cc at line 3530 [49.4397395]
B:BD[49.4465263] → [49.4465263:4465313]
```
            if (env.cgrid[dx][dy] != EMPTY_CLOUD)
```
[49.4465263]
[49.4465313]
```
            if (env.cgrid(doorpos) != EMPTY_CLOUD)
```
Deletion in crawl-ref/source/acr.cc at line 3539 [49.4397395]
B:BD[49.4465494] → [49.4465494:4465495]
Insertion in crawl-ref/source/acr.cc at line 3544 [49.4397395]
[49.4465606]
[49.4465606]

Replacement in crawl-ref/source/acr.cc at line 3548 [49.4397395]

B:BD[49.4465659] → [49.4465659:4465760]

        // convenience
        dx = you.x_pos + door_move.dx;
        dy = you.y_pos + door_move.dy;

[49.4465659]

[574.322]

        doorpos = you.pos() + door_move.delta;

Replacement in crawl-ref/source/acr.cc at line 3551 [49.4397395]
∅:D[140.18036] → [575.4261:4320]
B:BD[575.4261] → [575.4261:4320]
```
            in_bounds(dx, dy) ? grd[dx][dy] : DNGN_UNSEEN;
```
[140.18036]
[575.4320]
```
            in_bounds(doorpos) ? grd(doorpos) : DNGN_UNSEEN;
```
Replacement in crawl-ref/source/acr.cc at line 3568 [49.4397395]
B:BD[49.4465767] → [49.4465767:4465808]
```
    if (grd[dx][dy] == DNGN_CLOSED_DOOR)
```
[49.4465767]
[49.4465808]
```
    if (grd(doorpos) == DNGN_CLOSED_DOOR)
```

Replacement in crawl-ref/source/acr.cc at line 3571 [49.4397395]

B:BD[576.3279] → [577.3600:3665]

        find_connected_range(coord_def(dx,dy), DNGN_CLOSED_DOOR,

[576.3279]

[577.3665]

        find_connected_range(doorpos, DNGN_CLOSED_DOOR,

Replacement in crawl-ref/source/acr.cc at line 3576 [49.4397395]
∅:D[578.3020] → [49.4465814:4465903]
∅:D[576.3425] → [49.4465814:4465903]
∅:D[140.18038] → [49.4465814:4465903]
B:BD[49.4465814] → [49.4465814:4465903]
```
        int skill = you.dex + (you.skills[SK_TRAPS_DOORS] + you.skills[SK_STEALTH]) / 2;
```
[140.18038]
[49.4465903]
```
        int skill = you.dex +
            (you.skills[SK_TRAPS_DOORS] + you.skills[SK_STEALTH]) / 2;
```

Replacement in crawl-ref/source/acr.cc at line 3599 [49.4397395]

B:BD[49.4466125] → [576.3660:3746]

            const char* verb = player_is_airborne() ? "reach down and open" : "open";

[49.4466125]

[575.5035]

            const char* verb =
                player_is_airborne() ? "reach down and open" : "open";

Replacement in crawl-ref/source/acr.cc at line 3614 [49.4397395]
∅:D[579.2795] → [580.2999:3059]
B:BD[580.2999] → [580.2999:3059]
```
                set_envmap_obj(dc.x, dc.y, DNGN_OPEN_DOOR);
```
[579.2795]
[579.2796]
```
                set_envmap_obj(dc, DNGN_OPEN_DOOR);
```
Replacement in crawl-ref/source/acr.cc at line 3628 [49.4397395]
B:BD[579.2902] → [577.4224:4270]
```
            grd[dc.x][dc.y] = DNGN_OPEN_DOOR;
```
[579.2902]
[576.3995]
```
            grd(dc) = DNGN_OPEN_DOOR;
```

Replacement in crawl-ref/source/acr.cc at line 3632 [49.4397395]

B:BD[49.4466354] → [581.3947:3991]

B:BD[581.3991] → [432.27497:27553]

    else if (grd[dx][dy] == DNGN_OPEN_DOOR)
        _close_door(move_x, move_y); // for convenience

[49.4466354]

    else if (grd(doorpos) == DNGN_OPEN_DOOR)
        _close_door(move); // for convenience

Replacement in crawl-ref/source/acr.cc at line 3642 [49.4397395]
B:BD[49.4466586] → [432.27554:27602]
```
static void _close_door(int door_x, int door_y)
```
[49.4466525]
[49.4466635]
```
static void _close_door(coord_def move)
```

Replacement in crawl-ref/source/acr.cc at line 3644 [49.4397395]

B:BD[49.4466637] → [49.4466637:4466710]

    struct dist door_move;
    int dx, dy;             // door x, door y

[49.4466637]

[570.3714]

    dist door_move;
    coord_def doorpos;

Replacement in crawl-ref/source/acr.cc at line 3648 [49.4397395]
B:BD[570.3768] → [570.3768:3824]
```
    if (!you.duration[DUR_CONF] && !(door_x || door_y))
```
[570.3768]
[570.3824]
```
    if (!you.duration[DUR_CONF] && move.origin())
```

Replacement in crawl-ref/source/acr.cc at line 3650 [49.4397395]

B:BD[570.3830] → [570.3830:3897]

        int num = _check_adjacent(DNGN_OPEN_DOOR, door_x, door_y);

[570.3830]

[570.3897]

        int num = _check_adjacent(DNGN_OPEN_DOOR, move);

Replacement in crawl-ref/source/acr.cc at line 3656 [49.4397395]
B:BD[570.4005] → [570.4005:4055]
```
        else if (num == 1 && !(door_x || door_y))
```
[570.4005]
[570.4055]
```
        else if (num == 1 && move.origin())
```

Replacement in crawl-ref/source/acr.cc at line 3665 [49.4397395]

B:BD[570.4216] → [570.4216:4282]

        door_x = random2(3) - 1;
        door_y = random2(3) - 1;

[570.4216]

[570.4282]

        move.x = random2(3) - 1;
        move.y = random2(3) - 1;

Replacement in crawl-ref/source/acr.cc at line 3669 [49.4397395]
∅:D[570.4289] → [49.4466711:4466765]
B:BD[49.4466711] → [49.4466711:4466765]
```
    door_move.dx = door_x;
    door_move.dy = door_y;
```
[570.4289]
[49.4466765]
```
    door_move.delta = move;
```
Replacement in crawl-ref/source/acr.cc at line 3671 [49.4397395]
B:BD[49.4466766] → [582.4197:4225]
```
    if (!door_x && !door_y)
```
[49.4466766]
[49.4466795]
```
    if (move.origin())
```
Replacement in crawl-ref/source/acr.cc at line 3679 [49.4397395]
B:BD[49.4466948] → [49.4466948:4466996]
```
    if (door_move.dx == 0 && door_move.dy == 0)
```
[49.4466948]
[49.4466996]
```
    if (door_move.delta.origin())
```

Replacement in crawl-ref/source/acr.cc at line 3685 [49.4397395]

B:BD[49.4467076] → [49.4467076:4467165]

    // convenience
    dx = you.x_pos + door_move.dx;
    dy = you.y_pos + door_move.dy;

[49.4467076]

[49.4467165]

    doorpos = you.pos() + door_move.delta;

Replacement in crawl-ref/source/acr.cc at line 3688 [49.4397395]
∅:D[140.18077] → [575.5132:5187]
B:BD[575.5132] → [575.5132:5187]
```
        in_bounds(dx, dy) ? grd[dx][dy] : DNGN_UNSEEN;
```
[140.18077]
[140.18078]
```
        in_bounds(doorpos) ? grd(doorpos) : DNGN_UNSEEN;
```

Replacement in crawl-ref/source/acr.cc at line 3693 [49.4397395]

B:BD[576.4044] → [575.5220:5295]

        find_connected_identical(coord_def(dx,dy), grd[dx][dy], all_door);

[576.4044]

[575.5295]

        find_connected_identical(doorpos, grd(doorpos), all_door);

Replacement in crawl-ref/source/acr.cc at line 3697 [49.4397395]

B:BD[576.4247] → [576.4247:4312]

        for (std::set<coord_def>::iterator i = all_door.begin();

[576.4190]

[576.4312]

        for (std::set<coord_def>::const_iterator i = all_door.begin();

Deletion in crawl-ref/source/acr.cc at line 3712 [49.4397395]
B:BD[581.4368] → [140.18158:18159]
∅:D[581.4389] → [576.4624:4692]
∅:D[140.18159] → [576.4624:4692]
B:BD[576.4624] → [576.4624:4692]
```
                door_move.dx = 0;
                door_move.dy = 0;
```

Deletion in crawl-ref/source/acr.cc at line 3718 [49.4397395]

B:BD[576.4860] → [576.4860:4928]

                door_move.dx = 0;
                door_move.dy = 0;

Replacement in crawl-ref/source/acr.cc at line 3728 [49.4397395]

B:BD[49.4467687] → [49.4467687:4467776]

        int skill = you.dex + (you.skills[SK_TRAPS_DOORS] + you.skills[SK_STEALTH]) / 2;

[49.4467687]

[49.4467776]

        int skill = you.dex +
            (you.skills[SK_TRAPS_DOORS] + you.skills[SK_STEALTH]) / 2;

Replacement in crawl-ref/source/acr.cc at line 3739 [49.4397395]

B:BD[583.3557] → [584.4610:4692]

                mprf(MSGCH_SOUND, "You slam the %s%s shut with an echoing bang!",

[583.3557]

[584.4692]

                mprf(MSGCH_SOUND,
                     "You slam the %s%s shut with an echoing bang!",

Replacement in crawl-ref/source/acr.cc at line 3758 [49.4397395]

B:BD[49.4468154] → [576.5464:5529]

        for (std::set<coord_def>::iterator i = all_door.begin();

[49.4468154]

[576.5529]

        for (std::set<coord_def>::const_iterator i = all_door.begin();

Replacement in crawl-ref/source/acr.cc at line 3768 [49.4397395]
∅:D[579.2917] → [580.3389:3451]
B:BD[580.3389] → [580.3389:3451]
```
                set_envmap_obj(dc.x, dc.y, DNGN_CLOSED_DOOR);
```
[579.2917]
[579.2918]
```
                set_envmap_obj(dc, DNGN_CLOSED_DOOR);
```

Replacement in crawl-ref/source/acr.cc at line 4184 [49.4397395]

B:BD[49.4480414] → [409.7507:7622]

        && (you.x_pos <= 15 || you.x_pos >= (GXM - 16)
            || you.y_pos <= 15 || you.y_pos >= (GYM - 16)))

[49.4480414]

[49.4480541]

        && (you.pos().x <= 15 || you.pos().x >= (GXM - 16)
            || you.pos().y <= 15 || you.pos().y >= (GYM - 16)))

Replacement in crawl-ref/source/abyss.cc at line 491 [49.4482606]

B:BD[61.67957] → [61.67957:68176]

        mgrd(newpos) = mgrd(*ri);
        if (mgrd(*ri) != NON_MONSTER)
        {
            menv[mgrd(newpos)].x = newpos.x;
            menv[mgrd(newpos)].y = newpos.y;
            mgrd(*ri) = NON_MONSTER;
        }

[61.67957]

[49.4489893]

        if ( mgrd(*ri) != NON_MONSTER )
            menv[mgrd(*ri)].moveto(newpos);

Replacement in crawl-ref/source/abyss.cc at line 504 [49.4482606]

B:BD[49.4490169] → [441.17713:17781]

        if ( grid_distance(abyss_center, env.cloud[i].pos()) > 10 )

[49.4490169]

[49.4490293]

        if ( grid_distance(abyss_center, env.cloud[i].pos) > 10 )

Replacement in crawl-ref/source/abl-show.cc at line 1626 [49.4494389]

B:BD[585.41438] → [585.41438:41522]

            beam.target_x    = you.x_pos;
            beam.target_y    = you.y_pos;

[585.41438]

[585.41522]

            beam.target      = you.pos();

Replacement in crawl-ref/source/abl-show.cc at line 1740 [49.4494389]
B:BD[585.41826] → [441.20062:20102]
```
        if (beam.target() == you.pos())
```
[585.41826]
[586.2981]
```
        if (beam.target == you.pos())
```