description += "  " + describe_draconian_colour(subsp);

        if (describe_draconian_colour(subsp) != "")
            description += "  " + describe_draconian_colour(subsp);

        description += "  " + describe_draconian_role(mon);

        if (describe_draconian_role(mon) != "")
            description += "  " + describe_draconian_role(mon);

    unsigned char symbol = get_monster_data(mons.type)->showchar;
    std::string symbol_prefix = "__";
    symbol_prefix += symbol;
    symbol_prefix += "_prefix";
    description << getLongDescription(symbol_prefix);

        switch (mons.type)
        {
        case MONS_GUARDIAN_NAGA:
            description << getLongDescription("naga")
                        << "$These nagas are often used as guardians "
                           "by powerful creatures.$";
            break;
        case MONS_GREATER_NAGA:
            description << getLongDescription("naga")
                        << "$It looks strong and aggressive.$";
            break;
        case MONS_NAGA_MAGE:
            description << getLongDescription("naga")
                        << "$An eldritch nimbus trails its motions.$";
            break;
        case MONS_NAGA_WARRIOR:
            description << getLongDescription("naga")
                        << "$It bears scars of many past battles.$";
            break;
        }

    description << "\n";
    std::string symbol_suffix = "__";
    symbol_suffix += symbol;
    symbol_suffix += "_suffix";
    description << getLongDescription(symbol_suffix);

std::vector<std::string> database_find_bodies(DBM *database,
                                              const std::string &regex,
                                              bool ignore_case = false);

std::vector<std::string> getLongDescriptionByRegex(const std::string &regex);

