#include "los.h"

    coord_def     pos;         // exclusion centre
    int           radius;      // exclusion radius
    bool          autoexclude; // Was set automatically.
    int           mon;         // Monster around which exclusion is centered.
    env_show_grid show;        // los from exclusion centre
    bool          uptodate;    // Is show up to date?

    coord_def     pos;          // exclusion centre
    int           radius;       // exclusion radius
    los_def       los;          // los from exclusion centre
    bool          uptodate;     // Is los up to date?
    bool          autoexclude;  // Was set automatically.
    int           mon;          // Monster around which exclusion is centered.

    travel_exclude(const coord_def &p, int r = LOS_RADIUS,
                   bool autoexcl = false, int mons = NON_MONSTER,
                   bool vaultexcl = false);

    void set_exclude_show();

    void set_los();
    bool in_bounds(const coord_def& p) const;

    travel_exclude(const coord_def &p, int r = LOS_RADIUS,
                   bool autoexcl = false, int mons = NON_MONSTER,
                   bool vaultexcl = false)
        : pos(p), radius(r), autoexclude(autoexcl), mon(mons), vaultexclude(vaultexcl)
    {
        set_exclude_show();
    }

static std::vector<travel_exclude> curr_excludes;

typedef std::vector<travel_exclude> exclvec;
static exclvec curr_excludes;

    CLONE(opacity_excl)    

opacity_excl opc_excl;

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.

int travel_exclude::radius_sq() const

travel_exclude::travel_exclude(const coord_def &p, int r,
                               bool autoex, int mons, bool vault)
        : pos(p), radius(r),
          los(los_def(p, opc_excl, bounds_radius(r))),
          uptodate(false), autoexclude(autoex), vaultexclude(vault)

    return (radius > 0 ? radius*radius + 1 : 0);

    set_los();

void travel_exclude::set_exclude_show()

void travel_exclude::set_los()

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

    {
        // Radius might have been changed, and this is cheap.
        los.set_bounds(bounds_radius(radius));
        los.update();
    }

    return (see_cell(show, pos, p));

    return (los.see_cell(p));
}
bool travel_exclude::in_bounds(const coord_def &p) const
{
    return (radius == 0 && p == pos
            || los.in_bounds(p));

        curr_excludes[i].set_exclude_show();

        curr_excludes[i].set_los();

    for (unsigned int i = 0; i < curr_excludes.size(); i++)
        curr_excludes[i].uptodate = curr_excludes[i].uptodate &&
            (curr_excludes[i].pos - p).abs() <= curr_excludes[i].radius_sq();

    for (exclvec::iterator it = curr_excludes.begin();
                           it != curr_excludes.end(); ++it)
    {
        it->uptodate = it->uptodate && it->in_bounds(p);
    }

    for (unsigned int i = 0; i < curr_excludes.size(); i++)
        if (all || !curr_excludes[i].uptodate)
            curr_excludes[i].set_exclude_show();

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

                         const std::vector<travel_exclude> &exc)

                         const exclvec &exc)

        exc->set_exclude_show();

        exc->set_los();

    los_def patrol = los_def(mon->patrol_point, opacity_monmove(*mon),
                                                bounds_radius(rad));
    los_def lm;

    los_def patrol(mon->patrol_point, opacity_monmove(*mon), bounds_radius(rad));
    patrol.update();
    los_def lm(mon->pos(), opacity_monmove(*mon));

        lm.init(mon->pos(), opacity_monmove(*mon));

        lm.update();

    virtual ~opacity_func() {}

    virtual ~opacity_func() {}
    virtual opacity_func* clone() const = 0;

    virtual bounds_func* clone() const = 0;

#define CLONE(typename) \
    typename* clone() const \
    { \
        return (new typename(*this)); \
    }

    CLONE(opacity_default)

    CLONE(opacity_fullyopaque)

    CLONE(opacity_solid)

    CLONE(opacity_monmove)

    CLONE(bounds_radius_sq)

    CLONE(bounds_radius)

    CLONE(bounds_cur_los_radius)

    coord_def const * center;

    coord_def center;

    const bounds_func * bds;

    bounds_func const * bds;

    void init(const coord_def& c, const opacity_func &o = opc_default,
                                  const bounds_func &b = bds_default);
    void update();

    los_def(const los_def& l);
    ~los_def();
    los_def& operator=(const los_def& l);
    void init(const coord_def& center, const opacity_func& o,
                                       const bounds_func& b);

    void set_opacity(const opacity_func& o);
    void set_bounds(const bounds_func& b);
    void update();
    bool in_bounds(const coord_def& p) const;

    CLONE(opacity_trans)

// class los
// TODO: lazy update?

// class los_def

los_def::los_def() {}

                             const bounds_func &b)

                                     const bounds_func &b)
    : center(c), opc(o.clone()), bds(b.clone())

    init(c, o, b);

void los_def::init(const coord_def& c, const opacity_func &o,
                                   const bounds_func &b)

los_def::los_def(const los_def& los)
    : show(los.show), center(los.center),
      opc(los.opc->clone()), bds(los.bds->clone())
{
}
los_def& los_def::operator=(const los_def& los)
{
    init(los.center, *los.opc, *los.bds);
    show = los.show;
    return (*this);
}
void los_def::init(const coord_def &c, const opacity_func &o,
                   const bounds_func &b)
{
    set_center(c);
    set_opacity(o);
    set_bounds(b);
}
los_def::~los_def()

    center = &c;
    opc = &o;
    bds = &b;
    update();

    delete opc;
    delete bds; 

    losight(show, *center, *opc, *bds);

    losight(show, center, *opc, *bds);

    center = &c;
    update();

    center = c;
}
void los_def::set_opacity(const opacity_func &o)
{
    delete opc;
    opc = o.clone();
}
void los_def::set_bounds(const bounds_func &b)
{
    delete bds;
    bds = b.clone();
}
bool los_def::in_bounds(const coord_def& p) const
{
    return ((*bds)(p));

    return (::see_cell(show, *center, p));

    return (::see_cell(show, center, p));

// end los_def