bool mons_has_ranged_spell( const monsters *mon, bool attack_only = false );

bool mons_has_ranged_spell( const monsters *mon, bool attack_only = false,
                            bool ench_too = true );

    switch (monspell)
    {
    case SPELL_SUMMON_DEMON:
    case SPELL_SUMMON_GREATER_DEMON:
    case SPELL_SUMMON_UNDEAD:
    case SPELL_SUMMON_UFETUBUS:
    case SPELL_SUMMON_HORRIBLE_THINGS:
    case SPELL_SUMMON_DRAKES:
    case SPELL_SUMMON_MUSHROOMS:
    case SPELL_SUMMON_ICE_BEAST:

    if (monspell == SPELL_SMITING || spell_typematch(monspell, SPTYP_SUMMONING))

    default:
        return (false);
    }

    return (false);

static bool _ms_ranged_spell( spell_type monspell, bool attack_only )

static bool _ms_ranged_spell( spell_type monspell, bool attack_only = false,
                              bool ench_too = true)

    // These spells are ranged, but aren't direct attack spells.
    if (!attack_only && _ms_los_spell(monspell))

    // Check for Smiting specially, so it's not filtered along
    // with the summon spells.
    if (attack_only && monspell == SPELL_SMITING)

    // These spells are ranged, but aren't direct attack spells.
    if (_ms_los_spell(monspell))
        return (!attack_only);

    case SPELL_CANTRIP:

    case SPELL_BERSERKER_RAGE:

    case SPELL_CONFUSE:
    case SPELL_SLOW:
    case SPELL_PARALYSE:
    case SPELL_TELEPORT_OTHER:
        return (ench_too);

        // All conjurations count as ranged spells.

bool mons_has_ranged_spell( const monsters *mon, bool attack_only )

bool mons_has_ranged_spell( const monsters *mon, bool attack_only,
                            bool ench_too )

            if (_ms_ranged_spell( mon->spells[i], attack_only ))

            if (_ms_ranged_spell( mon->spells[i], attack_only, ench_too ))

        || ::mons_species(this->type) == MONS_CYCLOPS
        || ::mons_species(this->type) == MONS_OGRE);

            || ::mons_species(this->type) == MONS_CYCLOPS
            || ::mons_species(this->type) == MONS_OGRE);

    // Prevent monsters that have conjurations / summonings from
    // grabbing missiles.
    if (has_spell_of_type(SPTYP_CONJURATION | SPTYP_SUMMONING))

    // Prevent monsters that have conjurations from grabbing missiles.
    if (has_spell_of_type(SPTYP_CONJURATION))
        return (false);
    // Same for summonings, but make an exception for friendlies.
    if (!mons_friendly(this) && has_spell_of_type(SPTYP_SUMMONING))

}
// We don't want monsters to pick up ammunition that cancels out with
// the launcher brand or that is identical to the launcher brand,
// the latter in hope of another monster wandering by who may want to
// use the ammo in question.
static bool _compatible_launcher_ammo_brands(item_def *launcher,
                                             const item_def *ammo)
{
    const int bow_brand  = get_weapon_brand(*launcher);
    const int ammo_brand = get_ammo_brand(*ammo);
    switch (ammo_brand)
    {
    case SPMSL_FLAME:
    case SPMSL_FROST:
        return (bow_brand != SPWPN_FLAME && bow_brand != SPWPN_FROST);
    case SPMSL_CHAOS:
        return (bow_brand != SPWPN_CHAOS);
    default:
        return (true);
    }

    // Don't allow monsters to switch to another type of launcher
    // as that would require them to also drop their ammunition
    // and then try to find ammunition for their new launcher.
    // However, they may switch to another launcher if they're
    // out of ammo. (jpeg)

            return (fires_ammo_type(*elaunch) == mt
                    && mons_weapon_damage_rating(*elaunch) < mdam_rating

            return ((fires_ammo_type(*elaunch) == mt || !missiles())
                    && (mons_weapon_damage_rating(*elaunch) < mdam_rating
                        || mons_weapon_damage_rating(*elaunch) == mdam_rating
                           && get_weapon_brand(*elaunch) == SPWPN_NORMAL
                           && get_weapon_brand(launch) != SPWPN_NORMAL
                           && _compatible_launcher_ammo_brands(&launch,
                                                               missiles()))

    return (eslot == -1? false : pickup(launch, eslot, near));

    return (eslot == -1 ? false : pickup(launch, eslot, near));

}
static int _ego_damage_bonus(item_def &item)
{
    switch (get_weapon_brand(item))
    {
    case SPWPN_NORMAL:      return 0;
    case SPWPN_PROTECTION:  return 1;
    default:                return 2;
    case SPWPN_VORPAL:      return 3;
    }
}
static bool _item_race_matches_monster(const item_def &item, monsters *mons)
{
    return (get_equip_race(item) == ISFLAG_ELVEN
                && mons_genus(mons->type) == MONS_ELF
            || get_equip_race(item) == ISFLAG_ORCISH
                && mons_genus(mons->type) == MONS_ORC);

    const int mdam_rating = mons_weapon_damage_rating(item);

    const int new_wpn_dam = mons_weapon_damage_rating(item)
                            + _ego_damage_bonus(item);

            if (mons_weapon_damage_rating(*weap) < mdam_rating
                && !weap->cursed())

            const int old_wpn_dam = mons_weapon_damage_rating(*weap)
                                    + _ego_damage_bonus(*weap);
            bool new_wpn_better = (new_wpn_dam > old_wpn_dam);
            if (new_wpn_dam == old_wpn_dam)
            {
                // Use shopping value as a crude estimate of resistances etc.
                // XXX: This is not really logical as many properties don't
                //      apply to monsters (e.g. levitation, blink, berserk).
                // For simplicity, don't apply this check to secondary weapons
                // for dual wielding monsters.
                int oldval = item_value(*weap, true);
                int newval = item_value(item, true);
                // Vastly prefer matching racial type.
                if (_item_race_matches_monster(*weap, this))
                    oldval *= 2;
                if (_item_race_matches_monster(item, this))
                    newval *= 2;
                if (newval > oldval)
                    new_wpn_better = true;
            }
            if (new_wpn_better && !weap->cursed())

                    || mons_weapon_damage_rating(*weap)
                       < mons_weapon_damage_rating(*mslot_item(MSLOT_WEAPON)))

                    || old_wpn_dam
                       < mons_weapon_damage_rating(*mslot_item(MSLOT_WEAPON))
                         + _ego_damage_bonus(*mslot_item(MSLOT_WEAPON)))

static bool _item_race_matches_monster(const item_def &item, monsters *mons)
{
    return (get_equip_race(item) == ISFLAG_ELVEN
                && mons_genus(mons->type) == MONS_ELF
            || get_equip_race(item) == ISFLAG_ORCISH
                && mons_genus(mons->type) == MONS_ORC);
}

                int oldval = item_value(*existing_armour);
                int newval = item_value(item);

                int oldval = item_value(*existing_armour, true);
                int newval = item_value(item, true);

            if (mons_has_ranged_spell(this, true))

            // Neither summons nor hostile enchantments are counted for
            // this purpose.
            if (mons_has_ranged_spell(this, true, false))

                const int bow_brand = get_weapon_brand(*launch);

                           && (bow_brand != SPWPN_FLAME
                               || item_brand == SPMSL_POISONED)
                           && bow_brand != SPWPN_FROST))

                           &&_compatible_launcher_ammo_brands(launch, miss)))