static void _remove_sanctuary_property(coord_def where)

static void _remove_sanctuary_property(const coord_def& where)

//  Do not reset so as to allow monsters to see if their fleeing source
//  used to be the centre of a sanctuary. (jpeg)
//    env.sanctuary_pos.x = env.sanctuary_pos.y = -1;

    env.sanctuary_pos.set(-1, -1);

    // Now that the sanctuary is gone, monsters aren't afraid of it
    // anymore.
    for (int i = 0; i < MAX_MONSTERS; ++i)
    {
        monsters *mon = &menv[i];
        if (mon->alive())
            mons_stop_fleeing_from_sanctuary(mon);
    }

    int radius = 5;

    const int radius = 5;

    radius = size+1;
    for (int x = -radius; x <= radius; x++)
        for (int y = -radius; y <= radius; y++)
        {
            int posx = env.sanctuary_pos.x + x;
            int posy = env.sanctuary_pos.y + y;
            if (!inside_level_bounds(posx,posy))
                continue;
            int dist = distance(posx, posy, env.sanctuary_pos.x,
                                env.sanctuary_pos.y);

    for (radius_iterator ri(env.sanctuary_pos, size+1, true, false); ri; ++ri)
    {
        int dist = distance(*ri, env.sanctuary_pos);

            // If necessary overwrite sanctuary property.
            if (dist > size*size)
                _remove_sanctuary_property(coord_def(posx, posy));
        }

        // If necessary overwrite sanctuary property.
        if (dist > size*size)
            _remove_sanctuary_property(*ri);
    }

        _remove_sanctuary_property(coord_def(env.sanctuary_pos.x,
                                             env.sanctuary_pos.y));
        if (see_grid(coord_def(env.sanctuary_pos.x,env.sanctuary_pos.y)))

        _remove_sanctuary_property(env.sanctuary_pos);
        if (see_grid(env.sanctuary_pos))

    const int pattern     = random2(4);

    for ( radius_iterator ri(you.pos(), radius, false, false); ri; ++ri )

    for (radius_iterator ri(you.pos(), radius, false, false); ri; ++ri)

        int dist = _inside_circle(*ri, radius);

        const int dist = _inside_circle(*ri, radius);

        if (pattern == 0    // outward rays
            && (x == 0 || y == 0 || x == y || x == -y)
            || pattern == 1 // circles
            && (dist >= (radius-1)*(radius-1) && dist <= radius*radius
                || dist >= (radius/2-1)*(radius/2-1)
                && dist <= radius*radius/4)
            || pattern == 2 // latticed
            && (x%2 == 0 || y%2 == 0)
            || pattern == 3 // cross-like
            && (abs(x)+abs(y) < 5 && x != y && x != -y))

        bool in_yellow = false;
        switch (random2(4))

            env.map(pos).property |= FPROP_SANCTUARY_1; // yellow

        case 0:                 // outward rays
            in_yellow = (x == 0 || y == 0 || x == y || x == -y);
            break;
        case 1:                 // circles
            in_yellow = (dist >= (radius-1)*(radius-1)
                         && dist <= radius*radius
                         || dist >= (radius/2-1)*(radius/2-1)
                            && dist <= radius*radius/4);
            break;
        case 2:                 // latticed
            in_yellow = (x%2 == 0 || y%2 == 0);
            break;
        case 3:                 // cross-like
            in_yellow = (abs(x)+abs(y) < 5 && x != y && x != -y);
            break;
        default:
            break;

        else
            env.map(pos).property |= FPROP_SANCTUARY_2; // white

        env.map(pos).property |= (in_yellow ? FPROP_SANCTUARY_1
                                            : FPROP_SANCTUARY_2);

        // scare all attacking monsters inside sanctuary, and make

        // Scare all attacking monsters inside sanctuary, and make

                    if(you.can_see(mon))

                    if (you.can_see(mon))

                else if (mon->add_ench(mon_enchant(ENCH_FEAR, 0, KC_YOU)))

                else if (mons_is_influenced_by_sanctuary(mon))

                    behaviour_event(mon, ME_SCARE, MHITYOU);

                    mons_start_fleeing_from_sanctuary(mon);

                    // Check to see that monster is actually fleeing,
                    // since plants can't flee.

                    // Check to see that monster is actually fleeing.

        } // if (monster != NON_MONSTER)

        }

/* ***********************************************************************
 * called from: monstuff beam effects fight view
 * *********************************************************************** */
void behaviour_event(monsters *mon, int event_type, int src = MHITNOT,
                     coord_def src_pos = coord_def() );

