if (crawl_state.arena)
        arena_monster_died(monster, killer, killer_index, silent);

    int corpse = -1;

            place_monster_corpse(monster, silent);

            corpse = place_monster_corpse(monster, silent);

    if (crawl_state.arena)
        arena_monster_died(monster, killer, killer_index, silent, corpse);

    {

        for (int i = 0; i < NUM_MONSTER_SLOTS; i++)
        {
            int item = monster->inv[i];

        monster->destroy_inventory();

            if (item != NON_ITEM)
            {
                destroy_item(item);
                monster->inv[i] = NON_ITEM;
            }
        }
    }

        // Don't fight test spawners, since they're only pseduo-monsters
        // placed to spawn real monsters, plus they're impossible to kill.
        // But test spawners can fight each other, to give them a target o
        // spawn against.
        if (other->type == MONS_TEST_SPAWNER
            && mons->type != MONS_TEST_SPAWNER)
        {
            continue;
        }

                        int killer_index, bool silent);

                        int killer_index, bool silent, int corpse);

#define DEBUG_DIAGNOSTICS 1

    int turns       = 0;

    bool allow_animate       = true;

    bool do_move_spawners    = false;

    bool move_summons        = false;
    int  summon_throttle     = INT_MAX;

    std::vector<int> spawner_list;

    std::vector<int> a_spawners;
    std::vector<int> b_spawners;

    int item_drop_times[MAX_ITEMS];

    void zap_summons(monsters* mons)

    void adjust_spells(monsters* mons, bool no_summons, bool no_animate)

            if (spell_typematch(sp, SPTYP_SUMMONING))

            if (no_summons && spell_typematch(sp, SPTYP_SUMMONING))
                spells[i] = SPELL_NO_SPELL;
            else if (no_animate && sp == SPELL_ANIMATE_DEAD)

        if (!allow_summons)

        if (!allow_summons || !allow_animate)

                zap_summons(mons);

                adjust_spells(mons, !allow_summons, !allow_animate);

        spawner_list.clear();

        turns = 0;

        a_spawners.clear();
        b_spawners.clear();
        bzero(item_drop_times, sizeof(item_drop_times));

        allow_summons    = !strip_tag(spec, "no_summons");
        allow_immobile   = !strip_tag(spec, "no_immobile");
        allow_bands      = !strip_tag(spec, "no_bands");
        allow_zero_xp    =  strip_tag(spec, "allow_zero_xp");
        real_summons     =  strip_tag(spec, "real_summons");
        do_move_spawners =  strip_tag(spec, "move_spawners");

        allow_summons   = !strip_tag(spec, "no_summons");
        allow_animate   = !strip_tag(spec, "no_animate");
        allow_immobile  = !strip_tag(spec, "no_immobile");
        allow_bands     = !strip_tag(spec, "no_bands");
        allow_zero_xp   =  strip_tag(spec, "allow_zero_xp");
        real_summons    =  strip_tag(spec, "real_summons");
        move_summons    =  strip_tag(spec, "move_summons");
        summon_throttle = strip_number_tag(spec, "summon_throttle:");

        if (summon_throttle <= 0)
            summon_throttle = INT_MAX;

    // Move test spawners to a new position every turn to scatter each
    // faction all over the arena.
    void move_spawners()

    // Try to prevent random luck from letting one spawner fill up the
    // arena with so many monsters that the other spawner can never get
    // back on even footing.
    void balance_spawners()

        if (!do_move_spawners)

        if (a_spawners.size() == 0 || b_spawners.size() == 0)

        for (unsigned int i = 0; i < spawner_list.size(); i++)

        for (unsigned int i = 0; i < a_spawners.size(); i++)

            monsters* mon = &menv[spawner_list[i]];

            int idx = a_spawners[i];
            menv[idx].speed_increment *= faction_b.active_members;
            menv[idx].speed_increment /= faction_a.active_members;
        }

            if (!mon->alive() || mon->type != MONS_TEST_SPAWNER)
                continue;
            monster_teleport(mon, true, true);

        for (unsigned int i = 0; i < b_spawners.size(); i++)
        {
            int idx = b_spawners[i];
            menv[idx].speed_increment *= faction_a.active_members;
            menv[idx].speed_increment /= faction_b.active_members;

            int turns = 0;

                move_spawners();

                balance_spawners();

    if (mg.abjuration_duration > 0)
    {
        if (mg.behaviour == BEH_FRIENDLY
            && arena::faction_a.active_members > arena::summon_throttle)
        {
            return (true);
        }
        else if (mg.behaviour == BEH_HOSTILE
                 && arena::faction_b.active_members > arena::summon_throttle)
        {
            return (true);
        }
        
    }

        arena::spawner_list.push_back(monster->mindex());

    {
        if (monster->attitude == ATT_FRIENDLY)
            arena::a_spawners.push_back(monster->mindex());
        else if (monster->attitude == ATT_HOSTILE)
            arena::b_spawners.push_back(monster->mindex());
    }

    mprf("%s enters the arena!", monster->name(DESC_CAP_A).c_str());

    mprf("%s enters the arena!", monster->full_name(DESC_CAP_A, true).c_str());

            // Set the "drop" time here in case the monster drops the item
            // without dying, like being polymorphed.
            arena::item_drop_times[it] = arena::turns;

        if (!arena::allow_chain_summons)
            arena::zap_summons(monster);

        if (arena::move_summons)
            monster_teleport(monster, true, true);
        if (!arena::allow_chain_summons || !arena::allow_animate)
            arena::adjust_spells(monster, !arena::allow_chain_summons,
                                 !arena::allow_animate);

                        int killer_index, bool silent)

                        int killer_index, bool silent, int corpse)

    if (corpse != -1 && corpse != NON_ITEM)
        arena::item_drop_times[corpse] = arena::turns;
    // Won't be dropping any items.
    if (monster->flags & MF_HARD_RESET)
        return;
    for (int i = 0; i < NUM_MONSTER_SLOTS; i++)
    {
        int idx = monster->inv[i];
        if (idx == NON_ITEM)
            continue;
        if (mitm[idx].flags & ISFLAG_SUMMONED)
            continue;
        arena::item_drop_times[idx] = arena::turns;
    }

