// wow. this struct is only about 48 bytes, (excluding the name)

monsterentry *get_monster_data(int p_monsterid);

void init_monster_symbols();

unsigned char mons_char(int mc);

unsigned mons_char(int mc);

mon_display monster_symbols[NUM_MONSTERS];

static monsterentry *seekmonster(int p_monsterid);

#define smc seekmonster(mc)

#define smc get_monster_data(mc)

    {

    }

    init_monster_symbols();

void init_monster_symbols()
{
    for (int i = 0; i < NUM_MONSTERS; ++i)
    {
        mon_display &md = monster_symbols[i];
        const monsterentry *me = get_monster_data(i);
        if (me)
        {
            md.glyph = me->showchar;
            md.colour = me->colour;
        }
    }
    for (int i = 0, size = Options.mon_glyph_overrides.size();
         i < size; ++i)
    {
        const mon_display &md = Options.mon_glyph_overrides[i];
        if (md.type == MONS_PROGRAM_BUG)
            continue;
        if (md.glyph)
            monster_symbols[md.type].glyph = md.glyph;
        if (md.colour)
            monster_symbols[md.type].colour = md.colour;
    }
}

    const monsterentry *me = seekmonster(mc);

    const monsterentry *me = get_monster_data(mc);

    else if (((seekmonster(mon->type))->bitfields & M_SEE_INVIS) != 0)

    else if (((get_monster_data(mon->type))->bitfields & M_SEE_INVIS) != 0)

unsigned char mons_char(int mc)

unsigned mons_char(int mc)

    return static_cast<unsigned char>(smc->showchar);
}                               // end mons_char()

    return monster_symbols[mc].glyph;
}

int mons_class_colour(int mc)
{
    return monster_symbols[mc].colour;
}

int mons_class_colour(int mc)
{
    const monsterentry *m = smc;
    if (!m)
        return (BLACK);
    const int class_colour = m->colour;
    return (class_colour);
}                               // end mons_colour()

    return seekmonster(mon->type)->resist_magic == MAG_IMMUNE;

    return get_monster_data(mon->type)->resist_magic == MAG_IMMUNE;

    int u = (seekmonster(mon->type))->resist_magic;

    int u = (get_monster_data(mon->type))->resist_magic;

    struct monsterentry *mon_class = seekmonster( type );

    struct monsterentry *mon_class = get_monster_data( type );

    const monsterentry *m = seekmonster(mcls);

    const monsterentry *m = get_monster_data(mcls);

    result += seekmonster(nametype)->name;

    result += get_monster_data(nametype)->name;

    result += seekmonster(type)->name;

    result += get_monster_data(type)->name;

static monsterentry *seekmonster(int p_monsterid)

monsterentry *get_monster_data(int p_monsterid)

}                               // end seekmonster()

}                               // end get_monster_data()

    const monsterentry *me = seekmonster(m->type);

    const monsterentry *me = get_monster_data(m->type);

    const monsterentry *me1 = seekmonster(m1->type),
                       *me2 = seekmonster(m2->type);

    const monsterentry *me1 = get_monster_data(m1->type),
                       *me2 = get_monster_data(m2->type);

    const monsterentry *e = seekmonster(type);

    const monsterentry *e = get_monster_data(type);

    const monsterentry *m = seekmonster(mcls);

    const monsterentry *m = get_monster_data(mcls);

    MONS_ZOMBIE_SMALL, 'z', BROWN, "",

    MONS_ZOMBIE_SMALL, 'z', BROWN, "small zombie",

    MONS_ZOMBIE_LARGE, 'Z', BROWN, "",

    MONS_ZOMBIE_LARGE, 'Z', BROWN, "large zombie",

    MONS_SKELETON_SMALL, 'z', LIGHTGREY, "",

    MONS_SKELETON_SMALL, 'z', LIGHTGREY, "small skeleton",

    MONS_SKELETON_LARGE, 'Z', LIGHTGREY, "",

    MONS_SKELETON_LARGE, 'Z', LIGHTGREY, "large skeleton",

    MONS_SPECTRAL_THING, 'W', GREEN, "",

    MONS_SPECTRAL_THING, 'W', GREEN, "spectral thing",

    MONS_PLAYER_GHOST, 'p', DARKGREY, "",

    MONS_PLAYER_GHOST, 'p', DARKGREY, "player ghost",

    MONS_PANDEMONIUM_DEMON, '&', BLACK, "&",

    MONS_PANDEMONIUM_DEMON, '&', BLACK, "pandemonium lord",

    MONS_SIMULACRUM_SMALL, 'z', WHITE, "",

    MONS_SIMULACRUM_SMALL, 'z', WHITE, "small simulacrum",

    MONS_SIMULACRUM_LARGE, 'Z', WHITE, "",

    MONS_SIMULACRUM_LARGE, 'Z', WHITE, "large simulacrum",

        const char *sep, 
        std::string s, 
        bool trim = true, 
        bool accept_empties = false,
        int nsplits = -1);

    const std::string &sep, 
    std::string s, 
    bool trim = true, 
    bool accept_empties = false,
    int nsplits = -1);

        const char *sep, 
        std::string s,
        bool trim_segments,
        bool accept_empty_segments,
        int nsplits)

    const std::string &sep, 
    std::string s,
    bool trim_segments,
    bool accept_empty_segments,
    int nsplits)

    int separator_length = strlen(sep);

    int separator_length = sep.length();

