Exemplo n.º 1
0
    private void Start()
    {
        SeedRandom.SetSeed(seed);

        for (int i = 0; i < biomes.Length; i++)
        {
            VoxelData.biomeProbobilitySum += biomes[i].probobilityWeight;
        }

        isCreatingChuncks = false;


        spawnPosition = new Vector3(VoxelData.worldSizeInChunks * VoxelData.chunkSize / 2f,
                                    Noise.GetWeight((int)(VoxelData.worldSizeInChunks * VoxelData.chunkSize / 2f), (int)(VoxelData.worldSizeInChunks * VoxelData.chunkSize / 2f), this) + 2,
                                    VoxelData.worldSizeInChunks * VoxelData.chunkSize / 2f);

        GenerateWorld();
    }
Exemplo n.º 2
0
    public static int[,] GenerateBiomeMap(int mapWidth, int mapHeight, int seed, int biomesGrid, int biomesNum, float noiseMult, float noiseDist)
    {
        int[,] biomesMap = new int[mapWidth, mapHeight];

        System.Random prng = new System.Random(seed);
        SeedRandom.SetSeed(seed);

        int xS = prng.Next(10, 20);
        int yS = prng.Next(10, 20);

        float offsetX = prng.Next(-100000, 100000);
        float offsetY = prng.Next(-100000, 100000);

        for (int x = 0; x < mapWidth; x++)
        {
            for (int y = 0; y < mapHeight; y++)
            {
                int gridX = (int)Mathf.Floor(x / biomesGrid);
                int gridY = (int)Mathf.Floor(y / biomesGrid);

                if (x / biomesGrid - gridX > 0.5f)
                {
                    gridX -= 2;
                }
                else
                {
                    gridX -= 1;
                }

                if (y / biomesGrid - gridY > 0.5f)
                {
                    gridY -= 2;
                }
                else
                {
                    gridY -= 1;
                }

                int closest     = 0;
                int closestDist = int.MaxValue;
                for (int i = 0; i < 4; i++)
                {
                    for (int j = 0; j < 4; j++)
                    {
                        int curBiome = i * 4 + j;
                        int biomeX   = SeedRandom.Get(gridX + i, gridY + j) % biomesGrid;
                        int biomeY   = SeedRandom.Get(gridX + i, gridY + j) % biomesGrid;

                        int dist = ((gridX + i) * biomesGrid + biomeX - x) * ((gridX + i) * biomesGrid + biomeX - x) +
                                   ((gridY + j) * biomesGrid + biomeY - y) * ((gridY + j) * biomesGrid + biomeY - y);

                        dist += (int)(Mathf.PerlinNoise(noiseDist * ((gridX + i) * biomesGrid + biomeX - x + offsetX) / 100f,
                                                        noiseDist * ((gridY + j) * biomesGrid + biomeY - y + offsetY) / 100f) * noiseMult);

                        if (dist < closestDist)
                        {
                            closestDist = dist;
                            closest     = curBiome;
                        }
                    }
                }

                biomesMap[x, y] = SeedRandom.Get(gridX + closest / 4, gridY + closest % 4) % biomesNum;
            }
        }

        return(biomesMap);
    }
Exemplo n.º 3
0
    public static float[] GetBiomes(int x, int y, int seed, int biomesGrid, BiomeType[] biomes, float noiseMult, float noiseDist, float smoothnessMod)
    {
        System.Random prng = new System.Random(seed);
        SeedRandom.SetSeed(seed);

        float offsetX = prng.Next(-10000, 10000);
        float offsetY = prng.Next(-10000, 10000);


        int gridX = (int)Mathf.Floor(x / biomesGrid);
        int gridY = (int)Mathf.Floor(y / biomesGrid);

        if (x / biomesGrid - gridX > 0.5f)
        {
            gridX -= 2;
        }
        else
        {
            gridX -= 1;
        }

        if (y / biomesGrid - gridY > 0.5f)
        {
            gridY -= 2;
        }
        else
        {
            gridY -= 1;
        }

        float closestDist = float.MaxValue;

        float[] dists = new float[16];

        for (int i = 0; i < 4; i++)
        {
            for (int j = 0; j < 4; j++)
            {
                int curBiome = i * 4 + j;
                int biomeX   = SeedRandom.Get(gridX + i, gridY + j) % biomesGrid;
                int biomeY   = SeedRandom.Get(gridX + i, gridY + j) % biomesGrid;

                float dist = ((gridX + i) * biomesGrid + biomeX - x) * ((gridX + i) * biomesGrid + biomeX - x) +
                             ((gridY + j) * biomesGrid + biomeY - y) * ((gridY + j) * biomesGrid + biomeY - y);

                dist += (Mathf.PerlinNoise(noiseDist * ((gridX + i) * biomesGrid + biomeX - x + offsetX) / 100f,
                                           noiseDist * ((gridY + j) * biomesGrid + biomeY - y + offsetY) / 100f) * noiseMult);

                dists[curBiome] = dist;

                if (dist < closestDist)
                {
                    closestDist = dist;
                }
            }
        }

        float total = 0;

        for (int i = 0; i < 16; i++)
        {
            if (dists[i] - closestDist < smoothnessMod)
            {
                total += (smoothnessMod - dists[i] + closestDist) * (smoothnessMod - dists[i] + closestDist);
            }
        }

        float[] biomeWeights = new float[biomes.Length];



        for (int i = 0; i < 16; i++)
        {
            if (dists[i] - closestDist < smoothnessMod)
            {
                int val = SeedRandom.Get(gridX + i / 4, gridY + i % 4) % (VoxelData.biomeProbobilitySum);

                for (int j = 0; j < biomes.Length; j++)
                {
                    val -= biomes[j].probobilityWeight;
                    if (val < 0)
                    {
                        biomeWeights[j] += 1.0f * (smoothnessMod + closestDist - dists[i]) * (smoothnessMod + closestDist - dists[i]) / total;
                        break;
                    }
                }
            }
        }

        return(biomeWeights);
    }