Wie kann ich mithilfe eines Verlaufskreiskartengenerators natürlicher aussehende Inselgeländekarten anstelle kreisförmiger Kanten erstellen?

Behebung des Problems mit kreisförmigen Kanten im Gradient Circle Map Generator

In Ihrem Kartengenerator verwenden Sie eine Methode zum Erstellen von Inseln mit Farbverläufe, die zu kreisförmigen Kanten führen. Dieses Problem entsteht, weil das Perlin-Rauschen mit einem Farbgradienten multipliziert wird, was zu einer ungleichmäßigen Verteilung führt.

Alternativer Ansatz: Rauten- und Quadratalgorithmus

Wie von einem anderen Kommentator vorgeschlagen Erwägen Sie stattdessen die Verwendung des Diamant- und Quadratalgorithmus, der ein natürlicher aussehendes Gelände erzeugt. Hier ist eine Übersicht über die erforderlichen Schritte:

Generierungseigenschaften konfigurieren

Definieren Sie Parameter wie minimale und maximale Höhe, Meeresspiegel und Höhenbereiche für Vegetation, Sand, Erde usw.

Erstellen Sie eine Geländehöhenkarte

Verwenden Sie einen modifizierten Diamanten und Quadratalgorithmus zum Generieren einer Geländekarte mit Höhenwerten. Passen Sie den Algorithmus an, um inselähnliches Gelände zu erstellen, indem Sie Ecken mit der niedrigsten Höhe initialisieren, den ersten Diamantschritt ignorieren und Grenzpunkte nach jeder Quadratiteration auf die minimale Höhe korrigieren.

Oberflächenkarte erstellen

Höhenwerte basierend auf der Höhe auf Oberflächenmerkmale wie Wasser, Schnee, Erde, Sand und Vegetation zuordnen Bereiche.

Zusätzliche Funktionen

Fügen Sie zusätzliche Funktionen basierend auf der Steigung hinzu, z. B. Felsen und Klippen.

Implementierung in C

Hier ist ein C-Code-Schnipsel, der den Diamond-and-Square-Algorithmus zum Generieren der Geländehöhe demonstriert Karten:

void map_random(int _xs,int _ys)
{
    float a,b; int c,t,f;
    int x,y,z,xx,yy,mxs,mys,dx,dy,dx2,dy2,r,r2;
    int **ter=NULL,**typ=NULL;
    Randomize();
    // align resolution to power of 2
    for (mxs=1;mxs+1<_xs;mxs<<=1); if (mxs<3) mxs=3;
    for (mys=1;mys+1<_ys;mys<<=1); if (mys<3) mys=3;
    ter=new int*[mys+1]; for (y=0;y<=mys;y++) ter[y]=new int[mxs+1];
    typ=new int*[mys+1]; for (y=0;y<=mys;y++) typ[y]=new int[mxs+1];

    // [Terrain]
    // diamond & square random height map -> ter[][]
    dx=mxs; dx2=dx>>1; r=1<<16;                     // init step,half step and randomness
    dy=mys; dy2=dy>>1; r2=r>>1;
    // set corners values
    ter[  0][  0]=-r2;
    ter[  0][mxs]= -r2;
    ter[mys][  0]= -r2;
    ter[mys][mxs]= -r2;
    ter[dy2][dx2]= r2;
    for (;dx2|dy2;dx=dx2,dx2>>=1,dy=dy2,dy2>>=1)    // subdivide step until full image is filled
    {
        if (!dx) dx=1;
        if (!dy) dy=1;
        // diamond (skip first one for islands)
        for (y=dy2,yy=mys-dy2;y<=yy;y+=dy)
            for (x=dx2,xx=mxs-dx2;x<=xx;x+=dx)
                ter[y][x]=((ter[y-dy2][x-dx2]+ter[y-dy2][x+dx2]+ter[y+dy2][x-dx2]+ter[y+dy2][x+dx2])>>2)+Random(r)-r2;
        // square
        for (y=dy2,yy=mys-dy2;y<=yy;y+=dy)
            for (x=dx ,xx=mxs-dx ;x<=xx;x+=dx)
                ter[y][x]=((ter[y][x-dx2]+ter[y][x+dx2]+ter[y-dy2][x]+ter[y+dy2][x])>>2)+Random(r)-r2;
        for (y=dy ,yy=mys-dy ;y<=yy;y+=dy)
            for (x=dx2,xx=mxs-dx2;x<=xx;x+=dx)
                ter[y][x]=((ter[y][x-dx2]+ter[y][x+dx2]+ter[y-dy2][x]+ter[y+dy2][x])>>2)+Random(r)-r2;
        for (x=dx2,xx=mxs-dx2;x<=xx;x+=dx)
        {
            y=  0; ter[y][x]=((ter[y][x-dx2]+ter[y][x+dx2]+ter[y+dy2][x])/3)+Random(r)-r2;
            y=mys; ter[y][x]=((ter[y][x-dx2]+ter[y][x+dx2]+ter[y-dy2][x])/3)+Random(r)-r2;
        }
        for (y=dy2,yy=mys-dy2;y<=yy;y+=dy)
        {
            x=  0; ter[y][x]=((ter[y][x+dx2]+ter[y-dy2][x]+ter[y+dy2][x])/3)+Random(r)-r2;
            x=mxs; ter[y][x]=((ter[y][x-dx2]+ter[y-dy2][x]+ter[y+dy2][x])/3)+Random(r)-r2;
        }
    }
    // rescale to <h0,h1>
    xx=ter[0][0]; yy=xx;
    for (y=0;y<mys;y++)
        for (x=0;x<mxs;x++)
        {
            z=ter[y][x];
            if (xx>z) xx=z;
            if (yy<z) yy=z;
        }
    for (y=0;y<mys;y++)
        for (x=0;x<mxs;x++)
            ter[y][x]=h0+(((ter[y][x]-xx)*(h1-h0))/(yy-xx));
}

Dieser Algorithmus erstellt natürlich aussehende Geländekarten, die als Grundlage für Ihren Inselgenerator verwendet werden können.

Das obige ist der detaillierte Inhalt vonWie kann ich mithilfe eines Verlaufskreiskartengenerators natürlicher aussehende Inselgeländekarten anstelle kreisförmiger Kanten erstellen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!