fiddlerwoaroof/crawl - Change GVCGKTH5IJ4VSQEIN4CRC7ZFVZW26JPIYNCPTO7GY66CSZZEW3ZQC

This is an experimental attempt at selecting more intuitive beams for

targeting (see 1725723):

The default beam selected for targeting is the shortest available beam that is closest to the Bresenham line between src->targ.
Targeting beams convert aliased perpendiculars into diagonals, which look better. This requires an immortal fudge to make sure the diagonal conversion doesn't happen at the wrong places (when the conversion would cause the beam to miss the target square).
Tweaked beam bounce behaviour to look more natural.

Comments and suggestions welcome.

git-svn-id: https://crawl-ref.svn.sourceforge.net/svnroot/crawl-ref/trunk@1511 c06c8d41-db1a-0410-9941-cceddc491573

Created by dshaligram on June 2, 2007

GVCGKTH5IJ4VSQEIN4CRC7ZFVZW26JPIYNCPTO7GY66CSZZEW3ZQC

Dependencies

In channels

main

Change contents

Replacement in crawl-ref/source/view.h at line 159 [6.13254]

B:BD[4.1235] → [5.4:75]

               bool allow_fallback, ray_def& ray, int cycle_dir = 0 );

[4.1235]

[7.4]

               bool allow_fallback, ray_def& ray, int cycle_dir = 0,
               bool find_shortest = false );

Insertion in crawl-ref/source/view.cc at line 30 [6.16817]
[6.17979]
[6.17979]
```
#include <cmath>
```

Insertion in crawl-ref/source/view.cc at line 1146 [6.16817]

[4.16520]

}
double ray_def::reflect(double p, double c) const
{
    return (c + c - p);
}
double ray_def::reflect(bool rx, double oldx, double newx) const
{
    if (rx? abs(slope) > 1.0 : abs(slope) < 1.0)
        return (reflect(oldx, floor(oldx) + 0.5));
    const int flnew = newx;
    const int flold = oldx;
    return (reflect(oldx,
                    flnew > flold? flnew :
                    flold > flnew? flold :
                    (newx + oldx) / 2));
}
void ray_def::set_reflect_point(const double oldx, const double oldy,
                                double *newx, double *newy,
                                bool blocked_x, bool blocked_y)
{
    if (blocked_x == blocked_y)
    {
        // What to do?
        *newx = oldx;
        *newy = oldy;
        return;
    }
    if (blocked_x)
    {
        ASSERT(int(oldy) != int(*newy));
        *newy = oldy;
        *newx = reflect(true, oldx, *newx);
    }
    else
    {
        ASSERT(int(oldx) != int(*newx));
        *newx = oldx;
        *newy = reflect(false, oldy, *newy);
    }

Replacement in crawl-ref/source/view.cc at line 1200 [6.16817]
B:BD[4.16750] → [4.16750:16774]
```
    int rc = advance();
```
[4.16750]
[4.16774]
```
    const double oldaccx = accx, oldaccy = accy;
    int rc = advance(true);
```

Insertion in crawl-ref/source/view.cc at line 1204 [6.16817]

[4.16852]


    const bool blocked_x = grid_is_solid(grd[oldx][newy]);
    const bool blocked_y = grid_is_solid(grd[newx][oldy]);

Deletion in crawl-ref/source/view.cc at line 1215 [6.16817]

B:BD[4.17082] → [4.17082:17196]

        bool blocked_x = grid_is_solid(grd[oldx][newy]);
        bool blocked_y = grid_is_solid(grd[newx][oldy]);

Replacement in crawl-ref/source/view.cc at line 1222 [6.16817]
B:BD[4.17428] → [4.17428:17443]
```
    advance();
```
[4.17428]
[4.17443]
```
    set_reflect_point(oldaccx, oldaccy, &accx, &accy, blocked_x, blocked_y);
```
Replacement in crawl-ref/source/view.cc at line 1226 [6.16817]
B:BD[6.61101] → [4.17446:17470]
```
void ray_def::regress()
```
[6.61101]
[4.17470]
```
void ray_def::regress(const coord_def &point)
```
Replacement in crawl-ref/source/view.cc at line 1230 [6.16817]
B:BD[4.17553] → [4.17553:17568]
```
    advance();
```
[4.17553]
[4.17568]
```
    advance(true, &point);
```

Replacement in crawl-ref/source/view.cc at line 1234 [6.16817]

B:BD[6.61211] → [4.17610:17633]

int ray_def::advance()

[6.61211]

[4.17633]

int ray_def::advance_through(const coord_def &target)
{
    return (advance(true, &target));
}
int ray_def::advance(bool shortest_possible, const coord_def *target)
{
    if (!shortest_possible)
        return (raw_advance());
    
    // If we want to minimize the number of moves on the ray, look one
    // step ahead and see if we can get a diagonal.
    
    const coord_def old(accx, accy);
    const int ret = raw_advance();
    if (ret == 2 || (target && pos() == *target))
        return (ret);
    
    const double maccx = accx, maccy = accy;
    if (raw_advance() != 2)
    {
        const coord_def second(accx, accy);
        // If we can convert to a diagonal, do so.
        if ((second - old).abs() == 2)
            return (2);
    }
    // No diagonal, so roll back.
    accx = maccx;
    accy = maccy;
    return (ret);
}
int ray_def::raw_advance()

Insertion in crawl-ref/source/view.cc at line 1653 [6.16817]

[5.649]

[8.68]

// If find_shortest is true, examine all rays that hit the target and
// take the shortest (starting at ray.fullray_idx).

Replacement in crawl-ref/source/view.cc at line 1657 [6.16817]

B:BD[4.29149] → [5.650:716]

               bool allow_fallback, ray_def& ray, int cycle_dir )

