{

                }

                && you.attribute[ATTR_DEMONIC_RUNES] == 0)

                     && you.attribute[ATTR_DEMONIC_RUNES] == 0)

// like yesno(), but returns 0 for no, 1 for yes, and -1 for quit
// alt_yes and alt_yes2 allow up to two synonyms for 'Y'

// Like yesno(), but returns 0 for no, 1 for yes, and -1 for quit.
// alt_yes and alt_yes2 allow up to two synonyms for 'Y'.
// FIXME: This function is shaping up to be a monster. Help!

        return false;

        return (false);

        return true;

        return (true);

            if ((grd[you.x_pos][you.y_pos] != DNGN_FLOOR
                    && grd[you.x_pos][you.y_pos] != DNGN_SHALLOW_WATER)

            if (grd[you.x_pos][you.y_pos] != DNGN_FLOOR
                    && grd[you.x_pos][you.y_pos] != DNGN_SHALLOW_WATER

                // controlling teleport contaminates the player -- bwr

                // Controlling teleport contaminates the player. -- bwr

    }                           // end "if is_controlled"

    }   // end "if is_controlled"

        while ((grd[newx][newy] != DNGN_FLOOR
                && grd[newx][newy] != DNGN_SHALLOW_WATER)

        while (grd[newx][newy] != DNGN_FLOOR
                   && grd[newx][newy] != DNGN_SHALLOW_WATER

    if (randtele && player_in_a_dangerous_place()
        && you.level_type != LEVEL_ABYSS)

    // Teleporting in a labyrinth is also funny, but only for non-minotaurs.
    if (randtele
        && (you.level_type == LEVEL_LABYRINTH && you.species != SP_MINOTAUR
            || you.level_type != LEVEL_ABYSS && player_in_a_dangerous_place()))

// funny that no races are susceptible to poisons {dlb}

// Funny that no races are susceptible to poisons. {dlb}

    // only thirsty vampires are naturally poison resistant

    // Only thirsty vampires are naturally poison resistant.

    {

                || wearing_amulet(AMU_CONTROLLED_FLIGHT)
                ? FL_FLY : FL_LEVITATE);

                || wearing_amulet(AMU_CONTROLLED_FLIGHT) ? FL_FLY
                                                         : FL_LEVITATE);
    }

       {"Poison resistance    ", "           ", "        ", " +        ",  " +       ", " +       ", " +   "},

       {"Poison resistance    ", "           ", "        ", "          ",  " +       ", " +       ", " +   "},

// circular buffer for keeping past messages

// Circular buffer for keeping past messages.

        return (LIGHTBLUE);     // really, LIGHTGREY but that's plain text

        return (LIGHTBLUE);     // Really, LIGHTGREY but that's plain text.

// returns a colour or MSGCOL_MUTED