void behaviour_event(monsters *mon, mon_event_type event_type,
                     int src = MHITNOT, coord_def src_pos = coord_def());

/* ***********************************************************************
 * called from: fight - it_use3 - spells
 * *********************************************************************** */

        if (monster->type != -1

        if (monster->alive()

void behaviour_event(monsters *mon, int event, int src,

void behaviour_event(monsters *mon, mon_event_type event, int src,

    beh_type old_behaviour = mon->behaviour;

    const beh_type old_behaviour = mon->behaviour;

    if (is_sanctuary(mon->pos()) && mons_is_fleeing_sanctuary(mon))
    {
        mon->behaviour = BEH_FLEE;
        mon->foe = MHITYOU;
        mon->target = env.sanctuary_pos;
        return;
    }

        // Now set target x, y so that monster can whack
        // back (once) at an invisible foe.

        // Now set target so that monster can whack back (once) at an
        // invisible foe.

    {
        const bool flee_sanct = !mons_wont_attack(mon)
                                && is_sanctuary(mon->pos());
        // Stationary monsters can't flee, even from sanctuary.

        // Stationary monsters can't flee.

        // Berserking monsters don't flee, unless it's from sanctuary.
        if (mon->has_ench(ENCH_BERSERK) && !flee_sanct)

        // Berserking monsters don't flee.
        if (mon->has_ench(ENCH_BERSERK))

        // Neither do plants or nonliving beings, and sanctuary doesn't
        // affect plants.

        // Neither do plants or nonliving beings.

            || (mons_class_holiness(mon->type) == MH_NONLIVING && !flee_sanct))

            || mons_class_holiness(mon->type) == MH_NONLIVING)

    }

            break;
        // Don't stop fleeing from sanctuary.
        if (!mons_wont_attack(mon) && is_sanctuary(mon->pos()))

    default:

        return;
    }
    if (mons_is_fleeing_sanctuary(mon)
        && mons_is_fleeing(mon)
        && is_sanctuary(you.pos()))
    {

    if (is_sanctuary(monster->pos()) && !mons_friendly(monster)
        && !mons_is_fleeing(monster)
        && monster->add_ench(mon_enchant(ENCH_FEAR, 0, KC_YOU)))

    if (is_sanctuary(monster->pos())
        && mons_is_influenced_by_sanctuary(monster)
        && !mons_is_fleeing_sanctuary(monster))

        behaviour_event(monster, ME_SCARE, MHITNOT, monster->pos());

        mons_start_fleeing_from_sanctuary(monster);

    else if (mons_is_fleeing(monster) && inside_level_bounds(env.sanctuary_pos)
             && !is_sanctuary(monster->pos())
             && monster->target == env.sanctuary_pos)

    else if (mons_is_fleeing_sanctuary(monster)
             && !is_sanctuary(monster->pos()))

            || random2(5) > 2)

            || x_chance_in_y(2, 5))

            monster->del_ench(ENCH_FEAR);

            mons_stop_fleeing_from_sanctuary(monster);

    ME_SHOT,                            // attack at range

bool mons_is_influenced_by_sanctuary(const monsters *m);
bool mons_is_fleeing_sanctuary(const monsters *m);

void mons_start_fleeing_from_sanctuary(monsters *monster);
void mons_stop_fleeing_from_sanctuary(monsters *monster);

}
bool mons_is_influenced_by_sanctuary(const monsters *m)
{
    return (!mons_wont_attack(m)
            && mons_holiness(m) != MH_PLANT
            && !mons_is_stationary(m));

bool mons_is_fleeing_sanctuary(const monsters *m)
{
    return (mons_is_influenced_by_sanctuary(m)
            && inside_level_bounds(env.sanctuary_pos)
            && (m->flags & MF_FLEEING_FROM_SANCTUARY));
}

void mons_start_fleeing_from_sanctuary(monsters *monster)
{
    monster->flags |= MF_FLEEING_FROM_SANCTUARY;
    monster->target = env.sanctuary_pos;
    behaviour_event(monster, ME_SCARE, MHITNOT, env.sanctuary_pos);
}
void mons_stop_fleeing_from_sanctuary(monsters *monster)
{
    const bool had_flag = (monster->flags & MF_FLEEING_FROM_SANCTUARY);
    monster->flags &= (~MF_FLEEING_FROM_SANCTUARY);
    if (had_flag)
        behaviour_event(monster, ME_EVAL, MHITYOU);
}

    MF_GOD_GIFT           = 0x40000  // Is a god gift.

    MF_GOD_GIFT           = 0x40000, // Is a god gift.
    MF_FLEEING_FROM_SANCTUARY = 0x80000 // Is running away from player sanctuary