fiddlerwoaroof/crawl - Change EXYVMVO2EMMZW4LRYSHHHNRFLQ7P6YHNM7SLUO2X2KUMV3WQHQZQC

Move most exclusion code from travel.cc to exclude.cc.

Created by Robert Vollmert on October 26, 2009

EXYVMVO2EMMZW4LRYSHHHNRFLQ7P6YHNM7SLUO2X2KUMV3WQHQZQC

Dependencies

In channels

main

Change contents

Insertion in crawl-ref/source/travel.h at line 11 [7.29464]
[6.40]
[6.40]
```
#include "exclude.h"
```
Deletion in crawl-ref/source/travel.h at line 64 [7.29464]
B:BD[7.30213] → [8.1242:1289]
B:BD[8.1289] → [9.171:209]
B:BD[9.209] → [10.514:576]
B:BD[10.576] → [11.39:104]
∅:D[11.104] → [12.494:581]
∅:D[9.295] → [12.494:581]
∅:D[10.617] → [12.494:581]
B:BD[12.494] → [12.494:581]
∅:D[12.581] → [7.30248:30271]
∅:D[8.1381] → [7.30248:30271]
B:BD[7.30248] → [7.30248:30271]
```
void cycle_exclude_radius(const coord_def &p);
void del_exclude(const coord_def &p);
void set_exclude(const coord_def &p, int radius = LOS_RADIUS,
                 bool autoexcl = false, bool vaultexcl = false);
void maybe_remove_autoexclusion(const coord_def &p);
std::string get_exclusion_desc();
void clear_excludes();
```
Deletion in crawl-ref/source/travel.h at line 66 [7.29464]
B:BD[7.30336] → [8.1382:1424]
```
bool is_exclude_root(const coord_def &p);
```
Deletion in crawl-ref/source/travel.h at line 72 [7.29464]
B:BD[13.191] → [14.173:211]
```
bool is_excluded(const coord_def &p);
```
Deletion in crawl-ref/source/travel.h at line 344 [7.29464]
B:BD[7.36559] → [15.227:255]
B:BD[15.255] → [9.296:355]
```
void init_exclusion_los();
void update_exclusion_los(std::vector<coord_def> changed);
```
Deletion in crawl-ref/source/travel.h at line 345 [7.29464]
B:BD[7.36560] → [8.1425:1449]
B:BD[8.1449] → [6.59:278]
B:BD[6.278] → [16.39:97]
B:BD[16.97] → [17.39:118]
∅:D[17.118] → [16.98:167]
B:BD[6.415] → [16.98:167]
∅:D[16.167] → [6.416:476]
B:BD[11.530] → [6.416:476]
B:BD[6.476] → [3.39:116]
∅:D[3.116] → [16.232:272]
∅:D[17.193] → [16.232:272]
B:BD[16.232] → [16.232:272]
∅:D[18.172] → [8.1490:1491]
∅:D[16.272] → [8.1490:1491]
∅:D[15.321] → [8.1490:1491]
∅:D[11.530] → [8.1490:1491]
∅:D[6.586] → [8.1490:1491]
∅:D[12.935] → [8.1490:1491]
∅:D[19.2786] → [8.1490:1491]
B:BD[8.1490] → [8.1490:1491]
B:BD[8.1491] → [9.356:383]
B:BD[9.383] → [6.587:653]
∅:D[18.193] → [9.384:428]
∅:D[20.420] → [9.384:428]
∅:D[6.653] → [9.384:428]
B:BD[15.351] → [9.384:428]
B:BD[8.1673] → [8.1673:1677]
```
struct travel_exclude
{
    coord_def     pos;          // exclusion centre
    int           radius;       // exclusion radius
    los_def       los;          // los from exclusion centre
    bool          uptodate;     // Is los up to date?
    bool          autoex;       // Was set automatically.
    monster_type  mon;          // Monster around which exclusion is centered.
    bool          vault;        // Is this exclusion set by a vault?
    travel_exclude(const coord_def &p, int r = LOS_RADIUS,
                   bool autoex = false, monster_type mons = MONS_NO_MONSTER,
                   bool vault = false);
    int radius_sq() const;
    void set_los();
    bool in_bounds(const coord_def& p) const;
    bool affects(const coord_def& p) const;
};
```
Insertion in crawl-ref/source/travel.cc at line 23 [7.39949]
[21.283]
[22.534]
```
#include "exclude.h"
```
Replacement in crawl-ref/source/travel.cc at line 89 [7.39949]
B:BD[6.700] → [6.700:730]
```
static exclvec curr_excludes;
```
[6.700]
[7.41061]
```
exclvec curr_excludes;
```
Deletion in crawl-ref/source/travel.cc at line 272 [7.39949]
B:BD[23.350] → [15.383:385]
B:BD[15.385] → [19.2788:2789]
B:BD[19.2789] → [24.34:88]
∅:D[24.88] → [19.2838:2840]
∅:D[25.268] → [19.2838:2840]
∅:D[26.277] → [19.2838:2840]
B:BD[19.2838] → [19.2838:2840]
B:BD[19.2840] → [27.3187:3247]
∅:D[27.3247] → [24.149:151]
B:BD[24.149] → [24.149:151]
∅:D[24.151] → [15.385:386]
∅:D[25.552] → [15.385:386]
∅:D[19.3273] → [15.385:386]
B:BD[15.385] → [15.385:386]
B:BD[15.386] → [24.152:259]
B:BD[24.259] → [6.731:760]
∅:D[6.760] → [24.259:313]
B:BD[24.259] → [24.259:313]
∅:D[24.313] → [25.682:688]
B:BD[25.682] → [25.682:688]
B:BD[25.688] → [24.314:347]
∅:D[24.347] → [25.760:790]
B:BD[25.760] → [25.760:790]
B:BD[25.790] → [24.348:568]
∅:D[24.568] → [25.1010:1171]
B:BD[25.1010] → [25.1010:1171]
∅:D[25.1171] → [19.3679:3689]
B:BD[19.3679] → [19.3679:3689]
B:BD[19.3689] → [25.1172:1181]
B:BD[25.1181] → [6.761:1048]
∅:D[24.592] → [9.700:701]
∅:D[6.1048] → [9.700:701]
B:BD[25.1181] → [9.700:701]
B:BD[9.701] → [6.1049:1107]
B:BD[6.1107] → [28.40:121]
∅:D[28.121] → [6.1173:1257]
∅:D[16.346] → [6.1173:1257]
B:BD[6.1173] → [6.1173:1257]
B:BD[6.1257] → [5.40:111]
∅:D[5.111] → [9.739:741]
∅:D[16.407] → [9.739:741]
∅:D[6.1325] → [9.739:741]
B:BD[9.739] → [9.739:741]
B:BD[9.741] → [6.1326:1341]
∅:D[6.1341] → [9.790:792]
B:BD[9.790] → [9.790:792]
∅:D[9.792] → [19.3710:3711]
∅:D[25.1181] → [19.3710:3711]
B:BD[19.3710] → [19.3710:3711]
B:BD[19.3711] → [6.1342:1373]
∅:D[18.246] → [15.426:428]
∅:D[20.491] → [15.426:428]
∅:D[6.1373] → [15.426:428]
B:BD[15.426] → [15.426:428]
∅:D[18.307] → [19.3822:3843]
∅:D[29.374] → [19.3822:3843]
∅:D[24.658] → [19.3822:3843]
∅:D[30.790] → [19.3822:3843]
∅:D[9.846] → [19.3822:3843]
∅:D[25.1222] → [19.3822:3843]
B:BD[19.3822] → [19.3822:3843]
B:BD[19.3843] → [31.40:60]
B:BD[31.60] → [6.1374:1517]
∅:D[31.124] → [9.847:1039]
∅:D[20.561] → [9.847:1039]
∅:D[6.1517] → [9.847:1039]
B:BD[19.3843] → [9.847:1039]
B:BD[9.1039] → [31.125:173]
B:BD[31.173] → [6.1518:1680]
∅:D[18.338] → [15.457:548]
∅:D[20.599] → [15.457:548]
∅:D[32.1037] → [15.457:548]
∅:D[9.1076] → [15.457:548]
∅:D[6.1680] → [15.457:548]
∅:D[19.3843] → [15.457:548]
B:BD[15.457] → [15.457:548]
B:BD[15.548] → [6.1681:1717]
∅:D[18.375] → [15.593:596]
∅:D[20.645] → [15.593:596]
∅:D[6.1717] → [15.593:596]
B:BD[15.593] → [15.593:596]
B:BD[15.596] → [9.1077:1129]
∅:D[9.1129] → [15.636:638]
∅:D[19.3890] → [15.636:638]
B:BD[15.636] → [15.636:638]
B:BD[15.638] → [6.1718:1902]
∅:D[6.1902] → [9.1273:1276]
B:BD[9.1273] → [9.1273:1276]
B:BD[9.1276] → [33.34:77]
∅:D[33.77] → [9.1305:1307]
B:BD[9.1305] → [9.1305:1307]
B:BD[9.1307] → [6.1903:2091]
∅:D[18.416] → [19.4027:4030]
∅:D[20.695] → [19.4027:4030]
∅:D[6.2091] → [19.4027:4030]
B:BD[19.4027] → [19.4027:4030]
B:BD[19.4030] → [9.1408:1685]
∅:D[9.1685] → [19.4067:4069]
B:BD[19.4067] → [19.4067:4069]
B:BD[19.4069] → [9.1686:1859]
∅:D[23.350] → [7.45845:45848]
∅:D[15.807] → [7.45845:45848]
∅:D[9.1859] → [7.45845:45848]
∅:D[8.1971] → [7.45845:45848]
∅:D[19.4172] → [7.45845:45848]
B:BD[7.45845] → [7.45845:45848]
B:BD[7.45848] → [34.612:657]
B:BD[34.657] → [6.2092:2137]
∅:D[35.181] → [7.45886:45888]
∅:D[34.722] → [7.45886:45888]
∅:D[8.2080] → [7.45886:45888]
∅:D[6.2137] → [7.45886:45888]
B:BD[7.45886] → [7.45886:45888]
B:BD[7.45888] → [9.1860:1941]
∅:D[15.927] → [8.2138:2165]
∅:D[9.1941] → [8.2138:2165]
B:BD[8.2138] → [8.2138:2165]
∅:D[34.724] → [8.2166:2186]
B:BD[7.46155] → [8.2166:2186]
∅:D[8.2186] → [35.277:280]
B:BD[7.46173] → [35.277:280]
B:BD[35.280] → [36.158:195]
∅:D[36.195] → [35.398:400]
∅:D[14.257] → [35.398:400]
∅:D[8.2238] → [35.398:400]
B:BD[35.398] → [35.398:400]
∅:D[37.238] → [34.725:768]
B:BD[35.400] → [34.725:768]
∅:D[34.768] → [35.439:442]
∅:D[8.2281] → [35.439:442]
B:BD[35.439] → [35.439:442]
B:BD[35.442] → [34.769:831]
∅:D[34.831] → [35.487:489]
∅:D[8.2343] → [35.487:489]
B:BD[35.487] → [35.487:489]
B:BD[35.489] → [9.1942:2002]
∅:D[9.2002] → [8.2344:2423]
B:BD[7.46292] → [8.2344:2423]
∅:D[34.833] → [8.2424:2489]
B:BD[7.46404] → [8.2424:2489]
B:BD[8.2489] → [34.834:870]
∅:D[34.870] → [7.46422:46425]
∅:D[38.1587] → [7.46422:46425]
∅:D[8.2524] → [7.46422:46425]
B:BD[7.46422] → [7.46422:46425]
B:BD[7.46425] → [39.179:249]
B:BD[39.249] → [9.2003:2061]
∅:D[34.928] → [39.305:307]
∅:D[9.2061] → [39.305:307]
B:BD[39.305] → [39.305:307]
B:BD[39.307] → [40.135:207]
∅:D[40.207] → [41.172:267]
B:BD[41.172] → [41.172:267]
B:BD[41.267] → [42.6723:6737]
B:BD[42.6737] → [43.209:255]
∅:D[43.255] → [42.6792:6806]
B:BD[42.6792] → [42.6792:6806]
∅:D[42.6806] → [41.334:344]
B:BD[41.334] → [41.334:344]
B:BD[39.569] → [39.569:579]
B:BD[39.579] → [9.2062:2425]
```
}
opacity_type _feat_opacity(dungeon_feature_type feat)
{
    return (feat_is_opaque(feat) ? OPC_OPAQUE : OPC_CLEAR);
}
// A cell is considered clear unless the player knows it's
// opaque.
struct opacity_excl : opacity_func
{
    CLONE(opacity_excl)    
    opacity_type operator()(const coord_def& p) const
    {
        if (!is_terrain_seen(p))
            return OPC_CLEAR;
        else if (!is_terrain_changed(p))
            return _feat_opacity(env.grid(p));
        else if (env.map(p).object < NUM_REAL_FEATURES)
            return _feat_opacity((dungeon_feature_type) env.map(p).object);
        else
        {
            // If you have seen monsters, items or clouds there,
            // it must have been passable.
            return OPC_CLEAR;
        }
    }
};
static opacity_excl opc_excl;
// Note: bounds_radius gives a circle with square radius r*r+1;
// this doesn't work well for radius 0, but then we want to
// skip LOS calculation in that case anyway since it doesn't
// currently short-cut for small bounds. So radius 0 is special-cased.
travel_exclude::travel_exclude(const coord_def &p, int r,
                               bool autoexcl, monster_type mons, bool vaultexcl)
        : pos(p), radius(r),
          los(los_def(p, opc_excl, bounds_radius(r))),
          uptodate(false), autoex(autoex), mon(mons), vault(vaultexcl)
{
    set_los();
}
void travel_exclude::set_los()
{
    uptodate = true;
    if (radius > 0)
    {
        // Radius might have been changed, and this is cheap.
        los.set_bounds(bounds_radius(radius));
        los.update();
    }
}
bool travel_exclude::affects(const coord_def& p) const
{
    if (!uptodate)
        mprf(MSGCH_ERROR, "exclusion not up-to-date: e (%d,%d) p (%d,%d)",
             pos.x, pos.y, p.x, p.y);
    if (radius == 0)
        return (p == pos);
    return (los.see_cell(p));
}
bool travel_exclude::in_bounds(const coord_def &p) const
{
    return (radius == 0 && p == pos
            || los.in_bounds(p));
}
void init_exclusion_los()
{
    for (unsigned int i = 0; i < curr_excludes.size(); i++)
        curr_excludes[i].set_los();
}
void _mark_excludes_non_updated(const coord_def &p)
{
    for (exclvec::iterator it = curr_excludes.begin();
                           it != curr_excludes.end(); ++it)
    {
        it->uptodate = it->uptodate && it->in_bounds(p);
    }
}
void _update_exclusion_los(bool all=false)
{
    for (exclvec::iterator it = curr_excludes.begin();
                           it != curr_excludes.end(); ++it)
    {
        if (all || !it->uptodate)
            it->set_los();
    }
}
/*
 * Update exclusions' LOS to reflect changes within their range.
 * "changed" is a list of coordinates that have been changed.
 * Only exclusions that might have one of the changed points
 * in view are updated.
 */
void update_exclusion_los(std::vector<coord_def> changed)
{
    if (changed.empty())
        return;
    for (unsigned int i = 0; i < changed.size(); ++i)
        _mark_excludes_non_updated(changed[i]);
    _update_exclusion_los();
}
static bool _is_excluded(const coord_def &p,
                         const exclvec &exc)
{
    for (unsigned int i = 0; i < exc.size(); ++i)
        if (exc[i].affects(p))
            return (true);
    return (false);
}
bool is_excluded(const coord_def &p)
{
    return _is_excluded(p, curr_excludes);
}
static travel_exclude *_find_exclude_root(const coord_def &p)
{
    for (unsigned int i = 0; i < curr_excludes.size(); ++i)
        if (curr_excludes[i].pos == p)
            return (&curr_excludes[i]);
    return (NULL);
}
bool is_exclude_root(const coord_def &p)
{
    return (_find_exclude_root(p));
}
#ifdef USE_TILE
// update Gmap for squares surrounding exclude centre
static void _tile_exclude_gmap_update(const coord_def &p)
{
    for (int x = -8; x <= 8; x++)
        for (int y = -8; y <= 8; y++)
        {
            int px = p.x+x, py = p.y+y;
            if (in_bounds(coord_def(px,py)))
            {
                tiles.update_minimap(px, py);
            }
        }
}
#endif
static void _exclude_update()
{
    if (can_travel_interlevel())
    {
        LevelInfo &li = travel_cache.get_level_info(level_id::current());
        li.update();
    }
    set_level_exclusion_annotation(get_exclusion_desc());
}
static void _exclude_update(const coord_def &p)
{
#ifdef USE_TILE
    _tile_exclude_gmap_update(p);
#endif
    _exclude_update();
```

