bool allow_fallback, ray_def& ray );

               bool allow_fallback, ray_def& ray, int cycle_dir = 0 );

static int cyclic_offset( unsigned int ui, int cycle_dir, int startpoint,
                          int maxvalue )
{
    const int i = (int)ui;
    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;
    }
}

// If cycle_dir is 0, find the first fitting ray. If it is 1 or -1,
// assume that ray is appropriately filled in, and look for the next
// ray in that cycle direction.

               bool allow_fallback, ray_def& ray )

               bool allow_fallback, ray_def& ray, int cycle_dir )

    for ( unsigned int fullray = 0; fullray < fullrays.size();
          cur_offset += raylengths[fullray++] ) {

    for ( unsigned int fray = 0; fray < fullrays.size(); ++fray )
    {
        const int fullray = cyclic_offset( fray, cycle_dir, ray.fullray_idx,
                                           fullrays.size() );
        // yeah, yeah, this is O(n^2). I know.
        cur_offset = 0;
        for ( int i = 0; i < fullray; ++i )
            cur_offset += raylengths[i];

                 ray_coord_y[cellray + cur_offset] == absy ) {

                 ray_coord_y[cellray + cur_offset] == absy )
            {

                for ( inray = 0; inray < cellray; ++inray ) {

                for ( inray = 0; inray < cellray; ++inray )
                {

                    ray.fullray_idx = fullray;

        ray.fullray_idx = -1;

};
struct ray_def
{
    double accx;
    double accy;
    double slope;
    // Quadrant 1: down-right
    // Quadrant 2: down-left
    // Quadrant 3: up-left
    // Quadrant 4: up-right
    int quadrant;
    int fullray_idx;            // for cycling: where did we come from?
    
    int x() const { return (int)(accx); }
    int y() const { return (int)(accy); }
    int advance();              // returns the direction taken (0,1,2)
    void advance_and_bounce();
    void regress();

    bool choseRay;      // user wants a specific beam

    ray_def ray;        // ray chosen if necessary

    bool        is_beam;                // beams? (can hits multiple targets?)

    bool        is_beam;               // beams? (can hits multiple targets?)

    bool        chose_ray;      // do we want a specific ray?
    ray_def     ray;            // shoot on this specific ray

};
struct ray_def
{
    double accx;
    double accy;
    double slope;
    // Quadrant 1: down-right
    // Quadrant 2: down-left
    // Quadrant 3: up-left
    // Quadrant 4: up-right
    int quadrant;
    
    int x() const { return (int)(accx); }
    int y() const { return (int)(accy); }
    int advance();              // returns the direction taken (0,1,2)
    void advance_and_bounce();
    void regress();

    CMD_TARGET_CYCLE_BEAM,
    CMD_TARGET_HIDE_BEAM,

            // weapon in an untrained skill.  Since the game 
            // doesn't allow for much in the way of good launchers, 
            // we'll lower their weight.

            // weapon in an untrained skill.

            int weight = 0;

            const int weight = you.skills[i] + 1;
            count += weight;

            weight = you.skills[i] + 1;
            if (weight)
            {
                count += weight;
                if (random2(count) < weight)
                    skill = i;
            }

            if (random2(count) < weight)
                skill = i;

    case ' ': case '.': return CMD_TARGET_SELECT;

    case ' ': return CMD_TARGET_CYCLE_BEAM;
    case ':': return CMD_TARGET_HIDE_BEAM;
    case '.': return CMD_TARGET_SELECT;

//           choseRay       player wants a specific ray
//           ray            ...this one

    bool show_beam = false;
    ray_def ray;

    moves.choseRay      = false;

    // XXX Add: ability to cycle between appropriate rays!

        bool need_redraw = true;

        bool need_beam_redraw = false;

        case CMD_TARGET_CYCLE_BEAM:
            show_beam = find_ray(you.x_pos, you.y_pos, moves.tx, moves.ty,
                                 true, ray, (show_beam ? 1 : 0));
            need_beam_redraw = true;
            break;
            
        case CMD_TARGET_HIDE_BEAM:
            show_beam = false;
            need_beam_redraw = true;
            break;
            

                need_redraw = false;

            need_redraw = false;

                need_redraw = false;

                    need_redraw = false;

                need_redraw = false;

                need_redraw = false;

            if (mid == NON_MONSTER)
            {
                // XXX we can put in code for describing terrain here
                need_redraw = false;

            if (mid == NON_MONSTER) // can put in terrain description here

            }

            {
                need_redraw = false;

            }

            need_redraw = false;

                need_redraw = false;

                moves.choseRay = show_beam;
                moves.ray = ray;

            need_redraw = true; // not sure this is necessary

        }
        bool have_moved = false;
        if ( old_tx != moves.tx || old_ty != moves.ty )
        {
            have_moved = true;
            show_beam = show_beam &&
                find_ray(you.x_pos, you.y_pos, moves.tx, moves.ty, true, ray);

        if ( need_redraw )

        if ( have_moved )

            // XXX : put in beam redrawing code here

            if ( show_beam )
                need_beam_redraw = true;

        if ( need_beam_redraw )
        {
            viewwindow(true, false);
            if ( show_beam &&
                 in_vlos(grid2viewX(moves.tx), grid2viewY(moves.ty)) )
            {
                // Draw the new ray
                ray_def raycopy = ray;
                textcolor(MAGENTA);
                while ( raycopy.x() != moves.tx || raycopy.y() != moves.ty )
                {
                    if ( raycopy.x() != you.x_pos || raycopy.y() != you.y_pos )
                    {
                        if ( !in_los(raycopy.x(), raycopy.y()) )
                            break;
                        gotoxy( grid2viewX(raycopy.x() + 1),
                                grid2viewY(raycopy.y()));
                        cprintf("*");
                    }
                    raycopy.advance();
                }
                textcolor(LIGHTGREY);
            }
        }

    find_ray( pbolt.source_x, pbolt.source_y, pbolt.target_x, pbolt.target_y,
              true, ray);

    if ( pbolt.chose_ray )
        ray = pbolt.ray;
    else
        find_ray( pbolt.source_x, pbolt.source_y,
                  pbolt.target_x, pbolt.target_y, true, ray);

               can_see_invis(false), is_friendly(false), foe_ratio(0) 

               can_see_invis(false), is_friendly(false), foe_ratio(0),
               chose_ray(false)

    chose_ray = d.choseRay;
    if ( d.choseRay )
        ray = d.ray;