if ( oldflags != si.item.flags )

    if (oldflags != si.item.flags)

        add_hotkey(hotkey);

        hotkeys[0] = hotkey;

    menu.can_travel = can_travel;
    mtitle->quantity = items.size();

    menu.can_travel   = can_travel;
    mtitle->quantity  = items.size();

            MenuEntry *me = new ShopItemEntry(items[i],
                                              shop_item_name(items[i]),
                                              hotkey++);

            ShopItemEntry *me = new ShopItemEntry(items[i],
                                                  shop_item_name(items[i]),
                                                  hotkey++);

    else if (slot == you.equip[EQ_WEAPON])

    else if (slot == you.equip[EQ_WEAPON]
             && you.inv[slot].base_type == OBJ_WEAPONS
             && (get_weapon_brand(you.inv[slot]) != SPWPN_RETURNING
                 || you.skills[SK_THROWING] == 0))

        mpr("You can't quiver wielded items.");

        // Don't quiver a wielded weapon unless it's a weapon of returning
        // and we've got some throwing skill.
        mpr("You can't quiver wielded weapons.");

        for (int i = 0; i < NUM_EQUIP; i++)

        for (int i = EQ_CLOAK; i < NUM_EQUIP; i++)

        if (m_last_used_of_type[slot].link == you.equip[EQ_WEAPON])

        if (m_last_used_of_type[slot].link == you.equip[EQ_WEAPON]
            && you.equip[EQ_WEAPON] == -1)
        {

        }

//    const launch_retval desired_ret =
//        (slot == AMMO_THROW ? LRET_THROWN : LRET_LAUNCHED);

        // Don't quiver wielded weapon.
        if (you.equip[EQ_WEAPON] == i_inv)

        // Don't quiver a wielded weapon unless it's a weapon of returning
        // and we've got some throwing skill.
        if (you.equip[EQ_WEAPON] == i_inv
            && you.inv[i_inv].base_type == OBJ_WEAPONS
            && (get_weapon_brand(you.inv[i_inv]) != SPWPN_RETURNING
                || you.skills[SK_THROWING] == 0))
        {

        }

    if (!monster_senior(mpusher, mpushee))

    // Fleeing monsters of the same type may push past higher ranking ones.
    if (!monster_senior(mpusher, mpushee, mons_is_fleeing(mpusher)))

bool monster_senior(const monsters *first, const monsters *second);

bool monster_senior(const monsters *first, const monsters *second,
                    bool fleeing = false);

bool monster_senior(const monsters *m1, const monsters *m2)

bool monster_senior(const monsters *m1, const monsters *m2, bool fleeing)

        return (mchar1 < mchar2);

        return (fleeing || mchar1 < mchar2);

        return (m1->hit_dice > m2->hit_dice);

        return (fleeing || m1->hit_dice > m2->hit_dice);

    if (m1->type == MONS_QUEEN_BEE
        && (m2->type == MONS_KILLER_BEE
            || m2->type == MONS_KILLER_BEE_LARVA))

    if (mons_genus(m1->type) == MONS_KILLER_BEE
        && mons_genus(m2->type) == MONS_KILLER_BEE)

        return (true);
    }

        if (fleeing)
            return (true);

    if (m1->type == MONS_KILLER_BEE && m2->type == MONS_KILLER_BEE_LARVA)
        return (true);

        if (m1->type == MONS_QUEEN_BEE && m2->type != MONS_QUEEN_BEE)
            return (true);
        if (m1->type == MONS_KILLER_BEE && m2->type == MONS_KILLER_BEE_LARVA)
            return (true);
    }

    return (mchar1 == mchar2 && m1->hit_dice > m2->hit_dice);

    return (mchar1 == mchar2 && (fleeing || m1->hit_dice > m2->hit_dice));

#ifdef USE_TILE
    virtual bool get_tiles(std::vector<tile_def>& tileset) const;
#endif
};
class FeatureMenuEntry : public MenuEntry
{
public:
    coord_def pos;

    FeatureMenuEntry(const std::string &str, const coord_def p, int hotkey);

#include "tiles.h"

#ifdef USE_TILE
 #include "stuff.h"
 #include "tiles.h"
 #include "travel.h"
#endif