Deletion in crawl-ref/source/travel.cc at line 298 [7.39949]

B:BD[7.47122] → [7.47122:47124]

B:BD[7.47131] → [7.47131:47177]

B:BD[7.47177] → [44.2005:2041]

∅:D[44.2041] → [7.47253:47269]

B:BD[7.47253] → [7.47253:47269]

B:BD[7.47269] → [44.2042:2043]

∅:D[44.2043] → [39.580:650]

B:BD[7.47269] → [39.580:650]

B:BD[39.650] → [9.2429:2486]

∅:D[9.2486] → [41.345:352]

B:BD[39.697] → [41.345:352]

B:BD[41.352] → [9.2487:2488]

∅:D[41.352] → [7.47270:47297]

∅:D[39.703] → [7.47270:47297]

∅:D[9.2488] → [7.47270:47297]

B:BD[7.47270] → [7.47270:47297]

B:BD[7.47297] → [12.1213:1253]

∅:D[12.1253] → [41.353:354]

B:BD[7.47297] → [41.353:354]

B:BD[41.354] → [9.2489:2512]

∅:D[9.2512] → [7.47480:47483]

B:BD[7.47480] → [7.47480:47483]

B:BD[7.47483] → [9.2513:2574]

∅:D[9.2574] → [8.2525:2571]

