const int grid = grd[count_x][count_y];

                        const dungeon_feature_type grid = grd[count_x][count_y];

bool is_stair(unsigned gridc);
bool is_travelable_stair(unsigned gridc);
command_type stair_direction(int stair_feat);

bool is_stair(dungeon_feature_type gridc);
bool is_travelable_stair(dungeon_feature_type gridc);
command_type stair_direction(dungeon_feature_type stair_feat);

private:
    template <class C> void say_any(const C &coll, const char *stub) const;
    template <class citer> bool has_duplicates(citer, citer) const;
    
    std::string cleaned_feature_description(dungeon_feature_type feature) const;
    void add_item(const item_def &item);
    

    std::vector< named_thing<int> > portals;

private:
    template <class C> void say_any(const C &coll, const char *stub) const;
    template <class citer> bool has_duplicates(citer, citer) const;
    
    std::string cleaned_feature_description(dungeon_feature_type feature) const;
    void add_item(const item_def &item);
    void add_stair(const named_thing<int> &stair);
    std::vector<std::string> apply_quantities(
        const std::vector< named_thing<int> > &v) const;
    bool merge_feature(
        std::vector< named_thing<int> > &v,
        const named_thing<int> &feat) const;    

bool is_stair(unsigned gridc)

bool is_stair(dungeon_feature_type gridc)

bool is_travelable_stair(unsigned gridc)

bool is_travelable_stair(dungeon_feature_type gridc)

command_type stair_direction(int stair)

command_type stair_direction(dungeon_feature_type stair)

            int grid = grd[x][y];

            dungeon_feature_type grid = grd[x][y];

    : es_flags(0), current_level(NULL), items(), stairs(), shops(), altars()

    : es_flags(0), current_level(NULL), items(), stairs(),
      portals(), shops(), altars()

    {

    }

    if (s.find("a ") != std::string::npos)
        s = s.substr(2);
    else if (s.find("an ") != std::string::npos)
        s = s.substr(3);

}
bool explore_discoveries::merge_feature(
    std::vector< explore_discoveries::named_thing<int> > &v,
    const explore_discoveries::named_thing<int> &feat) const
{
    for (int i = 0, size = v.size(); i < size; ++i)
        if (feat == v[i])
        {
            ++v[i].thing;
            return (true);
        }
    return (false);

        stairs.push_back(
            named_thing<int>(
                cleaned_feature_description(grid), grid ) );

        const named_thing<int> stair(cleaned_feature_description(grid), 1);
        add_stair(stair);

        altars.push_back(
            named_thing<int>(
                cleaned_feature_description(grid), grid ) );
        es_flags |= ES_ALTAR;        

        const named_thing<int> altar(cleaned_feature_description(grid), 1);
        if (!merge_feature(altars, altar))
            altars.push_back(altar);
        es_flags |= ES_ALTAR;

void explore_discoveries::add_stair(
    const explore_discoveries::named_thing<int> &stair)
{
    if (merge_feature(stairs, stair) || merge_feature(portals, stair))
        return;
    // Hackadelic
    if (stair.name.find("stair") != std::string::npos)
        stairs.push_back(stair);
    else
        portals.push_back(stair);
}

std::vector<std::string> explore_discoveries::apply_quantities(
    const std::vector< named_thing<int> > &v) const
{
    static const char *feature_plural_qualifiers[] =
    {
        " leading ", " back to ", " to ", " of "
    };
    
    std::vector<std::string> things;
    for (int i = 0, size = v.size(); i < size; ++i)
    {
        const named_thing<int> &nt = v[i];
        if (nt.thing == 1)
            things.push_back(article_a(nt.name));
        else
            things.push_back(number_in_words(nt.thing)
                             + " "
                             + pluralise(nt.name, feature_plural_qualifiers));
    }
    return (things);
}

    say_any(altars, "Found %s altars.");
    say_any(stairs, "Found %s stairs.");

    say_any(apply_quantities(altars), "Found %s altars.");
    say_any(apply_quantities(portals), "Found %s gates.");
    say_any(apply_quantities(stairs), "Found %s stairs.");

extern const char *standard_plural_qualifiers[];

std::string pluralise(const std::string &name, 

std::string article_a(const std::string &name, bool lowercase = true);
std::string pluralise(const std::string &name,
                      const char *stock_plural_quals[] = standard_plural_qualifiers,

}
// Naively prefix A/an to a noun.
std::string article_a(const std::string &name, bool lowercase)
{
    if (!name.length()) return name;
    const char *a  = lowercase? "a " : "A ";
    const char *an = lowercase? "an " : "An ";
    switch (name[0])
    {
        case 'a': case 'e': case 'i': case 'o': case 'u':
        case 'A': case 'E': case 'I': case 'O': case 'U':
            return an + name;
        default:
            return a + name;
    }

const char *standard_plural_qualifiers[] =
{
    " of ", " labeled "
};

std::string pluralise(const std::string &name, 
                      const char *no_of[])

std::string pluralise(const std::string &name,
                      const char *qualifiers[],
                      const char *no_qualifier[])

    // Pluralise first word of names like 'eye of draining' or
    // 'scrolls labeled FOOBAR', but only if the whole name is not
    // suffixed by a supplied modifier, such as 'zombie' or 'skeleton'
    if ( (pos = name.find(" of ")) != std::string::npos 
            && !ends_with(name, no_of) )
        return pluralise(name.substr(0, pos)) + name.substr(pos);
    else if ( (pos = name.find(" labeled ")) != std::string::npos
              && !ends_with(name, no_of) )
        return pluralise(name.substr(0, pos)) + name.substr(pos);
    else if (ends_with(name, "us"))

    if (qualifiers)
    {
        for (int i = 0; qualifiers[i]; ++i)
            if ((pos = name.find(qualifiers[i])) != std::string::npos 
                && !ends_with(name, no_qualifier))
            {
                return pluralise(name.substr(0, pos)) + name.substr(pos);
            }
    }
    
    if (ends_with(name, "us"))

                                  const vault_placement &place)

                                 const vault_placement &place)

        return ("A rock staircase leading upwards.");

        return ("A rock staircase leading up.");

// Naively prefix A/an to a monster name. At the moment, we don't have monster
// names that demand more sophistication (maybe ynoxinul - don't know how 
// that's pronounced).
static std::string article_a(const std::string &name)
{
    if (!name.length()) return name;
    switch (name[0])
    {
        case 'a': case 'e': case 'i': case 'o': case 'u':
        case 'A': case 'E': case 'I': case 'O': case 'U':
            return "An " + name;
        default:
            return "A " + name;
    }
}

        return buf + pluralise(name, modifier_suffixes);

        return buf + pluralise(name, standard_plural_qualifiers, modifier_suffixes);

        return article_a(name);

        return article_a(name, false);