ray_def ray;
    if (!find_ray(you.pos(), spd.target, ray))

    if (!exists_ray(you.pos(), spd.target))

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

              ray_def& ray, const opacity_func &opc = opc_solid,
              const bounds_func &bds = bds_default, bool cycle = false);
bool exists_ray(const coord_def& source, const coord_def& target,
                const opacity_func &opc = opc_solid,
                const bounds_func &bds = bds_default);
dungeon_feature_type ray_blocker(const coord_def& source, const coord_def& target);

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

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

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

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

    if (!_find_ray_se(abs, ray, cycle, opc_trans, bds))

    if (!_find_ray_se(abs, ray, opc_trans, bds, cycle))

}
bool exists_ray(const coord_def& source, const coord_def& target,
                const opacity_func& opc, const bounds_func &bds)
{
    ray_def ray;
    return (find_ray(source, target, ray, opc, bds));
}
// Assuming that target is in view of source, but line of
// fire is blocked, what is it blocked by?
dungeon_feature_type ray_blocker(const coord_def& source,
                                 const coord_def& target)
{
    ray_def ray;
    if (!find_ray(source, target, ray, opc_default))
    {
        ASSERT (false);
        return (NUM_REAL_FEATURES);
    }
    ray.advance(false); // Must not cut corners!
    int blocked = 0;
    while (ray.pos() != target)
    {
        blocked += opc_solid(ray.pos());
        if (blocked >= OPC_OPAQUE)
            return (env.grid(ray.pos()));
        ray.advance(false);
    }
    ASSERT (false);
    return (NUM_REAL_FEATURES);

// XXX: fold this into generalized find_ray.

// Assuming the target is in view, is line-of-fire
// blocked, and by what?

    ray_def ray;
    if (!find_ray(you.pos(), where, ray))
        fallback_ray(you.pos(), where, ray);
    ray.advance_through(where);
    while (ray.pos() != where)
    {
        if (grd(ray.pos()) <= DNGN_MINMOVE)
        {
            if (feat != NULL)
                *feat = grd(ray.pos());
            return (true);
        }
        ray.advance_through(where);
    }
    return (false);

    if (exists_ray(you.pos(), where))
        return (false);
    if (feat == NULL)
        return (true);
    *feat = ray_blocker(you.pos(), where);
    return (true);

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

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

// Describe a cell, guaranteed to be in view.

    ray_def ray;
    return find_ray(source, target, ray);

    return exists_ray(source, target);