[4.29149]

[4.29200]

               bool allow_fallback, ray_def& ray, int cycle_dir,
               bool find_shortest )

Insertion in crawl-ref/source/view.cc at line 1667 [6.16817]

[4.29473]

[5.717]

    int shortest = INFINITE_DISTANCE;
    int imbalance = INFINITE_DISTANCE;
    std::vector<coord_def> unaliased_ray;

Insertion in crawl-ref/source/view.cc at line 1685 [6.16817]

[5.1160]

[6.66708]

                if (find_shortest)
                {
                    unaliased_ray.clear();
                    unaliased_ray.push_back(coord_def(0, 0));
                }

Insertion in crawl-ref/source/view.cc at line 1693 [6.16817]

[4.29880]

[5.1161]

                coord_def c1, c3;
                int real_length = 0;

Replacement in crawl-ref/source/view.cc at line 1697 [6.16817]

B:BD[5.1239] → [8.70:341]

                    if (grid_is_solid(
                            grd[sourcex
                                + signx * ray_coord_x[inray + cur_offset]]
                               [sourcey
                                + signy * ray_coord_y[inray + cur_offset]]))

[5.1239]

[6.66790]

                    const int xi = signx * ray_coord_x[inray + cur_offset];
                    const int yi = signy * ray_coord_y[inray + cur_offset];
                    if (grid_is_solid(grd[sourcex + xi][sourcey + yi]))

Replacement in crawl-ref/source/view.cc at line 1701 [6.16817]

B:BD[6.66812] → [4.30089:30148]

                        blocked = true;

[6.66812]

[4.30148]

                        blocked = true;

Insertion in crawl-ref/source/view.cc at line 1703 [6.16817]

[4.30179]

[6.67200]

                    }
                    if (find_shortest)
                    {
                        c3 = coord_def(xi, yi);
                        // We've moved at least two steps if inray > 0.
                        if (inray)
                        {
                            // 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();
                            }
                        }
                        else
                            ++real_length;
                        
                        unaliased_ray.push_back(c3);
                        c1 = unaliased_ray[real_length - 1];

Insertion in crawl-ref/source/view.cc at line 1729 [6.16817]

[6.67240]

[4.30180]


                if (find_shortest)
                    unaliased_ray.push_back(
                        coord_def(signx * absx, signy * absy));

Replacement in crawl-ref/source/view.cc at line 1734 [6.16817]

B:BD[4.30181] → [4.30181:30213]

                if ( !blocked )

[4.30181]

[6.67261]

                int cimbalance = 0;
                // If this ray is a candidate for shortest, calculate
                // the imbalance. I'm defining 'imbalance' as the
                // number of consecutive diagonal or orthogonal moves
                // in the ray. This is a reasonable measure of deviation from
                // the Bresenham line between our selected source and
                // destination.
                if (!blocked && find_shortest && shortest >= real_length)
                {
                    int diags = 0, straights = 0;
                    for (int i = 1, size = unaliased_ray.size(); i < size;
                         ++i)
                    {
                        const int dist =
                            (unaliased_ray[i] - unaliased_ray[i - 1]).abs();
                        if (dist == 2)
                        {
                            straights = 0;
                            if (++diags > cimbalance)
                                cimbalance = diags;
                        }
                        else
                        {
                            diags = 0;
                            if (++straights > cimbalance)
                                cimbalance = straights;
                        }
                    }
                }
                if ( !blocked
                     && (!find_shortest
                         || shortest > real_length
                         || (shortest == real_length
                             && imbalance > cimbalance)) )

