fiddlerwoaroof/crawl - Change TGJZXTUIAKCFZQJ54ZQEBGFBVZSJCAX6AWDRSH3TP7UJRLGUM5SAC

Massive change from using x and y to using coord_defs(). Not quite tested,

most likely broken in some places and might break tiles. Will fix in the near future.

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

Created by haranp on July 22, 2008

TGJZXTUIAKCFZQJ54ZQEBGFBVZSJCAX6AWDRSH3TP7UJRLGUM5SAC

Dependencies

In channels

main

Change contents

Replacement in crawl-ref/source/xom.cc at line 217 [52.3]

B:BD[50.291] → [51.4:65]

    move_item_to_grid(&thing_created, you.x_pos, you.y_pos);

[50.291]

[53.5]

    move_item_to_grid(&thing_created, you.pos());

Replacement in crawl-ref/source/view.h at line 96 [56.13254]

∅:D[54.56] → [55.5:69]

B:BD[57.147] → [55.5:69]

             int x_p, int y_p, bool clear_walls_block = false);

[54.56]

[56.14829]

             const coord_def& center, bool clear_walls_block = false);

Replacement in crawl-ref/source/view.h at line 108 [56.13254]

B:BD[56.15428] → [58.6:80]

∅:D[58.80] → [59.7:66]

B:BD[60.246] → [59.7:66]

bool noisy(int loudness, int nois_x, int nois_y, const char *msg = NULL);
void blood_smell( int strength, int blood_x, int blood_y);

[56.15428]

[61.5]

bool noisy(int loudness, const coord_def& where, const char *msg = NULL);
void blood_smell( int strength, const coord_def& where);

Replacement in crawl-ref/source/view.h at line 134 [56.13254]
B:BD[56.16777] → [62.452:496]
```
bool is_feature(int feature, int x, int y);
```
[56.16777]
[62.496]
```
bool is_feature(int feature, const coord_def& where);
```
Replacement in crawl-ref/source/view.h at line 157 [56.13254]
B:BD[63.46] → [63.46:86]
```
bool inside_level_bounds(coord_def &p);
```
[63.46]
[64.232]
```
bool inside_level_bounds(const coord_def &p);
```

Replacement in crawl-ref/source/view.h at line 164 [56.13254]

B:BD[65.54] → [65.54:89]

B:BD[65.89] → [66.7:45]

bool is_sanctuary( int x, int y );
bool is_bloodcovered( int x, int y );

[65.54]

[67.113]

bool is_sanctuary( const coord_def& p );
bool is_bloodcovered( const coord_def& p );

Replacement in crawl-ref/source/view.h at line 200 [56.13254]

B:BD[54.302] → [68.6:73]

bool grid_see_grid(int posx_1, int posy_1, int posx_2, int posy_2,

[54.302]

[68.73]

bool grid_see_grid(const coord_def& p1, const coord_def& p2,

Replacement in crawl-ref/source/view.h at line 235 [56.13254]
∅:D[69.2032] → [60.1168:1235]
B:BD[60.1168] → [60.1168:1235]
```
bool find_ray( int sourcex, int sourcey, int targetx, int targety,
```
[69.2032]
[70.5]
```
bool find_ray( const coord_def& source, const coord_def& target,
```

Replacement in crawl-ref/source/view.h at line 239 [56.13254]

B:BD[55.330] → [55.330:404]

int num_feats_between(int sourcex, int sourcey, int targetx, int targety,

[55.330]

[55.404]

int num_feats_between(const coord_def& source, const coord_def& target,

Replacement in crawl-ref/source/view.cc at line 155 [56.16817]
B:BD[56.20102] → [63.184:223]
```
bool inside_level_bounds(coord_def &p)
```
[56.20102]
[63.223]
```
bool inside_level_bounds(const coord_def &p)
```
Replacement in crawl-ref/source/view.cc at line 247 [56.16817]
B:BD[65.178] → [66.47:79]
```
bool is_sanctuary(int x, int y)
```
[65.178]
[65.211]
```
bool is_sanctuary(const coord_def& p)
```

Replacement in crawl-ref/source/view.cc at line 249 [56.16817]

B:BD[65.213] → [66.80:197]

    return (env.map[x][y].property == FPROP_SANCTUARY_1
            || env.map[x][y].property == FPROP_SANCTUARY_2);

[65.213]

[66.197]

    return (env.map(p).property == FPROP_SANCTUARY_1
            || env.map(p).property == FPROP_SANCTUARY_2);

Replacement in crawl-ref/source/view.cc at line 253 [56.16817]
B:BD[66.200] → [66.200:235]
```
bool is_bloodcovered(int x, int y)
```
[66.200]
[66.235]
```
bool is_bloodcovered(const coord_def& p)
```

Replacement in crawl-ref/source/view.cc at line 255 [56.16817]

B:BD[66.237] → [66.237:290]

    return (env.map[x][y].property == FPROP_BLOODY);

[66.237]

[65.264]

    return (env.map(p).property == FPROP_BLOODY);

Replacement in crawl-ref/source/view.cc at line 417 [56.16817]
B:BD[66.340] → [66.340:371]
```
    if (!is_bloodcovered(x,y))
```
[66.340]
[66.371]
```
    if (!is_bloodcovered(coord_def(x,y)))
```

Replacement in crawl-ref/source/view.cc at line 444 [56.16817]

B:BD[71.28] → [65.268:375]

            if (object < NUM_REAL_FEATURES
                && is_sanctuary(x,y) && object >= DNGN_MINMOVE)

[71.28]

[65.375]

            if (object < NUM_REAL_FEATURES && object >= DNGN_MINMOVE
                && is_sanctuary(coord_def(x,y)) )

Replacement in crawl-ref/source/view.cc at line 1106 [56.16817]

B:BD[72.5632] → [58.82:134]

        noisy(noise_level, monster->x, monster->y);

[72.5632]

[72.5686]

        noisy(noise_level, monster->pos());

Replacement in crawl-ref/source/view.cc at line 1535 [56.16817]

B:BD[60.13519] → [58.135:201]

bool noisy(int loudness, int nois_x, int nois_y, const char *msg)

[60.13519]

[56.57809]

bool noisy(int loudness, const coord_def& where, const char *msg)

Deletion in crawl-ref/source/view.cc at line 1537 [56.16817]
B:BD[56.57822] → [56.57822:57876]
```
    struct monsters *monster = 0;       // NULL {dlb}
```
Replacement in crawl-ref/source/view.cc at line 1540 [56.16817]
B:BD[60.13663] → [58.202:236]
```
    if (silenced(nois_x, nois_y))
```
[60.13663]
[60.13664]
```
    if (silenced(where))
```
Insertion in crawl-ref/source/view.cc at line 1544 [56.16817]
[60.13731]
[56.57966]
```
    const int player_distance = distance( you.pos(), where );
```

Deletion in crawl-ref/source/view.cc at line 1546 [56.16817]

B:BD[56.57967] → [73.7:97]

    const int player_distance =
        distance( you.x_pos, you.y_pos, nois_x, nois_y );

Replacement in crawl-ref/source/view.cc at line 1547 [56.16817]

B:BD[60.13758] → [73.98:168]

    if (player_distance <= dist && player_can_hear( nois_x, nois_y ))

[60.13758]

[60.13869]

    if (player_distance <= dist && player_can_hear( where ))

Replacement in crawl-ref/source/view.cc at line 1568 [56.16817]
B:BD[56.58012] → [56.58012:58040]
```
        monster = &menv[p];
```
[56.58012]
[56.58040]
```
        monsters* monster = &menv[p];
```

Replacement in crawl-ref/source/view.cc at line 1573 [56.16817]

B:BD[56.58095] → [56.58095:58214]

        if (distance(monster->x, monster->y, nois_x, nois_y) <= dist
            && !silenced(monster->x, monster->y))

[56.58095]

[56.58214]

        if (distance(monster->pos(), where) <= dist
            && !silenced(monster->pos()))

Replacement in crawl-ref/source/view.cc at line 1578 [56.16817]

B:BD[56.58343] → [56.58343:58403]

            if (nois_x == you.x_pos && nois_y == you.y_pos)

[56.58343]

[56.58403]

            if (where == you.pos())

Replacement in crawl-ref/source/view.cc at line 1581 [56.16817]

B:BD[56.58483] → [56.58483:58564]

                behaviour_event( monster, ME_DISTURB, MHITNOT, nois_x, nois_y );

[56.58483]

[56.58564]

                behaviour_event( monster, ME_DISTURB, MHITNOT, where );

Replacement in crawl-ref/source/view.cc at line 1604 [56.16817]

B:BD[59.482] → [59.482:541]

void blood_smell( int strength, int blood_x, int blood_y )

[59.482]

[59.541]

void blood_smell( int strength, const coord_def& where )

Replacement in crawl-ref/source/view.cc at line 1606 [56.16817]
B:BD[59.543] → [59.543:597]
```
    struct monsters *monster = 0;       // NULL {dlb}
```
[59.543]
[59.597]
```
    monsters *monster = NULL;
```
Replacement in crawl-ref/source/view.cc at line 1612 [56.16817]
B:BD[59.751] → [59.751:786]
```
         blood_x, blood_y, range);
```
[59.751]
[59.786]
```
         where.x, where.y, range);
```

Replacement in crawl-ref/source/view.cc at line 1624 [56.16817]

B:BD[59.1134] → [59.1134:1242]

            const int player_distance
                = distance( you.x_pos, you.y_pos, blood_x, blood_y );

[59.1134]

[59.1242]

            const int player_distance = distance( you.pos(), where );

Replacement in crawl-ref/source/view.cc at line 1635 [56.16817]
∅:D[74.201] → [59.1626:1675]
B:BD[59.1626] → [59.1626:1675]
```
                if (!see_grid(blood_x, blood_y))
```
[74.201]
[59.1675]
```
                if (!see_grid(where))
```

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

B:BD[59.2083] → [59.2083:2156]

        if (distance(monster->x, monster->y, blood_x, blood_y) <= range)

[59.2083]

[59.2156]

        if (distance(monster->pos(), where) <= range)

Replacement in crawl-ref/source/view.cc at line 1672 [56.16817]

B:BD[59.2829] → [59.2829:2961]

                        behaviour_event( monster, ME_DISTURB, MHITNOT,
                                         blood_x, blood_y );

[59.2829]

[59.2961]

                        behaviour_event(monster, ME_DISTURB, MHITNOT, where);

Replacement in crawl-ref/source/view.cc at line 1681 [56.16817]

B:BD[59.3214] → [59.3214:3291]

            behaviour_event( monster, ME_ALERT, MHITNOT, blood_x, blood_y );

[59.3214]

[59.3291]

            behaviour_event( monster, ME_ALERT, MHITNOT, where );

Replacement in crawl-ref/source/view.cc at line 1684 [56.16817]
B:BD[59.3307] → [59.3307:3335]
```
}      // end blood_smell()
```
[59.3307]
[59.3335]
```
}
```
Replacement in crawl-ref/source/view.cc at line 2347 [56.16817]
∅:D[75.919] → [60.28818:28885]
B:BD[56.66294] → [60.28818:28885]
```
// Find a nonblocked ray from sx, sy to tx, ty. Return false if no
```
[75.919]
[60.28885]
```
// Find a nonblocked ray from source to target. Return false if no
```
Replacement in crawl-ref/source/view.cc at line 2358 [56.16817]
∅:D[76.69] → [60.29082:29149]
∅:D[77.649] → [60.29082:29149]
B:BD[60.29082] → [60.29082:29149]
```
bool find_ray( int sourcex, int sourcey, int targetx, int targety,
```
[76.69]
[70.2548]
```
bool find_ray( const coord_def& source, const coord_def& target,
```

Insertion in crawl-ref/source/view.cc at line 2363 [56.16817]

[60.29231]


    const int sourcex = source.x;
    const int sourcey = source.y;
    const int targetx = target.x;
    const int targety = target.y;

Insertion in crawl-ref/source/view.cc at line 2373 [56.16817]
[78.6113]
[78.6113]
Replacement in crawl-ref/source/view.cc at line 2532 [56.16817]
∅:D[79.60] → [55.864:938]
∅:D[68.193] → [55.864:938]
∅:D[80.207] → [55.864:938]
B:BD[55.864] → [55.864:938]
```
int num_feats_between(int sourcex, int sourcey, int targetx, int targety,
```
[80.207]
[55.938]
```
int num_feats_between(const coord_def& source, const coord_def& target,
```

Replacement in crawl-ref/source/view.cc at line 2539 [56.16817]

B:BD[55.1135] → [55.1135:1209]

    int     max_dist = grid_distance(sourcex, sourcey, targetx, targety);

[55.1135]

[55.1209]

    int     max_dist = grid_distance(source, target);

Replacement in crawl-ref/source/view.cc at line 2544 [56.16817]

B:BD[81.1202] → [81.1202:1281]

    find_ray( sourcex, sourcey, targetx, targety, true, ray, 0, false, true );

[81.1202]

[81.1281]

    find_ray( source, target, true, ray, 0, false, true );

Replacement in crawl-ref/source/view.cc at line 2546 [56.16817]
∅:D[81.1282] → [55.1336:1407]
B:BD[55.1336] → [55.1336:1407]
```
    if (exclude_endpoints && ray.x() == sourcex && ray.y() == sourcey)
```
[81.1282]
[55.1407]
```
    if (exclude_endpoints && ray.pos() == source)
```

Replacement in crawl-ref/source/view.cc at line 2556 [56.16817]

B:BD[55.1522] → [55.1522:1581]

        dungeon_feature_type feat = grd[ray.x()][ray.y()];

[55.1522]

[55.1581]

        const dungeon_feature_type feat = grd(ray.pos());

Replacement in crawl-ref/source/view.cc at line 2558 [56.16817]
B:BD[55.1582] → [80.306:360]
```
        if (ray.x() == targetx && ray.y() == targety)
```
[55.1582]
[80.360]
```
        if (ray.pos() == target)
```

Replacement in crawl-ref/source/view.cc at line 2617 [56.16817]

B:BD[54.617] → [54.617:666]

             feature_grid &gr, int x_p, int y_p,

[54.617]

[55.1981]

             feature_grid &gr, const coord_def& center,

Insertion in crawl-ref/source/view.cc at line 2621 [56.16817]
[60.33007]
[60.33007]
```
    const int x_p = center.x;
    const int y_p = center.y;
```

Replacement in crawl-ref/source/view.cc at line 2657 [56.16817]

B:BD[82.117] → [82.117:188]

                    dfeat = grid_secret_door_appearance(realx, realy);

[82.117]

[83.453]

                    dfeat = grid_secret_door_appearance(coord_def(realx, realy));

Replacement in crawl-ref/source/view.cc at line 2721 [56.16817]
B:BD[62.14261] → [84.1130:1173]
```
bool is_feature(int feature, int x, int y)
```
[62.14261]
[84.1173]
```
bool is_feature(int feature, const coord_def& where)
```
Replacement in crawl-ref/source/view.cc at line 2723 [56.16817]
B:BD[84.1175] → [64.4426:4457]
```
    if (!env.map[x][y].object)
```
[84.1175]
[85.7]
```
    if (!env.map(where).object)
```
Replacement in crawl-ref/source/view.cc at line 2728 [56.16817]
B:BD[62.14538] → [62.14538:14566]
```
    short grid = grd[x][y];
```
[62.14538]
[62.14566]
```
    short grid = grd(where);
```

Replacement in crawl-ref/source/view.cc at line 2733 [56.16817]

B:BD[62.14604] → [86.283:344]

        return (travel_point_distance[x][y] == PD_EXCLUDED);

[62.14604]

[62.14658]

        return (travel_point_distance[where.x][where.y] == PD_EXCLUDED);

Replacement in crawl-ref/source/view.cc at line 2736 [56.16817]
B:BD[62.14686] → [62.14686:14720]
```
        return is_waypoint(x, y);
```
[62.14686]
[62.14742]
```
        return is_waypoint(where.x, where.y);
```
Replacement in crawl-ref/source/view.cc at line 2738 [56.16817]
B:BD[62.14756] → [62.14756:14787]
```
        return is_stash(x, y);
```
[62.14756]
[62.14794]
```
        return is_stash(where.x, where.y);
```

Replacement in crawl-ref/source/view.cc at line 2846 [56.16817]

∅:D[83.468] → [64.4458:4518]

B:BD[62.17577] → [64.4458:4518]

        return get_envmap_char(x, y) == (unsigned) feature;

[83.468]

[87.37]

        return get_envmap_char(where.x, where.y) == (unsigned) feature;

Replacement in crawl-ref/source/view.cc at line 2850 [56.16817]

B:BD[87.46] → [87.46:104]

static bool _is_feature_fudged(int feature, int x, int y)

[87.46]

[87.104]

static bool _is_feature_fudged(int feature, const coord_def& where)

Replacement in crawl-ref/source/view.cc at line 2852 [56.16817]
B:BD[87.106] → [87.106:137]
```
    if (!env.map[x][y].object)
```
[87.106]
[87.137]
```
    if (!env.map(where).object)
```
Replacement in crawl-ref/source/view.cc at line 2855 [56.16817]
B:BD[87.162] → [87.162:197]
```
    if (is_feature(feature, x, y))
```
[87.162]
[87.197]
```
    if (is_feature(feature, where))
```
Replacement in crawl-ref/source/view.cc at line 2860 [56.16817]
B:BD[87.345] → [87.345:373]
```
    short grid = grd[x][y];
```
[87.345]
[87.373]
```
    short grid = grd(where);
```

Replacement in crawl-ref/source/view.cc at line 2926 [56.16817]

B:BD[84.1767] → [87.1057:1112]

                if (_is_feature_fudged(feature, x, y))

[84.1767]

[84.1822]

                if (_is_feature_fudged(feature, coord_def(x, y)))

Replacement in crawl-ref/source/view.cc at line 2961 [56.16817]
B:BD[62.19673] → [62.19673:19724]
```
        if (is_feature(feature, coord.x, coord.y))
```
[62.19673]
[62.19724]
```
        if (is_feature(feature, coord))
```

Replacement in crawl-ref/source/view.cc at line 2980 [56.16817]

B:BD[62.20204] → [87.1113:1172]

        if (_is_feature_fudged(feature, coord.x, coord.y))

[62.20204]

[84.2291]

        if (_is_feature_fudged(feature, coord))

Replacement in crawl-ref/source/view.cc at line 3814 [56.16817]
∅:D[81.1617] → [68.503:570]
B:BD[68.503] → [68.503:570]
```
bool grid_see_grid(int posx_1, int posy_1, int posx_2, int posy_2,
```
[81.1617]
[68.570]
```
bool grid_see_grid(const coord_def& p1, const coord_def& p2,
```

Replacement in crawl-ref/source/view.cc at line 3817 [56.16817]

B:BD[68.621] → [68.621:697]

    if (distance(posx_1, posy_1, posx_2, posy_2) > LOS_RADIUS * LOS_RADIUS)

[68.621]

[68.697]

    if (distance(p1, p2) > LOS_RADIUS * LOS_RADIUS)

Replacement in crawl-ref/source/view.cc at line 3825 [56.16817]

B:BD[68.923] → [80.725:862]

    return (!num_feats_between(posx_1, posy_1, posx_2, posy_2, DNGN_UNSEEN,
                               max_disallowed, true, true));

[68.923]

[68.1051]

    return (!num_feats_between(p1, p2, DNGN_UNSEEN, max_disallowed,
                               true, true));

Replacement in crawl-ref/source/view.cc at line 4615 [56.16817]

B:BD[60.63995] → [60.63995:64049]

        object = grid_secret_door_appearance( x, y );

[60.63995]

[56.103107]

        object = grid_secret_door_appearance(coord_def(x, y));

Replacement in crawl-ref/source/view.cc at line 4681 [56.16817]

B:BD[60.65847] → [88.1145:1217]

                    object = grid_secret_door_appearance( gc.x, gc.y );

[60.65847]

[56.104535]

                    object = grid_secret_door_appearance( gc );

Replacement in crawl-ref/source/view.cc at line 4780 [56.16817]

B:BD[89.5002] → [89.5002:5064]

        object = grid_secret_door_appearance( pos.x, pos.y );

[89.5002]

[89.5064]

        object = grid_secret_door_appearance( pos );

Replacement in crawl-ref/source/view.cc at line 4865 [56.16817]

B:BD[56.106288] → [14.7:82]

    losight( env.show, grd, you.x_pos, you.y_pos ); // Must be done first.

[56.106288]

[56.106408]

    losight( env.show, grd, you.pos() ); // Must be done first.

Replacement in crawl-ref/source/view.cc at line 4869 [56.16817]

B:BD[55.3323] → [55.3323:3390]

    losight( env.no_trans_show, grd, you.x_pos, you.y_pos, true );

[55.3323]

[55.3390]

    losight( env.no_trans_show, grd, you.pos(), true );

Replacement in crawl-ref/source/view.cc at line 4925 [56.16817]
∅:D[90.152] → [91.296:358]
∅:D[92.403] → [91.296:358]
∅:D[71.898] → [91.296:358]
B:BD[91.296] → [91.296:358]
```
                        else if (is_feature('>', gc.x, gc.y))
```
[90.152]
[90.153]
```
                        else if (is_feature('>', gc))
```
Replacement in crawl-ref/source/view.cc at line 4929 [56.16817]
∅:D[90.206] → [64.8126:8188]
∅:D[91.442] → [64.8126:8188]
∅:D[71.979] → [64.8126:8188]
B:BD[64.8126] → [64.8126:8188]
```
                        else if (is_feature('_', gc.x, gc.y))
```
[90.206]
[64.8188]
```
                        else if (is_feature('_', gc))
```

Replacement in crawl-ref/source/view.cc at line 4938 [56.16817]

B:BD[90.340] → [90.340:465]

                            && (is_feature('>', gc.x, gc.y)
                                || is_feature('<', gc.x, gc.y)))

[90.340]

[90.465]

                            && (is_feature('>', gc) || is_feature('<', gc)))

Replacement in crawl-ref/source/view.cc at line 5027 [56.16817]

B:BD[60.70731] → [64.9668:9744]

                        object = grid_secret_door_appearance( gc.x, gc.y );

[60.70731]

[56.109430]

                        object = grid_secret_door_appearance( gc );

Replacement in crawl-ref/source/view.cc at line 5894 [56.16817]

B:BD[93.9658] → [93.9658:9730]

            find_ray( gridx, gridy, tx, ty, true, ray, 0, true, true );

[93.9658]

[93.9730]

            find_ray( coord_def(gridx, gridy), coord_def(tx, ty),
                      true, ray, 0, true, true );

Replacement in crawl-ref/source/tutorial.cc at line 1206 [84.5936]
B:BD[94.766] → [94.766:798]
```
        noisy(1, mon.x, mon.y);
```
[94.766]
[94.798]
```
        noisy(1, mon.pos());
```

Replacement in crawl-ref/source/tutorial.cc at line 1941 [84.5936]

B:BD[44.5947] → [44.5947:6016]

        tiles.add_text_tag(TAG_TUTORIAL, shop_name(gc.x, gc.y), gc);

[44.5947]

[95.1218]

        tiles.add_text_tag(TAG_TUTORIAL, shop_name(gc), gc);

Replacement in crawl-ref/source/travel.cc at line 438 [62.39949]

∅:D[64.11330] → [96.743:810]

B:BD[96.743] → [96.743:810]

        const int secret_door = grid_secret_door_appearance(x, y);

[64.11330]

[64.11331]

        const int secret_door = grid_secret_door_appearance(coord_def(x, y));

Replacement in crawl-ref/source/travel.cc at line 3936 [62.39949]

B:BD[97.3405] → [97.3405:3483]

        shops.push_back( named_thing<int>( shop_name(pos.x, pos.y), grid ) );

[97.3405]

[97.3483]

        shops.push_back( named_thing<int>( shop_name(pos), grid ) );

Replacement in crawl-ref/source/traps.h at line 24 [69.3043]

B:BD[69.3538] → [69.3538:3580]

               char beam_x, char beam_y);

[69.3538]

[69.3580]

               const coord_def& where);

Replacement in crawl-ref/source/traps.h at line 39 [69.3043]

∅:D[98.190] → [69.4179:4274]

B:BD[69.4179] → [69.4179:4274]

int get_trapping_net(int x, int y, bool trapped = true);
void mark_net_trapping(int x, int y);

[98.190]

[69.4274]

int get_trapping_net(const coord_def& where, bool trapped = true);
void mark_net_trapping(const coord_def& where);

Replacement in crawl-ref/source/traps.h at line 49 [69.3043]

B:BD[69.5195] → [69.5195:5266]

int trap_at_xy(int x, int y);
trap_type trap_type_at_xy(int x, int y);

[69.5194]

[99.153]

int trap_at_xy(const coord_def& xy);
trap_type trap_type_at_xy(const coord_def& xy);

Replacement in crawl-ref/source/traps.h at line 54 [69.3043]

B:BD[100.252] → [100.252:315]

void     handle_items_on_shaft(int x, int y, bool open_shaft);

[100.252]

[99.226]

void     handle_items_on_shaft(const coord_def& where, bool open_shaft);

Replacement in crawl-ref/source/traps.cc at line 50 [69.5308]
∅:D[101.280] → [69.6284:6333]
B:BD[69.6284] → [69.6284:6333]
```
int get_trapping_net(int x, int y, bool trapped)
```
[101.280]
[69.6333]
```
int get_trapping_net(const coord_def& where, bool trapped)
```
Replacement in crawl-ref/source/traps.cc at line 52 [69.5308]
B:BD[69.6335] → [36.137:191]
```
    for (stack_iterator si(coord_def(x,y)); si; ++si)
```
[69.6335]
[69.6411]
```
    for (stack_iterator si(where); si; ++si)
```
Replacement in crawl-ref/source/traps.cc at line 66 [69.5308]
∅:D[102.191] → [69.6797:6856]
B:BD[69.6797] → [69.6797:6856]
```
static void maybe_split_nets(item_def &item, int x, int y)
```
[102.191]
[69.6856]
```
static void maybe_split_nets(item_def &item, const coord_def& where)
```
Replacement in crawl-ref/source/traps.cc at line 88 [69.5308]
B:BD[69.7258] → [69.7258:7293]
```
    copy_item_to_grid( it, x, y );
```
[69.7258]
[69.7293]
```
    copy_item_to_grid( it, where );
```
Replacement in crawl-ref/source/traps.cc at line 91 [69.5308]
B:BD[69.7296] → [69.7296:7333]
```
void mark_net_trapping(int x, int y)
```
[69.7296]
[69.7333]
```
void mark_net_trapping(const coord_def& where)
```
Replacement in crawl-ref/source/traps.cc at line 93 [69.5308]
B:BD[69.7335] → [69.7335:7372]
```
    int net = get_trapping_net(x,y);
```
[69.7335]
[69.7372]
```
    int net = get_trapping_net(where);
```
Replacement in crawl-ref/source/traps.cc at line 96 [69.5308]
B:BD[69.7403] → [69.7403:7447]
```
        net = get_trapping_net(x,y, false);
```
[69.7403]
[69.7447]
```
        net = get_trapping_net(where, false);
```

Replacement in crawl-ref/source/traps.cc at line 98 [69.5308]

B:BD[69.7476] → [69.7476:7523]

            maybe_split_nets(mitm[net], x, y);

[69.7476]

[69.7523]

            maybe_split_nets(mitm[net], where);

Replacement in crawl-ref/source/traps.cc at line 171 [69.5308]

B:BD[69.9277] → [103.307:382]

            fall_into_a_pool(you.x_pos, you.y_pos, false, grd(you.pos()));

[69.9277]

[69.9363]

            fall_into_a_pool(you.pos(), false, grd(you.pos()));

Replacement in crawl-ref/source/traps.cc at line 182 [69.5308]

B:BD[104.295] → [104.295:349]

        int net = get_trapping_net(mons->x, mons->y);

[104.295]

[104.349]

        int net = get_trapping_net(mons->pos());

Replacement in crawl-ref/source/traps.cc at line 186 [69.5308]
B:BD[104.410] → [104.410:450]
```
        if (see_grid(mons->x, mons->y))
```
[104.410]
[104.450]
```
        if (see_grid(mons->pos()))
```

Replacement in crawl-ref/source/traps.cc at line 201 [69.5308]

B:BD[104.892] → [104.892:952]

        const int net = get_trapping_net(mons->x, mons->y);

[104.892]

[104.952]

        const int net = get_trapping_net(mons->pos());

Replacement in crawl-ref/source/traps.cc at line 290 [69.5308]
B:BD[69.11436] → [69.11436:11482]
```
void itrap( struct bolt &pbolt, int trapped )
```
[69.11436]
[69.11482]
```
void itrap( bolt &pbolt, int trapped )
```

Replacement in crawl-ref/source/traps.cc at line 329 [69.5308]

B:BD[69.12336] → [69.12336:12406]

    trap_item( base_type, sub_type, pbolt.target_x, pbolt.target_y );

[69.12336]

[69.12406]

    trap_item( base_type, sub_type, pbolt.target() );

Replacement in crawl-ref/source/traps.cc at line 332 [69.5308]
B:BD[69.12419] → [69.12419:12466]
```
}                               // end itrap()
```
[69.12419]
[69.12466]
```
}
```

Replacement in crawl-ref/source/traps.cc at line 415 [69.5308]

B:BD[105.399] → [105.399:479]

        noisy(12, you.x_pos, you.y_pos, "An alarm trap emits a blaring wail!");

[105.399]

[105.479]

        noisy(12, you.pos(), "An alarm trap emits a blaring wail!");

Replacement in crawl-ref/source/traps.cc at line 433 [69.5308]

B:BD[66.1101] → [66.1101:1171]

            bleed_onto_floor(you.x_pos, you.y_pos, -1, damage, true);

[66.1101]

[69.14548]

            bleed_onto_floor(you.pos(), -1, damage, true);

Replacement in crawl-ref/source/traps.cc at line 453 [69.5308]

B:BD[69.15056] → [69.15056:15142]

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

[69.15056]

[69.15142]

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

Replacement in crawl-ref/source/traps.cc at line 455 [69.5308]

B:BD[69.15184] → [69.15184:15241]

                mark_net_trapping(you.x_pos, you.y_pos);

[69.15184]

[69.15241]

                mark_net_trapping(you.pos());

Replacement in crawl-ref/source/traps.cc at line 457 [69.5308]

B:BD[69.15242] → [69.15242:15302]

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

[69.15242]

[69.15302]

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

Replacement in crawl-ref/source/traps.cc at line 580 [69.5308]

B:BD[69.16998] → [69.16998:17085]

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

[69.16998]

[69.17085]

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

Replacement in crawl-ref/source/traps.cc at line 601 [69.5308]

B:BD[69.17467] → [69.17467:17549]

        trap_item( OBJ_MISSILES, MI_THROWING_NET, beam.target_x, beam.target_y );

[69.17467]

[69.17549]

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

Replacement in crawl-ref/source/traps.cc at line 629 [69.5308]
∅:D[106.2212] → [69.18405:18453]
B:BD[69.18405] → [69.18405:18453]
```
    int net = get_trapping_net(mon->x, mon->y);
```
[106.2212]
[69.18453]
```
    int net = get_trapping_net(mon->pos());
```
Replacement in crawl-ref/source/traps.cc at line 776 [69.5308]
B:BD[69.20174] → [69.20174:20228]
```
    int net = get_trapping_net(you.x_pos, you.y_pos);
```
[69.20174]
[69.20228]
```
    int net = get_trapping_net(you.pos());
```

Replacement in crawl-ref/source/traps.cc at line 890 [69.5308]

B:BD[107.379] → [108.185:245]

    const int net = get_trapping_net(you.x_pos, you.y_pos);

[107.379]

[108.245]

    const int net = get_trapping_net(you.pos());

Replacement in crawl-ref/source/traps.cc at line 898 [69.5308]
B:BD[69.21789] → [69.21789:21830]
```
               char beam_x, char beam_y)
```
[69.21789]
[69.21830]
```
               const coord_def& where)
```
Replacement in crawl-ref/source/traps.cc at line 923 [69.5308]
B:BD[69.22359] → [69.22359:22401]
```
    if (igrd[beam_x][beam_y] != NON_ITEM)
```
[69.22359]
[69.22401]
```
    if (igrd(where) != NON_ITEM)
```

Replacement in crawl-ref/source/traps.cc at line 925 [69.5308]

B:BD[69.22407] → [69.22407:22470]

        if (items_stack( item, mitm[ igrd[beam_x][beam_y] ] ))

[69.22407]

[69.22470]

        if (items_stack( item, mitm[ igrd(where) ] ))

Replacement in crawl-ref/source/traps.cc at line 927 [69.5308]

B:BD[69.22480] → [69.22480:22543]

            inc_mitm_item_quantity( igrd[beam_x][beam_y], 1 );

[69.22480]

[69.22543]

            inc_mitm_item_quantity( igrd(where), 1 );

Replacement in crawl-ref/source/traps.cc at line 933 [69.5308]

B:BD[69.22731] → [69.22731:22789]

        if (mitm[ igrd[beam_x][beam_y] ].link != NON_ITEM

[69.22731]

[4.133]

        if (mitm[ igrd(where) ].link != NON_ITEM

Replacement in crawl-ref/source/traps.cc at line 937 [69.5308]

B:BD[69.22884] → [69.22884:22960]

            if (mitm[ mitm[ igrd[beam_x][beam_y] ].link ].link != NON_ITEM)

[69.22884]

[69.22960]

            if (mitm[ mitm[ igrd(where) ].link ].link != NON_ITEM)

Replacement in crawl-ref/source/traps.cc at line 940 [69.5308]
B:BD[69.23002] → [69.23002:23064]
```
    }                           // end of if igrd != NON_ITEM
```
[69.23002]
[69.23064]
```
    }
```
Replacement in crawl-ref/source/traps.cc at line 949 [69.5308]
∅:D[5.331] → [69.23065:23125]
∅:D[98.1418] → [69.23065:23125]
B:BD[69.23065] → [69.23065:23125]
```
    return (!copy_item_to_grid( item, beam_x, beam_y, 1 ));
```
[5.331]
[69.23125]
```
    return (!copy_item_to_grid( item, where, 1 ));
```
Replacement in crawl-ref/source/traps.cc at line 979 [69.5308]
∅:D[109.206] → [69.23823:23864]
B:BD[69.23823] → [69.23823:23864]
```
int trap_at_xy(int which_x, int which_y)
```
[109.206]
[69.23864]
```
int trap_at_xy(const coord_def& xy)
```

Replacement in crawl-ref/source/traps.cc at line 983 [69.5308]

B:BD[69.23940] → [109.207:302]

        if (env.trap[which_trap].x == which_x
            && env.trap[which_trap].y == which_y

[69.23940]

[109.302]

        if (env.trap[which_trap].pos() == xy

Replacement in crawl-ref/source/traps.cc at line 994 [69.5308]
B:BD[69.24288] → [69.24288:24328]
```
trap_type trap_type_at_xy(int x, int y)
```
[69.24288]
[69.24328]
```
trap_type trap_type_at_xy(const coord_def& xy)
```
Replacement in crawl-ref/source/traps.cc at line 996 [69.5308]
B:BD[69.24330] → [69.24330:24368]
```
    const int idx = trap_at_xy(x, y);
```
[69.24330]
[101.829]
```
    const int idx = trap_at_xy(xy);
```

Replacement in crawl-ref/source/traps.cc at line 1078 [69.5308]

B:BD[100.1241] → [100.1241:1299]

void handle_items_on_shaft(int x, int y, bool open_shaft)

[100.1241]

[100.1299]

void handle_items_on_shaft(const coord_def& pos, bool open_shaft)

Deletion in crawl-ref/source/traps.cc at line 1083 [69.5308]
B:BD[100.1351] → [100.1351:1376]
```
    coord_def pos(x, y);
```

Replacement in crawl-ref/source/transfor.cc at line 524 [56.143977]

B:BD[110.707] → [110.707:769]

            int net = get_trapping_net(you.x_pos, you.y_pos);

[110.707]

[110.769]

            int net = get_trapping_net(you.pos());

Replacement in crawl-ref/source/transfor.cc at line 605 [56.143977]

B:BD[110.994] → [110.994:1056]

            int net = get_trapping_net(you.x_pos, you.y_pos);

[110.994]

[110.1056]

            int net = get_trapping_net(you.pos());

Replacement in crawl-ref/source/transfor.cc at line 753 [56.143977]

B:BD[25.201] → [25.201:267]

    move_player_to_grid(you.x_pos, you.y_pos, false, true, true);

[25.201]

[56.158004]

    move_player_to_grid(you.pos(), false, true, true);

Replacement in crawl-ref/source/transfor.cc at line 876 [56.143977]

B:BD[56.160784] → [56.160784:160851]

            copy_item_to_grid( you.inv[i], you.x_pos, you.y_pos );

[56.160784]

[56.160851]

            copy_item_to_grid( you.inv[i], you.pos() );

Replacement in crawl-ref/source/terrain.h at line 24 [69.24828]

B:BD[69.25451] → [22.143:210]

bool fall_into_a_pool( int entry_x, int entry_y, bool allow_shift,

[69.25451]

[69.25519]

bool fall_into_a_pool( const coord_def& entry, bool allow_shift,

Replacement in crawl-ref/source/terrain.h at line 53 [69.24828]
∅:D[111.297] → [112.136:204]
∅:D[113.371] → [112.136:204]
B:BD[69.26358] → [112.136:204]
```
dungeon_feature_type grid_secret_door_appearance( int gx, int gy );
```
[111.297]
[69.26409]
```
dungeon_feature_type grid_secret_door_appearance( const coord_def& where );
```
Replacement in crawl-ref/source/terrain.cc at line 304 [69.26938]
∅:D[113.1158] → [112.206:273]
B:BD[69.32648] → [112.206:273]
```
dungeon_feature_type grid_secret_door_appearance( int gx, int gy )
```
[113.1158]
[69.32698]
```
dungeon_feature_type grid_secret_door_appearance( const coord_def& where )
```

Replacement in crawl-ref/source/terrain.cc at line 315 [69.26938]

B:BD[69.32943] → [69.32943:33012]

            const dungeon_feature_type targ = grd[gx + dx][gy + dy];

[69.32943]

[69.33012]

            const dungeon_feature_type targ = grd[where.x + dx][where.y + dy];

Replacement in crawl-ref/source/terrain.cc at line 397 [69.26938]
B:BD[69.35400] → [69.35400:35447]
```
        move_item_to_grid(&index, np.x, np.y);
```
[69.35400]
[69.35447]
```
        move_item_to_grid(&index, np);
```

Replacement in crawl-ref/source/terrain.cc at line 429 [69.26938]

B:BD[69.36225] → [69.36225:36282]

            if (shop_struct *s = get_shop(pos.x, pos.y))

[69.36225]

[69.36282]

            if (shop_struct *s = get_shop(pos))

Replacement in crawl-ref/source/terrain.cc at line 556 [69.26938]
∅:D[103.420] → [69.38392:38463]
∅:D[114.759] → [69.38392:38463]
B:BD[69.38392] → [69.38392:38463]
```
                move_player_to_grid(pos.x, pos.y, false, true, false);
```
[114.759]
[114.760]
```
                move_player_to_grid(pos, false, true, false);
```
Replacement in crawl-ref/source/terrain.cc at line 567 [69.26938]
∅:D[115.638] → [116.210:277]
B:BD[69.38622] → [116.210:277]
```
bool fall_into_a_pool( int entry_x, int entry_y, bool allow_shift,
```
[115.638]
[69.38690]
```
bool fall_into_a_pool( const coord_def& entry, bool allow_shift,
```

Replacement in crawl-ref/source/terrain.cc at line 630 [69.26938]

B:BD[69.40405] → [69.40405:40604]

            if (grid_distance( you.x_pos, you.y_pos, entry_x, entry_y ) == 1
                && (entry_x != empty[0] || entry_y != empty[1])
                && mgrd[entry_x][entry_y] == NON_MONSTER)

[69.40405]

[69.40604]

            if (grid_distance( you.pos(), entry ) == 1
                && (entry.x != empty[0] || entry.y != empty[1])
                && mgrd(entry) == NON_MONSTER)

Replacement in crawl-ref/source/terrain.cc at line 635 [69.26938]

B:BD[69.40649] → [69.40649:40721]

                empty[0] = entry_x;
                empty[1] = entry_y;

[69.40649]

[69.40721]

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

Replacement in crawl-ref/source/terrain.cc at line 658 [69.26938]

B:BD[69.41162] → [69.41162:41237]

            move_player_to_grid( empty[0], empty[1], false, false, true );

[69.41162]

[69.41237]

            move_player_to_grid( pos, false, false, true );

Replacement in crawl-ref/source/stuff.h at line 154 [56.217090]
B:BD[56.222104] → [56.222104:222151]
```
bool adjacent( int x, int y, int x2, int y2 );
```
[56.222104]
[56.222151]
```
bool adjacent( const coord_def& p1, const coord_def& p2 );
```
Replacement in crawl-ref/source/stuff.cc at line 1174 [56.224557]
B:BD[56.240481] → [56.240481:240527]
```
bool adjacent( int x, int y, int x2, int y2 )
```
[56.240481]
[56.240527]
```
bool adjacent( const coord_def& p1, const coord_def& p2 )
```
Replacement in crawl-ref/source/stuff.cc at line 1176 [56.224557]
B:BD[56.240529] → [56.240529:240580]
```
    return (abs(x - x2) <= 1 && abs(y - y2) <= 1);
```
[56.240529]
[56.240580]
```
    return grid_distance(p1, p2) <= 1;
```
Replacement in crawl-ref/source/stuff.cc at line 1580 [56.224557]
B:BD[60.115577] → [60.115577:115627]
```
    losight(env.show, grd, you.x_pos, you.y_pos);
```
[60.115577]
[60.115627]
```
    losight(env.show, grd, you.pos());
```
Replacement in crawl-ref/source/stash.cc at line 273 [62.147324]
B:BD[57.2828] → [57.2828:2866]
```
        trap = trap_type_at_xy(x, y);
```
[57.2828]
[117.4905]
```
        trap = trap_type_at_xy(coord_def(x, y));
```
Replacement in crawl-ref/source/stash.cc at line 772 [62.147324]
B:BD[62.163038] → [62.163038:163082]
```
    const shop_struct *sh = get_shop(x, y);
```
[62.163038]
[62.163082]
```
    const shop_struct *sh = get_shop(coord_def(x, y));
```
Replacement in crawl-ref/source/stash.cc at line 1097 [62.147324]
B:BD[62.170221] → [62.170221:170255]
```
    si.set_name(shop_name(x, y));
```
[62.170221]
[118.1566]
```
    si.set_name(shop_name(coord_def(x, y)));
```

Replacement in crawl-ref/source/spl-cast.cc at line 2050 [56.293070]

B:BD[119.15507] → [119.15507:15587]

        noisy(25, you.x_pos, you.y_pos, "You hear a voice calling your name!");

[119.15507]

[56.339773]

        noisy(25, you.pos(), "You hear a voice calling your name!");

Replacement in crawl-ref/source/spl-cast.cc at line 3756 [56.293070]

B:BD[120.40436] → [120.40436:40495]

            place_cloud(CLOUD_STINK, you.x_pos, you.y_pos,

[120.40436]

[45.714]

            place_cloud(CLOUD_STINK, you.pos(),

Replacement in crawl-ref/source/spells4.cc at line 296 [56.436250]
B:BD[56.445676] → [58.473:498]
```
        noisy(30, x, y);
```
[56.445676]
[56.445738]
```
        noisy(30, coord_def(x, y));
```
Replacement in crawl-ref/source/spells4.cc at line 314 [56.436250]
B:BD[119.16783] → [119.16783:16824]
```
        noisy(30, you.x_pos, you.y_pos);
```
[119.16783]
[119.16824]
```
        noisy(30, you.pos());
```

Replacement in crawl-ref/source/spells4.cc at line 561 [56.436250]

∅:D[119.17395] → [121.3342:3419]

B:BD[56.462622] → [121.3342:3419]

B:BD[121.3419] → [122.216:245]

        place_cloud(CLOUD_FIRE, x, y, strength + roll_dice(3, strength / 4),
                    KC_YOU);

[119.17395]

[119.17396]

        place_cloud(CLOUD_FIRE, coord_def(x, y),
                    strength + roll_dice(3, strength / 4), KC_YOU);

Replacement in crawl-ref/source/spells4.cc at line 746 [56.436250]
B:BD[121.3595] → [121.3595:3641]
```
            CLOUD_FIRE, you.x_pos, you.y_pos,
```
[121.3595]
[121.3641]
```
            CLOUD_FIRE, you.pos(),
```

Replacement in crawl-ref/source/spells4.cc at line 1088 [56.436250]

B:BD[56.478540] → [56.478540:478652]

    int next = 0, obj = mgrd[x][y];
    if (obj == NON_MONSTER)
        return 0;
    while (obj != NON_ITEM)

[56.478540]

[56.478652]

    for ( stack_iterator si(coord_def(x,y)); si; ++si )

Replacement in crawl-ref/source/spells4.cc at line 1090 [56.436250]

B:BD[56.478658] → [56.478658:478787]

        next = mitm[obj].link;
        if (mitm[obj].base_type == OBJ_CORPSES
            && mitm[obj].sub_type == CORPSE_BODY)

[56.478658]

[56.478787]

        if (si->base_type == OBJ_CORPSES
            && si->sub_type == CORPSE_BODY)

Replacement in crawl-ref/source/spells4.cc at line 1093 [56.436250]

B:BD[56.478797] → [56.478797:478880]

            if (!mons_skeleton(mitm[obj].plus))
                destroy_item(obj);

[56.478797]

[56.478880]

            if (!mons_skeleton(si->plus))
                destroy_item(si->index());

Replacement in crawl-ref/source/spells4.cc at line 1096 [56.436250]

B:BD[56.478897] → [123.266:320]

                turn_corpse_into_skeleton(mitm[obj]);

[56.478897]

[56.479066]

                turn_corpse_into_skeleton(*si);

Replacement in crawl-ref/source/spells4.cc at line 1098 [56.436250]
B:BD[56.479067] → [56.479067:479104]
```
            place_cloud(ctype, x, y,
```
[56.479067]
[56.479104]
```
            place_cloud(ctype, coord_def(x,y),
```
Deletion in crawl-ref/source/spells4.cc at line 1104 [56.436250]
B:BD[56.479248] → [56.479248:479269]
```
        obj = next;
```
Replacement in crawl-ref/source/spells4.cc at line 1112 [56.436250]
B:BD[56.479409] → [124.1163:1193]
```
    place_cloud( ctype, x, y,
```
[56.479409]
[121.3980]
```
    place_cloud( ctype, coord_def(x, y),
```
Replacement in crawl-ref/source/spells4.cc at line 2016 [56.436250]
B:BD[56.509171] → [42.4389:4432]
```
        trap = trap_at_xy(spd.tx, spd.ty);
```
[56.509171]
[124.2372]
```
        trap = trap_at_xy(spd.target());
```

Replacement in crawl-ref/source/spells4.cc at line 2523 [56.436250]

B:BD[125.76] → [125.76:186]

    const int ox = you.x_pos + (x - you.x_pos) * dist;
    const int oy = you.y_pos + (y - you.y_pos) * dist;

[125.76]

[55.5033]

    coord_def orig;
    orig.x = you.x_pos + (x - you.x_pos) * dist;
    orig.y = you.y_pos + (y - you.y_pos) * dist;

Replacement in crawl-ref/source/spells4.cc at line 2529 [56.436250]
∅:D[55.5131] → [125.190:206]
B:BD[125.190] → [125.190:206]
```
    int tx, ty;
```
[55.5131]
[55.5132]
```
    coord_def target;
```

Replacement in crawl-ref/source/spells4.cc at line 2536 [56.436250]

B:BD[126.7790] → [126.7790:7894]

        if (!random_near_space(ox, oy, tx, ty)
            && !random_near_space(ox, oy, tx, ty, true))

[126.7790]

[126.7894]

        if (!random_near_space(orig, target)
            && !random_near_space(orig, target, true))

Replacement in crawl-ref/source/spells4.cc at line 2543 [56.436250]

B:BD[126.7983] → [126.7983:8094]

        if (distance(ox, oy, tx, ty) > 10
            && distance(you.x_pos, you.y_pos, tx, ty) < 8)
        {

[126.7983]

[55.5531]

        if (distance(orig, target) > 10 && distance(you.pos(), target) < 8)

Deletion in crawl-ref/source/spells4.cc at line 2545 [56.436250]
B:BD[55.5553] → [126.8095:8105]
```
        }
```
Replacement in crawl-ref/source/spells4.cc at line 2546 [56.436250]
B:BD[55.5554] → [55.5554:5594]
```
        if (!see_grid_no_trans(tx, ty))
```
[55.5554]
[55.5594]
```
        if (!see_grid_no_trans(target))
```
Replacement in crawl-ref/source/spells4.cc at line 2556 [56.436250]
∅:D[55.5699] → [88.7089:7113]
B:BD[56.525580] → [88.7089:7113]
```
    you.moveto(tx, ty);
```
[55.5699]
[125.590]
```
    you.moveto(target);
```
Replacement in crawl-ref/source/spells3.cc at line 871 [56.531613]
B:BD[127.8262] → [128.167:199]
```
    if (is_sanctuary(a.x, a.y))
```
[127.8262]
[128.199]
```
    if (is_sanctuary(a))
```
Replacement in crawl-ref/source/spells3.cc at line 942 [56.531613]
B:BD[127.9942] → [127.9942:9989]
```
        losight(losgrid, grd, c.x, c.y, true);
```
[127.9942]
[127.9989]
```
        losight(losgrid, grd, c, true);
```
Replacement in crawl-ref/source/spells3.cc at line 1478 [56.531613]
∅:D[129.963] → [56.554333:554392]
B:BD[56.554333] → [56.554333:554392]
```
            if ((which_trap = trap_at_xy(srx, sry)) != -1)
```
[129.963]
[56.554392]
```
            if ((which_trap = trap_at_xy(coord_def(srx, sry))) != -1)
```

Replacement in crawl-ref/source/spells3.cc at line 1501 [56.531613]

B:BD[130.297] → [130.297:476]

B:BD[130.476] → [80.1346:1415]

            const coord_def pos = mon->pos();
            int walls = num_feats_between(you.x_pos, you.y_pos,
                                          pos.x, pos.y, DNGN_UNSEEN,
                                          DNGN_MAXWALL, true, true);

[130.297]

[130.533]

            int walls = num_feats_between(you.pos(), mon->pos(),
                                          DNGN_UNSEEN, DNGN_MAXWALL,
                                          true, true);

Replacement in crawl-ref/source/spells3.cc at line 1532 [56.531613]
B:BD[8.226] → [8.226:262]
```
    if (!in_los_bounds(ep.x, ep.y))
```
[8.226]
[131.502]
```
    if (!in_los_bounds(ep))
```

Replacement in crawl-ref/source/spells3.cc at line 1552 [56.531613]

B:BD[65.1950] → [117.6579:6670]

∅:D[117.6670] → [65.2033:2042]

B:BD[65.2033] → [65.2033:2042]

B:BD[65.2042] → [63.923:1015]

∅:D[63.1015] → [65.2126:2436]

B:BD[65.2126] → [65.2126:2436]

    for (int x = -radius; x <= radius; x++)
       for (int y = -radius; y <= radius; y++)
       {
          int posx = env.sanctuary_pos.x + x;
          int posy = env.sanctuary_pos.y + y;
          if (posx <= 0 || posx > GXM || posy <= 0 || posy > GYM)
              continue;
          if (is_sanctuary(posx, posy))
          {
              env.map[posx][posy].property = FPROP_NONE;
              if (see_grid(coord_def(posx,posy)))
                  seen_change = true;
          }
       }

[65.1950]

[65.2436]

    for (radius_iterator ri(env.sanctuary_pos, radius, true, false); ri; ++ri)
    {
        if (is_sanctuary(*ri))
        {
            env.map(*ri).property = FPROP_NONE;
            if (see_grid(*ri))
                seen_change = true;
        }
    }

Replacement in crawl-ref/source/spells3.cc at line 1592 [56.531613]
B:BD[132.172] → [133.167:226]
```
    if (you.running && is_sanctuary(you.x_pos, you.y_pos))
```
[132.172]
[133.226]
```
    if (you.running && is_sanctuary(you.pos()))
```

Replacement in crawl-ref/source/spells3.cc at line 1679 [56.531613]

B:BD[134.548] → [135.378:435]

            if (trap_type_at_xy(posx, posy) != NUM_TRAPS

[134.548]

[38.167]

            if (trap_type_at_xy(pos) != NUM_TRAPS

Replacement in crawl-ref/source/spells3.cc at line 1683 [56.531613]

B:BD[135.587] → [135.587:653]

                    trap_category( trap_type_at_xy(posx, posy) );

[135.587]

[135.653]

                    trap_category( trap_type_at_xy(pos) );

Replacement in crawl-ref/source/spells3.cc at line 1855 [56.531613]
B:BD[56.556405] → [136.1048:1083]
```
    if (!silenced( pos.x, pos.y ))
```
[56.556405]
[56.556444]
```
    if (!silenced( pos ))
```
Replacement in crawl-ref/source/spells3.cc at line 1859 [56.531613]
B:BD[56.556694] → [58.593:630]
```
            noisy(30, pos.x, pos.y);
```
[56.556694]
[56.556737]
```
            noisy(30, pos);
```

Replacement in crawl-ref/source/spells2.cc at line 245 [56.569242]

B:BD[56.573080] → [106.3752:3815]

∅:D[106.3815] → [56.573144:573205]

B:BD[56.573144] → [56.573144:573205]

                    behaviour_event( mon, ME_DISTURB, MHITYOU,
                                     you.x_pos, you.y_pos );

[56.573080]

[56.573205]

                    behaviour_event( mon, ME_DISTURB, MHITYOU, you.pos() );

Replacement in crawl-ref/source/spells2.cc at line 284 [56.569242]

B:BD[56.573989] → [128.227:299]

            if (see_grid_no_trans(adx, ady) && !is_sanctuary(adx, ady))

[56.573989]

[56.574025]

            coord_def ad(adx, ady);
            if (see_grid_no_trans(ad) && !is_sanctuary(ad))

Replacement in crawl-ref/source/spells2.cc at line 287 [56.569242]

B:BD[56.574039] → [56.574039:574163]

                if (igrd[adx][ady] == NON_ITEM
                    || env.cgrid[adx][ady] != EMPTY_CLOUD)
                {

[56.574039]

[56.574163]

                if (igrd(ad) == NON_ITEM || env.cgrid(ad) != EMPTY_CLOUD)

Deletion in crawl-ref/source/spells2.cc at line 289 [56.569242]

B:BD[56.574193] → [56.574193:574284]

                }
                int objl = igrd[adx][ady];
                int hrg = 0;

Replacement in crawl-ref/source/spells2.cc at line 290 [56.569242]

B:BD[56.574285] → [56.574285:574326]

                while (objl != NON_ITEM)

[56.574285]

[56.574326]

                for ( stack_iterator si(ad); si; ++si )

Replacement in crawl-ref/source/spells2.cc at line 292 [56.569242]

B:BD[56.574344] → [56.574344:574467]

                    if (mitm[objl].base_type == OBJ_CORPSES
                        && mitm[objl].sub_type == CORPSE_BODY)

[56.574344]

[56.574467]

                    if (si->base_type == OBJ_CORPSES
                        && si->sub_type == CORPSE_BODY)

Replacement in crawl-ref/source/spells2.cc at line 295 [56.569242]

B:BD[56.574489] → [56.574489:574598]

                        if (!mons_skeleton(mitm[objl].plus))
                            destroy_item(objl);

[56.574489]

[56.574598]

                        // Found a corpse. Skeletify it if possible.
                        if (!mons_skeleton(si->plus))
                            destroy_item(si->index());

Replacement in crawl-ref/source/spells2.cc at line 299 [56.569242]

B:BD[56.574627] → [123.325:392]

                            turn_corpse_into_skeleton(mitm[objl]);

[56.574627]

[56.574859]

                            turn_corpse_into_skeleton(*si);

Replacement in crawl-ref/source/spells2.cc at line 301 [56.569242]

B:BD[56.574860] → [56.574860:574920]

                        place_cloud(CLOUD_MIASMA, adx, ady,

[56.574860]

[121.4274]

                        place_cloud(CLOUD_MIASMA, ad,

Deletion in crawl-ref/source/spells2.cc at line 307 [56.569242]

B:BD[56.575046] → [56.575046:575121]

                    hrg = mitm[objl].link;
                    objl = hrg;

Replacement in crawl-ref/source/spells2.cc at line 412 [56.569242]
B:BD[137.16029] → [58.633:674]
```
        noisy(15, you.x_pos, you.y_pos);
```
[137.16029]
[138.630]
```
        noisy(15, you.pos());
```

Replacement in crawl-ref/source/spells2.cc at line 797 [56.569242]

B:BD[139.282] → [139.282:361]

            behaviour_event(monster, ME_WHACK, MHITYOU, you.x_pos, you.y_pos);

[139.282]

[56.593830]

            behaviour_event(monster, ME_WHACK, MHITYOU, you.pos());

Replacement in crawl-ref/source/spells2.cc at line 1834 [56.569242]
B:BD[140.3549] → [140.3549:3580]
```
        int tx = -1, ty = -1;
```
[140.3549]
[140.3580]
```
        coord_def target;
        bool found = false;
```

Replacement in crawl-ref/source/spells2.cc at line 1838 [56.569242]

B:BD[140.3627] → [140.3627:3768]

            if (!random_near_space(you.x_pos, you.y_pos, tx, ty, true, true)
                && distance(you.x_pos, you.y_pos, tx, ty) <= 5)

[140.3627]

[140.3768]

            if (!random_near_space(you.pos(), target, true, true)
                && distance(you.pos(), target) <= 5)

Insertion in crawl-ref/source/spells2.cc at line 1841 [56.569242]
[140.3782]
[140.3782]
```
                found = true;
```

Replacement in crawl-ref/source/spells2.cc at line 1847 [56.569242]

B:BD[140.3900] → [140.3900:4010]

        if (tx == -1 || ty == -1)
        {
            tx = you.x_pos;
            ty = you.y_pos;
        }

[140.3900]

[140.4010]

        if ( !found )
            target = you.pos();

Replacement in crawl-ref/source/spells2.cc at line 1853 [56.569242]

B:BD[140.4121] → [141.686:740]

B:BD[141.740] → [142.9076:9112]

                          coord_def(tx, ty), MHITNOT,
                          0, god));

[140.4121]

[140.4177]

                          target, MHITNOT, 0, god));

Deletion in crawl-ref/source/spells2.cc at line 1858 [56.569242]
B:BD[140.4243] → [140.4243:4244]

Replacement in crawl-ref/source/spells1.cc at line 109 [56.616635]

B:BD[56.618453] → [2.39:114]

            if (!beam.isValid || coord_def(beam.tx, beam.ty) == you.pos())

[56.618453]

[56.618484]

            if (!beam.isValid || coord_def(beam.target()) == you.pos())

Replacement in crawl-ref/source/spells1.cc at line 123 [56.616635]

B:BD[55.6847] → [55.6847:6900]

            if (see_grid_no_trans(beam.tx, beam.ty))

[55.6847]

[56.618658]

            if (see_grid_no_trans(beam.target()))

Replacement in crawl-ref/source/spells1.cc at line 125 [56.616635]

B:BD[56.618681] → [55.6901:6963]

            else if (trans_wall_blocking( beam.tx, beam.ty ))

[56.618681]

[55.6963]

            else if (trans_wall_blocking( beam.target() ))

Replacement in crawl-ref/source/spells1.cc at line 163 [56.616635]
∅:D[143.749] → [144.147:217]
∅:D[107.799] → [144.147:217]
∅:D[145.1071] → [144.147:217]
B:BD[56.619202] → [144.147:217]
```
            move_player_to_grid(beam.tx, beam.ty, false, true, true);
```
[145.1071]
[56.619268]
```
            move_player_to_grid(beam.target(), false, true, true);
```
Replacement in crawl-ref/source/spells1.cc at line 185 [56.616635]
B:BD[56.619670] → [56.619670:619686]
```
    int tx, ty;
```
[56.619670]
[56.619686]
```
    coord_def target;
```

Replacement in crawl-ref/source/spells1.cc at line 197 [56.616635]

B:BD[55.7844] → [55.7844:7978]

    else if (!random_near_space(you.x_pos, you.y_pos, tx, ty)
             && !random_near_space(you.x_pos, you.y_pos, tx, ty, true))

[55.7844]

[56.620014]

    else if (!random_near_space(you.pos(), target)
             && !random_near_space(you.pos(), target, true))

Replacement in crawl-ref/source/spells1.cc at line 222 [56.616635]
B:BD[56.620534] → [88.7293:7321]
```
        you.moveto(tx, ty);
```
[56.620534]
[56.620582]
```
        you.moveto(target);
```
Deletion in crawl-ref/source/spells1.cc at line 237 [56.616635]
B:BD[56.620887] → [56.620887:620900]
```
    return;
```
Replacement in crawl-ref/source/spells1.cc at line 294 [56.616635]
B:BD[60.154210] → [60.154210:154253]
```
    int sx, sy;
    int tx, ty;
    int i;
```
[60.154210]
[60.154253]
```
    coord_def source, target;
```

Replacement in crawl-ref/source/spells1.cc at line 296 [56.616635]

B:BD[60.154254] → [146.173:214]

B:BD[146.214] → [147.813:882]

    for (sx = you.x_pos, sy = you.y_pos;
         pow > 0;
         pow -= 8 + random2(13), sx = tx, sy = ty)

[60.154254]

[60.154368]

    for (source = you.pos(); pow > 0; pow -= 8 + random2(13), source = target)

Replacement in crawl-ref/source/spells1.cc at line 306 [56.616635]
B:BD[60.154621] → [60.154621:154655]
```
        tx = -1;
        ty = -1;
```
[60.154621]
[60.154655]
```
        target.x = -1;
        target.y = -1;
```
Replacement in crawl-ref/source/spells1.cc at line 309 [56.616635]
B:BD[60.154656] → [60.154656:154699]
```
        for (i = 0; i < MAX_MONSTERS; i++)
```
[60.154656]
[60.154699]
```
        for (int i = 0; i < MAX_MONSTERS; i++)
```
Replacement in crawl-ref/source/spells1.cc at line 311 [56.616635]
B:BD[60.154709] → [60.154709:154758]
```
            struct monsters *monster = &menv[i];
```
[60.154709]
[60.154758]
```
            monsters *monster = &menv[i];
```
Replacement in crawl-ref/source/spells1.cc at line 313 [56.616635]
B:BD[60.154759] → [60.154759:154796]
```
            if (monster->type == -1)
```
[60.154759]
[60.154796]
```
            if (invalid_monster(monster))
```

Replacement in crawl-ref/source/spells1.cc at line 316 [56.616635]

B:BD[60.154823] → [60.154823:154891]

            dist = grid_distance( sx, sy, monster->x, monster->y );

[60.154823]

[60.154891]

            dist = grid_distance( source, monster->pos() );

Replacement in crawl-ref/source/spells1.cc at line 329 [56.616635]

B:BD[60.155244] → [60.155244:155316]

            if (!check_line_of_sight( sx, sy, monster->x, monster->y ))

[60.155244]

[60.155316]

            if (!check_line_of_sight( source, monster->pos() ))

Replacement in crawl-ref/source/spells1.cc at line 340 [56.616635]

B:BD[60.155580] → [60.155580:155654]

                    tx = monster->x;
                    ty = monster->y;

[60.155580]

[60.155654]

                    target = monster->pos();

Replacement in crawl-ref/source/spells1.cc at line 344 [56.616635]

B:BD[60.155717] → [147.883:938]

            else if (tx == -1 || one_chance_in(count))

[60.155717]

[60.155774]

            else if (target.x == -1 || one_chance_in(count))

Replacement in crawl-ref/source/spells1.cc at line 347 [56.616635]

B:BD[60.155863] → [60.155863:155929]

                tx = monster->x;
                ty = monster->y;

[60.155863]

[146.323]

                target = monster->pos();

Replacement in crawl-ref/source/spells1.cc at line 355 [56.616635]

B:BD[148.218] → [147.989:1049]

        dist = grid_distance(sx, sy, you.x_pos, you.y_pos);

[148.218]

[60.156217]

        dist = grid_distance(source, you.pos());

Replacement in crawl-ref/source/spells1.cc at line 363 [56.616635]
B:BD[60.156437] → [146.325:351]
```
            if ((tx == -1
```
[60.156437]
[60.156464]
```
            if ((target.x == -1
```

Replacement in crawl-ref/source/spells1.cc at line 366 [56.616635]

B:BD[147.1121] → [147.1121:1191]

                && check_line_of_sight(sx, sy, you.x_pos, you.y_pos))

[147.1121]

[60.156648]

                && check_line_of_sight(source, you.pos()))

Replacement in crawl-ref/source/spells1.cc at line 368 [56.616635]

B:BD[60.156662] → [60.156662:156726]

                tx = you.x_pos;
                ty = you.y_pos;

[60.156662]

[60.156726]

                target = you.pos();

Replacement in crawl-ref/source/spells1.cc at line 372 [56.616635]

B:BD[60.156751] → [60.156751:156855]

        const bool see_source = see_grid( sx, sy );
        const bool see_targ   = see_grid( tx, ty );

[60.156751]

[60.156855]

        const bool see_source = see_grid( source );
        const bool see_targ   = see_grid( target );

Replacement in crawl-ref/source/spells1.cc at line 375 [56.616635]
B:BD[60.156856] → [60.156856:156878]
```
        if (tx == -1)
```
[60.156856]
[60.156878]
```
        if (target.x == -1)
```

Replacement in crawl-ref/source/spells1.cc at line 386 [56.616635]

B:BD[58.702] → [58.702:771]

            noisy(25, sx, sy, "You hear a mighty clap of thunder!");

[58.702]

[60.157234]

            noisy(25, source, "You hear a mighty clap of thunder!");

Replacement in crawl-ref/source/spells1.cc at line 393 [56.616635]
B:BD[60.157441] → [55.7979:8021]
```
        if (!see_grid_no_trans( tx, ty ))
```
[60.157441]
[60.157464]
```
        if (!see_grid_no_trans( target ))
```

Replacement in crawl-ref/source/spells1.cc at line 399 [56.616635]

B:BD[60.157583] → [60.157583:157695]

        beam.source_x = sx;
        beam.source_y = sy;
        beam.target_x = tx;
        beam.target_y = ty;

[60.157583]

[60.157695]

        beam.source_x = source.x;
        beam.source_y = source.y;
        beam.target_x = target.x;
        beam.target_y = target.y;

Replacement in crawl-ref/source/spells1.cc at line 407 [56.616635]
∅:D[148.255] → [60.157821:157869]
B:BD[60.157821] → [60.157821:157869]
```
        if (tx == you.x_pos && ty == you.y_pos)
```
[148.255]
[60.157869]
```
        if (target == you.pos())
```

Replacement in crawl-ref/source/spells1.cc at line 552 [56.616635]

B:BD[56.624554] → [121.4594:4662]

    place_cloud( CLOUD_FIRE, spelld.tx, spelld.ty, durat, KC_YOU );

[56.624554]

[149.10641]

    place_cloud( CLOUD_FIRE, spelld.target(), durat, KC_YOU );

Replacement in crawl-ref/source/spells1.cc at line 1701 [56.616635]

B:BD[56.642927] → [56.642927:642954]

    char stx = 0, sty = 0;

[56.642927]

[56.642954]

    for ( radius_iterator ri(you.pos(), 1); ri; ++ri )
    {
        if ( *ri == you.pos() )
            continue;

Replacement in crawl-ref/source/spells1.cc at line 1706 [56.616635]

B:BD[56.642955] → [56.642955:642990]

B:BD[56.642996] → [56.642996:643164]

B:BD[56.643164] → [60.159313:159383]

∅:D[60.159383] → [56.643241:643409]

B:BD[56.643241] → [56.643241:643409]

B:BD[56.643409] → [121.5040:5095]

∅:D[121.5095] → [56.643456:643480]

B:BD[56.643456] → [56.643456:643480]

    for (stx = -1; stx < 2; stx++)
        for (sty = -1; sty < 2; sty++)
        {
            if (sty == 0 && stx == 0)
                continue;
            //if ( one_chance_in(3) ) beam.range ++;
            if (!grid_is_solid(grd[you.x_pos + stx][you.y_pos + sty])
                && env.cgrid[you.x_pos + stx][you.y_pos + sty] == EMPTY_CLOUD)
            {
                place_cloud( CLOUD_FIRE, you.x_pos + stx, you.y_pos + sty,
                             1 + random2(6), KC_YOU );
            }
        }

[56.642955]

[150.2704]

        if (!grid_is_solid(grd(*ri)) && env.cgrid(*ri) == EMPTY_CLOUD)
            place_cloud( CLOUD_FIRE, *ri, 1 + random2(6), KC_YOU );
    }

Replacement in crawl-ref/source/shopping.h at line 27 [56.758673]
B:BD[56.759650] → [151.159:198]
```
shop_struct *get_shop(int sx, int sy);
```
[56.759650]
[56.759651]
```
shop_struct *get_shop(const coord_def& where);
```

Replacement in crawl-ref/source/shopping.h at line 29 [56.758673]

B:BD[56.759652] → [152.216:255]

B:BD[152.255] → [153.2186:2240]

std::string shop_name(int sx, int sy);
std::string shop_name(int sx, int sy, bool add_stop);

[56.759652]

[154.208]

std::string shop_name(const coord_def& where);
std::string shop_name(const coord_def& where, bool add_stop);

Replacement in crawl-ref/source/shopping.cc at line 235 [56.759950]

B:BD[56.763421] → [155.2034:2113]

    const std::string hello = "Welcome to " + shop_name(shop.x, shop.y) + "!";

[56.763421]

[156.361]

    const std::string hello = "Welcome to " + shop_name(shop.pos()) + "!";

Replacement in crawl-ref/source/shopping.cc at line 497 [56.759950]

B:BD[56.768855] → [56.768855:768931]

        move_item_to_grid( &item_got, env.shop[shop].x, env.shop[shop].y );

[56.768557]

[43.7105]

        move_item_to_grid( &item_got,
                           coord_def(env.shop[shop].x, env.shop[shop].y) );

Replacement in crawl-ref/source/shopping.cc at line 1653 [56.759950]

B:BD[156.921] → [156.921:998]

        mprf("%s appears to be closed.", shop_name(shop.x, shop.y).c_str());

[156.921]

[156.998]

        mprf("%s appears to be closed.", shop_name(shop.pos()).c_str());

Replacement in crawl-ref/source/shopping.cc at line 1662 [56.759950]
B:BD[56.798011] → [151.200:238]
```
shop_struct *get_shop(int sx, int sy)
```
[56.798011]
[56.798049]
```
shop_struct *get_shop(const coord_def& where)
```
Replacement in crawl-ref/source/shopping.cc at line 1664 [56.759950]
B:BD[56.798113] → [56.798113:798153]
```
    if (grd[sx][sy] != DNGN_ENTER_SHOP)
```
[56.798051]
[62.195266]
```
    if (grd(where) != DNGN_ENTER_SHOP)
```

Replacement in crawl-ref/source/shopping.cc at line 1671 [56.759950]

B:BD[56.798306] → [56.798306:798374]

        if (env.shop[shoppy].x == sx && env.shop[shoppy].y == sy &&

[56.798306]

[56.798374]

        if (env.shop[shoppy].pos() == where &&

Replacement in crawl-ref/source/shopping.cc at line 1680 [56.759950]
B:BD[153.2245] → [153.2245:2298]
```
std::string shop_name(int sx, int sy, bool add_stop)
```
[153.2245]
[153.2298]
```
std::string shop_name(const coord_def& where, bool add_stop)
```
Replacement in crawl-ref/source/shopping.cc at line 1682 [56.759950]
B:BD[153.2300] → [153.2300:2341]
```
    std::string name(shop_name(sx, sy));
```
[153.2300]
[153.2341]
```
    std::string name(shop_name(where));
```
Replacement in crawl-ref/source/shopping.cc at line 1688 [56.759950]
B:BD[56.798474] → [152.257:295]
```
std::string shop_name(int sx, int sy)
```
[56.798474]
[62.195448]
```
std::string shop_name(const coord_def& where)
```
Replacement in crawl-ref/source/shopping.cc at line 1690 [56.759950]
B:BD[62.195479] → [62.195479:195528]
```
    const shop_struct *cshop = get_shop(sx, sy);
```
[62.195450]
[62.195528]
```
    const shop_struct *cshop = get_shop(where);
```
Replacement in crawl-ref/source/shopping.cc at line 1693 [56.759950]
B:BD[62.195545] → [62.195545:195585]
```
    if (grd[sx][sy] != DNGN_ENTER_SHOP)
```
[62.195545]
[62.195585]
```
    if (grd(where) != DNGN_ENTER_SHOP)
```
Replacement in crawl-ref/source/shopping.cc at line 1733 [56.759950]
B:BD[56.799998] → [56.799998:800030]
```
        int temp = sx + sy % 4;
```
[56.799998]
[152.1311]
```
        int temp = where.x + where.y % 4;
```

Replacement in crawl-ref/source/religion.cc at line 806 [56.804403]

∅:D[157.2582] → [158.2953:3076]

∅:D[159.3278] → [158.2953:3076]

B:BD[158.2953] → [158.2953:3076]

    {
         fall_into_a_pool( you.x_pos, you.y_pos, true,
                           grd[you.x_pos][you.y_pos] );
    }

[159.3278]

[160.2529]

        fall_into_a_pool( you.pos(), true, grd(you.pos()) );

Replacement in crawl-ref/source/religion.cc at line 1059 [56.804403]

B:BD[161.3845] → [161.3845:3916]

            move_item_to_grid( &thing_created, you.x_pos, you.y_pos );

[161.3845]

[161.3916]

            move_item_to_grid( &thing_created, you.pos() );

Replacement in crawl-ref/source/religion.cc at line 1885 [56.804403]

B:BD[56.817695] → [60.179988:180071]

                        move_item_to_grid( &thing_created, you.x_pos, you.y_pos );

[56.817695]

[56.817775]

                        move_item_to_grid( &thing_created, you.pos() );

Replacement in crawl-ref/source/religion.cc at line 3277 [56.804403]

B:BD[162.4741] → [17.4830:4898]

            place_cloud( CLOUD_FIRE, ri->x, ri->y, durat, KC_YOU );

[162.4741]

[162.5079]

            place_cloud( CLOUD_FIRE, *ri, durat, KC_YOU );

Replacement in crawl-ref/source/religion.cc at line 3354 [56.804403]
∅:D[163.241] → [164.6433:6451]
∅:D[165.938] → [164.6433:6451]
∅:D[166.3048] → [164.6433:6451]
∅:D[167.4922] → [164.6433:6451]
∅:D[159.7403] → [164.6433:6451]
B:BD[164.6433] → [164.6433:6451]
B:BD[164.6451] → [23.3144:3274]
∅:D[168.910] → [164.6581:6599]
∅:D[23.3274] → [164.6581:6599]
∅:D[167.5056] → [164.6581:6599]
B:BD[164.6581] → [164.6581:6599]
```
                {
                    fall_into_a_pool(you.x_pos, you.y_pos, true,
                                     grd[you.x_pos][you.y_pos]);
                }
```
[166.3048]
[56.854941]
```
                    fall_into_a_pool(you.pos(), true, grd(you.pos()));
```

Replacement in crawl-ref/source/religion.cc at line 3430 [56.804403]

B:BD[149.14787] → [149.14787:14859]

            noisy(25, you.x_pos, you.y_pos); // same as scroll of noise

[149.14787]

[149.14859]

            noisy(25, you.pos()); // same as scroll of noise

Replacement in crawl-ref/source/religion.cc at line 3533 [56.804403]

B:BD[169.3944] → [58.3246:3314]

        noisy(25, you.x_pos, you.y_pos); // same as scroll of noise

[169.3944]

[169.4014]

        noisy(25, you.pos()); // same as scroll of noise

Replacement in crawl-ref/source/religion.cc at line 4851 [56.804403]
∅:D[170.3652] → [159.10736:10746]
B:BD[159.10736] → [159.10736:10746]
B:BD[159.10746] → [170.3653:3767]
∅:D[170.3767] → [159.10747:10757]
B:BD[165.1092] → [159.10747:10757]
```
        {
            fall_into_a_pool(you.x_pos, you.y_pos, true,
                             grd[you.x_pos][you.y_pos]);
        }
```
[170.3652]
[164.17154]
```
            fall_into_a_pool(you.pos(), true, grd(you.pos()));
```

Replacement in crawl-ref/source/religion.cc at line 5008 [56.804403]

B:BD[66.3733] → [66.3733:3883]

                     if (is_bloodcovered(you.x_pos+i, you.y_pos+j))
                         env.map[you.x_pos+i][you.y_pos+j].property = FPROP_NONE;

[66.3733]

[66.3883]

                    coord_def tmp = you.pos() + coord_def(i,j);
                    if (is_bloodcovered(tmp))
                        env.map(tmp).property = FPROP_NONE;

Replacement in crawl-ref/source/religion.cc at line 5714 [56.804403]

B:BD[171.3065] → [171.3065:3139]

    bleed_onto_floor(you.x_pos, you.y_pos, mons_class, max_chunks, true);

[171.3065]

[171.3139]

    bleed_onto_floor(you.pos(), mons_class, max_chunks, true);

Replacement in crawl-ref/source/player.h at line 30 [56.945993]
∅:D[172.296] → [60.336043:336115]
B:BD[60.336043] → [60.336043:336115]
```
bool move_player_to_grid( int x, int y, bool stepped, bool allow_shift,
```
[60.336043]
[47.2566]
```
bool move_player_to_grid( const coord_def& p, bool stepped, bool allow_shift,
```
Replacement in crawl-ref/source/player.cc at line 110 [56.962854]
∅:D[47.2691] → [60.337460:337532]
∅:D[173.3688] → [60.337460:337532]
B:BD[60.337460] → [60.337460:337532]
```
bool move_player_to_grid( int x, int y, bool stepped, bool allow_shift,
```
[47.2691]
[47.2692]
```
bool move_player_to_grid( const coord_def& p, bool stepped, bool allow_shift,
```
Replacement in crawl-ref/source/player.cc at line 113 [56.962854]
B:BD[60.337573] → [60.337573:337606]
```
    ASSERT( in_bounds( x, y ) );
```
[60.337573]
[60.337606]
```
    ASSERT( in_bounds( p ) );
```
Deletion in crawl-ref/source/player.cc at line 115 [56.962854]
B:BD[60.337607] → [60.337607:337619]
```
    int id;
```

Replacement in crawl-ref/source/player.cc at line 116 [56.962854]

B:BD[60.337700] → [60.337700:337764]

B:BD[60.337764] → [57.4534:4602]

B:BD[57.4602] → [173.3689:3762]

∅:D[173.3762] → [57.4603:4656]

B:BD[60.337901] → [57.4603:4656]

    const bool from_above = (you.x_pos == x && you.y_pos == y);
    const dungeon_feature_type old_grid = (from_above) ? DNGN_FLOOR
                                            : grd[you.x_pos][you.y_pos];
    const dungeon_feature_type new_grid = grd[x][y];

[60.337700]

[60.337937]

    const bool from_above = (you.pos() == p);
    const dungeon_feature_type old_grid = (from_above) ? DNGN_FLOOR : grd(p);
    const dungeon_feature_type new_grid = grd(p);

Replacement in crawl-ref/source/player.cc at line 124 [56.962854]

B:BD[115.3224] → [47.2747:2921]

    ASSERT(swapping && mgrd[x][y] != NON_MONSTER ||
           !swapping && (mgrd[x][y] == NON_MONSTER
                         || mons_is_submerged( &menv[ mgrd[x][y] ])));

[115.3224]

[60.338335]

    ASSERT(swapping && mgrd(p) != NON_MONSTER ||
           !swapping && (mgrd(p) == NON_MONSTER
                         || mons_is_submerged( &menv[ mgrd(p) ])));

Replacement in crawl-ref/source/player.cc at line 128 [56.962854]
B:BD[60.338336] → [174.2679:2718]
```
    const int cloud = env.cgrid[x][y];
```
[60.338336]
[174.2718]
```
    const int cloud = env.cgrid(p);
```

Replacement in crawl-ref/source/player.cc at line 134 [56.962854]

B:BD[174.2919] → [174.2919:3062]

            && (env.cgrid[you.x_pos][you.y_pos] == EMPTY_CLOUD
                || ctype != env.cloud[ env.cgrid[you.x_pos][you.y_pos] ].type))

[174.2919]

[174.3062]

            && (env.cgrid(you.pos()) == EMPTY_CLOUD
                || ctype != env.cloud[ env.cgrid(you.pos()) ].type))

Replacement in crawl-ref/source/player.cc at line 161 [56.962854]

B:BD[175.573] → [28.2550:2591]

                id = trap_at_xy( x, y );

[175.573]

[28.2591]

                const int id = trap_at_xy( p );

Replacement in crawl-ref/source/player.cc at line 163 [56.962854]

B:BD[28.2621] → [28.2621:2689]

                    grd[x][y] = trap_category( env.trap[id].type );

[28.2621]

[28.2689]

                    grd(p) = trap_category( env.trap[id].type );

Replacement in crawl-ref/source/player.cc at line 188 [56.962854]

B:BD[175.1112] → [176.2825:2882]

            const trap_type type = trap_type_at_xy(x,y);

[175.1112]

[176.2882]

            const trap_type type = trap_type_at_xy(p);

Replacement in crawl-ref/source/player.cc at line 209 [56.962854]

B:BD[177.3546] → [177.3546:3613]

                                            "s", trap_name(x, y)))

[177.3546]

[177.3613]

                                            "s", trap_name(p.x, p.y)))

Replacement in crawl-ref/source/player.cc at line 237 [56.962854]

B:BD[60.339522] → [60.339522:339628]

            int entry_x = (stepped) ? you.x_pos : x;
            int entry_y = (stepped) ? you.y_pos : y;

[60.339522]

[60.339628]

            const coord_def entry = (stepped) ? you.pos() : p;

Replacement in crawl-ref/source/player.cc at line 246 [56.962854]
∅:D[115.3423] → [88.7338:7368]
B:BD[60.340033] → [88.7338:7368]
```
            you.moveto(x, y);
```
[115.3423]
[60.340087]
```
            you.moveto(p);
```

Replacement in crawl-ref/source/player.cc at line 251 [56.962854]

∅:D[115.3483] → [60.340187:340264]

B:BD[60.340187] → [60.340187:340264]

            if (fall_into_a_pool( entry_x, entry_y, allow_shift, new_grid ))

[115.3483]

[60.340264]

            if (fall_into_a_pool( entry, allow_shift, new_grid ))

Replacement in crawl-ref/source/player.cc at line 275 [56.962854]

B:BD[60.341028] → [60.341028:341099]

                    noisy(SL_SPLASH, you.x_pos, you.y_pos, "Splash!");

[60.341028]

[60.341099]

                    noisy(SL_SPLASH, you.pos(), "Splash!");

Replacement in crawl-ref/source/player.cc at line 300 [56.962854]
∅:D[115.3606] → [88.7369:7391]
B:BD[60.341646] → [88.7369:7391]
```
    you.moveto(x, y);
```
[115.3606]
[178.5747361]
```
    you.moveto(p);
```
Replacement in crawl-ref/source/player.cc at line 316 [56.962854]
B:BD[60.342113] → [60.342113:342162]
```
        id = trap_at_xy( you.x_pos, you.y_pos );
```
[60.342113]
[60.342162]
```
        int id = trap_at_xy( you.pos() );
```
Replacement in crawl-ref/source/player.cc at line 328 [56.962854]
∅:D[57.4763] → [60.342405:342455]
B:BD[60.342405] → [60.342405:342455]
```
                grd[you.x_pos][you.y_pos] = type;
```
[57.4763]
[64.12846]
```
                grd(you.pos()) = type;
```

Replacement in crawl-ref/source/player.cc at line 2690 [56.962854]

B:BD[130.1726] → [130.1726:1904]

        int walls = num_feats_between(you.x_pos, you.y_pos,
                                      pos.x, pos.y, DNGN_UNSEEN,
                                      DNGN_MAXWALL);

[130.1726]

[130.1904]

        int walls = num_feats_between(you.pos(), pos,
                                      DNGN_UNSEEN, DNGN_MAXWALL);

Replacement in crawl-ref/source/player.cc at line 5545 [56.962854]
B:BD[60.356188] → [179.2288:2330]
```
    prev_move_x = 0;
    prev_move_y = 0;
```
[60.356188]
[179.2330]
```
    prev_move = coord_def(0,0);
```
Deletion in crawl-ref/source/player.cc at line 6663 [56.962854]
∅:D[179.2376] → [73.494:497]
B:BD[180.2077] → [73.494:497]
B:BD[73.497] → [179.2377:2463]
```
}
coord_def player::prev_move() const
{
    return coord_def(prev_move_x, prev_move_y);
```
Replacement in crawl-ref/source/player.cc at line 6667 [56.962854]
B:BD[179.2499] → [179.2499:2541]
```
    prev_move_x = 0;
    prev_move_y = 0;
```
[179.2499]
[179.2541]
```
    prev_move = coord_def(0,0);
```
Replacement in crawl-ref/source/player.cc at line 6949 [56.962854]
B:BD[181.4943] → [181.4943:4996]
```
    if (trap_type_at_xy(x_pos, y_pos) != TRAP_SHAFT)
```
[181.4943]
[181.4996]
```
    if (trap_type_at_xy(this->pos()) != TRAP_SHAFT)
```

Replacement in crawl-ref/source/player.cc at line 6969 [56.962854]

B:BD[181.5460] → [100.3428:3492]

            handle_items_on_shaft(you.x_pos, you.y_pos, false);

[181.5460]

            handle_items_on_shaft(you.pos(), false);

Replacement in crawl-ref/source/overmap.cc at line 564 [56.1070017]

B:BD[182.15396] → [182.15396:15462]

            static_cast<shop_type>(get_shop(pos.x, pos.y)->type);

[182.15396]

[182.15462]

            static_cast<shop_type>(get_shop(pos)->type);

Replacement in crawl-ref/source/ouch.h at line 110 [56.1101726]

B:BD[56.1104317] → [46.2573:2654]

void expose_items_to_element(beam_type flavour, int x, int y, int strength = 0);

[56.1104317]

[183.2614]

void expose_items_to_element(beam_type flavour, const coord_def& where,
                             int strength = 0);

Replacement in crawl-ref/source/ouch.cc at line 543 [56.1104358]

B:BD[60.365651] → [46.2656:2732]

void expose_items_to_element(beam_type flavour, int x, int y, int strength)

[60.365651]

[183.3296]

void expose_items_to_element(beam_type flavour, const coord_def& where,
                             int strength)

Replacement in crawl-ref/source/ouch.cc at line 552 [56.1104358]
B:BD[60.365652] → [184.2882:2936]
```
    for (stack_iterator si(coord_def(x,y)); si; ++si)
```
[60.365652]
[183.3497]
```
    for (stack_iterator si(where); si; ++si)
```
Replacement in crawl-ref/source/ouch.cc at line 574 [56.1104358]
B:BD[183.3903] → [183.3903:3931]
```
        if (see_grid(x, y))
```
[183.3903]
[183.3931]
```
        if (see_grid(where))
```

Replacement in crawl-ref/source/mtransit.cc at line 219 [185.8445]

B:BD[100.6538] → [100.6538:6607]

        if (!copy_item_to_grid(*item, where_to_go.x, where_to_go.y))

[100.6538]

[100.6607]

        if (!copy_item_to_grid(*item, where_to_go))

Deletion in crawl-ref/source/mstuff2.h at line 24 [56.1336995]

∅:D[69.58893] → [56.1337459:1337460]

B:BD[56.1337459] → [56.1337459:1337460]

B:BD[56.1337743] → [56.1337743:1337935]


/*
   beam_colour = _pass[0];
   beam_range = _pass[1];
   beam_damage = _pass[2];
   beam_hit = _pass[3];
   beam_type = _pass[4];
   beam_flavour = _pass[5];
   thing_thrown = _pass[6];
 */

Deletion in crawl-ref/source/mstuff2.h at line 25 [56.1336995]

B:BD[56.1337936] → [56.1337936:1338157]


// last updated 12may2000 {dlb}
/* ***********************************************************************
 * called from: monstuff - mstuff2
 * *********************************************************************** */

Replacement in crawl-ref/source/mstuff2.h at line 26 [56.1336995]

∅:D[48.3429] → [56.1338210:1338422]

∅:D[60.396693] → [56.1338210:1338422]

B:BD[56.1338210] → [56.1338210:1338422]

B:BD[56.1338422] → [186.4080:4138]

∅:D[186.4138] → [56.1338487:1338699]

B:BD[56.1338487] → [56.1338487:1338699]


// last updated 12may2000 {dlb}
/* ***********************************************************************
 * called from: monstuff
 * *********************************************************************** */
void setup_dragon(monsters *monster, struct bolt &pbolt);
// last updated 13feb2001 {gdl}
/* ***********************************************************************
 * called from: monstuff
 * *********************************************************************** */

[48.3429]

[187.14193]

void setup_dragon(monsters *monster, bolt &pbolt);

Replacement in crawl-ref/source/mstuff2.h at line 28 [56.1336995]

∅:D[187.14264] → [56.1338777:1338987]

B:BD[56.1338777] → [56.1338777:1338987]

B:BD[56.1338987] → [48.3430:3528]

∅:D[48.3528] → [56.1339071:1339283]

∅:D[187.14341] → [56.1339071:1339283]

B:BD[56.1339071] → [56.1339071:1339283]

B:BD[56.1339283] → [186.4139:4210]

∅:D[186.4210] → [56.1339361:1339362]

B:BD[56.1339361] → [56.1339361:1339362]

B:BD[56.1339362] → [188.200:265]


// last updated 7jan2001 {gdl}
/* ***********************************************************************
 * called from: monstuff
 * *********************************************************************** */
void setup_mons_cast(monsters *monster, bolt &pbolt,
                     spell_type spell_cast);
// last updated 28july2000 (gdl)
/* ***********************************************************************
 * called from: monstuff
 * *********************************************************************** */
bool mons_throw(monsters *monster, struct bolt &pbolt, int hand_used);
bool mons_thrown_object_destroyed( item_def *item, int x, int y,

[187.14264]

[188.265]

void setup_mons_cast(monsters *monster, bolt &pbolt, spell_type spell_cast);
bool mons_throw(monsters *monster, bolt &pbolt, int hand_used);
bool mons_thrown_object_destroyed( item_def *item, const coord_def& where,

Replacement in crawl-ref/source/mstuff2.h at line 32 [56.1336995]

B:BD[188.328] → [188.328:329]

∅:D[188.329] → [56.1339362:1339572]

B:BD[56.1339362] → [56.1339362:1339572]

B:BD[56.1339572] → [186.4211:4276]

∅:D[186.4276] → [56.1339644:1339855]

B:BD[56.1339644] → [56.1339644:1339855]


// last updated 07jan2001 (gdl)
/* ***********************************************************************
 * called from: monstuff
 * *********************************************************************** */
void setup_generic_throw(monsters *monster, struct bolt &pbolt);
// last updated 12may2000 {dlb}
/* ***********************************************************************
 * called from: monstuff
 * *********************************************************************** */

[188.328]

[186.4277]

void setup_generic_throw(monsters *monster, bolt &pbolt);

Deletion in crawl-ref/source/mstuff2.h at line 34 [56.1336995]

∅:D[186.4312] → [56.1339897:1340152]

B:BD[56.1339897] → [56.1339897:1340152]


// last updated 12may2000 {dlb}
/* ***********************************************************************
 * called from: beam - fight - files - monstuff - mstuff2 - spells4
 * *********************************************************************** */

Deletion in crawl-ref/source/mstuff2.h at line 35 [56.1336995]

∅:D[20.2641] → [56.1340214:1340428]

∅:D[60.396800] → [56.1340214:1340428]

B:BD[56.1340214] → [56.1340214:1340428]


// last updated Dec17,2000 -- gdl
/* ***********************************************************************
 * called from: monstuff
 * *********************************************************************** */

Deletion in crawl-ref/source/mstuff2.h at line 36 [56.1336995]
∅:D[186.4409] → [56.1340476:1340477]
B:BD[56.1340476] → [56.1340476:1340477]
Replacement in crawl-ref/source/mstuff2.cc at line 68 [56.1340842]
B:BD[56.1342428] → [56.1342428:1342485]
```
    int which_trap = trap_at_xy(monster->x, monster->y);
```
[56.1342428]
[7.2541]
```
    int which_trap = trap_at_xy(monster->pos());
```
Replacement in crawl-ref/source/mstuff2.cc at line 160 [56.1340842]
B:BD[105.2344] → [105.2344:2387]
```
        noisy(12, monster->x, monster->y);
```
[105.2344]
[105.2387]
```
        noisy(12, monster->pos());
```
Replacement in crawl-ref/source/mstuff2.cc at line 162 [56.1340842]
B:BD[105.2388] → [105.2388:2433]
```
        if (!silenced(you.x_pos, you.y_pos))
```
[105.2388]
[105.2433]
```
        if (!silenced(you.pos()))
```

Replacement in crawl-ref/source/mstuff2.cc at line 224 [56.1340842]

B:BD[189.2623] → [189.2623:2695]

                bleed_onto_floor(monster->x, monster->y, monster->type,

[189.2623]

[189.2695]

                bleed_onto_floor(monster->pos(), monster->type,

Replacement in crawl-ref/source/mstuff2.cc at line 271 [56.1340842]

B:BD[143.2021] → [143.2021:2090]

                   env.trap[which_trap].x, env.trap[which_trap].y );

[143.2021]

[7.2623]

                   env.trap[which_trap].pos() );

Replacement in crawl-ref/source/mstuff2.cc at line 274 [56.1340842]

B:BD[190.1126] → [190.1126:1181]

            mark_net_trapping(monster->x, monster->y);

[190.1126]

[190.1181]

            mark_net_trapping(monster->pos());

Replacement in crawl-ref/source/mstuff2.cc at line 276 [56.1340842]
∅:D[190.1182] → [143.2090:2164]
B:BD[143.2090] → [143.2090:2164]
```
        grd[env.trap[which_trap].x][env.trap[which_trap].y] = DNGN_FLOOR;
```
[190.1182]
[143.2164]
```
        grd(env.trap[which_trap].pos()) = DNGN_FLOOR;
```

Replacement in crawl-ref/source/mstuff2.cc at line 813 [56.1340842]

B:BD[191.2989] → [128.2702:2847]

        const bool buff_only     = !friendly && is_sanctuary(you.x_pos,
                                                             you.y_pos);

[191.2989]

        const bool buff_only     = !friendly && is_sanctuary(you.pos());

Replacement in crawl-ref/source/mstuff2.cc at line 1037 [56.1340842]
∅:D[192.326] → [56.1363213:1363233]
B:BD[56.1363213] → [56.1363213:1363233]
```
    int newx, newy;
```
[192.326]
[193.3456]
```
    coord_def newpos;
```

Replacement in crawl-ref/source/mstuff2.cc at line 1040 [56.1340842]

B:BD[56.1363255] → [56.1363255:1363333]

        newx = 10 + random2(GXM - 20);
        newy = 10 + random2(GYM - 20);

[56.1363255]

[56.1363333]

        newpos.x = 10 + random2(GXM - 20);
        newpos.y = 10 + random2(GYM - 20);

Replacement in crawl-ref/source/mstuff2.cc at line 1044 [56.1340842]
∅:D[194.13057] → [195.148:192]
B:BD[56.1363382] → [195.148:192]
B:BD[195.192] → [193.3474:3529]
∅:D[193.3529] → [195.249:259]
B:BD[195.249] → [195.249:259]
```
        if (mgrd[newx][newy] != NON_MONSTER
            || newx == you.x_pos && newy == you.y_pos)
        {
```
[194.13057]
[56.1363427]
```
        if (mgrd(newpos) != NON_MONSTER || newpos == you.pos())
```
Deletion in crawl-ref/source/mstuff2.cc at line 1046 [56.1340842]
B:BD[56.1363449] → [195.260:270]
```
        }
```

Replacement in crawl-ref/source/mstuff2.cc at line 1047 [56.1340842]

B:BD[56.1363450] → [31.2571:2639]

        if (is_sanctuary(newx, newy) && !mons_wont_attack(monster))

[56.1363450]

[128.3605]

        if (is_sanctuary(newpos) && !mons_wont_attack(monster))

Replacement in crawl-ref/source/mstuff2.cc at line 1050 [56.1340842]
∅:D[128.3639] → [60.400410:400472]
B:BD[56.1363450] → [60.400410:400472]
```
        if (monster_habitable_grid(monster, grd[newx][newy]))
```
[128.3639]
[56.1363534]
```
        if (monster_habitable_grid(monster, grd(newpos)))
```
Replacement in crawl-ref/source/mstuff2.cc at line 1054 [56.1340842]
B:BD[56.1363725] → [56.1363725:1363771]
```
    monster->x = newx;
    monster->y = newy;
```
[56.1363725]
[56.1363771]
```
    monster->x = newpos.x;
    monster->y = newpos.y;
```
Replacement in crawl-ref/source/mstuff2.cc at line 1057 [56.1340842]
B:BD[56.1363772] → [56.1363772:1363831]
```
    mgrd[monster->x][monster->y] = monster_index(monster);
```
[56.1363772]
[56.1363831]
```
    mgrd(monster->pos()) = monster_index(monster);
```

Replacement in crawl-ref/source/mstuff2.cc at line 1563 [56.1340842]

B:BD[188.537] → [188.537:767]

    if (really_returns && mons_thrown_object_destroyed(&item, pbolt.target_x,
                                                       pbolt.target_y, true,
                                                       pbolt.beam_source))

[188.537]

[188.767]

    if (really_returns && mons_thrown_object_destroyed(&item, pbolt.target(),
                                                       true, pbolt.beam_source))

Replacement in crawl-ref/source/mstuff2.cc at line 1596 [56.1340842]

B:BD[188.813] → [188.813:878]

bool mons_thrown_object_destroyed( item_def *item, int x, int y,

[188.813]

[188.878]

bool mons_thrown_object_destroyed( item_def *item, const coord_def& where,

Replacement in crawl-ref/source/mstuff2.cc at line 1603 [56.1340842]
∅:D[196.5666] → [188.1103:1159]
B:BD[188.1103] → [188.1103:1159]
```
    bool hostile_grid = grid_destroys_items(grd[x][y]);
```
[196.5666]
[188.1159]
```
    bool hostile_grid = grid_destroys_items(grd(where));
```
Replacement in crawl-ref/source/mstuff2.cc at line 1673 [56.1340842]
B:BD[197.2694] → [198.4784:4834]
```
        if (is_sanctuary(monster->x, monster->y))
```
[197.2694]
[198.4834]
```
        if (is_sanctuary(monster->pos()))
```
Replacement in crawl-ref/source/mstuff2.cc at line 1679 [56.1340842]
B:BD[56.1375475] → [198.4909:4955]
```
    if (is_sanctuary(monster->x, monster->y))
```
[56.1375475]
[198.4955]
```
    if (is_sanctuary(monster->pos()))
```
Replacement in crawl-ref/source/mstuff2.cc at line 2355 [56.1340842]
B:BD[199.3668] → [200.2571:2620]
```
    else if (is_sanctuary(target->x, target->y))
```
[199.3668]
[200.2620]
```
    else if (is_sanctuary(target->pos()))
```

Replacement in crawl-ref/source/mstuff2.cc at line 2517 [56.1340842]

∅:D[201.3732] → [196.21754:21776]

B:BD[202.462] → [196.21754:21776]

B:BD[196.21776] → [201.3733:3860]

∅:D[201.3860] → [196.21777:21799]

B:BD[202.593] → [196.21777:21799]

                    {
                        behaviour_event(mon, ME_DISTURB, MHITNOT,
                                        chief->x, chief->y);
                    }

[201.3732]

[203.2013]

                        behaviour_event(mon, ME_DISTURB, MHITNOT, chief->pos());

Replacement in crawl-ref/source/mstuff2.cc at line 2524 [56.1340842]

B:BD[203.2105] → [204.873:948]

            if (you.can_see(chief) && player_can_hear(chief->x, chief->y))

[203.2105]

[196.21800]

            if (you.can_see(chief) && player_can_hear(chief->pos()))

Replacement in crawl-ref/source/mstuff2.cc at line 2531 [56.1340842]
B:BD[202.664] → [202.664:707]
```
            noisy(15, chief->x, chief->y);
```
[202.664]
[203.2245]
```
            noisy(15, chief->pos());
```

Replacement in crawl-ref/source/mstuff2.cc at line 2614 [56.1340842]

B:BD[205.2519] → [206.2571:2685]

    if (is_sanctuary(you.x_pos, you.y_pos)
        || is_sanctuary(mon->x, mon->y))
    {
        return 0;
    }

[205.2519]

[206.2685]

    if (is_sanctuary(you.pos()) || is_sanctuary(mon->pos()))
        return false;

Replacement in crawl-ref/source/mstuff2.cc at line 2627 [56.1340842]
B:BD[206.2710] → [206.2710:2754]
```
        if (is_sanctuary(targ->x, targ->y))
```
[206.2710]
[205.2770]
```
        if (is_sanctuary(targ->pos()))
```
Replacement in crawl-ref/source/mstuff2.cc at line 2646 [56.1340842]
B:BD[192.423] → [18.2727:2781]
```
    const int net = get_trapping_net(mon->x, mon->y);
```
[192.423]
[192.479]
```
    const int net = get_trapping_net(mon->pos());
```

Replacement in crawl-ref/source/monstuff.h at line 108 [56.1390580]

B:BD[207.2639] → [207.2639:2691]

                     int src_x = 0, int src_y = 0);

[207.2639]

[56.1392736]

                     coord_def src_pos = coord_def() );

Replacement in crawl-ref/source/monstuff.h at line 127 [56.1390580]
B:BD[56.1393483] → [56.1393483:1393541]
```
bool random_near_space( int ox, int oy, int &tx, int &ty,
```
[56.1393483]
[128.3642]
```
bool random_near_space( const coord_def& origin, coord_def& target,
```

Replacement in crawl-ref/source/monstuff.cc at line 82 [56.1396662]

B:BD[208.2957] → [209.2569:2863]

static bool _mon_can_move_to_pos(const monsters *monster, const int count_x,
                                 const int count_y, bool just_check = false);
static bool _is_trap_safe(const monsters *monster, const int trap_x,
                          const int trap_y, bool just_check = false);

[208.2957]

static bool _mon_can_move_to_pos(const monsters *monster,
                                 const coord_def& delta,
                                 bool just_check = false);
static bool _is_trap_safe(const monsters *monster, const coord_def& where,
                          bool just_check = false);

Replacement in crawl-ref/source/monstuff.cc at line 92 [56.1396662]
B:BD[60.411315] → [60.411315:411342]
```
static int mmov_x, mmov_y;
```
[60.411315]
[56.1398409]
```
static coord_def mmov;
```
Replacement in crawl-ref/source/monstuff.cc at line 298 [56.1396662]
∅:D[196.22326] → [56.1404001:1404069]
B:BD[56.1404001] → [56.1404001:1404069]
```
                move_item_to_grid( &item, monster->x, monster->y );
```
[196.22326]
[196.22327]
```
                move_item_to_grid( &item, monster->pos() );
```
Replacement in crawl-ref/source/monstuff.cc at line 353 [56.1396662]
∅:D[210.9285] → [56.1405469:1405522]
B:BD[56.1405469] → [56.1405469:1405522]
B:BD[56.1405522] → [91.6307:6349]
```
    move_item_to_grid( &o, monster->x, monster->y );
    if (see_grid(monster->x, monster->y))
```
[210.9285]
[211.1912]
```
    move_item_to_grid( &o, monster->pos() );
    if (see_grid(monster->pos()))
```

Replacement in crawl-ref/source/monstuff.cc at line 804 [56.1396662]

∅:D[10.2577] → [121.5132:5208]

B:BD[56.1407564] → [121.5132:5208]

            place_cloud(CLOUD_FIRE, monster->x, monster->y, 2 + random2(4),

[10.2577]

[121.5208]

            place_cloud(CLOUD_FIRE, monster->pos(), 2 + random2(4),

Replacement in crawl-ref/source/monstuff.cc at line 821 [56.1396662]
∅:D[212.1961] → [121.5261:5333]
B:BD[56.1408147] → [121.5261:5333]
```
        place_cloud(CLOUD_COLD, monster->x, monster->y, 2 + random2(4),
```
[56.1407889]
[121.5333]
```
        place_cloud(CLOUD_COLD, monster->pos(), 2 + random2(4),
```

Replacement in crawl-ref/source/monstuff.cc at line 1173 [56.1396662]

B:BD[213.3039] → [213.3039:3104]

                         monster->x, monster->y, 1 + random2(3),

[213.3039]

[121.5679]

                         monster->pos(), 1 + random2(3),

Replacement in crawl-ref/source/monstuff.cc at line 1280 [56.1396662]

B:BD[11.2813] → [11.2813:2882]

                             monster->x, monster->y, 1 + random2(3),

[11.2813]

[11.2882]

                             monster->pos(), 1 + random2(3),

Replacement in crawl-ref/source/monstuff.cc at line 1515 [56.1396662]
∅:D[80.4985] → [60.419006:419076]
B:BD[60.419006] → [60.419006:419076]
```
            targetc = random_monster_at_grid(monster->x, monster->y);
```
[80.4985]
[56.1426068]
```
            targetc = random_monster_at_grid(monster->pos());
```
Replacement in crawl-ref/source/monstuff.cc at line 1644 [56.1396662]
B:BD[56.1428725] → [56.1428725:1428741]
```
    int nx, ny;
```
[56.1428725]
[56.1428741]
```
    coord_def near;
```

Replacement in crawl-ref/source/monstuff.cc at line 1648 [56.1396662]

B:BD[214.2613] → [214.2613:2675]

        losight(env.show, grd, monster->x, monster->y, true);

[214.2613]

[215.5860]

        losight(env.show, grd, monster->pos(), true);

Replacement in crawl-ref/source/monstuff.cc at line 1650 [56.1396662]
∅:D[215.5861] → [214.2680:2743]
B:BD[214.2680] → [214.2680:2743]
```
        if (!random_near_space(monster->x, monster->y, nx, ny,
```
[215.5861]
[128.3739]
```
        if (!random_near_space(monster->pos(), near,
```
Deletion in crawl-ref/source/monstuff.cc at line 1659 [56.1396662]
∅:D[192.710] → [110.2255:2256]
∅:D[18.2899] → [110.2255:2256]
B:BD[110.2255] → [110.2255:2256]
∅:D[110.2256] → [56.1428841:1428889]
B:BD[56.1428841] → [56.1428841:1428889]
```
    mgrd[monster->x][monster->y] = NON_MONSTER;
```
Insertion in crawl-ref/source/monstuff.cc at line 1660 [56.1396662]
[56.1428890]
[180.3980]
```
    mgrd(monster->pos()) = NON_MONSTER;
```
Deletion in crawl-ref/source/monstuff.cc at line 1662 [56.1396662]
∅:D[180.4027] → [56.1428890:1428932]
B:BD[56.1428890] → [56.1428890:1428932]
```
    monster->x = nx;
    monster->y = ny;
```

Replacement in crawl-ref/source/monstuff.cc at line 1663 [56.1396662]

B:BD[56.1428933] → [56.1428933:1428976]

    mgrd[nx][ny] = monster_index(monster);

[56.1428933]

[60.420257]

    // FIXME Shouldn't this use monsters::move_to_pos() ?
    monster->x = near.x;
    monster->y = near.y;
    mgrd(near) = monster_index(monster);

Replacement in crawl-ref/source/monstuff.cc at line 1679 [56.1396662]

∅:D[216.2800] → [56.1429159:1429237]

∅:D[80.5511] → [56.1429159:1429237]

B:BD[56.1429159] → [56.1429159:1429237]

B:BD[56.1429237] → [128.3903:3968]

bool random_near_space(int ox, int oy, int &tx, int &ty, bool allow_adjacent,
                       bool restrict_LOS, bool forbid_sanctuary)

[216.2800]

[56.1429260]

bool random_near_space(const coord_def& origin, coord_def& target,
                       bool allow_adjacent, bool restrict_LOS,
                       bool forbid_sanctuary)

Replacement in crawl-ref/source/monstuff.cc at line 1689 [56.1396662]

∅:D[217.4677] → [55.8556:8709]

B:BD[55.8556] → [55.8556:8709]

    bool trans_wall_block  = trans_wall_blocking(ox, oy);
    bool origin_is_player  = (you.pos() == coord_def(ox, oy));
    int  min_walls_between = 0;

[217.4677]

[56.1429281]

    const bool trans_wall_block  = trans_wall_blocking(origin);
    const bool origin_is_player  = (you.pos() == origin);
    int min_walls_between = 0;

Replacement in crawl-ref/source/monstuff.cc at line 1696 [56.1396662]

∅:D[218.6553] → [55.8773:8849]

B:BD[55.8773] → [55.8773:8849]

        min_walls_between = num_feats_between(ox, oy, you.x_pos, you.y_pos,

[218.6553]

[55.8849]

        min_walls_between = num_feats_between(origin, you.pos(),

Replacement in crawl-ref/source/monstuff.cc at line 1704 [56.1396662]

B:BD[56.1429295] → [55.9038:9098]

        int dx = random2(14);
        int dy = random2(14);

[56.1429295]

[55.9098]

        coord_def delta( random2(14), random2(14) );

Replacement in crawl-ref/source/monstuff.cc at line 1706 [56.1396662]

B:BD[55.9099] → [55.9099:9151]

        tx = ox - 6 + dx;
        ty = oy - 6 + dy;

[55.9099]

[56.1429365]

        target = origin - coord_def(6,6) + delta;

Replacement in crawl-ref/source/monstuff.cc at line 1709 [56.1396662]
∅:D[217.4732] → [56.1429398:1429432]
B:BD[56.1429398] → [56.1429398:1429432]
```
        if (tx == ox && ty == oy)
```
[217.4732]
[55.9152]
```
        if (target == origin)
```
Replacement in crawl-ref/source/monstuff.cc at line 1712 [56.1396662]
B:BD[55.9175] → [55.9175:9202]
```
        if (tried[dx][dy])
```
[55.9175]
[55.9202]
```
        if (tried(delta))
```
Replacement in crawl-ref/source/monstuff.cc at line 1715 [56.1396662]
B:BD[55.9225] → [55.9225:9255]
```
        tried[dx][dy] = true;
```
[55.9225]
[55.9255]
```
        tried(delta) = true;
```

Replacement in crawl-ref/source/monstuff.cc at line 1717 [56.1396662]

B:BD[55.9256] → [219.204:235]

B:BD[219.235] → [218.6561:6610]

∅:D[219.286] → [55.9304:9395]

∅:D[218.6610] → [55.9304:9395]

B:BD[55.9304] → [55.9304:9395]

B:BD[55.9395] → [218.6611:6661]

B:BD[218.6661] → [128.3969:4090]

        if (!in_bounds(tx, ty)
            || restrict_LOS && !see_grid(tx, ty)
            || grd[tx][ty] < DNGN_SHALLOW_WATER
            || mgrd[tx][ty] != NON_MONSTER
            || tx == you.x_pos && ty == you.y_pos
            || !allow_adjacent && distance(ox, oy, tx, ty) <= 2
            || forbid_sanctuary && is_sanctuary(tx, ty))

[55.9256]

[218.6726]

        if (!in_bounds(target)
            || restrict_LOS && !see_grid(target)
            || grd(target) < DNGN_SHALLOW_WATER
            || mgrd(target) != NON_MONSTER
            || target == you.pos()
            || !allow_adjacent && distance(origin, target) <= 2
            || forbid_sanctuary && is_sanctuary(target))

Replacement in crawl-ref/source/monstuff.cc at line 1741 [56.1396662]
B:BD[55.10266] → [218.6748:6800]
```
        if (!origin_is_player && !see_grid(tx, ty))
```
[55.10266]
[55.10318]
```
        if (!origin_is_player && !see_grid(target))
```
Replacement in crawl-ref/source/monstuff.cc at line 1747 [56.1396662]
B:BD[55.10451] → [55.10451:10494]
```
            if (see_grid_no_trans(tx, ty))
```
[55.10451]
[55.10494]
```
            if (see_grid_no_trans(target))
```

Replacement in crawl-ref/source/monstuff.cc at line 1753 [56.1396662]

B:BD[55.10559] → [55.10559:10620]

        int walls_passed = num_feats_between(tx, ty, ox, oy,

[55.10559]

[55.10620]

        int walls_passed = num_feats_between(target, origin,

Replacement in crawl-ref/source/monstuff.cc at line 1764 [56.1396662]

B:BD[55.10937] → [55.10937:11013]

        int walls_between = num_feats_between(tx, ty, you.x_pos, you.y_pos,

[55.10937]

[55.11013]

        int walls_between = num_feats_between(target, you.pos(),

Replacement in crawl-ref/source/monstuff.cc at line 1993 [56.1396662]
B:BD[207.2749] → [207.2749:2792]
```
                     int src_x, int src_y)
```
[207.2749]
[56.1436485]
```
                     coord_def src_pos)
```

Replacement in crawl-ref/source/monstuff.cc at line 2025 [56.1396662]

∅:D[220.3562] → [56.1437353:1437423]

B:BD[56.1437353] → [56.1437353:1437423]

            mon->target_x = src_x;
            mon->target_y = src_y;

[220.3562]

[56.1437423]

            mon->target_x = src_pos.x;
            mon->target_y = src_pos.y;

Replacement in crawl-ref/source/monstuff.cc at line 2082 [56.1396662]

∅:D[221.3252] → [222.2636:2701]

B:BD[222.2636] → [222.2636:2701]

                                && is_sanctuary(mon->x, mon->y);

[221.3252]

[223.2574]

                                && is_sanctuary(mon->pos());

Replacement in crawl-ref/source/monstuff.cc at line 2109 [56.1396662]
B:BD[56.1438734] → [224.4041:4079]
```
        if (see_grid(mon->x, mon->y))
```
[56.1438734]
[225.473]
```
        if (see_grid(mon->pos()))
```
Replacement in crawl-ref/source/monstuff.cc at line 2120 [56.1396662]
∅:D[34.2732] → [226.3434:3502]
B:BD[226.3434] → [226.3434:3502]
```
        if (!mons_wont_attack(mon) && is_sanctuary(mon->x, mon->y))
```
[34.2732]
[226.3502]
```
        if (!mons_wont_attack(mon) && is_sanctuary(mon->pos()))
```

Replacement in crawl-ref/source/monstuff.cc at line 2391 [56.1396662]

B:BD[227.2716] → [227.2716:2749]

            if (in_bounds(x, y))

[227.2716]

[227.2749]

            coord_def p(x,y);
            if (in_bounds(p))

Replacement in crawl-ref/source/monstuff.cc at line 2394 [56.1396662]

B:BD[227.2763] → [228.2574:2636]

                const dungeon_feature_type gridc = grd[x][y];

[227.2763]

[229.3014]

                const dungeon_feature_type gridc = grd(p);

Replacement in crawl-ref/source/monstuff.cc at line 2398 [56.1396662]

B:BD[227.2897] → [230.3050:3119]

                    e.push_back(level_exit(coord_def(x, y), false));

[227.2897]

[229.3419]

                    e.push_back(level_exit(p, false));

Replacement in crawl-ref/source/monstuff.cc at line 2401 [56.1396662]

B:BD[231.2624] → [231.2624:2684]

                const trap_type tt = trap_type_at_xy(x, y);

[231.2624]

[35.2574]

                const trap_type tt = trap_type_at_xy(p);

Replacement in crawl-ref/source/monstuff.cc at line 2403 [56.1396662]

∅:D[35.2635] → [230.3243:3312]

B:BD[230.3243] → [230.3243:3312]

                    e.push_back(level_exit(coord_def(x, y), false));

[35.2635]

[227.3390]

                    e.push_back(level_exit(p, false));

Replacement in crawl-ref/source/monstuff.cc at line 2425 [56.1396662]

B:BD[216.3642] → [216.3642:3755]

        int dist = grid_distance(mon->x, mon->y, e[i].target.x,
                                 e[i].target.y);

[216.3642]

[229.3989]

        int dist = grid_distance(mon->pos(), e[i].target);

Replacement in crawl-ref/source/monstuff.cc at line 2499 [56.1396662]

B:BD[56.1439988] → [232.3454:3519]

    bool trans_wall_block = trans_wall_blocking(mon->x, mon->y);

[56.1439988]

[232.3519]

    bool trans_wall_block = trans_wall_blocking(mon->pos());

Replacement in crawl-ref/source/monstuff.cc at line 2543 [56.1396662]
B:BD[233.3574] → [233.3574:3618]
```
        else if (!see_grid(mon->x, mon->y))
```
[233.3574]
[56.1441226]
```
        else if (!see_grid(mon->pos()))
```
Replacement in crawl-ref/source/monstuff.cc at line 2549 [56.1396662]
∅:D[220.5387] → [56.1441383:1441454]
B:BD[56.1441383] → [56.1441383:1441454]
```
        if (grid_distance( you.x_pos, you.y_pos, mon->x, mon->y ) == 1
```
[220.5387]
[234.3020]
```
        if (grid_distance( you.pos(), mon->pos() ) == 1
```

Replacement in crawl-ref/source/monstuff.cc at line 2811 [56.1396662]

B:BD[115.5712] → [115.5712:5793]

                    || grid_distance(mon->x, mon->y, you.x_pos, you.y_pos) == 1)

[115.5712]

[235.4645]

                    || grid_distance(mon->pos(), you.pos()) == 1)

Replacement in crawl-ref/source/monstuff.cc at line 2842 [56.1396662]

B:BD[235.5759] → [235.5759:5834]

                    || grid_see_grid(mon->x, mon->y, you.x_pos, you.y_pos,

[235.5759]

[235.5834]

                    || grid_see_grid(mon->pos(), you.pos(),

Replacement in crawl-ref/source/monstuff.cc at line 2865 [56.1396662]

B:BD[232.5380] → [235.5996:6129]

                        if (grid_see_grid(targ.x, targ.y, you.x_pos, you.y_pos,
                                          can_move))

[232.5380]

[232.5529]

                        if (grid_see_grid(targ, you.pos(), can_move))

Replacement in crawl-ref/source/monstuff.cc at line 2882 [56.1396662]

B:BD[232.6392] → [232.6392:6607]

                            else if (grid_see_grid(mon->x, mon->y,
                                                   mon->travel_path[0].x,
                                                   mon->travel_path[0].y,

[232.6392]

[232.6607]

                            else if (grid_see_grid(mon->pos(),
                                                   mon->travel_path[0],

Replacement in crawl-ref/source/monstuff.cc at line 2894 [56.1396662]

B:BD[232.7034] → [232.7034:7175]

                    const int dist = grid_distance(mon->x, mon->y,
                                                   you.x_pos, you.y_pos);

[232.7034]

[232.7175]

                    const int dist = grid_distance(mon->pos(),
                                                   you.pos());

Replacement in crawl-ref/source/monstuff.cc at line 2944 [56.1396662]

B:BD[232.8741] → [232.8741:8876]

                             mon->name(DESC_PLAIN).c_str(), mon->x, mon->y,
                             you.x_pos, you.y_pos, range);

[232.8741]

[232.8876]

                             mon->name(DESC_PLAIN).c_str(), mon->pos(),
                             you.pos(), range);

Replacement in crawl-ref/source/monstuff.cc at line 3066 [56.1396662]

B:BD[236.3157] → [236.3157:3229]

                if (grid_distance(mon->x, mon->y, you.x_pos, you.y_pos)

[236.3157]

[37.2574]

                if (grid_distance(mon->pos(), you.pos())

Replacement in crawl-ref/source/monstuff.cc at line 3134 [56.1396662]

B:BD[237.5227] → [232.11031:11236]

                    else if (!grid_see_grid(mon->x, mon->y,
                                            mon->travel_path[0].x,
                                            mon->travel_path[0].y, can_move))

[237.5227]

[237.5252]

                    else if (!grid_see_grid(mon->pos(), mon->travel_path[0],
                                            can_move))

Replacement in crawl-ref/source/monstuff.cc at line 3154 [56.1396662]

B:BD[237.6275] → [237.6275:6486]

                            if (grid_see_grid(mon->x, mon->y,
                                              mon->travel_path[i].x,
                                              mon->travel_path[i].y, can_move))

[237.6275]

[237.6486]

                            if (grid_see_grid(mon->pos(), mon->travel_path[i],
                                              can_move))

Replacement in crawl-ref/source/monstuff.cc at line 3241 [56.1396662]

B:BD[238.7594] → [238.7594:7673]

                                mon->patrol_point = coord_def(mon->x, mon->y);

[238.7594]

[238.7673]

                                mon->patrol_point = mon->pos();

Replacement in crawl-ref/source/monstuff.cc at line 3246 [56.1396662]

B:BD[238.7818] → [238.7818:7887]

                                mon->patrol_point = coord_def(0, 0);

[238.7818]

[232.12291]

                                mon->patrol_point.reset();

Replacement in crawl-ref/source/monstuff.cc at line 3409 [56.1396662]

B:BD[239.245] → [208.5162:5223]

static bool _mons_check_set_foe(monsters *mon, int x, int y,

[239.245]

[9.2558]

static bool _mons_check_set_foe(monsters *mon, const coord_def& p,

Replacement in crawl-ref/source/monstuff.cc at line 3412 [56.1396662]
B:BD[239.353] → [240.2844:2880]
```
    if (!inside_level_bounds(x, y))
```
[239.353]
[239.379]
```
    if (!inside_level_bounds(p))
```

Replacement in crawl-ref/source/monstuff.cc at line 3415 [56.1396662]

∅:D[9.2621] → [71.4233:4299]

B:BD[239.408] → [71.4233:4299]

B:BD[71.4299] → [226.3761:3821]

    if (!friendly && !neutral && x == you.x_pos && y == you.y_pos
        && mons_player_visible(mon) && !is_sanctuary(x, y))

[9.2621]

[239.499]

    if (!friendly && !neutral && p == you.pos()
        && mons_player_visible(mon) && !is_sanctuary(p))

Replacement in crawl-ref/source/monstuff.cc at line 3422 [56.1396662]
B:BD[239.563] → [239.563:598]
```
    if (mgrd[x][y] != NON_MONSTER)
```
[239.563]
[239.598]
```
    if (mgrd(p) != NON_MONSTER)
```
Replacement in crawl-ref/source/monstuff.cc at line 3424 [56.1396662]
B:BD[239.604] → [239.604:647]
```
        monsters *foe = &menv[mgrd[x][y]];
```
[239.604]
[239.647]
```
        monsters *foe = &menv[mgrd(p)];
```
Replacement in crawl-ref/source/monstuff.cc at line 3428 [56.1396662]
B:BD[218.7401] → [226.3822:3871]
```
            && (friendly || !is_sanctuary(x, y))
```
[218.7401]
[71.4300]
```
            && (friendly || !is_sanctuary(p))
```
Replacement in crawl-ref/source/monstuff.cc at line 3432 [56.1396662]
B:BD[239.774] → [239.774:809]
```
            mon->foe = mgrd[x][y];
```
[239.774]
[239.809]
```
            mon->foe = mgrd(p);
```

Replacement in crawl-ref/source/monstuff.cc at line 3451 [56.1396662]

B:BD[239.1072] → [208.5270:5416]

            if (_mons_check_set_foe(mon, x, my - k, friendly, neutral)
                || _mons_check_set_foe(mon, x, my + k, friendly, neutral))

[239.1072]

[208.5416]

            if (_mons_check_set_foe(mon, coord_def(x, my - k), friendly, neutral)
                || _mons_check_set_foe(mon, coord_def(x, my + k), friendly, neutral))

Replacement in crawl-ref/source/monstuff.cc at line 3458 [56.1396662]

B:BD[239.1273] → [208.5446:5592]

            if (_mons_check_set_foe(mon, mx - k, y, friendly, neutral)
                || _mons_check_set_foe(mon, mx + k, y, friendly, neutral))

[239.1273]

[208.5592]

            if (_mons_check_set_foe(mon, coord_def(mx - k, y), friendly, neutral)
                || _mons_check_set_foe(mon, coord_def(mx + k, y), friendly, neutral))

Replacement in crawl-ref/source/monstuff.cc at line 3623 [56.1396662]

B:BD[233.5548] → [233.5548:5615]

        monster->patrol_point = coord_def(monster->x, monster->y);

[233.5548]

[233.5615]

        monster->patrol_point = monster->pos();

Replacement in crawl-ref/source/monstuff.cc at line 3641 [56.1396662]
∅:D[240.2934] → [65.11082:11154]
B:BD[65.11082] → [65.11082:11154]
```
    if (is_sanctuary(monster->x, monster->y) && !mons_friendly(monster)
```
[240.2934]
[65.11154]
```
    if (is_sanctuary(monster->pos()) && !mons_friendly(monster)
```

Replacement in crawl-ref/source/monstuff.cc at line 3645 [56.1396662]

B:BD[65.11262] → [65.11262:11339]

        behaviour_event(monster, ME_SCARE, MHITNOT, monster->x, monster->y);

[65.11262]

[65.11339]

        behaviour_event(monster, ME_SCARE, MHITNOT, monster->pos());

Replacement in crawl-ref/source/monstuff.cc at line 3648 [56.1396662]

B:BD[63.4669] → [241.403:457]

             && !is_sanctuary(monster->x, monster->y)

[63.4669]

[32.2574]

             && !is_sanctuary(monster->pos())

Replacement in crawl-ref/source/monstuff.cc at line 3676 [56.1396662]

∅:D[233.5689] → [56.1465880:1465978]

B:BD[56.1465880] → [56.1465880:1465978]

    mmov_x = (dx > 0) ? 1 : ((dx < 0) ? -1 : 0);
    mmov_y = (dy > 0) ? 1 : ((dy < 0) ? -1 : 0);

[233.5689]

[56.1465978]

    mmov.x = (dx > 0) ? 1 : ((dx < 0) ? -1 : 0);
    mmov.y = (dy > 0) ? 1 : ((dy < 0) ? -1 : 0);

Replacement in crawl-ref/source/monstuff.cc at line 3681 [56.1396662]

B:BD[242.13978] → [242.13978:14072]

            || monster->target_x != you.x_pos
            || monster->target_y != you.y_pos))

[242.13978]

[56.1466019]

            || monster->target_pos() != you.pos()))

Replacement in crawl-ref/source/monstuff.cc at line 3683 [56.1396662]
B:BD[56.1466025] → [56.1466025:1466069]
```
        mmov_x *= -1;
        mmov_y *= -1;
```
[56.1466025]
[63.4785]
```
        mmov.x *= -1;
        mmov.y *= -1;
```

Replacement in crawl-ref/source/monstuff.cc at line 3689 [56.1396662]

∅:D[243.8126] → [63.4913:5127]

B:BD[63.4913] → [63.4913:5127]

    if (is_sanctuary(monster->x + mmov_x, monster->y + mmov_y)
        && (!is_sanctuary(monster->x, monster->y)
            || monster->x + mmov_x == you.x_pos
               && monster->y + mmov_y == you.y_pos))

[243.8126]

[63.5127]

    if (is_sanctuary(monster->pos() + mmov)
        && (!is_sanctuary(monster->pos())
            || monster->pos() + mmov == you.pos()))

Replacement in crawl-ref/source/monstuff.cc at line 3693 [56.1396662]
B:BD[63.5133] → [63.5133:5173]
```
        mmov_x = 0;
        mmov_y = 0;
```
[63.5133]
[56.1466069]
```
        mmov.reset();
```

Replacement in crawl-ref/source/monstuff.cc at line 3697 [56.1396662]

∅:D[243.8199] → [56.1466154:1466251]

B:BD[56.1466154] → [56.1466154:1466251]

    if (monster->target_x + mmov_x < 0 || monster->target_x + mmov_x >= GXM)
        mmov_x = 0;

[243.8199]

[56.1466251]

    if (monster->target_x + mmov.x < 0 || monster->target_x + mmov.x >= GXM)
        mmov.x = 0;

Replacement in crawl-ref/source/monstuff.cc at line 3700 [56.1396662]

B:BD[56.1466252] → [56.1466252:1466349]

    if (monster->target_y + mmov_y < 0 || monster->target_y + mmov_y >= GYM)
        mmov_y = 0;

[56.1466252]

[56.1466349]

    if (monster->target_y + mmov.y < 0 || monster->target_y + mmov.y >= GYM)
        mmov.y = 0;

Replacement in crawl-ref/source/monstuff.cc at line 3704 [56.1396662]
∅:D[63.5207] → [56.1466386:1466422]
B:BD[56.1466386] → [56.1466386:1466422]
```
    if (mmov_x == 0 && mmov_y == 0)
```
[63.5207]
[56.1466422]
```
    if (mmov == coord_def(0,0))
```
Replacement in crawl-ref/source/monstuff.cc at line 3719 [56.1396662]
B:BD[56.1466943] → [56.1466943:1466971]
```
                mmov_y = 0;
```
[56.1466943]
[56.1466971]
```
                mmov.y = 0;
```
Replacement in crawl-ref/source/monstuff.cc at line 3726 [56.1396662]
B:BD[56.1467112] → [56.1467112:1467140]
```
                mmov_x = 0;
```
[56.1467112]
[56.1467140]
```
                mmov.x = 0;
```

Replacement in crawl-ref/source/monstuff.cc at line 3739 [56.1396662]

B:BD[206.2821] → [206.2821:2922]

    return (is_sanctuary(you.x_pos, you.y_pos)
            || is_sanctuary(monster->x, monster->y));

[206.2821]

[206.2922]

    return (is_sanctuary(you.pos())
            || is_sanctuary(monster->pos()));

Replacement in crawl-ref/source/monstuff.cc at line 3795 [56.1396662]

B:BD[244.2681] → [245.2742:2850]

            || grid_distance(monster->x, monster->y,
                             you.x_pos, you.y_pos) > 1

[244.2681]

[218.7818]

            || grid_distance(monster->pos(),
                             you.pos()) > 1

Replacement in crawl-ref/source/monstuff.cc at line 3897 [56.1396662]
B:BD[203.3108] → [65.11751:11801]
```
        if (is_sanctuary(monster->x, monster->y))
```
[203.3108]
[65.11801]
```
        if (is_sanctuary(monster->pos()))
```
Replacement in crawl-ref/source/monstuff.cc at line 3919 [56.1396662]
B:BD[56.1471486] → [197.2756:2806]
```
        if (is_sanctuary(monster->x, monster->y))
```
[56.1471486]
[197.2806]
```
        if (is_sanctuary(monster->pos()))
```

Replacement in crawl-ref/source/monstuff.cc at line 3923 [56.1396662]

B:BD[56.1471531] → [246.2939:3015]

            && distance(you.x_pos, you.y_pos, monster->x, monster->y) <= 5)

[56.1471531]

[56.1471609]

            && distance(you.pos(), monster->pos()) <= 5)

Replacement in crawl-ref/source/monstuff.cc at line 3937 [56.1396662]

B:BD[56.1471906] → [246.3016:3089]

            if (distance(monster->x, monster->y, targ->x, targ->y) >= 5)

[56.1471906]

[56.1471981]

            if (distance(monster->pos(), targ->pos()) >= 5)

Replacement in crawl-ref/source/monstuff.cc at line 4131 [56.1396662]
B:BD[56.1476284] → [56.1476284:1476332]
```
            mmov_x = 0;
            mmov_y = 0;
```
[56.1476284]
[56.1476332]
```
            mmov.reset();
```
Replacement in crawl-ref/source/monstuff.cc at line 4234 [56.1396662]
B:BD[56.1478676] → [56.1478676:1478732]
```
                mmov_x = 0;
                mmov_y = 0;
```
[56.1478676]
[56.1478732]
```
                mmov.reset();
```

Replacement in crawl-ref/source/monstuff.cc at line 4263 [56.1396662]

∅:D[247.7102] → [218.8361:8456]

B:BD[248.4180] → [218.8361:8456]

            || silenced(monster->x, monster->y)
            || silenced(you.x_pos, you.y_pos))

[247.7102]

[248.4263]

            || silenced(monster->pos())
            || silenced(you.pos()))

Replacement in crawl-ref/source/monstuff.cc at line 4286 [56.1396662]

B:BD[248.4870] → [30.2574:2774]

            int walls = num_feats_between(you.x_pos, you.y_pos,
                                          monster->x, monster->y, DNGN_UNSEEN,
                                          DNGN_MAXWALL);

[248.4870]

[30.2774]

            int walls = num_feats_between(you.pos(), monster->pos(),
                                          DNGN_UNSEEN, DNGN_MAXWALL);

Replacement in crawl-ref/source/monstuff.cc at line 4781 [56.1396662]
B:BD[249.11987] → [249.11987:12036]
```
            if (!silenced(you.x_pos, you.y_pos))
```
[249.11987]
[249.12036]
```
            if (!silenced(you.pos()))
```
Replacement in crawl-ref/source/monstuff.cc at line 4901 [56.1396662]
B:BD[187.22724] → [187.22724:22774]
```
            if (silenced(monster->x, monster->y))
```
[187.22724]
[187.22774]
```
            if (silenced(monster->pos()))
```

Replacement in crawl-ref/source/monstuff.cc at line 4920 [56.1396662]

B:BD[187.23462] → [187.23462:23588]

                        if (!silenced(monster->x, monster->y)
                            && !silenced(you.x_pos, you.y_pos))

[187.23462]

[187.23588]

                        if (!silenced(monster->pos())
                            && !silenced(you.pos()))

Replacement in crawl-ref/source/monstuff.cc at line 4929 [56.1396662]

B:BD[187.23774] → [187.23774:23828]

                if (silenced(monster->x, monster->y))

[187.23774]

[187.23828]

                if (silenced(monster->pos()))

Replacement in crawl-ref/source/monstuff.cc at line 4996 [56.1396662]

B:BD[187.26808] → [187.26808:26926]

                    if (!silenced(monster->x, monster->y)
                        && !silenced(you.x_pos, you.y_pos))

[187.26808]

[187.26926]

                    if (!silenced(monster->pos())
                        && !silenced(you.pos()))

Replacement in crawl-ref/source/monstuff.cc at line 5039 [56.1396662]
B:BD[187.28144] → [187.28144:28192]
```
            && !silenced(you.x_pos, you.y_pos))
```
[187.28144]
[187.28192]
```
            && !silenced(you.pos()))
```
Replacement in crawl-ref/source/monstuff.cc at line 5062 [56.1396662]
B:BD[250.7309] → [29.2574:2619]
```
    if (is_sanctuary(monster->x, monster->y)
```
[250.7309]
[29.2619]
```
    if (is_sanctuary(monster->pos())
```
Replacement in crawl-ref/source/monstuff.cc at line 5374 [56.1396662]
B:BD[56.1503847] → [56.1503847:1503895]
```
            mmov_x = 0;
            mmov_y = 0;
```
[56.1503847]
[251.539]
```
            mmov.reset();
```

Replacement in crawl-ref/source/monstuff.cc at line 5482 [56.1396662]

B:BD[252.1907] → [252.1907:2006]

    if (!archer
        && adjacent( beem.target_x, beem.target_y, monster->x, monster->y ))
    {

[252.1907]

[56.1505304]

    if (!archer && adjacent(beem.target(), monster->pos()))

Deletion in crawl-ref/source/monstuff.cc at line 5484 [56.1396662]
B:BD[56.1505328] → [252.2007:2013]
```
    }
```

Replacement in crawl-ref/source/monstuff.cc at line 5656 [56.1396662]

∅:D[33.2659] → [253.2961:3041]

B:BD[253.2961] → [253.2961:3041]

    if (!is_sanctuary(mover->x, mover->y) || !is_sanctuary(moved->x, moved->y))

[33.2659]

[40.4439]

    if (!is_sanctuary(mover->pos()) || !is_sanctuary(moved->pos()))

Replacement in crawl-ref/source/monstuff.cc at line 5953 [56.1396662]

B:BD[143.4476] → [220.7472:7538]

            // Calculates mmov_x, mmov_y based on monster target.

[143.4476]

[208.7809]

            // Calculates mmov based on monster target.

Replacement in crawl-ref/source/monstuff.cc at line 5972 [56.1396662]

B:BD[220.8139] → [220.8139:8221]

                            mmov_x = xi;
                            mmov_y = yi;

[220.8139]

[220.8221]

                            mmov.x = xi;
                            mmov.y = yi;

Replacement in crawl-ref/source/monstuff.cc at line 5978 [56.1396662]
∅:D[254.6759] → [220.8315:8356]
B:BD[220.8315] → [220.8315:8356]
```
                    mmov_x = mmov_y = 0;
```
[254.6759]
[56.1510936]
```
                    mmov.reset();
```

Replacement in crawl-ref/source/monstuff.cc at line 5982 [56.1396662]

B:BD[220.8461] → [220.8461:8568]

                if (monster->x + mmov_x < 0 || monster->x + mmov_x >= GXM)
                    mmov_x = 0;

[220.8461]

[56.1511068]

                if (monster->x + mmov.x < 0 || monster->x + mmov.x >= GXM)
                    mmov.x = 0;

Replacement in crawl-ref/source/monstuff.cc at line 5985 [56.1396662]

B:BD[56.1511069] → [220.8569:8676]

                if (monster->y + mmov_y < 0 || monster->y + mmov_y >= GYM)
                    mmov_y = 0;

[56.1511069]

[56.1511142]

                if (monster->y + mmov.y < 0 || monster->y + mmov.y >= GYM)
                    mmov.y = 0;

Replacement in crawl-ref/source/monstuff.cc at line 5988 [56.1396662]

B:BD[56.1511143] → [220.8677:8891]

                if (!monster->can_pass_through(monster->x + mmov_x,
                                               monster->y + mmov_y))
                {
                    mmov_x = mmov_y = 0;
                }

[56.1511143]

[255.2652]

                if (!monster->can_pass_through(monster->pos() + mmov))
                    mmov.reset();

Replacement in crawl-ref/source/monstuff.cc at line 5991 [56.1396662]

B:BD[255.2653] → [220.8892:8968]

                int enemy = mgrd[monster->x + mmov_x][monster->y + mmov_y];

[255.2653]

[220.8968]

                int enemy = mgrd(monster->pos() + mmov);

Replacement in crawl-ref/source/monstuff.cc at line 5993 [56.1396662]

B:BD[220.9009] → [220.9009:9123]

                    && !is_sanctuary(monster->x, monster->y)
                    && (mmov_x != 0 || mmov_y != 0))

[220.9009]

[220.9123]

                    && !is_sanctuary(monster->pos())
                    && (mmov.x != 0 || mmov.y != 0))

Replacement in crawl-ref/source/monstuff.cc at line 5999 [56.1396662]

B:BD[220.9250] → [220.9250:9322]

                        mmov_x = 0;
                        mmov_y = 0;

[220.9250]

[220.9322]

                        mmov.reset();

Replacement in crawl-ref/source/monstuff.cc at line 6009 [56.1396662]

B:BD[220.9721] → [220.9721:9852]

                                            monster->x + mmov_x,
                                            monster->y + mmov_y);

[220.9721]

[220.9852]

                                            monster->pos() + mmov);

Replacement in crawl-ref/source/monstuff.cc at line 6083 [56.1396662]
∅:D[243.9715] → [143.6727:6801]
B:BD[143.6727] → [143.6727:6801]
```
            int targmon = mgrd[monster->x + mmov_x][monster->y + mmov_y];
```
[243.9715]
[143.6801]
```
            int targmon = mgrd(monster->pos() + mmov);
```

Replacement in crawl-ref/source/monstuff.cc at line 6105 [56.1396662]

B:BD[143.7381] → [143.7381:7445]

                    mmov_x = 0;
                    mmov_y = 0;

[143.7381]

[143.7445]

                    mmov.reset();

Replacement in crawl-ref/source/monstuff.cc at line 6114 [56.1396662]

B:BD[56.1514858] → [143.7528:7630]

            if (monster->x + mmov_x == you.x_pos
                && monster->y + mmov_y == you.y_pos)

[56.1514858]

[60.436610]

            if (monster->pos() + mmov == you.pos())

Replacement in crawl-ref/source/monstuff.cc at line 6148 [56.1396662]

B:BD[143.8709] → [143.8709:8814]

                    mmov_x = 0;
                    mmov_y = 0;
                    continue;   //break;

[143.8709]

[143.8814]

                    mmov.reset();
                    continue;

Replacement in crawl-ref/source/monstuff.cc at line 6360 [56.1396662]

B:BD[56.1522219] → [56.1522219:1522321]

            if (!silenced(you.x_pos, you.y_pos)
                && !silenced(monster->x, monster->y))

[56.1522219]

[56.1522321]

            if (!silenced(you.pos())
                && !silenced(monster->pos()))

Replacement in crawl-ref/source/monstuff.cc at line 6402 [56.1396662]

B:BD[60.439832] → [60.439832:439918]

    if (!silenced(you.x_pos, you.y_pos)
        && !silenced(monster->x, monster->y))

[60.439832]

[60.439918]

    if (!silenced(you.pos())
        && !silenced(monster->pos()))

Replacement in crawl-ref/source/monstuff.cc at line 6463 [56.1396662]

B:BD[60.441723] → [208.8892:8959]

static bool _monster_swaps_places( monsters *mon, int mx, int my )

[60.441723]

[60.441789]

static bool _monster_swaps_places( monsters *mon, const coord_def& delta )

Replacement in crawl-ref/source/monstuff.cc at line 6465 [56.1396662]
B:BD[60.441791] → [60.441791:441811]
```
    if (!mx && !my)
```
[60.441791]
[60.441811]
```
    if (delta.x == 0 && delta.y)
```
Replacement in crawl-ref/source/monstuff.cc at line 6468 [56.1396662]
B:BD[60.441836] → [256.2629:2679]
```
    int targmon = mgrd[mon->x + mx][mon->y + my];
```
[60.441836]
[60.441890]
```
    int targmon = mgrd(mon->pos() + delta);
```

Replacement in crawl-ref/source/monstuff.cc at line 6491 [56.1396662]

B:BD[60.442551] → [60.442551:442641]

    const int cx = mon->x, cy = mon->y,
              nx = mon->x + mx, ny = mon->y + my;

[60.442551]

[243.10381]

    const coord_def c = mon->pos();
    const coord_def n = mon->pos() + delta;

Replacement in crawl-ref/source/monstuff.cc at line 6494 [56.1396662]

∅:D[243.10382] → [208.8999:9090]

B:BD[60.442641] → [208.8999:9090]

    if (!_habitat_okay(mon, grd[nx][ny])
        || !_habitat_okay(m2, grd[cx][cy]))
    {

[243.10382]

[60.442728]

    if (!_habitat_okay(mon, grd(n)) || !_habitat_okay(m2, grd(c)))

Deletion in crawl-ref/source/monstuff.cc at line 6496 [56.1396662]
B:BD[60.442752] → [208.9091:9097]
```
    }
```
Replacement in crawl-ref/source/monstuff.cc at line 6500 [56.1396662]
∅:D[257.6921] → [60.443042:443115]
B:BD[60.443042] → [60.443042:443115]
```
    mon->x = nx;
    mon->y = ny;
    mgrd[nx][ny] = monster_index(mon);
```
[257.6921]
[60.443115]
```
    mon->x = n.x;
    mon->y = n.y;
    mgrd(n) = monster_index(mon);
```
Replacement in crawl-ref/source/monstuff.cc at line 6504 [56.1396662]
B:BD[60.443344] → [60.443344:443378]
```
    m2->x  = cx;
    m2->y  = cy;
```
[60.443116]
[60.443378]
```
    m2->x  = c.x;
    m2->y  = c.y;
```
Replacement in crawl-ref/source/monstuff.cc at line 6508 [56.1396662]
B:BD[60.443461] → [60.443461:443485]
```
    mgrd[cx][cy] = m2i;
```
[60.443461]
[60.443485]
```
    mgrd(c) = m2i;
```
Replacement in crawl-ref/source/monstuff.cc at line 6511 [56.1396662]
B:BD[89.6162] → [89.6162:6204]
```
    mon->check_redraw(coord_def(cx, cy));
```
[89.6162]
[180.4106]
```
    mon->check_redraw(c);
```

Replacement in crawl-ref/source/monstuff.cc at line 6518 [56.1396662]

B:BD[60.443583] → [208.9130:9194]

static bool _do_move_monster(monsters *monster, int xi, int yi)

[60.443583]

[255.2888]

static bool _do_move_monster(monsters *monster, const coord_def& delta)

Replacement in crawl-ref/source/monstuff.cc at line 6520 [56.1396662]
B:BD[255.2890] → [255.2890:2926]
B:BD[255.2926] → [243.10383:10419]
```
    const int fx = monster->x + xi,
              fy = monster->y + yi;
```
[255.2890]
[255.2956]
```
    const coord_def f = monster->pos() + delta;
```
Replacement in crawl-ref/source/monstuff.cc at line 6522 [56.1396662]
B:BD[255.2957] → [255.2957:2985]
```
    if (!in_bounds(fx, fy))
```
[255.2957]
[149.20440]
```
    if (!in_bounds(f))
```
Replacement in crawl-ref/source/monstuff.cc at line 6525 [56.1396662]
B:BD[255.3002] → [255.3002:3046]
```
    if (fx == you.x_pos && fy == you.y_pos)
```
[255.3002]
[255.3046]
```
    if (f == you.pos())
```
Replacement in crawl-ref/source/monstuff.cc at line 6531 [56.1396662]
∅:D[258.2718] → [255.3129:3149]
B:BD[255.3129] → [255.3129:3149]
```
    if (!xi && !yi)
```
[258.2718]
[255.3149]
```
    // XXX Is this necessary? Isn't it handled by the next case?
    if (f == monster->pos())
```
Replacement in crawl-ref/source/monstuff.cc at line 6539 [56.1396662]
B:BD[255.3259] → [255.3259:3296]
```
    if (mgrd[fx][fy] != NON_MONSTER)
```
[255.3259]
[255.3296]
```
    if (mgrd(f) != NON_MONSTER)
```

Replacement in crawl-ref/source/monstuff.cc at line 6541 [56.1396662]

B:BD[255.3302] → [255.3302:3366]

        monsters_fight( monster_index(monster), mgrd[fx][fy] );

[255.3302]

[149.20513]

        monsters_fight( monster_index(monster), mgrd(f) );

Deletion in crawl-ref/source/monstuff.cc at line 6544 [56.1396662]
B:BD[255.3388] → [255.3388:3409]
B:BD[255.3409] → [149.20537:20561]
```
    if (!xi && !yi)
        return (false);
```
Replacement in crawl-ref/source/monstuff.cc at line 6548 [56.1396662]
B:BD[255.3426] → [255.3426:3474]
```
    mgrd[monster->x][monster->y] = NON_MONSTER;
```
[255.3426]
[258.2719]
```
    mgrd(monster->pos()) = NON_MONSTER;
```
Replacement in crawl-ref/source/monstuff.cc at line 6550 [56.1396662]
∅:D[258.2720] → [255.3552:3594]
B:BD[255.3552] → [255.3552:3594]
```
    monster->x = fx;
    monster->y = fy;
```
[258.2720]
[258.2721]
```
    monster->x = f.x;
    monster->y = f.y;
```
Replacement in crawl-ref/source/monstuff.cc at line 6553 [56.1396662]
∅:D[259.2764] → [255.3972:4031]
B:BD[255.3972] → [255.3972:4031]
```
    mgrd[monster->x][monster->y] = monster_index(monster);
```
[258.2722]
[255.4031]
```
    mgrd(monster->pos()) = monster_index(monster);
```
Replacement in crawl-ref/source/monstuff.cc at line 6555 [56.1396662]
B:BD[255.4032] → [89.6205:6268]
```
    monster->check_redraw(monster->pos() - coord_def(xi, yi));
```
[255.4032]
[180.4176]
```
    monster->check_redraw(monster->pos() - delta);
```

Replacement in crawl-ref/source/monstuff.cc at line 6650 [56.1396662]

∅:D[260.2720] → [208.9556:9625]

B:BD[261.2433] → [208.9556:9625]

B:BD[208.9625] → [209.3455:3516]

static bool _is_trap_safe(const monsters *monster, const int trap_x,
                          const int trap_y, bool just_check)

[260.2720]

[262.1876]

static bool _is_trap_safe(const monsters *monster, const coord_def& where,
                          bool just_check)

Replacement in crawl-ref/source/monstuff.cc at line 6659 [56.1396662]
∅:D[258.2726] → [261.2520:2587]
B:BD[261.2520] → [261.2520:2587]
```
    const trap_struct &trap = env.trap[trap_at_xy(trap_x,trap_y)];
```
[258.2726]
[262.1987]
```
    const trap_struct &trap = env.trap[trap_at_xy(where)];
```

Replacement in crawl-ref/source/monstuff.cc at line 6676 [56.1396662]

B:BD[261.2824] → [261.2824:2908]

    const bool player_knows_trap = (grd[trap_x][trap_y] != DNGN_UNDISCOVERED_TRAP);

[261.2824]

[261.2908]

    const bool player_knows_trap = (grd(where) != DNGN_UNDISCOVERED_TRAP);

Replacement in crawl-ref/source/monstuff.cc at line 6696 [56.1396662]

∅:D[263.2971] → [264.1049:1143]

B:BD[264.1049] → [264.1049:1143]

            const int x = trap_x - monster->x;
            const int y = trap_y - monster->y;

[263.2971]

[258.2727]

            const int x = where.x - monster->x;
            const int y = where.y - monster->y;

Replacement in crawl-ref/source/monstuff.cc at line 6719 [56.1396662]

∅:D[258.2730] → [208.9757:10015]

B:BD[264.2213] → [208.9757:10015]

            if ((_mon_can_move_to_pos(monster, x-1, y, true)
                   || _mon_can_move_to_pos(monster, x+1,y, true))
                && (_mon_can_move_to_pos(monster, x,y-1, true)
                    || _mon_can_move_to_pos(monster, x,y+1, true)))

[258.2730]

[264.2467]

            if ((_mon_can_move_to_pos(monster, coord_def(x-1, y), true)
                 || _mon_can_move_to_pos(monster, coord_def(x+1,y), true))
                && (_mon_can_move_to_pos(monster, coord_def(x,y-1), true)
                    || _mon_can_move_to_pos(monster, coord_def(x,y+1), true)))

Replacement in crawl-ref/source/monstuff.cc at line 6771 [56.1396662]

B:BD[113.4338] → [24.2981:3041]

            grid = grid_secret_door_appearance(dc.x, dc.y);

[113.4338]

[24.3041]

            grid = grid_secret_door_appearance(dc);

Replacement in crawl-ref/source/monstuff.cc at line 6820 [56.1396662]

B:BD[264.2763] → [209.3848:3994]

static bool _mon_can_move_to_pos(const monsters *monster, const int count_x,
                                 const int count_y, bool just_check)

[264.2763]

[264.2893]

static bool _mon_can_move_to_pos(const monsters *monster,
                                 const coord_def& delta, bool just_check)

Replacement in crawl-ref/source/monstuff.cc at line 6823 [56.1396662]

B:BD[264.2895] → [264.2895:2985]

    const int targ_x = monster->x + count_x;
    const int targ_y = monster->y + count_y;

[264.2895]

[265.2668]

    const coord_def targ = monster->pos() + delta;

Replacement in crawl-ref/source/monstuff.cc at line 6826 [56.1396662]
∅:D[240.4431] → [63.5208:5254]
B:BD[264.3047] → [63.5208:5254]
```
    if (!inside_level_bounds(targ_x, targ_y))
```
[240.4431]
[235.6351]
```
    if (!inside_level_bounds(targ))
```

Replacement in crawl-ref/source/monstuff.cc at line 6831 [56.1396662]

∅:D[265.2756] → [65.14466:14556]

B:BD[65.14466] → [65.14466:14556]

        && is_sanctuary(targ_x, targ_y)
        && !is_sanctuary(monster->x, monster->y))

[265.2756]

[65.14556]

        && is_sanctuary(targ)
        && !is_sanctuary(monster->pos()))

Replacement in crawl-ref/source/monstuff.cc at line 6837 [56.1396662]

∅:D[240.4557] → [65.14641:14794]

B:BD[65.14641] → [65.14641:14794]

    if (is_sanctuary(monster->x, monster->y)
        && (targ_x == you.x_pos && targ_y == you.y_pos
            || mgrd[targ_x][targ_y] != NON_MONSTER))

[240.4557]

[65.14794]

    if (is_sanctuary(monster->pos())
        && (targ == you.pos() || mgrd(targ) != NON_MONSTER))

Replacement in crawl-ref/source/monstuff.cc at line 6843 [56.1396662]

B:BD[264.3138] → [266.204:270]

    const dungeon_feature_type target_grid = grd[targ_x][targ_y];

[264.3138]

[267.8345]

    const dungeon_feature_type target_grid = grd(targ);

Replacement in crawl-ref/source/monstuff.cc at line 6852 [56.1396662]
B:BD[264.3518] → [264.3518:3581]
```
    const int targ_cloud_num  = env.cgrid[ targ_x ][ targ_y ];
```
[264.3518]
[264.3581]
```
    const int targ_cloud_num  = env.cgrid(targ);
```

Replacement in crawl-ref/source/monstuff.cc at line 6857 [56.1396662]

B:BD[264.3735] → [264.3735:3805]

    const int curr_cloud_num = env.cgrid[ monster->x ][ monster->y ];

[264.3735]

[264.3805]

    const int curr_cloud_num = env.cgrid(monster->pos());

Replacement in crawl-ref/source/monstuff.cc at line 6867 [56.1396662]

B:BD[240.4659] → [240.4659:4772]

∅:D[240.4772] → [264.4142:4250]

B:BD[264.4142] → [264.4142:4250]

        // XXX: Are these bounds still valid? (jpeg)
        //      We should probably use in_bounds() instead.
        if (targ_x <= 7 || targ_x >= (GXM - 8)
            || targ_y <= 7 || targ_y >= (GYM - 8))
        {

[240.4659]

[235.6376]

        if (!in_bounds(targ))

Deletion in crawl-ref/source/monstuff.cc at line 6869 [56.1396662]
∅:D[235.6404] → [264.4276:4286]
B:BD[264.4276] → [264.4276:4286]
```
        }
```
Replacement in crawl-ref/source/monstuff.cc at line 6871 [56.1396662]
∅:D[240.4829] → [264.4342:4384]
B:BD[264.4342] → [264.4342:4384]
```
        if (count_x != 0 && count_y != 0)
```
[240.4829]
[235.6405]
```
        if (delta.x != 0 && delta.y != 0)
```

Replacement in crawl-ref/source/monstuff.cc at line 6885 [56.1396662]

B:BD[264.4724] → [218.8868:8946]

    if (monster->type == MONS_WANDERING_MUSHROOM && see_grid(targ_x, targ_y))

[264.4724]

[235.6484]

    if (monster->type == MONS_WANDERING_MUSHROOM && see_grid(targ))

Replacement in crawl-ref/source/monstuff.cc at line 6911 [56.1396662]
∅:D[268.346] → [264.5704:5760]
∅:D[269.1518] → [264.5704:5760]
B:BD[264.5704] → [264.5704:5760]
```
        && (targ_x != you.x_pos || targ_y != you.y_pos)
```
[268.346]
[264.5760]
```
        && targ != you.pos()
```

Replacement in crawl-ref/source/monstuff.cc at line 6913 [56.1396662]

B:BD[264.5802] → [264.5802:5860]

        && grd[monster->x][monster->y] == DNGN_DEEP_WATER

[264.5802]

[264.5860]

        && grd(monster->pos()) == DNGN_DEEP_WATER

Replacement in crawl-ref/source/monstuff.cc at line 6926 [56.1396662]
∅:D[220.10866] → [264.6252:6297]
B:BD[264.6252] → [264.6252:6297]
```
    if (mgrd[targ_x][targ_y] != NON_MONSTER)
```
[220.10866]
[264.6297]
```
    if (mgrd(targ) != NON_MONSTER)
```

Replacement in crawl-ref/source/monstuff.cc at line 6930 [56.1396662]

B:BD[264.6337] → [264.6337:6399]

            if (targ_x == monster->x && targ_y == monster->y)

[264.6337]

[235.6584]

            if (targ == monster->pos())

Replacement in crawl-ref/source/monstuff.cc at line 6937 [56.1396662]

B:BD[264.6555] → [264.6555:6609]

                  targmonster = mgrd[targ_x][targ_y];

[264.6555]

[220.10867]

                  targmonster = mgrd(targ);

Replacement in crawl-ref/source/monstuff.cc at line 6953 [56.1396662]
∅:D[68.6378] → [270.2778:2841]
B:BD[270.2778] → [270.2778:2841]
```
        && targ_x == you.x_pos
        && targ_y == you.y_pos)
```
[68.6378]
[270.2841]
```
        && targ == you.pos())
```

Replacement in crawl-ref/source/monstuff.cc at line 6960 [56.1396662]

∅:D[68.6487] → [264.6960:7014]

B:BD[264.6960] → [264.6960:7014]

B:BD[264.7014] → [208.10351:10431]

    const int which_trap = trap_at_xy(targ_x,targ_y);
    if (which_trap >= 0 && !_is_trap_safe(monster, targ_x, targ_y, just_check))

[68.6487]

[235.6716]

    const int which_trap = trap_at_xy(targ);
    if (which_trap >= 0 && !_is_trap_safe(monster, targ, just_check))

Replacement in crawl-ref/source/monstuff.cc at line 7083 [56.1396662]

B:BD[61.936] → [58.3355:3415]

                noisy(noise_level, monster->x, monster->y);

[61.936]

[61.998]

                noisy(noise_level, monster->pos());

Replacement in crawl-ref/source/monstuff.cc at line 7090 [56.1396662]

B:BD[58.3479] → [58.3479:3539]

                noisy(noise_level, monster->x, monster->y);

[58.3479]

[80.8112]

                noisy(noise_level, monster->pos());

Replacement in crawl-ref/source/monstuff.cc at line 7097 [56.1396662]
B:BD[255.5270] → [255.5270:5321]
```
        if (mmov_x || mmov_y || one_chance_in(15))
```
[255.5270]
[271.75]
```
        if (mmov.x || mmov.y || one_chance_in(15))
```

Replacement in crawl-ref/source/monstuff.cc at line 7099 [56.1396662]

B:BD[271.85] → [271.85:160]

            coord_def newpos = monster->pos() + coord_def(mmov_x, mmov_y);

[271.85]

[271.160]

            const coord_def newpos = monster->pos() + mmov;

Replacement in crawl-ref/source/monstuff.cc at line 7104 [56.1396662]

B:BD[271.343] → [208.10478:10544]

                return _do_move_monster(monster, mmov_x, mmov_y);

[271.343]

[271.401]

                return _do_move_monster(monster, mmov);

Replacement in crawl-ref/source/monstuff.cc at line 7110 [56.1396662]

B:BD[272.279] → [68.6785:6855]

∅:D[68.6855] → [56.1529973:1530009]

B:BD[56.1529973] → [56.1529973:1530009]

    // Let's not even bother with this if mmov_x and mmov_y are zero.
    if (mmov_x == 0 && mmov_y == 0)

[272.279]

[235.7333]

    // Let's not even bother with this if mmov.x and mmov.y are zero.
    if (mmov.x == 0 && mmov.y == 0)

Replacement in crawl-ref/source/monstuff.cc at line 7133 [56.1396662]

B:BD[264.10061] → [208.10545:10612]

                 _mon_can_move_to_pos(mons, count_x-1, count_y-1);

[264.10061]

[68.6923]

                 _mon_can_move_to_pos(mons, coord_def(count_x-1, count_y-1));

Replacement in crawl-ref/source/monstuff.cc at line 7138 [56.1396662]

B:BD[56.1537368] → [273.775:848]

    const coord_def newpos = monster->pos() + coord_def(mmov_x, mmov_y);

[56.1537368]

[68.6975]

    const coord_def newpos = monster->pos() + mmov;

Replacement in crawl-ref/source/monstuff.cc at line 7162 [56.1396662]

∅:D[12.2685] → [56.1538642:1538797]

B:BD[56.1538642] → [56.1538642:1538797]

    if ((grd[monster->x + mmov_x][monster->y + mmov_y] == DNGN_CLOSED_DOOR
            || grd[monster->x + mmov_x][monster->y + mmov_y] == DNGN_OPEN_DOOR)

[12.2685]

[56.1538797]

    if ((grd(newpos) == DNGN_CLOSED_DOOR || grd(newpos) == DNGN_OPEN_DOOR)

Replacement in crawl-ref/source/monstuff.cc at line 7165 [56.1396662]
B:BD[56.1538864] → [56.1538864:1538932]
```
        grd[monster->x + mmov_x][monster->y + mmov_y] = DNGN_FLOOR;
```
[56.1538864]
[56.1538932]
```
        grd(newpos) = DNGN_FLOOR;
```
Replacement in crawl-ref/source/monstuff.cc at line 7169 [56.1396662]
B:BD[274.618] → [274.618:682]
```
        if (see_grid(monster->x + mmov_x, monster->y + mmov_y))
```
[274.618]
[274.682]
```
        if (see_grid(newpos))
```

Replacement in crawl-ref/source/monstuff.cc at line 7187 [56.1396662]

B:BD[56.1539983] → [56.1539983:1540117]

B:BD[56.1540117] → [272.320:365]

∅:D[272.365] → [56.1540163:1540212]

B:BD[56.1540163] → [56.1540163:1540212]

        && grd[monster->x][monster->y] != DNGN_DEEP_WATER
        && grd[monster->x + mmov_x][monster->y + mmov_y] != DNGN_DEEP_WATER
        && (monster->x + mmov_x != you.x_pos
            || monster->y + mmov_y != you.y_pos)

[56.1539983]

[60.445843]

        && grd(monster->pos()) != DNGN_DEEP_WATER
        && grd(newpos) != DNGN_DEEP_WATER
        && newpos != you.pos()

Replacement in crawl-ref/source/monstuff.cc at line 7206 [56.1396662]

B:BD[56.1540757] → [106.9822:9914]

                        mmov_x = count_x - 1;
                        mmov_y = count_y - 1;

[56.1540757]

[56.1540852]

                        mmov.x = count_x - 1;
                        mmov.y = count_y - 1;

Replacement in crawl-ref/source/monstuff.cc at line 7217 [56.1396662]
∅:D[60.446042] → [56.1541163:1541215]
B:BD[56.1541163] → [56.1541163:1541215]
```
    if (good_move[mmov_x + 1][mmov_y + 1] == false)
```
[60.446042]
[56.1541215]
```
    if (good_move[mmov.x + 1][mmov.y + 1] == false)
```

Replacement in crawl-ref/source/monstuff.cc at line 7219 [56.1396662]

B:BD[56.1541221] → [246.3090:3288]

        int current_distance = grid_distance(monster->x, monster->y,
                                             monster->target_x,
                                             monster->target_y);

[56.1541221]

[56.1541424]

        int current_distance = grid_distance(monster->pos(),
                                             monster->target_pos());

Replacement in crawl-ref/source/monstuff.cc at line 7227 [56.1396662]

B:BD[56.1541518] → [56.1541518:1541584]

            if (compass_x[i] == mmov_x && compass_y[i] == mmov_y)

[56.1541518]

[56.1541584]

            if (compass_x[i] == mmov.x && compass_y[i] == mmov.y)

Replacement in crawl-ref/source/monstuff.cc at line 7282 [56.1396662]

B:BD[56.1543185] → [56.1543185:1543301]

                    mmov_x = compass_x[((dir+8)+sdir)%8];
                    mmov_y = compass_y[((dir+8)+sdir)%8];

[56.1543185]

[56.1543301]

                    mmov.x = compass_x[((dir+8)+sdir)%8];
                    mmov.y = compass_y[((dir+8)+sdir)%8];

Replacement in crawl-ref/source/monstuff.cc at line 7288 [56.1396662]

B:BD[56.1543435] → [56.1543435:1543551]

                    mmov_x = compass_x[((dir+8)-sdir)%8];
                    mmov_y = compass_y[((dir+8)-sdir)%8];

[56.1543435]

[56.1543551]

                    mmov.x = compass_x[((dir+8)-sdir)%8];
                    mmov.y = compass_y[((dir+8)-sdir)%8];

Replacement in crawl-ref/source/monstuff.cc at line 7297 [56.1396662]

B:BD[56.1543730] → [56.1543730:1543846]

                    mmov_x = compass_x[((dir+8)+sdir)%8];
                    mmov_y = compass_y[((dir+8)+sdir)%8];

[56.1543730]

[56.1543846]

                    mmov.x = compass_x[((dir+8)+sdir)%8];
                    mmov.y = compass_y[((dir+8)+sdir)%8];

Replacement in crawl-ref/source/monstuff.cc at line 7303 [56.1396662]

B:BD[56.1543980] → [56.1543980:1544096]

                    mmov_x = compass_x[((dir+8)-sdir)%8];
                    mmov_y = compass_y[((dir+8)-sdir)%8];

[56.1543980]

[56.1544096]

                    mmov.x = compass_x[((dir+8)-sdir)%8];
                    mmov.y = compass_y[((dir+8)-sdir)%8];

Replacement in crawl-ref/source/monstuff.cc at line 7320 [56.1396662]
B:BD[56.1544536] → [106.10046:10082]
∅:D[106.10082] → [55.11402:11461]
B:BD[55.11402] → [55.11402:11461]
```
        dungeon_feature_type feat =
            grd[monster->x + mmov_x][monster->y + mmov_y];
```
[56.1544536]
[55.11461]
```
        const dungeon_feature_type feat = grd(monster->pos() + mmov);
```
Replacement in crawl-ref/source/monstuff.cc at line 7322 [56.1396662]
∅:D[55.11524] → [56.1544612:1544670]
B:BD[56.1544612] → [56.1544612:1544670]
```
            && good_move[mmov_x + 1][mmov_y + 1] == true)
```
[55.11524]
[56.1544670]
```
            && good_move[mmov.x + 1][mmov.y + 1] == true)
```

Replacement in crawl-ref/source/monstuff.cc at line 7324 [56.1396662]

B:BD[56.1544680] → [56.1544680:1544752]

B:BD[56.1544752] → [273.1012:1089]

            grd[monster->x + mmov_x][monster->y + mmov_y] = DNGN_FLOOR;
            set_terrain_changed(monster->pos() + coord_def(mmov_x, mmov_y));

[56.1544680]

[56.1544752]

            grd(monster->pos() + mmov) = DNGN_FLOOR;
            set_terrain_changed(monster->pos() + mmov);

Replacement in crawl-ref/source/monstuff.cc at line 7327 [56.1396662]
B:BD[56.1544753] → [56.1544753:1544802]
```
            if (!silenced(you.x_pos, you.y_pos))
```
[56.1544753]
[60.446089]
```
            if (!silenced(you.pos()))
```
Replacement in crawl-ref/source/monstuff.cc at line 7333 [56.1396662]
∅:D[257.8070] → [56.1544919:1544995]
B:BD[56.1544919] → [56.1544919:1544995]
```
    if (good_move[mmov_x + 1][mmov_y + 1] && !(mmov_x == 0 && mmov_y == 0))
```
[257.8070]
[56.1544995]
```
    if (good_move[mmov.x + 1][mmov.y + 1] && !(mmov.x == 0 && mmov.y == 0))
```
Replacement in crawl-ref/source/monstuff.cc at line 7336 [56.1396662]
∅:D[68.7435] → [56.1545039:1545133]
B:BD[56.1545039] → [56.1545039:1545133]
```
        if (monster->x + mmov_x == you.x_pos
            && monster->y + mmov_y == you.y_pos)
```
[68.7435]
[56.1545133]
```
        if (monster->pos() + mmov == you.pos())
```
Replacement in crawl-ref/source/monstuff.cc at line 7339 [56.1396662]
∅:D[275.346] → [56.1545197:1545245]
∅:D[257.8098] → [56.1545197:1545245]
B:BD[56.1545197] → [56.1545197:1545245]
```
            mmov_x = 0;
            mmov_y = 0;
```
[275.346]
[56.1545245]
```
            mmov.reset();
```
Replacement in crawl-ref/source/monstuff.cc at line 7361 [56.1396662]
∅:D[257.8194] → [276.708:764]
B:BD[276.708] → [276.708:764]
```
                mmov_x = 0;
                mmov_y = 0;
```
[257.8194]
[258.2813]
```
                mmov.reset();
```
Replacement in crawl-ref/source/monstuff.cc at line 7372 [56.1396662]
∅:D[68.7484] → [56.1545773:1545843]
B:BD[56.1545773] → [56.1545773:1545843]
```
        int targmon = mgrd[monster->x + mmov_x][monster->y + mmov_y];
```
[68.7484]
[56.1545843]
```
        int targmon = mgrd(monster->pos() + mmov);
```

Replacement in crawl-ref/source/monstuff.cc at line 7376 [56.1396662]

B:BD[60.446217] → [208.10743:10813]

                ret = _monster_swaps_places(monster, mmov_x, mmov_y);

[60.446217]

[60.446280]

                ret = _monster_swaps_places(monster, mmov);

Replacement in crawl-ref/source/monstuff.cc at line 7384 [56.1396662]
∅:D[257.8289] → [56.1545950:1545998]
∅:D[60.446434] → [56.1545950:1545998]
B:BD[56.1545950] → [56.1545950:1545998]
```
            mmov_x = 0;
            mmov_y = 0;
```
[60.446434]
[56.1545998]
```
            mmov.reset();
```

Replacement in crawl-ref/source/monstuff.cc at line 7390 [56.1396662]

B:BD[56.1546113] → [106.10083:10144]

            place_cloud( CLOUD_FIRE, monster->x, monster->y,

[56.1546113]

[121.6327]

            place_cloud( CLOUD_FIRE, monster->pos(),

Replacement in crawl-ref/source/monstuff.cc at line 7397 [56.1396662]

B:BD[60.446557] → [106.10194:10257]

            place_cloud( CLOUD_MIASMA, monster->x, monster->y,

[60.446557]

[121.6462]

            place_cloud( CLOUD_MIASMA, monster->pos(),

Replacement in crawl-ref/source/monstuff.cc at line 7403 [56.1396662]
B:BD[56.1546391] → [255.5403:5432]
```
        mmov_x = mmov_y = 0;
```
[56.1546391]
[106.10258]
```
        mmov.reset();
```

Replacement in crawl-ref/source/monstuff.cc at line 7410 [56.1396662]

B:BD[56.1546600] → [255.5442:5513]

B:BD[255.5513] → [208.10814:10872]

    if (mmov_x || mmov_y || (monster->confused() && one_chance_in(6)))
        return _do_move_monster(monster, mmov_x, mmov_y);

[56.1546600]

[257.8347]

    if (mmov.x || mmov.y || (monster->confused() && one_chance_in(6)))
        return _do_move_monster(monster, mmov);

Replacement in crawl-ref/source/monstuff.cc at line 7595 [56.1396662]

B:BD[62.245593] → [62.245593:245672]

        behaviour_event(monster, ME_DISTURB, MHITNOT, monster->x, monster->y);

[62.245593]

[62.245672]

        behaviour_event(monster, ME_DISTURB, MHITNOT, monster->pos());

Replacement in crawl-ref/source/monplace.cc at line 162 [56.1641732]

B:BD[277.5396] → [114.3800:3865]

        return (trap_type_at_xy(mons->x, mons->y) == NUM_TRAPS);

[277.5396]

[277.5417]

        return (trap_type_at_xy(mons->pos()) == NUM_TRAPS);

Replacement in crawl-ref/source/monplace.cc at line 465 [56.1641732]
∅:D[278.4192] → [279.25018:25071]
B:BD[280.2354] → [279.25018:25071]
```
                int trap = trap_at_xy(pos.x, pos.y);
```
[278.4192]
[280.2401]
```
                int trap = trap_at_xy(pos);
```

Replacement in crawl-ref/source/monplace.cc at line 569 [56.1641732]

B:BD[281.3220] → [281.3220:3294]

    if (mg.behaviour != BEH_FRIENDLY && is_sanctuary(mg_pos.x, mg_pos.y))

[281.3220]

[281.3294]

    if (mg.behaviour != BEH_FRIENDLY && is_sanctuary(mg_pos))

Replacement in crawl-ref/source/monplace.cc at line 574 [56.1641732]
B:BD[281.3409] → [281.3409:3456]
```
    int trap = trap_at_xy(mg_pos.x, mg_pos.y);
```
[281.3409]
[281.3456]
```
    int trap = trap_at_xy(mg_pos);
```

Replacement in crawl-ref/source/monplace.cc at line 840 [56.1641732]

B:BD[282.4370] → [128.4095:4174]

        && (mg.behaviour == BEH_FRIENDLY || !is_sanctuary(mg.pos.x, mg.pos.y))

[282.4370]

[39.2578]

        && (mg.behaviour == BEH_FRIENDLY || !is_sanctuary(mg.pos))

Replacement in crawl-ref/source/monplace.cc at line 2640 [56.1641732]

B:BD[81.5396] → [81.5396:5469]

        if (grid_see_grid(pos.x, pos.y, path[i].x, path[i].y, can_move))

[81.5396]

[81.5469]

        if (grid_see_grid(pos, path[i], can_move))

Replacement in crawl-ref/source/monplace.cc at line 2687 [56.1641732]
B:BD[109.9125] → [109.9125:9168]
```
    const int trap = trap_at_xy(p.x, p.y);
```
[109.9068]
[109.9168]
```
    const int trap = trap_at_xy(p);
```
Replacement in crawl-ref/source/monplace.cc at line 2733 [56.1641732]
B:BD[263.4555] → [263.4555:4604]
```
    const int trap = trap_at_xy(npos.x, npos.y);
```
[263.4548]
[263.4604]
```
    const int trap = trap_at_xy(npos);
```
Replacement in crawl-ref/source/mon-util.h at line 754 [56.1682293]
B:BD[60.465423] → [60.465423:465474]
```
monster_type random_monster_at_grid(int x, int y);
```
[60.465423]
[268.627]
```
monster_type random_monster_at_grid(const coord_def& p);
```
Replacement in crawl-ref/source/mon-util.cc at line 148 [56.1699344]
B:BD[60.467459] → [60.467459:467509]
```
monster_type random_monster_at_grid(int x, int y)
```
[60.467459]
[60.467509]
```
monster_type random_monster_at_grid(const coord_def& p)
```
Replacement in crawl-ref/source/mon-util.cc at line 150 [56.1699344]
B:BD[60.467511] → [60.467511:467559]
```
    return (random_monster_at_grid(grd[x][y]));
```
[60.467511]
[60.467559]
```
    return (random_monster_at_grid(grd(p)));
```

Replacement in crawl-ref/source/mon-util.cc at line 2295 [56.1699344]

B:BD[26.2676] → [26.2676:2780]

    if (is_sanctuary(you.x_pos, you.y_pos)
        || is_sanctuary(beam.source_x, beam.source_y))
    {

[26.2676]

[56.1735287]

    if (is_sanctuary(you.pos()) || is_sanctuary(beam.source()))

Deletion in crawl-ref/source/mon-util.cc at line 2297 [56.1699344]
B:BD[56.1735311] → [26.2781:2787]
```
    }
```
Replacement in crawl-ref/source/mon-util.cc at line 2350 [56.1699344]
B:BD[56.1743874] → [56.1743874:1743934]
```
        if (adjacent(you.x_pos, you.y_pos, mon->x, mon->y))
```
[56.1743874]
[56.1743934]
```
        if (adjacent(you.pos(), mon->pos()))
```
Replacement in crawl-ref/source/mon-util.cc at line 2352 [56.1699344]
B:BD[56.1743963] → [250.7773:7821]
```
        if (is_sanctuary(you.x_pos, you.y_pos))
```
[56.1743963]
[250.7821]
```
        if (is_sanctuary(you.pos()))
```

Replacement in crawl-ref/source/mon-util.cc at line 2357 [56.1699344]

B:BD[56.1744052] → [250.7863:8028]

       if (adjacent( menv[mon->foe].x, menv[mon->foe].y, mon->x, mon->y ))
          targ_adj = true;
       if (is_sanctuary( menv[mon->foe].x, menv[mon->foe].y ))

[56.1744052]

[250.8028]

        if (adjacent(menv[mon->foe].pos(), mon->pos()))
            targ_adj = true;
        if (is_sanctuary(menv[mon->foe].pos()))

Replacement in crawl-ref/source/mon-util.cc at line 2440 [56.1699344]

B:BD[250.8415] → [250.8415:8525]

        if (spell_harms_target(monspell)
            && is_sanctuary(mon->target_x, mon->target_y))
        {

[250.8415]

[250.8525]

        if (spell_harms_target(monspell) && is_sanctuary(mon->target_pos()))

Deletion in crawl-ref/source/mon-util.cc at line 2442 [56.1699344]
B:BD[250.8552] → [250.8552:8562]
```
        }
```
Replacement in crawl-ref/source/mon-util.cc at line 3596 [56.1699344]
B:BD[48.8194] → [48.8194:8241]
```
    if (!move_item_to_grid(&item_index, x, y))
```
[48.8194]
[283.7446]
```
    if (!move_item_to_grid(&item_index, pos()))
```
Replacement in crawl-ref/source/mon-util.cc at line 4389 [56.1699344]
∅:D[284.309] → [52.41682:41755]
∅:D[242.15238] → [52.41682:41755]
B:BD[52.41682] → [52.41682:41755]
```
            else if (!silenced(you.x_pos, you.y_pos) && !silenced(x, y))
```
[242.15238]
[285.2794]
```
            else if (!silenced(you.pos()) && !silenced(x, y))
```
Replacement in crawl-ref/source/mon-util.cc at line 5181 [56.1699344]
∅:D[21.2767] → [114.5672:5735]
B:BD[114.5672] → [114.5672:5735]
```
                && trap_type_at_xy(pos.x, pos.y) == NUM_TRAPS)
```
[21.2767]
[114.5735]
```
                && trap_type_at_xy(pos) == NUM_TRAPS)
```
Replacement in crawl-ref/source/mon-util.cc at line 5372 [56.1699344]
B:BD[190.1330] → [190.1330:1371]
```
        int net = get_trapping_net(x,y);
```
[190.1330]
[190.1371]
```
        int net = get_trapping_net(this->pos());
```
Replacement in crawl-ref/source/mon-util.cc at line 5678 [56.1699344]
∅:D[286.2704] → [287.523:569]
B:BD[143.13472] → [287.523:569]
```
        int net = get_trapping_net(x,y,true);
```
[286.2704]
[143.13777]
```
        int net = get_trapping_net(this->pos(), true);
```

Replacement in crawl-ref/source/mon-util.cc at line 6188 [56.1699344]

B:BD[288.4039] → [49.7804:7880]

    return (!num_feats_between(x, y, p.x, p.y, DNGN_UNSEEN, max_disallowed,

[288.4039]

[80.8614]

    return (!num_feats_between(pos(), p, DNGN_UNSEEN, max_disallowed,

Replacement in crawl-ref/source/mon-util.cc at line 6273 [56.1699344]

B:BD[289.12655] → [289.12655:12768]

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

[289.12655]

[289.12768]

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

Deletion in crawl-ref/source/mon-util.cc at line 6275 [56.1699344]
B:BD[289.12792] → [289.12792:12798]
```
    }
```
Replacement in crawl-ref/source/mon-util.cc at line 6277 [56.1699344]
∅:D[290.10388] → [289.12829:12859]
B:BD[289.12829] → [289.12829:12859]
```
    mgrd[x][y] = NON_MONSTER;
```
[290.10388]
[289.12859]
```
    mgrd(pos()) = NON_MONSTER;
```
Replacement in crawl-ref/source/mon-util.cc at line 6284 [56.1699344]
B:BD[289.12986] → [289.12986:13024]
```
    mgrd[x][y] = monster_index(this);
```
[289.12986]
[289.13024]
```
    mgrd(newpos) = monster_index(this);
```
Replacement in crawl-ref/source/mon-util.cc at line 6297 [56.1699344]
B:BD[181.15060] → [181.15060:15105]
```
    if (trap_type_at_xy(x, y) != TRAP_SHAFT)
```
[181.15060]
[181.15105]
```
    if (trap_type_at_xy(this->pos()) != TRAP_SHAFT)
```

Replacement in crawl-ref/source/mon-util.cc at line 6327 [56.1699344]

B:BD[100.7708] → [100.7708:7768]

            handle_items_on_shaft(this->x, this->y, false);

[100.7708]

[291.1644]

            handle_items_on_shaft(this->pos(), false);

Replacement in crawl-ref/source/mon-util.cc at line 6345 [56.1699344]
∅:D[292.2770] → [100.7770:7822]
B:BD[100.7770] → [100.7770:7822]
```
    handle_items_on_shaft(this->x, this->y, false);
```
[292.2770]
[181.16160]
```
    handle_items_on_shaft(this->pos(), false);
```

Replacement in crawl-ref/source/misc.h at line 69 [56.1928926]

B:BD[293.3242] → [293.3242:3372]

void drop_blood_potions_stack( item_def &stack, int quant, int x = you.x_pos,
                               int y = you.y_pos );

[293.3242]

[293.3372]

void drop_blood_potions_stack( item_def &stack, int quant,
                               const coord_def& p = you.pos() );

Replacement in crawl-ref/source/misc.h at line 78 [56.1928926]

∅:D[294.3961] → [66.4197:4277]

B:BD[56.1932235] → [66.4197:4277]

void bleed_onto_floor(int x, int y, int mon, int damage, bool spatter = false);

[294.3961]

[295.2579]

void bleed_onto_floor(const coord_def& where, int mon, int damage,
                      bool spatter = false);

Replacement in crawl-ref/source/misc.cc at line 138 [56.1933596]
B:BD[296.6721] → [296.6721:6772]
```
    move_item_to_grid( &o, you.x_pos, you.y_pos );
```
[296.6721]
[123.6209]
```
    move_item_to_grid( &o, you.pos() );
```

Replacement in crawl-ref/source/misc.cc at line 174 [56.1933596]

∅:D[296.6807] → [66.4453:4531]

B:BD[66.4453] → [66.4453:4531]

        bleed_onto_floor(you.x_pos, you.y_pos, mons_class, max_chunks, true);

[296.6807]

[297.10243]

        bleed_onto_floor(you.pos(), mons_class, max_chunks, true);

Replacement in crawl-ref/source/misc.cc at line 395 [56.1933596]
B:BD[293.6682] → [293.6682:6729]
```
    move_item_to_grid( &o, blood.x, blood.y );
```
[293.6682]
[293.6729]
```
    move_item_to_grid( &o, coord_def(blood.x, blood.y) );
```
Replacement in crawl-ref/source/misc.cc at line 725 [56.1933596]
B:BD[297.14650] → [293.15215:15266]
```
    move_item_to_grid( &o, you.x_pos, you.y_pos );
```
[297.14650]
[297.14697]
```
    move_item_to_grid( &o, you.pos() );
```
Replacement in crawl-ref/source/misc.cc at line 804 [56.1933596]
∅:D[298.4996] → [293.17004:17076]
B:BD[293.17004] → [293.17004:17076]
```
void drop_blood_potions_stack(item_def &stack, int quant, int x, int y)
```
[298.4996]
[293.17076]
```
void drop_blood_potions_stack(item_def &stack, int quant, const coord_def& p)
```
Replacement in crawl-ref/source/misc.cc at line 820 [56.1933596]
∅:D[298.5074] → [293.17305:17329]
B:BD[297.16047] → [293.17305:17329]
```
    int o = igrd[x][y];
```
[298.5074]
[297.16087]
```
    int o = igrd[p.x][p.y];
```
Replacement in crawl-ref/source/misc.cc at line 1070 [56.1933596]
B:BD[56.1936957] → [296.9945:10005]
```
        copy_item_to_grid( potion2, you.x_pos, you.y_pos );
```
[56.1936957]
[296.10005]
```
        copy_item_to_grid( potion2, you.pos() );
```
Replacement in crawl-ref/source/misc.cc at line 1101 [56.1933596]
B:BD[66.5312] → [66.5312:5363]
```
static bool allow_bleeding_on_square(int x, int y)
```
[66.5312]
[66.5363]
```
static bool allow_bleeding_on_square(const coord_def& where)
```
Replacement in crawl-ref/source/misc.cc at line 1105 [56.1933596]
∅:D[298.6090] → [66.5468:5514]
B:BD[66.5468] → [66.5468:5514]
```
    if (env.map[x][y].property != FPROP_NONE)
```
[298.6090]
[66.5514]
```
    if (env.map(where).property != FPROP_NONE)
```
Replacement in crawl-ref/source/misc.cc at line 1109 [56.1933596]
∅:D[298.6132] → [66.5579:5637]
B:BD[66.5579] → [66.5579:5637]
```
    if (grd[x][y] >= DNGN_LAVA && grd[x][y] < DNGN_FLOOR)
```
[298.6132]
[299.2868]
```
    if (grd(where) >= DNGN_LAVA && grd(where) < DNGN_FLOOR)
```

Replacement in crawl-ref/source/misc.cc at line 1113 [56.1933596]

∅:D[298.6189] → [300.6206:6287]

B:BD[300.6206] → [300.6206:6287]

    if (grd[x][y] == DNGN_FOUNTAIN_BLUE || grd[x][y] == DNGN_FOUNTAIN_SPARKLING)

[298.6189]

[66.5637]

    if (grd(where) == DNGN_FOUNTAIN_BLUE
        || grd(where) == DNGN_FOUNTAIN_SPARKLING)
    {

Insertion in crawl-ref/source/misc.cc at line 1117 [56.1933596]
[66.5661]
[66.5661]
```
    }
```
Replacement in crawl-ref/source/misc.cc at line 1120 [56.1933596]
∅:D[298.6247] → [66.5718:5766]
B:BD[66.5718] → [66.5718:5766]
```
    if (is_good_god(grid_altar_god(grd[x][y])))
```
[298.6247]
[66.5766]
```
    if (is_good_god(grid_altar_god(grd(where))))
```

Replacement in crawl-ref/source/misc.cc at line 1126 [56.1933596]

B:BD[66.5825] → [66.5825:5907]

static void maybe_bloodify_square(int x, int y, int amount, bool spatter = false)

[66.5825]

[66.5907]

static void maybe_bloodify_square(const coord_def& where, int amount,
                                  bool spatter = false)

Replacement in crawl-ref/source/misc.cc at line 1132 [56.1933596]
B:BD[66.5946] → [66.5946:5998]
```
    if (!spatter && !allow_bleeding_on_square(x,y))
```
[66.5946]
[66.5998]
```
    if (!spatter && !allow_bleeding_on_square(where))
```
Replacement in crawl-ref/source/misc.cc at line 1140 [56.1933596]
B:BD[66.6171] → [66.6171:6199]
```
             x, y, amount);
```
[66.6171]
[66.6199]
```
             where.x, where.y, amount);
```

Replacement in crawl-ref/source/misc.cc at line 1142 [56.1933596]

B:BD[66.6206] → [66.6206:6300]

        if (allow_bleeding_on_square(x,y))
            env.map[x][y].property = FPROP_BLOODY;

[66.6206]

[297.18615]

        if (allow_bleeding_on_square(where))
            env.map(where).property = FPROP_BLOODY;

Replacement in crawl-ref/source/misc.cc at line 1146 [56.1933596]

∅:D[298.6317] → [59.7269:7356]

B:BD[59.7269] → [59.7269:7356]

        if (env.map[x][y].property == FPROP_BLOODY)
            blood_smell(12, x, y);

[298.6317]

[298.6318]

        if (env.map(where).property == FPROP_BLOODY)
            blood_smell(12, where);

Replacement in crawl-ref/source/misc.cc at line 1149 [56.1933596]
∅:D[298.6365] → [59.7402:7436]
B:BD[59.7402] → [59.7402:7436]
```
            blood_smell(7, x, y);
```
[298.6365]
[60.544399]
```
            blood_smell(7, where);
```

Replacement in crawl-ref/source/misc.cc at line 1154 [56.1933596]

∅:D[298.6431] → [301.2557:2645]

B:BD[66.6396] → [301.2557:2645]

∅:D[301.2645] → [66.6472:6490]

B:BD[66.6472] → [66.6472:6490]

B:BD[66.6490] → [295.2628:2722]

            for (int i = -1; i <= 1; i++)
                for (int j = -1; j <= 1; j++)
                {
                    if (i == 0 && j == 0) // current square
                        continue;

[298.6431]

[297.18617]

            for ( radius_iterator ri(where, 1, true, false); ri; ++ri )
            {
                if ( *ri == where ) // current square
                    continue;

Replacement in crawl-ref/source/misc.cc at line 1159 [56.1933596]

B:BD[297.18618] → [295.2723:2895]

                    // Spattering onto walls etc. less likely.
                    if (grd[x+i][y+j] < DNGN_MINMOVE && !one_chance_in(3))
                        continue;

[297.18618]

[66.6785]

                // Spattering onto walls etc. less likely.
                if (grd(*ri) < DNGN_MINMOVE && !one_chance_in(3))
                    continue;

Replacement in crawl-ref/source/misc.cc at line 1163 [56.1933596]
B:BD[66.6786] → [295.2896:2960]
∅:D[302.2722] → [66.6851:6869]
∅:D[295.2960] → [66.6851:6869]
B:BD[66.6851] → [66.6851:6869]
```
                    maybe_bloodify_square(x+i, y+j, amount/15);
                }
```
[66.6786]
[66.6869]
```
                maybe_bloodify_square(*ri, amount/15);
            }
```

Replacement in crawl-ref/source/misc.cc at line 1172 [56.1933596]

∅:D[298.6656] → [66.7114:7189]

B:BD[66.7114] → [66.7114:7189]

void bleed_onto_floor(int x, int y, int montype, int damage, bool spatter)

[298.6656]

[66.7189]

void bleed_onto_floor(const coord_def& where, int montype,
                      int damage, bool spatter)

Replacement in crawl-ref/source/misc.cc at line 1175 [56.1933596]
B:BD[66.7191] → [189.2779:2807]
```
    ASSERT(in_bounds(x,y));
```
[66.7191]
[66.7191]
```
    ASSERT(in_bounds(where));
```
Replacement in crawl-ref/source/misc.cc at line 1179 [56.1933596]
B:BD[66.7244] → [66.7244:7294]
```
    maybe_bloodify_square(x, y, damage, spatter);
```
[66.7244]
[66.7294]
```
    maybe_bloodify_square(where, damage, spatter);
```

Replacement in crawl-ref/source/misc.cc at line 1182 [56.1933596]

B:BD[295.2962] → [295.2962:3022]

static void _spatter_neighbours(int cx, int cy, int chance)

[295.2962]

[295.3022]

static void _spatter_neighbours(const coord_def& where, int chance)

Replacement in crawl-ref/source/misc.cc at line 1184 [56.1933596]

B:BD[295.3024] → [295.3024:3246]

    int posx, posy;
    for (int x = -1; x <= 1; x++)
        for (int y = -1; y <= 1; y++)
        {
            posx = cx + x;
            posy = cy + y;
            if (!in_bounds(posx, posy))
                continue;

[295.3024]

[66.7296]

    for ( radius_iterator ri(where, 1, true, false); ri; ++ri )
    {
        if (!allow_bleeding_on_square(*ri))
            continue;

Replacement in crawl-ref/source/misc.cc at line 1189 [56.1933596]

B:BD[66.7297] → [295.3247:3424]

            if (!allow_bleeding_on_square(posx, posy))
                continue;
            if (grd[posx][posy] < DNGN_MINMOVE && !one_chance_in(3))
                continue;

[66.7297]

[295.3424]

        if (grd(*ri) < DNGN_MINMOVE && !one_chance_in(3))
            continue;

Replacement in crawl-ref/source/misc.cc at line 1192 [56.1933596]

B:BD[295.3425] → [295.3425:3612]

            if (one_chance_in(chance))
            {
                env.map[posx][posy].property = FPROP_BLOODY;
                _spatter_neighbours(posx, posy, chance+1);
            }

[295.3425]

[295.3612]

        if (one_chance_in(chance))
        {
            env.map(*ri).property = FPROP_BLOODY;
            _spatter_neighbours(*ri, chance+1);

Insertion in crawl-ref/source/misc.cc at line 1197 [56.1933596]
[295.3622]
[295.3622]
```
    }
```
Deletion in crawl-ref/source/misc.cc at line 1202 [56.1933596]
B:BD[295.3673] → [295.3673:3689]
```
    int cx, cy;
```

Replacement in crawl-ref/source/misc.cc at line 1229 [56.1933596]

B:BD[295.3794] → [295.3794:3868]

        cx = 10 + random2(GXM - 10);
        cy = 10 + random2(GYM - 10);

[295.3794]

[237.12482]

        coord_def c;
        c.x = 10 + random2(GXM - 10);
        c.y = 10 + random2(GYM - 10);

Replacement in crawl-ref/source/misc.cc at line 1234 [56.1933596]

B:BD[295.3905] → [295.3905:4052]

        if (allow_bleeding_on_square(cx, cy))
            env.map[cx][cy].property = FPROP_BLOODY;
        _spatter_neighbours(cx, cy, startprob);

[295.3905]

[295.4052]

        if (allow_bleeding_on_square(c))
            env.map(c).property = FPROP_BLOODY;
        _spatter_neighbours(c, startprob);

Replacement in crawl-ref/source/misc.cc at line 1281 [56.1933596]

B:BD[303.1527] → [303.1527:1573]

                    i = trap_at_xy(srx, sry);

[303.1527]

[304.270]

                    i = trap_at_xy(coord_def(srx, sry));

Replacement in crawl-ref/source/misc.cc at line 1737 [56.1933596]

B:BD[305.3708] → [305.3708:3785]

                      && trap_type_at_xy(you.x_pos, you.y_pos) == TRAP_SHAFT

[305.3708]

[181.17536]

                  && trap_type_at_xy(you.pos()) == TRAP_SHAFT

Replacement in crawl-ref/source/misc.cc at line 2017 [56.1933596]

B:BD[181.20070] → [100.7829:7893]

            handle_items_on_shaft(you.x_pos, you.y_pos, false);

[181.20070]

            handle_items_on_shaft(you.pos(), false);

Replacement in crawl-ref/source/misc.cc at line 2410 [56.1933596]

∅:D[298.8747] → [133.2915:2990]

B:BD[133.2915] → [133.2915:2990]

        if (is_sanctuary(you.x_pos, you.y_pos) && env.sanctuary_time >= 5)

[298.8747]

[306.5358]

        if (is_sanctuary(you.pos()) && env.sanctuary_time >= 5)

Replacement in crawl-ref/source/misc.cc at line 2563 [56.1933596]

B:BD[307.1615] → [297.19405:19451]

∅:D[297.19451] → [121.7242:7313]

B:BD[121.7242] → [121.7242:7313]

        check_place_cloud( CLOUD_BLACK_SMOKE,
                           c.x, c.y, random_range( 4, 8 ), KC_OTHER );

[307.1615]

[307.1727]

        check_place_cloud(CLOUD_BLACK_SMOKE, c, random_range(4, 8), KC_OTHER);

Replacement in crawl-ref/source/misc.cc at line 2565 [56.1933596]

B:BD[307.1768] → [297.19452:19491]

∅:D[297.19491] → [121.7314:7385]

B:BD[307.1808] → [121.7314:7385]

        check_place_cloud( CLOUD_MIST,
                           c.x, c.y, random_range( 2, 5 ), KC_OTHER );

[307.1768]

[307.1869]

        check_place_cloud(CLOUD_MIST,        c, random_range(2, 5), KC_OTHER);

Replacement in crawl-ref/source/misc.cc at line 2652 [56.1933596]

B:BD[308.2793] → [308.2793:2860]

    dungeon_feature_type door = grid_secret_door_appearance(x, y);

[308.2793]

[308.2860]

    dungeon_feature_type door = grid_secret_door_appearance(coord_def(x, y));

Replacement in crawl-ref/source/misc.cc at line 2707 [56.1933596]

B:BD[309.5415] → [309.5415:5549]

    const bool inSanctuary   = (is_sanctuary(you.x_pos, you.y_pos)
                                 || is_sanctuary(mon->x, mon->y));

[309.5415]

[309.5549]

    const bool inSanctuary   = (is_sanctuary(you.pos())
                                || is_sanctuary(mon->pos()));

Replacement in crawl-ref/source/makeitem.cc at line 2862 [310.927]
B:BD[310.98502] → [310.98502:98549]
```
        move_item_to_grid( &p, x_pos, y_pos );
```
[310.98502]
[310.98549]
```
        move_item_to_grid( &p, coord_def(x_pos, y_pos) );
```

Replacement in crawl-ref/source/luadgn.cc at line 1300 [313.1232]

B:BD[311.5793] → [312.3899:3978]

∅:D[312.3978] → [311.5865:5912]

B:BD[311.5865] → [311.5865:5912]

        feature_description(luaL_checkint(ls, 1), luaL_checkint(ls, 2), false,
                            dtype, need_stop);

[311.5793]

[180.17264]

        feature_description(coord_def(luaL_checkint(ls, 1),
                                      luaL_checkint(ls, 2)),
                            false, dtype, need_stop);

Replacement in crawl-ref/source/luadgn.cc at line 1581 [313.1232]

B:BD[314.7493] → [314.7493:7550]

    place_cloud( ctype, x, y, pow, whose, spread_rate );

[314.7493]

[314.7550]

    place_cloud( ctype, coord_def(x, y), pow, whose, spread_rate );

Replacement in crawl-ref/source/items.h at line 40 [56.2580284]

B:BD[56.2581002] → [315.308:364]

∅:D[315.364] → [56.2581058:2581128]

B:BD[56.2581058] → [56.2581058:2581128]

bool move_item_to_grid( int *const obj, int x, int y );
void move_item_stack_to_grid( int x, int y, int targ_x, int targ_y );

[56.2581002]

[56.2581128]

bool move_item_to_grid( int *const obj, const coord_def& p );
void move_item_stack_to_grid( const coord_def& from, const coord_def& to );

Replacement in crawl-ref/source/items.h at line 98 [56.2580284]

B:BD[56.2583183] → [316.2699:2769]

bool copy_item_to_grid( const item_def &item, int x_plos, int y_plos,

[56.2583183]

[62.341913]

bool copy_item_to_grid( const item_def &item, const coord_def& p,

Replacement in crawl-ref/source/items.cc at line 1633 [56.2584728]
B:BD[56.2617136] → [124.8006:8069]
```
// Moves mitm[obj] to (x,y)... will modify the value of obj to
```
[56.2617136]
[124.8069]
```
// Moves mitm[obj] to p... will modify the value of obj to
```
Replacement in crawl-ref/source/items.cc at line 1638 [56.2584728]
B:BD[56.2617371] → [315.366:421]
```
bool move_item_to_grid( int *const obj, int x, int y )
```
[56.2617371]
[56.2617426]
```
bool move_item_to_grid( int *const obj, const coord_def& p )
```
Insertion in crawl-ref/source/items.cc at line 1640 [56.2584728]
[56.2617428]
[123.10081]
```
    int& ob(*obj);
```
Replacement in crawl-ref/source/items.cc at line 1642 [56.2584728]
∅:D[123.10133] → [56.2617479:2617537]
B:BD[56.2617479] → [56.2617479:2617537]
```
    if (*obj == NON_ITEM || !is_valid_item( mitm[*obj] ))
```
[123.10133]
[315.422]
```
    if (ob == NON_ITEM || !is_valid_item( mitm[ob] ))
```
Insertion in crawl-ref/source/items.cc at line 1644 [56.2584728]
[315.446]
[56.2617553]
```
    item_def& item(mitm[ob]);
```
Replacement in crawl-ref/source/items.cc at line 1648 [56.2584728]
B:BD[56.2617589] → [56.2617589:2617630]
```
    if (is_stackable_item( mitm[*obj] ))
```
[56.2617589]
[56.2617630]
```
    if (is_stackable_item( item ))
```
Replacement in crawl-ref/source/items.cc at line 1651 [56.2584728]
B:BD[56.2617679] → [56.2617679:2617745]
```
        for (int i = igrd[x][y]; i != NON_ITEM; i = mitm[i].link)
```
[56.2617679]
[56.2617745]
```
        for (stack_iterator si(p); si; ++si)
```
Replacement in crawl-ref/source/items.cc at line 1654 [56.2584728]
∅:D[317.6658] → [56.2617831:2617858]
B:BD[56.2617831] → [56.2617831:2617858]
```
            if (*obj == i)
```
[317.6658]
[124.8128]
```
            if (ob == si->index())
```
Replacement in crawl-ref/source/items.cc at line 1657 [56.2584728]
B:BD[56.2617895] → [56.2617895:2617947]
```
            if (items_stack( mitm[*obj], mitm[i] ))
```
[56.2617895]
[56.2617947]
```
            if (items_stack( item, *si ))
```

Replacement in crawl-ref/source/items.cc at line 1661 [56.2584728]

B:BD[56.2618094] → [56.2618094:2618224]

                inc_mitm_item_quantity( i, mitm[*obj].quantity );
                destroy_item( *obj );
                *obj = i;

[56.2618094]

[315.492]

                inc_mitm_item_quantity( si->index(), item.quantity );
                destroy_item( ob );
                ob = si->index();

Replacement in crawl-ref/source/items.cc at line 1670 [56.2584728]

B:BD[3.324] → [3.324:467]

    else if (mitm[*obj].quantity > 1
             && (mitm[*obj].base_type != OBJ_FOOD
                 || mitm[*obj].sub_type != FOOD_CHUNK))

[3.324]

[318.20871]

    else if (item.quantity > 1
             && (item.base_type != OBJ_FOOD
                 || item.sub_type != FOOD_CHUNK))

Replacement in crawl-ref/source/items.cc at line 1674 [56.2584728]
B:BD[318.20877] → [318.20877:20917]
```
        while (mitm[*obj].quantity > 1)
```
[318.20877]
[318.20917]
```
        while (item.quantity > 1)
```

Replacement in crawl-ref/source/items.cc at line 1677 [56.2584728]

B:BD[318.20995] → [318.20995:21097]

            if (copy_item_to_grid(mitm[*obj], x, y, 1, false))
                --mitm[*obj].quantity;

[318.20995]

[318.21097]

            if (copy_item_to_grid(item, p, 1, false))
                --item.quantity;

Replacement in crawl-ref/source/items.cc at line 1680 [56.2584728]
B:BD[318.21114] → [318.21114:21155]
```
                mitm[*obj].quantity = 1;
```
[318.21114]
[56.2618262]
```
                item.quantity = 1;
```
Replacement in crawl-ref/source/items.cc at line 1684 [56.2584728]
B:BD[56.2618279] → [56.2618279:2618311]
```
    ASSERT( *obj != NON_ITEM );
```
[56.2618279]
[56.2618311]
```
    ASSERT( ob != NON_ITEM );
```
Replacement in crawl-ref/source/items.cc at line 1687 [56.2584728]
∅:D[124.8300] → [56.2618385:2618410]
B:BD[56.2618385] → [56.2618385:2618410]
```
    unlink_item( *obj );
```
[124.8300]
[56.2618410]
```
    unlink_item( ob );
```
Replacement in crawl-ref/source/items.cc at line 1690 [56.2584728]
∅:D[41.2785] → [56.2618438:2618482]
B:BD[56.2618438] → [56.2618438:2618482]
```
    mitm[*obj].x = x;
    mitm[*obj].y = y;
```
[41.2785]
[56.2618482]
```
    item.x = p.x;
    item.y = p.y;
```
Replacement in crawl-ref/source/items.cc at line 1694 [56.2584728]
∅:D[41.2819] → [56.2618516:2618573]
B:BD[56.2618516] → [56.2618516:2618573]
```
    mitm[*obj].link = igrd[x][y];
    igrd[x][y] = *obj;
```
[41.2819]
[319.13450]
```
    item.link = igrd(p);
    igrd(p) = ob;
```
Replacement in crawl-ref/source/items.cc at line 1697 [56.2584728]
B:BD[319.13451] → [320.6458:6487]
```
    if (is_rune(mitm[*obj]))
```
[319.13451]
[320.6487]
```
    if (is_rune(item))
```

Replacement in crawl-ref/source/items.cc at line 1700 [56.2584728]

B:BD[320.6543] → [320.6543:6612]

            you.attribute[ATTR_RUNES_IN_ZOT] += mitm[*obj].quantity;

[320.6543]

[320.6612]

            you.attribute[ATTR_RUNES_IN_ZOT] += item.quantity;

Replacement in crawl-ref/source/items.cc at line 1702 [56.2584728]

B:BD[320.6618] → [320.6618:6713]

    else if (mitm[*obj].base_type == OBJ_ORBS
             && you.level_type == LEVEL_DUNGEON)

[320.6618]

[320.6713]

    else if (item.base_type == OBJ_ORBS && you.level_type == LEVEL_DUNGEON)

Replacement in crawl-ref/source/items.cc at line 1710 [56.2584728]

B:BD[56.2618589] → [56.2618589:2618658]

void move_item_stack_to_grid( int x, int y, int targ_x, int targ_y )

[56.2618589]

[56.2618658]

void move_item_stack_to_grid( const coord_def& from, const coord_def& to )

Replacement in crawl-ref/source/items.cc at line 1712 [56.2584728]
B:BD[56.2618660] → [41.2820:2852]
```
    if (igrd[x][y] == NON_ITEM)
```
[56.2618660]
[41.2852]
```
    if (igrd(from) == NON_ITEM)
```
Replacement in crawl-ref/source/items.cc at line 1716 [56.2584728]
∅:D[124.8360] → [56.2618720:2618782]
B:BD[56.2618720] → [56.2618720:2618782]
```
    for (int o = igrd[x][y]; o != NON_ITEM; o = mitm[o].link)
```
[124.8360]
[56.2618782]
```
    for (stack_iterator si(from); si; ++si)
```

Replacement in crawl-ref/source/items.cc at line 1718 [56.2584728]

B:BD[56.2618788] → [56.2618788:2618844]

        mitm[o].x = targ_x;
        mitm[o].y = targ_y;

[56.2618788]

[41.2870]

        si->x = to.x;
        si->y = to.y;

Replacement in crawl-ref/source/items.cc at line 1722 [56.2584728]

B:BD[41.2934] → [41.2934:3008]

        if (mitm[o].link == NON_ITEM && igrd[targ_x][targ_y] != NON_ITEM)

[41.2934]

[41.3008]

        if (si->link == NON_ITEM && igrd(to) != NON_ITEM)

Replacement in crawl-ref/source/items.cc at line 1724 [56.2584728]
B:BD[41.3018] → [41.3018:3067]
```
            mitm[o].link = igrd[targ_x][targ_y];
```
[41.3018]
[41.3067]
```
            si->link = igrd(to);
```

Replacement in crawl-ref/source/items.cc at line 1729 [56.2584728]

B:BD[56.2618851] → [56.2618851:2618917]

    igrd[targ_x][targ_y] = igrd[x][y];
    igrd[x][y] = NON_ITEM;

[56.2618851]

[56.2618917]

    igrd(to) = igrd(from);
    igrd(from) = NON_ITEM;

Replacement in crawl-ref/source/items.cc at line 1735 [56.2584728]
∅:D[210.9883] → [124.8361:8431]
B:BD[56.2618949] → [124.8361:8431]
```
bool copy_item_to_grid( const item_def &item, int x_plos, int y_plos,
```
[210.9883]
[62.355178]
```
bool copy_item_to_grid( const item_def &item, const coord_def& p,
```

Replacement in crawl-ref/source/items.cc at line 1748 [56.2584728]

B:BD[56.2619305] → [56.2619305:2619381]

        for (int i = igrd[x_plos][y_plos]; i != NON_ITEM; i = mitm[i].link)

[56.2619305]

[56.2619381]

        for (stack_iterator si(p); si; ++si)

Replacement in crawl-ref/source/items.cc at line 1750 [56.2584728]
B:BD[56.2619391] → [56.2619391:2619437]
```
            if (items_stack( item, mitm[i] ))
```
[56.2619391]
[56.2619437]
```
            if (items_stack( item, *si ))
```

Replacement in crawl-ref/source/items.cc at line 1752 [56.2584728]

B:BD[56.2619451] → [293.21686:21743]

                inc_mitm_item_quantity( i, quant_drop );

[56.2619451]

[293.21743]

                inc_mitm_item_quantity( si->index(), quant_drop );

Replacement in crawl-ref/source/items.cc at line 1757 [56.2584728]

B:BD[293.21787] → [293.21787:21867]

                    drop_blood_potions_stack(help, quant_drop, x_plos, y_plos);

[293.21787]

[296.11998]

                    drop_blood_potions_stack(help, quant_drop, p);

Replacement in crawl-ref/source/items.cc at line 1762 [56.2584728]

B:BD[62.355391] → [62.355391:355505]

                if (mark_dropped && !mitm[i].slot)
                    mitm[i].slot = index_to_letter(item.link);

[62.355391]

[56.2619508]

                if (mark_dropped && !si->slot)
                    si->slot = index_to_letter(item.link);

Replacement in crawl-ref/source/items.cc at line 1770 [56.2584728]
∅:D[210.9993] → [56.2619631:2619699]
B:BD[56.2619631] → [56.2619631:2619699]
```
    int new_item = get_item_slot(10);
    if (new_item == NON_ITEM)
```
[210.9993]
[56.2619699]
```
    int new_item_idx = get_item_slot(10);
    if (new_item_idx == NON_ITEM)
```
Insertion in crawl-ref/source/items.cc at line 1773 [56.2584728]
[56.2619723]
[56.2619723]
```
    item_def& new_item = mitm[new_item_idx];
```
Replacement in crawl-ref/source/items.cc at line 1776 [56.2584728]
∅:D[210.10012] → [56.2619741:2619768]
B:BD[56.2619741] → [56.2619741:2619768]
```
    mitm[new_item] = item;
```
[210.10012]
[56.2619768]
```
    new_item = item;
```

Replacement in crawl-ref/source/items.cc at line 1779 [56.2584728]

∅:D[210.10064] → [56.2619819:2619949]

B:BD[56.2619819] → [56.2619819:2619949]

    mitm[new_item].quantity = quant_drop;
    mitm[new_item].x = 0;
    mitm[new_item].y = 0;
    mitm[new_item].link = NON_ITEM;

[210.10064]

[62.355506]

    new_item.quantity = quant_drop;
    new_item.x = 0;
    new_item.y = 0;
    new_item.link = NON_ITEM;

Replacement in crawl-ref/source/items.cc at line 1786 [56.2584728]

B:BD[62.355535] → [210.10065:10125]

∅:D[210.10125] → [62.355593:355733]

B:BD[62.355593] → [62.355593:355733]

        mitm[new_item].slot   = index_to_letter(item.link);
        mitm[new_item].flags |= ISFLAG_DROPPED;
        mitm[new_item].flags &= ~ISFLAG_THROWN;
        origin_set_unknown(mitm[new_item]);

[62.355535]

[62.355733]

        new_item.slot   = index_to_letter(item.link);
        new_item.flags |= ISFLAG_DROPPED;
        new_item.flags &= ~ISFLAG_THROWN;
        origin_set_unknown(new_item);

Replacement in crawl-ref/source/items.cc at line 1792 [56.2584728]
B:BD[56.2619950] → [56.2619950:2620002]
```
    move_item_to_grid( &new_item, x_plos, y_plos );
```
[56.2619950]
[321.3366]
```
    move_item_to_grid( &new_item_idx, p );
```
Replacement in crawl-ref/source/items.cc at line 1798 [56.2584728]
∅:D[210.10221] → [293.22162:22214]
B:BD[293.22162] → [293.22162:22214]
```
        remove_newest_blood_potion(mitm[new_item]);
```
[210.10221]
[293.22214]
```
        remove_newest_blood_potion(new_item);
```
Replacement in crawl-ref/source/items.cc at line 1821 [56.2584728]
B:BD[56.2620501] → [322.3715:3763]
```
    move_item_to_grid( &item, dest.x, dest.y );
```
[56.2620501]
[56.2620549]
```
    move_item_to_grid( &item, dest );
```

Replacement in crawl-ref/source/items.cc at line 1892 [56.2584728]

B:BD[56.2624633] → [57.6992:7060]

    const dungeon_feature_type my_grid = grd[you.x_pos][you.y_pos];

[56.2624633]

[60.636665]

    const dungeon_feature_type my_grid = grd(you.pos());

Replacement in crawl-ref/source/items.cc at line 1896 [56.2584728]

B:BD[323.4303] → [323.4303:4376]

                               you.x_pos, you.y_pos, quant_drop, true ))

[323.4303]

[324.1344]

                               you.pos(), quant_drop, true ))

Replacement in crawl-ref/source/item_use.h at line 169 [56.2777340]

B:BD[188.1900] → [188.1900:1978]

bool thrown_object_destroyed( item_def *item, int x, int y, bool returning );

[188.1900]

[60.728709]

bool thrown_object_destroyed( item_def *item, const coord_def& where,
                              bool returning );

Replacement in crawl-ref/source/item_use.cc at line 2583 [56.2781507]

B:BD[325.1919] → [46.3177:3252]

        hit = (affect(pbolt, pbolt.target_x, pbolt.target_y, &item) != 0);

[325.1919]

[326.685]

        hit = (affect(pbolt, pbolt.target(), &item) != 0);

Replacement in crawl-ref/source/item_use.cc at line 2585 [56.2781507]

B:BD[326.724] → [327.3776:3852]

            beam_drop_object(pbolt, &item, pbolt.target_x, pbolt.target_y);

[326.724]

[325.2063]

            beam_drop_object(pbolt, &item, pbolt.target());

Replacement in crawl-ref/source/item_use.cc at line 2596 [56.2781507]

B:BD[188.2281] → [328.3332:3478]

∅:D[328.3478] → [188.2425:2435]

B:BD[188.2425] → [188.2425:2435]

        if (did_return && thrown_object_destroyed(&item, pbolt.target_x,
                                                  pbolt.target_y, true))
        {

[188.2281]

[329.4945]

        if (did_return && thrown_object_destroyed(&item, pbolt.target(), true))

Deletion in crawl-ref/source/item_use.cc at line 2598 [56.2781507]
∅:D[329.4977] → [188.2466:2476]
B:BD[188.2466] → [188.2466:2476]
```
        }
```
Replacement in crawl-ref/source/item_use.cc at line 2632 [56.2781507]
B:BD[252.14412] → [58.3716:3756]
```
        noisy(6, you.x_pos, you.y_pos);
```
[252.14412]
[56.2830565]
```
        noisy(6, you.pos());
```

Replacement in crawl-ref/source/item_use.cc at line 2642 [56.2781507]

B:BD[188.2478] → [188.2478:2555]

bool thrown_object_destroyed( item_def *item, int x, int y, bool returning )

[188.2478]

[188.2555]

bool thrown_object_destroyed( item_def *item, const coord_def& where,
                              bool returning )

Replacement in crawl-ref/source/item_use.cc at line 2676 [56.2781507]
B:BD[188.3489] → [188.3489:3540]
```
    hostile_grid = grid_destroys_items(grd[x][y]);
```
[188.3489]
[188.3540]
```
    hostile_grid = grid_destroys_items(grd(where));
```

Replacement in crawl-ref/source/item_use.cc at line 2686 [56.2781507]

B:BD[188.3817] → [188.3817:3925]

        if (player_can_hear(x, y))
            mprf(MSGCH_SOUND, grid_item_destruction_message(grd[x][y]));

[188.3817]

[188.3925]

        if (player_can_hear(where))
            mprf(MSGCH_SOUND, grid_item_destruction_message(grd(where)));

Replacement in crawl-ref/source/item_use.cc at line 4367 [56.2781507]

B:BD[56.2861515] → [285.2923:2999]

        noisy(25, you.x_pos, you.y_pos, "You hear a loud clanging noise!");

[56.2861515]

[56.2861606]

        noisy(25, you.pos(), "You hear a loud clanging noise!");

Replacement in crawl-ref/source/it_use3.cc at line 243 [56.2870456]
B:BD[56.2877599] → [58.3833:3874]
```
        noisy(25, you.x_pos, you.y_pos);
```
[56.2877599]
[56.2877642]
```
        noisy(25, you.pos());
```

Replacement in crawl-ref/source/fight.cc at line 642 [56.3140790]

B:BD[226.4689] → [226.4689:4890]

        const coord_def atk_pos = attacker->pos();
        const coord_def def_pos = defender->pos();
        if (is_sanctuary(atk_pos.x, atk_pos.y)
            || is_sanctuary(def_pos.x, def_pos.y))

[226.4689]

[226.4890]

        if (is_sanctuary(attacker->pos()) || is_sanctuary(defender->pos()))

Replacement in crawl-ref/source/fight.cc at line 825 [56.3140790]

B:BD[330.1147] → [331.2985:3062]

            bleed_onto_floor(where.x, where.y, defender->id(), blood, true);

[330.1147]

[331.3062]

            bleed_onto_floor(where, defender->id(), blood, true);

Replacement in crawl-ref/source/fight.cc at line 2427 [56.3140790]

B:BD[189.3350] → [189.3350:3498]

            {
                bleed_onto_floor(pos.x, pos.y, defender->id(),
                                 def->hit_points, true);
            }

[189.3350]

[332.2858]

                bleed_onto_floor(pos, defender->id(), def->hit_points, true);

Replacement in crawl-ref/source/fight.cc at line 3121 [56.3140790]

B:BD[226.5158] → [226.5158:5273]

    if ((is_sanctuary(atk_pos.x, atk_pos.y)
         || is_sanctuary(def_pos.x, def_pos.y))
        && atk != def)

[226.5158]

[226.5273]

    if ((is_sanctuary(atk_pos) || is_sanctuary(def_pos)) && atk != def)

Replacement in crawl-ref/source/fight.cc at line 3944 [56.3140790]

B:BD[66.8487] → [189.3831:3898]

                bleed_onto_floor(pos.x, pos.y, type, blood, true);

[66.8487]

[189.3898]

                bleed_onto_floor(pos, type, blood, true);

Replacement in crawl-ref/source/externs.h at line 593 [56.3270163]
B:BD[56.3276051] → [179.2983:3021]
```
  int prev_move_x;
  int prev_move_y;
```
[56.3276051]
[179.3021]
```
  coord_def prev_move;
```
Deletion in crawl-ref/source/externs.h at line 789 [56.3270163]
B:BD[179.3024] → [179.3024:3057]
```
    coord_def prev_move() const;
```
Insertion in crawl-ref/source/externs.h at line 1319 [56.3270163]
[333.803]
[56.3281305]
```
    coord_def pos() const { return coord_def(x,y); }
```
Insertion in crawl-ref/source/externs.h at line 1331 [56.3270163]
[56.3281524]
[56.3281524]
```
    coord_def pos() const { return coord_def(x,y); }
```
Insertion in crawl-ref/source/externs.h at line 1339 [56.3270163]
[57.7352]
[67.3162]
```
    coord_def pos() const { return coord_def(x,y); }
```
Replacement in crawl-ref/source/effects.cc at line 1680 [56.3382105]
∅:D[53.3285] → [56.3424704:3424771]
∅:D[334.6681] → [56.3424704:3424771]
B:BD[56.3424704] → [56.3424704:3424771]
```
        move_item_to_grid( &thing_created, you.x_pos, you.y_pos );
```
[334.6681]
[56.3424771]
```
        move_item_to_grid( &thing_created, you.pos() );
```
Replacement in crawl-ref/source/effects.cc at line 1893 [56.3382105]
B:BD[335.1630] → [58.3901:3951]
```
        noisy(noise_level, you.x_pos, you.y_pos);
```
[335.1630]
[105.4116]
```
        noisy(noise_level, you.pos());
```
Replacement in crawl-ref/source/effects.cc at line 1929 [56.3382105]
B:BD[336.1484] → [58.3952:4002]
```
        noisy(noise_level, you.x_pos, you.y_pos);
```
[336.1484]
[60.947747]
```
        noisy(noise_level, you.pos());
```
Replacement in crawl-ref/source/effects.cc at line 2014 [56.3382105]
B:BD[56.3428044] → [58.4003:4040]
```
    noisy(10, you.x_pos, you.y_pos);
```
[56.3428044]
[56.3428103]
```
    noisy(10, you.pos());
```
Replacement in crawl-ref/source/effects.cc at line 2102 [56.3382105]
B:BD[337.719] → [338.2666:2710]
```
    if (is_sanctuary(you.x_pos, you.y_pos))
```
[337.719]
[338.2710]
```
    if (is_sanctuary(you.pos()))
```
Replacement in crawl-ref/source/effects.cc at line 2478 [56.3382105]
B:BD[337.12682] → [339.2671:2718]
```
        if (is_sanctuary(you.x_pos, you.y_pos)
```
[337.12682]
[339.2718]
```
        if (is_sanctuary(you.pos())
```
Replacement in crawl-ref/source/effects.cc at line 2893 [56.3382105]
∅:D[340.11024] → [174.4587:4623]
B:BD[174.4587] → [174.4587:4623]
```
          if (is_bloodcovered(x,y))
```
[340.11024]
[174.4623]
```
          if (is_bloodcovered(coord_def(x,y)))
```
Insertion in crawl-ref/source/effects.cc at line 2898 [56.3382105]
[174.4778]
[117.23693]
```
          {
```

Replacement in crawl-ref/source/effects.cc at line 2901 [56.3382105]

B:BD[174.4839] → [174.4839:5042]

                    if (is_bloodcovered(x+i,y+j)
                        && one_chance_in(5))
                    {
                        env.map[x+i][y+j].property = FPROP_NONE;
                    }

[174.4839]

[174.5042]

                   if (is_bloodcovered(coord_def(x+i,y+j))
                       && one_chance_in(5))
                   {
                       env.map[x+i][y+j].property = FPROP_NONE;
                   }

Replacement in crawl-ref/source/effects.cc at line 2907 [56.3382105]
B:BD[174.5059] → [300.8748:8749]
[174.5059]
[300.8749]
```
          }
```
Replacement in crawl-ref/source/directn.h at line 156 [56.3696722]
B:BD[62.450682] → [62.450682:450716]
```
bool in_los_bounds(int x, int y);
```
[56.3697569]
[62.450716]
```
bool in_los_bounds(const coord_def& p);
```
Insertion in crawl-ref/source/directn.h at line 159 [56.3696722]
[62.450782]
[62.450782]
```
bool in_los(const coord_def &pos);
```

Replacement in crawl-ref/source/directn.h at line 172 [56.3696722]

B:BD[56.3697902] → [312.4310:4379]

std::string feature_description(int mx, int my, bool bloody = false,

[56.3697902]

[153.34875]

std::string feature_description(const coord_def& where, bool bloody = false,

Replacement in crawl-ref/source/directn.cc at line 88 [56.3697945]

B:BD[56.3699345] → [126.14026:14127]

static void _describe_feature(int mx, int my, bool oos);
static void _describe_cell(int mx, int my);

[56.3699345]

[62.451608]

static void _describe_feature(const coord_def& where, bool oos);
static void _describe_cell(const coord_def& where);

Replacement in crawl-ref/source/directn.cc at line 91 [56.3697945]

B:BD[62.451609] → [126.14128:14368]

static bool _find_object(  int x, int y, int mode, bool need_path, int range );
static bool _find_monster( int x, int y, int mode, bool need_path, int range );
static bool _find_feature( int x, int y, int mode, bool need_path, int range );

[62.451609]

[341.1670]

static bool _find_object(  const coord_def& where, int mode, bool need_path, int range );
static bool _find_monster( const coord_def& where, int mode, bool need_path, int range );
static bool _find_feature( const coord_def& where, int mode, bool need_path, int range );

Replacement in crawl-ref/source/directn.cc at line 96 [56.3697945]

B:BD[342.6122] → [342.6122:6200]

static bool _find_mlist( int x, int y, int mode, bool need_path, int range );

[342.6122]

[342.6200]

static bool _find_mlist( const coord_def& where, int mode, bool need_path, int range );

Replacement in crawl-ref/source/directn.cc at line 99 [56.3697945]
∅:D[342.6208] → [126.14369:14419]
B:BD[341.1671] → [126.14369:14419]
```
static char _find_square_wrapper( int tx, int ty,
```
[342.6208]
[126.14419]
```
static char _find_square_wrapper( const coord_def& targ,
```

Replacement in crawl-ref/source/directn.cc at line 101 [56.3697945]

B:BD[126.14496] → [126.14496:14570]

                                  bool (*targ)(int, int, int, bool, int),

[126.14496]

[126.14570]

                                  bool (*targ)(const coord_def&, int, bool, int),

Replacement in crawl-ref/source/directn.cc at line 106 [56.3697945]
B:BD[341.2019] → [126.14773:14817]
```
static char _find_square( int xps, int yps,
```
[341.2019]
[126.14817]
```
static char _find_square( const coord_def& where,
```

Replacement in crawl-ref/source/directn.cc at line 108 [56.3697945]

B:BD[126.14885] → [126.14885:14951]

                          bool (*targ)(int, int, int, bool, int),

[126.14885]

[126.14951]

                          bool (*targ)(const coord_def&, int, bool, int),

Replacement in crawl-ref/source/directn.cc at line 113 [56.3697945]
B:BD[126.15159] → [126.15159:15207]
```
static void _describe_oos_square(int x, int y);
```
[126.15159]
[126.15207]
```
static void _describe_oos_square(const coord_def& where);
```

Replacement in crawl-ref/source/directn.cc at line 295 [56.3697945]

B:BD[343.17721] → [344.3810:3867]

static bool _is_target_in_range(int x, int y, int range)

[343.17721]

[344.3867]

static bool _is_target_in_range(const coord_def& where, int range)

Replacement in crawl-ref/source/directn.cc at line 301 [56.3697945]
∅:D[116.7603] → [344.3948:4013]
B:BD[344.3948] → [344.3948:4013]
```
    return (grid_distance(you.x_pos, you.y_pos, x, y) <= range);
```
[116.7603]
[344.4013]
```
    return (grid_distance(you.pos(), where) <= range);
```

Replacement in crawl-ref/source/directn.cc at line 385 [56.3697945]

B:BD[343.20311] → [344.4097:4223]

        else if (!_is_target_in_range(you.prev_grd_targ.x, you.prev_grd_targ.y,
                                      range))

[343.20311]

[344.4223]

        else if (!_is_target_in_range(you.prev_grd_targ, range))

Replacement in crawl-ref/source/directn.cc at line 398 [56.3697945]

B:BD[343.20414] → [343.20414:20511]

        find_ray(you.x_pos, you.y_pos, moves.tx, moves.ty, true, ray,
                 0, true);

[343.20414]

[343.20511]

        find_ray(you.pos(), moves.target(), true, ray, 0, true);

Replacement in crawl-ref/source/directn.cc at line 424 [56.3697945]

B:BD[343.21137] → [344.4530:4656]

        else if (!_is_target_in_range(you.prev_grd_targ.x, you.prev_grd_targ.y,
                                      range))

[343.21137]

[344.4656]

        else if (!_is_target_in_range(you.prev_grd_targ, range))

Replacement in crawl-ref/source/directn.cc at line 437 [56.3697945]

B:BD[343.21226] → [343.21226:21323]

        find_ray(you.x_pos, you.y_pos, moves.tx, moves.ty, true, ray,
                 0, true);

[343.21226]

[343.21323]

        find_ray(you.pos(), moves.target(), true, ray, 0, true);

Replacement in crawl-ref/source/directn.cc at line 559 [56.3697945]
∅:D[345.11955] → [346.324:395]
B:BD[346.324] → [346.324:395]
```
        find_ray(you.x_pos, you.y_pos, moves.tx, moves.ty, true, ray);
```
[345.11955]
[347.160]
```
        find_ray(you.pos(), moves.target(), true, ray);
```

Replacement in crawl-ref/source/directn.cc at line 574 [56.3697945]

B:BD[218.11332] → [218.11332:11407]

                && _is_target_in_range(montarget->x, montarget->y, range))

[218.11332]

[348.778]

                && _is_target_in_range(montarget->pos(), range))

Replacement in crawl-ref/source/directn.cc at line 688 [56.3697945]

B:BD[342.7258] → [342.7258:7332]

            if (_find_square_wrapper(moves.tx, moves.ty, monsfind_pos, 1,

[342.7258]

[342.7332]

            if (_find_square_wrapper(moves.target(), monsfind_pos, 1,

Replacement in crawl-ref/source/directn.cc at line 784 [56.3697945]

B:BD[77.2904] → [77.2904:2979]

            show_beam = find_ray(you.x_pos, you.y_pos, moves.tx, moves.ty,

[77.2904]

[77.2979]

            show_beam = find_ray(you.pos(), moves.target(),

Replacement in crawl-ref/source/directn.cc at line 805 [56.3697945]
∅:D[349.734] → [70.8022:8101]
∅:D[116.7784] → [70.8022:8101]
B:BD[70.8022] → [70.8022:8101]
```
                show_beam = find_ray(you.x_pos, you.y_pos, moves.tx, moves.ty,
```
[116.7784]
[70.8101]
```
                show_beam = find_ray(you.pos(), moves.target(),
```

Replacement in crawl-ref/source/directn.cc at line 825 [56.3697945]

B:BD[126.15634] → [126.15634:15707]

            if (_find_square_wrapper(moves.tx, moves.ty, objfind_pos, 1,

[126.15634]

[126.15707]

            if (_find_square_wrapper(moves.target(), objfind_pos, 1,

Replacement in crawl-ref/source/directn.cc at line 924 [56.3697945]

B:BD[341.9483] → [126.15864:15940]

            if (_find_square_wrapper( moves.tx, moves.ty, objfind_pos, dir,

[341.9483]

[126.15940]

            if (_find_square_wrapper( moves.target(), objfind_pos, dir,

Replacement in crawl-ref/source/directn.cc at line 941 [56.3697945]

B:BD[341.10205] → [126.16226:16303]

            if (_find_square_wrapper( moves.tx, moves.ty, monsfind_pos, dir,

[341.10205]

[126.16303]

            if (_find_square_wrapper( moves.target(), monsfind_pos, dir,

Replacement in crawl-ref/source/directn.cc at line 1131 [56.3697945]

B:BD[77.3546] → [109.11220:11375]

            show_beam = show_beam && find_ray(you.x_pos, you.y_pos, moves.tx,
                                              moves.ty, true, ray, 0, true);

[77.3546]

[56.3704179]

            show_beam = show_beam && find_ray(you.pos(), moves.target(),
                                              true, ray, 0, true);

Replacement in crawl-ref/source/directn.cc at line 1153 [56.3697945]

B:BD[81.6382] → [81.6382:6461]

            || show_beam && find_ray(you.x_pos, you.y_pos, moves.tx, moves.ty,

[81.6382]

[81.6461]

            || show_beam && find_ray(you.pos(), moves.target(),

Replacement in crawl-ref/source/directn.cc at line 1173 [56.3697945]

B:BD[350.2089] → [351.3421:3484]

                        if (!in_los(raycopy.x(), raycopy.y()))

[350.2089]

[77.4329]

                        if (!in_los(raycopy.pos()))

Replacement in crawl-ref/source/directn.cc at line 1204 [56.3697945]
B:BD[352.9654] → [352.9654:9683]
B:BD[352.9683] → [126.16545:16585]
```
    if (!see_grid(c.x, c.y))
        _describe_oos_square(c.x, c.y);
```
[352.9654]
[352.9722]
```
    if (!see_grid(c))
        _describe_oos_square(c);
```
Replacement in crawl-ref/source/directn.cc at line 1207 [56.3697945]
B:BD[352.9750] → [126.16586:16620]
```
        _describe_cell(c.x, c.y);
```
[352.9750]
[352.9783]
```
        _describe_cell(c);
```
Replacement in crawl-ref/source/directn.cc at line 1272 [56.3697945]
B:BD[62.452939] → [126.16850:16897]
```
static void _describe_oos_square(int x, int y)
```
[62.452939]
[62.452985]
```
static void _describe_oos_square(const coord_def& where)
```
Replacement in crawl-ref/source/directn.cc at line 1276 [56.3697945]
∅:D[116.7881] → [64.18314:18366]
B:BD[353.2428] → [64.18314:18366]
```
    if (!in_bounds(x, y) || !is_terrain_seen(x, y))
```
[116.7881]
[62.453013]
```
    if (!in_bounds(where) || !is_terrain_seen(where))
```
Replacement in crawl-ref/source/directn.cc at line 1279 [56.3697945]
B:BD[62.453052] → [62.453052:453078]
B:BD[62.453078] → [126.16898:16933]
```
    describe_stash(x, y);
    _describe_feature(x, y, true);
```
[62.453030]
[62.453119]
```
    describe_stash(where.x, where.y);
    _describe_feature(where, true);
```

Replacement in crawl-ref/source/directn.cc at line 1285 [56.3697945]

B:BD[62.457889] → [354.11638:11785]

    return (in_los_bounds(x, y)
            && (env.show(view2show(coord_def(x, y)))
                || coord_def(x, y) == grid2view(you.pos())));

[62.457889]

[62.457968]

    return in_vlos(coord_def(x,y));

Replacement in crawl-ref/source/directn.cc at line 1290 [56.3697945]

B:BD[75.2056] → [75.2056:2092]

    return (in_vlos(pos.x, pos.y));

[75.2056]

[75.2092]

    return (in_los_bounds(pos) && (env.show(view2show(pos))
                                   || pos == grid2view(you.pos())));

Replacement in crawl-ref/source/directn.cc at line 1296 [56.3697945]

B:BD[62.457999] → [88.16890:16940]

    return (in_vlos(grid2view(coord_def(x, y))));

[62.457999]

[355.3452]

    return in_los(coord_def(x,y));
}
bool in_los(const coord_def& pos)
{
    return (in_vlos(grid2view(pos)));

Replacement in crawl-ref/source/directn.cc at line 1329 [56.3697945]

B:BD[342.8458] → [342.8458:8538]

static bool _find_mlist( int x, int y, int idx, bool need_path, int range = -1)

[342.8458]

[342.8538]

static bool _find_mlist( const coord_def& where, int idx, bool need_path, int range = -1)

Replacement in crawl-ref/source/directn.cc at line 1334 [56.3697945]

B:BD[342.8600] → [342.8600:8659]

    if (!_is_target_in_range(x, y, range) || !in_los(x,y))

[342.8600]

[342.8659]

    if (!_is_target_in_range(where, range) || !in_los(where))

Replacement in crawl-ref/source/directn.cc at line 1337 [56.3697945]
B:BD[342.8684] → [342.8684:8725]
```
    const int targ_mon = mgrd[ x ][ y ];
```
[342.8684]
[342.8725]
```
    const int targ_mon = mgrd(where);
```

Replacement in crawl-ref/source/directn.cc at line 1388 [56.3697945]

B:BD[62.458211] → [126.16934:17001]

static bool _find_monster( int x, int y, int mode, bool need_path,

[62.458211]

[126.17001]

static bool _find_monster( const coord_def& where, int mode, bool need_path,

Replacement in crawl-ref/source/directn.cc at line 1392 [56.3697945]
∅:D[356.5606] → [357.1591:1641]
∅:D[354.11843] → [357.1591:1641]
B:BD[62.458305] → [357.1591:1641]
B:BD[357.1641] → [344.5572:5624]
```
    if ((mode == TARG_FRIEND || mode == TARG_ANY)
         && x == you.x_pos && y == you.y_pos)
    {
```
[356.5606]
[357.1690]
```
    if ((mode == TARG_FRIEND || mode == TARG_ANY) && where == you.pos())
```
Deletion in crawl-ref/source/directn.cc at line 1394 [56.3697945]
B:BD[357.1713] → [344.5625:5631]
```
    }
```
Replacement in crawl-ref/source/directn.cc at line 1396 [56.3697945]
∅:D[356.5641] → [344.5665:5708]
B:BD[344.5665] → [344.5665:5708]
```
    if (!_is_target_in_range(x, y, range))
```
[356.5641]
[344.5708]
```
    if (!_is_target_in_range(where, range))
```
Replacement in crawl-ref/source/directn.cc at line 1399 [56.3697945]
∅:D[354.11847] → [344.5741:5782]
B:BD[344.5741] → [344.5741:5782]
```
    const int targ_mon = mgrd[ x ][ y ];
```
[354.11847]
[354.11848]
```
    const int targ_mon = mgrd(where);
```
Replacement in crawl-ref/source/directn.cc at line 1402 [56.3697945]
B:BD[358.2826] → [358.2826:2875]
```
    if (targ_mon == NON_MONSTER || !in_los(x,y))
```
[358.2826]
[345.12682]
```
    if (targ_mon == NON_MONSTER || !in_los(where))
```
Replacement in crawl-ref/source/directn.cc at line 1406 [56.3697945]
B:BD[345.12774] → [345.12774:12820]
```
    if (need_path && !see_grid_no_trans(x,y))
```
[345.12774]
[358.2875]
```
    if (need_path && !see_grid_no_trans(where))
```
Replacement in crawl-ref/source/directn.cc at line 1430 [56.3697945]
B:BD[62.458804] → [126.17045:17096]
```
static bool _find_feature( int x, int y, int mode,
```
[62.458804]
[126.17096]
```
static bool _find_feature( const coord_def& where, int mode,
```

Replacement in crawl-ref/source/directn.cc at line 1434 [56.3697945]

B:BD[62.458918] → [64.18367:18441]

    if (!in_los(x, y) && (!Options.target_oos || !is_terrain_seen(x, y)))

[62.458918]

[62.458986]

    if (!in_los(where) && (!Options.target_oos || !is_terrain_seen(where)))

Replacement in crawl-ref/source/directn.cc at line 1437 [56.3697945]
B:BD[62.459011] → [62.459011:459046]
```
    return is_feature(mode, x, y);
```
[62.459011]
[62.459046]
```
    return is_feature(mode, where);
```
Replacement in crawl-ref/source/directn.cc at line 1440 [56.3697945]
B:BD[62.459049] → [126.17163:17212]
```
static bool _find_object(int x, int y, int mode,
```
[62.459049]
[126.17212]
```
static bool _find_object(const coord_def& where, int mode,
```
Replacement in crawl-ref/source/directn.cc at line 1445 [56.3697945]
B:BD[344.6667] → [344.6667:6704]
```
    const int mons = mgrd[ x ][ y ];
```
[344.6667]
[344.6704]
```
    const int mons = mgrd(where);
```
Replacement in crawl-ref/source/directn.cc at line 1454 [56.3697945]
∅:D[344.6916] → [62.459099:459132]
∅:D[116.7889] → [62.459099:459132]
B:BD[62.459099] → [62.459099:459132]
```
    const int item = igrd[x][y];
```
[116.7889]
[344.6917]
```
    const int item = igrd(where);
```

Replacement in crawl-ref/source/directn.cc at line 1458 [56.3697945]

∅:D[116.7891] → [344.6987:7121]

B:BD[344.6987] → [344.6987:7121]

    return (in_los(x, y) || Options.target_oos && is_terrain_seen(x, y)
                            && (is_stash(x, y) || is_mimic));

[116.7891]

[62.459399]

    return (in_los(where) || Options.target_oos && is_terrain_seen(where)
            && (is_stash(where.x,where.y) || is_mimic));

Replacement in crawl-ref/source/directn.cc at line 1513 [56.3697945]
B:BD[62.460794] → [62.460794:460827]
```
bool in_los_bounds(int x, int y)
```
[62.460794]
[62.460827]
```
bool in_los_bounds(const coord_def& p)
```
Replacement in crawl-ref/source/directn.cc at line 1515 [56.3697945]
B:BD[62.460829] → [88.16999:17051]
```
    return crawl_view.in_view_los(coord_def(x, y));
```
[62.460829]
[62.460879]
```
    return crawl_view.in_view_los(p);
```
Replacement in crawl-ref/source/directn.cc at line 1532 [56.3697945]
B:BD[56.3713019] → [126.17328:17372]
```
static char _find_square( int xps, int yps,
```
[56.3713019]
[126.17372]
```
static char _find_square( const coord_def& where,
```

Replacement in crawl-ref/source/directn.cc at line 1534 [56.3697945]

B:BD[126.17440] → [126.17440:17509]

                          bool (*find_targ)( int x, int y, int mode,

[126.17440]

[126.17509]

                          bool (*find_targ)( const coord_def& wh, int mode,

Replacement in crawl-ref/source/directn.cc at line 1542 [56.3697945]
∅:D[341.12709] → [62.461516:461564]
B:BD[56.3713159] → [62.461516:461564]
```
    int temp_xps = xps;
    int temp_yps = yps;
```
[341.12709]
[88.17163]
```
    int temp_xps = where.x;
    int temp_yps = where.y;
```
Replacement in crawl-ref/source/directn.cc at line 1556 [56.3697945]
B:BD[56.3713487] → [62.461708:461745]
```
        if (in_los_bounds(xps, yps))
```
[56.3713487]
[62.461745]
```
        if (in_los_bounds(where))
```

Replacement in crawl-ref/source/directn.cc at line 1560 [56.3697945]

B:BD[62.461877] → [88.17208:17358]

            const bool vis = (env.show(view2show(coord_def(xps, yps)))
                              || view2grid(coord_def(xps, yps)) == you.pos());

[62.461877]

[116.8297]

            const bool vis = (env.show(view2show(where))
                              || view2grid(where) == you.pos());

Replacement in crawl-ref/source/directn.cc at line 1601 [56.3697945]

B:BD[62.462934] → [345.13299:13372]

            if (find_targ(you.x_pos, you.y_pos, mode, need_path, range))

[62.462934]

[359.927]

            if (find_targ(you.pos(), mode, need_path, range))

Replacement in crawl-ref/source/directn.cc at line 1607 [56.3697945]

B:BD[359.1049] → [126.17694:17828]

            return _find_square(ctrx, ctry, mfp, direction, find_targ,
                                need_path, mode, range, false,

[359.1049]

[126.17828]

            return _find_square(coord_def(ctrx, ctry), mfp, direction,
                                find_targ, need_path, mode, range, false,

Replacement in crawl-ref/source/directn.cc at line 1613 [56.3697945]

B:BD[92.24551] → [126.17895:18029]

            return _find_square(minx, maxy, mfp, direction, find_targ,
                                need_path, mode, range, false,

[92.24551]

[126.18029]

            return _find_square(coord_def(minx, maxy), mfp, direction,
                                find_targ, need_path, mode, range, false,

Replacement in crawl-ref/source/directn.cc at line 1739 [56.3697945]

B:BD[56.3717592] → [345.13767:13830]

        if (find_targ(targ_x, targ_y, mode, need_path, range))

[56.3717592]

[88.17930]

        if (find_targ(coord_def(targ_x, targ_y), mode, need_path, range))

Replacement in crawl-ref/source/directn.cc at line 1748 [56.3697945]

B:BD[62.464753] → [126.18096:18388]

        _find_square(ctrx, ctry, mfp, direction, find_targ, need_path, mode,
                     range, false, _next_los(direction, los, wrap))
      : _find_square(minx, maxy, mfp, direction, find_targ, need_path, mode,
                     range, false, _next_los(direction, los, wrap)));

[62.464753]

[341.12835]

      _find_square(coord_def(ctrx, ctry), mfp, direction, find_targ, need_path,
                   mode, range, false, _next_los(direction, los, wrap))
      : _find_square(coord_def(minx, maxy), mfp, direction, find_targ,
                     need_path, mode, range, false,
                     _next_los(direction, los, wrap)));

Replacement in crawl-ref/source/directn.cc at line 1758 [56.3697945]
B:BD[360.1118] → [126.18389:18439]
```
static char _find_square_wrapper( int tx, int ty,
```
[360.1118]
[126.18439]
```
static char _find_square_wrapper( const coord_def& targ,
```

Replacement in crawl-ref/source/directn.cc at line 1760 [56.3697945]

B:BD[126.18516] → [126.18516:18592]

                                  bool (*find_targ)(int x, int y, int mode,

[126.18516]

[126.18592]

                                  bool (*find_targ)(const coord_def& where, int mode,

Replacement in crawl-ref/source/directn.cc at line 1765 [56.3697945]

B:BD[341.13186] → [126.18799:18869]

    const char r =  _find_square(grid2viewX(tx), grid2viewY(ty), mfp,

[341.13186]

[126.18869]

    const char r =  _find_square(grid2view(targ), mfp,

Replacement in crawl-ref/source/directn.cc at line 1773 [56.3697945]
B:BD[62.465326] → [126.18994:19050]
```
static void _describe_feature(int mx, int my, bool oos)
```
[62.465326]
[62.466040]
```
static void _describe_feature(const coord_def& where, bool oos)
```
Replacement in crawl-ref/source/directn.cc at line 1775 [56.3697945]
B:BD[62.466042] → [60.979950:979991]
```
    if (oos && !is_terrain_seen(mx, my))
```
[62.466042]
[62.466080]
```
    if (oos && !is_terrain_seen(where))
```
Replacement in crawl-ref/source/directn.cc at line 1778 [56.3697945]
B:BD[62.466240] → [361.2671:2716]
```
    dungeon_feature_type grid = grd[mx][my];
```
[62.466240]
[113.4916]
```
    dungeon_feature_type grid = grd(where);
```
Replacement in crawl-ref/source/directn.cc at line 1780 [56.3697945]
B:BD[113.4952] → [113.4952:5004]
```
        grid = grid_secret_door_appearance(mx, my);
```
[113.4952]
[116.8301]
```
        grid = grid_secret_door_appearance(where);
```

Replacement in crawl-ref/source/directn.cc at line 1838 [56.3697945]

B:BD[362.5498] → [312.4523:4646]

    feat = feature_description(you.x_pos, you.y_pos,
                               is_bloodcovered(you.x_pos, you.y_pos),

[362.5498]

[312.4646]

    feat = feature_description(you.pos(), is_bloodcovered(you.pos()),

Replacement in crawl-ref/source/directn.cc at line 2156 [56.3697945]

B:BD[60.980767] → [312.4822:4883]

std::string feature_description(int mx, int my, bool bloody,

[60.980767]

[312.4883]

std::string feature_description(const coord_def& where, bool bloody,

Replacement in crawl-ref/source/directn.cc at line 2159 [56.3697945]
B:BD[60.980817] → [112.484:529]
```
    dungeon_feature_type grid = grd[mx][my];
```
[60.980817]
[112.529]
```
    dungeon_feature_type grid = grd(where);
```

Replacement in crawl-ref/source/directn.cc at line 2161 [56.3697945]

B:BD[112.565] → [112.565:617]

        grid = grid_secret_door_appearance(mx, my);

[112.565]

[112.617]

        grid = grid_secret_door_appearance(where);

Replacement in crawl-ref/source/directn.cc at line 2166 [56.3697945]

B:BD[111.3848] → [111.3848:3924]

        find_connected_identical(coord_def(mx, my), grd[mx][my], all_door);

[111.3848]

[111.3924]

        find_connected_identical(where, grd(where), all_door);

Replacement in crawl-ref/source/directn.cc at line 2185 [56.3697945]

B:BD[181.23242] → [312.4961:5036]

        return (feature_description(grid, trap_type_at_xy(mx, my), bloody,

[181.23242]

[153.40842]

        return (feature_description(grid, trap_type_at_xy(where), bloody,

Replacement in crawl-ref/source/directn.cc at line 2188 [56.3697945]
B:BD[60.982305] → [153.40898:40944]
```
        return (shop_name(mx, my, add_stop));
```
[60.982305]
[311.8903]
```
        return (shop_name(where, add_stop));
```

Replacement in crawl-ref/source/directn.cc at line 2193 [56.3697945]

B:BD[311.9018] → [126.19722:19792]

                    _marker_feature_description(coord_def(mx, my))));

[311.9018]

[60.982341]

                    _marker_feature_description(where)));

Replacement in crawl-ref/source/directn.cc at line 2510 [56.3697945]
B:BD[363.5280] → [126.20313:20356]
```
static void _describe_cell(int mx, int my)
```
[363.5280]
[62.473931]
```
static void _describe_cell(const coord_def& where)
```
Replacement in crawl-ref/source/directn.cc at line 2517 [56.3697945]
B:BD[359.1204] → [359.1204:1248]
```
    if (mx == you.x_pos && my == you.y_pos)
```
[359.1204]
[364.1442]
```
    if (where == you.pos())
```
Replacement in crawl-ref/source/directn.cc at line 2520 [56.3697945]
∅:D[359.1270] → [56.3718338:3718375]
∅:D[365.38587] → [56.3718338:3718375]
B:BD[56.3718338] → [56.3718338:3718375]
```
    if (mgrd[mx][my] != NON_MONSTER)
```
[359.1270]
[56.3718375]
```
    if (mgrd(where) != NON_MONSTER)
```
Replacement in crawl-ref/source/directn.cc at line 2522 [56.3697945]
B:BD[56.3718381] → [56.3718381:3718411]
```
        int i = mgrd[mx][my];
```
[56.3718381]
[56.3718411]
```
        int i = mgrd(where);
```
Replacement in crawl-ref/source/directn.cc at line 2568 [56.3697945]
B:BD[65.17402] → [65.17402:17432]
```
    if (is_sanctuary(mx, my))
```
[65.17402]
[65.17432]
```
    if (is_sanctuary(where))
```
Replacement in crawl-ref/source/directn.cc at line 2571 [56.3697945]
∅:D[65.17486] → [56.3723654:3723696]
B:BD[56.3723654] → [56.3723654:3723696]
```
    if (env.cgrid[mx][my] != EMPTY_CLOUD)
```
[65.17486]
[56.3723696]
```
    if (env.cgrid(where) != EMPTY_CLOUD)
```

Replacement in crawl-ref/source/directn.cc at line 2573 [56.3697945]

B:BD[56.3723702] → [366.234:289]

        const int cloud_inspected = env.cgrid[mx][my];

[56.3723702]

[348.2152]

        const int cloud_inspected = env.cgrid(where);

Replacement in crawl-ref/source/directn.cc at line 2582 [56.3697945]
B:BD[56.3725115] → [56.3725115:3725153]
```
    int targ_item = igrd[ mx ][ my ];
```
[56.3725115]
[56.3725153]
```
    int targ_item = igrd(where);
```
Replacement in crawl-ref/source/directn.cc at line 2609 [56.3697945]
B:BD[312.5143] → [312.5143:5176]
```
    if (is_bloodcovered(mx, my))
```
[312.5143]
[312.5176]
```
    if (is_bloodcovered(where))
```

Replacement in crawl-ref/source/directn.cc at line 2612 [56.3697945]

B:BD[312.5200] → [312.5200:5268]

    std::string feature_desc = feature_description(mx, my, bloody);

[312.5200]

[367.1808]

    std::string feature_desc = feature_description(where, bloody);

Replacement in crawl-ref/source/directn.cc at line 2615 [56.3697945]

B:BD[368.20897] → [369.6739:6812]

    if (map_marker *mark = env.markers.find(coord_def(mx, my), MAT_ANY))

[368.20897]

[180.24537]

    if (map_marker *mark = env.markers.find(where, MAT_ANY))

Replacement in crawl-ref/source/directn.cc at line 2622 [56.3697945]

∅:D[180.24680] → [370.4386:4421]

B:BD[368.21017] → [370.4386:4421]

B:BD[370.4421] → [126.20395:20454]

∅:D[126.20454] → [371.1074:1125]

B:BD[370.4479] → [371.1074:1125]

B:BD[371.1125] → [364.1692:1760]

∅:D[371.1174] → [372.2262:2322]

∅:D[364.1760] → [372.2262:2322]

∅:D[370.4520] → [372.2262:2322]

∅:D[368.21056] → [372.2262:2322]

B:BD[372.2262] → [372.2262:2322]

    const std::string traveldest =
        _stair_destination_description(coord_def(mx, my));
    const dungeon_feature_type feat = grd[mx][my];
    mprf(MSGCH_DIAGNOSTICS, "(%d,%d): %s - %s (%d/%s)%s%s", mx, my,
         stringize_glyph(get_screen_glyph(mx, my)).c_str(),

[180.24680]

[368.21057]

    const std::string traveldest = _stair_destination_description(where);
    const dungeon_feature_type feat = grd(where);
    mprf(MSGCH_DIAGNOSTICS, "(%d,%d): %s - %s (%d/%s)%s%s", where.x, where.y,
         stringize_glyph(get_screen_glyph(where)).c_str(),

Replacement in crawl-ref/source/directn.cc at line 2643 [56.3697945]

B:BD[364.1767] → [373.826:881]

        const dungeon_feature_type feat = grd[mx][my];

[364.1767]

[116.8440]

        const dungeon_feature_type feat = grd(where);

Replacement in crawl-ref/source/describe.cc at line 1937 [56.3736416]
B:BD[374.5075] → [374.5075:5125]
```
    std::string desc = feature_description(x, y);
```
[374.5075]
[374.5125]
```
    std::string desc = feature_description(coord_def(x, y));
```

Replacement in crawl-ref/source/delay.cc at line 483 [56.3963459]

B:BD[321.14538] → [321.14538:14655]

            bleed_onto_floor(you.x_pos, you.y_pos, corpse.plus, delay.duration,
                             false);

[321.14538]

[123.13752]

            bleed_onto_floor(you.pos(), corpse.plus, delay.duration, false);

Replacement in crawl-ref/source/delay.cc at line 1051 [56.3963459]

B:BD[56.3970198] → [375.5910:5990]

        const int pass_x = delay.parm1;
        const int pass_y = delay.parm2;

[56.3970198]

[60.1003982]

        const coord_def pass(delay.parm1, delay.parm2);

Replacement in crawl-ref/source/delay.cc at line 1053 [56.3963459]
B:BD[60.1003983] → [375.5991:6031]
```
        if (pass_x != 0 && pass_y != 0)
```
[60.1003983]
[375.6031]
```
        if (pass.x != 0 && pass.y != 0)
```
Replacement in crawl-ref/source/delay.cc at line 1056 [56.3963459]
B:BD[60.1004213] → [375.6042:6087]
```
            switch (grd[ pass_x ][ pass_y ])
```
[60.1004213]
[375.6087]
```
            switch (grd(pass))
```

Replacement in crawl-ref/source/delay.cc at line 1059 [56.3963459]

B:BD[376.3959] → [376.3959:4028]

                if (!you.can_pass_through_feat(grd[pass_x][pass_y]))

[376.3959]

[376.4028]

                if (!you.can_pass_through_feat(grd(pass)))

Replacement in crawl-ref/source/delay.cc at line 1065 [56.3963459]

B:BD[375.6560] → [375.6560:6618]

                grd[ pass_x ][ pass_y ] = DNGN_OPEN_DOOR;

[375.6560]

[375.6618]

                grd(pass) = DNGN_OPEN_DOOR;

Replacement in crawl-ref/source/delay.cc at line 1070 [56.3963459]
∅:D[298.9476] → [375.6736:6784]
B:BD[375.6736] → [375.6736:6784]
```
            int mon = mgrd[ pass_x ][ pass_y ];
```
[298.9476]
[375.6784]
```
            int mon = mgrd(pass);
```
Insertion in crawl-ref/source/delay.cc at line 1073 [56.3963459]
[60.1005334]
[298.9477]
```
                monsters* m = &menv[mon];
```

Replacement in crawl-ref/source/delay.cc at line 1075 [56.3963459]

∅:D[298.9535] → [377.3081:3128]

B:BD[375.6879] → [377.3081:3128]

∅:D[377.3128] → [375.6927:7078]

B:BD[375.6927] → [375.6927:7078]

                if (!shift_monster(&menv[mon])
                    && !monster_blink(&menv[mon]))
                {
                    monster_teleport( &menv[mon], true, true );
                }

[298.9535]

[60.1005417]

                if (!shift_monster(m) && !monster_blink(m))
                    monster_teleport( m, true, true );

Replacement in crawl-ref/source/delay.cc at line 1079 [56.3963459]

B:BD[60.1005451] → [375.7079:7147]

            move_player_to_grid(pass_x, pass_y, false, true, true);

[60.1005451]

[375.7147]

            move_player_to_grid(pass, false, true, true);

Replacement in crawl-ref/source/delay.cc at line 1216 [56.3963459]

∅:D[377.3338] → [375.8358:8425]

B:BD[375.8358] → [375.8358:8425]

                                you.x_pos, you.y_pos, delay.parm2,

[377.3338]

[375.8425]

                                you.pos(), delay.parm2,

Replacement in crawl-ref/source/delay.cc at line 1771 [56.3963459]
B:BD[65.17928] → [65.17928:17976]
```
        if (is_sanctuary(you.x_pos, you.y_pos))
```
[65.17928]
[65.17976]
```
        if (is_sanctuary(you.pos()))
```

Replacement in crawl-ref/source/decks.cc at line 1388 [56.3987460]

B:BD[104.4756] → [104.4756:4822]

                int net = get_trapping_net(you.x_pos, you.y_pos);

[104.4756]

[104.4822]

                int net = get_trapping_net(you.pos());

Replacement in crawl-ref/source/decks.cc at line 1480 [56.3987460]

B:BD[234.58819] → [340.16399:16468]

            if (grd[rx][ry] == DNGN_FLOOR && trap_at_xy(rx,ry) == -1

[234.58819]

[340.16468]

            if (grd[rx][ry] == DNGN_FLOOR && trap_at_xy(coord_def(rx,ry)) == -1

Replacement in crawl-ref/source/decks.cc at line 1495 [56.3987460]

B:BD[378.19827] → [378.19827:19877]

                const int i = trap_at_xy(fx, fy);

[378.19827]

[378.19877]

                const int i = trap_at_xy(coord_def(fx, fy));

Replacement in crawl-ref/source/decks.cc at line 1528 [56.3987460]

B:BD[379.3380] → [379.3380:3459]

        if (is_valid_shaft_level() && grd[you.x_pos][you.y_pos] == DNGN_FLOOR)

[379.3380]

[379.3459]

        if (is_valid_shaft_level() && grd(you.pos()) == DNGN_FLOOR)

Replacement in crawl-ref/source/decks.cc at line 1532 [56.3987460]

B:BD[379.3556] → [379.3556:3697]

                const int i = trap_at_xy(you.x_pos, you.y_pos);
                grd[you.x_pos][you.y_pos] = trap_category(env.trap[i].type);

[379.3556]

[380.2867]

                const int i = trap_at_xy(you.pos());
                grd(you.pos()) = trap_category(env.trap[i].type);

Replacement in crawl-ref/source/decks.cc at line 1562 [56.3987460]

B:BD[124.10081] → [340.17019:17088]

            if (grd[rx][ry] == DNGN_FLOOR && trap_at_xy(rx,ry) == -1

[124.10081]

[340.17088]

            if (grd[rx][ry] == DNGN_FLOOR && trap_at_xy(coord_def(rx,ry)) == -1

Replacement in crawl-ref/source/decks.cc at line 2569 [56.3987460]

∅:D[234.61944] → [381.2549:2627]

B:BD[381.2549] → [381.2549:2627]

            cur_try = random_monster_at_grid(you.x_pos + dx, you.y_pos + dy);

[234.61944]

[234.61945]

            cur_try = random_monster_at_grid(you.pos() + coord_def(dx,dy));

Replacement in crawl-ref/source/debug.cc at line 1421 [56.4016436]
B:BD[56.4041981] → [56.4041981:4042044]
```
    move_item_to_grid( &thing_created, you.x_pos, you.y_pos );
```
[56.4041981]
[56.4042044]
```
    move_item_to_grid( &thing_created, you.pos() );
```
Replacement in crawl-ref/source/debug.cc at line 4104 [56.4016436]
B:BD[382.3290] → [382.3290:3340]
```
    move_player_to_grid(x, y, false, true, true);
```
[382.3290]
[382.3340]
```
    move_player_to_grid(coord_def(x, y), false, true, true);
```
Replacement in crawl-ref/source/cloud.h at line 41 [56.4095213]
B:BD[56.4095507] → [56.4095507:4095559]
```
void move_cloud( int cloud, int new_x, int new_y );
```
[56.4095507]
[56.4095559]
```
void move_cloud( int cloud, const coord_def& newpos );
```

Replacement in crawl-ref/source/cloud.h at line 43 [56.4095213]

B:BD[56.4095560] → [213.7013:7085]

void check_place_cloud( cloud_type cl_type, int x, int y, int lifetime,

[56.4095560]

[314.16261]

void check_place_cloud( cloud_type cl_type, const coord_def& p, int lifetime,

Replacement in crawl-ref/source/cloud.h at line 45 [56.4095213]

B:BD[314.16330] → [383.7662:7730]

void place_cloud( cloud_type cl_type, int ctarget_x, int ctarget_y,

[314.16330]

[383.7730]

void place_cloud( cloud_type cl_type, const coord_def& ctarget,

Replacement in crawl-ref/source/cloud.cc at line 49 [56.4095717]

B:BD[56.4096488] → [126.31517:31667]

static void _new_cloud( int cloud, cloud_type type, int x, int y, int decay,
                        kill_category whose, unsigned char spread_rate )

[56.4096488]

[56.4096558]

static void _new_cloud( int cloud, cloud_type type, const coord_def& p,
                        int decay, kill_category whose,
                        unsigned char spread_rate )

Replacement in crawl-ref/source/cloud.cc at line 57 [56.4095717]

B:BD[126.31755] → [126.31755:31835]

    env.cloud[ cloud ].x           = x;
    env.cloud[ cloud ].y           = y;

[126.31755]

[126.31835]

    env.cloud[ cloud ].x           = p.x;
    env.cloud[ cloud ].y           = p.y;

Replacement in crawl-ref/source/cloud.cc at line 61 [56.4095717]
B:BD[314.16735] → [126.31880:31924]
```
    env.cgrid[ x ][ y ]            = cloud;
```
[314.16735]
[56.4096781]
```
    env.cgrid(p)                   = cloud;
```

Replacement in crawl-ref/source/cloud.cc at line 65 [56.4095717]

B:BD[307.3709] → [126.31925:31998]

static void _place_new_cloud(cloud_type cltype, int x, int y, int decay,

[307.3709]

[126.31998]

static void _place_new_cloud(cloud_type cltype, const coord_def& p, int decay,

Replacement in crawl-ref/source/cloud.cc at line 76 [56.4095717]

B:BD[307.3979] → [126.32095:32166]

            _new_cloud( ci, cltype, x, y, decay, whose, spread_rate );

[307.3979]

[307.4029]

            _new_cloud( ci, cltype, p, decay, whose, spread_rate );

Replacement in crawl-ref/source/cloud.cc at line 88 [56.4095717]

B:BD[307.4288] → [307.4288:4326]


    for (int yi = -1; yi <= 1; ++yi)

[307.4288]

[307.4326]

    radius_iterator ri(coord_def(cloud.x, cloud.y), 1, true, false, true);
    for ( ; ri; ++ri )

Replacement in crawl-ref/source/cloud.cc at line 91 [56.4095717]

B:BD[307.4332] → [307.4332:4467]

        for (int xi = -1; xi <= 1; ++xi)
        {
            if ((!xi && !yi) || random2(100) >= spreadch)
                continue;

[307.4332]

[307.4467]

        if (random2(100) >= spreadch)
            continue;

Replacement in crawl-ref/source/cloud.cc at line 94 [56.4095717]

B:BD[307.4468] → [307.4468:4548]

            const int x = cloud.x + xi;
            const int y = cloud.y + yi;

[307.4468]

[307.4548]

        if (!in_bounds(*ri)
            || env.cgrid(*ri) != EMPTY_CLOUD
            || grid_is_solid(grd(*ri))
            || is_sanctuary(*ri) && !is_harmless_cloud(cloud.type))
        {
            continue;
        }

Replacement in crawl-ref/source/cloud.cc at line 102 [56.4095717]

B:BD[307.4549] → [106.16776:16809]

∅:D[106.16809] → [307.4583:4637]

B:BD[307.4583] → [307.4583:4637]

B:BD[307.4637] → [198.5293:5418]

∅:D[198.5418] → [307.4686:4847]

B:BD[307.4686] → [307.4686:4847]

B:BD[307.4847] → [126.32220:32342]

            if (!in_bounds(x, y)
                    || env.cgrid[x][y] != EMPTY_CLOUD
                    || grid_is_solid(grd[x][y])
                    || is_sanctuary(x, y) && !is_harmless_cloud(cloud.type))
                continue;
            int newdecay = cloud.decay / 2 + 1;
            if (newdecay >= cloud.decay)
                newdecay = cloud.decay - 1;
            _place_new_cloud( cloud.type, x, y, newdecay, cloud.whose,
                              cloud.spread_rate );

[307.4549]

[307.4906]

        int newdecay = cloud.decay / 2 + 1;
        if (newdecay >= cloud.decay)
            newdecay = cloud.decay - 1;
        
        _place_new_cloud( cloud.type, *ri, newdecay, cloud.whose,
                          cloud.spread_rate );

Replacement in crawl-ref/source/cloud.cc at line 109 [56.4095717]
B:BD[307.4907] → [307.4907:4947]
```
            extra_decay += 8;
        }
```
[307.4907]
[307.4947]
```
        extra_decay += 8;
```

Replacement in crawl-ref/source/cloud.cc at line 157 [56.4095717]

B:BD[384.4648] → [46.4849:4919]

                                env.cloud[cc].x, env.cloud[cc].y, 2);

[384.4648]

[384.4715]

                                env.cloud[cc].pos(), 2);

Replacement in crawl-ref/source/cloud.cc at line 167 [56.4095717]

B:BD[307.6554] → [307.6554:6654]

        const int cloud_x = env.cloud[ cloud ].x;
        const int cloud_y = env.cloud[ cloud ].y;

[307.6554]

[307.6654]

        const coord_def cloud_pos = env.cloud[ cloud ].pos();

Replacement in crawl-ref/source/cloud.cc at line 175 [56.4095717]
∅:D[121.9065] → [307.6807:6862]
∅:D[314.17082] → [307.6807:6862]
∅:D[126.33070] → [307.6807:6862]
B:BD[307.6807] → [307.6807:6862]
```
        env.cgrid[ cloud_x ][ cloud_y ] = EMPTY_CLOUD;
```
[126.33070]
[307.6862]
```
        env.cgrid(cloud_pos)            = EMPTY_CLOUD;
```
Replacement in crawl-ref/source/cloud.cc at line 182 [56.4095717]
∅:D[106.16867] → [56.4096931:4096982]
B:BD[56.4096931] → [56.4096931:4096982]
```
void move_cloud( int cloud, int new_x, int new_y )
```
[106.16867]
[56.4096982]
```
void move_cloud( int cloud, const coord_def& newpos )
```

Replacement in crawl-ref/source/cloud.cc at line 189 [56.4095717]

B:BD[56.4097117] → [56.4097117:4097162]

B:BD[56.4097162] → [126.33071:33161]

        env.cgrid[ new_x ][ new_y ] = cloud;
        env.cloud[ cloud ].x        = new_x;
        env.cloud[ cloud ].y        = new_y;

[56.4097117]

[56.4097238]

        env.cgrid(newpos) = cloud;
        env.cloud[ cloud ].x        = newpos.x;
        env.cloud[ cloud ].y        = newpos.y;

Replacement in crawl-ref/source/cloud.cc at line 198 [56.4095717]

B:BD[307.6988] → [213.7358:7430]

void check_place_cloud( cloud_type cl_type, int x, int y, int lifetime,

[307.6988]

[314.17083]

void check_place_cloud( cloud_type cl_type, const coord_def& p, int lifetime,

Replacement in crawl-ref/source/cloud.cc at line 201 [56.4095717]

B:BD[307.7056] → [307.7056:7116]

    if (!in_bounds(x, y) || env.cgrid[x][y] != EMPTY_CLOUD)

[307.7056]

[307.7116]

    if (!in_bounds(p) || env.cgrid(p) != EMPTY_CLOUD)

Replacement in crawl-ref/source/cloud.cc at line 204 [56.4095717]

B:BD[307.7133] → [314.17147:17211]

    place_cloud( cl_type, x, y, lifetime, whose, spread_rate );

[307.7133]

[385.1158]

    place_cloud( cl_type, p, lifetime, whose, spread_rate );

Replacement in crawl-ref/source/cloud.cc at line 222 [56.4095717]
B:BD[56.4097489] → [213.7431:7483]
∅:D[213.7483] → [121.9411:9457]
B:BD[121.9411] → [121.9411:9457]
```
void place_cloud(cloud_type cl_type, int ctarget_x,
                 int ctarget_y, int cl_range,
```
[56.4097489]
[314.17212]
```
void place_cloud(cloud_type cl_type, const coord_def& ctarget, int cl_range,
```

Replacement in crawl-ref/source/cloud.cc at line 225 [56.4095717]

B:BD[56.4097622] → [198.5419:5494]

    if (is_sanctuary(ctarget_x, ctarget_y) && !is_harmless_cloud(cl_type))

[56.4097622]

[198.5494]

    if (is_sanctuary(ctarget) && !is_harmless_cloud(cl_type))

Replacement in crawl-ref/source/cloud.cc at line 230 [56.4095717]
B:BD[56.4097644] → [56.4097644:4097670]
B:BD[56.4097670] → [121.9496:9558]
```
    // more compact {dlb}
    const int target_cgrid = env.cgrid[ctarget_x][ctarget_y];
```
[56.4097644]
[56.4097742]
```
    const int target_cgrid = env.cgrid(ctarget);
```

Replacement in crawl-ref/source/cloud.cc at line 242 [56.4095717]

B:BD[56.4098174] → [56.4098174:4098297]

            cl_new = env.cgrid[ ctarget_x ][ ctarget_y ];
            delete_cloud( env.cgrid[ ctarget_x ][ ctarget_y ] );

[56.4098174]

[56.4098297]

            cl_new = env.cgrid(ctarget);
            delete_cloud( env.cgrid(ctarget) );

Replacement in crawl-ref/source/cloud.cc at line 280 [56.4095717]

B:BD[126.33613] → [126.33613:33687]

        _new_cloud( cl_new, cl_type, ctarget_x, ctarget_y, cl_range * 10,

[126.33613]

[126.33687]

        _new_cloud( cl_new, cl_type, ctarget, cl_range * 10,

Replacement in crawl-ref/source/cloud.cc at line 290 [56.4095717]

B:BD[56.4099362] → [126.33769:33847]

                _new_cloud( ci, cl_type, ctarget_x, ctarget_y, cl_range * 10,

[56.4099362]

[126.33847]

                _new_cloud( ci, cl_type, ctarget, cl_range * 10,

Insertion in crawl-ref/source/beam.h at line 174 [56.4124541]

[69.108438]

    }
    coord_def source() const
    {
        return (coord_def(source_x, source_y));

Replacement in crawl-ref/source/beam.h at line 238 [56.4124541]

B:BD[56.4127743] → [60.1219835:1219895]

bool check_line_of_sight( int sx, int sy, int tx, int ty );

[56.4127743]

bool check_line_of_sight( const coord_def& source, const coord_def& target );

Replacement in crawl-ref/source/beam.h at line 252 [56.4124541]
∅:D[386.16594] → [387.11348:11409]
B:BD[56.4128028] → [387.11348:11409]
```
int affect(bolt &beam, int x, int y, item_def *item = NULL);
```
[386.16594]
[325.2917]
```
int affect(bolt &beam, const coord_def& p, item_def *item = NULL);
```

Replacement in crawl-ref/source/beam.h at line 254 [56.4124541]

B:BD[325.2918] → [325.2918:2985]

void beam_drop_object( bolt &beam, item_def *item, int x, int y );

[325.2918]

[60.1219941]

void beam_drop_object( bolt &beam, item_def *item, const coord_def& where );

Deletion in crawl-ref/source/beam.cc at line 80 [56.4128068]

B:BD[56.4129748] → [56.4129748:4129867]

static int spreadx[] = { 0, 0, 1, -1 };
static int spready[] = { -1, 1, 0, 0 };
static int opdir[]   = { 2, 1, 4, 3 };

Replacement in crawl-ref/source/beam.cc at line 88 [56.4128068]

B:BD[208.11697] → [208.11697:11993]

static bool _beam_term_on_target(bolt &beam, int x, int y);
static void _beam_explodes(bolt &beam, int x, int y);
static int  _affect_wall(bolt &beam, int x, int y);
static int  _affect_place_clouds(bolt &beam, int x, int y);
static void _affect_place_explosion_clouds(bolt &beam, int x, int y);

[208.11697]

[387.11411]

static bool _beam_term_on_target(bolt &beam, const coord_def& p);
static void _beam_explodes(bolt &beam, const coord_def& p);
static int  _affect_wall(bolt &beam, const coord_def& p);
static int  _affect_place_clouds(bolt &beam, const coord_def& p);
static void _affect_place_explosion_clouds(bolt &beam, const coord_def& p);

Replacement in crawl-ref/source/beam.cc at line 100 [56.4128068]
B:BD[208.12363] → [208.12363:12416]
```
static void _explosion_map(bolt &beam, int x, int y,
```
[208.12363]
[208.12416]
```
static void _explosion_map(bolt &beam, const coord_def& p,
```

Replacement in crawl-ref/source/beam.cc at line 102 [56.4128068]

B:BD[208.12471] → [208.12471:12541]

static void _explosion_cell(bolt &beam, int x, int y, bool drawOnly);

[208.12471]

[56.4131394]

static void _explosion_cell(bolt &beam, const coord_def& p, bool drawOnly);

Replacement in crawl-ref/source/beam.cc at line 167 [56.4128068]
B:BD[60.1220825] → [60.1220825:1220863]
```
    int x = you.x_pos, y = you.y_pos;
```
[60.1220825]
[60.1220863]
```
    coord_def p = you.pos();
```
Replacement in crawl-ref/source/beam.cc at line 178 [56.4128068]
B:BD[60.1221075] → [60.1221075:1221115]
```
        x = mon->x;
        y = mon->y;
```
[60.1221075]
[60.1221115]
```
        p = mon->pos();
```
Replacement in crawl-ref/source/beam.cc at line 181 [56.4128068]
B:BD[60.1221122] → [60.1221122:1221149]
```
    if (!see_grid( x, y ))
```
[60.1221122]
[60.1221149]
```
    if (!see_grid(p))
```
Replacement in crawl-ref/source/beam.cc at line 184 [56.4128068]
∅:D[388.3848] → [389.1712:1786]
B:BD[60.1221170] → [389.1712:1786]
```
    const int drawx = grid2viewX(x);
    const int drawy = grid2viewY(y);
```
[388.3848]
[60.1221253]
```
    const coord_def drawp = grid2view(p);
```
Replacement in crawl-ref/source/beam.cc at line 186 [56.4128068]
B:BD[60.1221254] → [389.1787:1824]
```
    if (in_los_bounds(drawx, drawy))
```
[60.1221254]
[60.1221314]
```
    if (in_los_bounds(drawp))
```
Replacement in crawl-ref/source/beam.cc at line 190 [56.4128068]
∅:D[44.225462] → [178.5936845:5936906]
B:BD[178.5936845] → [178.5936845:5936906]
```
        TileDrawBolt(drawx-1, drawy-1, tileidx_zap(colour));
```
[44.225462]
[178.5936906]
```
        TileDrawBolt(drawp.x-1, drawp.y-1, tileidx_zap(colour));
```
Replacement in crawl-ref/source/beam.cc at line 193 [56.4128068]
B:BD[89.7385] → [15.3002:3044]
```
        cgotoxy(drawx, drawy, GOTO_DNGN);
```
[89.7385]
[15.3044]
```
        cgotoxy(drawp.x, drawp.y, GOTO_DNGN);
```

Replacement in crawl-ref/source/beam.cc at line 271 [56.4128068]

∅:D[323.8331] → [58.4172:4251]

B:BD[243.13615] → [58.4172:4251]

        noisy(25, you.x_pos, you.y_pos, "You hear a mighty clap of thunder!");

[323.8331]

[56.4132906]

        noisy(25, you.pos(), "You hear a mighty clap of thunder!");

Replacement in crawl-ref/source/beam.cc at line 1706 [56.4128068]

B:BD[390.4711] → [208.13159:13236]

static bool _affect_mon_in_wall(bolt &pbolt, item_def *item, int tx, int ty)

[390.4711]

[391.4052]

static bool _affect_mon_in_wall(bolt &pbolt, item_def *item,
                                const coord_def& where)

Replacement in crawl-ref/source/beam.cc at line 1711 [56.4128068]
B:BD[391.4073] → [391.4073:4101]
```
    int mid = mgrd[tx][ty];
```
[391.4073]
[391.4101]
```
    int mid = mgrd(where);
```

Replacement in crawl-ref/source/beam.cc at line 1718 [56.4128068]

B:BD[391.4233] → [6.2730:2777]

            && (grd[tx][ty] == DNGN_METAL_WALL

[391.4233]

[6.2777]

            && (grd(where) == DNGN_METAL_WALL

Replacement in crawl-ref/source/beam.cc at line 1755 [56.4128068]
∅:D[323.8721] → [392.856:931]
B:BD[56.4169767] → [392.856:931]
```
    int &tx(pbolt.pos.x), &ty(pbolt.pos.y);     // test(new) x,y - integer
```
[323.8721]
[56.4169919]
```
    coord_def &testpos(pbolt.pos);
```

Replacement in crawl-ref/source/beam.cc at line 1803 [56.4128068]

∅:D[393.255] → [77.4751:4801]

B:BD[77.4751] → [77.4751:4801]

B:BD[77.4801] → [70.8544:8634]

        find_ray( pbolt.source_x, pbolt.source_y,
                  pbolt.target_x, pbolt.target_y, true, ray,
                  0, true );

[393.255]

[393.256]

        find_ray( pbolt.source(), pbolt.target(), true, ray, 0, true );

Replacement in crawl-ref/source/beam.cc at line 1830 [56.4128068]
∅:D[78.40797] → [56.4172170:4172176]
B:BD[56.4172170] → [56.4172170:4172176]
B:BD[56.4172176] → [60.1228975:1229019]
```
    {
        tx = ray.x();
        ty = ray.y();
```
[78.40797]
[394.385]
```
    {        
        testpos = ray.pos();
```
Replacement in crawl-ref/source/beam.cc at line 1834 [56.4128068]
B:BD[243.13751] → [243.13751:13797]
```
        if (env.cgrid[tx][ty] != EMPTY_CLOUD)
```
[243.13751]
[394.486]
```
        if (env.cgrid(testpos) != EMPTY_CLOUD)
```
Replacement in crawl-ref/source/beam.cc at line 1838 [56.4128068]
∅:D[243.13848] → [60.1229020:1229060]
B:BD[56.4172705] → [60.1229020:1229060]
```
        if (grid_is_solid(grd[tx][ty]))
```
[243.13848]
[56.4172740]
```
        if (grid_is_solid(grd(testpos)))
```
Replacement in crawl-ref/source/beam.cc at line 1841 [56.4128068]
∅:D[386.30683] → [208.13237:13288]
B:BD[56.4172813] → [208.13237:13288]
```
            if (_affects_wall(pbolt, grd[tx][ty]))
```
[386.30683]
[56.4172850]
```
            if (_affects_wall(pbolt, grd(testpos)))
```

Replacement in crawl-ref/source/beam.cc at line 1846 [56.4128068]

B:BD[60.1229169] → [387.33347:33414]

                    rangeRemaining -= affect(pbolt, tx, ty, item);

[60.1229169]

[56.4173102]

                    rangeRemaining -= affect(pbolt, testpos, item);

Replacement in crawl-ref/source/beam.cc at line 1849 [56.4128068]
∅:D[386.30801] → [60.1229170:1229218]
B:BD[56.4173150] → [60.1229170:1229218]
```
                if (grid_is_solid(grd[tx][ty]))
```
[386.30801]
[56.4173211]
```
                if (grid_is_solid(grd(testpos)))
```

Replacement in crawl-ref/source/beam.cc at line 1856 [56.4128068]

B:BD[391.4804] → [208.13289:13341]

                if (!_isBouncy(pbolt, grd[tx][ty]))

[391.4804]

[70.8732]

                if (!_isBouncy(pbolt, grd(testpos)))

Replacement in crawl-ref/source/beam.cc at line 1859 [56.4128068]

B:BD[391.4874] → [387.33415:33482]

                    rangeRemaining -= affect(pbolt, tx, ty, item);

[391.4874]

[391.4935]

                    rangeRemaining -= affect(pbolt, testpos, item);

Replacement in crawl-ref/source/beam.cc at line 1867 [56.4128068]
∅:D[395.535] → [60.1229344:1229412]
∅:D[70.8799] → [60.1229344:1229412]
∅:D[124.14476] → [60.1229344:1229412]
∅:D[78.40865] → [60.1229344:1229412]
B:BD[60.1229344] → [60.1229344:1229412]
```
                    tx = ray.x();
                    ty = ray.y();
```
[124.14476]
[60.1229412]
```
                    testpos = ray.pos();
```

Replacement in crawl-ref/source/beam.cc at line 1883 [56.4128068]

B:BD[78.40990] → [19.3074:3182]

                while (rangeRemaining > 0
                        && grid_is_solid(grd[ray.x()][ray.y()]));

[78.40990]

[56.4174718]

                while (rangeRemaining > 0 && grid_is_solid(grd(ray.pos())));

Replacement in crawl-ref/source/beam.cc at line 1888 [56.4128068]
∅:D[396.3819] → [60.1229843:1229903]
B:BD[60.1229843] → [60.1229843:1229903]
```
                tx = ray.x();
                ty = ray.y();
```
[396.3819]
[56.4175360]
```
                testpos = ray.pos();
```
Replacement in crawl-ref/source/beam.cc at line 1890 [56.4128068]
B:BD[56.4175414] → [56.4175414:4175451]
```
        } // endif - is tx, ty wall?
```
[56.4175414]
[56.4175451]
```
        } // endif - are we in a wall wall?
```

Replacement in crawl-ref/source/beam.cc at line 1892 [56.4128068]

B:BD[56.4175452] → [386.30802:30863]

        // At this point, if grd[tx][ty] is still a wall, we

[56.4175452]

[56.4175513]

        // At this point, if grd(testpos) is still a wall, we

Replacement in crawl-ref/source/beam.cc at line 1894 [56.4128068]
B:BD[56.4175582] → [60.1229904:1229944]
```
        if (grid_is_solid(grd[tx][ty]))
```
[56.4175582]
[56.4175669]
```
        if (grid_is_solid(grd(testpos)))
```

Replacement in crawl-ref/source/beam.cc at line 1905 [56.4128068]

∅:D[60.1230130] → [56.4176061:4176119]

B:BD[56.4176061] → [56.4176061:4176119]

∅:D[323.8753] → [208.13342:13407]

B:BD[56.4176119] → [208.13342:13407]

        if (tx == pbolt.target_x && ty == pbolt.target_y)
            beamTerminate = _beam_term_on_target(pbolt, tx, ty);

[60.1230130]

[56.4176175]

        if (testpos == pbolt.target())
            beamTerminate = _beam_term_on_target(pbolt, testpos);

Replacement in crawl-ref/source/beam.cc at line 1923 [56.4128068]

∅:D[323.8779] → [387.33483:33546]

B:BD[392.972] → [387.33483:33546]

                rangeRemaining -= affect(pbolt, tx, ty, item);

[392.972]

[56.4176698]

                rangeRemaining -= affect(pbolt, testpos, item);

Replacement in crawl-ref/source/beam.cc at line 1948 [56.4128068]

B:BD[56.4177169] → [60.1230383:1230456]

        if (!pbolt.is_tracer && pbolt.name[0] != '0' && see_grid(tx,ty))

[56.4177169]

[56.4177246]

        if (!pbolt.is_tracer && pbolt.name[0] != '0' && see_grid(testpos))

Replacement in crawl-ref/source/beam.cc at line 1956 [56.4128068]

∅:D[243.13945] → [389.1825:1905]

B:BD[56.4177522] → [389.1825:1905]

            int drawx = grid2viewX(tx);
            int drawy = grid2viewY(ty);

[243.13945]

[178.5937176]

            coord_def drawpos = grid2view(testpos);

Replacement in crawl-ref/source/beam.cc at line 1962 [56.4128068]

B:BD[387.33548] → [386.31433:31553]

            if (tile_beam != -1 && in_los_bounds(drawx, drawy)
                && (tx != you.x_pos || ty != you.y_pos))

[387.33548]

[178.5937395]

            if (tile_beam != -1 && in_los_bounds(drawpos)
                && (testpos != you.pos()))

Replacement in crawl-ref/source/beam.cc at line 1965 [56.4128068]

B:BD[178.5937409] → [178.5937409:5937468]

                TileDrawBolt(drawx-1, drawy-1, tile_beam);

[178.5937409]

[178.5937468]

                TileDrawBolt(drawpos.x-1, drawpos.y-1, tile_beam);

Replacement in crawl-ref/source/beam.cc at line 1971 [56.4128068]
B:BD[56.4177639] → [389.1906:1951]
```
            if (in_los_bounds(drawx, drawy))
```
[56.4177639]
[56.4177707]
```
            if (in_los_bounds(drawpos))
```
Replacement in crawl-ref/source/beam.cc at line 1974 [56.4128068]
∅:D[27.2788] → [397.8553:8592]
B:BD[56.4177721] → [397.8553:8592]
```
                cgotoxy(drawx, drawy);
```
[27.2788]
[398.8571]
```
                cgotoxy(drawpos.x, drawpos.y);
```
Replacement in crawl-ref/source/beam.cc at line 2003 [56.4128068]
B:BD[399.3082] → [19.3210:3257]
```
        beam_drop_object(pbolt, item, tx, ty);
```
[399.3082]
[124.14481]
```
        beam_drop_object(pbolt, item, testpos);
```
Replacement in crawl-ref/source/beam.cc at line 2010 [56.4128068]
B:BD[56.4178912] → [56.4178912:4178970]
```
    int ox = pbolt.target_x;
    int oy = pbolt.target_y;
```
[56.4178912]
[56.4178970]
```
    coord_def targetcopy = pbolt.target();
```
Replacement in crawl-ref/source/beam.cc at line 2012 [56.4128068]
B:BD[56.4178971] → [208.13408:13443]
```
    _beam_explodes(pbolt, tx, ty);
```
[56.4178971]
[56.4179005]
```
    _beam_explodes(pbolt, testpos);
```

Replacement in crawl-ref/source/beam.cc at line 2016 [56.4128068]

B:BD[56.4179036] → [56.4179036:4179094]

        pbolt.target_x = ox;
        pbolt.target_y = oy;

[56.4179036]

[56.4179094]

        pbolt.target_x = targetcopy.x;
        pbolt.target_y = targetcopy.y;

Replacement in crawl-ref/source/beam.cc at line 2849 [56.4128068]

B:BD[56.4201006] → [60.1235257:1235316]

bool check_line_of_sight( int sx, int sy, int tx, int ty )

[56.4201006]

[60.1235316]

bool check_line_of_sight( const coord_def& source, const coord_def& target )

Replacement in crawl-ref/source/beam.cc at line 2851 [56.4128068]
B:BD[60.1235318] → [60.1235318:1235372]
```
    const int dist = grid_distance( sx, sy, tx, ty );
```
[60.1235318]
[56.4201006]
```
    const int dist = grid_distance( source, target );
```
Replacement in crawl-ref/source/beam.cc at line 2864 [56.4128068]
B:BD[60.1235680] → [60.1235680:1235731]
```
    return find_ray( sx, sy, tx, ty, false, ray );
```
[60.1235680]
[60.1235731]
```
    return find_ray( source, target, false, ray );
```
Replacement in crawl-ref/source/beam.cc at line 2912 [56.4128068]
B:BD[56.4201625] → [208.14398:14451]
```
static void _beam_explodes(bolt &beam, int x, int y)
```
[56.4201625]
[56.4201684]
```
static void _beam_explodes(bolt &beam, const coord_def& p)
```
Replacement in crawl-ref/source/beam.cc at line 2919 [56.4128068]
B:BD[56.4201820] → [56.4201820:4201866]
```
    beam.target_x = x;
    beam.target_y = y;
```
[56.4201820]
[56.4201866]
```
    beam.target_x = p.x;
    beam.target_y = p.y;
```

Replacement in crawl-ref/source/beam.cc at line 2985 [56.4128068]

B:BD[56.4203345] → [208.14508:14587]

        big_cloud( CLOUD_POISON, _whose_kill(beam), x, y, 0, 7 + random2(5) );

[56.4203345]

[56.4203482]

        big_cloud(CLOUD_POISON, _whose_kill(beam), p.x, p.y, 0, 7 + random2(5));

Replacement in crawl-ref/source/beam.cc at line 2993 [56.4128068]
∅:D[400.3077] → [208.14588:14649]
∅:D[340.21843] → [208.14588:14649]
B:BD[213.8160] → [208.14588:14649]
```
        big_cloud( cl_type, _whose_kill(beam), x, y, 0, 9 );
```
[340.21843]
[56.4203736]
```
        big_cloud( cl_type, _whose_kill(beam), p.x, p.y, 0, 9 );
```

Replacement in crawl-ref/source/beam.cc at line 2999 [56.4128068]

B:BD[187.54580] → [208.14650:14706]

        big_cloud( CLOUD_COLD, _whose_kill(beam), x, y,

[187.54580]

[187.54635]

        big_cloud( CLOUD_COLD, _whose_kill(beam), p.x, p.y,

Replacement in crawl-ref/source/beam.cc at line 3021 [56.4128068]
B:BD[56.4204193] → [208.14767:14826]
```
static bool _beam_term_on_target(bolt &beam, int x, int y)
```
[56.4204193]
[56.4204244]
```
static bool _beam_term_on_target(bolt &beam, const coord_def& p)
```
Replacement in crawl-ref/source/beam.cc at line 3050 [56.4128068]
B:BD[60.1237090] → [60.1237090:1237162]
```
    if (beam.aimed_at_spot && x == beam.target_x && y == beam.target_y)
```
[56.4204932]
[60.1237162]
```
    if (beam.aimed_at_spot && p == beam.target())
```

Replacement in crawl-ref/source/beam.cc at line 3056 [56.4128068]

B:BD[56.4204955] → [325.3051:3117]

void beam_drop_object( bolt &beam, item_def *item, int x, int y )

[56.4204955]

[56.4205035]

void beam_drop_object( bolt &beam, item_def *item, const coord_def& p )

Replacement in crawl-ref/source/beam.cc at line 3065 [56.4128068]

B:BD[124.14665] → [124.14665:14724]

            && !thrown_object_destroyed(item, x, y, false)

[124.14665]

[124.14724]

            && !thrown_object_destroyed(item, p, false)

Replacement in crawl-ref/source/beam.cc at line 3067 [56.4128068]

B:BD[124.14758] → [124.14758:14886]

            && !mons_thrown_object_destroyed(item, x, y, false,
                                             beam.beam_source))

[124.14758]

[56.4205312]

            && !mons_thrown_object_destroyed(item, p, false, beam.beam_source))

Replacement in crawl-ref/source/beam.cc at line 3072 [56.4128068]

∅:D[386.32265] → [188.4700:4880]

B:BD[188.4700] → [188.4700:4880]

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

[386.32265]

[188.4880]

            if (you.pos() == p && you.attribute[ATTR_HELD]
                || mgrd(p) != NON_MONSTER &&
                   mons_is_caught(&menv[mgrd(p)]))

Replacement in crawl-ref/source/beam.cc at line 3077 [56.4128068]
∅:D[386.32325] → [188.4952:5013]
B:BD[188.4952] → [188.4952:5013]
```
                if (get_trapping_net(x,y, true) == NON_ITEM)
```
[386.32325]
[188.5013]
```
                if (get_trapping_net(p, true) == NON_ITEM)
```
Replacement in crawl-ref/source/beam.cc at line 3082 [56.4128068]
B:BD[56.4206214] → [56.4206214:4206259]
```
        copy_item_to_grid( *item, x, y, 1 );
```
[56.4205926]
[401.720]
```
        copy_item_to_grid( *item, p, 1 );
```
Replacement in crawl-ref/source/beam.cc at line 3088 [56.4128068]
B:BD[60.1237914] → [208.14827:14885]
```
static bool _found_player(const bolt &beam, int x, int y)
```
[60.1237914]
[56.4208416]
```
static bool _found_player(const bolt &beam, const coord_def& p)
```
Replacement in crawl-ref/source/beam.cc at line 3094 [56.4128068]
B:BD[56.4209893] → [60.1238122:1238186]
```
    return (grid_distance(x, y, you.x_pos, you.y_pos) <= dist);
```
[56.4209893]
[56.4209915]
```
    return (grid_distance(p, you.pos()) <= dist);
```
Replacement in crawl-ref/source/beam.cc at line 3097 [56.4128068]
B:BD[56.4209918] → [387.35486:35539]
```
int affect(bolt &beam, int x, int y, item_def *item)
```
[56.4209918]
[56.4210530]
```
int affect(bolt &beam, const coord_def& p, item_def *item)
```
Replacement in crawl-ref/source/beam.cc at line 3106 [56.4128068]
B:BD[60.1238341] → [60.1238341:1238375]
```
    if (grid_is_solid(grd[x][y]))
```
[60.1238341]
[56.4210630]
```
    if (grid_is_solid(grd(p)))
```

Replacement in crawl-ref/source/beam.cc at line 3111 [56.4128068]

B:BD[56.4210738] → [208.14886:14930]

B:BD[56.4210780] → [208.14931:14982]

        if (_affects_wall(beam, grd[x][y]))
            rangeUsed += _affect_wall(beam, x, y);

[56.4210738]

[387.35540]

        if (_affects_wall(beam, grd(p)))
            rangeUsed += _affect_wall(beam, p);

Replacement in crawl-ref/source/beam.cc at line 3118 [56.4128068]
∅:D[402.2798] → [60.1238517:1238555]
∅:D[391.5181] → [60.1238517:1238555]
B:BD[56.4210987] → [60.1238517:1238555]
```
        if (grid_is_solid(grd[x][y]))
```
[402.2798]
[391.5182]
```
        if (grid_is_solid(grd(p)))
```
Replacement in crawl-ref/source/beam.cc at line 3120 [56.4128068]
B:BD[391.5192] → [391.5192:5226]
```
            int mid = mgrd[x][y];
```
[391.5192]
[391.5226]
```
            int mid = mgrd(p);
```

Replacement in crawl-ref/source/beam.cc at line 3124 [56.4128068]

B:BD[391.5320] → [208.14983:15042]

                if (_affect_mon_in_wall(beam, NULL, x, y))

[391.5320]

[387.35542]

                if (_affect_mon_in_wall(beam, NULL, p))

Replacement in crawl-ref/source/beam.cc at line 3138 [56.4128068]

B:BD[56.4211059] → [56.4211059:4211131]

    // grd[x][y] will NOT be a wall for the remainder of this function.

[56.4211059]

[56.4211131]

    // grd(p) will NOT be a wall for the remainder of this function.

Replacement in crawl-ref/source/beam.cc at line 3146 [56.4128068]
B:BD[46.5046] → [46.5046:5111]
∅:D[403.2822] → [208.15106:15161]
∅:D[46.5111] → [208.15106:15161]
∅:D[183.5291] → [208.15106:15161]
B:BD[60.1238581] → [208.15106:15161]
```
        expose_items_to_element(beam.flavour, x, y, burn_power);
        rangeUsed += _affect_place_clouds(beam, x, y);
```
[46.5046]
[403.2858]
```
        expose_items_to_element(beam.flavour, p, burn_power);
        rangeUsed += _affect_place_clouds(beam, p);
```
Replacement in crawl-ref/source/beam.cc at line 3151 [56.4128068]
∅:D[243.14289] → [208.15162:15197]
B:BD[60.1238656] → [208.15162:15197]
```
    if (_found_player(beam, x, y))
```
[243.14289]
[56.4211365]
```
    if (_found_player(beam, p))
```
Replacement in crawl-ref/source/beam.cc at line 3163 [56.4128068]
∅:D[124.14888] → [208.15248:15294]
B:BD[60.1239106] → [208.15248:15294]
```
        if (_beam_term_on_target(beam, x, y))
```
[124.14888]
[56.4211431]
```
        if (_beam_term_on_target(beam, p))
```
Replacement in crawl-ref/source/beam.cc at line 3169 [56.4128068]
∅:D[323.9259] → [56.4211624:4211650]
B:BD[56.4211624] → [56.4211624:4211650]
```
    int mid = mgrd[x][y];
```
[323.9259]
[404.2606]
```
    int mid = mgrd(p);
```
Replacement in crawl-ref/source/beam.cc at line 3187 [56.4128068]
∅:D[124.14890] → [208.15362:15412]
B:BD[404.3140] → [208.15362:15412]
```
            if (_beam_term_on_target(beam, x, y))
```
[124.14890]
[404.3189]
```
            if (_beam_term_on_target(beam, p))
```
Replacement in crawl-ref/source/beam.cc at line 3234 [56.4128068]
∅:D[386.32489] → [208.15631:15681]
B:BD[56.4212645] → [208.15631:15681]
```
static int _affect_wall(bolt &beam, int x, int y)
```
[386.32489]
[56.4212701]
```
static int _affect_wall(bolt &beam, const coord_def& p)
```

Replacement in crawl-ref/source/beam.cc at line 3241 [56.4128068]

B:BD[56.4212786] → [56.4212786:4212919]

B:BD[56.4212919] → [55.17125:17229]

B:BD[55.17229] → [136.2691:2724]

        if (grd[x][y] == DNGN_STONE_WALL
            || grd[x][y] == DNGN_METAL_WALL
            || grd[x][y] == DNGN_PERMAROCK_WALL
            || grd[x][y] == DNGN_CLEAR_STONE_WALL
            || grd[x][y] == DNGN_CLEAR_PERMAROCK_WALL
            || !in_bounds(x, y))

[56.4212786]

[56.4213000]

        if (grd(p) == DNGN_STONE_WALL
            || grd(p) == DNGN_METAL_WALL
            || grd(p) == DNGN_PERMAROCK_WALL
            || grd(p) == DNGN_CLEAR_STONE_WALL
            || grd(p) == DNGN_CLEAR_PERMAROCK_WALL
            || !in_bounds(p))

Replacement in crawl-ref/source/beam.cc at line 3251 [56.4128068]

B:BD[56.4213045] → [55.17230:17308]

        if (grd[x][y] == DNGN_ROCK_WALL || grd[x][y] == DNGN_CLEAR_ROCK_WALL)

[56.4213045]

[56.4213086]

        if (grd(p) == DNGN_ROCK_WALL || grd(p) == DNGN_CLEAR_ROCK_WALL)

Replacement in crawl-ref/source/beam.cc at line 3253 [56.4128068]
B:BD[56.4213096] → [56.4213096:4213132]
```
            grd[x][y] = DNGN_FLOOR;
```
[56.4213096]
[124.14965]
```
            grd(p) = DNGN_FLOOR;
```

Replacement in crawl-ref/source/beam.cc at line 3256 [56.4128068]

∅:D[386.32541] → [66.9883:9974]

B:BD[66.9883] → [66.9883:9974]

            if (is_bloodcovered(x,y))
                env.map[x][y].property = FPROP_NONE;

[386.32541]

[56.4213132]

            if (is_bloodcovered(p))
                env.map(p).property = FPROP_NONE;

Replacement in crawl-ref/source/beam.cc at line 3261 [56.4128068]
B:BD[56.4213183] → [56.4213183:4213236]
```
                if (!silenced(you.x_pos, you.y_pos))
```
[56.4213183]
[56.4213236]
```
                if (!silenced(you.pos()))
```
Replacement in crawl-ref/source/beam.cc at line 3278 [56.4128068]
B:BD[405.1070] → [405.1070:1106]
```
        const int wgrd = grd[x][y];
```
[405.1070]
[405.1106]
```
        const int wgrd = grd(p);
```
Replacement in crawl-ref/source/beam.cc at line 3286 [56.4128068]
B:BD[406.1373] → [406.1373:1409]
```
                if (see_grid(x, y))
```
[406.1373]
[208.15742]
```
                if (see_grid(p))
```
Replacement in crawl-ref/source/beam.cc at line 3296 [56.4128068]
∅:D[406.1689] → [405.1166:1226]
B:BD[405.1166] → [405.1166:1226]
```
        grd[x][y] = DNGN_FLOOR;
        if (see_grid(x, y))
```
[406.1689]
[208.15923]
```
        grd(p) = DNGN_FLOOR;
        if (see_grid(p))
```

Replacement in crawl-ref/source/beam.cc at line 3302 [56.4128068]

B:BD[405.1356] → [208.16053:16129]

        place_cloud(CLOUD_FIRE, x, y, random2(10) + 15, _whose_kill(beam));

[405.1356]

[405.1490]

        place_cloud(CLOUD_FIRE, p, random2(10) + 15, _whose_kill(beam));

Replacement in crawl-ref/source/beam.cc at line 3312 [56.4128068]
B:BD[56.4213605] → [56.4213605:4213640]
```
        int targ_grid = grd[x][y];
```
[56.4213605]
[56.4213640]
```
        int targ_grid = grd(p);
```
Replacement in crawl-ref/source/beam.cc at line 3316 [56.4128068]
∅:D[387.35988] → [136.2725:2757]
B:BD[55.17431] → [136.2725:2757]
```
            && in_bounds(x, y))
```
[387.35988]
[56.4213786]
```
            && in_bounds(p))
```

Replacement in crawl-ref/source/beam.cc at line 3318 [56.4128068]

B:BD[56.4213796] → [56.4213796:4213885]

            grd[ x ][ y ] = DNGN_FLOOR;
            if (!silenced(you.x_pos, you.y_pos))

[56.4213796]

[56.4213885]

            grd(p) = DNGN_FLOOR;
            if (!silenced(you.pos()))

Replacement in crawl-ref/source/beam.cc at line 3329 [56.4128068]
B:BD[56.4214155] → [56.4214155:4214191]
```
            grd[x][y] = DNGN_FLOOR;
```
[56.4214155]
[66.9975]
```
            grd(p) = DNGN_FLOOR;
```

Replacement in crawl-ref/source/beam.cc at line 3332 [56.4128068]

∅:D[386.32593] → [66.10026:10117]

B:BD[66.10026] → [66.10026:10117]

            if (is_bloodcovered(x,y))
                env.map[x][y].property = FPROP_NONE;

[386.32593]

[56.4214191]

            if (is_bloodcovered(p))
                env.map(p).property = FPROP_NONE;

Replacement in crawl-ref/source/beam.cc at line 3335 [56.4128068]
B:BD[56.4214192] → [56.4214192:4214241]
```
            if (!silenced(you.x_pos, you.y_pos))
```
[56.4214192]
[56.4214241]
```
            if (!silenced(you.pos()))
```
Replacement in crawl-ref/source/beam.cc at line 3337 [56.4128068]
B:BD[56.4214255] → [56.4214255:4214294]
```
                if (!see_grid( x, y ))
```
[56.4214255]
[60.1240014]
```
                if (!see_grid( p ))
```
Replacement in crawl-ref/source/beam.cc at line 3345 [56.4128068]
B:BD[56.4214466] → [387.36027:36063]
```
            else if (see_grid(x,y))
```
[56.4214466]
[387.36063]
```
            else if (see_grid(p))
```
Replacement in crawl-ref/source/beam.cc at line 3362 [56.4128068]
B:BD[56.4214971] → [208.16130:16188]
```
static int _affect_place_clouds(bolt &beam, int x, int y)
```
[56.4214971]
[56.4215035]
```
static int _affect_place_clouds(bolt &beam, const coord_def& p)
```
Replacement in crawl-ref/source/beam.cc at line 3366 [56.4128068]
B:BD[56.4215090] → [208.16189:16243]
```
        _affect_place_explosion_clouds( beam, x, y );
```
[56.4215090]
[56.4215143]
```
        _affect_place_explosion_clouds( beam, p );
```
Replacement in crawl-ref/source/beam.cc at line 3371 [56.4128068]
B:BD[56.4215246] → [56.4215246:4215305]
```
    if (env.cgrid[x][y] != EMPTY_CLOUD)     // hit a cloud
```
[56.4215246]
[56.4215305]
```
    if (env.cgrid(p) != EMPTY_CLOUD)     // hit a cloud
```
Replacement in crawl-ref/source/beam.cc at line 3376 [56.4128068]
∅:D[387.36159] → [213.8221:8269]
B:BD[56.4215412] → [213.8221:8269]
```
            env.cloud[ env.cgrid[x][y] ].type =
```
[387.36159]
[213.8269]
```
            env.cloud[ env.cgrid(p) ].type =
```
Replacement in crawl-ref/source/beam.cc at line 3384 [56.4128068]
B:BD[56.4215579] → [56.4215579:4215617]
```
        int clouty = env.cgrid[x][y];
```
[56.4215579]
[56.4215617]
```
        int clouty = env.cgrid(p);
```

Replacement in crawl-ref/source/beam.cc at line 3393 [56.4128068]

B:BD[56.4216032] → [56.4216032:4216116]

            if (!silenced(x, y)
                && !silenced(you.x_pos, you.y_pos))

[56.4216032]

[56.4216116]

            if (!silenced(p)
                && !silenced(you.pos()))

Replacement in crawl-ref/source/beam.cc at line 3406 [56.4128068]

B:BD[60.1240542] → [208.16244:16322]

        place_cloud( CLOUD_POISON, x, y, random2(4) + 2, _whose_kill(beam) );

[60.1240542]

[56.4216498]

        place_cloud( CLOUD_POISON, p, random2(4) + 2, _whose_kill(beam) );

Replacement in crawl-ref/source/beam.cc at line 3409 [56.4128068]

B:BD[56.4216532] → [387.36171:36231]

B:BD[387.36231] → [407.2763:2820]

    if (grd[x][y] == DNGN_LAVA && beam.flavour == BEAM_COLD
        || grid_is_watery(grd[x][y]) && _is_fiery(beam))

[56.4216532]

[56.4216719]

    if (grd(p) == DNGN_LAVA && beam.flavour == BEAM_COLD
        || grid_is_watery(grd(p)) && _is_fiery(beam))

Replacement in crawl-ref/source/beam.cc at line 3412 [56.4128068]

B:BD[56.4216725] → [208.16323:16400]

        place_cloud( CLOUD_STEAM, x, y, 2 + random2(5), _whose_kill(beam) );

[56.4216725]

[56.4216859]

        place_cloud( CLOUD_STEAM, p, 2 + random2(5), _whose_kill(beam) );

Replacement in crawl-ref/source/beam.cc at line 3415 [56.4128068]

B:BD[56.4216866] → [307.7372:7436]

B:BD[307.7442] → [208.16401:16477]

    if (beam.flavour == BEAM_COLD && grid_is_watery(grd[x][y]))
        place_cloud( CLOUD_COLD, x, y, 2 + random2(5), _whose_kill(beam) );

[56.4216866]

[56.4217004]

    if (beam.flavour == BEAM_COLD && grid_is_watery(grd(p)))
        place_cloud( CLOUD_COLD, p, 2 + random2(5), _whose_kill(beam) );

Replacement in crawl-ref/source/beam.cc at line 3420 [56.4128068]

B:BD[60.1240626] → [208.16478:16554]

        place_cloud( CLOUD_COLD, x, y, random2(5) + 3, _whose_kill(beam) );

[60.1240626]

[56.4217149]

        place_cloud( CLOUD_COLD, p, random2(5) + 3, _whose_kill(beam) );

Replacement in crawl-ref/source/beam.cc at line 3425 [56.4128068]

B:BD[56.4217232] → [208.16555:16632]

        place_cloud( CLOUD_STEAM, x, y, random2(5) + 2, _whose_kill(beam) );

[60.1240665]

[56.4217372]

        place_cloud( CLOUD_STEAM, p, random2(5) + 2, _whose_kill(beam) );

Replacement in crawl-ref/source/beam.cc at line 3428 [56.4128068]

B:BD[60.1240709] → [208.16633:16711]

        place_cloud( CLOUD_MIASMA, x, y, random2(5) + 2, _whose_kill(beam) );

[60.1240703]

[60.1240853]

        place_cloud( CLOUD_MIASMA, p, random2(5) + 2, _whose_kill(beam) );

Replacement in crawl-ref/source/beam.cc at line 3432 [56.4128068]

B:BD[60.1240928] → [208.16712:16790]

        place_cloud( CLOUD_POISON, x, y, random2(4) + 3, _whose_kill(beam) );

[60.1240928]

[56.4217740]

        place_cloud( CLOUD_POISON, p, random2(4) + 3, _whose_kill(beam) );

Replacement in crawl-ref/source/beam.cc at line 3437 [56.4128068]

B:BD[56.4217809] → [208.16791:16860]

static void _affect_place_explosion_clouds(bolt &beam, int x, int y)

[56.4217760]

[56.4217884]

static void _affect_place_explosion_clouds(bolt &beam, const coord_def& p)

Replacement in crawl-ref/source/beam.cc at line 3443 [56.4128068]

∅:D[408.10301] → [407.2821:2939]

B:BD[56.4217972] → [407.2821:2939]

    if (grd[x][y] == DNGN_LAVA && beam.flavour == BEAM_COLD
         || grid_is_watery(grd[x][y]) && _is_fiery(beam))

[408.10301]

[56.4218159]

    if (grd(p) == DNGN_LAVA && beam.flavour == BEAM_COLD
         || grid_is_watery(grd(p)) && _is_fiery(beam))

Replacement in crawl-ref/source/beam.cc at line 3446 [56.4128068]

B:BD[56.4218165] → [208.16861:16938]

        place_cloud( CLOUD_STEAM, x, y, 2 + random2(5), _whose_kill(beam) );

[56.4218165]

[56.4218299]

        place_cloud( CLOUD_STEAM, p, 2 + random2(5), _whose_kill(beam) );

Replacement in crawl-ref/source/beam.cc at line 3490 [56.4128068]

B:BD[56.4220025] → [208.16939:17006]

        place_cloud( cl_type, x, y, duration, _whose_kill(beam) );

[56.4220025]

[56.4220076]

        place_cloud( cl_type, p, duration, _whose_kill(beam) );

Replacement in crawl-ref/source/beam.cc at line 3495 [56.4128068]

B:BD[56.4220199] → [208.17007:17089]

        place_cloud( CLOUD_COLD, x, y, 2 + random2avg(5, 2), _whose_kill(beam) );

[60.1240963]

[56.4220268]

        place_cloud( CLOUD_COLD, p, 2 + random2avg(5, 2), _whose_kill(beam) );

Replacement in crawl-ref/source/beam.cc at line 3500 [56.4128068]

B:BD[56.4220407] → [208.17090:17161]

        place_cloud( CLOUD_STINK, x, y, duration, _whose_kill(beam) );

[56.4220407]

[56.4220459]

        place_cloud( CLOUD_STINK, p, duration, _whose_kill(beam) );

Replacement in crawl-ref/source/beam.cc at line 3510 [56.4128068]

B:BD[56.4220674] → [208.17162:17232]

        place_cloud( CLOUD_FIRE, x, y, duration, _whose_kill(beam) );

[56.4220674]

[56.4220725]

        place_cloud( CLOUD_FIRE, p, duration, _whose_kill(beam) );

Replacement in crawl-ref/source/beam.cc at line 3512 [56.4128068]
∅:D[409.4597] → [56.4220726:4220791]
B:BD[56.4220726] → [56.4220726:4220791]
```
        if (grd[x][y] == DNGN_FLOOR && mgrd[x][y] == NON_MONSTER
```
[56.4220726]
[56.4220791]
```
        if (grd(p) == DNGN_FLOOR && mgrd(p) == NON_MONSTER
```

Replacement in crawl-ref/source/beam.cc at line 3520 [56.4128068]

B:BD[279.53891] → [279.53891:53930]

B:BD[279.53930] → [410.6402:6477]

                mgen_data::hostile_at(
                    MONS_FIRE_VORTEX, coord_def(x, y), 0, 0, false, god));

[279.53891]

[56.4220912]

                mgen_data::hostile_at(MONS_FIRE_VORTEX, p, 0, 0, false, god));

Replacement in crawl-ref/source/beam.cc at line 3560 [56.4128068]
B:BD[60.1241722] → [124.15238:15297]
∅:D[124.15297] → [60.1241782:1241834]
B:BD[60.1241782] → [60.1241782:1241834]
```
    int dist = grid_distance(beem.target_x, beem.target_y,
                             you.x_pos, you.y_pos);
```
[60.1241722]
[60.1241834]
```
    int dist = grid_distance(beem.target(), you.pos());
```
Replacement in crawl-ref/source/beam.cc at line 4179 [56.4128068]
∅:D[124.15572] → [59.8603:8668]
B:BD[59.8603] → [59.8603:8668]
```
        bleed_onto_floor(you.x_pos, you.y_pos, -1, blood, true);
```
[124.15572]
[59.8668]
```
        bleed_onto_floor(you.pos(), -1, blood, true);
```
Replacement in crawl-ref/source/beam.cc at line 4394 [56.4128068]
B:BD[60.1246988] → [60.1246988:1247033]
```
        if (!silenced(you.x_pos, you.y_pos))
```
[60.1246988]
[60.1247033]
```
        if (!silenced(you.pos()))
```

Replacement in crawl-ref/source/beam.cc at line 4460 [56.4128068]

B:BD[60.1247908] → [65.18072:18198]

                if (is_sanctuary(mon->x, mon->y)
                    || is_sanctuary(you.x_pos, you.y_pos))
                {

[60.1247908]

[65.18198]

                if (is_sanctuary(mon->pos()) || is_sanctuary(you.pos()))

Deletion in crawl-ref/source/beam.cc at line 4462 [56.4128068]
B:BD[65.18242] → [65.18242:18260]
```
                }
```

Replacement in crawl-ref/source/beam.cc at line 4650 [56.4128068]

B:BD[411.4884] → [65.18262:18376]

            if (is_sanctuary(mon->x, mon->y)
                || is_sanctuary(you.x_pos, you.y_pos))
            {

[411.4884]

[65.18376]

            if (is_sanctuary(mon->pos()) || is_sanctuary(you.pos()))

Deletion in crawl-ref/source/beam.cc at line 4652 [56.4128068]
B:BD[65.18416] → [65.18416:18430]
```
            }
```
Replacement in crawl-ref/source/beam.cc at line 4725 [56.4128068]
∅:D[412.3424] → [56.4240409:4240485]
B:BD[56.4240409] → [56.4240409:4240485]
```
        if (!silenced(you.x_pos, you.y_pos) && beam.flavour == BEAM_MISSILE
```
[412.3424]
[59.8847]
```
        if (!silenced(you.pos()) && beam.flavour == BEAM_MISSILE
```

Replacement in crawl-ref/source/beam.cc at line 4755 [56.4128068]

B:BD[59.9323] → [59.9323:9389]

        bleed_onto_floor(mon->x, mon->y, mon->type, blood, true);

[59.9323]

[59.9389]

        bleed_onto_floor(mon->pos(), mon->type, blood, true);

Replacement in crawl-ref/source/beam.cc at line 5182 [56.4128068]
B:BD[56.4249717] → [56.4249717:4249773]
```
    int x = pbolt.target_x;
    int y = pbolt.target_y;
```
[56.4249717]
[413.6208]
```
    coord_def p = pbolt.target();
```
Replacement in crawl-ref/source/beam.cc at line 5286 [56.4128068]
∅:D[414.6204] → [386.37395:37458]
B:BD[56.4252622] → [386.37395:37458]
```
        if (see_grid(x,y) || x == you.x_pos && y == you.y_pos)
```
[414.6204]
[56.4252687]
```
        if (see_grid(p) || p == you.pos())
```

Replacement in crawl-ref/source/beam.cc at line 5290 [56.4128068]

B:BD[56.4252735] → [386.37459:37524]

            if (silenced(x,y) || silenced(you.x_pos, you.y_pos))

[56.4252735]

[386.37524]

            if (silenced(p) || silenced(you.pos()))

Replacement in crawl-ref/source/beam.cc at line 5323 [56.4128068]

B:BD[415.1480] → [415.1480:1598]

        find_ray( beam.source_x, beam.source_y, beam.target_x, beam.target_y,
                  true, ray, 0, true );

[415.1480]

[415.1598]

        find_ray( beam.source(), beam.target(), true, ray, 0, true );

Replacement in crawl-ref/source/beam.cc at line 5326 [56.4128068]

B:BD[415.1657] → [415.1657:1723]

        if (ray.x() == beam.source_x && ray.y() == beam.source_y)

[415.1657]

[415.1723]

        if (ray.pos() == beam.source())

Replacement in crawl-ref/source/beam.cc at line 5403 [56.4128068]
B:BD[56.4253489] → [416.2882:2934]
```
    if (is_sanctuary(beam.target_x, beam.target_y))
```
[56.4253489]
[416.2934]
```
    if (is_sanctuary(beam.target()))
```
Replacement in crawl-ref/source/beam.cc at line 5426 [56.4128068]
B:BD[56.4253975] → [58.4252:4305]
```
    noisy(10 + 5 * r, beam.target_x, beam.target_y);
```
[56.4253975]
[56.4254028]
```
    noisy(10 + 5 * r, beam.target());
```
Replacement in crawl-ref/source/beam.cc at line 5436 [56.4128068]
∅:D[13.2812] → [208.19732:19773]
B:BD[56.4254458] → [208.19732:19773]
```
    _explosion_map(beam, 0, 0, 0, 0, r);
```
[13.2812]
[56.4254498]
```
    _explosion_map(beam, coord_def(0, 0), 0, 0, r);
```

Replacement in crawl-ref/source/beam.cc at line 5457 [56.4128068]

B:BD[56.4255086] → [208.19774:19824]

            _explosion_cell(beam, 0, 0, drawing);

[56.4255086]

[124.15985]

            _explosion_cell(beam, coord_def(0, 0), drawing);

Replacement in crawl-ref/source/beam.cc at line 5466 [56.4128068]

B:BD[56.4255363] → [208.19825:19887]

                    _explosion_cell(beam, -rad, ay, drawing);

[56.4255363]

[56.4255424]

                    _explosion_cell(beam, coord_def(-rad, ay), drawing);

Replacement in crawl-ref/source/beam.cc at line 5469 [56.4128068]

B:BD[56.4255471] → [208.19888:19949]

                    _explosion_cell(beam, rad, ay, drawing);

[56.4255471]

[56.4255531]

                    _explosion_cell(beam, coord_def(rad, ay), drawing);

Replacement in crawl-ref/source/beam.cc at line 5476 [56.4128068]

B:BD[56.4255690] → [208.19950:20012]

                    _explosion_cell(beam, ax, -rad, drawing);

[56.4255690]

[56.4255751]

                    _explosion_cell(beam, coord_def(ax, -rad), drawing);

Replacement in crawl-ref/source/beam.cc at line 5479 [56.4128068]

B:BD[56.4255798] → [208.20013:20074]

                    _explosion_cell(beam, ax, rad, drawing);

[56.4255798]

[56.4255858]

                    _explosion_cell(beam, coord_def(ax, rad), drawing);

Replacement in crawl-ref/source/beam.cc at line 5519 [56.4128068]

B:BD[56.4256539] → [208.20075:20144]

static void _explosion_cell(bolt &beam, int x, int y, bool drawOnly)

[56.4256539]

[56.4256614]

static void _explosion_cell(bolt &beam, const coord_def& p, bool drawOnly)

Replacement in crawl-ref/source/beam.cc at line 5522 [56.4128068]
B:BD[56.4256646] → [56.4256646:4256716]
```
    int realx = beam.target_x + x;
    int realy = beam.target_y + y;
```
[56.4256646]
[56.4256716]
```
    coord_def realpos = beam.target() + p;
```
Replacement in crawl-ref/source/beam.cc at line 5534 [56.4128068]
B:BD[56.4256936] → [56.4256936:4256972]
```
        affect(beam, realx, realy);
```
[56.4256936]
[56.4256972]
```
        affect(beam, realpos);
```

Replacement in crawl-ref/source/beam.cc at line 5546 [56.4128068]

B:BD[56.4257223] → [389.1952:2030]

        int drawx = grid2viewX(realx);
        int drawy = grid2viewY(realy);

[56.4257223]

[56.4257310]

        const coord_def drawpos = grid2view(realpos);

Replacement in crawl-ref/source/beam.cc at line 5548 [56.4128068]

B:BD[56.4257311] → [414.6458:6538]

        if (see_grid(realx, realy) || realx == you.x_pos && realy == you.y_pos)

[56.4257311]

[56.4257393]

        // XXX Don't you always see your own grid?
        if (see_grid(realpos) || realpos == you.pos())

Replacement in crawl-ref/source/beam.cc at line 5552 [56.4128068]

B:BD[178.5937550] → [178.5937550:5937663]

            if (in_los_bounds(drawx, drawy))
                TileDrawBolt(drawx-1, drawy-1, tileidx_bolt(beam));

[178.5937550]

[178.5937663]

            if (in_los_bounds(drawpos))
                TileDrawBolt(drawpos.x-1, drawpos.y-1, tileidx_bolt(beam));

Replacement in crawl-ref/source/beam.cc at line 5556 [56.4128068]
B:BD[56.4257431] → [389.2031:2076]
```
            if (in_los_bounds(drawx, drawy))
```
[56.4257431]
[56.4257499]
```
            if (in_los_bounds(drawpos))
```

Replacement in crawl-ref/source/beam.cc at line 5558 [56.4128068]

B:BD[56.4257513] → [397.8593:8643]

                cgotoxy(drawx, drawy, GOTO_DNGN);

[56.4257513]

[398.9032]

                cgotoxy(drawpos.x, drawpos.y, GOTO_DNGN);

Replacement in crawl-ref/source/beam.cc at line 5568 [56.4128068]
B:BD[56.4257768] → [208.20287:20341]
```
static void _explosion_map( bolt &beam, int x, int y,
```
[56.4257768]
[56.4257828]
```
static void _explosion_map( bolt &beam, const coord_def& p,
```
Replacement in crawl-ref/source/beam.cc at line 5572 [56.4128068]
∅:D[417.2823] → [387.41198:41227]
∅:D[340.22256] → [387.41198:41227]
B:BD[56.4257921] → [387.41198:41227]
```
    if (x*x + y*y > r*r + r)
```
[417.2823]
[56.4257956]
```
    if (p.x*p.x + p.y*p.y > r*r + r)
```
Replacement in crawl-ref/source/beam.cc at line 5579 [56.4128068]
∅:D[48.12442] → [417.2847:2910]
B:BD[417.2847] → [417.2847:2910]
```
    const coord_def loc(beam.target_x + x, beam.target_y + y);
```
[48.12442]
[198.5849]
```
    const coord_def loc(beam.target() + p);
```
Replacement in crawl-ref/source/beam.cc at line 5586 [56.4128068]
B:BD[417.3022] → [417.3022:3058]
```
    if (is_sanctuary(loc.x, loc.y))
```
[417.3022]
[56.4258017]
```
    if (is_sanctuary(loc))
```
Replacement in crawl-ref/source/beam.cc at line 5591 [56.4128068]
B:BD[417.3180] → [417.3180:3216]
```
    const int dngn_feat = grd(loc);
```
[417.3180]
[56.4258235]
```
    const dungeon_feature_type dngn_feat = grd(loc);
```

Replacement in crawl-ref/source/beam.cc at line 5597 [56.4128068]

B:BD[78.41318] → [78.41318:41384]

        && (x != 0 || y != 0) && !_affects_wall(beam, dngn_feat))

[78.41318]

[56.4258485]

        && (p.x != 0 || p.y != 0) && !_affects_wall(beam, dngn_feat))

Replacement in crawl-ref/source/beam.cc at line 5603 [56.4128068]

∅:D[340.22453] → [56.4258576:4258610]

B:BD[56.4258576] → [56.4258576:4258610]

    explode_map[x+9][y+9] = true;

[340.22453]

[56.4258610]

    explode_map(p + coord_def(9,9)) = true;
    const coord_def spread[] = { coord_def(0, -1), coord_def( 0, 1),
                                 coord_def(1,  0), coord_def(-1, 0) };
    const int opdir[]        = { 2, 1, 4, 3 };

Replacement in crawl-ref/source/beam.cc at line 5610 [56.4128068]
∅:D[340.22521] → [78.41468:41500]
B:BD[78.41468] → [78.41468:41500]
```
    for (int i = 0; i < 4; i++)
```
[340.22521]
[56.4258711]
```
    const int spreadsize = ARRAYSZ(spread);
    for (int i = 0; i < spreadsize; i++)
```

Replacement in crawl-ref/source/beam.cc at line 5616 [56.4128068]

B:BD[56.4258777] → [56.4258777:4258835]

            if (x * spreadx[i] < 0 || y * spready[i] < 0)

[56.4258777]

[56.4258835]

            if (p.x * spread[i].x < 0 || p.y * spread[i].y < 0)

Replacement in crawl-ref/source/beam.cc at line 5619 [56.4128068]

B:BD[56.4258863] → [208.20407:20530]

            _explosion_map( beam, x + spreadx[i], y + spready[i],
                            count + cadd, opdir[i], r );

[56.4258863]

[56.4258984]

            _explosion_map( beam, p + spread[i], count + cadd, opdir[i], r );

Insertion in crawl-ref/source/acr.cc at line 181 [56.4397395]
[418.16604]
[419.2766]
```
static void _move_player(coord_def move);
```

Replacement in crawl-ref/source/acr.cc at line 637 [56.4397395]

B:BD[56.4411028] → [56.4411028:4411091]

            move_item_to_grid( &islot, you.x_pos, you.y_pos );

[56.4411028]

[56.4411091]

            move_item_to_grid( &islot, you.pos() );

Replacement in crawl-ref/source/acr.cc at line 654 [56.4397395]

B:BD[56.4411575] → [56.4411575:4411642]

                move_item_to_grid( &islot, you.x_pos, you.y_pos );

[56.4411575]

[420.7459]

                move_item_to_grid( &islot, you.pos() );

Replacement in crawl-ref/source/acr.cc at line 676 [56.4397395]

B:BD[421.880] → [421.880:943]

            move_item_to_grid( &islot, you.x_pos, you.y_pos );

[421.880]

[421.943]

            move_item_to_grid( &islot, you.pos() );

Replacement in crawl-ref/source/acr.cc at line 1696 [56.4397395]

B:BD[84.90382] → [422.756:901]

    bool shaft = (trap_type_at_xy(you.x_pos, you.y_pos) == TRAP_SHAFT
                  && grd[you.x_pos][you.y_pos] != DNGN_UNDISCOVERED_TRAP);

[84.90382]

[130.3558]

    bool shaft = (trap_type_at_xy(you.pos()) == TRAP_SHAFT
                  && grd(you.pos()) != DNGN_UNDISCOVERED_TRAP);

Replacement in crawl-ref/source/acr.cc at line 2910 [56.4397395]

∅:D[317.18232] → [423.2120:2196]

B:BD[423.2120] → [423.2120:2196]

            move_player_to_grid( you.x_pos, you.y_pos, false, true, true );

[317.18232]

[56.4455290]

            move_player_to_grid( you.pos(), false, true, true );

Replacement in crawl-ref/source/acr.cc at line 3040 [56.4397395]
B:BD[100.8712] → [100.8712:8755]
```
        ASSERT(in_bounds(trap.x, trap.y));
```
[100.8712]
[100.8755]
```
        ASSERT(in_bounds(trap.pos()));
```
Replacement in crawl-ref/source/acr.cc at line 3042 [56.4397395]
B:BD[100.8756] → [100.8756:8809]
```
        handle_items_on_shaft(trap.x, trap.y, true);
```
[100.8756]
[100.8809]
```
        handle_items_on_shaft(trap.pos(), true);
```

Replacement in crawl-ref/source/acr.cc at line 3588 [56.4397395]

B:BD[58.4412] → [58.4412:4461]

                noisy(15, you.x_pos, you.y_pos);

[58.4412]

[424.3280]

                noisy(15, you.pos());

Replacement in crawl-ref/source/acr.cc at line 3591 [56.4397395]

B:BD[424.3304] → [424.3304:3378]

        else if (one_chance_in(skill) && !silenced(you.x_pos, you.y_pos))

[424.3304]

[56.4465973]

        else if (one_chance_in(skill) && !silenced(you.pos()))

Replacement in crawl-ref/source/acr.cc at line 3595 [56.4397395]
B:BD[58.4564] → [58.4564:4609]
```
            noisy(10, you.x_pos, you.y_pos);
```
[58.4564]
[56.4466092]
```
            noisy(10, you.pos());
```

Replacement in crawl-ref/source/acr.cc at line 3617 [56.4397395]

B:BD[425.2888] → [16.3759:3832]

                if (!seen_secret && grd[dc.x][dc.y] == DNGN_SECRET_DOOR)

[425.2888]

[16.3832]

                if (!seen_secret && grd(dc) == DNGN_SECRET_DOOR)

Replacement in crawl-ref/source/acr.cc at line 3621 [56.4397395]

B:BD[16.3938] → [16.3938:4005]

                        = grid_secret_door_appearance(dc.x, dc.y);

[16.3938]

[16.4005]

                        = grid_secret_door_appearance(dc);

Replacement in crawl-ref/source/acr.cc at line 3748 [56.4397395]

B:BD[58.4725] → [58.4725:4774]

                noisy(25, you.x_pos, you.y_pos);

[58.4725]

[424.3677]

                noisy(25, you.pos());

Replacement in crawl-ref/source/acr.cc at line 3755 [56.4397395]
B:BD[58.4878] → [58.4878:4923]
```
            noisy(10, you.x_pos, you.y_pos);
```
[58.4878]
[56.4467964]
```
            noisy(10, you.pos());
```

Insertion in crawl-ref/source/acr.cc at line 4039 [56.4397395]

[418.27732]

[56.4472973]

{
    _move_player( coord_def(move_x, move_y) );
}
static void _move_player(coord_def move)

Deletion in crawl-ref/source/acr.cc at line 4048 [56.4397395]
B:BD[60.1280617] → [426.2722:2795]
```
    monsters *beholder = NULL;  // beholding monster preventing movement
```
Insertion in crawl-ref/source/acr.cc at line 4056 [56.4397395]
[56.4473080]
[427.19983]
```
    // When confused, sometimes make a random move
```

Replacement in crawl-ref/source/acr.cc at line 4061 [56.4397395]

B:BD[56.4473178] → [56.4473178:4473252]

            move_x = random2(3) - 1;
            move_y = random2(3) - 1;

[56.4473178]

[179.3251]

            move.x = random2(3) - 1;
            move.y = random2(3) - 1;

Replacement in crawl-ref/source/acr.cc at line 4065 [56.4397395]

B:BD[56.4473262] → [56.4473262:4473365]

B:BD[56.4473365] → [60.1280618:1280665]

B:BD[60.1280665] → [428.4534:4596]


        const int new_targ_x = you.x_pos + move_x;
        const int new_targ_y = you.y_pos + move_y;
        if (!in_bounds(new_targ_x, new_targ_y)
            || !you.can_pass_through(new_targ_x, new_targ_y))

[56.4473262]

[56.4473480]

        
        const coord_def& new_targ = you.pos() + move;
        if (!in_bounds(new_targ) || !you.can_pass_through(new_targ))

Replacement in crawl-ref/source/acr.cc at line 4076 [56.4397395]
B:BD[56.4474507] → [427.20016:20058]
```
    } // end of if you.duration[DUR_CONF]
```
[56.4474507]
[248.10727]
```
    }
```

Replacement in crawl-ref/source/acr.cc at line 4078 [56.4397395]

B:BD[248.10728] → [248.10728:10948]

B:BD[248.10948] → [428.4597:4673]

    const int targ_x = you.x_pos + move_x;
    const int targ_y = you.y_pos + move_y;
    const dungeon_feature_type targ_grid  =  grd[ targ_x ][ targ_y ];
    const unsigned short targ_monst = mgrd[ targ_x ][ targ_y ];
    const bool           targ_pass  = you.can_pass_through(targ_x, targ_y);

[248.10728]

[248.11011]

    const coord_def& targ = you.pos() + move;
    const dungeon_feature_type targ_grid  =  grd(targ);
    const unsigned short targ_monst = mgrd(targ);
    const bool           targ_pass  = you.can_pass_through(targ);

Replacement in crawl-ref/source/acr.cc at line 4089 [56.4397395]

B:BD[65.18974] → [65.18974:19123]

                                     || is_sanctuary(you.x_pos, you.y_pos)
                                        && is_sanctuary(targ_x, targ_y));

[65.18974]

[65.19123]

                                     || is_sanctuary(you.pos())
                                        && is_sanctuary(targ));

Insertion in crawl-ref/source/acr.cc at line 4094 [56.4397395]
[340.25548]
[426.2850]
```
    monsters *beholder = NULL;
```

Replacement in crawl-ref/source/acr.cc at line 4099 [56.4397395]

B:BD[248.11311] → [130.3608:3703]

B:BD[130.3703] → [429.4900:5115]

             monsters* mon = &menv[you.beheld_by[i]];
             coord_def pos = mon->pos();
             int olddist = grid_distance(you.x_pos, you.y_pos, pos.x, pos.y);
             int newdist = grid_distance(you.x_pos + move_x, you.y_pos + move_y,
                                         pos.x, pos.y);

[248.11311]

[130.3831]

             monsters& mon = menv[you.beheld_by[i]];
             int olddist = grid_distance(you.pos(), mon.pos());
             int newdist = grid_distance(targ, mon.pos());

Replacement in crawl-ref/source/acr.cc at line 4105 [56.4397395]
B:BD[248.11599] → [426.2912:2945]
```
                 beholder = mon;
```
[248.11599]
[426.2945]
```
                 beholder = &mon;
```
Replacement in crawl-ref/source/acr.cc at line 4109 [56.4397395]
B:BD[248.11869] → [248.11869:11901]
```
    } // end of beholding check
```
[248.11869]
[56.4474561]
```
    }
```
Deletion in crawl-ref/source/acr.cc at line 4113 [56.4397395]
∅:D[62.552892] → [56.4474662:4474702]
B:BD[56.4474662] → [56.4474662:4474702]
```
        move_x = 0;
        move_y = 0;
```

Replacement in crawl-ref/source/acr.cc at line 4154 [56.4397395]

B:BD[60.1281684] → [47.4100:4175]

        if (!move_player_to_grid(targ_x, targ_y, true, false, swap, swap))

[60.1281684]

[430.741]

        if (!move_player_to_grid(targ, true, false, swap, swap))

Replacement in crawl-ref/source/acr.cc at line 4160 [56.4397395]
B:BD[179.3288] → [179.3288:3356]
∅:D[430.761] → [105.5623:5624]
∅:D[179.3356] → [105.5623:5624]
B:BD[60.1281748] → [105.5623:5624]
B:BD[56.4478886] → [56.4478886:4478926]
B:BD[56.4479884] → [56.4479884:4479885]
```
        you.prev_move_x = move_x;
        you.prev_move_y = move_y;
        move_x = 0;
        move_y = 0;
```
[179.3288]
[60.1282102]
```
        you.prev_move = move;
        move.reset();
```
Deletion in crawl-ref/source/acr.cc at line 4163 [56.4397395]
B:BD[60.1282135] → [431.662:694]
```
        // item_check( false );
```
Deletion in crawl-ref/source/acr.cc at line 4164 [56.4397395]
B:BD[431.724] → [105.5792:5793]

Replacement in crawl-ref/source/acr.cc at line 4169 [56.4397395]

B:BD[179.3363] → [418.27733:27776]

∅:D[418.27776] → [179.3364:3432]

B:BD[60.1282267] → [179.3364:3432]

        _open_door(move_x, move_y, false);
        you.prev_move_x = move_x;
        you.prev_move_y = move_y;

[179.3363]

[179.3432]

        _open_door(move.x, move.y, false);
        you.prev_move = move;

Replacement in crawl-ref/source/acr.cc at line 4175 [56.4397395]
B:BD[62.553081] → [432.2503:2504]
∅:D[432.2504] → [56.4480247:4480287]
∅:D[62.553081] → [56.4480247:4480287]
B:BD[56.4480247] → [56.4480247:4480287]
B:BD[56.4480287] → [432.2505:2506]
∅:D[432.2506] → [56.4480287:4480317]
B:BD[56.4480287] → [56.4480287:4480317]
```
        move_x = 0;
        move_y = 0;
        you.turn_is_over = 0;
```
[62.553081]
[343.31486]
```
        move.reset();
        you.turn_is_over = false;
```
Deletion in crawl-ref/source/acr.cc at line 4183 [56.4397395]
B:BD[426.3257] → [426.3257:3298]
```
        move_x = 0;
        move_y = 0;
```

Replacement in crawl-ref/source/acr.cc at line 4199 [56.4397395]

B:BD[56.4480673] → [56.4480673:4480766]

B:BD[56.4480776] → [56.4480776:4480844]

        int igly = 0;
        int ig2 = 0;
        for (igly = 0; igly < MAX_ITEMS; igly++)
            if (is_valid_item( mitm[igly] ))
                ig2++;

[56.4480673]

[56.4480854]

        int j = 0;
        for (int i = 0; i < MAX_ITEMS; i++)
            if (is_valid_item( mitm[i] ))
                ++j;

Replacement in crawl-ref/source/acr.cc at line 4204 [56.4397395]

B:BD[56.4480855] → [185.16058:16129]

        mprf( MSGCH_DIAGNOSTICS, "Number of items present: %d", ig2 );

[56.4480855]

[56.4480968]

        mprf( MSGCH_DIAGNOSTICS, "Number of items present: %d", j );

Replacement in crawl-ref/source/acr.cc at line 4206 [56.4397395]

B:BD[56.4480969] → [56.4480969:4481038]

B:BD[56.4481048] → [56.4481048:4481110]

        ig2 = 0;
        for (igly = 0; igly < MAX_MONSTERS; igly++)
            if (menv[igly].type != -1)
                ig2++;

[56.4480969]

[56.4481120]

        j = 0;
        for (int i = 0; i < MAX_MONSTERS; i++)
            if (menv[i].type != -1)
                ++j;

Replacement in crawl-ref/source/acr.cc at line 4211 [56.4397395]

B:BD[56.4481121] → [433.28178:28251]

        mprf( MSGCH_DIAGNOSTICS, "Number of monsters present: %d", ig2);

[56.4481121]

[433.28251]

        mprf( MSGCH_DIAGNOSTICS, "Number of monsters present: %d", j);

Replacement in crawl-ref/source/acr.cc at line 4217 [56.4397395]
∅:D[60.1282408] → [56.4481447:4481500]
B:BD[56.4481447] → [56.4481447:4481500]
```
}                               // end move_player()
```
[60.1282408]
[343.31528]
```
}
```

Replacement in crawl-ref/source/abyss.cc at line 63 [56.4482606]

B:BD[434.996] → [435.4443:4514]

        if (not_seen && grid_see_grid(cp.x, cp.y, centre.x, centre.y))

[434.996]

[435.4514]

        if (not_seen && grid_see_grid(cp, centre))

Replacement in crawl-ref/source/abyss.cc at line 262 [56.4482606]

B:BD[56.4486960] → [56.4486960:4487023]

                    move_item_to_grid( &thing_created, i, j );

[56.4486960]

[56.4487023]

                    move_item_to_grid( &thing_created, coord_def(i, j) );

Replacement in crawl-ref/source/abyss.cc at line 489 [56.4482606]

B:BD[295.5775] → [41.3547:3606]

    for (int i = you.x_pos - 10; i <= you.x_pos + 10; i++)

[295.5775]

[56.4489165]

    for (radius_iterator ri(you.pos(), 10, true, false); ri; ++ri)

Replacement in crawl-ref/source/abyss.cc at line 491 [56.4482606]

B:BD[56.4489171] → [56.4489171:4489224]

        if (i < 0 || i >= GXM)
            continue;

[56.4489171]

[56.4489224]

        const coord_def newpos = coord_def(45,35) + *ri - you.pos();

Replacement in crawl-ref/source/abyss.cc at line 493 [56.4482606]

B:BD[56.4489225] → [41.3607:3670]

∅:D[41.3670] → [56.4489287:4489458]

B:BD[56.4489287] → [56.4489287:4489458]

B:BD[56.4489458] → [295.5776:5805]

∅:D[295.5805] → [56.4489486:4489528]

B:BD[56.4489486] → [56.4489486:4489528]

B:BD[56.4489528] → [295.5806:5832]

        for (int j = you.y_pos - 10; j <= you.y_pos + 10; j++)
        {
            if (j < 0 || j >= GYM)
                continue;
            const int ipos = 45 + i - you.x_pos;
            const int jpos = 35 + j - you.y_pos;
            // Move terrain.
            grd[ipos][jpos] = grd[i][j];
            // Move item.

[56.4489225]

[41.3671]

        // Move terrain.
        grd(newpos) = grd(*ri);
        
        // Move item.

Replacement in crawl-ref/source/abyss.cc at line 498 [56.4482606]

B:BD[41.3690] → [41.3690:3907]

            if (igrd[i][j] != NON_ITEM)
            {
                 mprf(MSGCH_DIAGNOSTICS,
                      "Move item stack from (%d, %d) to (%d, %d)",
                      i, j, ipos, jpos);
            }

[41.3690]

[41.3907]

        if (igrd(*ri) != NON_ITEM)
        {
            mprf(MSGCH_DIAGNOSTICS,
                 "Move item stack from (%d, %d) to (%d, %d)",
                 ri->x, ri->y, newpos.x, newpos.y);
        }

Replacement in crawl-ref/source/abyss.cc at line 505 [56.4482606]
∅:D[41.3914] → [56.4489553:4489610]
∅:D[295.5832] → [56.4489553:4489610]
B:BD[56.4489553] → [56.4489553:4489610]
```
            move_item_stack_to_grid( i, j, ipos, jpos );
```
[41.3914]
[56.4489610]
```
        move_item_stack_to_grid( *ri, newpos );
```

Replacement in crawl-ref/source/abyss.cc at line 507 [56.4482606]

B:BD[56.4489611] → [295.5833:5862]

∅:D[295.5862] → [56.4489639:4489893]

B:BD[56.4489639] → [56.4489639:4489893]

            // Move monster.
            mgrd[ipos][jpos] = mgrd[i][j];
            if (mgrd[i][j] != NON_MONSTER)
            {
                menv[mgrd[ipos][jpos]].x = ipos;
                menv[mgrd[ipos][jpos]].y = jpos;
                mgrd[i][j] = NON_MONSTER;
            }

[56.4489611]

[56.4489893]

        // Move monster.
        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;
        }

Replacement in crawl-ref/source/abyss.cc at line 516 [56.4482606]

B:BD[56.4489894] → [295.5863:5890]

∅:D[295.5890] → [56.4489920:4490037]

B:BD[56.4489920] → [56.4489920:4490037]

            // Move cloud,
            if (env.cgrid[i][j] != EMPTY_CLOUD)
                move_cloud( env.cgrid[i][j], ipos, jpos );
        }

[56.4489894]

[56.4490037]

        // Move cloud,
        if (env.cgrid(*ri) != EMPTY_CLOUD)
            move_cloud( env.cgrid(*ri), newpos );

Massive change from using x and y to using coord_defs(). Not quite tested,

Dependencies

In channels

Change contents

Replacement in crawl-ref/source/xom.cc at line 217 [52.3]

Replacement in crawl-ref/source/view.h at line 96 [56.13254]

Replacement in crawl-ref/source/view.h at line 108 [56.13254]

Replacement in crawl-ref/source/view.h at line 134 [56.13254]

Replacement in crawl-ref/source/view.h at line 157 [56.13254]

Replacement in crawl-ref/source/view.h at line 164 [56.13254]

Replacement in crawl-ref/source/view.h at line 200 [56.13254]

Replacement in crawl-ref/source/view.h at line 235 [56.13254]

Replacement in crawl-ref/source/view.h at line 239 [56.13254]

Replacement in crawl-ref/source/view.cc at line 155 [56.16817]

Replacement in crawl-ref/source/view.cc at line 247 [56.16817]

Replacement in crawl-ref/source/view.cc at line 249 [56.16817]

Replacement in crawl-ref/source/view.cc at line 253 [56.16817]

Replacement in crawl-ref/source/view.cc at line 255 [56.16817]

Replacement in crawl-ref/source/view.cc at line 417 [56.16817]

Replacement in crawl-ref/source/view.cc at line 444 [56.16817]

Replacement in crawl-ref/source/view.cc at line 1106 [56.16817]

Replacement in crawl-ref/source/view.cc at line 1535 [56.16817]

Deletion in crawl-ref/source/view.cc at line 1537 [56.16817]

Replacement in crawl-ref/source/view.cc at line 1540 [56.16817]

Insertion in crawl-ref/source/view.cc at line 1544 [56.16817]

Deletion in crawl-ref/source/view.cc at line 1546 [56.16817]

Replacement in crawl-ref/source/view.cc at line 1547 [56.16817]

Replacement in crawl-ref/source/view.cc at line 1568 [56.16817]

Replacement in crawl-ref/source/view.cc at line 1573 [56.16817]

Replacement in crawl-ref/source/view.cc at line 1578 [56.16817]

Replacement in crawl-ref/source/view.cc at line 1581 [56.16817]

Replacement in crawl-ref/source/view.cc at line 1604 [56.16817]

Replacement in crawl-ref/source/view.cc at line 1606 [56.16817]

Replacement in crawl-ref/source/view.cc at line 1612 [56.16817]

Replacement in crawl-ref/source/view.cc at line 1624 [56.16817]

Replacement in crawl-ref/source/view.cc at line 1635 [56.16817]

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

Replacement in crawl-ref/source/view.cc at line 1672 [56.16817]

Replacement in crawl-ref/source/view.cc at line 1681 [56.16817]

Replacement in crawl-ref/source/view.cc at line 1684 [56.16817]

Replacement in crawl-ref/source/view.cc at line 2347 [56.16817]

Replacement in crawl-ref/source/view.cc at line 2358 [56.16817]

Insertion in crawl-ref/source/view.cc at line 2363 [56.16817]

Insertion in crawl-ref/source/view.cc at line 2373 [56.16817]

Replacement in crawl-ref/source/view.cc at line 2532 [56.16817]

Replacement in crawl-ref/source/view.cc at line 2539 [56.16817]

Replacement in crawl-ref/source/view.cc at line 2544 [56.16817]

Replacement in crawl-ref/source/view.cc at line 2546 [56.16817]

Replacement in crawl-ref/source/view.cc at line 2556 [56.16817]

Replacement in crawl-ref/source/view.cc at line 2558 [56.16817]

Replacement in crawl-ref/source/view.cc at line 2617 [56.16817]

Insertion in crawl-ref/source/view.cc at line 2621 [56.16817]

Replacement in crawl-ref/source/view.cc at line 2657 [56.16817]

Replacement in crawl-ref/source/view.cc at line 2721 [56.16817]

Replacement in crawl-ref/source/view.cc at line 2723 [56.16817]

Replacement in crawl-ref/source/view.cc at line 2728 [56.16817]

Replacement in crawl-ref/source/view.cc at line 2733 [56.16817]

Replacement in crawl-ref/source/view.cc at line 2736 [56.16817]

Replacement in crawl-ref/source/view.cc at line 2738 [56.16817]

Replacement in crawl-ref/source/view.cc at line 2846 [56.16817]

Replacement in crawl-ref/source/view.cc at line 2850 [56.16817]

Replacement in crawl-ref/source/view.cc at line 2852 [56.16817]

Replacement in crawl-ref/source/view.cc at line 2855 [56.16817]

Replacement in crawl-ref/source/view.cc at line 2860 [56.16817]