short get_resist_level(mon_resist_flags res_type) const;

short mon_resist_def::get_resist_level(mon_resist_flags res_type) const
{
    switch (res_type)
    {
    case MR_RES_ELEC:
        return elec;
    case MR_RES_POISON:
        return poison;
    case MR_RES_FIRE:
        return fire;
    case MR_RES_STEAM:
        return steam;
    case MR_RES_COLD:
        return cold;
    case MR_RES_ACID:
        return acid;
    default:
        return (0);
    }
}

    }
}
static int _get_resist_level(const mon_resist_def resist,
                             mon_resist_flags res_type)
{
    switch (res_type)
    {
    case MR_RES_ELEC:
        return resist.elec;
    case MR_RES_POISON:
        return resist.poison;
    case MR_RES_FIRE:
        return resist.fire;
    case MR_RES_STEAM:
        return resist.steam;
    case MR_RES_COLD:
        return resist.cold;
    case MR_RES_ACID:
        return resist.acid;
    default:
        return (0);

    const char* modifiers[] = {
        "susceptible",          // -1
        "resistant",            // +1
        "very resistant",       // +2
        "extremely resistant"   // +3

    const mon_resist_def resist = get_mons_resists(&mon);
    const mon_resist_flags resists[] = {
        MR_RES_ELEC,  MR_RES_POISON, MR_RES_FIRE,
        MR_RES_STEAM, MR_RES_COLD,   MR_RES_ACID

    const mon_resist_def resist = get_mons_resists(&mon);
    std::vector<mon_resist_flags> resists;
    resists.push_back(MR_RES_ELEC);
    resists.push_back(MR_RES_POISON);
    resists.push_back(MR_RES_FIRE);
    resists.push_back(MR_RES_STEAM);
    resists.push_back(MR_RES_COLD);
    resists.push_back(MR_RES_ACID);

    for (unsigned int i = 0; i < resists.size(); ++i)

    for (unsigned int i = 0; i < ARRAYSZ(resists); ++i)

        int level = _get_resist_level(resist, resists[i]);
        const char* attackname = _get_resist_name(resists[i]);

        int level = resist.get_resist_level(resists[i]);

            const int offset = (level < 0) ? 0 : std::min(level, 3);
            switch (offset)

            const char* attackname = _get_resist_name(resists[i]);
            level = std::max(level, -1);
            level = std::min(level,  3);
            switch (level)

                case 0:

                case -1:

    std::string result = "";

    std::vector<std::string> all_resists;

    std::vector<std::string> resist_descriptions;

        result  = modifiers[3];
        result += " to ";
        result += comma_separated_line(extreme_resists.begin(),
                                       extreme_resists.end(),
                                       " and ", ", ");
        all_resists.push_back(result);

        const std::string tmp = "extremely resistant to "
            + comma_separated_line(extreme_resists.begin(),
                                   extreme_resists.end());
        resist_descriptions.push_back(tmp);

        result  = modifiers[2];
        result += " to ";
        result += comma_separated_line(high_resists.begin(),
                                       high_resists.end(),
                                       " and ", ", ");
        all_resists.push_back(result);

        const std::string tmp = "very resistant to "
            + comma_separated_line(high_resists.begin(), high_resists.end());
        resist_descriptions.push_back(tmp);

        result  = modifiers[1];
        result += " to ";
        result += comma_separated_line(base_resists.begin(),
                                       base_resists.end(),
                                       " and ", ", ");
        all_resists.push_back(result);

        const std::string tmp = "resistant to "
            + comma_separated_line(base_resists.begin(), base_resists.end());
        resist_descriptions.push_back(tmp);

    if (!all_resists.empty())

    std::ostringstream result;
    if (!resist_descriptions.empty())

        result  = pronoun;
        result += " is ";
        result += comma_separated_line(all_resists.begin(),
                                       all_resists.end(),
                                       "; and ", "; ");
        result += ".$";

        result << pronoun << " is "
               << comma_separated_line(resist_descriptions.begin(),
                                       resist_descriptions.end(),
                                       "; and ", "; ")
               << ".$";

        result += pronoun;
        result += " is ";
        result += modifiers[0];
        result += " to ";
        result += comma_separated_line(suscept.begin(),
                                       suscept.end(),
                                       " and ", ", ");
        result += ".$";

        result << pronoun << " is susceptible to "
               << comma_separated_line(suscept.begin(), suscept.end())
               << ".$";

    {
        result += pronoun;
        result += " is immune to magical enchantments.$";
    }

        result << pronoun << " is immune to magical enchantments.$";

    {
        result += pronoun;
        result += " can see invisible.$";
    }

        result << pronoun << " can see invisible.$";

    {
        result += pronoun;
        result += " can sense the presence of invisible creatures.$";
    }

        result << pronoun << " can sense the presence of invisible creatures.$";

    if (speed < 10 || speed > 10)

    if (speed != 10)

        result += pronoun;
        result += " is ";

        result << pronoun << " is ";

            result += "very slow";

            result << "very slow";

            result += "slow";

            result << "slow";

            result += "extremely fast";

            result << "extremely fast";

            result += "very fast";

            result << "very fast";

            result += "fast";
        result += ".$";

            result << "fast";
        result << ".$";

    {
        result += pronoun;
        result += " can ";
        result += (fly == FL_FLY ? "fly" : "levitate");
        result += ".$";
    }
    return result;
}
/*
// Return a string of the form "She is resistant to fire."
static std::string _resistance_description(const char* pronoun,
                                           int level, const char* attackname)
{
    const char* modifiers[] = {
        "susceptible",          // -1
        "resistant",            // +1
        "very resistant",       // +2
        "extremely resistant"   // +3
    };
    std::string result;
    if (level != 0)

        const int offset = (level < 0) ? 0 : std::min(level, 3);
        result = pronoun;
        result += " is ";
        result += modifiers[offset];
        result += " to ";
        result += attackname;
        result += ".$";

        result << pronoun << " can "
               << (fly == FL_FLY ? "fly" : "levitate") << ".$";

    return result;
}

static std::string _monster_resists_string(const monsters& mon)
{
    const mon_resist_def resist = get_mons_resists(&mon);
    const char* pronoun = mons_pronoun(static_cast<monster_type>(mon.type),
                                       PRONOUN_CAP, true);
    std::string result;
    // Not shown: hellfire, asphyxiation, sticky flames.
    result += _resistance_description(pronoun, resist.elec,   "electricity");
    result += _resistance_description(pronoun, resist.poison, "poison");
    result += _resistance_description(pronoun, resist.fire,   "fire");
    result += _resistance_description(pronoun, resist.steam,  "steam");
    result += _resistance_description(pronoun, resist.cold,   "cold");
    result += _resistance_description(pronoun, resist.acid,   "acid");
    return result;

    return result.str();

*/

//---------------------------------------------------------------
//
// describe_monsters
//
// Contains sketchy descriptions of every monster in the game.
//
//---------------------------------------------------------------