if (!find_ray(begin, towards, ray, 0, true))

    if (!find_ray(begin, towards, ray))

    // Quadrant by sign of x/y coordinate.

    int fullray_idx;   // for cycling: where did we come from?

    // For cycling: where did we come from?
    int cycle_idx;

    : accx(ax), accy(ay), slope(s), quadx(qx), quady(qy), fullray_idx(idx)

    : accx(ax), accy(ay), slope(s), quadx(qx), quady(qy), cycle_idx(idx)

            if (!find_ray(coord_def(gridx, gridy), coord_def(tx, ty),
                          ray, 0, true, true))

            if (!find_ray(coord_def(gridx, gridy), coord_def(tx, ty), ray))

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

              ray_def& ray, bool cycle = false, bool ignore_solid = false);

// XXX: fullrays is not needed anymore after precomputation.

// We also store the minimal cellrays by target position
// for efficient retrieval by find_ray.
// XXX: Consider condensing this representation.
struct cellray;
FixedArray<std::vector<cellray>, LOS_MAX_RANGE+1, LOS_MAX_RANGE+1> min_cellrays;

// pre-squared LOS radius

// Pre-squared LOS radius.

    // The footprint of this ray is stored in
    // ray_coords[start..start+length-1].

    // Returns the cells it travels through, excluding the origin.

// A cellray given by fullray and length.

// A cellray given by fullray and index of end-point.

    // A cellray passes through cells ray_coords[ray.start..ray.start+end].

    int length;

    unsigned int end; // Relative index (inside ray) of end cell.

    cellray(const los_ray& r, int l) : ray(r), length(l) {}

    cellray(const los_ray& r, unsigned int e)
        : ray(r), end(e), imbalance(-1), slope_diff(-1)
    {
    }
    // The end-point's index inside ray_coord.
    int index() const { return (ray.start + end); }
    // The end-point.
    coord_def target() const { return ray_coords[index()]; }

    int index() const { return ray.start + length; }
    coord_def end() const { return ray_coords[index()]; }

    // XXX: Currently ray/cellray[0] is the first point outside the origin.
    coord_def operator[](unsigned int i)
    {
        ASSERT(0 <= i && i <= end);
        return ray_coords[ray.start+i];
    }
    // Parameters used in find_ray. These need to be calculated
    // only for the minimal cellrays.
    int imbalance;
    double slope_diff;
    void calc_params();

// Compare two cellrays to the same target.
// This determines which ray is considered better by find_ray,
// used with list::sort.
// Returns true if a is strictly better than b, false else.
bool _is_better(const cellray& a, const cellray& b)
{
    // Only compare cellrays with equal target.
    ASSERT(a.target() == b.target());
    // calc_params() has been called.
    ASSERT(a.imbalance >= 0 && b.imbalance >= 0);
    if (a.imbalance < b.imbalance)
        return (true);
    else if (a.imbalance > b.imbalance)
        return (false);
    else
        return (a.slope_diff < b.slope_diff);
}

    if (a.end() != b.end())

    if (a.target() != b.target())

    int enda = cura + a.length;
    int endb = curb + b.length;

    int enda = cura + a.end;
    int endb = curb + b.end;

// Returns a vector which lists all minimal cellrays (by index).

