// Note: find_ray relies on the fact that 2*OPC_HALF == OPC_OPAQUE.
// On the other hand, losight tracks this explicitly.

    OPC_CLEAR,
    OPC_HALF,    // for opaque clouds; two or more block
    OPC_OPAQUE,

    OPC_CLEAR  = 0,
    OPC_HALF   = 1,    // for opaque clouds; two or more block
    OPC_OPAQUE = 2,

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

              ray_def& ray, bool cycle = false,
              const opacity_func &opc = opc_solid,
              const bounds_func &bds = bds_default);

// Coordinate transformation so we can find_ray quadrant-by-quadrant.
// TODO: Unify with los_params.
struct trans
{
    coord_def source;
    int signx, signy;
    coord_def transform(coord_def l)
    {
        return coord_def(source.x + signx*l.x, source.y + signy*l.y);
    }
};

// opc has been translated for this quadrant.
// XXX: Allow finding ray of minimum opacity.

                  bool cycle, bool ignore_solid, trans t)

                  bool cycle, const opacity_func& opc,
                  const bounds_func& bds)

    if (target.abs() > LOS_RADIUS2)

    if (!bds(target))

        mprf(MSGCH_DIAGNOSTICS, "cycling from %d (total %d), ignores_solid=%d",
             ray.cycle_idx, min.size(), ignore_solid);

        mprf(MSGCH_DIAGNOSTICS, "cycling from %d (total %d)",
             ray.cycle_idx, min.size());

    if (ignore_solid)

    int blocked = OPC_OPAQUE;
    for (unsigned int i = start;
         (blocked >= OPC_OPAQUE) && (i < start + min.size()); i++)

        index = start % min.size();

        index = i % min.size();

    }
    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++)
            {
                coord_def cur = t.transform(c[j]);
                blocked = grid_is_solid(grd(cur));
            }
        }
        if (blocked)
            return (false);

        blocked = OPC_CLEAR;
        // Check all inner points.
        for (unsigned int j = 0; j < c.end && blocked < OPC_OPAQUE; j++)
            blocked += opc(c[j]);

    if (blocked >= OPC_OPAQUE)
        return (false);

// Coordinate transformation so we can find_ray quadrant-by-quadrant.
struct opacity_trans : opacity_func
{
    const coord_def& source;
    int signx, signy;
    const opacity_func& orig;
    opacity_trans(const opacity_func& opc, const coord_def& s, int sx, int sy)
        : source(s), signx(sx), signy(sy), orig(opc)
    {
    }

    opacity_type operator()(const coord_def &l) const
    {
        return orig(transform(l));
    }
    coord_def transform(const coord_def &l) const
    {
        return coord_def(source.x + signx*l.x, source.y + signy*l.y);
    }
};

// ray.

// ray. We only ever use ray.cycle_idx.

              ray_def& ray, bool cycle, bool ignore_solid)

              ray_def& ray, bool cycle,
              const opacity_func& opc, const bounds_func &bds)

    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;

    opacity_trans opc_trans = opacity_trans(opc, source, signx, signy);

    ray.quadx = 1;
    ray.quady = 1;
    if (!_find_ray_se(abs, ray, cycle, ignore_solid, t))
        return false;

    if (!_find_ray_se(abs, ray, cycle, opc_trans, bds))
        return (false);

    return true;

    return (true);