simple_god_message(info);

    simple_god_message(info, god);

void update_message_status();

void update_message_status(void);

void update_turn_count();

void update_turn_count(void);

void print_stats();
void print_stats_level();
void draw_border();

void print_stats(void);
void print_stats_level(void);
void draw_border(void);
std::string mpr_monster_list(bool past = false);

void update_monster_pane();

void update_monster_pane(void);

static bool _mons_hostile(const monsters *mon)
{
    return (!mons_friendly(mon) && !mons_neutral(mon));
}
static const char* _get_monster_name(const monsters *mon, bool list_a = false)
{
    std::string desc = "";
    bool adj = false;
    if (mons_friendly(mon))
    {
        desc += "friendly ";
        adj = true;
    }
    else if (mons_neutral(mon))
    {
        desc += "neutral ";
        adj = true;
    }
    if (adj && list_a)
    {
        desc = (mon->is_named() ? "the " : "a ") + desc;
        list_a = false;
    }
    desc += mon->name(list_a ? DESC_NOCAP_A : DESC_PLAIN);
    if (!(mon->mname).empty())
    {
        desc += " (";
        desc += mons_type_name(mon->type, DESC_PLAIN);
        desc += ")";
    }
    return desc.c_str();
}
// Returns true if the first monster is more aggressive (in terms of
// hostile/neutral/friendly) than the second, or, if both monsters share the
// same attitude, if the first monster has a lower type.
// If monster type and attitude are the same, return false.
static bool _compare_monsters_attitude( const monsters *m1, const monsters *m2 )
{
    if (_mons_hostile(m1) && !_mons_hostile(m2))
        return (true);

    if (mons_neutral(m1))
    {
        if (mons_friendly(m2))
            return (true);
        if (_mons_hostile(m2))
            return (false);
    }
    if (mons_friendly(m1) && !mons_friendly(m2))
        return (false);
    // If we get here then monsters have the same attitude.
    // FIXME: replace with difficulty comparison
    return (m1->type < m2->type);
}
static void _get_visible_monsters(std::vector<std::string>& describe)
{
    int ystart = you.y_pos - 9, xstart = you.x_pos - 9;
    int yend = you.y_pos + 9, xend = you.x_pos + 9;
    if ( xstart < 0 ) xstart = 0;
    if ( ystart < 0 ) ystart = 0;
    if ( xend >= GXM ) xend = GXM;
    if ( yend >= GYM ) yend = GYM;
    std::vector<const monsters*> mons;
    // monster check
    for (int y = ystart; y < yend; ++y)
        for (int x = xstart; x < xend; ++x)
            if (see_grid(x,y))
            {
                const unsigned short targ_monst = mgrd[x][y];
                if (targ_monst != NON_MONSTER)
                {
                    const monsters *mon = &menv[targ_monst];
                    if (player_monster_visible(mon)
                        && !mons_is_submerged(mon)
                        && !mons_is_mimic(mon->type))
                    {
                        mons.push_back(mon);
                    }
                }
            }
    if (mons.empty())
        return;
    std::sort( mons.begin(), mons.end(), _compare_monsters_attitude );
    int count = 0;
    int size = mons.size();
    for (int i = 0; i < size; ++i)
    {
        if (i > 0 && _compare_monsters_attitude(mons[i-1], mons[i]))
        {
            if (count == 1)
                describe.push_back(_get_monster_name(mons[i-1], true));
            else
            {
                describe.push_back(number_in_words(count) + " "
                                   + pluralise(_get_monster_name(mons[i-1])));
            }
            count = 0;
        }
        count++;
    }
    // handle last monster
    if (mons.size() == 1
        || _compare_monsters_attitude(mons[size-2], mons[size-1]))
    {
        describe.push_back(_get_monster_name(mons[size-1], true));
    }
    else
    {
        describe.push_back(number_in_words(count) + " "
                           + pluralise(_get_monster_name(mons[size-1])));
    }
}
// If past is true, the messages should be printed in the past tense
// because they're needed for the morgue dump.
std::string mpr_monster_list(bool past)
{
    std::vector<std::string> describe;
    _get_visible_monsters(describe);
    std::string msg = "";
    if (describe.empty())
    {
        msg  = "There ";
        msg += (past ? "were" : "are");
        msg += " no monsters in sight!";
        return (msg);
    }
    msg = "You ";
    msg += (past ? "could" : "can");
    msg += " see ";
    if (describe.size() == 1)
        msg += describe[0];
    else
    {
        msg += comma_separated_line(describe.begin(), describe.end(),
                                    ", and ", ", ");
    }
    msg += ".";
    return (msg);
}

            + me->hpdice[3];

                       + me->hpdice[3];

        if (mons_looks_stabbable(m)) m_brands |= 1;
        if (mons_looks_distracted(m)) m_brands |= 2;

        if (mons_looks_stabbable(m))   m_brands |= 1;
        if (mons_looks_distracted(m))  m_brands |= 2;

