fiddlerwoaroof/crawl - Change PEWNWU7TD3LETUMWCCI365KH7PVV2XCUOIFTPBH2LK2ZPGS4URZAC

Some find_ray cleanup.

Created by Robert Vollmert on October 13, 2009

PEWNWU7TD3LETUMWCCI365KH7PVV2XCUOIFTPBH2LK2ZPGS4URZAC

Dependencies

In channels

main

Change contents

Deletion in crawl-ref/source/los.cc at line 567 [5.26450]

∅:D[4.6802] → [5.40752:40889]

B:BD[5.40752] → [5.40752:40889]


    const int sourcex = source.x;
    const int sourcey = source.y;
    const int targetx = target.x;
    const int targety = target.y;

Replacement in crawl-ref/source/los.cc at line 568 [5.26450]

B:BD[5.40890] → [5.40890:41110]

    const int signx = ((targetx - sourcex >= 0) ? 1 : -1);
    const int signy = ((targety - sourcey >= 0) ? 1 : -1);
    const int absx  = signx * (targetx - sourcex);
    const int absy  = signy * (targety - sourcey);

[5.40890]

[6.4371]

    const int signx = ((target.x - source.x >= 0) ? 1 : -1);
    const int signy = ((target.y - source.y >= 0) ? 1 : -1);
    const int absx  = signx * (target.x - source.x);
    const int absy  = signy * (target.y - source.y);

Replacement in crawl-ref/source/los.cc at line 588 [5.26450]

B:BD[5.41815] → [4.6907:6945]

            if (lray[cellray] == abs)

[5.41815]

[5.41935]

            if (lray[cellray] != abs)
                continue;
            if (find_shortest)
            {
                unaliased_ray.clear();
                unaliased_ray.push_back(coord_def(0, 0));
            }
            // Check if we're blocked so far.
            bool blocked = false;
            coord_def c1, c3;
            int real_length = 0;
            for (inray = 0; inray <= cellray; ++inray)

Replacement in crawl-ref/source/los.cc at line 603 [5.26450]

B:BD[5.41949] → [5.41949:41984]

                if (find_shortest)

[5.41949]

[5.41984]

                const int xi = signx * ray_coords[inray + fullrays[fray].start].x;
                const int yi = signy * ray_coords[inray + fullrays[fray].start].y;
                if (inray < cellray && !ignore_solid
                    && grid_is_solid(grd[source.x + xi][source.y + yi]))

Replacement in crawl-ref/source/los.cc at line 608 [5.26450]

B:BD[5.42002] → [5.42002:42107]

                    unaliased_ray.clear();
                    unaliased_ray.push_back(coord_def(0, 0));

[5.42002]

[5.42107]

                    blocked = true;
                    break;

Replacement in crawl-ref/source/los.cc at line 612 [5.26450]

B:BD[5.42126] → [5.42126:42344]

                // Check if we're blocked so far.
                bool blocked = false;
                coord_def c1, c3;
                int real_length = 0;
                for (inray = 0; inray <= cellray; ++inray)

[5.42126]

[5.42344]

                if (find_shortest)

Replacement in crawl-ref/source/los.cc at line 614 [5.26450]

B:BD[5.42362] → [3.3036:3210]

∅:D[3.3210] → [5.42514:42761]

∅:D[6.4630] → [5.42514:42761]

∅:D[4.7100] → [5.42514:42761]

B:BD[5.42514] → [5.42514:42761]

                    const int xi = signx * ray_coords[inray + fullrays[fray].start].x;
                    const int yi = signy * ray_coords[inray + fullrays[fray].start].y;
                    if (inray < cellray && !ignore_solid
                        && grid_is_solid(grd[sourcex + xi][sourcey + yi]))
                    {
                        blocked = true;
                        break;
                    }

[5.42362]

[5.42761]

                    c3 = coord_def(xi, yi);

Replacement in crawl-ref/source/los.cc at line 616 [5.26450]

B:BD[5.42762] → [5.42762:42801]

                    if (find_shortest)

[5.42762]

[5.42801]

                    // We've moved at least two steps if inray > 0.
                    if (inray)

Replacement in crawl-ref/source/los.cc at line 619 [5.26450]

B:BD[5.42823] → [5.42823:42979]

                        c3 = coord_def(xi, yi);
                        // We've moved at least two steps if inray > 0.
                        if (inray)

[5.42823]

[5.42979]

                        // Check for a perpendicular corner on the ray and
                        // pretend that it's a diagonal.
                        if ((c3 - c1).abs() != 2)
                            ++real_length;
                        else

Replacement in crawl-ref/source/los.cc at line 625 [5.26450]

B:BD[5.43005] → [5.43005:43462]

                            // Check for a perpendicular corner on the ray and
                            // pretend that it's a diagonal.
                            if ((c3 - c1).abs() != 2)
                                ++real_length;
                            else
                            {
                                // c2 was a dud move, pop it off
                                unaliased_ray.pop_back();
                            }

[5.43005]

[5.43462]

                            // c2 was a dud move, pop it off
                            unaliased_ray.pop_back();

Deletion in crawl-ref/source/los.cc at line 628 [5.26450]

B:BD[5.43488] → [5.43488:43675]

                        else
                            ++real_length;
                        unaliased_ray.push_back(c3);
                        c1 = unaliased_ray[real_length - 1];

