fiddlerwoaroof/crawl - Change 2EBEWIV4YHXXAFR4GG2GMZJ2K77NK762HNQ77CZLHI3LDVGX7RJAC

A rewrite of losight() to allow future generalization.

Parameters relevant to the LOS calculation are now passed as an object los_param that takes care of coordinate translation, bounds checking, opacity of cells and what is written to the output array.

A check for in_bounds was changed to map_bounds for simlicity; this should not have any effect.

Special casing for arena was removed from losight; instead calc_show_los now calls the new losight_permissive.

Created by Robert Vollmert on October 8, 2009

2EBEWIV4YHXXAFR4GG2GMZJ2K77NK762HNQ77CZLHI3LDVGX7RJAC

Dependencies

In channels

main

Change contents

Replacement in crawl-ref/source/terrain.h at line 56 [5.24828]

B:BD[3.1864] → [4.4191:4268]

dungeon_feature_type grid_appearance(feature_grid &gr, const coord_def &gc);

[3.1864]

dungeon_feature_type grid_appearance(const feature_grid &gr, const coord_def &gc);

Replacement in crawl-ref/source/terrain.cc at line 371 [5.26938]

B:BD[4.4310] → [4.4310:4386]

dungeon_feature_type grid_appearance(feature_grid &gr, const coord_def &gc)

[4.4310]

[4.4386]

dungeon_feature_type grid_appearance(const feature_grid &gr, const coord_def &gc)

Insertion in crawl-ref/source/makefile.obj at line 40 [7.79]
[2.24727]
[6.17065]
```
losparam.o \
```

File addition: losparam.h (----------)

[8.24]

/*
 *  File:       losparam.h
 *  Summary:    Parameters for the LOS algorithm
 */
#ifndef LOSPARAM_H
#define LOSPARAM_H
enum opacity_type
{
    OPC_CLEAR,
    OPC_HALF,    // for opaque clouds; two or more block
    OPC_OPAQUE,
     
    NUM_OPACITIES
};
// Subclasses of this are passed to losight() to modify the
// LOS calculation. Implementations will have to translate between
// relative coordinates (-8,-8)..(8,8) and real coordinates,
// specify how opaque the cells are and determine what values
// are written to the visible cells.
struct los_param
{
    virtual ~los_param() {}
    // Whether the translated coordinate lies in the map (including boundary)
    virtual bool map_bounds(const coord_def& p) const = 0;
    // appearance(p) will be copied to show(p) for visible p.
    virtual unsigned appearance(const coord_def& p) const = 0;
    virtual opacity_type opacity(const coord_def& p) const = 0;
};
// Provides translation to given center and bounds checking.
struct los_param_trans : los_param
{
    coord_def center;
    los_param_trans(const coord_def& c);
    coord_def trans(const coord_def& p) const;
    bool map_bounds(const coord_def& p) const;
};
// A complete base implementation that does standard visibility
// based on env.grid.
struct los_param_base : los_param_trans
{
    los_param_base(const coord_def& c);
    dungeon_feature_type feature(const coord_def& p) const;
    unsigned appearance(const coord_def& p) const;
    unsigned short cloud_idx(const coord_def& p) const;
    opacity_type opacity(const coord_def& p) const;
};
// Provides a compatible set of parameters for use with the
// legacy losight() function.
struct los_param_compat : los_param_base
{
    feature_grid grid;
    bool solid_blocks;
    bool ignore_clouds;
    los_param_compat(const feature_grid& gr, const coord_def& c,
                     bool sb, bool ic);
    dungeon_feature_type feature(const coord_def& p) const;
    unsigned appearance(const coord_def& p) const;
    opacity_type opacity(const coord_def& p) const;
};
#endif

File addition: losparam.cc (----------)

[8.24]

/*
 *  File:       losparam.h
 *  Summary:    Parameters for the LOS algorithm 
 */
