#include "quiver.h"

            const int idx = get_current_fire_item();
            if ( idx == ENDOFPACK )

            const item_def* item;
            int idx;
            you.m_quiver->get_desired_item(&item, &idx);
            if ( item == NULL )

            }
            else if ( idx == -1 )
            {
                mpr("No missiles left.");
                return SPRET_ABORT;

#include "quiver.h"

    const int idx = get_current_fire_item();
    if ( idx == ENDOFPACK )

    int idx;
    const item_def* item;
    you.m_quiver->get_desired_item(&item, &idx);
    if ( item == NULL )

        return false;
    }
    else if ( idx == -1 )
    {
        mpr("No missiles left.");

        you.quiver_change = true;

        else if (ammo == you.quiver[get_quiver_type()])
            you.quiver_change = true;

    // Returns an item, or a reason why we returned an invalid item
    int get_default_slot(std::string& no_item_reason) const;
    void get_fire_order(std::vector<int>& v) const { _get_fire_order(v, false); }

    int get_fire_item(std::string* no_item_reason=0) const;
    void get_fire_order(std::vector<int>& v) const;

    void on_item_thrown(const item_def&);

    void on_item_fired_fi(const item_def&);
    void on_inv_quantity_change(int slot, int amt);

    void _get_fire_order(std::vector<int>&, bool ignore_inscription_etc) const;

    void _get_fire_order(std::vector<int>&,
                         bool ignore_inscription_etc,
                         const item_def* launcher) const;
    void _maybe_fill_empty_slot();

    item_def m_last_weapon;

static ammo_t _get_weapon_ammo_type();
static bool _item_matches(const item_def &item, fire_type types);

static ammo_t _get_weapon_ammo_type(const item_def*);
static bool _item_matches(const item_def &item, fire_type types, const item_def* launcher);
static bool _items_similar(const item_def& a, const item_def& b);

        *item_out = NULL;
        *slot_out = -1;

        if (item_out) *item_out = NULL;
        if (slot_out) *slot_out = -1;

        *slot_out = _get_pack_slot(m_last_used_of_type[m_last_used_type]);
        if (*slot_out == -1)

        const int slot = _get_pack_slot(m_last_used_of_type[m_last_used_type]);
        if (slot == -1)

            *item_out = &m_last_used_of_type[m_last_used_type];

            if (item_out) *item_out = &m_last_used_of_type[m_last_used_type];

            *item_out = &you.inv[*slot_out];

            if (item_out) *item_out = &you.inv[slot];

        if (slot_out) *slot_out = slot;

// This is the first item displayed in the fire interface.
int player_quiver::get_default_slot(std::string& no_item_reason) const

// This differs from get_desired_item; that method can return
// an item that is not in inventory, while this one cannot.
// If no item can be found, return the reason why.
int player_quiver::get_fire_item(std::string* no_item_reason) const

        _get_fire_order(order, false);

        _get_fire_order(order, false, you.weapon());

        _get_fire_order(full_fire_order, true);
        if (full_fire_order.size() == 0)

        _get_fire_order(full_fire_order, true, you.weapon());
        if (no_item_reason == NULL)

            no_item_reason = "No suitable missiles.";

            // nothing
        }
        else if (full_fire_order.size() == 0)
        {
            *no_item_reason = "No suitable missiles.";

                no_item_reason = make_stringf(

                *no_item_reason = make_stringf(

                no_item_reason = make_stringf(

                *no_item_reason = make_stringf(

        const ammo_t t = _get_weapon_ammo_type();

        const ammo_t t = _get_weapon_ammo_type(weapon);

        m_last_used_of_type[t].quantity = 1;    // ensure it's valid

        m_last_used_of_type[t].quantity = 1;    // 0 makes it invalid :(
        m_last_used_type = t;

        m_last_used_type = AMMO_THROW;

// Notification that ltem was fired with 'f' 't'
void player_quiver::on_item_thrown(const item_def& item)

// Notification that ltem was fired with 'f' 'i'
void player_quiver::on_item_fired_fi(const item_def& item)

    m_last_used_of_type[AMMO_THROW] = item;
    m_last_used_of_type[AMMO_THROW].quantity = 1;

    // currently no difference
    on_item_fired(item);

// Called when the player might have switched weapons, or might have
// picked up something interesting.

    m_last_used_type = _get_weapon_ammo_type();

    // Only switch m_last_used_type if weapon really changed
    const item_def* weapon = you.weapon();
    if (weapon == NULL)
    {
        if (m_last_weapon.base_type != OBJ_UNASSIGNED)
        {
            m_last_weapon.base_type = OBJ_UNASSIGNED;
            m_last_used_type = AMMO_THROW;
        }
    }
    else
    {
        if (! _items_similar(*weapon, m_last_weapon))
        {
            m_last_weapon = *weapon;
            m_last_used_type = _get_weapon_ammo_type(weapon);
        }
    }
                
    _maybe_fill_empty_slot();

void player_quiver::_get_fire_order(std::vector<int>& order, bool ignore_inscription_etc) const

void player_quiver::on_inv_quantity_change(int slot, int amt)
{
    if (m_last_used_of_type[m_last_used_type].base_type == OBJ_UNASSIGNED)
    {
        // Empty quiver.  Maybe we can fill it now?
        _maybe_fill_empty_slot();
        you.quiver_change = true;
    }
    else if (m_last_used_of_type[m_last_used_type].base_type !=
             you.inv[slot].base_type)
    {
        // Not our current stack; don't bother
    }
    else
    {
        // Maybe matches current stack.  Redraw if so.
        int qv_slot; get_desired_item(NULL, &qv_slot);
        if (qv_slot == slot)
            you.quiver_change = true;
    }
}
// If current quiver slot is empty, fill it with something useful.
void player_quiver::_maybe_fill_empty_slot()
{
    const item_def* weapon = you.weapon();
    const ammo_t slot = _get_weapon_ammo_type(weapon);
    if (! is_valid_item(m_last_used_of_type[slot]))
    {
        // const launch_retval desired_ret =
        //     (weapon && is_range_weapon(*weapon)) ? LRET_LAUNCHED : LRET_THROWN;
        const launch_retval desired_ret =
            (slot == AMMO_THROW ? LRET_THROWN : LRET_LAUNCHED);
        std::vector<int> order;  _get_fire_order(order, false, weapon);
        for (unsigned int i=0; i<order.size(); i++)
        {
            if (is_launched(&you, weapon, you.inv[order[i]]) == desired_ret)
            {
                m_last_used_of_type[slot] = you.inv[order[i]];
                m_last_used_of_type[slot].quantity = 1;
                break;
            }
        }
    }
}
void player_quiver::get_fire_order(std::vector<int>& v) const
{
    _get_fire_order(v, false, you.weapon());
}
// Get a sorted list of items to show in the fire interface.
// 
// If ignore_inscription_etc, ignore =f and Options.fire_items_start.
// This is used for generating informational error messages, when the
// fire order is empty.
//
// launcher determines what items match the 'launcher' fire_order type.
void player_quiver::_get_fire_order(
    std::vector<int>& order,
    bool ignore_inscription_etc,
    const item_def* launcher) const

        const item_def *weapon = you.weapon();
        if (weapon && weapon->sub_type == WPN_BLOWGUN)

        if (launcher && launcher->sub_type == WPN_BLOWGUN)

                if (is_valid_item(you.inv[i_inv]) && you.inv[i_inv].launched_by(*weapon))

                if (is_valid_item(you.inv[i_inv]) && you.inv[i_inv].launched_by(*launcher))

            if (_item_matches(item, (fire_type)Options.fire_order[i_flags]))

            if (_item_matches(item, (fire_type)Options.fire_order[i_flags], launcher))

static bool _item_matches(const item_def &item, fire_type types)

static bool _item_matches(const item_def &item, fire_type types, const item_def* launcher)

    ASSERT(!is_valid_item(item));

    ASSERT(is_valid_item(item));

            const item_def *weapon = you.weapon();
            if (weapon && item.launched_by(*weapon))

            if (launcher && item.launched_by(*launcher))

        if (items_stack(item, you.inv[i]))

        const item_def& inv_item = you.inv[i];
        if (inv_item.quantity && _items_similar(item, you.inv[i]))

static ammo_t _get_weapon_ammo_type()

static ammo_t _get_weapon_ammo_type(const item_def* weapon)

    const int wielded = you.equip[EQ_WEAPON];
    if (wielded == -1)
        return (AMMO_THROW);
    item_def &weapon = you.inv[wielded];
    if (weapon.base_type != OBJ_WEAPONS)
        return (AMMO_THROW);

    if (weapon == NULL)
        return AMMO_THROW;
    if (weapon->base_type != OBJ_WEAPONS)
        return AMMO_THROW;

    switch (weapon.sub_type)

    switch (weapon->sub_type)

            return (AMMO_BLOWGUN);

            return AMMO_BLOWGUN;

            return (AMMO_SLING);

            return AMMO_SLING;

            return (AMMO_BOW);

            return AMMO_BOW;

            return (AMMO_CROSSBOW);

            return AMMO_CROSSBOW;

            return (AMMO_HAND_CROSSBOW);

            return AMMO_HAND_CROSSBOW;

            return (AMMO_THROW);

            return AMMO_THROW;

}
static bool _items_similar(const item_def& a, const item_def& b)
{
    // this is a reasonable implementation for now
    return items_stack(a, b, true);

#include "quiver.h"

    : m_quiver(0)

    kills = new KillMaster();

    kills = new KillMaster();   // why isn't this done in init()?

    : m_quiver(0)

    // why doesn't this do a copy_from?
    player_quiver* saved_quiver = m_quiver;

    m_quiver = saved_quiver;

    *m_quiver = *(other.m_quiver);

// why is this not called "operator="?

    KillMaster *_kills = kills;

    KillMaster *saved_kills = kills;
    player_quiver* saved_quiver = m_quiver;

    kills  = _kills;

    kills  = saved_kills;

    m_quiver = saved_quiver;
    *m_quiver = *(other.m_quiver);

    if (m_quiver) delete m_quiver;
    m_quiver = new player_quiver;

#include "quiver.h"

    if (you.quiver[get_quiver_type()] == obj)
        you.quiver_change = true;

    you.m_quiver->on_inv_quantity_change(obj, amount);

    if (you.quiver[get_quiver_type()] == obj)
        you.quiver_change = true;

    you.m_quiver->on_inv_quantity_change(obj, amount);

int get_current_fire_item();

quiver_type get_quiver_type(void);

#include "quiver.h"

static std::string _fire_get_noitem_reason();

// Helper for _get_fire_order
static bool _fire_item_matches(const item_def &item, unsigned fire_type)
{
    if (!is_valid_item(item))
        return (false);
    if (you.attribute[ATTR_HELD])
    {
        if (item.base_type == OBJ_MISSILES)
        {
            const item_def *weapon = you.weapon();
            if (weapon && weapon->sub_type == WPN_BLOWGUN
                && item.launched_by(*weapon))
            {
                return (true);
            }
        }
        return (false);
    }
    if (fire_type & FIRE_INSCRIBED)
        if (item.inscription.find("+f", 0) != std::string::npos)
            return true;
    if (item.base_type == OBJ_MISSILES)
    {
        if ((fire_type & FIRE_DART) && item.sub_type == MI_DART)
            return (true);
        if ((fire_type & FIRE_STONE) && item.sub_type == MI_STONE)
            return (true);
        if ((fire_type & FIRE_JAVELIN) && item.sub_type == MI_JAVELIN)
            return (true);
        if ((fire_type & FIRE_ROCK) && item.sub_type == MI_LARGE_ROCK)
            return (true);
        if ((fire_type & FIRE_NET) && item.sub_type == MI_THROWING_NET)
            return (true);
        if (fire_type & FIRE_LAUNCHER)
        {
            const item_def *weapon = you.weapon();
            if (weapon && item.launched_by(*weapon))
                return (true);
        }
    }
    else if (item.base_type == OBJ_WEAPONS
             && is_throwable(item, you.body_size()))
    {
        if ((fire_type & FIRE_RETURNING) && item.special == SPWPN_RETURNING
             && item_ident(item, ISFLAG_KNOW_TYPE))
        {
            return (true);
        }
        if ((fire_type & FIRE_DAGGER) && item.sub_type == WPN_DAGGER)
            return (true);
        if ((fire_type & FIRE_SPEAR) && item.sub_type == WPN_SPEAR)
            return (true);
        if ((fire_type & FIRE_HAND_AXE) && item.sub_type == WPN_HAND_AXE)
            return (true);
        if ((fire_type & FIRE_CLUB) && item.sub_type == WPN_CLUB)
            return (true);
    }
    return (false);
}

quiver_type get_quiver_type()
{
    const int wielded = you.equip[EQ_WEAPON];
    if (wielded == -1)
        return (QUIVER_THROW);
    item_def &weapon = you.inv[wielded];
    if (weapon.base_type != OBJ_WEAPONS)
        return (QUIVER_THROW);
    switch (weapon.sub_type)
    {
        case WPN_BLOWGUN:
            return (QUIVER_BLOWGUN);
        case WPN_SLING:
            return (QUIVER_SLING);
        case WPN_BOW:
        case WPN_LONGBOW:
            return (QUIVER_BOW);
        case WPN_CROSSBOW:
            return (QUIVER_CROSSBOW);
        case WPN_HAND_CROSSBOW:
            return (QUIVER_HAND_CROSSBOW);
        default:
            return (QUIVER_THROW);
    }
}
// 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)
{
    for (int i_inv=Options.fire_items_start; i_inv<ENDOFPACK; i_inv++)
    {
        const item_def& item = you.inv[i_inv];
        if (!is_valid_item(item))
            continue;
        if (you.equip[EQ_WEAPON] == i_inv)
            continue;
        // =f prevents item from being in fire order
        if (!Hack_Ignore_F_Inscription &&
            strstr(item.inscription.c_str(), "=f"))
            continue;
        for (unsigned int i_flags=0;
             i_flags<Options.fire_order.size();
             i_flags++)
        {
            if (_fire_item_matches(item, Options.fire_order[i_flags]))
            {
                fire_order.push_back( (i_flags<<16) | (i_inv & 0xffff) );
                break;
            }
        }
    }
    std::sort(fire_order.begin(), fire_order.end());
    for (unsigned int i=0; i<fire_order.size(); i++)
    {
        fire_order[i] &= 0xffff;
    }
}

    _get_fire_order(fire_order);

    you.m_quiver->get_fire_order(fire_order);

        return ENDOFPACK;
    if (current == ENDOFPACK)

        return -1;
    if (current == -1)

int get_current_fire_item()
{
    std::vector<int> fire_order;
    _get_fire_order(fire_order);
    if (fire_order.size() == 0)
        return ENDOFPACK;
    if (! Options.fire_quiver_best)
    {
        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(ENDOFPACK), selected_from_inventory(false), need_prompt(false)

        : m_slot(-1), selected_from_inventory(false), need_prompt(false)

        item = get_current_fire_item();

        m_slot = you.m_quiver->get_fire_item(&m_noitem_reason);

    int item;

    int m_slot;
    std::string m_noitem_reason;

    const int next_item = get_next_fire_item(item, +1);
    bool no_other_items = (next_item == ENDOFPACK || next_item == item);

    const int next_item = get_next_fire_item(m_slot, +1);
    bool no_other_items = (next_item == -1 || next_item == m_slot);

    if (item == ENDOFPACK)

    if (m_slot == -1)

        const item_def& item_def = you.inv[item];

        const item_def& item_def = you.inv[m_slot];

    if (item == ENDOFPACK)
        msg << "<red>" << _fire_get_noitem_reason() << "</red>";

    if (m_slot == -1)
    {
        msg << "<red>" << m_noitem_reason << "</red>";
    }

            << you.inv[item].name(DESC_INVENTORY_EQUIP)

            << you.inv[m_slot].name(DESC_INVENTORY_EQUIP)

          const int next = get_next_fire_item(item, direction);
          if (next != item && next != ENDOFPACK)

          const int next = get_next_fire_item(m_slot, direction);
          if (next != m_slot && next != -1)

              item = next;

              m_slot = next;

          if (selected != ENDOFPACK &&

          if (selected >= 0 &&

              item = selected;

              m_slot = selected;

static bool _fire_choose_item_and_target(int& item, dist& target)

static bool _fire_choose_item_and_target(int& slot, dist& target)

    const bool was_chosen = (item != -1);

    const bool was_chosen = (slot != -1);

        if (you.equip[EQ_WEAPON] == item
            && item_cursed(you.inv[item]))

        if (you.equip[EQ_WEAPON] == slot
            && item_cursed(you.inv[slot]))

        beh.item = item; // force item to be the prechosen one

        beh.m_slot = slot; // force item to be the prechosen one

    if (beh.item == ENDOFPACK)

    if (beh.m_slot == -1)

    if (was_chosen || beh.item != item)

    if (was_chosen || ! beh.selected_from_inventory)

        item = beh.item;
        if (! beh.selected_from_inventory)
        {
            you.quiver[get_quiver_type()] = beh.item;
            you.quiver_change = true;
        }

        you.m_quiver->on_item_fired(you.inv[beh.m_slot]);
    }
    else
    {
        you.m_quiver->on_item_fired_fi(you.inv[beh.m_slot]);

    you.quiver_change = true;
    slot = beh.m_slot;

// Returns an item slot, or ENDOFPACK on abort/failure

// Returns an item slot, or -1 on abort/failure

        return ENDOFPACK;

        return -1;

        return ENDOFPACK;

        return -1;

}
static std::string _fire_get_noitem_reason()
{
    const int cur_item = get_current_fire_item();
    if (cur_item != ENDOFPACK)
    {
        // Shouldn't be calling this if there is a good default item!
        return std::string("Buggy.");
    }
    // Tell the user why we might have skipped their missile
    unwind_var<int> unwind_festart(Options.fire_items_start, 0);
    unwind_var<bool> unwind_inscription(Hack_Ignore_F_Inscription, true);
    const int skipped_item = get_current_fire_item();
    char buf[200];
    if (skipped_item == ENDOFPACK)
    {
        return std::string("No suitable missiles.");
    }
    else if (skipped_item < unwind_festart.original_value())
    {
        // no room for showing index_to_letter(skipped_item);
        snprintf(buf, 200,
                 "Nothing suitable (fire_items_start = '%c').",
                 index_to_letter(unwind_festart.original_value()));
        return std::string(buf);
    }
    else
    {
        snprintf(buf, 200,
                 "Nothing suitable (ignored '=f'-inscribed item on '%c').",
                 index_to_letter(skipped_item));
        return std::string(buf);
    }

class player_quiver;

  player_quiver* m_quiver;

#include "quiver.h"

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

    const int thrown = missile_slot == -1 ? you.m_quiver->get_fire_item() : missile_slot;

                    missile_slot == -1? get_current_fire_item() :

                    missile_slot == -1? you.m_quiver->get_fire_item() :

                if (missile < ENDOFPACK)

                if (missile < ENDOFPACK && missile >= 0)

#include "quiver.h"

    const int item = get_current_fire_item();

    const item_def* item;
    int slot;
    you.m_quiver->get_desired_item(&item, &slot);

    if (item == ENDOFPACK)

    if (slot == -1 && !is_valid_item(*item))
    {

    }
    else if (slot == -1)
    {
        wstring += "-) ";
        wstring += you.inv[slot].name(DESC_PLAIN);
        wstring += " (empty)";
    }

        wstring += you.inv[item].name(DESC_INVENTORY_EQUIP);

        wstring += you.inv[slot].name(DESC_INVENTORY_EQUIP);

                             menu_colour_item_prefix(you.inv[item]),

                             menu_colour_item_prefix(you.inv[slot]),

#include "quiver.h"

        if (Options.fire_quiver_best)
        {
            mpr("Use fire_quiver_best=false if you want manual quiver control.");
            break;
        }
        const int cur = you.quiver[get_quiver_type()];
        if (cur != ENDOFPACK)

        int cur;
        you.m_quiver->get_desired_item(NULL, &cur);
        const int next = get_next_fire_item(cur, +1);
        if (next != -1)

            const int next = get_next_fire_item(cur, +1);
            you.quiver[get_quiver_type()] = next;

            // kind of a hacky way to get quiver to change
            you.m_quiver->on_item_fired(you.inv[next]);