コード例 #1
0
        static bool LowestPointFound(int chance, NativeArray <float> heightmapData, float maxTerrainHeight, int hx, int hy, int hDim, int upperBound, int index, int tdDim, NativeArray <byte> tileData)
        {
            int newChance = (int)(chance - (chance * heightmapData[JobA.Idx(hy, hx, hDim)] * 2));

            if (tileData[index] != dirt ||
                JobA.Row(index, tdDim) - 5 <= 0 ||
                JobA.Col(index, tdDim) + 5 >= tdDim ||
                JobA.Row(index, tdDim) + 5 >= tdDim ||
                JobA.Col(index, tdDim) - 5 <= 0)
            {
                return(false);
            }
            else
            {
                float thisHeight = heightmapData[JobA.Idx(hy, hx, hDim)] * maxTerrainHeight;
                if (JobA.Idx(hy - 5, hx - 5, hDim) < 0 ||
                    JobA.Idx(hy - 5, hx - 5, hDim) > upperBound ||
                    JobA.Idx(hy - 5, hx + 5, hDim) < 0 ||
                    JobA.Idx(hy - 5, hx + 5, hDim) > upperBound ||
                    JobA.Idx(hy + 5, hx - 5, hDim) < 0 ||
                    JobA.Idx(hy + 5, hx - 5, hDim) > upperBound ||
                    JobA.Idx(hy + 5, hx + 5, hDim) < 0 ||
                    JobA.Idx(hy + 5, hx + 5, hDim) > upperBound)
                {
                    return(false);
                }
                else
                {
                    for (int a = -4; a < 5; a++)
                    {
                        for (int b = -4; b < 5; b++)
                        {
                            if ((a != 0 && b != 0) && heightmapData[JobA.Idx(hy + a, hx + b, hDim)] * maxTerrainHeight < thisHeight + (0.0000035f * Mathf.Abs(a)) + (0.0000035f * Mathf.Abs(b)))
                            {
                                return(false);
                            }
                        }
                    }
                    return(JobRand.Next(0, 100) <= newChance);
                }
            }
        }
コード例 #2
0
            public void Execute(int index)
            {
                int x  = JobA.Row(index, tdDim);
                int y  = JobA.Col(index, tdDim);
                int uB = heightmapData.Length;

                // Height sample for ocean and beach tiles
                int   hx     = (int)Mathf.Clamp(hDim * ((float)x / (float)tdDim), 0, hDim - 1);
                int   hy     = (int)Mathf.Clamp(hDim * ((float)y / (float)tdDim), 0, hDim - 1);
                float height = heightmapData[JobA.Idx(hy, hx, hDim)] * maxTerrainHeight;

                // Ocean and Beach texture
                if (height <= oceanElevation)
                {
                    tileData[index] = water;
                    return;
                }
                // Adds a little +/- randomness to threshold so beach line isn't too regular
                if (height <= beachElevation + (JobRand.Next(100000000, 250000000) / 10000000f))
                {
                    tileData[index] = dirt;
                    return;
                }

                // Get latitude and longitude of this tile
                int latitude  = (int)(mapPixelX * MapsFile.WorldMapTileDim + x);
                int longitude = (int)(MapsFile.MaxWorldTileCoordZ - mapPixelY * MapsFile.WorldMapTileDim + y);

                // Set texture tile using weighted noise
                float weight = 0;

                if (interestingErodedTerrainEnabled)
                {
                    weight += NoiseWeight(latitude, longitude, height);
                }
                else
                {
                    weight += NoiseWeight(latitude, longitude, height);
                }


                int climateNum = 9;

                switch (worldClimate)
                {
                case (int)MapsFile.Climates.Desert:
                    climateNum = 0;
                    break;

                case (int)MapsFile.Climates.Desert2:
                    climateNum = 1;
                    break;

                case (int)MapsFile.Climates.Mountain:
                    climateNum = 2;
                    break;

                case (int)MapsFile.Climates.Rainforest:
                    climateNum = 3;
                    break;

                case (int)MapsFile.Climates.Swamp:
                    climateNum = 4;
                    break;

                case (int)MapsFile.Climates.Subtropical:
                    climateNum = 5;
                    break;

                case (int)MapsFile.Climates.MountainWoods:
                    climateNum = 6;
                    break;

                case (int)MapsFile.Climates.Woodlands:
                    climateNum = 7;
                    break;

                case (int)MapsFile.Climates.HauntedWoodlands:
                    climateNum = 8;
                    break;

                case (int)MapsFile.Climates.Ocean:
                    climateNum = 9;
                    break;
                }
                tileData[index] = GetWeightedRecord(weight, upperWaterSpread[climateNum], lowerGrassSpread[climateNum], upperGrassSpread[climateNum]);

                // Check for lowest local point in desert to place oasis
                if (worldClimate == (int)MapsFile.Climates.Desert2 && LowestPointFound(30, heightmapData, maxTerrainHeight, hx, hy, hDim, uB, index, tdDim, tileData))
                {
                    tileData[index] = water;
                    return;
                }

                if (worldClimate == (int)MapsFile.Climates.Desert && LowestPointFound(80, heightmapData, maxTerrainHeight, hx, hy, hDim, uB, index, tdDim, tileData))
                {
                    tileData[index] = water;
                    return;
                }

                // Rock Mountain Face
                int rnd = JobRand.Next(75, 90);

                if (SteepnessWithinLimits(true, Mathf.Clamp(rnd - ((height / maxTerrainHeight) / rnd), 40f, 90f), heightmapData, maxTerrainHeight, hx, hy, hDim, uB, index, tdDim, tileData))
                {
                    tileData[index] = stone;
                    return;
                }

                /* rnd = JobRand.Next(25,35);
                 * if (tileData[index] == stone && SteepnessWithinLimits(false, Mathf.Clamp(rnd - ((height / maxTerrainHeight) / rnd),40f,90f), heightmapData, maxTerrainHeight, hx, hy, hDim, uB, index, tdDim, tileData)) {
                 *  tileData[index] = grass;
                 *  return;
                 * } */

                // Max angle for dirt patches
                rnd = JobRand.Next(20, 25);
                if (tileData[index] == dirt && SteepnessWithinLimits(false, rnd, heightmapData, maxTerrainHeight, hx, hy, hDim, uB, index, tdDim, tileData))
                {
                    tileData[index] = dirt;
                    return;
                }

                if (tileData[index] == dirt && !SteepnessWithinLimits(false, rnd, heightmapData, maxTerrainHeight, hx, hy, hDim, uB, index, tdDim, tileData))
                {
                    tileData[index] = grass;
                    return;
                }
            }