static bool _sort_corpses(int a, int b)

static bool _sort_by_age(int a, int b)

    return (mitm[a].special < mitm[b].special);

    return (arena::item_drop_times[a] < arena::item_drop_times[b]);

    arena::item_drop_times[i] = 0; \

// Culls the items which have been on the floor the longest, culling the newest
// items last.  Items which a monster dropped voluntarily or because of
// being polymorphed, rather than because of dying, are culled earlier than
// they should be, but it's not like we have to be fair to the arena monsters.

    // Try to cull 15% of items.
    const int cull_target = MAX_ITEMS * 15 / 100;

    std::vector<int> items;

    int cull_count      = 0;
    std::vector<int> artefacts;
    std::vector<int> egos;
    std::vector<int> ammo;
    std::vector<int> wands;
    std::vector<int> potions;
    std::vector<int> scrolls;
    std::vector<int> corpses;

#ifdef DEBUG_DIAGNOSTICS
    int non_floor_items = 0;
#endif

#ifdef DEBUG_DIAGNOSTICS
        if (!is_valid_item(item))
        {
            mprf("Invalid item in arena_cull_items()!!", MSGCH_ERROR);
            non_floor_items++;
            continue;
        }
#endif

        {
#ifdef DEBUG_DIAGNOSTICS
            if (item.pos == coord_def(-1, -1))
                mprf("Player item in arena_cull_items()!!", MSGCH_ERROR);
            non_floor_items++;
#endif

        }

        bool cull = false;
        switch(item.base_type)
        {
        case OBJ_WEAPONS:
        case OBJ_ARMOUR:
            if (is_artefact(item))
                artefacts.push_back(i);
            else if (item.special != 0)
                egos.push_back(i);
            else
                // Always cull boring equipment.
                cull = true;
            break;

        items.push_back(i);
    }

        case OBJ_MISSILES:
            if (item.sub_type == MI_JAVELIN
                || item.sub_type == MI_THROWING_NET)
            {
                ammo.push_back(i);
            }
            else
                // Arrows/needles/etc on the floor are just clutter.
                cull = true;
            break;

    // Cull half of items on the floor.
    const int cull_target = items.size() / 2;
          int cull_count  = 0;

        case OBJ_WANDS:
            if (item.plus == 0)
                // Get rid of empty wands.
                cull = true;
            else
                wands.push_back(i);
            break;

    std::sort(items.begin(), items.end(), _sort_by_age);
    std::vector<int> ammo;

        case OBJ_SCROLLS:
            scrolls.push_back(i);
            break;

    for (unsigned int i = 0, end = items.size(); i < end; i++)
    {
        const int      idx = items[i];
        const item_def &item(mitm[idx]);

        case OBJ_POTIONS:
            potions.push_back(i);
            break;

        // If the drop time is 0 then this is probably thrown ammo.
        if (arena::item_drop_times[idx] == 0)
        {
            // We know it's at least this old.
            arena::item_drop_times[idx] = arena::turns;

        case OBJ_CORPSES:
            if (item.sub_type == CORPSE_SKELETON)
                // If it's rotted away into a skeleton then there's no one
                // around who can uses corpses.
                cull = true;
            else
                corpses.push_back(i);

            // Arrows/needles/etc on the floor is just clutter.
            if (item.base_type != OBJ_MISSILES
               || item.sub_type == MI_JAVELIN
               || item.sub_type == MI_THROWING_NET)
            {
                ammo.push_back(idx);
                continue;
            }
        }
        DESTROY_ITEM(idx);
        if (cull_count >= cull_target)

        default:
            // Get rid of everything else.
            cull = true;
        } // switch(item.base_type)

    }

        if (cull)
            DESTROY_ITEM(i);
    } // for (int i = 0; i < MAX_ITEMS; i++)

        mprf(MSGCH_DIAGNOSTICS, "Arena culled %d misc items, done.",
                                 cull_count);

        mprf(MSGCH_DIAGNOSTICS, "On turn #%d culled %d items dropped by "
                                "monsters, done.",
             arena::turns, cull_count);

    if (cull_count > 0)
        mprf(MSGCH_DIAGNOSTICS, "Arena culled %d misc items.", cull_count);

    mprf(MSGCH_DIAGNOSTICS, "On turn #%d culled %d items dropped by "
                            "monsters, culling some more.",
         arena::turns, cull_count);

    // Get rid of oldest corpses first.
    std::sort(corpses.begin(), corpses.end(), _sort_corpses);
    std::vector<int>* lists[] = {&corpses, &ammo, &egos, &potions,
                                 &scrolls, &wands, &artefacts, NULL};