// Returns a colour or MSGCOL_MUTED.

        // note that if the plain channel is muted, then we're protecting

        // Note that if the plain channel is muted, then we're protecting

            // a special case right now for monster damage (at least until

            // A special case right now for monster damage (at least until

            // colour here will result in only the death messages coloured

            // colour here will result in only the death messages coloured.

    do_message_print( channel, channel == MSGCH_GOD? you.religion : 0,

    do_message_print( channel, channel == MSGCH_GOD ? you.religion : 0,

        return;
    }
    std::string help = inf;
    if (help.find("</") != std::string::npos)
    {
        std::string col = colour_to_str(channel_to_colour(channel));
        if (!col.empty())
            help = "<" + col + ">" + help + "</" + col + ">";
        // Handing over to the experts...
        formatted_mpr(formatted_string::parse_string(help), channel);

    // if a message is exactly STEPSIZE characters long,

    // If a message is exactly STEPSIZE characters long,

        // did the message break?

        // Did the message break?

            // yes, find a nicer place to break it.

            // Aes, find a nicer place to break it.

                // found a good spot to break

                // Found a good spot to break.

                i += where + 1; // skip past the space!

                i += where + 1; // Skip past the space!

// checks whether a given message contains patterns relevant for
// notes, stop_running or sounds and handles these cases

// Checks whether a given message contains patterns relevant for
// notes, stop_running or sounds and handles these cases.

// adds a given message to the message history

// Adds a given message to the message history.

    // reset colour

    // Reset colour.

    // equipment lists just waste space in the message recall

    // Equipment lists just waste space in the message recall.

        Store_Message[ Next_Message ].text = message;

        Store_Message[ Next_Message ].text    = message;

        Store_Message[ Next_Message ].param = param;

        Store_Message[ Next_Message ].param   = param;

    if ( colour == MSGCOL_MUTED )

    if (colour == MSGCOL_MUTED)

    if (silenced(you.x_pos, you.y_pos) &&
        (channel == MSGCH_SOUND || channel == MSGCH_TALK))

    if (silenced(you.x_pos, you.y_pos)
        && (channel == MSGCH_SOUND || channel == MSGCH_TALK))

    for (unsigned i = 0; i < Options.force_more_message.size(); ++i)
    {
        if (Options.force_more_message[i].is_filtered( channel, imsg ))
        {
            more();
            New_Message_Count = 0;
            // One more() is quite enough, thank you!
            break;
        }
    }

// output given string as formatted message(s), but check patterns

// Output given string as formatted message(s), but check patterns

    {

    }

        // message playback explicitly only handles colors for
        // the tutorial channel... guess we'll store bare strings
        // for the rest, then.
        if (channel == MSGCH_TUTORIAL)
            mpr_store_messages(fs.to_colour_string(), channel, param);
        else
            mpr_store_messages(unformatted, channel, param);

        for (unsigned f = 0; f < Options.force_more_message.size(); ++f)
        {
            if (Options.force_more_message[f].is_filtered(channel, st_nocolor))
            {
                more();
                New_Message_Count = 0;
                // One more() is quite enough, thank you!
                break;
            }
        }
        mpr_store_messages(fs.to_colour_string(), channel, param);

    // turn cursor off -- avoid 'cursor dance'

    // Turn cursor off -- avoid 'cursor dance'.

}                               // end mseclr()

}

        {

        }

        {

        }

            // calculate line in circular buffer

            // Calculate line in circular buffer.

            // avoid wrap-around

            // Avoid wrap-around.

            // for tutorial texts (for now, used for debugging)
            // allow formatted output of tagged messages
            if (Store_Message[ line ].channel == MSGCH_TUTORIAL)

            // Allow formatted output of tagged messages.
            formatted_string fs = formatted_string::parse_string(text, true);
            int curcol = 1;
            for ( unsigned int j = 0; j < fs.ops.size(); ++j )

                formatted_string fs = formatted_string::parse_string(text, true);
                int curcol = 1;
                for ( unsigned int j = 0; j < fs.ops.size(); ++j )

                switch ( fs.ops[j].type )

                    switch ( fs.ops[j].type )
                    {
                    case FSOP_COLOUR:
                        colour = fs.ops[j].x;
                        break;
                    case FSOP_TEXT:
                        textcolor( colour );
                        cgotoxy(curcol, wherey(), GOTO_CRT);
                        cprintf(fs.ops[j].text.c_str());
                        curcol += multibyte_strlen(fs.ops[j].text);
                        break;
                    case FSOP_CURSOR:
                        break;
                    }

                case FSOP_COLOUR:
                    colour = fs.ops[j].x;
                    break;
                case FSOP_TEXT:
                    textcolor( colour );
                    cgotoxy(curcol, wherey(), GOTO_CRT);
                    cprintf(fs.ops[j].text.c_str());
                    curcol += multibyte_strlen(fs.ops[j].text);
                    break;
                case FSOP_CURSOR:
                    break;

            else
#if DEBUG_DIAGNOSTICS
            cprintf( "%d: %s", line, text.c_str() );
#else
            cprintf( "%s", text.c_str() );
