void set_redraw_status( unsigned long flags );

void set_redraw_status(unsigned long flags);

std::string make_time_string( time_t abs_time, bool terse )

std::string make_time_string(time_t abs_time, bool terse)

void set_redraw_status( unsigned long flags )

void set_redraw_status(unsigned long flags)

static bool tag_follower_at(const coord_def &pos)

static bool _tag_follower_at(const coord_def &pos)

    if (!fmenv->alive()

    if (fmenv->type == MONS_PLAYER_GHOST
        || !fmenv->alive()
        || !fmenv->can_use_stairs()

    // Return true for monsters that can't use stairs (so that friendly
    // monsters adjacent to them can still follow you through stairs),
    // but don't tag them as followers.
    if (fmenv->can_use_stairs())
    {
        // Monster is chasing player through stairs.
        fmenv->flags |= MF_TAKING_STAIRS;

    // Monster is chasing player through stairs.
    fmenv->flags |= MF_TAKING_STAIRS;

        // Clear patrolling/travel markers.
        fmenv->patrol_point.reset();
        fmenv->travel_path.clear();
        fmenv->travel_target = MTRAV_NONE;

    // Clear patrolling/travel markers.
    fmenv->patrol_point.reset();
    fmenv->travel_path.clear();
    fmenv->travel_target = MTRAV_NONE;

        mprf(MSGCH_DIAGNOSTICS, "%s is marked for following.",
             fmenv->name(DESC_CAP_THE, true).c_str() );

    mprf(MSGCH_DIAGNOSTICS, "%s is marked for following.",
         fmenv->name(DESC_CAP_THE, true).c_str() );

    }

    for ( adjacent_iterator ai; ai; ++ai )

    for (adjacent_iterator ai; ai; ++ai)

                    if (tag_follower_at(fp))

                    if (_tag_follower_at(fp))

    for ( stack_iterator si(you.pos()); si; ++si )

    for (stack_iterator si(you.pos()); si; ++si)

    mon->colour = EC_UNHOLY;

        || m->type == MONS_ROTTING_DEVIL
        || m->type == MONS_CURSE_TOE)

        || m->type == MONS_ROTTING_DEVIL || m->type == MONS_CURSE_TOE)

    // Monsters too stupid to use stairs (e.g. zombies) are also disqualified.
    if (!m->can_use_stairs())
        return (false);

    // aren't pushers and shovers, zombies are zombies. Worms and elementals
    // are on the list because all 'w' are currently unrelated.

    // aren't pushers and shovers. Worms and elementals are on the list because
    // all 'w' are currently unrelated.

            && mchar != 'G' && mchar != 'Z' && mchar != 'z'
            && mchar != 'w' && mchar != '#');

            && mchar != 'G' && mchar != 'w' && mchar != '#');

    int mchar1 = me1->showchar,
        mchar2 = me2->showchar;

    int mchar1 = me1->showchar;
    int mchar2 = me2->showchar;

    // Skeletal warriors can push past zombies large and small.
    if (m1->type == MONS_SKELETAL_WARRIOR && (mchar2 == 'z' || mchar2 == 'Z'))
        return (m1->hit_dice > m2->hit_dice);

    // Monsters that are smart enough to use stairs can push past monsters
    // too stupid to use stairs (e.g. zombies).
    if (m1->can_use_stairs() && !m2->can_use_stairs())
        return (true);

    if (type == MONS_PLAYER_GHOST)
        return (false);
    if (mons_is_zombified(this) && !mons_enslaved_intact_soul(this))
        return (false);
    return (true);

    return (!mons_is_zombified(this) || mons_enslaved_intact_soul(this));

    // Monster has to be already tagged in order to follow.
    if (!testbits( fmenv->flags, MF_TAKING_STAIRS ))

    // The monster has to already be tagged in order to follow.
    if (!testbits(fmenv->flags, MF_TAKING_STAIRS))

    for ( adjacent_iterator ai; ai; ++ai )

    for (adjacent_iterator ai; ai; ++ai)