private static BiomeSettings InterpolateBiome(BiomeSettings BestSetting, float best, BiomeSettings SecondSetting, float second)
{
var newSetting = new BiomeSettings();
newSetting.TerrainAmplitude = BestSetting.TerrainAmplitude * best + SecondSetting.TerrainAmplitude * second;
newSetting.TopLayerThickness = (int)(BestSetting.TopLayerThickness * best + SecondSetting.TopLayerThickness * second);
newSetting.TreeRate = BestSetting.TreeRate * best + SecondSetting.TreeRate * second;
// TODO: Make decoration rate a float.
newSetting.DecorationRate = (int)(BestSetting.DecorationRate * best + SecondSetting.DecorationRate * second);
if (best < second)
{
newSetting.DefaultBlocktype = BestSetting.DefaultBlocktype;
newSetting.TopLayerType = BestSetting.TopLayerType;
newSetting.UnderLayerType = BestSetting.UnderLayerType;
newSetting.TreeModel = BestSetting.TreeModel;
newSetting.DecorationModel = BestSetting.DecorationModel;
}
else
{
newSetting.DefaultBlocktype = SecondSetting.DefaultBlocktype;
newSetting.TopLayerType = SecondSetting.TopLayerType;
newSetting.UnderLayerType = SecondSetting.UnderLayerType;
newSetting.TreeModel = SecondSetting.TreeModel;
newSetting.DecorationModel = SecondSetting.DecorationModel;
}
return(newSetting);
}
public void SetBiome(BiomeSettings biome)
{
if (currentBiome != null)
{
lastGroundColor = currentBiome.groundColor;
}
currentBiome = biome;
}
public Zone(MacroMap mesh, MacroMap.CellMesh.Submesh cells, int id, BiomeSettings biome, TriRunner settings)
{
_mesh = mesh;
Submesh = cells;
Id = id;
Biome = biome;
Influence = new Influence(id);
}
// TODO: Place trees into the chunk array.
public void GenerateVegetation(Chunk chunk, BiomeSettings CurrentSettings)
{
bool placedTree = false;
for (int x = 0; x < ChunkSize.x; x++)
{
for (int z = 0; z < ChunkSize.z; z++)
{
// Placing trees
float treeChance = rng.RandfRange(1f, 100f);
if (treeChance < CurrentSettings.TreeRate)
{
var file = (ArrayMesh)ResourceLoader.Load(CurrentSettings.TreeModel);
foreach (var item in file.GetMetaList())
{
if (item == "voxel_size")
{
continue;
}
int ty = chunk.HighestAt(x, z) + 1;
var array = item.Split(",");
var result = new Vector3(Mathf.Abs(int.Parse(array[0].Right(1))),
Mathf.Abs(int.Parse(array[1])),
Mathf.Abs(int.Parse(array[2].Left(array[2].Length - 1))));
var voxelPosition = result + new Vector3(x, ty, z);
if ((voxelPosition.x < 0 || voxelPosition.x >= 16) ||
(voxelPosition.y < 0 || voxelPosition.y >= 255) ||
(voxelPosition.z < 0 || voxelPosition.z >= 16))
{
continue;
}
chunk.Voxels[(int)voxelPosition.x, (int)voxelPosition.y, (int)voxelPosition.z].Active = true;
}
//// Placing point.
//// Creating and setting the mesh.
//var meshInstance = new MeshInstance();
//meshInstance.Mesh =
//// Adding it next frame.(safe with mutex lock)
//CallDeferred("add_child", meshInstance);
//// Moving it next frame(not in the tree yet :))
//meshInstance.SetDeferred("translation", new Vector3(x + (Offset.x * ChunkSize.x) -10, ty,
// z + (Offset.y * ChunkSize.z + 10)));
placedTree = true;
}
}
}
}
public void OnEnable()
{
Settings = (BiomeSettings)target;
foreach (var elevationData in Settings.Elevations)
{
if (elevationData.EditorName == "")
{
elevationData.EditorName = "Hello World!";
}
}
}
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
Rect rect = position;
rect.height = EditorGUIUtility.singleLineHeight;
property.isExpanded = EditorGUI.Foldout(rect, property.isExpanded, "Biomes", true, EditorStyles.foldoutHeader);
if (property.isExpanded)
{
if (settings == null)
{
settings = ((BiomeSettings)property.serializedObject.targetObject);
}
GUI.backgroundColor = Color.red;
rect.y += EditorGUIUtility.singleLineHeight;
float startX = rect.x;
//rect.x = 0;
rect.width = columnWidth;
EditorGUI.LabelField(rect, "Zones");
foreach (var moistureZone in Enum.GetNames(typeof(MoistureZone)))
{
rect.x += columnWidth;
EditorGUI.LabelField(rect, moistureZone, moistureStyle);
}
rect.x = startX;
var values = Enum.GetValues(typeof(ElevationZone));
for (int i = 0; i < values.Length; ++i)
{
rect.y += EditorGUIUtility.singleLineHeight;
EditorGUI.LabelField(rect, values.GetValue(i).ToString(), elevationStyle);
var elevation = BiomeDictionary.biomeLookup[i];
for (int j = 0; j < elevation.Length; ++j)
{
rect.x += columnWidth;
EditorGUI.ColorField(rect, settings.biomeColors[elevation[j]]);
rect.y += EditorGUIUtility.singleLineHeight;
EditorGUI.LabelField(rect, ((BiomeType)elevation[j]).ToString(), biomeLabelStyle);
rect.y -= EditorGUIUtility.singleLineHeight;
}
rect.x = startX;
rect.y += EditorGUIUtility.singleLineHeight;
}
}
}
public void SetBiome(BiomeSettings biome, bool skipTransition = false)
{
currentBiome = biome;
if (!skipTransition)
{
StartTransition();
}
else
{
StartTransition();
FinishTransition();
CleanUpTransition();
}
}
public override void OnInspectorGUI()
{
BiomeSettings biomes = (BiomeSettings)target;
EditorStyles.label.wordWrap = true;
EditorGUILayout.PropertyField(serializedObject.FindProperty("riverSubdivisions"));
EditorGUILayout.PropertyField(serializedObject.FindProperty("riverAmplitude"));
if (biomes.biomeColors.Count != Enum.GetNames(typeof(BiomeType)).Length)
{
for (int i = biomes.biomeColors.Count; i < Enum.GetNames(typeof(BiomeType)).Length; ++i)
{
biomes.biomeColors.Add(Color.black);
}
}
for (int i = 0; i < Enum.GetNames(typeof(BiomeType)).Length; ++i)
{
BiomeType biomeType = (BiomeType)i;
EditorGUILayout.BeginHorizontal();
{
EditorGUILayout.LabelField(biomeType.ToString());
biomes.biomeColors[i] = EditorGUILayout.ColorField(biomes.biomeColors[i], GUILayout.Width(120));
}
EditorGUILayout.EndHorizontal();
}
biomes.isElevationFoldout = EditorGUILayout.Foldout(biomes.isElevationFoldout, "Elevation Start Heights", true);
if (biomes.isElevationFoldout)
{
for (int i = 0; i < biomes.elevationStartHeights.Length; ++i)
{
EditorGUI.indentLevel = 1;
EditorGUILayout.BeginHorizontal();
{
EditorGUILayout.LabelField(((ElevationZone)i).ToString(), GUILayout.Width(60));
biomes.elevationStartHeights[i] = EditorGUILayout.DelayedFloatField(biomes.elevationStartHeights[i]);
}
EditorGUILayout.EndHorizontal();
EditorGUI.indentLevel = 0;
}
}
EditorGUILayout.PropertyField(serializedObject.FindProperty("biomeDictionary"));
serializedObject.ApplyModifiedProperties();
}
private void SetBiome(BiomeSettings biome, bool skipTransition = false)
{
background.SetBiome(biome, skipTransition);
level.SetBiome(biome);
foreground.SetBiome(biome);
weather.SetBiome(biome);
if (biome.mergeChunk != null)
{
level.introChunks.Enqueue(biome.mergeChunk);
}
#pragma warning disable CS0618
player.dustParticles.startColor = biome.dustColor;
#pragma warning restore CS0618
}
public Color GetVegetation(BiomeSettings biome, float random)
{
float acumProb = 0;
int index = 0;
for (int t = 0; t < biome.Vegetation.Length; t++)
{
acumProb += biome.Vegetation[t].Probability;
if (random < acumProb)
{
index = t;
break;
}
}
return(biome.Vegetation[index].Color);
}
private static float GetMatch(float temp, float humidity, BiomeSettings biome)
{
float realTemp, realHum, realTargetTemp, realTargetHum;
float targetTemp = biome.TargetTemperature;
float targetHum = biome.TargetHumidity;
realTemp = (TemperatureManager.GetOriginalTemperature(temp) - 1f) / 2;
realHum = humidity / 100f;
realTargetTemp = (TemperatureManager.GetOriginalTemperature(targetTemp) - 1f) / 2;
realTargetHum = targetHum / 100f;
float diffTemp = realTemp > realTargetTemp ? realTargetTemp - realTemp : realTemp - realTargetTemp;
float diffHum = realHum > realTargetHum ? realTargetHum - realHum : realHum - realTargetHum;
return(1f + (diffTemp + diffHum));
}
public void SetBiome(BiomeSettings biome)
{
currentBiome = biome;
TurnOffAll();
if (currentBiome.weather == BiomeSettings.Weather.None)
{
// nothing to do
}
else if (currentBiome.weather == BiomeSettings.Weather.Raining)
{
TurnOnRain();
}
else if (currentBiome.weather == BiomeSettings.Weather.Snowing)
{
TurnOnSnow();
}
}
public void SwapLayers(BiomeSettings biome)
{
// layers
for (int i = 0; i < layers.Length; i++)
{
// remember where old layer was
float copyX = layers[i].transform.position.x;
// Destroy and reinstantiate new layer
Destroy(layers[i].gameObject);
layers[i] = Instantiate(biome.layers[i], transform);
// calculate by how much we'll need to move the children to recover their rightful place
float moveBy = layers[i].transform.position.x - copyX;
// move the parent where the old layer was
layers[i].transform.position = new Vector3(
copyX,
layers[i].transform.position.y,
layers[i].transform.position.z);
// move the children to recover appropiate place
for (int j = 0; j < layers[i].childCount; j++)
{
layers[i].GetChild(j).transform.position += new Vector3(moveBy, 0, 0);
}
}
// sky image
backgroundImage.transform.position = new Vector3(
backgroundImage.transform.position.x,
backgroundImage.transform.position.y,
biome.backgroundZ);
// brights
Destroy(brights.gameObject);
brights = Instantiate(biome.brights, transform);
}
public static BiomeSettings GetBiomeSettings(Biomes biome)
{
var newBiomeSettings = new BiomeSettings();
switch (biome)
{
case Biomes.Tundra:
newBiomeSettings.TargetHumidity = Tundra.TargetHumidity;
newBiomeSettings.TargetTemperature = Tundra.TargetTemperature;
newBiomeSettings.DefaultBlocktype = Tundra.DefaultBlocktype;
newBiomeSettings.TopLayerType = Tundra.TopLayerType;
newBiomeSettings.UnderLayerType = Tundra.UnderLayerType;
newBiomeSettings.Mountains = Tundra.Mountains;
newBiomeSettings.TerrainAmplitude = Tundra.TerrainAmplitude;
newBiomeSettings.TopLayerThickness = Tundra.TopLayerThickness;
newBiomeSettings.TreeModel = Tundra.TreeModel;
newBiomeSettings.TreeRate = Tundra.TreeRate;
newBiomeSettings.DecorationModel = Tundra.DecorationModel;
newBiomeSettings.DecorationRate = Tundra.DecorationRate;
break;
case Biomes.BorealForest:
newBiomeSettings.TargetHumidity = BorealForest.TargetHumidity;
newBiomeSettings.TargetTemperature = BorealForest.TargetTemperature;
newBiomeSettings.DefaultBlocktype = BorealForest.DefaultBlocktype;
newBiomeSettings.TopLayerType = BorealForest.TopLayerType;
newBiomeSettings.UnderLayerType = BorealForest.UnderLayerType;
newBiomeSettings.Mountains = BorealForest.Mountains;
newBiomeSettings.TerrainAmplitude = BorealForest.TerrainAmplitude;
newBiomeSettings.TopLayerThickness = BorealForest.TopLayerThickness;
newBiomeSettings.TreeModel = BorealForest.TreeModel;
newBiomeSettings.TreeRate = BorealForest.TreeRate;
newBiomeSettings.DecorationModel = BorealForest.DecorationModel;
newBiomeSettings.DecorationRate = BorealForest.DecorationRate;
break;
case Biomes.Woodlands:
newBiomeSettings.TargetHumidity = Woodlands.TargetHumidity;
newBiomeSettings.TargetTemperature = Woodlands.TargetTemperature;
newBiomeSettings.DefaultBlocktype = Woodlands.DefaultBlocktype;
newBiomeSettings.TopLayerType = Woodlands.TopLayerType;
newBiomeSettings.UnderLayerType = Woodlands.UnderLayerType;
newBiomeSettings.Mountains = Woodlands.Mountains;
newBiomeSettings.TerrainAmplitude = Woodlands.TerrainAmplitude;
newBiomeSettings.TopLayerThickness = Woodlands.TopLayerThickness;
newBiomeSettings.TreeModel = Woodlands.TreeModel;
newBiomeSettings.TreeRate = Woodlands.TreeRate;
newBiomeSettings.DecorationModel = Woodlands.DecorationModel;
newBiomeSettings.DecorationRate = Woodlands.DecorationRate;
break;
case Biomes.ColdDesert:
newBiomeSettings.TargetHumidity = ColdDesert.TargetHumidity;
newBiomeSettings.TargetTemperature = ColdDesert.TargetTemperature;
newBiomeSettings.DefaultBlocktype = ColdDesert.DefaultBlocktype;
newBiomeSettings.TopLayerType = ColdDesert.TopLayerType;
newBiomeSettings.UnderLayerType = ColdDesert.UnderLayerType;
newBiomeSettings.Mountains = ColdDesert.Mountains;
newBiomeSettings.TerrainAmplitude = ColdDesert.TerrainAmplitude;
newBiomeSettings.TopLayerThickness = ColdDesert.TopLayerThickness;
newBiomeSettings.TreeModel = ColdDesert.TreeModel;
newBiomeSettings.TreeRate = ColdDesert.TreeRate;
newBiomeSettings.DecorationModel = ColdDesert.DecorationModel;
newBiomeSettings.DecorationRate = ColdDesert.DecorationRate;
break;
case Biomes.Desert:
newBiomeSettings.TargetHumidity = Desert.TargetHumidity;
newBiomeSettings.TargetTemperature = Desert.TargetTemperature;
newBiomeSettings.DefaultBlocktype = Desert.DefaultBlocktype;
newBiomeSettings.TopLayerType = Desert.TopLayerType;
newBiomeSettings.UnderLayerType = Desert.UnderLayerType;
newBiomeSettings.Mountains = Desert.Mountains;
newBiomeSettings.TerrainAmplitude = Desert.TerrainAmplitude;
newBiomeSettings.TopLayerThickness = Desert.TopLayerThickness;
newBiomeSettings.TreeModel = Desert.TreeModel;
newBiomeSettings.TreeRate = Desert.TreeRate;
newBiomeSettings.DecorationModel = Desert.DecorationModel;
newBiomeSettings.DecorationRate = Desert.DecorationRate;
break;
case Biomes.Savanna:
newBiomeSettings.TargetHumidity = Savanna.TargetHumidity;
newBiomeSettings.TargetTemperature = Savanna.TargetTemperature;
newBiomeSettings.DefaultBlocktype = Savanna.DefaultBlocktype;
newBiomeSettings.TopLayerType = Savanna.TopLayerType;
newBiomeSettings.UnderLayerType = Savanna.UnderLayerType;
newBiomeSettings.Mountains = Savanna.Mountains;
newBiomeSettings.TerrainAmplitude = Savanna.TerrainAmplitude;
newBiomeSettings.TopLayerThickness = Savanna.TopLayerThickness;
newBiomeSettings.TreeModel = Savanna.TreeModel;
newBiomeSettings.TreeRate = Savanna.TreeRate;
newBiomeSettings.DecorationModel = Savanna.DecorationModel;
newBiomeSettings.DecorationRate = Savanna.DecorationRate;
break;
case Biomes.RainForest:
newBiomeSettings.TargetHumidity = RainForest.TargetHumidity;
newBiomeSettings.TargetTemperature = RainForest.TargetTemperature;
newBiomeSettings.DefaultBlocktype = RainForest.DefaultBlocktype;
newBiomeSettings.TopLayerType = RainForest.TopLayerType;
newBiomeSettings.UnderLayerType = RainForest.UnderLayerType;
newBiomeSettings.Mountains = RainForest.Mountains;
newBiomeSettings.TerrainAmplitude = RainForest.TerrainAmplitude;
newBiomeSettings.TopLayerThickness = RainForest.TopLayerThickness;
newBiomeSettings.TreeModel = RainForest.TreeModel;
newBiomeSettings.TreeRate = RainForest.TreeRate;
newBiomeSettings.DecorationModel = RainForest.DecorationModel;
newBiomeSettings.DecorationRate = RainForest.DecorationRate;
break;
case Biomes.TropicRainForest:
newBiomeSettings.TargetHumidity = TropicRainForest.TargetHumidity;
newBiomeSettings.TargetTemperature = TropicRainForest.TargetTemperature;
newBiomeSettings.DefaultBlocktype = TropicRainForest.DefaultBlocktype;
newBiomeSettings.TopLayerType = TropicRainForest.TopLayerType;
newBiomeSettings.UnderLayerType = TropicRainForest.UnderLayerType;
newBiomeSettings.Mountains = TropicRainForest.Mountains;
newBiomeSettings.TerrainAmplitude = TropicRainForest.TerrainAmplitude;
newBiomeSettings.TopLayerThickness = TropicRainForest.TopLayerThickness;
newBiomeSettings.TreeModel = TropicRainForest.TreeModel;
newBiomeSettings.TreeRate = TropicRainForest.TreeRate;
newBiomeSettings.DecorationModel = TropicRainForest.DecorationModel;
newBiomeSettings.DecorationRate = TropicRainForest.DecorationRate;
break;
case Biomes.Forest:
newBiomeSettings.TargetHumidity = Forest.TargetHumidity;
newBiomeSettings.TargetTemperature = Forest.TargetTemperature;
newBiomeSettings.DefaultBlocktype = Forest.DefaultBlocktype;
newBiomeSettings.TopLayerType = Forest.TopLayerType;
newBiomeSettings.UnderLayerType = Forest.UnderLayerType;
newBiomeSettings.Mountains = Forest.Mountains;
newBiomeSettings.TerrainAmplitude = Forest.TerrainAmplitude;
newBiomeSettings.TopLayerThickness = Forest.TopLayerThickness;
newBiomeSettings.TreeModel = Forest.TreeModel;
newBiomeSettings.TreeRate = Forest.TreeRate;
newBiomeSettings.DecorationModel = Forest.DecorationModel;
newBiomeSettings.DecorationRate = Forest.DecorationRate;
break;
}
return(newBiomeSettings);
}
public DesertGenerator(MacroMap macroMap, IEnumerable <Cell> zoneCells, int id, BiomeSettings biome, TriRunner settings) : base(macroMap, zoneCells, id, biome, settings)
{
Assert.IsTrue(biome.Type == BiomeType.Desert);
_dunesNoise = new FastNoise(_random.Seed);
_dunesNoise.SetFrequency(1);
_hillsOrientation = _random.Range(0, 180f);
_stoneBlock = settings.AllBlocks.First(b => b.Block == BlockType.Stone);
_globalZoneHeight = _random.Range(0, 10);
}
public void GetChunkData(Chunk chunk)
{
// Chunk global position.
var Offset = chunk.Offset;
// Settings !
float temperature = TemperatureManager.GetTemperature(0 + (int)(Offset.x * ChunkSize.x), 0 + (int)(Offset.y * ChunkSize.z));
float humidity = TemperatureManager.GetHumidity(0 + (int)(Offset.x * ChunkSize.x), 0 + (int)(Offset.y * ChunkSize.z));
BiomeSettings CurrentSettings = BiomeManager.BestMatch(temperature, humidity);
bool placedTree = false;
for (int z = 0; z < ChunkSize.z; z += 1)
{
for (int x = 0; x < ChunkSize.x; x += 1)
{
temperature = TemperatureManager.GetTemperature(x + (int)(chunk.Offset.x * ChunkSize.x), z + (int)(chunk.Offset.y * ChunkSize.z));
humidity = TemperatureManager.GetHumidity(x + (int)(chunk.Offset.x * ChunkSize.x), z + (int)(chunk.Offset.y * ChunkSize.z));
CurrentSettings = BiomeManager.BestMatch(temperature, humidity);
// Global position of the cube.
int gX = ((int)Offset.x * (int)Chunk.ChunkSize.x) + x;
int gZ = ((int)Offset.y * (int)Chunk.ChunkSize.z) + z;
float noiseResult = ((Noise.GetNoise2d(gX, gZ) * CurrentSettings.TerrainAmplitude) + 1f) * (ChunkSize.y / 2);
float height = Mathf.Clamp(Mathf.Stepify(noiseResult, 1), 0, 254);
// Default type
BlockType type = CurrentSettings.DefaultBlocktype;
// Filling under the chunk too.
for (int i = 0; i <= height; i++)
{
chunk.Voxels[x, i, z].Active = true;
chunk.Voxels[x, i, z].Type = type;
}
// Big mountains?
if (CurrentSettings.Mountains)
{
GenerateMountains(chunk, x, z, (int)Mathf.Clamp(height, 0f, 254f));
}
// Add X layers of block on top of the generated rock.
var pos = chunk.HighestAt(x, z);
for (int i = 0; i < CurrentSettings.TopLayerThickness; i++)
{
// Adding some dirt under top layer.
var newType = CurrentSettings.UnderLayerType;
// if highest block, its grass!
if (i == 0)
{
newType = CurrentSettings.TopLayerType;
}
// Placing block. Making sure its under 255 height.
chunk.Voxels[x, Mathf.Clamp(pos - i, 0, 254), z].Type = newType;
}
// Placing decoration
int decorationChance = rng.RandiRange(1, 100);
if (decorationChance < CurrentSettings.DecorationRate)
{
// Placing point
int dy = chunk.HighestAt(x, z) + 1;
var mesh = (ArrayMesh)ResourceLoader.Load(CurrentSettings.DecorationModel);
chunk.AddVoxelSprite(new VoxelSprite(mesh, new Vector3(x, dy, z)));
}
// Placing trees
float treeChance = rng.RandfRange(1f, 100f);
//GD.Print(treeChance + " <= " + CurrentSettings.TreeRate);
if (treeChance < CurrentSettings.TreeRate)
{
//GD.Print("Placed tree");
var file = (ArrayMesh)ResourceLoader.Load(CurrentSettings.TreeModel);
int ty = chunk.HighestAt(x, z) + 1;
//Placing point.
// Creating and setting the mesh.
var meshInstance = new MeshInstance();
meshInstance.Mesh = file;
meshInstance.Name = CurrentSettings.TreeModel;
// Adding it next frame.(safe with mutex lock)
CallDeferred("add_child", meshInstance);
// Moving it next frame(not in the tree yet :))
meshInstance.SetDeferred("translation", new Vector3(x + (Offset.x * ChunkSize.x) - 10, ty,
z + (Offset.y * ChunkSize.z + 10)));
//meshInstance.SetDeferred("rotation_degrees", new Vector3(0, rng.RandfRange(0, 360), 0));
}
}
}
}
public BaseZoneGenerator(MacroMap macroMap, IEnumerable <Cell> zoneCells, int id, BiomeSettings biome, TriRunner settings)
{
_macroMap = macroMap;
_settings = settings;
_random = new Random(unchecked (settings.Seed + id));
_microReliefNoise = new FastNoise(_random.Seed);
_microReliefNoise.SetFrequency(1);
_resourcesNoise = new FastNoise(_random.Seed);
_resourcesNoise.SetFrequency(0.05);
Assert.IsTrue(zoneCells.All(c => c.ZoneId == id));
Zone = new Macro.Zone(_macroMap, _macroMap.GetSubmesh(zoneCells), id, biome, settings);
}
public void SetBiome(BiomeSettings biome)
{
currentBiome = biome;
}
public CavesGenerator(MacroMap macroMap, IEnumerable <Cell> zoneCells, int id, BiomeSettings biome, TriRunner settings) : base(macroMap, zoneCells, id, biome, settings)
{
Assert.IsTrue(biome.Type == BiomeType.Caves);
_cavesNoise = new FastNoise(_random.Seed);
_cavesNoise.SetFrequency(0.1);
}
public MountainsGenerator(MacroMap macroMap, IEnumerable <Cell> zoneCells, int id, BiomeSettings biome, TriRunner settings) : base(macroMap, zoneCells, id, biome, settings)
{
Assert.IsTrue(biome.Type == BiomeType.Mountain);
_microReliefNoise = new FastNoise(_random.Seed);
_microReliefNoise.SetFrequency(1);
}
public TestZoneGenerator(MacroMap macroMap, IEnumerable <Cell> zoneCells, int id, BiomeSettings biome, TriRunner settings) : base(macroMap, zoneCells, id, biome, settings)
{
Assert.IsTrue(biome.Type >= BiomeType.TestBegin && biome.Type <= BiomeType.TestEnd);
_generator = new FastNoise(unchecked (settings.Seed + id));
_generator.SetFrequency(1);
}
