Options.tile_tag_pref = TAGPREF_TUTORIAL;

tag_pref string2tag_pref(const char *opt);
const char *tag_pref2string(tag_pref pref);

};
enum cursor_type
{
    CURSOR_MOUSE,
    CURSOR_TUTORIAL,
    CURSOR_MAX

enum text_tag_type
{
    TAG_NAMED_MONSTER,
    TAG_TUTORIAL,
    TAG_CELL_DESC,
    TAG_MAX
};

struct tag_def
{
    tag_def() { text = NULL; left = right = 0; }
    const char* text;
    char left, right;
    char type;
};

    // Draw text labels
    // TODO enne - add an option for this
    // TODO enne - be more intelligent about not covering stuff up
    for (unsigned int t = 0; t < TAG_MAX; t++)

    FixedArray<tag_def, ENV_SHOW_DIAMETER, ENV_SHOW_DIAMETER> tag_show;
    int total_tags = 0;
    for (int t = TAG_MAX - 1; t >= 0; t--)

            if (!on_screen(m_tags[t][i].gc))

            if (!crawl_view.in_grid_los(m_tags[t][i].gc))
                continue;
            const coord_def ep = grid2show(m_tags[t][i].gc);
            if (tag_show(ep).text)
                continue;
            const char *str = m_tags[t][i].tag.c_str();
            int width = m_tag_font->string_width(str);
            tag_def &def = tag_show(ep);
            const int buffer = 2;
            def.left = -width / 2 - buffer;
            def.right = width / 2 + buffer;
            def.text = str;
            def.type = t;
            total_tags++;
        }
        if (total_tags)
            break;
    }
    if (!total_tags)
        return;
    // Draw text tags.
    // TODO enne - be more intelligent about not covering stuff up
    for (int y = 0; y < ENV_SHOW_DIAMETER; y++)
    {
        for (int x = 0; x < ENV_SHOW_DIAMETER; x++)
        {
            coord_def ep(x, y);
            tag_def &def = tag_show(ep);
            if (!def.text)

            const coord_def gc = show2grid(ep);

            to_screen_coords(m_tags[t][i].gc, pc);

            to_screen_coords(gc, pc);

            m_tag_font->render_string(pc.x, pc.y, m_tags[t][i].tag.c_str(),

            m_tag_font->render_string(pc.x, pc.y, def.text,

#include "Kills.h"

        if (menv[idx].is_named() && !mons_friendly_real(&menv[idx])
            && menv[idx].type != MONS_PANDEMONIUM_DEMON)

        const monsters *mon = &menv[idx];
        if (!player_monster_visible(mon) 
            || mons_is_lurking(mon)
            || (mons_is_mimic(mon->type) && !mons_is_known_mimic(mon))
            || mons_class_flag(mon->type, M_NO_EXP_GAIN))

            if (menv[idx].type == MONS_PLAYER_GHOST)
            {
                // Beautification hack.  "Foo's ghost" is a little bit
                // verbose as a tag.  "Foo" on its own should be sufficient.
                tiles.add_text_tag(TAG_NAMED_MONSTER, menv[idx].mname, gc);
            }
            else
            {
                tiles.add_text_tag(TAG_NAMED_MONSTER,
                                   menv[idx].name(DESC_CAP_A), gc);
            }

            return;
        }
        const tag_pref pref = Options.tile_tag_pref;
        if (pref == TAGPREF_NONE)
            return;
        else if (pref == TAGPREF_TUTORIAL)
        {
            const long kills = you.kills->num_kills(mon);
            const int limit = 3;
            if (!mon->is_named() && kills > limit)
                return;
        }
        else if (!mon->is_named())
            return;
        if (pref != TAGPREF_NAMED && mons_friendly_real(mon))
            return;
        // HACK.  Names cover up pan demons in a weird way.
        if (mon->type == MONS_PANDEMONIUM_DEMON)
            return;
        if (mon->type == MONS_PLAYER_GHOST)
        {
            // Beautification hack.  "Foo's ghost" is a little bit
            // verbose as a tag.  "Foo" on its own should be sufficient.
            tiles.add_text_tag(TAG_NAMED_MONSTER, mon->mname, gc);

        else
        {
            tiles.add_text_tag(TAG_NAMED_MONSTER, mon->name(DESC_PLAIN), gc);
        }

}
static FixedVector<const char*, TAGPREF_MAX>
    tag_prefs("none", "tutorial", "named", "enemy");
tag_pref string2tag_pref(const char *opt)
{
    for (int i = 0; i < TAGPREF_MAX; i++)
    {
        if (!stricmp(opt, tag_prefs[i]))
            return ((tag_pref)i);
    }
    return TAGPREF_ENEMY;

const char *tag_pref2string(tag_pref pref)
{
    return tag_prefs[pref];
}

    const coord_def gc = view2grid(show2view(ep));

    const coord_def gc = show2grid(ep);

const std::string tile_cols[24] =

static std::string tile_cols[24] =

    tile_tag_pref = crawl_state.arena ? TAGPREF_NAMED : TAGPREF_ENEMY;

    else if (key == "tile_tag_pref")
    {
        tile_tag_pref = string2tag_pref(field.c_str());
    }

    tag_pref    tile_tag_pref;

enum cursor_type
{
    CURSOR_MOUSE,
    CURSOR_TUTORIAL,
    CURSOR_MAX
};
// Ordering of tags is important: higher values cover up lower ones.
enum text_tag_type
{
    TAG_NAMED_MONSTER = 0,
    TAG_TUTORIAL      = 1,
    TAG_CELL_DESC     = 2,
    TAG_MAX
};
enum tag_pref
{
    TAGPREF_NONE,     // never display text tags
    TAGPREF_TUTORIAL, // display text tags on "new" monsters
    TAGPREF_NAMED,    // display text tags on named monsters (incl. friendlies)
    TAGPREF_ENEMY,    // display text tags on enemy named monsters
    TAGPREF_MAX
};

inline coord_def show2grid(const coord_def &pos)
{
    return (view2grid(show2view(pos)));
}

    int num_kills(const monsters *mon) const;

    // Number of kills, by category.
    long num_kills(const monsters *mon, kill_category cat) const;
    // Number of kills, any category.
    long num_kills(const monsters *mon) const;

}
long KillMaster::num_kills(const monsters *mon, kill_category cat) const
{
    return categorized_kills[cat].num_kills(mon);

long KillMaster::num_kills(const monsters *mon) const
{
    long total = 0;
    for (int cat = 0; cat < KC_NCATEGORIES; cat++)
        total += categorized_kills[cat].num_kills(mon);
    return total;
}

}
int Kills::num_kills(const monsters *mon) const
{
    kill_monster_desc desc(mon);
    kill_map::const_iterator iter = kills.find(desc);
    int total = (iter == kills.end() ? 0 : iter->second.kills);
    if (desc.modifier == kill_monster_desc::M_SHAPESHIFTER)
    {
        desc.modifier = kill_monster_desc::M_NORMAL;
        iter = kills.find(desc);
        total += (iter == kills.end() ? 0 : iter->second.kills);
    }
    return total;

# tile_tag_pref = enemy

                tile_window_height, tile_map_pixels, tile_full_screen

                tile_window_height, tile_map_pixels, tile_full_screen,
                tile_tag_pref

   tile_tag_pref       = tutorial

tile_window_width = 1024
tile_window_height = 768
         The width and height of the window, in pixels.

tile_window_width  = 0 
tile_window_height = 0
         The width and height of the window, in pixels.  If set to zero, it
         will auto-size the window.

tile_tag_pref = (none | tutorial | named | enemy)
         This option defaults to "enemy" normally and "tutorial" in tutorial
         modes.  This settings determines which monsters receive text tag
         labels above them, describing what kind of monster they are.
         The "none" option turns off all tags.  The "tutorial" option
         shows the name of all monsters that the player has only killed
         a few times.  The "named" options shows the names for all monsters
         with names, friendly and enemy.  The "enemy" option only shows the
         name of enemy monsters with names (such as uniques and ghosts.)