fiddlerwoaroof/crawl - Change AL7EYY4HB7JNEFGDB6NVVHCVVUYYKUJKC4UFH4T7XUT3P5NT4NAAC

Get rid of los_param outside of los.cc/losparam.cc.

The nicer interface to losight is now void losight(env_show_grid& sh, const coord_def& center, const opacity_func &opc = opc_default, const bounds_func &bds = bds_default);

bounds_func provides the LOS boundary (usually just a circle with radius the current LOS radius). opacity_func is a mapping of grid coordinates to opacity values.

Created by Robert Vollmert on October 16, 2009

AL7EYY4HB7JNEFGDB6NVVHCVVUYYKUJKC4UFH4T7XUT3P5NT4NAAC

Dependencies

In channels

main

Change contents

Replacement in crawl-ref/source/travel.cc at line 279 [8.39949]
B:BD[7.2789] → [2.230:277]
```
struct los_param_excl : public los_param_trans
```
[7.2789]
[7.2838]
```
opacity_type _feat_opacity(dungeon_feature_type feat)
```

Replacement in crawl-ref/source/travel.cc at line 281 [8.39949]

B:BD[7.2840] → [5.430:699]

∅:D[9.332] → [7.2875:2876]

∅:D[5.699] → [7.2875:2876]

B:BD[7.2875] → [7.2875:2876]

B:BD[7.2876] → [9.333:413]

∅:D[9.413] → [7.3081:3082]

B:BD[7.3081] → [7.3081:3082]

B:BD[7.3082] → [9.414:552]

    int radius_sq;
    los_param_excl(const coord_def& c, int r)
        : los_param_trans(c), radius_sq(r)
    {
    }
    bool los_bounds(const coord_def& p) const
    {
        return (p.abs() <= radius_sq &&
                los_param_trans::los_bounds(p));
    }
    unsigned appearance(const coord_def& p) const
    {
        return 1;
    }
    opacity_type _feat_opacity(dungeon_feature_type feat) const
    {
        return grid_is_opaque(feat) ? OPC_OPAQUE : OPC_CLEAR;
    }

[7.2840]

[10.385]

    return (grid_is_opaque(feat) ? OPC_OPAQUE : OPC_CLEAR);
}

Replacement in crawl-ref/source/travel.cc at line 284 [8.39949]

B:BD[10.386] → [9.553:682]

    // A cell is considered clear unless the player knows it's
    // opaque.
    opacity_type opacity(const coord_def& p) const

[10.386]

[9.682]

// A cell is considered clear unless the player knows it's
// opaque.
struct opacity_excl : opacity_func
{
    opacity_type operator()(const coord_def& p) const

Replacement in crawl-ref/source/travel.cc at line 290 [8.39949]

B:BD[9.688] → [9.688:760]

        const coord_def& q = trans(p);
        if (!is_terrain_seen(q))

[9.688]

[9.760]

        if (!is_terrain_seen(p))

Replacement in crawl-ref/source/travel.cc at line 292 [8.39949]

B:BD[9.790] → [9.790:1010]

        else if (!is_terrain_changed(q))
            return _feat_opacity(env.grid(q));
        else if (env.map(q).object < NUM_REAL_FEATURES)
            return _feat_opacity((dungeon_feature_type) env.map(q).object);

[9.790]

[9.1010]

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

Insertion in crawl-ref/source/travel.cc at line 304 [8.39949]
[9.1181]
[5.700]
```
opacity_excl opc_excl;
```

Replacement in crawl-ref/source/travel.cc at line 313 [8.39949]

B:BD[10.428] → [5.793:846]

    losight(show, los_param_excl(pos, radius_sq()));

[10.428]

[7.3822]

    losight(show, pos, opc_excl, bounds_radius_sq(radius_sq()));

Replacement in crawl-ref/source/stuff.cc at line 1697 [13.224557]
B:BD[11.115577] → [12.257:307]
```
    losight(env.show, los_param_base(you.pos()));
```
[11.115577]
[11.115627]
```
    losight(env.show, you.pos());
```

Replacement in crawl-ref/source/spells3.cc at line 1059 [13.531613]

B:BD[14.1400] → [12.329:387]

        losight(losgrid, los_param_solid(caster->pos()));

[14.1400]

[15.9662]