B:BD[7.47483] → [8.2525:2571]

∅:D[8.2571] → [7.47517:47519]

B:BD[7.47517] → [7.47517:47519]

B:BD[7.47519] → [9.2575:2624]

∅:D[9.2624] → [34.1277:1330]

B:BD[7.47519] → [34.1277:1330]

∅:D[34.1330] → [8.2624:2630]

B:BD[8.2624] → [8.2624:2630]

B:BD[8.2630] → [9.2625:2708]

∅:D[9.2708] → [8.2922:2932]

B:BD[8.2922] → [8.2922:2932]

B:BD[8.2932] → [9.2709:2775]

∅:D[9.2775] → [8.3035:3051]

B:BD[8.3035] → [8.3035:3051]

B:BD[8.3051] → [9.2776:2821]

∅:D[9.2821] → [8.3051:3054]

B:BD[8.3051] → [8.3051:3054]

B:BD[8.3054] → [9.2822:2889]

∅:D[12.1309] → [8.3094:3096]

∅:D[9.2889] → [8.3094:3096]

B:BD[8.3094] → [8.3094:3096]

B:BD[8.3096] → [9.2890:3112]

∅:D[39.769] → [8.3196:3199]

∅:D[12.1415] → [8.3196:3199]

∅:D[9.3112] → [8.3196:3199]

