Así que estoy haciendo un generador de mapas que hace islas al azar. Utiliza el ruido Perlin en el corazón del generador y luego un método que usa círculos con gradientes para hacer las islas.

El método de círculo crea una serie de círculos en el centro del mapa con un gradiente de un color que comienza en 64 a 0. El problema es que este método está creando una apariencia no natrual en partes del mapa con bordes circulares. Cuando el ruido de perlin se genera para un píxel, obtendrá ese píxel en el mapa de gradiente y luego lo multiplicará por el valor azul.

Entonces, si el ruido perlin da un uno en el píxel 1, 5 y el valor azul en el mapa de gradiente es 54, generará un valor de ruido de 54. Si el ruido perlin en el píxel 130, 560 es 0.5 y el valor de color del gradiente es 64 entonces el valor de ruido de 32.

Esto es lo que estoy obteniendo:

Hay dos puntos clave para el código, el bit perlin:

noise = NoiseGenerator.Noise(x, y);
double gradColour = getGradColour(x, y).B;
double addedNoise = noise * gradColour;
double gradNoise = addedNoise;// - gradColour;

Y luego el generador de mapas de gradiente:

    public static void DrawGrad(float X, float Y, float R, Color C1, Color C2)
    {
        Graphics g = Graphics.FromImage(imgGrad);
        GraphicsPath path = new GraphicsPath();
        path.AddEllipse(X, Y, R, R);

        PathGradientBrush pathGrBrush = new PathGradientBrush(path);
        pathGrBrush.CenterColor = C1;

        Color[] colours = { C2 };
        pathGrBrush.SurroundColors = colours;
        g.FillEllipse(pathGrBrush, X, Y, R, R);
        //g.FillEllipse(Brushes.Red, X, Y, R, R);
        g.Flush();
    }

        int amount = rnd.Next(25, 30);
        for (int i = 0; i < amount / 4; i++)
        {
            float X = rnd.Next(-800, 1748);
            float Y = rnd.Next(-800, 1748);
            float R = rnd.Next(1000, 1200);
            DrawGrad(X, Y, R, Color.FromArgb(255, 0, 0, rnd.Next(15, 20)), Color.FromArgb(0, 0, 0, 0));
        }
        for (int i = 0; i < amount; i++)
        {
            double positionDiv = 1.98;
            double X1 = rnd.Next(0, 450) / positionDiv;
            double Y1 = rnd.Next(0, 450) / positionDiv;
            double R1 = rnd.Next(300, 650) / 4;
            float R = (float)R1;
            float X = (float)X1;
            float Y = (float)Y1;

            while (X + R > 1004)
            {
                X = 924 - R;
            }
            while (Y + R > 1004)
            {
                Y = 924 - R;
            }
            if(X < 30)
            {
                X = 30;
            }
            if(Y < 30)
            {
                Y = 30;
            }
            DrawGrad(X, Y, R, Color.FromArgb(255, 0, 0, rnd.Next(40, 64)), Color.FromArgb(0, 0, 0, rnd.Next(13, 17)));
        }

Me preguntaba si alguien más conoce algún otro método en C # que pueda crear una isla con ruido de perlin. Cualquier consejo sería muy apreciado.