#ifdef DEBUG_DIAGNOSTICS
    const char* list_names[] = {"corpses", "ammo", "egos", "potions",
                                "scrolls", "wands", "artefacts"};
#endif

    const int count1 = cull_count;
    for (unsigned int i = 0; i < ammo.size(); i++)
    {
        DESTROY_ITEM(ammo[i]);
        if (cull_count >= cull_target)
            break;
    }

    for (int i = 0; lists[i] != NULL; i++)

    if (cull_count >= cull_target)

        std::vector<int>* vec = lists[i];
        for (unsigned int j = 0; j < vec->size(); j++)
        {
            DESTROY_ITEM((*vec)[j]);
            if (cull_count >= cull_target)
            {
#ifdef DEBUG_DIAGNOSTICS
                mprf(MSGCH_DIAGNOSTICS, "Arena culled %d %s, done.", j + 1,
                     list_names[i]);
#endif
                return (first_avail);
            }
        } // for (unsigned int j = 0; j < vec->size(); j++)

        if (vec->size() > 0)
            mprf(MSGCH_DIAGNOSTICS, "Arena culled %d %s.", vec->size(),
                 list_names[i]);

        mprf(MSGCH_DIAGNOSTICS, "Culled %d (probably) ammo items, done.",
             cull_count - count1);

    } // for (int i = 0; lists[i] != NULL; i++)

        return (first_avail);
    }

    mprf(MSGCH_DIAGNOSTICS, "Arena only culled %d of a desired %d items.",

    mprf(MSGCH_DIAGNOSTICS, "Culled %d items total, short of target %d.",

#endif // DEBUG_DIAGNOSTICS

#endif