|| s_type != S_SILENT && (silenced(you.pos())
                                  || silenced(monster->pos())))

        || s_type != S_SILENT && player_can_hear(monster->pos()))

    stack_iterator( const coord_def& pos );
    stack_iterator( int start_link );

    explicit stack_iterator( const coord_def& pos );
    explicit stack_iterator( int start_link );

    adjacent_iterator( const coord_def& pos = you.pos(),
                       bool _exclude_center = true ) :

    explicit adjacent_iterator( const coord_def& pos = you.pos(),
                                bool _exclude_center = true ) :

bool player_can_hear(int x, int y);
inline bool player_can_hear(const coord_def &p)
{
    return player_can_hear(p.x, p.y);
}

bool player_can_hear(const coord_def& p);

bool player_can_hear(int x, int y)

bool player_can_hear(const coord_def& p)

    return (!silenced(coord_def(x, y)) && !silenced(you.pos()));

    return (!silenced(p) && !silenced(you.pos()));

//* * called from: acr

void       init_spell_name_cache();

void init_spell_name_cache();

// * called from: spell

// * called from: it_use3 - spell - spells3

// * called from: chardump - it_use3 - player - spell - spl-book -
// *              spells0 - spells3

// * called from: chardump - spell - spl-book - spells0

// * called from: chardump - command - debug - spl-book - spells0

