Unit pemijahan di dunia yang dibuat oleh Perlin noise?

Ada beberapa masalah yang saya temui dalam game berbasis kebisingan Perlin saya. Lihatlah screenshot terlampir di bawah ini.

Area putih yang Anda lihat adalah dinding, dan area hitam bisa dilalui dengan berjalan kaki. Segitiga di tengah adalah pemain.

Saya telah mengimplementasikan fisika dalam game ini dengan menggambarnya menjadi tekstur (piksel putih atau hitam), dan kemudian mendapatkannya dari CPU.

Namun, sekarang saya berdiri dengan masalah yang berbeda. Saya ingin unit (atau merayap, apa pun sebutan Anda) untuk terus-menerus muncul, di tepi layar. Intinya di sini adalah bahwa dalam pertandingan terakhir, akan ada "kabut perang" yang tidak memungkinkan pemain untuk melihat sejauh itu.

Saya pikir saya hanya bisa memindai piksel di tepi layar dan melihat apakah tekstur fisiknya hitam, lalu menelurkan barang secara acak di sana. Namun, jika Anda melihat screenshot kedua, ada (di sudut kiri atas) contoh di mana saya tidak ingin creep muncul (karena mereka tidak akan dapat menjangkau pemain dari sana) .

Apakah mungkin untuk memiliki GPU menentukan spawn-spot ini untuk saya, atau cara lain? Saya berpikir untuk membuat vektor antara titik yang diusulkan di tepi layar dan pemain, dan kemudian mengikutinya setiap 10 voxel, dan melihat apakah dinding bertabrakan, sebelum menelurkan unit di sana.

Namun, solusi yang diusulkan di atas mungkin terlalu intensif CPU.

Ada saran tentang masalah ini?

Catatan 1 Untuk unit yang muncul, saya tidak ingin menggunakan bentuk pathfinding apa pun untuk menghindari tabrakan di dinding saat unit ini berjalan ke arah pemain. Oleh karena itu, unit harus menelurkan di tepi layar, di lokasi di mana berjalan dalam garis lurus ke arah pemain tidak akan bertabrakan dengan dinding apa pun.

Ada algoritma yang cukup berguna untuk pekerjaan ini, jauh lebih efisien daripada algoritma banjir dalam situasi ini (kerumitannya adalah runtime sebanding dengan ukuran batas daripada area yang dibanjiri): ini adalah algoritma kotak marching. Konsepnya sederhana: mulai dari lokasi pemain (titik tengah layar), pilih arah dan berjalan sampai Anda menemukan dinding. Ketika Anda bertabrakan dengan dinding, Anda memulai algoritme: Anda memilih orientasi (atas atau bawah) dan mulai berbaris di atas batas area ini, menyoroti piksel. Ini memberi Anda batas dalam untuk area yang diizinkan. Setelah itu, Anda cukup memeriksa apakah kandidat poin untuk unit pemijahan terletak pada batas ini.

Ini adalah prinsip yang harus Anda ikuti untuk menjalankan batas:

http://en.wikipedia.org/wiki/File:Marchsquares.png (meh saya belum bisa memposting foto)

Deskripsi Wikipedia (walaupun memiliki banyak kompleksitas karena digunakan dengan aplikasi lain dalam pikiran):

http://en.wikipedia.org/wiki/Marching_squares

Membuat banjir mengisi dari posisi pemain; setiap area "banjir" kemudian merupakan area bermain yang valid, dan yang lainnya adalah tembok.

EDIT: Mengenai persyaratan tambahan "yang dapat dijangkau dalam garis lurus", ingatlah bahwa dalam ruang diskrit , Anda harus mendefinisikannya sedikit lebih jauh. Misalnya, semua jalur di atas bisa menjadi "garis lurus" yang valid di lingkungan seperti itu, dan saya telah melihat semuanya digunakan dalam permainan di beberapa titik:

Secara khusus, sebagian besar dari itu tidak komutatif - yang berarti hanya karena Anda dapat mencapai B dari A dalam "garis lurus" tidak berarti Anda juga dapat mencapai A dari B; tidak sebaliknya yang benar.

Selain itu, ada pertanyaan tentang bagaimana Anda menangani gerakan diagonal jika salah satu atau kedua titik "samping" menghalangi.

Bagaimana kalau membiarkan saja terjadi? Saya tidak melihat ada masalah khusus dalam hal itu.

jika penting bagi Anda untuk hanya menandai poin dengan garis lurus yang valid ke pemain, Anda dapat menggunakan algoritme seperti berikut (ini adalah kode c ++), ia menghabiskan lebih dari sekadar penimbunan banjir. mungkin ada beberapa bug kecil (saya akan senang jika ada yang memperbaiki mereka) karena saya tidak menguji kode sendiri tetapi Anda akan mendapatkan ide.