#endif

    case OBJ_CORPSES:
        // Skeletons cannot be eaten.
        if (item.sub_type == CORPSE_SKELETON)
        {
            prefixes.push_back("inedible");
            break;
        }
        // intentional fall-through

        if (!can_ingest(item.base_type, item.sub_type, true, true, false)

        if (item.base_type != OBJ_CORPSES
               && !can_ingest(item.base_type, item.sub_type, true, true, false)
            || you.species == SP_VAMPIRE && !mons_has_blood(item.plus)

        // intentional fall-through
    case OBJ_CORPSES:
        if (is_poisonous(item) && !player_res_poison())

        if (is_poisonous(item))

    {

    }

    const bool dangerous =
        (player_in_a_dangerous_place() && you.experience_level > 1);

    const bool dangerous = (player_in_a_dangerous_place()
                            && you.experience_level > 1);

    {

    }

    // check for alternate spellings

    // Check for alternate spellings.

        // Check if we have a direct colour index

        // Check if we have a direct colour index.

// returns -1 if unmatched else returns 0-15

// Returns -1 if unmatched else returns 0-15.

    force_more_message.clear();

        && key != "travel_stop_message"

        && key != "travel_stop_message" && key != "force_more_message"

                       message_filter( channel, s ) );

                        message_filter( channel, s ) );

                    message_filter( fragments[i] ) );
        }
    }
    else if (key == "force_more_message")
    {
        std::vector<std::string> fragments = split_string(",", field);
        for (int i = 0, count = fragments.size(); i < count; ++i)
        {
            if (fragments[i].length() == 0)
                continue;
            std::string::size_type pos = fragments[i].find(":");
            if (pos && pos != std::string::npos)
            {
                std::string prefix = fragments[i].substr(0, pos);
                int channel = str_to_channel( prefix );
                if (channel != -1 || prefix == "any")
                {
                    std::string s = fragments[i].substr( pos + 1 );
                    trim_string( s );
                    force_more_message.push_back(
                        message_filter( channel, s ) );
                    continue;
                }
            }
            force_more_message.push_back(

// look for a butchering implement. If fallback is true,

// Look for a butchering implement. If fallback is true,

    // if we didn't swap above, then we still can't cut...let's call

    // If we didn't swap above, then we still can't cut...let's call

    // prompt for new weapon

    // Prompt for new weapon.

    // let's see if the user did something...

    // Let's see if the user did something...

    int num = 0;

    const bool can_bottle = (you.species == SP_VAMPIRE
                             && you.experience_level > 5
                             && (!you.duration[DUR_PRAYER]
                                 || !god_likes_butchery(you.religion)));
    int num        = 0;
    int num_bottle = 0;

            continue;
        // Only actually count corpses, not skeletons.
        if (obj.base_type != OBJ_CORPSES || obj.sub_type != CORPSE_BODY)
            continue;
        // Only saprovorous characters care about rotten food.
        if (food_is_rotten(obj) && !player_mutation_level(MUT_SAPROVOROUS))

        if (obj.base_type == OBJ_CORPSES && obj.sub_type == CORPSE_BODY)
            num++;

        num++;
        if (can_bottle && mons_has_blood(obj.plus))
            num_bottle++;

    std::string verb = (you.species == SP_VAMPIRE
                        && you.experience_level > 5) ? "bottle" : "butcher";
    std::string noun, pronoun;

    std::string verb = (num_bottle ? (num == num_bottle ? "bottle"
                                                        : "bottle or butcher")
                                   : "butcher");

    std::string noun, pronoun;

        text << "If you dropped the " << noun << " in your pack on solid "
             << "ground then you could " << verb << " " << pronoun  << ".";

        text << "If you dropped the " << noun << " in your pack "
             << "then you could " << verb << " " << pronoun  << ".";

            // return pre-chosen corpse if it exists

            // Return pre-chosen corpse if it exists.

            mprf("There isn't anything to %s here.",

            mprf("There isn't anything to %sbutcher here.",

                  && you.experience_level > 5) ? "bottle" : "butcher");

                  && you.experience_level > 5) ? "bottle or " : "");

            std::string corpse_name = mitm[o].name(DESC_NOCAP_A);
            const bool sacrifice = (you.duration[DUR_PRAYER]
                                    && god_likes_butchery(you.religion));
            // We don't need to check for undead because
            // * Mummies can't eat
            // * Ghouls relish the bad things
            // * Vampires won't bottle bad corpses
            if (!sacrifice && !you.is_undead)
            {
                // Don't bother colouring if it's only for sacrificing.
                std::string cprf       = menu_colour_item_prefix(mitm[o]);
                std::string colour     = "";
                std::string colour_off = "";
                int col = menu_colour(corpse_name, cprf, "pickup");
                if (col != LIGHTGRAY)
                    colour = colour_to_str( col );
                if (!colour.empty())
                {
                    // Order is important here.
                    colour_off  = "</" + colour + ">";
                    colour      = "<" + colour + ">";
                    corpse_name = colour + corpse_name + colour_off;
                }
            }

                     (!can_bottle_blood_from_corpse(mitm[o].plus)
                      || you.duration[DUR_PRAYER]
                         && god_likes_butchery(you.religion)) ? "Butcher"
                                                              : "Bottle",
                     mitm[o].name(DESC_NOCAP_A).c_str());

                     (sacrifice
                      || !can_bottle_blood_from_corpse(mitm[o].plus)) ?
                            "Butcher" : "Bottle",
                     corpse_name.c_str());

                            MT_INVLIST,
                            OBJ_FOOD,
                            true, true, true, 0, NULL,
                            OPER_EAT );

                                    MT_INVLIST,
                                    OBJ_FOOD,
                                    true, true, true, 0, NULL,
                                    OPER_EAT );

                            MT_INVLIST,
                            OSEL_VAMP_EAT,
                            true, true, true, 0, NULL,
                            OPER_EAT );

                                    MT_INVLIST,
                                    OSEL_VAMP_EAT,
                                    true, true, true, 0, NULL,
                                    OPER_EAT );

}                               // end eat_food()

}

