&& (you.hunger_state < HS_HUNGRY

        && (you.hunger_state <= HS_STARVING

    if (food && (you.hunger_state < HS_HUNGRY || you.hunger <= food))

    if (food && (you.hunger_state <= HS_STARVING || you.hunger <= food))

            const int prefcol = menu_colour(wpn.name(DESC_INVENTORY));

            const std::string prefix = menu_colour_item_prefix(wpn);
            const int prefcol = menu_colour(wpn.name(DESC_INVENTORY), prefix);

        switch (you.hunger_state)

        if (Options.detailed_hunger)

        case HS_ENGORGED:
            textcolor( LIGHTGREEN );
            cprintf( "Engorged" );
            break;

            switch (you.hunger_state)
            {
            case HS_ENGORGED:
                textcolor( LIGHTGREEN );
                cprintf( "Engorged" );
                break;
            case HS_VERY_FULL:
                textcolor( GREEN );
                cprintf( "Very Full" );
                break;

        case HS_FULL:
            textcolor( GREEN );
            cprintf( "Full" );
            break;

            case HS_FULL:
                textcolor( GREEN );
                cprintf( "Full" );
                break;

        case HS_SATIATED:
            break;

            case HS_SATIATED:
                break;

        case HS_HUNGRY:
            textcolor( YELLOW );
            cprintf( "Hungry" );
            break;

            case HS_HUNGRY:
                textcolor( YELLOW );
                cprintf( "Hungry" );
                break;

        case HS_STARVING:
            textcolor( RED );
            cprintf( "Starving" );
            break;

            case HS_VERY_HUNGRY:
                textcolor( YELLOW );
                cprintf( "Very Hungry" );
                break;
            case HS_NEAR_STARVING:
                textcolor( YELLOW );
                cprintf( "Near Starving" );
                break;
            case HS_STARVING:
                textcolor( RED );
                cprintf( "Starving" );
                break;
            }

        else
        {
            switch (you.hunger_state)
            {
            case HS_ENGORGED:
                textcolor( LIGHTGREEN );
                cprintf( "Engorged" );
                break;

            case HS_VERY_FULL:
            case HS_FULL:
                textcolor( GREEN );
                cprintf( "Full" );
                break;
            case HS_SATIATED:
                break;
            case HS_HUNGRY:
            case HS_VERY_HUNGRY:
            case HS_NEAR_STARVING:
                textcolor( YELLOW );
                cprintf( "Hungry" );
                break;
            case HS_STARVING:
                textcolor( RED );
                cprintf( "Starving" );
                break;
            }
        }

            result << name;

            result << Options.user_note_prefix << name;

int menu_colour(const std::string &itemtext,
                const std::string &prefix = "");

    virtual int highlight_colour() const
    {
        return (menu_colour(get_text()));
    }

int menu_colour(const std::string &itemtext);

int menu_colour(const std::string &text)

int menu_colour(const std::string &text, const std::string &prefix)

    std::string tmp_text = prefix + text;

        if (cm.pattern.matches(text))

        if (cm.pattern.matches(tmp_text))

    return (::menu_colour(entry->get_text()));

    return entry->highlight_colour();

/* ***********************************************************************
 * called from: command - itemname - invent.h
 * *********************************************************************** */
const std::string menu_colour_item_prefix(const item_def &item);

const std::string menu_colour_item_prefix(const item_def &item)
{
    std::string str = "";
    if (Options.menu_colour_prefix_id)
    {
        if (item_ident(item, ISFLAG_KNOW_TYPE)
            || item.base_type == OBJ_FOOD
            || item.base_type == OBJ_CORPSES)
        {
            str += "identified ";
        }
        else
        {
            if (get_ident_type(item.base_type,
                               item.sub_type) == ID_KNOWN_TYPE)
            {
                // Wands are only fully identified if we know the
                // number of charges.
                if (item.base_type == OBJ_WANDS)
                    str += "known ";
                // Rings are fully identified simply by knowing their
                // type, unless the ring has plusses, like a ring of
                // dexterity.
                else if (item.base_type == OBJ_JEWELLERY
                         && !jewellery_is_amulet(item))
                {
                    if (item.plus == 0 && item.plus2 == 0)
                        str += "identified ";
                    else
                        str += "known ";
                }
                // All other types of magical items are fully identified
                // simply by knowing the type
                else
                    str += "identified ";
            }
            else
                str += "unidentified ";
        }
    }
    if (Options.menu_colour_prefix_class)
    {
        str += item_class_name(item.base_type, true) + " ";
    }
    return str;
}

#include "itemname.h"

    virtual int highlight_colour() const
    {
        return menu_colour(get_text(),
                           menu_colour_item_prefix( *( (item_def*) item) ) );
    }

    user_note_prefix       = "";

    detailed_hunger        = false;

    menu_colour_prefix_class = false;
    menu_colour_prefix_id    = false;

    }
    else if (key == "user_note_prefix")
    {
        // field is already cleaned up from trim_string()
        user_note_prefix = field;

    else if (key == "detailed_hunger")
    {
        detailed_hunger = read_bool(field, detailed_hunger);
    }

    }
    else if (key == "menu_colour_prefix_class" ||
             key == "menu_color_prefix_class")
    {
        menu_colour_prefix_class = read_bool(field, menu_colour_prefix_class);

    else if (key == "menu_colour_prefix_id" ||
             key == "menu_color_prefix_id")
    {
        menu_colour_prefix_id = read_bool(field, menu_colour_prefix_id);
    }

    else if (you.hunger <= 1533)
        newstate = HS_NEAR_STARVING;
    else if (you.hunger <= 2066)
        newstate = HS_VERY_HUNGRY;

    else if (you.hunger < 9000)
        newstate = HS_FULL;

        newstate = HS_FULL;

        newstate = HS_VERY_FULL;

        char oldstate = you.hunger_state;

        if (newstate < HS_SATIATED)
            interrupt_activity( AI_HUNGRY );

        if (Options.detailed_hunger)
        {
            if (newstate < HS_SATIATED)
                interrupt_activity( AI_HUNGRY );
        }
        else
        {
            // Don't interrupt on changing from hungry to very hungry
            // or very hungry to near starving if they don't want
            // detailed hunger info.
            if (newstate == HS_STARVING ||
                (newstate < HS_SATIATED && oldstate >= HS_SATIATED))
                interrupt_activity( AI_HUNGRY );

            // Don't inform user of changing from hungry to very hungry
            // or very hungry to near starving if they don't want
            // detailed hunger info.
            if (newstate < HS_SATIATED && oldstate < HS_SATIATED &&
                newstate != HS_STARVING)
                suppress_message = true;
        }

            switch (you.hunger_state)

            if (Options.detailed_hunger)
            {
                switch (you.hunger_state)
                {
                case HS_STARVING:
                    mpr("You are starving!", MSGCH_FOOD);
                    learned_something_new(TUT_YOU_STARVING);
                    break;
                case HS_HUNGRY:
                    mpr("You are feeling hungry.", MSGCH_FOOD);
                    learned_something_new(TUT_YOU_HUNGRY);
                    break;
                case HS_VERY_HUNGRY:
                    mpr("You are feeling very hungry.", MSGCH_FOOD);
                    learned_something_new(TUT_YOU_HUNGRY);
                    break;
                case HS_NEAR_STARVING:
                    mpr("You are near starving.", MSGCH_FOOD);
                    learned_something_new(TUT_YOU_HUNGRY);
                    break;
                default:
                    break;
                }
            }
            else

            case HS_STARVING:
                mpr("You are starving!", MSGCH_FOOD);
                learned_something_new(TUT_YOU_STARVING);
                break;
            case HS_HUNGRY:
                mpr("You are feeling hungry.", MSGCH_FOOD);
                learned_something_new(TUT_YOU_HUNGRY);
                break;
            default:
                break;

                switch (you.hunger_state)
                {
                case HS_STARVING:
                    mpr("You are starving!", MSGCH_FOOD);
                    learned_something_new(TUT_YOU_STARVING);
                    break;
                case HS_HUNGRY:
                case HS_VERY_HUNGRY:
                case HS_NEAR_STARVING:
                    mpr("You are feeling hungry.", MSGCH_FOOD);
                    learned_something_new(TUT_YOU_HUNGRY);
                    break;
                default:
                    break;
                }

    std::string user_note_prefix; // Prefix for user notes

    bool        detailed_hunger; // Informational-only hunger levels

    bool       menu_colour_prefix_class; // Prefix item class to string
    bool       menu_colour_prefix_id;    // Prefix id-status to string

    HS_NEAR_STARVING,
    HS_VERY_HUNGRY,

    HS_ENGORGED                        //    5

    HS_VERY_FULL,
    HS_ENGORGED                        //    8

        int       colour    = MSGCOL_BLACK;

        {

            colour = menu_colour(estr.str(),
                                 menu_colour_item_prefix(you.inv[armour_id]));
        }

        mpr( estr.str().c_str(), MSGCH_EQUIPMENT, menu_colour(estr.str()) );

        if (colour == MSGCOL_BLACK)
            colour = menu_colour(estr.str());
        mpr( estr.str().c_str(), MSGCH_EQUIPMENT, colour);

        int       colour       = MSGCOL_BLACK;

        {

            std::string
                prefix = menu_colour_item_prefix(you.inv[jewellery_id]);
            colour = menu_colour(jstr.str(), prefix);
        }

        mpr( jstr.str().c_str(), MSGCH_EQUIPMENT, menu_colour(jstr.str()) );

        if (colour == MSGCOL_BLACK)
            colour = menu_colour(jstr.str());
        mpr( jstr.str().c_str(), MSGCH_EQUIPMENT, colour);

}                               // end list_jewellery()

}

    int         colour;

        colour = menu_colour(wstring,
                             menu_colour_item_prefix(you.inv[weapon_id]));

        colour = menu_colour(wstring);

    mpr(wstring.c_str(), MSGCH_EQUIPMENT, menu_colour(wstring));

    mpr(wstring.c_str(), MSGCH_EQUIPMENT, colour);

        colour = MSGCOL_BLACK;

            colour = menu_colour(wstring,
                                 menu_colour_item_prefix(you.inv[i]));

        if (colour == MSGCOL_BLACK)
            colour = menu_colour(wstring);

        mpr(wstring.c_str(), MSGCH_EQUIPMENT, menu_colour(wstring));

        mpr(wstring.c_str(), MSGCH_EQUIPMENT, colour);

    colour = MSGCOL_BLACK;

    {

        colour = menu_colour(wstring,
                             menu_colour_item_prefix(you.inv[item]));
    }

    mpr( wstring.c_str(), MSGCH_EQUIPMENT, menu_colour(wstring) );

    if (colour == MSGCOL_BLACK)
        colour = menu_colour(wstring);
    mpr( wstring.c_str(), MSGCH_EQUIPMENT, colour );

    if (hungerCheck && you.hunger_state < HS_HUNGRY)

    if (hungerCheck && you.hunger_state <= HS_STARVING)

