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.

8 files changed, 82 insertions, 197 deletions

diff --git a/crawl-ref/source/effects.cc b/crawl-ref/source/effects.cc
index a98d43b465..76b26a88c3 100644
--- a/crawl-ref/source/effects.cc
+++ b/crawl-ref/source/effects.cc
@@ -4357,7 +4357,7 @@ static int _mushroom_ring(item_def &corpse, int & seen_count)
     std::vector<std::vector<coord_def> > radius_points;
 
     env_show_grid losgrid;
-    losight(losgrid, los_param_solid(corpse.pos));
+    losight(losgrid, corpse.pos, opc_solid);
 
     collect_radius_points(radius_points, corpse.pos, losgrid);
 
diff --git a/crawl-ref/source/los.cc b/crawl-ref/source/los.cc
index 896ad452c9..08c3fe2d32 100644
--- a/crawl-ref/source/los.cc
+++ b/crawl-ref/source/los.cc
@@ -759,7 +759,7 @@ int num_feats_between(const coord_def& source, const coord_def& target,
 bool cell_see_cell(const coord_def& p1, const coord_def& p2)
 {
     env_show_grid show;
-    losight(show, los_param_nocloud(p1));
+    losight(show, p1);
     return see_grid(show, p1, p2);
 }
 
@@ -862,11 +862,11 @@ void losight(env_show_grid& sh, const los_param& dat)
 struct los_param_funcs : public los_param
 {
     coord_def center;
-    opacity_func opc;
-    bounds_func bounds;
+    const opacity_func& opc;
+    const bounds_func& bounds;
 
     los_param_funcs(const coord_def& c,
-                    opacity_func o, bounds_func b)
+                    const opacity_func& o, const bounds_func& b)
         : center(c), opc(o), bounds(b)
     {
     }
@@ -888,7 +888,7 @@ struct los_param_funcs : public los_param
 };
 
 void losight(env_show_grid& sh, const coord_def& center,
-             opacity_func opc, bounds_func bounds)
+             const opacity_func& opc, const bounds_func& bounds)
 {
     losight(sh, los_param_funcs(center, opc, bounds));
 }
@@ -908,12 +908,12 @@ void calc_show_los()
 {
     if (!crawl_state.arena && !crawl_state.arena_suspended)
     {
-        // Must be done first.
         losight(env.show, you.pos());
 
         // What would be visible, if all of the translucent walls were
         // made opaque.
-        losight(env.no_trans_show, los_param_solid(you.pos()));
+        // XXX: figure out what this should really do.
+        losight(env.no_trans_show, you.pos(), opc_solid);
     }
     else
     {
diff --git a/crawl-ref/source/los.h b/crawl-ref/source/los.h
index 7e70bd7a08..fb370c1abd 100644
--- a/crawl-ref/source/los.h
+++ b/crawl-ref/source/los.h
@@ -32,8 +32,8 @@ bool cell_see_cell(const coord_def& p1, const coord_def& p2);
 
 void clear_rays_on_exit();
 void losight(env_show_grid& sh, const coord_def& center,
-             opacity_func opc = &opc_default,
-             bounds_func bounds = &bounds_los_radius);
+             const opacity_func &opc = opc_default,
+             const bounds_func &bds = bds_default);
 void losight(env_show_grid& sh, const los_param& param);
 void calc_show_los();
 
diff --git a/crawl-ref/source/losparam.cc b/crawl-ref/source/losparam.cc
index 47c995f5bd..f24acf4551 100644
--- a/crawl-ref/source/losparam.cc
+++ b/crawl-ref/source/losparam.cc
@@ -14,7 +14,7 @@ REVISION("$Rev$");
 #include "stuff.h"
 #include "terrain.h"
 
-opacity_type opc_default(const coord_def& p)
+opacity_type opacity_default::operator()(const coord_def& p) const
 {
     int m;
     dungeon_feature_type f = env.grid(p);
@@ -30,117 +30,32 @@ opacity_type opc_default(const coord_def& p)
         return OPC_CLEAR;
 }
 
-bool bounds_los_radius(const coord_def& p)
-{
-    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
+// Make anything solid block in addition to normal LOS.
+// XXX: Are trees, bushes solid?
+opacity_type opacity_solid::operator()(const coord_def& p) const
 {
     int m;
-    dungeon_feature_type f = feature(p);
-    if (grid_is_opaque(f))
+    dungeon_feature_type f = env.grid(p);
+    if (grid_is_solid(f))
         return OPC_OPAQUE;
-    else if (is_opaque_cloud(cloud_idx(p)))
+    else if (is_opaque_cloud(env.cgrid(p)))
         return OPC_HALF;
     else if (f == DNGN_TREES)
         return OPC_HALF;
-    else if ((m = mgrd(trans(p))) != NON_MONSTER && menv[m].type == MONS_BUSH)
+    else if ((m = mgrd(p)) != NON_MONSTER && menv[m].type == MONS_BUSH)
         return OPC_HALF;
     else
         return OPC_CLEAR;
 }
 
-
-/* los_param_solid */
-
-los_param_solid::los_param_solid(const coord_def& c)
-    : los_param_base(c)
+// LOS bounded by fixed presquared radius.
+bool bounds_radius_sq::operator()(const coord_def& p) const
 {
+    return (p.abs() <= radius_sq);
 }
 
-opacity_type los_param_solid::opacity(const coord_def& p) const
+// LOS bounded by current global LOS radius.
+bool bounds_los_radius::operator()(const coord_def& p) const
 {
-    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;
+    return (p.abs() <= get_los_radius_squared());
 }
diff --git a/crawl-ref/source/losparam.h b/crawl-ref/source/losparam.h
index 8953c1883e..e8b59e9d1a 100644
--- a/crawl-ref/source/losparam.h
+++ b/crawl-ref/source/losparam.h
@@ -15,11 +15,48 @@ enum opacity_type
     NUM_OPACITIES
 };
 
-typedef opacity_type (*opacity_func)(const coord_def&);
-typedef bool (*bounds_func)(const coord_def&);
+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;
+};
 
