void tile_place_ray(const coord_def& gc);

void tile_place_ray(const coord_def& gc, bool in_range);

    TILE_FLAG_RAY_OOR   = 0x00800000,

        add_quad(TEX_DUNGEON, TILE_RAY_MESH, x, y);

        add_quad(TEX_DUNGEON, TILE_RAY, x, y);
    else if (bg & TILE_FLAG_RAY_OOR)
        add_quad(TEX_DUNGEON, TILE_RAY_OUT_OF_RANGE, x, y);

unsigned int tileRayCount = 0;
FixedVector<coord_def, 30> tileRays;

unsigned int num_tile_rays = 0;
struct tile_ray
{
    coord_def ep;
    bool in_range;
};
FixedVector<tile_ray, 30> tile_ray_vec;

void tile_place_ray(const coord_def& gc)

void tile_place_ray(const coord_def& gc, bool in_range)

    if (tileRayCount < tileRays.size() - 1)

    if (num_tile_rays < tile_ray_vec.size() - 1)

        tileRays[tileRayCount++] = view2show(grid2view(gc));

        tile_ray_vec[num_tile_rays].in_range = in_range;
        tile_ray_vec[num_tile_rays++].ep = view2show(grid2view(gc));

void tile_draw_rays(bool resetCount)

void tile_draw_rays(bool reset_count)

    for (unsigned int i = 0; i < tileRayCount; i++)
        env.tile_bg[tileRays[i].x-1][tileRays[i].y-1] |= TILE_FLAG_RAY;

    for (unsigned int i = 0; i < num_tile_rays; i++)
    {
        int flag = tile_ray_vec[i].in_range ? TILE_FLAG_RAY : TILE_FLAG_RAY_OOR;
        env.tile_bg[tile_ray_vec[i].ep.x-1][tile_ray_vec[i].ep.y-1] |= flag;
    }

    if (resetCount)
        tileRayCount = 0;

    if (reset_count)
        num_tile_rays = 0;

dc-misc/ray RAY_MESH

dc-misc/ray RAY
dc-misc/ray_out_of_range RAY_OUT_OF_RANGE

#ifndef USE_TILE

#endif

                           int glych, int mcol)

                           int glych, int mcol, bool in_range)

    tile_place_ray(pos);

    tile_place_ray(pos, in_range);

                {

                    if (range > 0)
                    {
                        ray_def raycopy = ray;
                        int l = 0;
                        while (raycopy.pos() != moves.target && l < range)
                        {
                            l++;
                            raycopy.advance_through(moves.target);
                        }
                        moves.target = raycopy.pos();
                    }
                }

                                       bcol | COLFLAG_REVERSE);

                                       bcol | COLFLAG_REVERSE, in_range);

                const bool in_range = (range < 0)
                    || grid_distance(raycopy.pos(), you.pos()) <= range;

                               MAGENTA | COLFLAG_REVERSE);

                               MAGENTA | COLFLAG_REVERSE, in_range);

        the path will be shown.

        the path will be shown.  This is always true for the tile
        version.