public static BiomeData GetBiome(float temp, float rainfall, float height)
{
BiomeData closest = null;
float closestDist = float.MaxValue;
foreach (var biome in BiomeLibrary.Biomes)
{
float dist = Math.Abs(biome.Temp - temp) + Math.Abs(biome.Rain - rainfall) +
Math.Abs(biome.Height - height);
if (dist < closestDist)
{
closest = biome;
closestDist = dist;
}
}
return(closest);
}
/*
* public void GenerateOres(VoxelChunk chunk, ComponentManager components, ContentManager content,
* GraphicsDevice graphics)
* {
* Vector3 origin = chunk.Origin;
* int chunkSizeX = chunk.SizeX;
* int chunkSizeY = chunk.SizeY;
* int chunkSizeZ = chunk.SizeZ;
* Voxel v = chunk.MakeVoxel(0, 0, 0);
* for (int x = 0; x < chunkSizeX; x++)
* {
* for (int z = 0; z < chunkSizeZ; z++)
* {
* int h = chunk.GetFilledVoxelGridHeightAt(x, chunkSizeY - 1, z);
* for (int y = 1; y < chunkSizeY; y++)
* {
* foreach (
* KeyValuePair<string, VoxelLibrary.ResourceSpawnRate> spawns in VoxelLibrary.ResourceSpawns)
* {
* float s = spawns.Value.VeinSize;
* float p = spawns.Value.VeinSpawnThreshold;
* v.GridPosition = new Vector3(x, y, z);
* if (v.IsEmpty || y >= h - 1 || !(y - h/2 < spawns.Value.MaximumHeight) ||
* !(y - h/2 > spawns.Value.MinimumHeight) ||
* !(PlayState.Random.NextDouble() <= spawns.Value.Probability) || v.Type.Name != "Stone")
* {
* continue;
* }
*
* float caviness = (float) NoiseGenerator.Noise((float) (x + origin.X)*s,
* (float) (z + origin.Z)*s,
* (float) (y + origin.Y + h)*s);
*
* if (caviness > p)
* {
* v.Type = VoxelLibrary.GetVoxelType(spawns.Key);
* }
* continue;
* }
* }
* }
* }
* }
*/
public void GenerateFauna(VoxelChunk chunk, ComponentManager components, ContentManager content, GraphicsDevice graphics, FactionLibrary factions)
{
int waterHeight = (int)(SeaLevel * chunk.SizeY);
Voxel v = chunk.MakeVoxel(0, 0, 0);
for (int x = 0; x < chunk.SizeX; x++)
{
for (int z = 0; z < chunk.SizeZ; z++)
{
Vector2 vec = new Vector2(x + chunk.Origin.X, z + chunk.Origin.Z) / PlayState.WorldScale;
Overworld.Biome biome = Overworld.Map[(int)MathFunctions.Clamp(vec.X, 0, Overworld.Map.GetLength(0) - 1), (int)MathFunctions.Clamp(vec.Y, 0, Overworld.Map.GetLength(1) - 1)].Biome;
BiomeData biomeData = BiomeLibrary.Biomes[biome];
int y = chunk.GetFilledVoxelGridHeightAt(x, chunk.SizeY - 1, z);
if (!chunk.IsCellValid(x, (int)(y - chunk.Origin.Y), z))
{
continue;
}
v.GridPosition = new Vector3(x, y, z);
if (chunk.Data.Water[v.Index].WaterLevel != 0 || y <= waterHeight)
{
continue;
}
foreach (FaunaData animal in biomeData.Fauna)
{
if (y <= 0 || !(PlayState.Random.NextDouble() < animal.SpawnProbability))
{
continue;
}
EntityFactory.CreateEntity <Body>(animal.Name, chunk.Origin + new Vector3(x, y, z) + Vector3.Up * 1.0f);
break;
}
}
}
}
public static MaybeNull <BiomeData> GetBiomeForConditions(float Temperature, float Rainfall, float Elevation)
{
InitializeBiomes();
BiomeData closest = null;
var closestDist = float.MaxValue;
foreach (var biome in Library.Biomes)
{
var dist = Math.Abs(biome.Temp - Temperature) + Math.Abs(biome.Rain - Rainfall) + Math.Abs(biome.Height - Elevation);
if (dist < closestDist)
{
closest = biome;
closestDist = dist;
}
}
return(closest);
}
public VoxelChunk GenerateChunk(Vector3 origin, WorldManager World, float maxHeight)
{
float waterHeight = NormalizeHeight(SeaLevel + 1.0f / VoxelConstants.ChunkSizeY, maxHeight);
VoxelChunk c = new VoxelChunk(Manager, origin, GlobalVoxelCoordinate.FromVector3(origin).GetGlobalChunkCoordinate());
for (int x = 0; x < VoxelConstants.ChunkSizeX; x++)
{
for (int z = 0; z < VoxelConstants.ChunkSizeZ; z++)
{
Vector2 v = Overworld.WorldToOverworld(new Vector2(x + origin.X, z + origin.Z), World.WorldScale, World.WorldOrigin);
var biome = Overworld.Map[(int)MathFunctions.Clamp(v.X, 0, Overworld.Map.GetLength(0) - 1), (int)MathFunctions.Clamp(v.Y, 0, Overworld.Map.GetLength(1) - 1)].Biome;
BiomeData biomeData = BiomeLibrary.Biomes[biome];
Vector2 pos = Overworld.WorldToOverworld(new Vector2(x + origin.X, z + origin.Z), World.WorldScale, World.WorldOrigin);
float hNorm = NormalizeHeight(Overworld.LinearInterpolate(pos, Overworld.Map, Overworld.ScalarFieldType.Height), maxHeight);
float h = MathFunctions.Clamp(hNorm * VoxelConstants.ChunkSizeY, 0.0f, VoxelConstants.ChunkSizeY - 2);
int stoneHeight = (int)(MathFunctions.Clamp((int)(h - (biomeData.SoilLayer.Depth + (Math.Sin(v.X) + Math.Cos(v.Y)))), 1, h));
int currentSubsurfaceLayer = 0;
int depthWithinSubsurface = 0;
for (int y = VoxelConstants.ChunkSizeY - 1; y >= 0; y--)
{
var voxel = new VoxelHandle(c, new LocalVoxelCoordinate(x, y, z));
if (y == 0)
{
voxel.RawSetType(VoxelLibrary.GetVoxelType("Bedrock"));
continue;
}
if (y <= stoneHeight && stoneHeight > 1)
{
voxel.RawSetType(VoxelLibrary.GetVoxelType(biomeData.SubsurfaceLayers[currentSubsurfaceLayer].VoxelType));
depthWithinSubsurface++;
if (depthWithinSubsurface > biomeData.SubsurfaceLayers[currentSubsurfaceLayer].Depth)
{
depthWithinSubsurface = 0;
currentSubsurfaceLayer++;
if (currentSubsurfaceLayer > biomeData.SubsurfaceLayers.Count - 1)
{
currentSubsurfaceLayer = biomeData.SubsurfaceLayers.Count - 1;
}
}
}
else if ((y == (int)h || y == stoneHeight) && hNorm > waterHeight)
{
if (biomeData.ClumpGrass &&
NoiseGenerator.Noise(pos.X / biomeData.ClumpSize, 0, pos.Y / biomeData.ClumpSize) >
biomeData.ClumpTreshold)
{
voxel.RawSetType(VoxelLibrary.GetVoxelType(biomeData.SoilLayer.VoxelType));
if (!String.IsNullOrEmpty(biomeData.GrassDecal))
{
var decal = GrassLibrary.GetGrassType(biomeData.GrassDecal);
voxel.RawSetGrass(decal.ID);
}
}
else if (!biomeData.ClumpGrass)
{
voxel.RawSetType(VoxelLibrary.GetVoxelType(biomeData.SoilLayer.VoxelType));
if (!String.IsNullOrEmpty(biomeData.GrassDecal))
{
var decal = GrassLibrary.GetGrassType(biomeData.GrassDecal);
voxel.RawSetGrass(decal.ID);
}
}
else
{
voxel.RawSetType(VoxelLibrary.GetVoxelType(biomeData.SoilLayer.VoxelType));
}
}
else if (y > h && y > 0)
{
voxel.RawSetType(VoxelLibrary.emptyType);
}
else if (hNorm <= waterHeight)
{
voxel.RawSetType(VoxelLibrary.GetVoxelType(biomeData.ShoreVoxel));
}
else
{
voxel.RawSetType(VoxelLibrary.GetVoxelType(biomeData.SoilLayer.VoxelType));
}
}
}
}
return(c);
}
public static void GenerateCaveVegetation(VoxelChunk chunk, int x, int y, int z, int caveHeight, BiomeData biome, Vector3 vec, WorldManager world, Perlin NoiseGenerator)
{
var vUnder = new VoxelHandle(chunk, new LocalVoxelCoordinate(x, y - 1, z));
var wayUnder = new VoxelHandle(chunk, new LocalVoxelCoordinate(x, y - caveHeight, z));
wayUnder.RawSetType(VoxelLibrary.GetVoxelType(biome.SoilLayer.VoxelType));
var grassType = GrassLibrary.GetGrassType(biome.GrassDecal);
if (grassType != null)
{
wayUnder.RawSetGrass(grassType.ID);
}
foreach (VegetationData veg in biome.Vegetation)
{
if (!MathFunctions.RandEvent(veg.SpawnProbability))
{
continue;
}
if (NoiseGenerator.Noise(vec.X / veg.ClumpSize, veg.NoiseOffset, vec.Y / veg.ClumpSize) < veg.ClumpThreshold)
{
continue;
}
if (!vUnder.IsEmpty && vUnder.Type.Name == biome.SoilLayer.VoxelType)
{
vUnder.RawSetType(VoxelLibrary.GetVoxelType(biome.SoilLayer.VoxelType));
vUnder.RawSetGrass(0);
float treeSize = MathFunctions.Rand() * veg.SizeVariance + veg.MeanSize;
WorldManager.DoLazy(() =>
{
if (!GameSettings.Default.FogofWar)
{
GameComponent entity = EntityFactory.CreateEntity <GameComponent>(veg.Name,
vUnder.WorldPosition + new Vector3(0.5f, 1.0f, 0.5f),
Blackboard.Create("Scale", treeSize));
}
else
{
world.ComponentManager.RootComponent.AddChild(new ExploredListener(
world.ComponentManager, vUnder)
{
EntityToSpawn = veg.Name,
SpawnLocation = vUnder.WorldPosition + new Vector3(0.5f, 1.0f, 0.5f),
BlackboardData = Blackboard.Create("Scale", treeSize)
});
}
});
}
}
float spawnLikelihood = (world.InitialEmbark.Difficulty + 0.1f);
foreach (FaunaData animal in biome.Fauna)
{
if (y <= 0 || !(MathFunctions.Random.NextDouble() < animal.SpawnProbability * spawnLikelihood))
{
continue;
}
FaunaData animal1 = animal;
WorldManager.DoLazy(() =>
{
if (!GameSettings.Default.FogofWar)
{
var entity = EntityFactory.CreateEntity <GameComponent>(animal1.Name,
wayUnder.WorldPosition + Vector3.Up * 1.5f);
}
else
{
world.ComponentManager.RootComponent.AddChild(new ExploredListener
(world.ComponentManager, new VoxelHandle(chunk, wayUnder.Coordinate.GetLocalVoxelCoordinate()))
{
EntityToSpawn = animal1.Name,
SpawnLocation = wayUnder.WorldPosition + Vector3.Up * 1.5f
});
}
});
break;
}
}
public void GenerateCaves(VoxelChunk chunk, WorldManager world)
{
if (CaveLevels == null)
{
CaveLevels = new List <int>();
var caveStep = 48 / world.GenerationSettings.NumCaveLayers;
for (var i = 0; i < world.GenerationSettings.NumCaveLayers; ++i)
{
CaveLevels.Add(4 + (caveStep * i));
}
}
Vector3 origin = chunk.Origin;
BiomeData biome = BiomeLibrary.GetBiome("Cave");
var hellBiome = BiomeLibrary.GetBiome("Hell");
for (int x = 0; x < VoxelConstants.ChunkSizeX; x++)
{
for (int z = 0; z < VoxelConstants.ChunkSizeZ; z++)
{
var topVoxel = VoxelHelpers.FindFirstVoxelBelow(new VoxelHandle(
chunk, new LocalVoxelCoordinate(x, VoxelConstants.ChunkSizeY - 1, z)));
for (int i = 0; i < CaveLevels.Count; i++)
{
int y = CaveLevels[i];
if (y <= 0 || y >= topVoxel.Coordinate.Y)
{
continue;
}
var frequency = i < CaveFrequencies.Count ? CaveFrequencies[i] : CaveFrequencies[CaveFrequencies.Count - 1];
var caveBiome = (y <= HellLevel) ? hellBiome : biome;
Vector3 vec = new Vector3(x, y, z) + chunk.Origin;
double caveNoise = CaveNoise.GetValue((x + origin.X) * CaveNoiseScale * frequency,
(y + origin.Y) * CaveNoiseScale * 3.0f, (z + origin.Z) * CaveNoiseScale * frequency);
double heightnoise = NoiseGenerator.Noise((x + origin.X) * NoiseScale * frequency,
(y + origin.Y) * NoiseScale * 3.0f, (z + origin.Z) * NoiseScale * frequency);
int caveHeight = Math.Min(Math.Max((int)(heightnoise * 5), 1), 3);
if (!(caveNoise > CaveSize))
{
continue;
}
bool invalidCave = false;
for (int dy = 0; dy < caveHeight; dy++)
{
if (y - dy <= 0)
{
continue;
}
var voxel = new VoxelHandle(chunk, new LocalVoxelCoordinate(x, y - dy, z));
foreach (var coord in VoxelHelpers.EnumerateAllNeighbors(voxel.Coordinate))
{
VoxelHandle v = new VoxelHandle(Manager.ChunkData, coord);
if (!v.IsValid || (v.Sunlight))
{
invalidCave = true;
break;
}
}
if (!invalidCave)
{
voxel.RawSetType(VoxelLibrary.emptyType);
}
else
{
break;
}
}
if (!invalidCave && caveNoise > CaveSize * 1.8f && y - caveHeight > 0 && y > LavaLevel)
{
GenerateCaveVegetation(chunk, x, y, z, caveHeight, caveBiome, vec, world, NoiseGenerator);
}
}
}
}
/*
* // Second pass sets the caves to empty as needed
* for (int x = 0; x < VoxelConstants.ChunkSizeX; x++)
* {
* for (int y = 0; y < VoxelConstants.ChunkSizeY; y++)
* {
* for (int z = 0; z < VoxelConstants.ChunkSizeZ; z++)
* {
* VoxelHandle handle = new VoxelHandle(chunk, new LocalVoxelCoordinate(x, y, z));
* if (handle.Type == magicCube)
* {
* handle.RawSetType(VoxelLibrary.emptyType);
* }
* }
* }
* }
*/
}
public VoxelChunk GenerateChunk(Vector3 origin, int chunkSizeX, int chunkSizeY, int chunkSizeZ, ComponentManager components, ContentManager content, GraphicsDevice graphics)
{
float waterHeight = SeaLevel;
VoxelChunk c = new VoxelChunk(Manager, origin, 1,
Manager.ChunkData.GetChunkID(origin + new Vector3(0.5f, 0.5f, 0.5f)), chunkSizeX, chunkSizeY, chunkSizeZ)
{
ShouldRebuild = true,
ShouldRecalculateLighting = true
};
Voxel voxel = c.MakeVoxel(0, 0, 0);
for (int x = 0; x < chunkSizeX; x++)
{
for (int z = 0; z < chunkSizeZ; z++)
{
Vector2 v = new Vector2(x + origin.X, z + origin.Z) / PlayState.WorldScale;
Overworld.Biome biome = Overworld.Map[(int)MathFunctions.Clamp(v.X, 0, Overworld.Map.GetLength(0) - 1), (int)MathFunctions.Clamp(v.Y, 0, Overworld.Map.GetLength(1) - 1)].Biome;
BiomeData biomeData = BiomeLibrary.Biomes[biome];
Vector2 pos = new Vector2(x + origin.X, z + origin.Z) / PlayState.WorldScale;
float hNorm = Overworld.GetValue(Overworld.Map, pos, Overworld.ScalarFieldType.Height);
float h = MathFunctions.Clamp(hNorm * chunkSizeY, 0.0f, chunkSizeY - 2);
int stoneHeight = (int)Math.Max(h - 2, 1);
for (int y = 0; y < chunkSizeY; y++)
{
voxel.GridPosition = new Vector3(x, y, z);
if (y == 0)
{
voxel.Type = VoxelLibrary.GetVoxelType("Bedrock");
voxel.Health = 255;
continue;
}
if (y <= stoneHeight && stoneHeight > 1)
{
voxel.Type = VoxelLibrary.GetVoxelType(biomeData.SubsurfVoxel);
voxel.Health = VoxelLibrary.GetVoxelType(biomeData.SubsurfVoxel).StartingHealth;
}
else if ((y == (int)h || y == stoneHeight) && hNorm > waterHeight)
{
if (biomeData.ClumpGrass &&
NoiseGenerator.Noise(pos.X / biomeData.ClumpSize, 0, pos.Y / biomeData.ClumpSize) >
biomeData.ClumpTreshold)
{
voxel.Type = VoxelLibrary.GetVoxelType(biomeData.GrassVoxel);
voxel.Health = VoxelLibrary.GetVoxelType(biomeData.GrassVoxel).StartingHealth;
}
else if (!biomeData.ClumpGrass)
{
voxel.Type = VoxelLibrary.GetVoxelType(biomeData.GrassVoxel);
voxel.Health = VoxelLibrary.GetVoxelType(biomeData.GrassVoxel).StartingHealth;
}
else
{
voxel.Type = VoxelLibrary.GetVoxelType(biomeData.SoilVoxel);
voxel.Health = VoxelLibrary.GetVoxelType(biomeData.SoilVoxel).StartingHealth;
}
}
else if (y > h && y > 0)
{
voxel.Type = VoxelLibrary.GetVoxelType("empty");
}
else if (hNorm < waterHeight)
{
voxel.Type = VoxelLibrary.GetVoxelType(biomeData.ShoreVoxel);
voxel.Health = VoxelLibrary.GetVoxelType(biomeData.ShoreVoxel).StartingHealth;
}
else
{
voxel.Type = VoxelLibrary.GetVoxelType(biomeData.SoilVoxel);
voxel.Health = VoxelLibrary.GetVoxelType(biomeData.SoilVoxel).StartingHealth;
}
}
}
}
GenerateCaves(c);
GenerateWater(c);
GenerateLava(c);
c.ShouldRebuildWater = true;
return(c);
}
public void GenerateVegetation(VoxelChunk chunk, ComponentManager components, ContentManager content, GraphicsDevice graphics)
{
int waterHeight = (int)(SeaLevel * chunk.SizeY);
bool updated = false;
Voxel v = chunk.MakeVoxel(0, 0, 0);
Voxel vUnder = chunk.MakeVoxel(0, 0, 0);
for (int x = 0; x < chunk.SizeX; x++)
{
for (int z = 0; z < chunk.SizeZ; z++)
{
Vector2 vec = new Vector2(x + chunk.Origin.X, z + chunk.Origin.Z) / PlayState.WorldScale;
Overworld.Biome biome = Overworld.Map[(int)MathFunctions.Clamp(vec.X, 0, Overworld.Map.GetLength(0) - 1), (int)MathFunctions.Clamp(vec.Y, 0, Overworld.Map.GetLength(1) - 1)].Biome;
BiomeData biomeData = BiomeLibrary.Biomes[biome];
int y = chunk.GetFilledVoxelGridHeightAt(x, chunk.SizeY - 1, z);
if (!chunk.IsCellValid(x, (int)(y - chunk.Origin.Y), z))
{
continue;
}
v.GridPosition = new Vector3(x, y, z);
if (!v.IsEmpty || chunk.Data.Water[v.Index].WaterLevel != 0 || y <= waterHeight)
{
continue;
}
foreach (VegetationData veg in biomeData.Vegetation)
{
if (y <= 0)
{
continue;
}
if (!MathFunctions.RandEvent(veg.SpawnProbability))
{
continue;
}
if (NoiseGenerator.Noise(vec.X / veg.ClumpSize, veg.NoiseOffset, vec.Y / veg.ClumpSize) < veg.ClumpThreshold)
{
continue;
}
int yh = chunk.GetFilledVoxelGridHeightAt(x, y, z);
if (yh > 0)
{
vUnder.GridPosition = new Vector3(x, yh - 1, z);
if (!vUnder.IsEmpty && vUnder.TypeName == biomeData.GrassVoxel)
{
vUnder.Type = VoxelLibrary.GetVoxelType(biomeData.SoilVoxel);
updated = true;
float offset = veg.VerticalOffset;
if (vUnder.RampType != RampType.None)
{
offset -= 0.25f;
}
float treeSize = MathFunctions.Rand() * veg.SizeVariance + veg.MeanSize;
EntityFactory.CreateEntity <Body>(veg.Name, chunk.Origin + new Vector3(x, y, z) + new Vector3(0, treeSize * offset, 0), Blackboard.Create("Scale", treeSize));
}
}
break;
}
}
}
if (updated)
{
chunk.ShouldRebuild = true;
}
}
private static void GenerateCaveFauna(VoxelChunk chunk, WorldManager world, BiomeData biome, int y, int x, int z)
{
}
public void GenerateCaves(VoxelChunk chunk, WorldManager world)
{
Vector3 origin = chunk.Origin;
BiomeData biome = BiomeLibrary.GetBiome("Cave");
for (int x = 0; x < VoxelConstants.ChunkSizeX; x++)
{
for (int z = 0; z < VoxelConstants.ChunkSizeZ; z++)
{
var topVoxel = VoxelHelpers.FindFirstVoxelBelow(new VoxelHandle(
chunk, new LocalVoxelCoordinate(x, VoxelConstants.ChunkSizeY - 1, z)));
for (int i = 0; i < CaveLevels.Count; i++)
{
int y = CaveLevels[i];
if (y <= 0 || y >= topVoxel.Coordinate.Y)
{
continue;
}
Vector3 vec = new Vector3(x, y, z) + chunk.Origin;
double caveNoise = CaveNoise.GetValue((x + origin.X) * CaveNoiseScale * CaveFrequencies[i],
(y + origin.Y) * CaveNoiseScale * 3.0f, (z + origin.Z) * CaveNoiseScale * CaveFrequencies[i]);
double heightnoise = NoiseGenerator.Noise((x + origin.X) * NoiseScale * CaveFrequencies[i],
(y + origin.Y) * NoiseScale * 3.0f, (z + origin.Z) * NoiseScale * CaveFrequencies[i]);
int caveHeight = Math.Min(Math.Max((int)(heightnoise * 5), 1), 3);
if (!(caveNoise > CaveSize))
{
continue;
}
bool invalidCave = false;
for (int dy = 0; dy < caveHeight; dy++)
{
if (y - dy <= 0)
{
continue;
}
var voxel = new VoxelHandle(chunk, new LocalVoxelCoordinate(x, y - dy, z));
foreach (var coord in VoxelHelpers.EnumerateAllNeighbors(voxel.Coordinate))
{
VoxelHandle v = new VoxelHandle(Manager.ChunkData, coord);
if (v.IsValid && (v.LiquidLevel > 0 || v.Sunlight))
{
invalidCave = true;
break;
}
}
if (!invalidCave)
{
voxel.RawSetType(VoxelLibrary.emptyType);
}
else
{
break;
}
}
if (!invalidCave && caveNoise > CaveSize * 1.8f && y - caveHeight > 0)
{
GenerateCaveVegetation(chunk, x, y, z, caveHeight, biome, vec, world, NoiseGenerator);
GenerateCaveFauna(chunk, world, biome, y - caveHeight, x, z);
}
}
}
}
/*
* // Second pass sets the caves to empty as needed
* for (int x = 0; x < VoxelConstants.ChunkSizeX; x++)
* {
* for (int y = 0; y < VoxelConstants.ChunkSizeY; y++)
* {
* for (int z = 0; z < VoxelConstants.ChunkSizeZ; z++)
* {
* VoxelHandle handle = new VoxelHandle(chunk, new LocalVoxelCoordinate(x, y, z));
* if (handle.Type == magicCube)
* {
* handle.RawSetType(VoxelLibrary.emptyType);
* }
* }
* }
* }
*/
}
public void GenerateCaves(VoxelChunk chunk)
{
Vector3 origin = chunk.Origin;
int chunkSizeX = chunk.SizeX;
int chunkSizeY = chunk.SizeY;
int chunkSizeZ = chunk.SizeZ;
BiomeData biome = BiomeLibrary.Biomes[Overworld.Biome.Cave];
List <Voxel> neighbors = new List <Voxel>();
Voxel vUnder = chunk.MakeVoxel(0, 0, 0);
for (int x = 0; x < chunkSizeX; x++)
{
for (int z = 0; z < chunkSizeZ; z++)
{
int h = chunk.GetFilledVoxelGridHeightAt(x, chunk.SizeY - 1, z);
for (int i = 0; i < CaveLevels.Count; i++)
{
int y = CaveLevels[i];
if (y <= 0 || y >= h - 1)
{
continue;
}
Vector3 vec = new Vector3(x, y, z) + chunk.Origin;
double caveNoise = CaveNoise.GetValue((x + origin.X) * CaveNoiseScale * CaveFrequencies[i],
(y + origin.Y) * CaveNoiseScale * 3.0f, (z + origin.Z) * CaveNoiseScale * CaveFrequencies[i]);
double heightnoise = NoiseGenerator.Noise((x + origin.X) * NoiseScale * CaveFrequencies[i],
(y + origin.Y) * NoiseScale * 3.0f, (z + origin.Z) * NoiseScale * CaveFrequencies[i]);
int caveHeight = Math.Min(Math.Max((int)(heightnoise * 5), 1), 3);
if (caveNoise > CaveSize)
{
bool waterFound = false;
for (int dy = 0; dy < caveHeight; dy++)
{
int index = chunk.Data.IndexAt(x, y - dy, z);
chunk.GetNeighborsManhattan(x, y - dy, z, neighbors);
if (neighbors.Any(v => v.WaterLevel > 0))
{
waterFound = true;
}
if (waterFound)
{
break;
}
chunk.Data.Types[index] = 0;
}
if (!waterFound && caveNoise > CaveSize * 1.8f && y - caveHeight > 0)
{
int indexunder = chunk.Data.IndexAt(x, y - caveHeight, z);
chunk.Data.Types[indexunder] = (byte)VoxelLibrary.GetVoxelType(biome.GrassVoxel).ID;
chunk.Data.Health[indexunder] = (byte)VoxelLibrary.GetVoxelType(biome.GrassVoxel).StartingHealth;
chunk.Data.IsExplored[indexunder] = false;
foreach (VegetationData veg in biome.Vegetation)
{
if (!MathFunctions.RandEvent(veg.SpawnProbability))
{
continue;
}
if (NoiseGenerator.Noise(vec.X / veg.ClumpSize, veg.NoiseOffset, vec.Y / veg.ClumpSize) < veg.ClumpThreshold)
{
continue;
}
vUnder.GridPosition = new Vector3(x, y - 1, z);
if (!vUnder.IsEmpty && vUnder.TypeName == biome.GrassVoxel)
{
vUnder.Type = VoxelLibrary.GetVoxelType(biome.SoilVoxel);
float offset = veg.VerticalOffset;
if (vUnder.RampType != RampType.None)
{
offset -= 0.25f;
}
float treeSize = MathFunctions.Rand() * veg.SizeVariance + veg.MeanSize;
GameComponent entity = EntityFactory.CreateEntity <GameComponent>(veg.Name, chunk.Origin + new Vector3(x, y, z) + new Vector3(0, treeSize * offset, 0), Blackboard.Create("Scale", treeSize));
entity.GetRootComponent().SetActiveRecursive(false);
entity.GetRootComponent().SetVisibleRecursive(false);
if (GameSettings.Default.FogofWar)
{
ExploredListener listener = new ExploredListener(
PlayState.ComponentManager, entity, PlayState.ChunkManager, vUnder);
}
}
}
}
foreach (FaunaData animal in biome.Fauna)
{
if (y <= 0 || !(PlayState.Random.NextDouble() < animal.SpawnProbability))
{
continue;
}
var entity = EntityFactory.CreateEntity <GameComponent>(animal.Name, chunk.Origin + new Vector3(x, y, z) + Vector3.Up * 1.0f);
entity.GetRootComponent().SetActiveRecursive(false);
entity.GetRootComponent().SetVisibleRecursive(false);
if (GameSettings.Default.FogofWar)
{
ExploredListener listener = new ExploredListener(PlayState.ComponentManager, entity,
PlayState.ChunkManager, chunk.MakeVoxel(x, y, z));
}
break;
}
}
}
}
}
}
public VoxelChunk GenerateChunk(Vector3 origin, int chunkSizeX, int chunkSizeY, int chunkSizeZ, ComponentManager components, ContentManager content, GraphicsDevice graphics)
{
float waterHeight = SeaLevel + 1.0f / chunkSizeY;
VoxelChunk c = new VoxelChunk(Manager, origin, 1,
Manager.ChunkData.GetChunkID(origin + new Vector3(0.5f, 0.5f, 0.5f)), chunkSizeX, chunkSizeY, chunkSizeZ)
{
ShouldRebuild = true,
ShouldRecalculateLighting = true
};
Voxel voxel = c.MakeVoxel(0, 0, 0);
for (int x = 0; x < chunkSizeX; x++)
{
for (int z = 0; z < chunkSizeZ; z++)
{
Vector2 v = new Vector2(x + origin.X, z + origin.Z) / WorldScale;
Overworld.Biome biome = Overworld.Map[(int)MathFunctions.Clamp(v.X, 0, Overworld.Map.GetLength(0) - 1), (int)MathFunctions.Clamp(v.Y, 0, Overworld.Map.GetLength(1) - 1)].Biome;
BiomeData biomeData = BiomeLibrary.Biomes[biome];
Vector2 pos = new Vector2(x + origin.X, z + origin.Z) / WorldScale;
float hNorm = Overworld.LinearInterpolate(pos, Overworld.Map, Overworld.ScalarFieldType.Height);
float h = MathFunctions.Clamp(hNorm * chunkSizeY, 0.0f, chunkSizeY - 2);
int stoneHeight = (int)Math.Max(h - biomeData.SoilLayer.Depth, 1);
int currentGrassLayer = 0;
int currentSoilLayer = 0;
int currentSubsurfaceLayer = 0;
int depthWithinSubsurface = 0;
for (int y = chunkSizeY - 1; y >= 0; y--)
{
voxel.GridPosition = new Vector3(x, y, z);
if (y == 0)
{
voxel.Type = VoxelLibrary.GetVoxelType("Bedrock");
voxel.Health = 8;
continue;
}
if (y <= stoneHeight && stoneHeight > 1)
{
voxel.Type = VoxelLibrary.GetVoxelType(biomeData.SubsurfaceLayers[currentSubsurfaceLayer].VoxelType);
voxel.Health = VoxelLibrary.GetVoxelType(biomeData.SubsurfaceLayers[currentSubsurfaceLayer].VoxelType).StartingHealth;
depthWithinSubsurface++;
if (depthWithinSubsurface > biomeData.SubsurfaceLayers[currentSubsurfaceLayer].Depth)
{
depthWithinSubsurface = 0;
currentSubsurfaceLayer++;
if (currentSubsurfaceLayer > biomeData.SubsurfaceLayers.Count - 1)
{
currentSubsurfaceLayer = biomeData.SubsurfaceLayers.Count - 1;
}
}
}
else if ((y == (int)h || y == stoneHeight) && hNorm > waterHeight)
{
if (biomeData.ClumpGrass &&
NoiseGenerator.Noise(pos.X / biomeData.ClumpSize, 0, pos.Y / biomeData.ClumpSize) >
biomeData.ClumpTreshold)
{
voxel.Type = VoxelLibrary.GetVoxelType(biomeData.GrassLayer.VoxelType);
voxel.Health = VoxelLibrary.GetVoxelType(biomeData.GrassLayer.VoxelType).StartingHealth;
}
else if (!biomeData.ClumpGrass)
{
voxel.Type = VoxelLibrary.GetVoxelType(biomeData.GrassLayer.VoxelType);
voxel.Health = VoxelLibrary.GetVoxelType(biomeData.GrassLayer.VoxelType).StartingHealth;
}
else
{
voxel.Type = VoxelLibrary.GetVoxelType(biomeData.SoilLayer.VoxelType);
voxel.Health = VoxelLibrary.GetVoxelType(biomeData.SoilLayer.VoxelType).StartingHealth;
}
}
else if (y > h && y > 0)
{
voxel.Type = VoxelLibrary.GetVoxelType("empty");
}
else if (hNorm <= waterHeight)
{
voxel.Type = VoxelLibrary.GetVoxelType(biomeData.ShoreVoxel);
voxel.Health = VoxelLibrary.GetVoxelType(biomeData.ShoreVoxel).StartingHealth;
}
else
{
voxel.Type = VoxelLibrary.GetVoxelType(biomeData.SoilLayer.VoxelType);
voxel.Health = VoxelLibrary.GetVoxelType(biomeData.SoilLayer.VoxelType).StartingHealth;
}
}
}
}
GenerateWater(c);
GenerateLava(c);
GenerateCaves(c, components.World);
//GenerateAquifers(c);
//GenerateLavaTubes(c);
c.ShouldRecalculateLighting = true;
c.ShouldRebuildWater = true;
return(c);
}