Insertion in crawl-ref/source/view.cc at line 1771 [6.16817]

[4.30246]

                    shortest  = real_length;
                    imbalance = cimbalance;

Replacement in crawl-ref/source/view.cc at line 1782 [6.16817]

B:BD[4.30644] → [4.30644:30677]

                    return true;

[4.30644]

[6.67328]

                    if (!find_shortest)
                        return true;

Insertion in crawl-ref/source/view.cc at line 1788 [6.16817]

[4.30694]

[9.553]


    if (find_shortest && shortest != INFINITE_DISTANCE)
        return (true);

Replacement in crawl-ref/source/externs.h at line 251 [6.3270163]
∅:D[10.19484] → [11.440265:440319]
∅:D[12.145921] → [11.440265:440319]
B:BD[6.3272140] → [11.440265:440319]
```
    bool operator == (const coord_def &other) const {
```
[12.145921]
[11.440319]
```
    bool operator == (const coord_def &other) const
    {
```
Replacement in crawl-ref/source/externs.h at line 256 [6.3270163]
B:BD[11.440371] → [11.440371:440425]
```
    bool operator != (const coord_def &other) const {
```
[11.440371]
[13.26680]
```
    bool operator != (const coord_def &other) const
    {
```

Replacement in crawl-ref/source/externs.h at line 261 [6.3270163]

