void terse_describe_square(const coord_def &c);

void terse_describe_square(const coord_def &c, bool in_range = true);

static void _describe_cell(const coord_def& where);

static void _describe_cell(const coord_def& where, bool in_range = true);

        do_anything = (range >= 0);
        if (range < 0)
            return;
        // Save and replace grid colours. -1 means unchanged.

        if ( range < 0 )
            return;

        const coord_def offset(9,9);

            if (grid_is_solid(*ri) && grid_distance(you.pos(), *ri) > range)

            if (grid_distance(you.pos(), *ri) > range)

                orig_colours(*ri - you.pos() + coord_def(9,9)) =
                    env.grid_colours( *ri );

                orig_colours(*ri - you.pos() + offset) = env.grid_colours(*ri);

        // Save and replace monster colours.
        for (int i = 0; i < MAX_MONSTERS; ++i)
        {
            if (menv[i].alive()
                && grid_distance(menv[i].pos(), you.pos()) > range
                && you.can_see(&menv[i]))
            {
                orig_mon_colours[i] = menv[i].colour;
                menv[i].colour = DARKGREY;
            }
            else
            {
                orig_mon_colours[i] = -1;
            }
        }
        // Repaint.

        if (!do_anything)
            return;
        // Restore grid colours.

        const coord_def offset(9,9);

                    env.grid_colours(you.pos()+c-coord_def(9,9)) = old_colour;

                    env.grid_colours(you.pos() + c - offset) = old_colour;

        // Restore monster colours.
        for (int i = 0; i < MAX_MONSTERS; ++i)
            if (orig_mon_colours[i] != -1)
                menv[i].colour = orig_mon_colours[i];
        // Repaint.

    bool do_anything;

    int orig_mon_colours[MAX_MONSTERS];

            terse_describe_square(moves.target);

            bool in_range = (range < 0
                             || grid_distance(moves.target, you.pos()) < range);
            terse_describe_square(moves.target, in_range);

void terse_describe_square(const coord_def &c)

void terse_describe_square(const coord_def &c, bool in_range)

        _describe_cell(c);

        _describe_cell(c, in_range);

std::string _mon_enchantments_string(const monsters* mon)
{
    const bool paralysed = mons_is_paralysed(mon);
    std::vector<std::string> enchant_descriptors;
    for (mon_enchant_list::const_iterator e = mon->enchantments.begin();
         e != mon->enchantments.end(); ++e)
    {
        const std::string tmp =
            _describe_mons_enchantment(*mon, e->second, paralysed);
        if (!tmp.empty())
            enchant_descriptors.push_back(tmp);
    }
    if (paralysed)
        enchant_descriptors.push_back("paralysed");
    
    if (!enchant_descriptors.empty())
    {
        return
            mon->pronoun(PRONOUN_CAP)
            + " is "
            + comma_separated_line(enchant_descriptors.begin(),
                                   enchant_descriptors.end())
            + ".";
    }
    else
        return "";
}

    std::string text = get_monster_desc(mon);
    text += ".";
    print_formatted_paragraph(text, get_number_of_cols());

    const int numcols = get_number_of_cols();
    std::string text = get_monster_desc(mon) + ".";
    print_formatted_paragraph(text, numcols);

    std::string desc = "";
    std::string last_desc = "";
    std::string tmp = "";
    const bool paralysed = mons_is_paralysed(mon);
    if (paralysed)
        last_desc += "paralysed";
    for (mon_enchant_list::const_iterator e = mon->enchantments.begin();
         e != mon->enchantments.end(); ++e)
    {
         tmp = _describe_mons_enchantment(*mon, e->second, paralysed);
         if (!tmp.empty())
         {
             if (!desc.empty())
                 desc += ", ";
             desc += last_desc;
             last_desc = tmp;
         }
    }
    if (!last_desc.empty())
    {
        if (!desc.empty())
            desc += ", and ";
        desc += last_desc;
    }
    if (!desc.empty())
    {
        text = mon->pronoun(PRONOUN_CAP);
        text += " is ";
        text += desc;
        text += ".";
        print_formatted_paragraph(text, get_number_of_cols());
    }

    text = _mon_enchantments_string(mon);
    if (!text.empty())
        print_formatted_paragraph(text, numcols);

static void _describe_cell(const coord_def& where)

static void _describe_cell(const coord_def& where, bool in_range)

        int i = mgrd(where);

        const monsters* mon = &menv[mgrd(where)];

        if (_mon_submerged_in_water(&menv[i]))

        if (_mon_submerged_in_water(mon))

        if (!player_monster_visible( &menv[i] ))

        if (!player_monster_visible(mon))

        if (!player_monster_visible( &menv[i] ))

        if (!player_monster_visible(mon))

        _describe_monster(&menv[i]);

        _describe_monster(mon);

        if (mons_is_mimic( menv[i].type ))

        if (mons_is_mimic(mon->type))

            monster_described = true;

        {
            if ( !in_range )
            {
                mprf(MSGCH_EXAMINE_FILTER, "%s is out of range.",
                     mon->pronoun(PRONOUN_CAP).c_str());
            }
            monster_described = true;            
        }

        debug_stethoscope(i);

        debug_stethoscope(mgrd(where));

        if (Options.tutorial_left && tutorial_monster_interesting(&menv[i]))

        if (Options.tutorial_left && tutorial_monster_interesting(mon))