B:BD[8.3196] → [8.3196:3199]

B:BD[8.3199] → [9.3113:3142]

B:BD[9.3142] → [11.729:809]

∅:D[11.809] → [8.3248:3339]

∅:D[12.1480] → [8.3248:3339]

B:BD[8.3248] → [8.3248:3339]

B:BD[8.3339] → [44.2044:2080]

∅:D[44.2080] → [7.47616:47633]

B:BD[7.47616] → [7.47616:47633]

B:BD[7.47633] → [8.3340:3363]

∅:D[8.3363] → [45.11215:11231]

B:BD[45.11215] → [45.11215:11231]

B:BD[45.11231] → [46.339:340]

B:BD[46.340] → [9.3143:3196]

∅:D[9.3196] → [7.47767:47773]

∅:D[8.3424] → [7.47767:47773]

B:BD[7.47767] → [7.47767:47773]

B:BD[7.47773] → [9.3197:3227]

B:BD[9.3227] → [6.2138:2162]

∅:D[18.441] → [7.48070:48091]

∅:D[20.729] → [7.48070:48091]

∅:D[6.2162] → [7.48070:48091]

∅:D[9.3260] → [7.48070:48091]

B:BD[7.48070] → [7.48070:48091]

B:BD[7.48091] → [3.118:166]