// Determine all minimal cellrays.
// They're stored globally by target in min_cellrays,
// and returned as a list of indices into ray_coords.

            std::list<cellray>& min = minima(c.end());

            std::list<cellray>& min = minima(c.target());

        for (min_it = minima(*qi).begin(); min_it != minima(*qi).end(); min_it++)

    {
        std::list<cellray>& min = minima(*qi);
        for (min_it = min.begin(); min_it != min.end(); min_it++)
        {
            // Calculate imbalance and slope difference for sorting.
            min_it->calc_params();

        }
        min.sort(_is_better);
        min_cellrays(*qi) = std::vector<cellray>(min.begin(), min.end());
    }

    // Determine nonduplicated rays and store their end points.
    std::vector<int> min_cellrays = _find_minimal_cellrays();
    const int n_min_rays          = min_cellrays.size();

    // Determine minimal cellrays and store their indices in ray_coords.
    std::vector<int> min_indices = _find_minimal_cellrays();
    const int n_min_rays         = min_indices.size();

        cellray_ends[i] = ray_coords[min_cellrays[i]];

        cellray_ends[i] = ray_coords[min_indices[i]];

                                   ->get(min_cellrays[i]));

                                   ->get(min_indices[i]));

}
static int _cyclic_offset(int i, int cycle_dir, int startpoint,
                          int maxvalue)
{
    if (startpoint < 0)
        return i;
    switch (cycle_dir)
    {
    case 1:
        return (i + startpoint + 1) % maxvalue;
    case -1:
        return (i - 1 - startpoint + maxvalue) % maxvalue;
    case 0:
    default:
        return i;
    }

}
static bool _superior_ray(int imbalance, int rayimbalance,
                          double slope_diff, double ray_slope_diff)
{
    if (imbalance != rayimbalance)
        return (imbalance > rayimbalance);
    return (slope_diff > ray_slope_diff);

// Compute the imbalance, defined 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.
static int _imbalance(const std::vector<coord_def>& ray)

static int _imbalance(ray_def ray, const coord_def& target)

    for (int i = 1, size = ray.size(); i < size; ++i)

    while (ray.pos() != target)

        const int dist =
           (ray[i] - ray[i - 1]).abs();
        if (dist == 2)

        adv_type adv = ray.advance_through(target);
        if (adv == ADV_XY)

            diags++;

void cellray::calc_params()
{
    coord_def trg = target();
    imbalance = _imbalance(ray, trg);
    slope_diff = _slope_factor(ray) - _calc_slope(trg.x, trg.y);
}

                  int cycle_dir, bool find_best,
                  bool ignore_solid, trans t)

                  bool cycle, bool ignore_solid, trans t)

    bool found = false;
    int imbalance   = INFINITE_DISTANCE;
    const double want_slope = _calc_slope(target.x, target.y);
    double slope_diff       = VERTICAL_SLOPE * 10.0;
    double ray_slope_diff = slope_diff;
    std::vector<coord_def> unaliased_ray;

    const std::vector<cellray> &min = min_cellrays(target);
    ASSERT(min.size() > 0);
    cellray c = min[0]; // XXX: const cellray &c ?
    unsigned int index = 0;

    for (unsigned int fray = 0; fray < fullrays.size(); ++fray)
    {
        const int fullray = _cyclic_offset(fray, cycle_dir, ray.fullray_idx,
                                           fullrays.size());
        los_ray lray = fullrays[fullray];

#ifdef DEBUG_DIAGNOSTICS
    if (cycle)
        mprf(MSGCH_DIAGNOSTICS, "cycling from %d (total %d), ignores_solid=%d",
             ray.cycle_idx, min.size(), ignore_solid);
#endif

        for (unsigned int cellray = 0; cellray < lray.length; ++cellray)
        {
            if (lray[cellray] != target)
                continue;

    unsigned int start = cycle ? ray.cycle_idx + 1 : 0;
    ASSERT(0 <= start && start <= min.size());

            if (find_best)

    if (ignore_solid)
    {
        index = start % min.size();
        c = min[index];
    }
    else
    {
        bool blocked = true;
        for (unsigned int i = start; blocked && (i < start + min.size()); i++)
        {
            index = i % min.size();
            c = min[index];
            blocked = false;
            // Check all inner points.
            for (unsigned int j = 0; j < c.end && !blocked; j++)

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

                coord_def cur = t.transform(c[j]);
                blocked = grid_is_solid(grd(cur));

            // Check if we're blocked so far.
            bool blocked = false;
            coord_def c1, c3;
            for (unsigned int inray = 0; inray <= cellray; ++inray)
            {
                c3 = ray_coords[inray + fullrays[fray].start];
                if (inray < cellray && !ignore_solid
                    && grid_is_solid(grd(t.transform(c3))))
                {
                    blocked = true;
                    break;
                }
                if (find_best)
                {
                    // 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)
                        {
                            // c2 was a dud move, pop it off
                            unaliased_ray.pop_back();
                        }
                    }
                    unaliased_ray.push_back(c3);
                    c1 = unaliased_ray[unaliased_ray.size() - 2];
                }
            }
            // If this ray is a candidate for shortest, calculate
            // the imbalance.
            int cimbalance = 0;
            if (!blocked && find_best)
            {
                cimbalance = _imbalance(unaliased_ray);
                ray_slope_diff = fabs(_slope_factor(lray) - want_slope);
            }
            if (blocked || (find_best &&
                            !_superior_ray(imbalance, cimbalance,
                                           slope_diff, ray_slope_diff)))
            {
                continue;
            }
            // Success!
            found = true;
            ray             = lray;
            ray.fullray_idx = fullray;
            imbalance  = cimbalance;
            slope_diff = ray_slope_diff;
            if (!find_best)
                return (true);

        if (blocked)
            return (false);

    return (found);

    ray = c.ray;
    ray.cycle_idx = index;
    return (true);

// If cycle_dir is 0, find the first fitting ray. If it is 1 or -1,

// If cycle is false, find the first fitting ray. If it is true,

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

// ray.

              ray_def& ray, int cycle_dir,
              bool find_best, bool ignore_solid)

              ray_def& ray, bool cycle, bool ignore_solid)

    if (!_find_ray_se(abs, ray, cycle_dir, find_best, ignore_solid, t))

    if (!_find_ray_se(abs, ray, cycle, ignore_solid, t))

    if (find_ray(a, b, *ray, 0, true))

    if (find_ray(a, b, *ray))

        moves.choseRay = find_ray(you.pos(), moves.target,
                                  moves.ray, 0, true);

        moves.choseRay = find_ray(you.pos(), moves.target, moves.ray);

        moves.choseRay = find_ray(you.pos(), moves.target,
                                  moves.ray, 0, true);

        moves.choseRay = find_ray(you.pos(), moves.target, moves.ray);

    if (!find_ray(you.pos(), where, ray, 0, true))

    if (!find_ray(you.pos(), where, ray))

            have_beam = find_ray(you.pos(), moves.target,
                                 ray, (show_beam ? 1 : 0));

            have_beam = find_ray(you.pos(), moves.target, ray, show_beam);

                have_beam = find_ray(you.pos(), moves.target,
                                     ray, 0, true);

                have_beam = find_ray(you.pos(), moves.target, ray);

                 have_beam = find_ray(you.pos(), moves.target,
                                      ray, 0, true);

                 have_beam = find_ray(you.pos(), moves.target, ray);

    if (!find_ray(begin, towards, ray, 0, true))

    if (!find_ray(begin, towards, ray))

        if (!find_ray(source, target, ray, 0, true))

        if (!find_ray(source, target, ray))