Bagaimana cara menghapus entitas dari loop game saya ketika sudah mati?

Ok jadi saya punya daftar besar semua entitas saya yang saya lewati dan perbarui. Di AS3 saya bisa menyimpan ini sebagai Array (panjang dinamis, tidak diketik), Vektor (diketik) atau daftar tertaut (bukan asli). Saat ini saya menggunakan Array tetapi saya berencana untuk mengubah ke Vector atau daftar yang ditautkan jika lebih cepat.

Lagi pula, pertanyaan saya, ketika Entitas dihancurkan, bagaimana saya harus menghapusnya dari daftar? Saya dapat membatalkan posisinya, memisahkannya atau hanya memasang bendera di atasnya untuk mengatakan "lewati aku, aku sudah mati." Saya mengumpulkan entitas saya, jadi Entitas yang sudah mati kemungkinan besar akan hidup kembali di beberapa titik. Untuk setiap jenis koleksi, apa strategi terbaik saya, dan kombinasi jenis pengumpulan dan metode penghapusan mana yang paling berhasil?

Saya akan menyimpan semua add / remove dalam daftar terpisah dan melakukan operasi tersebut setelah saya mengulangi pembaruan-loop.

Kerangka Flixel menggunakan bendera mati (sebenarnya beberapa bendera yang menentukan apakah itu harus ditarik, diperbarui, dan sebagainya). Saya akan mengatakan bahwa jika Anda akan menghidupkan kembali entitas, dan jika kinerja adalah masalah, Anda menggunakan bendera mati. Dalam pengalaman saya, instantiasi entitas baru adalah operasi paling mahal dalam use case yang Anda gambarkan, dan menyambungkan atau membatalkan elemen dapat menyebabkan memori mengembung mengingat pengumpulan sampah Flash yang kadang-kadang sarat dengan sampah.

Sementara beberapa teknik secara inheren lebih efisien daripada yang lain, itu hanya masalah jika Anda kehabisan siklus pada platform target Anda. Gunakan teknik apa pun yang memungkinkan Anda menyelesaikan permainan dengan lebih cepat. Cobalah untuk tidak bergantung pada implementasi spesifik dari struktur data kontainer Anda sementara itu dan itu akan membantu Anda untuk mengoptimalkan setelahnya jika Anda membutuhkannya.

Hanya untuk membahas beberapa teknik yang sudah dibahas oleh orang lain di sini. Jika urutan entitas penting, maka bendera mati dapat memungkinkan Anda untuk melakukan splice selama loop pembaruan Anda pada frame berikutnya. misalnya. pseudocode sangat sederhana:

void updateGame()
{
  // updateEntities()
  Entity* pSrcEntity = &mEntities[0];
  Entity* pDstEntity = &mEntities[0];
  newNumEntities = 0;
  for (int i = 0; i < numEntities; i++)
  {
    if (!pSrcEntity->isDead)
    {
       // could be inline but whatever.
       updateEntity(pDstEntity, pSrcEntity);
       // if entity just died, don't update the pDstEntity pointer, 
       // and just let the next entity updated overwrite it.
       if (!pDstEntity->isDead)
       {
          pDstEntity++;
          newNumEntities++;
       }
    }
    pSrcEntity++;
  }
}
numEntities = newNumEntities;

Ini adalah karakteristik dari skema ini:

• kekompakan alami entitas (walaupun dengan kemungkinan 1 frame latensi sebelum slot entitas dapat direklamasi).
• tidak ada masalah pemesanan ulang secara acak.
• sementara daftar Linkedly ganda memiliki O (1) penyisipan / penghapusan, tetapi sangat sulit untuk membuat prefetch cache latency yang optimal. Menyimpannya dalam array yang ringkas memungkinkan teknik prefetching blok bekerja dengan baik.
• Dalam hal penghancuran multi-objek, Anda tidak perlu melakukan shift-copy yang berlebihan untuk menjaga ketertiban dan kekompakan (semuanya dilakukan sekali selama pembaruan pass)
• Anda memanfaatkan sentuhan data yang harus sudah ada dalam cache selama pembaruan.
• Ini berfungsi dengan baik jika sumber dan entitas tujuan Anda akan memisahkan array. Anda kemudian dapat menggandakan buffer array entitas Anda untuk memanfaatkan multicore / eg. satu utas memperbarui / menulis entitas untuk bingkai N, sedangkan utas lain sedang merender entitas bingkai sebelumnya untuk bingkai N-1.
• Kekompakan berarti lebih mudah untuk DMA keseluruhan untuk prosesor heterogen untuk bahkan lebih banyak CPU misalnya. SPU atau GPU.

Berbicara dalam hal pengalaman pemrograman umum saya, splicing biasanya merupakan operasi lambat, yang melibatkan pengalihan semua elemen yang ada ke atas. Saya pikir menetapkannya ke nol akan menjadi solusi terbaik di sini ; bendera mati akan berfungsi tetapi Anda harus berhati-hati untuk tidak membiarkannya membuat kode Anda berantakan.

