mpr( "* * * LOW MAGIC WARNING * * *", MSGCH_DANGER_MAGIC );

        mpr( "* * * LOW MAGIC WARNING * * *", MSGCH_DANGER );

            break;
        case MSGCH_DANGER_MAGIC:
            ret = LIGHTCYAN;

    if (Options.sound_mappings.size() > 0) 

    if (!Options.sound_mappings.empty()) 

                break;
            }
        }
    }
    if (!Options.message_colour_mappings.empty())
    {
        std::string message = inf;
        for (int i = 0, size = Options.message_colour_mappings.size();
             i < size; ++i)
        {
            const message_colour_mapping &m =
                Options.message_colour_mappings[i];
            if (m.message.is_filtered(channel, message))
            {
                colour = m.colour;

// Splits string 's' on the separator 'sep'. If trim == true, trims each
// segment. If accept_empties == true, accepts empty segments. If nsplits >= 0,
// splits on the first nsplits occurrences of the separator, and stores the
// remainder of the string as the last segment; negative values of nsplits
// split on all occurrences of the separator.

        bool accept_empties = false);

        bool accept_empties = false,
        int nsplits = -1);

static void add_segment(std::vector<std::string> &segs,
                        std::string s,
                        bool trim,
                        bool accept_empty)
{
    if (trim && !s.empty())
        trim_string(s);

    if (accept_empty || !s.empty())
        segs.push_back(s);
}

        bool accept_empty_segments)

        bool accept_empty_segments,
        int nsplits)

    while ((pos = s.find(sep, 0)) != std::string::npos)

    while (nsplits && (pos = s.find(sep)) != std::string::npos)

        if (pos > 0 || accept_empty_segments)
            segments.push_back(s.substr(0, pos));

        add_segment(segments, s.substr(0, pos),
                    trim_segments, accept_empty_segments);
        

    }
    if (s.length() > 0)
        segments.push_back(s);
    
    if (trim_segments)
    {
        for (int i = 0, count = segments.size(); i < count; ++i)
            trim_string(segments[i]);

        
        if (nsplits > 0)
            --nsplits;

    if (!s.empty())
        add_segment(segments, s, trim_segments, accept_empty_segments);

    "rotten_meat", "equipment", "floor", "multiturn", "diagnostic","tutorial",
    "magic_warning",

    "rotten_meat", "equipment", "floor", "multiturn", "diagnostic","tutorial"

    message_colour_mappings.clear();

}
void game_options::add_message_colour_mappings(const std::string &field)
{
    std::vector<std::string> fragments = split_string(",", field);
    for (int i = 0, count = fragments.size(); i < count; ++i)
        add_message_colour_mapping(fragments[i]);

message_filter game_options::parse_message_filter(const std::string &filter)
{
    std::string::size_type pos = filter.find(":");
    if (pos && pos != std::string::npos)
    {
        std::string prefix = filter.substr(0, pos);
        int channel = str_to_channel( prefix );
        if (channel != -1 || prefix == "any")
        {
            std::string s = filter.substr( pos + 1 );
            trim_string( s );
            return message_filter( channel, s );
        }
    }

    return message_filter( filter );
}
void game_options::add_message_colour_mapping(const std::string &field)
{
    std::vector<std::string> cmap = split_string(":", field, true, true, 1);
    if (cmap.size() != 2)
        return;
    const int col = str_to_colour( cmap[0] );
    if (col == -1)
        return;
    message_colour_mapping m = { parse_message_filter( cmap[1] ), col };
    message_colour_mappings.push_back( m );
}

        && key != "message_colour" && key != "message_color"

        for (int i = 0, count = seg.size(); i < count; ++i) {

        for (int i = 0, count = seg.size(); i < count; ++i)
        {

            if (cpos != std::string::npos) {

            if (cpos != std::string::npos)
            {

    }
    else if (key == "message_colour" || key == "message_color")
    {
        add_message_colour_mappings(field);

    int colour;
};
struct message_colour_mapping
{
    message_filter message;

    std::vector<message_colour_mapping> message_colour_mappings;

    void add_message_colour_mappings(const std::string &);
    void add_message_colour_mapping(const std::string &);
    message_filter parse_message_filter(const std::string &s);

    MSGCH_DANGER_MAGIC,   // low magic warning

# Message colours
message_colour = lightcyan:LOW MAGIC WARNING

                terse_hand, delay_message_clear, menu_colour, 

                terse_hand, delay_message_clear, menu_colour, message_colour,

message_colour = <colour>:[<channel>:]<regex>
        message_colour allows you to override colours for individual messages.
        For instance, if you find the low hp warning to be insufficiently
        attention grabbing, you could do something like
          message_colour = yellow:LOW HITPOINT WARNING
        You can also narrow the message match to a specific channel:
          message_colour = lightred:god:xom