std::vector<std::string> getLongDescKeysByRegex(const std::string &regex);
std::vector<std::string> getLongDescBodiesByRegex(const std::string &regex);

        if (key.find("__") != std::string::npos)
        {
            dbKey = dbm_nextkey(database);
            continue;
        }

            matches.push_back(key);
        dbKey = dbm_nextkey(database);
    }
    return (matches);
}
std::vector<std::string> database_find_bodies(DBM *database,
                                              const std::string &regex,
                                              bool ignore_case)
{
    text_pattern             tpat(regex, ignore_case);
    std::vector<std::string> matches;
    datum dbKey = dbm_firstkey(database);
    while (dbKey.dptr != NULL)
    {
        std::string key((const char *)dbKey.dptr, dbKey.dsize);
        if (key.find("__") != std::string::npos)
        {
            dbKey = dbm_nextkey(database);
            continue;
        }
        datum dbBody = dbm_fetch(database, dbKey);
        std::string body((const char *)dbBody.dptr, dbBody.dsize);
        if (tpat.matches(body))

std::vector<std::string> getLongDescriptionByRegex(const std::string &regex)

std::vector<std::string> getLongDescKeysByRegex(const std::string &regex)

}
std::vector<std::string> getLongDescBodiesByRegex(const std::string &regex)
{
    if (!descriptionDB)
    {
        std::vector<std::string> empty;
        return (empty);
    }
    return database_find_bodies(descriptionDB, regex, true);

__N_suffix
$"The insensible son of Pandu sank down till he reached the Naga kingdom.
Nagas, furnished with fangs containing virulent venom, bit him by
thousands. The vegetable poison, mingled in the blood of the son of the
Wind god, was neutralised by the snake-poison. The serpents had bitten
all over his frame, except his chest, the skin of which was so tough that
their fangs could not penetrate it.
"On regaining consciousness, the son of Kunti burst his bands and began
to press the snakes down under the ground. A remnant fled for life, and
going to their king Vasuki, represented, 'O king of snakes, a man drowned
under the water, bound in chords of shrubs; probably he had drunk poison.
For when he fell amongst us, he was insensible. But when we began to bite
him, he regained his senses, and bursting his fetters, commenced laying
at us. May it please Your Majesty to enquire who is.'"
	-_The Mahabharata, Sambhava Parva, Section CXXVIII
%%%%

greater naga
A hybrid; human from the chest up, with a scaly, muscular torso trailing off like that of a snake.
It looks strong an agressive.
%%%%

%%%%
guardian naga
A hybrid; human from the chest up, with a scaly, muscular torso trailing off like that of a snake.
These nagas are often used as guardians by powerful creatures.

pandemonium lord
Powerful demons inhabitting the endless halls of Pandemonium, each is different, with its own set of strengths and weaknesses.
%%%%

A skeleton compelled to unlife by the exercise of necromancy.

A large skeleton compelled to unlife by the exercise of necromancy.

A hybrid; human from the chest up, with a scaly, muscular torso trailing off like that of a snake.
%%%%
naga mage

"The insensible son of Pandu sank down till he reached the Naga kingdom.
Nagas, furnished with fangs containing virulent venom, bit him by
thousands. The vegetable poison, mingled in the blood of the son of the
Wind god, was neutralised by the snake-poison. The serpents had bitten
all over his frame, except his chest, the skin of which was so tough that
their fangs could not penetrate it.
"On regaining consciousness, the son of Kunti burst his bands and began
to press the snakes down under the ground. A remnant fled for life, and
going to their king Vasuki, represented, 'O king of snakes, a man drowned
under the water, bound in chords of shrubs; probably he had drunk poison.
For when he fell amongst us, he was insensible. But when we began to bite
him, he regained his senses, and bursting his fetters, commenced laying
at us. May it please Your Majesty to enquire who is.'"
	-_The Mahabharata, Sambhava Parva, Section CXXVIII

An eldritch nimbus trails its motions.
%%%%
naga warrior
A hybrid; human from the chest up, with a scaly, muscular torso trailing off like that of a snake.
It bears scars of many past battles.

%%%%
small skeleton
A skeleton compelled to unlife by the exercise of necromancy.
%%%%
small zombie
A corpse raised to undeath by necromancy.

tentacled monster

tentacled monstrosity

zombie
A corpse raised to undeath by necromancy.
%%%%

void list_commands(bool wizard, int hotkey = 0);

void list_commands(bool wizard, int hotkey = 0,
                   bool do_redraw_screen = false);

#include "mon-util.h"

static std::string list_commands_err = "";
static std::string select_desc_key(std::vector<std::string> keys)
{
    Menu desc_menu(MF_SINGLESELECT | MF_ANYPRINTABLE |
                   MF_ALWAYS_SHOW_MORE | MF_ALLOW_FORMATTING);
    desc_menu.set_title(new MenuEntry("Describe which?", MEL_TITLE));

static void find_description()

    desc_menu.set_highlighter(NULL);
    for (unsigned int i = 0, size = keys.size(); i < size; i++)
    {
        const char  letter = index_to_letter(i);
        std::string str    = uppercase_first(keys[i]);
        MenuEntry *me = new MenuEntry(uppercase_first(keys[i]),
                                      MEL_ITEM, 1, letter);
        monster_type mon = get_monster_by_name(str, true);
        if (mon < NUM_MONSTERS && mon != MONS_PROGRAM_BUG)
        {
            monsterentry *mon_en = get_monster_data(mon);
            me->colour = mon_en->colour;
            if (me->colour == BLACK)
                me->colour = LIGHTGREY;
            str += " ('";
            str += (char) mon_en->showchar;
            str += "')";
            me->text = str;
        }
        me->data = (void*) &keys[i];
        desc_menu.add_entry(me);
    }
    std::vector<MenuEntry*> sel = desc_menu.show();
    redraw_screen();
    if ( sel.empty() )
    {
        list_commands_err = "Okay, then.";
        return ("");
    }
    else
    {
        ASSERT(sel.size() == 1);
        ASSERT(sel[0]->hotkeys.size() == 1);
        return *((std::string*) sel[0]->data);
    }
}
static std::string find_description_key(std::string regex)
{
    std::vector<std::string> key_matches = getLongDescKeysByRegex(regex);
    if (key_matches.size() == 1)
        return (key_matches[0]);
    else if (key_matches.size() > 52)
    {
        list_commands_err = "Too many matches for '";
        list_commands_err += regex + "'";
        return ("");
    }
    std::vector<std::string> body_matches = getLongDescBodiesByRegex(regex);
    if (key_matches.size() == 0 && body_matches.size() == 0)
    {
        list_commands_err = "No matches for '";
        list_commands_err += regex + "'";
        return ("");
    }
    else if (key_matches.size() == 0 && body_matches.size() == 1)
        return (body_matches[0]);
    // Merge key_matches and body_matches, discarding duplicates.
    std::vector<std::string> tmp = key_matches;
    tmp.insert(tmp.end(), body_matches.begin(), body_matches.end());
    std::sort(tmp.begin(), tmp.end());
    std::vector<std::string> all_matches;
    for (unsigned int i = 0, size = tmp.size(); i < size; i++)
        if (i == 0 || all_matches[all_matches.size() - 1] != tmp[i])
        {
            all_matches.push_back(tmp[i]);
        }
    if (all_matches.size() > 52)
    {
        list_commands_err = "Too many matches for '";
        list_commands_err += regex + "'";
        return ("");
    }
    return select_desc_key(all_matches);
}
static std::string find_monster_key(unsigned char showchar)
{
    std::vector<std::string> mon_keys;
    for (int i = 0; i < NUM_MONSTERS; i++)
    {
        if (i == MONS_PROGRAM_BUG)
            continue;
        monsterentry *me = get_monster_data(i);
        if (me == NULL || me->name == NULL || me->name[0] == '\0')
            continue;
        if (me->mc != i)
            continue;
        if (getLongDescription(me->name) == "")
            continue;
        if (me->showchar == showchar)
            mon_keys.push_back(me->name);
    }
    if (mon_keys.size() == 0)
    {
        list_commands_err = "No monsters displayed with symbol '";
        list_commands_err += showchar;
        list_commands_err += "'";
        return ("");
    }        
    else if (mon_keys.size() > 52)
    {
        list_commands_err = "Too many monsters for symbol '";
        list_commands_err += showchar;
        list_commands_err += "'";
        return ("");
    }
    std::sort(mon_keys.begin(), mon_keys.end());
    return select_desc_key(mon_keys);
}
static bool find_description()

    mpr("Describe what? (can be a partial name or a regex) ");

    mpr("Describe a monster, spell, or feature; regexs and partial names "
        "are fine.  Enter a single letter to list monsters displayed by "
        "that symbol.");
    mpr("Describe what? ");

        canned_msg( MSG_OK);
        return;

        list_commands_err = "Okay, then.";
        return (false);

        mpr("Description must contain at least one non-space.");
        return;

        list_commands_err = "Description must contain at least one non-space.";
        return (false);

    std::string key   = regex;
    std::string desc  = getLongDescription(key);

    std::string key;
    std::string desc;

    if (desc == "")

    if (regex.size() == 1)

        std::vector<std::string> matches = getLongDescriptionByRegex(regex);

        key = find_monster_key(regex[0]);

        if (matches.size() == 0)
        {
            mprf("Nothing matches '%s'", buf);
            return;
        }
        else if (matches.size() > 1)
        {
            std::string prefix = "No exact match for '" +
                regex +  "', possible matches are: ";

        if (key == "")
            return (false);

            // Use mpr_comma_separated_list() because the list
            // might be *LONG*.
            mpr_comma_separated_list(prefix, matches, " and ", ", ",
                                     MSGCH_PLAIN);
            return;
        }
        else

        desc = getLongDescription(key);
    }
    else if (desc == "")
    {
        // Try to get an exact match first.
        key   = regex;
        desc  = getLongDescription(key);
        key = find_description_key(regex);
        if (key == "")
            return (false);
        desc = getLongDescription(key);
    }
    monster_type mon_num = get_monster_by_name(key, true);
    if (mon_num < NUM_MONSTERS && mon_num != MONS_PROGRAM_BUG)
    {
        if (mons_genus(mon_num) == MONS_DRACONIAN)

            // Only one match, use that.
            key  = matches[0];
            desc = getLongDescription(key);

            monsters mon;
            mon.type = mon_num;
            switch (mon_num)
            {
            case MONS_BLACK_DRACONIAN:
            case MONS_MOTTLED_DRACONIAN:
            case MONS_YELLOW_DRACONIAN:
            case MONS_GREEN_DRACONIAN:
            case MONS_PURPLE_DRACONIAN:
            case MONS_RED_DRACONIAN:
            case MONS_WHITE_DRACONIAN:
            case MONS_PALE_DRACONIAN:
                mon.number = mon_num;
                break;
            default:
                mon.number = 0;
                break;
            }
            describe_monsters(mon);
            return (false);

        unsigned char symbol = get_monster_data(mon_num)->showchar;
        std::string symbol_prefix = "__";
        symbol_prefix += symbol;
        symbol_prefix += "_prefix";
        desc = getLongDescription(symbol_prefix) + desc;
        std::string symbol_suffix = "__";
        symbol_suffix += symbol;
        symbol_suffix += "_suffix";
        desc += getLongDescription(symbol_suffix);

    return (true);

        find_description();
        if ( getch() == 0 )
            getch();

        if (find_description())
            if ( getch() == 0 )
                getch();

void list_commands(bool wizard, int hotkey)

void list_commands(bool wizard, int hotkey, bool do_redraw_screen)

        if (do_redraw_screen)
            redraw_screen();

    list_commands_err = "";

    if (do_redraw_screen)
    {
        clrscr();
        redraw_screen();
    }
    if (list_commands_err != "")
        mpr(list_commands_err.c_str());

        list_commands(true);        // tell it to list wizard commands
        redraw_screen();

        list_commands(true, 0, true);  // tell it to list wizard commands

        {

            redraw_screen();
        }

            list_commands(false);
        redraw_screen();

            list_commands(false, 0, true);