void straightlineFill(Point startPoint, Texture target)
{
    queue<Point> pointQueue;
    for (int dx = -1;dx <=1;dx ++)
            for(int dy = -1;dy <=1;dy++)
                if(dx != 0 && dy != 0)
                    pointQueue.push(point(startPoint.x + dx, startPoint.y + dy));
    while (!pointQueue.empty())
    {
        point front = pointQueue.front();
        pointQueue.pop();
        if (target.pixelAt(front) == COLOR_SPAWNABLE||
            target.pixelAt(front) == COLOR_WALL||
            target.pixelAt(front) == COLOR_NOT_SPAWNABLE)
                continue;
        taraget.setPixelAt(front, colorFilled); 
        for (int dx = -1;dx <=1;dx ++)
            for(int dy = -1;dy <=1;dy++)
                if(dx != 0 && dy != 0)
                    pointQueue.push(point(front.x + dx, front.y + dy));
        // up until now was the normal floodfill code
        // and here is the part that will do the real straight line checking

        // lineDX & lineDY will keep how much the line we are checking is skewed
        int lineDX = front.x - startPoint.x;
        int lineDY = front.y - startPoint.y;

        // step will show us how much we have to travel to reach each point of line
        point step;
        if (abs(lineDX) < abs(lineDY))
        {
            if (lineDX < 0)
                step = point(-1,0);
            if (lineDX == 0)
                if (lineDY < 0)
                    step = point(0,-1);
                else
                    step = point(0,1);
            if (lineDX > 0)
                step = point(1,0);
        }

        if (abs(lineDX) < abs(lineDY))
        {
            if (lineDY < 0)
                step = point(0,-1);
            if (lineDY == 0)
                if (lineDX < 0)
                    step = point(-1,0);
                else
                    step = point(1,0);
            if (lineDY > 0)
                step = point(0,1);
        }

        // moved will keep how much we have traveled so far, it's just some value that will speed up calculations and doesn't have any mathematical value
        point moved = 0;

        // spawnable will keep if the current pixel is a valid spawnpaint

        bool spawnable = true;

        // now we will travel on the straight line from player position to the edges of the map and check if whole line is valid spawn points or not.

        while (target.isInside(front))
        {
            front = front + step;
            moved = moved + point(step.x * lineDX, step.y * lineDY);
            if (step.x != 0 && moved.x < moved.y)
            {
                moved.x = moved.x - lineDY * sign(lineDY);
                front.y = front.y + sign(lineDY);
            }
            if (step.y != 0 && moved.y < moved.x)
            {
                moved.y = moved.y - lineDX * sign(lineDX);
                front.x = front.x + sign(lineDX);
            }

            if (target.getPixelAt(front) == COLOR_WALL)
                spawnable = false;

            if (spawnable)
            {
                target.setPixelAt(front,COLOR_SPAWNABLE);
                for (int dx = -1;dx <=1;dx ++)
                    for(int dy = -1;dy <=1;dy++)
                        if(dx != 0 && dy != 0)
                            pointQueue.push(point(front.x + dx, front.y + dy));             
            }
            else
            {
                target.setPixelAt(front,COLOR_NOT_SPAWNABLE);
            }
        }
    }
}

Anda dapat mengisi peta dengan warna-warna yang mewakili area cembung ..., dengan cara ini Anda dapat menelurkan unit Anda jika terletak di area yang sama. Atau Anda dapat mencari area yang mudah dijangkau dengan lebih mudah.

Ini adalah data statis sehingga Anda dapat melakukan precalc.

Anda harus mengisi titik-titik penemuan gambar di mana ada perubahan dari konvave ke cembung, secara visual sepertinya mudah ditemukan, Anda memiliki dua situasi:

1. Horizontal: Perubahan warna oranye ke biru.
2. Vertikal: Di mana merah berubah hijau dan oranye.

Berikut adalah sesuatu yang saya benar-benar digunakan dalam permainan saya sendiri (dunia 2d dihasilkan suara simpleks, hampir persis seperti milik Anda) - Sinar. Mulai dari pemain, tentukan orientasi (acak jika Anda mau), dan ikuti garis itu sampai Anda menekan sesuatu (tepi layar ATAU asteroid). Jika Anda menekan tepi layar (dan bukan asteroid / gumpalan putih), maka Anda tahu ada garis lurus dan terbuka dari tepi layar ke pemain. Kemudian muncul monster pada titik yang Anda tekan. Jika Anda menabrak asteroid, lakukan tes ulang.

Solusi (non-GPU) lain yang dapat Anda gunakan adalah pencarian jalur. Sebelum menggambar peta, cari jalan dari setiap titik potensial di setiap tepi peta dan lihat apakah ada jalur ke tengah. Pencarian jalur * cukup baik untuk biaya / kinerja, tetapi Anda dapat melakukan ini sebelum permainan dimulai jika itu masalah.

Titik bertelur yang tidak memiliki jalur dapat diletakkan pada daftar pengecualian; atau sebaliknya (titik mana pun dengan jalur dapat diletakkan pada daftar penyertaan).