B:BD[10.19492] → [10.19492:19546]

    bool operator <  (const coord_def &other) const {

[10.19492]

[10.19546]

    bool operator <  (const coord_def &other) const
    {

Replacement in crawl-ref/source/externs.h at line 266 [6.3270163]

B:BD[12.145929] → [12.145929:145989]

    const coord_def &operator += (const coord_def &other) {

[12.145929]

[12.145989]

    const coord_def &operator += (const coord_def &other)
    {

Replacement in crawl-ref/source/externs.h at line 273 [6.3270163]

B:BD[12.146068] → [12.146068:146128]

    const coord_def &operator -= (const coord_def &other) {

[12.146068]

[12.146128]

    const coord_def &operator -= (const coord_def &other)
    {

Replacement in crawl-ref/source/externs.h at line 280 [6.3270163]

B:BD[12.146207] → [12.146207:146265]

    coord_def operator + (const coord_def &other) const {

[12.146207]

[12.146265]

    coord_def operator + (const coord_def &other) const
    {

Replacement in crawl-ref/source/externs.h at line 287 [6.3270163]

B:BD[12.146345] → [12.146345:146403]

    coord_def operator - (const coord_def &other) const {

[12.146345]

[12.146403]

    coord_def operator - (const coord_def &other) const
    {

Insertion in crawl-ref/source/externs.h at line 292 [6.3270163]
[12.146481]
[12.146481]
```
    }
    int abs() const
    {
        return (x * x + y * y);
```
Insertion in crawl-ref/source/externs.h at line 310 [6.3270163]
[5.1488]
[5.1488]
```
public:
```
Replacement in crawl-ref/source/externs.h at line 320 [6.3270163]
B:BD[5.1744] → [5.1744:1749]
```
    
```
[5.1744]
[3.4915]
```
public:
```

Replacement in crawl-ref/source/externs.h at line 324 [6.3270163]

∅:D[3.5021] → [5.1833:1904]

B:BD[5.1833] → [5.1833:1904]

    int advance();              // returns the direction taken (0,1,2)

[3.5021]

[5.1904]

    coord_def pos() const { return coord_def(accx, accy); }
    
    // returns the direction taken (0,1,2)
    int advance(bool shorten = false, const coord_def *p = NULL);
    int advance_through(const coord_def &point);

Replacement in crawl-ref/source/externs.h at line 330 [6.3270163]

B:BD[5.1935] → [5.1935:1955]

    void regress();

[5.1935]

[6.3272264]

    void regress(const coord_def &point);
private:
    int raw_advance();
    double reflect(bool x, double oldc, double newc) const;
    double reflect(double x, double c) const;
    void set_reflect_point(const double oldx, const double oldy,
                           double *newx, double *newy,
                           bool blocked_x, bool blocked_y);

Insertion in crawl-ref/source/externs.h at line 357 [6.3270163]

[6.3272831]


    // target - source (source == you.pos())
    coord_def target() const
    {
        return coord_def(tx, ty);
    }

Insertion in crawl-ref/source/externs.h at line 419 [6.3270163]

[14.2397]

[4.895951]


    coord_def target() const
    {
        return (coord_def(target_x, target_y));
    }

Replacement in crawl-ref/source/direct.cc at line 294 [6.3697945]
∅:D[15.951] → [16.1361:1422]
B:BD[16.1361] → [16.1361:1422]
```
void direction(struct dist& moves, targeting_type restricts,
```
[15.951]
[17.9582]
```
void direction(dist& moves, targeting_type restricts,
```

Replacement in crawl-ref/source/direct.cc at line 469 [6.3697945]

B:BD[5.3149] → [5.3149:3217]

            show_beam = false;
            need_beam_redraw = true;

[5.3149]

[5.3217]

            if (show_beam)
            {
                show_beam = false;
                need_beam_redraw = true;
            }
            else
            {
                show_beam = find_ray(you.x_pos, you.y_pos, moves.tx, moves.ty,
                                     true, ray, 0, true);
                need_beam_redraw = show_beam;
            }

Replacement in crawl-ref/source/direct.cc at line 708 [6.3697945]

B:BD[5.3583] → [5.3583:3662]

                find_ray(you.x_pos, you.y_pos, moves.tx, moves.ty, true, ray);

[5.3583]

[6.3704179]

                find_ray(you.x_pos, you.y_pos, moves.tx, moves.ty, true, ray,
                         0, true);

Replacement in crawl-ref/source/direct.cc at line 751 [6.3697945]

B:BD[5.4543] → [5.4543:4582]

                    raycopy.advance();

[5.4543]

[5.4582]

                    raycopy.advance_through(moves.target());

Replacement in crawl-ref/source/direct.cc at line 775 [6.3697945]
B:BD[17.10713] → [17.10713:10750]
```
        mx = (GXM  - 1) - you.x_pos;
```
[17.10713]
[17.10750]
```
        mx = (GXM - 1) - you.x_pos;
```
Replacement in crawl-ref/source/beam.cc at line 1265 [6.4128068]
B:BD[6.4169427] → [6.4169427:4169480]
```
void fire_beam( struct bolt &pbolt, item_def *item )
```
[6.4169427]
[6.4169480]
```
void fire_beam( bolt &pbolt, item_def *item )
```
Insertion in crawl-ref/source/beam.cc at line 1270 [6.4128068]
[6.4169943]
[18.319]
```
    bool did_bounce = false;
```

Replacement in crawl-ref/source/beam.cc at line 1306 [6.4128068]

B:BD[5.4801] → [5.4801:4863]

                  pbolt.target_x, pbolt.target_y, true, ray);

[5.4801]

[2.256]

                  pbolt.target_x, pbolt.target_y, true, ray,
                  0, true );

Replacement in crawl-ref/source/beam.cc at line 1311 [6.4128068]
B:BD[4.1228821] → [4.1228821:1228844]
```
        ray.advance();
```
[4.1228821]
[6.4171324]
```
        ray.advance_through(pbolt.target());
```

Replacement in crawl-ref/source/beam.cc at line 1356 [6.4128068]

B:BD[4.1229256] → [4.1229256:1229344]

                if (!isBouncy(pbolt, grd[tx][ty])) {
                    ray.regress();

[4.1229256]

[4.1229344]

                if (!isBouncy(pbolt, grd[tx][ty]))
                {
                    ray.regress(pbolt.target());

Insertion in crawl-ref/source/beam.cc at line 1363 [6.4128068]
[4.1229494]
[6.4174385]
```
                did_bounce = true;
```
Replacement in crawl-ref/source/beam.cc at line 1368 [6.4128068]
B:BD[4.1229542] → [4.1229542:1229577]
```
                    ray.regress();
```
[4.1229542]
[4.1229577]
```
                    ray.regress(pbolt.target());
```

Replacement in crawl-ref/source/beam.cc at line 1466 [6.4128068]

B:BD[6.4178369] → [4.1230518:1230541]

        ray.advance();

[6.4178369]

[6.4178492]


        if (!did_bounce)
            ray.advance_through(pbolt.target());
        else
            ray.advance(true);

This is an experimental attempt at selecting more intuitive beams for

Dependencies

In channels

Change contents

Replacement in crawl-ref/source/view.h at line 159 [6.13254]

Insertion in crawl-ref/source/view.cc at line 30 [6.16817]

Insertion in crawl-ref/source/view.cc at line 1146 [6.16817]

Replacement in crawl-ref/source/view.cc at line 1200 [6.16817]

Insertion in crawl-ref/source/view.cc at line 1204 [6.16817]

Deletion in crawl-ref/source/view.cc at line 1215 [6.16817]

Replacement in crawl-ref/source/view.cc at line 1222 [6.16817]

Replacement in crawl-ref/source/view.cc at line 1226 [6.16817]

Replacement in crawl-ref/source/view.cc at line 1230 [6.16817]