        losight(losgrid, caster->pos(), opc_solid);

Insertion in crawl-ref/source/losparam.h at line 16 [16.3217]

[16.3473]

};
struct opacity_func
{
    virtual ~opacity_func() {}
    virtual opacity_type operator()(const coord_def& p) const = 0;
};
struct bounds_func
{
    virtual ~bounds_func() {}
    virtual bool operator()(const coord_def& p) const = 0;
};
// Default LOS rules.
struct opacity_default : opacity_func
{
    opacity_type operator()(const coord_def& p) const;

Insertion in crawl-ref/source/losparam.h at line 35 [16.3217]
[16.3476]
[6.2838]
```
static opacity_default opc_default = opacity_default();
```

Replacement in crawl-ref/source/losparam.h at line 37 [16.3217]

B:BD[6.2839] → [6.2839:2942]

typedef opacity_type (*opacity_func)(const coord_def&);
typedef bool (*bounds_func)(const coord_def&);

[6.2839]

[16.3476]

// Make anything solid block in addition to normal LOS.
// XXX: Are trees, bushes solid?
struct opacity_solid : opacity_func
{
    opacity_type operator()(const coord_def& p) const;
};
static opacity_solid opc_solid = opacity_solid();
// LOS bounded by fixed presquared radius.
struct bounds_radius_sq : bounds_func
{
    int radius_sq;
    bounds_radius_sq(int r_sq)
        : radius_sq(r_sq) {}
    bool operator()(const coord_def& p) const;
};

Replacement in crawl-ref/source/losparam.h at line 54 [16.3217]

B:BD[16.3477] → [6.2943:3031]

opacity_type opc_default(const coord_def&);
bool bounds_los_radius(const coord_def& p);

[16.3477]

[6.3031]

// LOS bounded by current global LOS radius.
struct bounds_los_radius : bounds_func
{
    bool operator()(const coord_def& p) const;
};
static bounds_los_radius bds_default = bounds_los_radius();

Deletion in crawl-ref/source/losparam.h at line 78 [16.3217]

B:BD[16.4140] → [16.4140:4205]

B:BD[16.4205] → [2.3081:3123]

∅:D[2.3123] → [16.4240:4355]

B:BD[16.4240] → [16.4240:4355]

B:BD[16.4355] → [17.3277:3324]

∅:D[17.3324] → [16.4402:4406]

B:BD[16.4402] → [16.4402:4406]

B:BD[16.4406] → [18.3036:3062]

B:BD[18.3062] → [2.3124:3177]

∅:D[2.3177] → [18.3108:3260]

B:BD[18.3108] → [18.3108:3260]

};
// Provides translation to given center and bounds checking.
struct los_param_trans : public los_param
{
    coord_def center;
    los_param_trans(const coord_def& c);
    coord_def trans(const coord_def& p) const;
    bool los_bounds(const coord_def& p) const;
};
// Everything is visible.
struct los_param_permissive : public los_param_trans
{
    los_param_permissive(const coord_def& c);
    unsigned appearance(const coord_def& p) const;
    opacity_type opacity(const coord_def& p) const;

Deletion in crawl-ref/source/losparam.h at line 79 [16.3217]
B:BD[18.3263] → [18.3263:3264]
B:BD[18.3264] → [19.4126:4170]
B:BD[19.4170] → [2.3178:3228]
∅:D[2.3228] → [16.4532:4534]
∅:D[19.4213] → [16.4532:4534]
B:BD[16.4532] → [16.4532:4534]
B:BD[16.4534] → [19.4214:4257]
```
// Standard visibility disregarding clouds.
struct los_param_nocloud : public los_param_trans
{
    los_param_nocloud(const coord_def& c);
```

Deletion in crawl-ref/source/losparam.h at line 80 [16.3217]

B:BD[16.4575] → [16.4575:4686]

B:BD[16.4686] → [19.4258:4338]

B:BD[19.4338] → [2.3229:3278]

∅:D[2.3278] → [19.4380:4423]

B:BD[19.4380] → [19.4380:4423]

∅:D[19.4423] → [16.4686:4798]

B:BD[16.4686] → [16.4686:4798]

B:BD[16.4798] → [12.3146:3241]

B:BD[12.3241] → [2.3279:3326]

∅:D[2.3326] → [12.3281:3324]

B:BD[12.3281] → [12.3281:3324]

B:BD[16.5107] → [16.5107:5108]

B:BD[16.5219] → [16.5219:5275]

    dungeon_feature_type feature(const coord_def& p) const;
    unsigned appearance(const coord_def& p) const;
    opacity_type opacity(const coord_def& p) const;
};
// Standard visibility.
struct los_param_base : public los_param_nocloud
{
    los_param_base(const coord_def& c);
    unsigned short cloud_idx(const coord_def& p) const;
    opacity_type opacity(const coord_def& p) const;
};
// Like los_param_base, but any solid object blocks.
// This includes clear walls and statues.
struct los_param_solid : public los_param_base
{
    los_param_solid(const coord_def& c);
    opacity_type opacity(const coord_def& p) const;
};