//int spell_restriction(int which_spell, int which_restriction);
int apply_area_visible(int (*func) (int, int, int, int), int power,

typedef int cell_func(coord_def where, int pow, int aux);
int apply_area_visible(cell_func cf, int power,

int apply_area_square(int (*func) (int, int, int, int),
                              int cx, int cy, int power);

int apply_area_square(cell_func cf, const coord_def& where, int power);

int apply_area_around_square( int (*func) (int, int, int, int),
                              int targ_x, int targ_y, int power );

int apply_area_around_square(cell_func cf, const coord_def& where, int power );

int apply_random_around_square( int (*func) (int, int, int, int),
                                int targ_x, int targ_y, bool hole_in_middle,
                                int power, int max_targs );

int apply_random_around_square( cell_func cf, const coord_def& where,
                                bool hole_in_middle, int power, int max_targs );

int apply_one_neighbouring_square(int (*func) (int, int, int, int),
                                          int power);

int apply_one_neighbouring_square(cell_func cf, int power);

int apply_area_within_radius(int (*func) (int, int, int, int),
                              int x, int y, int pow, int radius, int ctype);

int apply_area_within_radius(cell_func cf,  const coord_def& where,
                             int pow, int radius, int ctype);

int apply_area_visible( int (*func) (int, int, int, int), int power,
                        bool pass_through_trans)

int apply_area_visible( cell_func cf, int power, bool pass_through_trans)

    int x, y;

    //jmf: FIXME: randomly start from other quadrants, like raise_dead?
    for (x = you.x_pos - 8; x <= you.x_pos + 8; x++)
    {
        for (y = you.y_pos - 8; y <= you.y_pos + 8; y++)
        {
            if ((pass_through_trans && see_grid(x, y))
                 || (!pass_through_trans && see_grid_no_trans(x, y)))
                rv += func(x, y, power, 0);
        }
    }

    for (radius_iterator ri(you.pos(), LOS_RADIUS); ri; ++ri)
        if ( pass_through_trans || see_grid_no_trans(*ri) )
            rv += cf(*ri, power, 0);

int apply_area_square( int (*func) (int, int, int, int), int cx, int cy,
                        int power )

int apply_area_square( cell_func cf, const coord_def& where, int power )

    int x, y;

    for (x = cx - 1; x <= cx + 1; x++)
        for (y = cy - 1; y <= cy + 1; y++)
            rv += func(x, y, power, 0);

    for (adjacent_iterator ai(where, false); ai; ++ai)
        rv += cf(*ai, power, 0);

int apply_area_around_square( int (*func) (int, int, int, int),
                              int targ_x, int targ_y, int power)

int apply_area_around_square( cell_func cf, const coord_def& where, int power)

    int x, y;

    for (x = targ_x - 1; x <= targ_x + 1; x++)
        for (y = targ_y - 1; y <= targ_y + 1; y++)
        {
            if (x == targ_x && y == targ_y)
                continue;
            else
                rv += func(x, y, power, 0);
        }

    for (adjacent_iterator ai(where, true); ai; ++ai)
        rv += cf(*ai, power, 0);

int apply_random_around_square( int (*func) (int, int, int, int),
                                int targ_x, int targ_y,
                                bool hole_in_middle, int power, int max_targs )

int apply_random_around_square( cell_func cf, const coord_def& where,
                                bool exclude_center, int power, int max_targs )

    if (max_targs >= 9 && !hole_in_middle)
        return (apply_area_square( func, targ_x, targ_y, power ));

    if (max_targs >= 9 && !exclude_center)
        return (apply_area_square( cf, where, power ));

    if (max_targs >= 8 && hole_in_middle)
        return (apply_area_around_square( func, targ_x, targ_y, power ));

    if (max_targs >= 8 && exclude_center)
        return (apply_area_around_square( cf, where, power ));

    FixedVector< coord_def, 8 > targs;

    coord_def targs[8];

    for (int x = targ_x - 1; x <= targ_x + 1; x++)

    for (adjacent_iterator ai(where, exclude_center); ai; ++ai)

        for (int y = targ_y - 1; y <= targ_y + 1; y++)
        {
            if (hole_in_middle && (x == targ_x && y == targ_y))
                continue;
            if (mgrd[x][y] == NON_MONSTER
                && !(x == you.x_pos && y == you.y_pos))
            {
                continue;
            }

        if (mgrd(*ai) == NON_MONSTER && *ai != you.pos())
            continue;

            // Found target
            count++;

        // Found target
        count++;

            // Slight difference here over the basic algorithm...
            //
            // For cases where the number of choices <= max_targs it's
            // obvious (all available choices will be selected).
            //
            // For choices > max_targs, here's a brief proof:
            //
            // Let m = max_targs, k = choices - max_targs, k > 0.
            //
            // Proof, by induction (over k):
            //
            // 1) Show n = m + 1 (k = 1) gives uniform distribution,
            //    P(new one not chosen) = 1 / (m + 1).
            //                                         m     1     1
            //    P(specific previous one replaced) = --- * --- = ---
            //                                        m+1    m    m+1
            //
            //    So the probablity is uniform (ie. any element has
            //    a 1/(m+1) chance of being in the unchosen slot).
            //
            // 2) Assume the distribution is uniform at n = m+k.
            //    (ie. the probablity that any of the found elements
            //     was chosen = m / (m+k) (the slots are symetric,
            //     so it's the sum of the probabilities of being in
            //     any of them)).
            //
            // 3) Show n = m + k + 1 gives a uniform distribution.
            //    P(new one chosen) = m / (m + k + 1)
            //    P(any specific previous choice remaining chosen)
            //    = [1 - P(swaped into m+k+1 position)] * P(prev. chosen)
            //              m      1       m
            //    = [ 1 - ----- * --- ] * ---
            //            m+k+1    m      m+k
            //
            //       m+k     m       m
            //    = ----- * ---  = -----
            //      m+k+1   m+k    m+k+1
            //
            // Therefore, it's uniform for n = m + k + 1.  QED
            //
            // The important thing to note in calculating the last
            // probability is that the chosen elements have already
            // passed tests which verify that they *don't* belong
            // in slots m+1...m+k, so the only positions an already
            // chosen element can end up in are its original
            // position (in one of the chosen slots), or in the
            // new slot.
            //
            // The new item can, of course, be placed in any slot,
            // swapping the value there into the new slot... we
            // just don't care about the non-chosen slots enough
            // to store them, so it might look like the item
            // automatically takes the new slot when not chosen
            // (although, by symetry all the non-chosen slots are
            // the same... and similarly, by symetry, all chosen
            // slots are the same).
            //
            // Yes, that's a long comment for a short piece of
            // code, but I want people to have an understanding
            // of why this works (or at least make them wary about
            // changing it without proof and breaking this code). -- bwr

        // Slight difference here over the basic algorithm...
        //
        // For cases where the number of choices <= max_targs it's
        // obvious (all available choices will be selected).
        //
        // For choices > max_targs, here's a brief proof:
        //
        // Let m = max_targs, k = choices - max_targs, k > 0.
        //
        // Proof, by induction (over k):
        //
        // 1) Show n = m + 1 (k = 1) gives uniform distribution,
        //    P(new one not chosen) = 1 / (m + 1).
        //                                         m     1     1
        //    P(specific previous one replaced) = --- * --- = ---
        //                                        m+1    m    m+1
        //
        //    So the probablity is uniform (ie. any element has
        //    a 1/(m+1) chance of being in the unchosen slot).
        //
        // 2) Assume the distribution is uniform at n = m+k.
        //    (ie. the probablity that any of the found elements
        //     was chosen = m / (m+k) (the slots are symetric,
        //     so it's the sum of the probabilities of being in
        //     any of them)).
        //
        // 3) Show n = m + k + 1 gives a uniform distribution.
        //    P(new one chosen) = m / (m + k + 1)
        //    P(any specific previous choice remaining chosen)
        //    = [1 - P(swaped into m+k+1 position)] * P(prev. chosen)
        //              m      1       m
        //    = [ 1 - ----- * --- ] * ---
        //            m+k+1    m      m+k
        //
        //       m+k     m       m
        //    = ----- * ---  = -----
        //      m+k+1   m+k    m+k+1
        //
        // Therefore, it's uniform for n = m + k + 1.  QED
        //
        // The important thing to note in calculating the last
        // probability is that the chosen elements have already
        // passed tests which verify that they *don't* belong
        // in slots m+1...m+k, so the only positions an already
        // chosen element can end up in are its original
        // position (in one of the chosen slots), or in the
        // new slot.
        //
        // The new item can, of course, be placed in any slot,
        // swapping the value there into the new slot... we
        // just don't care about the non-chosen slots enough
        // to store them, so it might look like the item
        // automatically takes the new slot when not chosen
        // (although, by symetry all the non-chosen slots are
        // the same... and similarly, by symetry, all chosen
        // slots are the same).
        //
        // Yes, that's a long comment for a short piece of
        // code, but I want people to have an understanding
        // of why this works (or at least make them wary about
        // changing it without proof and breaking this code). -- bwr

            // Accept the first max_targs choices, then when
            // new choices come up, replace one of the choices
            // at random, max_targs/count of the time (the rest
            // of the time it replaces an element in an unchosen
            // slot -- but we don't care about them).
            if (count <= max_targs)
            {
                targs[ count - 1 ].x = x;
                targs[ count - 1 ].y = y;
            }
            else if (x_chance_in_y(max_targs, count))
            {
                const int pick = random2( max_targs );
                targs[ pick ].x = x;
                targs[ pick ].y = y;
            }

        // Accept the first max_targs choices, then when
        // new choices come up, replace one of the choices
        // at random, max_targs/count of the time (the rest
        // of the time it replaces an element in an unchosen
        // slot -- but we don't care about them).
        if (count <= max_targs)
        {
            targs[ count - 1 ] = *ai;
        }
        else if (x_chance_in_y(max_targs, count))
        {
            const int pick = random2( max_targs );
            targs[ pick ] = *ai;

    const int targs_found = (count < max_targs) ? count : max_targs;

    const int targs_found = std::min(count, max_targs);

            ASSERT( targs[i].x && targs[i].y );
            rv += func( targs[i].x, targs[i].y, power, 0 );

            ASSERT( !targs[i].origin() );
            rv += cf( targs[i], power, 0 );

}                               // end apply_random_around_square()

}

int apply_one_neighbouring_square(int (*func) (int, int, int, int), int power)

int apply_one_neighbouring_square(cell_func cf, int power)

    struct dist bmove;

    dist bmove;

    int rv = func(you.x_pos + bmove.dx, you.y_pos + bmove.dy, power, 1);

    int rv = cf(coord_def(you.x_pos + bmove.dx, you.y_pos + bmove.dy),
                power, 1);

int apply_area_within_radius( int (*func) (int, int, int, int),
                              int x, int y, int pow, int radius, int ctype )

int apply_area_within_radius( cell_func cf, const coord_def& where,
                              int pow, int radius, int ctype )

    int ix, iy;
    int sq_radius = radius * radius;
    int sx, sy, ex, ey;       // start and end x, y - bounds checked
    int rv = 0;
    // begin x,y
    sx = x - radius;
    sy = y - radius;
    if (sx < 0) sx = 0;
    if (sy < 0) sy = 0;

    // end x,y
    ex = x + radius;
    ey = y + radius;
    if (ex > GXM) ex = GXM;
    if (ey > GYM) ey = GYM;

    int rv = 0;

    for (ix = sx; ix < ex; ix++)
    {
        for (iy = sy; iy < ey; iy++)
        {
            if (distance(x, y, ix, iy) <= sq_radius)
                rv += func(ix, iy, pow, ctype);
        }
    }

    for ( radius_iterator ri(where, radius, false, false); ri; ++ri )
        rv += cf(*ri, pow, ctype);

}                               // end apply_area_within_radius()

}

        holy_word(50, HOLY_WORD_SPELL, you.x_pos, you.y_pos, true);

        holy_word(50, HOLY_WORD_SPELL, you.pos(), true);

        torment(TORMENT_SPELL, you.x_pos, you.y_pos);

        torment(TORMENT_SPELL, you.pos());

            torment_monsters(you.x_pos, you.y_pos, 0, TORMENT_GENERIC);

            torment_monsters(you.pos(), 0, TORMENT_GENERIC);

