public static void GenerateOres(VoxelChunk Chunk, ChunkGeneratorSettings Settings)
{
for (int x = 0; x < VoxelConstants.ChunkSizeX; x++)
{
for (int z = 0; z < VoxelConstants.ChunkSizeZ; z++)
{
var overworldPosition = OverworldMap.WorldToOverworld(new Vector2(x + Chunk.Origin.X, z + Chunk.Origin.Z), Settings.Overworld.InstanceSettings.Origin);
var normalizedHeight = NormalizeHeight(Settings.Overworld.Map.LinearInterpolate(overworldPosition, OverworldField.Height));
var height = MathFunctions.Clamp(normalizedHeight * Settings.WorldSizeInChunks.Y * VoxelConstants.ChunkSizeY, 0.0f, Settings.WorldSizeInChunks.Y * VoxelConstants.ChunkSizeY - 2);
for (int y = 0; y < VoxelConstants.ChunkSizeY; y++)
{
if (Chunk.Origin.Y + y >= height)
{
break;
}
if (Chunk.Origin.Y + y == 0)
{
continue;
}
var v = Chunk.Manager.CreateVoxelHandle(new GlobalVoxelCoordinate(Chunk.Origin.X + x, Chunk.Origin.Y + y, Chunk.Origin.Z + z));
if (v.Sunlight)
{
continue;
}
foreach (var voxelType in Library.EnumerateVoxelTypes())
{
if (voxelType.SpawnClusters)
{
if (Chunk.Origin.Y + y < voxelType.MinSpawnHeight)
{
continue;
}
if (Chunk.Origin.Y + y > voxelType.MaxSpawnHeight)
{
continue;
}
var vRand = new Random(voxelType.ID);
var noiseVector = new Vector3(Chunk.Origin.X + x, Chunk.Origin.Y + y, Chunk.Origin.Z + z) * Settings.CaveNoiseScale * 2.0f;
noiseVector += new Vector3(vRand.Next(0, 64), vRand.Next(0, 64), vRand.Next(0, 64));
var fade = 1.0f - ((Chunk.Origin.Y + y - voxelType.MinSpawnHeight) / voxelType.MaxSpawnHeight);
var oreNoise = Settings.CaveNoise.GetValue(noiseVector.X, noiseVector.Y, noiseVector.Z);
if (Math.Abs(oreNoise) < voxelType.Rarity * fade)
{
v.RawSetType(voxelType);
}
}
}
}
}
}
}
public static void GenerateSurfaceLife(VoxelChunk TopChunk, ChunkGeneratorSettings Settings)
{
var creatureCounts = new Dictionary <string, Dictionary <string, int> >();
var worldDepth = Settings.WorldSizeInChunks.Y * VoxelConstants.ChunkSizeY;
for (var x = TopChunk.Origin.X; x < TopChunk.Origin.X + VoxelConstants.ChunkSizeX; x++)
{
for (var z = TopChunk.Origin.Z; z < TopChunk.Origin.Z + VoxelConstants.ChunkSizeZ; z++)
{
var overworldPosition = OverworldMap.WorldToOverworld(new Vector2(x, z), Settings.Overworld.InstanceSettings.Origin);
if (Settings.Overworld.Map.GetBiomeAt(new Vector3(x, 0, z), Settings.Overworld.InstanceSettings.Origin).HasValue(out var biome))
{
var normalizedHeight = NormalizeHeight(Settings.Overworld.Map.LinearInterpolate(overworldPosition, OverworldField.Height));
var height = (int)MathFunctions.Clamp(normalizedHeight * worldDepth, 0.0f, worldDepth - 2);
var voxel = Settings.World.ChunkManager.CreateVoxelHandle(new GlobalVoxelCoordinate(x, height, z));
if (!voxel.IsValid ||
voxel.Coordinate.Y == 0 ||
voxel.Coordinate.Y >= worldDepth - Settings.TreeLine)
{
continue;
}
if (voxel.LiquidLevel != 0)
{
continue;
}
var above = VoxelHelpers.GetVoxelAbove(voxel);
if (above.IsValid && (above.LiquidLevel != 0 || !above.IsEmpty))
{
continue;
}
foreach (var animal in biome.Fauna)
{
if (MathFunctions.RandEvent(animal.SpawnProbability))
{
if (!creatureCounts.ContainsKey(biome.Name))
{
creatureCounts[biome.Name] = new Dictionary <string, int>();
}
var dict = creatureCounts[biome.Name];
if (!dict.ContainsKey(animal.Name))
{
dict[animal.Name] = 0;
}
if (dict[animal.Name] < animal.MaxPopulation)
{
EntityFactory.CreateEntity <GameComponent>(animal.Name,
voxel.WorldPosition + Vector3.Up * 1.5f);
}
break;
}
}
if (voxel.Type.Name != biome.SoilLayer.VoxelType)
{
continue;
}
foreach (VegetationData veg in biome.Vegetation)
{
if (voxel.GrassType == 0)
{
continue;
}
if (MathFunctions.RandEvent(veg.SpawnProbability) &&
Settings.NoiseGenerator.Noise(voxel.Coordinate.X / veg.ClumpSize,
veg.NoiseOffset, voxel.Coordinate.Z / veg.ClumpSize) >= veg.ClumpThreshold)
{
var treeSize = MathFunctions.Rand() * veg.SizeVariance + veg.MeanSize;
EntityFactory.CreateEntity <Plant>(veg.Name,
voxel.WorldPosition + new Vector3(0.5f, 1.0f, 0.5f),
Blackboard.Create("Scale", treeSize));
break;
}
}
}
}
}
}
public static VoxelChunk GenerateChunk(GlobalChunkCoordinate ID, ChunkGeneratorSettings Settings)
{
var origin = new GlobalVoxelCoordinate(ID, new LocalVoxelCoordinate(0, 0, 0));
var worldDepth = Settings.WorldSizeInChunks.Y * VoxelConstants.ChunkSizeY;
var waterHeight = NormalizeHeight(Settings.Overworld.GenerationSettings.SeaLevel + 1.0f / worldDepth);
var c = new VoxelChunk(Settings.World.ChunkManager, ID);
if (GameSettings.Current.NoStone)
{
return(c);
}
for (int x = 0; x < VoxelConstants.ChunkSizeX; x++)
{
for (int z = 0; z < VoxelConstants.ChunkSizeZ; z++)
{
var overworldPosition = OverworldMap.WorldToOverworld(new Vector2(x + origin.X, z + origin.Z), Settings.Overworld.InstanceSettings.Origin);
if (Settings.Overworld.Map.GetBiomeAt(new Vector3(x + origin.X, 0, z + origin.Z), Settings.Overworld.InstanceSettings.Origin).HasValue(out var biomeData))
{
var normalizedHeight = NormalizeHeight(Settings.Overworld.Map.LinearInterpolate(overworldPosition, OverworldField.Height));
var height = MathFunctions.Clamp(normalizedHeight * worldDepth, 0.0f, worldDepth - 2);
var stoneHeight = (int)MathFunctions.Clamp((int)(height - (biomeData.SoilLayer.Depth + (Math.Sin(overworldPosition.X) + Math.Cos(overworldPosition.Y)))), 1, height);
for (int y = 0; y < VoxelConstants.ChunkSizeY; y++)
{
var globalY = origin.Y + y;
var voxel = VoxelHandle.UnsafeCreateLocalHandle(c, new LocalVoxelCoordinate(x, y, z));
if (globalY == 0)
{
voxel.RawSetType(Library.GetVoxelType("Bedrock"));
continue;
}
// Below the stone line, use subsurface layers.
if (globalY <= stoneHeight && stoneHeight > 1)
{
var depth = stoneHeight - globalY - biomeData.SubsurfaceLayers[0].Depth + 1;
var subsurfaceLayer = 0;
while (depth > 0 && subsurfaceLayer < biomeData.SubsurfaceLayers.Count - 1)
{
depth -= biomeData.SubsurfaceLayers[subsurfaceLayer].Depth;
subsurfaceLayer += 1;
}
voxel.RawSetType(Library.GetVoxelType(biomeData.SubsurfaceLayers[subsurfaceLayer].VoxelType));
}
// Otherwise, on the surface.
else if ((globalY == (int)height || globalY == stoneHeight) && normalizedHeight > waterHeight)
{
voxel.RawSetType(Library.GetVoxelType(biomeData.SoilLayer.VoxelType));
if (!String.IsNullOrEmpty(biomeData.GrassDecal))
{
if (!biomeData.ClumpGrass || (biomeData.ClumpGrass &&
Settings.NoiseGenerator.Noise(overworldPosition.X / biomeData.ClumpSize, 0, overworldPosition.Y / biomeData.ClumpSize) > biomeData.ClumpTreshold))
{
voxel.RawSetGrass(Library.GetGrassType(biomeData.GrassDecal).ID);
}
}
}
else if (globalY > height && globalY > 0)
{
voxel.RawSetType(Library.EmptyVoxelType);
}
else if (normalizedHeight <= waterHeight)
{
voxel.RawSetType(Library.GetVoxelType(biomeData.ShoreVoxel));
}
else
{
voxel.RawSetType(Library.GetVoxelType(biomeData.SoilLayer.VoxelType));
}
}
}
}
}
return(c);
}