Replacement in crawl-ref/source/losparam.cc at line 17 [16.5319]

B:BD[6.3035] → [6.3035:3080]

opacity_type opc_default(const coord_def& p)

[6.3035]

[6.3080]

opacity_type opacity_default::operator()(const coord_def& p) const

Replacement in crawl-ref/source/losparam.cc at line 33 [16.5319]

B:BD[18.3267] → [6.3448:3491]

bool bounds_los_radius(const coord_def& p)

[18.3267]

[6.3491]

// Make anything solid block in addition to normal LOS.
// XXX: Are trees, bushes solid?
opacity_type opacity_solid::operator()(const coord_def& p) const

Deletion in crawl-ref/source/losparam.cc at line 37 [16.5319]

B:BD[6.3493] → [6.3493:3545]

∅:D[6.3545] → [18.3267:3290]

B:BD[18.3267] → [18.3267:3290]

∅:D[18.3290] → [16.5548:5684]

B:BD[16.5548] → [16.5548:5684]

B:BD[16.5684] → [17.3344:3369]

∅:D[17.3369] → [16.5707:5710]

B:BD[16.5707] → [16.5707:5710]

B:BD[16.5710] → [17.3370:3429]

∅:D[17.3429] → [16.5769:5771]

B:BD[16.5769] → [16.5769:5771]

B:BD[16.5771] → [17.3430:3504]

∅:D[17.3504] → [18.3291:3413]

B:BD[16.5806] → [18.3291:3413]

∅:D[18.3413] → [16.5806:5809]

B:BD[16.5806] → [16.5806:5809]

B:BD[16.5809] → [18.3414:3615]

B:BD[18.3615] → [19.4425:4449]

∅:D[19.4449] → [18.3636:3637]

B:BD[18.3636] → [18.3636:3637]

B:BD[18.3637] → [19.4450:4507]

∅:D[19.4507] → [16.5860:5890]

B:BD[16.5860] → [16.5860:5890]

B:BD[16.5890] → [19.4508:4582]

∅:D[19.4582] → [16.5961:5997]

B:BD[16.5961] → [16.5961:5997]

B:BD[16.5997] → [19.4583:4648]

∅:D[19.4648] → [16.6059:6102]

B:BD[16.6059] → [16.6059:6102]

B:BD[16.6102] → [19.4649:4956]

∅:D[19.4956] → [16.6102:6271]