∅:D[3.166] → [12.1516:1559]

∅:D[17.240] → [12.1516:1559]

B:BD[12.1516] → [12.1516:1559]

B:BD[12.1559] → [3.167:231]

∅:D[28.180] → [12.1639:1640]

∅:D[3.231] → [12.1639:1640]

B:BD[12.1639] → [12.1639:1640]

B:BD[12.1640] → [17.241:378]

∅:D[17.378] → [7.48159:48166]

∅:D[11.900] → [7.48159:48166]

∅:D[12.1719] → [7.48159:48166]

∅:D[8.3832] → [7.48159:48166]

B:BD[7.48159] → [7.48159:48166]

B:BD[7.48166] → [9.3261:3285]

∅:D[9.3285] → [12.1726:1913]

B:BD[12.1726] → [12.1726:1913]

B:BD[12.1913] → [9.3286:3339]

∅:D[9.3339] → [12.2043:2049]

B:BD[12.2043] → [12.2043:2049]

B:BD[12.2049] → [9.3340:3383]

B:BD[9.3383] → [16.408:483]

∅:D[16.483] → [9.3463:3491]

B:BD[9.3463] → [9.3463:3491]

∅:D[9.3491] → [12.2479:2488]

B:BD[12.2479] → [12.2479:2488]

B:BD[12.2488] → [9.3492:3538]

∅:D[9.3538] → [12.2535:2634]

B:BD[12.2535] → [12.2535:2634]

B:BD[12.2634] → [2.38:98]

∅:D[2.98] → [12.2700:2706]

B:BD[12.2700] → [12.2700:2706]

B:BD[12.2706] → [3.232:371]

∅:D[28.294] → [12.2833:2873]

∅:D[3.371] → [12.2833:2873]

∅:D[17.447] → [12.2833:2873]

B:BD[12.2833] → [12.2833:2873]

∅:D[12.2873] → [7.48721:48727]

B:BD[7.48721] → [7.48721:48727]