static bool _player_has_enough_food()
{
    int food_value = 0;
    item_def item;
    for (unsigned slot = 0; slot < ENDOFPACK; ++slot)
    {
        item = you.inv[slot];
        if (!is_valid_item(item))
            continue;
        if (!can_ingest(item.base_type, item.sub_type, true, true, false))
            continue;
        if (food_is_rotten(item) && !player_mutation_level(MUT_SAPROVOROUS))
            continue;
        if (is_poisonous(item))
            continue;
        if (is_mutagenic(item))
            continue;
        if (causes_rot(item) && you.species != SP_GHOUL)
            continue;
        // Vampires can only drain corpses.
        if (you.species == SP_VAMPIRE)
            food_value += 3;
        else
        {
            if (item.base_type != OBJ_FOOD)
                continue;
            switch (item.sub_type)
            {
            case FOOD_CHUNK:
                if (!player_mutation_level(MUT_HERBIVOROUS))
                    food_value += 2 * item.quantity;
                break;
            case FOOD_MEAT_RATION:
                if (!player_mutation_level(MUT_HERBIVOROUS))
                    food_value += 3 * item.quantity;
                break;
            case FOOD_BREAD_RATION:
                if (!player_mutation_level(MUT_CARNIVOROUS))
                    food_value += 3 * item.quantity;
                break;
            default:
                // Only count snacks if we really like them
                if (is_preferred_food(item))
                    food_value += item.quantity;
                break;
            }
        }
    }
    // You have "enough" food if you have, e.g.
    //  1 meat ration + 1 chunk, or 2 chunks for carnivores, or
    //  5 items of fruit, or 1 bread ration and 2 fruit items as a herbivore.
    return (food_value > 5);
}

                // Xom thinks this is funny if you're in a labyrinth
                // and are low on food.
                if (you.level_type == LEVEL_LABYRINTH
                    && !_player_has_enough_food())
                {
                    xom_is_stimulated(64);
                }

                // Xom thinks this is funny if you're in a labyrinth
                // and are low on food.
                if (you.level_type == LEVEL_LABYRINTH
                    && !_player_has_enough_food())
                {
                    xom_is_stimulated(32);
                }

                    gourmand,
                    nutrition,
                    effective_nutrition,
                    epercent);

                gourmand, nutrition, effective_nutrition, epercent);

        nutrition = CHUNK_BASE_NUTRITION;
        hp_amt = 1 + random2(5) + random2(1 + you.experience_level);

        nutrition    = CHUNK_BASE_NUTRITION;
        hp_amt       = 1 + random2(5) + random2(1 + you.experience_level);

