fiddlerwoaroof/crawl - Change RGO2JV5HFKZFXO7KJWDXGDMNBR6NIAOMJW34NHRTLLVN2N7XGW7QC

Further cleanup by converting to bit_array.

Created by Robert Vollmert on October 10, 2009

RGO2JV5HFKZFXO7KJWDXGDMNBR6NIAOMJW34NHRTLLVN2N7XGW7QC

Dependencies

In channels

main

Change contents

Replacement in crawl-ref/source/los.cc at line 2 [3.26450]

B:BD[3.26454] → [3.26454:26518]

 *  File:       los.cc
 *  Summary:    Line-of-sight algorithm.

[3.26454]

[3.26518]

 *  File:        los.cc
 *  Summary:     Line-of-sight algorithm.

Insertion in crawl-ref/source/los.cc at line 14 [3.26450]
[3.26599]
[3.26618]
```
#include "bitary.h"
```

Replacement in crawl-ref/source/los.cc at line 58 [3.26450]

B:BD[4.3717] → [2.3042:3124]

typedef FixedArray<unsigned long*, LOS_MAX_RANGE+1, LOS_MAX_RANGE+1> blockrays_t;

[4.3717]

[2.3124]

typedef FixedArray<bit_array*, LOS_MAX_RANGE+1, LOS_MAX_RANGE+1> blockrays_t;

Replacement in crawl-ref/source/los.cc at line 64 [3.26450]

B:BD[4.3901] → [4.3901:3975]

unsigned long* dead_rays     = NULL;
unsigned long* smoke_rays    = NULL;

[4.3901]

[4.3975]

bit_array *dead_rays     = NULL;
bit_array *smoke_rays    = NULL;

Replacement in crawl-ref/source/los.cc at line 69 [3.26450]

B:BD[3.27668] → [3.27668:27717]

B:BD[3.27717] → [2.3152:3288]

    delete[] dead_rays;
    delete[] smoke_rays;
    for (int x = 0; x <= LOS_MAX_RANGE; x++)
        for (int y = 0; y <= LOS_MAX_RANGE; y++)
            delete[] los_blockrays[x][y];

[3.27668]

[3.27745]

   delete dead_rays;
   delete smoke_rays;
   for (int x = 0; x <= LOS_MAX_RANGE; x++)
       for (int y = 0; y <= LOS_MAX_RANGE; y++)
           delete los_blockrays[x][y];

Deletion in crawl-ref/source/los.cc at line 92 [3.26450]

B:BD[3.27980] → [4.3977:4043]

∅:D[4.4043] → [3.28048:28177]

B:BD[3.28048] → [3.28048:28177]

B:BD[3.28177] → [4.4044:4111]

∅:D[4.4111] → [3.28246:28360]

B:BD[3.28246] → [3.28246:28360]

bool _get_bit_in_long_array(const unsigned long* data, int where)
{
    int wordloc = where / LONGSIZE;
    int bitloc = where % LONGSIZE;
    return ((data[wordloc] & (1UL << bitloc)) != 0);
}
static void _set_bit_in_long_array(unsigned long* data, int where)
{
    int wordloc = where / LONGSIZE;
    int bitloc = where % LONGSIZE;
    data[wordloc] |= (1UL << bitloc);
}

Deletion in crawl-ref/source/los.cc at line 240 [3.26450]
B:BD[2.3529] → [2.3529:3563]
∅:D[2.3563] → [3.33072:33126]
B:BD[3.33072] → [3.33072:33126]
```
    const int num_nondupe_words =
        (num_nondupe_rays + LONGSIZE - 1) / LONGSIZE;
```
Deletion in crawl-ref/source/los.cc at line 241 [3.26450]
B:BD[2.3613] → [2.3613:3681]
```
    const int num_words = (num_cellrays + LONGSIZE - 1) / LONGSIZE;
```
Deletion in crawl-ref/source/los.cc at line 243 [3.26450]
B:BD[2.3718] → [2.3718:3749]
```
    // allocate and initialize
```

Replacement in crawl-ref/source/los.cc at line 246 [3.26450]

B:BD[2.3853] → [2.3853:4179]

            full_los_blockrays[x][y] = new unsigned long[num_words];
            memset((void*)full_los_blockrays[x][y], 0, sizeof(unsigned long) * num_words);
            los_blockrays[x][y] = new unsigned long[num_nondupe_words];
            memset((void*)los_blockrays[x][y], 0, sizeof(unsigned long) * num_nondupe_words);

[2.3853]

[2.4179]

            full_los_blockrays[x][y] = new bit_array(num_cellrays);
            los_blockrays[x][y] = new bit_array(num_nondupe_rays);

Replacement in crawl-ref/source/los.cc at line 261 [3.26450]

B:BD[3.34130] → [2.4345:4425]

                _set_bit_in_long_array(full_los_blockrays[x][y], cur_offset+j);

[3.34130]

[3.34196]

                full_los_blockrays[x][y]->set(cur_offset+j);

