bool find_ray(const coord_def& source, const coord_def& target,
              bool allow_fallback, ray_def& ray, int cycle_dir,
              bool find_shortest, bool ignore_solid)

struct trans

    unsigned int cellray, inray;

    coord_def source;
    int signx, signy;

    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);
    const coord_def abs = coord_def(absx, absy);

    coord_def transform(coord_def l)
    {
        return coord_def(source.x + signx*l.x, source.y + signy*l.y);
    }
};

// Find ray in positive quadrant.
bool _find_ray_se(const coord_def& target, bool allow_fallback,
                  ray_def& ray, int cycle_dir, bool find_shortest,
                  bool ignore_solid, trans t)
{
    ASSERT(target.x >= 0 && target.y >= 0 && !target.origin());

    const double want_slope = _calc_slope(absx, absy);

    const double want_slope = _calc_slope(target.x, target.y);

        for (cellray = 0; cellray < lray.length; ++cellray)

        for (unsigned int cellray = 0; cellray < lray.length; ++cellray)

            if (lray[cellray] != abs)

            if (lray[cellray] != target)

            for (inray = 0; inray <= cellray; ++inray)

            for (unsigned int inray = 0; inray <= cellray; ++inray)

                const int xi = signx * ray_coords[inray + fullrays[fray].start].x;
                const int yi = signy * ray_coords[inray + fullrays[fray].start].y;

                c3 = ray_coords[inray + fullrays[fray].start];

                    && grid_is_solid(grd[source.x + xi][source.y + yi]))

                    && grid_is_solid(grd(t.transform(c3))))

                    c3 = coord_def(xi, yi);

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

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

        ray.accx = 0.5;
        ray.accy = 0.5;
        if (target.x == 0)

        {
            ray.slope  = target.y - source.y;
            ray.slope /= target.x - source.x;
            if (ray.slope < 0)
                ray.slope = -ray.slope;
        }
        _set_ray_quadrant(ray, source.x, source.y, target.x, target.y);

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

bool find_ray(const coord_def& source, const coord_def& target,
              bool allow_fallback, ray_def& ray, int cycle_dir,
              bool find_shortest, bool ignore_solid)
{
    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);
    const coord_def abs = coord_def(absx, absy);
    trans t;
    t.source = source;
    t.signx = signx;
    t.signy = signy;

    ray.accx -= source.x;
    ray.accy -= source.y;
    if (signx < 0)
        ray.accx = 1.0 - ray.accx;
    if (signy < 0)
        ray.accy = 1.0 - ray.accy;
    ray.quadrant = QUAD_SE;
    if (!_find_ray_se(abs, allow_fallback, ray, cycle_dir,
                      find_shortest, ignore_solid, t))
        return false;
    if (signx < 0)
        ray.accx = 1.0 - ray.accx;
    if (signy < 0)
        ray.accy = 1.0 - ray.accy;
    ray.accx += source.x;
    ray.accy += source.y;
    _set_ray_quadrant(ray, source.x, source.y, target.x, target.y);
    return true;
}