&& !mons_is_mimic( monster->type )

                interrupt_activity( AI_SEE_MONSTER, monster );

                if (!mons_is_mimic( monster->type ))
                    interrupt_activity( AI_SEE_MONSTER, monster );

#include "monstuff.h"

static bool is_greed_inducing_square(const LevelStashes *ls,
                                     const coord_def &c);

    if (ES_item && igrd(pos) != NON_ITEM)
        ed.found_item( pos, mitm[ igrd(pos) ] );

    if (ES_item)
    {
        if (mgrd(pos) != NON_MONSTER)
        {
            const monsters *mons = &menv[ mgrd(pos) ];
            if (mons_is_mimic(mons->type)
                && !mons_is_known_mimic(mons))
            {
                item_def item;
                get_mimic_item(mons, item);
                ed.found_item(pos, item);
            }
        }
        
        if (igrd(pos) != NON_ITEM)
            ed.found_item( pos, mitm[ igrd(pos) ] );
    }

static bool is_greed_inducing_square(const LevelStashes *ls, const coord_def &c)
{
    if (ls && ls->needs_visit(c.x, c.y))
        return (true);
    const int m_ind = mgrd(c);
    if (m_ind != NON_MONSTER)
    {
        const monsters *mons = &menv[ m_ind ];
        if (mons_is_mimic(mons->type)
            && mons_was_seen(mons)
            && !mons_is_known_mimic(mons))
        {
            item_def mimic_item;
            get_mimic_item(mons, mimic_item);
            if (item_needs_autopickup(mimic_item))
                return (true);
        }
    }
    return (false);
}

    return (ls && ls->needs_visit(c.x, c.y));

    return ::is_greed_inducing_square(ls, c);

        if (current_level && current_level->needs_visit(pos.x, pos.y))

        if (current_level && is_greed_inducing_square(current_level, pos))

	marshallString(th, you.inv[i].inscription.c_str(), 80);

        marshallString(th, you.inv[i].inscription.c_str(), 80);

inline bool testbits(unsigned int flags, unsigned int test)

inline bool testbits(unsigned long flags, unsigned long test)

    if (!silent)

    const bool now_visible = mons_near(monster);
    if (!silent && now_visible)

    if (player_monster_visible(monster) && mons_near(monster))

    if (player_monster_visible(monster) && now_visible)

    // Teleporting mimics change form - if they reappear out of LOS, they are
    // no longer known.
    if (mons_is_mimic(monster->type))
    {
        if (now_visible)
            monster->flags |= MF_KNOWN_MIMIC;
        else
            monster->flags &= ~MF_KNOWN_MIMIC;
    }

void get_mimic_item( const struct monsters *mimic, item_def &item )

void get_mimic_item( const monsters *mimic, item_def &item )

    if (mons_near( monster ) 

    if (mons_near( monster )

void seen_monster(struct monsters *monster)

void seen_monster(monsters *monster)

    if ( MONST_INTERESTING(monster) &&
         monster->type != MONS_PANDEMONIUM_DEMON &&
         monster->type != MONS_PLAYER_GHOST )

    if ( !mons_is_mimic(monster->type)
         && MONST_INTERESTING(monster)
         && monster->type != MONS_PANDEMONIUM_DEMON
         && monster->type != MONS_PLAYER_GHOST )

bool mons_was_seen(const monsters *m);
bool mons_is_known_mimic(const monsters *m);

}
bool mons_was_seen(const monsters *m)
{
    return testbits(m->flags, MF_SEEN);

bool mons_is_known_mimic(const monsters *m)
{
    return mons_is_mimic(m->type) && testbits(m->flags, MF_KNOWN_MIMIC);
}

    // If a mimic is attacking the player, it is thereafter known.
    if (mons_is_mimic(attacker->type))
        attacker->flags |= MF_KNOWN_MIMIC;

    // Any objects seen in combat are thereafter known mimics.
    if (mons_is_mimic(attacker->type) && mons_near(attacker))
        attacker->flags |= MF_KNOWN_MIMIC;
    if (mons_is_mimic(defender->type) && mons_near(defender))
        defender->flags |= MF_KNOWN_MIMIC;

// Note: These are currently stored in chars!!!
// Need to fix struct monsters and the savefile if you want more.

// These are now saved in an unsigned long in the monsters struct.

    MF_DIVINE_PROTECTION  = 0x80   // Monster has divine protection.

    MF_DIVINE_PROTECTION  = 0x80,  // Monster has divine protection.
    
    MF_KNOWN_MIMIC        = 0x100  // Mimic that has taken a swing at the PC,
                                   // or that the player has inspected with ?

    // Now that the player has examined it, he knows it's a mimic.
    if (mons_is_mimic(menv[which_mons].type))
        menv[which_mons].flags |= MF_KNOWN_MIMIC;

void mimic_alert(struct monsters *mimic)

void mimic_alert(monsters *mimic)