Perlin gürültüsüyle yapılan bir dünyada yumurtlama birimleri?

Perlin gürültüye dayalı oyunumda karşılaştığım bazı sorunlar var. Aşağıdaki ekteki ekran görüntüsüne bir göz atın.

Gördüğünüz beyaz alanlar duvarlar ve siyah alanlar yürünebilir. Ortadaki üçgen oyuncu.

Bu oyunda fiziği bir dokuya (beyaz veya siyah piksel) çizerek ve ardından CPU'dan alarak uyguladım.

Ancak şimdi elimde farklı bir sorun var. Ekranın kenarında birimlerin (ya da onları ne derseniz deyin) sürekli ortaya çıkmasını istiyorum. Buradaki nokta, son oyunda, oyuncunun bunu çok fazla görmesine izin vermeyen bir "savaş sisi" olacağı.

Ekranın kenarındaki pikselleri tarayabildiğimi ve fizik dokularının siyah olup olmadığını anlayabildiğimi ve sonra rastgele rastgele bir şeyler üretebileceğimi düşündüm. Ancak, ekran görüntüsüne ikinci kez bakarsanız, (sol üst köşede) sürüngenlerin ortaya çıkmasını istemeyeceğim bir örnek var (çünkü oradan oyuncuya ulaşamayacaklar) .

GPU'nun bu yumurtlama noktalarını bir şekilde benim için veya başka bir şekilde belirlemesini sağlamak mümkün mü? Ekranın kenarındaki önerilen nokta ile oyuncu arasında vektörler yapmayı ve sonra her 10 vokselde bir izlemeyi düşündüm ve orada bir birim yumurtlamadan önce bir duvarın çarpışıp çarpışmadığını görün.

Bununla birlikte, yukarıda önerilen çözüm çok CPU yoğun olabilir.

Bu konuda herhangi bir öneriniz var mı?

Not 1 Ortaya çıkan birimler için, duvardaki çarpışmalardan kaçınmak için herhangi bir yol bulma yöntemi kullanmak istemiyorum, çünkü bu birimler oynatıcıya doğru ilerliyor. Olur oyuncuya doğru düz bir çizgide yürüyen nereye nedenle, birimler bir yerde, ekranın kenarında yumurtlamaya gerekir değil herhangi duvarlarla çarpışır.

Bu iş için oldukça kullanışlı bir algoritma var, bu durumda taşkın algoritmasından çok daha verimli (karmaşıklığı, çalışma zamanının taşkın alanından ziyade sınır boyutuyla orantılı olması): yürüyen kareler algoritması. Konsept basit: oyuncuların konumunu (ekran orta noktası) başlatın, bir yön seçin ve bir duvar bulana kadar yürüyün. Duvarla çarpıştığınızda, algoritmayı başlatırsınız: bir yönlendirme (yukarı veya aşağı) seçersiniz ve pikselleri vurgulayarak bu alanın sınırı boyunca yürümeye başlarsınız. Bu size izin verilen alanın iç sınırını verir. Daha sonra, yumurtlama birimleri için aday noktaların bu sınırda olup olmadığını kontrol edersiniz.

Sınırı çalıştırmak için izlemeniz gereken prensip budur:

http://en.wikipedia.org/wiki/File:Marchsquares.png (meh Henüz fotoğraf gönderemiyorum)

Wikipedia açıklaması (daha fazla karmaşıklığa sahip olmasına rağmen, diğer uygulamalar düşünülerek kullanıldığından):

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

Oyuncunun konumundan bir taşkın dolgu yapın ; o zaman "sular altında" her alan geçerli bir oyun alanı ve diğerleri duvarlar.

EDIT: "düz bir çizgi ulaşılabilir" ek gereksinimi gelince, ayrı bir alanda , bunu biraz daha tanımlamak gerektiğini unutmayın. Örneğin, yukarıdaki tüm yollar böyle bir ortamda geçerli bir "düz çizgi" olabilir ve hepsinin bir noktada bir oyunda kullanıldığını gördüm:

Özellikle, bunların çoğu değişmeli değildir - bu da A'ya B'den "düz bir çizgide" ulaşabileceğiniz anlamına gelmez, A'ya B'den de ulaşabileceğiniz anlamına gelmez; aksi tam tersi de doğru değildir.

Ayrıca, "yan" noktalardan biri veya her ikisi de engelleniyorsa çapraz hareketi nasıl ele alacağınız sorusu vardır.

Yumurtlamaların gerçekleşmesine izin vermeye ne dersiniz? Bunda özel bir sorun görmüyorum.

oyuncuya sadece geçerli bir düz çizgiyle noktaları işaretlemeniz önemliyse, aşağıdakine benzer bir algoritma kullanabilirsiniz (bu bir c ++ kodu), normal taşkın dolgudan daha fazlasını tüketir. kod kendim test etmedi çünkü bazı küçük hatalar (kimse onları düzeltirse sevinirim) olabilir ama fikir alırsınız.

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);
            }
        }
    }
}

Haritayı dışbükey alanları temsil eden renklerle doldurabilirsiniz ..., böylece aynı bölgede yer alıyorsa ünitenizi oluşturabilirsiniz. Veya ulaşılabilir alanları daha kolay arayabilirsiniz.

Bu statik veridir, böylece önceden hesaplayabilirsiniz.

içbükeyden dışbükeyde bir değişiklik olan görüntü bulma noktalarını doldurmanız gerekiyordu, görsel olarak bulmak kolay görünüyor, iki durumunuz var:

1. Yatay: Turuncudan maviye değiştiği yer.
2. Dikey: Kırmızının yeşil ve turuncu renkte değiştiği yerler.

İşte kendi oyunumda kullandığım bir şey (neredeyse sizinki gibi 2d simpleks gürültü üretilen dünya) - Rays. Oynatıcıdan başlayın, bir yönlendirme belirleyin (isterseniz rastgele) ve bir şeye çarpana kadar (ekranın kenarı VEYA asteroit) o ​​çizgi boyunca ilerleyin. Ekranın kenarına vurursanız (asteroit / beyaz bir damla değil), ekranın kenarından oynatıcıya düz, açık bir çizgi olduğunu bilirsiniz. Sonra vurduğunuz noktada bir canavar yaratın. Bir asteroit vurursanız testi tekrar yapın.

Kullanabileceğiniz başka bir (GPU olmayan) çözüm, yol bulmadır. Haritayı çizmeden önce, haritanın her bir kenarındaki olası her bir çıkış noktasından yol bulun ve merkeze bir yol olup olmadığını görün. Bir * yol bulma maliyet / performans açısından oldukça uygundur, ancak bu bir sorun varsa oyun başlamadan önce yapabilirsiniz.

Yolu olmayan herhangi bir yumurtlama noktası bir hariç tutma listesine konulabilir; veya tam tersi (bir yol içeren herhangi bir nokta bir dahil etme listesine konabilir).