    quantity = 1;
}
FeatureMenuEntry::FeatureMenuEntry(const std::string &str, const coord_def p, int hotkey) :
    MenuEntry(str, MEL_ITEM, 1, hotkey)
{
    pos      = p;

    return false;

    return (false);

bool FeatureMenuEntry::get_tiles(std::vector<tile_def>& tileset) const
{
    if (!in_bounds(pos))
        return (false);
    tileset.push_back(tile_def(tileidx_feature(grd(pos), pos.x, pos.y),
                               TEX_DUNGEON));
    if (is_travelable_stair(grd(pos)) && !travel_cache.know_stair(pos))
        tileset.push_back(tile_def(TILE_NEW_STAIR, TEX_DEFAULT));
    return (true);
}

    while ( true )

    while (true)

        add_item_formatted_string(formatted_string::parse_string(std::string(s, eolpos, newpos-eolpos)));
        if ( newpos == std::string::npos )

        add_item_formatted_string(formatted_string::parse_string(
                                        std::string(s, eolpos, newpos-eolpos)));
        if (newpos == std::string::npos)

        // If we get the message, we know the item is cursed now.
        item.flags |= ISFLAG_KNOW_CURSE;

    // if you happen to be wielding the wand, its display might change.

    // If you happen to be wielding the wand, its display might change.

    std::vector<coord_def> list_features;

        if (grid_stair_direction(grd(*ri)) != CMD_NO_CMD)
            list_features.push_back(*ri);

    if (list_mons.empty() && list_items.empty())

    if (list_mons.empty() && list_items.empty() && list_features.empty())

        mprf("Neither monsters nor items are visible.");

        mprf("No monsters, items or features are visible.");

    desc_menu.set_title(
        new MenuEntry("Visible Monsters/Items (select for more detail, '!' to view/travel):",
                      MEL_TITLE));

    std::string title = "";
    if (!list_mons.empty())
        title += "Monsters";
    if (!list_items.empty())
    {
        if (!title.empty())
            title += "/";
        title += "Items";
    }
    if (!list_features.empty())
    {
        if (!title.empty())
            title += "/";
        title += "Features";
    }
    title = "Visible " + title + " (select for more detail, '!' to view/travel):";
    desc_menu.set_title( new MenuEntry(title, MEL_TITLE));

//         desc_menu.mdisplay->set_num_columns(1);

    if (list_items.size())

    if (!list_items.empty())

    if (!list_features.empty())
    {
        desc_menu.add_entry( new MenuEntry("Features", MEL_SUBTITLE) );
        for (unsigned int i = 0; i < list_features.size(); ++i, ++hotkey)
        {
            const coord_def c = list_features[i];
            std::string desc = "";
#ifndef USE_TILE
//            get_screen_glyph(c)
            const coord_def e  = c - you.pos() + coord_def(9,9);
            unsigned short col = env.show_col(e);;
            int object         = env.show(e);
            unsigned ch;
            get_item_symbol( object, &ch, &col );
            const std::string colour_str = colour_to_str(col);
            desc = "(<" + colour_str + ">";
            desc += stringize_glyph(ch);
            if (ch == '<')
                desc += '<';
            desc += "</" + colour_str +">) ";
#endif
            desc += feature_description(c);
            if (is_travelable_stair(grd(c)) && !travel_cache.know_stair(c))
                desc += " (not visited)";
            FeatureMenuEntry *me = new FeatureMenuEntry(desc, c, hotkey);
            me->tag        = "description";
            // Hack to make features selectable.
            me->quantity   = c.x*100 + c.y + 3;
            desc_menu.add_entry(me);
        }
    }

    std::vector<MenuEntry*> sel;

        std::vector<MenuEntry*> sel = desc_menu.show();

        sel = desc_menu.show();

                start_travel( c );
                break;
            }
        }
        else
        {
            const int num = quant - 3;
            const int y = num % 100;
            const int x = (num - y)/100;
            coord_def c(x,y);
            if (desc_menu.menu_action == InvMenu::ACT_EXAMINE)
                describe_feature_wide(c);
            else // ACT_EXECUTE -> travel to feature
            {

positive outcome when evoking items.

positive outcome when evoking items. Also, high skill may let you determine
the amount of charges a zapped wand has left.

        if (mon->add_ench(ENCH_CHARM))

        if (!mon->has_ench(ENCH_CHARM))

            // FIXME: Put in an exception for fungi, plants and other
            // things you won't notice becoming charmed.

            mon->add_ench(ENCH_CHARM);