コード例 #3
0
            // Gets noise value
            private float NoiseWeight(float worldX, float worldY, float height)
            {
                float persistanceRnd = 0.95f;
                int   climateNum     = 9;

                switch (worldClimate)
                {
                case (int)MapsFile.Climates.Desert:
                    climateNum     = 0;
                    persistanceRnd = persistance[climateNum] + ((height / maxTerrainHeight) * 2) - 0.25f;
                    break;

                case (int)MapsFile.Climates.Desert2:
                    climateNum     = 1;
                    persistanceRnd = persistance[climateNum] + ((height / maxTerrainHeight) * 2) - 0.25f;
                    break;

                case (int)MapsFile.Climates.Mountain:
                    climateNum = 2;
                    if ((height / maxTerrainHeight) + JobRand.Next(-5, 5) / 1000f > treeLine)
                    {
                        persistanceRnd = persistance[climateNum] - treeLine + ((height / maxTerrainHeight) * 1.2f);
                    }
                    else
                    {
                        persistanceRnd = persistance[climateNum] - (1 - (height / maxTerrainHeight)) * 0.4f;
                    }
                    break;

                case (int)MapsFile.Climates.Rainforest:
                    climateNum     = 3;
                    persistanceRnd = persistance[climateNum] + ((height / maxTerrainHeight) * 1.5f) - 0.35f;
                    break;

                case (int)MapsFile.Climates.Swamp:
                    climateNum     = 4;
                    persistanceRnd = persistance[climateNum] + ((height / maxTerrainHeight) * 3) - 0.25f;
                    break;

                case (int)MapsFile.Climates.Subtropical:
                    climateNum     = 5;
                    persistanceRnd = persistance[climateNum] + ((height / maxTerrainHeight) * 2f) - 0.25f;
                    break;

                case (int)MapsFile.Climates.MountainWoods:
                    climateNum     = 6;
                    persistanceRnd = persistance[climateNum] + ((height / maxTerrainHeight) * 1.5f) - 0.35f;
                    break;

                case (int)MapsFile.Climates.Woodlands:
                    climateNum = 7;
                    if (interestingErodedTerrainEnabled)
                    {
                        persistanceRnd = persistance[climateNum] + ((height / maxTerrainHeight) * 1.5f);
                    }
                    else
                    {
                        persistanceRnd = persistance[climateNum] + ((height / maxTerrainHeight) * 1.4f) - 0.30f;
                    }
                    break;

                case (int)MapsFile.Climates.HauntedWoodlands:
                    climateNum     = 8;
                    persistanceRnd = persistance[climateNum] + ((height / maxTerrainHeight) * 1.5f) - 0.35f;
                    break;

                case (int)MapsFile.Climates.Ocean:
                    climateNum     = 9;
                    persistanceRnd = persistance[climateNum] + ((height / maxTerrainHeight) * 1.5f) - 0.35f;
                    break;
                }
                return(GetNoise(worldX, worldY, frequency[climateNum], amplitude[climateNum], persistanceRnd, octaves, seed));
            }