std::vector<int>       respawn_list;
        std::vector<coord_def> respawn_pos;

            respawn_list.clear();
            respawn_pos.clear();

    bool respawn             = false;

    char             to_respawn[MAX_MONSTERS];

                to_respawn[imon] = i;

        respawn         =  strip_tag(spec, "respawn");

        if (real_summons && respawn)
            throw (std::string("Can't set real_summons and respawn at "
                               "same time."));

        for (int i = 0; i < MAX_MONSTERS; i++)
            to_respawn[i] = -1;

    void do_respawn(faction &fac)
    {
        for (unsigned int i = 0; i < fac.respawn_list.size(); i++)
        {
            coord_def pos      = fac.respawn_pos[i];
            int       spec_idx = fac.respawn_list[i];
            mons_spec spec     = fac.members.get_monster(spec_idx);
            if (fac.friendly)
                spec.attitude = ATT_FRIENDLY;
            int idx = dgn_place_monster(spec, 0, pos, false, true);
            if (idx != -1)
                to_respawn[idx] = spec_idx;
        }
        fac.respawn_list.clear();
        fac.respawn_pos.clear();
    }

                do_respawn(faction_a);
                do_respawn(faction_b);

    // Only respawn those monsers which were initally placed in the
    // arena.
    const int midx = monster->mindex();
    if (arena::respawn && arena::to_respawn[midx] != -1)
    {
        arena::faction *fac = NULL;
        if (monster->attitude == ATT_FRIENDLY)
            fac = &arena::faction_a;
        else if (monster->attitude == ATT_HOSTILE)
            fac = &arena::faction_b;
        if (fac)
        {
            fac->respawn_list.push_back(arena::to_respawn[midx]);
            fac->respawn_pos.push_back(monster->pos());
            arena::to_respawn[midx] = -1;
        }
    }

* respawn: When one of the originally replaced monsters is killed it will
      be replaced by the same type of monster.  This allows for an endless
      fight between exactly specified factions, rather than the random
      kind you get by pitting two test spawners against each other.