void
monster_pane_info::to_string(
    int count,
    std::string& desc,
    int& desc_color) const

void monster_pane_info::to_string( int count, std::string& desc,
                                   int& desc_color) const

    if (equip == EQ_BOOTS &&
           (you.species == SP_CENTAUR || you.species == SP_NAGA))

    if (equip == EQ_BOOTS
        && (you.species == SP_CENTAUR || you.species == SP_NAGA))

    {

    }

    {

    }

    if ( you.religion != GOD_NO_GOD )

    if (you.religion != GOD_NO_GOD)

        if ( player_under_penance() )

        if (player_under_penance())

            if ( prank < 0 || you.religion == GOD_XOM)

            if (prank < 0 || you.religion == GOD_XOM)

            godpowers = godpowers.substr(0, 29 - prank) + " " +
                std::string(prank, '*');

            godpowers = godpowers.substr(0, 29 - prank)
                         + " " + std::string(prank, '*');

             you.spell_no, player_spell_levels(), (player_spell_levels() == 1) ? "" : "s");

             you.spell_no, player_spell_levels(),
             (player_spell_levels() == 1) ? "" : "s");

    const int rmuta = wearing_amulet(AMU_RESIST_MUTATION, calc_unid)
                      || player_mutation_level(MUT_MUTATION_RESISTANCE) == 3
                      || you.religion == GOD_ZIN && you.piety >= 150;

    const int rmuta = (wearing_amulet(AMU_RESIST_MUTATION, calc_unid)
                       || player_mutation_level(MUT_MUTATION_RESISTANCE) == 3
                       || you.religion == GOD_ZIN && you.piety >= 150);

    {

    }

            // Kind of a hack -- we don't care really what items these

            // Kind of a hack -- we don't really care what items these

            if ((pos = name.find(qualifiers[i])) != std::string::npos 

            if ((pos = name.find(qualifiers[i])) != std::string::npos

    else if (ends_with(name, "ch") || ends_with(name, "sh") 

    else if (ends_with(name, "ch") || ends_with(name, "sh")

    return std::string(tens[ten]) 

    return std::string(tens[ten])

                (thousands? hundreds_in_words(thousands) + pow_in_words(pow)
                : ""));

                        (thousands? hundreds_in_words(thousands)
                                    + pow_in_words(pow)
                                  : ""));

// The old school way of doing short delays via low level I/O sync.  

// The old school way of doing short delays via low level I/O sync.

// Not the greatest version of snprintf, but a functional one that's 

// Not the greatest version of snprintf, but a functional one that's

// special behaviour for size == 0, largely because the return value 
// in that case varies depending on which standard is being used (SUSv2 

// special behaviour for size == 0, largely because the return value
// in that case varies depending on which standard is being used (SUSv2

    char *buff = new char [ 10 * size ];  // hopefully enough 

    char *buff = new char [ 10 * size ];  // hopefully enough

    int ret = strlen( str );  

    int ret = strlen( str );

void *compile_glob_pattern(const char *pattern, bool icase) 

void *compile_glob_pattern(const char *pattern, bool icase)

    return pcre_compile(pattern, 

    return pcre_compile(pattern,

        {

        }

                    "skills,spells,overview,mutations,messages,screenshot,"
                    "kills,notes");

                    "skills,spells,overview,mutations,messages,"
                    "screenshot,monlist,kills,notes");

        dump_kill_places =
            field == "none"? KDO_NO_PLACES :
            field == "all" ? KDO_ALL_PLACES :
                             KDO_ONE_PLACE;

        dump_kill_places = (field == "none" ? KDO_NO_PLACES :
                            field == "all"  ? KDO_ALL_PLACES
                                            : KDO_ONE_PLACE);

static void sdump_monster_list(dump_params &);

    { "monlist",        sdump_monster_list  },

    {

    }

    par.text += "\n\n";
}
static void sdump_monster_list(dump_params &par)
{
    std::string monlist = mpr_monster_list(par.se);
    trim_string(monlist);
    par.text += monlist;

}
static bool _mons_hostile(const monsters *mon)
{
    return (!mons_friendly(mon) && !mons_neutral(mon));

static const char* _get_monster_name(const monsters *mon, bool list_a = false)
{
    std::string desc = "";
    bool adj = false;
    if (mons_friendly(mon))
    {
        desc += "friendly ";
        adj = true;
    }
    else if (mons_neutral(mon))
    {
        desc += "neutral ";
        adj = true;
    }
    if (adj && list_a)
    {
        desc = "a " + desc;
        list_a = false;
    }
    desc += mons_type_name(mon->type, (list_a ? DESC_NOCAP_A : DESC_PLAIN));
    return desc.c_str();
}
// Returns true if the first monster is more aggressive (in terms of
// hostile/neutral/friendly) than the second or, if both monsters share the
// same attitude, if the first monster has a lower type.
// If monster type and attitude are the same, return false.
static bool _compare_monsters_attitude( const monsters *m1, const monsters *m2 )
{
    if (_mons_hostile(m1) && !_mons_hostile(m2))
        return (true);
    if (mons_neutral(m1))
    {
        if (mons_friendly(m2))
            return (true);
        if (_mons_hostile(m2))
            return (false);
    }
    if (mons_friendly(m1) && !mons_friendly(m2))
        return (false);
    // If we get here then monsters have the same attitude.
    // FIX ME: replace with difficulty comparison
    return (m1->type < m2->type);
}
void get_visible_monsters(std::vector<std::string>& describe)
{
    int ystart = you.y_pos - 9, xstart = you.x_pos - 9;
    int yend = you.y_pos + 9, xend = you.x_pos + 9;
    if ( xstart < 0 ) xstart = 0;
    if ( ystart < 0 ) ystart = 0;
    if ( xend >= GXM ) xend = GXM;
    if ( yend >= GYM ) yend = GYM;
    std::vector<const monsters*> mons;
    // monster check
    for ( int y = ystart; y < yend; ++y )
        for ( int x = xstart; x < xend; ++x )
            if ( see_grid(x,y) )
            {
                const unsigned short targ_monst = mgrd[x][y];
                if ( targ_monst != NON_MONSTER )
                {
                    const monsters *mon = &menv[targ_monst];
                    if ( player_monster_visible(mon)
                         && !mons_is_submerged(mon)
                         && !mons_is_mimic(mon->type))
                    {
                        mons.push_back(mon);
                    }
                }
            }
    if (mons.empty())
        return;
    std::sort( mons.begin(), mons.end(), _compare_monsters_attitude );
    int count = 0;
    int size = mons.size();
    for (int i = 0; i < size; ++i)
    {
        if (i > 0 && _compare_monsters_attitude(mons[i-1], mons[i]))
        {
            if (count == 1)
                describe.push_back(_get_monster_name(mons[i-1], true));
            else
            {
                describe.push_back(number_in_words(count) + " "
                                   + pluralise(_get_monster_name(mons[i-1])));
            }
            count = 0;
        }
        count++;
    }
    // handle last monster
    if (mons.size() == 1 ||
        _compare_monsters_attitude(mons[size-2], mons[size-1]))
    {
        describe.push_back(_get_monster_name(mons[size-1], true));
    }
    else
    {
        describe.push_back(number_in_words(count) + " "
                           + pluralise(_get_monster_name(mons[size-1])));
    }
}
static void _mpr_monsters()
{
    std::vector<std::string> describe;
    get_visible_monsters(describe);
    if (describe.empty())
    {
        mpr("There are no monsters in sight!");
    }
    else if (describe.size() == 1)
    {
        mprf("You can see %s.", describe[0].c_str());
    }
    else
    {
        std::string msg  = "You can see ";
                    msg += comma_separated_line(describe.begin(),
                                                describe.end(),
                                                ", and ", ", ");
                    msg += ".";
        mpr(msg.c_str());
    }
}

        _mpr_monsters();

        mpr(mpr_monster_list().c_str());

# dump_order += messages,screenshot,kills_by_place,kills

# dump_order += messages,screenshot,monlist,kills_by_place,kills

dump_order += skills,spells,overview,mutations,messages,screenshot
dump_order += kills

dump_order += skills,spells,overview,mutations,messages,screenshot,
dump_order += monlist,kills