B:BD[7.48727] → [12.2874:3503]

}
void clear_excludes()
{
    // Sanity checks
    if (!player_in_mappable_area())
        return;
#ifdef USE_TILE
    for (int i = curr_excludes.size()-1; i >= 0; i--)
        _tile_exclude_gmap_update(curr_excludes[i].pos);
#endif
    curr_excludes.clear();
    clear_level_exclusion_annotation();
    _exclude_update();
}
// Cycles the radius of an exclusion, including "off" state.
void cycle_exclude_radius(const coord_def &p)
{
    // XXX: scanning through curr_excludes twice
    if (travel_exclude *exc = _find_exclude_root(p))
    {
        if (exc->radius == LOS_RADIUS)
            set_exclude(p, 0);
        else
        {
            ASSERT(exc->radius == 0);
            del_exclude(p);
        }
    }
    else
        set_exclude(p, LOS_RADIUS);
}
// Remove a possible exclude.
void del_exclude(const coord_def &p)
{
    for (unsigned int i = 0; i < curr_excludes.size(); ++i)
        if (curr_excludes[i].pos == p)
        {
            curr_excludes.erase(curr_excludes.begin() + i);
            break;
        }
    _exclude_update(p);
}
// Set or update an exclude.
void set_exclude(const coord_def &p, int radius, bool autoexcl, bool vaultexcl)
{
    // Sanity checks; excludes can be set in Pan and regular dungeon
    // levels only.
    if (!player_in_mappable_area())
        return;
    if (!in_bounds(p))
        return;
    if (travel_exclude *exc = _find_exclude_root(p))
    {
        exc->radius = radius;
        exc->set_los();
    }
    else
    {
        monster_type montype = MONS_NO_MONSTER;
        const monsters *m = monster_at(p);
        if (m && you.can_see(m))
            montype = m->type;
        curr_excludes.push_back(travel_exclude(p, radius, autoexcl,
                                               montype, vaultexcl));
    }
    _exclude_update(p);
}
// If a grid that was placed automatically no longer contains the original
// monster (or it is invisible), remove the exclusion.
void maybe_remove_autoexclusion(const coord_def &p)
{
    if (travel_exclude *exc = _find_exclude_root(p))
    {
        const monsters *m = monster_at(p);
        if (exc->autoex && (!m || !you.can_see(m) || m->type != exc->mon))
            del_exclude(p);
    }
}
// Lists all exclusions on the current level.
std::string get_exclusion_desc()
{
    std::vector<std::string> monsters;
    int count_other = 0;
    for (unsigned int i = 0; i < curr_excludes.size(); ++i)
    {
        if (!invalid_monster_type(curr_excludes[i].mon))
            monsters.push_back(mons_type_name(curr_excludes[i].mon, DESC_PLAIN));
        else
            count_other++;
    }
    if (count_other > 0)
    {
        snprintf(info, INFO_SIZE, "%d %sexclusion%s",
                 count_other, monsters.empty() ? "" : "more ",
                 count_other > 1 ? "s" : "");
        monsters.push_back(info);
    }
    else if (monsters.empty())
        return "";
    std::string desc = "";
    if (monsters.size() > 1 || count_other == 0)
    {
        snprintf(info, INFO_SIZE, "exclusion%s: ",
                 monsters.size() > 1 ? "s" : "");
        desc += info;
    }
    return (desc + comma_separated_line(monsters.begin(), monsters.end(),
                                        ", and ", ", "));

Replacement in crawl-ref/source/travel.cc at line 2397 [7.39949]

B:BD[35.912] → [34.8919:8973]

        if (_is_excluded( stair, li.get_excludes() ))

[35.912]

[47.229]

        if (is_excluded( stair, li.get_excludes() ))

Replacement in crawl-ref/source/travel.cc at line 2581 [7.39949]

B:BD[7.105738] → [48.300:366]

        std::vector<travel_exclude> old_excludes = curr_excludes;

[7.105738]

[7.105843]

        exclvec old_excludes = curr_excludes;

Replacement in crawl-ref/source/travel.cc at line 2987 [7.39949]
B:BD[7.115323] → [33.126:159]
```
    _update_exclusion_los(true);
```
[7.115323]
[49.369]
```
    init_exclusion_los();
```
Insertion in crawl-ref/source/exclude.h at line 3 [4.2964]
[4.3001]
[4.3001]
```
#include "los.h"
```

Insertion in crawl-ref/source/exclude.h at line 9 [4.2964]

[4.3180]


void init_exclusion_los();
void update_exclusion_los(std::vector<coord_def> changed);
bool is_exclude_root(const coord_def &p);
void cycle_exclude_radius(const coord_def &p);
void del_exclude(const coord_def &p);
void set_exclude(const coord_def &p, int radius = LOS_RADIUS,
                 bool autoexcl = false, bool vaultexcl = false);
void maybe_remove_autoexclusion(const coord_def &p);
std::string get_exclusion_desc();
void clear_excludes();

Insertion in crawl-ref/source/exclude.h at line 22 [4.2964]

[4.3181]

struct travel_exclude
{
    coord_def     pos;          // exclusion centre
    int           radius;       // exclusion radius
    los_def       los;          // los from exclusion centre
    bool          uptodate;     // Is los up to date?
    bool          autoex;       // Was set automatically.
    monster_type  mon;          // Monster around which exclusion is centered.
    bool          vault;        // Is this exclusion set by a vault?
    travel_exclude(const coord_def &p, int r = LOS_RADIUS,
                   bool autoex = false, monster_type mons = MONS_NO_MONSTER,
                   bool vault = false);
    int radius_sq() const;
    void set_los();
    bool in_bounds(const coord_def& p) const;
    bool affects(const coord_def& p) const;
};
typedef std::vector<travel_exclude> exclvec;
extern exclvec curr_excludes; // in travel.cc
bool is_excluded(const coord_def &p, const exclvec &exc = curr_excludes);

Insertion in crawl-ref/source/exclude.cc at line 11 [4.3225]
[4.3373]
[4.3373]
```
#include "overmap.h"
```
Insertion in crawl-ref/source/exclude.cc at line 13 [4.3225]
[4.3392]
[4.3392]
```
#include "terrain.h"
```
Deletion in crawl-ref/source/exclude.cc at line 18 [4.3225]
B:BD[4.3435] → [4.3435:3477]
```
// TODO: move other exclusion code here.
```

Insertion in crawl-ref/source/exclude.cc at line 75 [4.3225]

[4.5171]

    }
}
opacity_type _feat_opacity(dungeon_feature_type feat)
{
    return (feat_is_opaque(feat) ? OPC_OPAQUE : OPC_CLEAR);
}
// A cell is considered clear unless the player knows it's
// opaque.
struct opacity_excl : opacity_func
{
    CLONE(opacity_excl)
    opacity_type operator()(const coord_def& p) const
    {
        if (!is_terrain_seen(p))
            return OPC_CLEAR;
        else if (!is_terrain_changed(p))
            return _feat_opacity(env.grid(p));
        else if (env.map(p).object < NUM_REAL_FEATURES)
            return _feat_opacity((dungeon_feature_type) env.map(p).object);
        else
        {
            // If you have seen monsters, items or clouds there,
            // it must have been passable.
            return OPC_CLEAR;
        }
    }
};
static opacity_excl opc_excl;
// Note: bounds_radius gives a circle with square radius r*r+1;
// this doesn't work well for radius 0, but then we want to
// skip LOS calculation in that case anyway since it doesn't
// currently short-cut for small bounds. So radius 0 is special-cased.
travel_exclude::travel_exclude(const coord_def &p, int r,
                               bool autoexcl, monster_type mons, bool vaultexcl)