int str_to_colour( const std::string &str, int default_colour = -1 );

int str_to_colour( const std::string &str, int default_colour = -1,
                   bool accept_number = true );

#include "mon-util.h"

int str_to_colour( const std::string &str, int default_colour )

int str_to_colour( const std::string &str, int default_colour,
                   bool accept_number )

    if (ret == 16)

    if (ret == 16 && accept_number)

    mon_glyph_overrides.clear();

    if (s.length() > 1 && s[0] == '\\')
        s = s.substr(1);

    if (s.length() > 1 && s[0] == '\\')
        s = s.substr(1);

}
void game_options::add_mon_glyph_override(monster_type mtype,
                                          mon_display &mdisp)
{
    mdisp.type = mtype;
    mon_glyph_overrides.push_back(mdisp);
}
void game_options::add_mon_glyph_overrides(const std::string &mons,
                                           mon_display &mdisp)
{
    // If one character, this is a monster letter.
    int letter = -1;
    if (mons.length() == 1)
        letter = mons[0] == '_' ? ' ' : mons[0];
    
    for (int i = 0; i < NUM_MONSTERS; ++i)
    {
        const monsterentry *me = get_monster_data(i);
        if (!me || me->mc == MONS_PROGRAM_BUG)
            continue;
        
        if (me->showchar == letter || me->name == mons)
            add_mon_glyph_override(static_cast<monster_type>(i), mdisp);
    }
}
mon_display game_options::parse_mon_glyph(const std::string &s) const
{
    mon_display md;
    std::vector<std::string> phrases = split_string(" ", s);
    for (int i = 0, size = phrases.size(); i < size; ++i)
    {
        const std::string &p = phrases[i];
        const int col = str_to_colour(p, -1, false);
        if (col != -1 && colour)
            md.colour = col;
        else
            md.glyph = p == "_"? ' ' : read_symbol(p);
    }
    return (md);
}
void game_options::add_mon_glyph_override(const std::string &text)
{
    std::vector<std::string> override = split_string(":", text);
    if (override.size() != 2u)
        return;
    mon_display mdisp = parse_mon_glyph(override[1]);
    if (mdisp.glyph || mdisp.colour)
        add_mon_glyph_overrides(override[0], mdisp);

void game_options::add_all(const std::string &s, const std::string &separator,
                           void (game_options::*add)(const std::string &))
{
    const std::vector<std::string> defs = split_string(separator, s);
    for (int i = 0, size = defs.size(); i < size; ++i)
        (this->*add)( defs[i] );
}

        && key != "mon_glyph"

        std::vector<std::string> defs = split_string(";", field);
        
        for (int i = 0, size = defs.size(); i < size; ++i)
            add_feature_override( defs[i] );

        add_all(field, ";", &game_options::add_feature_override);

    else if (key == "mon_glyph")
    {
        add_all(field, ",", &game_options::add_mon_glyph_override);
    }

struct mon_display
{
    monster_type type;
    unsigned     glyph;
    unsigned     colour;

    mon_display(monster_type m = MONS_PROGRAM_BUG,
                unsigned gly = 0,
                unsigned col = 0) : type(m), glyph(gly), colour(col) { }
};

    std::vector<mon_display>      mon_glyph_overrides;

    void add_all(const std::string &s, const std::string &separator,
                 void (game_options::*add)(const std::string &));
    void add_mon_glyph_override(monster_type mtype, mon_display &mdisp);    
    void add_mon_glyph_overrides(const std::string &mons, mon_display &mdisp);
    void add_mon_glyph_override(const std::string &);
    mon_display parse_mon_glyph(const std::string &s) const;

    // Read the init file

    // Init monsters up front - needed to handle the mon_glyph option right.
    init_monsters(mcolour);
    
    // Read the init file.

    init_monster_symbols();

    init_monsters(mcolour);     // this needs to be way up top {dlb}

    init_monster_symbols();

# char_set, cset_ascii, cset_ibm, cset_dec, cset_any, feature

# char_set, cset_ascii, cset_ibm, cset_dec, cset_any, feature, mon_glyph

                classic_item_colours

                mon_glyph, classic_item_colours

mon_glyph = <monster name or symbol> : <colour> <glyph>
        The mon_glyph option allows you to customise the symbol and
        colour used to display a monster.

        You can customise symbols based on monster names or their existing
        symbols. For instance, if you want to put elves on E and efreeti
        on e, you can do this:
        mon_glyph = e : E
        mon_glyph = E : e
        If you want to change the symbol for a monster that uses a
        space as a symbol, specify an underscore on the left:
        mon_glyph = _ : #
        (That changes shades to use #.)
        You can specify a different symbol, or a colour, or both, in
        any order. Here are more examples:
        mon_glyph = deep elf annihilator : E lightmagenta
        mon_glyph = Xtahua : lightmagenta D
        mon_glyph = large zombie : darkgrey
        mon_glyph = small simulacrum : x
        (The left hand side of the : is case-sensitive.)
        
        You can specify symbols using their code points using the
        syntax as shown in feature. If you're using char_set=unicode,
        you can use unicode code points:
        
        mon_glyph = draconian scorcher : x6e9
        A single _ is treated as a space; if you want a real underscore,
        put a \ in front of it like this:
        mon_glyph = player ghost : \_