# menu_colour_prefix_id    = true
# menu_colour_prefix_class = true

# Identified artefacts
menu_colour = white:( [-+] the)
# These lines will colour ego items; they require that
# menu_colour_prefix_id and menu_colour_prefix_class be set to true
# menu_colour = green:(^identified armour .* pair of .* of )
# menu_colour = lightgrey:(^identified armour .* pair of )
# menu_colour = green:(^identified (weapon|armour) .* of )

# dump_order += kills_by_place,,kills

# dump_order += kills_by_place,kills

# user_note_prefix=@@@

#
# detailed_hunger = true

                terse_hand, delay_message_clear, menu_colour, message_colour,
                increasing_skill_progress, show_inventory_weights,
                show_turns, show_beam, item_stack_summary_minimum

                terse_hand, delay_message_clear, menu_colour,
                menu_colour_prefix_id, menu_colour_prefix_class
                message_colour, increasing_skill_progress,
                show_inventory_weights, show_turns, show_beam,
                item_stack_summary_minimum

        To colour identified artefacts, try
          menu_colour = white:( [-+] the)

menu_colour_prefix_id = false
        Setting this option to true will prefix the string against
        which menu_colour regexes are matched (not the string
        displayed) with the item's identification state: "unidentified"
        for unidentified, "known" for wands for which you know the type
        but don't know the number of charges, and for rings with plusses
        for which you know the type but don't know the plus value, and
        "identified" for other identified items.
        Note that the prefix is put before the the *entire* string which
        is displayed, so if you're wielding a uncursed dagger which has
        the 'a' slot, the string the regexes will match against is
        "identified  a - an uncursed dagger (weapon)".
menu_colour_prefix_class = false
        Setting this option to true will prefix the string against which
        menu_colour regexes are matched (not the string displayed) with
        the item's object type: armour, weapon, wand, etc.  If both
        this option and menu_colour_prefix_id are set to true, then
        the identification string comes before the object type string
        (i.e., "identified weapon", "known wand", etc).
        Note that the prefix is put before the the *entire* string which
        is displayed, so if you're wielding a uncursed dagger which has
        the 'a' slot, the string the regexes will match against is
        "weapon  a - an uncursed dagger (weapon)".

user_note_prefix = <string>
        Prefixes manually added notes with the given string, to make
        them easier to find.

detailed_hunger = false
        If set to true, then Crawl will tell you about three additional
        hunger states: near starving, very hungry, and very full.
        These hunger states are informational only, and have no effect
        upon game play.