#include "AppHdr.h"
REVISION("$Rev$");
#include "losparam.h"
#include "cloud.h"
#include "externs.h"
#include "stuff.h"
#include "terrain.h"
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::map_bounds(const coord_def& p) const
{
    return ::map_bounds(trans(p));
}
los_param_base::los_param_base(const coord_def& c)
    : los_param_trans(c)
{
}
dungeon_feature_type los_param_base::feature(const coord_def& p) const
{
    return env.grid(trans(p));
}
unsigned los_param_base::appearance(const coord_def& p) const
{
    return grid_appearance(trans(p));
}
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
{
    dungeon_feature_type f = feature(p);
    if (grid_is_opaque(f))
        return OPC_OPAQUE;
    else if (is_opaque_cloud(cloud_idx(p)))
        return OPC_HALF;
    else
        return OPC_CLEAR;
}
los_param_compat::los_param_compat(const feature_grid& gr, const coord_def& c,
                                   bool sb, bool ic)
    : los_param_base(c), grid(gr), solid_blocks(sb), ignore_clouds(ic)
{
}
dungeon_feature_type los_param_compat::feature(const coord_def& p) const
{
    return grid(trans(p));
}
unsigned los_param_compat::appearance(const coord_def& p) const
{
    return grid_appearance(grid, trans(p));
}
opacity_type los_param_compat::opacity(const coord_def& p) const
{
    dungeon_feature_type f = feature(p);
    if (grid_is_opaque(f) || solid_blocks && grid_is_solid(f))
        return OPC_OPAQUE;
    else if (!ignore_clouds && is_opaque_cloud(cloud_idx(p)))
        return OPC_HALF;
    else
        return OPC_CLEAR;
}

Insertion in crawl-ref/source/los.h at line 10 [2.24780]
[2.24902]
[2.24902]
```
#include "losparam.h"
```
Insertion in crawl-ref/source/los.h at line 37 [2.24780]
[2.25858]
[2.25858]
```
void losight(env_show_grid& sh, const los_param& dat);
```
Insertion in crawl-ref/source/los.cc at line 18 [2.26450]
[2.26679]
[2.26679]
```
#include "losparam.h"
```
Insertion in crawl-ref/source/los.cc at line 39 [2.26450]
[2.27329]
[2.27329]
```
const coord_def sh_o = coord_def(sh_xo, sh_yo);
```

Replacement in crawl-ref/source/los.cc at line 743 [2.26450]

B:BD[2.50944] → [2.50944:51089]

void losight(env_show_grid &sh,
             feature_grid &gr, const coord_def& center,
             bool clear_walls_block, bool ignore_clouds)

[2.50944]

[2.51089]


void _losight_quadrant(env_show_grid& sh, const los_param& dat, int sx, int sy)

Deletion in crawl-ref/source/los.cc at line 746 [2.26450]

B:BD[2.51091] → [2.51091:51743]

    raycast();
    const int x_p = center.x;
    const int y_p = center.y;
    // go quadrant by quadrant
    const int quadrant_x[4] = {  1, -1, -1,  1 };
    const int quadrant_y[4] = {  1,  1, -1, -1 };
    // clear out sh
    sh.init(0);
    if (crawl_state.arena || crawl_state.arena_suspended)
    {
        for (int y = -ENV_SHOW_OFFSET; y <= ENV_SHOW_OFFSET; ++y)
            for (int x = -ENV_SHOW_OFFSET; x <= ENV_SHOW_OFFSET; ++x)
            {
                const coord_def pos = center + coord_def(x, y);
                if (map_bounds(pos))
                    sh[x + sh_xo][y + sh_yo] = gr(pos);
            }
        return;
    }

Replacement in crawl-ref/source/los.cc at line 749 [2.26450]

