const int idx = get_fire_item_index();

            const int idx = get_current_fire_item();

    const int idx = get_fire_item_index();

    const int idx = get_current_fire_item();

        int q = you.quiver[get_quiver_type()] = get_fire_item_index();

        int q = you.quiver[get_quiver_type()] = get_current_fire_item();

int get_fire_item_index(int start_from = 0, bool forward = true,
                        bool check_quiver = true);

int get_current_fire_item();
int get_next_fire_item(int current, int offset);

}
static bool Hack_Ignore_F_Inscription = false;    // only for "why can't I fire" feedback
static bool fire_item_okay(const item_def &item, unsigned flags)
{
    return (fire_item_matches(item, flags)
            && (Hack_Ignore_F_Inscription || strstr(item.inscription.c_str(), "=f") == 0)
            && you.equip[EQ_WEAPON] != item.link);

// Search all items in pack for a fire_item_okay item.
// If check_quiver, quiver item is checked first.
// Then, check all items in the loop determined by start and forward
static int find_fire_item_matching(unsigned fire_type, int start,
                                   bool forward, bool check_quiver)

// Not free, but not a performance issue either.
static bool Hack_Ignore_F_Inscription = false;    // only for "why can't I fire" feedback
static void _get_fire_order(std::vector<int>& fire_order)

    if (check_quiver)
    {
        const int q = you.quiver[get_quiver_type()];
        if (q >= 0 && q < ENDOFPACK && fire_item_okay(you.inv[q], fire_type))
            return (q);
    }
    const int dir = forward? 1 : -1;
    int end = forward? ENDOFPACK : -1;
    for (int i = start; i != end; )

    for (unsigned int i_inv=Options.fire_items_start; i_inv<ENDOFPACK; i_inv++)

        if (i >= Options.fire_items_start
            && fire_item_okay(you.inv[i], fire_type))
        {
            return (i);
        }

        const item_def& item = you.inv[i_inv];
        if (!is_valid_item(item))
            continue;
        // =f prevents item from being in fire order
        if (!Hack_Ignore_F_Inscription &&
            strstr(item.inscription.c_str(), "=f"))
            continue;

        i += dir;
        if (i == -1)

        unsigned int i_flags;
        for (i_flags=0; i_flags<Options.fire_order.size(); i_flags++)

            i   += ENDOFPACK;
            end = start;

            if (fire_item_matches(item, Options.fire_order[i_flags])
                && you.equip[EQ_WEAPON] != i_inv)
            {
                fire_order.push_back( (i_flags<<16) | (i_inv & 0xffff) );
                break;
            }

        else if (i == ENDOFPACK)

        if (i_flags == Options.fire_order.size())

            i   = 0;
            end = start;

            // Didn't match any flags -- last chance is the +f inscription
            if (strstr(item.inscription.c_str(), "+f"))
            {
                fire_order.push_back( (i_flags<<16) | (i_inv & 0xffff) );
            }

    return (ENDOFPACK);

    std::sort(fire_order.begin(), fire_order.end());
    for (unsigned int i=0; i<fire_order.size(); i++)
    {
        fire_order[i] &= 0xffff;
    }

// Note: This is a simple implementation, not an efficient one. -- bwr
//
// Returns item index or ENDOFPACK if no item found for auto-firing
int get_fire_item_index(int start_from, bool forward, bool check_quiver)

int get_next_fire_item(int current, int direction)

    int item = ENDOFPACK;

    std::vector<int> fire_order;
    _get_fire_order(fire_order);

    for (unsigned i = 0; i < Options.fire_order.size(); i++)

    if (fire_order.size() == 0)
        return ENDOFPACK;
    if (current == ENDOFPACK)
        return fire_order[0];
    for (unsigned i=0; i<fire_order.size(); i++)

        const unsigned fire_flags = Options.fire_order[i];
        if ((item =
             find_fire_item_matching(fire_flags,
                                     start_from,
                                     forward,
                                     check_quiver)) != ENDOFPACK)
            break;

        if (fire_order[i] == current)
        {
            unsigned next = (i + fire_order.size() + direction) % fire_order.size();
            return fire_order[next];
        }

    return fire_order[0];
}

    // either item was found or is still ENDOFPACK for no item
    return (item);

int get_current_fire_item()
{
    std::vector<int> fire_order;
    _get_fire_order(fire_order);
    if (fire_order.size() == 0)
        return ENDOFPACK;
    const int q = you.quiver[get_quiver_type()];
    for (unsigned i = 0; i < fire_order.size(); i++)
        if (q == fire_order[i])
            return q;
    return fire_order[0];

        item = get_fire_item_index();

        item = get_current_fire_item();

    const int next_item
                = get_fire_item_index((item + 1) % ENDOFPACK, true, false);

    const int next_item = get_next_fire_item(item, +1);

          const int direction = (key == CONTROL('N')) ? +1 : -1;
          const int start = (item + ENDOFPACK + direction) % ENDOFPACK;
          const int next = get_fire_item_index(start, (direction==1), false);

          const int direction = (key == CONTROL('P')) ? -1 : +1;
          const int next = get_next_fire_item(item, direction);

    const int cur_item = get_fire_item_index();

    const int cur_item = get_current_fire_item();

    const int skipped_item = get_fire_item_index();

    const int skipped_item = get_current_fire_item();

    const int thrown = missile_slot == -1? get_fire_item_index() : missile_slot;

    const int thrown = missile_slot == -1? get_current_fire_item() : missile_slot;

                    missile_slot == -1? get_fire_item_index() :

                    missile_slot == -1? get_current_fire_item() :

    const int item = get_fire_item_index();

    const int item = get_current_fire_item();

            const int next = get_fire_item_index((cur+1) % ENDOFPACK, true, false);

            const int next = get_next_fire_item(cur, +1);