// Liches may wear anything.

    for ( adjacent_iterator ai(parent->pos()); ai; ++ai )

    for (adjacent_iterator ai(parent->pos()); ai; ++ai)

                continue;

            continue;

}
static bool _target_is_unreachable(monsters *mon)
{
    return (mon->travel_target == MTRAV_UNREACHABLE
            || mon->travel_target == MTRAV_KNOWN_UNREACHABLE);

    if (mon->travel_target != MTRAV_UNREACHABLE || one_chance_in(12))

    if (!_target_is_unreachable(mon) || one_chance_in(12))

        const bool native = mons_is_native_in_branch(mon);
        int range = 0;
        switch (mons_intel(mon))
        {
        case I_PLANT:
            range = 2;
            break;
        case I_INSECT:
            range = 4;
            break;
        case I_ANIMAL:
            range = 5;
            break;
        case I_NORMAL:
            range = LOS_RADIUS;
            break;
        default:
            // Highly intelligent monsters can find their way
            // anywhere. (range == 0 means no restriction.)
            break;
        }
        if (range)
        {
            if (native)
                range += 3;
            else if (mons_class_flag(mon->type, M_BLOOD_SCENT))
                range++;
        }

        const int range = mons_tracking_range(mon);

    for ( adjacent_iterator ai(p); ai; ++ai )

    for (adjacent_iterator ai(p); ai; ++ai)

int mons_tracking_range(const monsters *mon);

                       bool diag = true, bool msg = false);

                       bool diag = true, bool msg = false,
                       bool pass_unmapped = false);

    // If true, unmapped terrain is treated as traversable no matter the
    // monster involved.
    // (Used for player estimates of whether a monster can travel somewhere.)
    bool traverse_unmapped;

int mons_tracking_range(const monsters *mon)
{

    int range = 0;
    switch (mons_intel(mon))
    {
    case I_PLANT:
        range = 2;
        break;
    case I_INSECT:
        range = 4;
        break;
    case I_ANIMAL:
        range = 5;
        break;
    case I_NORMAL:
        range = LOS_RADIUS;
        break;
    default:
        // Highly intelligent monsters can find their way
        // anywhere. (range == 0 means no restriction.)
        break;
    }
    if (range)
    {
        if (mons_is_native_in_branch(mon))
            range += 3;
        else if (mons_class_flag(mon->type, M_BLOOD_SCENT))
            range++;
    }
    return (range);
}

                                     bool msg)

                                     bool msg, bool pass_unmapped)

    allow_diagonals = diag;

    allow_diagonals   = diag;
    traverse_unmapped = pass_unmapped;

    if (traverse_unmapped && grd(p) == DNGN_UNSEEN)
        return (true);

#include "monplace.h"

// Returns true if the monster has a path to the player, or it has to be
// assumed that this is the case.
static bool _mons_has_path_to_player(const monsters *mon)
{
    int m = monster_index(mon);
    // Don't consider sleeping monsters safe, in case the player would
    // rather retreat and try another path for maximum stabbing chances.
    if (mons_is_sleeping(mon))
        return (true);
    // If the monster is awake and knows a path towards the player
    // (even though the player cannot know this) treat it as unsafe.
    if (mon->travel_target == MTRAV_PLAYER)
        return (true);
    if (mon->travel_target == MTRAV_KNOWN_UNREACHABLE)
        return (false);
    // Try to find a path from monster to player, using the map as it's
    // known to the player and assuming unknown terrain to be traversable.
    monster_pathfind mp;
    const int range = mons_tracking_range(mon);
    if (range > 0)
        mp.set_range(range);
    if (mp.init_pathfind(&menv[m], you.pos(), true, false, true))
        return (true);
    // Now we know the monster cannot possibly reach the player.
    menv[m].travel_target = MTRAV_KNOWN_UNREACHABLE;
    return (false);
}

                       && !_mons_has_path_to_player(mon)

    for ( radius_iterator ri(you.pos(), range); ri; ++ri )

    for (radius_iterator ri(you.pos(), range); ri; ++ri)

    {

    }

                    && (!temp || you.species == SP_VAMPIRE
                                 && you.hunger_state == HS_STARVING));

                    && (you.species != SP_VAMPIRE
                        || temp && you.hunger_state == HS_STARVING));

    MTRAV_UNREACHABLE  // Not travelling because target is unreachable.

    MTRAV_UNREACHABLE, // Not travelling because target is unreachable.
    MTRAV_KNOWN_UNREACHABLE // As above, and the player knows this.

//    mprf("Question key: %s", key.c_str());

//    mprf("Answer key: %s", key.c_str());

# still see you

# still see you)

Please submit a bug report on Sourceforge, and give as much information as you can. (What were you doing at the time? What did you expect to happen, what happened instead? etc.) Sometimes a screenshot can be helpful. For crashes, or monsters/items/levels behaving oddly, we probably need a save file. To be on the safe side, attach the entire zipped save of the character on question. If there are error messages, please write them down. 

Please submit a bug report on Sourceforge, and give as much information as you can. (What were you doing at the time? What did you expect to happen, what happened instead? etc.) Sometimes a screenshot can be helpful. For crashes, or monsters/items/levels behaving oddly, we probably need a save file. To be on the safe side, attach the entire zipped save of the character in question. If there are error messages, please write them down.