B:BD[16.6102] → [16.6102:6271]

    return (p.abs() <= get_los_radius_squared());
}
/* los_param_trans */
los_param_trans::los_param_trans(const coord_def& c)
    : center(c)
{
}
coord_def los_param_trans::trans(const coord_def& p) const
{
    return (p + center);
}
bool los_param_trans::los_bounds(const coord_def& p) const
{
    return (map_bounds(trans(p)) && p.abs() <= get_los_radius_squared());
}
/* los_param_permissive */
los_param_permissive::los_param_permissive(const coord_def& c)
    : los_param_trans(c)
{
}
unsigned los_param_permissive::appearance(const coord_def& p) const
{
    return env.grid(trans(p));
}
opacity_type los_param_permissive::opacity(const coord_def& p) const
{
    return OPC_CLEAR;
}
/* los_param_nocloud */
los_param_nocloud::los_param_nocloud(const coord_def& c)
    : los_param_trans(c)
{
}
dungeon_feature_type los_param_nocloud::feature(const coord_def& p) const
{
    return env.grid(trans(p));
}
unsigned los_param_nocloud::appearance(const coord_def& p) const
{
    return grid_appearance(trans(p));
}
opacity_type los_param_nocloud::opacity(const coord_def& p) const
{
    dungeon_feature_type f = feature(p);
    if (grid_is_opaque(f))
        return OPC_OPAQUE;
    else
        return OPC_CLEAR;
}
/* los_param_base */
los_param_base::los_param_base(const coord_def& c)
    : los_param_nocloud(c)
{
}
unsigned short los_param_base::cloud_idx(const coord_def& p) const
{
    return env.cgrid(trans(p));
}
opacity_type los_param_base::opacity(const coord_def& p) const
{

Replacement in crawl-ref/source/losparam.cc at line 38 [16.5319]

∅:D[20.4057] → [16.6271:6339]

B:BD[16.6271] → [16.6271:6339]

    dungeon_feature_type f = feature(p);
    if (grid_is_opaque(f))

[20.4057]

[16.6339]

    dungeon_feature_type f = env.grid(p);
    if (grid_is_solid(f))

Replacement in crawl-ref/source/losparam.cc at line 41 [16.5319]
B:BD[16.6366] → [16.6366:6410]
```
    else if (is_opaque_cloud(cloud_idx(p)))
```
[16.6366]
[3.4197]
```
    else if (is_opaque_cloud(env.cgrid(p)))
```

Replacement in crawl-ref/source/losparam.cc at line 45 [16.5319]

B:BD[16.6435] → [4.3034:3113]

    else if ((m = mgrd(trans(p))) != NON_MONSTER && menv[m].type == MONS_BUSH)

[16.6435]

[20.4122]

    else if ((m = mgrd(p)) != NON_MONSTER && menv[m].type == MONS_BUSH)

Deletion in crawl-ref/source/losparam.cc at line 50 [16.5319]
B:BD[16.6472] → [12.3383:3384]

Replacement in crawl-ref/source/losparam.cc at line 51 [16.5319]

B:BD[18.3639] → [12.3385:3485]

/* los_param_solid */
los_param_solid::los_param_solid(const coord_def& c)
    : los_param_base(c)

[18.3639]

[12.3485]

// LOS bounded by fixed presquared radius.
bool bounds_radius_sq::operator()(const coord_def& p) const

Insertion in crawl-ref/source/losparam.cc at line 54 [16.5319]
[12.3487]
[12.3487]
```
    return (p.abs() <= radius_sq);
```

Replacement in crawl-ref/source/losparam.cc at line 57 [16.5319]

B:BD[16.6473] → [12.3490:3554]

opacity_type los_param_solid::opacity(const coord_def& p) const

[16.6473]

[12.3554]

// LOS bounded by current global LOS radius.
bool bounds_los_radius::operator()(const coord_def& p) const

Replacement in crawl-ref/source/losparam.cc at line 60 [16.5319]

B:BD[12.3556] → [12.3556:3754]

    dungeon_feature_type f = feature(p);
    if (grid_is_solid(f))
        return OPC_OPAQUE;
    else if (is_opaque_cloud(cloud_idx(p)))
        return OPC_HALF;
    else
        return OPC_CLEAR;

[12.3556]

[16.6783]

    return (p.abs() <= get_los_radius_squared());

Replacement in crawl-ref/source/los.h at line 35 [21.24780]

B:BD[6.3604] → [6.3604:3705]

             opacity_func opc = &opc_default,
             bounds_func bounds = &bounds_los_radius);

[6.3604]

[6.3705]

             const opacity_func &opc = opc_default,
             const bounds_func &bds = bds_default);

Replacement in crawl-ref/source/los.cc at line 762 [21.26450]
B:BD[19.5389] → [19.5389:5431]
```
    losight(show, los_param_nocloud(p1));
```
[19.5389]
[19.5431]
```
    losight(show, p1);
```

Replacement in crawl-ref/source/los.cc at line 865 [21.26450]

B:BD[6.3833] → [6.3833:3879]

    opacity_func opc;
    bounds_func bounds;

[6.3833]

[6.3879]

    const opacity_func& opc;
    const bounds_func& bounds;

Replacement in crawl-ref/source/los.cc at line 869 [21.26450]

B:BD[6.3920] → [6.3920:3971]

                    opacity_func o, bounds_func b)

[6.3920]

[6.3971]

                    const opacity_func& o, const bounds_func& b)

Replacement in crawl-ref/source/los.cc at line 891 [21.26450]

B:BD[6.4403] → [6.4403:4454]

             opacity_func opc, bounds_func bounds)

[6.4403]

[6.4454]

             const opacity_func& opc, const bounds_func& bounds)

Deletion in crawl-ref/source/los.cc at line 911 [21.26450]
B:BD[21.55239] → [21.55239:55270]
```
        // Must be done first.
```

Replacement in crawl-ref/source/los.cc at line 915 [21.26450]

B:BD[21.55409] → [12.3816:3880]

        losight(env.no_trans_show, los_param_solid(you.pos()));

[21.55409]

[21.55467]

        // XXX: figure out what this should really do.
        losight(env.no_trans_show, you.pos(), opc_solid);

Replacement in crawl-ref/source/effects.cc at line 4360 [13.3382105]
B:BD[22.18641] → [12.3929:3980]
```
    losight(losgrid, los_param_solid(corpse.pos));
```
[22.18641]
[22.18686]
```
    losight(losgrid, corpse.pos, opc_solid);
```