bool backlight_monsters(int x, int y, int pow, int garbage);

bool backlight_monsters(coord_def where, int pow, int garbage);

int disperse_monsters(int x, int y, int pow, int message);

int disperse_monsters(coord_def where, int pow, int message);

static int _make_a_rot_cloud(int x, int y, int pow, cloud_type ctype);
static int _quadrant_blink(int x, int y, int pow, int garbage);

static int _make_a_rot_cloud(const coord_def& where, int pow, cloud_type ctype);
static int _quadrant_blink(coord_def where, int pow, int garbage);

static int _shatter_monsters(int x, int y, int pow, int garbage)

static int _shatter_monsters(coord_def where, int pow, int garbage)

    const int  monster = mgrd[x][y];

    const int  monster = mgrd(where);

static int _shatter_items(int x, int y, int pow, int garbage)

static int _shatter_items(coord_def where, int pow, int garbage)

    int broke_stuff = 0, next, obj = igrd[x][y];

    int broke_stuff = 0;

    if (obj == NON_ITEM)
        return 0;
    while (obj != NON_ITEM)

    for ( stack_iterator si(where); si; ++si )

        next = mitm[obj].link;
        switch (mitm[obj].base_type)

        if (si->base_type == OBJ_POTIONS && !one_chance_in(10))

        case OBJ_POTIONS:
            if (!one_chance_in(10))
            {
                broke_stuff++;
                destroy_item(obj);
            }
            break;
        default:
            break;

            broke_stuff++;
            destroy_item(si->index());

        obj = next;

        if (!silenced(coord_def(x, y)) && !silenced(you.pos()))

        if (player_can_hear(where))

