named_thing_collection affected_monsters;

                poison_monster(monster, KC_YOU);

                bool affected =
                    poison_monster(monster, KC_YOU, 1, false, false);

                if (coinflip()) // 50-50 chance for a "double hit" {dlb}
                    poison_monster(monster, KC_YOU);

                if (coinflip() && poison_monster(monster, KC_YOU, false, false))
                    affected = true;

                if (affected)
                    affected_monsters.add_thing(monster->name(DESC_PLAIN));

}                               // end cast_toxic_radiance()

    if (!affected_monsters.empty())
    {
        const std::string message =
            make_stringf("%s %s poisoned.",
                         affected_monsters.describe(DESC_CAP_THE).c_str(),
                         affected_monsters.size() == 1? "is" : "are");
        if (static_cast<int>(message.length()) < get_number_of_cols() - 2)
            mpr(message.c_str());
        else
            // Exclamation mark to suggest that a lot of creatures were
            // affected.
            mpr("The monsters around you are poisoned!");
    }
}

#include <map>

// A collection of named things that can be stacked. The collection merges
// things that should be merged (by name) and outputs a comma-separated list
// with the preferred description type.
class named_thing_collection
{
public:
    named_thing_collection();
    void add_thing(const std::string &name);
    std::string describe(description_level_type desc,
                         const char **plural_qualifiers = NULL,
                         const char **no_qualifier_suffix = NULL) const;
    size_t size() const;
    bool   empty() const;
private:
    typedef std::map<std::string, int> name_count_map;
    name_count_map names;
    size_t nnames;
};

// Applies a description type to a name, but does not pluralise! You
// must pluralise the name if needed. The quantity is used to prefix the
// name with a quantity if appropriate.
std::string apply_description(description_level_type desc,
                              const std::string &name,
                              int quantity = 1,
                              bool num_in_words = false);

std::string number_to_string(unsigned number, bool in_words = false);

#include <sstream>

std::string number_to_string(unsigned number, bool in_words)
{
    return (in_words? number_in_words(number) : make_stringf("%u", number));
}
std::string apply_description(description_level_type desc,
                              const std::string &name,
                              int quantity, bool in_words)
{
    switch (desc)
    {
    case DESC_CAP_THE:
        return ("The " + name);
    case DESC_NOCAP_THE:
        return ("the " + name);
    case DESC_CAP_A:
        return (quantity > 1?
                number_to_string(quantity, in_words) + name
                : article_a(name, false));
    case DESC_NOCAP_A:
        return (quantity > 1?
                number_to_string(quantity, in_words) + name
                : article_a(name, true));
    case DESC_CAP_YOUR:
        return ("Your " + name);
    case DESC_NOCAP_YOUR:
        return ("your " + name);
    case DESC_PLAIN:
    default:
        return (name);
    }
}

//////////////////////////////////////////////////////////////////////////
// named_thing_collection
named_thing_collection::named_thing_collection()
    : names(), nnames(0u)
{
}

void named_thing_collection::add_thing(const std::string &name)
{
    names[name]++;
    nnames++;
}
size_t named_thing_collection::size() const
{
    return (nnames);
}
bool named_thing_collection::empty() const
{
    return (!nnames);
}
std::string named_thing_collection::describe(
    description_level_type desc,
    const char **plural_qualifiers,
    const char **no_qualifier_suffixes) const
{
    if (empty())
        return ("");
    
    std::ostringstream out;
    for (name_count_map::const_iterator i = names.begin();
         i != names.end(); )
    {
        const std::pair<std::string, int> &curr(*i);
        if (i != names.begin())
        {
            ++i;
            out << (i == names.end()? " and " : ", ");
        }
        else
            ++i;
        
        const std::string name =
            curr.second > 1? pluralise(curr.first, plural_qualifiers,
                                     no_qualifier_suffixes)
            : curr.first;
        out << apply_description(desc, name, curr.second);
        switch (desc)
        {
        case DESC_CAP_A:
            desc = DESC_NOCAP_A;
            break;
        case DESC_CAP_THE:
            desc = DESC_NOCAP_THE;
            break;
        case DESC_CAP_YOUR: case DESC_NOCAP_YOUR:
            desc = DESC_PLAIN;
            break;
        default:
            break;
        }
    }
    return (out.str());
}
/////////////////////////////////////////////////////////////////////////

void poison_monster( struct monsters *monster, kill_category who,
                     int levels = 1, bool force = false );

bool poison_monster( monsters *monster, kill_category who,
                     int levels = 1, bool force = false, bool verbose = true );

void poison_monster( monsters *monster,

bool poison_monster( monsters *monster,

                     bool force )

                     bool force,
                     bool verbose)

        return;

        return (false);

        return;

        return (false);

    if (new_pois.degree > old_pois.degree)

    if (new_pois.degree > old_pois.degree && verbose)

}                               // end poison_monster()

    return (new_pois.degree > old_pois.degree);
}