-opacity_type opc_default(const coord_def&);
-bool bounds_los_radius(const coord_def& p);
+// Default LOS rules.
+struct opacity_default : opacity_func
+{
+    opacity_type operator()(const coord_def& p) const;
+};
+static opacity_default opc_default = opacity_default();
+
+// 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;
+};
+
+// 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();
 
 // Subclasses of this are passed to losight() to modify the
 // LOS calculation. Implementations will have to translate between
@@ -40,53 +77,4 @@ struct los_param
     virtual opacity_type opacity(const coord_def& p) const = 0;
 };
 
-// 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;
-};
-
-// Standard visibility disregarding clouds.
-struct los_param_nocloud : public los_param_trans
-{
-    los_param_nocloud(const coord_def& c);
-
-    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;
-};
-
 #endif
diff --git a/crawl-ref/source/spells3.cc b/crawl-ref/source/spells3.cc
index b8a2032777..6facccd714 100644
--- a/crawl-ref/source/spells3.cc
+++ b/crawl-ref/source/spells3.cc
@@ -1056,7 +1056,7 @@ int animate_dead(actor *caster, int pow, beh_type beha, unsigned short hitting,
     // Use an alternate LOS grid, based on the caster's LOS.
     env_show_grid losgrid;
     if (caster->atype() != ACT_PLAYER)
-        losight(losgrid, los_param_solid(caster->pos()));
+        losight(losgrid, caster->pos(), opc_solid);
 
     int number_raised = 0;
     int number_seen   = 0;
diff --git a/crawl-ref/source/stuff.cc b/crawl-ref/source/stuff.cc
index 3b3324ea50..89212293ce 100644
--- a/crawl-ref/source/stuff.cc
+++ b/crawl-ref/source/stuff.cc
@@ -1694,7 +1694,7 @@ bool is_trap_square(dungeon_feature_type grid)
 // applied to new games.
 void zap_los_monsters()
 {
-    losight(env.show, los_param_base(you.pos()));
+    losight(env.show, you.pos());
 
     for (rectangle_iterator ri(crawl_view.vlos1, crawl_view.vlos2); ri; ++ri )
     {
diff --git a/crawl-ref/source/travel.cc b/crawl-ref/source/travel.cc
index 339e5fb298..10c080aa62 100644
--- a/crawl-ref/source/travel.cc
+++ b/crawl-ref/source/travel.cc
@@ -276,42 +276,23 @@ bool is_traversable(dungeon_feature_type grid)
     return (traversable_terrain[grid] == TRAVERSABLE);
 }
 
-struct los_param_excl : public los_param_trans
+opacity_type _feat_opacity(dungeon_feature_type feat)
 {
-    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;
-    }
+    return (grid_is_opaque(feat) ? OPC_OPAQUE : OPC_CLEAR);
+}
 
-    // A cell is considered clear unless the player knows it's
-    // opaque.
-    opacity_type opacity(const coord_def& p) const
+// 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
     {
-        const coord_def& q = trans(p);
-        if (!is_terrain_seen(q))
+        if (!is_terrain_seen(p))
             return OPC_CLEAR;
-        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);
+        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,
@@ -320,6 +301,7 @@ struct los_param_excl : public los_param_trans
         }
     }
 };
+opacity_excl opc_excl;
 
 int travel_exclude::radius_sq() const
 {
@@ -328,7 +310,7 @@ int travel_exclude::radius_sq() const
 
 void travel_exclude::set_exclude_show()
 {
-    losight(show, los_param_excl(pos, radius_sq()));
+    losight(show, pos, opc_excl, bounds_radius_sq(radius_sq()));
     uptodate = true;
 }