Deletion in crawl-ref/source/los.cc at line 280 [3.26450]
B:BD[2.4568] → [2.4568:4578]
```
        {
```

Replacement in crawl-ref/source/los.cc at line 281 [3.26450]

B:BD[2.4633] → [2.4633:4835]

∅:D[2.4835] → [3.35456:35466]

B:BD[3.35456] → [3.35456:35466]

                if (_get_bit_in_long_array(full_los_blockrays[x][y],
                                           nondupe_cellrays[i]))
                    _set_bit_in_long_array(los_blockrays[x][y], i);
        }

[2.4633]

[3.35466]

                los_blockrays[x][y]->set(i,
                    full_los_blockrays[x][y]->get(nondupe_cellrays[i]));

Replacement in crawl-ref/source/los.cc at line 287 [3.26450]

B:BD[2.4930] → [2.4930:4977]

            delete[] full_los_blockrays[x][y];

[2.4930]

[3.35548]

            delete full_los_blockrays[x][y];

Replacement in crawl-ref/source/los.cc at line 289 [3.26450]

B:BD[3.35549] → [3.35549:35659]

    dead_rays  = new unsigned long[num_nondupe_words];
    smoke_rays = new unsigned long[num_nondupe_words];

[3.35549]

[3.35659]

    dead_rays  = new bit_array(num_nondupe_rays);
    smoke_rays = new bit_array(num_nondupe_rays);

Deletion in crawl-ref/source/los.cc at line 723 [3.26450]
B:BD[3.51806] → [2.5252:5320]
```
    const int num_words = (num_cellrays + LONGSIZE - 1) / LONGSIZE;
```

Replacement in crawl-ref/source/los.cc at line 725 [3.26450]

B:BD[5.7531] → [2.5321:5459]

    memset((void*)dead_rays,  0, sizeof(unsigned long) * num_words);
    memset((void*)smoke_rays, 0, sizeof(unsigned long) * num_words);

[5.7531]

[3.52229]

    dead_rays->reset();
    smoke_rays->reset();

Replacement in crawl-ref/source/los.cc at line 740 [3.26450]

B:BD[5.8148] → [2.5555:5667]

                for (int i = 0; i < num_words; ++i)
                    dead_rays[i] |= los_blockrays[x][y][i];

[5.8148]

[5.8255]

                *dead_rays |= *los_blockrays[x][y];

Replacement in crawl-ref/source/los.cc at line 744 [3.26450]

B:BD[5.8367] → [2.5668:5720]

∅:D[2.5720] → [3.53032:53050]

∅:D[5.8428] → [3.53032:53050]

B:BD[3.53032] → [3.53032:53050]

B:BD[3.53050] → [2.5721:5861]

∅:D[2.5861] → [3.53220:53238]

∅:D[5.8541] → [3.53220:53238]

B:BD[3.53220] → [3.53220:53238]

                for (int i = 0; i < num_words; ++i)
                {
                    dead_rays[i]  |= (smoke_rays[i] & los_blockrays[x][y][i]);
                    smoke_rays[i] |= los_blockrays[x][y][i];
                }

[5.8367]

[5.8542]

                *dead_rays  |= (*smoke_rays & *los_blockrays[x][y]);
                *smoke_rays |= *los_blockrays[x][y];

Replacement in crawl-ref/source/los.cc at line 754 [3.26450]
∅:D[2.5953] → [5.8711:8740]
B:BD[5.8711] → [5.8711:8740]
B:BD[5.8740] → [2.5954:6012]
```
    unsigned int rayidx = 0;
    for (int wordloc = 0; wordloc < num_words; ++wordloc)
```
[2.5953]
[5.8807]
```
    for (unsigned int rayidx = 0; rayidx < num_cellrays; ++rayidx)
```

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

B:BD[5.8813] → [5.8813:8871]

B:BD[5.8920] → [5.8920:8987]

        const unsigned long curword = dead_rays[wordloc];
        for (unsigned int bitloc = 0; bitloc < LONGSIZE; ++bitloc)

[5.8813]

[3.53896]

        // make the cells seen by this ray at this point visible
        if (!dead_rays->get(rayidx))

Replacement in crawl-ref/source/los.cc at line 759 [3.26450]

B:BD[3.53906] → [5.8988:9109]

∅:D[5.9109] → [3.54092:54106]

B:BD[3.54092] → [3.54092:54106]

B:BD[3.54106] → [5.9110:9340]

B:BD[5.9340] → [6.3544:3583]

B:BD[3.54253] → [5.9414:9466]

B:BD[3.54928] → [3.54928:54942]

B:BD[3.54942] → [5.9467:9552]

            // make the cells seen by this ray at this point visible
            if ( ((curword >> bitloc) & 1UL) == 0 )
            {
                // 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.los_bounds(p))
                    sh(p+sh_o) = dat.appearance(p);
            }
            ++rayidx;
            if (rayidx == num_cellrays)
                break;

[3.53906]

[3.54942]

            // 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.los_bounds(p))
                sh(p+sh_o) = dat.appearance(p);