Kami sebenarnya hanya berbicara tentang pengumpulan sumber daya di ruang obrolan, sebenarnya. Ini latihan yang sangat bagus, dan senang mendengar Anda melakukan itu. :)

Secara pribadi, saya akan menggunakan daftar tertaut. Iterasi daftar yang disukai cepat, serta menambah dan menghapus item. Menggunakan Array atau Vector akan menjadi pilihan yang baik jika Anda membutuhkan akses langsung ke item dalam struktur (mis. Akses ke indeks), tetapi itu tidak terdengar seperti Anda membutuhkannya.

Setiap kali Anda menghapus item dari daftar tertaut, Anda dapat menambahkannya ke kumpulan objek yang kemudian dapat didaur ulang untuk menghemat alokasi memori.

Saya telah menggunakan struktur data poligonal di beberapa proyek dan sangat senang dengan mereka.

Sunting: Maaf, saya pikir jawabannya tidak terlalu jelas dalam hal strategi penghapusan: Saya sarankan untuk menghapus item dari daftar, segera setelah itu mati dan menambahkannya langsung ke struktur penyatuan (daur ulang). Karena menghapus item dari daftar tertaut sangat performan, saya tidak melihat masalah dalam melakukannya.

"Cukup tetapkan bendera di atasnya untuk mengatakan" lewati aku, aku sudah mati. "Aku mengumpulkan entitasku, jadi Entitas yang sudah mati kemungkinan besar akan hidup kembali di beberapa titik"

Saya pikir Anda menjawab pertanyaan Anda sendiri sehubungan dengan aplikasi spesifik ini. Saya akan menjauh dari array jika Anda berencana untuk mengerjakannya selain dari push dan pop. Daftar tertaut akan menjadi cara yang lebih cerdas untuk dilakukan jika Anda berencana melakukan operasi berat. Dengan semua yang dikatakan, jika Anda berencana untuk mengintegrasikan kembali entitas yang sama ke dalam game maka masuk akal untuk hanya menetapkan variabel boolean dan memeriksanya selama loop operasi game.

Salah satu solusi umum dan bersih yang saya temukan pada lib yang saya gunakan adalah menggunakan peta yang dapat dikunci.

Anda memiliki 2 operasi lock()dan unlock(), sementara Anda mengulangi peta Anda akan lock(), sekarang dari titik ini setiap operasi yang mengubah peta tidak berpengaruh, itu hanya akan didorong ke dalam CommandQueueyang akan berjalan setelah Anda menelepon unlock().

Jadi menghapus entitas akan memiliki pseudo-code berikut:

void lockableMap::remove(std::string id) {
   if(isLocked) {
       commandQueue.add(new RemoveCommand(id));
   } else {
       //remove element from map
   }

dan ketika kamu unlock()

isLocked = false
commandQueue.execute(this);

Satu-satunya hal yang harus Anda pertimbangkan adalah bahwa Anda hanya akan menghapus entitas setelah loop.

EDIT: ini adalah solusi yang diusulkan oleh Simon.

Inilah jawaban yang saya dapatkan dari Liosan :
/gamedev//a/46765/24633

Saya punya dua metode.

Saat Anda memanggil objek yang akan dihapus, itu benar-benar menetapkan dua flag:

1.Satu untuk memberitahu wadah bahwa suatu objek telah dihapus

2.Satu untuk memberitahu kontainer objek mana yang telah diminta untuk dihapus

void object::deleteObject()
{
    container->objectHasBeenDeleted = true;
    isToDelete = true;
}

Satu Menggunakan vektor objek

std::vector<object*> objects;

Kemudian dalam fungsi pembaruan, periksa untuk melihat apakah suatu objek telah dihapus dan jika demikian iterate melalui semua objek dan hapus yang memiliki tanda hapus

void container::update()
{
    if (objectHasBeenDeleted)
    {
        std::vector<object*>::iterator ListIterator;
        for(ListIterator=objects.begin(); ListIterator!=objects.end();)
        {
            if( (*ListIterator)->isToDelete )
            {
                ListIterator = objects.erase(ListIterator);
                delete *ListIterator;
            }
            else {
                ++ListIterator;
            }
        }
    objectHasBeenDeleted = false;
    }
}

Dua Menggunakan vektor (pointer ke a) objek.

std::vector<object*> *objects;

Dalam fungsi pembaruan, jika suatu objek akan dihapus, beralih melalui objek dan tambahkan objek yang tidak akan dihapus ke vektor baru. hapus vektor objek dan atur pointer ke vektor baru

void container::update()
{
    if (objectHasBeenDeleted)
    {
        std::vector<object*> *newVector;
        unsigned long i;
        for (i = 0; i < objects->size(); i++)
        {
            if (!objects->at(i)->isToDelete)
            {
                newVector->push_back(objects->at(i));
            }
        }
        delete objects;
        objects = newVector;
        objectHasBeenDeleted = false;
    }
}