bool exclude_center = false );

                     bool exclude_center = false,
                     const env_show_grid* losgrid = NULL );

    const env_show_grid* losgrid;

radius_iterator::radius_iterator( const coord_def& _center, int _radius,
                                  bool _roguelike_metric, bool _require_los,
                                  bool _exclude_center )

radius_iterator::radius_iterator(const coord_def& _center, int _radius,
                                 bool _roguelike_metric, bool _require_los,
                                 bool _exclude_center,
                                 const env_show_grid* _losgrid)

      iter_done(false)

      losgrid(_losgrid), iter_done(false)

    if (require_los && !see_grid(location))
        return (false);

    if (require_los)
    {
        if (!losgrid && !see_grid(location))
            return (false);
        if (losgrid && !see_grid(*losgrid, center, location))
            return (false);
    }

// Note that quiet will *not* suppress the message about a corpse
// you are butchering being animated.

                if (!quiet)
                {
                    if (was_butchering)
                        mpr("The corpse you are butchering rises to attack!");

                // ignores quiet
                if (was_butchering)
                    mpr("The corpse you are butchering rises to attack!");

                    if (see_grid(a))
                        mpr("The dead are walking!");
                }

                if (!quiet && see_grid(a))
                    mpr("The dead are walking!");

    static env_show_grid losgrid;
    const coord_def c(caster->pos());

    int minx = c.x - 6;
    int maxx = c.x + 7;
    int miny = c.y - 6;
    int maxy = c.y + 7;
    int xinc = 1;
    int yinc = 1;

    // Use an alternate LOS grid, based on the caster's LOS.
    env_show_grid losgrid;
    if (caster->atype() != ACT_PLAYER)
        losight(losgrid, grd, caster->pos(), true);

    if (coinflip())
    {
        minx = c.x + 6;
        maxx = c.x - 7;
        xinc = -1;
    }

    radius_iterator ri(caster->pos(), 6, true, true, false,
                       caster->atype() == ACT_PLAYER ? &env.no_trans_show
                                                     : &losgrid);

    if (coinflip())

    // Sweep all squares in LOS.
    for (; ri; ++ri)

        miny = c.y + 6;
        maxy = c.y - 7;
        yinc = -1;
    }
    if (caster != &you)
        losight(losgrid, grd, c, true);
    env_show_grid &los(caster == &you? env.no_trans_show : losgrid);
    coord_def a;
    for (a.x = minx; a.x != maxx; a.x += xinc)
    {
        for (a.y = miny; a.y != maxy; a.y += yinc)

        // This will produce a message if the corpse you are butchering
        // is raised.
        if (animate_remains(*ri, CORPSE_BODY, beha, hitting, god,
                            actual, true) > 0)

            if (!in_bounds(a) || !see_grid(los, c, a))
                continue;
            // Search all the items on the ground for a corpse.  Only
            // one of a stack will be raised.
            for (stack_iterator si(a); si; ++si)
            {
                const bool was_butchering = is_being_butchered(*si, false);
                if (animate_remains(a, CORPSE_BODY, beha, hitting, god,
                                    actual, true) > 0)
                {
                    number_raised++;
                    if (see_grid(a))
                         number_seen++;
                    if (was_butchering)
                        mpr("The corpse you are butchering rises to attack!");
                    break;
                }
            }

            number_raised++;
            if (see_grid(*ri))
                number_seen++;

    int how_many_max = std::min(8, 4 + random2(pow) / 20);

    bool rc = false;
    const item_def* weapon = you.weapon();

    const int chunk = you.equip[EQ_WEAPON];
    if (chunk != -1
        && is_valid_item(you.inv[chunk])
        && (you.inv[chunk].base_type == OBJ_CORPSES
            || (you.inv[chunk].base_type == OBJ_FOOD
                && you.inv[chunk].sub_type == FOOD_CHUNK)))

    if (weapon
        && (weapon->base_type == OBJ_CORPSES
            || (weapon->base_type == OBJ_FOOD
                && weapon->sub_type == FOOD_CHUNK)))

        const monster_type mon =
            static_cast<monster_type>(you.inv[chunk].plus);

        const monster_type mon = static_cast<monster_type>(weapon->plus);

        if (you.inv[chunk].quantity < how_many_max)
            how_many_max = you.inv[chunk].quantity;

        int how_many = std::min(8, 4 + random2(pow) / 20);
        how_many = std::min<int>(how_many, weapon->quantity);

        dec_inv_item_quantity(chunk, how_many_max);

        dec_inv_item_quantity(you.equip[EQ_WEAPON], how_many);

        for (int i = 0; i < how_many_max; ++i)

        for (int i = 0; i < how_many; ++i)

            return (true);

            rc = true;

        mpr("You feel cold for a second.");
        return (false);

        else
            mpr("You feel cold for a second.");
    }
    else
    {
        mpr("You need to wield a piece of raw flesh for this spell to be "
            "effective!");

    mpr("You need to wield a piece of raw flesh for this spell to be "
        "effective!");
    return (false);

    return (rc);

}
void stop_butcher_delay()
{
    if (current_delay_action() == DELAY_BUTCHER
        || current_delay_action() == DELAY_BOTTLE_BLOOD
        || current_delay_action() == DELAY_OFFER_CORPSE)
    {
        stop_delay();
    }

}
void stop_butcher_delay()
{
    if (_is_butcher_delay(current_delay_action()))
        stop_delay();