Comment puis-je générer des cartes de terrain insulaires d'aspect plus naturel au lieu de bords circulaires à l'aide d'un générateur de cartes de cercles de dégradé ?

Résoudre le problème des bords circulaires dans le générateur de carte de cercle de dégradé

Dans votre générateur de carte, vous utilisez une méthode de création d'îles en utilisant dégradés, ce qui conduit à des bords circulaires. Ce problème se pose car le bruit Perlin est multiplié par un dégradé de couleurs, ce qui entraîne une distribution inégale.

Approche alternative : algorithme diamant et carré

Comme suggéré par un autre commentateur , envisagez plutôt d'utiliser l'algorithme Diamond and Square, qui génère un terrain d'apparence plus naturelle. Voici un aperçu des étapes à suivre :

Configurer les propriétés de génération

Définir des paramètres tels que l'élévation minimale et maximale, le niveau de la mer et les plages d'élévation pour la végétation, le sable et la terre. , etc.

Créer une carte de hauteur du terrain

Utiliser un diamant modifié et Algorithme carré pour générer une carte de terrain avec des valeurs de hauteur. Ajustez l'algorithme pour créer des terrains de type insulaire en initialisant les coins avec l'élévation la plus basse, en ignorant le premier pas de losange et en corrigeant les points de bordure à l'élévation minimale après chaque itération carrée.

Créer une carte de surface

Mappez les valeurs d'élévation avec des caractéristiques de surface telles que l'eau, la neige, la terre, le sable et la végétation en fonction de l'altitude. plages.

Fonctionnalités supplémentaires

Ajoutez des fonctionnalités supplémentaires basées sur la pente, telles que des rochers et des falaises.

Implémentation en C

Voici un extrait de code C qui démontre l'algorithme Diamond and Square pour générer la hauteur du terrain cartes :

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

Cet algorithme produit des cartes de terrain d'apparence naturelle qui peuvent être utilisées comme base pour votre générateur d'îles.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!