}
static const double VERTICAL_SLOPE = 10000.0;
static double calc_slope(double x, double y)
{
    if (double_is_zero(x))
        return (VERTICAL_SLOPE);
    const double slope = y / x;
    return (slope > VERTICAL_SLOPE? VERTICAL_SLOPE : slope);
}
static double slope_factor(const ray_def &ray)
{
    double xdiff = fabs(ray.accx - 0.5), ydiff = fabs(ray.accy - 0.5);
    if (double_is_zero(xdiff) && double_is_zero(ydiff))
        return ray.slope;
    const double slope = calc_slope(ydiff, xdiff);
    return (slope + ray.slope) / 2.0;

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

    const double want_slope = calc_slope(absx, absy);

    double slope_diff = VERTICAL_SLOPE * 10.0;

                const double ray_slope_diff =
                    find_shortest? fabs(slope_factor(fullrays[fullray])
                                      - want_slope)
                    : 0.0;

                     && (!find_shortest
                         || shortest > real_length
                         || (shortest == real_length
                             && imbalance > cimbalance)) )

                     &&  (!find_shortest
                          || superior_ray(shortest, imbalance,
                                          real_length, cimbalance,
                                          slope_diff, ray_slope_diff)))

                    shortest  = real_length;
                    imbalance = cimbalance;
                    ray = fullrays[fullray];

                    ray        = fullrays[fullray];

                    shortest   = real_length;
                    imbalance  = cimbalance;
                    slope_diff = ray_slope_diff;

            ray.slope = 10000.0;

            ray.slope = VERTICAL_SLOPE;

bool in_vlos(const coord_def &pos);

bool in_vlos(const coord_def &pos)
{
    return (in_vlos(pos.x, pos.y));
}