Insertion in crawl-ref/source/los.cc at line 629 [5.26450]

[5.43697]

                    else
                        ++real_length;
                    unaliased_ray.push_back(c3);
                    c1 = unaliased_ray[real_length - 1];

Insertion in crawl-ref/source/los.cc at line 635 [5.26450]
[5.43715]
[5.43715]
```
            }
```

Replacement in crawl-ref/source/los.cc at line 637 [5.26450]

B:BD[5.43752] → [5.43752:43822]

B:BD[5.43822] → [2.3835:3905]

∅:D[2.3905] → [5.44138:44212]

B:BD[5.44138] → [5.44138:44212]

B:BD[5.44212] → [2.3906:3966]

                // If this ray is a candidate for shortest, calculate
                // the imbalance.
                int cimbalance = 0;
                if (!blocked && find_shortest && shortest >= real_length)
                    cimbalance = _imbalance(unaliased_ray);

[5.43716]

[5.44500]

            // If this ray is a candidate for shortest, calculate
            // the imbalance.
            int cimbalance = 0;
            if (!blocked && find_shortest && shortest >= real_length)
                cimbalance = _imbalance(unaliased_ray);

Replacement in crawl-ref/source/los.cc at line 643 [5.26450]

B:BD[5.45016] → [5.45016:45078]

B:BD[5.45078] → [4.7101:7167]

                const double ray_slope_diff = find_shortest ?
                    fabs(_slope_factor(lray) - want_slope) : 0.0;

[5.44501]

[5.45157]

            const double ray_slope_diff = find_shortest ?
                fabs(_slope_factor(lray) - want_slope) : 0.0;

Replacement in crawl-ref/source/los.cc at line 646 [5.26450]

B:BD[5.45158] → [5.45158:45290]

                if (!blocked
                    &&  (!find_shortest
                         || _superior_ray(shortest, imbalance,

[5.45158]

[5.45290]

            if (blocked || (find_shortest &&
                            _superior_ray(shortest, imbalance,

Replacement in crawl-ref/source/los.cc at line 650 [5.26450]

B:BD[5.45429] → [5.45429:45479]

B:BD[5.45479] → [4.7168:7212]

∅:D[4.7212] → [5.45536:45583]

B:BD[5.45536] → [5.45536:45583]

                {
                    // Success!
                    ray             = lray;
                    ray.fullray_idx = fullray;

[5.45429]

[5.45583]

            {
                continue;
            }
            // Success!
            ray             = lray;
            ray.fullray_idx = fullray;

Replacement in crawl-ref/source/los.cc at line 658 [5.26450]

B:BD[5.45584] → [5.45584:45724]

                    shortest   = real_length;
                    imbalance  = cimbalance;
                    slope_diff = ray_slope_diff;

[5.45584]

[5.45724]

            shortest   = real_length;
            imbalance  = cimbalance;
            slope_diff = ray_slope_diff;

Replacement in crawl-ref/source/los.cc at line 662 [5.26450]

B:BD[5.45725] → [5.45725:45913]

                    if (sourcex > targetx)
                        ray.accx = 1.0 - ray.accx;
                    if (sourcey > targety)
                        ray.accy = 1.0 - ray.accy;

[5.45725]

[5.45913]

            if (source.x > target.x)
                ray.accx = 1.0 - ray.accx;
            if (source.y > target.y)
                ray.accy = 1.0 - ray.accy;

Replacement in crawl-ref/source/los.cc at line 667 [5.26450]

B:BD[5.45914] → [5.45914:45996]

                    ray.accx += sourcex;
                    ray.accy += sourcey;

[5.45914]

[5.45996]

            ray.accx += source.x;
            ray.accy += source.y;

Replacement in crawl-ref/source/los.cc at line 670 [5.26450]

B:BD[5.45997] → [5.45997:46188]

                    _set_ray_quadrant(ray, sourcex, sourcey, targetx, targety);
                    if (!find_shortest)
                        return (true);
                }
            }

[5.45997]

[5.46188]

            _set_ray_quadrant(ray, source.x, source.y, target.x, target.y);
            if (!find_shortest)
                return (true);

Replacement in crawl-ref/source/los.cc at line 681 [5.26450]

B:BD[5.46315] → [5.46315:46415]

        ray.accx = sourcex + 0.5;
        ray.accy = sourcey + 0.5;
        if (targetx == sourcex)

[5.46315]

[5.46415]

        ray.accx = source.x + 0.5;
        ray.accy = source.y + 0.5;
        if (target.x == source.x)

Replacement in crawl-ref/source/los.cc at line 687 [5.26450]

B:BD[5.46478] → [5.46478:46566]

            ray.slope  = targety - sourcey;
            ray.slope /= targetx - sourcex;

[5.46478]

[5.46566]

            ray.slope  = target.y - source.y;
            ray.slope /= target.x - source.x;

Replacement in crawl-ref/source/los.cc at line 692 [5.26450]

B:BD[5.46647] → [5.46647:46715]

        _set_ray_quadrant(ray, sourcex, sourcey, targetx, targety);

[5.46647]

[5.46715]

        _set_ray_quadrant(ray, source.x, source.y, target.x, target.y);