// Returns true if a food item (also corpses) is poisonous AND the player
// is not poison resistant.

        return (false);
    if (player_res_poison())

// Returns true if a food item (also corpses) is mutagenic.

// Returns true if a food item (also corpses) may cause sickness.

// Returns true if a food item (also corpses) will cause rotting.

    if (food.base_type != OBJ_FOOD && food.sub_type != FOOD_CHUNK)

    if (food.base_type != OBJ_FOOD && food.base_type != OBJ_CORPSES)

    // Vampires don't really have a preferred food type, but they really
    // like blood potions.
    if (you.species == SP_VAMPIRE)
        return (is_blood_potion(food));

            return true;

            return (true);

                return true;

                return (true);

                return false;

                return (false);

        return false;

        return (false);

            return true;

            return (true);

    std::vector<message_filter> force_more_message;

    if ( !fake_draw )

    if (!fake_draw)

        // Vampires can't turn into bats when full of blood.

        // Give messages if the character cannot use innate talents right now.
        // * Vampires can't turn into bats when full of blood.
        // * Permanent flying (Kenku) cannot be turned off.

        else if (you.species == SP_KENKU && you.experience_level >= 5)
        {
            if (you.flight_mode() == FL_FLY)
                mpr("You're already flying!");
            else if (you.flight_mode() == FL_LEVITATE)
                mpr("You can only start flying from the ground.");
        }

    //jmf: "upgrade" for draconians -- expensive flight
    // note: this ability only applies to this counter

    // jmf: "upgrade" for draconians -- expensive flight
    // Note: This ability only applies to this counter.

        // Now you can only turn levitation off if you have an
        // activatable item.  Potions and miscast effects will
        // have to time out (this makes the miscast effect actually
        // a bit annoying). -- bwr
        _add_talent(talents, you.duration[DUR_LEVITATION] ?
                    ABIL_EVOKE_STOP_LEVITATING : ABIL_EVOKE_LEVITATE,
                    check_confused);

        // Has no effect on permanently flying Kenku.
        if (!you.permanent_levitation() && you.flight_mode() != FL_FLY)
        {
            // Now you can only turn levitation off if you have an
            // activatable item.  Potions and miscast effects will
            // have to time out (this makes the miscast effect actually
            // a bit annoying). -- bwr
            _add_talent(talents, you.duration[DUR_LEVITATION] ?
                        ABIL_EVOKE_STOP_LEVITATING : ABIL_EVOKE_LEVITATE,
                        check_confused);
        }

menu = lightgreen:.*equipped.*

menu = green:.*equipped.*

# Spriggans don't care for corpses and chunks.
#

                travel_stop_message, runrest_ignore_message,
                runrest_ignore_poison, runrest_ignore_monster,
                trapwalk_safe_hp, trap_prompt, rest_wait_both

                travel_stop_message, force_more_message,
                runrest_ignore_message, runrest_ignore_poison, 
                runrest_ignore_monster, trapwalk_safe_hp, 
                trap_prompt, rest_wait_both

force_more_message = <list of regexes>
        Any message that contains a regex specified here, will enforce a
        -More- prompt, so it can be used to highlight really important
        events.
        The syntax is identical to that of travel_stop_message.