B:BD[2.51884] → [2.51884:52039]

    for (int quadrant = 0; quadrant < 4; ++quadrant)
    {
        const int xmult = quadrant_x[quadrant];
        const int ymult = quadrant_y[quadrant];

[2.51884]

[2.52039]

    // clear out the dead rays array
    memset( (void*)dead_rays,  0, sizeof(unsigned long) * num_words);
    memset( (void*)smoke_rays, 0, sizeof(unsigned long) * num_words);

Replacement in crawl-ref/source/los.cc at line 753 [2.26450]

B:BD[2.52040] → [2.52040:52229]

        // clear out the dead rays array
        memset( (void*)dead_rays,  0, sizeof(unsigned long) * num_words);
        memset( (void*)smoke_rays, 0, sizeof(unsigned long) * num_words);

[2.52040]

[2.52229]

    // kill all blocked rays
    const unsigned long* inptr = los_blockrays;

Replacement in crawl-ref/source/los.cc at line 756 [2.26450]

B:BD[2.52230] → [2.52230:52315]

        // kill all blocked rays
        const unsigned long* inptr = los_blockrays;

[2.52230]

[2.52315]

    for (int x = 0; x <= LOS_MAX_RANGE_X; ++x)
        for (int y = 0; y <= LOS_MAX_RANGE_Y; ++y, inptr += num_words)
        {
            coord_def p = coord_def(sx*x, sy*y);
            if (!dat.map_bounds(p))
                continue;

Replacement in crawl-ref/source/los.cc at line 763 [2.26450]

B:BD[2.52316] → [2.52316:52483]

        for (int xdiff = 0; xdiff <= LOS_MAX_RANGE_X; ++xdiff)
            for (int ydiff = 0; ydiff <= LOS_MAX_RANGE_Y;
                 ++ydiff, inptr += num_words)

[2.52316]

[2.52483]

            // if this cell is opaque...
            switch (dat.opacity(p))

Replacement in crawl-ref/source/los.cc at line 766 [2.26450]

B:BD[2.52497] → [2.52497:53032]


                const int realx = x_p + xdiff * xmult;
                const int realy = y_p + ydiff * ymult;
                if (!map_bounds(realx, realy))
                    continue;
                coord_def real(realx, realy);
                dungeon_feature_type dfeat = grid_appearance(gr, real);
                // if this cell is opaque...
                // ... or something you can see but not walk through ...
                if (grid_is_opaque(dfeat)
                    || clear_walls_block && dfeat < DNGN_MINMOVE)

[2.52497]

[2.53032]

            case OPC_OPAQUE:
                // then block the appropriate rays
                for (unsigned int i = 0; i < num_words; ++i)
                    dead_rays[i] |= inptr[i];
                break;
            case OPC_HALF:
                // block rays which have already seen a cloud
                for (unsigned int i = 0; i < num_words; ++i)

Replacement in crawl-ref/source/los.cc at line 775 [2.26450]

B:BD[2.53050] → [2.53050:53220]

                    // then block the appropriate rays
                    for (unsigned int i = 0; i < num_words; ++i)
                        dead_rays[i] |= inptr[i];

[2.53050]

[2.53220]

                    dead_rays[i]  |= (smoke_rays[i] & inptr[i]);
                    smoke_rays[i] |= inptr[i];

Replacement in crawl-ref/source/los.cc at line 778 [2.26450]

B:BD[2.53238] → [2.53238:53679]

                else if (!ignore_clouds
                         && is_opaque_cloud(env.cgrid[realx][realy]))
                {
                    // block rays which have already seen a cloud
                    for (unsigned int i = 0; i < num_words; ++i)
                    {
                        dead_rays[i]  |= (smoke_rays[i] & inptr[i]);
                        smoke_rays[i] |= inptr[i];
                    }
                }

[2.53238]

[2.53679]

                break;
            default:
                break;

Insertion in crawl-ref/source/los.cc at line 782 [2.26450]
[2.53693]
[2.53693]
```
        }
```

Replacement in crawl-ref/source/los.cc at line 784 [2.26450]

B:BD[2.53694] → [2.53694:53896]

        // ray calculation done, now work out which cells in this
        // quadrant are visible
        unsigned int rayidx = 0;
        for (unsigned int wordloc = 0; wordloc < num_words; ++wordloc)

[2.53694]

[2.53896]

    // ray calculation done, now work out which cells in this
    // quadrant are visible
    unsigned int rayidx = 0;
    for (unsigned int wordloc = 0; wordloc < num_words; ++wordloc)
    {
        const unsigned long curword = dead_rays[wordloc];
        // Note: the last word may be incomplete
        for (unsigned int bitloc = 0; bitloc < LONGSIZE; ++bitloc)

Replacement in crawl-ref/source/los.cc at line 793 [2.26450]

B:BD[2.53906] → [2.53906:54092]

            const unsigned long curword = dead_rays[wordloc];
            // Note: the last word may be incomplete
            for (unsigned int bitloc = 0; bitloc < LONGSIZE; ++bitloc)

[2.53906]

[2.54092]

            // make the cells seen by this ray at this point visible
            if ( ((curword >> bitloc) & 1UL) == 0 )

Replacement in crawl-ref/source/los.cc at line 796 [2.26450]

B:BD[2.54106] → [2.54106:54235]

                // make the cells seen by this ray at this point visible
                if ( ((curword >> bitloc) & 1UL) == 0 )

[2.54106]

[2.54235]

                // this ray is alive!
                const coord_def p = coord_def(sx * compressed_ray_x[rayidx],
                                              sy * compressed_ray_y[rayidx]);
                // update shadow map
                if (dat.map_bounds(p) && p.abs() <= _los_radius_squared)

Replacement in crawl-ref/source/los.cc at line 802 [2.26450]

B:BD[2.54253] → [2.54253:54813]

                    // this ray is alive!
                    const int realx = xmult * compressed_ray_x[rayidx];
                    const int realy = ymult * compressed_ray_y[rayidx];
                    // update shadow map
                    if (x_p + realx >= 0 && x_p + realx < GXM
                        && y_p + realy >= 0 && y_p + realy < GYM
                        && realx * realx + realy * realy <= _los_radius_squared)
                    {
                        sh[sh_xo+realx][sh_yo+realy] = gr[x_p+realx][y_p+realy];
                    }

[2.54253]

[2.54813]

                    sh(p+sh_o) = dat.appearance(p);

Deletion in crawl-ref/source/los.cc at line 804 [2.26450]

B:BD[2.54831] → [2.54831:54928]

                ++rayidx;
                if (rayidx == num_cellrays)
                    break;

Insertion in crawl-ref/source/los.cc at line 805 [2.26450]

[2.54942]

            ++rayidx;
            if (rayidx == num_cellrays)
                break;

Insertion in crawl-ref/source/los.cc at line 810 [2.26450]
[2.54958]
[2.54958]
```
}
```

Replacement in crawl-ref/source/los.cc at line 812 [2.26450]

B:BD[2.54959] → [2.54959:55065]

    // [dshaligram] The player's current position is always visible.
    sh[sh_xo][sh_yo] = gr[x_p][y_p];

[2.54959]

[2.55065]

void losight(env_show_grid& sh, const los_param& dat)
{
    sh.init(0);

Replacement in crawl-ref/source/los.cc at line 816 [2.26450]

B:BD[2.55066] → [2.55066:55147]

    *dead_rays     = NULL;
    *smoke_rays    = NULL;
    *los_blockrays = NULL;

[2.55066]

[2.55147]

    // ensure precomputations are done
    raycast();
    const int quadrant_x[4] = {  1, -1, -1,  1 };
    const int quadrant_y[4] = {  1,  1, -1, -1 };
    for (int q = 0; q < 4; ++q)
    {
        _losight_quadrant(sh, dat, quadrant_x[q], quadrant_y[q]);
    }
    // center is always visible
    const coord_def o = coord_def(0,0);
    sh(o+sh_o) = dat.appearance(o);
}
void losight(env_show_grid &sh, feature_grid &gr,
             const coord_def& center, bool clear_walls_block,
             bool ignore_clouds)
{
    losight(sh, los_param_compat(gr, center, clear_walls_block, ignore_clouds));
}
void losight_permissive(env_show_grid &sh, const coord_def& center)
{
    for (int x = -ENV_SHOW_OFFSET; x <= ENV_SHOW_OFFSET; ++x)
        for (int y = -ENV_SHOW_OFFSET; y <= ENV_SHOW_OFFSET; ++y)
        {
            const coord_def pos = center + coord_def(x, y);
            if (map_bounds(pos))
                sh[x + sh_xo][y + sh_yo] = env.grid(pos);
        }

Replacement in crawl-ref/source/los.cc at line 863 [2.26450]

B:BD[2.55488] → [2.55488:55540]

        losight(env.show, grd, crawl_view.glosc());

[2.55488]

[2.55540]

        losight_permissive(env.show, crawl_view.glosc());