: pos(p), radius(r),
los(los_def(p, opc_excl, bounds_radius(r))),
uptodate(false), autoex(autoex), mon(mons), vault(vaultexcl)
{
    set_los();
}
void travel_exclude::set_los()
{
    uptodate = true;
    if (radius > 0)
    {
        // Radius might have been changed, and this is cheap.
        los.set_bounds(bounds_radius(radius));
        los.update();
    }
}
bool travel_exclude::affects(const coord_def& p) const
{
    if (!uptodate)
        mprf(MSGCH_ERROR, "exclusion not up-to-date: e (%d,%d) p (%d,%d)",
             pos.x, pos.y, p.x, p.y);
    if (radius == 0)
        return (p == pos);
    return (los.see_cell(p));
}
bool travel_exclude::in_bounds(const coord_def &p) const
{
    return (radius == 0 && p == pos
            || los.in_bounds(p));
}
void _mark_excludes_non_updated(const coord_def &p)
{
    for (exclvec::iterator it = curr_excludes.begin();
         it != curr_excludes.end(); ++it)
    {
        it->uptodate = it->uptodate && it->in_bounds(p);

Insertion in crawl-ref/source/exclude.cc at line 157 [4.3225]

[4.5180]

void _update_exclusion_los(bool all=false)
{
    for (exclvec::iterator it = curr_excludes.begin();
         it != curr_excludes.end(); ++it)
    {
        if (all || !it->uptodate)
            it->set_los();
    }
}

Insertion in crawl-ref/source/exclude.cc at line 167 [4.3225]

[4.5181]

void init_exclusion_los()
{
    _update_exclusion_los(true);
}
/*
 * Update exclusions' LOS to reflect changes within their range.
 * "changed" is a list of coordinates that have been changed.
 * Only exclusions that might have one of the changed points
 * in view are updated.
 */
void update_exclusion_los(std::vector<coord_def> changed)
{
    if (changed.empty())
        return;
    for (unsigned int i = 0; i < changed.size(); ++i)
        _mark_excludes_non_updated(changed[i]);
    _update_exclusion_los();
}
bool is_excluded(const coord_def &p, const exclvec &exc)
{
    for (unsigned int i = 0; i < exc.size(); ++i)
        if (exc[i].affects(p))
            return (true);
    return (false);
}
static travel_exclude *_find_exclude_root(const coord_def &p)
{
    for (unsigned int i = 0; i < curr_excludes.size(); ++i)
        if (curr_excludes[i].pos == p)
            return (&curr_excludes[i]);
    return (NULL);
}
bool is_exclude_root(const coord_def &p)
{
    return (_find_exclude_root(p));
}
#ifdef USE_TILE
// update Gmap for squares surrounding exclude centre
static void _tile_exclude_gmap_update(const coord_def &p)
{
    for (int x = -8; x <= 8; x++)
        for (int y = -8; y <= 8; y++)
        {
            int px = p.x+x, py = p.y+y;
            if (in_bounds(coord_def(px,py)))
            {
                tiles.update_minimap(px, py);
            }
        }
}
#endif
static void _exclude_update()
{
    if (can_travel_interlevel())
    {
        LevelInfo &li = travel_cache.get_level_info(level_id::current());
        li.update();
    }
    set_level_exclusion_annotation(get_exclusion_desc());
}
static void _exclude_update(const coord_def &p)
{
#ifdef USE_TILE
    _tile_exclude_gmap_update(p);
#endif
    _exclude_update();
}
void clear_excludes()
{
    // Sanity checks
    if (!player_in_mappable_area())
        return;
#ifdef USE_TILE
    for (int i = curr_excludes.size()-1; i >= 0; i--)
        _tile_exclude_gmap_update(curr_excludes[i].pos);
#endif
    curr_excludes.clear();
    clear_level_exclusion_annotation();
    _exclude_update();
}
// Cycles the radius of an exclusion, including "off" state.
void cycle_exclude_radius(const coord_def &p)
{
    // XXX: scanning through curr_excludes twice
    if (travel_exclude *exc = _find_exclude_root(p))
    {
        if (exc->radius == LOS_RADIUS)
            set_exclude(p, 0);
        else
        {
            ASSERT(exc->radius == 0);
            del_exclude(p);
        }
    }
    else
        set_exclude(p, LOS_RADIUS);
}
// Remove a possible exclude.
void del_exclude(const coord_def &p)
{
    for (unsigned int i = 0; i < curr_excludes.size(); ++i)
        if (curr_excludes[i].pos == p)
        {
            curr_excludes.erase(curr_excludes.begin() + i);
            break;
        }
    _exclude_update(p);
}
// Set or update an exclude.
void set_exclude(const coord_def &p, int radius, bool autoexcl, bool vaultexcl)
{
    // Sanity checks; excludes can be set in Pan and regular dungeon
    // levels only.
    if (!player_in_mappable_area())
        return;
    if (!in_bounds(p))
        return;
    if (travel_exclude *exc = _find_exclude_root(p))
    {
        exc->radius = radius;
        exc->set_los();
    }
    else
    {
        monster_type montype = MONS_NO_MONSTER;
        const monsters *m = monster_at(p);
        if (m && you.can_see(m))
            montype = m->type;
        curr_excludes.push_back(travel_exclude(p, radius, autoexcl,
                                               montype, vaultexcl));
    }
    _exclude_update(p);
}
// If a grid that was placed automatically no longer contains the original
// monster (or it is invisible), remove the exclusion.
void maybe_remove_autoexclusion(const coord_def &p)
{
    if (travel_exclude *exc = _find_exclude_root(p))
    {
        const monsters *m = monster_at(p);
        if (exc->autoex && (!m || !you.can_see(m) || m->type != exc->mon))
            del_exclude(p);
    }
}
// Lists all exclusions on the current level.
std::string get_exclusion_desc()
{
    std::vector<std::string> monsters;
    int count_other = 0;
    for (unsigned int i = 0; i < curr_excludes.size(); ++i)
    {
        if (!invalid_monster_type(curr_excludes[i].mon))
            monsters.push_back(mons_type_name(curr_excludes[i].mon, DESC_PLAIN));
        else
            count_other++;
    }
    if (count_other > 0)
    {
        snprintf(info, INFO_SIZE, "%d %sexclusion%s",
                 count_other, monsters.empty() ? "" : "more ",
                 count_other > 1 ? "s" : "");
        monsters.push_back(info);
    }
    else if (monsters.empty())
        return "";
    std::string desc = "";
    if (monsters.size() > 1 || count_other == 0)
    {
        snprintf(info, INFO_SIZE, "exclusion%s: ",
                 monsters.size() > 1 ? "s" : "");
        desc += info;
    }
    return (desc + comma_separated_line(monsters.begin(), monsters.end(),
                                        ", and ", ", "));
}

Move most exclusion code from travel.cc to exclude.cc.

Dependencies

In channels

Change contents

Insertion in crawl-ref/source/travel.h at line 11 [7.29464]

Deletion in crawl-ref/source/travel.h at line 64 [7.29464]

Deletion in crawl-ref/source/travel.h at line 66 [7.29464]

Deletion in crawl-ref/source/travel.h at line 72 [7.29464]

Deletion in crawl-ref/source/travel.h at line 344 [7.29464]

Deletion in crawl-ref/source/travel.h at line 345 [7.29464]

Insertion in crawl-ref/source/travel.cc at line 23 [7.39949]

Replacement in crawl-ref/source/travel.cc at line 89 [7.39949]

Deletion in crawl-ref/source/travel.cc at line 272 [7.39949]

Deletion in crawl-ref/source/travel.cc at line 298 [7.39949]

Replacement in crawl-ref/source/travel.cc at line 2397 [7.39949]

Replacement in crawl-ref/source/travel.cc at line 2581 [7.39949]

Replacement in crawl-ref/source/travel.cc at line 2987 [7.39949]

Insertion in crawl-ref/source/exclude.h at line 3 [4.2964]

Insertion in crawl-ref/source/exclude.h at line 9 [4.2964]

Insertion in crawl-ref/source/exclude.h at line 22 [4.2964]

Insertion in crawl-ref/source/exclude.cc at line 11 [4.3225]

Insertion in crawl-ref/source/exclude.cc at line 13 [4.3225]

Deletion in crawl-ref/source/exclude.cc at line 18 [4.3225]

Insertion in crawl-ref/source/exclude.cc at line 75 [4.3225]

Insertion in crawl-ref/source/exclude.cc at line 157 [4.3225]

Insertion in crawl-ref/source/exclude.cc at line 167 [4.3225]