static int _shatter_walls(int x, int y, int pow, int garbage)

static int _shatter_walls(coord_def where, int pow, int garbage)

    if (x <= 5 || x >= GXM - 5 || y <= 5 || y >= GYM - 5)
        return (0);

    if ( !in_bounds(where) )
        return 0;

    switch (grd[x][y])

    switch (grd(where))

        if (see_grid(x, y))

        if (see_grid(where))

        grd[x][y] = DNGN_FLOOR;

        grd(where) = DNGN_FLOOR;

        if (see_grid(x, y))

        if (see_grid(where))

        grd[x][y] = DNGN_FLOOR;

        grd(where) = DNGN_FLOOR;

        noisy(30, coord_def(x, y));

        noisy(30, where);

        grd[x][y] = DNGN_FLOOR;

        grd(where) = DNGN_FLOOR;

    apply_area_within_radius(_shatter_items, you.x_pos, you.y_pos,
                             pow, rad, 0);
    apply_area_within_radius(_shatter_monsters, you.x_pos, you.y_pos,
                             pow, rad, 0);
    int dest = apply_area_within_radius( _shatter_walls, you.x_pos, you.y_pos,

    apply_area_within_radius(_shatter_items, you.pos(), pow, rad, 0);
    apply_area_within_radius(_shatter_monsters, you.pos(), pow, rad, 0);
    int dest = apply_area_within_radius( _shatter_walls, you.pos(),

static int _sleep_monsters(int x, int y, int pow, int garbage)

static int _sleep_monsters(coord_def where, int pow, int garbage)

    const int mnstr = mgrd[x][y];

    const int mnstr = mgrd(where);

static int _tame_beast_monsters(int x, int y, int pow, int garbage)

static int _tame_beast_monsters(coord_def where, int pow, int garbage)

    const int which_mons = mgrd[x][y];

    const int which_mons = mgrd(where);

static int _ignite_poison_objects(int x, int y, int pow, int garbage)

static int _ignite_poison_objects(coord_def where, int pow, int garbage)

    int obj = igrd[x][y], next, strength = 0;

    int strength = 0;

    if (obj == NON_ITEM)
        return (0);
    while (obj != NON_ITEM)

    for ( stack_iterator si(where); si; ++si )

        next = mitm[obj].link;
        if (mitm[obj].base_type == OBJ_POTIONS)

        if (si->base_type == OBJ_POTIONS)

            switch (mitm[obj].sub_type)

            switch (si->sub_type)

                destroy_item(obj);

                destroy_item(si->index());

        // else if ( it's ammo that's poisoned) {
        //   strength += number_of_ammo;
        //   destroy_item(ammo);
        //  }
        obj = next;

        place_cloud(CLOUD_FIRE, coord_def(x, y),

        place_cloud(CLOUD_FIRE, where,

static int _ignite_poison_clouds( int x, int y, int pow, int garbage )

static int _ignite_poison_clouds( coord_def where, int pow, int garbage )

    const int cloud = env.cgrid[x][y];

    const int cloud = env.cgrid(where);

static int _ignite_poison_monsters(int x, int y, int pow, int garbage)

static int _ignite_poison_monsters(coord_def where, int pow, int garbage)

    struct bolt beam;

    bolt beam;

    const int mon_index = mgrd[x][y];

    const int mon_index = mgrd(where);

static int _discharge_monsters( int x, int y, int pow, int garbage )

static int _discharge_monsters( coord_def where, int pow, int garbage )

    const int mon = mgrd[x][y];

    const int mon = mgrd(where);

    struct bolt beam;

    bolt beam;

    if (x == you.x_pos && y == you.y_pos)

    if (where == you.pos())

        damage += apply_random_around_square( _discharge_monsters, x, y,

        damage += apply_random_around_square( _discharge_monsters, where,

    dam = apply_random_around_square( _discharge_monsters, you.x_pos, you.y_pos,

    dam = apply_random_around_square( _discharge_monsters, you.pos(),

static int _distortion_monsters(int x, int y, int pow, int message)

static int _distortion_monsters(coord_def where, int pow, int message)

    int specdam = 0;
    int monster_attacked = mgrd[x][y];
    if (monster_attacked == NON_MONSTER)
        return 0;
    struct monsters *defender = &menv[monster_attacked];

    if (x == you.x_pos && y == you.y_pos)

    if (where == you.pos())

    int monster_attacked = mgrd(where);
    if (monster_attacked == NON_MONSTER)
        return 0;
    int specdam = 0;
    monsters *defender = &menv[monster_attacked];

int disperse_monsters(int x, int y, int pow, int message)

int disperse_monsters(coord_def where, int pow, int message)

    const int monster_attacked = mgrd[x][y];

    const int monster_attacked = mgrd(where);

    struct monsters *defender = &menv[monster_attacked];

    monsters *defender = &menv[monster_attacked];

    if (apply_area_around_square( disperse_monsters,
                                  you.x_pos, you.y_pos, pow ) == 0)

    if (apply_area_around_square( disperse_monsters, you.pos(), pow ) == 0)

static int _spell_swap_func(int x, int y, int pow, int message)

static int _spell_swap_func(coord_def where, int pow, int message)

    int monster_attacked = mgrd[x][y];

    int monster_attacked = mgrd(where);

    struct monsters *defender = &menv[monster_attacked];

    monsters *defender = &menv[monster_attacked];

        int old_x = defender->x;
        int old_y = defender->y;

        coord_def old_pos = defender->pos();

            you.moveto(old_x, old_y);

            you.moveto(old_pos);

static int _make_a_rot_cloud(int x, int y, int pow, cloud_type ctype)

static int _make_a_rot_cloud(const coord_def& where, int pow, cloud_type ctype)

    for ( stack_iterator si(coord_def(x,y)); si; ++si )

    for ( stack_iterator si(where); si; ++si )

            place_cloud(ctype, coord_def(x,y),

            place_cloud(ctype, where,

static int _passwall(int x, int y, int pow, int garbage)

static int _passwall(coord_def where, int pow, int garbage)

    int x = where.x, y = where.y;

static int _intoxicate_monsters(int x, int y, int pow, int garbage)

static int _intoxicate_monsters(coord_def where, int pow, int garbage)

    int mon = mgrd[x][y];

    int mon = mgrd(where);

bool backlight_monsters(int x, int y, int pow, int garbage)

bool backlight_monsters(coord_def where, int pow, int garbage)

    int mon = mgrd[x][y];

    int mon = mgrd(where);

static int _rot_living(int x, int y, int pow, int message)

static int _rot_living(coord_def where, int pow, int message)

    int mon = mgrd[x][y];

    int mon = mgrd(where);

static int _rot_undead(int x, int y, int pow, int garbage)

static int _rot_undead(coord_def where, int pow, int garbage)

    int mon = mgrd[x][y];

    int mon = mgrd(where);

static int _rot_corpses(int x, int y, int pow, int garbage)

static int _rot_corpses(coord_def where, int pow, int garbage)

    return _make_a_rot_cloud(x, y, pow, CLOUD_MIASMA);

    return _make_a_rot_cloud(where, pow, CLOUD_MIASMA);

static int _snake_charm_monsters(int x, int y, int pow, int message)

static int _snake_charm_monsters(coord_def where, int pow, int message)

    int mon = mgrd[x][y];

    int mon = mgrd(where);

static int _quadrant_blink(int x, int y, int pow, int garbage)

static int _quadrant_blink(coord_def where, int pow, int garbage)

    if (x == you.x_pos && y == you.y_pos)

    if (where == you.pos())

    coord_def orig;
    orig.x = you.x_pos + (x - you.x_pos) * dist;
    orig.y = you.y_pos + (y - you.y_pos) * dist;

    coord_def orig = you.pos() + (where - you.pos()) * dist;

    holy_word(100, HOLY_WORD_ZIN, you.x_pos, you.y_pos, true);

    holy_word(100, HOLY_WORD_ZIN, you.pos(), true);

            holy_word(100, HOLY_WORD_SHINING_ONE, you.x_pos, you.y_pos, true);

            holy_word(100, HOLY_WORD_SHINING_ONE, you.pos(), true);

        torment(monster_index(monster), monster->x, monster->y);

        torment(monster_index(monster), monster->pos());

        player_can_hear(luaL_checkint(ls,1), luaL_checkint(ls, 2)))

        player_can_hear(coord_def(luaL_checkint(ls,1), luaL_checkint(ls, 2))))

        torment_monsters(you.x_pos, you.y_pos, 0, TORMENT_GENERIC);

        torment_monsters(you.pos(), 0, TORMENT_GENERIC);

        torment( TORMENT_SCROLL, you.x_pos, you.y_pos );

        torment( TORMENT_SCROLL, you.pos() );

        if (!holy_word(pow, HOLY_WORD_SCROLL, you.x_pos, you.y_pos,

        if (!holy_word(pow, HOLY_WORD_SCROLL, you.pos(),

            torment(TORMENT_SPWLD, you.x_pos, you.y_pos);

            torment(TORMENT_SPWLD, you.pos());

        torment(TORMENT_SPWLD, you.x_pos, you.y_pos);

        torment(TORMENT_SPWLD, you.pos());

int holy_word(int pow, int caster, int x, int y, bool silent);

int holy_word(int pow, int caster, const coord_def& where, bool silent);

int holy_word_monsters(int x, int y, int pow, int caster);

int holy_word_monsters(coord_def where, int pow, int caster);

int torment(int caster, int x, int y);

int torment(int caster, const coord_def& where);

int torment_monsters(int x, int y, int pow, int caster);

int torment_monsters(coord_def where, int pow, int caster);

int holy_word_monsters(int x, int y, int pow, int caster)

int holy_word_monsters(coord_def where, int pow, int caster)

    if (x == you.x_pos && y == you.y_pos)

    if (where == you.pos())

    int mon = mgrd[x][y];

    int mon = mgrd(where);

int holy_word(int pow, int caster, int x, int y, bool silent)

int holy_word(int pow, int caster, const coord_def& where, bool silent)

    return apply_area_within_radius(holy_word_monsters, x, y, pow, 8, caster);

    return apply_area_within_radius(holy_word_monsters, where, pow, 8, caster);

int torment_monsters(int x, int y, int pow, int caster)

int torment_monsters(coord_def where, int pow, int caster)

    if (x == you.x_pos && y == you.y_pos)

    if (where == you.pos())

    int mon = mgrd[x][y];

    int mon = mgrd(where);

int torment(int caster, int x, int y)

int torment(int caster, const coord_def& where)

    return apply_area_within_radius(torment_monsters, x, y, 0, 8, caster);

    return apply_area_within_radius(torment_monsters, where, 0, 8, caster);

static int _recite_to_monsters(int x, int y, int pow, int unused)

static int _recite_to_monsters(coord_def where, int pow, int unused)

    const int mon = mgrd[x][y];

    const int mon = mgrd(where);

static int _drain_monsters(int x, int y, int pow, int garbage)

static int _drain_monsters(coord_def where, int pow, int garbage)

    if (coord_def(x,y) == you.pos())

    if (where == you.pos())

        const int mnstr = mgrd[x][y];

        const int mnstr = mgrd(where);

    case CARD_TORMENT: torment(TORMENT_CARDS, you.x_pos, you.y_pos); break;

    case CARD_TORMENT: torment(TORMENT_CARDS, you.pos()); break;

        if (backlight_monsters(mon->x, mon->y, beam.hit, 0))

        if (backlight_monsters(mon->pos(), beam.hit, 0))

        torment(TORMENT_GENERIC, you.x_pos, you.y_pos);

        torment(TORMENT_GENERIC, you.pos());

        torment(TORMENT_GENERIC, you.x_pos, you.y_pos);

        torment(TORMENT_GENERIC, you.pos());

static int _lugonu_warp_monster(int x, int y, int pow, int)

static int _lugonu_warp_monster(coord_def where, int pow, int)

    if (!in_bounds(x, y) || mgrd[x][y] == NON_MONSTER)

    if (!in_bounds(where) || mgrd(where) == NON_MONSTER)

    monsters &mon = menv[ mgrd[x][y] ];

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

    apply_area_around_square( _lugonu_warp_monster, you.x_pos, you.y_pos, pow );

    apply_area_around_square( _lugonu_warp_monster, you.pos(), pow );